在日常工作中，我們經常使用 err != nil 來判斷程序或函數是否報錯，或者使用 defer {recover = err} 來判斷是否有 panic 嚴重錯誤，但稍不注意，很容易掉進 err shadow 的陷阱。

1. 變量作用域

package main

import "fmt"

func main() {
    x := 100
    func() {
        x := 200 // x will shadow outer x
        fmt.Println(x)
    }()

    fmt.Println(x)
}

輸出如下：

200
100

結果分析：
x 變量在 func 裏面打印為 200，在外層打印為 100，這就是變量的作用域(variable scope)。func 裏面的變量 x 是一個新變量，只不過與外層 x 重名了(variable redeclaration)，此時裏層 x 的作用域僅限於 func {} block，而外層 x 的作用域則是 main {} block，此時裏層變量 x 發生了 variable shadowing，外層 x 不受影響，依然是 100。

改一下寫法：

package main

import "fmt"

func main() {
    x := 100
    func() {
        x = 200 // x will override outer x
        fmt.Println(x)
    }()

    fmt.Println(x)
}

輸出如下：

200
200

此時，func 裏面的變量 x 僅僅是覆蓋了外層 x，並沒有定義新的變量，所以內外層輸出都是 200。

2. err shadow - 無名 error

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println("func err1:", test1())
}

func test1() error {
    var err error

    defer func() {
        fmt.Println("defer err1:", err)
    }()

    if _, err := os.Open("xxx"); err != nil {
        return err
    }

    return nil
}

輸出如下：

defer err1: <nil>
func err1: open xxx: no such file or directory

結果分析：
func test1 首先定義了 var err error 變量，但下面的 os.Open 報錯使用 err := 被局部 err shadow 了，雖然顯式使用了 return err 返回錯誤，但由於 test1() error 返回參數是無名的(unnamed variable)，導致 defer 中 err 獲取不到被 err shadow 的錯誤 err，取的仍然是外層初始化 var err error 值，所以輸出為 err1: <nil>。

只需要將第 19 行改一下，即可避免 err shadow：

if _, err = os.Open("xxx"); err != nil {
        return err
    }

輸出如下：

defer err1: open xxx: no such file or directory
func err1: open xxx: no such file or directory

3. err shadow - 有名 error

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println("func err2:", test2())
}

func test2() (err error) {

    defer func() {
        fmt.Println("defer err2:", err)
    }()

    if _, err := os.Open("xxx"); err != nil {
        return // return without err will compilation error
    }

    return
}

上面的 test2 運行會有編譯報錯，這是 go compiler 在編譯時做了 variable shadowing 檢查，發現有就直接編譯報錯。修改一下即可：

func main() {
    fmt.Println("func err3:", test3())
}

func test3() (err error) {

    defer func() {
        fmt.Println("defer err3:", err)
    }()

    if _, err := os.Open("xxx"); err != nil {
        return err
    }

    return
}

輸出如下：

defer err3: open xxx: no such file or directory
func err3: open xxx: no such file or directory

4. 嵌套 err shadow

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

func main() {
    fmt.Println("func err4:", test4())
}

func test4() (err error) {

    defer func() {
        fmt.Println("defer err4:", err)
    }()

    if _, err := os.Open("xxx"); err == nil {
        if err := json.Unmarshal([]byte("{}"), &struct{}{}); err == nil {
            fmt.Println("OK")
        }
    }

    return
}

輸出如下：

defer err4: <nil>
func err4: <nil>

結果分析：
func test4() 是一個有名返回 err error，則函數初始化時會 var err error 定義對應的有名變量(named variable)，但下面的 os.Open 或 json.Unmarshal 都使用了 err := 重定義 err 變量，造成了 err shadow，因此在函數退出時，外層 err 依然是 nil，defer 獲取也就是 nil。

改一下寫法即可：

func main() {
    fmt.Println("func err5:", test5())
}

func test5() (err error) {

    defer func() {
        fmt.Println("defer err5:", err)
    }()

    if _, err = os.Open("xxx"); err == nil {
        if err = json.Unmarshal([]byte("{}"), &struct{}{}); err == nil {
            fmt.Println("OK")
        }
    }

    return
}

輸出如下：

defer err5: open xxx: no such file or directory
func err5: open xxx: no such file or directory

5. 小結

本文通過幾個實例，分析了在實際工作中很容易出現的 err shadow 問題，究其本質原因主要是變量作用域引起的，在官方文檔中提到：An identifier declared in a block may be redeclared in an inner block. While the identifier of the inner declaration is in scope, it denotes the entity declared by the inner declaration.

另外，在函數返回值命名方面，我們需要考慮無名、有名參數的情況，在保證代碼邏輯正確的情況下，建議使用工具 go linter 或 go vet 來檢測編譯器沒檢測到的 variable shadowing，避免踩到坑。