Golang Casting Exemples

Exemple 1 : Casting de type de base Golang

Commençons par l'exemple de transtypage direct et de base dans Go car nous avons besoin d'un transtypage pour modifier le type de la variable, n'importe où.

Ici, nous commençons par la fonction principale en déclarant une variable nommée « x » de type « int » et lui attribuons la valeur 31. Ensuite, la variable « y » est déclarée à l'aide de l'opérateur d'affectation abrégé « := ». Le type de 'y' est automatiquement déterminé à partir de l'expression sur le côté droit qui est le résultat de la conversion de 'x' en 'float64'. Ainsi, dans ce programme, la valeur de 'x' est convertie en 'float64' et est affectée à 'y'.

Les résultats récupérés du casting de base dans Go s'affichent comme suit :

Exemple 2 : Casting de type implicite Golang

La conversion de type implicite n'est pas autorisée entre différents types. Go applique un typage fort, ce qui signifie que nous ne pouvons pas attribuer ou utiliser directement une valeur d'un type comme un autre type sans conversion explicite. Dans ce qui suit, nous essayons d'effectuer le casting implicite qui génère l'exception par Go :

Voici le code qui commence par la fonction main() où une variable 'integer' est déclarée avec le type 'int'. La valeur attribuée à la variable 'entier' est 9,08, qui est un nombre à virgule flottante. Étant donné que nous tentons d'affecter une valeur à virgule flottante directement à une variable entière, cela entraîne une erreur de non-concordance de type. Ensuite, nous utilisons la fonction 'printf' du package 'fmt' pour imprimer la valeur de la variable 'integer' en utilisant le spécificateur de format '%g'.

Comme prévu, le casting de type implicite n'est pas acceptable dans Golang. Le cast de type implicite précédent génère l'erreur suivante :

Exemple 3 : Casting de type explicite Golang

La conversion de type explicite nous permet de convertir en toute sécurité les valeurs entre types compatibles tout en indiquant explicitement une intention. Cela garantit que nous sommes conscients de la conversion de type et aide à prévenir les erreurs de type accidentelles. Considérez le casting explicite suivant :

Ici, une variable 'floatVal' est créée avec le type 'float32', et on lui attribue la valeur '6.75'. Ensuite, une variable « intVal » est déclarée avec le type « int ». Pour affecter la valeur de floatVal à intVal, la conversion de type est utilisée. Pour transformer le floatVal en une valeur entière, la fonction 'int' est utilisée avec floatVal comme entrée. Après cela, le 'fmt.Printf('Float Value is %g\n', floatVal)' imprime la valeur de floatVal en utilisant le spécificateur de format %g qui convient à l'impression des valeurs à virgule flottante. Alors que la ligne de code 'fmt.Printf('Integer Value is %d', intVal)' imprime la valeur de intVal en utilisant le spécificateur de format %d qui convient à l'impression des valeurs entières.

La sortie suivante génère les valeurs pour floatVal et intVal après le cast :

Exemple 4 : Casting de type Golang pour obtenir la moyenne

Ensuite, nous effectuons le casting pour obtenir le nombre moyen à partir des valeurs données. Passons en revue le code source qui est fourni dans ce qui suit :

Ici, nous déclarons initialement trois variables. Le 'total' est une variable entière qui est initialisée avec la valeur de 900. Le 'MyNumber' est une variable entière qui est initialisée avec la valeur de 20. La moyenne calculée est ensuite stockée dans la variable float32 'average'. La formule moyenne est ensuite donnée pour effectuer le calcul. Pour garantir que la division est effectuée en tant que division à virgule flottante, les valeurs de 'total' et 'MyNumber' sont converties en float32 à l'aide de la conversion de type. La moyenne calculée est affectée à la variable « moyenne ». Enfin, la chaîne de format '%f\n' utilisée dans la fonction 'printf' spécifie qu'une valeur flottante doit être imprimée, suivie d'un caractère de saut de ligne.

La valeur résultante en tant que moyenne est récupérée après avoir impliqué le casting de type dans le code précédent :

Exemple 5 : Golang Int et diffusion de type chaîne

De plus, Go propose également la diffusion entre les types Int et String. Nous pouvons accomplir cela en utilisant la fonction du package strconv.

Voici le code qui commence par la déclaration de deux variables. Le « str » est une variable de chaîne qui est initialisée avec la valeur de « 1999 » et le « entier » est une variable entière qui est initialisée avec la valeur de « 1999 ». Après cela, la fonction « strconv.Atoi() » est utilisée pour convertir la chaîne « str » en une valeur entière. La valeur renvoyée de 'v' représente l'entier converti et l'identifiant '_' vide est utilisé pour ignorer toute erreur potentielle renvoyée par Atoi().

Ensuite, la fonction strconv.Itoa() est utilisée pour transformer l'entier en une valeur de chaîne. La valeur renvoyée qui est 'toStr' représente la chaîne convertie.

La sortie affiche la conversion de la chaîne « 1999 » en un entier, puis revient à une chaîne qui produit la valeur d'origine de « 1999 » :

Exemple 6 : Casting de type Golang entre chaîne et octets

De plus, le casting en Go peut également être effectué dans les types chaîne et octet. Les codes suivants illustrent la conversion entre les chaînes et les tranches d'octet :

Ici, les variables sont d'abord déclarées comme 'myStr' et 'b1' qui sont initialisées avec certaines valeurs. Ensuite, l'expression []byte(myStr) convertit la chaîne 'myStr' en une tranche d'octets à l'aide de la conversion de type. Il affecte la tranche d'octets résultante à la variable 'b1'. Après cela, l'expression 'chaîne (b1)' reconvertit la tranche d'octets b1 en une chaîne à l'aide de la conversion de type. Il affecte la chaîne résultante à la variable 'toString'.

La sortie montre la conversion entre la chaîne 'Hey There' et sa représentation de tranche d'octets correspondante dans ce qui suit :

Exemple 7 : Casting de type Golang pour obtenir la racine carrée

Maintenant, nous effectuons le casting dans Go pour trouver les résultats de la racine carrée. Le code est placé comme suit :

Ici, la variable 'n' est déclarée comme un int et attribue la valeur de '144'. La variable 'SqrtN' est déclarée en tant que float64 et stocke la racine carrée calculée de 'n'. Ensuite, la fonction math.Sqrt() est déployée pour calculer la racine carrée de « n ». Puisque math.Sqrt() attend un argument float64, et la valeur de 'n' est convertie en float64 en utilisant float64(n). Après cela, la chaîne de format « Racine carrée de %d est %.2f\n » appelle la fonction « printf » qui spécifie une valeur entière (%d) et une valeur à virgule flottante (%.2f). Le spécificateur de précision '.2' dans '%.2f' garantit que la racine carrée est imprimée avec deux décimales.

La sortie suivante est extraite et indique la racine carrée de la valeur donnée :

Conclusion

Le casting en Go est abordé avec des exemples distincts qui sont tous exécutables. Gardez à l'esprit que dans Go, le transtypage est explicite, ce qui impose un typage fort et favorise la clarté et la fiabilité du code.