Go语言：变量的声明

在计算机语言中，变量是以可读的名称表示保存值的存储位置。变量存储的值都有对应的类型，它的类型决定了变量存储值的空间以及操作。在Go语言中，它的命名需要符合Go语言：标识符命名规则。

变量在使用之前，需要先声明变量。Go语言提供了多种声明变量的方式，主要分为：

1. 使用关键词var基本格式声明变量
2. 多变量的声明
3. 使用简短赋值符:=声明变量

下面介绍变量的多种声明方式

声明变量的基本格式

GO语言声明变量的基本格式是使用 var 关键字声明，如下：

var variable_name type = expression

其中：

• variable_name：表示变量名，需把variable_name替换为实际使用的变量名。
• type：表示变量类型，需把type替换为实际使用变量类型，如string，int等等。
• expression：在等号右边，是对变量进行赋值的表达式，即对变量赋初始值。

示例：

package main

import "fmt"

func main() {
    var i int = 8
    fmt.Println(i)
}

示例中，定义了变量i，它的类型为整型int，赋初始值为8。所以打印输出结果为：

8

变量缺省值

在声明变量时，是可以不赋初始值，其格式为：

var variable_name type

当变量声明时，没有显式赋初始值，Go语言会使用变量类型的默认值初始化变量，该默认值也称为该类型的零值。因为默认值是在变量未显式初始化时赋值，也称为缺省值。如int类型的变量缺省值为0，string类型的变量缺省值为空字符串“”。

示例：

package main

import "fmt"

func main() {
    var i int
    fmt.Println(i)
}

输出结果：

0

因为变量的缺省值是由变量类型决定，所以当变量声明没有显式赋初始值时，必须指定其类型。

变量的类型推断

从变量的缺省值我们知道，类型决定了变量的缺省值。反过来，变量的值也能确定变量的类型。所以，Go语言中允许我们在声明变量时，不显式指定变量的类型。这种方式称为变量的类型推断。其格式是：

var variable_name = expression

以下为基本类型数值对应的Go语言类型

对于Array，Pointer和Structure类型，Go语言也会根据值做类型推断。

示例：

package main

import "fmt"

func main() {
    var a = 123      //int
    var b = "bstring" //string
    var c = 5.6      //float64
    var d = true     //bool
    var e = 'a'      //rune
    var f = 3 + 5i   //complex128
    var g = mystruct{name: "test"}  //main.MyStruct

    fmt.Printf("Type: %T Value: %v\n", a, a)
    fmt.Printf("Type: %T Value: %v\n", b, b)
    fmt.Printf("Type: %T Value: %v\n", c, c)
    fmt.Printf("Type: %T Value: %v\n", d, d)
    fmt.Printf("Type: %T Value: %v\n", e, e)
    fmt.Printf("Type: %T Value: %v\n", f, f)
    fmt.Printf("Type: %T Value: %v\n", g, g)
}

type mystruct struct {
    name string
}

多变量声明

多变量声明根据多个变量的类型是否相同分为两种：

1. 相同类型的变量声明
2. 不同类型的变量声明

单个变量的缺省值声明和类型推断同样适用于多变量声明，在此就不重复说明。

相同类型的多变量声明

对于多个变量的声明，如果它们的类型是相同的，可以使用以下格式声明：

var name1, name2, …..,nameN type = value1, value2, …..,valueN

示例：

package main

import "fmt"

func main() {
    var a, b int = 8, 9
    var c,d int
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}

输出结果：

8
9
0
0

不同类型多变量声明

对于多个变量的声明，如果它们的类型不同，可以使用以下示例格式：

package main

import "fmt"

func main() {
    var (
        a int
        b int    = 10
        c string = "cstring"
    )

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

先声明var关键词，接着在括号里声明变量，声明的变量可以赋初始值，如果不赋初始值，则使用类型的缺省值。

输出结果：

0
10
cstring

多变量声明的类型推断

多变量声明的类型推断格式：

var name1, name2,…,nameN = value1,value2,…,valueN

各个变量的类型由它各自的值确定，示例：

import "fmt"

func main() {
    var a, b, c = 10, true, "cstring"
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

这种赋值常常使用在返回多个变量的方法上，如：

var f,err = os.Open(filename)

其中，f为os.Open返回的文件和错误err。

简短变量声明

Go 提供了另一种声明变量的方法，它使用 := 运算符。当使用 := 运算符时，var 关键词和类型信息都可以省略。以下是此类声明的格式：

 variable_name := expression

简短变量声明，既省略了var关键词，并且使用了Go语言的类型推断特性。以上类型推断的示例可以改写为：

package main

import "fmt"

func main() {
    a := 123      //int
    b := "bstring" //string
    c := 5.6      //float64
    d := true     //bool
    e := 'a'      //rune
    f := 3 + 5i   //complex128
    g := mystruct{name: "test"}  //main.MyStruct

    fmt.Printf("Type: %T Value: %v\n", a, a)
    fmt.Printf("Type: %T Value: %v\n", b, b)
    fmt.Printf("Type: %T Value: %v\n", c, c)
    fmt.Printf("Type: %T Value: %v\n", d, d)
    fmt.Printf("Type: %T Value: %v\n", e, e)
    fmt.Printf("Type: %T Value: %v\n", f, f)
    fmt.Printf("Type: %T Value: %v\n", g, g)
}

type mystruct struct {
    name string
}

:=运算符使用说明

使用:=运算符需要满足以下条件：

1. := 运算符仅在函数中可用。在函数之外是不允许的。

2. 使用 := 声明的变量不能多次使用 := 运算符重新声明。以下示例会报错：

a := 1
a := 2

3. := 运算符可声明多个变量。

a,b := 1, 2

4. 在多变量声明的情况下，如果至少一个变量是新的，则 := 也可以再次用于特定变量。

a, b := 1, 2
b, c := 3, 4

注意：第二行代码变量b虽然已被声明赋值，但由于c是新变量，所以允许使用:=运算符重新赋值。