Go竞赛试题

发表于 |

110题为单选题，1120题为多选题，每道题目5分，总分100分，竞赛试卷为60分钟，可以提前交卷。

1. 下面哪个logo是属于go语言的，正确答案是（）

A.

B.

C.

D.

解析
答案:D
A是lua的logo
B是python的logo
C是php的logo
D是go的logo

2. 下面程序的执行结果是（）

1
2
3
4
5
6
7
8
9
10
func main() {
   var a int = 10

   if a < 20 {
       fmt.Printf("a 小于 20\n" )
   } else {
       fmt.Printf("a 不小于 20\n" );
   }
   fmt.Printf("a 的值为 : %d\n", a)
}

A.a 小于 20，a 的值为 : 10
B.a 不小于 20，a 的值为 : 10
C.a 不小于 10，a 的值为 : 20
D.a 小于 10，a 的值为 : 20

解析
答案:A
a 赋值为10，10 是小于 20的，所以 a 小于20

3. 下面程序执行之后的结果是()

1
2
3
4
5
func tryDefer() {
    defer fmt.Printf("%d\t", 1)
    defer fmt.Printf("%d\t", 2)
    fmt.Printf("%d\t", 3)
}

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

解析
选B

  1. defer列表是一个栈结构，先进先出,故2在1 之前打印
  2. defer是在函数结束时执行（return之前或者出错之前），所以3先打印，所以答案选B

4. 关于以下代码片段运行的输出结果，以下正确的是（ ）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func test() int {
	fmt.Println("test()")
	return 18
}

func init () {
    fmt.Println("init()1")
}

func init () {
    fmt.Println("init()2")
}

var age = test()

func main() {
    fmt.Println("main()")
}

A. init()1
init()2
test()
main()

B. test()
init()1
init()2
main()

C. init()1
init()2
main()
test()

D. 编译错误

答案：B

解析：
init函数，先于main函数执行，实现包级别的一些初始化操作， 包的每个源文件可以有多个init函数。
Go程序执行的顺序为:

  1. 程序初始化： 初始化导入的包 ；初始化包作用域的变量；执行包的init函数
  2. 执行main 函数

5. 下面描述正确的是()

A. 下面程序可以正常运行

1
2
3
4
5
6
func main() {
	var a int64 = 1
	var b int32
	b = a
	fmt.Println(b)
}

B. Go是强类型语言
C. Go语言可以定义不使用的变量
D. 任何类型（int,float,struct,interface..）都可以进行类型断言

解析
答案：B
A. Go语言是强类型语言，int64和int32是不同的类型，cannot use a (type int64) as type int32 in assignment
C. Go语言定义的变量一定要使用
D. 只有接口类型的对象才可以进行类型断言

6. 以下哪个不是Go语言的保留关键字（）

A. const
B. static
C. fallthrough
D. select

解析
选择B
static不是go的关键字

7. 下面程序的执行结果是（）

1
2
3
4
5
6
7
8
9
func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

A. len=3 cap=5 slice=[0 0 0]
B. len=5 cap=5 slice=[0 0 0 0 0]
C. len=3 cap=3 slice=[0 0 0]
D. len=3 cap=5 slice=[0 0 0 0 0]

解析
答案:A
切片是可索引的，并且可以由 len() 方法获取长度。
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。
这里 make 一个 len 为3，cap 为5的数组，所以答案为A

8. 针对以下结构体，请在下面几种初始化的代码中选出正确的选项（）

1
2
3
4
5
type Student struct {
    Name string
    Score float32
    Age int
}

A.

1
2
3
var stu = new(Student)
(*stu).Score = 88
(*stu).Age = 22

B.

1
2
var stu *Student
(*stu).Age = 24

C.

1
var stu = Student{"Age":25}

D.

1
stu := Student{'jack', 88.5, 30}

解析
选择A
B. 结构指针未初始化
C. 字段名Age不能使用双引号
D. 字段Name为string类型，值不能使用单引号

9. 阅读以下程序代码，请问程序的输出是 ( )

A. 10 original 10
B. 10 changed 10
C. 10 original 100
D. 10 changed 100

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main

import "fmt"

type data struct {
	num int
	str *string
	ptr *int
}

func (d data) testFunc() {
	d.num = 100
	*d.str = "changed"

	var value int = 100
	d.ptr = &value
}

func main() {
	str := "original"
	val := 10

	d := data{10, &str, &val}
	d.testFunc()

	fmt.Printf("%v %v %v", d.num, *d.str, *d.ptr)
}

答案：B

解析：

Go 语言的函数对整型和数组类型的参数都是值传递的，对于结构体和指针类型也是如此。 本质上，Go 中只有值传递。传递结构体时，会对结构体中的全部内容进行拷贝， 对于指针str、ptr形参和实参都指向同一个变量的地址。*d.str等同于str，其赋值对原始的str变量进行了修改，而d.ptr只是修改了指针指向新的地址。函数调用后，指针的地址改变如下图：1592187494896

10. 针对以下代码，请哪个选项的输出结果是正确的（）

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"
import "reflect"

func main() {
    var x float64 = 6
    fmt.Println(reflect.TypeOf(x))
    fmt.Println(reflect.ValueOf(x))
}

A. float64、6.0
B. float64、6
C. int、6
D. int、6.0

解析
选B
解析：reflect.TypeOf返回的是变量定义时的类型，reflect.ValueOf返回变量的值；

11. 下面程序的执行结果是（）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 发送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}

        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        go sum(s[:], c)
        x, y, z := <-c, <-c, <-c // 从通道 c 中接收

        fmt.Println(x, y, z)
}

A. -5 17 12
B. 17 -5 12
C. -5 12 17
D. 17 12 -5

解析
答案:A、B、C、D
-9、4、0 之和：-5
7、2、8 之和：17
7、2、8、-9、4、0 之和：12
他们是通过通道无序返回赋值给x、y、z的，所以以上答案均有可能是正确答案

12. 关于异常的触发，下面说法正确的是（）

A. 空指针解析
B. 下标越界
C. 除数为0
D. 调用panic函数

解析
答案:ABCD
A、B、C是常见的异常，显示调用panic函数也会导致异常的触发。

13. 属于控制语句的选项是（）

A. if
B. switch
C. select
D. control

解析
答案:A、B、C
A、B、C 都是 go 语言的控制语句，D不是的

14. 下面说法正确的是（）

A. 当调用os.Exit()方法退出程序时，defer不会被执行
B. defer在函数中可以定义多个，并按在函数出现的顺序执行
C. Go语言中可以通过recover()来捕获异常
D. 在Go中函数是一等公民

解析
答案选择ACD
A. 正确：当发生panic时，所在goroutine的所有defer会被执行，但是当调用os.Exit()方法退出程序时，defer并不会被执行。
B. defer列表是一个栈结构，先进先出
D. Go中函数可以被命名可以被赋值可以当作参数被传进另一个函数也可以被另一个函数当作返回值可以放在任何位置。

15. 下列关于Go函数的说法正确的是（ ）

A. Go函数通过关键字func来声明
B. Go函数可以返回多个值
C. Go函数支持可变参数，不支持默认参数
D. Go函数支持重载

答案：ABC

解析：

C. 正确，Go支持可变参数，以slice切片传递可变参数，但不支持使用默认参数
D. Go函数不可以重载

16. 下列对于interface的描述正确的是()

A. Go中类型要实现某个接口， 只要实现这个接口里面的所有方法就可以了
B. 我们可以将任意一个值赋给空接口类型
C. 接口是值传递
D. 接口是引用传递

解析
答案:ABC
A. 接口的实现是隐式的，没有具体表明是怎么实现了接口，只要实现了接口里面的方法就可以了
CD. 在go中只有值传递，接口也是值传递

17. 通过指针变量 p 访问其成员变量 name，正确的是（）？

A. p.name
B. (&p).name
C. (*p).name
D. p->name

答案：AC

对于指针变量，操作符 “&” 取变量地址，”*” 通过指针访问目标对象

访问指针指向的结构体成员，不⽀持 “->” 运算符，直接⽤ “.” 访问目标成员。也可以先拿到结构体变量(*p)，再通过 “.”访问结构体成员

18. Go 语言中 range 关键字用于 for 循环中迭代哪些元素（）

A. 数组(array)
B. 切片(slice)
C. 通道(channel)
D. 集合(map)

解析
答案:A、B、C、D
Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

19. 关于结构体，以下说法正确的是（）

A. 结构体中成员必须有字段名。
B. 结构体中不能包含自身类型的成员变量，但是可以包含自身类型的成员指针。
C. 结构体中并没有继承的概念，但可以使用组合的方式来达到代码复用效果。
D. 结构体使用type关键字定义。

解析
选择BCD
结构体支持匿名成员

20. 下列说法中正确的是（）

A. Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。
B. 同一个程序中的所有 goroutine 不共享地址空间。
C. 通道可用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。
D. 通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小。

解析
答案:A、C、D
B选项：同一个程序中的所有 goroutine 都共享同一个地址空间