GO语言基础笔记（三）：复合类型

        深入学习Go语言中的复合类型：数组、切片、映射（Map）和结构体。这些类型是构建复杂数据结构和实现复杂逻辑的基础。

目录

1. 数组（Array）

 遍历数组

多维数组

数组作为函数参数 

2. 切片（Slice）

切片的长度和容量

添加元素到切片

切片的切片操作

使用make创建切片 

多维切片 

遍历切片 

3. 映射（Map）

检索映射中的元素

删除映射中的元素

使用make创建映射

遍历映射

4. 结构体（Struct）

结构体作为函数参数

使用指针操作结构体

定义结构体的方法

---

1. 数组（Array）

• 定义：数组是具有相同类型元素的固定长度序列。
• 声明方式：var arr [n]Type，其中n是数组的长度，Type是存储元素的类型。
• 特点：长度固定，一旦声明，长度不能改变。

var arr [5]int
arr[0] = 1
fmt.Println(arr) // 输出：[1 0 0 0 0]

 遍历数组

    // 使用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)
    }

多维数组

    // 声明一个二维数组
    var matrix [2][3]int
    matrix[0] = [3]int{1, 2, 3}
    matrix[1] = [3]int{4, 5, 6}
    fmt.Println("二维数组:", matrix)

数组作为函数参数 

    // 数组作为函数参数
    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，切片不需要指定长度。
• 特点：长度可变，可以动态地增长或缩短。

slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice) // 输出：[1 2 3 4]

切片的长度和容量

    // 使用len和cap函数
    fmt.Println("长度:", len(slice2), "容量:", cap(slice2))

添加元素到切片

    // 添加元素到切片
    slice2 = append(slice2, 6)
    fmt.Println("添加元素后的切片:", slice2)

切片的切片操作

    // 创建切片的切片
    subSlice := slice2[1:3]
    fmt.Println("切片的切片:", subSlice)

使用make创建切片 

    // 使用make创建切片
    slice3 := make([]int, 3) // 长度为3的切片
    fmt.Println("使用make创建的切片:", slice3)

多维切片 

    // 创建一个二维切片
    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)

遍历切片 

    // 使用for range遍历切片
    for index, value := range slice2 {
        fmt.Printf("索引：%d, 值：%d\n", index, value)
    }
}

3. 映射（Map）

• 定义：映射是存储键值对的无序集合。
• 声明方式：var mapVar map[KeyType]ValueType。
• 特点：键唯一，通过键快速检索对应的值。

m := make(map[string]int)
m["key1"] = 7
m["key2"] = 13
fmt.Println(m) // 输出：map[key1:7 key2:13]

检索映射中的元素

    // 检索键值对
    age, ok := map2["Alice"]
    if ok {
        fmt.Println("Alice的年龄:", age)
    } else {
        fmt.Println("Alice不在映射中")
    }

删除映射中的元素

    // 删除键值对
    delete(map2, "Bob")
    fmt.Println("删除Bob后的映射:", map2)

使用make创建映射

    // 使用make创建映射
    map3 := make(map[string]int)
    map3["Dave"] = 28
    fmt.Println("使用make创建的映射:", map3)

遍历映射

    // 使用for range遍历映射
    for key, value := range map2 {
        fmt.Printf("键：%s, 值：%d\n", key, value)
    }
}

4. 结构体（Struct）

• 定义：结构体是一种聚合数据类型，它将不同类型的数据聚合到一个复合类型中。
• 声明方式：type StructName struct { Field1 Type1; Field2 Type2; ... }。
• 特点：非常适合用来创建数据模型。

type Person struct {
    Name string
    Age  int
}

var p Person
p.Name = "Alice"
p.Age = 30
fmt.Println(p) // 输出：{Alice 30}

结构体作为函数参数

    // 调用函数，传递结构体作为参数
    printPerson(person1)
    printPerson(person2)
}

// 函数接受一个Person类型的参数
func printPerson(p Person) {
    fmt.Printf("%s is %d years old.\n", p.Name, p.Age)
}

使用指针操作结构体

    // 使用指针修改结构体
    changeName(&person1, "Alice Cooper")
    fmt.Println("Updated Person 1:", person1)
}

// 函数接受一个指向Person的指针，并修改其中的字段
func changeName(p *Person, newName string) {
    p.Name = newName
}

定义结构体的方法

// Person类型的方法
func (p Person) Greet() {
    fmt.Println("Hi, my name is", p.Name)
}

func main() {
    person1 := Person{Name: "Alice", Age: 30}
    person1.Greet() // 调用Person的方法
}