Cara melakukan penukaran jenis data dalam golang

Tiada penukaran jenis tersirat dalam golang Semua penukaran jenis mesti diisytiharkan secara eksplisit dengan sintaks "valueOfTypeB = typeB(valueOfTypeA)". Penukaran jenis hanya boleh berjaya jika definisi adalah betul Apabila menukar daripada jenis dengan julat nilai yang lebih besar kepada jenis dengan julat nilai yang lebih kecil, kehilangan ketepatan (pemotongan) akan berlaku.

Persekitaran pengendalian tutorial ini: sistem Windows 10, GO 1.11.2, komputer thinkpad t480.

Penukaran jenis data bahasa Go

Penukaran jenis berlaku apabila nilai ditukar daripada satu jenis kepada jenis yang lain. Bahasa statik seperti c/c dan Java menyediakan penukaran jenis tersirat, tetapi ini berbeza untuk sistem jenis yang kuat seperti golang tidak menyokong penukaran jenis automatik atau penukaran jenis tersirat.

Memandangkan tiada penukaran jenis tersirat dalam bahasa Go, semua penukaran jenis mesti diisytiharkan secara eksplisit:

valueOfTypeB = typeB(valueOfTypeA)

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

Contoh:

a := 5.0
b := int(a)

Penukaran jenis hanya boleh berjaya apabila definisinya betul, seperti menukar daripada jenis dengan julat nilai yang lebih kecil kepada jenis dengan julat nilai yang lebih besar ( Tukar int16 kepada int32). Kehilangan ketepatan (pemangkasan) berlaku apabila menukar daripada jenis dengan julat yang lebih besar kepada jenis dengan julat yang lebih kecil (menukar int32 kepada int16 atau float32 kepada int).

Hanya pembolehubah jenis pendasar yang sama boleh ditukar antara satu sama lain (seperti menukar jenis int16 kepada jenis int32 Ralat kompilasi akan berlaku apabila pembolehubah jenis asas yang berbeza ditukar kepada satu sama lain (seperti menukar jenis bool kepada jenis 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))
}

Penerangan kod adalah seperti berikut:

• Baris 11 hingga 14 mengeluarkan julat berangka beberapa jenis integer sepunya.

• Baris 17, isytihar dan mulakan pembolehubah a daripada jenis int32.

• Baris 19, gunakan kata kerja %x bagi fmt.Printf untuk mengeluarkan nilai dalam format perenambelasan Baris ini mengeluarkan nilai 32-bit sebelum penukaran.

• Baris 22, tukar nilai a kepada jenis int16, iaitu, tukar daripada jenis integer bertanda 32-bit kepada jenis integer bertanda 16-bit Disebabkan julat nilai int16 jenis Julat nilai lebih kecil daripada jenis int32, jadi nilai akan dipotong (ketepatan hilang).

• Baris 24, mengeluarkan nilai pembolehubah yang ditukar, iaitu nilai b, dan juga dicetak dalam perenambelasan dan perpuluhan.

• Baris 27, math.Pi ialah pemalar bagi pakej matematik Ia tidak mempunyai jenis secara lalai Ia akan disimpulkan secara automatik berdasarkan jenis sebenar di mana ia dirujuk .Pi ditugaskan kepada pembolehubah c, jadi jenisnya ialah float32.

• Barisan 29, tukar float32 kepada jenis int dan output.

Output kod adalah seperti berikut:

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

Menurut hasil output, julat integer bertanda 16-bit ialah -32768~32767, dan nilai pembolehubah a ialah 1047483647. dalam julat ini. Nilai perenambelasan sepadan 1047483647 ialah 0x3e6f54ff Selepas ditukar kepada jenis int16, panjang dipendekkan separuh, iaitu, ia dipotong separuh dalam perenambelasan dan menjadi 0x54ff, dan nilai perpuluhan yang sepadan ialah 21759.

Apabila nombor titik terapung ditukar kepada integer, bahagian perpuluhan akan dialih keluar dan hanya bahagian integer akan dikekalkan.

Taipkan amalan penukaran

Amalan praktikal 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)
}

Keputusan ujian

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

Pertempuran Praktikal 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)
}

Keputusan Ujian

n2= 32 n3= 32

Pertempuran Praktikal 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)
}

Keputusan ujian

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

Untuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati: Video Pengaturcaraan! !

Atas ialah kandungan terperinci Cara melakukan penukaran jenis data dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!