implémentation de l'assertion Golang

Golang est un langage doté de puissantes capacités de concurrence et de programmation système. Il s'agit d'un langage compilé conçu pour rendre la programmation plus rapide et plus facile. Les assertions sont un concept important dans Golang. Il permet aux programmeurs de « affirmer » le type d'une variable ou d'une interface lors de l'écriture du code, afin que le type correct puisse être vérifié au moment de l'exécution.

1. Qu'est-ce qu'une affirmation ?

L'assertion est une méthode de vérification de type qui peut déterminer si une variable ou une interface appartient à un certain type lors de l'exécution du code. En règle générale, les assertions sont utilisées pour vérifier l'exactitude du code après la compilation et pour détecter et résoudre les erreurs plus tôt.

Dans Golang, les assertions sont implémentées via le mot-clé "interface{}". interface{} représente une interface vide, qui peut accepter tous les types de données. Les interfaces vides peuvent être converties en d'autres types concrets à l'aide de conversions de types.

Par exemple, le code suivant utilise le mot-clé "interface{}" pour implémenter une assertion :

var i interface{} = "Hello"
s := i.(string)
fmt.Println(s)

Dans cet exemple, l'interface vide "interface{}" est utilisée pour enregistrer la chaîne "Bonjour". Ensuite, utilisez l'assertion "i.(string)" pour la convertir en type chaîne. Enfin, utilisez "fmt.Println(s)" pour imprimer la chaîne "Bonjour".

2. Trois méthodes d'assertion dans Golang

Dans Golang, il existe trois façons d'assertion, à savoir les déclarations de vérification de type, les déclarations d'assertion de type et les déclarations de jugement de type :

1. Déclarations de vérification de type

value, isType := someVariable.(Type)

Parmi elles, "valeur" "Représente une variable qui peut stocker la valeur convertie ; "isType" est une variable de type booléen, qui est définie sur True si la conversion réussit.

Par exemple :

var i interface{} = 55
s, ok := i.(string)
if ok {
  fmt.Printf("%q
", s)
} else {
  fmt.Printf("unexpected type %T
", i)
} 

Dans cet exemple, la variable "i" est une interface vide et stocke la valeur de type Integer "55". Convertissez-le en type chaîne en utilisant l'assertion "s, ok := i.(string)" et stockez la valeur convertie dans la variable "s" ; stockez le résultat de la conversion dans la variable "ok". Ensuite, le résultat de la conversion est jugé via l'instruction conditionnelle « if ok ». S'il s'agit d'un type chaîne, la chaîne « 55 » est imprimée, sinon « type inattendu » est imprimé.

2. Instruction d'assertion de type

value := someVariable.(Type)

L'instruction d'assertion de type est similaire à l'instruction de vérification de type, mais elle ne renvoie pas de valeur booléenne indiquant si la conversion a réussi. Si la conversion de type échoue, le programme plantera et renverra une erreur de panique.

Par exemple :

var i interface{} = 55
s := i.(string) // panic: interface conversion: interface is int, not string

Dans cet exemple, la variable "i" est une interface vide et stocke la valeur de type Integer "55". Bien que nous ayons l'intention de le convertir en type chaîne, l'assertion de type générera une erreur de panique, "conversion d'interface : l'interface est un entier, pas une chaîne".

3. Déclaration de jugement de type

switch someVariable.(type) {
case Type1:
    // someVariable 为Type1类型
case Type2:
    // someVariable 为Type2类型
default:
    // someVariable 不是Type1或Type2类型
}

L'instruction de jugement de type est similaire à l'instruction de vérification de type, mais elle ne renvoie pas de valeur booléenne si la conversion est réussie. En utilisant l'instruction de jugement de type, « switch someVariable.(type) » peut déterminer le type d'une variable et exécuter différents blocs de code en fonction de ses différents types.

Par exemple :

var i interface{} = 55
switch i.(type) {
case int:
  fmt.Println("i is an int")
case string:
  fmt.Println("i is a string")
default:
  fmt.Printf("Unexpected type %T", i)
}

Dans cet exemple, la variable "i" est une interface vide et stocke une valeur de type Integer. En utilisant l'instruction de jugement de type, « switch i.(type) » peut déterminer le type de la variable « i » et exécuter le bloc de code correspondant. Puisque "i" est un type entier, le code affichera "i est un int".

3. Conclusion

À Golang, l'assertion est une technologie couramment utilisée. Il permet aux programmeurs de vérifier le type de variables ou d'interfaces au moment de l'exécution pour éviter de graves conséquences causées ultérieurement par des erreurs de type. Dans cet article, nous présentons trois méthodes d'assertion dans Golang, notamment les instructions de vérification de type, les instructions d'assertion de type et les instructions de jugement de type. Chaque méthode d'assertion a ses avantages et ses limites, et les programmeurs peuvent choisir la méthode qui leur convient en fonction de leurs besoins réels.

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!