Go面试题解析

昨天AstaXie发布GoCN每日新闻(2017-07-19)含一篇Go面试题。阅读和评论量挺高，是测试面试者对Go本身基础概念理解掌握程度，以及Go实战经验。这也是在Go中容易遇到的坑，我也曾遇到过。于是快马加鞭，抢在原作者前发布Go面试题答案和解析说明，供大家参考。如有错误请指出，谢谢。

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

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

在线运行
答： 输出内容为：

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

解析：
考察对defer的理解，defer函数属延迟执行，延迟到调用者函数执行 return 命令前被执行。多个defer之间按LIFO先进后出顺序执行。
故考题中，在Panic触发时结束函数运行，在return前先依次打印:打印后、打印中、打印前 。最后由runtime运行时抛出打印panic异常信息。
需要注意的是，函数的return value 不是原子操作.而是在编译器中分解为两部分：返回值赋值 和 return 。而defer刚好被插入到末尾的return前执行。故可以在derfer函数中修改返回值。如下示例：

package main
import (
    "fmt"
)
func main() {
    fmt.Println(doubleScore(0))    //0
    fmt.Println(doubleScore(20.0)) //40
    fmt.Println(doubleScore(50.0)) //50
}
func doubleScore(source float32) (score float32) {
    defer func() {
        if score < 1 || score >= 100 {
            //将影响返回值
            score = source
        }
    }()
    score = source * 2
    return
    //或者
    //return source * 2
}

在线运行
该实例可以在defer中修改返回值score的值。具体参见官方文档

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

package main
import (
    "fmt"
)
type student struct {
    Name string
    Age  int
}
func pase_student() map[string]*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
    }
    return m
}
func main() {
    students := pase_student()
    for k, v := range students {
        fmt.Printf("key=%s,value=%v \n", k, v)
    }
}

在线运行
答：输出的均是相同的值：&{wang 22}
解析 因为for遍历时，变量stu指针不变，每次遍历仅进行struct值拷贝，故m[stu.Name]=&stu实际上一致指向同一个指针，最终该指针的值为遍历的最后一个struct的值拷贝。形同如下代码：

var stu student 
for _, stu = range stus {
    m[stu.Name] = &stu
}

修正方案，取数组中原始值的指针：

for i, _ := range stus {
    stu:=stus[i]
    m[stu.Name] = &stu
}

3、下面的代码会输出什么，并说明原因

func main() {
    runtime.GOMAXPROCS(1)
    wg := sync.WaitGroup{}
    wg.Add(20)
    for i := 0; i < 10; i++ {
        go func() {
            fmt.Println("i: ", i)
            wg.Done()
        }()
    }
    for i := 0; i < 10; i++ {
        go func(i int) {
            fmt.Println("i: ", i)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

在线运行
答： 将随机输出数字，但前面一个循环中并不会输出所有值。
解析：
实际上第一行是否设置CPU为1都不会影响后续代码。
2017年7月25日：将GOMAXPROCS设置为1，将影响goroutine的并发，后续代码中的go func()相当于串行执行。
两个for循环内部go func 调用参数i的方式是不同的，导致结果完全不同。这也是新手容易遇到的坑。
第一个go func中i是外部for的一个变量，地址不变化。遍历完成后，最终i=10。故go func执行时，i的值始终是10（10次遍历很快完成）。
第二个go func中i是函数参数，与外部for中的i完全是两个变量。尾部(i)将发生值拷贝，go func内部指向值拷贝地址。

4、下面代码会输出什么？

type People struct{}
func (p *People) ShowA() {
    fmt.Println("showA")
    p.ShowB()
}
func (p *People) ShowB() {
    fmt.Println("showB")
}
type Teacher struct {
    People
}
func (t *Teacher) ShowB() {
    fmt.Println("teacher showB")
}
func main() {
    t := Teacher{}
    t.ShowA()
}

在线运行
答： 将输出：

showA
showB

解析
Go中没有继承！ 没有继承！没有继承！是叫组合！组合！组合！
这里People是匿名组合People。被组合的类型People所包含的方法虽然升级成了外部类型Teacher这个组合类型的方法，但他们的方法(ShowA())调用时接受者并没有发生变化。
这里仍然是People。毕竟这个People类型并不知道自己会被什么类型组合，当然也就无法调用方法时去使用未知的组合者Teacher类型的功能。
因此这里执行t.ShowA()时，在执行ShowB()时该函数的接受者是People，而非Teacher。具体参见官方文档

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

func main() {
    runtime.GOMAXPROCS(1)
    int_chan := make(chan int, 1)
    string_chan := make(chan string, 1)
    int_chan <- 1
    string_chan <- "hello"
    select {
    case value := <-int_chan:
        fmt.Println(value)
    case value := <-string_chan:
        panic(value)
    }
}

在线运行
答： 有可能触发异常，是随机事件。
解析
单个chan如果无缓冲时，将会阻塞。但结合 select可以在多个chan间等待执行。有三点原则：

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

此考题中的两个case中的两个chan均能return，则会随机执行某个case块。故在执行程序时，有可能执行第二个case，触发异常。具体参见官方文档

6、下面代码输出什么？

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}
func main() {
    a := 1                                             //line 1
    b := 2                                             //2
    defer calc("1", a, calc("10", a, b))  //3
    a = 0                                              //4
    defer calc("2", a, calc("20", a, b))  //5
    b = 1                                              //6
}

在线运行
答 输出结果为：

10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

解析
在解题前需要明确两个概念：

• defer是在函数末尾的return前执行，先进后执行，具体见问题1。
• 函数调用时 int 参数发生值拷贝。

不管代码顺序如何，defer calc func中参数b必须先计算，故会在运行到第三行时，执行calc("10",a,b)输出：10 1 2 3得到值3，将cal("1",1,3)存放到延后执执行函数队列中。
执行到第五行时，现行计算calc("20", a, b)即calc("20", 0, 2)输出：20 0 2 2得到值2,将cal("2",0,2)存放到延后执行函数队列中。
执行到末尾行，按队列先进后出原则依次执行：cal("2",0,2)、cal("1",1,3) ，依次输出：2 0 2 2、1 1 3 4 。

7、请写出以下输入内容

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

在线运行
答： 将输出：[0 0 0 0 0 1 2 3]
解析
make可用于初始化数组，第二个可选参数表示数组的长度。数组是不可变的。
当执行make([]int,5)时返回的是一个含义默认值(int的默认值为0)的数组:[0,0,0,0,0]。而append函数是便是在一个数组或slice后面追加新的元素，并返回一个新的数组或slice。
这里append(s,1,2,3)是在数组s的继承上追加三个新元素:1、2、3，故返回的新数组为[0 0 0 0 0 1 2 3]

8、下面的代码有什么问题?

type UserAges struct {
    ages map[string]int
    sync.Mutex
}
func (ua *UserAges) Add(name string, age int) {
    ua.Lock()
    defer ua.Unlock()
    ua.ages[name] = age
}
func (ua *UserAges) Get(name string) int {
    if age, ok := ua.ages[name]; ok {
        return age
    }
    return -1
}

在线运行
答： 在执行 Get方法时可能被panic
解析
虽然有使用sync.Mutex做写锁，但是map是并发读写不安全的。map属于引用类型，并发读写时多个协程见是通过指针访问同一个地址，即访问共享变量，此时同时读写资源存在竞争关系。会报错误信息:“fatal error: concurrent map read and map write”。
可以在在线运行中执行，复现该问题。那么如何改善呢? 当然Go1.9新版本中将提供并发安全的map。首先需要了解两种锁的不同：

1. sync.Mutex互斥锁
2. sync.RWMutex读写锁，基于互斥锁的实现，可以加多个读锁或者一个写锁。

利用读写锁可实现对map的安全访问，在线运行改进版 。利用RWutex进行读锁。

type RWMutex
    func (rw *RWMutex) Lock() 
    func (rw *RWMutex) RLock()
    func (rw *RWMutex) RLocker() Locker
    func (rw *RWMutex) RUnlock()
    func (rw *RWMutex) Unlock()

9、下面的迭代会有什么问题？

func (set *threadSafeSet) Iter() <-chan interface{} {
    ch := make(chan interface{})
    go func() {
        set.RLock()
        for elem := range set.s {
            ch <- elem
        }
        close(ch)
        set.RUnlock()
    }()
    return ch
}

在线运行
答： 内部迭代出现阻塞。默认初始化时无缓冲区，需要等待接收者读取后才能继续写入。
解析
chan在使用make初始化时可附带一个可选参数来设置缓冲区。默认无缓冲，题目中便初始化的是无缓冲区的chan，这样只有写入的元素直到被读取后才能继续写入，不然就一直阻塞。
设置缓冲区大小后，写入数据时可连续写入到缓冲区中，直到缓冲区被占满。从chan中接收一次便可从缓冲区中释放一次。可以理解为chan是可以设置吞吐量的处理池。
来自社区fiisio的说明

ch := make(chan interface{}) 和 ch := make(chan interface{},1)是不一样的
无缓冲的 不仅仅是只能向 ch 通道放 一个值 而是一直要有人接收，那么ch <- elem才会继续下去，要不然就一直阻塞着，也就是说有接收者才去放，没有接收者就阻塞。
而缓冲为1则即使没有接收者也不会阻塞，因为缓冲大小是1只有当 放第二个值的时候 第一个还没被人拿走，这时候才会阻塞

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 = "You are a good boy"
    } else {
        talk = "hi"
    }
    return
}
func main() {
    var peo People = Stduent{}
    think := "bitch"
    fmt.Println(peo.Speak(think))
}

在线运行
答： 编译失败，值类型 Student{} 未实现接口People的方法，不能定义为 People类型。
解析
考题中的 func (stu *Stduent) Speak(think string) (talk string) 是表示结构类型*Student的指针有提供该方法，但该方法并不属于结构类型Student的方法。因为struct是值类型。
修改方法：

• 定义为指针 go var peo People = &Stduent{}
• 方法定义在值类型上,指针类型本身是包含值类型的方法。 go func (stu Stduent) Speak(think string) (talk string) { //... }

11. 在go中，new和make的区别

关于new

new 内置函数分配内存。第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针

• new 的作用是初始化一个指向类型的指针（*T）
• new是内奸函数，函数定义 func new(Type) *Type
• 使用new来分配空间。
• 传递给new的是一个类型，不是一个值；返回值是指向这个新分配的`零值的指针。

关于make

make内置函数分配并初始化类型为slice、map或chan(仅)的对象。
与new一样，第一个参数是类型，而不是值。
与new不同，make的返回类型与其参数的类型相同，而不是指向它的指针。

结果的规格取决于类型:

• Slice: size指定长度。切片的容量等于它的长度。可以提供第二个整型参数来指定不同的容量;

它必须不小于长度。例如，make([]int, 0,10)分配一个大小为10的底层数组，并返回由这个底层数组支持的长度为0、容量为10的片。

• Map: 一个空映射被分配了足够的空间来容纳指定数量的元素。大小可以省略，在这种情况下，分配一个小的初始大小。
• 通道: 通道的缓冲区用指定的缓冲区容量初始化。如果为0，或者省略大小，则通道未缓冲。
• make的作用是为 slice, map、chan 初始化并返回引用（T）
• make是内那家函数，函数定义 func make(Type, size IntegerType) Type

1.2 go中 Printf、Sprintf、Fprintf 函数的区别用法是什么