【Go】Go语言切片（Slice）深度剖析与应用实战-CSDN博客

本文链接：https://blog.csdn.net/qq_42978535/article/details/142653960

Go语言的切片（slice）是一个非常强大和灵活的内置数据结构，它使得对动态数组的操作变得更加简单和高效。切片不仅能够存储元素的序列，还提供了丰富的操作接口。在本文中，我们将深入剖析 Go 切片的特性、用法及其应用场景，并通过实际案例进行演示。

一、什么是切片（Slice）

切片是 Go 语言中用于表示一组元素的动态数组，它是一种引用类型，提供对数组部分的灵活视图。与数组不同的是，切片可以动态增长，且在内存中表现得更为高效。

1.1 切片的基本结构

一个切片包含以下三个基本属性：

指针（Pointer）：指向切片所引用的底层数组的首地址。
长度（Length）：切片中元素的数量。
容量（Capacity）：切片底层数组的长度，从切片的起始位置到底层数组的末尾。

二、切片的创建

2.1 使用 `make` 函数创建切片

package main

import "fmt"

func main() {
    // 使用 make 函数创建一个切片，长度为 5，容量为 10
    slice1 := make([]int, 5, 10)
    fmt.Println("Slice1:", slice1)
    fmt.Println("Length:", len(slice1))
    fmt.Println("Capacity:", cap(slice1))
}

输出：

Slice1: [0 0 0 0 0]
Length: 5
Capacity: 10

2.2 使用字面量创建切片

package main

import "fmt"

func main() {
    // 使用字面量创建切片
    slice2 := []int{1, 2, 3, 4, 5}
    fmt.Println("Slice2:", slice2)
    fmt.Println("Length:", len(slice2))
    fmt.Println("Capacity:", cap(slice2))
}

输出：

Slice2: [1 2 3 4 5]
Length: 5
Capacity: 5

三、切片的操作

3.1 访问和修改切片元素

package main

import "fmt"

func main() {
    slice := []string{"apple", "banana", "cherry"}
    fmt.Println("Original Slice:", slice)

    // 访问元素
    fmt.Println("First Element:", slice[0])

    // 修改元素
    slice[1] = "blueberry"
    fmt.Println("Modified Slice:", slice)
}

输出：

Original Slice: [apple banana cherry]
First Element: apple
Modified Slice: [apple blueberry cherry]

3.2 切片的追加

使用内置的 append 函数向切片中添加元素。append 函数返回一个新的切片。

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    fmt.Println("Original Slice:", slice)

    // 追加元素
    slice = append(slice, 4, 5)
    fmt.Println("After Append:", slice)
}

输出：

Original Slice: [1 2 3]
After Append: [1 2 3 4 5]

3.3 切片的切割

使用切片语法可以从已有切片中生成新的切片。

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5, 6}
    newSlice := slice[1:4]  // 从索引1到索引4（不包括索引4）
    fmt.Println("New Slice:", newSlice)
}

输出：

New Slice: [2 3 4]

四、切片的特性

4.1 切片的共享底层数组

切片是引用类型，多个切片可以共享同一个底层数组。

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    slice1 := original[0:3]  // [1, 2, 3]
    slice2 := original[1:4]  // [2, 3, 4]

    // 修改 slice1
    slice1[0] = 100
    fmt.Println("Original Array after slice1 modification:", original) // [100 2 3 4 5]
    fmt.Println("Slice2:", slice2) // [2 3 4]
}

输出：

Original Array after slice1 modification: [100 2 3 4 5]
Slice2: [2 3 4]

4.2 切片的容量增长

当向切片中追加元素时，如果超过了切片的容量，会自动扩容，底层数组的大小会加倍。

package main

import "fmt"

func main() {
    slice := make([]int, 0, 2)
    fmt.Println("Initial Capacity:", cap(slice))

    for i := 0; i < 10; i++ {
        slice = append(slice, i)
        fmt.Printf("After Append %d, Capacity: %d\n", i, cap(slice))
    }
}

输出：

Initial Capacity: 2
After Append 0, Capacity: 2
After Append 1, Capacity: 2
After Append 2, Capacity: 4
After Append 3, Capacity: 4
After Append 4, Capacity: 8
After Append 5, Capacity: 8
After Append 6, Capacity: 8
After Append 7, Capacity: 8
After Append 8, Capacity: 16
After Append 9, Capacity: 16

五、切片的应用场景

5.1 数组转切片

在实际开发中，数组和切片常常需要相互转换。

package main

import "fmt"

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    slice := array[:]
    fmt.Println("Slice from Array:", slice)
}

5.2 函数参数使用切片

切片作为函数参数，方便传递多个值。

package main

import "fmt"

func sum(numbers []int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    slice := []int{1, 2, 3, 4, 5}
    fmt.Println("Sum:", sum(slice))
}