上一篇文章 说说 Go 语言 for-range 的坑 说的是 for-range 的，工作中，其实还是遇到蛮多奇奇怪怪的问题，这里也顺便整理了一下，就当作是续集：）

先继续看 for-range 的另一个坑：

下面代码输出什么？

func main() {
    var a = []int{1, 2, 3, 4, 5}
    var r = make([]int, 0)

    for i, v := range a {
        if i == 0 {
            a = append(a, 6, 7)
        }
        r = append(r, v)
    }
    fmt.Println(r)
}

答案：[1 2 3 4 5]。
剖析：for range 后跟的都是值拷贝。所以 a 在遍历的时候，新增了 6 和 7 两个元素，但是 range a 是使用 a 的副本参与循环，副本的 len = 5，所以 r = [1 2 3 4 5]，也就是只获取到 a 的底层数组的前 5 个元素。

OK，相信你看懂了。那这道题呢？

func main() {
    var a = [5]int{1, 2, 3, 4, 5}
    var r [5]int
    for i, v := range a {
        if i == 0 {
            a[1] = 12
            a[2] = 13
        }
        r[i] = v
    }
    fmt.Println("r = ", r)
    fmt.Println("a = ", a)
}

答案：r=[1 2 3 4 5]，a=[1 12 13 4 5]。
剖析：原理同上，range a 此时会复制数组 a，但如果 a 的定义为切片，var a = []int{1, 2, 3, 4, 5}，最终的输出，r 和 a 就是一样的了，都是 [1 12 13 4 5]。

最后一行输出什么？

func main() {
    x := 1
    fmt.Println(x)
    {
        fmt.Println(x)
        i, x := 2, 2
        fmt.Println(i, x)
    }
    fmt.Println(x) // print ?
}

答案：1。
知识点：变量隐藏。
剖析：使用变量简短声明符号 := 时，符号左边多个变量，只需保证至少有一个变量是新声明的，并对已定义的变量尽进行赋值操作。但如果出现作用域，会导致变量隐藏的问题。如果你使用 Goland，你会发现 x 变量，变成了另一种颜色，也就是说这两个变量不一样，因为作用域不一样。
小结：非常常见，又十分隐秘的坑。

下面代码输出什么？

func main() {
    x := interface{}(nil)
    _, y := x.(interface{})
    println(y)
}

答案：false。
知识点：类型断言。
剖析：

1. 类型断言语法：i.(Type)，其中 i 是接口，Type 是类型或接口。
2. 编译时，编译器会自动检测 i 的动态类型与 Type 是否一致。但是，如果动态类型不存在，则断言总是失败——本例 x 没有类型，所以输出 false 。

下面代码是否正确？

func main() {
    m := make(map[string]int, 2)
    cap(m)
}

答案：false。
剖析：

1. 使用 make 创建 map 变量时可以指定第二个参数，不过会被忽略。
2. cap 函数适用于数组、数组指针、slice 和 channel，不适用于 map。

位运算的坑整理

1. 取反符号是 ^，而不是 ~，这点跟很多语言不一样。
2. 当 ^ 是二元运算符的时候，代表异或运算。
3. &^ 这是 按位置零 符号，看个例子就明白了：

func main() {
    var x uint8 = 214
    var y uint8 = 92
    fmt.Printf("x: %08b\n", x)
    fmt.Printf("y: %08b\n", y)
    fmt.Printf("x | y: %08b\n", x|y)
    fmt.Printf("x &^ y: %08b\n", x&^y)
}

程序输出：

x: 11010110
y: 01011100
x | y: 11011110
x &^ y: 10000010

也就是说，y 的哪一位为 1，输出的那一位就是 0，和 | 运算相反。这个符号其他语言好像没见过，看了例子，是不是觉得也挺简单的。