Pourquoi le fallthrough n'est-il pas autorisé dans les commutateurs de type Go ?

Commutateurs de type par rapport aux instructions de commutation normales

Dans Go, le repli est autorisé dans les instructions de commutation normales, mais pas dans les commutateurs de type. Bien que la spécification Go n'explique pas explicitement la raison de cet écart, elle découle des différences sous-jacentes entre les deux constructions.

Instructions de commutation normales :

Dans un environnement normal Dans l'instruction switch, l'expression switch est évaluée à une seule valeur constante d'un type spécifique. Cette valeur est ensuite comparée aux constantes des instructions case. Si l'expression switch correspond à une constante, le bloc case correspondant est exécuté.

Le passage dans les instructions switch normales permet à l'exécution de passer au bloc case suivant, que l'expression switch corresponde ou non à la constante case. Ce comportement peut être utile lorsque des instructions case consécutives gèrent des scénarios associés.

Type Switches :

Tapez les commutateurs, d'autre part, évaluez l'expression du commutateur en une valeur d'interface. . Le type de la valeur d'interface est ensuite déterminé dynamiquement au moment de l'exécution et comparé aux types spécifiés dans les instructions case. En fonction de la correspondance, le bloc de cas correspondant est exécuté.

Contrairement aux instructions switch normales, le fallthrough n'est pas autorisé dans les commutateurs de type car il ne peut pas être appliqué de manière cohérente. La raison en est que l'expression switch dans un switch de type peut renvoyer une valeur d'interface de n'importe quel type. Si le fallthrough était autorisé, le type de l'expression switch changerait à mesure qu'elle passe d'un bloc de cas au suivant.

Par exemple, considérons le type switch suivant :

switch i := x.(type) {
case int:
    fmt.Println(i + 1)
    fallthrough // Error: cannot fallthrough in type switch
case float64:
    fmt.Println(i + 2.0)
}

Dans ce cas code, si l'expression switch x est un entier, le bloc case int sera exécuté. Si le repli était autorisé, l'exécution se poursuivrait jusqu'au bloc case float64. Cependant, à ce stade, le type de l'expression switch i changerait de int à float64.

Cela entraînerait une rupture de cohérence du type, car l'instruction case suivante s'attend à ce que l'expression switch soit un float64. Pour maintenir la cohérence, le remplacement n'est pas autorisé dans les commutateurs de type.

Approches alternatives pour la gestion des types conditionnels :

Si vous devez gérer plusieurs types de manière conditionnelle, il y a existe des approches alternatives pour taper des commutateurs :

• Utilisez plusieurs instructions switch normales : Créez des instructions switch distinctes pour chacune type que vous devez gérer.
• Utilisez l'assertion de type d'interface vide : Utilisez l'assertion de type .(interface{}) pour vérifier le type de la valeur de l'interface, puis gérez la valeur en conséquence .

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!