Go | 初步了解「整數」型別

💬 簡介

在 Go 語言中，整數型別（Integer Types）是最基本的數值型別之一，廣泛應用於數字運算、計算、索引等場景。
理解不同整數型別的特性和範圍，能幫助根據需求選擇最合適的型別，避免出現溢位或記憶體浪費等問題。

本篇文章將介紹 Go 語言中的整數型別，並深入探討它們的使用方法。

圖片來源：Gophers（地鼠造型的原創者為 Renee French）

🔎 Go 語言中的整數型別

1️⃣ 有符號與無符號整數

有符號和無符號兩類整數型別。

• 有符號整數：可以表示正數、零和負數。
• 無符號整數：只能表示正數和零。

  📝這兩者的差異主要體現在範圍的不同。

• 範例：有符號與無符號整數

  1 2 3 4 5 6 7 8 9 10 11

  package main import "fmt" func main() { var a int = -10 // 有符號整數 var b uint = 10 // 無符號整數 fmt.Println(a) // 輸出：-10 fmt.Println(b) // 輸出：10 }

  📝在這個範例中，a 是有符號整數，可以表示負數，而 b 是無符號整數，無法表示負數。

2️⃣ 整數型別的範圍

每個整數型別都有固定的範圍，範圍大小是由位元數決定的。
以 8 位整數為例，int8 的範圍是從 -128 到 127，而 int64 的範圍則可以從 -9223372036854775808 到 9223372036854775807。

• 範例：範圍示範

  1 2 3 4 5 6 7 8 9 10 11 12 13

  package main import "fmt" func main() { // 使用 int8 型別 var numInt8 int8 = 127 fmt.Println("int8 範圍：", numInt8, "到", -numInt8) // 使用 int64 型別 var numInt64 int64 = 9223372036854775807 fmt.Println("int64 範圍：", -numInt64, "到", numInt64) }

  📝在這個範例中，int8 和 int64 顯示了其對應的範圍，幫助我們理解不同型別的數值極限。

3️⃣ 預設整數型別

int 和 uint 型別會根據系統架構（32 位或 64 位）自動決定大小。因此，int 和 uint 會根據系統環境的不同而有所區別。
這使得 int 成為大多數情況下的首選整數型別。

• 範例：使用預設整數型別

  1 2 3 4 5 6 7 8 9 10

  package main import "fmt" func main() { var x int = 42 var y uint = 50 fmt.Println(x, y) // 輸出：42 50 }

  📝在這個範例中，int 和 uint 的大小根據系統架構自動選擇，無需手動指定。

4️⃣ 整數運算與溢位

基本的整數運算，例如加法、減法、乘法和除法。
然而，需要注意整數溢位的問題，特別是在使用較小範圍的整數型別時。當運算結果超出範圍，會發生溢位。

• 範例：溢位示範

  1 2 3 4 5 6 7 8 9

  package main import "fmt" func main() { var a int8 = 127 var b int8 = 1 fmt.Println(a + b) // 溢位，輸出：-128 }

  📝在這個範例中，當 a 和 b 相加時，結果超過 int8 的範圍，發生溢位，返回負數。

⚠️ 注意事項

1️⃣ 選擇適合的整數型別

選擇整數型別時應根據數值範圍的需求來選擇適合的型別，避免不必要地使用過大的型別，從而浪費記憶體空間，或者選擇過小的型別，導致溢位問題。

• 範例：選擇合適的整數型別

  1 2 3 4 5 6 7 8

  package main import "fmt" func main() { var smallValue int8 = 120 // 如果數字過大，應選擇較大的型別 fmt.Println(smallValue) }

2️⃣ 溢位與錯誤處理

Go 語言不會自動檢查整數溢位，因此應當格外小心。可以考慮在可能發生溢位的情況下，使用更大的型別或進行額外的範圍檢查。

🔢 整數型別範圍一覽

下表列出了 Go 語言中所有整數型別的範圍和所占用的位元組數：

📝一個位元組代表八個位元。

範例：整數型別範圍與溢位示範

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

package main

import "fmt"

func main() {
  // 使用 int8 型別
  var numInt8 int8 = 127
  fmt.Println("int8 範圍：", -128, "到", 127)
  fmt.Println("int8 的值：", numInt8)

  // int8 溢位測試
  numInt8Overflow := numInt8 + 1 // 溢位
  fmt.Println("int8 溢位後的值：", numInt8Overflow) // 應該會顯示 -128

  // 使用 int16 型別
  var numInt16 int16 = 32767
  fmt.Println("int16 範圍：", -32768, "到", 32767)
  fmt.Println("int16 的值：", numInt16)

  // int16 溢位測試
  numInt16Overflow := numInt16 + 1 // 溢位
  fmt.Println("int16 溢位後的值：", numInt16Overflow) // 應該會顯示 -32768

  // 使用 int32 型別
  var numInt32 int32 = 2147483647
  fmt.Println("int32 範圍：", -2147483648, "到", 2147483647)
  fmt.Println("int32 的值：", numInt32)

  // int32 溢位測試
  numInt32Overflow := numInt32 + 1 // 溢位
  fmt.Println("int32 溢位後的值：", numInt32Overflow) // 應該會顯示 -2147483648

  // 使用 int64 型別
  var numInt64 int64 = 9223372036854775807
  fmt.Println("int64 範圍：", -9223372036854775808, "到", 9223372036854775807)
  fmt.Println("int64 的值：", numInt64)

  // int64 溢位測試
  numInt64Overflow := numInt64 + 1 // 溢位
  fmt.Println("int64 溢位後的值：", numInt64Overflow) // 應該會顯示 -9223372036854775808

  // 使用 int 型別（32 位或 64 位）
  var numInt int = 2147483647
  fmt.Println("int 範圍：32 位：", -2147483648, "到", 2147483647, " 64 位：", -9223372036854775808, "到", 9223372036854775807)
  fmt.Println("int 的值：", numInt)

  // int 溢位測試
  numIntOverflow := numInt + 1 // 溢位
  fmt.Println("int 溢位後的值：", numIntOverflow)

  // 使用 uint8 型別
  var numUint8 uint8 = 255
  fmt.Println("uint8 範圍：", 0, "到", 255)
  fmt.Println("uint8 的值：", numUint8)

  // uint8 溢位測試
  numUint8Overflow := numUint8 + 1 // 溢位
  fmt.Println("uint8 溢位後的值：", numUint8Overflow) // 應該會顯示 0

  // 使用 uint16 型別
  var numUint16 uint16 = 65535
  fmt.Println("uint16 範圍：", 0, "到", 65535)
  fmt.Println("uint16 的值：", numUint16)

  // uint16 溢位測試
  numUint16Overflow := numUint16 + 1 // 溢位
  fmt.Println("uint16 溢位後的值：", numUint16Overflow) // 應該會顯示 0

  // 使用 uint32 型別
  var numUint32 uint32 = 4294967295
  fmt.Println("uint32 範圍：", 0, "到", 4294967295)
  fmt.Println("uint32 的值：", numUint32)

  // uint32 溢位測試
  numUint32Overflow := numUint32 + 1 // 溢位
  fmt.Println("uint32 溢位後的值：", numUint32Overflow) // 應該會顯示 0

  // 使用 uint64 型別
  var numUint64 uint64 = 18446744073709551615
  fmt.Println("uint64 範圍：", 0, "到", 18446744073709551615)
  fmt.Println("uint64 的值：", numUint64)

  // uint64 溢位測試
  numUint64Overflow := numUint64 + 1 // 溢位
  fmt.Println("uint64 溢位後的值：", numUint64Overflow) // 應該會顯示 0
}

✨ 額外補充

在 Go 語言中，整數不僅可以以十進制表示，還可以使用其他進制來表示數字。這些進制方式有助於在某些情況下更直觀地表達數值。以下是不同進制的表示方式與範例：

• 十進制（Decimal）：這是我們最常用的數字表示方式，數字就是普通的數字。例如：42。
• 十六進制（Hexadecimal）：以 0x 開頭，常用於表示位元運算中的數字。例如：0x2A 表示十進制的 42。
• 二進制（Binary）：以 0b 開頭，常用於低層次的程式設計，像是位元操作。例如：0b101010 也表示十進制的 42。
• 八進制（Octal）：以 0o 開頭，八進制也被用來表示一些特定的數值。例如：0o52 表示十進制的 42。

• 範例：各個進制示範

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

  package main import "fmt" func main() { // 十進制表示 var decimal int = 42 fmt.Println("十進制：", decimal) // 輸出：42 // 十六進制表示 var hex int = 0x2A fmt.Println("十六進制：", hex) // 輸出：42 // 二進制表示 var binary int = 0b101010 fmt.Println("二進制：", binary) // 輸出：42 // 八進制表示 var octal int = 0o52 fmt.Println("八進制：", octal) // 輸出：42 }

🎯總結

整數型別非常靈活，提供了多種選擇來滿足不同的數值需求。理解每個整數型別的範圍、特性和應用場景，能幫助選擇最合適的型別，避免錯誤和溢位問題。選擇合適的型別和謹慎處理運算中的溢位是寫出高效且穩定程式碼的關鍵。

最後建議回顧一下 Go | 菜鳥教學 目錄，了解其章節內容。

註：以上參考了
Go
A Tour of Go - Basic types