MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Go语言切片定义与高效使用

2023-01-126.5k 阅读

Go 语言切片基础

在 Go 语言中，切片（slice）是一种重要的数据结构，它基于数组类型进行了一层封装。切片提供了动态的、灵活的数组功能，使得在编程过程中处理一系列同类型数据更加方便。

切片的定义

切片的定义语法如下：

var identifier []type

其中，identifier 是切片变量名，type 是切片中元素的类型。例如，定义一个整数类型的切片：

var numbers []int

这里定义了一个名为 numbers 的切片，它可以存放 int 类型的数据。需要注意的是，此时 numbers 是一个空切片，它的值为 nil，且长度为 0。

也可以在定义切片时初始化它：

var numbers = []int{1, 2, 3}

这样就创建了一个包含三个整数的切片 numbers。

另外，还可以通过 make 函数来创建切片：

numbers := make([]int, 5)

这里使用 make 函数创建了一个长度为 5 的 int 类型切片 numbers。make 函数的第一个参数是切片的类型，第二个参数是切片的长度。如果需要指定切片的容量（capacity），可以传入第三个参数：

numbers := make([]int, 5, 10)

这表示创建了一个长度为 5，容量为 10 的 int 类型切片。容量表示切片在不重新分配内存的情况下最多可以容纳的元素个数。

切片的长度和容量

切片有两个重要的属性：长度（length）和容量（capacity）。可以使用 len 函数获取切片的长度，使用 cap 函数获取切片的容量。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := make([]int, 5, 10)
    fmt.Printf("Length: %d\n", len(numbers))
    fmt.Printf("Capacity: %d\n", cap(numbers))
}

运行上述代码，输出结果为：

Length: 5
Capacity: 10

切片的长度是指当前切片中实际包含的元素个数，而容量是指从切片的起始位置到其底层数组末尾的元素个数。

访问切片元素

可以通过索引来访问切片中的元素，索引从 0 开始。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3}
    fmt.Println(numbers[0])
    fmt.Println(numbers[1])
    fmt.Println(numbers[2])
}

上述代码会依次输出切片 numbers 中的三个元素：1、2、3。

如果尝试访问超出切片长度的索引，会导致运行时错误。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3}
    fmt.Println(numbers[3])
}

运行这段代码会报错：panic: runtime error: index out of range [3] with length 3。

切片的操作

切片的追加

在 Go 语言中，使用 append 函数可以向切片中追加元素。append 函数的定义如下：

func append(slice []Type, elems ...Type) []Type

其中，slice 是要追加元素的切片，elems 是要追加的元素，可以是多个。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3}
    numbers = append(numbers, 4)
    fmt.Println(numbers)
}

上述代码将数字 4 追加到了切片 numbers 中，输出结果为：[1 2 3 4]。

如果追加元素后，切片的长度超过了其容量，Go 语言会自动重新分配内存，创建一个更大的底层数组，并将原切片的内容复制到新数组中。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := make([]int, 0, 3)
    numbers = append(numbers, 1)
    numbers = append(numbers, 2)
    numbers = append(numbers, 3)
    numbers = append(numbers, 4)
    fmt.Println(numbers)
    fmt.Printf("Length: %d\n", len(numbers))
    fmt.Printf("Capacity: %d\n", cap(numbers))
}

在上述代码中，初始创建的切片 numbers 容量为 3，当追加到第 4 个元素时，容量会自动扩大。运行结果如下：

[1 2 3 4]
Length: 4
Capacity: 6

可以看到，容量从 3 变为了 6。通常，当切片容量不足时，新的容量会变为原来的两倍（如果原来的容量小于 1024）。如果原来的容量大于或等于 1024，新的容量会增加原来容量的 1/4。

切片的截取

切片可以通过截取操作获取一个新的切片。截取操作使用 : 符号，语法如下：

slice[start:end]

其中，start 是截取的起始索引（包含），end 是截取的结束索引（不包含）。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    subNumbers := numbers[1:3]
    fmt.Println(subNumbers)
}

上述代码从切片 numbers 中截取了索引 1 到 2 的元素，得到新的切片 subNumbers，输出结果为：[2 3]。

如果省略 start，则默认从切片的起始位置开始截取：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    subNumbers := numbers[:3]
    fmt.Println(subNumbers)
}

输出结果为：[1 2 3]。

如果省略 end，则截取到切片的末尾：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    subNumbers := numbers[2:]
    fmt.Println(subNumbers)
}

输出结果为：[3 4 5]。

切片的复制

使用 copy 函数可以将一个切片的内容复制到另一个切片中。copy 函数的定义如下：

func copy(dst, src []Type) int

其中，dst 是目标切片，src 是源切片。copy 函数返回实际复制的元素个数。例如：

package main

import (
    "fmt"
)

func main() {
    source := []int{1, 2, 3}
    destination := make([]int, 3)
    n := copy(destination, source)
    fmt.Println(destination)
    fmt.Println("Copied elements:", n)
}

上述代码将切片 source 的内容复制到切片 destination 中，输出结果为：

[1 2 3]
Copied elements: 3

需要注意的是，如果目标切片的长度小于源切片的长度，copy 函数只会复制目标切片长度的元素个数。例如：

package main

import (
    "fmt"
)

func main() {
    source := []int{1, 2, 3}
    destination := make([]int, 2)
    n := copy(destination, source)
    fmt.Println(destination)
    fmt.Println("Copied elements:", n)
}

输出结果为：

[1 2]
Copied elements: 2

切片与底层数组

切片是基于数组实现的，每个切片都指向一个底层数组。切片包含三个部分：指向底层数组的指针、切片的长度和切片的容量。

底层数组的共享

当通过截取操作创建新的切片时，新切片和原切片会共享底层数组。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    subNumbers := numbers[1:3]
    subNumbers[0] = 20
    fmt.Println(numbers)
}

在上述代码中，修改 subNumbers 切片的第一个元素，会影响到原切片 numbers，输出结果为：[1 20 3 4 5]。这是因为 subNumbers 和 numbers 共享同一个底层数组。

切片扩容对底层数组的影响

当切片进行追加操作导致容量不足时，会重新分配内存，创建一个新的底层数组，并将原切片的内容复制到新数组中。此时，原切片和新切片不再共享底层数组。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := make([]int, 0, 3)
    numbers = append(numbers, 1)
    numbers = append(numbers, 2)
    numbers = append(numbers, 3)
    subNumbers := numbers[:2]
    numbers = append(numbers, 4)
    subNumbers[0] = 20
    fmt.Println(numbers)
    fmt.Println(subNumbers)
}

在上述代码中，首先创建了一个容量为 3 的切片 numbers，然后截取得到 subNumbers。当向 numbers 追加第 4 个元素时，容量不足，会重新分配内存。此时，修改 subNumbers 的第一个元素，不会影响到 numbers。输出结果为：

[1 2 3 4]
[20 2]

高效使用切片

预分配容量

在创建切片时，如果能够预先知道切片可能需要的最大容量，通过 make 函数指定容量可以避免多次重新分配内存，提高性能。例如，假设要创建一个包含 1000 个整数的切片：

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()
    numbers := make([]int, 0, 1000)
    for i := 0; i < 1000; i++ {
        numbers = append(numbers, i)
    }
    elapsed := time.Since(start)
    fmt.Printf("Time taken: %s\n", elapsed)
}

如果不预先分配容量：

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()
    var numbers []int
    for i := 0; i < 1000; i++ {
        numbers = append(numbers, i)
    }
    elapsed := time.Since(start)
    fmt.Printf("Time taken: %s\n", elapsed)
}

通过对比这两段代码的运行时间，可以发现预先分配容量的代码运行速度更快。这是因为不预先分配容量时，每次追加元素都可能导致底层数组重新分配内存，而预先分配容量可以减少这种开销。

避免不必要的切片复制

在函数调用中，如果传递的切片较大，应该尽量避免在函数内部对切片进行复制操作，因为复制切片会增加内存开销和时间开销。例如：

package main

import (
    "fmt"
)

func modifySlice(slice []int) {
    newSlice := make([]int, len(slice))
    copy(newSlice, slice)
    newSlice[0] = 100
}

func main() {
    numbers := []int{1, 2, 3}
    modifySlice(numbers)
    fmt.Println(numbers)
}

在上述代码中，modifySlice 函数复制了传入的切片 numbers，然后修改了复制后的切片。这样做不仅增加了内存开销，而且对原切片 numbers 没有影响。如果想要直接修改原切片，可以直接操作传入的切片：

package main

import (
    "fmt"
)

func modifySlice(slice []int) {
    slice[0] = 100
}

func main() {
    numbers := []int{1, 2, 3}
    modifySlice(numbers)
    fmt.Println(numbers)
}

这样就避免了不必要的切片复制，提高了效率。

及时释放不再使用的切片

当切片不再使用时，应该及时释放其占用的内存。可以通过将切片置为 nil 来实现，这样垃圾回收器就可以回收底层数组占用的内存。例如：

package main

import (
    "fmt"
)

func main() {
    numbers := make([]int, 1000000)
    // 使用 numbers 切片
    numbers = nil
    // 此时 numbers 切片占用的内存可以被垃圾回收器回收
    fmt.Println("Slice set to nil")
}

及时释放不再使用的切片，可以避免内存泄漏，提高程序的内存使用效率。

切片在并发编程中的应用

在 Go 语言的并发编程中，切片也有着广泛的应用。

共享切片的并发访问问题

当多个 goroutine 并发访问和修改同一个切片时，可能会出现数据竞争问题。例如：

package main

import (
    "fmt"
    "sync"
)

var numbers []int
var wg sync.WaitGroup

func addNumber() {
    defer wg.Done()
    numbers = append(numbers, 1)
}

func main() {
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go addNumber()
    }
    wg.Wait()
    fmt.Println(len(numbers))
}

在上述代码中，多个 goroutine 同时向 numbers 切片中追加元素，可能会导致数据竞争。运行这段代码，可能会得到小于 10 的结果。

使用互斥锁解决并发访问问题

为了解决共享切片并发访问的问题，可以使用互斥锁（sync.Mutex）。例如：

package main

import (
    "fmt"
    "sync"
)

var numbers []int
var mu sync.Mutex
var wg sync.WaitGroup

func addNumber() {
    defer wg.Done()
    mu.Lock()
    numbers = append(numbers, 1)
    mu.Unlock()
}

func main() {
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go addNumber()
    }
    wg.Wait()
    fmt.Println(len(numbers))
}

在上述代码中，通过 mu.Lock() 和 mu.Unlock() 对 numbers 切片的追加操作进行加锁和解锁，保证了同一时间只有一个 goroutine 可以修改切片，从而避免了数据竞争问题。

使用通道（channel）处理切片数据

通道是 Go 语言中用于 goroutine 之间通信的重要机制。在处理切片数据时，可以使用通道来避免共享切片带来的并发问题。例如，假设有一个切片需要在多个 goroutine 中进行处理：

package main

import (
    "fmt"
    "sync"
)

func processNumber(number int, wg *sync.WaitGroup) {
    defer wg.Done()
    // 处理 number
    fmt.Println("Processing number:", number)
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup
    ch := make(chan int)

    for _, number := range numbers {
        wg.Add(1)
        go func(num int) {
            ch <- num
            processNumber(num, &wg)
        }(number)
    }

    go func() {
        wg.Wait()
        close(ch)
    }()

    for number := range ch {
        // 这里可以对从通道接收的 number 进行进一步处理
        fmt.Println("Received number from channel:", number)
    }
}

在上述代码中，通过通道 ch 来传递切片中的元素，每个 goroutine 从通道中接收元素并进行处理，避免了共享切片的并发问题。

总结切片的要点

切片是 Go 语言中非常重要的数据结构，它具有动态、灵活的特点。在使用切片时，要注意以下几点：

  1. 合理定义和初始化切片，根据需求选择合适的定义方式和预分配容量。
  2. 注意切片的长度和容量的变化，特别是在追加元素时。
  3. 了解切片与底层数组的关系，避免因共享底层数组导致的意外数据修改。
  4. 在并发编程中，要妥善处理切片的并发访问问题，可以使用互斥锁或通道来保证数据的一致性。

通过深入理解切片的原理和高效使用方法，可以写出更加健壮、高效的 Go 语言程序。希望本文对您理解和使用 Go 语言切片有所帮助。