GO语言基础理论知识总结以及自评150题（第二十五天）

试题转自网上以及牛客网，答案解析是自己做的，如果有误差欢迎评论
邮箱：[email protected]

选择题

1. 【初级】下面属于关键字的是（）
   A. func
   B. def
   C. struct
   D. class

参考答案：AC，func 定义函数，struct 定义结构体

2. 【初级】定义一个包内全局字符串变量，下面语法正确的是（）
   A. var str string
   B. str := “”
   C. str = “”
   D. var str = “”

参考答案：AD ，B ：= 只能用于函数体内局部变量

3. 【初级】通过指针变量 p 访问其成员变量 name，下面语法正确的是（）
   A. p.name
   B. (*p).name
   C. (&p).name
   D. p->name

参考答案：AB D是C语言的访问方式，GO中无 ->

4. 【初级】关于接口和类的说法，下面说法正确的是（）
   A. 一个类只需要实现了接口要求的所有函数，我们就说这个类实现了该接口
   B. 实现类的时候，只需要关心自己应该提供哪些方法，不用再纠结接口需要拆得多细才合理
   C. 类实现接口时，需要导入接口所在的包
   D. 接口由使用方按自身需求来定义，使用方无需关心是否有其他模块定义过类似的接口

参考答案：ABD

5. 【初级】关于字符串连接，下面语法正确的是（）
   A. str := ‘abc’ + ‘123’
   B. str := “abc” + “123”
   C. str ：= ‘123’ + “abc”
   D. fmt.Sprintf(“abc%d”, 123)

参考答案：BD ‘’ 是单字符

6. 【初级】关于协程，下面说法正确是（）
   A. 协程和线程都可以实现程序的并发执行
   B. 线程比协程更轻量级
   C. 协程不存在死锁问题
   D. 通过channel来进行协程间的通信

参考答案：AD 协程比线程轻量

7. 【中级】关于init函数，下面说法正确的是（）
   A. 一个包中，可以包含多个init函数
   B. 程序编译时，先执行导入包的init函数，再执行本包内的init函数
   C. main包中，不能有init函数
   D. init函数可以被其他函数调用

参考答案：AB

init函数用于包的初始化，如初始化包中的变量，这个初始化在package xxx的时候完成，也就是在main之前完成；
2、每个包可以拥有多个init函数， 每个包的源文件也可以拥有多个init函数；
3、同一个包中多个init函数的执行顺序是没有明确定义的，但是不同包的init函数是根据包导入的依赖关系决定的。
4、init函数不能被其他函数调用，其实在main函数之前自动执行的
关于import _ " "的说明

go对包导入非常严格，不允许导入不使用的包。但是有时候我们导入包只是为了做一些初始化的工作，这样就应该采用import _ "
"的形式，如第II节的例程中我们采用了import _ " "的形式导入level1和level2包，这样就可以在只完成初始化，也不会报错

8. 【初级】关于循环语句，下面说法正确的有（）
   A. 循环语句既支持for关键字，也支持while和do-while
   B. 关键字for的基本使用方法与C/C++中没有任何差异
   C. for循环支持continue和break来控制循环，但是它提供了一个更高级的break，可以选择中断哪一个循环
   D. for循环不支持以逗号为间隔的多个赋值语句，必须使用平行赋值的方式来初始化多个变量
   参考答案：CD 不支持while和do-while

9. 【初级】关于类型转化，下面语法正确的是（）
   A. type MyInt int
   var i int = 1
   var j MyInt = i

B.
type MyInt int
var i int= 1
var j MyInt = (MyInt)i

C.
type MyInt int
var i int= 1
var j MyInt = MyInt(i)

D.
type MyInt int
var i int= 1
var j MyInt = i.(MyInt)

参考答案：C A没有类型转化， B 变量加（）

19. 【初级】关于局部变量的初始化，下面正确的使用方式是（）
    A. var i int = 10
    B. var i = 10
    C. i := 10
    D. i = 10

参考答案：ABC

20. 【初级】关于const常量定义，下面正确的使用方式是（）
    A.const Pi float64 = 3.14159265358979323846
    const zero= 0.0
    B.
    const (
    size int64= 1024
    eof = -1
    )
    C.
    const (
    ERR_ELEM_EXISTe rror = errors.New(“element already exists”)
    ERR_ELEM_NT_EXIST error = errors.New(“element not exists”)
    )

D.
const u, vfloat32 = 0, 3
const a,b, c = 3, 4, “foo”

参考答案：ABD

22. 【初级】关于布尔变量b的赋值，下面错误的用法是（）
    A. b = true
    B. b = 1
    C. b = bool(1)
    D. b = (1 == 2)

参考答案：BC 布尔值为：true或 flase

23. 【中级】下面的程序的运行结果是（）

func main() {  
  if (true) {
    defer fmt.Printf("1")
  } else {
    defer fmt.Printf("2")
 }
   fmt.Printf("3")
}

A. 3 2 1
B. 3 2
C. 3 1
D. 1 3

参考答案：C defer 时间延迟函数

31. 【初级】关于switch语句，下面说法正确的有（）
    A. 条件表达式必须为常量或者整数
    B. 单个case中，可以出现多个结果选项
    C. 需要用break来明确退出一个case
    D. 只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case

参考答案：BD 条件表达式可以为表达式 ，go中不需要用break来明确退出一个case

33. 【中级】 golang中的引用类型包括（）
    A. 数组切片
    B. map
    C. channel
    D. interface

参考答案：ABCD

golang中分为值类型和引用类型
值类型分别有：int系列、float系列、bool、string、数组和结构体
引用类型有：指针、slice切片、管道channel、接口interface、map、函数等
值类型的特点是：变量直接存储值
引用类型的特点是：变量存储的是一个地址，这个地址对应的空间里才是真正存储的值

34. 【中级】 golang中的指针运算包括（）
    A. 可以对指针进行自增或自减运算
    B. 可以通过“&”取指针的地址
    C. 可以通过“*”取指针指向的数据
    D. 可以对指针进行下标运算

参考答案：BC ,指针不能下标，加减运算

35. 【初级】关于main函数（可执行程序的执行起点），下面说法正确的是（）
    A. main函数不能带参数
    B. main函数不能定义返回值
    C. main函数所在的包必须为main包
    D. main函数中可以使用flag包来获取和解析命令行参数

参考答案：ABCD ，go语言和C语言不一样，go 中Main函数和init函数都没有参数和返回值的定义。

36. 【中级】下面赋值正确的是（）
    A. var x = nil
    B. var x interface{} = nil
    C. var x string = nil
    D. var x error = nil

参考答案：BD nil == C语言中的NULL 是无类型的数值常亮 A无法解释类型，C,cannot use nil as type string in assignment, error 和 interface{} 接口类的都可以赋值为nil

37. 【中级】关于整型切片的初始化，下面正确的是（）
    A. s := make([]int)
    B. s := make([]int, 0)
    C. s := make([]int, 5, 10)
    D. s := []int{1, 2, 3, 4, 5}

参考答案：BCD make 必须要类型 容量

57. 【中级】关于函数声明，下面语法错误的是（）
    A. func f(a, b int) (value int, err error)
    B. func f(a int, b int) (value int, err error)
    C. func f(a, b int) (value int, error)
    D. func f(a int, b int) (int, int, error)

参考答案：C error 需要单独声明形参

72. 【中级】关于GetPodAction定义，下面赋值正确的是（）

type Fragment interface {
Exec(transInfo *TransInfo) error
}

 type GetPodAction struct {

}

func (g GetPodAction) Exec(transInfo*TransInfo) error {
…
return nil

}

A. var fragment Fragment =new(GetPodAction)
B. var fragment Fragment = GetPodAction
C. var fragment Fragment = &GetPodAction{}
D. var fragment Fragment = GetPodAction{}

参考答案：ACD Fragment interface 实现的是接口类型， 类似重载，接口类型的变量的实例化可以通过类对象进行初始化，调用的时候使用fragment.Exec()

82. 【中级】关于接口，下面说法正确的是（）
    A. 只要两个接口拥有相同的方法列表（次序不同不要紧），那么它们就是等价的，可以相互赋值
    B. 如果接口A的方法列表是接口B的方法列表的子集，那么接口B可以赋值给接口A
    C. 接口查询是否成功，要在运行期才能够确定
    D. 接口赋值是否可行，要在运行期才能够确定

参考答案：ABC

只要两个接口拥有相同的方法列表（次序不同不要紧），那么它们就是等价的，可以相互赋值。 Go语言接口是否可以赋值，是在编译期就确定的。接口的查询是在运行期确定。

83. 【初级】关于channel，下面语法正确的是（）
    A. var ch chan int
    B. ch := make(chan int)
    C. <- ch
    D. ch <-

参考答案：ABC ,没有 ch <-

84. 【初级】关于同步锁，下面说法正确的是（）
    A. 当一个goroutine获得了Mutex后，其他goroutine就只能乖乖的等待，除非该goroutine释放这个Mutex
    B. RWMutex在读锁占用的情况下，会阻止写，但不阻止读
    C. RWMutex在写锁占用情况下，会阻止任何其他goroutine（无论读和写）进来，整个锁相当于由该goroutine独占
    D. Lock()操作需要保证有Unlock()或RUnlock()调用与之对应

参考答案：ABC 无论是RWMutex还是Mutex，与Lock()对应的都是Unlock()

85. 【中级】 golang中大多数数据类型都可以转化为有效的JSON文本，下面几种类型除外（）
    A. 指针
    B. channel
    C. complex
    D. 函数

参考答案：BCD 指针本身不能进行序列化，go提供了隐式转换，表面进行的是指针序列化，内部会针对指针进行取值操作，实际还是针对的起所指的对象进行序列化了

87. 【初级】 flag是bool型变量，下面if表达式符合编码规范的是（）
    A. if flag == 1
    B. if flag
    C. if flag == false
    D. if !flag
    参考答案：BD

88. 【初级】 value是整型变量，下面if表达式符合编码规范的是（）
    A. if value == 0
    B. if value
    C. if value != 0
    D. if !value

参考答案：AC

89. 【中级】关于函数返回值的错误设计，下面说法正确的是（）
    A. 如果失败原因只有一个，则返回bool
    B. 如果失败原因超过一个，则返回error
    C. 如果没有失败原因，则不返回bool或error
    D. 如果重试几次可以避免失败，则不要立即返回bool或error

参考答案：ABCD

90. 【中级】关于异常设计，下面说法正确的是（）
    A. 在程序开发阶段，坚持速错，让程序异常崩溃
    B. 在程序部署后，应恢复异常避免程序终止
    C. 一切皆错误，不用进行异常设计
    D. 对于不应该出现的分支，使用异常处理

参考答案：ABD

91. 【中级】关于slice或map操作，下面正确的是（）
    A.

92. var s []int

s =append(s,1)

B.

var mmap[string]int

m[“one”]= 1

C.

var s[]int

s =make([]int, 0)

s =append(s,1)

D.

var mmap[string]int

m =make(map[string]int)

m[“one”]= 1

参考答案：ACD

Make只用来创建slice,map,channel。 其中map使用前必须初始化，一定要make才能使用。
append可直接动态扩容slice，而map不行，map在使用前必须初始化。 var m map[string]int =
make(map[string]int) m[“one”] = 1 或者 var m map[string]int =
map[string]int{“two”, 2} m[“one”] = 1

93. 【中级】关于channel的特性，下面说法正确的是（）
    A. 给一个 nil channel 发送数据，造成永远阻塞
    B. 从一个 nil channel 接收数据，造成永远阻塞
    C. 给一个已经关闭的 channel 发送数据，引起 panic
    D. 从一个已经关闭的 channel 接收数据，如果缓冲区中为空，则返回一个零值

参考答案：ABCD nil channel代表channel未初始化，向未初始化的channel读写数据会造成永久阻塞。关闭(close)未初始化的channel会引起panic

94. 【中级】关于无缓冲和有缓存的channel，下面说法正确的是（）
    A. 无缓冲的channel是默认的缓冲为1的channel
    B. 无缓冲的channel和有缓冲的channel都是同步的
    C. 无缓冲的channel和有缓冲的channel都是非同步的
    D. 无缓冲的channel是同步的，而有缓冲的channel是非同步的

参考答案：D

95. 【中级】关于异常的触发，下面说法正确的是（）
    A. 空指针解析
    B. 下标越界
    C. 除数为0
    D. 调用panic函数

参考答案：ABCD

96. 【中级】关于cap函数的适用类型，下面说法正确的是（）
    A. array
    B. slice
    C. map
    D. channel

参考答案：ABD cap的作用—— arry：返回数组的元素个数 slice：返回slice的最大容量 channel：返回channel的buffer容量，map中使用len表示大小

100.【中级】关于map，下面说法正确的是（）
A. map反序列化时json.unmarshal的入参必须为map的地址
B. 在函数调用中传递map，则子函数中对map元素的增加不会导致父函数中map的修改
C. 在函数调用中传递map，则子函数中对map元素的修改不会导致父函数中map的修改
D. 不能使用内置函数delete删除map的元素

参考答案：A B，
C:map是引用对象，在子函数中对引用对象进行操作会影响到父函数中引用对象
D：delete(m map[type]type,key type)，delete可以根据key删除map中的元素

102.【初级】关于select机制，下面说法正确的是（）
A. select机制用来处理异步IO问题
B. select机制最大的一条限制就是每个case语句里必须是一个IO操作
C. golang在语言级别支持select关键字
D. select关键字的用法与switch语句非常类似，后面要带判断条件

参考答案：ABC
select后不用带判断条件，case后带判断条件

填空题

1. 【初级】声明一个整型变量i__________

参考答案：var i int

2. 【初级】声明一个含有10个元素的整型数组a__________

参考答案：var a [10]int

3. 【初级】声明一个整型数组切片s__________

参考答案：var s []int

4. 【初级】声明一个整型指针变量p__________

参考答案：var p *int

5. 【初级】声明一个key为字符串型value为整型的map变量m__________

参考答案：var m map[string]int

6. 【初级】声明一个入参和返回值均为整型的函数变量f__________

参考答案：var f func(a int) int

7. 【初级】声明一个只用于读取int数据的单向channel变量ch__________

参考答案：var ch <-chan int

10. 【中级】下面的程序的运行结果是__________

11. for i := 0; i < 5; i++ {

12. defer fmt.Printf("%d ", i)

}

参考答案：4 3 2 1 0

13. 【中级】下面的程序的运行结果是__________

func main() {
    x := 1
    {
        x := 2
        fmt.Print(x)
    }
    fmt.Println(x)
}

参考答案：2 1

21. 【中级】下面的程序的运行结果是__________

func main() {
	strs := []string{"one","two", "three"}
	for _, s := range strs {
    	go func() {
  			time.Sleep(1 * time.Second)
			fmt.Printf("%s ", s)
  		}()
    }
    time.Sleep(3 * time.Second)
}

参考答案：three threethree
因为主进程循环遍历快，子线程运行都是主线程遍历完

package main
import ("fmt"
        "time")

	func main() {
		strs := []string{"one","two", "three"}
		for _, s := range strs {
			go func() {
				 
				fmt.Printf("%s ", s)
			  }()
			time.Sleep(1 * time.Second)
		}
		time.Sleep(3 * time.Second)
	}

one two three 

32. 【中级】下面的程序的运行结果是__________

33. func main() {

34. x := []string{“a”, “b”,“c”}

35. for v := range x {

36. fmt.Print(v)

37. }

}

参考答案：0 1 2

38. 【中级】下面的程序的运行结果是__________

39. func main() {

40. x := []string{“a”, “b”,“c”}

41. for _, v := range x {

42. fmt.Print(v)

43. }

}

参考答案：abc

44. 【初级】下面的程序的运行结果是__________

45. func main() {

46. i := 1

47. j := 2

48. i, j = j, i

49. fmt.Printf("%d%d\n", i, j)

}

参考答案：2 1

50. 【初级】下面的程序的运行结果是__________

51. func incr(p *int) int {

52. *p++

53. return *p

54. }

55. func main() {

56. v := 1

57. incr(&v)

58. fmt.Println(v)

}

参考答案：2

59. 【初级】启动一个goroutine的关键字是__________

参考答案：go

60. 【中级】下面的程序的运行结果是__________

package main
import ("fmt")
type Slice []int

func NewSlice() Slice {
	return make(Slice, 0)
}
	
func (s* Slice) Add(elem int) *Slice {
	*s = append(*s, elem)
	fmt.Print(elem)
	fmt.Print("\n")
	return s
}

func main() {  
	s := NewSlice()
	defer s.Add(1)
	s.Add(2)
	s.Add(3)
}

参考答案：２　３　１

判断题

1. 【初级】数组是一个值类型（）

参考答案：T

2. 【初级】使用map不需要引入任何库（）

参考答案：T ，内置类型

3. 【中级】内置函数delete可以删除数组切片内的元素（）

参考答案：F 不可以，map是可以的

4. 【初级】指针是基础类型（）

参考答案：F

5. 【初级】 interface{}是可以指向任意对象的Any类型（）

参考答案：T

6. 【中级】下面关于文件操作的代码可能触发异常（）

7. file, err := os.Open(“test.go”)

8. defer file.Close()

9. if err != nil {

10. fmt.Println(“open file failed:”,err)

11. return

12. }

…

参考答案：T

13. 【初级】 Golang不支持自动垃圾回收（）

参考答案：F

14. 【初级】 Golang支持反射，反射最常见的使用场景是做对象的序列化（）

参考答案：T

21. 【初级】通过成员变量或函数首字母的大小写来决定其作用域（）

参考答案：T

22. 【初级】对于常量定义zero(const zero = 0.0)，zero是浮点型常量（）

参考答案：F Go中的常量通常是无类型的。但可以参与一些“有类型”的计算 float32

23. 【初级】对变量x的取反操作是~x（）

参考答案：F go不支持，用^！代替 C语言是~

24. 【初级】下面的程序的运行结果是xello（）

25. func main() {

26. str := “hello”

27. str[0] = ‘x’

28. fmt.Println(str)

}

参考答案：F
字符串是不可变的，所以不能对字符串中某个字符单独赋值。没有字符串下标操作。

29. 【初级】 golang支持goto语句（）

参考答案：T

30. 【初级】下面代码中的指针p为野指针，因为返回的栈内存在函数结束时会被释放（）

31. type TimesMatcher struct {

32. base int

33. }

34. func NewTimesMatcher(base int) *TimesMatcher{

35. return &TimesMatcher{base:base}

36. }

37. func main() {

38. p := NewTimesMatcher(3)

39. …

}

参考答案：F
GO语言的内存回收机制规定，只要有一个指针指向引用一个变量，那么这个变量就不会被释放，因此在GO语言中返回函数参数或临时变量是安全的，golang对局部变量的生命周期不做假设，而是根据是否被引用了来决定对象被创建在堆上还是栈上。这一过程称之为内存escape。

40. 【初级】匿名函数可以直接赋值给一个变量或者直接执行（）

参考答案：T

41. 【初级】如果调用方调用了一个具有多返回值的方法，但是却不想关心其中的某个返回值，可以简单地用一个下划线“_”来跳过这个返回值，该下划线对应的变量叫匿名变量（）

参考答案：T

42. 【初级】在函数的多返回值中，如果有error或bool类型，则一般放在最后一个（）

参考答案：T

43. 【初级】错误是业务过程的一部分，而异常不是（）

参考答案：T

44. 【初级】函数执行时，如果由于panic导致了异常，则延迟函数不会执行（）

参考答案：F

45. 【中级】当程序运行时，如果遇到引用空指针、下标越界或显式调用panic函数等情况，则先触发panic函数的执行，然后调用延迟函数。调用者继续传递panic，因此该过程一直在调用栈中重复发生：函数停止执行，调用延迟执行函数。如果一路在延迟函数中没有recover函数的调用，则会到达该携程的起点，该携程结束，然后终止其他所有携程，其他携程的终止过程也是重复发生：函数停止执行，调用延迟执行函数（）

参考答案：F

当内置的panic()函数调用时，外围函数或方法的执行会立即终止。然后，任何延迟执行(defer)的函数或方法都会被调用，就像其外围函数正常返回一样。最后，调用返回到该外围函数的调用者，就像该外围调用函数或方法调用了panic()一样，因此该过程一直在调用栈中重复发生：函数停止执行，调用延迟执行函数等。当到达main()函数时不再有可以返回的调用者，因此这个过程会终止，并将包含传入原始panic()函数中的值的调用栈信息输出到os.Stderr ,协程会遍历所有调用栈上需要执行的defer，如果执行完这些defer没有遇到recover，会直接调用exit退出程序

46. 【初级】同级文件的包名不允许有多个（）

参考答案：T

47. 【中级】可以给任意类型添加相应的方法（）

参考答案：F，自定义类型

48. 【初级】 golang虽然没有显式的提供继承语法，但是通过匿名组合实现了继承（）

参考答案：T

49. 【初级】使用for range迭代map时每次迭代的顺序可能不一样，因为map的迭代是随机的（）

参考答案：T

50. 【初级】 switch后面可以不跟表达式（）

参考答案：T

52. 【初级】 golang中没有构造函数的概念，对象的创建通常交由一个全局的创建函数来完成，以NewXXX来命名（）

参考答案：T

80. 【中级】 channel本身必然是同时支持读写的，所以不存在单向channel（）

参考答案：F ，单项channel，单向channel只能用于写入或者读取数据。channel本身同时支持读写的，单向channel是对channel的一种使用限制。

81. 【初级】 import后面的最后一个元素是包名（）

参考答案：F，标准包使用的是给定的短路径，如"fmt"、“net/http”，自己的包，需要在工作目录(GOPATH)下指定一个目录,improt 导入包，实际上就是基于工作目录的文件夹目录

面试题

1 写出下面代码输出内容。

package main
import (
“fmt”
)
func main() {
defer_call()
}
func defer_call() {
defer func() {fmt.Println(“打印前”)}()
defer func() {fmt.Println(“打印中”)}()
defe rfunc() {fmt.Println(“打印后”)}()
panic(“触发异常”)
}

考点：defer执行顺序
解答：
defer 是后进先出。
panic 需要等defer 结束后才会向上传递。 出现panic恐慌时候，会先按照defer的后入先出的顺序执行，最后才会执行panic。

打印后
打印中
打印前
panic: 触发异常

2 以下代码有什么问题，说明原因。

type student struct {
Name string
Age int
}
func pase_student() {
m := make(map[string]*student)
stus := []student{
{Name: “zhou”,Age: 24},
{Name: “li”,Age: 23},
{Name: “wang”,Age: 22},
}
for _,stu := range stus {
m[stu.Name] =&stu
}
}

考点：foreach
解答：
这样的写法初学者经常会遇到的，很危险！ 与Java的foreach一样，都是使用副本的方式。所以m[stu.Name]=&stu实际上一致指向同一个指针， 最终该指针的值为遍历的最后一个struct的值拷贝。 就像想修改切片元素的属性：

for _, stu := range stus {
stu.Age = stu.Age+10}

package main

import "fmt"
type student struct{
	Name string
	Age  int
}
func pase_student() {
    m := make(map[string]*student)
    stus := []student{
        {Name: "zhou",Age: 24},
        {Name: "li",Age: 23},
        {Name: "wang",Age: 22},
    }   
    for _,stu := range stus {
		
		m[stu.Name] =&stu     //这种遍历方式相当于 地址一样的，结构体里面的内容更改，会导致map 中的内容更改
		stu.Name = "wang"
		fmt.Println(m[stu.Name])
	}
	
	fmt.Println(m)
}
func main() {  
    pase_student()
}

<nil>
<nil>
&{wang 22}
map[li:0xc0000044a0 wang:0xc0000044a0 zhou:0xc0000044a0]

4 下面代码会输出什么？

type People struct{}

func (p People)ShowA() {
fmt.Println(“showA”)
p.ShowB()
}
func(pPeople)ShowB() {
fmt.Println(“showB”)
}
typeTeacher struct {
People
}
func(t*Teacher)ShowB() {
fmt.Println(“teachershowB”)
}
funcmain() {
t := Teacher{}
t.ShowA()
}

考点：go的组合继承
解答：
这是Golang的组合模式，可以实现OOP的继承。 被组合的类型People所包含的方法虽然升级成了外部类型Teacher这个组合类型的方法（一定要是匿名字段），但它们的方法(ShowA())调用时接受者并没有发生变化。 此时People类型并不知道自己会被什么类型组合，当然也就无法调用方法时去使用未知的组合者Teacher类型的功能。
showAshowB

5 下面代码会触发异常吗？请详细说明

func main() {
runtime.GOMAXPROCS(1)
int_chan := make(chanint, 1)
string_chan := make(chanstring, 1)
int_chan <- 1
string_chan <- “hello”
select {
case value := <-int_chan:
fmt.Println(value)
casevalue := <-string_chan:
panic(value)
}
}

考点：select随机性
解答：
select会随机选择一个可用通用做收发操作。 所以代码是有肯触发异常，也有可能不会。 单个chan如果无缓冲时，将会阻塞。但结合 select可以在多个chan间等待执行。有三点原则：

select 中只要有一个case能return，则立刻执行。
当如果同一时间有多个case均能return则伪随机方式抽取任意一个执行。
如果没有一个case能return则可以执行”default”块。

6 下面代码输出什么？

func calc(index string, a, b int) int {
ret := a+ b
fmt.Println(index,a, b, ret)
return ret
}
func main() {
a := 1
b := 2
defer calc(“1”, a,calc(“10”, a, b)) a = 0
defer calc(“2”, a,calc(“20”, a, b)) b = 1
}

考点：defer执行顺序
解答：
这道题类似第1题 需要注意到defer执行顺序和值传递 index:1肯定是最后执行的，但是index:1的第三个参数是一个函数，所以最先被调用
calc(“10”,1,2)>10,1,2,3 执行index:2时,与之前一样，需要先调用calc(“20”,0,2)>20,0,2,2 执行到b=1时候开始调用，index:2==>calc(“2”,0,2)>2,0,2,2最后执行index:1>calc(“1”,1,3)==>1,1,3,4

10 1 2 320 0 2 22 0 2 21 1 3 4

7 请写出以下输入内容

func main() {
s := make([]int,5)
s = append(s,1, 2, 3)
fmt.Println(s)
}

考点：make默认值和append
解答：
make初始化是由默认值,默认值为0

[00000123]

改为:

s := make([]int, 0)
s = append(s, 1, 2, 3)
fmt.Println(s)//[1 2 3]

10 以下代码能编译过去吗？为什么？

package main
import ( “fmt”)
type People interface {
Speak(string) string
}
type Stduent struct{}
func(stu*Stduent)Speak(think string)(talk string) {
if think == “bitch” {
talk = “Youare a good boy”
} else {
talk = “hi”
}
return
}
funcmain() {
var peo People = Stduent{}
think := “bitch”
fmt.Println(peo.Speak(think))
}

考点：golang的方法集
解答：
golang的方法集仅仅影响接口实现和方法表达式转化，与通过实例或者指针调用方法无关。
var peo Stduent = Stduent{}
或者
var peo People = new(Stduent)

11 以下代码打印出来什么内容，说出为什么。

package main
import ( “fmt”)
typePeople interface {
Show()
}
typeStudent struct{}
func(stuStudent)Show() {
}
funclive()People {
var stuStudent
return stu
}
funcmain() { if live() == nil
{
fmt.Println(“AAAAAAA”)
} else {
fmt.Println(“BBBBBBB”)
}
}

考点：interface内部结构
解答：
很经典的题！ 这个考点是很多人忽略的interface内部结构。 go中的接口分为两种一种是空的接口类似这样：

var ininterface{}

另一种如题目：

type People interface {
Show()
}

他们的底层结构如下：

type eface struct { //空接口
_type _type //类型信息
data unsafe.Pointer //指向数据的指针(go语言中特殊的指针类型unsafe.Pointer类似于c语言中的void)}
typeiface struct { //带有方法的接口
tab itab //存储type信息还有结构实现方法的集合
data unsafe.Pointer //指向数据的指针(go语言中特殊的指针类型unsafe.Pointer类似于c语言中的void)}
type_type struct {
size uintptr //类型大小
ptrdata uintptr //前缀持有所有指针的内存大小
hash uint32 //数据hash值
tflag tflag
align uint8 //对齐
fieldalign uint8 //嵌入结构体时的对齐
kind uint8 //kind 有些枚举值kind等于0是无效的
alg *typeAlg //函数指针数组，类型实现的所有方法
gcdata *byte str nameOff
ptrToThis typeOff
}type itab struct {
inter *interfacetype //接口类型
_type *_type //结构类型
link *itab
bad int32
inhash int32
fun [1]uintptr //可变大小方法集合}

可以看出iface比eface 中间多了一层itab结构。 itab 存储_type信息和[]fun方法集，从上面的结构我们就可得出，因为data指向了nil 并不代表interface 是nil， 所以返回值并不为空，这里的fun(方法集)定义了接口的接收规则，在编译的过程中需要验证是否实现接口 结果：

BBBBBBB
12.是否可以编译通过？如果通过，输出什么？

func main() {
i := GetValue()
switch i.(type) {
caseint:
println(“int”)
casestring:
println(“string”)
caseinterface{}:
println(“interface”)
default:
println(“unknown”)
}
}
funcGetValue()int {
return1
}

解析
考点：type

编译失败，因为type只能使用在interface

13.下面函数有什么问题？

func funcMui(x,y int)(sum int,error){
returnx+y,nil
}

解析
考点：函数返回值命名
在函数有多个返回值时，只要有一个返回值有指定命名，其他的也必须有命名。 如果返回值有有多个返回值必须加上括号； 如果只有一个返回值并且有命名也需要加上括号； 此处函数第一个返回值有sum名称，第二个未命名，所以错误。

14.是否可以编译通过？如果通过，输出什么？

package mainfunc main() { println(DeferFunc1(1)) println(DeferFunc2(1)) println(DeferFunc3(1))
}func DeferFunc1(i int)(t int) {
t = i deferfunc() {
t += 3
}() return t
}
funcDeferFunc2(i int)int {
t := i deferfunc() {
t += 3
}() return t
}
funcDeferFunc3(i int)(t int) { deferfunc() {
t += i
}() return2}

解析
考点:defer和函数返回值
需要明确一点是defer需要在函数结束前执行。 函数返回值名字会在函数起始处被初始化为对应类型的零值并且作用域为整个函数 DeferFunc1有函数返回值t作用域为整个函数，在return之前defer会被执行，所以t会被修改，返回4; DeferFunc2函数中t的作用域为函数，返回1;DeferFunc3返回3

15.是否可以编译通过？如果通过，输出什么？

funcmain() { list := new([]int)
list = append(list,1)
fmt.Println(list)
}

解析
考点：new

list:=make([]int,0)

16.是否可以编译通过？如果通过，输出什么？

package main
import “fmt”
func main() {
s1 := []int{1, 2, 3}
s2 := []int{4, 5}
s1 = append(s1,s2)
fmt.Println(s1)
}

解析
考点：append
append切片时候别漏了’…’

17.是否可以编译通过？如果通过，输出什么？

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”)
}
}

解析
考点:结构体比较
进行结构体比较时候，只有相同类型的结构体才可以比较，结构体是否相同不但与属性类型个数有关，还与属性顺序相关。

sn3:= struct {
name string
age int
}
{age:11,name:“qq”}

sn3与sn1就不是相同的结构体了，不能比较。 还有一点需要注意的是结构体是相同的，但是结构体属性中有不可以比较的类型，如map,slice。 如果该结构属性都是可以比较的，那么就可以使用“==”进行比较操作。

可以使用reflect.DeepEqual进行比较

if reflect.DeepEqual(sn1, sm) {
fmt.Println(“sn1==sm”)
}else {
fmt.Println(“sn1!=sm”)
}

所以编译不通过： invalid operation: sm1 == sm2

18.是否可以编译通过？如果通过，输出什么？

func Foo(x interface{}) { if x== nil {
fmt.Println(“emptyinterface”)
return
}
fmt.Println(“non-emptyinterface”)
}
func main() {
var x *int = nil
Foo(x)
}

解析
考点：interface内部结构

non-emptyinterface

19.是否可以编译通过？如果通过，输出什么？

func GetValue(m map[int]string, id int)(string, bool) {
if _,exist := m[id]; exist {
return"存在数据", true
}
returnnil, false
}
func main() {
intmap:=map[int]string{
1:“a”,
2:“bb”,
3:“ccc”,
}
v,err:=GetValue(intmap,3)
fmt.Println(v,err)
}

解析
考点：函数返回值类型
nil 可以用作 interface、function、pointer、map、slice 和 channel 的“空值”。但是如果不特别指定的话，Go 语言不能识别类型，所以会报错。
报:cannot use nil as type string in return argument

改为：

func GetValue(m map[int]string, id int)(string, bool) {    
	if _,exist := m[id]; exist {        
	  return"存在数据", true
    }  
	return "", false
}

20.是否可以编译通过？如果通过，输出什么？

const (
x = iota
y
z = “zz”
k
p = iota)
func main()
{
fmt.Println(x,y,z,k,p)
}

解析
考点：iota
结果:

0 1 zz zz 4

21.编译执行下面代码会出现什么?

package main
var(
size :=1024
max_size = size*2)
func main() {
println(size,max_size)
}

解析
考点:变量简短模式限制：= ,只能在函数内部使用
结果：

syntaxerror: unexpected :=

22.下面函数有什么问题？

package main
const cl = 100
var bl = 123
funcmain() {
println(&bl,bl)
println(&cl,cl)
}

解析
考点:常量
常量不同于变量的在运行期分配内存，常量通常会被编译器在预处理阶段直接展开，作为指令数据使用，

cannot take the address of cicannot take the address of ci

23.编译执行下面代码会出现什么?

package main
funcmain() {
for i:=0;i<10;i++ {
loop
println(i)
} goto loop
}

解析
考点：goto
goto不能跳转到其他函数或者内层代码

goto loop jumps intoblock starting at

29.编译执行下面代码会出现什么?

package main
func test(x int)(func(),func()) {
	return func() {
		println("*******1")
		println(x)
		x+=10
	}, func() {
			println("*******2")
		println(x)
	}
}
func main() {
	a,b:= test(100) // a=func(){println("*******1") println(x) x+=10}
	a()   
	b()
}

解析
考点：闭包引用相同变量，包内部可以被修改，包外边不能修改
结果：
*******1
100
*******2
110