一、Go数据结构-数组基本使用¶

1.1 什么是数组¶

在 Go 语言中，数组（Array）是一种用于存储一组相同类型元素的数据结构。数组的长度是固定的，一旦定义后，其大小不能改变。数组在 Go 中是值类型，这意味着当你将一个数组赋值给另一个数组时，会进行一次数组内容的复制。

1.2 声明数组¶

在 Go 中声明数组需要指定数组的长度和元素类型。

声明数组格式： var 数组名字 = [数组长度]数组类型{数组的数据}

下面定义关于老师名字的数组,将下面代码粘贴到00-Declare-Array-1.go文件中并保存该文件

package main

import "fmt"

func main() {
    var teacherNameArray = [3]string{"张三", "王五", "李四"}
    fmt.Println(teacherNameArray)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出。

部分 2 - 声明数组

var teacherNameArray = [3]string{"张三", "王五", "李四"}

这行代码声明了一个包含三个字符串元素的数组 teacherNameArray。使用 [3]string 表示数组类型，然后在花括号内指定初始值。

部分 3 - 输出数组内容

fmt.Println(teacherNameArray)

使用 fmt.Println() 函数输出数组的内容，结果会显示整个数组的元素。

运行上面代码

$ go run .\00-Declare-Array-1.go
[张三 王五 李四]

除了上面方法声明数组外，我们还可以使用语法糖来声明数组。下面定义关于老师年龄的数组,将下面代码粘贴到00-Declare-Array-2.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAgeArray := [3]int{18, 19, 20}
    fmt.Println(teacherAgeArray)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出。

部分 2 - 声明数组

teacherAgeArray := [3]int{18, 19, 20}

这行代码使用简短变量声明方式声明了一个包含三个整数元素的数组 teacherAgeArray。使用 [3]int 表示数组类型，然后在花括号内指定初始值

部分 3 - 输出数组内容

fmt.Println(teacherAgeArray)

运行上面代码

$ go run .\00-Declare-Array-2.go
[18 19 20]

1.3 数组元素¶

1.3.1 访问数组元素¶

在 Go 语言中，通过索引来访问数组元素是一种常见的操作。数组索引从 0 开始，表示第一个元素，依次递增。

访问数组元素格式： 数组名字[索引]

下面定义关于老师名字的数组,并通过索引访问数组元素，将下面代码粘贴到01-AccessArrayElements.go文件中并保存该文件

package main

import "fmt"

func main() {
    var teacherNameArray = [3]string{"张三", "王五", "李四"}
    fmt.Println("第一位老师的名字: ", teacherNameArray[0])
    fmt.Println("第二位老师的名字: ", teacherNameArray[1])
    fmt.Println("第三位老师的名字: ", teacherNameArray[2])
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出

部分 2 - 声明数组并初始化

var teacherNameArray = [3]string{"张三", "王五", "李四"}

这行代码声明了一个包含三个字符串元素的数组 teacherNameArray，并通过初始化赋予了元素初始值。

部分 3 - 访问数组元素

fmt.Println("第一位老师的名字: ", teacherNameArray[0])
fmt.Println("第二位老师的名字: ", teacherNameArray[1])
fmt.Println("第三位老师的名字: ", teacherNameArray[2])

通过索引 0、1 和 2 访问数组中的不同元素，并输出对应的老师名字。

运行上面代码

$ go run .\01-AccessArrayElements.go
第一位老师的名字:  张三
第二位老师的名字:  王五
第三位老师的名字:  李四

1.3.2 修改数组元素¶

在 Go 语言中，修改数组元素是一种常见的操作，可以通过索引来访问并更新数组中的特定元素。

修改数组元素格式： 数组名字[索引]=新元素

下面定义关于老师名字的数组,并通过索引修改数组元素，将下面代码粘贴到02-ModifyArrayElements.go文件中并保存该文件

package main

import "fmt"

func main() {
    var teacherNameArray = [3]string{"张三", "王五", "李四"}
    teacherNameArray[0] = "张武"
    fmt.Println("第一位老师的新的名字: ", teacherNameArray[0])
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出

部分 2 - 声明数组并初始化

var teacherNameArray = [3]string{"张三", "王五", "李四"}

这行代码声明了一个包含三个字符串元素的数组 teacherNameArray，并通过初始化赋予了元素初始值。

部分 3 - 修改数组元素

teacherNameArray[0] = "张武"

使用索引 0 来修改数组中的第一个元素，将其值从 "张三" 修改为 "张武"。

部分 4 - 输出修改后的元素

fmt.Println("第一位老师的新的名字: ", teacherNameArray[0])

输出修改后的第一个老师的名字。

运行上面代码

$ go run .\02-ModifyArrayElements.go
第一位老师的新的名字:  张武

1.4 数组长度¶

1.4.1 获取数组长度¶

在 Go 语言中，数组的长度是固定的，即在声明数组时就需要指定数组的长度。数组的长度表示数组可以容纳的元素数量，它是数组类型的一部分。

获取数组长度格式： len(数组名字)

下面定义关于老师名字的数组,并通过len获取数组长度，将下面代码粘贴到03-ArrayLength-1.go文件中并保存该文件

package main

import "fmt"

func main() {
    var teacherNameArray = [3]string{"张三", "王五", "李四"}
    fmt.Println("teacherNameArray数组长度: ", len(teacherNameArray))
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出

部分 2 - 声明数组并初始化

var teacherNameArray = [3]string{"张三", "王五", "李四"}

这行代码声明了一个包含三个字符串元素的数组 teacherNameArray，并通过初始化赋予了元素初始值。

部分 3 - 获取数组长度

fmt.Println("teacherNameArray数组长度: ", len(teacherNameArray))

使用 len() 函数来获取数组 teacherNameArray 的长度，并将结果输出。

运行上面代码

$ go run .\03-ArrayLength-1.go
teacherNameArray数组长度:  3

1.4.2 自动推断数组长度¶

在 Go 语言中，数组的长度可以被自动推断，也就是说你不必明确地指定数组的长度，而是可以让编译器根据初始化值的个数来推断数组的长度。这种特性使得数组的初始化更加方便，尤其是在元素数量可能变化的情况下。

在声明数组的时候，可以使用 ... 来让编译器根据提供的初始化值来自动推断数组的长度。

将下面代码粘贴到03-ArrayLength-2.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherNameArray := [...]string{"张三", "王五", "李四"}
    fmt.Println(teacherNameArray)
    fmt.Println("数组长度:", len(teacherNameArray))

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出

部分 2 - main函数

func main() {
    // 代码部分
}

这是程序入口，所有的代码都将在这个函数中执行。

部分 3 - 数组定义和初始化

teacherNameArray := [...]string{"张三", "王五", "李四"}

定义了一个包含三个字符串元素的数组 teacherNameArray，并使用自动推断数组长度的方式进行了初始化。

部分 4 - 打印整个数组

fmt.Println(teacherNameArray)

使用 fmt.Println() 函数来打印整个数组 teacherNameArray，将数组的所有元素一次性输出。

部分 5 - 获取数组长度并打印

fmt.Println("数组长度:", len(teacherNameArray))

使用 len() 函数来获取数组 teacherNameArray 的长度，这个长度会根据你提供的初始化值的个数进行推断。然后，你使用fmt.Println() 函数来打印数组的长度。

运行上面代码

$ go run .\03-ArrayLength-2.go
[张三 王五 李四]
数组长度: 3

1.5 遍历数组¶

在 Go 语言中，遍历数组是指逐个访问数组中的元素。遍历数组通常使用循环结构来实现，以便访问数组中的每个元素并执行相应的操作。

下面使用 for 循环来遍历数组,将下面代码粘贴到04-Iterate-through-array-1.go文件中并保存该文件

package main

import "fmt"

func main() {
    var teacherNameArray = [3]string{"张三", "王五", "李四"}
    for i := 0; i < len(teacherNameArray); i++ {
        fmt.Printf("第%d个数据为:%s\n", i+1, teacherNameArray[i])
    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出

部分 2 - 主函数

func main() {
    // 代码内容
}

这是程序的入口函数，所有的代码都会在这里执行。

部分 3 - 声明和初始化数组

var teacherNameArray = [3]string{"张三", "王五", "李四"}

在主函数中，声明了一个包含三个字符串元素的数组 teacherNameArray，并使用字面值初始化了数组的元素。

部分 4 - 使用for循环遍历数组

for i := 0; i < len(teacherNameArray); i++ {
    fmt.Printf("第%d个数据为:%s\n", i+1, teacherNameArray[i])
}

在循环内部，使用 for 循环遍历数组的每个元素。循环变量 i 从 0 开始，逐渐增加，直到达到数组长度（len(teacherNameArray)）为止。在循环体内，使用 fmt.Printf() 格式化输出了每个元素的索引和值。

运行上面代码

$ go run .\04-Iterate-through-array-1.go
第1个数据为:张三
第2个数据为:王五
第3个数据为:李四

除了上面使用 for 循环来遍历数组外,也可以使用for-range循环遍历，将下面代码粘贴到04-Iterate-through-array-2.go文件中并保存该文件

package main

import "fmt"

func main() {
    var teacherNameArray = [3]string{"张三", "王五", "李四"}
    for key, value := range teacherNameArray {
        fmt.Printf("第%d个数据为:%s\n", key+1, value)
    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出

部分 2 - main函数

func main() {
    // 代码部分
}

这是程序入口，所有的代码都将在这个函数中执行。

部分 3 - 数组定义

var teacherNameArray = [3]string{"张三", "王五", "李四"}

定义了一个包含三个字符串元素的数组 teacherNameArray，其中每个字符串是老师的名字。

部分 4 - for循环和range

for key, value := range teacherNameArray {
    // 代码部分
}

这是一个 for 循环，使用 range 关键字遍历数组 teacherNameArray 中的每个元素。在每次迭代中，key 表示当前元素的索引，value 表示当前元素的值。

部分 5 - 输出信息

fmt.Printf("第%d个数据为:%s\n", key+1, value)

在循环体内，使用 fmt.Printf() 来格式化输出每个元素的索引（通过 key+1 加1以得到人类可读的编号）和值。

部分 6 - main函数闭合

}

代码结束于这里，表示 main 函数的结束。

运行上面代码

$ go run .\04-Iterate-through-array-2.go
第1个数据为:张三
第2个数据为:王五
第3个数据为:李四

1.6 学习数组注意事项¶

学习 Go 语言的数组时，以下几点是需要注意的：

• 数组长度固定： 数组在声明后其长度就是固定的，无法在运行时改变。因此，在选择数组作为数据结构时，需要确保数组的长度能够满足你的需求。

• 数组索引从 0 开始： 数组的索引是从 0 开始的，即第一个元素的索引为 0，第二个元素的索引为 1，以此类推。要注意索引越界问题，避免访问不存在的索引。

• 数组是值类型： 在赋值操作中，数组会被复制。这意味着当将一个数组赋值给另一个数组时，会创建一个新的副本，而不是引用原始数组。这可能会导致性能问题，特别是在处理大型数组时。

• 数组长度是类型的一部分： 在 Go 中，数组的长度也是数组类型的一部分。例如，[5]int 和 [10]int 是不同的类型。这也意味着你不能将长度不同的数组直接进行赋值或比较。

• 使用切片进行动态操作： 如果需要动态大小的数据结构，可以使用切片（Slice）。切片是对数组的抽象，可以更灵活地操作数据。切片允许你动态添加、删除元素，具有更好的扩展性。

• 遍历数组： 使用 for 循环遍历数组时，注意循环变量的范围和索引的限制，避免索引越界错误。

• 内存使用： 数组在内存中占用连续的存储空间。在处理大型数组时，可能会受到内存使用方面的限制。要谨慎处理内存，避免不必要的资源浪费。

• 初始化和默认值： 在声明数组后，如果不显式地初始化数组元素，它们会被初始化为对应类型的默认值（例如，整数数组的元素默认为 0）。

• 选择合适的数据结构： 虽然数组是一种基本的数据结构，但在实际开发中，根据具体需求选择合适的数据结构是很重要的。有时切片、映射（Map）或其他数据结构可能更适合特定的场景。

二、Go数据结构-切片基本使用¶

主要以下几方面介绍Go语言中切片:

• 什么是切片
• 访问元素
• 修改元素
• 添加元素
• 创建切片
• 切片长度和容量
• 切片截取
• 删除元素
• 深拷贝
• 浅拷贝

2.1 什么是切片¶

Go语言中的切片（Slice）是一种强大且灵活的数据结构，用于存储一系列相同类型的元素。切片可以看作是对底层数组的一个引用，它提供了动态大小、方便操作以及自动扩容的能力。

2.2 访问元素¶

切片的元素可以通过索引来访问，索引从0开始，以元素的顺序递增。

访问元素的基本语法：

// 假设有一个切片或数组 slice
element := slice[index]

• element :你要访问的元素
• index :元素的索引

将下面代码粘贴到00-BasicSliceOperations-01.go文件中并保存该文件

package main

import "fmt"

func main() {
    var s1 []int
    s2 := []int{1, 2, 3}
    fmt.Println("最初的切片数据是: ", s1)
    fmt.Println("访问的切片第一个元素是: ", s2[0])

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包和主函数

package main

import "fmt"

在这部分，代码声明了包名为 "main"，这是一个特殊的包名，用于标识一个可执行程序。然后，通过 import "fmt" 导入了 "fmt" 包，这个包提供了格式化输入输出的功能。

部分 2 - 变量声明和切片初始化

var s1 []int
s2 := []int{1, 2, 3}

这部分代码声明了两个切片变量。首先，声明了一个名为 s1 的切片，它是一个空切片，没有任何元素。然后，使用短变量声明方式初始化了一个名为 s2 的切片，其中包含三个整数元素。

部分 3 - 输出语句

fmt.Println("最初的切片数据是: ", s1)
fmt.Println("访问的切片第一个元素是: ", s2[0])

这部分代码使用 fmt.Println 函数输出信息。第一条语句输出了 s1 切片的内容，由于 s1 是空切片，所以输出为空。第二条语句输出了 s2 切片的第一个元素，即索引为 0 的元素，这里是数字 1。

部分 4 - 主函数结束

// 主函数结束
}

这是主函数的结束标志。整个程序的执行从 func main() 开始，直到遇到 } 结束。

运行上面代码

$ go run .\00-BasicSliceOperations-01.go
最初的切片数据是:  []
访问的切片第一个元素是:  1

2.3 修改元素¶

修改切片或数组中的元素与访问元素非常相似。可以使用索引来定位要修改的元素，并将其替换为新的值。

访问元素的基本语法：

// 假设有一个切片或数组 slice
slice[index] = newValue

• index :要修改的元素的索引
• newValue :要将元素修改成的新值

将下面代码粘贴到00-BasicSliceOperations-02.go文件中并保存该文件

package main

import "fmt"

func main() {
    s2 := []int{1, 2, 3}
    s2[0] = 88
    fmt.Println("切片修改完的数据是: ", s2)
    fmt.Println("切片修改完第一个元素的结果是: ", s2[0])

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包声明和导入

package main

import "fmt"

这部分代码声明了包名为 "main"，这是一个特殊的包名，用于标识一个可执行程序。然后，通过 import "fmt" 导入了 "fmt" 包，这个包提供了格式化输入输出的功能。

部分 2 - 主函数

func main() {

这是主函数的开始标志，也是程序的入口点。在 Go 语言中，每个可执行程序都必须包含一个 main 函数作为程序的入口。

部分 3 - 切片的创建和修改

s2 := []int{1, 2, 3}
s2[0] = 88

这部分代码首先声明并初始化一个名为 s2 的整型切片，包含了三个元素 1、2 和 3。然后，它将 s2 的第一个元素（索引为 0）修改为 88。

部分 4 - 输出语句

fmt.Println("切片修改完的数据是: ", s2)
fmt.Println("切片修改完第一个元素的结果是: ", s2[0])

这部分代码使用 fmt.Println 函数来输出信息。第一条语句输出修改后的切片 s2 的内容，第二条语句输出修改后的切片 s2 的第一个元素，即索引为 0 的元素。

部分 5 - 主函数结束

}

这是主函数的结束标志。整个程序的执行从 func main() 开始，直到遇到 } 结束。

运行上面代码

$ go run .\00-BasicSliceOperations-02.go
切片修改完的数据是:  [88 2 3]
切片修改完第一个元素的结果是:  88

2.4 添加元素¶

使用内置的append函数可以向切片末尾添加元素，如果底层数组的容量不够，append会自动扩容。

添加元素的基本语法：

// 假设有一个切片 slice
newSlice := append(slice, element1, element2, ...)

• slice :要添加元素的切片
• element1、element2 等:要添加的元素

将下面代码粘贴到00-BasicSliceOperations-03.go文件中并保存该文件

package main

import "fmt"

func main() {
    s1 := []int{1, 2, 3}
    s1 = append(s1, 4)
    fmt.Println("添加完元素后的结果是: ", s1)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包声明和导入

package main

import "fmt"

这部分代码声明了包名为 "main"，这是一个特殊的包名，用于标识一个可执行程序。然后，通过 import "fmt" 导入了 "fmt" 包，这个包提供了格式化输入输出的功能。

部分 2 - 主函数

func main() {

这是主函数的开始标志，也是程序的入口点。在 Go 语言中，每个可执行程序都必须包含一个 main 函数作为程序的入口。

部分 3 - 切片的创建和添加元素

s1 := []int{1, 2, 3}
s1 = append(s1, 4)

这部分代码首先声明并初始化一个名为 s1 的整型切片，包含了三个元素 1、2 和 3。然后，使用 append 函数将元素 4 添加到切片 s1 的末尾。

部分 4 - 输出语句

fmt.Println("添加完元素后的结果是: ", s1)

这部分代码使用 fmt.Println 函数输出文本和切片的内容。它将添加元素后的切片 s1 的内容打印出来。

部分 5 - 主函数结束

}

这是主函数的结束标志。整个程序的执行从 func main() 开始，直到遇到 } 结束。

运行上面代码

$ go run .\00-BasicSliceOperations-03.go
添加完元素后的结果是:  [1 2 3 4]

2.5 创建切片¶

在Go语言中，创建切片的方法有多种。最常见的方式是使用make函数，它可以用来创建一个指定长度和容量的切片。

使用 make 函数创建切片的基本语法:

// 声明一个切片
slice := make([]T, length, capacity)

• T :表示切片中的元素类型
• length: 表示切片的初始长度
• capacity :表示切片的初始容量

接下来创建一个整型切片，将下面代码粘贴到00-BasicSliceOperations-04.go文件中并保存该文件

package main

import "fmt"

func main() {
    var s1 []int
    s2 := make([]int, 3, 5)
    fmt.Println("切片默认长度是: ", len(s1))
    fmt.Println("切片默认容量是: ", cap(s1))
    fmt.Println("创建后的切片长度是: ", len(s2))
    fmt.Println("创建后的切片容量是: ", cap(s2))
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包声明和导入

package main

import "fmt"

这部分代码声明了包名为 "main"，这是一个特殊的包名，用于标识一个可执行程序。然后，通过 import "fmt" 导入了 "fmt" 包，这个包提供了格式化输入输出的功能。

部分 2 - 主函数

func main() {

这是主函数的开始标志，也是程序的入口点。在 Go 语言中，每个可执行程序都必须包含一个 main 函数作为程序的入口。

部分 3 - 声明切片和创建切片

var s1 []int
s2 := make([]int, 3, 5)

这部分代码首先声明了一个名为 s1 的空切片。然后，使用 make 函数创建一个名为 s2 的切片，初始长度为 3，容量为 5。

部分 4 - 输出语句

fmt.Println("切片默认长度是: ", len(s1))
fmt.Println("切片默认容量是: ", cap(s1))
fmt.Println("创建后的切片长度是: ", len(s2))
fmt.Println("创建后的切片容量是: ", cap(s2))

这部分代码使用 fmt.Println 函数输出文本和切片的长度和容量信息。它分别打印了切片 s1 的长度和容量（切片为空，所以长度和容量都为 0），以及切片 s2 的长度和容量（根据 make 函数指定的值）。

部分 5 - 主函数结束

}

这是主函数的结束标志。整个程序的执行从 func main() 开始，直到遇到 } 结束。

运行上面代码

$ go run .\00-BasicSliceOperations-04.go
切片默认长度是:  0
切片默认容量是:  0
创建后的切片长度是:  3
创建后的切片容量是:  5

2.6 切片长度和容量¶

切片具有长度（Length）和容量（Capacity）两个属性。长度是切片中实际包含的元素数量，而容量是底层数组从切片的开始位置到数组末尾的元素数量。

切片长度和容量的基本语法：

// 假设有一个切片 slice
length := len(slice)     // 获取切片的长度
capacity := cap(slice)   // 获取切片的容量

• slice ：要获取长度和容量的切片

将下面代码粘贴到00-BasicSliceOperations-05.go文件中并保存该文件

package main

import "fmt"

func main() {
    s1 := make([]int, 5, 10)
    fmt.Println("切片s1默认长度是: ", len(s1))
    fmt.Println("切片s1默认容量是: ", cap(s1))
    fmt.Println("切片s1初始数据是: ", s1)
    s1 = append(s1, 1, 2, 3)
    fmt.Println("第一次增加后的初始数据是: ", s1)
    fmt.Println("第一次增加后切片s1长度是: ", len(s1))
    fmt.Println("第一次增加后切片s1容量是: ", cap(s1))
    s1 = append(s1, 4, 5, 6)
    fmt.Println("第二次增加后的初始数据是: ", s1)
    fmt.Println("第二次增加后切片s1长度是: ", len(s1))
    fmt.Println("第二次增加后切片s1容量是: ", cap(s1))
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包声明和导入

package main

这部分代码声明了包名为 "main"，这是一个特殊的包名，用于标识一个可执行程序。

部分 2 - 导入语句

import "fmt"

这部分代码通过 import 关键字导入了 "fmt" 包，这个包提供了格式化输入输出的功能。

部分 3 - 主函数

func main() {

这是主函数的开始标志，也是程序的入口点。在 Go 语言中，每个可执行程序都必须包含一个 main 函数作为程序的入口。

部分 4 - 创建切片和输出初始信息

s1 := make([]int, 5, 10)
fmt.Println("切片s1默认长度是: ", len(s1))
fmt.Println("切片s1默认容量是: ", cap(s1))
fmt.Println("切片s1初始数据是: ", s1)

这部分代码首先使用 make 函数创建一个初始长度为 5、容量为 10 的整型切片 s1。然后，通过 fmt.Println 分别打印了切片的长度、容量和初始内容。

部分 5 - 添加元素并输出信息

s1 = append(s1, 1, 2, 3)
fmt.Println("第一次增加后的初始数据是: ", s1)
fmt.Println("第一次增加后切片s1长度是: ", len(s1))
fmt.Println("第一次增加后切片s1容量是: ", cap(s1))

这部分代码使用 append 函数向切片 s1 添加了元素 1、2 和 3。然后，通过 fmt.Println 打印了添加元素后的切片内容、长度和容量。

部分 6 - 再次添加元素并输出信息

s1 = append(s1, 4, 5, 6)
fmt.Println("第二次增加后的初始数据是: ", s1)
fmt.Println("第二次增加后切片s1长度是: ", len(s1))
fmt.Println("第二次增加后切片s1容量是: ", cap(s1))

这部分代码再次使用 append 函数向切片 s1 添加了元素 4、5 和 6。然后，通过 fmt.Println 打印了再次添加元素后的切片内容、长度和容量。

部分 7 - 主函数结束

}

这是主函数的结束标志。整个程序的执行从 func main() 开始，直到遇到 } 结束。

注意:当你通过 append 函数向切片 s1 添加了元素时，由于切片 s1 的容量为 10，当添加的元素超过容量时，底层数组会重新分配一个更大的内存块，然后将现有元素复制到新的内存块中，从而实现切片的扩容。一般容量扩容规律是初始容量*2

运行上面代码

$ go run .\00-BasicSliceOperations-05.go
切片s1默认长度是:  5
切片s1默认容量是:  10
切片s1初始数据是:  [0 0 0 0 0]
第一次增加后的初始数据是:  [0 0 0 0 0 1 2 3]
第一次增加后切片s1长度是:  8
第一次增加后切片s1容量是:  10
第二次增加后的初始数据是:  [0 0 0 0 0 1 2 3 4 5 6]
第二次增加后切片s1长度是:  11
第二次增加后切片s1容量是:  20

2.7 切片截取¶

当在Go语言中使用切片(slice)时，可以使用切片切取(slice slicing)来获取切片中的一部分元素。切片切取允许创建一个新的切片，其中包含原始切片中指定范围的元素。

切片切取的基本语法：

newSlice := originalSlice[startIndex:endIndex]

• newSlice :一个新的切片
• originalSlice:要切取的原始切片
• startIndex :切取的起始索引（包含）
• endIndex 是切取的结束索引（不包含）

将下面代码粘贴到00-BasicSliceOperations-06.go文件中并保存该文件

package main

import "fmt"

func main() {
    var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println("最初的数据: ", s1)
    // 获取前4位数据
    fmt.Println("切片s1前四位的数据: ", s1[:4])
    // 获取后4位数据
    fmt.Println("切片s1后四位的数据: ", s1[6:])
    // 获取第3位和第4位数据
    fmt.Println("切片s1第3位和第4位数据: ", s1[2:4])
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包导入

import "fmt"

这部分代码用于导入名为 fmt 的包，它提供了格式化输入和输出的功能。

部分 2 - 主函数

func main() {
    // ...
}

这是程序的入口点，所有的代码逻辑都将在主函数中执行。

部分 3 - 切片的初始化

var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

部分 4 - 输出初始化数据

fmt.Println("最初的数据: ", s1)

这一行代码使用 fmt.Println 函数将切片 s1 的内容输出到控制台，显示切片中的初始数据。

部分 5 - 切片表达式示例

fmt.Println("切片s1前四位的数据: ", s1[:4])
fmt.Println("切片s1后四位的数据: ", s1[6:])
fmt.Println("切片s1第3位和第4位数据: ", s1[2:4])

这部分代码演示了不同切片表达式的使用：

• s1[:4]：获取从切片开头到索引3（不包括4）的元素，即前四位元素。
• s1[6:]：获取从索引6开始到切片末尾的所有元素，即后四位元素。
• s1[2:4]：获取从索引2到索引3（不包括4）的元素，即第3和第4位元素。

运行上面代码

$ go run .\00-BasicSliceOperations-06.go
最初的数据:  [1 2 3 4 5 6 7 8 9 10]
切片s1前四位的数据:  [1 2 3 4]
切片s1后四位的数据:  [7 8 9 10]
切片s1第3位和第4位数据:  [3 4]

2.8 删除元素¶

Go语言中没有直接的删除切片元素的方法，但可以通过切片操作来实现删除。

2.8.1 删除第一个元素¶

将下面代码粘贴到00-BasicSliceOperations-07.go文件中并保存该文件

package main

import "fmt"

func main() {
    var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println("最初的数据: ", s1)
    // 删除第一个元素
    s1 = s1[1:]
    fmt.Println("删除第一个元素: ", s1)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包导入

import "fmt"

这部分代码用于导入名为 fmt 的包，它提供了格式化输入和输出的功能。

部分 2 - 主函数

func main() {
    // ...
}

这是程序的入口点，所有的代码逻辑都将在主函数中执行。

部分 3 - 初始切片创建

var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

这一行代码创建了一个初始切片 s1，其中包含整数 1 到 10。

部分 4 - 打印初始数据

fmt.Println("最初的数据: ", s1)

这行代码使用 fmt.Println 函数来打印初始切片 s1 中的所有元素，显示在控制台上。

部分 5 - 删除第一个元素

s1 = s1[1:]

在这行代码中，使用了切片的切割操作，通过 s1[1:] 来创建一个新的切片。这个新切片包含原始切片 s1 从索引 1 到最后一个元素的部分，从而达到删除原始切片中第一个元素的效果。

部分 6 - 打印删除后的数据

fmt.Println("删除第一个元素: ", s1)

这行代码使用 fmt.Println 函数来打印删除第一个元素后的切片 s1 中的所有元素，显示在控制台上。

运行上面代码

$ go run .\00-BasicSliceOperations-07.go
最初的数据:  [1 2 3 4 5 6 7 8 9 10]
删除第一个元素:  [2 3 4 5 6 7 8 9 10]

2.8.2 删除最后一个元素¶

将下面代码粘贴到00-BasicSliceOperations-08.go文件中并保存该文件

package main

import "fmt"

func main() {
    var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println("最初的数据: ", s1)
    // 删除最后一个元素
    s1 = s1[:len(s1)-1]
    fmt.Println("删除最后一个元素: ", s1)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包导入

import "fmt"

这部分代码用于导入名为 fmt 的包，它提供了格式化输入和输出的功能。

部分 2 - 主函数

func main() {
    // ...
}

这是程序的入口点，所有的代码逻辑都将在主函数中执行。

部分 3 - 初始切片创建

var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

这一行代码创建了一个初始切片 s1，其中包含整数 1 到 10。

部分 4 - 打印初始数据

fmt.Println("最初的数据: ", s1)

这行代码使用 fmt.Println 函数来打印初始切片 s1 中的所有元素，显示在控制台上。

部分 5 - 删除最后一个元素

s1 = s1[:len(s1)-1]

在这行代码中，使用切片的切割操作，通过 s1[:len(s1)-1] 来创建一个新的切片。这个新切片包含原始切片 s1 从索引 0 到倒数第二个元素的部分，即删除了最后一个元素。

部分 6 - 打印删除后的数据

fmt.Println("删除最后一个元素: ", s1)

这行代码使用 fmt.Println 函数将删除最后一个元素后的切片 s1 中的所有元素打印到控制台，以展示删除效果。

运行上面代码

$ go run .\00-BasicSliceOperations-08.go
最初的数据:  [1 2 3 4 5 6 7 8 9 10]
删除最后一个元素:  [1 2 3 4 5 6 7 8 9]

2.8.3 删除某个元素¶

下面演示如何删除某个元素(这里指5)，将下面代码粘贴到00-BasicSliceOperations-09.go文件中并保存该文件

package main

import "fmt"

func main() {
    var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println("最初的数据: ", s1)
    // 删除元素5 [:4] [6:]
    s1 = append(s1[:4], s1[5:]...)
    fmt.Println("删除中间元素5: ", s1)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包导入

import "fmt"

这部分代码用于导入名为 fmt 的包，它提供了格式化输入和输出的功能。

部分 2 - 初始切片创建

var s1 = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

这一行代码创建了一个初始切片 s1，其中包含整数从 1 到 10。

部分 3 - 打印初始数据

fmt.Println("最初的数据: ", s1)

这行代码使用 fmt.Println 函数将初始切片 s1 中的所有元素打印到控制台，用于显示初始数据。

部分 4 - 删除中间元素

s1 = append(s1[:4], s1[5:]...)

在这行代码中，使用切片的切割和重新组合操作来删除切片中的中间元素。s1[:4] 表示切片的前四个元素，s1[5:] 表示切片的从索引 5 开始的元素。通过使用 append 函数将这两部分重新组合在一起，删除了切片中的第 5 个元素（索引为 4 的元素）。

部分 5 - 打印删除后的数据

fmt.Println("删除中间元素5: ", s1)

这行代码使用 fmt.Println 函数将删除中间元素后的切片 s1 中的所有元素打印到控制台，以展示删除效果。

运行上面代码

$ go run .\00-BasicSliceOperations-09.go
最初的数据:  [1 2 3 4 5 6 7 8 9 10]
删除中间元素5:  [1 2 3 4 6 7 8 9 10]

2.9 深拷贝¶

2.9.1 什么是深拷贝¶

深拷贝是指在将一个切片赋值给另一个切片时，不仅复制了切片的指针和长度信息，还会创建一个全新的底层数组，并将原切片的元素复制到新的底层数组中。这样，两个切片之间的数据完全独立，修改一个切片不会影响另一个切片。

通俗点来讲，现在想象你有两个完全相同的宝箱，每个都有一样的彩色玻璃珠。你和你的朋友分别拿了一个宝箱，都不知道对方的宝箱。你往自己的宝箱里放玻璃珠，这不会影响到你朋友的宝箱。深拷贝就是这样，两个切片虽然有相同的数据，但它们是独立的，互不干扰。

2.9.2 深拷贝应用场景¶

如果复制变量涉及到值类型，一般都是深拷贝。其中值类型包括：

• int
• float
• string
• struct
• array
• bool

2.9.3 深拷贝示例¶

将下面代码粘贴到01-DeepCopy-1.go文件中并保存该文件

package main

import "fmt"

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := make([]int, len(s1))
    // 深拷贝
    copy(s2, s1)
    // 修改s2中的第一个元素为10
    s2[0] = 10
    fmt.Println("初始数据是: ", s1)
    fmt.Println("修改后的数据是: ", s2)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包导入

import "fmt"

这行代码导入了Go语言标准库中的fmt包，它提供了格式化输入输出的功能，你可以通过它来打印输出内容。

部分 2 - 主函数

func main() {
   // ...
}

这是Go程序的主函数，程序从这里开始执行。

部分 3 - 切片的创建和赋值

s1 := []int{1, 2, 3, 4, 5}
s2 := make([]int, len(s1))
copy(s2, s1)

• s1 是一个整数切片，包含了值为 1 到 5 的元素。
• s2 是通过 make 函数创建的整数切片，其长度与 s1 相同。然后，通过 copy 函数，将 s1 中的元素复制到 s2 中，实现了对 s1 的深拷贝。

部分 4 - 修改切片元素

s2[0] = 10

这行代码将 s2 切片的第一个元素（索引为0）从原来的值修改为10。

部分 5 - 打印输出

fmt.Println(s1)
fmt.Println(s2)

这两行代码使用了导入的 fmt 包中的 Println 函数，分别将 s1 和 s2 切片的内容打印输出到控制台。

运行上面代码

$ go run .\01-DeepCopy-1.go
初始数据是:  [1 2 3 4 5]
修改后的数据是:  [10 2 3 4 5]

2.10 浅拷贝¶

2.10.1 什么是浅拷贝¶

浅拷贝是指在将一个切片赋值给另一个切片时，只复制了切片的指针和长度信息，而底层的数据仍然被多个切片所共享。这意味着如果你修改了一个切片的元素，另一个切片也会受到影响，因为它们共享同一份底层数据。

通俗点来讲，你可以想象有一个宝箱里放了一些彩色玻璃珠。你拿了一个空瓶子，然后用一个标签指向宝箱，这样你知道玻璃珠在哪里。这时，你的朋友也来拿了一个空瓶子，也用一个标签指向了同样的宝箱。现在，无论你还是你的朋友往瓶子里放东西，都会影响到同一个宝箱里的东西。这就是浅拷贝，两个切片共享同一个数据，一个变了，另一个也会变。

2.10.2 浅拷贝应用场景¶

如果复制变量涉及到引用类型，一般都是浅拷贝。其中引用类型包括：

• slice
• map
• channel
• interface

2.10.3 浅拷贝示例¶

将下面代码粘贴到02-ShallowCopy-1.go文件中并保存该文件

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    // 浅拷贝
    s2 := s1
    s2[0] = 88
    fmt.Println("s1的数据: ", s1)
    fmt.Println("s1中第一个元素的内存地址: ", unsafe.Pointer(&s1[0]))
    fmt.Println("s2的数据: ", s2)
    fmt.Println("s2中第一个元素的内存地址: ", unsafe.Pointer(&s2[0]))
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包导入

import "fmt"

这部分代码用于导入名为 fmt 的包，它提供了格式化输入和输出的功能。

部分 2 - 初始切片创建

s1 := []int{1, 2, 3, 4, 5}

部分 3 - 浅拷贝

s2 := s1

这行代码进行了浅拷贝，将切片 s1 的内容复制给了切片 s2。这意味着 s1 和 s2 指向相同的底层数组，它们共享同一份数据。

部分 4 - 修改s2

s2[0] = 88

在这行代码中，修改了切片 s2 的第一个元素，将其改为 88。

部分 5 - 打印数据

fmt.Println("s1的数据: ", s1)
fmt.Println("s1中第一个元素的内存地址: ", unsafe.Pointer(&s1[0]))
fmt.Println("s2的数据: ", s2)
fmt.Println("s2中第一个元素的内存地址: ", unsafe.Pointer(&s2[0]))

这几行代码使用 fmt.Println 函数打印了以下内容：

• 切片 s1 中的数据。
• 切片 s1 中第一个元素的内存地址。
• 切片 s2 中的数据。
• 切片 s2 中第一个元素的内存地址。

运行上面代码，通过比较内存地址，可以看到 s1 和 s2 的第一个元素的内存地址相同，这是因为它们共享了同一个底层数组。

$ go run .\02-ShallowCopy-1.go
s1的数据:  [88 2 3 4 5]
s1中第一个元素的内存地址:  0xc00000e420
s2的数据:  [88 2 3 4 5]
s2中第一个元素的内存地址:  0xc00000e420

三、Go数据结构-映射/字典/对象¶

主要以下几方面介绍Go语言中字典(对象):

• 什么是字典(对象)
• map创建
• map操作

3.1 什么是字典(对象)¶

Map 是一种无序的键值对集合，也被称为字典、关联数组或哈希表。在 Go 语言中，map 是一种内置的数据结构，用于存储一组键值对，其中键是唯一的，而值可以重复。Map 在实际应用中非常常见，用于快速查找和存储数据。

注意事项

• 字典是引用类型：当将字典赋值给另一个变量时，它们将共享相同的底层数据。这意味着修改一个变量的字典会影响到另一个变量的字典。
• 字典的键类型：字典的键可以是任意可比较的类型，如整数、字符串、结构体（只要它们的字段是可比较的），数组等。切片、函数和包含切片的结构体不能作为字典的键。
• 并发安全性：默认情况下，字典不是并发安全的，如果多个 Goroutine 同时访问和修改同一个字典，可能会引发竞态条件。如果需要在并发环境中使用字典，可以考虑使用 sync.Map。

3.2 map创建¶

在 Go 语言中，要创建一个 map，可以使用内置的 make 函数来初始化一个空的 map。map 是一种用于存储键值对的数据结构，键是唯一的，而值可以重复。

创建map一般存在三种方法,分别如下：

• 使用 make 函数创建并初始化 map

• 使用 map 字面值创建并初始化 map

• 声明并初始化 map 变量

其中第一种方法最常见，具体如下：

3.2.1 方法一¶

使用 make 函数来创建一个空的 map，并可以在初始化时指定初始键值对。make 函数的参数是 map，以及可选的容量估计值（通常不需要）。

将下面代码粘贴到00-BasicMapOperations-00.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    teacherAge["张三"] = 88 // 后面的值会覆盖前面的值
    fmt.Println("字典(对象)赋值后的值：", teacherAge)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这行代码导入了标准库中的 "fmt" 包，它提供了输入和输出的功能。

部分 2 - 主函数

func main() {
    // ...
}

main 函数是程序的入口，代码从这里开始执行。

部分 3 - 创建和初始化map

teacherAge := make(map[string]int)

这行代码使用 make 函数创建了一个空的 map，用于存储教师的姓名和年龄信息。键的类型为字符串，值的类型为整数。

部分 4 - 打印初始的空map

fmt.Println("字典(对象)初始化的值：", teacherAge)

这行代码使用 fmt.Println 函数将 "字典(对象)初始化的值：" 和空的 map 打印输出。

部分 5 - 添加键值对到map中

teacherAge["张三"] = 18
teacherAge["李四"] = 19
teacherAge["刘五"] = 20

这几行代码使用键值对方式将教师的姓名作为键，年龄作为值，依次添加到 map 中。

部分 6 - 修改已有的键的值

teacherAge["张三"] = 88 // 后面的值会覆盖前面的值

这行代码将已存在键 "张三" 的值修改为 88。在 map 中，相同的键只能有一个唯一的值。

部分 7 - 打印赋值后的map

fmt.Println("字典(对象)赋值后的值：", teacherAge)

这行代码使用 fmt.Println 函数将 "字典(对象)赋值后的值：" 和修改后的 map 打印输出。

运行上面代码

$ go run .\00-BasicMapOperations-00.go
字典(对象)初始化的值： map[]
字典(对象)赋值后的值： map[刘五:20 张三:88 李四:19]

3.2.2 方法二¶

使用 map 字面值的方式创建并初始化 map。

将下面代码粘贴到00-BasicMapOperations-01.go文件中并保存该文件

package main

import "fmt"

func main() {
    Count := map[string]int{
        "one":   1,
        "two":   2,
        "three": 3,
    }
    fmt.Println(Count)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这行代码导入了标准库中的 "fmt" 包，用于输出结果。

部分 2 - 主函数

func main() {
    // ...
}

main 函数是程序的入口，代码从这里开始执行。

部分 3 - 使用map字面值创建map

Count := map[string]int{
    "one":   1,
    "two":   2,
    "three": 3,
}

这段代码使用 map 字面值的方式创建了一个 map，其中包含了三组键值对。键的类型是字符串，值的类型是整数。

部分 4 - 打印map

fmt.Println(Count)

这行代码使用 fmt.Println 函数将创建的 map 打印输出。

运行上面代码

$ go run .\00-BasicMapOperations-01.go
map[one:1 three:3 two:2]

3.2.3 方法三¶

在声明 map 变量时同时指定其类型:

将下面代码粘贴到00-BasicMapOperations-02.go文件中并保存该文件

package main

import "fmt"

func main() {
    // 未初始化的map
    var Count map[string]int
    fmt.Println("未初始化的map: ", Count)
    // 未初始化的map不能直接使用，需要初始化
    Count = make(map[string]int) // make函数map类型必须要和var指定的map类型一致
    Count["one"] = 1
    fmt.Println("初始化后的map: ", Count)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这行代码导入了标准库中的 "fmt" 包，用于输出结果。

部分 2 - 主函数

func main() {
    // ...
}

main 函数是程序的入口，代码从这里开始执行。

部分 3 - 声明未初始化的map变量

var Count map[string]int

这行代码声明了一个未初始化的 map 变量 Count，键的类型是字符串，值的类型是整数。

部分 4 - 打印未初始化的map

fmt.Println("未初始化的 map: ", Count)

这行代码使用 fmt.Println 函数将未初始化的 map 打印输出。由于 Count 是未初始化的，其值为 nil。

部分 5 - 初始化map

Count = make(map[string]int) // make 函数的 map 类型必须与 var 指定的 map 类型一致

这行代码使用 make 函数初始化了 Count map，以便后续可以使用。这里make 函数的 map 类型必须与 var 指定的 map 类型保持一致

部分 6 - 向map添加键值对

Count["one"] = 1

这行代码将键 "one" 的值设置为 1。

部分 7 - 打印初始化的map

fmt.Println("初始化后的 map: ", Count)

这行代码使用 fmt.Println 函数将初始化后的 map 打印输出，显示键值对的内容。

运行上面代码

$ go run .\00-BasicMapOperations-02.go
未初始化的map:  map[]
初始化后的map:  map[one:1]

3.3 map操作¶

3.3.1 添加键值对¶

使用键值对方式向字典中添加数据，键和值之间使用 : 分隔。添加的键必须是字典键的类型，而值必须是字典值的类型。

将下面代码粘贴到01-BasicMapOperations-00.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    // 添加新的键值对
    teacherAge["王六"] = 88
    fmt.Println("字典(对象)添加新的键值对的值：", teacherAge)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

package main

import "fmt"

• package main：指定当前文件属于名为 "main" 的包，这是一个特殊的包名，用于表示一个可独立执行的程序。
• import "fmt"：导入了 Go 标准库中的 "fmt" 包，该包提供了格式化输入输出的功能

部分 2 - 主函数部分

func main() {

• func main()：这是程序的主函数入口。Go 语言中的每个可执行程序都必须包含一个名为 main 的函数，作为程序的起点

部分 3 - 字典的创建和初始化

    teacherAge := make(map[string]int)

• teacherAge := make(map[string]int)：创建了一个名为 teacherAge 的空字典。使用 make 函数来创建 map，第一个参数是键的类型，这里是字符串类型 string，第二个参数是值的类型，这里是整数类型 int。

部分 4 - 打印初始空字典内容

    fmt.Println("字典(对象)初始化的值：", teacherAge)

• fmt.Println("字典(对象)初始化的值：", teacherAge)：使用 fmt.Println 函数打印出初始的空字典内容。此处 teacherAge 是一个空字典，因此打印的内容为 map[]。

部分 5 - 向字典中添加键值对

    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20

• 这几行代码将不同老师的名字作为键，对应的年龄作为值，添加到了 teacherAge 字典中。

部分 6 - 向字典中添加新的键值对

    teacherAge["王六"] = 88

• 这行代码添加了一个新的键值对，将键 "王六" 和值 88 添加到了 teacherAge 字典中

部分 7 - 打印更新后的字典内容

    fmt.Println("字典(对象)添加新的键值对的值：", teacherAge)

• fmt.Println("字典(对象)添加新的键值对的值：", teacherAge)：使用 fmt.Println 函数打印出更新后的字典内容。现在字典中包含了所有的老师及其年龄信息，因此输出的内容为 map[刘五:20 张三:18 李四:19 王六:88]。

运行上面代码

$ go run .\01-BasicMapOperations-00.go
字典(对象)初始化的值： map[]
字典(对象)添加新的键值对的值： map[刘五:20 张三:18 李四:19 王六:88]

3.3.2 访问值¶

通过键访问字典中的值，如果键存在，则返回相应的值；如果键不存在，则返回值类型的零值。

将下面代码粘贴到01-BasicMapOperations-01.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    // 查看刘五对应的值
    value := teacherAge["刘五"]
    fmt.Println("字典(对象)刘五的值：", value)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

package main

import "fmt"

• package main：指定当前文件属于名为 "main" 的包，这是一个特殊的包名，用于表示一个可独立执行的程序。
• import "fmt"：导入了 Go 标准库中的 "fmt" 包，该包提供了格式化输入输出的功能

部分 2 - 主函数部分

func main() {

• func main()：这是程序的主函数入口。Go 语言中的每个可执行程序都必须包含一个名为 main 的函数，作为程序的起点

部分 3 - 字典的创建和初始化

    teacherAge := make(map[string]int)

• teacherAge := make(map[string]int)：创建了一个名为 teacherAge 的空字典。使用 make 函数来创建 map，第一个参数是键的类型，这里是字符串类型 string，第二个参数是值的类型，这里是整数类型 int。

部分 4 - 打印初始空字典内容

    fmt.Println("字典(对象)初始化的值：", teacherAge)

• fmt.Println("字典(对象)初始化的值：", teacherAge)：使用 fmt.Println 函数打印出初始的空字典内容。此处 teacherAge 是一个空字典，因此打印的内容为 map[]。

部分 5 - 向字典中添加键值对

    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20

• 这几行代码将不同老师的名字作为键，对应的年龄作为值，添加到了 teacherAge 字典中。

部分 6 - 获取特定键的值并打印

    value := teacherAge["刘五"]
    fmt.Println("字典(对象)刘五的值：", value)

• 这几行代码演示了如何从字典中获取特定键的值。使用键 "刘五" 获取了对应的值，并将其存储在变量 value 中。然后使用 fmt.Println 函数打印出了键 "刘五" 对应的值。

运行上面代码

$ go run .\01-BasicMapOperations-01.go
字典(对象)初始化的值： map[]
字典(对象)刘五的值： 20

3.3.3 修改值¶

通过键访问字典中的值，然后重新赋值来修改字典中的值。

将下面代码粘贴到01-BasicMapOperations-02.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    // 修改刘五的值为22
    teacherAge["刘五"] = 22
    value := teacherAge["刘五"]
    fmt.Println("字典(对象)刘五修改后的值：", value)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

package main

import "fmt"

• package main：指定当前文件属于名为 "main" 的包，这是一个特殊的包名，用于表示一个可独立执行的程序。
• import "fmt"：导入了 Go 标准库中的 "fmt" 包，该包提供了格式化输入输出的功能

部分 2 - 主函数部分

func main() {

• func main()：这是程序的主函数入口。Go 语言中的每个可执行程序都必须包含一个名为 main 的函数，作为程序的起点

部分 3 - 字典的创建和初始化

    teacherAge := make(map[string]int)

• teacherAge := make(map[string]int)：创建了一个名为 teacherAge 的空字典。使用 make 函数来创建 map，第一个参数是键的类型，这里是字符串类型 string，第二个参数是值的类型，这里是整数类型 int。

部分 4 - 打印初始空字典内容

    fmt.Println("字典(对象)初始化的值：", teacherAge)

• fmt.Println("字典(对象)初始化的值：", teacherAge)：使用 fmt.Println 函数打印出初始的空字典内容。此处 teacherAge 是一个空字典，因此打印的内容为 map[]。

部分 5 - 向字典中添加键值对

    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20

• 这几行代码将不同老师的名字作为键，对应的年龄作为值，添加到了 teacherAge 字典中。

部分 6 - 修改键的值

    teacherAge["刘五"] = 22

• 这行代码将键 "刘五" 对应的值从 20 修改为 22。

部分 7 - 获取修改后的键的值并打印

    value := teacherAge["刘五"]
    fmt.Println("字典(对象)刘五修改后的值：", value)

• 这几行代码演示了如何从字典中获取特定键的值。使用键 "刘五" 获取了修改后的对应值 22，并将其存储在变量 value 中。然后使用 fmt.Println 函数打印出了键 "刘五" 修改后的值。

运行上面代码

$ go run .\01-BasicMapOperations-02.go
字典(对象)初始化的值： map[]
字典(对象)刘五修改后的值： 22

3.3.4 删除键值对¶

使用 delete 函数来删除字典中的键值对，将要删除的键作为参数传递给 delete 函数。

将下面代码粘贴到01-BasicMapOperations-03.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    // 删除键值对
    delete(teacherAge, "刘五")
    fmt.Println("字典(对象)删除键值对后的值：", teacherAge)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

package main

import "fmt"

• package main：指定当前文件属于名为 "main" 的包，这是一个特殊的包名，用于表示一个可独立执行的程序。
• import "fmt"：导入了 Go 标准库中的 "fmt" 包，该包提供了格式化输入输出的功能

部分 2 - 主函数部分

func main() {

• func main()：这是程序的主函数入口。Go 语言中的每个可执行程序都必须包含一个名为 main 的函数，作为程序的起点

部分 3 - 字典的创建和初始化

    teacherAge := make(map[string]int)

• teacherAge := make(map[string]int)：创建了一个名为 teacherAge 的空字典。使用 make 函数来创建 map，第一个参数是键的类型，这里是字符串类型 string，第二个参数是值的类型，这里是整数类型 int。

部分 4 - 打印初始空字典内容

    fmt.Println("字典(对象)初始化的值：", teacherAge)

• fmt.Println("字典(对象)初始化的值：", teacherAge)：使用 fmt.Println 函数打印出初始的空字典内容。此处 teacherAge 是一个空字典，因此打印的内容为 map[]。

部分 5 - 向字典中添加键值对

    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20

• 这几行代码将不同老师的名字作为键，对应的年龄作为值，添加到了 teacherAge 字典中。

部分 6 - 删除键值对

    delete(teacherAge, "刘五")

• 这行代码使用 delete 函数从字典中删除键 "刘五" 及其对应的值

部分 7 - 打印删除键值对后的字典内容

    fmt.Println("字典(对象)删除键值对后的值：", teacherAge)

• fmt.Println("字典(对象)删除键值对后的值：", teacherAge)：使用 fmt.Println 函数打印出删除键值对后的字典内容。现在字典中不再包含键 "刘五" 及其对应的值。

运行上面代码

$ go run .\01-BasicMapOperations-03.go
字典(对象)初始化的值： map[]
字典(对象)删除键值对后的值： map[张三:18 李四:19]

3.3.5 检查键是否存在¶

在访问字典时，你可以使用第二个返回值来检查指定的键是否存在。如果存在，第二个返回值为 true，否则为 false。

将下面代码粘贴到01-BasicMapOperations-04.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    // 检查名为刘五的键是否存在
    age, people := teacherAge["刘五"]
    if people {
        fmt.Println("能查到名为刘五的键，且它对应的值：", age)
    } else {
        fmt.Println("不能查看名为刘五的键")
    }
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

package main

import "fmt"

• package main：指定当前文件属于名为 "main" 的包，这是一个特殊的包名，用于表示一个可独立执行的程序。
• import "fmt"：导入了 Go 标准库中的 "fmt" 包，该包提供了格式化输入输出的功能

部分 2 - 主函数部分

func main() {

• func main()：这是程序的主函数入口。Go 语言中的每个可执行程序都必须包含一个名为 main 的函数，作为程序的起点

部分 3 - 字典的创建和初始化

    teacherAge := make(map[string]int)

• teacherAge := make(map[string]int)：创建了一个名为 teacherAge 的空字典。使用 make 函数来创建 map，第一个参数是键的类型，这里是字符串类型 string，第二个参数是值的类型，这里是整数类型 int。

部分 4 - 打印初始空字典内容

    fmt.Println("字典(对象)初始化的值：", teacherAge)

• fmt.Println("字典(对象)初始化的值：", teacherAge)：使用 fmt.Println 函数打印出初始的空字典内容。此处 teacherAge 是一个空字典，因此打印的内容为 map[]。

部分 5 - 向字典中添加键值对

    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20

• 这几行代码将不同老师的名字作为键，对应的年龄作为值，添加到了 teacherAge 字典中。

部分 6 - 检查键是否存在并获取值

    age, people := teacherAge["刘五"]
    if people {
        fmt.Println("能查到名为刘五的键，且它对应的值：", age)
    } else {
        fmt.Println("不能查看名为刘五的键")
    }

• 这几行代码演示了如何检查字典中是否存在特定键。使用 teacherAge["刘五"] 来尝试获取键 "刘五" 对应的值，然后使用布尔值 people 来表示是否找到了该键。
• 通过一个条件语句判断是否找到了键 "刘五"，如果找到了，则使用 fmt.Println 函数打印出键 "刘五" 对应的值，否则打印出没有找到键 "刘五" 的信息。

运行上面代码

$ go run .\01-BasicMapOperations-04.go
字典(对象)初始化的值： map[]
能查到名为刘五的键，且它对应的值： 20

3.3.6 迭代map¶

使用 range 关键字可以在循环中遍历字典的键值对。在每次迭代中，range 会返回键和对应的值。

将下面代码粘贴到01-BasicMapOperations-05.go文件中并保存该文件

package main

import "fmt"

func main() {
    teacherAge := make(map[string]int)
    fmt.Println("字典(对象)初始化的值：", teacherAge)
    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20
    // 循环读取字典
    for k, v := range teacherAge {
        fmt.Printf("老师：%s,年龄：%d\n", k, v)
    }
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

package main

import "fmt"

• package main：指定当前文件属于名为 "main" 的包，这是一个特殊的包名，用于表示一个可独立执行的程序。
• import "fmt"：导入了 Go 标准库中的 "fmt" 包，该包提供了格式化输入输出的功能

部分 2 - 主函数部分

func main() {

• func main()：这是程序的主函数入口。Go 语言中的每个可执行程序都必须包含一个名为 main 的函数，作为程序的起点

部分 3 - 字典的创建和初始化

    teacherAge := make(map[string]int)

• teacherAge := make(map[string]int)：创建了一个名为 teacherAge 的空字典。使用 make 函数来创建 map，第一个参数是键的类型，这里是字符串类型 string，第二个参数是值的类型，这里是整数类型 int。

部分 4 - 打印初始空字典内容

    fmt.Println("字典(对象)初始化的值：", teacherAge)

• fmt.Println("字典(对象)初始化的值：", teacherAge)：使用 fmt.Println 函数打印出初始的空字典内容。此处 teacherAge 是一个空字典，因此打印的内容为 map[]。

部分 5 - 向字典中添加键值对

    teacherAge["张三"] = 18
    teacherAge["李四"] = 19
    teacherAge["刘五"] = 20

• 这几行代码将不同老师的名字作为键，对应的年龄作为值，添加到了 teacherAge 字典中。

部分 6 - 循环遍历字典并打印键值对

    for k, v := range teacherAge {
        fmt.Printf("老师：%s, 年龄：%d\n", k, v)
    }

• 这部分代码使用 for ... range 循环遍历字典的键值对。
• 对于每个键值对，循环将键赋值给变量 k，值赋值给变量 v，然后使用 fmt.Printf 函数打印出每位老师的名字和年龄。

运行上面代码

$ go run .\01-BasicMapOperations-05.go
字典(对象)初始化的值： map[]
老师：李四,年龄：19
老师：刘五,年龄：20
老师：张三,年龄：18

3.3.7 注意事项¶

在进行map操作时，有以下事情需要注意:

• 尝试访问字典中不存在的键会返回值类型的零值。为了区分实际值和零值，你可以使用上述的检查键是否存在的方法。
• 修改一个不存在的键会导致添加新的键值对。
• 使用 delete 函数删除一个不存在的键不会引发错误。
• 字典是无序的，迭代字典时元素的顺序不保证与添加时的顺序一致。
• 字典是引用类型，传递字典时实际传递的是指向底层数据的指针。

四、Go数据结构-数据嵌套¶

主要以下几方面介绍Go语言中数据嵌套:

• 什么是数据嵌套
• 数据嵌套示例

4.1 什么是数据嵌套¶

在Go语言中，数据嵌套通常是通过结构体（Struct）来实现的。结构体是一种自定义的数据类型，可以将不同类型的数据字段组合在一起，形成一个更复杂的数据结构。在结构体中，你可以嵌套其他结构体或内置数据类型，以创建更复杂的数据组织方式。

4.2 数据嵌套类型示例¶

4.2.1 切片嵌套对象¶

在 Go 语言中，切片嵌套对象是一种将多个对象组织成切片的数据嵌套方式。这种模式适用于需要表示多个相同类型的对象的集合，例如一组学生、员工或订单。

将下面代码粘贴到00-DataNesting-00.go文件中并保存该文件。创建了一个切片 menu，其中包含了两个字典 order1 和 order2，每个字典表示一天的菜单。然后使用循环遍历 menu 切片，输出每一天的菜单及其对应的菜名和价格。

package main

import "fmt"

func main() {
    order1 := map[string]int{
        "韭菜炒蛋": 13,
        "宫保鸡丁": 15,
    }
    order2 := map[string]int{
        "蛋汤":  11,
        "鸡蛋羹": 15,
    }
    // 切片嵌套对象
    var menu []map[string]int
    menu = append(menu, order1, order2)
    for day, order := range menu {
        fmt.Printf("第%d天的菜单是:\n", day+1)
        for dish, price := range order {
            fmt.Printf("\t菜名:%s,价格:%d\n", dish, price)
        }
    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这一部分导入了 Go 语言的标准库中的 "fmt" 包，用于格式化输出

部分 2 - 主函数

func main() {
    // 代码内容
}

这是程序的主函数，程序从这里开始执行。

部分 3 - 定义菜单对象

order1 := map[string]int{
    "韭菜炒蛋": 13,
    "宫保鸡丁": 15,
}

order2 := map[string]int{
    "蛋汤":  11,
    "鸡蛋羹": 15,
}

这里定义了两个字典，order1 和 order2，每个字典表示一天的菜单。菜名作为键，价格作为值。

部分 4 - 创建菜单切片

var menu []map[string]int
menu = append(menu, order1, order2)

这里创建了一个切片 menu，并使用 append 函数将两个字典 order1 和 order2 添加到切片中。

部分 5 - 遍历菜单切片

for day, order := range menu {
    // 循环内部的代码
}

这个循环遍历切片 menu，对于每一天的菜单，它会执行循环内部的代码。

部分 6 - 输出菜单信息

fmt.Printf("第%d天的菜单是:\n", day+1)
for dish, price := range order {
    fmt.Printf("\t菜名:%s,价格:%d\n", dish, price)
}

在循环内部，首先输出一天的菜单标题，然后通过嵌套循环遍历这一天的菜单字典，输出每个菜名和价格。

运行上面代码

$ go run .\00-DataNesting-00.go
第1天的菜单是:
        菜名:韭菜炒蛋,价格:13
        菜名:宫保鸡丁,价格:15
第2天的菜单是:
        菜名:蛋汤,价格:11
        菜名:鸡蛋羹,价格:15

4.2.2 对象嵌套对象¶

在 Go 语言中，对象（结构体）嵌套对象也是一种常见的数据嵌套方式。这种方式适用于将一个结构体嵌套在另一个结构体中，以构建更复杂的数据模型。

将下面代码粘贴到00-DataNesting-01.go文件中并保存该文件。假设有两个不同的结构体，分别是 Author（作者）和 Book（书籍）。通过对象嵌套对象的方式，将 Author 嵌套在 Book 结构体中，以表示一本书的作者信息。

package main

import "fmt"

type Author struct {
    FirstName string
    LastName  string
}

type Book struct {
    Title  string
    Year   int
    Author Author
}

func main() {
    author := Author{
        FirstName: "z",
        LastName:  "q",
    }

    book := Book{
        Title:  "从零开始学Go",
        Year:   2023,
        Author: author,
    }

    fmt.Println("本书的主题：", book.Title)
    fmt.Printf("本书的主题: %s%s\n", book.Author.FirstName, book.Author.LastName)
    fmt.Println("本书的出版年份: ", book.Year)

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这一部分导入了 Go 语言的标准库中的 "fmt" 包，用于格式化输出

部分 2 - 定义结构体

type Author struct {
    FirstName string
    LastName  string
}

type Book struct {
    Title  string
    Year   int
    Author Author
}

这里定义了两个结构体：Author 和 Book。Author 结构体包含了作者的名字和姓氏，Book 结构体表示一本书的信息，包括标题、出版年份和作者。Book 结构体中使用了嵌套结构体 Author，以表示书的作者信息。

部分 3 - 主函数

func main() {
    // 代码内容
}

这是程序的主函数，程序从这里开始执行。

部分 4 - 创建作者对象和书籍对象

author := Author{
    FirstName: "z",
    LastName:  "q",
}

book := Book{
    Title:  "从零开始学Go",
    Year:   2023,
    Author: author,
}

这部分代码创建了一个 Author 对象和一个 Book 对象。author 对象表示作者的信息，book 对象表示书籍的信息。注意，book 对象中的 Author 字段使用了 author 对象作为值，以表示书的作者信息。

部分 5 - 输出书籍信息

fmt.Println("本书的主题：", book.Title)
fmt.Printf("本书的作者: %s%s\n", book.Author.FirstName, book.Author.LastName)
fmt.Println("本书的出版年份: ", book.Year)