1 本地包声明

包是Go程序的基本单位，所以每个Go程序源代码的开始都是一个包声明：

package pkgName

这就是包声明，pkgName 告诉编译器，当前文件属于哪个包。一个包可以对应多个*.go源文件，标记它们属于同一包的唯一依据就是这个package声明，也就是说：无论多少个源文件，只要它们开头的package包相同，那么它们就属于同一个包，在编译后就只会生成一个.a文件，并且存放在$GOPATH/pkg文件夹下。

示例：

(1) 我们在$GOPATH/目录下，创建如下结构的文件夹和文件：

分别写入如下的代码：

hello.go

//hello.go
package hello

import (
  "fmt"
)

func SayHello() {
  fmt.Println("SayHello()-->Hello")
}

hello2.go

//hello2.go
package hello

import (
  "fmt"
)

func SayWorld() {
  fmt.Println("SayWorld()-->World")
}

main.go

//main.go
package main

import (
  "hello"
)

func main() {
  hello.SayHello()
  hello.SayWorld()
}

分析：

根据hello.go/hello2.go中的package声明可知，它们俩属于同一个包–hello，那么根据分析，编译后只会生成一个*.a文件。

执行命令：

go install hello

该命令的意思大概是：编译并安装hello包，这里安装的意思是将生成的*.a文件放到工作目录$GOPATH/pkg目录下去

运行后：

从结果看出，果然只生成了一个包，并且名为hello.a

那么我们提出第二个问题：生成的*.a文件名是否就是我们定义的包名+.a后缀？

为了验证这个问题，我们对源码做一些更改：
将hello.go/hello2.go中的package声明改为如下：

package hello_a

在编译安装包之前，先清除上一次生成的包：

go clean -i hello

再次编译安装该包：

go install hello_a

按照“正常推理”，上面这句命令是没什么问题的，因为我们已经将包名改成hello_a了啊，但是实际的运行结果是这样的：

oh~No!!
那么，我们再试试用这条命令：

go install hello

卧槽！！居然成功了！！是不是？？

那么我们尝试生成一下可执行程序，看看能不能正常运行呢？

go build main

又报错了！！！

看这报错提示，好像应该改一下main.go源码，那就改成如下吧：

//main.go
package main

import (
  "hello_a"
)

func main() {
  hello_a.SayHello()
  hello_a.SayWorld()
}

改成上面这样也合情合理哈？毕竟我们把包名定义成了hello_a了！
那就再来编译一次吧：

go build main

继续报错！

等等！！有新的发现，对比上两次的报错信息，可见第一次还能能找到hello_a包的，更改源码后居然还TM找不到hello_a包了？？
好吧，那咱再改回去，不过这回只改包的导入语句，改成：

import (
  "hello"
)

再次编译：

go build main

卧槽！！居然没报错了！！再运行一下可执行程序：

好吧，终于得到了想要的结果！

那进行到这里能说明什么呢？

（1） 一个包确实可以由多个源文件组成，只要它们开头的包声明一样
（2）一个包对应生成一个*.a文件，生成的文件名并不是包名+.a
（3） go install ××× 这里对应的并不是包名，而是路径名！！
（4） import ××× 这里使用的也不是包名，也是路径名！
（5） ×××××.SayHello() 这里使用的才是包名！

那么问题又来了，我们该如何理解（3）、（4）中的路径名呢？
我觉得，可以这样理解：
这里指定的是该×××路径名就代表了此目录下唯一的包，编译器连接器默认就会去生成或者使用它，而不需要我们手动指明！

好吧，问题又来了，如果一个目录下有多个包可以吗？如果可以，那该怎么编译和使用？？

那我们继续改改源代码：

首先，保持hello2.go 不变，改动hello.go为如下代码：

//hello.go
package hello

import (
  "fmt"
)

func SayHello() {
  fmt.Println("SayHello()-->Hello")
}

并且更改main.go的源码如下

//main.go
package main

import (
  "hello"
)

func main() {
  hello.SayHello()
  hello_a.SayWorld()
}

再次清理掉上次生成的可执行程序与包：

go clean -i hello
go clean -x main

你可以试着执行如上的命令，如果不能清除，那就手动删除吧！
反正，还原成如下样子：

那么再次尝试编译并安装包，不过注意了，此时hello目录下有两个包了，不管是否正确，我们先尝试一下：

go install hello

oh～～果然出错了！！

 
看到了吗？它说它找到了两个包了啊！！！

那这能说明什么呢？？

其实这就更加确定的说明了，我们上面的推测是正确的！

（3） go install ××× 这里对应的并不是包名，而是路径名！！

这里指定的是该×××路径名就代表了此目录下唯一的包，编译器连接器默认就会去生成或者使用它，而不需要我们手动指明！

好吧，证明了这个还是挺兴奋的！！那我们继续！！

如果一个目录下，真的有两个或者更多个包，那该如何生成？？
抱着试一试的态度，我尝试了许多可能，但无一正确，最后一个命令的结果是让我崩溃的：

go help install

恩！对！你没有看错:installs the packages named by the import paths
What the fuck!! 以后还是决定要先看文档再自己做测试！！

好吧，综上所述，一个目录下就只能有一个包吧，因为都是指定路径，没有办法指定路径下的某个具体的包，这样的做法其实也挺好，让源代码结构更清晰！

2 包的导入问题

导入包：

• 标准包使用的是给定的短路径，如"fmt"、"net/http"
• 自己的包，需要在工作目录(GOPATH)下指定一个目录,improt 导入包，实际上就是基于工作目录的文件夹目录

导入包的多种方式：

• 直接根据$GOPATH/src目录导入import "test/lib"(路径其实是$GOPATH/src/test/lib)
• 别名导入：import alias_name "test/lib" ，这样使用的时候，可以直接使用别名
• 使用点号导入：import . "test/lib"，作用是使用的时候直接省略包名
• 使用下划线导入：improt _ "test/lib"，该操作其实只是引入该包。当导入一个包时，它所有的init()函数就会被执行，但有些时候并非真的需要使用这些包，仅仅是希望它的init()函数被执行而已。这个时候就可以使用_操作引用该包。即使用_操作引用包是无法通过包名来调用包中的导出函数，而是只是为了简单的调用其init函数()。往往这些init函数里面是注册自己包里面的引擎，让外部可以方便的使用，例如实现database/sql的包，在init函数里面都是调用了sql.Register(name string, driver driver.Driver)注册自己，然后外部就可以使用了。
• 相对路径导入     import   "./model"  //当前文件同一目录的model目录，但是不建议这种方式import

首先，还是对上面的示例程序做一个更改，这次我们让它变得更加简单点，因为接下来讨论的东西，可能会稍微有点绕～～

首先，删除hello2.go，清理掉编译生成的文件，其他文件内容如下：

hello.go

//hello.go
package hello

import (
  "fmt"
)

func SayHello() {
  fmt.Println("SayHello()-->Hello")
}

main.go

//main.go
package main

import (
  "hello"
)

func main() {
  hello.SayHello()
}

最后，让整体保持如下的样式：

我们先编译一次，让程序能够运行起来：

go install hello
go build main
./main

好吧，假如你能看到输出，那就没问题了！
此时，再来看看整体的结构：

按照C/C++的方式来说，此时生成了hello.a这个链接库，那么源文件那些应该就没有必要了吧，所以。。。。我们这样搞一下，我们来更改一下hello.go源码，但不编译它！
hello.go

//hello.go
package hello

import (
  "fmt"
)

func SayHello() {
  fmt.Println("SayHello()-->Hello_modifi...")
}

然后，我们删除之前的可执行文件main，再重新生成它：

rm main
go build main

恩～～等等，我看一下运行结果：

What the fuck！！！为什么出来的是这货？？？

好吧，为了一探究竟，我们再次删除main文件，并再次重新编译，不过命令上得做点手脚，我们要看看编译器连接器这两个小婊砸到底都干了些什么，为啥是隔壁老王的儿子出来了？？！！

rm main
go build -x -v main

结果：

那么我们一步一步对这个结果做一个分析：

#首先，它好像指定了一个临时工作目录
WORK=/tmp/go-build658882358 

#看着样子，它好像是要准备编译hello目录下的包
hello
#然后创建了一系列临时文件夹
mkdir -p $WORK/hello/_obj/  
mkdir -p $WORK/

#进入包的源文件目录
cd /home/yuxuan/GoProjects/import/src/hello 

#调用6g这个编译器编译生成hello.a，存放在$WORK/临时目录下
/opt/go/pkg/tool/linux_amd64/6g -o $WORK/hello.a -trimpath $WORK -p hello -complete -D _/home/yuxuan/GoProjects/import/src/hello -I $WORK -pack ./hello.go

#要编译main目录下的包了
main
#还是创建一系列的临时文件夹
mkdir -p $WORK/main/_obj/  
mkdir -p $WORK/main/_obj/exe/

#进入main文件夹
cd /home/yuxuan/GoProjects/import/src/main

#调用6g编译器，编译生成main.a，存放于$WORK/临时目录下
/opt/go/pkg/tool/linux_amd64/6g -o $WORK/main.a -trimpath $WORK -p main -complete -D _/home/yuxuan/GoProjects/import/src/main -I $WORK -I /home/yuxuan/GoProjects/import/pkg/linux_amd64 -pack ./main.go

#最后它进入了一个“当前目录”，应该就是我们执行go build命令的目录
cd .

#调用连接器6l 然后它链接生成a.out,存放与临时目录下的$WORK/main/_obj/exe/文件夹中，但是在链接选项中并未直接发现hello.a
#从链接选项：-L $WORK -L /home/yuxuan/GoProjects/import/pkg/linux_amd64中可以看出，连接器首先搜索了$WORK临时目录下的所有*.a文件，然后再去搜索/home/yuxuan/GoProjects/import/pkg/linux_amd64目录下的*.a文件，可见原因
/opt/go/pkg/tool/linux_amd64/6l -o $WORK/main/_obj/exe/a.out -L $WORK -L /home/yuxuan/GoProjects/import/pkg/linux_amd64 -extld=gcc $WORK/main.a

#最后，移动可执行文件并重命名
mv $WORK/main/_obj/exe/a.out main

到这里，其实差不多也就得出结论了，连接器在连接时，其实使用的并不是我们工作目录下的hello.a文件，而是以该最新源码编译出的临时文件夹中的hello.a文件。

当然，如果你对这个结论有所怀疑，可以试试手动执行上述命令，在最后链接时，去掉-L $WORK的选项，再看看运行结果！

那么，这是对于有源代码的第三方库，如果没有源代码呢？

其实，结果显而易见，没有源代码，上面的临时编译不可能成功，那么临时目录下就不可能有.a文件，所以最后链接时就只能链接到工作目录下的.a文件！

但是，如果是自带的Go标准库呢？

其实也可以用上述的方法验证一下，验证过程就不写了吧？
最后得到的结果是：对于标准库，即便是修改了源代码，只要不重新编译Go源码，那么链接时使用的就还是已经编译好的*.a文件！

3 导入包的三种模式

包导入有三种模式：正常模式、别名模式、简便模式

Go language specification中关于import package时列举的一个例子如下：

Import declaration Local name of Sin

import “lib/math” math.Sin 
import m “lib/math” m.Sin 
import . “lib/math” Sin

我们看到import m “lib/math” m.Sin一行，在上面的结论中说过lib/math是路径，import语句用m替代lib/math，并在代码中通过m访问math包中导出的函数Sin。
那m到底是包名还是路径呢？
答案显而易见，能通过m访问Sin，那m肯定是包名了！
那问题又来了，import m “lib/math”该如何理解呢？

根据上面得出的结论，我们尝试这样理解m：m指代的是lib/math路径下唯一的那个包！

4 总结

经过上面这一长篇大论，是时候该总结一下成果了：

多个源文件可同属于一个包，只要声明时package指定的包名一样；一个包对应生成一个*.a文件，生成的文件名并不是包名+.a组成，应该是目录名+.a组成go install ××× 这里对应的并不是包名，而是路径名！！import ××× 这里使用的也不是包名，也是路径名×××××.SayHello() 这里使用的才是包名！指定×××路径名就代表了此目录下唯一的包，编译器连接器默认就会去生成或者使用它，而不需要我们手动指明！一个目录下就只能有一个包存在对于调用有源码的第三方包，连接器在连接时，其实使用的并不是我们工作目录下的.a文件，而是以该最新源码编译出的临时文件夹中的.a文件对于调用没有源码的第三方包，上面的临时编译不可能成功，那么临时目录下就不可能有.a文件，所以最后链接时就只能链接到工作目录下的.a文件对于标准库，即便是修改了源代码，只要不重新编译Go源码，那么链接时使用的就还是已经编译好的*.a文件包导入有三种模式：正常模式、别名模式、简便模式