01
一个函数内defer的执行顺序与其声明顺序相反
出现panic语句时，会先执行defer后执行panic
出现panic语句时，声明在panic后面的任何代码不再执行
package main
import(
"fmt"
)
func main(){
defer func(){fmt.Println("打印前")}()
defer func(){fmt.Println("打印中")}()
defer func(){fmt.Println("打印后")}()
panic("结束")
}
$ go run main.go
打印后
打印中
打印前
panic: 结束
02
for range 循环的时候会创建每个元素的副本，而不是元素的引用
所以 m[key] = &val 取的都是变量 val 的地址
所以最后 map 中的所有元素的值都是变量 val 的地址，因为最后 val 被赋值为3，所有输出都是3
package main
import(
"fmt"
)
func main(){
slice := []int{0,1,2,3}
m := make(map[int]*int)
for key,val := range slice {
m[key] = &val
}
for k,v := range m {
fmt.Println(k,"->",*v)
}
}
$ go run main.go
0 -> 3
1 -> 3
2 -> 3
3 -> 3
03
// 下面两段代码输出什么
// 1.
func main() {
s := make([]int, 5)
s = append(s, 1, 2, 3)
fmt.Println(s)
}
// [0,0,0,0,0,1,2,3]
// 2.
func main() {
s := make([]int,0)
s = append(s,1,2,3,4)
fmt.Println(s)
}
// [1,2,3,4]
// 下面这段代码有什么缺陷
func funcMui(x,y int)(sum int,error){
return x+y,nil
}
// 第二个返回值没有命名
// 正确写法
func funcMui(x,y int)(sum int, err error){
return x+y,nil
}
// new() 与 make() 的区别
package main
import(
"fmt"
)
func main(){
s1 := new([]int)
s2 := make([]int, 0)
fmt.Println(s1)
fmt.Println(s2)
}
// 输出:
$ go run main.go
&[]
[]
04
// 下面这段代码能否通过编译，不能的话原因是什么；如果能，输出什么。
func main() {
list := new([]int)
list = append(list, 1)
fmt.Println(list)
}
// 不能通过编译，new([]int) 之后的 list 是一个 *[]int 类型的指针，
// 不能对指针执行 append 操作。
// 可以改写为:
func main() {
list := new([]int)
*list = append(*list, 1)
fmt.Println(*list)
}
// 下面这段代码能否通过编译，如果可以，输出什么？
func main() {
s1 := []int{1, 2, 3}
s2 := []int{4, 5}
s1 = append(s1, s2)
fmt.Println(s1)
}
// 不能通过编译。
// append() 的第二个参数不能直接使用 slice，需使用 … 操作符，将一个切片追加到另一个切片上：append(s1,s2…)。或者直接跟上元素，形如：append(s1,1,2,3)。
// 下面这段代码能否通过编译，如果可以，输出什么？
var(
size := 1024
max_size = size*2
)
func main() {
fmt.Println(size,max_size)
}
// 不能通过编译。变量声明的简短模式，形如：x := 100。有限制：
// 只能在函数内部使用简短模式
05
// 下面这段代码能否通过编译
package main
import(
"fmt"
)
func main() {
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")
}
sm1 := struct {
age int
m map[string]string
}{age: 11, m: map[string]string{"a": "1"}}
sm2 := struct {
age int
m map[string]string
}{age: 11, m: map[string]string{"a": "1"}}
if sm1 == sm2 {
fmt.Println("sm1 == sm2")
}
}
// 不能通过编译, 因为
// invalid operation: sm1 == sm2 (struct containing map[string]string cannot be compared)
// 什么是可比较的呢，常见的有 bool、数值型、字符、指针、数组等，像切片、map、函数等是不能比较的
