TOC

Comment convertir des types de données en un clic

introduction

Dans Go, les types de données sont utilisés pour classifier un type de données particulier, en déterminant les valeurs que vous pouvez affecter au type et les opérations que vous pouvez y exécuter. Lors de la programmation, il est parfois nécessaire de convertir des valeurs entre types afin de manipuler les valeurs d’une manière différente. Par exemple, vous devrez peut-être concaténer des valeurs numériques avec des chaînes ou représenter des décimales dans des nombres initialisés sous forme de valeurs entières. Les données générées par l'utilisateur se voient souvent automatiquement attribuer le type de données chaîne, même s'il s'agit de nombres; pour effectuer des opérations mathématiques dans cette entrée, vous devez convertir la chaîne en un type de données numérique.

Puisque Go est un langage de type statique,data types are bound to variablesest plutôt que des valeurs. Cela signifie que, si vous définissez une variable comme unint, il ne peut s'agir que d'unint; vous ne pouvez pas lui attribuer unstring sans convertir le type de données de la variable. La nature statique des types de données dans Go attribue encore plus d'importance à la conversion.

Ce didacticiel vous guidera dans la conversion de nombres et de chaînes, ainsi que des exemples vous permettant de vous familiariser avec différents cas d'utilisation.

Conversion de types de nombres

Go a plusieurs types numériques à choisir. Ils se divisent principalement en deux types généraux:integers etfloating-point numbers.

Il existe de nombreuses situations dans lesquelles vous souhaiterez peut-être effectuer une conversion entre types numériques. La conversion entredifferent sizes of numeric types peut aider à optimiser les performances pour des types spécifiques d'architecture système. Si vous avez un entier provenant d'une autre partie de votre code et que vous souhaitez effectuer une division dessus, vous pouvez convertir cet entier en un nombre flottant afin de préserver la précision de l'opération. De plus, travailler avec des durées de temps implique généralement une conversion de nombre entier. Pour résoudre ces situations, Go a destype conversions intégrés pour la plupart des types numériques.

Conversion entre types d'entiers

Go a beaucoup de types de données entiers à choisir. Quand utiliser l'un sur l'autre est généralement plus d'environperformance; cependant, il y aura des moments où vous devrez convertir d'un type entier à un autre. Par exemple, Go génère parfois automatiquement des valeurs numériques en tant queint, qui peuvent ne pas correspondre à votre valeur d'entrée. Si votre valeur d'entrée étaitint64, vous ne pourriez pas utiliser les nombresint etint64 dans la même expression mathématique tant que vous n'aurez pas converti leurs types de données pour correspondre.

Supposons que vous ayez unint8 et que vous deviez le convertir enint32. Vous pouvez le faire en l'enveloppant dans la conversion de typeint32(): 

var index int8 = 15

var bigIndex int32

bigIndex = int32(index)

fmt.Println(bigIndex)
Output15

Ce bloc de code définitindex comme un type de donnéesint8 etbigIndex comme un type de donnéesint32. Pour stocker la valeur deindex dansbigIndex, il convertit le type de données enint32. Ceci est fait en encapsulant la conversionint32() autour de la variableindex.

Pour vérifier vos types de données, vous pouvez utiliser l'instructionfmt.Printf et le verbe%T avec la syntaxe suivante: 

fmt.Printf("index data type:    %T\n", index)
fmt.Printf("bigIndex data type: %T\n", bigIndex)
Outputindex data type:    int8
bigIndex data type: int32

Comme cela utilise le verbe%T, l'instruction print renvoie le type de la variable et non la valeur réelle de la variable. De cette façon, vous pouvez confirmer le type de données converti.

Vous pouvez également convertir un entier de taille plus grande en un entier de taille plus petite: 

var big int64 = 64

var little int8

little = int8(big)

fmt.Println(little)
Output64

Gardez à l'esprit que lors de la conversion d'entiers, vous pouvez potentiellement dépasser la valeur maximale du type de données etwraparound: 

var big int64 = 129
var little = int8(big)
fmt.Println(little)
Output-127

Un enveloppement survient lorsque la valeur est convertie en un type de données trop petit pour la contenir. Dans l'exemple précédent, le type de données 8 bitsint8 ne disposait pas de suffisamment d'espace pour contenir la variable 64 bitsbig. Des précautions doivent toujours être prises lors de la conversion d'un type de données à grand nombre en un type de données à petit nombre afin de ne pas tronquer les données par accident.

Conversion d'entiers en flottants

La conversion d’entiers en nombres flottants dans Go est similaire à la conversion d’un type d’entier en un autre. Vous pouvez utiliser les conversions de type intégrées en encapsulantfloat64() oufloat32() autour de l'entier que vous convertissez: 

var x int64 = 57

var y float64 = float64(x)

fmt.Printf("%.2f\n", y)
Output57.00

Ce code déclare une variablex de typeint64 et initialise sa valeur à57. 

var x int64 = 57

Enveloppant la conversionfloat64() autour dex, la valeur de57 sera convertie en une valeur flottante de57.00. 

var y float64 = float64(x)

Le verbe d'impression%.2f indique àfmt.Printf de formater le flottant avec deux décimales.

Vous pouvez également utiliser ce processus sur une variable. Le code suivant déclaref comme égal à57, puis imprime le nouveau float: 

var f float64 = 57
fmt.Printf("%.2f\n", f)
Output57.00

En utilisantfloat32() oufloat64(), vous pouvez convertir des entiers en flottants. Ensuite, vous apprendrez à convertir les flottants en entiers.

Conversion de floats en entiers

Go peut convertir les floats en entiers, mais le programme perdra la précision du float.

L'emballage des flottants dansint(), ou l'un de ses types de données indépendants de l'architecture, fonctionne de la même manière que lorsque vous l'avez utilisé pour convertir d'un type entier à un autre. Vous pouvez ajouter un nombre à virgule flottante à l'intérieur des parenthèses pour le convertir en entier: 

var f float64 = 390.8
var i int = int(f)

fmt.Printf("f = %.2f\n", f)
fmt.Printf("i = %d\n", i)
Outputf = 390.80
i = 390

Cette syntaxe convertirait le float390.8 en entier390, en supprimant la décimale.

Vous pouvez également l'utiliser avec des variables. Le code suivant déclareb égal à125.0 etc égal à390.8, puis les affiche sous forme d'entiers. La déclaration de variable courte (:=) raccourcit la syntaxe: 

b := 125.0
c := 390.8

fmt.Println(int(b))
fmt.Println(int(c))
Output125
390

Lors de la conversion de flottants en nombres entiers avec le typeint(), Go coupe les nombres décimaux et restants d'un flottant pour créer un entier. Notez que, même si vous souhaitez arrondir 390,8 à 391, Go ne le fera pas via le typeint(). Au lieu de cela, il laissera tomber la décimale.

Nombres convertis par division

Lors de la division des types entiers dans Go, le résultat sera également un type entier, avec lemodulus, ou le reste, supprimé: 

a := 5 / 2
fmt.Println(a)
Output2

Si, lors de la division, l'un des types de nombre est un float, tous les types seront automatiquement déclarés comme float: 

    a := 5.0 / 2
    fmt.Println(a)
Output2.5

Cela divise le flottant5.0 par l'entier2, et la réponse2.5 est un flottant qui conserve la précision décimale.

Dans cette section, vous avez converti entre différents types de données numériques, y compris différentes tailles d’entiers et de nombres à virgule flottante. Ensuite, vous apprendrez à convertir des nombres et des chaînes.

Conversion avec des chaînes

Unstring est une séquence d'un ou plusieurs caractères (lettres, chiffres ou symboles). Les chaînes sont une forme courante de données dans les programmes informatiques et vous devrez peut-être convertir ces chaînes en nombres ou les nombres en chaînes assez souvent, en particulier lorsque vous prenez des données générées par l'utilisateur.

Conversion de nombres en chaînes

Vous pouvez convertir des nombres en chaînes en utilisant la méthodestrconv.Itoa du packagestrconv de la bibliothèque standard Go. Si vous transmettez un nombre ou une variable entre les parenthèses de la méthode, cette valeur numérique sera convertie en une valeur de chaîne.

Voyons d’abord la conversion des entiers. Pour convertir l'entier12 en une valeur de chaîne, vous pouvez passer12 dans la méthodestrconv.Itoa: 

package main

import (
    "fmt"
    "strconv"
)

func main() {
    a := strconv.Itoa(12)
    fmt.Printf("%q\n", a)
}

Lors de l'exécution de ce programme, vous recevrez le résultat suivant: 

Output"12"

Les guillemets autour du nombre 12 signifient que le nombre n'est plus un entier, mais une valeur de chaîne.

Vous avez utilisé l'opérateur d'affectation:= pour à la fois déclarer une nouvelle variable avec le nom dea et affecter la valeur renvoyée par la fonctionstrconv.Itoa(). Dans ce cas, vous avez attribué la valeur12 à votre variable. Vous avez également utilisé le verbe%q dans la fonctionfmt.Printf, qui indique à la fonction de citer la chaîne fournie.

Avec les variables, vous pouvez commencer à voir à quel point il peut être pratique de convertir des entiers en chaînes. Supposons que vous souhaitiez suivre l'évolution de la programmation quotidienne d'un utilisateur et saisir le nombre de lignes de code qu'il écrit à la fois. Vous souhaitez afficher ce commentaire à l'utilisateur et vous imprimerez simultanément des valeurs de chaîne et d'entier: 

package main

import (
    "fmt"
)

func main() {
    user := "Sammy"
    lines := 50

    fmt.Println("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
}

Lorsque vous exécutez ce code, le message d'erreur suivant s'affiche: 

Outputinvalid operation: ("Congratulations, " + user + "! You just wrote ") + lines (mismatched types string and int)

Vous ne pouvez pas concaténer des chaînes et des entiers dans Go, vous devrez donc convertir la variablelines en valeur de chaîne: 

package main

import (
    "fmt"
    "strconv"
)

func main() {
    user := "Sammy"
    lines := 50

    fmt.Println("Congratulations, " + user + "! You just wrote " + strconv.Itoa(lines) + " lines of code.")
}

Maintenant, lorsque vous exécutez le code, vous recevrez le résultat suivant qui félicite votre utilisateur pour ses progrès: 

OutputCongratulations, Sammy! You just wrote 50 lines of code.

Si vous souhaitez convertir un float en chaîne plutôt qu'un entier en chaîne, suivez les mêmes étapes et le même format. Lorsque vous passez un float dans la méthodefmt.Sprint, à partir du packagefmt dans la bibliothèque standard Go, une valeur de chaîne du float sera renvoyée. Vous pouvez utiliser la valeur float elle-même ou une variable: 

package main

import (
    "fmt"
)

func main() {
    fmt.Println(fmt.Sprint(421.034))

    f := 5524.53
    fmt.Println(fmt.Sprint(f))
}
Output421.034
5524.53

Vous pouvez tester pour vous assurer que tout est correct en concaténant une chaîne: 

package main

import (
    "fmt"
)

func main() {
    f := 5524.53
    fmt.Println("Sammy has " + fmt.Sprint(f) + " points.")
}
OutputSammy has 5524.53 points.

Vous pouvez être sûr que votre float a été correctement converti en chaîne car la concaténation a été effectuée sans erreur.

Conversion de chaînes en nombres

Les chaînes peuvent être converties en nombres à l'aide du packagestrconv de la bibliothèque standard Go. Le packagestrconv a des fonctions pour convertir les types de nombres entiers et flottants. C'est une opération très courante lors de l'acceptation d'une entrée par l'utilisateur. Par exemple, si vous aviez un programme qui demandait l'âge d'une personne, lorsqu'elle saisit la réponse, elle est capturée sous forme destring. Vous devrez alors le convertir enint pour faire des calculs avec lui.

Si votre chaîne ne contient pas de décimales, vous souhaiterez probablement la convertir en entier à l'aide de la fonctionstrconv.Atoi. Si vous savez que vous utiliserez le nombre comme flottant, vous utiliseriezstrconv.ParseFloat.

Prenons l’exemple de l’utilisateur Sammy qui garde trace des lignes de code écrites chaque jour. Vous voudrez peut-être manipuler ces valeurs avec des maths pour fournir des commentaires plus intéressants à l'utilisateur, mais ces valeurs sont actuellement stockées dans des chaînes: 

package main

import (
    "fmt"
)

func main() {
    lines_yesterday := "50"
    lines_today := "108"

    lines_more := lines_today - lines_yesterday

    fmt.Println(lines_more)
}
Outputinvalid operation: lines_today - lines_yesterday (operator - not defined on string)

Les deux valeurs numériques étant stockées dans des chaînes, vous avez reçu une erreur. L'opérande- pour la soustraction n'est pas un opérande valide pour deux valeurs de chaîne.

Modifiez le code pour inclure la méthodestrconv.Atoi() qui convertira les chaînes en nombres entiers, ce qui vous permettra de faire des calculs avec des valeurs qui étaient à l'origine des chaînes. Comme il existe un risque d'échec lors de la conversion d'une chaîne en un entier, vous devez vérifier les erreurs éventuelles. Vous pouvez utiliser une instructionif pour vérifier si votre conversion a réussi. 

package main

import (
    "fmt"
    "log"
    "strconv"
)

func main() {
    lines_yesterday := "50"
    lines_today := "108"

    yesterday, err := strconv.Atoi(lines_yesterday)
    if err != nil {
        log.Fatal(err)
    }

    today, err := strconv.Atoi(lines_today)
    if err != nil {
        log.Fatal(err)
    }
    lines_more := today - yesterday

    fmt.Println(lines_more)
}

Comme il est possible qu'une chaîne ne soit pas un nombre, la méthodestrconv.Atoi() renverra à la fois le type converti, ainsi qu'une erreur potentielle. Lors de la conversion delines_yesterday avec la fonctionstrconv.Atoi, vous devez vérifier la valeur de retour deerr pour vous assurer que la valeur a été convertie. Sierr n'est pasnil, cela signifie questrconv.Atoi n'a pas réussi à convertir la valeur de chaîne en entier. Dans cet exemple, vous avez utilisé une instructionif pour vérifier l'erreur, et si une erreur était renvoyée, vous avez utilisélog.Fatal pour consigner l'erreur et quitter le programme.

Lorsque vous exécutez le code précédent, vous obtiendrez: 

Output58

Maintenant, essayez de convertir une chaîne qui n'est pas un nombre: 

package main

import (
    "fmt"
    "strconv"
)

func main() {
    a := "not a number"
    b, err := strconv.Atoi(a)
    fmt.Println(b)
    fmt.Println(err)
}

Vous obtiendrez l'erreur suivante: 

Output0
strconv.Atoi: parsing "not a number": invalid syntax

Étant donné queb a été déclaré, mais questrconv.Atoi n'a pas réussi à effectuer une conversion, une valeur n'a jamais été affectée àb. Notez queb a la valeur de0. En effet, Go a des valeurs par défaut, appelées des valeurs zéro dans Go. strconv.Atoi fournit une erreur décrivant pourquoi il n'a pas réussi à convertir la chaîne également.

Conversion de chaînes et d'octets

Les chaînes en Go sont stockées sous forme de tranche d'octets. Dans Go, vous pouvez convertir entre une tranche d'octets et une chaîne en l'enveloppant dans les conversions correspondantes de[]byte() etstring(): 

package main

import (
    "fmt"
)

func main() {
    a := "my string"

    b := []byte(a)

    c := string(b)

    fmt.Println(a)

    fmt.Println(b)

    fmt.Println(c)
}

Ici, vous avez stocké une valeur de chaîne dansa, puis vous l'avez convertie en une tranche d'octetsb, puis converti la tranche d'octets en une chaîne en tant quec. Vous imprimez ensuitea,b etc à l'écran: 

Outputmy string
[109 121 32 115 116 114 105 110 103]
my string

La première ligne de sortie est la chaîne d'originemy string. La deuxième ligne imprimée est la tranche d'octet qui constitue la chaîne d'origine. La troisième ligne indique que la tranche d'octet peut être reconvertie en une chaîne et imprimée.

Conclusion

Ce didacticiel Go a montré comment convertir plusieurs types de données natifs importants en d'autres types de données, principalement via des méthodes intégrées. Le fait de pouvoir convertir des types de données dans Go vous permettra d’accepter des entrées utilisateur et de calculer des données numériques pour différents types de nombres. Par la suite, lorsque vous utiliserez Go pour écrire des programmes qui acceptent des données provenant de nombreuses sources différentes, telles que des bases de données et des API, vous utiliserez ces méthodes de conversion pour vous assurer de pouvoir exploiter vos données. Vous pourrez également optimiser le stockage en convertissant les données en types de données plus petits.

Si vous souhaitez une analyse plus approfondie des types de données dans Go, consultez notre article surUnderstanding Data Types in Go.

Related