Comment convertir les types de données à Golang

La conversion de type dans GO doit être effectuée explicitement et ne peut pas être implicitement. Pour les types numériques, utilisez le type cible comme fonction de conversion, tel que INT64 (a), mais faites attention au débordement et à la perte de précision; La conversion entre les chaînes et les nombres nécessite des fonctions telles que ATOI, ParseInt, Parsefloat, ITOA et FormatFloat dans le package STRCONV et gérer les erreurs possibles; Les chaînes et les tranches d'octets peuvent être directement converties les unes aux autres via [] octets (s) et chaîne (b), adaptés aux opérations d'E / S et de réseau; La conversion du type d'interface {} (ou tout) dépend de l'assertion de type x. (Type) ou de type commutateur pour extraire en toute sécurité le type d'origine pour éviter la panique; Les structures ne peuvent être converties directement que lorsque les champs sont complètement cohérents, et il est généralement recommandé de copier ou d'utiliser manuellement les bibliothèques de mappage, tandis que les types personnalisés basés sur des types de base peuvent être convertis via des opérations de conversion explicites. En bref, GO nécessite que toutes les conversions doivent être explicites, garantissant la sécurité de type et réduisant les erreurs potentielles des conversions implicites.

La conversion des types de données dans GO (Golang) est une tâche courante, d'autant plus que GO est typiquement typique et n'autorise pas les conversions de type implicite, même entre des types similaires comme int et int64 . Vous devez convertir explicitement les valeurs lorsque vous vous déplacez entre différents types. Voici comment gérer les conversions de type communes dans GO.

1. Conversion entre les types numériques

GO nécessite un casting explicite pour les types numériques, même s'ils sont étroitement liés.

 var a int = 42
var b int64 = int64 (a)
var c float64 = float64 (a)
var d uint = uint (c) // être prudent: flotter à int troncise

• Utilisez le type cible comme fonction: TargetType(value)
• Soyez prudent avec les débordements et les troncatures (par exemple, la conversion d'un grand float64 en int peut perdre de précision ou envelopper)

Conversions numériques courantes:

• int ↔ int8 , int16 , int32 , int64
• int ↔ uint , uint32 , uint64
• int ↔ float32 , float64

⚠️ Validez toujours les plages pour éviter un comportement inattendu.

2. Conversion entre les chaînes et les nombres

Pour convertir les chaînes en numéros et vice versa, utilisez le package strconv .

Chaîne à numéro

 importer "strConv"

// chaîne à int
num, err: = strConv.oi ("123")
Si err! = Nil {
    log.fatal (err)
}

// ou plus de contrôle avec Parseint
i64, err: = strConv.ParseInt ("123", 10, 64) // base 10, taille bit 64
Si err! = Nil {
    log.fatal (err)
}
i: = int (i64)

// parsefloat
f, err: = strConv.Parsefloat ("3.14", 64)
Si err! = Nil {
    log.fatal (err)
}

• Atoi est un raccourci pour ParseInt(s, 10, 0)
• Le deuxième argument dans ParseInt est la base (par exemple, 10 pour décimal, 16 pour hex)
• Le troisième est de taille bit (0 signifie inférer, mais généralement 32 ou 64)

Numéro à la chaîne

 str: = strCconv.itoa (123) // int à la chaîne

// ou utiliser des fonctions de format
str = strConv.formatint (123, 10)
str = strConv.formatfloat (3.14, 'f', 2, 64) // format 'f', 2 décimales

• Itoa est court pour FormatInt(i, 10)
• FormatFloat permet le contrôle de la précision et du format ( 'f' , 'e' , 'g' )

3. Conversion entre les chaînes et les octets

Les cordes GO sont immuables, tandis que []byte est une tranche et mutable. La conversion est simple.

 S: = "Hello"
b: = [] octet (s)

// retour à la chaîne
S2: = chaîne (b)

• Utile lorsque vous travaillez avec des données d'E / S, de JSON ou de réseau
• Aucune importation nécessaire - Go permet une conversion directe entre string et []byte

Remarque: Lorsque vous traitez du texte non ASCII (par exemple, UTF-8), assurez-vous que votre logique respecte l'encodage.

4. Conversion à et depuis interface{} (tout)

Dans Go, tout type peut être affecté à interface{} (pre-go 1.18) ou any (Go 1.18). Pour extraire le type d'origine, utilisez un type d'affirmation ou de commutation de type.

Assertion de type

 var x any = "bonjour"
str, ok: = x. (String) // Affirmation de type sûr
Si ok {
    fmt.println (str)
} autre {
    fmt.println ("pas une chaîne")
}

• Utilisez value, ok := interface.(Type) pour éviter les paniques
• Si le type est faux, ok sera false

Type d'interrupteur

 func printType (v any) {
    Switch Val: = v. (Type) {
    Case String:
        fmt.println ("String:", Val)
    cas Int:
        fmt.println ("int:", val)
    case float64:
        fmt.println ("float64:", val)
    défaut:
        fmt.println ("type inconnu")
    }
}

Utile lors de la gestion des données dynamiques comme JSON Unmarshaling.

5. Convertir des structures et des types de personnalité

Vous pouvez convertir entre les types de structure s'ils ont la même structure sous-jacente.

 Tapez user struct {
    Chaîne de noms
    Âge int
}

type admin struct {
    Chaîne de noms
    Âge int
}

u: = utilisateur {"bob", 30}
a: = admin (u) // ne fonctionne que si les champs correspondent exactement

• Pas de pratique courante - Better pour copier les champs manuellement ou utiliser des bibliothèques comme mapper si nécessaire
• Ne fonctionne que si tous les champs correspondants sont identifiés au nom, au type et à l'ordre

Pour les types nommés personnalisés basés sur les primitives:

 Tapez l'utilisateur INT64

var id userId = userId (42)
var num int64 = int64 (id)

Résumé

• Utilisez la coulée directe pour les types numériques: TargetType(value)
• Utilisez strconv pour les conversions de chaîne / nombre
• Convertir entre string et []byte directement
• Utilisez des assertions ou des commutateurs de type pour interface{} ou any
• Soyez prudent avec les débordements, la perte de précision et les conversions non valides

La conversion de type dans GO est explicite et sûre lorsque vous faites attentivement. Gérez toujours les erreurs (en particulier dans strconv ) et validez les hypothèses sur les données.

Fondamentalement, Go vous fait réfléchir à ce que vous convertiez - il n'y a pas de coercition automatique, ce qui empêche de nombreux bugs.

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!