go - 在 Go 中分配 slice 与重新声明 slice

Question

我正在尝试将 slice 用作队列数据结构，并且我想出了这个实现，这会导致无限循环。这是因为 queue slice 没有用子 slice queue[1:] 更新。

func badQueue() {
    queue := []int{0,1,2,3,4,5}
    for len(queue) > 0 {
        current, queue := queue[0], queue[1:]
        fmt.Println(current, queue)
    }
}

0 [1 2 3 4 5]
0 [1 2 3 4 5]
0 [1 2 3 4 5]
0 [1 2 3 4 5]
0 [1 2 3 4 5]
...

我发现问题与我重新声明 current 和 queue(使用 :=)有关而不是分配值，这解决了问题:

func goodQueue() {
    queue := []int{0,1,2,3,4,5}
    var current int
    for len(queue) > 0 {
        current, queue = queue[0], queue[1:]
        fmt.Println(current, queue)
    }
}

0 [1 2 3 4 5]
1 [2 3 4 5]
2 [3 4 5]
3 [4 5]
4 [5]
5 []

我知道导致问题的原因，但我不完全理解为什么在这种情况下重新声明操作与分配的工作方式不同。为什么队列没有用队列的子片(queue[1:])重新声明？

谢谢!

Answer 1

因为你可以有多个同名的变量，只要它们的作用域不同。内部作用域中的变量将遮蔽外部作用域中的变量。

所以如果我们分解你的例子

func badQueue() {
    // queue from outer scope, lets call it A
    queue := []int{0,1,2,3,4,5}
    // the only visible queue here is A, so len(queue) will always refer to A
    for len(queue) > 0 {
        // same thing here, the only visible queue is A, so queue[0] and queue[1:]
        // both refer to A
        // We are also declaring new variables, queue and current
        // This queue is now shadowing the outer queue, let's call this one B
        current, queue := queue[0], queue[1:]

        // Here queue will refer to B
        fmt.Println(current, queue)

        // When the current iteration of the loop ends current and queue B is destroyed
        // because they go out of scope and the loop start over with A unchanged
    }
}