Aller au didacticiel de conversion des types de données de langue

Go n'effectue pas de conversion de type implicite des données et ne peut effectuer que des opérations de conversion manuellement. Jetons un coup d'œil à la méthode de conversion du type de données en langage go .

Opération de conversion simple

La façon de convertir les types de données est très simple.

valueOfTypeB = typeB(valueOfTypeA)

Par exemple :

// 浮点数
a := 5.0

// 转换为int类型
b := int(a)

Go permet la conversion entre deux types ayant la même structure sous-jacente. Par exemple :

// IT类型的底层是int类型
type IT int

// a的类型为IT，底层是int
var a IT = 5

// 将a(IT)转换为int，b现在是int类型
b := int(5)

// 将b(int)转换为IT，c现在是IT类型
c := IT(b)

Mais remarque :

1. Tous les types de données ne peuvent pas être convertis, par exemple, le type de chaîne "abcd" au format alphabétique peut être converti en int. Cela échouera certainement

2. Il est sûr de convertir une basse précision en haute précision. Cependant, la précision sera perdue lorsque les valeurs de haute précision seront converties en basse précision. Par exemple, convertissez int32 Convertissez en int16 et float32 en int

3. Cette méthode de conversion simple ne peut pas convertir int (float) et chaîne les uns vers les autres. Pour convertir entre des types volumineux, vous pouvez utiliser. Les fonctions fournies par le package strconv

strconv

Le package strconv fournit des fonctions de conversion de type entre les chaînes et les types de données simples. Les types simples peuvent être convertis en caractères Les chaînes peuvent également être converties en d’autres types simples.

Ce package fournit de nombreuses fonctions, qui sont grossièrement divisées en plusieurs catégories :

1. Convertir une chaîne en int : Atoi()

2. Convertir un int en chaîne : Itoa. ()

3. La fonction de classe ParseTP convertit la chaîne en type TP : ParseBool(), ParseFloat(), ParseInt(), ParseUint(). Étant donné que la conversion de chaîne vers d'autres types peut échouer, ces fonctions ont une deuxième valeur de retour indiquant si la conversion doit être effectuée. Modification réussie

4. La fonction de classe FormatTP convertit les autres types en chaîne : FormatBool(), FormatFloat(), FormatInt(), FormatUint()

5. La fonction de classe AppendTP est utilisée pour convertir TP en chaîne puis l'ajouter à une tranche : AppendBool(), AppendFloat(), AppendInt(), AppendUint()

et quelques autres fonctions qui sont fondamentalement inutilisées, voir le manuel officiel : allez doc strconv ou https://golang.org/pkg/strconv/.

Lorsque certains types ne peuvent pas être convertis, une erreur sera signalée. L'erreur renvoyée est le type d'erreur auto-défini dans le package strconv. Il existe deux sortes Erreur :

var ErrRange = errors.New("value out of 

range")
var ErrSyntax = errors.New("invalid syntax")

Par exemple, utiliser Atoi("a") pour convertir "a" en type int échoue naturellement. si print génère des informations d'erreur et affichera :

strconv.Atoi: parsing "a": invalid 

syntax

Conversion entre chaîne et int

La plus courante est la conversion entre chaîne et int :

1.int est converti en chaîne : Itoa()

// Itoa(): int -> string
println("a" + strconv.Itoa(32))  // a32

2.string est converti en int : Atoi()

func Atoi(s string) (int, error)

Puisque la chaîne ne peut pas être convertie en int, cette fonction a deux Return value : la première valeur de retour est convertie en int valeur, et la deuxième valeur de retour détermine si la conversion est réussie.

// Atoi(): string -> int
i,_ := strconv.Atoi("3")
println(3 + i)   // 6
// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
    println("converted failed")
}

Fonction de classe Parse

La fonction de classe Parse est utilisée pour convertir des chaînes en valeurs d'un type donné : ParseBool(), ParseFloat(), ParseInt() , ParseUint().

Étant donné que la conversion de chaîne vers d'autres types peut échouer, ces fonctions ont deux valeurs de retour, la première valeur de retour est enregistrée La valeur convertie, la deuxième valeur de retour détermine si la conversion est réussie.

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

ParseFloat() ne peut recevoir que des nombres à virgule flottante de type float64.

ParseInt() et ParseUint() ont 3 paramètres :

func ParseInt(s string, base int, bitSize int) 

(i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

Le paramètre bitSize indique vers quel bit d'int/uint convertir. Les valeurs valides sont 0, 8, 16, 32. , 64. Lorsque bitSize=0 heure, indiquant la conversion en type int ou uint. Par exemple, bitSize=8 signifie que le type de la valeur convertie est int8 ou uint8.

Le paramètre de base indique la méthode de base à utiliser pour analyser la chaîne donnée. Les valeurs valides sont 0 et 2-36. Quand base=0 , indiquant que le préfixe de la chaîne est utilisé pour déterminer dans quelle base analyser : ceux commençant par 0x sont analysés en hexadécimal, et ceux commençant par 0 Il est analysé au format octal et les autres sont analysés au format décimal.

Analyse "-42" en mode décimal et l'enregistre sous le type int64 :

i, _ := strconv.ParseInt("-42", 10, 

64)

Analyse "23" en mode quinaire et l'enregistre sous le type int64 :

i, _ := strconv.ParseInt("23", 5, 64)
println(i)    // 13

Parce que dans un système à 5 chiffres, 23 signifie porter deux fois et ajouter 3, donc le nombre décimal correspondant est 5*2+3=13.

Analysez 23 en hexadécimal et enregistrez-le sous le type int64 :

i, _ := strconv.ParseInt("23", 16, 64)
println(i)    // 35

Parce qu'en hexadécimal, 23 signifie porter 2 fois et ajouter 3, donc le nombre décimal correspondant est 16 *2+3=35 .

Analysez 23 en base 15 et enregistrez-le sous le type int64 :

i, _ := strconv.ParseInt("23", 15, 64)
println(i)    // 33

Parce qu'en base 15, 23 signifie porter 2 fois et ajouter 3, donc le nombre décimal correspondant est 15 *2+3 =33.

Fonction de classe Format

Formate le type donné en type chaîne : FormatBool(), FormatFloat(), FormatInt(), FormatUint().

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16)
s := strconv.FormatUint(42, 16)

FormatInt() et FormatUint() ont deux paramètres :

func FormatInt(i int64, base int) string
func FormatUint(i uint64, base int) string

La base du deuxième paramètre spécifie la base vers laquelle convertir le premier paramètre. La valeur valide est 2<=base< ;=36. . en spécifiant Lorsque le chiffre de base de est supérieur à 10, la valeur supérieure à 10 est représentée par les lettres a à z. Par exemple, en hexadécimal, les nombres 10 à 15 sont utilisés respectivement a-f signifie que dans le système hexadécimal, les valeurs 10 à 16 sont représentées respectivement par a-g.

Par exemple : FormatInt(-42, 16) signifie convertir -42 en un nombre hexadécimal, et le résultat de la conversion est -2a.

FormatFloat() a de nombreux paramètres :

func FormatFloat(f float64, fmt byte, prec, 

bitSize int) string

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制） 、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、 'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很 大时用'E'格式，否则'f'格式）。

prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小 数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则 代表使用最少数量的、但又必需的数字来表示f。

Append类函数

AppendTP类函数用于将TP转换成字符串后append到一个slice中：AppendBool()、 AppendFloat()、AppendInt()、AppendUint()。

Append类的函数和Format类的函数工作方式类似，只不过是将转换后的结果追加到一个 slice中。

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 声明一个slice
    b10 := []byte("int (base 10):")
    
    // 将转换为10进制的string，追加到slice中
    b10 = strconv.AppendInt(b10, -42, 10)
    fmt.Println(string(b10))

    b16 := []byte("int (base 16):")
    b16 = strconv.AppendInt(b16, -42, 16)
    fmt.Println(string(b16))
}

输出结果：

int (base 10):-42
int (base 16):-2a

更多golang知识请关注golang教 程栏目。

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!