Golang showing different capacities when slicing something differently

I'm trying to understand slices in Go, and have came across the following code ( Go playground ):

package main

import "fmt"

func main() {
	s := []int{1, 2, 3, 4, 5, 6}
	example1(s)
	fmt.Printf("\n")
	example2(s)
}

func example1(s []int) {
	fmt.Printf("Example 1: \n")
	printSlice(s)

	s = s[:4]
	printSlice(s)
}

func example2(s []int) {
	fmt.Printf("Example 2: \n")
	printSlice(s)

	s = s[2:]
	printSlice(s)
}

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

For which the output is:

Example 1: 
len=6 cap=6 [1 2 3 4 5 6]
len=4 cap=6 [1 2 3 4]

Example 2: 
len=6 cap=6 [1 2 3 4 5 6]
len=4 cap=4 [3 4 5 6]

While the length of the slices looks alright, what I don't undertand is why the capacity after slicing is 6 in the first example and 4 in the second example.

The capacity of the slice is the number of elements that can be stored in the underlying array starting at the beginning of the slice. Your underlying array can store 6 elements. In example1, you create a new slice starting at the first element and extending for 4 elements, but the capacity is still 6 because your slice starts at the beginning of the underlying array. In example2, the slice starts at element 2 of the underlying array, so there's only room for 4 more elements, so the capacity is 4.

This article gives a good explanation of how slices work.