Pourquoi la comparaison d'une interface nulle avec « nil » échoue-t-elle dans Go ?

Interfaces et comparaisons de types dans Go

Dans Go, les interfaces fournissent un moyen de définir un ensemble commun de méthodes que différents types peuvent implémenter. Cependant, il est important de comprendre comment fonctionnent les comparaisons d'interface pour éviter un comportement inattendu.

Considérez le code suivant :

<code class="go">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"
}</code>

Dans cet exemple, nous créons un type Goof personnalisé qui implémente l'interface d'erreur. . On passe ensuite un pointeur nul de type *Goof vers une fonction TestError qui attend une erreur. Contre-intuitivement, le programme n'imprime pas "L'erreur n'est pas nulle."

En effet, les comparaisons d'interface vérifient non seulement la valeur mais également le type. Dans ce cas, l'instance nulle de *Goof est d'un type différent de celui de l'interface d'erreur. Par conséquent, la comparaison err == nil échoue.

Pour surmonter ce problème, il existe plusieurs options. La première consiste à déclarer err directement comme variable de type error :

<code class="go">var err error = g</code>

Une autre option consiste à renvoyer nil à partir de votre fonction si une erreur se produit :

<code class="go">func MyFunction() error {
    // ...

    if errorOccurred {
        return nil
    }

    // ...
}</code>

En comprenant comment les comparaisons d'interface travaillez, vous pouvez éviter les pièges potentiels et écrire du code Go plus efficace.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!