9.8 自定义包的目录结构、go install 和 go test

为了示范，我们创建了一个名为 uc 的简单包，它含有一个 UpperCase 函数将字符串的所有字母转换为大写。当然这并不值得创建一个自定义包，同样的功能已被包含在 strings 包里，但是同样的技巧也可以应用在更复杂的包中。

9.8.1 自定义包的目录结构

下面的结构给了你一个好的示范（uc 代表通用包名, 名字为粗体的代表目录，斜体代表可执行文件）:

  1. /home/user/goprograms
  2.     ucmain.go    (uc 包主程序)
  3.     Makefile (ucmain 的 makefile)
  4.     ucmain
  5.     src/uc     (包含 uc 包的 go 源码)
  6.         uc.go
  7.          uc_test.go
  8.          Makefile (包的 makefile)
  9.          uc.a
  10.          _obj
  11.             uc.a
  12.         _test
  13.             uc.a
  14.     bin        (包含最终的执行文件)
  15.         ucmain
  16.     pkg/linux_amd64
  17.         uc.a    (包的目标文件)

将你的项目放在 goprograms 目录下(你可以创建一个环境变量 GOPATH，详见第 2.2/3 章节：在 .profile 和 .bashrc 文件中添加 export GOPATH=/home/user/goprograms)，而你的项目将作为 src 的子目录。uc 包中的功能在 uc.go 中实现。

示例 9.6 uc.go：

  1. package uc
  2. import "strings"
  4. func UpperCase(str string) string {
  5.     return strings.ToUpper(str)
  6. }

包通常附带一个或多个测试文件，在这我们创建了一个 uc_test.go 文件，如第 9.8 节所述。

示例 9.7 test.go

  1. package uc
  2. import "testing"
  4. type ucTest struct {
  5.     in, out string
  6. }
  8. var ucTests = []ucTest {
  9.     ucTest{"abc", "ABC"},
  10.     ucTest{"cvo-az", "CVO-AZ"},
  11.     ucTest{"Antwerp", "ANTWERP"},
  12. }
  14. func TestUC(t *testing.T) {
  15.     for _, ut := range ucTests {
  16.         uc := UpperCase(ut.in)
  17.         if uc != ut.out {
  18.             t.Errorf("UpperCase(%s) = %s, must be %s", ut.in, uc,
  19.             ut.out)
  20.         }
  21.     }
  22. }

通过指令编译并安装包到本地：go install uc, 这会将 uc.a 复制到 pkg/linux_amd64 下面。

另外，使用 make ，通过以下内容创建一个包的 Makefile 在 src/uc 目录下:

  1. include $(GOROOT)/src/Make.inc
  3. TARG=uc
  4. GOFILES=\
  5.         uc.go\
  7. include $(GOROOT)/src/Make.pkg

在该目录下的命令行调用: gomake

这将创建一个 _obj 目录并将包编译生成的存档 uc.a 放在该目录下。

这个包可以通过 go test 测试。

创建一个 uc.a 的测试文件在目录下，输出为 PASS 时测试通过。

在第 13.8 节我们将给出另外一个测试例子并进行深入研究。

备注：有可能你当前的用户不具有足够的资格使用 go install（没有权限）。这种情况下，选择 root 用户 su。确保 Go 环境变量和 Go 源码路径也设置给 su，同样也适用你的普通用户（详见第 2.3 节）。

接下来我们创建主程序 ucmain.go:

示例 9.8 ucmain.go：

  1. package main
  2. import (
  3.     "./src/uc"
  4.     "fmt"
  5. )
  7. func main() {
  8.     str1 := "USING package uc!"
  9.     fmt.Println(uc.UpperCase(str1))
  10. }

然后在这个目录下输入 go install。

另外复制 uc.a 到 /home/user/goprograms 目录并创建一个 Makefile 并写入文本：

  1. include $(GOROOT)/src/Make.inc
  2. TARG=ucmain
  3. GOFILES=\
  4.     ucmain.go\
  6. include $(GOROOT)/src/Make.cmd

执行 gomake 编译 ucmain.go 生成可执行文件 ucmain

运行 ./ucmain 显示: USING PACKAGE UC!。

9.8.2 本地安装包

本地包在用户目录下，使用给出的目录结构，以下命令用来从源码安装本地包：

  1. go install /home/user/goprograms/src/uc # 编译安装 uc
  2. cd /home/user/goprograms/uc
  3. go install ./uc     # 编译安装 uc（和之前的指令一样）
  4. cd ..
  5. go install .    # 编译安装 ucmain

安装到 $GOPATH 下：

如果我们想安装的包在系统上的其他 Go 程序中被使用，它一定要安装到 $GOPATH 下。 这样做，在 .profile 和 .bashrc 中设置 export GOPATH=/home/user/goprograms。

然后执行 go install uc 将会复制包存档到 $GOPATH/pkg/LINUX_AMD64/uc。

现在，uc 包可以通过 import "uc" 在任何 Go 程序中被引用。

9.8.3 依赖系统的代码

在不同的操作系统上运行的程序以不同的代码实现是非常少见的：绝大多数情况下语言和标准库解决了大部分的可移植性问题。

你有一个很好的理由去写平台特定的代码，例如汇编语言。这种情况下，按照下面的约定是合理的：

  1. prog1.go
  2. prog1_linux.go
  3. prog1_darwin.go
  4. prog1_windows.go

prog1.go 定义了不同操作系统通用的接口，并将系统特定的代码写到 prog1os.go 中。 对于 Go 工具你可以指定 `prog1$GOOS.go或prog1$GOARCH.go或在平台 Makefile 中：prog1$(GOOS).go` 或 prog1_$(GOARCH).go\。

链接