日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Golang?Defer基礎操作詳解_Golang

作者：~龐貝 ? 更新時間： 2022-11-23 編程語言

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誰先誰后

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后的語句后執行

函數的返回值初始化

該知識點不屬于defer本身，但是調用的場景卻與defer有聯系，所以也算是defer必備了解的知識點之一。

如 ： func DeferFunc1(i int) (t int) {}

其中返回值t int，這個t會在函數起始處被初始化為對應類型的零值并且作用域為整個函數。

示例代碼

package main
import "fmt"
func DeferFunc1(i int) (t int) {
    fmt.Println("t = ", t)
    return 2
}
func main() {
    DeferFunc11(10)
}

結果

t = ?0

證明，只要聲明函數的返回值變量名稱，就會在函數初始化時候為之賦值為0，而且在函數體作用域可見。

有名函數返回值遇見defer情況

在沒有defer的情況下，其實函數的返回就是與return一致的，但是有了defer就不一樣了。

我們通過知識點2得知，先return，再defer，所以在執行完return之后，還要再執行defer里的語句，依然可以修改本應該返回的結果。

package main
import "fmt"
func returnButDefer() (t int) {  //t初始化0， 并且作用域為該函數全域
    defer func() {
        t = t * 10
    }()
    return 1
}
func main() {
    fmt.Println(returnButDefer())
}

該returnButDefer()本應的返回值是1，但是在return之后，又被defer的匿名func函數執行，所以t=t*10被執行，最后returnButDefer()返回給上層main()的結果為10

$ go run test.go
10

defer遇見panic

我們知道，能夠觸發defer的是遇見return(或函數體到末尾)和遇見panic。

根據知識點2，我們知道，defer遇見return情況如下：

那么，遇到panic時，遍歷本協程的defer鏈表，并執行defer。在執行defer過程中:遇到recover則停止panic，返回recover處繼續往下執行。如果沒有遇到recover，遍歷完本協程的defer鏈表后，向stderr拋出panic信息

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 之后，永遠執行不到") }()
}

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可以保證你的一些資源一定會被關閉，從而避免一些異常出現的問題。

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僅有最后一個可以被revover捕獲。

觸發panic(“panic”)后defer順序出棧執行，第一個被執行的defer中 會有panic(“defer panic”)異常語句，這個異常將會覆蓋掉main中的異常panic(“panic”)，最后這個異常被第二個執行的defer捕獲到。

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))
}

這里，有4個函數，他們的index序號分別為1，2，3，4。

那么這4個函數的先后執行順序是什么呢？這里面有兩個defer， 所以defer一共會壓棧兩次，先進棧1，后進棧2。 那么在壓棧function1的時候，需要連同函數地址、函數形參一同進棧，那么為了得到function1的第二個參數的結果，所以就需要先執行function3將第二個參數算出，那么function3就被第一個執行。同理壓棧function2，就需要執行function4算出function2第二個參數的值。然后函數結束，先出棧fuction2、再出棧function1.

所以順序如下：

1.defer壓棧function1，壓棧函數地址、形參1、形參2(調用function3) --> 打印3

2.defer壓棧function2，壓棧函數地址、形參1、形參2(調用function4) --> 打印4

3.defer出棧function2, 調用function2 --> 打印2

4.defer出棧function1, 調用function1–> 打印1

3
4
2
1

defer面試真題

了解以上6個defer的知識點，我們來驗證一下網上的真題吧。

下面代碼輸出什么？

package main
import "fmt"
func DeferFunc1(i int) (t int) {
	t = i
	defer func() {
		t += 3
	}()
	return t
}
func DeferFunc2(i int) int {
	t := i
	defer func() {
		t += 3
	}()
	return t
}
func DeferFunc3(i int) (t int) {
	defer func() {
		t += i
	}()
	return 2
}
func DeferFunc4() (t int) {
	defer func(i int) {
		fmt.Println(i)
		fmt.Println(t)
	}(t)
	t = 1
	return 2
}
func main() {
	fmt.Println(DeferFunc1(1))
	fmt.Println("................")
	fmt.Println(DeferFunc2(1))
	fmt.Println("................")
	fmt.Println(DeferFunc3(1))
	fmt.Println("................")
	DeferFunc4()
	/*
		4
		................
		1
		................
		3
		................
		0
		2
	*/
}

DeferFunc1：

func DeferFunc1(i int) (t int) {
    t = i
    defer func() {
        t += 3
    }()
    return t
}

1.將返回值t賦值為傳入的i，此時t為1

2.執行return語句將t賦值給t（等于啥也沒做）

3.執行defer方法，將t + 3 = 4

4.函數返回 4

因為t的作用域為整個函數所以修改有效。

DeferFunc2:

func DeferFunc2(i int) int {
    t := i
    defer func() {
        t += 3
    }()
    return t
}

1.創建變量t并賦值為1

2.執行return語句，注意這里是將t賦值給返回值，此時返回值為1（這個返回值并不是t）

3.執行defer方法，將t + 3 = 4

4.函數返回返回值1

也可以按照如下代碼理解

func DeferFunc2(i int) (result int) {
    t := i
    defer func() {
        t += 3
    }()
    return t
}

上面的代碼return的時候相當于將t賦值給了result，當defer修改了t的值之后，對result是不會造成影響的。

DeferFunc3:

func DeferFunc3(i int) (t int) {
    defer func() {
        t += i
    }()
    return 2
}

1.首先執行return將返回值t賦值為2

2.執行defer方法將t + 1

3.最后返回 3

DeferFunc4:

func DeferFunc4() (t int) {
    defer func(i int) {
        fmt.Println(i)
        fmt.Println(t)
    }(t)
    t = 1
    return 2
}

1.初始化返回值t為零值 0

2.首先執行defer的第一步，賦值defer中的func入參t為0

3.執行defer的第二步，將defer壓棧

4.將t賦值為1

5.執行return語句，將返回值t賦值為2

6.執行defer的第三步，出棧并執行

因為在入棧時defer執行的func的入參已經賦值了，此時它作為的是一個形式參數，所以打印為0；相對應的因為最后已經將t的值修改為2，所以再打印一個2

原文鏈接：https://blog.csdn.net/qq_53267860/article/details/126840279

欄目分類
最近更新