如何在 Golang 中使用常數

Golang 中的 Constant 或 Const是什麼？以下是關於在 Go 中使用常數需要了解的內容。

顧名思義，constant 就是固定的意思。在程式語言中也是如此，一旦定義了常數的值，就不能再修改它。可以有任何基本資料型別的常數，如整數常數、動態常數、字元常數或字串。

如何聲明：常數像變數一樣聲明，但使用 const 關鍵字作為前綴來聲明具有特定資料類型的常數。不能使用“: = ”語法聲明常數。

例如：

package main

import "fmt"

const PI = 3.14

func main() 
{
	const GFG = "Quantrimang"
	fmt.Println("Hello", GFG)

	fmt.Println("Happy", PI, "Day")

	const Correct= true
	fmt.Println("Go rules?", Correct)
}

結果：

Hello Quantrimang
Happy 3.14 Day
Go rules? true

關於 Golang 中常數你需要知道的事情

無類型和有類型的數字常數

類型常數的行為類似於只能與相同類型交互作用的不可變變量，而無類型常數的行為類似於可以與相似類型交互作用的文字常數。在 Go 中，常數可以用型別聲明，也可以不用型別聲明。以下範例顯示了類型化和非類型化、命名和未命名的數字常數。

const untypedInteger          = 123
const untypedFloating          = 123.12

const typedInteger  int             = 123
const typedFloatingPoint   float64  = 123.12

Go語言中的常數列表如下：

• 常數（整數常數、動態常數、複數常數）
• 字串
• 布林常數

數位常數

數值常數是具有高精度的數值。因為 Go 是一種靜態型別語言，所以它不允許組合數字類型的操作。您無法添加float64到int，甚至無法int32添加到int。但是，寫1e6*time.Second或math.Exp(1)甚至仍然有效1<>。在 Go 中，常數與變數不同，其行為類似於常規數字。

數字常數有三種：

1. 整數
2. 浮點
3. 複雜的

整數常數：

• 前綴指定基數：十六進位為 0x 或 0X，八進位為 0，十進位為無。
• 整數文字也可以具有後綴，該後綴由 U（大寫）和 L（小寫）組合而成，分別代表無符號和長整型。
• 它可以是十進制、八進製或十六進制常數。
• int最多可以儲存 64 位元整數，有時更少。

以下是一些整數常數的範例：

85 /* thập phân */
0213 /* bát phân */
0x4b /* thập lục phân */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
212 /* Hợp lệ */
215u /* Hợp lệ */
0xFeeL /* Hợp lệ */
078 /* Không hợp lệ: 8 không phải là chữ số bát phân */
032UU /* Không hợp lệ: không thể lặp lại hậu tố */

複數常數：

複數常數的工作方式與浮點常數非常相似。它是整數常數（或參數）的有序對或實數對。且常數之間用逗號分隔，數字對放在括號中。第一個常數是實部，第二個常數是虛部。複數常數 COMPLEX*8 使用8 個位元組的儲存空間。

例如：

(0.0, 0.0) (-123.456E+30, 987.654E-29)

動態型別常數：

• 實數常數有整數部分、小數部分、小數部分和指數部分。
• 可以表示為十進位或指數形式的實數常數。
• 當以十進制形式表示時，它必須包含小數點、指數或兩者。
• 而當以指數形式表示時，它必須包含整數部分、小數部分，或兩者兼有。

例如：

3.14159 /* Hợp lệ */
314159E-5L /* Hợp lệ */
510E /* Không hợp lệ: số mũ không đầy đủ */
210f /* Không hợp lệ: không có số thập phân hoặc số mũ */
.e55 /* Không hợp lệ: thiếu số nguyên hoặc phân số */

字串

• Go 支援兩種類型的字串文字，即” ”（雙引號樣式）和‘ ‘（反向引號樣式）。
• +字串可以用and運算子連接起來+=。
• 字串包含與文字字元類似的字元：普通字元、轉義序列和通用字元。這是一個沒有風格的角色。
• 字串類型的零值是空字串，可以用” ”或”文字表示。
• 所有字串類型都可以使用諸如==、!=和 之類的運算子進行比較（比較相似的類型）

句法：

kiểu _string struct {
các phần tử *byte // các byte cơ bản
len int // số byte
}

例如：

"hello, quantrimang" 

"hello, \ 

quantrimang" 

"hello, " "quan" "trimang" 

這裡，所有三個語句都是相同的，也就是說，它們沒有任何特定的類型。

例如：

package main

import "fmt"

func main()
{
	const A = "GFG"
	var B = "GeeksforGeeks"
	
	// Chuỗi Concat.
	var helloWorld = A+ " " + B
	helloWorld += "!"
	fmt.Println(helloWorld) 
	
	// Chuỗi so sánh.
	fmt.Println(A == "GFG") 
	fmt.Println(B < a)="">

結果：

GFG Quantrimang!
true
false

時間複雜度：O(1)
輔助空間：O(1)

布林常數

布林常數與字串常數類似。它應用與字串常數相同的規則。唯一的區別是它有兩個沒有類型的 consttrue和false。

package main

import "fmt"

const Pi = 3.14

func main() 
{
	const trueConst = true
	
	// Định nghĩa kiểu bằng từ khóa type
	type myBool bool 
	var defaultBool = trueConst // được phép
	var customBool myBool = trueConst // được phép
	
	// defaultBool = customBool // không được phép
	fmt.Println(defaultBool)
	fmt.Println(customBool) 
}

結果：

true
true

時間複雜度： O(1)
輔助空間： O(1)

Go 中的常數： Go 有字元、字串、布林和數字常數。 Const 宣告一個常數值。const當存在變數時，可以出現語句，從而執行沒有任何固定精度的算術運算。

// Minh họa hằng số bằng cách dùng go.
package main

import (
	"fmt"
	"math"
)

const s string = "Quantrimang"

func main() {
	fmt.Println(s)

	const n = 5

	const d = 3e10 / n
	fmt.Println(d)

	fmt.Println(int64(d))

	fmt.Println(math.Sin(n))
}

結果：

Quantrimang
6e+09
6000000000
-0.9589242746631385

時間複雜度： O(1)
輔助空間： O(1)

如果您想一次定義多個常數，您可以使用括號區塊來實現，如下所示。

package main

import "fmt"

const (
	GFG	 = "Quantrimang"
	Correct = true
	Pi	 = 3.14
)

// Hàm chính
func main() {

	fmt.Println("value of GFG : ", GFG)

	fmt.Println("value of Correct : ", Correct)

	fmt.Println("value of Pi : ", Pi)
}

結果：

value of GFG :  Quantrimang
value of Correct :  true
value of Pi :  3.14