Comment puis-je gérer plusieurs cas dans les commutateurs de type Go sans obtenir d'erreurs « interface sans méthode » ?

Gestion de plusieurs cas dans les commutateurs de type dans Go

Les commutateurs de type fournissent un moyen d'activer le type d'une valeur d'interface dans Go. Cependant, lorsque vous tentez de gérer plusieurs cas dans un commutateur de type, vous pouvez rencontrer une erreur indiquant qu'une méthode spécifique n'est pas définie car l'interface n'a pas de méthode. Cela peut se produire lorsque l'expression de changement de type d'une valeur d'interface est suivie de plusieurs clauses case.

Par exemple, considérons le code suivant :

package main

import (
    "fmt"
)

type A struct {
    a int
}

func (this *A) test() {
    fmt.Println(this)
}

type B struct {
    A
}

func main() {
    var foo interface{}
    foo = A{}
    switch a := foo.(type) {
        case B, A:
            a.test()
    }
}

L'exécution de ce code entraînera une erreur :

panic: interface conversion: interface {} is interface with no methods

Cette erreur se produit car les commutateurs de type avec plusieurs clauses case attribuent le type de l'expression dans TypeSwitchGuard à la variable dans chaque clause. Puisque foo a le type interface{}, a aura également le type interface{} dans les deux cas, quel que soit le type sous-jacent réel de foo. Ceci, à son tour, conduit à ce que l'interface n'ait aucune méthode, y compris la méthode test(), qui était supposée dans le commutateur.

Pour résoudre le problème, on peut affirmer que foo a la méthode souhaitée en utilisant un type affirmation. Les assertions de type convertissent efficacement une valeur d'interface en un type spécifique si la valeur implémente l'interface. Une approche typique consiste à créer un nouveau type qui définit la méthode requise :

type tester interface {
    test()
}

Ensuite, dans l'instruction switch, vérifiez si foo satisfait l'interface et convertissez-la en type approprié avant d'accéder à sa méthode :

if a, ok := foo.(tester); ok {
    fmt.Println("foo has test() method")
    a.test()
}

En utilisant les assertions de type, vous pouvez gérer plusieurs cas dans les commutateurs de type même lorsque les types sous-jacents n'ont pas de méthode commune, garantissant que la méthode correcte est appelée pour le type réel de foo.

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!