为什么cap不打印基础数组的长度？

Question

I am reading the A Tour of GO, in the Slice length and capacity section, I ran the example:

package main

import "fmt"

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

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

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

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

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

When I build the app and run it, it prints like this:

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

In the Go docs, the cap is the length of the underlying array, why it's value is not 6?

Answer 1

In the Go docs, the cap is the length of the underlying array, why it's value is not 6?

Because the capacity is not the size of the backing array (there may be special cases when they are equal, but in general they are not). When a slice is created by slicing a backing array, using 0 for the low index (or omitting it), and the array length for the high index (or omitting it), then yes, the capacity will be equal to the array's length.

Spec: Length and capacity:

The capacity of a slice is the number of elements for which there is space allocated in the underlying array.

So the capacity starts at the first element of the slice, and if that is not the same as the first element of the backing array, they won't be equal. This is also stated explicitly in the Tour page you linked:

The capacity of a slice is the number of elements in the underlying array, counting from the first element in the slice.

There is also a full slice expression which has the form of:

a[low : high : max]

Where you can control the resulting slice's capacity, you can limit how far future slicing may extend the slice. The max index may point to an element before the last element of the array.

See this example:

a := [10]int{}

s := a[:] // len=10, cap=10
fmt.Printf("len=%d, cap=%d
", len(s), cap(s))

s = a[2:] // len=8, cap=8
fmt.Printf("len=%d, cap=%d
", len(s), cap(s))

s = a[2:7] // len=5, cap=8
fmt.Printf("len=%d, cap=%d
", len(s), cap(s))

s = a[2:7:8] // len=5, cap=6
fmt.Printf("len=%d, cap=%d
", len(s), cap(s))

Outputs (try it on the Go Playground):

len=10, cap=10
len=8, cap=8
len=5, cap=8
len=5, cap=6