概述

Go 语言中的程序由软件包组成,一般来说,软件包会依赖于其他软件包,这些软件包可能是标准库或者是第三方的软件包。但是,无论是哪里的,包都需要先导入才能使用其导出的标识符,而这需要通过调用 import 语句:

  1. package main
  2. import (
  3. "fmt"
  4. "math"
  5. )
  6. func main() {
  7. fmt.Println(math.Exp2(10)) // 1024
  8. }

上面我们有一个 导入声明 和两个 Import 语句。每个 Import 语句都定义了单个包的导入。

名为 main 的软件包用于创建可执行二进制文件。程序执行通过调用在 package main 中的 main 的函数开始。

但是…… 还有其他一些不太为人所知的选项在各种情况下都很有用:

  1. import (
  2. "math"
  3. m "math"
  4. . "math"
  5. _ "math"
  6. )

这四个导入规范中的每一个都有不同的表现,在本文中,我们将分析这些差异。

导入包只能引用导入包中的导出标识符。导出的标识符是以 Unicode 大写字母开头的 -  https://golang.org/ref/spec#Exported_identifiers

基础

Import 语句声明

  1. ImportDeclaration = "import" ImportSpec
  2. ImportSpec = [ "." | "_" | Identifier ] ImportPath

我们来看一些例子:

  1. import . "fmt"
  2. import _ "io"
  3. import log "github.com/sirupsen/logrus"
  4. import m "math"

因式导入声明

导入两个或更多包可以用两种方式编写。我们可以编写多个导入声明:

  1. import "io"
  2. import "bufio"

或者我们可以使用因式导入声明(在单个导入声明中使用多个 ImportSpec):

  1. import (
  2. "io"
  3. "bufio"
  4. )

第二个选项特别有用,如果包有很多导入,然后 import 多次重复关键字会降低可读性。如果您不使用 https://github.com/bradfitz/goimports 等自动修复导入的工具,它还可以节省一些击键。

(短)导入路径

在导入语句中使用的字符串字面量(每个导入声明包含一个或多个导入语句)指定要导入的包。这个字符串被称为导入路径。根据语言规范,它取决于实现如何解释导入路径(字符串),但在实际中它是路径相关包的 vendor 目录或 go env GOPATH/src(更多关于 GOPATH)。

内置的软件包可以使用短路径进行导入,例如 “math” 和 “fmt”。

.go 文件剖析

每个.go 文件的结构都是一样的。首先是包的描述,可选地在前面加注释,通常描述包的用途。然后是零个或多个导入声明。第三部分包含零个或多个顶级声明(源代码):

  1. // description...
  2. package main // package clause
  3. // zero or more import declarations
  4. import (
  5. "fmt"
  6. "strings"
  7. )
  8. import "strconv"
  9. // top-level declarations
  10. func main() {
  11. fmt.Println(strings.Repeat(strconv.FormatInt(15, 16), 5))
  12. }

强制的组织形式不允许引入不必要的混乱,这简化了解析过程,并基本上导航了代码库(导入声明不能放在包子句之前,也不能与顶级声明交错,因此总是很容易找到)。

import 范围

导入的范围是文件块。这意味着它可以从整个文件中访问,但不在整个包中:

  1. // github.com/mlowicki/a/main.go
  2. package main
  3. import "fmt"
  4. func main() {
  5. fmt.Println(a)
  6. }
  7. // github.com/mlowicki/a/foo.go
  8. package main
  9. var a int = 1
  10. func hi() {
  11. fmt.Println("Hi!")
  12. }

这样的程序不能编译:

  1. > go build
  2. # github.com/mlowicki/a
  3. ./foo.go:6:2: undefined: fmt

关于范围的更多内容我以前有一篇文章讲过:Scopes in Go

import 的类型

自定义包名称

按照惯例,导入路径的最后一个组件也是导入包的名称。当然,没有什么能阻止我们不遵循这个惯例:

  1. # github.com/mlowicki/main.go
  2. package main
  3. import (
  4. "fmt"
  5. "github.com/mlowicki/b"
  6. )
  7. func main() {
  8. fmt.Println(c.B)
  9. }
  10. # github.com/mlowicki/b/b.go
  11. package c
  12. var B = "b"

输出很简单: b。尽管有可能可以写成其他形式,但按照惯例通常会更好 - 各种工具都依赖于它。

如果未在导入规范中指定自定义软件包名称,则使用来自软件包子句的名称来引用导入软件包中的导出标识符:

  1. package main
  2. import "fmt"
  3. func main() {
  4. fmt.Println("Hi!")
  5. }

可以传递自定义包名称以进行导入:

  1. # github.com/mlowicki/b/b.go
  2. package b
  3. var B = "b"
  4. package main
  5. import (
  6. "fmt"
  7. c "github.com/mlowicki/b"
  8. )
  9. func main() {
  10. fmt.Println(c.B)
  11. }

结果和以前一样。如果我们的软件包与其他软件包具有相同的接口(导出的标识符),则这种导入形式非常有用。其中一个例子是 https://github.com/sirupsen/logrus,它具有与日志兼容的 API :

  1. import log "github.com/sirupsen/logrus"

如果我们只使用在内置日志包中找到的 API,那么替换这种导入 import "log" 并不需要对源代码进行任何更改。它也稍短(但仍然有意义),因此可以节省一些击键。

将所有导出的标识符放入导入块

例如这样的导入语句:

  1. import m "math"
  2. import "fmt"

可以引用导出标识符与导入规范(m.Exp)中传递的包名称,也可以引用导入包(fmt.Println)的包子句中的名称。还有另一个选项允许访问导出的标识符而不需要合格的标识符:

  1. package main
  2. import (
  3. "fmt"
  4. . "math"
  5. )
  6. func main() {
  7. fmt.Println(Exp2(6)) // 64
  8. }

什么时候可能有用?在测试中。假设我们已经打包了一个由包 b 导入的包。现在我们要添加测试来打包 a。如果测试也将在包 a 中进行,并且测试也将导入包 b(因为那么需要在那里实现一些东西),那么我们将最终得到禁止的循环依赖。避免这种情况的一种方法是将测试放入单独的软件包,如 a_tests。然后,我们需要导入包 a 并引用具有合格标识符的每个导出的标识符。为了使我们的生活更轻松,我们可以导入包一个用点:

  1. import . "a"

然后在没有包名称的情况下从包 a 中引用导出的标识符(就像测试在同一包中但未导出标识符不可访问时一样)。

如果至少有一个导出的标识符是共同的,那么使用点作为包名称导入两个包是不可能的:

  1. # github.com/mlowicki/c
  2. package c
  3. var V = "c"
  4. # github.com/mlowkci/b
  5. package b
  6. var V = "b"
  7. # github.com/mlowicki/a
  8. package main
  9. import (
  10. "fmt"
  11. . "github.com/mlowicki/b"
  12. . "github.com/mlowicki/c"
  13. )
  14. func main() {
  15. fmt.Println(V)
  16. }
  17. > go run main.go
  18. # command-line-arguments
  19. ./main.go:6:2: V redeclared during import "github.com/mlowicki/c"
  20. previous declaration during import "github.com/mlowicki/b"
  21. ./main.go:6:2: imported and not used: "github.com/mlowicki/c"

用空白标识符导入

如果包被导入但是未被使用(源代码),Golang 的编译器就会大声叫嚷:

  1. package main
  2. import "fmt"
  3. func main() {}

用点导入所有导出的标识符直接添加到导入文件块的过程中,在编译源代码时也会失败。唯一的变体是具有空白标识符的变体。需要知道 init 函数是为了理解为什么我们需要使用空白标识符导入。以前的一篇文章也已经介绍了 init 函数:init function in Go,我鼓励你从上到下阅读它,但本质上是像下面这样导入:

  1. import _ "math"

不需要在导入文件中使用包数学,但是从导入包中初始化函数将被执行(包和它的依赖关系将被初始化)。如果我们只关注由导入的包完成的引导工作,但我们没有引用任何导出的标识符,这很有用。

如果程序包导入时没有空白标识符并且完全不使用,编译将会失败。

循环导入

Go 规范明确禁止循环导入 - 当程序包间接导入时。最明显的例子是,当包一个进口包 b 和包 b 接着导入包一:

  1. # github.com/mlowicki/a/main.go
  2. package a
  3. import "github.com/mlowicki/b"
  4. var A = b.B
  5. # github.com/mlowicki/b/main.go
  6. package b
  7. import "github.com/mlowicki/a"
  8. var B = a.A

试图构建这两个包中的任何一个都会导致错误:

  1. > go build
  2. can't load package: import cycle not allowed
  3. package github.com/mlowicki/a
  4. imports github.com/mlowicki/b
  5. imports github.com/mlowicki/a

当然,它可以是更复杂的场景,如 a→b→c→d→a 其中 x → y 表示包 x 导入包 y。

软件包不能自行导入:

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/mlowicki/a"
  5. )
  6. var A = "a"
  7. func main() {
  8. fmt.Println(a.A)
  9. }

编译这个包也会给出错误:can’t load package: import cycle not allowed。

Reference

  1. 原文:Import declarations in Go