defer的执行顺序
多个defer出现的时候,它是一个“栈”的关系,也就是先进后出。一个函数中,写在前面的defer会比写在后面的defer调用的晚。
package main
import "fmt"
func main() {
defer func1()
defer func2()
defer func3()
}
func func1() {
fmt.Println("A")
}
func func2() {
fmt.Println("B")
}
func func3() {
fmt.Println("C")
}
//输出结果:C B A
defer和return的先后顺序
return之后的语句先执行,defer后的语句后执行。
package main
import "fmt"
func deferFunc() int {
fmt.Println("defer func called")
return 0
}
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
defer 无名返回值 有名返回值
- 函数返回值初始化
该知识点不属于defer本身,但是调用的场景却与defer有联系,所以也算是defer必备了解的知识点之一。
如 : func DeferFunc1(i int) (t int) {}
其中返回值t int,这个t会在函数起始处被初始化为对应类型的零值并且作用域为整个函数。
package main
import "fmt"
func DeferFunc(i int) (t int) {
fmt.Println("t = ", t)
return 2
}
func main() {
DeferFunc(10)
}
//输出
//t = 0
- defer、return 和无名的返回值
package main
func main() {
name := run()
println("return: name = " + name)
}
func run() (string) {
name := "Paul"
defer sayHello(&name)
name = "John"
return name
}
func sayHello(name *string) {
*name = "George"
println("Hello " + *name)
}
// 输出
// Hello George
// return: name = John
- defer、return 和有名返回值
//传指针
package main
func main() {
name := run()
println("return: name = " + name)
}
func run() (x string) {
name := "Paul"
x = name
defer sayHello(&x)
name = "John"
return name
}
func sayHello(name *string) {
println("Hello " + *name)
*name = "George"
println("Hello " + *name)
}
//输出
//Hello John
//Hello George
//return: name = George
//传值
package main
func main() {
name := run()
println("return: name = " + name)
}
func run() (x string) {
name := "Paul"
x = name
defer sayHello(x)
name = "John"
return name
}
func sayHello(name string) {
println("Hello " + name)
name = "George"
println("Hello " + name)
}
//输出
//Hello Paul
//Hello George
//return: name = John
说明:defer,return 和返回值三者之间的执行逻辑
return最先执行,return负责将结果写入返回值中;接着defer开始执行一些收尾工作;最后函数携带当前返回值退出
defer 闭包
- 闭包是什么
闭包是由函数及其相关引用环境组合而成的实体,即
闭包=函数+引用环境
一般的函数都有函数名,但是匿名函数就没有。匿名函数不能独立存在,但可以直接调用或者赋值于某个变量。匿名函数也被称为闭包,一个闭包继承了函数声明时的作用域。在Golang中,所有的匿名函数都是闭包。
有个不太恰当的例子,可以把闭包看成是一个类,一个闭包函数调用就是实例化一个类。闭包在运行时可以有多个实例,它会将同一个作用域里的变量和常量捕获下来,无论闭包在什么地方被调用(实例化)时,都可以使用这些变量和常量。而且,闭包捕获的变量和常量是引用传递,不是值传递。
package main
func main() {
name := run()
println("return: name = " + name)
}
func run() (string) {
name := "Paul"
aFun := func() {
println("Hello " + name)
name = "George"
println("Hello " + name)
}
name = "John"
aFun()
bfunc:= func() {
println("Hello " + name)
name = "Bobbi"
println("Hello " + name)
}
bfunc()
return name
}
//输出
//Hello John
//Hello George
//Hello George
//Hello Bobbi
//return: name = Bobbi
- defer与闭包
package main
func main() {
name := run()
println("return: name = " + name)
}
func run() (x string) {
name := "Paul"
aFun := func() {
println("Hello " + x)
x = "George"
println("Hello " + x)
}
defer aFun()
name = "John"
return name
}
//输出
//Hello John
//Hello George
//return: name = George
package main
func main() {
name := run()
println("return: name = " + name)
}
func run() (x string) {
name := "Paul"
x = name
aFun := func(x string) {
println("Hello " + x)
x = "George"
println("Hello " + x)
}
defer aFun(x)
name = "John"
return name
}
//输出:
//Hello Paul
//Hello George
//return: name = John
defer panic recover
能够触发defer的是遇见return(或函数体到末尾)和遇见panic。
遇见panic的情况:遍历本协程的defer链表,并执行defer。在执行defer过程中:遇到recover则停止panic,返回recover处继续往下执行。如果没有遇到recover,遍历完本协程的defer链表后,向stderr抛出panic信息。
A. defer遇见panic,但是并不捕获异常的情况
package main
import (
"os"
"fmt"
"time"
)
func main() {
var user = os.Getenv("USER_")
go func() {
defer func() {
fmt.Println("defer here")
}()
if user == "" {
panic("should set user env.")
}
}()
time.Sleep(1 * time.Second)
fmt.Printf("get result %d\r\n", 1)
}
//输出
//defer here
//panic: should set user env.
说明:会发现defer中的字符串”defer here”打印出来了,而main流程中的”ger result”没有打印,说明panic坚守了自己的原则:
执行,且只执行,当前goroutine的defer
B.defer遇见panic,并捕获异常
package main
import (
"fmt"
)
func main() {
defer_call()
fmt.Println("main 正常结束")
}
func defer_call() {
defer func() {
fmt.Println("defer: panic 之前1, 捕获异常")
if err := recover(); err != nil {
fmt.Println(err)
}
}()
defer func() { fmt.Println("defer: panic 之前2, 不捕获") }()
panic("异常内容") //触发defer出栈
defer func() { fmt.Println("defer: panic 之后, 永远执行不到") }()
}
//输出
//defer: panic 之前2, 不捕获
//defer: panic 之前1, 捕获异常
//异常内容
//main 正常结束
参考:
Golang中的Defer必掌握的7知识点
Golang中defer、闭包以及命名返回值
Golang: 深入理解panic and recover
网友评论