Go 語言中的變量和常量是什麼？示例說明

變量與常量是大多數程式語言中的基本概念。它們是用於存儲和管理數據的建構塊。

在這篇文章中，我們將看看變量和常量在Go語言中的運作方式。

變量是什麼？

變量是一個由名稱（或識別符）标识的存儲位置，它持有一個值。這個值在程序執行過程中可以更改（或變化）。這就是為什麼它叫作變量。

例如：

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

我們創建了一個標識為myName的變量，它持有一個字符串值。

如果你注意到了，我們將值更改為另一個字符串，並且我們可以多次这样做，因為變量允許這樣做。

變量允許您存儲不同類型的數據，如整數、浮點數、字符串或物件。

在Go中創建變量的方法

在Go中有兩種主要方法來創建變量，分别是顯式声明和簡短声明。

顯式声明

這是Go中創建變量的傳統方式。它通過使用var關鍵詞並宣告變量的類型，使您的代碼更具可讀性和清晰度。

package main

import "fmt"

func main() {

    var age int = 25

    var name string = "Temitope"

    var height float64 = 5.7

    fmt.Println(age, name, height)

}

您可以看到，對於每個變量，我們在賦予值之前宣告了它的數據類型。

output:
25 Temitope 5.7

var關鍵詞和數據類型也可以沒有初始值使用：

package main

import "fmt"

func main() {
    var age int
    var name string
    var height float64

    age = 25
    name = "Temitope"
    height = 5.7

    fmt.Println(age, name, height)
}

這樣，變量首先宣告而沒有初始值。然後在代碼後面賦予值。您仍然會得到與第一家相同的輸出。

簡短變量宣告

速寫變量宣告語法（`:=`）是一種更簡潔的宣告變量方式。這種方法允許您在單一行內宣告和初始化變量，而無需明確地說明其類型，因為類型是从分配的值中推斷出來的。

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

在這裡，每個變量都與其值一起宣告，Go從中推斷出數據類型。例如，`age`用`25`這個值宣告並初始化，Go推斷其類型為`int`。`name`宣告為”Temitope”，Go推斷其類型為`string`。最後，`height`宣告為`5.7`，Go推斷其類型為`float64`。

output:
25 Temitope 5.7

速寫變量宣告的一个缺點是，您只能在函數內使用它。

多重變量宣告

您可以在同一行宣告和初始化多個變量，通過用逗號分隔每個變量。這種方法簡單直接。當變量相關或者您想要一起初始化它們時，常使用這種方法。例如：

package main

import "fmt"

func main() {

    var age, height int = 25, 180

    var name, city string = "Temitope", "New York"

    fmt.Println(age, height)

    fmt.Println(name, city)
}

在這裡，變量`age`和`height`都宣告為整數，並分别初始化為`25`和`180`。變量`name`和`city`也都被宣告為字符串，並分别初始化為”Temitope”和”New York”。

Output:
25 180
Temitope New York

您也可以像這樣在區塊中宣告多個變量：

package main

import "fmt"

func main() {

    var (
        age int = 25

        name string = "Temitope"

        height int = 180

        city string = "New York"
    )

    fmt.Println(age, name, height, city)

}

在這裡，變量`age`、`name`、`height`和`city`在一個單一的`var`區塊中宣告，每個變量都有自己的行。

Output:
25 Temitope 180 New York

零值

當變量宣告而未初始化時，它們會被默認賦予零值。這些值根據變量類型而有所不同。以下是您可以宣告默認值的一個例子：

package main

import "fmt"

func main() {

    var intValue int

    var floatValue float64

    var boolValue bool

    var stringValue string

    var ptrValue *int

    var sliceValue []int

    var mapValue map[string]int

    fmt.Println("Zero values:")

    fmt.Println("int:", intValue)

    fmt.Println("float64:", floatValue)

    fmt.Println("bool:", boolValue)

    fmt.Println("string:", stringValue)

    fmt.Println("pointer:", ptrValue)

    fmt.Println("slice:", sliceValue)

    fmt.Println("map:", mapValue)

}

在上面嘅代码中，会发生咩事呢？

整數 intValue 會被授予零值 0。
浮點數 floatValue 會被授予零值 0。
布爾值 boolValue 會被授予零值 false。
字符串 stringValue 會被授予零值 “”（空字符串）。
指標 ptrValue、切片 sliceValue 同 MAP mapValue 都会被授予零值 nil。

输出：

Output:
Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: []
map: map[]

變量範圍是什麼？

變量可以宣告為全局或局部的。變量範圍決定咗它在哪里可以被訪問和修改。

全局變量是在任何函數外部宣告的，通常在文件頂部，並且可以被同一包內的任何函數訪問。以下是一個例子：

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {

    globalCounter++

}

func main() {

    fmt.Println("Initial Counter:", globalCounter)

    incrementCounter()

    fmt.Println("After Increment:", globalCounter)

}

在上述例子中，globalCounter 是全局變量，它可以被 incrementCounter 函數和 main 函數訪問。

此外，globalCounter 的值在函數調用之間持続。這意味著在一個函數中對它的任何更改都會影響程序其他部分中的其值。

相對地，局部變量是在函數或區塊內宣告的，並且只能在該特定函數或區塊內訪問。它們在函數或區塊執行時創建，一旦完成即销毁。例如：

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

    fmt.Println("Local Counter:", localCounter)

}

func main() {

    incrementCounter()

    incrementCounter()

}

在上面代碼中，我們在 incrementCounter 函數內有 localCounter 作為局部變量。每次調用 incrementCounter 時，都會創建一個新的 localCounter，初始化為 0 並增加。

＜code>localCounter 的值在函數調用之間不持続，所以當對函數進行更改時，它不能影響程序的任何部分。

Go 中的命名惯例

正確命名變量對於写出清晰、可讀和可維護的代碼非常重要。Go 對於變量的命名有一些特定的慣例和規則。以下是一些它們：

使用描述性的命名: 使用能清楚描述變量用途或內容的命名。例如，不要使用模糊的名稱如 x 或 y，而是使用像 age、totalPrice 或 userName 這類的名稱，它們能清楚傳達變量所代表的意義。
多詞名稱使用驼峰命名法: 在 Go 語言中，通常將由多個詞組成的變量名稱使用驼峰命名法。第一個詞的首字母小寫，每個後續詞的首字母大寫。
避免使用下划線: 與某些其他語言不同，Go 更喜欢驼峰命名法而非在變量名稱中使用下划線分隔詞彙。遵守 camelCase 以符合 Go 的風格惯例。
短期變量使用簡短名稱：對於短期變量，如迴圈計數器或索引，可以使用像 i、j 或 k 這樣的簡短名稱。

Go 中的常數是什麼？

常數是在編譯時定義的不變值，在整个程式執行過程中不能更改。它們用於定義事先已知且將保持不變的值。

比方說你正在建立一個线上商店，標準運費總是 $10。你可以將它宣告為一個常數，所以你可以在程式中的任何需要應用運費的地方使用它。如果運費率發生變化，你只需要在一個地方更新值即可。

如何在 Go 中宣告常數

你可以使用 const 關鍵詞來宣告常數，後跟名稱、类型（如果值暗示了类型則可选），以及常數的值。以下是宣告方式：

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

如果你嘗試在宣告後更改常數，則會獲得編譯時錯誤。

Go 中的常數類型

常數可以分為類型常數或非類型常數。兩類常數 serve 同一目的。它們為程式提供固定的、不變的值。不過，它們在 Go 如何處理它們的類型以及在使用時它們的靈活性方面有所不同。

未宣告型別的常數在未使用型別化語境時不會被賦予型別。當你宣告一個未宣告型別的常數時，Go 會在該常數使用時推斷其型別。這使得未宣告型別的常數更加靈活，因為它們可以在不進行型別轉換的情況下用於多種設定中。

package main

import "fmt"

const gravity = 9.81

func main() {

    var height int = 10

    var acceleration float64 = gravity * float64(height)

    fmt.Println("Acceleration:", acceleration)

}

在這裡，gravity 是未宣告型別的常數。這意味著 Go 可以根据它的使用方式推斷其型別。當 gravity 与 float64 一起用於計算時，Go 會自動將其當作 float64 來處理。

與未宣告型別的常數不同，宣告型別的常數具有顯式宣告的型別。這意味著它們只能用在匹配該型別的上下文中，或者轉為兼容型別。宣告型別的常數較嚴格，確保值總是作為它被宣告時指定的大型別處理。

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

在這裡，speedOfLight 是一個型別為 int 的宣告常數。

它只能用於其他 int 值的操作中，或顯式轉為其他型別。

那就是本文的結論了

在本文中，我們查看了 Go 語言中變量和常數的性与如何宣告它們。

變量和常數是程式設計中非常重要的工具。它們讓開發者能有效管理和操作數據。當你理解了如何使用它們，你就可以提高你的程式碼質量。

如果你覺得這篇內容有幫助，請分享給他人。

目錄：