Like Share Discussion Bookmark Smile

J.J. Huang   2025-02-07   Getting Started Golang 01.基本型別   瀏覽次數:次   DMCA.com Protection Status

Go | 「常量」的介紹與使用

💬 簡介

常量(Constant)是指在程式執行過程中值不會改變的變數。常量的使用能夠提高程式的可讀性與維護性,並減少錯誤發生的機會。理解常量的定義、使用方法以及適合的應用場景,對於寫出穩定、高效的程式碼至關重要。

本篇文章將介紹常量,並深入探討其特性及最佳使用方法。

圖片來源:Gophers(地鼠造型的原創者為 Renee French)


🔎 Go 語言中的常量

1️⃣ 常量的定義

常量使用 const 關鍵字來定義。常量在編譯時就會被賦值,一旦賦值後無法改變。常量可以是數值型別、字串型別或布林型別。

  • 範例:定義常量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    package main

    import "fmt"

    const Pi = 3.14159 // 定義常量 Pi

    func main() {
    fmt.Println("圓周率:", Pi) // 輸出:圓周率: 3.14159
    }

    📝在這個範例中,我們定義了一個名為 Pi 的常量,其值為圓周率,並且在程式中使用它。

2️⃣ 常量的型別

常量的型別是由其值來推斷的。也可以明確指定常量的型別,這樣可以避免類型推斷不當。

  • 範例:指定常量型別
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package main

    import "fmt"

    const EarthGravity float64 = 9.81 // 指定型別為 float64

    func main() {
    fmt.Println("地球重力加速度:", EarthGravity) // 輸出:地球重力加速度: 9.81
    fmt.Printf("EarthGravity 的型別是:%T\n", EarthGravity) // 輸出:EarthGravity 的型別是:float64
    }

    📝在這個範例中,我們使用 float64 明確指定了 EarthGravity 的型別。

3️⃣ 常量的多重定義

允許同一個 const 區塊中定義多個常量,這樣有助於提高程式的可讀性。

  • 例:多重常量定義
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package main

    import "fmt"

    const (
    Pi = 3.14159
    Radius = 10
    )

    func main() {
    fmt.Println("圓周率:", Pi) // 輸出:圓周率: 3.14159
    fmt.Println("圓的半徑:", Radius) // 輸出:圓的半徑: 10
    }

    📝在這個範例中,我們在同一個區塊中定義了 PiRadius 兩個常量。

4️⃣ 常量與運算

常量可以用於運算,並且運算結果仍然是一個常量。這使得在程式中運用常量進行數學計算更加簡潔。

  • 範例:常量運算
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package main

    import "fmt"

    const (
    Length = 20
    Width = 5
    )

    func main() {
    area := Length * Width // 計算面積
    fmt.Println("長方形面積:", area) // 輸出:長方形面積: 100
    }

    📝在這個範例中,我們使用常量 LengthWidth 計算長方形的面積,結果仍是常量。

5️⃣ 預設常量型別

常量根據值自動推斷型別。如果沒有明確指定,則常量會根據其值的型別自動分配。

  • 範例:自動推斷型別
    1
    2
    3
    4
    5
    6
    7
    8
    9
    package main

    import "fmt"

    const Pi = 3.14159 // 自動推斷為 float64 型別

    func main() {
    fmt.Println("圓周率的型別:", Pi) // 輸出:圓周率的型別: 3.14159
    }

    📝在這個範例中,常量 Pi 被自動推斷為float64` 型別。


⚠️ 注意事項

1️⃣ 常量面值的型別

常量面值,雖然看起來可能是相同的數值,但不同的寫法會對應不同的常數型別。舉例來說:

  • 0:是無類型的整數(int)。
  • 0.0:是無類型的浮點數(float64)。
  • 0i:是無類型的複數數字(complex128)。
  • \u0000:是無類型的字元(rune,實際上是 int32)。

同樣地,布林值 truefalse 也是無類型的布林型別。字串面值常數則是無類型的字串類型。

  • 範例:不同面值對應不同型別
    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"

    const (
    a = 0 // 無類型整數
    b = 0.0 // 無類型浮點數
    c = 0i // 無類型複數
    d = '\u0000' // 無類型字元
    e = true // 無類型布林
    f = "hello" // 無類型字串
    )

    func main() {
    fmt.Printf("a 的型別:%T\n", a) // int
    fmt.Printf("b 的型別:%T\n", b) // float64
    fmt.Printf("c 的型別:%T\n", c) // complex128
    fmt.Printf("d 的型別:%T\n", d) // rune (int32)
    fmt.Printf("e 的型別:%T\n", e) // bool
    fmt.Printf("f 的型別:%T\n", f) // string
    }

    📝這段程式碼顯示了不同的常量面值會對應到不同的類型,即使它們的值相同。這提醒我們在使用常量時要注意其具體型別。

2️⃣ 常量與變數的區別

常量與變數的最大區別在於,常量一旦定義後,值就無法改變,而變數則可以在程式執行過程中隨時修改。

  • 範例:常量與變數的區別
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package main

    import "fmt"

    const Pi = 3.14 // 常量
    var radius = 10 // 變數

    func main() {
    fmt.Println("圓周率:", Pi) // 輸出:圓周率: 3.14
    fmt.Println("圓的半徑:", radius) // 輸出:圓的半徑: 10

    radius = 20 // 修改變數
    fmt.Println("新的圓的半徑:", radius) // 輸出:新的圓的半徑: 20
    }

    📝常量 Pi 無法修改,而變數 radius 則可以在後續的程式中改變其值。

3️⃣ 使用常量提高程式的可讀性

使用常量來代替硬編碼的數值,能使程式碼更加清晰易懂,並且方便日後的維護與修改。

  • 範例:提升可讀性
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    package main

    import "fmt"

    const MaxRetries = 5 // 最大重試次數

    func main() {
    for i := 1; i <= MaxRetries; i++ {
    fmt.Println("第", i, "次重試")
    }
    }

    📝在這個範例中,我們使用常量 MaxRetries 來指定最大重試次數,這樣如果需要修改時,只需更改常量值即可,避免硬編碼的問題。


✨ 額外補充

iota:簡單又強大的常量生成器

iota 是 Go 語言中一個特殊的常量生成器,用來在一組常量中自動生成連續的數值。它的初始值是 0,並且在每遇到一個 const 區塊中的新常量定義時,會自動遞增。

  • 範例:使用 iota 自動生成常量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package main

    import "fmt"

    const (
    _ = iota // 忽略第 0 的值
    Monday // iota = 1
    Tuesday // iota = 2
    Wednesday // iota = 3
    )

    func main() {
    fmt.Println(Monday) // 輸出:1
    fmt.Println(Tuesday) // 輸出:2
    fmt.Println(Wednesday) // 輸出:3
    }

    📝在這個範例中,iota 會自動從 0 開始遞增,並且用來定義一週的每一天。透過這樣的方式,我們可以輕鬆地生成一組連續的常量。


🎯總結

常量扮演著重要的角色,它們幫助編寫更加穩定、可讀且易維護的程式碼。合理地使用常量,能夠減少錯誤並提高程式的可維護性。在需要不變值的情況下,選擇常量而非變數是一個非常好的選擇。

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


註:以上參考了
Go