Does Go slicing operator allocate new underlying array?

I was reading this article which explains how slices in Go are implemented under the hood:
https://medium.com/swlh/golang-tips-why-pointers-to-slices-are-useful-and-how-ignoring-them-can-lead-to-tricky-bugs-cac90f72e77b

At the end of the article is this snippet of Go code:

func main() {
    slice:= make([]string, 1, 3)
  
    func(slice []string){
        slice=slice[1:3]
        slice[0]="b"
        slice[1]="b"
        fmt.Print(len(slice))
        fmt.Print(slice)
    }(slice)
    fmt.Print(len(slice)) 
    fmt.Print(slice)
}

My first guess was this would print:

2 [b b]3 [ b b]

In fact it prints:

2[b b]1[]

Which suggests that when anonymous function creates a new local slice by slicing the one passed to it as argument causes a new underlying array to be allocated for the slice. I've confirmed this with this modified version of code:

func main() {
	slice := make([]string, 1, 3)

	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
	fmt.Printf("adress of underlying array in main: %p\n", unsafe.Pointer(hdr.Data))

	func(slice []string) {
		hdr := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
		fmt.Printf("adress of underlying array in func before slicing: %p\n", unsafe.Pointer(hdr.Data))
		slice = slice[1:3]
		slice[0] = "b"
		slice[1] = "b"
		hdr = (*reflect.SliceHeader)(unsafe.Pointer(&slice))
		fmt.Printf("adress of underlying array in func after slicing: %p\n", unsafe.Pointer(hdr.Data))
		fmt.Print(len(slice))
		fmt.Println(slice)
	}(slice)
	fmt.Print(len(slice))
	fmt.Println(slice)
}

Which prints:

adress of underlying array in main: 0xc0000121b0
adress of underlying array in func before slicing: 0xc0000121b0
adress of underlying array in func after slicing: 0xc0000121c0
2[b b]
1[]

My question is: why is the slicing operation in anonymous function causing a new array to be allocated? My understanding was that if in main we are creating a slice with capacity 3, an underlying array with length 3 is created and when anonymous function is manipulating the slice, it is manipulating the same underlying array.

As mkopriva mentioned, the reslicing does not reallocate anything. Reallocation happens only when appending new values would exceed the slice's capacity (source).

The output you got is because the elements you are "able to see" in a slice (including when you print it) depend on its length:

> The number of elements is called the length of the slice and is never negative. [...] The length of a slice s can be discovered by the built-in function len;

The original slice constructed with slice := make([]string, 1, 3), has length=1, so when you print it, the output will be the one element at position 0 of the backing array, which is an empty string.

With this code:

slice = slice[1:3]
slice[0] = "b"
slice[1] = "b"

you are effectively mutating the elements at position 1 and 2 of the backing array, none of which is an element of the original slice.

If you reslice the original slice up to capacity — thus extending its length, it will print what you expect:

	slice = slice[:cap(slice)]
	fmt.Println(len(slice)) // 3
	fmt.Println(slice)      // [ b b]
                            //  ^ first is empty string