Go基础篇

Go命令行工具

// 当前路径编译
go build
go build -o 新名字.exe
// 编译后可执行文件保留在命令执行的路径
go build 完整项目名
// 运行 go 文件
go run main.go
// 编译后移动可执行文件到 GOPATH/bin 目录
go install
// 查看go环境变量
go env
// 修改环境变量，direct 是一个特殊指示符，用于指示 Go 回到源地址去抓取（比如 GitHub 等）
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GO111MODULE=on
// 初始化项目，完整项目名 通常设置为：域名/作者/项目名
go mod init 完整项目名
// 从网上下载源码到 $GOPATH/src/，-u表示强制更新现有依赖
go get -u gopl.io/ch1/helloworld
// 下载当前目录中go.mod所指定的依赖包
go mod download

跨平台编译

Windows编译可执行文件

cmd

SET CGO_ENABLED=0	// 禁用CGO
SET GOOS=linux  	// 目标平台是linux，目标平台为 mac 把 GOOS 改为 darwin 即可
SET GOARCH=amd64	// 目标处理器架构是amd64

PowerShell

$ENV:CGO_ENABLED=0
$ENV:GOOS="linux"
$ENV:GOARCH="amd64"

再执行下面的命令，得到能够在Linux平台运行的可执行文件

go build

Mac编译可执行文件

// 目标平台为 Windows 把 GOOS 改为 Windows 即可
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build

Linux编译可执行文件

// 目标平台为 mac 把 GOOS 改为 darwin 即可
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build

VSCode中配置Go

  // go
  "gopls": {
    // 支持打开多个模块
    "build.experimentalWorkspaceModule": true
  },
  "code-runner.executorMap": {
    "go": "cd $dir && go run ."
  },

语法特性

• 语句末尾不加分号

• 变量声明时会自动赋予默认值

  • 整型和浮点型=>0

  • 字符串=>""

  • 布尔型=>false

  • 切片、函数、指针变量=>nil

• 类型推导，在声明变量时可以自动判断变量类型，而不用声明变量类型

• 短变量声明：:=，只能用于函数体内部

• 匿名变量声明：_，表示占位，用于接收被忽略的值

• 函数体外部的每个语句都必须以关键字开始（var、const、func等）

• 不允许将整型强制转换为布尔型，布尔型无法参与数值运算，也无法与其他类型进行转换

• 字符串只能使用双引号 "" 和反引号 ` ` 而不能使用单引号 ''

• 反引号用于定义多行的字符串，多行字符串中的转义字符将失效

• 字符串拼接使用 +

变量

// 全局变量
var 变量名 变量类型
var 变量名 = 表达式
var 变量名 变量类型 = 表达式

var (
    a string
    b int
    c bool
    d float32
)

// 局部变量
// 同时声明多个变量，必须是相同的数据类型
var name, age = "张三", 20

// 短变量声明，必须在函数内部使用，属于局部变量
func main() {
	n := 10
}

// 匿名变量声明,匿名变量不占用命名空间，不会分配内存
x, _ := a, b

常量

只需把 var 换成了 const，常量在定义的时候必须赋值

const pi = 3.1415

// const同时声明多个常量时，如果省略了值则表示和上面一行的值相同
const (
    pi = 3.1415
    e
)

// 常量计数器,iota 可理解为 const 语句块中的行索引
// 在 const 关键字出现时将被重置为 0
const (
	n1 = iota //0
	n2 = 100  //100
	n3 = iota //2
    _
	n5        //4
)
const n6 = iota //0

const (
	a, b = iota + 1, iota + 2 //1,2
	c, d                      //2,3
	e, f                      //3,4
)

位移运算

<< 表示左移操作，1<<10 表示将 1 的二进制表示向左移10位，也就是由 1 变成了 10000000000 ，也就是十进制的 1024

数据类型

int8 int16 int32 int64
uint8 uint16 uint32 uint64
uint int uintptr
float32 float64
complex64 complex128
bool
byte rune

内置函数

fmt.Printf() - 数据类型
len(v) - 获取对象的长度
strings.Split(string,sep) - 分割（需要导包）
strings.contains() - 判断是否包含
strings.HasPrefix() - 前缀判断
strings.HasSuffix() - 后缀判断
strings.Index() - 子串出现的位置
strings.LastIndex() - 子串出现的位置
strings.Join() - join操作

Number literals syntax

v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25

func main(){
	var a int = 10
	
	// 二进制
	fmt.Printf("%b \n", a)  // 1010
	
	// 十进制
	fmt.Printf("%d \n", a)  // 10
 
	// 八进制  以0开头
	var b int = 077
	fmt.Printf("%o \n", b)  // 77
 
	// 十六进制  以0x开头
	var c int = 0xff
	fmt.Printf("%x \n", c)  // ff
	fmt.Printf("%X \n", c)  // FF
}

浮点型

func main() {
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%.2f\n", math.Pi)
}

byte和rune类型

• uint8 类型，或者叫 byte 型，代表了ASCII码 的一个字符

• rune 类型，代表一个 UTF-8字符

• 当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。

• rune 类型实际是一个 int32

func main() {
	s := "hello 世界"

	//byte
	for i := 0; i < len(s); i++ {
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	// 104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 228(ä) 184(¸) 150(–) 231(ç) 149(•) 140(Œ)

	//rune
	for _, r := range s {
		fmt.Printf("%v(%c) ", r, r)
	}
	// 104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 19990(世) 30028(界)
}

字符串

要修改字符串，需要先将其转换成 []rune 或 []byte ，完成后再转换为 string。无论哪种转换，都会重新分配内存，并复制字节数组

func main() {
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}

判断结构

func main() {
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

循环结构

func main() {
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}

	j := 0
	for j < 10 {
		fmt.Println(j)
		j++
	}
    
    for {
		fmt.Println("hi")
	}
}

for range 循环可以遍历数组、切片、字符串、map 及 通道（channel）

Switch Case

func main() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}
}

Break

func main() {
forloop1:
	for i := 0; i < 10; i++ {
		// forloop2:
		for j := 0; j < 10; j++ {
			if j == 2 {
				break forloop1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	fmt.Println("...")
}

Continue

func main() {
forloop1:
	for i := 0; i < 5; i++ {
		// forloop2:
		for j := 0; j < 5; j++ {
			if i == 2 && j == 2 {
				continue forloop1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
}

Array

• 定义：var name [元素数量]Type

• 数组的长度必须是常量，并且长度是数组类型的一部分，长度不同的数组类型也不同，数组一旦定义，长度就不能改变

• 多维数组只有第一层可以使用 ... 进行数组长度推导

• 数组是值类型，赋值和传参会复制整个数组，因此改变副本的值，不会改变本身的值

• [n]*T 表示指针数组，*[n]T 表示数组指针

初始化数组

一维

func main() {
	// 初始化为 int 类型的 [0 0 0]
	var array1 [3]int
	// 使用指定的初始值 [1 2 0]
	var array2 = [3]int{1, 2}
	// 自动推断数组的长度 [北京 上海 深圳]
	var array3 = [...]string{"北京", "上海", "深圳"}
	// 使用指定索引值 [0 1 0 5]
	array4 := [...]int{1: 1, 3: 5}
    
	fmt.Println(array1)
	fmt.Println(array2)
	fmt.Println(array3)
	fmt.Println(array4)
}

多维

func main() {
	a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	fmt.Println(a)       // [[北京 上海] [广州 深圳] [成都 重庆]]
	fmt.Println(a[2][1]) // 重庆
}

遍历数组

一维

func main() {
	var a = [...]string{"北京", "上海", "深圳"}
	
	// 方法1：for循环遍历
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}

	// 方法2：for range遍历
	for index, value := range a {
		fmt.Println(index, value)
	}
}

多维

func main() {
	array := [...][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}
	for _, v1 := range array {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}
}

切片

切片是一个引用类型，它的内部结构包含 地址、长度 和 容量

声明：var name []Type

初始化：var name []Type{}

内置的 len() 函数求切片的长度，内置的 cap() 函数求切片的容量

简单表达式

func main() {
	a := []int{1, 2, 3, 4, 5}
	s := a[1:3]
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s)) // s:[2 3] len(s):2 cap(s):4
}

完整表达式

表达式为 a[low:high:max]，最终得到的是一个长度是 high - low，容量为 max - low 的切片

func main() {
	a := []int{1, 2, 3, 4, 5}
	t := a[1:3:5]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t, len(t), cap(t)) // t:[2 3] len(t):2 cap(t):4
}

make()函数

定义：make([]Type, size, cap)

func main() {
	a := make([]int, 2, 10)
	fmt.Printf("a:%v len(a):%v cap(a):%v\n", a, len(a), cap(a))
}

要检查切片是否为空，请始终使用 len(a) == 0 来判断，而不应该使用 a == nil 来判断

赋值拷贝

切片是引用类型，都指向了同一块内存地址，赋值拷贝后两个变量共享底层数组

func main() {
	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

copy()函数

定义：copy(destSlice, srcSlice []Type)

• srcSlice: 数据来源切片

• destSlice: 目标切片

func main() {
	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)
	copy(c, a)
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]
}

遍历切片

func main() {
	s := []int{1, 3, 5}

	// 方法1：for循环遍历
	for i := 0; i < len(s); i++ {
		fmt.Println(i, s[i])
	}

	// 方法2：for range遍历
	for index, value := range s {
		fmt.Println(index, value)
	}
}

append()函数

func main() {
	var citySlice []string
	citySlice = append(citySlice, "北京")
	citySlice = append(citySlice, "上海", "广州", "深圳")

	a := []string{"成都", "重庆"}
	citySlice = append(citySlice, a...)
	fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]
}

切片扩容策略

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

删除元素

从切片a中删除索引为index的元素：a = append(a[:index], a[index+1:]...)

func main() {
	// 从切片中删除元素
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]
}

区分数组与切片

var arr [5]int

slice := make([]int,3,5)

func main() {
	// 在 [] 操作符中设定数值的叫数组
	var arr1 [5]int
	arr2 := [5]int{1, 2, 3}
	arr3 := [...]int{1, 2, 3}
	// arr1 => type:[5]int len:5 cap:5 value:[0 0 0 0 0]
	fmt.Printf("arr1 => type:%T len:%v cap:%v value:%v\n", arr1, len(arr1), cap(arr1), arr1)
	// arr2 => type:[5]int len:5 cap:5 value:[1 2 3 0 0]
	fmt.Printf("arr2 => type:%T len:%v cap:%v value:%v\n", arr2, len(arr2), cap(arr2), arr2)
	// arr3 => type:[3]int len:3 cap:3 value:[1 2 3]
	fmt.Printf("arr3 => type:%T len:%v cap:%v value:%v\n", arr3, len(arr3), cap(arr3), arr3)

	// [] 中未设定数值的叫切片
	var slice1 []int  // nil 切片
	slice2 := []int{} // 空切片
	slice3 := []int{1, 2, 3}
	slice4 := make([]int, 0)    // 空切片
	slice5 := make([]int, 3, 5) // 零切片
	// slice1 => type:[]int len:0 cap:0 value:[]
	fmt.Printf("slice1 => type:%T len:%v cap:%v value:%v\n", slice1, len(slice1), cap(slice1), slice1)
	// slice2 => type:[]int len:0 cap:0 value:[]
	fmt.Printf("slice2 => type:%T len:%v cap:%v value:%v\n", slice2, len(slice2), cap(slice2), slice2)
	// slice3 => type:[]int len:3 cap:3 value:[1 2 3]
	fmt.Printf("slice3 => type:%T len:%v cap:%v value:%v\n", slice3, len(slice3), cap(slice3), slice3)
	// slice4 => type:[]int len:0 cap:0 value:[]
	fmt.Printf("slice4 => type:%T len:%v cap:%v value:%v\n", slice4, len(slice4), cap(slice4), slice4)
	// slice5 => type:[]int len:3 cap:5 value:[0 0 0]
	fmt.Printf("slice5 => type:%T len:%v cap:%v value:%v\n", slice5, len(slice5), cap(slice5), slice5)
}

map

定义：make(map[KeyType]ValueType, [cap])

func main() {
	myMap := make(map[string]string, 8)
	myMap["key"] = "value"
	fmt.Println(myMap)                      // map[key:value]
	fmt.Println(myMap["key"])               // value
	fmt.Printf("type of myMap:%T\n", myMap) // type of myMap:map[string]string
	
    // 判断某个键是否存在
    v, ok := myMap["key"]
	if ok {
		fmt.Printf("value is: %s", v)
	} else {
		fmt.Print("no value")
	}
}

func main() {
	userInfo := map[string]string{
		"username": "root",
		"password": "123456",
	}
	fmt.Println(userInfo)
}

遍历map

遍历map时的元素顺序与添加键值对的顺序无关

func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 70
	scoreMap["李四"] = 80
	scoreMap["王五"] = 90
    
	for k, v := range scoreMap {
		fmt.Println(k, v)
	}
    
	for k := range scoreMap {
		fmt.Println(k)
	}
}

delete()函数

定义：delete(map, key)

func main() {
	scoreMap := make(map[string]int)
	scoreMap["张三"] = 70
	scoreMap["李四"] = 80
	scoreMap["王五"] = 90

	delete(scoreMap, "李四")
	for k, v := range scoreMap {
		fmt.Println(k, v)
	}
}

指定顺序遍历map

func main() {
	rand.Seed(time.Now().UnixNano()) //初始化随机数种子
	var scoreMap = make(map[string]int, 200)
	for i := 0; i < 100; i++ {
		key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
		value := rand.Intn(100)          //生成0~99的随机整数
		scoreMap[key] = value
	}
	//取出map中的所有key存入切片keys
	var keys = make([]string, 0, 200)
	for key := range scoreMap {
		keys = append(keys, key)
	}
	//对切片进行排序
	sort.Strings(keys)
	//按照排序后的key遍历map
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}
}

切片中存map

map类型的切片

func main() {
	var mapSlice = make([]map[string]string, 3)
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value)
	}
	fmt.Println("after init")
	mapSlice[0] = make(map[string]string, 10)
	mapSlice[0]["name"] = "root"
	mapSlice[0]["password"] = "123456"
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value)
	}
}

map中存切片

切片类型的map

func main() {
	var sliceMap = make(map[string][]string, 3)
	fmt.Println(sliceMap)
	fmt.Println("after init")
	key := "address"
	value, ok := sliceMap[key]
	if !ok {
		value = make([]string, 0, 2)
	}
	value = append(value, "北京", "上海", "广州", "深圳")
	sliceMap[key] = value
	fmt.Println(sliceMap)
}

函数

定义

func sayHello() {
	fmt.Println("Hello")
}

func intSum(x int, y int) int {
	return x + y
}

// 类型简写
func intSum(x, y int) int {
	return x + y
}

// 可变参数，固定参数搭配可变参数使用时，可变参数要放在固定参数的后面
func intSum(x int, y ...int) int {
	fmt.Println(x, y)
	sum := x
	for _, v := range y {
		sum = sum + v
	}
	return sum
}
// 函数调用
ret := intSum3(100, 10, 20, 30)
fmt.Println(ret) // 160

返回值

// 多值返回
func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}

// 返回值命名
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

// 返回值补充
func someFunc(x string) []int {
	if x == "" {
		return nil // 没必要返回[]int{}
	}
	...
}

变量作用域

全局变量

// 定义全局变量num
var num int64 = 10

func testGlobalVar() {
	fmt.Printf("num=%d\n", num) // 函数中可以访问全局变量num
}

func main() {
	testGlobalVar() // num=10
}

局部变量

func testLocalVar() {
	// 定义一个函数局部变量x,仅在该函数内生效
	var x int64 = 100
	fmt.Printf("x=%d\n", x)
}

func main() {
	testLocalVar()
	fmt.Println(x) // 此时无法使用变量x
}

变量优先级

如果局部变量和全局变量重名，优先访问局部变量

//定义全局变量num
var num int64 = 10

func testNum() {
	num := 100
	fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量
}

func main() {
	testNum() // num=100
}

函数类型与变量

type calculation func(int, int) int

// 满足条件的函数都是 calculation 类型的函数
func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

func main() {
	// add 和 sub 都能赋值给calculation类型的变量
	var c calculation
	c = add
	fmt.Println(c(1, 2))

	d := sub
	fmt.Println(d(2, 1))
}

高阶函数

函数作为参数

func add(x, y int) int {
	return x + y
}
func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}
func main() {
	ret := calc(10, 20, add)
	fmt.Println(ret) //30
}

函数作为返回值

func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("无法识别的操作符")
		return nil, err
	}
}

匿名函数

匿名函数需要保存到某个变量或者作为立即执行函数，多用于实现回调函数和闭包

func main() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通过变量调用匿名函数

	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

闭包

闭包=函数+引用环境

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

func adder2(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder2(10)
	fmt.Println(f(10)) //20
	fmt.Println(f(20)) //40
	fmt.Println(f(30)) //70

	f1 := adder2(20)
	fmt.Println(f1(40)) //60
	fmt.Println(f1(50)) //110
}

func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

func main() {
	jpgFunc := makeSuffixFunc(".jpg")
	txtFunc := makeSuffixFunc(".txt")
	fmt.Println(jpgFunc("test")) //test.jpg
	fmt.Println(txtFunc("test")) //test.txt
}

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

func main() {
	f1, f2 := calc(10)
	fmt.Println(f1(1), f2(2)) //11 9
	fmt.Println(f1(3), f2(4)) //12 8
	fmt.Println(f1(5), f2(6)) //13 7
}

defer语句

将 defer 后面跟随的语句进行延迟处理，先被 defer 的语句最后被执行，最后被 defer 的语句，最先被执行。由于 defer 语句延迟调用的特性，所以 defer 语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}

输出：

start
end
3
2
1

defer执行时机

在Go语言的函数中 return 语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而 defer 语句执行的时机就在返回值赋值操作后，RET指令执行前。具体如下图所示：

defer经典案例

func f1() int {
	x := 5
	defer func() {
		x++
	}()
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	return 5
}

func f3() (y int) {
	x := 5
	defer func() {
		x++
	}()
	return x
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}
func main() {
	fmt.Println(f1())
	fmt.Println(f2())
	fmt.Println(f3())
	fmt.Println(f4())
}

defer面试题

defer注册要延迟执行的函数时，该函数所有的参数都需要确定其值

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

内置函数

内置函数	介绍
close	主要用来关闭channel
len	用来求长度，比如string、array、slice、map、channel
new	用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
make	用来分配内存，主要用来分配引用类型，比如chan、map、slice
append	用来追加元素到数组、slice中
panic和recover	用来做错误处理

异常处理

panic 可以在任何地方引发，但 recover 只有在 defer 调用的函数中有效

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

程序运行期间 funcB 中引发了 panic 导致程序崩溃，异常退出了。这个时候我们就可以通过 recover 将程序恢复回来，继续往后执行

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	defer func() {
		err := recover()
		//如果程序出出现了panic错误,可以通过recover恢复过来
		if err != nil {
			fmt.Println("recover in B")
		}
	}()
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

注意：

1. recover() 必须搭配 defer 使用。

2. defer 一定要在可能引发 panic 的语句之前定义。

指针

func main() {
	a := 10
	b := &a
	fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
	fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
	fmt.Println(&b)                    // 0xc00000e018
}

指针取值

func main() {
	a := 10
	b := &a // 取变量a的地址，将指针保存到b中
	fmt.Printf("type of b:%T\n", b)
	c := *b // 指针取值（根据指针去内存取值）
	fmt.Printf("type of c:%T\n", c)
	fmt.Printf("value of c:%v\n", c)
}

输出

type of b:*int
type of c:int
value of c:10

**总结：**取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

• 对变量进行取地址（&）操作，可以获得这个变量的指针变量。

• 指针变量的值是指针地址。

• 对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。

指针传值

func modify1(x int) {
	x = 100
}

func modify2(x *int) {
	*x = 100
}

func main() {
	a := 10
	modify1(a)
	fmt.Println(a) // 10
	modify2(&a)
	fmt.Println(a) // 100
}

内存分配

func main() {
	var a *int
	*a = 100
	fmt.Println(*a)

	var b map[string]int
	b["Go"] = 100
	fmt.Println(b)
}

执行上面的代码会引发panic，为什么呢？ 在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。Go语言中new和make是内建的两个函数，主要用来分配内存。

new

new是一个内置的函数，它的函数签名如下：

func new(Type) *Type

• Type表示类型，new函数只接受一个参数，这个参数是一个类型

• *Type表示类型指针，new函数返回一个指向该类型内存地址的指针

new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值

func main() {
	a := new(int)
	b := new(bool)
	fmt.Printf("%T\n", a) // *int
	fmt.Printf("%T\n", b) // *bool
	fmt.Println(*a)       // 0
	fmt.Println(*b)       // false
}	

开始的示例代码中 var a *int 只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应该按照如下方式使用内置的new函数对a进行初始化之后就可以正常对其赋值

func main() {
	var a *int
	a = new(int)
	*a = 10
	fmt.Println(*a)
}

make

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。make函数的函数签名如下：

func make(t Type, size ...IntegerType) Type

make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作

开始的示例中var b map[string]int只是声明变量b是一个map类型的变量，需要像下面的示例代码一样使用make函数进行初始化操作之后，才能对其进行键值对赋值

func main() {
	var b map[string]int
	b = make(map[string]int, 10)
	b["Go"] = 100
	fmt.Println(b)
}

new与make的区别

1. 二者都是用来做内存分配的

2. make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身

3. 而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针

type

自定义类型

type NewInt int

类型别名

type MyInt = int
type byte = uint8
type rune = int32

区别

// 自定义类型
type NewInt int

// 类型别名
type MyInt = int

func main() {
	var a NewInt
	var b MyInt

	fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
	fmt.Printf("type of b:%T\n", b) //type of b:int
}

结果显示

a(自定义)类型是 main.NewInt，表示main包下定义的 NewInt 类型。

b(别名)类型是 int,MyInt 类型只会在代码中存在，编译完成时并不会有 MyInt 类型。

结构体

Go语言中通过 struct 来实现面向对象

type 类型名 struct {
    字段名 字段类型
    字段名 字段类型
    …
}

type person struct {
	name string
	city string
	age  int8
}

type person1 struct {
	name, city string
	age        int8
}

• 类型名：标识自定义结构体的名称，在同一个包内不能重复。

• 字段名：表示结构体字段名。结构体中的字段名必须唯一。

• 字段类型：表示结构体字段的具体类型。

结构体实例化

func main() {
	var p person
	p.name = "张三"
	p.city = "深圳"
	p.age = 18
	fmt.Printf("p=%v\n", p)  // p1={张三 深圳 18}
	fmt.Printf("p=%#v\n", p) // p1=main.person{name:"张三", city:"深圳", age:18}
}

注：

%v		// 只输出所有的值
%+v 	// 先输出字段名字，再输出该字段的值
%#v		// 先输出结构体名，再输出结构体值（字段名字+字段的值）

匿名结构体

func main() {
	var user struct {
		name string
		age  int
	}
	user.name = "张三"
	user.age = 18
	fmt.Printf("%#v\n", user) // struct { name string; age int }{name:"张三", age:18}
}

指针结构体

Go语言中支持对结构体指针直接使用 . 来访问结构体的成员

func main() {
	var p = new(person)
	p.name = "张三"
	p.age = 18
	p.city = "深圳"
	fmt.Printf("%T\n", p)    // *main.person
	fmt.Printf("p=%#v\n", p) // p=&main.person{name:"张三", city:"深圳", age:18}
}

取结构体的地址实例化

使用 & 对结构体进行取地址操作，相当于对该结构体类型进行了一次 new 实例化操作

func main() {
	p := &person{}
	fmt.Printf("%T\n", p)    // *main.person
	fmt.Printf("p=%#v\n", p) // p=&main.person{name:"", city:"", age:0}
	p.name = "张三"
	p.age = 18
	p.city = "深圳"
	fmt.Printf("p=%#v\n", p) // p=&main.person{name:"张三", city:"深圳", age:18}
}

p.name = "张三" 其实在底层是 (*p).name = "张三"，这是Go语言帮我们实现的语法糖

结构体初始化

没有初始化的结构体，其成员变量都是对应其类型的零值

func main() {
	var p person
	fmt.Printf("p=%#v\n", p) // p=main.person{name:"", city:"", age:0}
}

func main() {
	// 使用键值对初始化
	p := person{
		name: "张三",
		city: "深圳",
		age:  18,
	}
	fmt.Printf("p=%#v\n", p) // p=main.person{name:"张三", city:"深圳", age:18}
}

func main() {
	// 对结构体指针进行键值对初始化
	p := &person{
		city: "深圳",
		age:  18,
	}
	fmt.Printf("p=%#v\n", p) // p=&main.person{name:"", city:"深圳", age:18}
}

func main() {
	// 使用值的列表初始化
	p := &person{
		"张三",
		"深圳",
		18,
	}
	fmt.Printf("p=%#v\n", p) // p=&main.person{name:"张三", city:"深圳", age:18}
}

结构体内存布局

结构体占用一块连续的内存

func main() {
	type test struct {
		a int8
		b int8
		c int8
		d int8
	}
	n := test{
		1, 2, 3, 4,
	}
	fmt.Printf("n.a %p\n", &n.a) // n.a 0xc00012a058
	fmt.Printf("n.b %p\n", &n.b) // n.b 0xc00012a059
	fmt.Printf("n.c %p\n", &n.c) // n.c 0xc00012a05a
	fmt.Printf("n.d %p\n", &n.d) // n.d 0xc00012a05b
}

空结构体

空结构体是不占用空间的

func main() {
	var v struct{}
	fmt.Println(unsafe.Sizeof(v)) // 0
}

面试题

type student struct {
	name string
	age  int
}

func main() {
	m := make(map[string]*student)
	stus := []student{
		{name: "张三", age: 18},
		{name: "李四", age: 23},
		{name: "王五", age: 9000},
	}

	for _, stu := range stus {
		m[stu.name] = &stu
	}

	for k, v := range m {
		fmt.Println(k, "=>", v.name)
	}
}

构造函数

Go语言的结构体没有构造函数，可以自己实现。 例如，下方的代码就实现了一个 person 的构造函数。 因为 struct 是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

type person struct {
	name string
	city string
	age  int8
}

func newPerson(name, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}

func main() {
	p := newPerson("张三", "深圳", 18)
	fmt.Printf("%#v\n", p) // &main.person{name:"张三", city:"深圳", age:18}
}

方法和接收者

Go语言中的 方法（Method) 是一种作用于特定类型变量的函数。这种特定类型变量叫做 接收者(Receiver)。接收者的概念就类似于其他语言中的 this 或者 self

方法的定义格式如下：

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    函数体
}

其中

• 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称的首字母小写，而不是 self、this 之类的命名。例如，Person 类型的接收者变量应该命名为 p，Connector 类型的接收者变量应该命名为 c 等

• 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型

• 方法名、参数列表、返回参数：具体格式与函数定义相同

// Person 结构体
type Person struct {
	name string
	age  int8
}

// NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

// Dream Person 做梦的方法
func (p Person) Dream() {
	fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
}

func main() {
	p := NewPerson("张三", 18)
	p.Dream()
}

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型

指针类型的接收者

指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self。 例如我们为Person添加一个SetAge方法，来修改实例变量的年龄

// Person 结构体
type Person struct {
	name string
	age  int8
}

// NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

// SetAge 设置p的年龄
// 使用指针接收者
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}

func main() {
	p := NewPerson("张三", 18)
	fmt.Println(p.age) // 18
	p.SetAge(15)
	fmt.Println(p.age) // 15
}

值类型的接收者

当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身

// Person 结构体
type Person struct {
	name string
	age  int8
}

// NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

// SetAge2 设置p的年龄
// 使用值接收者
func (p Person) SetAge(newAge int8) {
	p.age = newAge
}

func main() {
	p := NewPerson("张三", 18)
	fmt.Println(p.age) // 18
	p.SetAge(15)       // (*p).SetAge(15)
	fmt.Println(p.age) // 18
}

什么时候应该使用指针类型接收者

1. 需要修改接收者中的值

2. 接收者是拷贝代价比较大的大对象

3. 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者

任意类型添加方法

在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法

// MyInt将int定义为自定义MyInt类型
type MyInt int

// SayHello 为MyInt添加一个SayHello的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一个int")
}
func main() {
	var m MyInt
	m.SayHello() // Hello, 我是一个int。
	m = 100
	fmt.Printf("%#v  %T\n", m, m) // 100  main.MyInt
}

注意：非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法

结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段

//Person 结构体Person类型
type Person struct {
	string
	int
}

func main() {
	p1 := Person{
		"张三",
		18,
	}
	fmt.Printf("%#v\n", p1)        // main.Person{string:"张三", int:18}
	fmt.Println(p1.string, p1.int) // 张三 18
}

注意：这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个

嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针

// Address 地址结构体
type Address struct {
	Province string
	City     string
}

// User 用户结构体
type User struct {
	Name    string
	Gender  string
	Address Address
}

func main() {
	user := User{
		Name:   "张三",
		Gender: "男",
		Address: Address{
			Province: "广东",
			City:     "深圳",
		},
	}
	fmt.Printf("user=%#v\n", user) // user=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
}

嵌套匿名字段

上面user结构体中嵌套的 Address 结构体也可以采用匿名字段的方式

// Address 地址结构体
type Address struct {
	Province string
	City     string
}

// User 用户结构体
type User struct {
	Name    string
	Gender  string
	Address // 匿名字段
}

func main() {
	var user User
	user.Name = "张三"
	user.Gender = "男"
	user.Address.Province = "广东"   // 匿名字段默认使用类型名作为字段名
	user.City = "深圳"               // 匿名字段可以省略
	fmt.Printf("user=%#v\n", user) // user=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
}

当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找

嵌套结构体的字段名冲突

嵌套结构体内部可能存在相同的字段名，在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名

// Address 地址结构体
type Address struct {
	Province   string
	City       string
	CreateTime string
}

// Email 邮箱结构体
type Email struct {
	Account    string
	CreateTime string
}

// User 用户结构体
type User struct {
	Name   string
	Gender string
	Address
	Email
}

func main() {
	var user User
	user.Name = "张三"
	user.Gender = "男"
	user.Address.CreateTime = "2022" // 指定Address结构体中的CreateTime
	user.Email.CreateTime = "2022"   // 指定Email结构体中的CreateTime
	fmt.Printf("user=%#v\n", user)   // user=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"", City:"", CreateTime:"2022"}, Email:main.Email{Account:"", CreateTime:"2022"}}
}

结构体的“继承”

Go语言中使用结构体也可以实现其他编程语言中面向对象的继承

// Animal 动物
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s会动！\n", a.name)
}

// Dog 狗
type Dog struct {
	Feet    int8
	*Animal // 通过嵌套匿名结构体实现继承
}

func (d *Dog) wang() {
	fmt.Printf("%s会汪汪汪~\n", d.name)
}

func main() {
	d := &Dog{
		Feet: 4,
		Animal: &Animal{ // 注意嵌套的是结构体指针
			name: "乐乐",
		},
	}
	d.wang() // 乐乐会汪汪汪~
	d.move() // 乐乐会动！
}

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）

结构体与JSON序列化

// Student 学生
type Student struct {
	ID     int
	Gender string
	Name   string
}

// Class 班级
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 10; i++ {
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}

	// JSON序列化：结构体=>JSON格式的字符串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n", data)

	// JSON反序列化：JSON格式的字符串=>结构体
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

结构体标签（Tag）

Tag 是结构体的元信息，可以在运行的时候通过反射的机制读取出来。Tag 在结构体字段的后方定义，由一对反引号包裹起来

`key1:"value1" key2:"value2"`

结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。

注意：为结构体编写 Tag 时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。

//Student 学生
type Student struct {
	ID     int    `json:"id"` // 通过指定tag实现json序列化该字段时的key
	Gender string // json序列化是默认使用字段名Gender作为key
	name   string // 私有不能被json包访问
}

func main() {
	s1 := Student{
		ID:     1,
		Gender: "男",
		name:   "张三",
	}
	data, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data) // json str:{"id":1,"Gender":"男"}
}

结构体和方法

因为slice和map这两种数据类型都包含了指向底层数据的指针，因此我们在需要复制它们时要特别注意

type Person struct {
	name   string
	age    int8
	dreams []string
}

func (p *Person) SetDreams(dreams []string) {
	p.dreams = dreams
}

func main() {
	p := Person{name: "张三", age: 18}
	data := []string{"吃饭", "睡觉", "打豆豆"}
	p.SetDreams(data)
	data[1] = "不睡觉"
	fmt.Println(p.dreams) // [吃饭 不睡觉 打豆豆]
}

正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值

type Person struct {
	name   string
	age    int8
	dreams []string
}

func (p *Person) SetDreams(dreams []string) {
	p.dreams = make([]string, len(dreams))
	copy(p.dreams, dreams)
}

func main() {
	p := Person{name: "张三", age: 18}
	data := []string{"吃饭", "睡觉", "打豆豆"}
	p.SetDreams(data)
	data[1] = "不睡觉"
	fmt.Println(p.dreams) // [吃饭 睡觉 打豆豆]
}

同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题

包

创建包

在Go语言中通过标识符的首字母 大/小写 来控制标识符的对外 可见（public）/不可见（private）

// 创建第一个包，路径为 /demo/mypackage.go
package demo

import "fmt"

// 首字母小写，对外不可见(只能在当前包内使用)
var num = 100

// 首字母大写，对外可见(可在其它包中使用)
const Mode = 1

// 首字母小写，对外不可见(只能在当前包内使用)
type person struct {
	name string // 仅限包内访问的字段
	Age  int    // 可在包外访问的字段
}

// 首字母大写，对外可见(可在其它包中使用)
type Student struct {
	Name  string // 可在包外访问的字段
	class string // 仅限包内访问的字段
}

// 首字母小写，对外不可见(只能在当前包内使用)
func sayHi() {
	var myName = "张三"
	fmt.Println(myName)
}

// 首字母大写，对外可见(可在其它包中使用)
func Add(x, y int) int {
	return x + y
}

// 创建第二个包，路径为 /demo/init.go
package demo

import "fmt"

func init() {
	fmt.Println("init")
}

引入包

如果引入一个包的时候为其设置了一个特殊 _ 作为包名，那么这个包的引入方式就称为匿名引入。一个包被匿名引入的目的主要是为了加载这个包，从而使得这个包中的资源得以初始化。被匿名引入的包中的 init 函数将被执行并且仅执行一遍。匿名引入的包与其他方式导入的包一样都会被编译到可执行文件中。

package main

import (
	f "fmt" // 包取别名

	_ "github.com/toki-plus/study/03-package/demo"         // 匿名引入
	mypackage "github.com/toki-plus/study/03-package/demo" // 指定包引入
)

func main() {
	sum := mypackage.Add(1, 2)
	f.Println(sum)
}

init()函数

init()函数不接收任何参数也没有任何返回值，我们也不能在代码中主动调用它。当程序启动的时候，init函数会按照它们声明的顺序自动执行。一个包的初始化过程是按照代码中引入的顺序来进行的，所有在该包中声明的 init 函数都将被串行调用并且仅调用执行一次。每一个包初始化的时候都是先执行依赖的包中声明的 init 函数再执行当前包中声明的 init 函数。确保在程序的 main 函数开始执行时所有的依赖包都已初始化完成。

每一个包的初始化是先从初始化包级别变量开始的。例如从下面的示例中我们就可以看出包级别变量的初始化会先于 init 初始化函数。

package main

import "fmt"

var x int8 = 10

const pi = 3.14

func init() {
	fmt.Println("x:", x)
	fmt.Println("pi:", pi)
	sayHi()
}

func sayHi() {
	fmt.Println("Hello World!")
}

func main() {
	fmt.Println("你好，世界！")
}

x: 10
pi: 3.14
Hello World!
你好，世界！

go module

相关命令

命令	介绍
go mod init	初始化项目依赖，生成go.mod文件
go mod download	根据go.mod文件下载依赖
go mod tidy	比对项目文件中引入的依赖与go.mod进行比对
go mod graph	输出依赖关系图
go mod edit	编辑go.mod文件
go mod vendor	将项目的所有依赖导出至vendor目录
go mod verify	检验一个依赖包是否被篡改过
go mod why	解释为什么需要某个依赖

GOPRIVATE

设置了GOPROXY 之后，go 命令就会从配置的代理地址拉取和校验依赖包。当我们在项目中引入了非公开的包（公司内部git仓库或 github 私有仓库等），此时便无法正常从代理拉取到这些非公开的依赖包，这个时候就需要配置 GOPRIVATE 环境变量。GOPRIVATE用来告诉 go 命令哪些仓库属于私有仓库，不必通过代理服务器拉取和校验。GOPRIVATE 的值也可以设置多个，多个地址之间使用英文逗号 “,” 分隔。我们通常会把自己公司内部的代码仓库设置到 GOPRIVATE 中，例如：

go env -w GOPRIVATE="git.mycompany.com"

这样在拉取以 git.mycompany.com 为路径前缀的依赖包时就能正常拉取了。此外，如果公司内部自建了 GOPROXY 服务，那么我们可以通过设置 GONOPROXY=none，允许通内部代理拉取私有仓库的包。

go.mod文件

go.mod 文件中记录了当前项目中所有依赖包的相关信息，声明依赖的格式如下：

require module/path v1.2.3

其中：

• require：声明依赖的关键字

• module/path：依赖包的引入路径

• v1.2.3：依赖包的版本号。支持以下几种格式：

  • latest：最新版本

  • v1.0.0：详细版本号

  • commit hash：指定某次commit hash

引入某些没有发布过 tag 版本标识的依赖包时，go.mod 中记录的依赖版本信息就会出现类似 v0.0.0-20210218074646-139b0bcd549d 的格式，由版本号、commit时间和commit的hash值组成。

go.sum文件

使用go module下载了依赖后，项目目录下还会生成一个go.sum文件，这个文件中详细记录了当前项目中引入的依赖包的信息及其hash 值。go.sum 文件内容通常是以类似下面的格式出现。

<module> <version>/go.mod <hash>

或者

<module> <version> <hash>
<module> <version>/go.mod <hash>

不同于其他语言提供的基于中心的包管理机制，例如 npm 和 pypi 等，Go并没有提供一个中央仓库来管理所有依赖包，而是采用分布式的方式来管理包。为了防止依赖包被非法篡改，Go module 引入了 go.sum 机制来对依赖包进行校验。

依赖保存位置

Go module 会把下载到本地的依赖包以类似下面的形式保存在 $GOPATH/pkg/mod 目录下，每个依赖包都会带有版本号进行区分，这样就允许在本地存在同一个包的多个不同版本。

mod
├── cache
├── cloud.google.com
├── github.com
    	└──q1mi
          ├── [email protected]
          ├── [email protected]
          └── [email protected]
...

如果想清除所有本地已缓存的依赖包数据，可以执行 go clean -modcache 命令。

发布包

在github创建一个名为hello的项目

$ git clone [email protected]:toki-plus/hello.git
$ cd hello
$ go mod init github.com/toki-plus/hello

创建一个 hello.go 文件

package hello

import "fmt"

func SayHi() {
	fmt.Println("Hi, I'm Toki!")
}

$ git add .
$ git commit -m "first commit"
$ git push

打好 tag 推送到远程仓库

$ git tag -a v1.0.0 -m "release version v0.1.0"
$ git push origin v1.0.0

经过上面的操作我们就发布了一个版本号为 v0.1.0 的版本。

Go modules中建议使用语义化版本控制，其建议的版本号格式如下：

其中：

• 主版本号：发布了不兼容的版本迭代时递增（breaking changes）。

• 次版本号：发布了功能性更新时递增。

• 修订号：发布了bug修复类更新时递增。

发布新的主版本

现在我们的 hello 项目要进行与之前版本存在不兼容的更新，我们计划让 SayHi 函数支持向指定人发出问候。更新后的 SayHi 函数内容如下：

package hello

import "fmt"

// SayHi 向指定人打招呼的函数
func SayHi(name string) {
	fmt.Printf("Hello %s, I'm Toki, nice to meet you!\n", name)
}

由于改动巨大（修改了函数之前的调用规则），对之前使用该包作为依赖的用户影响巨大，需要发布一个主版本号递增的 v2 版本

// 在 hello/go.mod 文件中添加 v2 版本

module github.com/toki-plus/hello/v2

go 1.18

把修改后的代码提交

$ git add .
$ git commit -m "second commit"
$ git push

打好 tag 推送到远程仓库

$ git tag -a v2.0.0 -m "release version v2.0.0"
$ git push origin v2.0.0

这样在不影响使用旧版本的用户的前提下，我们新的版本也发布出去了。想要使用 v2 版本的代码包的用户只需按修改后的引入路径下载即可

go get github.com/toki-plus/hello/[email protected]

在代码中使用的过程与之前类似，只是需要注意引入路径要添加 v2 版本后缀。

package main

import (
	"fmt"

	"github.com/toki-plus/hello/v2" // 引入v2版本
)

func main() {
	hello.SayHi("张三") // v2版本的SayHi函数需要传入字符串参数
}

废弃已发布版本

如果某个发布的版本存在致命缺陷不再想让用户使用时，我们可以使用 retract 声明废弃的版本。例如我们在 hello/go.mod 文件中按如下方式声明即可对外废弃 v0.1.2 版本

module github.com/toki-plus/hello

go 1.18


retract v0.1.2

用户使用go get下载 v0.1.2 版本时就会收到提示，催促其升级到其他版本