CODEWITHSUNDEEP
goslice
Pizzas
Pizzas

Reputation: 479

Decreasing slice capacity

My question is about slice length and capacity. I'm learning about Go here: https://tour.golang.org/moretypes/11.

(My question was marked as a possible duplicate of this; however, this is not the case. My question is specifically about the cutting off the first few elements of a slice and the implications of that.)

Why does the line s = s[2:] decrease the capacity when s = s[:4] and s = s[:0] do not? The only difference I see is that there is a number before the colon in s = s[2:] while there is a number after the colon in the other two lines.

Is there any way to recover the first two elements that we cut off with s = s[2:]?

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\n", len(s), cap(s), s)
}

After clicking the Run button, we get the following.

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]

Upvotes: 41

Views: 9428

Answers (3)

zangw
zangw

Reputation: 48366

The slices.Clip of "golang.org/x/exp/slices" could reduce the capacity of slice through Full slice expressions.

Clip removes unused capacity from the slice, returning s[:len(s):len(s)].

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

    s = s[:4]
    printSlice(s)

    s = slices.Clip(s)
    printSlice(s)

}

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

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

Playground

Upvotes: 0

Zombo
Zombo

Reputation: 1

You can use a full slice expression:

package main

func main() {
   s := []int{2, 3, 5, 7, 11, 13}
   { // example 1
      t := s[:0]
      println(cap(t) == 6)
   }
   { // example 2
      t := s[:0:0]
      println(cap(t) == 0)
   }
}

https://golang.org/ref/spec#Slice_expressions

Upvotes: 2

Alex Efimov
Alex Efimov

Reputation: 3703

You can read more about slices here. But I think this passage answers your question:

Slicing does not copy the slice's data. It creates a new slice value that points to the original array. This makes slice operations as efficient as manipulating array indices. Therefore, modifying the elements (not the slice itself) of a re-slice modifies the elements of the original slice.

So you cannot recover the slice data if you are assigning it to the same variable.

The capacity decrease is because by dropping the first 2 elements you are changing the pointer to the new slice (slices are referenced by the pointer to the first element).

How slices are represented in the memory: def

make([]byte, 5)

memory vis

s = s[2:4]

slice cap decrease

Upvotes: 37

Related Questions