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

![[file-20250410195451878.png]]

知识点2:defer与return谁先谁后

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

结论:return之后的语句先执行，defer后的语句后执行

知识点3:函数的返回值初始化

如

func DeferFunc1(i int)(t int){//t在函数起始处被初始化为对应类型的零值且作用域为整个函数。
}

![[file-20250410201204722.png]]

package main

import "fmt"

func DeferFunc1(i int) (t int) {

    fmt.Println("t = ", t)

    return 2
}

func main() {
    DeferFunc11(10)
}

结果

t =  0

只要声明函数的返回值变量名称，就会在函数初始化时为之赋值为0，而且在函数体作用域可见。

知识点4:有名函数返回值遇见defer情况

在没有defer的情况下，其实函数的返回就是与return一致的，但是有了defer就不一样了。

package main

import "fmt"

func returnButDefer() (t int) {  //t初始化0， 并且作用域为该函数全域

    defer func() {
        t = t * 10//return过后开始执行此时t的值变为10
    }()

    return 1
}

func main() {
    fmt.Println(returnButDefer())
}

结果

10

知识点5: defer遇见panic

触发defer的是遇见return(或者函数体到末尾)和遇见panic。总结就是函数退出触发defer
内层函数的defer+recover()捕获不到外层的panic
例如:

package main  
  
import "fmt"  
  
func main() {  
    func() {  
       defer func() {  
          if err := recover(); err != nil {  
             fmt.Println("aaaaa")  
          }  
       }()  
    }()  
    panic("kkkkk")  
}

defer遇到return![[file-20250410205645057.png]]
到遇到panic时，遍历本协程的defer链表，并执行defer。在执行defer过程中，遇到recover则停止panic，返回recocver处继续向下执行。没有遇到recover，遍历完本协程的defer链表后，向stderr抛出panic信息。
![[file-20250410210028605.png]]
A.defer遇到panic不捕获

package main

import (
    "fmt"
)

func main() {
    defer_call()

    fmt.Println("main 正常结束")
}

func defer_call() {
    defer func() { fmt.Println("defer: panic 之前1") }()
    defer func() { fmt.Println("defer: panic 之前2") }()

    panic("异常内容")  //触发defer出栈

	defer func() { fmt.Println("defer: panic 之后，永远执行不到") }()
}

result

defer: panic 之前2
defer: panic 之前1
panic: 异常内容
//... 异常堆栈信息

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 正常结束

defer最大的功能是panic后依然有效，所以defer可以保证一些资源一定会关闭，从而避免一些异常出现的问题

知识点6:defer中包含panic

package main

import (
    "fmt"
)

func main()  {

    defer func() {
       if err := recover(); err != nil{
           fmt.Println(err)
       }else {
           fmt.Println("fatal")
       }
    }()

    defer func() {
        panic("defer panic")
    }()

    panic("panic")
}

结果

defer panic

panic仅有最后一个可以被recover捕获
因为第一个执行的defer中的异常语句会覆盖main中的异常，然后被第二个执行的defer捕获

知识点7:defer下的函数参数包含子函数

package main

import "fmt"

func function(index int, value int) int {

    fmt.Println(index)

    return index
}

func main() {
    defer function(1, function(3, 0))
    defer function(2, function(4, 0))
}