深入学习Go语言中的复合类型：数组、切片、映射（Map）和结构体。这些类型是构建复杂数据结构和实现复杂逻辑的基础。
目录
[1. 数组（Array）](#1. 数组（Array）)
[2. 切片（Slice）](#2. 切片（Slice）)
[3. 映射（Map）](#3. 映射（Map）)
[4. 结构体（Struct）](#4. 结构体（Struct）)
1. 数组（Array）
- 定义：数组是具有相同类型元素的固定长度序列。
- 声明方式 ：
var arr [n]Type，其中n是数组的长度，Type是存储元素的类型。 - 特点：长度固定，一旦声明，长度不能改变。
Go
var arr [5]int
arr[0] = 1
fmt.Println(arr) // 输出：[1 0 0 0 0]遍历数组
Go
// 使用for循环遍历数组
for i := 0; i < len(arr2); i++ {
fmt.Printf("arr2[%d] = %d\n", i, arr2[i])
}
// 使用for range遍历数组
for index, value := range arr2 {
fmt.Printf("索引：%d, 值：%d\n", index, value)
}多维数组
Go
// 声明一个二维数组
var matrix [2][3]int
matrix[0] = [3]int{1, 2, 3}
matrix[1] = [3]int{4, 5, 6}
fmt.Println("二维数组:", matrix)数组作为函数参数
Go
// 数组作为函数参数
sum := sumArray(arr2)
fmt.Println("数组和:", sum)
}
// 函数接受一个整型数组作为参数
func sumArray(arr [5]int) int {
sum := 0
for _, value := range arr {
sum += value
}
return sum
}2. 切片（Slice）
- 定义：切片是对数组的封装，提供更灵活、更强大的序列接口。
- 声明方式 ：
var slice []Type，切片不需要指定长度。 - 特点：长度可变，可以动态地增长或缩短。
Go
slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice) // 输出：[1 2 3 4]切片的长度和容量
Go
// 使用len和cap函数
fmt.Println("长度:", len(slice2), "容量:", cap(slice2))添加元素到切片
Go
// 添加元素到切片
slice2 = append(slice2, 6)
fmt.Println("添加元素后的切片:", slice2)切片的切片操作
Go
// 创建切片的切片
subSlice := slice2[1:3]
fmt.Println("切片的切片:", subSlice)使用make创建切片
Go
// 使用make创建切片
slice3 := make([]int, 3) // 长度为3的切片
fmt.Println("使用make创建的切片:", slice3)多维切片
Go
// 创建一个二维切片
twoDSlice := make([][]int, 3)
for i := 0; i < 3; i++ {
innerLen := i + 1
twoDSlice[i] = make([]int, innerLen)
for j := 0; j < innerLen; j++ {
twoDSlice[i][j] = i + j
}
}
fmt.Println("二维切片:", twoDSlice)遍历切片
Go
// 使用for range遍历切片
for index, value := range slice2 {
fmt.Printf("索引：%d, 值：%d\n", index, value)
}
}3. 映射（Map）
- 定义：映射是存储键值对的无序集合。
- 声明方式 ：
var mapVar map[KeyType]ValueType。 - 特点：键唯一，通过键快速检索对应的值。
Go
m := make(map[string]int)
m["key1"] = 7
m["key2"] = 13
fmt.Println(m) // 输出：map[key1:7 key2:13]检索映射中的元素
Go
// 检索键值对
age, ok := map2["Alice"]
if ok {
fmt.Println("Alice的年龄:", age)
} else {
fmt.Println("Alice不在映射中")
}删除映射中的元素
Go
// 删除键值对
delete(map2, "Bob")
fmt.Println("删除Bob后的映射:", map2)使用make创建映射
Go
// 使用make创建映射
map3 := make(map[string]int)
map3["Dave"] = 28
fmt.Println("使用make创建的映射:", map3)遍历映射
Go
// 使用for range遍历映射
for key, value := range map2 {
fmt.Printf("键：%s, 值：%d\n", key, value)
}
}4. 结构体（Struct）
- 定义：结构体是一种聚合数据类型，它将不同类型的数据聚合到一个复合类型中。
- 声明方式 ：
type StructName struct { Field1 Type1; Field2 Type2; ... }。 - 特点：非常适合用来创建数据模型。
Go
type Person struct {
Name string
Age int
}
var p Person
p.Name = "Alice"
p.Age = 30
fmt.Println(p) // 输出：{Alice 30}结构体作为函数参数
Go
// 调用函数，传递结构体作为参数
printPerson(person1)
printPerson(person2)
}
// 函数接受一个Person类型的参数
func printPerson(p Person) {
fmt.Printf("%s is %d years old.\n", p.Name, p.Age)
}使用指针操作结构体
Go
// 使用指针修改结构体
changeName(&person1, "Alice Cooper")
fmt.Println("Updated Person 1:", person1)
}
// 函数接受一个指向Person的指针，并修改其中的字段
func changeName(p *Person, newName string) {
p.Name = newName
}定义结构体的方法
Go
// Person类型的方法
func (p Person) Greet() {
fmt.Println("Hi, my name is", p.Name)
}
func main() {
person1 := Person{Name: "Alice", Age: 30}
person1.Greet() // 调用Person的方法
}