1 题目（单选题）

如下Go语言程序的输出结果是（）

package main

import "fmt"

func f1(name string) string {

fmt.Println("in f1", name)

return name

}

func f2(name string) string {

fmt.Println("in f2", name)

return name

}

func f3() {

defer f2(f1("function"))

fmt.Println("in f3 function")

}

func main() {

f3()

}

in f1 function
in f3 function
in f2 function
in f1 function
in f2 function
in f3 function
in f3 function
in f1 function
in f2 function
in f3 function
in f2 function
in f1 function

2 实际答题情况

正确答案 A。

各个选项的选择率为：

A	20.2%
B	0.8%
C	78.2%
D	0.8%

3 知识点解读

defer 是 Go 语言中用于延迟执行函数调用的关键字，defer 语句主要包括下面这些知识点：

1) 延迟执行

defer语句会将紧跟其后的函数调用推迟到包含该defer语句的函数返回前执行。

这个特性使得程序员可以在不改变函数逻辑的情况下，确保在函数结束时执行特定操作。

例如：

package main

import "fmt"

func main() {

defer cleanUp()

fmt.Println("hello")

}

func cleanUp() {

fmt.Println("world")

}

运行结果为：

hello

world

2) 执行顺序

如果在一个函数中有多个defer语句，会按照后进先出（LIFO，Last In First Out）的原则执行，即最后声明的defer函数最先被执行，以此类推直至所有的defer函数都被执行完毕。举个例子：

package main

import "fmt"

func add(a, b int) {

fmt.Println("Result =", a + b)

}

func main() {

fmt.Println("Begin")

defer fmt.Println("End")

defer add(36, 64)

defer add(2, 8)

}

运行结果：

Begin

Result = 10

Result = 100

End

3) 与return配合使用

当 defer 与 return 同时存在时，先执行return语句，再执行defer语句。

下面例子演示了defer 与 return 执行的先后顺序：

package main

import "fmt"

func deferFunc() {

fmt.Println("defer func called")

}

func returnFunc() int {

fmt.Println("return func called")

return 0

}

func returnAndDefer() int {

defer deferFunc()

return returnFunc()

}

func main() {

returnAndDefer()

}

输出结果：

return func called

defer func called

可以看到，return 后面的语句先执行，defer 后面的语句后执行

4) 函数参数的值

在 defer 声明时，函数的参数会立即求值并被保存，但实际调用会延迟到包含 defer 语句的函数即将返回时执行。

package main

import "fmt"

func printIndex(index int, _ int) int {

fmt.Print(index)

return index

}

func main() {

defer printIndex(1, printIndex(3, 0))

defer printIndex(2, printIndex(4, 0))

}

这里有 4 次函数调用，index 分别为 1，2，3，4。

那么这 4 次函数的先后执行顺序是什么呢？这里面有两个 defer 语句，所以 defer 一共会压栈两次：先压 printIndex(1, printIndex(3, 0))，后压 printIndex(2, printIndex(4, 0))。

在压栈 printIndex(1, printIndex(3, 0)) 的时候，需要连同函数地址、函数形参一同进栈，为了得到 printIndex(1, printIndex(3, 0)) 的第二个参数的结果，所以需要先执行printIndex(3, 0)将第二个参数算出，于是 printIndex(3, 0) 就被第一个执行。

同理压栈 printIndex(2, printIndex(4, 0))，需要执行 printIndex(4, 0)，于是 printIndex(4, 0) 就被第二个执行。

执行顺序如下：

（1） defer 压栈 printIndex(1, printIndex(3, 0))，压栈函数地址、形参 1、形参 2 (调用 printIndex(3, 0)) –> 打印 3

（2） defer 压栈 printIndex(2, printIndex(4, 0))，压栈函数地址、形参 1、形参 2 (调用 printIndex(4, 0)) –> 打印 4

（3） defer 出栈 printIndex(2, printIndex(4, 0)), 调用 printIndex2 –> 打印 2

（4） defer 出栈 printIndex(1, printIndex(3, 0)), 调用 printIndex1 –> 打印 1

最终输出结果：3421