Learning Golang: Easy way to remember a slice’s capacity

I’m learning Golang since last week. Figured I’ll learn a language that’s not similar to Ruby and Javascript. Decided to go with go as it seems to have good adoption, which means “GO JOBS ARE AVAILABLE”.

While learning about slices, the notion of capacity was difficult for me to understand.

But then I had an “oh-shit-yup-makes-sense-now” moment about how to think about the capacity.

Capacity of a slice is defined as:

The capacity of a slice is the number of elems in the underlying array, counting from the 1st elem in the slice.

Given this slice/array (and this helper-function):

s := []int{2, 3, 5, 7, 11, 13}


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

We can create various slices out of this slice s.

But first, the len and cap of the original slice s:

// len: 6, cap: 6
// op: [2 3 5 7 11 13]
printSlice(s)

It has 6 items in slice. So its len is 6 and its cap is 6.

Wait, how’s the cap 6?

Ok, here’s the “oh-shit-yup-makes-sense-now” moment this post is all about.

A slice’s capacity depends only upon the start index of the slice. Ignore the end index while calculating the capacity.

Here’s the formula version of it:

slice’s capacity = underlying array’s length - slice’s start index

Using this, you can calculate (and visualize) the capacity easily.

Here are various slices created out of the original slice s above.

  // zero-length: can be extended
  s1 := s[:0]
  // len: 0, cap: 6 
  // has no elems, but can be extended to hold (all) 6 items
  // op: []
  printSlice(s1)
  // capacity is 6 because of the formula:
  // capacity = len(s) - start-index-of-slice
  // capacity = 6 - 0 = 6


  // zero-length: CANNOT be extended
  s4 := s[6:]
  // len: 0, cap: 0
  // has no elems, and can't be extended too
  // op: []
  printSlice(s4)
  // capacity = len(s) - start-index-of-slice
  // capacity = 6 - 6 = 0


  // extending
  s2 := s[:4]
  // len: 4, cap: 6
  // has 4 elems (from idx 0 till idx 3),
  // and can be extended to hold a total of (all) 6 items
  // op: [2 3 5 7]
  printSlice(s2)
  // capacity = len(s) - start-index-of-slice
  // capacity = 6 - 0 = 6
  // (notice that the end index 4 has nothing to do with this)


  // shortening
  s3 := s[2:]
  // len: 4, cap: 4 
  // has 4 elems after the 2nd item. Can only hold a total of 4 items.
  // (can't extend to left. only right is allowed)
  // op: [5 7 11 13]
  printSlice(s3)
  // capacity = len(s) - start-index-of-slice
  // capacity = 6 - 2 = 4

The end.