变量声明
可以一次声明多个变量：
var identifier1, identifier2 type
实例2
package main
import "fmt"
var c, python, java bool
func main() {
var a string = "test"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
var i int
fmt.Println(i, c, python, java)
}
以上实例输出结果为：
test
1 2
-
数值类型（包括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
Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type.
Outside a function, every statement begins with a keyword (var, func, and so on) and so the := construct is not available.
注意 *:=* 左侧如果没有声明新的变量，就产生编译错误，格式：
v_name := value
例如：
var intVal int
intVal :=1 // 这时候会产生编译错误
intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
可以将 var f string = “Runoob” 简写为 f := “Runoob”：
实例
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f)
}
输出结果是：
Runoob
多变量声明
//类型相同多个变量, 非全局变量
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
常量声明（const）
const identifier [type] = value
你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。
- 显式类型定义：
const b string = "abc" - 隐式类型定义：
const b = "abc"
多个相同类型的声明可以简写为：
const c_name1, c_name2 = value1, value2
以下实例演示了常量的应用：
实例
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" *//多重赋值*
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
println()
println(a, b, c)
}
以上实例运行结果为：
面积为 : 50
1 false str
Default Values
Variables declared without an explicit initial value are given their zero value.
The zero value is:
0for numeric types,falsefor the boolean type, and""(the empty string) for strings.
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)
}
//output 0 0 false ""
变量作用域
局部变量
在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。
以下实例中 main() 函数使用了局部变量 a, b, c：
实例
package main
import "fmt"
func main() {
*/\* 声明局部变量 \*/*
var a, b, c int
*/\* 初始化参数 \*/*
a = 10
b = 20
c = a + b
fmt.Printf ("结果： a = %d, b = %d and c = %d\n", a, b, c)
}
以上实例执行输出结果为：
结果： a = 10, b = 20 and c = 30
全局变量
在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。
全局变量可以在任何函数中使用，以下实例演示了如何使用全局变量：
实例
package main
import "fmt"
*/\* 声明全局变量 \*/*
var g int
func main() {
*/\* 声明局部变量 \*/*
var a, b int
*/\* 初始化参数 \*/*
a = 10
b = 20
g = a + b
fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}
以上实例执行输出结果为：
结果： a = 10, b = 20 and g = 30
Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。实例如下：
实例
package main
import "fmt"
*/\* 声明全局变量 \*/*
var g int = 20
func main() {
*/\* 声明局部变量 \*/*
var g int = 10
fmt.Printf ("结果： g = %d\n", g)
}
以上实例执行输出结果为：
结果： g = 10
形式参数
形式参数会作为函数的局部变量来使用。实例如下：
实例
package main
import "fmt"
*/\* 声明全局变量 \*/*
var a int = 20;
func main() {
*/\* main 函数中声明局部变量 \*/*
var a int = 10
var b int = 20
var c int = 0
fmt.Printf("main()函数中 a = %d\n", a);
c = sum( a, b);
fmt.Printf("main()函数中 c = %d\n", c);
}
*/\* 函数定义-两数相加 \*/*
func sum(a, b int) int {
fmt.Printf("sum() 函数中 a = %d\n", a);
fmt.Printf("sum() 函数中 b = %d\n", b);
return a + b;
}
以上实例执行输出结果为：
main()函数中 a = 10
sum() 函数中 a = 10
sum() 函数中 b = 20
main()函数中 c = 30
初始化局部和全局变量
不同类型的局部和全局变量默认值为：
| 数据类型 | 初始化默认值 |
|---|---|
| int | 0 |
| float32 | 0 |
| pointer | nil |