Comment puis-je éviter les assertions de type répétitives dans les commutateurs de type Go ?

Éviter les assertions de type dans les commutateurs de type Go

Dans Go, les commutateurs de type offrent un moyen pratique de gérer différents types d'objets dans une seule construction. Cependant, les assertions de type répétitives dans les cas peuvent devenir fastidieuses et verbeuses. Cet article résout ce problème en explorant une méthode alternative pour éliminer le besoin d'assertions de type explicites.

Le problème

Considérez l'extrait de code suivant :

switch question.(type) {
case interfaces.ComputedQuestion:
    handleComputedQuestion(question.(interfaces.ComputedQuestion), symbols)
case interfaces.InputQuestion:
    handleInputQuestion(question.(interfaces.InputQuestion), symbols)
}

Dans cet code, le type de la variable de question est affirmé soit à interfaces.ComputedQuestion, soit à interfaces.InputQuestion dans chaque cas. Cette assertion de type est nécessaire pour passer correctement l'objet question à la fonction appropriée.

La solution

La solution réside dans l'affectation du résultat du changement de type à une nouvelle variable, qui attribue automatiquement le type affirmé :

switch question := question.(type) {
case interfaces.ComputedQuestion:
    handleComputedQuestion(question, symbols)
case interfaces.InputQuestion:
    handleInputQuestion(question, symbols)
}

En attribuant question := question.(type) à la variable de question dans le commutateur de type, le type affirmé correct est attribué automatiquement, éliminant ainsi le besoin pour les assertions de type explicites. Cette technique améliore considérablement la lisibilité du code et réduit le risque d'erreurs.

Exemple concret

Considérez l'exemple simplifié suivant :

package main

func main() {
    var num interface{} = 5
    switch num := num.(type) {
    case int:
        println("num is an int", num)
    case string:
        println("num is a string", num)
    }
}

Dans cet exemple, le num La variable d'interface reçoit la valeur int 5. Le commutateur de type attribue num comme int et imprime l'instruction "num est un int" avec sa valeur. Si num se voyait attribuer une chaîne, l'instruction "num est une chaîne" serait imprimée à la place.

Conclusion

En utilisant la technique d'attribution du résultat d'un changement de type, les développeurs peuvent éviter le utilisation répétitive d'assertions de type dans le cas d'un changement de type dans Go. Cette technique simplifie le code, réduit les erreurs et améliore la lisibilité.

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!