去切片-结束时不要惊慌[重复]

Why does this code work? Specifically, the lines that reference the slice range a[5:] and return a zero length slice? Both the length and the capacity are reported as five, yet referencing a sixth non-existent element does not cause a panic:

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4, 5}
    fmt.Println(a, "Len(a)=", len(a), "Cap(a)=", cap(a))

    fmt.Println(a[4]) // Works as expected
    // fmt.Println(a[5]) // XXX-runtime error:index out of range
    fmt.Println(a[5:]) // Works--returns a zero-length slice--but why?

    a = append(a[:4], a[5:]...)
    fmt.Println(a, "Len(a)=", len(a), "Cap(a)=", cap(a))

}

Go Playground: https://play.golang.org/p/7evt4Y0ADD3

In Go Slice - difference between [:n] and [n:] the explanation is that the underlying array is actually longer than the slice, so accessing the range a[5:] is simply accessing the longer array. But when you run this code you'll see that the length and capacity of the slice is actually reported as 5. And if you uncomment the reference to a[5] you'll see that does cause a panic as expected.

Can I count on this behavior or am I running into a specification/compiler bug that could be fixed in a future release?

</div>

This is expected behavior; slice[cap(slice):] refers to a zero-length slice at the end of slice. Per the spec:

For arrays or strings, the indices are in range if 0 <= low <= high <= len(a), otherwise they are out of range. For slices, the upper index bound is the slice capacity cap(a) rather than the length.

Note that it is <= len(a), not < len(a); an index equal to the length/capacity is allowed per the specification.