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 包的导入问题
首先，还是对上面的示例程序做一个更改，这次我们让它变得更加简单点，因为接下来讨论的东西，可能会稍微有点绕～～
首先，删除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...")
}
rm main
go build main
恩～～等等，我看一下运行结果：
What the fuck！！！为什么出来的是这货？？？
好吧，为了一探究竟，我们再次删除main文件，并再次重新编译，不过命令上得做点手脚，我们要看看编译器连接器这两个小婊砸到底都干了些什么，为啥是隔壁老王的儿子出来了？？！！
rm main
go build -x -v main
结果：
那么我们一步一步对这个结果做一个分析：
#首先，它好像指定了一个临时工作目录
WORK=@H_502_433@/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的选项，再看看运行结果！
其实，结果显而易见，没有源代码，上面的临时编译不可能成功，那么临时目录下就不可能有@H_403_520@.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() 这里使用的才是包名！
- 指定×××路径名就代表了此目录下唯一的包，编译器连接器默认就会去生成或者使用它，而不需要我们手动指明！
- 一个目录下就只能有一个包存在
- 对于调用有源码的第三方包，连接器在连接时，其实使用的并不是我们工作目录下的@H_403_520@.a文件，而是以该最新源码编译出的临时文件夹中的.a文件
- 对于调用没有源码的第三方包，上面的临时编译不可能成功，那么临时目录下就不可能有@H_403_520@.a文件，所以最后链接时就只能链接到工作目录下的.a文件
- 对于标准库，即便是修改了源代码，只要不重新编译Go源码，那么链接时使用的就还是已经编译好的*.a文件
- 包导入有三种模式：正常模式、别名模式、简便模式
