Go中的短變數宣告運算符

Golang中的短變數宣告運算子（:=）用於建立具有唯一名稱和初始值的變數。使用該運算子的主要目的是宣告和初始化函數內部的局部變量，並縮小變數的範圍。變數的類型由表達式的類型決定。 var 關鍵字也用於建立特定類型的變數。因此可以說，在 Golang 中建立變數有兩種方法，如下所示：

• 使用 var 關鍵字
• 使用短變數宣告運算子（:=）

現在讓我們學習如何在 Golang 中使用短變數宣告運算子！

主要內容

• Golang 中使用短變數宣告運算子的語法
• 使用短聲明運算子聲明多個變數
• 局部變數或全域變數

Golang 中使用短變數宣告運算子的語法

variable_name := biểu thức hoặc giá trị

在這裡，您必須在聲明後立即初始化變數。但是使用var關鍵字可以避免在聲明時初始化。無需提及變數的類型。右側的表達式或值用於評估變數的類型。

例如：這裡我們使用短聲明運算子來宣告變量，而不指定變數的型別。變數的型別由運算子右邊的表達式的型別決定:=。

// Minh họa chương trình Go dùng := (toán tử khai báo ngắn) 
package main

import "fmt"

func main() {

	// khai báo và khởi tạo biến
	a := 30

	// lấy một biến chuỗi
	Language: = "Go Programming"

	fmt.Println("The Value of a is: ", a)
	fmt.Println("The Value of Language is: ", Language)

}

結果：

The Value of a is:  30
The Value of Language is:  Go Programming

使用短聲明運算子聲明多個變數

短聲明運算子也可用於在單一聲明中聲明相同或不同類型的多個變數。這些變數的類型由運算子右側的表達式來評估:=。

例如：

// Minh họa chương trình Go dùng toán tử khai báo ngắn := short để khai báo nhiều
// biến thành một câu lệnh khai báo duy nhất
package main

import "fmt"

func main() { 

// nhiều biến của cùng kiểu(int)
geek1, geek2, geek3 := 117, 7834, 5685

// nhiều biến của các kiểu khác nhau
geek4, geek5, geek6 := "GFG", 859.24, 1234

// Hiện giá trị và kiểu của biến
fmt.Printf("The value of geek1 is : %d\n", geek1) 
fmt.Printf("The type of geek1 is : %T\n", geek1) 

fmt.Printf("\nThe value of geek2 is : %d\n", geek2) 
fmt.Printf("The type of geek2 is : %T\n", geek2) 

fmt.Printf("\nThe value of geek3 is : %d\n", geek3) 
fmt.Printf("The type of geek3 is : %T\n", geek3)

fmt.Printf("\nThe value of geek4 is : %s\n", geek4) 
fmt.Printf("The type of geek4 is : %T\n", geek4)


fmt.Printf("\nThe value of geek5 is : %f\n", geek5) 
fmt.Printf("The type of geek5 is : %T\n", geek5)

fmt.Printf("\nThe value of geek6 is : %d\n", geek6) 
fmt.Printf("The type of geek6 is : %T\n", geek6)

} 

結果：

The value of geek1 is : 117
The type of geek1 is : int

The value of geek2 is : 7834
The type of geek2 is : int

The value of geek3 is : 5685
The type of geek3 is : int

The value of geek4 is : GFG
The type of geek4 is : string

The value of geek5 is : 859.240000
The type of geek5 is : float64

The value of geek6 is : 1234
The type of geek6 is : int

要記住的重點：

當運算子左側至少有一個變數:=被宣告為新變數時，可以使用短聲明運算子。短變數宣告運算子的作用類似於對同一詞法區塊內宣告的變數進行賦值。為了更好地理解這個概念，我們舉一個例子。

例1：下面的程式將拋出一個錯誤，因為運算子的左邊沒有新的變數:=。

// Minh họa chương trình Go dùng khai báo biến ngắn
package main

import "fmt"

func main() { 

	// lấy hai biến
	p, q := 100, 200

	fmt.Println("Value of p ", p, "Value of q ", q)

	// Báo lỗi vì không có biến mới ở bên tay trái của :=
	p, q := 500, 600
	
	fmt.Println("Value of p ", p, "Value of q ", q)
}

錯誤：

./prog.go:17:10: no new variables on left side of := 

範例 2：

在下面的程式中，您可以看到行 geek3, geek2 := 456, 200 將正常工作而不會出現任何錯誤，因為運算符左側至少有一個新變量，即 geek3 :=。

// Chương trình Go dùng toán tử khai báo biến ngắn
package main 

import "fmt"

func main() { 

// Ở đây, khai báo biến ngắn hoạt động
// như một phép gán cho biến geek1
// vì cùng một biến có trong cùng một khối
// do đó giá trị của geek2 được thay đổi từ 100 thành 200
geek1, geek2 := 78, 100

// ở đây, := được sử dụng như một phép gán cho geek2
// vì nó đã được khai báo. Ngoài ra, dòng này
// sẽ hoạt động tốt vì geek3 mới được tạo
// biến
geek3, geek2 := 456, 200

// Nếu bạn thử chạy các dòng được chú thích,
// thì trình biên dịch sẽ báo lỗi vì
// các biến này đã được định nghĩa
// geek1, geek2 := 745, 956
// geek3 := 150

// Hiện giá trị của các biến
fmt.Printf("The value of geek1 and geek2 is : %d %d\n", geek1, geek2) 
											
fmt.Printf("The value of geek3 and geek2 is : %d %d\n", geek3, geek2) 
} 

結果：

The value of geek1 and geek2 is : 78 200
The value of geek3 and geek2 is : 456 200

Go 是一種強型別語言，因為您無法將不同資料類型的值指派給宣告的變數。

例如：

// Minh họa chương trình Go dùng toán tử khai báo biến ngắn
package main 

import "fmt"

func main() { 

	// lấy một biến của int
	z := 50
	
	fmt.Printf("Value of z is %d", z)
	
	// gán lại giá trị của kiểu chuỗi
// nó sẽ đưa ra lỗi
	z := "Golang"
} 

錯誤：

./prog.go:16:4: no new variables on left side of := 
./prog.go:16:7: cannot use “Golang” (type string) as type int in assignment 
 

在簡短的變數宣告中，Golang 允許使用傳回多個值的函數呼叫來初始化一組變數。或者你可以說變數也可以被分配在運行時評估的值。

例如：

// Tại đây, hàm math.Max function trả về
// số lớn nhất trong biến i 
i := math.Max(x, y)

局部變數或全域變數

借助短變數宣告運算子（:=），可以宣告作用域僅在區塊層級的局部變數。一般情況下，局部變數是在函數區塊內部宣告的。如果您嘗試使用短聲明運算子聲明全域變量，則會收到錯誤。

例 1：

// Chương trình Go hiển thị cách sử dụng toán tử :=
// để khai báo các biến cục bộ
package main

import "fmt"

// sử dụng từ khóa var để khai báo
// và khởi tạo biến
// đó là package hoặc bạn có thể nói
// phạm vi cấp toàn cục
var geek1 = 900

// sử dụng khai báo biến ngắn
// sẽ báo lỗi
geek2 := 200

func main() {

// truy cập geek1 bên trong hàm
fmt.Println(geek1)

// truy cập geek2 bên trong hàm
fmt.Println(geek2)

}

錯誤：

./prog.go:15:1: syntax error: non-declaration statement outside function body 

範例 2：

// Chương trình Go dùng toán tử := operator
// để khai báo các biến cục bộ
package main 

import "fmt"

// dùng từ khóa var để khai báo
// và khởi tạo biến
// nó đóng gói hoặc bạn có thể báo
// phạm vi cấp toàn cục
var geek1 = 900


func main() { 

// dùng khai báo biến ngắn
// bên trong hàm chính
// nó có phạm vi cục bộ tức là không thể
// truy cập bên ngoài hàm chính
geek2 := 200

// truy cập geek1 bên trong hàm này
fmt.Println(geek1) 

// truy cập geek2 bên trong hàm này
fmt.Println(geek2) 
	
} 

結果：

900
200