第3章：Go语言复合数据类型

第3章：Go语言复合数据类型

1. 数组

1.1 数组声明和初始化

// 方式1：声明固定长度数组
var numbers [5]int  // 声明一个包含5个整数的数组，默认零值

// 方式2：初始化数组
arr1 := [5]int{1, 2, 3, 4, 5}  // 完全初始化

// 方式3：部分初始化
arr2 := [5]int{1, 2}  // 前两个元素为1,2，其余为0

// 方式4：自动推断数组长度
arr3 := [...]int{1, 2, 3, 4, 5}  // 长度自动计算为5

// 方式5：指定索引初始化
arr4 := [5]int{1: 10, 3: 30}  // 索引1和3位置赋值，其他为0

1.2 数组遍历

// 方式1：传统for循环
numbers := [5]int{10, 20, 30, 40, 50}
for i := 0; i < len(numbers); i++ {
    fmt.Printf("索引 %d: %d\n", i, numbers[i])
}

// 方式2：range遍历
for index, value := range numbers {
    fmt.Printf("索引 %d: %d\n", index, value)
}

// 只需要值，忽略索引
for _, value := range numbers {
    fmt.Println(value)
}

2. 切片（Slice）

2.1 切片的创建和使用

// 方式1：从数组创建切片
arr := [5]int{1, 2, 3, 4, 5}
slice1 := arr[1:4]  // 包含索引1到3的元素

// 方式2：直接创建切片
slice2 := []int{1, 2, 3, 4, 5}

// 方式3：使用make创建
slice3 := make([]int, 5)       // 长度为5的切片
slice4 := make([]int, 5, 10)   // 长度5，容量10的切片

2.2 切片操作

// 添加元素
slice := []int{1, 2, 3}
slice = append(slice, 4)        // 添加单个元素
slice = append(slice, 5, 6, 7)  // 添加多个元素

// 复制切片
src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src)

// 删除元素
slice = append(slice[:2], slice[3:]...)  // 删除索引2的元素

// 切片截取
subSlice := slice[1:4]  // 获取子切片

2.3 动态扩展

// 自动扩容机制
slice := []int{}
for i := 0; i < 20; i++ {
    slice = append(slice, i)
    fmt.Printf("长度：%d, 容量：%d\n", len(slice), cap(slice))
}

3. Map

3.1 Map的声明和初始化

// 方式1：使用make创建
ages := make(map[string]int)
ages["Alice"] = 25
ages["Bob"] = 30

// 方式2：直接初始化
scores := map[string]int{
    "Math":    90,
    "English": 85,
}

// 检查键是否存在
value, exists := scores["Math"]
if exists {
    fmt.Println("找到值:", value)
}

3.2 Map增删改查

// 添加和修改
users := map[string]string{}
users["admin"] = "password"  // 添加
users["admin"] = "newpass"   // 修改

// 删除
delete(users, "admin")

// 遍历
for key, value := range users {
    fmt.Printf("%s: %s\n", key, value)
}

4. 结构体

4.1 结构体定义

// 基本结构体定义
type Person struct {
    Name string
    Age  int
}

// 创建结构体实例
alice := Person{
    Name: "Alice",
    Age:  25,
}

// 匿名结构体
student := struct {
    Name string
    Age  int
}{
    Name: "Bob",
    Age:  20,
}

4.2 方法和接收者

// 值接收者方法
func (p Person) Introduce() string {
    return fmt.Sprintf("我是%s，今年%d岁", p.Name, p.Age)
}

// 指针接收者方法
func (p *Person) Birthday() {
    p.Age++
}

// 使用方法
alice := Person{Name: "Alice", Age: 25}
fmt.Println(alice.Introduce())
alice.Birthday()

4.3 结构体嵌套

// 匿名嵌套
type Employee struct {
    Person  // 匿名嵌套
    Company string
}

// 有名字的嵌套
type Company struct {
    employee Person
    Address  string
}

// 使用
emp := Employee{
    Person:  Person{Name: "Charlie", Age: 30},
    Company: "Google",
}
fmt.Println(emp.Name)  // 可以直接访问嵌套结构体的字段

4.4 结构体标签（tag）

// 结构体标签
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}