在计算机语言中，变量是以可读的名称表示保存值的
变量在使用之前，需要先声明变量。Go语言提供了多种声明变量的方式，主要分为：
- 使用关键词
var基本格式声明变量 - 多变量的声明
- 使用简短赋值符
:=声明变量
下面介绍变量的多种声明方式
声明变量的基本格式
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语言类型
| 变量值类型 | Go语言的基本类型 |
| 整数 | int |
| 浮点数 | float64 |
| 复数 | complex128 |
| 字符串 | string |
| 字符 | int32 或者 rune |
对于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
}多变量声明
多变量声明根据多个变量的类型是否相同分为两种：
- 相同类型的变量声明
- 不同类型的变量声明
单个变量的缺省值声明和类型推断同样适用于多变量声明，在此就不重复说明。
相同类型的多变量声明
对于多个变量的声明，如果它们的类型是相同的，可以使用以下格式声明：
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 := 23. := 运算符可声明多个变量。
a,b := 1, 24. 在多变量声明的情况下，如果至少一个变量是新的，则 := 也可以再次用于特定变量。
a, b := 1, 2
b, c := 3, 4注意：第二行代码变量b虽然已被声明赋值，但由于c是新变量，所以允许使用:=运算符重新赋值。
