21.编译执行下面代码会出现什么?
1package main 2var( 3 size :=1024 4 max_size = size*2 5) 6func main() { 7 println(size,max_size) 8}
解析
考点:变量简短模式
变量简短模式限制：
- 定义变量同时显式初始化
- 不能提供数据类型
- 只能在函数内部使用
结果：
syntax error: unexpected :=
22.下面函数有什么问题？
1package main 2const cl = 100 3 4var bl = 123 5 6func main() { 7 println(&bl,bl) 8 println(&cl,cl) 9} 10
解析
考点:常量
常量不同于变量的在运行期分配内存，常量通常会被编译器在预处理阶段直接展开，作为指令数据使用，
cannot take the address of cl
23.编译执行下面代码会出现什么?
1package main 2 3func main() { 4 5 for i:=0;i<10 ;i++ { 6 loop: 7 println(i) 8 } 9 goto loop 10}
解析
考点：goto
goto不能跳转到其他函数或者内层代码
goto loop jumps into block starting at
24.编译执行下面代码会出现什么?
1package main 2import "fmt" 3 4func main() { 5 type MyInt1 int 6 type MyInt2 = int 7 var i int =9 8 var i1 MyInt1 = i 9 var i2 MyInt2 = i 10 fmt.Println(i1,i2) 11}
解析
考点：**Go 1.9 新特性 Type Alias **
基于一个类型创建一个新类型，称之为defintion；基于一个类型创建一个别名，称之为alias。 MyInt1为称之为defintion，虽然底层类型为int类型，但是不能直接赋值，需要强转； MyInt2称之为alias，可以直接赋值。
结果:
cannot use i (type int) as type MyInt1 in assignment
25.编译执行下面代码会出现什么?
1package main 2import "fmt" 3 4type User struct { 5} 6type MyUser1 User 7type MyUser2 = User 8func (i MyUser1) m1(){ 9 fmt.Println("MyUser1.m1") 10} 11func (i User) m2(){ 12 fmt.Println("User.m2") 13} 14 15func main() { 16 var i1 MyUser1 17 var i2 MyUser2 18 i1.m1() 19 i2.m2() 20}
解析
考点：**Go 1.9 新特性 Type Alias **
因为MyUser2完全等价于User，所以具有其所有的方法，并且其中一个新增了方法，另外一个也会有。 但是
i1.m2()
是不能执行的，因为MyUser1没有定义该方法。 结果:
1MyUser1.m1 2User.m2
26.编译执行下面代码会出现什么?
1package main 2 3import "fmt" 4 5type T1 struct { 6} 7func (t T1) m1(){ 8 fmt.Println("T1.m1") 9} 10type T2 = T1 11type MyStruct struct { 12 T1 13 T2 14} 15func main() { 16 my:=MyStruct{} 17 my.m1() 18}
解析
考点：**Go 1.9 新特性 Type Alias **
是不能正常编译的,异常：
ambiguous selector my.m1
结果不限于方法，字段也也一样；也不限于type alias，type defintion也是一样的，只要有重复的方法、字段，就会有这种提示，因为不知道该选择哪个。 改为:
1my.T1.m1() 2my.T2.m1()
type alias的定义，本质上是一样的类型，只是起了一个别名，源类型怎么用，别名类型也怎么用，保留源类型的所有方法、字段等。
27.编译执行下面代码会出现什么?
1package main 2 3import ( 4 "errors" 5 "fmt" 6) 7 8var ErrDidNotWork = errors.New("did not work") 9 10func DoTheThing(reallyDoIt bool) (err error) { 11 if reallyDoIt { 12 result, err := tryTheThing() 13 if err != nil || result != "it worked" { 14 err = ErrDidNotWork 15 } 16 } 17 return err 18} 19 20func tryTheThing() (string,error) { 21 return "",ErrDidNotWork 22} 23 24func main() { 25 fmt.Println(DoTheThing(true)) 26 fmt.Println(DoTheThing(false)) 27}
解析
考点：变量作用域
因为 if 语句块内的 err 变量会遮罩函数作用域内的 err 变量，结果：
1<nil> 2<nil>
改为：
1func DoTheThing(reallyDoIt bool) (err error) { 2 var result string 3 if reallyDoIt { 4 result, err = tryTheThing() 5 if err != nil || result != "it worked" { 6 err = ErrDidNotWork 7 } 8 } 9 return err 10}
28.编译执行下面代码会出现什么?
1package main 2 3func test() []func() { 4 var funs []func() 5 for i:=0;i<2 ;i++ { 6 funs = append(funs, func() { 7 println(&i,i) 8 }) 9 } 10 return funs 11} 12 13func main(){ 14 funs:=test() 15 for _,f:=range funs{ 16 f() 17 } 18}
解析
考点：闭包延迟求值
for循环复用局部变量i，每一次放入匿名函数的应用都是想一个变量。 结果：
10xc042046000 2 20xc042046000 2
如果想不一样可以改为：
1func test() []func() { 2 var funs []func() 3 for i:=0;i<2 ;i++ { 4 x:=i 5 funs = append(funs, func() { 6 println(&x,x) 7 }) 8 } 9 return funs 10}
29.编译执行下面代码会出现什么?
1package main 2 3func test(x int) (func(),func()) { 4 return func() { 5 println(x) 6 x+=10 7 }, func() { 8 println(x) 9 } 10} 11 12func main() { 13 a,b:=test(100) 14 a() 15 b() 16} 17
解析
考点：闭包引用相同变量*
结果：
1100 2110
30.编译执行下面代码会出现什么?
1package main 2 3import ( 4 "fmt" 5 "reflect" 6) 7 8func main1() { 9 defer func() { 10 if err:=recover();err!=nil{ 11 fmt.Println(err) 12 }else { 13 fmt.Println("fatal") 14 } 15 }() 16 17 defer func() { 18 panic("defer panic") 19 }() 20 panic("panic") 21} 22 23func main() { 24 defer func() { 25 if err:=recover();err!=nil{ 26 fmt.Println("++++") 27 f:=err.(func()string) 28 fmt.Println(err,f(),reflect.TypeOf(err).Kind().String()) 29 }else { 30 fmt.Println("fatal") 31 } 32 }() 33 34 defer func() { 35 panic(func() string { 36 return "defer panic" 37 }) 38 }() 39 panic("panic") 40}
解析
考点：panic仅有最后一个可以被revover捕获
触发panic("panic")后顺序执行defer，但是defer中还有一个panic，所以覆盖了之前的panic("panic")
defer panic