Las instancias de error nulas no se muestran como nulas

Para comprender las comparaciones de interfaces, es fundamental reconocer que evalúan tanto el tipo como el valor.

Considere el fragmento 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"
}

Aquí, esperamos "El error no es nulo" ya que g es nulo. Sin embargo, debido a las comparaciones de interfaces, obtenemos "El error es nulo". Esto se debe a que (*Goof)(nil) tiene un tipo diferente que error(nil).

Para resolver esto, puede declarar var err error en lugar de var g *Goof. Alternativamente, si su función devuelve un error, simplemente devuelva nil.

Para mayor aclaración, las comparaciones de interfaces verifican si los tipos son idénticos, no si un tipo implementa una interfaz. Como tal, el siguiente ejemplo demuestra que incluso las interfaces no nulas con los mismos datos subyacentes pueden compararse como desiguales debido a diferentes tipos:

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