in Golang, what's the different between `array[:]` and `[]slice{array[0],array[1],...}` ？

I'd love to know why, please give me a little hint.

I want to append an array into res, the res is a Two-dimensional slice. So I need convert first.
When I convert an array into a slice, there is a bug.

// I need a map to remove duplicates
mm := map[[3]int]bool{}
mm[[3]int{-1, -1, 2}] = true
mm[[3]int{-1, -1, 2}] = true
mm[[3]int{-1, 0, 1}] = true

var res [][]int
for k, _ := range mm {
	res = append(res, k[:])
}
fmt.Printf("the res is %v\n", res)

the res is [[-1 0 1] [-1 0 1]]

But the result is not what I want.

then I tentatively modified the for loop a bit

for k, _ := range mm {
	//res = append(res, k[:])
	res = append(res, []int{k[0], k[1], k[2]})
}

the res is [[-1 0 1] [-1 -1 2]]

now the result is right, but why?
What's the different between k[:] and []int{k[0],k[1],k[2]}?

Change the loop to

for k, _ := range mm {
	j := k
	res = append(res, j[:])
}

Your original loop declares a variable k of type [3]int, which has a particular location in memory. Every iteration of the loop, a different key from map mm is copied to that variable. So far, so good.

When you convert it to a slice using k[:], it creates a slice header that points to the array k. It goes wrong here - the next iteration of the loop, the value of k gets overwritten. All slices created in the loop point to the same backing array k at the same location in memory.

By copying the value of k first to a variable that was declared inside the loop, you give each slice its own backing array, and you avoid the problem.

> The Go Programming Language Specification
>
> For statements
>
> For statements with range clause
>
> The iteration variables may be declared by the "range" clause using a form of short variable declaration (:=). In this case their types are set to the types of the respective iteration values and their scope is the block of the "for" statement; they are re-used in each iteration.

Adding the k := k statement shadows the re-used iteration variable k with a local variable k for each iteration.

package main

import "fmt"

func main() {
    mm := map[[3]int]bool{}
    mm[[3]int{-1, -1, 2}] = true
    mm[[3]int{-1, -1, 2}] = true
    mm[[3]int{-1, 0, 1}] = true
    fmt.Println(mm)

    var res [][]int
    for k, _ := range mm {
	    k := k
	    res = append(res, k[:])
    }
    fmt.Println(res)
}

https://go.dev/play/p/4BdXzdThxXd

map[[-1 -1 2]:true [-1 0 1]:true]
[[-1 -1 2] [-1 0 1]]