好像还没有人回答数组变切片的问题，贴一下运行结果吧：
i:0, e:1
i:1, e:3
i:2, e:6
i:3, e:10
i:4, e:15
i:5, e:21
[22 3 6 10 15 21]

每次循环打印了一个索引和值，看起来 range 切片的话，是会每次取 slice[i] 的值，但是应该还是发生了拷贝，不能通过 e 直接修改原值。

第一个问题，在类型switch语句中，如何对被判断类型的那个值做类型转换，尝试在 switch 语句中重新定义了一个 uint8 类型的变量和被判断类型的值做加法操作，一共尝试了三种方法，发现需要使用 type assertion 才可以，强转或者直接相加都会出错。

转换语句是：val.(uint8)

完整验证代码：

val := interface{}(byte(1))
switch t := val.(type) {
case uint8:
    var c uint8 = 2

    //use type assertion
    fmt.Println(c + val.(uint8))

    //invalid operation: c + val (mismatched types uint8 and interface {})
    //fmt.Println(c + val)

    //cannot convert val (type interface {}) to type uint8: need type assertion
    //fmt.Println(c + uint8(val))

default:
    fmt.Printf("unsupported type: %T", t)
}

第二个问题，在if语句中，初始化子句声明的变量的作用域是在该if语句之内，if语句之外使用该变量会提示 “undefined”。

验证代码：

m := make(map[int]bool)
if _, ok := m[1]; ok {
    fmt.Printf("exist: %v\n", ok)
} else {
    fmt.Printf("not exist: %v\n", ok)
}

//fmt.Println(ok) //报错，提示 undefined: ok

老师遇到一个问题，希望能帮忙解答下！
您在文章中说range表达式的结果值是会被复制的，那么是所有的都会被复制么？ 我看了资料，发现字典和通道类型好像没有发生复制！

// Lower a for range over a map.
// The loop we generate:
// var hiter map_iteration_struct
// for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
// index_temp = *hiter.key
// value_temp = *hiter.val
// index = index_temp
// value = value_temp
// original body
// }
很是疑惑，希望能得到指点！谢谢

关于数组变切片那个地方。我理解如下：切片自己不拥有任何数据，它只是底层数组的一种表示，对切片的任何操作都会被反映到底层数组中去。
package main

import "fmt"

func main() {

    numbers3 := []int{1, 2, 3, 4, 5, 6}
    maxIndex3 := len(numbers2) - 1 //6-1= 5
    for i, e := range numbers3 { // 0:1 1:2 2:3 3:4 4:5 5:6
        if i == maxIndex3 { // 5
            numbers3[0] += e // 0,7
        } else {
            numbers3[i+1] += e // 1:3
        }
        // 0:1 1:(1+2)3 2:3 3:4 4:5 5:6
        // 0:1 1:3 2:(3+3)6 3:4 4:5 5:6
        // 0:1 1:3 2:6 3:(6+4)10 4:5 5:6
        // 0:1 1:3 2:6 3:10 4:(10+5)15 5:6
        // 0:1 1:3 2:6 3:10 4:15 5:(15+6)21
        // 0:(21+1)22 1:3 2:6 3:10 4:15 5:21
        // 22 3 6 10 15 21
    }
    fmt.Println(numbers3)
}

咖啡色的羊驼的答案貌似是错误的吧？
1. 在类型switch语句中，t := value6.(type)；匹配到哪个case表达式，t就会是哪种具体的数据类型；
2. 在if语句中，子句声明的变量的作用域 比 随后的花括号内的变量的的作用域 更大
    if a := 10; a > 0 {
        a := 20
        println(a)
    }
反证法：如果咖啡色的羊驼说的对，上面的语句不应该编译通过才对。

关于2这个细微的差异，也适用于for i:=0; i<10; i++ 语句。
在for语句中的使用匿名函数，很可能出现“loop variable capture”问题。根本原因也是i的作用域与{}中的变量的作用域是不同的。