mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2024-11-28 09:09:07 +00:00
106 lines
5.3 KiB
Markdown
106 lines
5.3 KiB
Markdown
### 3.6.2. 无类型常量
|
||
|
||
Go语言的常量有个不同寻常之处。虽然一个常量可以有任意有一个确定的基础类型，例如int或float64，或者是类似time.Duration这样命名的基础类型，但是许多常量并没有一个明确的基础类型。编译器为这些没有明确的基础类型的数字常量提供比基础类型更高精度的算术运算；你可以认为至少有256bit的运算精度。这里有六种未明确类型的常量类型，分别是无类型的布尔型、无类型的整数、无类型的字符、无类型的浮点数、无类型的复数、无类型的字符串。
|
||
|
||
通过延迟明确常量的具体类型，无类型的常量不仅可以提供更高的运算精度，而且可以直接用于更多的表达式而不需要显式的类型转换。例如，例子中的ZiB和YiB的值已经超出任何Go语言中整数类型能表达的范围，但是它们依然是合法的常量，而且可以像下面常量表达式依然有效（译注：YiB/ZiB是在编译期计算出来的，并且结果常量是1024，是Go语言int变量能有效表示的）：
|
||
|
||
```Go
|
||
fmt.Println(YiB/ZiB) // "1024"
|
||
```
|
||
|
||
另一个例子，math.Pi无类型的浮点数常量，可以直接用于任意需要浮点数或复数的地方：
|
||
|
||
```Go
|
||
var x float32 = math.Pi
|
||
var y float64 = math.Pi
|
||
var z complex128 = math.Pi
|
||
```
|
||
|
||
如果math.Pi被确定为特定类型，比如float64，那么结果精度可能会不一样，同时对于需要float32或complex128类型值的地方则会强制需要一个明确的类型转换：
|
||
|
||
```Go
|
||
const Pi64 float64 = math.Pi
|
||
|
||
var x float32 = float32(Pi64)
|
||
var y float64 = Pi64
|
||
var z complex128 = complex128(Pi64)
|
||
```
|
||
|
||
对于常量面值，不同的写法可能会对应不同的类型。例如0、0.0、0i和`\u0000`虽然有着相同的常量值，但是它们分别对应无类型的整数、无类型的浮点数、无类型的复数和无类型的字符等不同的常量类型。同样，true和false也是无类型的布尔类型，字符串面值常量是无类型的字符串类型。
|
||
|
||
前面说过除法运算符/会根据操作数的类型生成对应类型的结果。因此，不同写法的常量除法表达式可能对应不同的结果：
|
||
|
||
```Go
|
||
var f float64 = 212
|
||
fmt.Println((f - 32) * 5 / 9) // "100"; (f - 32) * 5 is a float64
|
||
fmt.Println(5 / 9 * (f - 32)) // "0"; 5/9 is an untyped integer, 0
|
||
fmt.Println(5.0 / 9.0 * (f - 32)) // "100"; 5.0/9.0 is an untyped float
|
||
```
|
||
|
||
只有常量可以是无类型的。当一个无类型的常量被赋值给一个变量的时候，就像下面的第一行语句，或者出现在有明确类型的变量声明的右边，如下面的其余三行语句，无类型的常量将会被隐式转换为对应的类型，如果转换合法的话。
|
||
|
||
```Go
|
||
var f float64 = 3 + 0i // untyped complex -> float64
|
||
f = 2 // untyped integer -> float64
|
||
f = 1e123 // untyped floating-point -> float64
|
||
f = 'a' // untyped rune -> float64
|
||
```
|
||
|
||
上面的语句相当于:
|
||
|
||
```Go
|
||
var f float64 = float64(3 + 0i)
|
||
f = float64(2)
|
||
f = float64(1e123)
|
||
f = float64('a')
|
||
```
|
||
|
||
无论是隐式或显式转换，将一种类型转换为另一种类型都要求目标可以表示原始值。对于浮点数和复数，可能会有舍入处理：
|
||
|
||
```Go
|
||
const (
|
||
deadbeef = 0xdeadbeef // untyped int with value 3735928559
|
||
a = uint32(deadbeef) // uint32 with value 3735928559
|
||
b = float32(deadbeef) // float32 with value 3735928576 (rounded up)
|
||
c = float64(deadbeef) // float64 with value 3735928559 (exact)
|
||
d = int32(deadbeef) // compile error: constant overflows int32
|
||
e = float64(1e309) // compile error: constant overflows float64
|
||
f = uint(-1) // compile error: constant underflows uint
|
||
)
|
||
```
|
||
|
||
对于一个没有显式类型的变量声明（包括简短变量声明），常量的形式将隐式决定变量的默认类型，就像下面的例子：
|
||
|
||
```Go
|
||
i := 0 // untyped integer; implicit int(0)
|
||
r := '\000' // untyped rune; implicit rune('\000')
|
||
f := 0.0 // untyped floating-point; implicit float64(0.0)
|
||
c := 0i // untyped complex; implicit complex128(0i)
|
||
```
|
||
|
||
注意有一点不同：无类型整数常量转换为int，它的内存大小是不确定的，但是无类型浮点数和复数常量则转换为内存大小明确的float64和complex128。
|
||
如果不知道浮点数类型的内存大小是很难写出正确的数值算法的，因此Go语言不存在整型类似的不确定内存大小的浮点数和复数类型。
|
||
|
||
|
||
如果要给变量一个不同的类型，我们必须显式地将无类型的常量转化为所需的类型，或给声明的变量指定明确的类型，像下面例子这样：
|
||
|
||
```Go
|
||
var i = int8(0)
|
||
var i int8 = 0
|
||
```
|
||
|
||
当尝试将这些无类型的常量转为一个接口值时（见第7章），这些默认类型将显得尤为重要，因为要靠它们明确接口对应的动态类型。
|
||
|
||
```Go
|
||
fmt.Printf("%T\n", 0) // "int"
|
||
fmt.Printf("%T\n", 0.0) // "float64"
|
||
fmt.Printf("%T\n", 0i) // "complex128"
|
||
fmt.Printf("%T\n", '\000') // "int32" (rune)
|
||
```
|
||
|
||
现在我们已经讲述了Go语言中全部的基础数据类型。下一步将演示如何用基础数据类型组合成数组或结构体等复杂数据类型，然后构建用于解决实际编程问题的数据结构，这将是第四章的讨论主题。
|
||
|
||
|
||
|
||
|