1. Go斷言的使用

Go中的斷言用于判斷變量的類型，其使用形式如下所示：

value, ok := x.(T)

上面的代碼是判斷x是否為T類型的變量：

• 如果 T 的某個具體的類型，斷言會檢查 x 是否為該類型，如果是的話買就返回 x 以及一個布爾值true，反之返回一個false
• 如果 T 是接口類型，類型斷言會檢查 x 的動態(tài)類型是否滿足 T。如果檢查成功，返回值是一個類型為 T 的接口值，以及一個布爾值true，反之返回一個false
• 我們也可以不接受返回的布爾值，在這種情況下，如果斷言失敗，會直接panic，所以非常不推薦這種處理方式

另外，斷言和可以與switch配合使用

    switch a.(type) {
        case int:
        fmt.Println("the type of a is int")
        case string:
        fmt.Println("the type of a is string")
        case float64:
        fmt.Println("the type of a is float")
        default:
        fmt.Println("unknown type")
    }

2. 閉包的解讀

閉包是由函數(shù)和與其相關(guān)的引用環(huán)境組合而成的實體。

概念上說起來有些抽象，下面我們以一個具體的例子來理解。

func foo1(x int) func() {
  return func() {
    x = x + 1
    fmt.Printf("foo2 val = %d\n", x)
  }
}

f1 := foo1(1)
f1() // 2
f1() // 3

在上面的例子中，f1() 與他的變量x(值為1)共同組成了一個閉包，每次調(diào)用f1()，x的值就會+1并且打印。

從某種意義上來說，閉包延長了變量的生命周期（棧上分配改為了堆上分配）。

2.1 指針傳遞

func foo2(x *int) func() {
  return func() {
    *x = *x + 1
    fmt.Printf("foo2 val = %d\n", *x)
  }
}

x := 1
f1 := foo2(&x)
f2 := foo2(&x)
f1() // 2
f2() // 3

通過第一個例子，我們知道，函數(shù)以及其環(huán)境(傳入的變量)組成了閉包，這個時候，如果傳入的是一個指針，那么就會存在多個閉包共用一個變量的情況。

2.2 延遲綁定

閉包的延遲綁定，通俗地說，就是閉包的函數(shù)在第一次調(diào)用的時候才會與環(huán)境的變量進(jìn)行綁定，我們依然以上面提到的兩個函數(shù)為例子：

func foo1(x int) func() {
  return func() {
    x = x + 1
    fmt.Printf("foo2 val = %d\n", x)
  }
}

func foo2(x *int) func() {
  return func() {
    *x = *x + 1
    fmt.Printf("foo2 val = %d\n", *x)
  }
}

x := 1
f1 := foo1(x)
f2 := foo2(&x)
f2() // 2
f1() // 3

• 我們創(chuàng)建了f1與f2兩個閉包函數(shù)，以及變量 x 的值為1
• 在f1與f2創(chuàng)建的時候，變量并沒有與函數(shù)綁定
• 第一次調(diào)用f2()時，&x與其綁定，x的值+1，變?yōu)?
• 第一次調(diào)用f1()時，x與其綁定，這時x已經(jīng)變?yōu)?了，再+1，所以變?yōu)?

2.3 Go Routine的延遲綁定

我們在一個函數(shù)中啟動 Go Routine 調(diào)用另一個函數(shù)：

func show(v interface{}) {
    fmt.Printf("foo4 val = %v\n", v)
}
func foo4() {
    values := []int{1, 2, 3, 5}
    for _, val := range values {
        go show(val)
    }
}
?
foo4()
//foo3 val = 2
//foo3 val = 3
//foo3 val = 1
//foo3 val = 5

因為Go Routine的執(zhí)行順序是隨機并行的，因此執(zhí)行多次foo4()輸出的順序不一行相同，但是一定打印了“1，2，3，5”各個元素。

但是，如果我們以匿名函數(shù)的形式嘗試復(fù)現(xiàn)上面的邏輯，會發(fā)現(xiàn)：

func foo5() {
    values := []int{1, 2, 3, 5}
    for _, val := range values {
        go func() {
            fmt.Printf("foo5 val = %v\n", val)
        }()
    }
}

foo5()
//foo3 val = 5
//foo3 val = 5
//foo3 val = 5
//foo3 val = 5

其實這個問題的本質(zhì)同閉包的延遲綁定，或者說，這段匿名函數(shù)的對象就是閉包。在我們調(diào)用go func() { xxx }()的時候，只要沒有真正開始執(zhí)行這段代碼，那它還只是一段函數(shù)聲明。而在這段匿名函數(shù)被執(zhí)行的時候，才是內(nèi)部變量尋找真正賦值的時候。for-loop的遍歷幾乎是“瞬時”完成的，4個Go Routine真正被執(zhí)行在其后，所以會產(chǎn)生上面的情況。

到此這篇關(guān)于Golang 斷言與閉包使用解析的文章就介紹到這了,更多相關(guān)Go 斷言與閉包內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論