Les instances d'erreur nulles ne s'affichent pas comme nulles

Pour comprendre les comparaisons d'interfaces, il est essentiel de reconnaître qu'elles évaluent à la fois le type et la valeur.

Considérez l'extrait de code :

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

Ici, on s'attend à "L'erreur n'est pas nulle" puisque g est nul. Cependant, en raison des comparaisons d'interface, nous obtenons "L'erreur est nulle". En effet, (*Goof)(nil) a un type différent de error(nil).

Pour résoudre ce problème, vous pouvez déclarer var err error au lieu de var g *Goof. Alternativement, si votre fonction renvoie une erreur, renvoyez simplement nil.

Pour plus de précisions, les comparaisons d'interface vérifient si les types sont identiques, et non si un type implémente une interface. En tant que tel, l'exemple suivant démontre que même des interfaces non nulles avec les mêmes données sous-jacentes peuvent être considérées comme inégales en raison de différents types :

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