Pourquoi comparer une tranche nulle à une interface{} aboutit-il à un résultat différent de la comparaison directe d'une tranche nulle à zéro ?

Passage d'une tranche nulle à l'interface : résoudre l'énigme

Dans Go, la distinction entre une tranche nulle et une valeur d'interface nulle{} peut conduire à des résultats inattendus. Considérez l'extrait de terrain de jeu suivant :

<code class="go">package main

import "fmt"

func main() {
    var i []int = nil
    yes(i) // true
    no(i)  // false
}

func yes(thing []int) {
    fmt.Println(thing == nil)
}

func no(thing interface{}) {
    fmt.Println(thing == nil)
}</code>

Pourquoi ces fonctions produisent-elles des résultats différents ?

Comprendre l'interface{}

Une variable d'interface{} ressemble à une structure avec deux champs : type et données. Dans ce cas, cela ressemble à {[]int (type), nil (data)}.

Nil Slice vs. Nil Interface

En oui, le nil la tranche est passée directement. La comparaison vérifie si nil est égal à nil, ce qui est évalué comme vrai.

En non, la tranche nil est enveloppée dans une interface{}, ce qui donne {[]int (type), nil (data)}. La comparaison de cette interface avec nil vérifie si le type est nul, ce qui n'est pas le cas. Par conséquent, le résultat est faux.

Raison de la différence

Ce comportement découle du fait que les interfaces encapsulent à la fois le type et la valeur. Comparer une interface à nil vérifie un type nul, tandis que comparer la valeur des données sous-jacentes est différent. Dans le cas de non, le type n'est pas nul, donc la comparaison renvoie faux.

Conclusion

Le comportement apparemment paradoxal est dû aux différences subtiles entre les tranches nulles et aucune interface. Comprendre cette distinction est crucial pour éviter toute confusion lorsque vous travaillez avec des interfaces dans Go.

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!