mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2024-12-26 14:56:21 +00:00
105 lines
4.9 KiB
Markdown
105 lines
4.9 KiB
Markdown
### 3.6.2. 無類型常量
|
|
|
|
|
|
Go語言的常量有點不尋常. 雖然一個常量可以有任意有一個確定的基礎類型, 例如 int 或 float64, 或者是類似 time.Duration 這樣命名的基礎類型, 但是許多常量併沒有一個明確的基礎類型. 編譯期爲這些沒有明確的基礎類型的數字常量提供比基礎類型或機器更高精度的算術運算; 你可以認爲至少有256bit的運算精度. 這里有六種未明確類型的常量類型, 分别是 無類型的布爾型, 無類型的整數, 無類型的字符, 無類型的浮點數, 無類型的複數, 無類型的字符串.
|
|
|
|
通過延遲明確具體類型, 無類型的常量不僅可以提供更高的精度, 而且可以直接用於更多的表達式而不需要類型轉換. 例如 例子中的 ZiB 和 YiB 的值已經超齣任何Go中整數類型能表達的范圍, 但是它們依然是合法的常量, 而且可以像下面表達式這樣使用:
|
|
|
|
```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語言中全部的基礎數據類型. 下一步將演示如何用基礎數據類型組合成數組或結構體等複雜數據類型, 然後構建用於解決實際編程問題的數據結構, 這將是第四章的討論主題.
|
|
|
|
|
|
|
|
|