Go language basics-packages

What is a package and why do we use it?

The Go program we have seen so far only has one file, which contains a main function and several other functions. In actual business development, this method of writing all source code into a single file is not scalable. This kind of code reusability and maintainability will become impossible, and this is where packages can come in handy.

A package is a collection of files ending in .go located in the same directory, used to organize source code for better reusability and readability. Packages provide code partitioning to make maintaining Go projects easier.

For example, suppose we are writing a financial system in Go, including the following functions: simple interest calculation, compound interest calculation, etc. A simple way to organize this system is to divide it according to functionality. We can create three packages simpleinterest, compoundinterest and loan. If the loan package needs to use the functions of the simpleinterest package, it only needs to simply import the simpleinterest package, so that the code can be reused.

We will learn about the package by creating a simple application that calculates how much interest is given a principal, an interest rate, and time.

main function and main package

Every executable Go application must contain the main function. This function is the entry point for program execution, and the main function should be in the main package.

package packagename

The above syntax is used to specify that the source file belongs to the packagename package, which usually appears on the first line of the file.

Let's start creating the main function and main package for our application.

Run the following command to create a directory named learnpackage in the current user's Documents directory.

mkdir ~/Documents/learnpackage/

Create a file named main.go in the learnpackage directory, which contains the following code:

package main

import "fmt"

func main() {
    fmt.Println("Simple interest calculation")
}

package main code is used to specify that the file belongs to the main package;

## The #import "packagename" statement is used to import an existing package;

packagename.FunctionName() is to call the function in the package;

上面代码的第 3 行，我们导入 fmt 包以便能调用包里的 Println() 函数，fmt 是 Go 语言标准库中内置的一个包。主函数会打印 Simple interest calculation。

cd 到 learnpackage 目录并且编译上面的代码

cd ~/Documents/learnpackage/
go install

如果一切顺利，二进制文件将被编译并可以执行。在终端中键入命令 learnpackage，将会看到如下输出：

Simple interest calculation

Go Module

我们将会这样构建代码，与计算利息相关的功能函数都放在 simpleinterest 包里。为此，我们需要创建一个自定义包 simpleinterest，其中包含计算利息的函数。在创建自定义包之前，我们需要先了解 Go Modules，创建自定义包需要 Go Modules。

简单来说，Go Module 只不过是 Go 包的集合。你可能会有疑问，为什么我们需要 Go 模块来创建自定义包呢？答案是我们创建的自定义包的导入路径来源于 go 模块的名称。除此之外，我们的应用程序使用的所有其他第三方包（例如来自 github 的源代码）将与版本一起出现在 go.mod 文件中。当我们创建一个新模块时，会创建出一个 go.mod 文件，下一小节会讲到这点。

可能你又会疑惑了：为什么到现在我们还没有创建 Go 模块程序也能执行成功？答案是，本系列教程到目前为止，我们从未创建过自定义包，因此不需要 Go 模块。

理论知识学完了，让我们来创建自己的 Go 模块和自定义包。

创建 Go module

执行下面命令确保在 learnpackage 目录下，

cd ~/Documents/learnpackage/

在该目录下输入如下命令创建名为 learnpackage 的 go 模块。

go mod init learnpackage

上面的命令将创建一个名为 go.mod 的文件，下面是该文件的内容：

module learnpackage

go 1.13

代码行 module learnpackage 指定模块的名字为 learnpackage。正如之前提到的，learnpackage 是模块的基础路径，想要导入模块的任何一个包必须基于此路径。最后一行指定此模块中的文件使用 1.13 的 go 版本。

创建一个自定义包：计算利息

属于一个包的源文件应该放在它们自己的单独文件夹中。Go 中的约定是文件夹名称与包名相同。

让我们在 learnpackage 文件夹中创建一个名为 simpleinterest 的文件夹。mkdir simpleinterest 将会创建该文件夹。

simpleinterest 文件夹中的所有文件都应该以 package simpleinterest 开头，因为它们都属于 simpleinterest 包。

在 simpleinterest 文件夹中创建一个文件 simpleinterest.go。

下面是程序的结构目录：

├── learnpackage
│   ├── go.mod
│   ├── main.go
│   └── simpleinterest
│       └── simpleinterest.go

将以下代码添加到 simpleinterest.go 文件中。

package simpleinterest

//Calculate calculates and returns the simple interest for a principal p, rate of interest r for time duration t years
func Calculate(p float64, r float64, t float64) float64 {
    interest := p * (r / 100) * t
    return interest
}

在上面的代码中，我们创建了一个计算并返回利息的函数 Calculate()。

导入自定义包

要使用自定义包，我们必须先导入它。导入路径是模块名加上包的子目录和包名。在我们的例子中，模块名称是 learnpackage，包 simpleinterest 位于 learnpackage 下的 simpleinterest 文件夹中。

├── learnpackage
│   └── simpleinterest

所以 import "learnpackage/simpleinterest" 代码将导入 simpleinterest 包。

如果我们的目录结构是这样的：

learnpackage
│   └── finance
│       └── simpleinterest

那么导入包的语句将会是 mport "learnpackage/finance/simpleinterest"。

将下面的代码加入 main.go

package main

import (
    "fmt"
    "learnpackage/simpleinterest"
)

func main() {
    fmt.Println("Simple interest calculation")
    p := 5000.0
    r := 10.0
    t := 1.0
    si := simpleinterest.Calculate(p, r, t)
    fmt.Println("Simple interest is", si)
}

上面的代码导入了 simpleinterest 包并使用了 Calculate() 函数来计算利息。标准库中的包不需要模块名称前缀，比如直接导入 fmt 包也是可以的。执行代码输出：

Simple interest calculation
Simple interest is 500

关于 go install 更多的知识

现在我们了解了包的工作原理，是时候来讨论关于 go install 的用法了。像 go install 这样的 Go 工具在当前目录的上下文中工作。我们来理解是什么意思，到目前为止，我们一直在目录 ~/Documents/learnpackage/ 中运行 go install。如果我们尝试在其他任何目录执行这个命令，将会报错。

尝试执行命令 cd ~/Documents/ 然后运行 go install learnpackage，它将失败并出现以下错误：

can't load package: package learnpackage: cannot find package "learnpackage" in any of:
    /usr/local/Cellar/go/1.13.7/libexec/src/learnpackage (from $GOROOT)
    /Users/nramanathan/go/src/learnpackage (from $GOPATH)

我们一起来分析下错误的原因，go install 需要一个可选的包名作为参数（在我们的例子中包名是 learnpackage），如果执行命令的当前目录或者其父级目录下存在这个包，它会尝试编译 main 函数。

我们在 Documents 目录中没有 go.mod 文件，因此 go install 会提示找不到包 learnpackage。

当我们 cd 到 ~/Documents/learnpackage/ 目录时，该目录下存在 go.mod 文件，该文件中指定了模块名称 learnpackage。

所以 go install learnpackage 将在 ~/Documents/learnpackage/ 目录中工作。

但是到目前为止，我们只是在使用 go install 并且没有指定包名。如果没有指定包名，go install 将默认为当前工作目录中的模块名，这就是我们没有指定包名但仍然能执行成功的原因。因此，在 ~/Documents/learnpackage/ 目录下执行下面 3 个命令是等效的：

go install

go install .

go install learnpackage

上面我们提到 go install 能够递归地在父目录中搜索 go.mod 文件，让我们检查一下这点是否正确。

cd ~/Documents/learnpackage/simpleinterest/

执行上面的命令 cd 到 simpleinterest 目录，在该目录下执行下面的命令：

go install learnpackage

Go install 将能在父目录 learnpackage 中找到一个 go.mod 文件，该文件定义了模块 learnpackage，因此它可以工作。

可导出

simpleinterest 包里的 Calculate() 函数开头字母是大写的。这在 Go 中有特别的定义，任何以大写字母开头的变量或函数都是可导出。只能访问其他包中可导出的变量或者函数，在我们这个例子中，我们能在 main 包里访问 Calculate() 函数，因为它是可导出的。

如果将 Calculate() 函数开头字母小写 calculate()，再次尝试从 main 包访问，将会报错：

# learnpackage
./main.go:13:8: cannot refer to unexported name simpleinterest.calculate
./main.go:13:8: undefined: simpleinterest.calculate

因此，如果你想从其他包能访问包内的函数，则应将其首字母大写。

init 函数

Go 里每个包都可以包含一个 init() 函数。init() 函数不能有任何返回值，也不能有任何参数。在代码中不能显式地调用 init() 函数，包初始化时会自动调用 init() 函数。init() 函数语法如下：

func init() {
}

init() 函数可以用于执行初始化任务，也可用于程序运行前一些参数的验证。

包的初始化顺序如下：

1.首先初始化包级别的变量；2.接着会调用 init() 函数，一个包可以有多个 init() 函数（在单个文件中或分布在多个文件中），它们按照呈现给编译器的顺序被调用；

如果一个包导入其他包，则首先初始化导入的包。

一个包即使被多个包导入，也只会被初始化一次。

我们对之前的程序做一些修改，以便能更好地学习了解 init() 函数。

首先，让我们将 init 函数添加到 simpleinterest.go 文件中。

package simpleinterest

import "fmt"

/*
 * init function added
 */
func init() {
    fmt.Println("Simple interest package initialized")
}
//Calculate calculates and returns the simple interest for principal p, rate of interest r for time duration t years
func Calculate(p float64, r float64, t float64) float64 {
    interest := p * (r / 100) * t
    return interest
}

上面的代码添加了一个简单的 init 函数，它只负责打印 Simple interest package initialized。

现在，我们来修改下 main 包，我们都知道计算利息时、利率和时间都应该大于零，我们将在 main.go 文件里定义包级别的变量并且在 init() 函数校验这些变量。

main.go 文件如下：

package main

import (
    "fmt"
    "learnpackage/simpleinterest" //importing custom package
    "log"
)
var p, r, t = 5000.0, 10.0, 1.0

/*
* init function to check if p, r and t are greater than zero
 */
func init() {
    println("Main package initialized")
    if p < 0 {
        log.Fatal("Principal is less than zero")
    }
    if r < 0 {
        log.Fatal("Rate of interest is less than zero")
    }
    if t < 0 {
        log.Fatal("Duration is less than zero")
    }
}

func main() {
    fmt.Println("Simple interest calculation")
    si := simpleinterest.Calculate(p, r, t)
    fmt.Println("Simple interest is", si)
}

main.go 修改如下：

1.p、r 和 t 变量从主函数级别移至包级别。2.添加了一个 init() 函数，如果本 金、利率或时间有一个小于 0，log.Fatal() 会打印日志并终止程序。

初始化顺序如下：

1.导入的包首先被初始化，因此 simpleinterest 包首先被初始化并且它的 init 方法被调用。2.接下来初始化包级变量 p、r 和 t。3.接着调用 main.go 里的 init() 函数。4.最后调用 main() 函数。

执行程序将会输出：

Simple interest package initialized
Main package initialized
Simple interest calculation
Simple interest is 500

正如我们预期的那样，simpleinterest 包的 init 函数首先被调用，然后是包级变量 p、r 和 t 的初始化，接下来调用 main 包的 init() 函数，它检查 p、r 和 t 是否小于零，如果 if 语句为真则会终止程序。关于 if 语句的使用我们将在另外章节介绍。在我们的程序里，所有的 if 条件都为 false，程序继续执行，最后调用 main() 函数。

我们来简单修改下代码，

将 main.go 文件的这行代码：

var p, r, t = 5000.0, 10.0, 1.0

修改成：

var p, r, t = -5000.0, 10.0, 1.0

我们已将 p 初始化为负数。

现在如果执行程序就会输出：

Simple interest package initialized
Main package initialized
2020/02/15 21:25:12 Principal is less than zero

因为 p 是负数，所有程序在输出 Principal is less than zero 之后便终止了。

空白符 _

源代码里导入包如果不适用是非法的，编译器编译时会提示，这样做的原因是为了避免未使用的包太多，这将显着增加编译时间。将 main.go 中的代码替换为以下内容：

package main

import (
        "learnpackage/simpleinterest"
)

func main() {

}

执行上面的代码将会报错：

# learnpackage
./main.go:4:2: imported and not used: "learnpackage/simpleinterest"

但是在平时开发时，导入一个包可能现在不用，在之后代码的某个地方使用是很常见的，这时候该怎么办？

这时候空白符 _ 就能派上用场了，上面代码的报错可以使用空白符消除。

package main

import (
        "learnpackage/simpleinterest"
)

var _ = simpleinterest.Calculate

func main() {

}

上面的代码行 var _ = simpleinterest.Calculate 虽然能消除错误，但是不建议这种方式，我们应该特别留意这类代码，并在程序开发完成之后删除，包括导入但未使用的包。因此，建议在使用 import 导入包时使用 _ 消除此类错误。

有时我们导入一个包只是为了确保初始化，即使我们不需要使用包中的任何函数或变量。例如，我们可能需要确保调用 simpleinterest 包的 init 函数，即使我们不需要用到包里的任何函数或者变量。这种情况下也可以使用 _ 空白标识符，如下所示：

package main

import (
    _ "learnpackage/simpleinterest"
)

func main() {

}

执行上面的代码会输出 Simple Interest package initialized，我们已经成功地初始化了 simpleinterest 包，即使它没有在代码中的任何地方被使用。

The above is the detailed content of Go language basics-packages. For more information, please follow other related articles on the PHP Chinese website!