创建和导入 Go 包 - Go 包管理指南

介绍

在前一节中，你完成了一个基本的 Go 程序，其中包含以下代码行：

package main
import "fmt"

我们如何理解这两行代码？如何有效地使用 package 和 import 语句？

在本实验中，你将学习如何在 Go 中创建和导入包。这将使你能够将代码组织成可重用的模块，从而使你的 Go 项目更具可维护性和可扩展性。

知识点：

包的定义和声明
理解导出（public）和未导出（private）的标识符
导入包的不同形式：单行导入、分组导入、点导入、别名导入和匿名导入

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL go(("Golang")) -.-> go/BasicsGroup(["Basics"]) go(("Golang")) -.-> go/FunctionsandControlFlowGroup(["Functions and Control Flow"]) go(("Golang")) -.-> go/AdvancedTopicsGroup(["Advanced Topics"]) go/BasicsGroup -.-> go/variables("Variables") go/FunctionsandControlFlowGroup -.-> go/functions("Functions") go/AdvancedTopicsGroup -.-> go/time("Time") subgraph Lab Skills go/variables -.-> lab-149064{{"创建和导入 Go 包"}} go/functions -.-> lab-149064{{"创建和导入 Go 包"}} go/time -.-> lab-149064{{"创建和导入 Go 包"}} end

声明和定义包

在 Go 中，**包（package）**类似于 Python 中的模块或 C 中的库。它是用于组织和重用代码的源代码文件的集合。每个 Go 文件必须在文件开头声明一个包。

注意：一个 Go 程序必须有且仅有一个名为 main 的包，它作为程序的执行入口。如果没有它，程序将无法生成可执行文件。

关键点：

导出（公共）标识符：以大写字母开头的标识符（变量、函数、类型等）可以从其他包中访问。可以将这些视为包的公共接口。
未导出（私有）标识符：以小写字母开头的标识符只能在同一个包内访问。这些被视为包的内部实现细节。
包的内聚性：同一文件夹中的所有文件必须属于同一个包。这确保了相关代码保持在一起。
包命名规范：包名应为小写、简短且具有描述性，避免使用下划线或大写字母。

让我们创建一个自定义包：

创建一个名为 propagandist 的文件夹，并在其中创建一个文件 propagandist.go：
```
mkdir ~/project/propagandist
touch ~/project/propagandist/propagandist.go
```
在 propagandist.go 中编写以下代码：
```
package propagandist

var Shout = "I Love LabEx" // 公共变量
var secret = "I love the dress" // 私有变量

func Hit() string {
    return "Don't hit me, please!"
}
```
- Shout 是公共的，因为它以大写字母开头。这意味着你可以从导入 propagandist 的其他包中访问它。
- secret 是私有的，因为它以小写字母开头。它只能在 propagandist 包内使用。
- Hit 是一个公共函数，可以从其他包中访问。
为包初始化一个 Go 模块：
```
cd ~/project/propagandist
go mod init propagandist
```
此命令在 propagandist 目录中初始化一个新的 Go 模块，这有助于管理包的依赖项。

单包导入

为了使用 propagandist 包，让我们创建一个新的 Go 程序。这一步将演示如何在你的 Go 代码中导入和使用单个包。

在项目文件夹中创建一个名为 pacExercise.go 的新 Go 文件：
```
touch ~/project/pacExercise.go
```
为程序初始化一个 Go 模块：
```
cd ~/project
go mod init pacExercise
```
更新 go.mod 文件以包含本地包依赖项，在终端中运行以下命令：
```
echo "replace propagandist => ./propagandist" >> go.mod
```
重要提示： 此命令向你的 go.mod 文件添加了一个 replace 指令。这非常关键，因为它告诉 Go 应该从本地目录 ./propagandist 中获取 propagandist 包，而不是尝试从远程仓库下载它。你应在终端中执行此命令，这会将 replace propagandist => ./propagandist 这一行追加到你的 go.mod 文件中。不要手动直接写入这一行。
在 pacExercise.go 中编写以下代码以导入并使用 propagandist 包：
```
package main

import (
    "fmt"
    "propagandist"
)

func main() {
    fmt.Println(propagandist.Shout) // 访问公共变量
}
```
- 此代码导入了用于打印输出的 fmt 包和 propagandist 包。
- 然后通过 propagandist.Shout 访问 propagandist 包中的公共变量 Shout。
运行程序：
```
go mod tidy
go run pacExercise.go
```
go mod tidy 命令确保你的 go.mod 文件更新了所有新的依赖项。go run pacExercise.go 命令编译并执行程序。

预期输出：
```
I Love LabEx
```

分组导入

当导入多个包时，你可以使用分组导入来提高代码的可读性和组织性。这是一种风格选择，不会改变代码的功能。

修改 pacExercise.go 以使用分组导入：
```
package main

import (
    "fmt"
    "propagandist"
)

func main() {
    fmt.Println(propagandist.Shout)
}
```
在上面的代码片段中，fmt 和 propagandist 包被导入到一个用括号括起来的 import 块中。这使得读取和管理多个包的导入更加容易。这与之前的示例完全相同，展示了如何使用分组导入语法。
运行程序以确认它仍然正常工作：
```
go run pacExercise.go
```
程序应该能够无错误地执行，并输出与之前相同的结果。

点导入

使用**点导入（dot import）**时，你可以在调用包中的函数或变量时省略包名前缀。通常不推荐使用这种方式，因为它可能导致命名空间冲突并降低代码的可读性。然而，了解它的用法仍然是有意义的。

修改 pacExercise.go 以对 fmt 使用点导入：

package main

import . "fmt"
import "propagandist"

func main() {
    Println(propagandist.Shout) // 不需要 `fmt.` 前缀
}

这里，import . "fmt" 表示你可以直接使用 fmt 包中的函数和变量，而无需 fmt. 前缀。
例如，你可以使用 Println 而不是 fmt.Println。

运行程序：
```
go run pacExercise.go
```
预期输出：
```
I Love LabEx
```

别名导入

你可以为导入的包设置别名，以提高代码的清晰度或避免两个包名称相似时发生冲突。这对于提高代码的可读性和管理命名空间冲突非常有帮助。

修改 pacExercise.go 以将 fmt 别名为 io：
```
package main

import io "fmt"
import "propagandist"

func main() {
    io.Println(propagandist.Shout) // 使用别名 `io` 而不是 `fmt`
}
```
- import io "fmt" 为 fmt 包创建了一个别名 io。
- 现在，你可以使用 io.Println 而不是 fmt.Println。
运行程序：
```
go run pacExercise.go
```

匿名导入

匿名导入用于导入一个包以利用其副作用，例如运行其 init() 函数，而无需直接引用其导出的标识符。这对于注册驱动程序或执行其他初始化任务的包非常有用。

修改 pacExercise.go 以包含对 time 的匿名导入：
```
package main

import (
    "fmt"
    "propagandist"
    _ "time" // 匿名导入
)

func main() {
    fmt.Println(propagandist.Shout)
}
```
- import _ "time" 是匿名导入。下划线 _ 用作空白标识符，告诉编译器你导入该包是为了其副作用，而不会在代码中直接引用其中的任何内容。
- 当程序运行时，time 包的 init() 函数将会执行。虽然 time 包在这里没有明显的副作用，但许多包使用这种方式来注册数据库驱动程序或配置设置。
运行程序：
```
go run pacExercise.go
```
预期输出：
```
I Love LabEx
```

总结

在本实验中，你学习了以下内容：

如何在 Go 中创建和定义自定义包，封装可重用的代码。
公共（导出）和私有（未导出）标识符之间的区别，以及它们如何影响可访问性。
导入包的各种方式及其适用场景：
- 单包导入：一次导入一个包。
- 分组导入：在单个块中导入多个包以提高组织性。
- 点导入：导入包并直接使用其标识符，无需包名前缀。（需谨慎使用）
- 别名导入：为导入的包重命名以提高可读性或避免命名冲突。
- 匿名导入：仅为了包的副作用（例如初始化）而导入包。
包中 init() 函数的作用，以及匿名导入如何触发其执行。

通过完成本实验，你现在已经掌握了如何有效地使用包来构建和管理 Go 项目。你可以创建可重用的模块，控制标识符的访问权限，并更好地组织代码，从而开发出更具可维护性和可扩展性的 Go 应用程序。

Summary

In this lab, you learned:

How to create and define custom packages in Go, encapsulating reusable code.
The difference between public (exported) and private (unexported) identifiers and how they impact accessibility.
Various ways to import packages, each with its use case:
- Single-item import: Importing one package at a time.
- Grouped import: Importing multiple packages in a single block for better organization.
- Dot import: Importing a package and using its identifiers directly without the package name prefix. (Use with caution)
- Alias import: Renaming imported packages for better readability or to avoid naming conflicts.
- Anonymous import: Importing a package solely for its side effects, such as initialization.
The role of the init() function in packages and how anonymous imports can trigger its execution.
The detailed workings of Go's initialization process, including:
- How package-level variables are initialized before init() functions
- The guaranteed execution order of init() functions across dependent packages
- How multiple init() functions work within a package
- The complete initialization flow from dependent packages to the main function

By completing this lab, you are now equipped to structure and manage Go projects using packages effectively. You can create reusable modules, control access to identifiers, better organize your code, and understand the initialization process, leading to more maintainable and scalable Go applications.