Golang 短变量声明操作符(:=)

Golang中的短变量声明操作符(:=)是用来创建具有适当名称和初始值的变量。使用这个操作符的主要目的是在函数中声明和初始化 局部变量 ，并缩小变量的范围。变量的类型由表达式的类型决定。var关键字也用于创建特定类型的变量。所以你可以说，在Golang中有两种创建变量的方法，如下。

使用var关键字
使用简短的变量声明操作符（:=）。

在这篇文章中，我们将只讨论短变量声明操作符。要了解var关键字，你可以参考 Go中的var关键字。 你也可以阅读 var关键字和短变量声明操作符之间的区别 ，以正确理解两者的使用。

使用短变量声明操作符的语法 。

variable_name := expression or value

在这里，你必须在声明后就初始化变量。但是使用var关键字，你可以避免在声明时进行初始化。 没有必要提及变量的类型。 右手边的表达式或值用于评估变量的类型。

例子： 在这里，我们使用short declaration操作符来声明变量，我们没有指定变量的类型。变量的类型是由 := 操作符右边的表达式的类型决定的。

// Go program to illustrate the use
// of := (short declaration
// operator)
package main
 
import "fmt"
 
func main() {
 
    // declaring and initializing the variable 
    a := 30
 
    // taking a string variable
    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

使用短声明操作符（:=）声明多个变量

短声明操作符也可以用来在单个声明中声明 相同类型或不同类型 的多个变量。这些变量的类型是由 := 操作符右边的表达式来评估的。

例子

// Go program to illustrate how to use := short
// declaration operator to declare multiple
// variables into a single declaration statement
package main
  
import "fmt"
 
func main() {
 
// multiple variables of same type(int)
geek1, geek2, geek3 := 117, 7834, 5685
 
// multiple variables of different types
geek4, geek5, geek6 := "GFG", 859.24, 1234
 
// Display the value and
// type of the variables
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： 下面的程序会出现错误，因为在:=操作符的左边没有新的变量。

// Go program to illustrate the concept
// of short variable declaration
package main
 
import "fmt"
 
func main() { 
 
    // taking two variables
    p, q := 100, 200
 
    fmt.Println("Value of p ", p, "Value of q ", q)
 
    // this will give an error as
    // there are no new variable
    // on the left-hand side of :=
    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 。

// Go program to show how to use
// short variable declaration operator
package main
 
import "fmt"
 
func main() {
 
// Here, short variable declaration acts
// as an assignment for geek1 variable
// because same variable present in the same block
// so the value of geek2 is changed from 100 to 200
geek1, geek2 := 78, 100
 
// here, := is used as an assignment for geek2
// as it is already declared. Also, this line
// will work fine as geek3 is newly created
// variable
geek3, geek2 := 456, 200
 
// If you try to run the commented lines,
// then compiler will gives error because
// these variables are already defined
// geek1, geek2 := 745, 956
// geek3 := 150
 
// Display the values of the variables
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是一种强类型的语言，因为你不能把其他类型的值分配给已声明的变量。
例子

// Go program to show how to use
// short variable declaration operator
package main
 
import "fmt"
 
func main() {
 
    // taking a variable of int type
    z := 50
     
    fmt.Printf("Value of z is %d", z)
     
    // reassigning the value of string type
    // it will give an error
    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

在一个简短的变量声明中，允许通过返回多个值的调用函数来初始化一组变量。或者你可以说变量也可以被赋值，在运行时被评估。
例子

// Here, math.Max function return 
// the maximum number in i variable
i := math.Max(x, y)

本地变量还是全局变量？

在短变量声明操作符（:=）的帮助下， 你只能声明 只有块级范围的 局部变量 。一般来说，局部变量是在功能块内声明的。如果你试图用短声明操作符来声明全局变量，那么你会得到一个错误。

例1 :

// Go program to show the use of := operator
// to declare local variables
package main
   
import "fmt"
   
// using var keyword to declare 
// and initialize the variable
// it is package or you can say 
// global level scope
var geek1 = 900
   
// using short variable declaration
// it will give an error
geek2 := 200
   
func main() {
   
// accessing geek1 inside the function
fmt.Println(geek1)
  
// accessing geek2 inside the function
fmt.Println(geek2)
       
}

错误。

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

例2 :

// Go program to show the use of := operator
// to declare local variables
package main
   
import "fmt"
   
// using var keyword to declare 
// and initialize the variable
// it is package or you can say 
// global level scope
var geek1 = 900
 
   
func main() {
 
// using short variable declaration
// inside the main function
// it has local scope i.e. can't
// accessed outside the main function
geek2 := 200
   
// accessing geek1 inside the function
fmt.Println(geek1)
  
// accessing geek2 inside the function
fmt.Println(geek2)
       
}