Go语言变量声明（var关键字）

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存，是计算机语言中能储存计算结果或能表示值抽象概念。

变量可以通过变量名访问。

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

声明变量的一般形式是使用 var 关键字：

var identifier type

其中，var 是声明变量的关键字，identifier是变量名，type 是变量的类型。

可以一次声明多个变量：

var identifier1, identifier2 type

package main
import "fmt"
func main() {
    var a string = "go"
    fmt.Println(a)
    var b, c int = 1, 2
    fmt.Println(b, c)
}

以上实例输出结果为：

go
1 2

注意：Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。

变量类型与命名

Go语言的基本类型有：

• bool
• string
• int、int8、int16、int32、int64
• uint、uint8、uint16、uint32、uint64、uintptr
• byte // uint8 的别名
• rune // int32 的别名 代表一个 Unicode 码
• float32、float64
• complex64、complex128

当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。所有的内存在 Go 中都是经过初始化的。

变量的命名规则遵循骆驼命名法，即首个单词小写，每个新单词的首字母大写，例如：numShips 和 startDate 。

变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

var v_name v_type
v_name = value

零值就是变量没有做初始化时系统默认设置的值。

package main
import "fmt"
func main() {

    // 声明一个变量并初始化
    var a = "GO"
    fmt.Println(a)

    // 没有初始化就为零值
    var b int
    fmt.Println(b)

    // bool 零值为 false
    var c bool
    fmt.Println(c)
}

以上实例执行结果为：

GO
0
false

数值类型（包括complex64/128）为 0

布尔类型为 false

字符串为 ""（空字符串）

以下几种类型为 nil：

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

package main
import "fmt"
func main() {
    var i int
    var f float64
    var b bool
    var s string
    fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

输出结果是：

0 0 false ""

第二种，根据值自行判定变量类型。

var v_name = value

实例

package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}

输出结果是：

true

第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

v_name := value

简短模式（short variable declaration）有以下限制：

• 定义变量，同时显式初始化。
• 不能提供数据类型。
• 只能用在函数内部。

和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

下面通过一段代码来演示简短格式变量声明的基本样式。

func main() {
   x:=100
   a,s:=1, "abc"
}

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。var 形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。

例如：

var intVal int 

intVal :=1 // 这时候会产生编译错误

intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句

可以将 var f string = "GO" 简写为 f := "GO"：

实例

package main
import "fmt"
func main() {
    f := "GO" // var f string = "GO"
    fmt.Println(f)
}

输出结果是：

GO

多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

实例

package main
var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"
func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为：

0 0 0 false 1 2 123 hello 123 hello