Instâncias de erro nulas não exibidas como nulas

Para entender as comparações de interface, é crucial reconhecer que elas avaliam tanto o tipo quanto o valor.

Considere o snippet de código:

type Goof struct {}

func (goof *Goof) Error() string {
    return fmt.Sprintf("I'm a goof")
}

func TestError(err error) {
    if err == nil {
        fmt.Println("Error is nil")
    } else {
        fmt.Println("Error is not nil")
    }
}

func main() {
    var g *Goof // nil
    TestError(g) // expect "Error is nil"
}

Aqui, esperamos "Erro não é nulo", já que g é nulo. No entanto, devido a comparações de interface, obtemos "Erro nulo". Isso ocorre porque (*Goof)(nil) tem um tipo diferente de error(nil).

Para resolver isso, você pode declarar var err error em vez de var g *Goof. Alternativamente, se sua função retornar um erro, simplesmente retorne nil.

Para maiores esclarecimentos, as comparações de interface verificam se os tipos são idênticos, não se um tipo implementa uma interface. Como tal, o exemplo a seguir demonstra que mesmo interfaces não nulas com os mesmos dados subjacentes podem ser comparadas como desiguais devido a tipos diferentes:

package main

import "fmt"

type Bob int

func main() {
    var x int = 3
    var y Bob = 3
    var ix, iy interface{} = x, y
    fmt.Println(ix == iy)
}