Comment effectuer une conversion de type de données dans Golang

Il n'y a pas de conversion de type implicite dans Golang. Toutes les conversions de type doivent être explicitement déclarées avec la syntaxe "valueOfTypeB = typeB(valueOfTypeA)". La conversion de type ne peut réussir que si la définition est correcte. Lors de la conversion d'un type avec une plage de valeurs plus grande vers un type avec une plage de valeurs plus petite, une perte de précision (troncation) se produira.

L'environnement d'exploitation de ce tutoriel : système windows10, GO 1.11.2, ordinateur thinkpad t480.

Conversion de type de données de langue Go

La conversion de type se produit lorsqu'une valeur est convertie d'un type à un autre type. Les langages statiques tels que c/c++ et Java fournissent une conversion de type implicite, mais c'est différent pour un système de type fort comme Golang ne prend pas en charge la conversion de type automatique ou la conversion de type implicite.

Comme il n'y a pas de conversion de type implicite dans le langage Go, toutes les conversions de type doivent être explicitement déclarées :

valueOfTypeB = typeB(valueOfTypeA)

signifie : 类型 B 的值 = 类型 B(类型 A 的值)

Exemple :

a := 5.0
b := int(a)

La conversion de type ne peut être définie que correctement La conversion est réussie, comme conversion d'un type avec une plage de valeurs plus petite en un type avec une plage de valeurs plus grande (conversion de int16 en int32). Une perte de précision (troncation) se produit lors de la conversion d'un type avec une plage plus grande vers un type avec une plage plus petite (conversion de int32 en int16 ou float32 en int).

Seules les variables du même type sous-jacent peuvent être converties entre elles (comme la conversion du type int16 en type int32). Des erreurs de compilation se produiront lorsque des variables de types sous-jacents différents sont converties les unes dans les autres (comme la conversion du type bool). au type int) :

package main
import (
        "fmt"
        "math"
)
func main() {
        // 输出各数值范围
        fmt.Println("int8 range:", math.MinInt8, math.MaxInt8)
        fmt.Println("int16 range:", math.MinInt16, math.MaxInt16)
        fmt.Println("int32 range:", math.MinInt32, math.MaxInt32)
        fmt.Println("int64 range:", math.MinInt64, math.MaxInt64)
        // 初始化一个32位整型值
        var a int32 = 1047483647
        // 输出变量的十六进制形式和十进制值
        fmt.Printf("int32: 0x%x %d\n", a, a)
        // 将a变量数值转换为十六进制, 发生数值截断
        b := int16(a)
        // 输出变量的十六进制形式和十进制值
        fmt.Printf("int16: 0x%x %d\n", b, b)
        // 将常量保存为float32类型
        var c float32 = math.Pi
        // 转换为int类型, 浮点发生精度丢失
        fmt.Println(int(c))
}

La description du code est la suivante :

• Les lignes 11 à 14 génèrent les plages numériques de plusieurs types entiers courants.

• Ligne 17, déclarez la variable a de type int32 et initialisez-la.

• Ligne 19, utilise le verbe %x de fmt.Printf pour afficher la valeur au format hexadécimal. Cette ligne affiche la valeur 32 bits d'un avant la conversion.

• Ligne 22, convertissez la valeur de a en type int16, c'est-à-dire convertissez du type entier signé 32 bits en type entier signé 16 bits, car la plage de valeurs du type int16 est plus petite que la plage de valeurs de int32 tapez , donc la valeur est tronquée (la précision est perdue).

• La ligne 24 génère la valeur de variable a convertie, qui est la valeur de b, et est également imprimée aux formats hexadécimal et décimal.

• Ligne 27, math.Pi est une constante du package math. Il n'a pas de type par défaut et sera automatiquement déduit en fonction du type réel où il est référencé. Ici, math.Pi est affecté à la variable c, donc le type est float32.

• Ligne 29, convertissez float32 en type int et en sortie.

La sortie du code est la suivante :

int8 range: -128 127
int16 range: -32768 32767
int32 range: -2147483648 2147483647
int64 range: -9223372036854775808 9223372036854775807
int32: 0x3e6f54ff 1047483647
int16: 0x54ff 21759
3

Selon le résultat de sortie, la plage de l'entier signé 16 bits est -32768~32767, et la valeur de la variable a, 1047483647, n'est pas dans cette plage. La valeur hexadécimale correspondante de 1047483647 est 0x3e6f54ff. Après la conversion en type int16, la longueur est raccourcie de moitié, c'est-à-dire qu'elle est réduite de moitié en hexadécimal et devient 0x54ff, et la valeur décimale correspondante est 21759.

Lorsqu'un nombre à virgule flottante est converti en nombre entier, la partie décimale sera supprimée et seule la partie entière sera conservée.

Pratique de conversion de type

Pratique 1

package main

import (
   "fmt"
)

// 演示 golang 中基本数据类型的转换
func main() {
   var i int32 = 100
   // 将 i => float
   var n1 float32 = float32(i)
   var n2 int8 = int8(i)
   var n3 int64 = int64(i) // 低精度 => 高精度
   fmt.Printf("i=%v n1=%v n2=%v n3=%v \n", i, n1, n2, n3)
   // 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
   fmt.Printf("i type is %T\n", i) // int32
   // 在转换中，比如将 int64  转成 int8 (-128---127) ，编译时不会报错，
   // 只是转换的结果是按溢出处理，和我们希望的结果不一样
   var num1 int64 = 999999
   var num2 int8 = int8(num1)
   fmt.Println("num2=", num2)
}

Résultats des tests

i=100 n1=100 n2=100 n3=100
i type is int32
num2= 63

Pratique 2

package main
import (
   "fmt"
   _ "fmt" // 如果我们没有使用到一个包，但是有想去掉，前面加一个 _ 表示忽略
)

func main() {
   // 小练习
   var n1 int32 = 12
   var n2 int64
   var n3 int8
   // n2 = n1 + 20  // int32 ---> int64 错误
   // n3 = n1 + 20  // int32 ---> int8 错误
   n2 = int64(n1) + 20  // 正确
   n3 = int8(n1) + 20  // 正确
   fmt.Println("n2=", n2, "n3=", n3)
}

Résultats des tests

n2= 32 n3= 32

P pratique 3

package main

import (
   "fmt"
   _ "fmt" // 如果我们没有使用到一个包，但是有想去掉，前面加一个 _ 表示忽略
)

func main() {
   var n1 int32 = 12
   var n3 int8
   var n4 int8
   n4 = int8(n1) + 127 // 编译通过，但是结果 不是 127+12 ,按溢出处理
   n3 = int8(n1) + 128 // 编译不过
   fmt.Println(n4, n3)
}

Résultats des tests

# command-line-arguments
.\main.go:23:16: constant 128 overflows int8

Plus pour la programmation connaissances connexes, veuillez visiter : Vidéo de programmation ! !

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!