Go 类型转换

在 Go 语言中,类型转换指的是将 “一种数据类型” 转换为 “另一种数据类型”。

在日常数学计算里,整数 10 和小数 3.5 可以直接相加得到 13.5。但在 Go 语言中,如果我们直接把一个整数变量和一个浮点数变量相加,会发生什么呢?先来看下面这几行代码:

a := 10
b := 3.5
fmt.Println(a + b)

编译上面这段代码时,Go 编译器会直接报错 invalid operation: a + b (mismatched types int and float64),提示 int 和 float64 的数据类型不匹配,无法直接相加。

这也是 Go 语言一条很严格的规则:Go 语言不支持自动(隐式)类型转换。只要两个变量的类型不完全相同,无论是相互赋值还是放在一起运算,都必须由我们手动完成 “显式类型转换”。

前面学习常量时之所以能直接写 10 + 3.5,是因为未指定类型的字面量会自动适配。一旦把数值存进变量,它的类型就固定下来了,不能再直接跨类型混合计算。

Go 类型转换语法

在 Go 语言中,基本数值类型之间的转换语法非常统一,写法就像调用一个以目标类型命名的函数一样。

语法:

目标类型(变量或表达式)

说明:

小括号外面的 “目标类型” 是我们希望转换成的类型,比如 int、int64、float64 等;小括号里面则是待转换的变量、常量或表达式。

回到开头报错的例子,只要先使用 float64(a) 把整型变量 a 转为 float64,再计算 float64(a) + b,就能顺利算出 13.5 了。

需要注意的是,调用 float64(a) 只是根据 a 的值生成了一个新的 float64 值,并不会改变变量 a 本身原有的类型。另外,这种转换语法主要用于数值类型之间,Go 语言不允许使用 int(true) 或 bool(1) 在布尔类型与数字之间相互转换。

注意: 在 C 或 Java 等语言中,强制类型转换通常写成 (double)a。而在 Go 语言中,小括号是包在变量或表达式外面的,必须写成 float64(a),小伙伴们不要把位置写反了。

数值类型转换示例

下面我们来看几个不同数值类型相互转换的例子。

示例 1:不同整数类型转换

package main

import "fmt"

func main() {
    var a int = 10
    var b int64 = 20

    sum := int64(a) + b    // 将 a 转为 int64 后再相加
    fmt.Println(sum)
}

运行结果如下。

30

分析:

int64(a) + b 表示先将 int 类型的变量 a 显式转换为 int64 类型,然后再与同样是 int64 类型的变量 b 相加,因此程序可以正常算出结果 30。

在 Go 语言中,哪怕同属于整数,只要类型名称不同(如 int、int8、int32 和 int64),编译器就会将它们视为完全不同的类型。如果未作转换就直接相加,下面这种写法就会报错。

sum := a + b

在实际开发中,遇到 int 和 int64 这类不同位数的整数时,我们都需要先显式转换统一类型,然后才能放在一起运算。

接下来我们再看整数与浮点数之间的转换。前面学习运算符时我们知道,两个整数直接相除会自动丢弃小数部分;如果想要保留小数结果,就需要先将整数转换为浮点数。

示例 2:整型转换为浮点型

package main

import "fmt"

func main() {
    a := 10
    b := 4

    r1 := a / b                      // 整数直接相除
    r2 := float64(a) / float64(b)    // 转为 float64 后再相除

    fmt.Println(r1)
    fmt.Println(r2)
}

运行结果如下。

2
2.5

分析:

在这个例子中,a 和 b 都是 int 整数类型。直接计算 a / b(即 10 / 4)会执行整数除法,小数部分被直接舍弃,所以 r1 的结果是 2。

而在计算 r2 时,我们先使用 float64(a) 和 float64(b) 将两个整数分别转换成了浮点数 10.0 和 4.0,然后再相除,就能保留小数部分得到准确的 2.5。

注意在 Go 语言中,不能像 C 或 Java 那样只转换一边写成 float64(a) / b。因为 float64 和 int 类型不匹配,编译器依然会直接报错。

另外,在将整数除法转换为浮点数时,初学的小伙伴还容易把小括号的范围括错,误把整个除法算式都包进了小括号里。

// 正确方式
r := float64(a) / float64(b)

// 错误方式
r := float64(a / b)

为什么错误方式得不到 2.5 呢?因为 float64(a / b) 会先算括号里的整数除法 10 / 4 得到 2,小数部分已经丢掉了。最后再转成浮点数,结果依然是 2。因此计算平均值或百分比时,记得先把两边的变量各自转成 float64 再相除。

反过来,如果我们把一个带有小数的浮点数转换成整数,小数部分会怎么处理呢?请看下面例子。

示例 3:浮点型转换为整型

package main

import "fmt"

func main() {
    f1 := 3.14
    f2 := 3.99
    f3 := -3.99

    n1 := int(f1)    // 截断小数部分
    n2 := int(f2)    // 截断小数部分
    n3 := int(f3)    // 截断小数部分

    fmt.Println(n1, n2, n3)
}

运行结果如下。

3 3 -3

分析:

从运行结果可以看出,无论是 3.14 还是已经非常接近 4 的 3.99,使用 int() 转换为整数之后结果都是 3;而负数 -3.99 转换后结果是 -3。

需要注意的是,将浮点数转换为整数时并不会四舍五入,而是直接截断并舍去小数点后面的所有数字。

把小范围类型(如 uint8)转换成大范围类型(如 uint16)是非常安全的。但如果反过来,把一个大范围类型的数值强行转换成小范围类型,就可能发生 “数据溢出” 问题。我们来看最后一个例子。

示例 4:类型转换的数据溢出

package main

import "fmt"

func main() {
    var num uint16 = 258        // 超出 uint8 的最大值 255
    var b uint8 = uint8(num)    // 转为 uint8
    fmt.Println(b)
}

运行结果如下。

2

分析:

变量 num 的值是 258,而目标类型 uint8 只占 1 个字节(8 个二进制位),最大只能表示 255。为什么 258 转成 uint8 会变成 2 呢?因为十进制 258(即 256 + 2)换算成二进制是 9 位的 1 0000 0010。

当执行 uint8(num) 放进 8 位的 uint8 时,最左边的第 9 位 1(代表 256)装不下会被直接截断。最终只剩下低 8 位 0000 0010(即十进制 2),如下图所示。

大范围整数转小范围整数发生高位截断

如果是有符号整数大转小发生溢出,正数甚至可能直接变成负数。因此在实际开发中,当我们需要把大范围整数(如 int64、uint16)转换为小范围整数(如 int8、uint8)时,一定要先确认数值没有超出目标类型的取值范围。

数值转换与数字转字符串的区别

上面介绍的 目标类型(变量) 语法,主要适用于数值类型之间的转换。如果我们想把整数 65 转换成数字文本 "65",千万不要直接写成 string(65)。

在 Go 语言中,string(整数) 会把整数当作 Unicode 字符编码来处理。比如执行 string(65) 得到的结果是字母 "A" 而不是 "65",代码检查工具也会对此给出警告。

如果要把数字真正转换成字符串文本,我们需要借助标准库 strconv 包,具体用法会在后面的 “Go int 转 string” 一节中专门介绍。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号