Comment l'assertion de type peut-elle être effectuée en Go avec des interfaces inconnues ?

Assertion de type dans Go pour les interfaces inconnues

Le processus de récupération de la valeur d'un objet par réflexion et exécution d'une assertion de type pour obtenir l'objet réel en utilisant des méthodes comme :

obj := new(User)
out := reflect.ValueOf(obj).Elem().Interface().(User)
fmt.Println(out == *obj) // true

est bien connue. Cependant, des défis surviennent lorsque le type de l'objet n'est pas connu à l'avance. Considérons une fonction qui accepte une interface inconnue :

func Foo(obj interface{}) bool {
    // out := reflect.ValueOf(obj).Elem().Interface().( ... )
    return out == *obj
}

func main() {
    obj := new(User)
    fmt.Println(Foo(obj))
}

Dans la fonction Foo, il n'est pas possible de déterminer le type d'objet transmis. Cela pose la question : comment effectuer une assertion de type dans de tels scénarios ?

La réponse réside dans la nature des assertions de type. Les assertions de type permettent de tirer parti de la vérification de type statique dans Go même lorsque vous travaillez avec des interfaces dont le type ne peut pas être vérifié de manière statique. Cette fonctionnalité fonctionne sur le principe suivant :

Étant donné une variable s typée statiquement de type t, le compilateur s'assure que s reste toujours de type t. Il refuse la compilation si s est utilisé comme un type différent, car cela violerait la garantie établie.

Maintenant, imaginez une variable d'interface i. Puisque son type ne peut pas être connu au moment de la compilation, le compilateur ne peut pas garantir que l'affectation de i à s ne brisera pas la garantie que s est de type t. Les assertions de type résolvent ce problème en déclarant : "Nous vérifierons au moment de l'exécution si les types correspondent et effectuerons l'affectation uniquement lorsqu'ils le feront." Le compilateur approuve cette approche car il espère que l'affectation n'aura lieu que lorsque les types seront compatibles, préservant ainsi la garantie que s soit de type t.

Essentiellement, cela signifie que ce qui suit se produit au moment de l'exécution :

if (i has type t) {
    s = i
} else {
    s = t{} // Zero value of t
}

L'impossibilité de la fonctionnalité demandée découle de la nécessité pour le compilateur de connaître le type par rapport auquel effectuer la vérification. Sans cette connaissance, le type statique de s ne peut pas être déterminé, ce qui rend le processus de vérification irréalisable.

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!