181-194

181. interface{} 是可以指向任意对象的 Any 类型，是否正确？

• A. false

• B. true

答：B

182. 下面的代码有什么问题？

type ConfigOne struct {
    Daemon string
}

func (c *ConfigOne) String() string {
    return fmt.Sprintf("print: %v", c)
}

func main() {
    c := &ConfigOne{}
    c.String()
}

答：无限递归循环，栈溢出。

解析：

知识点：类型的 String() 方法。如果类型定义了 String() 方法，使用 Printf()、Print() 、 Println() 、 Sprintf() 等格式化输出时会自动使用 String() 方法。

183. 定义一个包内全局字符串变量，下面语法正确的是？

• A. var str string

• B. str := ""

• C. str = ""

• D. var str = ""

答：A D

解析：

全局变量要定义在函数之外，而在函数之外定义的变量只能用 var 定义。短变量声明 := 只能用于函数之内。

184. 下面的代码有什么问题？

func main() {

    wg := sync.WaitGroup{}

    for i := 0; i < 5; i++ {
        go func(wg sync.WaitGroup, i int) {
            wg.Add(1)
            fmt.Printf("i:%d\n", i)
            wg.Done()
        }(wg, i)
    }

    wg.Wait()

    fmt.Println("exit")
}

解析：

知识点：WaitGroup 的使用。存在两个问题：

• 在协程中使用 wg.Add()；

• 使用了 sync.WaitGroup 副本；

修复代码：

func main() {

    wg := sync.WaitGroup{}

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Printf("i:%d\n", i)
            wg.Done()
        }(i)
    }

    wg.Wait()

    fmt.Println("exit")
}

或者：

func main() {

    wg := &sync.WaitGroup{}

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(wg *sync.WaitGroup,i int) {
            fmt.Printf("i:%d\n", i)
            wg.Done()
        }(wg,i)
    }

    wg.Wait()

    fmt.Println("exit")
}

185. 下面的代码输出什么？

func main() {
    var a []int = nil
    a, a[0] = []int{1, 2}, 9
    fmt.Println(a)
}

答：运行时错误

解析：

知识点：多重赋值。

多重赋值分为两个步骤，有先后顺序：

• 计算等号左边的索引表达式和取址表达式，接着计算等号右边的表达式；

• 赋值；

186. 下面代码中的指针 p 为野指针，因为返回的栈内存在函数结束时会被释放？

type TimesMatcher struct {
    base int
}

func NewTimesMatcher(base int) *TimesMatcher  {
    return &TimesMatcher{base:base}
}

func main() {
    p := NewTimesMatcher(3)
    fmt.Println(p)
}

• A. false

• B. true

答：A

解析：

Go语言的内存回收机制规定，只要有一个指针指向引用一个变量，那么这个变量就不会被释放（内存逃逸），因此在 Go 语言中返回函数参数或临时变量是安全的。

187. 下面这段代码输出什么？

func main() {
    count := 0
    for i := range [256]struct{}{} {
        m, n := byte(i), int8(i)
        if n == -n {
            count++
        }
        if m == -m {
            count++
        }
    }
    fmt.Println(count)
}

解析：

讨论 #8

知识点：数值溢出。当 i 的值为 0、128 是会发生相等情况，注意 byte 是 uint8 的别名。

188. 下面代码输出什么？

const (
    azero = iota
    aone  = iota
)

const (
    info  = "msg"
    bzero = iota
    bone  = iota
)

func main() {
    fmt.Println(azero, aone)
    fmt.Println(bzero, bone)
}

答：0 1 1 2

解析：

知识点：iota 的使用。这道题易错点在 bzero、bone 的值，在一个常量声明代码块中，如果 iota 没出现在第一行，则常量的初始值就是非 0 值。

189. 同级文件的包名不允许有多个，是否正确？

• A. true

• B. false

答：A

解析：

一个文件夹下只能有一个包，可以多个.go文件，但这些文件必须属于同一个包。

190. 下面的代码有什么问题，请说明。

type data struct {
    name string
}

func (p *data) print() {
    fmt.Println("name:", p.name)
}

type printer interface {
    print()
}

func main() {
    d1 := data{"one"}
    d1.print()

    var in printer = data{"two"}
    in.print()
}

答：编译报错

cannot use data literal (type data) as type printer in assignment:
data does not implement printer (print method has pointer receiver)

解析：

结构体类型 data 没有实现接口 printer。知识点：接口。

191. 函数执行时，如果由于 panic 导致了异常，则延迟函数不会执行。这一说法是否正确？

• A. true

• B. false

答：B

解析：

由 panic 引发异常以后，程序停止执行，然后调用延迟函数（defer），就像程序正常退出一样。

192. 下面代码输出什么？

func main() {
    a := [3]int{0, 1, 2}
    s := a[1:2]

    s[0] = 11
    s = append(s, 12)
    s = append(s, 13)
    s[0] = 21

    fmt.Println(a)
    fmt.Println(s)
}

答：

[0 11 12]
[21 12 13]

193. 下面这段代码输出什么？请简要说明。

func main() {
    fmt.Println(strings.TrimRight("ABBA", "BA"))
}

答：输出结果为""

解析：

题解 #4

strings.TrimRight的作用是把有包含第二个参数的组合项的对应字母都替换掉，比如"BA"的组合集合为{"BA", "AB", "A", "B"}； 但是它有一个中止条件，如果从右到左有一个字母或字母组合不为"BA"的排列组合集合中的元素，便会停止cut，把当前已cut完的字符串返回

194. 下面代码输出什么？

func main() {
    var src, dst []int
    src = []int{1, 2, 3}
    copy(dst, src) 
    fmt.Println(dst)
}

答：输出结果为[]

解析：

题解 #5

copy函数实际上会返回一个int值，这个int是一个size，计算逻辑为size = min(len(dst), len(src))，这个size的大小， 决定了src要copy几个元素给dst，由于题目中，dst声明了，但是没有进行初始化，所以dst的len是0，因此实际没有从src上copy到任何元素给dst