切片 (Slice)

什么是切片

切片是 Go 语言中最重要的数据结构之一,它是对数组的抽象。切片提供了动态数组的功能,比固定大小的数组更灵活。

切片的声明和初始化

1. 声明切片

var slice []int                    // 声明一个 int 类型的切片,零值为 nil
var slice = []int{}               // 声明并初始化为空切片
slice := []int{1, 2, 3, 4, 5}     // 声明并初始化切片

2. 使用 make 函数创建切片

slice := make([]int, 5)           // 长度为 5,容量为 5
slice := make([]int, 5, 10)       // 长度为 5,容量为 10

3. 从数组创建切片

arr := [6]int{1, 2, 3, 4, 5, 6}
slice := arr[1:4]                 // 从索引 1 到 3(不包含 4)

切片的基本操作

1. 访问和修改元素

slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice[0])             // 访问第一个元素
slice[0] = 10                     // 修改第一个元素

2. 追加元素

slice := []int{1, 2, 3}
slice = append(slice, 4)          // 追加单个元素
slice = append(slice, 5, 6, 7)    // 追加多个元素
slice = append(slice, []int{8, 9}...) // 追加另一个切片

3. 复制切片

src := []int{1, 2, 3, 4, 5}
dst := make([]int, len(src))
copy(dst, src)                    // 将 src 复制到 dst

4. 切片操作

slice := []int{1, 2, 3, 4, 5}
subSlice := slice[1:4]            // [2, 3, 4]
prefix := slice[:3]               // [1, 2, 3]
suffix := slice[2:]               // [3, 4, 5]

切片的内部结构

切片由三个部分组成:

  • 指针:指向底层数组的指针

  • 长度:切片中元素的数量

  • 容量:从切片开始位置到底层数组结束的元素数量

slice := make([]int, 5, 10)
fmt.Printf("长度: %d, 容量: %d\n", len(slice), cap(slice)) // 长度: 5, 容量: 10

实际应用示例

package main

import "fmt"

func main() {
    // 动态添加学生成绩
    scores := []int{}
    scores = append(scores, 85, 92, 78, 96, 88)

    // 计算平均分
    total := 0
    for _, score := range scores {
        total += score
    }
    average := float64(total) / float64(len(scores))

    fmt.Printf("平均分: %.2f\n", average)

    // 找出高于平均分的成绩
    var highScores []int
    for _, score := range scores {
        if float64(score) > average {
            highScores = append(highScores, score)
        }
    }

    fmt.Printf("高于平均分的成绩: %v\n", highScores)
}

 

切片 (Slice)

1. 切片基础

切片声明和初始化

// 声明切片
var numbers []int

// 使用 make 创建切片
numbers = make([]int, 5)    // 长度为5,容量为5
numbers = make([]int, 3, 5) // 长度为3,容量为5

// 切片字面量
fruits := []string{"apple", "banana", "orange"}

// 从数组创建切片
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4] // [2, 3, 4]

切片操作

func sliceOperations() {
    numbers := []int{1, 2, 3, 4, 5}
    
    // 长度和容量
    fmt.Printf("Length: %d, Capacity: %d\n", len(numbers), cap(numbers))
    
    // 添加元素
    numbers = append(numbers, 6, 7, 8)
    
    // 切片操作
    subset := numbers[2:5] // [3, 4, 5]
    
    // 复制切片
    copySlice := make([]int, len(numbers))
    copy(copySlice, numbers)
}

2. 切片高级操作

切片扩容机制

func demonstrateGrowth() {
    slice := make([]int, 0, 1)
    
    for i := 0; i < 10; i++ {
        fmt.Printf("Before append: len=%d, cap=%d\n", len(slice), cap(slice))
        slice = append(slice, i)
        fmt.Printf("After append: len=%d, cap=%d\n", len(slice), cap(slice))
    }
}

切片作为函数参数

func modifySlice(s []int) {
    s[0] = 100 // 修改原切片
}

func appendToSlice(s []int) []int {
    return append(s, 999) // 返回新切片
}

// 使用示例
numbers := []int{1, 2, 3}
modifySlice(numbers)
fmt.Println(numbers) // [100, 2, 3]

newNumbers := appendToSlice(numbers)
fmt.Println(newNumbers) // [100, 2, 3, 999]
作者:admin  创建时间:2025-09-23 22:26
最后编辑:admin  更新时间:2025-09-23 22:28