Golang basic_leaminggo mod 以及包详解

Posted 2023-01-14 知其黑、受其白

阅读目录

• 一、Golang 中包的介绍和定义
• 二、Golang 包管理工具 go mod
• • 1、go mod init 初始化项目
  • 2、go mod 其他命令
• 三、Golang 中自定义包
• • 1、定义一个包
  • • 1.1、定义一个包名为 calc 的包
    • 1.2、main.go 中引入这个包
  • 2、导入一个包
• 四、Golang 中 init() 初始化函数
• 五、Golang 中使用第三方包
• • 1、找到我们需要下载安装的第三方包的地址
  • 2、安装这个包
  • 3、看文档使用这个包
• 示例下载 gjson 包
• 开始使用多模块的工作空间
• • 1、创建 workspace 目录
  • 2、初始化模块
  • 3、创建工作空间
  • 4、在 workspace 目录下运行程序
  • 5、下载并修改 golang.org/x/example 模块
  • • 5.1、拷贝仓库
    • 5.2、添加模块到工作空间
  • 6、添加新函数
  • 7、修改 hello 程序，使用函数
  • 更多关于工作空间

一、Golang 中包的介绍和定义

包（package）是多个Go 源码的集合，是一种高级的代码复用方案，Go 语言为我们提供了很多内置包，如 fmt、strconv、strings、sort、errors、time、encoding/json、os、io 等。

Golang 中的包可以分为三种：
1、系统内置包。
2、自定义包。
3、第三方包。

系统内置包: Golang 语言给我们提供的内置包，引入后可以直接使用，如 fmt、strconv、strings、sort、errors、time、encoding/json、os、io 等。

自定义包：开发者自己写的包。

第三方包：属于自定义包的一种，需要下载安装到本地后才可以使用，如前面给大家介绍的 "github.com/shopspring/decimal" 包解决 float 精度丢失问题。

二、Golang 包管理工具 go mod

在Golang1.11 版本之前如果我们要自定义包的话必须把项目放在GOPATH 目录。

Go1.11 版本之后无需手动配置环境变量，使用go mod 管理项目，也不需要非得把项目放到GOPATH指定目录下，你可以在你磁盘的任何位置新建一个项目, Go1.13 以后可以彻底不要GOPATH了。

1、go mod init 初始化项目

实际项目开发中我们首先要在我们项目目录中用 go mod 命令生成一个go.mod 文件管理我们项目的依赖。

比如我们的golang 项目文件要放在了itying 这个文件夹，这个时候我们需要在itying 文件夹里面使用go mod 命令生成一个go.mod 文件。

2、go mod 其他命令

• download download modules to local cache (下载依赖的 module 到本地cache))
• edit edit go.mod from tools or scripts (编辑 go.mod 文件)
• graph print module requirement graph (打印模块依赖图))
• init initialize new module in current directory (再当前文件夹下初始化一个新的 module, 创建go.mod 文件))
• tidy add missing and remove unused modules (增加丢失的module，去掉未用的 module)
• vendor make vendored copy of dependencies (将依赖复制到vendor 下)
• verify verify dependencies have expected content (校验依赖检查下载的第三方库有没有本地修改，如果有修改，则会返回非0，否则验证成功。)
• why explain why packages or modules are needed (解释为什么需要依赖)

三、Golang 中自定义包

包（package）是多个Go 源码的集合，一个包可以简单理解为一个存放多个.go 文件的文件夹。

该文件夹下面的所有go 文件都要在代码的第一行添加如下代码，声明该文件归属的包。

package 包名

注意事项：

• 一个文件夹下面直接包含的文件只能归属一个package，同样一个package 的文件不能在多个文件夹下。
• 包名可以不和文件夹的名字一样，包名不能包含 - 符号。
• 包名为 main 的包为应用程序的入口包，这种包编译后会得到一个可执行文件，而编译不包含main 包的源代码则不会得到可执行文件。

1、定义一个包

如果想在一个包中引用另外一个包里的标识符（如变量、常量、类型、函数等）时，该标识符必须是对外可见的（public）。

在Go 语言中只需要将标识符的首字母大写就可以让标识符对外可见了。

1.1、定义一个包名为 calc 的包

代码如下：E:\\golang\\src\\pkg\\calc\\calc.go

创建文件夹：pkg\\calc，创建文件：calc.go。

package calc

//首字母大小表示公有，首字母小写表示私有
var a = 100  //私有变量
var Age = 20 //公有变量
func Add(x, y int) int 
	return x + y

func Sum(x, y int) int 
	return x - y

1.2、main.go 中引入这个包

访问一个包里面的公有属性方法的时候需要通过包名称.去访问。

package main

import (
	"fmt"
	"one/main/src/pkg/calc"
)

func main() 
	c := calc.Add(10, 20)
	fmt.Println(c)

running...
30

2、导入一个包

单行导入

单行导入的格式如下：

import "包1"
import "包2"

多行导入

多行导入的格式如下：

import (
	"包1"
	"包2"
)

匿名导入包

如果只希望导入包，而不使用包内部的数据时，可以使用匿名导入包。

具体的格式如下：

import _ "包的路径"

匿名导入的包与其他方式导入的包一样都会被编译到可执行文件中。

自定义包名

在导入包名的时候，我们还可以为导入的包设置别名。

通常用于导入的包名太长或者导入的包名冲突的情况。

具体语法格式如下：

import 别名 "包的路径"

单行引入定义别名：

import c "itying/calc"

多行引入定义别名：

import (
	"fmt"
	c "itying/calc"
)

四、Golang 中 init() 初始化函数

init() 函数介绍

在Go 语言程序执行时导入包语句会自动触发包内部 init()函数的调用。

需要注意的是： init() 函数没有参数也没有返回值。

init()函数在程序运行时自动被调用执行，不能在代码中主动调用它。

包初始化执行的顺序如下图所示：

init()函数执行顺序

Go 语言包会从main 包开始检查其导入的所有包，每个包中又可能导入了其他的包。

Go 编译器由此构建出一个树状的包引用关系，再根据引用顺序决定编译顺序，依次编译这些包的代码。

在运行时，被最后导入的包会最先初始化并调用其init()函数， 如下图示：

五、Golang 中使用第三方包

我们可以在 https://pkg.go.dev/ 查找看常见的 golang 第三方包。

1、找到我们需要下载安装的第三方包的地址

比如前面给大家演示的解决 float 精度损失的包 decimal。

https://github.com/shopspring/decimal

2、安装这个包

第一种方法：go get 包名称（全局）

go get github.com/shopspring/decimal

PS E:\\golang\\src> go get github.com/shopspring/decimal
go: downloading github.com/shopspring/decimal v1.3.1
go: added github.com/shopspring/decimal v1.3.1
PS E:\\golang\\src>

查看包安装路径：

go env

以下即是go的包安装路径
set GOPATH=C:\\Users\\Administrator\\go

第二种方法：go mod download （全局）

package main

import (
	"fmt"

	"github.com/shopspring/decimal"
)

func main() 
	quantity := decimal.NewFromInt(3)
	fmt.Println(quantity)

运行命令

go mod download

go run .\\main.go 或者 go install

赖包会自动下载到 $GOPATH/pkg/mod，多个项目可以共享缓存的mod，注意使用 go mod download 的时候首先需要在你的项目里面引入第三方包。

第三种方法：go mod vendor 将依赖复制到当前项目的 vendor 下（本项目）

go mod vendor

将依赖复制到当前项目的 vendor 下。

注意：使用 go mod vendor 的时候首先需要在你的项目里面引入第三方包。

3、看文档使用这个包

包安装完毕后我们就可以看文档使用这个包了…

示例下载 gjson 包

PS E:\\golang\\src> go get -u github.com/tidwall/gjson
go: downloading github.com/tidwall/gjson v1.14.4
go: downloading github.com/tidwall/pretty v1.2.0
go: downloading github.com/tidwall/match v1.1.1
go: downloading github.com/tidwall/pretty v1.2.1
go: added github.com/tidwall/gjson v1.14.4
go: added github.com/tidwall/match v1.1.1
go: added github.com/tidwall/pretty v1.2.1
PS E:\\golang\\src>

开始使用多模块的工作空间

用一个共享的多模块工作空间创建两个模块。

跨越这些模块进行更改，并且在构建中看到这些结果的改变。

1、创建 workspace 目录

PS E:\\> mkdir workspace


    目录: E:\\


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----          2023/1/8     17:18                workspace


PS E:\\>

2、初始化模块

创建一个新的 hello 模块，将依赖于 golang.org/x/example 模块。

创建一个 hello 模块：

PS E:\\workspace> mkdir hello


    目录: E:\\workspace


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----          2023/1/8     18:12                hello


PS E:\\workspace> cd .\\hello\\
PS E:\\workspace\\hello> go mod init example.com/hello
go: creating new go.mod: module example.com/hello
PS E:\\workspace\\hello> dir


    目录: E:\\workspace\\hello


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----          2023/1/8     18:13             34 go.mod


PS E:\\workspace\\hello>

通过使用 go get 命令添加依赖于 golang.org/x/example 模块。

PS E:\\workspace\\hello> go get golang.org/x/example
go: downloading golang.org/x/example v0.0.0-20220412213650-2e68773dfca0
go: added golang.org/x/example v0.0.0-20220412213650-2e68773dfca0
PS E:\\workspace\\hello>

在 hello 文件夹中创建一个 hello.go 文件，里面包含下面的内容：

package main

import (
  "fmt"
  "golang.org/x/example/stringutil"
)


func main() 
  fmt.Println(stringutil.Reverse("Hello"))

现在，运行 hello 程序：

PS E:\\workspace\\hello> go run .\\hello.go
olleH
PS E:\\workspace\\hello>
PS E:\\workspace\\hello> go run .\\hello.go
敌无下天
PS E:\\workspace\\hello>

3、创建工作空间

在这一步，我们将创建 go.work 文件，使用模块指定一个工作空间。

初始化工作空间，在 workspace 目录下，运行：

PS E:\\workspace> go work init ./hello
PS E:\\workspace>
PS E:\\workspace> ls


    目录: E:\\workspace


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----          2023/1/8     18:20                hello
-a----          2023/1/8     18:33             21 go.work


PS E:\\workspace>

go work init 命令告诉 go 为一个包含 ./hello 目录中的模块的工作空间，创建一个go.work 文件。

这个 go 命令产生的 go.work 文件，看起来像这样：

go.work 文件拥有 go.mod 文件相似的语法。

go 指令告诉 Go 应该使用哪个版本的 Go 来解释文件。
它 go.mod 中 go 指令是类似的。

use 指令告诉 Go，当做构建的时候，在目录 hello 中的模块，是主模块。

4、在 workspace 目录下运行程序

在 workspace 目录下，运行：

PS E:\\workspace> go run example.com/hello
敌无下天
PS E:\\workspace>

这个Go命令包含所有在工作空间中的所有模块作为主模块。

这允许我们在模块中引用一个包，甚至在模块之外。

运行 go run 命令在模块或工作空间外面，将产生错误结果，因为go命令不知道应该使用哪个模块。

接下来，我们将添加一个本地拷贝 golang.org/x/example 模块到工作空间。

我们将添加一个新的函数到 stringutil 模块中，我们能够使用，用来替换 Reverse。

5、下载并修改 golang.org/x/example 模块

在这一步，我们将下载一个Git仓库到拷贝，包含了 golang.org/x/example 模块，添加它到工作空间。

添加一个新的函数到它里面，然后我们在 hello 程序中使用。

5.1、拷贝仓库

在 workspace 目录下，运行 git 命令，拷贝仓库。

拷贝上面下载过的这个包，并重命名为：example

5.2、添加模块到工作空间

example 是文件夹。

PS E:\\workspace> go work use ./example
PS E:\\workspace>

go work use 命令，添加一个新的模块到 go.work 文件中。

它看起来像这样：

PS E:\\workspace> cat .\\go.work
go 1.19

use (
        ./example
        ./hello
)
PS E:\\workspace>

这个模块，现在既包含了 example.com/hello 模块，也包含了 golang.org/x/example 模块。

这将允许我们使用新代码，我们将在 stringutil 模块中写的，替换我们通过 go get 命令下载，在模块缓存中的模块版本。

6、添加新函数

我们将添加一个新函数，去讲字符串变成大写，到 golang.org/x/example/stringutil 包中。

在 workspace/example/stringutil 目录中，创建一个文件名叫 toupper.go 的文件，包含下面的内容：

package stringutil

import "unicode"

// 将参数中的所有字符转成大写
func ToUpper(s string) string 
	r := []rune(s + "_wg")
	for i := range r 
		r[i] = unicode.ToUpper(r[i])
	
	return string(r)

7、修改 hello 程序，使用函数

修改 workspace/hello/hello.go 文件，包含下面的内容：

package main

import (
	"fmt"

	"golang.org/x/example/stringutil"
)

func main() 
	// fmt.Println(stringutil.Reverse("Hello"))
	fmt.Println(stringutil.ToUpper("Hello"))

在工作空间中运行代码：

PS E:\\workspace> go run example.com/hello
ASDF_WG
PS E:\\workspace>

Go 命令在 go.work 文件指定的 hello 目录中查找命令行中指定的 example.com/hello 模块，同样使用 go.work 文件解析 golang.org/x/example 导入。

可以使用 go.work 代替添加 replace 指令来跨多个模块工作。

因为两个模块在同一个工作空间，所以你很容易在一个模块中改变，然后在另一个模块中使用。

更进一步：

现在，要正确发布这些模块，我们需要发布 golang.org/x/example 模块，例如，v0.1.0。这通常通过在模块的版本控制存储库上标记提交来完成。

发布完成后，我们可以在 hello/go.mod 中增加对 golang.org/x/example 模块的要求：

$ cd hello/
$ go get golang.org/x/example@v0.1.0

这样， go 命令可以正确解析工作区之外的模块。

更多关于工作空间

• go work use [-r] [dir]为 dir 的 go.work 文件添加一个 use 指令（如果存在），如果参数目录不存在，则删除 use 目录。-r 标志递归地检查 dir 的子目录。
• go work edit 编辑 go.work 文件，类似 go mod edit
• go work sync 将工作区构建列表中的依赖项同步到每个工作区模块中。