【初级】下面属于关键字的是（）

• A. func
• B. def
• C. struct
• D. class

参考答案：AC
golang关键字：

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

插播一条广告→ByteDance 字节跳动go方向工程师大量招人←内推链接

【初级】定义一个包内全局字符串变量，下面语法正确的是（）

• A. var str string
• B. str := ""
• C. str = ""
• D. var str = ""

参考答案：AD
解析参考：go语言之行--包与变量

【初级】通过指针变量 p 访问其成员变量 name，下面语法正确的是（）

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

参考答案：AB
解析参考：Go 语言指针

【初级】关于接口和类的说法，下面说法正确的是（）

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

参考答案：ABD
解析参考：

Golang的重要特征：接口是隐式实现的，程序员不需要显示声明类型T实现了接口I。这项工作是由Go编译器自动完成的(永远不要让人去做机器应该做的事情)。这种行为的优雅实现使得如下这种方式成为可能：定义一个接口，这个接口被已经写好的类型自动实现(不需要对之前已完成的类型做修改)。

【初级】关于字符串连接，下面语法正确的是（）

• A. str := ‘abc’ + ‘123’
• B. str := "abc" + "123"
• C. str ：= '123' + "abc"
• D. fmt.Sprintf("abc%d", 123)

参考答案：BD
解析参考：字符串应使用双引号

【初级】关于协程，下面说法正确是（）

• A. 协程和线程都可以实现程序的并发执行
• B. 线程比协程更轻量级
• C. 协程不存在死锁问题
• D. 通过channel来进行协程间的通信

参考答案：AD
参考解析：死锁

【中级】关于init函数，下面说法正确的是（）

A. 一个包中，可以包含多个init函数
B. 程序编译时，先执行导入包的init函数，再执行本包内的init函数
C. main包中，不能有init函数
D. init函数可以被其他函数调用
参考答案：AB
参考解析：五分钟理解golang的init函数

【初级】关于循环语句，下面说法正确的有（）

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

参考答案：CD
参考解析：Go 语言 for 循环、break、continue 讲解

【中级】对于函数定义：

func add(args ...int) int {
    sum :=0
    for _,arg := range args {
        sum += arg
    }
    return sum
}

下面对add函数调用正确的是（）

• A. add(1, 2)
• B. add(1, 3, 7)
• C. add([]int{1, 2})
• D. add([]int{1, 3, 7}...)

参考答案：ABD
参考解析：Go 系列教程 —— 12. 可变参数函数

【初级】关于类型转化，下面语法正确的是（）

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
参考解析：Go 语言类型转换

【初级】关于局部变量的初始化，下面正确的使用方式是（）

• A. var i int = 10
• B. var i = 10
• C. i := 10
• D. i = 10

参考答案：ABC

【初级】关于const常量定义，下面正确的使用方式是（）

A.

const Pi float64 = 3.14159265358979323846
const zero = 0.0

B.

const (
    size int64 = 1024
    eof = -1 
)

C.

const (
    ERR_ELEM_EXIST error = errors.New("element already exists")
    ERR_ELEM_NT_EXIST error = errors.New("element not exists")
)

D.

const u, v float32 = 0, 3 
const a, b, c = 3, 4, "foo"

参考答案：ABD
参考解析：Go语言常量和const关键字

【初级】关于布尔变量b的赋值，下面错误的用法是（）

• A. b = true
• B. b = 1
• C. b = bool(1)
• D. b = (1 == 2)

参考答案：BC

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

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

• A. 321
• B. 32
• C. 31
• D. 13

参考答案：C
参考解析：fmt.Printf("2")没有被压入栈，所以程序退出前的延迟执行自然也就没有它。

【初级】关于switch语句，下面说法正确的有（）

• A. 条件表达式必须为常量或者整数
• B. 单个case中，可以出现多个结果选项
• C. 需要用break来明确退出一个case
• D. 只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case

参考答案：BD
参考解析：Go语言switch case语句

【中级】golang中没有隐藏的this指针，这句话的含义是（）

• A. 方法施加的对象显式传递，没有被隐藏起来
• B. golang是简化版的面向对象语言
• C. golang的面向对象表达更直观，对于面向过程只是换了一种语法形式来表达
• D. 方法施加的对象不需要非得是指针，也不用非得叫this

参考答案：ACD
参考解析：牛客原题

【中级】golang中的引用类型包括（）

• A. 数组切片
• B. map
• C. channel
• D. interface

参考答案：ABCD
参考解析：牛客原题

【中级】golang中的指针运算包括（）

• A. 可以对指针进行自增或自减运算
• B. 可以通过“&”取指针的地址
• C. 可以通过“*”取指针指向的数据
• D. 可以对指针进行下标运算

参考答案：BC
参考解析：go语言的指针不支持运算

【初级】下面说法正确的是（）

• A. 不允许左大括号单独一行
• B. 不允许出现未使用的变量
• C. 不允许出现未使用的import
• D. 不允许在一个目录下有两个包

参考答案：ABCD

【中级】下面赋值正确的是（）

• A. var x = nil
• B. var x interface{} = nil
• C. var x string = nil
• D. var x error = nil

参考答案：BD

【中级】关于整型切片的初始化，下面正确的是（）

• A. s := make([]int)
• B. s := make([]int, 0)
• C. s := make([]int, 5, 10)
• D. s := []int{1, 2, 3, 4, 5}

参考答案：BCD

【中级】从切片中删除一个元素，下面的算法实现正确的是（）

A.

func (s *Slice)Remove(value interface{}) error{
    for i, v := range *s {
        if isEqual(value, v) {
            if i== len(*s) - 1 {
                *s = (*s)[:i]
            }else {
                *s = append((*s)[:i],(*s)[i + 2:]...)
            }
            return nil
        }
    }
    return ERR_ELEM_NT_EXIST
}

B.

func (s *Slice)Remove(value interface{}) error{
    for i, v := range *s {
        if isEqual(value, v) {
            *s = append((*s)[:i],(*s)[i + 1:])
            return nil
        }
    }
    return ERR_ELEM_NT_EXIST
}

C.

func (s *Slice)Remove(value interface{}) error{
    for i, v := range *s {
        if isEqual(value, v) {
            delete(*s, v)
            return nil
        }
    }
    return ERR_ELEM_NT_EXIST
}

D.

func (s *Slice)Remove(value interface{}) error{
    for i, v := range *s {
        if isEqual(value, v) {
            *s = append((*s)[:i],(*s)[i + 1:]...)
            return nil
        }
    }
    return ERR_ELEM_NT_EXIST
}

参考答案：D

【简单】对于局部变量整型切片x的赋值，下面定义正确的是（）

A.

x := []int{
    1, 2, 3,
    4, 5, 6,
}

B.

x := []int{
    1, 2, 3,
    4, 5, 6
}

C.

x := []int{
    1, 2, 3,
    4, 5, 6}

D.

x := []int{1, 2, 3, 4, 5, 6,}

参考答案：ACD
参考解析：go语言编译器会自动在以标识符、数字字面量、字母字面量、字符串字面量、特定的关键字（break、continue、fallthrough和return）、增减操作符（++和--）、或者一个右括号、右方括号和右大括号（即)、]、}）结束的非空行的末尾自动加上分号。
对于B选项，6是数字字面量，所以在6的后面会自动加上一个分号，导致编译出错。
对于D选项，gofmt会自动把6后面的“,”去掉，关掉gofmt后测试，也能通过编译，正常运行

【简单】关于变量的自增和自减操作，下面语句正确的是（）

A.

i := 1
i++

B.

i := 1
j = i++

C.

i := 1
++i

D.

i := 1
i--

参考答案：AD

【中级】关于函数声明，下面语法错误的是（）

• 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

【中级】如果Add函数的调用代码为：

func main() {
    var a Integer = 1
    var b Integer = 2
    var i interface{} = &a
    sum := i.(*Integer).Add(b)
    fmt.Println(sum)
}

则Add函数定义正确的是（）
A.

type Integer int
func (a Integer) Add(b Integer) Integer {
     return a + b
}

B.

type Integer int
func (a Integer) Add(b *Integer) Integer {
     return a + *b
}

C.

type Integer int
func (a *Integer) Add(b Integer) Integer {
     return *a + b
}

D.

type Integer int
func (a *Integer) Add(b *Integer) Integer {
     return *a + *b
}

参考答案：AC

【中级】如果Add函数的调用代码为：

func main() {
    var a Integer = 1
    var b Integer = 2
    var i interface{} = a
    sum := i.(Integer).Add(b)
    fmt.Println(sum)
}

则Add函数定义正确的是（）
A.

type Integer int
func (a Integer) Add(b Integer) Integer {
     return a + b
}

B.

type Integer int
func (a Integer) Add(b *Integer) Integer {
     return a + *b
}

C.

type Integer int
func (a *Integer) Add(b Integer) Integer {
     return *a + b
}

D.

type Integer int
func (a *Integer) Add(b *Integer) Integer {
     return *a + *b
}

参考答案：A

参考地址：https://studygolang.com/articles/9838