变量相当于计算机中一块存储区域的命名，通过定义变量能像系统申请到一块存储空间。通过使用变量名，能对这块存储空间进行操作。

定义变量

在go中，可以使用var关键字来定义变量，且要将值类型放置到变量定义后面。

  1. var i int

可以同时定义多个同类型变量

var i1,i2 int

可以分组定义

var (
    a,a1 int
    b string
  c bool
)

需要注意的是定义变量后，系统会将变量初始化为该类型的初始值，入`i`会为`0`，`b`是`空字符串`，`c`是`flase`

package main

import "fmt"

// 定义一个
var i int

// 定义多个同类型
var i1, i2 int

// 分组定义
var (
    a, a1 int
    b     string
)

func main() {
    fmt.Printf("i is %d \n", i)
    fmt.Printf("i1 is %d \n", i1)
    fmt.Printf("i2 is %d \n", i2)
    fmt.Printf("a is %d \n", a)
    fmt.Printf("a1 is %d \n", a1)
    fmt.Printf("b is %s \n", b)
}

变量初始化

如果需要在定义变量同时对变量进行初始化，可以选择一下三种方式

  • 常规赋值

    var c int = 10

  • 自动推导类型，如果定义时不指定类型，在编译期间，编译器会自动推导

    var c1 = 10

  • 可以忽略var 关键字使用:,在编译期间，编译器也会自动推导。需要注意使用：初始化的变量名称必须是不存在的，否则会编译报错

    c2 := 10

    ``` package main

import “fmt”

func main() { var c int = 10 var c1 = 10 c2 := 10

fmt.Printf("c is %d \n", c)
fmt.Printf("c1 is %d \n", c1)
fmt.Printf("c2 is %d \n", c2)

}

<a name="jzWGY"></a>
## 变量赋值，多重赋值
在go中变量初始化，变量赋值是两种概念。如果使用上面一行代码定义变量，内部会先执行初始化，然后再赋值，变量初始化，只会`执行一次`，变量赋值会`执行多次`。

var d int fmt.Printf(“d is %d \n”, d) // 输出0 d = 100 fmt.Printf(“d is %d \n”, d) // 输出100 d = 200 fmt.Printf(“d is %d \n”, d) // 输出200


在go中还支持变量多重赋值，交换变量值非常方便。

d1 := 1
d2 := 2
fmt.Printf("d1 is %d \n", d1)
fmt.Printf("d2 is %d \n", d2)
d1, d2 = d2, d1
fmt.Printf("d1 is %d \n", d1)
fmt.Printf("d2 is %d \n", d2)

```
package main

import "fmt"

func main() {
    var d int
    fmt.Printf("d is %d \n", d) // 输出0
    d = 100
    fmt.Printf("d is %d \n", d) // 输出100
    d = 200
    fmt.Printf("d is %d \n", d) // 输出200

    d1 := 1
    d2 := 2
    fmt.Printf("d1 is %d \n", d1)
    fmt.Printf("d2 is %d \n", d2)
    d1, d2 = d2, d1
    fmt.Printf("d1 is %d \n", d1)
    fmt.Printf("d2 is %d \n", d2)
}

匿名变量

假设我们有一个方法，这个方法有多个返回值，这时候我们需要定义多个变量来对返回值进行接收，导致我们定义了很多无用的变量。这个时候我们可以使用_定义一个匿名变量来对返回值进行接收，任何赋予它的值都会被丢弃回收。

package main

import "fmt"

func GetName() (name, nickName string) {
    name = "test"
    nickName = "测试"

    return name, nickName
}

func main() {
    _, nickName := GetName()
    fmt.Printf("nickName is %s \n", nickName)
}

变量的作用域

每个定义的变量在程序中都有一定的作用范围，这个我们称之为变量作用域，go中分为全局变量以及局部变量。

  • 全局变量：定义在函数体外的变量，我们称之为全局变量。可以在整个包，甚至外部包使用（如果以大写开头），不管你是在那个源文件下调用。
  • 局部变量：在函数体内定义的变量，我们称之为局部变量，局部变量只能在定义的函数体内使用，函数中的参数以及返回值也是局部变量

但你可以在某个代码块的内层代码块中使用相同名称的变量，则此时外部的同名变量将会暂时隐藏（结束内部代码块的执行后隐藏的外部同名变量又会出现，而内部同名变量则被释放），你任何的操作都只会影响内部代码块的局部变量。比如定义了一个全局变量d2,在函数体中再定义一个局部变量d2,修改局部变量d2不会对全局变量有任何影响。

package main

import "fmt"

var d2 = 10

func Test() {
    var d2 = 20
    fmt.Printf("局部变量d2 is %d \n", d2)
}

func main() {
    Test()
    fmt.Printf("全局变量d2 is %d \n", d2)
}