创建Go模块

一、包、模块、函数的关系

​ 在开始本文章之前，我们首先需要了解一下Go的包、模块、函数之间的关系，以便更好地进行接下来的操作。

​ 我们还是拿hello目录来讲解，查看其目录树，得到的结果如下所示：

pzs@pzs-ubuntu22:~/go_study$ tree hello/
hello/
├── go.mod
├── go.sum
└── hello.go

​ 在这里，可以看到hello其实就是一个Go包，而hello.go就是一个Go模块，然后查看hello.go里面的内容，如下所示：

package main
//....
func main() {fmt.Println(quote.Go())
}

​ 可以看到main()函数是位于模块下的。因此我们可以大致总结出其包含关系为：包 > 模块 >函数。

​ 注：这里为啥hello.go的package的名称为main呢？是因为Go中规定了，main函数所在的包名称必须为main。若模块中不含main函数的话，那么我们就得使用该模块所在包的名称。

二、创建模块

2.1 创建目录

​ 首先，创建一个greetings 目录, 用于存放模块：

pzs@pzs-ubuntu22:~/go_study$ mkdir greetings/
pzs@pzs-ubuntu22:~/go_study$ cd greetings/
pzs@pzs-ubuntu22:~/go_study/greetings$ 

2.2 跟踪包

之后使用go mod init命令初始化目录：

pzs@pzs-ubuntu22:~/go_study/greetings$ go mod init github/pzs/greetings
go: creating new go.mod: module github/pzs/greetings

2.3 编写模块代码

之后在greetings目录下创建一个greetings.go文件，作为我们的模块：

package greetings // 表明模块所处的包的名称，也就是模块文件所在的目录名称import "fmt"// Hello returns a greeting for the named person.
func Hello(name string) string { // 在Go中，名称以大写字母开头的函数可以被不在同一包中的函数调用。而以小写开头的函数，只能在同一个包的不同模块之间调用！！！// Return a greeting that embeds the name in a message.message := fmt.Sprintf("Hi, %v. Welcome!", name)  // return message
}

在上面这个代码中，有如下几点需要说明：

1. 在 Go 中，:= 运算符是在一行中声明和初始化变量的快捷方式（Go 使用右侧的值来确定变量的类型）

   message := fmt.Sprintf("Hi, %v. Welcome!", name) 
   // 也等价于如下：
   // var message string   
   // message = fmt.Sprintf("Hi, %v. Welcome!", name)
   

2. 在Go中，名称以大写字母开头的函数可以被不在同一包中的函数调用。而以小写开头的函数，只能在同一个包的不同模块之间调用！如本例中的Hello函数名为大写开头，所以这个函数可以被其它包引用。

3. 使用 fmt 包的 Sprintf 函数创建问候消息。第一个参数是格式字符串，Sprintf 将名称参数的值替换为 %v 格式动词。

4. Go语言中的函数形式：

   

三、其它模块调用函数

3.1 修改hello.go代码

​ 我们选用hello来调用greetings包中greetings.go模块的Hello函数。首先需要修改hello.go代码，修改后的结果如下所示：

package main // 声明一个主包。在 Go 中，作为应用程序执行的代码必须位于主包中。import ("fmt""github.com/pzs/greetings"
)func main() { message := greetings.Hello("pzs")fmt.Println(message)
}

​ 但此时我们运行hello.go文件时候会出现错误的情况，这个是因为我的hello包还找到github.com/pzs/greetings, 因此接下来我们还需要告诉hello包，greetings包在哪。

3.2 修改go.mod文件

​ 为此，使用 go mod edit 命令编辑 github.com/pzs/hello 模块，将 Go 工具从其模块路径（模块所在的位置）重定向到本地目录（模块所在的位置）。

pzs@pzs-ubuntu22:~/go_study/hello$ go mod edit -replace github.com/pzs/greetings=../greetings

​ 该命令指定github.com/pzs/greetings应替换为 …/greetings 以查找依赖项。运行命令后，hello 目录中的 go.mod 文件应包含替换指令：

module github.com/pzs/hellogo 1.21.3replace github.com/pzs/greetings => ../greetings

​ 在 hello 目录中的命令提示符下，运行go mod tidy命令来同步 github.com/pzs/hello 模块的依赖项，添加代码所需但尚未在模块中跟踪的依赖项:

pzs@pzs-ubuntu22:~/go_study/hello$ go mod tidy
go: found github.com/pzs/greetings in github.com/pzs/greetings v0.0.0-00010101000000-000000000000

​ 命令完成后，github.com/pzs/hello 模块的 go.mod 文件应如下所示：

module github.com/pzs/hellogo 1.21.3replace github.com/pzs/greetings => ../greetingsrequire github.com/pzs/greetings v0.0.0-00010101000000-000000000000

​ 注：v0.0.0-00010101000000-000000000000代表这个包还没有版本号，若有版本号的话，则会出现如下的声明：

require example.com/greetings v1.1.0

3.3 运行程序

之后，就可以直接运行hello.go文件，调用greetings.go模块的Hello函数了，运行结果如下所示：

pzs@pzs-ubuntu22:~/go_study/hello$ go run hello.go 
Hi, pzs. Welcome!

到此，我们就成功的在一个模块内调用另外一个自己开发的模块了！但是还存在一个问题就是，如果发生了错误，那么该怎么处理呢？所以，接下来，让我们一起来看一下Go语言的错误处理相关的内容。

四、错误处理

4.1 函数添加错误处理

​ 处理错误是可靠代码的一个基本特征。在本节中，将添加一些代码以从greetings模块返回错误，然后在调用者中处理它。

​ 首先，我们需要对greetings.go中的Hello函数进行一些修改，添加错误处理代码：

package greetingsimport ("errors""fmt"
)// Hello returns a greeting for the named person.
func Hello(name string) (string, error) {// If no name was given, return an error with a message.if name == "" {return "", errors.New("empty name")}// If a name was received, return a value that embeds the name// in a greeting message.message := fmt.Sprintf("Hi, %v. Welcome!", name)return message, nil
}

在这里，有以下几点需要进行说明：

1. 更改函数，使其返回两个值：string和error。调用者将检查第二个值以查看是否发生错误。 （任何 Go 函数都可以返回多个值）

2. 导入Go标准库errors包，这样你就可以使用它的errors.New函数。

3. 添加 if 语句来检查无效请求（名称应为空字符串），如果请求无效则返回错误。 error.New 函数返回一个错误，其中包含您的消息。

4. 添加 nil（意味着没有错误）作为成功返回中的第二个值。这样，调用者就可以看到该函数成功了。

4.2 调用者获取函数返回值

​ 在 hello/hello.go 文件中，处理 Hello 函数现在返回的错误以及非错误值。修改后的hello.go文件如下所示：

package mainimport ("fmt""log""github.com/pzs/greetings"
)func main() {// Set properties of the predefined Logger, including// the log entry prefix and a flag to disable printing// the time, source file, and line number.log.SetPrefix("greeting:")log.SetFlags(0)// Request a greeting message.message, err := greetings.Hello("")// If an error was returned, print it to the console and// exit the program.if err != nil {log.Fatal(err)}// If no error was returned, print the returned message// to the console.fmt.Println(message)
}

在这里，有以下几点需要进行说明：

1. 配置日志包以在其日志消息的开头打印命令名称（“greetings：”），不带时间戳或源文件信息。

2. 将 Hello 参数从 pzs的名字更改为空字符串，以便您可以尝试错误处理代码。

3. 将两个 Hello 返回值（包括错误）分配给变量。

4. 使用标准库的log包中的函数输出错误信息。如果出现错误，可以使用日志包的 Fatal 函数打印错误并停止程序。

4.4 执行错误处理代码

​ 在 hello 目录中的命令行中，运行 hello.go 以确认代码有效,运行结果如下所示：

pzs@pzs-ubuntu22:~/go_study/hello$ go run hello.go 
greeting:empty name
exit status 1

​ 到此，我们就成功地添加了错误处理代码了，此时我们的程序健壮性也将进一步得到保障！但是又有一个问题，需要思考一下，就是我们虽然添加了错误处理代码，但是每次修改完函数都要重新运行整个程序才能知道我们写的对不对，比较麻烦！所以，我们得考虑做一个单元测试来单独测试我们修改后的函数是否正确！

​

五、单元测试

5.1 编写测试文件

​ Go 对单元测试的内置支持使您可以更轻松地进行测试。具体来说，使用命名约定、Go 的测试包和 go test 命令，可以快速编写和执行测试。

​ 在Go语言中以 _test.go 结尾的文件名告诉 go test 命令该文件包含测试函数。

​ 这里，我们需要对greetings.go模块进行单元测试，因此首先需要创建一个greetings_test.go文件，内容如下所示：

package greetingsimport ("regexp""testing"
)// TestHelloName calls greetings.Hello with a name, checking
// for a valid return value.
func TestHelloName(t *testing.T) {name := "pzs"want := regexp.MustCompile(`\b` + name + `\b`)msg, err := Hello("pzs")if !want.MatchString(msg) || err != nil {t.Fatalf(`Hello("pzs") = %q, %v, want match for %#q, nil`, msg, err, want)}
}// TestHelloEmpty calls greetings.Hello with an empty string,
// checking for an error.
func TestHelloEmpty(t *testing.T) {msg, err := Hello("")if msg != "" || err == nil {t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)}
}

在这里，有以下几点需要进行说明：

1. 在与您正在测试的代码相同的包中实现测试功能。

2. 创建两个测试函数来测试greetings.Hello 函数。测试函数名称的形式为 TestName，其中 Name 表示有关特定测试的信息。此外，测试函数将指向测试包的testing.T 类型的指针作为参数。您可以使用此参数的方法来报告和记录测试。

3. 实施两个测试：

   • TestHelloName 调用 Hello 函数，传递一个名称值，该函数应该能够返回有效的响应消息。如果调用返回错误或意外响应消息（不包含您传入的名称的消息），则可以使用 t 参数的 Fatalf 方法将消息打印到控制台并结束本测试函数。
   • TestHelloEmpty 使用空字符串调用 Hello 函数。**此测试旨在确认您的错误处理是否有效。**如果调用返回非空字符串或没有错误，则可以使用 t 参数的 Fatalf 方法将消息打印到控制台并结束本测试函数。

5.2 执行测试用例

在greetings目录下的命令行中，运行go test命令来执行测试。go test 命令执行测试文件（名称以 _test.go 结尾）中的测试函数（名称以 Test 开头）。您可以添加 -v 标志来获取列出所有测试及其结果的详细输出。

pzs@pzs-ubuntu22:~/go_study/greetings$ go test -v
=== RUN   TestHelloName
--- PASS: TestHelloName (0.00s)
=== RUN   TestHelloEmpty
--- PASS: TestHelloEmpty (0.00s)
PASS
ok      github/pzs/greetings    0.002s

注：执行测试用例的时候，是并发执行的，也就是一个测试用例的失败之后，t.Fatalf只会终止所在的测试函数的执行，而不会终止其它测试用例的执行！

​ 到此，我们也就对我们编写的函数进行了单元测试，那么一般到这个情况下，当所有的测试用例都通过的时候，就可以打包分发上线啦！接下来就让我们一起来看看是如何打包的。

六、编译并安装应用程序

虽然 go run 命令是在频繁更改时编译和运行程序的有用快捷方式，但它不会生成二进制可执行文件。

​ 本主题介绍了两个用于构建代码的附加命令：

1. go build 命令编译包及其依赖项，但不会安装结果。
2. go install 命令编译并安装软件包。

6.1 编译应用程序

​ 从 hello 目录中的命令行运行 go build 命令将代码编译为可执行文件：

pzs@pzs-ubuntu22:~/go_study/hello$ go build
pzs@pzs-ubuntu22:~/go_study/hello$ ls
go.mod  go.sum  hello  hello.go

​ 可以看到多出来了一个hello可执行文件！我们可以检验一下这个文件是否有效，直接通过命令行的方式运行该程序：

pzs@pzs-ubuntu22:~/go_study/hello$ ./hello 
greeting:empty name

​ 可以看到该文件是有效的，并且成功运行了

6.1 编译并安装应用程序

​ 首先我们需要找到go的安装路径，go install会将可执行文件安装到go的安装路径内。

pzs@pzs-ubuntu22:~/go_study/hello$  go list -f '{{.Target}}'
/home/pzs/go/bin/hello

注：使用该命令之前，hello命令下必须要有通过go build编译生成的hello文件。命令执行的结果表明：二进制文件将会被安装到该位置下。

​ 之后需要将 Go 安装目录添加到系统的 shell 路径。

$ export PATH=$PATH:/home/pzs/go/bin

注：添加到/etc/profile或者$HOME/.profile内，然后使用source命令生效即可！

​ 更新 shell 路径后，运行 go install 命令来编译并安装包。

$ go install

​ 此时，二进制文件就被移动到指定位置了，之后在任何终端内只需键入应用程序的名称即可运行您的应用程序，其结果如下所示：

pzs@pzs-ubuntu22:~/go_study/greetings$ hello
greeting:empty name
pzs@pzs-ubuntu22:~/go_study/greetings$ ls
go.mod  greetings.go  greetings_test.go

​ 可以看到，我们greetings目录下没有hello文件，但是也能成功地运行hello可执行文件。