变量可以通过变量名访问。  
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。  
声明变量的一般形式是使用 var 关键字：  
`var identifier type`  
可以一次声明多个变量：  
`var identifier1, identifier2 type`

### 变量声明

第一种，指定变量类型，如果没有初始化，则变量默认为零值。  
零值就是变量没有做初始化时系统默认设置的值。

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

布尔类型为 false

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

以下几种类型为 nil：

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

```go
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`  
例如：

```go
var intVal int 
intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明
```

直接使用下面的语句即可：  
`intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句`  
`intVal := 1` 相等于：

```go
var intVal int 
intVal =1
```

### 多变量声明

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

```go
package main
import "fmt"

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"
    fmt.Println(x, y, a, b, c, d, e, f, g, h)
}
```

以上实例执行结果为：  
`0 0 0 false 1 2 123 hello 123 hello`

### 值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：  
![4.4.2_fig4.1.jpg](../../../_resources/4.4.2_fig4.1.jpg)  
当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：  
![4.4.2_fig4.2.jpg](../../../_resources/4.4.2_fig4.2.jpg)  
可以通过 `&i`来获取变量`i`的内存地址，例如：0xf840000040（每次的地址都可能不一样）。  
值类型变量的值存储在堆中。  
![4.4.2_fig4.3.jpg](../../../_resources/4.4.2_fig4.3.jpg)  
内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。  
更复杂的数据通常会需要使用多个字，这些数据一般使用引用类型保存。  
一个引用类型的变量 `r1` 存储的是 `r1` 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。  
这个内存地址称之为指针，这个指针实际上也被存在另外的某一个值中。  
同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。  
当使用赋值语句`r2 = r1` 时，只有引用（地址）被复制。  
如果`r1` 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，`r2` 也会受到影响。