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

  1. package main
  2. import "fmt"
  3. func main() {
  4.     var a string = "Hello"
  5.     fmt.Println(a)
  7.     var b, c = 1, 2
  8.     fmt.Println(b, c)
  9. }

输出结果为：
Hello
1 2

变量声明

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

  1. var v_name v_type
  2. v_name = value

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

  1. package main
  2. import "fmt"
  3. func main() {
  4.     // 声明一个变量并初始化
  5.     var a = "Hello"
  6.     fmt.Println(a)
  8.     // 没有初始化就为零值
  9.     var b int
  10.     fmt.Println(b)
  12.     // bool零值为false
  13.     var c bool
  14.     fmt.Println(c)
  15. }

以上实例执行结果为：
Hello
0
false
数值类型（包括complex64/128）为0
布尔类型为false
字符串为””(空字符串)
以下几种类型为nil：

  1. var a *int
  2. var a []int
  3. var a map[string] int
  4. var a chan int // what's this?
  5. var a func(string) int
  6. var a error // error是接口
  1. package main
  2. import "fmt"
  4. func main() {
  5.     var i int
  6.     var f float64
  7.     var b bool
  8.     var s string
  9.     fmt.Println("%v %v %v %q\n", i, f, b, s)
  10. }

输出结果是：
0 0 false ""
第二种，根据值自行判定变量类型
var v_name = value

  1. package main
  2. import "fmt"
  3. func main() {
  4.     var d = true
  5.     fmt.Println(d)
  6. }

输出结果是：true
第三种，如果变量已经使用var声明过了，再使用**:=**声明变量，就产生编译错误，格式：
v_name := value
例如：

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

直接使用下面的语句即可：
intVal := 1相等于：

  1. var intVal int
  2. intVal = 1

可以将var f string = "Hello"简写成f := "Hello"

  1. package main
  2. import "fmt"
  3. func main() {
  4.     f := "Hello, World!" // var f string = "Hello, World"
  5.     fmt.Println(f)
  6. }

多变量声明

  1. // 类型相同多个变量，非全局变量
  2. var vname1, vname2, vname3 type
  3. vname1, vname2, vname3 = v1, v2, v3
  5. var vname1, vname2, vname3 = v1, v2, v3 // 和python很像，不需要显示声明类型，自动推断
  7. vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误
  9. // 这种因式分解关键字的写法一般用于声明全局变量
  10. var (
  11.     vname1 v_type1
  12.     vname2 v_type2
  13. )
  1. package main
  2. import "fmt"
  4. var x, y int
  5. var ( // 这种因式分解关键字的写法一般用于声明全局变量
  6.     a int
  7.     b bool
  8. )
  10. var c, d int = 1, 2
  11. var e, f = 123, "hello"
  13. // 这种不带声明格式的只能在函数体中出现
  14. // g, h := 123, "hello"
  16. func main() {
  17.     g, h = 123, "hello"
  18.     fmt.Println(x, y, a, b, c, d, e, f, g, h)
  19. }

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

值类型和引用类型

所有像int、float、bool和string这些基本类型都属于值类型，使用这些类型的变量直接指向存在的内存中的值

  1. var i = 7 // 自动判断类型
  2. j = i // 实际上是在内存中将i的值进行了拷贝，可以通过 &i 来获取变量i的内存地址，例如0xf840000040

简短形式赋值，使用 := 赋值操作

变量的初始化时省略变量的类型而由系统自动推断，声明语句不必写上 var 关键字，可以简写为var a := 50 或b := false

注意事项

  1. 不可以对相同名称的变量使用初始化声明，会提示：no new variables on left side of :=
  2. 声明的局部变量必须被使用，会提示：a declared and not used
  3. 全局变量允许声明但不使用
  4. 如果需要交换两个变量，则可以使用a, b = b, a，两个变量的类型必须相同
  5. 空白标识符 被用于抛弃值， 如值5 在： , b = 5, 7中被抛弃