Go语言中nil接口与nil指针的陷阱解析

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    errChan := make(chan error)
    go func() {
        var e *exec.Error = nil // e 是一个类型为 *exec.Error，值为 nil 的指针
        errChan <- e            // 将 e 赋值给 error 接口并发送
    }()
    err := <-errChan
    if err != nil { // 此时 err 的类型为 *exec.Error，值为 nil，因此接口 err 不为 nil
        fmt.Printf("err != nil, but err = %v\n", err) // 输出: err != nil, but err = <nil>
    }
}

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    errChan := make(chan error)
    go func() {
        var e *exec.Error = nil
        if e == nil { // 判断具类型指针是否为 nil
            errChan <- nil // 如果是 nil，则发送一个真正的 nil error 接口
        } else {
            errChan <- e // 否则发送实际的错误
        }
    }()
    err := <-errChan
    if err != nil { // 此时 err 为 nil，条件不满足
        fmt.Printf("err != nil, but err = %v\n", err)
    } else {
        fmt.Println("err is truly nil") // 输出: err is truly nil
    }
}

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    errChan := make(chan error)
    go func() {
        var e *exec.Error = nil
        errChan <- e // 模拟第三方包发送一个指向 nil 的具类型错误
    }()

    err := <-errChan
    if err != nil {
        // 尝试进行类型断言
        if execErr, ok := err.(*exec.Error); ok && execErr == nil {
            fmt.Println("Received a *exec.Error pointer that is nil")
        } else {
            fmt.Printf("Received a non-nil error: %v\n", err)
        }
    } else {
        fmt.Println("Received a truly nil error")
    }
}

package main

import (
    "fmt"
    "os/exec"
    "reflect"
)

// IsNil 检查一个接口是否真正持有 nil 值
func IsNil(i interface{}) bool {
    // 首先检查接口本身是否为 nil (类型和值都为 nil)
    if i == nil {
        return true
    }

    // 获取接口的值部分
    v := reflect.ValueOf(i)

    // 只有特定类型的 Kind 才能是 nil
    switch v.Kind() {
    case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
        // 对于这些类型，可以使用 IsNil() 方法判断其是否为 nil
        return v.IsNil()
    }

    // 其他类型（如 int, string, struct 等）不能是 nil，所以直接返回 false
    return false
}

func main() {
    errChan := make(chan error)
    go func() {
        var e *exec.Error = nil
        errChan <- e // 发送一个指向 nil 的具类型错误
    }()

    err := <-errChan
    if IsNil(err) {
        fmt.Println("The error is logically nil (via reflect)") // 输出: The error is logically nil (via reflect)
    } else {
        fmt.Printf("The error is not nil: %v\n", err)
    }

    // 验证 IsNil 函数
    var s *string = nil
    fmt.Printf("IsNil(*string(nil)): %t\n", IsNil(s)) // true

    var i interface{} = nil
    fmt.Printf("IsNil(interface{}(nil)): %t\n", IsNil(i)) // true

    var nonNilErr error = fmt.Errorf("actual error")
    fmt.Printf("IsNil(actual error): %t\n", IsNil(nonNilErr)) // false
}