Go语言从入门到规范-7.1、Go语言命令

Go语言从入门到规范-7.1、Go语言命令

---

1. 前言

正是由于命令的存在，使得Go在某些情况下像是python等语言一样解释执行，实际上Go的命令确实吸收了解释器的优点，使得一些常见系统的交叉编译更加方便（虽然失去了部分自由性，但是仍然可自行扩展适配），然后又将编译语言所需要的编译、链接等过程封装命令化，不同平台等都是一套命令，而当有新的需求后，支撑命令的程序也可以随着Go升级而升级，使得Go兼具解释性语言和编译型语言的特性。

2. 命令简介

这是一组用来构建并处理 Go 源码的程序套件。本套件中的程序并不直接运行，而是通过 go 程序来调用。

运行这些程序最普通的方式就是作为 go 程序的子命令，例如 go fmt。若像这样运行， 该命令就会在Go源码的完整包上进行操作，它使用 go 程序通过适当的实参来调用基本的二进制程序以进行包级处理。

也可作为独立的二进制程序，加上未修改的实参，并使用 go 的 tool 子命令来运行，例如 go tool vet。以下调用风格也是允许的，例如， 检查单个源文件而非整个包：go tool vet myprogram.go 对比于 go vet mypackage。 有一些命令，如 yacc，只能通过 go 的 tool 子命令来访问。

最后，fmt 与 doc 两个命令也作为常规的二进制被安装为 gofmt 和 godoc，因为它们偶尔会被引用。

欲获取更多文档、调用方法及用法详述，请点击以下链接。

名称		简介
go		go 程序管理 Go 源码以及运行其它在此列出的命令。用法详述见命令文档。
cgo		Cgo 使 Go 包的创建能够调用 C 代码。
cover		Cover 用于创建并优化由 "go test -coverprofile" 生成的规模评估。
fix		Fix 发现使用旧语言与库特性的 Go 程序，并使用较新的特性来重写它们。
fmt		Fmt 格式化 Go 包，它作为独立的gofmt命令，使用更一般的选项同样有效。
godoc		Godoc 从 Go 包中提取并生成文档。
vet		Vet 检查 Go 源码并报告可疑的构造，例如 Printf 调用的实参数与格式化字符串不匹配。
yacc		Yacc 是 yacc 的一个版本，它生成在 Go 中实现的解析器。

这是一个简略的列表。编译器及更多文档见完整的命令参考

3. go命令

Go是一个管理Go源代码的工具。

用法：

go command [arguments]

go命令包括：

build   编译包和依赖项
clean   删除目标文件
env     打印Go环境信息
fix     在包上运行go工具修复
gofmt   在包源码上运行gofmt
get     下载并安装软件包和依赖项
install 编译和安装软件包和依赖项
list    列出全部扩展
run     编译并运行Go程序
test    测试包
tool    运行指定的go工具
version 打印Go版本
vet     在软件包上运行Go工具vet

使用“go help [command]”获取命令的更多信息。

额外的帮助主题:

c           在Go和c之间调用
filetype    文件系统
gopath      GOPATH环境变量
importpath  导入路径语言
packages    包列表说明
teslflag    测试标志说明
testfunc    测试功能说明

使用“go help [topic]”来获取关于该话题的更多信息。

4. 编译包和依赖项build

用法：

go build [-o output] [-i] [build flags] [packages]

Build编译以导入路径命名的包及其依赖项，但不安装结果。

如果参数是.go文件的列表，build将它们视为指定单个包的源文件列表。

当命令行指定单个主包时，build将生成的可执行文件写入输出。否则，build会编译包，但会丢弃结果，只用于检查是否可以构建包。

-o标志指定输出文件名。如果没有指定，输出文件名依赖于参数并派生于包的名称，如p.a表示包p，除非p是’main’。如果包是main并且提供了文件名，则文件名派生于提到的第一个文件名，例如f1表示’go build f1.go f2.go”;如果没有提供文件(‘go build’)，输出文件名就是包含目录的基本名称。

-i标志安装与目标相关的包。

构建flags由build、clean、get、install、list、run和test命令共享:

-a
    强制重新构建已经更新的包。
    在Go版本中，不适用于标准库。
-n
    打印命令但不运行它们。
-p n
    可以并行运行的构建的数量。
    默认值是可用的cpu数量。
-race
    启用数据竞争检测。
    仅支持linux/amd64, freebsd/amd64, darwin/amd64和windows/amd64。
-v
    在编译包时打印包名。
-work
    打印临时工作目录的名称和退出时不要删除。
-x
    打印命令
-ccflags 'arg list'
    每个5c、6c或8c编译器调用传递的参数。
-compiler name
    要使用的编译器名称，如在运行时。编译器(gccgo或gc)。
-gccgoflags 'arg list'
    参数传递给每个gccgo编译器/链接器调用。
-gcflags 'arg list'
    每个5g、6g或8g编译器调用传递的参数。
-installsuffix suffix
    用于包安装目录名称的后缀，为了使输出与默认构建分开。
    如果使用-race标志，安装后缀将自动设置为race
或者，如果显式设置，则附加有_race。
-ldflags 'flag list'
    参数传递给每个5l、6l或8l链接器调用。
-tags 'tag list'
    构建过程中要考虑的构建标记列表。
    有关构建标记的更多信息，请参见在go/ Build包的文档中构建约束。

列表标志接受空格分隔的字符串列表。若要在列表中的元素中嵌入空格，请用单引号或双引号将其包围。

有关指定包的更多信息，请参见“去帮助包”。有关安装包和二进制文件的更多信息，请运行’go help gopath’。关于Go和C/c++之间调用的更多信息，运行’ Go help C '。

参见：go install， go get，go clean

5. 删除目标文件

用法：

go clean [-i] [-r] [-n] [-x] [build flags] [packages]

Clean从包源目录中删除目标文件。go命令在临时目录中构建大多数对象，所以go clean主要关注其他工具或手动调用go build留下的对象文件。

具体来说，clean将从与导入路径对应的每个源目录中删除以下文件:

_obj/            旧的对象文件，makefile产生
_test/           旧的测试文件, Makefiles产生
_testmain.go     旧的gotest文件, Makefiles产生
test.out         旧的测试log, Makefiles产生
build.out        旧的测试log, Makefiles产生
*.[568ao]        对象文件, Makefiles产生

DIR(.exe)        go build产生
DIR.test(.exe)   go test -c产生
MAINFILE(.exe)   go build MAINFILE.go产生
*.so             SWIG产生

在列表中，DIR表示目录的最终路径元素，而MAINFILE是在构建包时未包含的目录中任何Go源文件的基本名称。

-i标志导致clean删除相应的已安装的归档文件或二进制文件('go install’将创建的文件)。

-n标志导致clean打印它将执行的删除命令，但不会运行它们。

-r标志导致clean被递归应用到由导入路径命名的包的所有依赖项。

-x标志导致clean在执行删除命令时打印它们。

有关构建标志的更多信息，请参阅’go help build’。

有关指定包的更多信息，请参见“go help packages”。

6. 打印Go环境信息

用法：

go env [var ...]

Env打印Go环境信息。

默认情况下，env将信息打印为shell脚本(在Windows上是批处理文件)。如果给出一个或多个变量名作为参数，env将每个已命名变量的值打印在该行上。

7. 在包上运行go工具fix

用法：

go fix [packages]

Fix对以导入路径命名的包运行Go Fix命令。

有关修复的更多信息，请参见“godoc修复”。有关指定包的更多信息，请参见“去帮助包”。

要运行特定选项的fix，请运行’go tool fix’。

参见:go fmt，go vet。

8. 在package sources上运行gofmt

用法：

go fmt [-n] [-x] [packages]

Fmt对以导入路径命名的包运行’gofmt -l -w’命令。它打印被修改的文件的名称。

有关gofmt的更多信息，请参见“godoc gofmt”。有关指定包的更多信息，请参见“go help packages”。

-n标志打印将要执行的命令。-x标志在执行命令时打印命令。

要运行带有特定选项的gofmt，请运行gofmt本身。

参见:go fix，go vet。

9. 通过处理源代码生成Go文件

用法：

go generate [-run regexp] [file.go... | packages]

生成由现有文件中的指令描述的运行命令。这些命令可以运行任何进程，但目的是创建或更新Go源文件，例如通过运行yacc。

Go generate不会通过Go build, Go get, Go test等方式自动运行。它必须显式地运行。

Go generate扫描文件中的指令，这些指令是表格中的行，

//go:generate command argument...

(注意:“//go”中没有空格和前导空格)这里的命令是要运行的生成器，对应于一个可以在本地运行的可执行文件。它必须在shell路径(gofmt)，一个完全限定的路径(/usr/you/bin/mytool)，或者一个命令别名，如下所述。

请注意，go generate并不解析文件，所以看起来像注释中的指令或多行字符串的行将被视为指令。

指令的参数是空格分隔的标记或双引号字符串，在运行时作为单独的参数传递给生成器。

引用字符串使用

$GOARCH     执行架构(arm、amd64等)
$GOOS       执行操作系统(linux、windows等)
$GOFILE     文件的基本名称。
$GOPACKAGE  包含该指令的文件的包名。 

除了变量替换和带引号的字符串计算外，在命令行上不执行“globbing”之类的特殊处理。

作为运行该命令之前的最后一步，对任何具有字母数字名称(例如$GOFILE或$HOME)的环境变量的任何调用都将在整个命令行中展开。变量展开的语法在所有操作系统上都是$NAME。由于求值的顺序，变量甚至在带引号的字符串中进行扩展。如果没有设置变量NAME，$NAME扩展为空字符串。

一种形式的指令，

//go:generate -command xxx args...

对于源文件的其余部分，指定字符串XXX表示由参数标识的命令。这可用于创建别名或处理多字生成器。例如,

//go:generate -command yacc go tool yacc

指定命令“yacc”代表生成器“go tool yacc”。

按照命令行上给出的顺序，一次生成一个进程包。如果命令行列出.go文件，则将它们视为单个包。在包中，generate按照文件名的顺序处理包中的源文件，一次一个。在源文件中，generate按照生成器在文件中出现的顺序运行生成器，每次一个。

如果任何生成器返回错误退出状态，“go generate”将跳过该包的所有进一步处理。

生成器在包的源目录中运行。

Go generate接受一个特定的标志:

-run=""
    if non-empty, specifies a regular expression to
    select directives whose command matches the expression.

它还接受标准的构建标志-v、-n和-x。-v标志在处理包和文件时打印包和文件的名称。-n标志打印将要执行的命令。-x标志在执行命令时打印命令。

有关指定包的更多信息，请参见“go help packages”。

10. 下载并安装软件包和依赖项

用法：

go get [-d] [-f] [-fix] [-t] [-u] [build flags] [packages]

Get下载并安装按导入路径命名的包及其依赖项。

-d标志指示下载包后停止;也就是说，它指示get不要安装软件包。

-f标志仅在-u设置时有效，它强制get -u不验证每个包是否已从其导入路径所暗示的源代码控制存储库签出。如果源文件是原始文件的本地分支，这将非常有用。

-fix标志指示在解析依赖项或构建代码之前，对下载的包运行修复工具。

-t标志还指示下载为指定的包构建测试所需的包。

u标志指示使用网络更新已命名包及其依赖项。默认情况下，get使用网络检出丢失的包，但不使用它查找现有包的更新。

Get还接受构建标志来控制安装。参见“go help build”。

签出或更新包时，get会查找与本地安装的Go版本相匹配的分支或标记。最重要的规则是，如果本地安装运行的版本是“go1”，搜索名为“go1”的分支或标记。如果不存在这样的版本，它将检索包的最新版本。

有关指定包的更多信息，请参见“go help packages”。

有关’go get’如何找到要下载的源代码的更多信息，请参见’go help importpath’。

参见:go build，go install，go clean。

11. 编译和安装软件包和依赖项

用法：

go install [build flags] [packages]

Install编译并安装由导入路径命名的包及其依赖项。

有关构建标志的更多信息，请参阅’go help build’。有关指定包的更多信息，请参见“去帮助包”。

也可以看到:go build，go get，go clean。

12. 列出套件包

用法：

go list [-e] [-f format] [-json] [build flags] [packages]

List列出了按导入路径命名的包，每行一个。

默认输出显示包导入路径:

code.google.com/p/google-api-go-client/books/v1
code.google.com/p/goauth2/oauth
code.google.com/p/sqlite

-f标志使用包模板的语法为列表指定了一种替代格式。默认输出相当于-f ‘{{. importpath}}’。传递给模板的结构体是:

type Package struct {
    Dir           string // directory containing package sources
    ImportPath    string // import path of package in dir
    ImportComment string // path in import comment on package statement
    Name          string // package name
    Doc           string // package documentation string
    Target        string // install path
    Goroot        bool   // is this package in the Go root?
    Standard      bool   // is this package part of the standard Go library?
    Stale         bool   // would 'go install' do anything for this package?
    Root          string // Go root or Go path dir containing this package

    // Source files
    GoFiles        []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
    CgoFiles       []string // .go sources files that import "C"
    IgnoredGoFiles []string // .go sources ignored due to build constraints
    CFiles         []string // .c source files
    CXXFiles       []string // .cc, .cxx and .cpp source files
    MFiles         []string // .m source files
    HFiles         []string // .h, .hh, .hpp and .hxx source files
    SFiles         []string // .s source files
    SwigFiles      []string // .swig files
    SwigCXXFiles   []string // .swigcxx files
    SysoFiles      []string // .syso object files to add to archive

    // Cgo directives
    CgoCFLAGS    []string // cgo: flags for C compiler
    CgoCPPFLAGS  []string // cgo: flags for C preprocessor
    CgoCXXFLAGS  []string // cgo: flags for C++ compiler
    CgoLDFLAGS   []string // cgo: flags for linker
    CgoPkgConfig []string // cgo: pkg-config names

    // Dependency information
    Imports []string // import paths used by this package
    Deps    []string // all (recursively) imported dependencies

    // Error information
    Incomplete bool            // this package or a dependency has an error
    Error      *PackageError   // error loading package
    DepsErrors []*PackageError // errors loading dependencies

    TestGoFiles  []string // _test.go files in package
    TestImports  []string // imports from TestGoFiles
    XTestGoFiles []string // _test.go files outside package
    XTestImports []string // imports from XTestGoFiles
}

模板函数“join”调用strings.Join。

模板函数"context"返回构建上下文，定义如下:

type Context struct {
    GOARCH        string   // target architecture
    GOOS          string   // target operating system
    GOROOT        string   // Go root
    GOPATH        string   // Go path
    CgoEnabled    bool     // whether cgo can be used
    UseAllFiles   bool     // use files regardless of +build lines, file names
    Compiler      string   // compiler to assume when computing target paths
    BuildTags     []string // build constraints to match in +build lines
    ReleaseTags   []string // releases the current release is compatible with
    InstallSuffix string   // suffix to use in the name of the install dir
}

有关这些字段含义的更多信息，请参见go/build包的Context类型的文档。

-json标志导致包数据以JSON格式打印，而不是使用模板格式。

-e标志更改错误包的处理，即无法找到或格式不正确的包。默认情况下，list命令为每个错误包打印一个错误到标准错误，并在通常打印过程中忽略这些包。使用-e标志，list命令不会将错误打印到标准错误，而是使用通常的打印处理错误包。错误的包将有一个非空的ImportPath和一个非空的Error字段;其他信息可能丢失，也可能不丢失(归零)。

有关构建标志的更多信息，请参阅’go help build’。

有关指定包的更多信息，请参见“go help packages”。

13. 编译并运行Go程序

用法：

go run [build flags] [-exec xprog] gofiles... [arguments...]

Run编译并运行包含Go源文件的主包。Go源文件被定义为以".go”后缀的文件。

默认情况下，'go run’直接运行编译后的二进制文件:‘a.out arguments…’。如果给出了-exec标志，'go run’将使用xprog: 'xprog a.o narguments…'调用二进制文件。如果没有给出-exec标志，GOOS或GOARCH与系统默认值不同，并且在当前搜索路径上可以找到一个名为go_KaTeX parse error: Expected group after '_' at position 5: GOOS_̲GOARCH_exec的程序，‘go run’使用该程序调用二进制文件，例如’go_nacl_386_exec a.out arguments…’。这允许在模拟器或其他执行方法可用时执行交叉编译的程序。

有关构建标志的更多信息，请参阅’go help build’。

参见：go build

14. 测试包

用法：

go test [-c] [-i] [build and test flags] [packages] [flags for test binary]

'Go test’自动测试由导入路径命名的包。它以如下格式输出测试结果的摘要:

ok   archive/tar   0.011s
FAIL archive/zip   0.022s
ok   compress/gzip 0.033s
...

然后是每个失败包的详细输出。

‘Go test’会重新编译每个包，以及任何文件名匹配文件模式"*test.go"的文件。文件名以“”(包括“_test.go”)或“。”开头的文件将被忽略。这些附加文件可以包含测试函数、基准函数和示例函数。更多信息请参见’go help testfunc’。每个列出的包都会导致执行一个单独的测试二进制文件。

声明带有后缀“_test”的包的测试文件将被编译为一个单独的包，然后与主测试二进制文件链接并运行。

默认情况下，go测试不需要参数。它编译和测试当前目录中的源代码包(包括测试)，并运行测试。

该包构建在一个临时目录中，因此它不会干扰非测试安装。

除了构建标志，'go test’本身处理的标志是:

-c
    Compile the test binary to pkg.test but do not run it
    (where pkg is the last element of the package's import path).
    The file name can be changed with the -o flag.

-exec xprog
    Run the test binary using xprog. The behavior is the same as
    in 'go run'. See 'go help run' for details.

-i
    Install packages that are dependencies of the test.
    Do not run the test.

-o file
    Compile the test binary to the named file.
    The test still runs (unless -c or -i is specified).

测试二进制文件也接受控制测试执行的标志;这些标记也可以通过“go test”访问。详情请参阅’go help testflag’。

如果测试二进制文件需要任何其他标志，它们应该显示在包名之后。go工具将第一个以负号开头的参数视为一个标志，它不能识别自己;该参数和所有后续参数都作为参数传递给测试二进制文件。

有关构建标志的更多信息，请参阅’go help build’。有关指定包的更多信息，请参见“go help packages”。

参见：go build，go vet

15. 运行指定的go工具

用法：

go tool [-n] command [args...]

工具运行由参数标识的go工具命令。如果没有参数，它将打印已知工具的列表。

-n标志导致工具打印将要执行的命令，但不执行它。

有关每个工具命令的更多信息，请参见“go tool command -h”。

16. 打印Go版本

go version

Version打印由runtime.Version报告的Go版本。

17. 在软件包上运行go工具vet

用法:

go vet [-n] [-x] [packages]

Vet对以导入路径命名的包运行Go Vet命令。

更多关于vet的信息，请参见“godoc golang.org/x/tools/cmd/vet”。有关指定包的更多信息，请参见“去go help packages”。

要运行带有特定选项的vet工具，请运行’go tool vet’。

-n标志打印将要执行的命令。-x标志在执行命令时打印命令。

参见:go fmt, go fix。

18. 在Go和C之间调用

在Go和C/ c++代码之间有两种不同的调用方式。

第一个是cgo工具，它是Go发行版的一部分。有关如何使用它的信息，请参阅cgo文档(godoc cmd/cgo)。

第二个是SWIG程序，它是一种用于语言间接口的通用工具。有关SWIG的信息，请参见http://swig.org/。当运行go build时，任何扩展名为. SWIG的文件都将被传递给SWIG。任何扩展名为.swigcxx的文件都将通过-c++选项传递给SWIG。

当使用cgo或SWIG时，go build会将任何. C、.m、.s或.s文件传递给C编译器，将任何.cc、.cpp、.cxx文件传递给c++编译器。可以设置CC或CXX环境变量来分别确定要使用的C或c++编译器。

19. 文件类型

go命令检查每个目录中受限制的文件集的内容。它根据文件名的扩展名识别要检查的文件。这些扩展是:

.go
    Go source files.
.c, .h
    C source files.
    If the package uses cgo, these will be compiled with the
    OS-native compiler (typically gcc); otherwise they will be
    compiled with the Go-specific support compiler,
    5c, 6c, or 8c, etc. as appropriate.
.cc, .cpp, .cxx, .hh, .hpp, .hxx
    C++ source files. Only useful with cgo or SWIG, and always
    compiled with the OS-native compiler.
.m
    Objective-C source files. Only useful with cgo, and always
    compiled with the OS-native compiler.
.s, .S
    Assembler source files.
    If the package uses cgo, these will be assembled with the
    OS-native assembler (typically gcc (sic)); otherwise they
    will be assembled with the Go-specific support assembler,
    5a, 6a, or 8a, etc., as appropriate.
.swig, .swigcxx
    SWIG definition files.
.syso
    System object files.

除了.syso之外，每种类型的文件都可能包含构建约束，但go命令会在文件中第一个非空行或//风格行注释项停止扫描构建约束。

20. GOPATH环境变量

Go路径用于解析导入语句。它是由go/build包实现并记录的。

GOPATH环境变量列出了寻找Go代码的地方。在Unix上，该值是冒号分隔的字符串。在Windows上，该值是一个分号分隔的字符串。在计划9中，值是一个列表。

必须将GOPATH设置为获取、构建和安装标准Go树之外的包。

GOPATH中列出的每个目录必须有一个规定的结构:

src/目录保存源代码。'src’下面的路径决定了导入路径或可执行文件名。

pkg/目录包含已安装的包对象。和Go树一样，每个目标操作系统和体系结构对都有自己的pkg (pkg/GOOS_GOARCH)子目录。

如果DIR是GOPATH中列出的目录，那么在DIR/src/foo/bar中包含source的包可以被导入为"foo/bar"，并将其编译后的形式安装到"DIR/pkg/GOOS_GOARCH/foo/bar.a"中。

bin/目录保存已编译的命令。每个命令都以其源目录命名，但仅以最终元素命名，而不是以整个路径命名。也就是说，在DIR/src/foo/quux中带有source的命令被安装到DIR/bin/quux中，而不是DIR/bin/foo/quux。foo/被剥离，以便您可以将DIR/bin添加到您的PATH以获得已安装的命令。如果设置了GOBIN环境变量，命令会安装到它所指定的目录下，而不是DIR/bin。

下面是一个目录布局的示例:

GOPATH=/home/user/gocode

/home/user/gocode/
    src/
        foo/
            bar/               (go code in package bar)
                x.go
            quux/              (go code in package main)
                y.go
    bin/
        quux                   (installed command)
    pkg/
        linux_amd64/
            foo/
                bar.a          (installed package object)

Go搜索GOPATH中列出的每个目录以找到源代码，但是新的包总是被下载到列表中的第一个目录中。

21. 导入路径语法

导入路径(参见’go help packages’)表示存储在本地文件系统中的包。通常，导入路径表示一个标准包(如"unicode/utf8")或在某个工作空间中找到的包(参见’go help gopath’)。

22. 相对导入路径

以./或…开头的导入路径。/称为相对路径。工具链以两种方式支持相对导入路径。

首先，相对路径可以用作命令行上的简写。如果您在包含以"unicode"导入的代码的目录下工作，并且想要运行"unicode/utf8"的测试，您可以键入"go test ./utf8"，而不需要指定完整路径。类似地，在相反的情况下，"go test …“将从"unicode/utf8"目录中测试"unicode”。也允许使用相对模式，如“go test ./…”来测试所有子目录。有关模式语法的详细信息，请参阅’go help packages’。

其次，如果正在编译不在工作空间中的Go程序，可以在该程序的import语句中使用相对路径来引用附近也不在工作空间中的代码。这使得在通常的工作空间之外使用小的多包程序很容易，但是这样的程序不能通过“go install”(没有工作空间可以安装它们)来安装，所以每次构建它们时都要从头开始重新构建。为了避免歧义，Go程序不能在工作空间内使用相对导入路径。

23. 远程导入路径

某些导入路径还描述了如何使用修订控制系统获取包的源代码。

一些公共代码托管网站有特殊的语法:

Bitbucket (Git, Mercurial)

    import "bitbucket.org/user/project"
    import "bitbucket.org/user/project/sub/directory"

GitHub (Git)

    import "github.com/user/project"
    import "github.com/user/project/sub/directory"

Google Code Project Hosting (Git, Mercurial, Subversion)

    import "code.google.com/p/project"
    import "code.google.com/p/project/sub/directory"

    import "code.google.com/p/project.subrepository"
    import "code.google.com/p/project.subrepository/sub/directory"

Launchpad (Bazaar)

    import "launchpad.net/project"
    import "launchpad.net/project/series"
    import "launchpad.net/project/series/sub/directory"

    import "launchpad.net/~user/project/branch"
    import "launchpad.net/~user/project/branch/sub/directory"

IBM DevOps Services (Git)

    import "hub.jazz.net/git/user/project"
    import "hub.jazz.net/git/user/project/sub/directory"

对于托管在其他服务器上的代码，导入路径可以通过版本控制类型限定，或者go工具可以通过https/http动态获取导入路径，并从HTML中的<meta>标记中发现代码所在的位置。

要声明代码位置，请使用表单的导入路径

repository.vcs/path

使用命名的版本控制系统指定给定的存储库(带或不带.vcs后缀)，然后是存储库中的路径。支持的版本控制系统有:

Bazaar      .bzr
Git         .git
Mercurial   .hg
Subversion  .svn

举个例子：

import "example.org/user/foo.hg"

表示Mercurial存储库example.org/user/foo或foo.hg和

import "example.org/repo.git/foo/bar"

表示Git仓库的foo/bar目录example.org/repo或repo.git。

当版本控制系统支持多种协议时，在下载时依次尝试每种协议。例如，Git下载尝试Git://，然后是"https://"，然后是http://.

如果导入路径不是一个已知的代码托管站点，也没有版本控制限定符，那么go工具会尝试通过https/http获取导入，并在文档的HTML <head>中查找<meta>标记。

meta标签的形式如下:

<meta name="go-import" content="import-prefix vcs repo-root">

import-prefix是与存储库根对应的导入路径。它必须是一个前缀或与“go get”获取的包的精确匹配。如果不是完全匹配，则在前缀处发出另一个http请求来验证<meta>标记匹配。

vcs是“git”、“hg”、“svn”等，

repo-root是版本控制系统的根，它包含一个方案，不包含.vcs限定符。

例如,

import "example.org/pkg/foo"

会引致下列request:

https://example.org/pkg/foo?go-get=1 (preferred)
http://example.org/pkg/foo?go-get=1  (fallback)

如果该页面包含元标记

<meta name="go-import" content="example.org git https://code.org/r/p/exproj">

go工具将验证https://example.org/?go-get=1包含相同的元标签，然后git克隆https://code.org/r/p/exproj到GOPATH/src/example.org。

新下载的包被写到GOPATH环境变量中列出的第一个目录中(参见’go help GOPATH ')。

go命令尝试下载适合所使用的go版本的软件包版本。Run “go help get” for more。

24. 检查导入路径

当上面描述的自定义导入路径特性重定向到已知代码托管站点时，每个生成的包都有两个可能的导入路径，分别使用自定义域或已知托管站点。

如果一个包语句后面(在下一个换行符之前)紧跟着一个以下两种形式之一的注释，就说它有一个“import comment”:

package math // import "path"
package math /* import "path" * /

go命令将拒绝安装带有import注释的包，除非该包被导入路径引用。通过这种方式，导入注释让包作者确保使用了自定义导入路径，而不是到底层代码托管站点的直接路径。

详情请参见https://golang.org/s/go14customimport。

25. package lists说明

Many commands apply to a set of packages:

go action [packages]

通常，[packages]是一个导入路径列表。
导入路径，该路径是根路径或以。或. .元素被解释为文件系统路径，并表示该目录中的包。

否则，导入路径P表示在目录DIR/src/P中找到的包，在GOPATH环境变量中列出了一些DIR(参见’go help GOPATH ')。

如果没有给出导入路径，则该操作将应用于当前目录中的包。

有三个保留的路径名不应该被用go工具构建的包使用:

-“main”表示独立可执行文件中的顶级包。

-“all”展开到所有GOPATH树中的所有包目录。例如，'go list all’列出本地系统上的所有包。

-“std”类似于所有的，只是扩展到了标准Go库中的包。

如果导入路径包含一个或多个“…”通配符，那么它就是一个模式，每个通配符都可以匹配任何字符串，包括空字符串和包含斜杠的字符串。这样的模式扩展到在GOPATH树中找到的所有名称与模式匹配的包目录。作为特例，x/…匹配x和x的子目录。例如,net/…。在子目录中扩展为网络和包。

导入路径还可以命名要从远程存储库下载的包。运行’go help importpath’获取详细信息。

程序中的每个包必须有一个唯一的导入路径。按照惯例，这是通过用属于您的唯一前缀开始每个路径来安排的。例如，在谷歌内部使用的路径都以’谷歌’开头，而表示远程存储库的路径以代码的路径开头，例如’code.google.com/p/project’。

作为一种特殊情况，如果包列表是来自单个目录的.go文件列表，则该命令将应用于完全由这些文件组成的单个合成包，忽略这些文件中的任何构建约束，并忽略目录中的任何其他文件。

go工具会忽略以“。”或“_”开头的目录和文件名，如名为“testdata”的目录。

25. 测试标志说明

'go test’命令接受应用于’go test’本身的标志和应用于结果二进制测试的标志。
一些标志控制概要文件，并编写适合“go工具pprof”的执行概要文件;运行“go tool pprof help”获取更多信息。pprof的——alloc_space、——alloc_objects和——show_bytes选项控制信息的显示方式。
'go test’命令可以识别以下标志，并控制任何测试的执行:

-bench regexp
    Run benchmarks matching the regular expression.
    By default, no benchmarks run. To run all benchmarks,
    use '-bench .' or '-bench=.'.

-benchmem
    Print memory allocation statistics for benchmarks.

-benchtime t
    Run enough iterations of each benchmark to take t, specified
    as a time.Duration (for example, -benchtime 1h30s).
    The default is 1 second (1s).

-blockprofile block.out
    Write a goroutine blocking profile to the specified file
    when all tests are complete.
    Writes test binary as -c would.

-blockprofilerate n
    Control the detail provided in goroutine blocking profiles by
    calling runtime.SetBlockProfileRate with n.
    See 'godoc runtime SetBlockProfileRate'.
    The profiler aims to sample, on average, one blocking event every
    n nanoseconds the program spends blocked.  By default,
    if -test.blockprofile is set without this flag, all blocking events
    are recorded, equivalent to -test.blockprofilerate=1.

-cover
    Enable coverage analysis.

-covermode set,count,atomic
    Set the mode for coverage analysis for the package[s]
    being tested. The default is "set" unless -race is enabled,
    in which case it is "atomic".
    The values:
    set: bool: does this statement run?
    count: int: how many times does this statement run?
    atomic: int: count, but correct in multithreaded tests;
        significantly more expensive.
    Sets -cover.

-coverpkg pkg1,pkg2,pkg3
    Apply coverage analysis in each test to the given list of packages.
    The default is for each test to analyze only the package being tested.
    Packages are specified as import paths.
    Sets -cover.

-coverprofile cover.out
    Write a coverage profile to the file after all tests have passed.
    Sets -cover.

-cpu 1,2,4
    Specify a list of GOMAXPROCS values for which the tests or
    benchmarks should be executed.  The default is the current value
    of GOMAXPROCS.

-cpuprofile cpu.out
    Write a CPU profile to the specified file before exiting.
    Writes test binary as -c would.

-memprofile mem.out
    Write a memory profile to the file after all tests have passed.
    Writes test binary as -c would.

-memprofilerate n
    Enable more precise (and expensive) memory profiles by setting
    runtime.MemProfileRate.  See 'godoc runtime MemProfileRate'.
    To profile all memory allocations, use -test.memprofilerate=1
    and pass --alloc_space flag to the pprof tool.

-outputdir directory
    Place output files from profiling in the specified directory,
    by default the directory in which "go test" is running.

-parallel n
    Allow parallel execution of test functions that call t.Parallel.
    The value of this flag is the maximum number of tests to run
    simultaneously; by default, it is set to the value of GOMAXPROCS.

-run regexp
    Run only those tests and examples matching the regular
    expression.

-short
    Tell long-running tests to shorten their run time.
    It is off by default but set during all.bash so that installing
    the Go tree can run a sanity check but not spend time running
    exhaustive tests.

-timeout t
    If a test runs longer than t, panic.

-v
    Verbose output: log all tests as they are run. Also print all
    text from Log and Logf calls even if the test succeeds.

测试二进制文件称为pkg.test，其中pkg是包含包源的目录名，可以在使用’go test -c’构建它之后直接调用它。当直接调用测试二进制文件时，每个标准标志名都必须加上’test ‘前缀。’，如-test.run=TestMyFunc或-test.v。
当运行’go test’时，上面没有列出的标记将不加更改地传递。例如，命令:

go test -x -v -cpuprofile=prof.out -dir=testdata -update

将编译测试二进制文件，然后作为

pkg.test -test.v -test.cpuprofile=prof.out -dir=testdata -update

生成概要文件的测试标志(除了覆盖率)也将测试二进制文件留在pkg.test中，以便在分析概要文件时使用。

“go test”不能识别的标志必须放在任何指定的包裹后面。

26. 测试功能说明

'go test’命令期望在"*_test. exe "中找到test、benchmark和示例函数。Go”对应于测试包的文件。

测试函数是一个名为TestXXX的函数(其中XXX是任何不以小写字母开头的字母数字字符串)，并且应该有签名，

func TestXXX(t *testing.T) { ... }

基准函数是一个名为BenchmarkXXX的函数，它应该具有签名，

func BenchmarkXXX(b *testing.B) { ... }

示例函数类似于测试函数，但不是使用*testing。T报告成功或失败，将输出打印到os.Stdout。该输出将与函数的“output:”注释进行比较，“output:”注释必须是函数体中的最后一条注释(参见下面的示例)。如果一个示例没有这样的注释，或者在“Output:”之后没有文本，则编译但不执行。

Godoc显示了ExampleXXX的主体，以演示函数、常量或变量XXX的使用。例如，接收类型为T或*T的方法M被命名为ExampleT_M。对于给定的函数、常量或变量，可以有多个示例，以末尾_xxx区分，其中xxx是一个不以大写字母开头的后缀。

下面是一个例子:

func ExamplePrintln() {
    Println("The output of\nthis example.")
    // Output: The output of
    // this example.
}

当整个测试文件包含单个示例函数、至少一个其他函数、类型、变量或常量声明，并且没有测试或基准函数时，它将作为示例呈现。

有关更多信息，请参见测试包的文档。