100道GO笔试_答案&解析&扩展_选择题21-44

时间：2021-04-19 15:15:15 阅读：0 评论：0 收藏：0 [点我收藏+]

关于整型切片的初始化，下面正确的是：
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初始化切片的时候，除了类型，长度也是必须的，而容量则是可选的，因此BC正确，A错误。D则是通过定义并初始化的方式，正确。

从切片中删除一个元素，下面的算法实现正确的是：

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
}

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
}

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
}

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
[解析&更多]：
这就没什么好说的了，只要对比一下D答案，自然就知道其他几个的问题所在。

对于局部变量整型切片 x 的赋值，下面定义正确的是：

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

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

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

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

[答案]：ACD
[解析&更多]：
基础语法，没什么好说的，自己看一下就可以了。

关于变量的自增和自减操作，下面语句正确的是：
A.

i := 1
i++

i := 1
j = i++

i := 1
++i

i := 1
i--

[答案]：AD
[解析&更多]：
golang中有i++,i--的操作，但是并没有++i,--i的操作，因此AD正确，C错误，B虽然在语法上没有问题，但是其将值赋值给了另一个变量，属于多此一举。

关于函数声明，下面语法错误的是：

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
[解析&更多]：
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
}

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

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

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

[答案]：AC
[解析&更多]：
观察调用函数，传入的参数是一个Integer,所以入参必然为Integer，排除B,D。
调用该函数的是一个*Integer,所以接收者为*Integer的C正确，但是A也能使用*Integer调用，所以A也正确。

如果 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
}

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

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

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

[答案]：A
[解析&更多]：
同上一题，只是这一次的调用者变成了Integer类型，所以不能使用*Integer接受，因此只有一个答案。A

关于 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
[解析&更多]：
基础知识

关于接口，下面说法正确的是：

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

[答案]：ABC
[解析&更多]：
ABC为基础知识，D在于在编译期间只需要判断接口是否能够接受赋值的类型即可判断是否可行。

关于 channel，下面语法正确的是：

A. var ch chan int
B. ch := make(chan int)
C. <- ch
D. ch <-

[答案]：ABC
[解析&更多]：
A：声明一个没有缓冲的channel
B：同上
C：接收数据（只是没有变量去接收）
D：发送数据，但是并知名发送内容，因此错误

关于同步锁，下面说法正确的是：

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

[答案]：ABC
[解析&更多]：

golang 中大多数数据类型都可以转化为有效的 JSON 文本，下面几种类型除外：

A. 指针
B. channel
C. complex
D. 函数

[答案]：BCD
[解析&更多]：

flag 是 bool 型变量，下面 if 表达式符合编码规范的是：

A. if flag == 1
B. if flag
C. if flag == false
D. if !flag

[答案]：BD
[解析&更多]：

value 是整型变量，下面 if 表达式符合编码规范的是：

A. if value == 0
B. if value
C. if value != 0
D. if !value

[答案]：AC
[解析&更多]：

关于函数返回值的错误设计，下面说法正确的是：

A. 如果失败原因只有一个，则返回 bool
B. 如果失败原因超过一个，则返回 error
C. 如果没有失败原因，则不返回 bool 或 error
D. 如果重试几次可以避免失败，则不要立即返回 bool 或 error

[答案]：ABCD
[解析&更多]：

关于异常设计，下面说法正确的是：

A. 在程序开发阶段，坚持速错，让程序异常崩溃
B. 在程序部署后，应恢复异常避免程序终止
C. 一切皆错误，不用进行异常设计
D. 对于不应该出现的分支，使用异常处理

[答案]：ABD
[解析&更多]：

关于 slice 或 map 操作，下面正确的是：

A.
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
10
m = make(map[string]int)
m["one"] = 1

[答案]：ACD
[解析&更多]：

关于 channel 的特性，下面说法正确的是：

A. 给一个 nil channel 发送数据，造成永远阻塞
B. 从一个 nil channel 接收数据，造成永远阻塞
C. 给一个已经关闭的 channel 发送数据，引起 panic
D. 从一个已经关闭的 channel 接收数据，如果缓冲区中为空，则返回一个零值

[答案]：ABCD
[解析&更多]：

关于无缓冲和有冲突的 channel，下面说法正确的是：

A. 无缓冲的 channel 是默认的缓冲为 1 的 channel
B. 无缓冲的 channel 和有缓冲的 channel 都是同步的
C. 无缓冲的 channel 和有缓冲的 channel 都是非同步的
D. 无缓冲的 channel 是同步的，而有缓冲的 channel 是非同步的

[答案]：D
[解析&更多]：

关于异常的触发，下面说法正确的是：

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

[答案]：ABCD
[解析&更多]：

关于 cap 函数的适用类型，下面说法正确的是：

A. array
B. slice
C. map
D. channel

[答案]：ABCD
[解析&更多]：

关于 map，下面说法正确的是：

A. map 反序列化时 json.unmarshal 的入参必须为 map 的地址
B. 在函数调用中传递 map，则子函数中对 map 元素的增加不会导致父函数中 map 的修改
C. 在函数调用中传递 map，则子函数中对 map 元素的修改不会导致父函数中 map 的修改
D. 不能使用内置函数 delete 删除 map 的元素

[答案]：A
[解析&更多]：