golang切片的盖子与透镜

Question

Go语言中切片的cap和len有什么区别？

根据定义：

切片既有长度也有容量。

切片的长度是它包含的元素数。

切片的容量是底层数组中的元素数，从切片中的第一个元素开始计数。

x := make([]int, 0, 5) // len(b)=0, cap(b)=5

len是否仅表示非空值？

Answer 1

简单的解释Slice是自增长形式的数组，所以有两个主要属性。

Length是切片所具有的元素总数（），可用于循环遍历我们存储在切片中的元素。同样，当我们打印切片时，所有元素都被打印出来，直到长度被打印出来。

容量是基础数组中没有元素的总数，当您附加更多元素时，长度将增加，直到容量。在这之后，任何进一步附加到切片的操作都会导致容量自动增加（大约是原来的两倍），并且长度不会增加附加的元素数。

真正神奇的是，当你从一个切片中切出子切片时，所有实际的读/写都发生在底层数组上。因此，子切片中的任何变化也将改变原始切片和底层数组中的数据。其中任何子切片都可以有自己的长度和容量。

仔细阅读下面的程序。其修改版本的Go语言游览示例

package main

import "fmt"

func main() {
    sorig := []int{2, 3, 5, 7, 11, 13}
    printSlice(sorig)

    // Slice the slice to give it zero length.
    s := sorig[:0]
    printSlice(s)

    // Extend its length.
    s = s[:4]
    s[2] = 555
    printSlice(s)

    // Drop its first two values.
    s = s[2:]
    printSlice(s)
    
    printSlice(sorig)
}

func printSlice(s []int) {
    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)

//Output
//len=6 cap=6 [2 3 5 7 11 13]
//len=0 cap=6 []
//len=4 cap=6 [2 3 555 7]
//len=2 cap=4 [555 7]
//len=6 cap=6 [2 3 555 7 11 13]

Answer 2

从源代码：

// The len built-in function returns the length of v, according to its type:
//  Array: the number of elements in v.
//  Pointer to array: the number of elements in *v (even if v is nil).
//  Slice, or map: the number of elements in v; if v is nil, len(v) is zero.
//  String: the number of bytes in v.
//  Channel: the number of elements queued (unread) in the channel buffer;
//  if v is nil, len(v) is zero.
func len(v Type) int

// The cap built-in function returns the capacity of v, according to its type:
//  Array: the number of elements in v (same as len(v)).
//  Pointer to array: the number of elements in *v (same as len(v)).
//  Slice: the maximum length the slice can reach when resliced;
//  if v is nil, cap(v) is zero.
//  Channel: the channel buffer capacity, in units of elements;
//  if v is nil, cap(v) is zero.
func cap(v Type) int

Answer 3

切片是一种在封面下使用数组的抽象。

cap告诉您底层阵列的容量len告诉您数组中有多少项。

Go中的切片抽象非常好，因为它会为你调整底层数组的大小，另外在Go中数组不能调整大小，所以切片几乎总是被使用。

例子：

s := make([]int, 0, 3)
for i := 0; i < 5; i++ {
    s = append(s, i)
    fmt.Printf("cap %v, len %v, %p\n", cap(s), len(s), s)
}

将输出如下内容：

cap 3, len 1, 0x1040e130
cap 3, len 2, 0x1040e130
cap 3, len 3, 0x1040e130
cap 6, len 4, 0x10432220
cap 6, len 5, 0x10432220

如您所见，一旦容量满足，append将返回一个容量更大的新切片。在第四次迭代中，您会注意到一个更大的容量和新的指针地址。

以身作则

我知道您没有询问数组和追加，但它们是理解切片和内置原因的基础。