Why Can Go Slices Be Sliced Up To Their Length, Not Just Their Capacity?

Why Can Slices Be Sliced Up to the Length of the Underlying Array in Go?

Go arrays and slices provide convenient ways to work with data collections. One particular behavior that may seem surprising is the ability to slice a slice up to its length instead of its capacity. To understand this, let's delve into the Go specification.

According to the Slice Expressions section of the Go spec, for arrays or strings, indices are considered in range if they satisfy the following condition:

0 <= low <= high <= len(a)

If the indices fall outside this range, they are considered out of range. However, for slices, the upper index bound is the slice capacity, denoted by cap(a), as opposed to the length, denoted by len(a).

This means that the following slicing operations on a slice a are allowed up to len(a) inclusive:

a[0:]
a[1:]
a[2:]

In these cases, the resulting slices start at index 0 and have lengths of 0, 1, and 2, respectively.

However, slicing beyond the length of a results in a panic:

a[3:] // Doesn't panic (empty slice)
a[4:] // Panics

The a[3:] slicing doesn't panic because the index 3 is within the range [0, len(a)], even though it results in an empty slice. On the other hand, a[4:] panics because the index 4 is out of range, where range is defined as [0, len(a)).

Thus, Go allows slicing up to the length of the underlying array because the specification explicitly states that the upper index bound for slices is defined by the capacity rather than the length. This behavior enables convenient slicing operations without causing unintended panics in common scenarios.

The above is the detailed content of Why Can Go Slices Be Sliced Up To Their Length, Not Just Their Capacity?. For more information, please follow other related articles on the PHP Chinese website!