Short variable declaration operator in Go

The short variable declaration operator (:=) in Golang is used to create variables with a specific name and initial value. The main purpose of using this operator is to declare and initialize local variables inside functions and to narrow the scope of variables. The type of the variable is determined by the type of the expression. The var keyword is also used to create variables of a specific type. So you can say that there are two ways to create variables in Golang as follows:

• Using the var keyword
• Use the short variable declaration operator (:=)

Now let's learn how to use the short variable declaration operator in Golang!

Main content

• Syntax for using short variable declaration operator in Golang
• Declaring multiple variables using the short declaration operator
• Local variable or global variable

Syntax for using short variable declaration operator in Golang

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

Here, you have to initialize the variable immediately after declaration. But using var keyword , you can avoid initialization at the time of declaration. There is no need to mention the type of the variable. The expression or value on the right side is used to evaluate the type of the variable.

For example, here we are declaring variables using the short declaration operator and not specifying the type of the variable. The type of the variable is determined by the type of the expression on the right side of the operator :=.

// 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)

}

Result:

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

Declaring multiple variables using the short declaration operator

The short declaration operator can also be used to declare multiple variables of the same or different types in a single declaration. The types of these variables are evaluated by the expression on the right side of the operator :=.

For example:

// 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)

} 

Result:

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

Important points to remember:

The short declaration operator can be used when at least one variable on the left side of the operator :=is newly declared. The short variable declaration operator works like an assignment to variables that have been declared in the same lexical block. To understand this concept better, let's take an example.

Example 1: The program below will throw an error because there is no new variable on the left side of the operator :=.

// 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)
}

Error:

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

Example 2:

In the program below, you can see the line geek3, geek2 := 456, 200 will work fine without any error because there is at least one new variable i.e. geek3 on the left side of the operator :=.

// 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) 
} 

Result:

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

Go is a strongly typed language because you cannot assign a value of a different data type to a declared variable.

For example:

// 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"
} 

Error:

./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 
 

In a short variable declaration, Golang allows initializing a set of variables using a function call that returns multiple values. Or you can say variables can also be assigned values ​​that are evaluated at runtime.

For example:

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

Local variable or global variable

With the help of short declaration operator (:=), you can declare local variables whose scope is only at the block level. Generally, local variables are declared inside the function block. If you try to declare global variables using short declaration operator then you will get an error.

Example 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)

}

Error:

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

Example 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) 
	
} 

Result:

900
200