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

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Println(math.Exp2(10))  // 1024
}

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

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

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

import (
    "math"
    m "math"
    . "math"
    _ "math"
)

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

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

基础

Import 语句声明

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

我们来看一些例子:

import . "fmt"
import _ "io"
import log "github.com/sirupsen/logrus"
import m "math"

因式导入声明

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

import "io"
import "bufio"

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

import (
    "io"
    "bufio"
)

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

(短)导入路径

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

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

.go 文件剖析

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

// description...
package main // package clause
// zero or more import declarations
import (
    "fmt"
    "strings"
)
import "strconv"
// top-level declarations
func main() {
    fmt.Println(strings.Repeat(strconv.FormatInt(15, 16), 5))
}

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

import 范围

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

// github.com/mlowicki/a/main.go
package main
import "fmt"
func main() {
    fmt.Println(a)
}
// github.com/mlowicki/a/foo.go
package main
var a int = 1
func hi() {
    fmt.Println("Hi!")
}

这样的程序不能编译:

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

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

import 的类型

自定义包名称

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

# github.com/mlowicki/main.go
package main
import (
    "fmt"
    "github.com/mlowicki/b"
)
func main() {
    fmt.Println(c.B)
}
# github.com/mlowicki/b/b.go
package c
var B = "b"

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

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

package main
import "fmt"
func main() {
    fmt.Println("Hi!")
}

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

# github.com/mlowicki/b/b.go
package b
var B = "b"
package main
import (
    "fmt"
    c "github.com/mlowicki/b"
)
func main() {
    fmt.Println(c.B)
}

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

import log "github.com/sirupsen/logrus"

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

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

例如这样的导入语句:

import m "math"
import "fmt"

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

package main
import (
    "fmt"
    . "math"
)
func main() {
    fmt.Println(Exp2(6))  // 64
}

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

import . "a"

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

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

# github.com/mlowicki/c
package c
var V = "c"
# github.com/mlowkci/b
package b
var V = "b"
# github.com/mlowicki/a
package main
import (
    "fmt"
    . "github.com/mlowicki/b"
    . "github.com/mlowicki/c"
)
func main() {
    fmt.Println(V)
}
> go run main.go
# command-line-arguments
./main.go:6:2: V redeclared during import "github.com/mlowicki/c"
    previous declaration during import "github.com/mlowicki/b"
./main.go:6:2: imported and not used: "github.com/mlowicki/c"

用空白标识符导入

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

package main
import "fmt"

func main() {}

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

import _ "math"

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

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

循环导入

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

# github.com/mlowicki/a/main.go
package a
import "github.com/mlowicki/b"
var A = b.B
# github.com/mlowicki/b/main.go
package b
import "github.com/mlowicki/a"
var B = a.A

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

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

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

软件包不能自行导入:

package main
import (
    "fmt"
    "github.com/mlowicki/a"
)
var A = "a"
func main() {
    fmt.Println(a.A)
}

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

Reference

  1. 原文:Import declarations in Go