GO语言基础教程（47）Go复合数据类型：Go语言复合类型深度社交图鉴：数组太死板？切片才是真·社交达人！-优快云博客

朋友们，码农们！举起你们的键盘，今天我们来聊点Go语言里真正让程序变得“有血有肉”的东西——复合数据类型。

你可能会想：“数据类型？不就是int,string那些吗？我早就会了。” 嗯，如果说那些基本类型是独行侠，那复合数据类型就是一个超级社团。想象一下，你一个人去吃饭，这叫string name = “你”；但当你需要组织一个部门团建，你就需要一个花名册，这就是复合数据类型的作用——把多个数据项打包成一个整体来管理。

Go语言里有四位主要的“社团领袖”：数组、切片、Map和结构体。它们性格迥异，各有各的社交法则。搞懂它们，你就能在Go世界里混得风生水起。

第一位：数组（Array）——规则严苛的“老干部”

数组，是编程界的老古董，作风严谨，一丝不苟。

它的社交名片：

特点： 长度固定，类型统一。一旦声明了长度，就不能再改变。
口头禅： “我们团就这么多人，一个不能多，一个不能少。”

这就像你定了一个10人的餐桌，来了第11个人？对不起，没他的位置，门口站着去。

完整代码示例：感受一下老干部的作风

package main

import "fmt"

func main() {
    // 声明一个长度为3的字符串数组，像分配了3个固定座位
    var team [3]string
    team[0] = "张三" // 第一位
    team[1] = "李四" // 第二位
    team[2] = "王五" // 第三位
    // team[3] = "赵六" // 放开这行会报错：数组越界！因为只有3个座位。

    fmt.Println("我们的团队阵容：", team) // 输出：[张三 李四 王五]

    // 更常见的写法：直接初始化
    luckyNumbers := [5]int{2, 4, 8, 16, 32}
    fmt.Println("幸运数字是：", luckyNumbers)

    // 让编译器自己数数组长度
    autoLength := [...]string{"苹果", "香蕉", "橙子"}
    fmt.Println("水果数量：", len(autoLength)) // 输出：3
}

深度分析：
数组的优点是性能好，因为内存是连续分配的，CPU读起来快。但它的致命缺点就是不灵活。在需要动态增减成员的场景下（比如处理用户上传的文件列表），数组就显得力不从心了。所以，在现代的Go代码中，数组直接出场的机会不多，它更多是作为一位幕后大佬，因为……

第二位：切片（Slice）——八面玲珑的“社交达人”

切片，是Go语言中最常用、最核心的复合类型，没有之一。它本质上是一个**“动态数组”**，或者说是对数组的一个“灵活视图”。

它的社交名片：

特点： 长度可变，基于数组或直接创建。拥有长度(len)和容量(cap)两个属性。
口头禅： “地方不够？咱再扩一扩！人少了？咱就缩一缩！”

这就像一个可以随时加座、撤座的超级大包间。来多少人，咱都能安排！

完整代码示例：看看达人是如何社交的

package main

import "fmt"

func main() {
    // 方法1：基于数组“切”出一片
    array := [5]int{1, 2, 3, 4, 5}
    slice1 := array[1:4] // 切出 [2, 3, 4] , 注意是左闭右开区间
    fmt.Println("从数组切出来的：", slice1)

    // 方法2：直接使用make函数创建
    slice2 := make([]int, 3, 5) // 创建一个切片，初始长度3，容量5
    slice2[0] = 10
    slice2[1] = 20
    slice2[2] = 30
    // slice2[3] = 40 // 这里会报错，因为当前长度只到2
    fmt.Printf("slice2: len=%d, cap=%d, %v\n", len(slice2), cap(slice2), slice2)

    // 方法3：最常用的直接初始化
    shoppingCart := []string{"牛奶", "面包", "鸡蛋"}
    fmt.Println("购物车：", shoppingCart)

    // 切片的看家本领：动态追加
    shoppingCart = append(shoppingCart, "咖啡")
    fmt.Println("追加后：", shoppingCart)

    // 甚至可以一次性追加多个元素
    shoppingCart = append(shoppingCart, "芝士", "水果")
    fmt.Println("再追加：", shoppingCart)

    // 容量不够时，切片会自动扩容（通常是翻倍），这个过程对我们是透明的，太省心了！
    for i := 0; i < 10; i++ {
        shoppingCart = append(shoppingCart, fmt.Sprintf("商品%d", i))
        fmt.Printf("长度：%d, 容量：%d\n", len(shoppingCart), cap(shoppingCart))
    }
}

深度分析：
切片内部有三个东西：一个指针（指向底层数组）、长度（当前有多少元素）和容量（最大能放多少元素）。当你用append追加元素，如果容量够，就直接放；如果不够，Go就会悄悄地申请一块更大的内存，把老数据复制过去，然后继续追加。这个“自动扩容”的特性，让它成为了处理动态数据集合的绝对主力。

记住：在Go里，99%的情况下，你用的都是切片，而不是数组。

第三位：映射（Map）——秒回信息的“活字典”

Map，也叫字典或哈希表。它是键(Key)-值(Value)对的无敌组合。

它的社交名片：

特点： 通过唯一的键，可以瞬间找到对应的值。查找速度极快，时间复杂度接近O(1)。
口头禅： “你报名字，我秒回他电话！”

这就像一个公司的通讯录，你不需要知道张三坐在第几排第几个，你只需要输入“张三”，系统立刻告诉你他的分机号。

完整代码示例：体验一下秒回的快感

package main

import "fmt"

func main() {
    // 声明并初始化一个map，键是string，值是int
    studentScores := map[string]int{
        "张三": 90,
        "李四": 85,
        "王五": 95,
    }
    fmt.Println("原始成绩单：", studentScores)

    // 增/改：简单粗暴，直接赋值
    studentScores["赵六"] = 88 // 新增
    studentScores["李四"] = 92 // 修改
    fmt.Println("更新后成绩单：", studentScores)

    // 查：通过键来访问值
    score, exists := studentScores["张三"]
    if exists {
        fmt.Printf("张三的成绩是：%d\n", score)
    } else {
        fmt.Println("查无此人！")
    }

    // 另一种写法，更紧凑
    if score, ok := studentScores["孙七"]; ok {
        fmt.Printf("孙七的成绩是：%d\n", score)
    } else {
        fmt.Println("孙七还没录入成绩。")
    }

    // 删：使用delete函数
    delete(studentScores, "王五")
    fmt.Println("删除王五后：", studentScores)

    // 遍历map (顺序是随机的！)
    fmt.Println("--- 遍历开始 ---")
    for name, score := range studentScores {
        fmt.Printf("%s -> %d\n", name, score)
    }
    fmt.Println("--- 遍历结束 ---")
}

深度分析：
Map的键必须是可比较的类型（比如int, string, 数组等，但不能是切片、函数、Map）。它的高效来自于哈希函数，通过计算键的哈希值，直接定位到数据存储的位置，所以无论这个Map有多大，查找速度都几乎一样快。但切记，遍历Map的顺序是不确定的，别指望它每次都能按你插入的顺序输出。

第四位：结构体（Struct）——事无巨细的“档案管理员”

如果说前面三位管理的都是同质化的数据（一堆数字、一堆字符串），那结构体就是来管理不同类型的数据的。

它的社交名片：

特点： 将多个不同类型的字段（Field）组合成一个单一的、有意义的复合类型。
口头禅： “关于这个人的所有信息，都在这张表上了。”

这就像一份员工档案，里面有姓名（字符串）、工号（整数）、生日（时间类型）、在职状态（布尔值）等等。

完整代码示例：创建一份个人档案

package main

import (
    "fmt"
    "time"
)

// 使用`type`和`struct`关键字定义一个结构体类型，名为Person
type Person struct {
    Name      string
    Age       int
    Height    float64
    IsStudent bool
    BirthDate time.Time
}

func main() {
    // 方法1：按字段顺序初始化（不推荐，容易出错）
    p1 := Person{"张三", 20, 175.5, true, time.Date(2003, 5, 1, 0, 0, 0, 0, time.UTC)}
    fmt.Printf("p1: %+v\n", p1) // %+v 可以打印出字段名，非常方便

    // 方法2：使用字段名指定值初始化（推荐！清晰明了）
    p2 := Person{
        Name:      "李四",
        Age:       25,
        Height:    180.0,
        IsStudent: false,
        BirthDate: time.Date(1998, 10, 15, 0, 0, 0, 0, time.UTC),
    }
    fmt.Printf("p2: %+v\n", p2)

    // 方法3：先声明，再逐个字段赋值
    var p3 Person
    p3.Name = "王五"
    p3.Age = 30
    p3.IsStudent = false
    // 没有赋值的字段，会是其类型的零值（如Height是0.0）
    fmt.Printf("p3: %+v\n", p3)

    // 访问和修改结构体的字段
    p2.Age = 26 // 李四过生日了，年龄+1
    fmt.Printf("李四更新后的年龄：%d\n", p2.Age)

    // 结构体可以包含其他结构体，实现复杂的数据模型
    type Address struct {
        City, ZipCode string
    }
    type Employee struct {
        PersonInfo Person
        WorkAddr   Address
        Salary     int
    }

    employee := Employee{
        PersonInfo: p2,
        WorkAddr:   Address{City: "北京", ZipCode: "100000"},
        Salary:     15000,
    }
    fmt.Printf("员工完整信息：%+v\n", employee)
    fmt.Printf("他在%s工作\n", employee.WorkAddr.City) // 访问嵌套结构的字段
}

深度分析：
结构体是Go语言面向对象编程的基石。通过组合结构体，你可以构建出非常复杂的数据模型，比如一本书、一辆车、一个订单。它让代码的逻辑变得非常清晰，数据管理井井有条。后面你会学到为结构体定义方法，那它就真正变成了一个拥有数据和行为的“对象”了。