第一天

demo1. defer用法

func DeferCall() {
    defer func() { fmt.Println("打印前") }()
    defer func() { fmt.Println("打印中") }()
    defer func() { fmt.Println("打印后") }()
    panic("触发异常")
    defer func() { fmt.Println("121") }()  // 执行不到
}
// OUT：
打印后
打印中
打印前
panic: 触发异常
// 解析：
defer的执行顺序是先进后出。当出现panic语句时，会先按照defer的先进后出的顺序执行，最后才会执行panic

demo2. for循环时创建每个元素的副本，注意指针类型数据

func PointerTest() {
    slice := []int{0, 1, 2, 3}
    m := make(map[int]*int)
    for key, val := range slice {
        //temp := val
        m[key] = &val
    }
    for k, v := range m {
        fmt.Println(k, "->", *v)
    }
}
// OUT：
0 -> 3
1 -> 3
2 -> 3
3 -> 3
// 解析：
for range 循环时会创建每个元素的副本，而不是元素的引用，所以 m[key]=&val 取的都是变量val的地址，所以最后map中的所有元素的值都是变量val的地址，因为最后val被赋值为3，所有输出都是3
// 修改：
temp := val
m[key] = &temp

demo3. new和make的区别

//Test31 is a function
func Test31() {
    s := make([]int, 5)
    s = append(s, 1, 2, 3)
    fmt.Println(s)
}
//Test32 is a function
func Test32() {
    s := make([]int, 0)
    s = append(s, 1, 2, 3, 4)
    fmt.Println(s)
}
//FuncMui is a function
func FuncMui(x, y int) (sum int, error) {
    return (x + y), nil
}
//阐述new与make的区别
// OUT：
[0 0 0 0 0 1 2 3]
[1 2 3 4]
syntax error: mixed named and unnamed function parameters
// 解析：
1、make定义切片时，初始化了切片的长度为5，默认值为0
2、第二个返回值没有命名
在函数有多个返回值时，情况如下：
只要有一个返回值有命名，其他的也必须命令。
如果有多个返回值必须加上括号()。
如果只有一个返回值且命名也必须加上括号()。
这里的第一个返回值有命名sum，第二个没有命名，所以出现语法错误
3、new(T)和make(T,args)是go语言内建函数，用来分配内存，但适用的类型不同：
new(T)会为T类型的新值分配已置零的内存空间，并返回地址(指针)，即类型为*T的值，换句话说，返回一个指针，该指针指向新分配的，类型为T的零值。适用于值类型，如数组、结构体等。
make(T,args)返回初始化后的T类型的值，这个值并不是T类型的零值，也不是指针*T，是经过初始化之后的T的引用。make()只适用于slice、map、chanael

demo4. 下列程序是否能够通过编译

// 第1题
func Test41() {
    list := new([]int)
    list = append(list,1)
    fmt.Println(list)
}
// 第2题
func Test42() {
    s1 := []int{1,2,3}
    s2 := []int{4,5}
    s1 = append(s1,s2)
    fmt.Println(s1)
}
// 第3题
var(
    size := 1024
    max_size := size*2
)
func main ()  {
    fmt.Println(size, max_size)
}
// OUT：
1、不能通过编译
new([]int)返回的是一个*[]int类型指针，即list变量是个指针变量，不能对指针执行append操作。可以使用make()初始化后再用。
同样，map、chan建议使用make()或字面量的方式进行初始化，不可用new()。
2、不能通过编译
append()的第二个参数不能直接使用slice，需使用 ... 操作符，将一个切片追加到另一个切片中：append(s1,s2...)，或者直接跟上元素，如：append(s1,1,2,3)。
3、不能通过编译
变量声明的简短模式具有限制：
1)、必须使用显示初始化
2)、不能提供数据类型，编译器会自动推导
3)、只能在函数内部使用简短模式

demo5. test

// 第1题
sn1 := struct {
    age int
    name string
}{ age: 11,name: "qq" }
sn2 := struct {
    age int
    name string
}{
    age: 11,
    name: "qq",
}
if sn1 == sn2 {
    fmt.Println("sn1 == sn2")
}
// 第 2 题
sm1 := struct {
    age int
    m map[string]string
}{
    age: 11,
    m: map[string]string,
}
sm2 := struct {
    age int
    m map[string]string
}{
    age: 11,
    m: map[string]string,
}
if sm1 == sm2 {
    fmt.Println("sm1 == sm2")
}
// OUT：