1 本地包声明

创新互联是一家专业提供卫东企业网站建设,专注与做网站、成都做网站、H5页面制作、小程序制作等业务。10年已为卫东众多企业、政府机构等服务。创新互联专业网站设计公司优惠进行中。

包是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文件包导入有三种模式：正常模式、别名模式、简便模式

到此这篇关于Golang import本地包和导入问题相关详解的文章就介绍到这了,更多相关Golang import包内容请搜索创新互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持创新互联！