如何在 Go 中清除切片？

Question

Go 中清除切片的正确方法是什么？

这是我在 go 论坛中找到的内容：

// test.go
package main

import (
    "fmt"
)

func main() {
    letters := []string{"a", "b", "c", "d"}
    fmt.Println(cap(letters))
    fmt.Println(len(letters))
    // clear the slice
    letters = letters[:0]
    fmt.Println(cap(letters))
    fmt.Println(len(letters))
}

这是正确的吗？

澄清一下，缓冲区已被清除，因此可以重新使用。

一个例子是 bytes 包中的 Buffer.Truncate 函数。

注意 Reset 仅调用 Truncate(0)。因此，在这种情况下，第 70 行将计算： b.buf = b.buf[0:0]

http://golang.org/src/pkg/bytes/buffer.go

// Truncate discards all but the first n unread bytes from the buffer.
60  // It panics if n is negative or greater than the length of the buffer.
61  func (b *Buffer) Truncate(n int) {
62      b.lastRead = opInvalid
63      switch {
64      case n < 0 || n > b.Len():
65          panic("bytes.Buffer: truncation out of range")
66      case n == 0:
67          // Reuse buffer space.
68          b.off = 0
69      }
70      b.buf = b.buf[0 : b.off+n]
71  }
72  
73  // Reset resets the buffer so it has no content.
74  // b.Reset() is the same as b.Truncate(0).
75  func (b *Buffer) Reset() { b.Truncate(0) }

Answer 1

将切片设置为

nil

是清除切片的最佳方法。 Go 中的

nil

切片表现得非常好，将切片设置为

nil

会将底层内存释放给垃圾收集器。

看游乐场

package main

import (
    "fmt"
)

func dump(letters []string) {
    fmt.Println("letters = ", letters)
    fmt.Println(cap(letters))
    fmt.Println(len(letters))
    for i := range letters {
        fmt.Println(i, letters[i])
    }
}

func main() {
    letters := []string{"a", "b", "c", "d"}
    dump(letters)
    // clear the slice
    letters = nil
    dump(letters)
    // add stuff back to it
    letters = append(letters, "e")
    dump(letters)
}

打印

letters =  [a b c d]
4
4
0 a
1 b
2 c
3 d
letters =  []
0
0
letters =  [e]
1
1
0 e

请注意，切片可以很容易地使用别名，以便两个切片指向相同的底层内存。设置为

nil

将消除该锯齿。

此方法将容量更改为零。

Answer 2

这完全取决于您对“清晰”的定义是什么。其中有效的肯定是：

slice = slice[:0]

但是有一个问题。如果切片元素的类型为 T：

var slice []T

然后强制

len(slice)

为零，通过上述“技巧”，不会 使

的任何元素

slice[:cap(slice)]

有资格进行垃圾收集。在某些情况下，这可能是最佳方法。但这也可能是“内存泄漏”的原因 - 内存未使用，但可能可达（重新切片“切片”后），因此不是垃圾“可收集”。

Answer 3

我出于自己的目的对这个问题进行了一些研究；我有一个结构体切片（包括一些指针），我想确保我做对了；最终出现在这个帖子上，并想分享我的结果。

为了练习，我做了一点 go Playground： https://play.golang.org/p/9i4gPx3lnY

相当于：

package main

import "fmt"

type Blah struct {
    babyKitten int
    kittenSays *string
}

func main() {
    meow := "meow"
    Blahs := []Blah{}
    fmt.Printf("Blahs: %v\n", Blahs)
    Blahs = append(Blahs, Blah{1, &meow})
    fmt.Printf("Blahs: %v\n", Blahs)
    Blahs = append(Blahs, Blah{2, &meow})
    fmt.Printf("Blahs: %v\n", Blahs)
    //fmt.Printf("kittenSays: %v\n", *Blahs[0].kittenSays)
    Blahs = nil
    meow2 := "nyan"
    fmt.Printf("Blahs: %v\n", Blahs)
    Blahs = append(Blahs, Blah{1, &meow2})
    fmt.Printf("Blahs: %v\n", Blahs)
    fmt.Printf("kittenSays: %v\n", *Blahs[0].kittenSays)
}

按原样运行该代码将显示“meow”和“meow2”变量相同的内存地址：

Blahs: []
Blahs: [{1 0x1030e0c0}]
Blahs: [{1 0x1030e0c0} {2 0x1030e0c0}]
Blahs: []
Blahs: [{1 0x1030e0f0}]
kittenSays: nyan

我认为这证实了该结构已被垃圾收集。奇怪的是，取消注释打印行，将为喵喵产生不同的内存地址：

Blahs: []
Blahs: [{1 0x1030e0c0}]
Blahs: [{1 0x1030e0c0} {2 0x1030e0c0}]
kittenSays: meow
Blahs: []
Blahs: [{1 0x1030e0f8}]
kittenSays: nyan

我认为这可能是由于打印以某种方式被推迟（？），但是一些内存管理行为的有趣说明，并且再投一票：

[]MyStruct = nil

Answer 4

Go 1.21（2023 年第 3 季度）将提出一个新的内置关键字：

clear()

问题 56351 包括 以下文档：

内置函数

clear

采用map、slice或type参数类型作为参数，并删除或清零所有元素。

的零值

致电	参数类型	结果>
clear(m)	map[K]T	删除所有条目，导致空 map (len(m) == 0)
clear(s)	[]T	将 s 长度内的所有元素设置为 T
clear(t)	输入参数	见下文>

如果参数类型是类型参数，则其类型集中的所有类型都必须是映射或切片，并且

clear

执行与实际类型参数对应的操作。

如果地图或切片是

nil

，则

clear

是无操作。

Answer 5

2023更新

在Go 1.21中你可以使用clear函数：

https://tip.golang.org/ref/spec#Clear