Go 变量是什么?
学习一门编程语言,最先要了解的是什么?当然是词汇。就像学英语一样,再简单的一句话,我们也得先弄清楚每一个单词是什么意思,才能明白整句话表达的含义。
学习 Go 语言也是如此。我们先来看一句简单的代码:
var age int = 20上面这行代码就相当于 Go 语言中的 “一句话”,我们称之为 “语句”。其中,age 就是 Go 语言中的变量。所谓的变量,指的就是在程序运行过程中,值可以发生改变的量。
想要使用变量,我们就得先给它起一个名字(即变量名),就像每个人都有自己的名字一样。当别人喊你的名字时,你就知道喊的是你。当程序需要使用某个变量时,直接通过变量名就能找到它。
变量的名字一般是固定不变的,但它里面存放的值却可以随时改变。这就像人一样,名字从出生起就固定下来了,但年龄却会一年一年地增长。

使用 var 声明变量
在 Go 语言中,我们可以使用 var 关键字来声明一个变量。其中,var 是英文单词 “variable(变量)” 的缩写。声明变量其实就是告诉计算机开辟一块内存空间,用来存放指定数据类型的数据。
语法:
// 方式 1
var 变量名 类型 = 值
// 方式 2
var 变量名 = 值
// 方式 3
var 变量名 类型
变量名 = 值说明:
使用 var 声明变量主要有上面 3 种方式:方式 1 显式指定类型并赋初值;方式 2 省略类型名;方式 3 先声明变量,后面再赋值。需要注意,Go 语言声明变量时习惯把 “变量类型” 写在 “变量名” 的后面。
如果我们在声明变量的同时直接赋了初始值(即方式 2),Go 编译器会自动根据右边的值识别出对应类型,此时就可以把中间的类型名省略不写。
平时给变量起名时,一般以英文字母或下划线开头,不能以数字开头。为了方便阅读,我们尽量选用有意义的英文单词,比如 age、score 等。
示例 1:使用 var 声明变量
package main
import "fmt"
func main() {
var age int = 20 // 指定为 int 类型
var name = "Jack" // 自动推断为 string 类型
fmt.Println(age, name)
}运行结果如下。
20 Jack分析:
var age int = 20 表示声明了一个名为 age 的整型(int)变量,并将初始值设为 20。第 2 行 var name = "Jack" 省略了类型名,因为右边的 "Jack" 是字符串,编译器会自动推断出 name 是 string 类型。
代码行末尾 // 后面的文字是注释,用来给我们自己看说明,编译器会自动忽略它们。最后一行调用 fmt.Println() 把 age 和 name 的值打印到屏幕上;同时传入多个以英文逗号(,)隔开的变量时,打印出的结果中间会自动加上一个空格。
有时候我们在声明变量时,暂时还不确定它具体要存什么值。这时也可以先声明变量,等后面需要用到时再给它赋值。
示例 2:先声明再赋值
package main
import "fmt"
func main() {
var score int // 只声明变量,不赋初值
fmt.Println(score)
score = 95 // 后续再给变量赋值
fmt.Println(score)
}运行结果如下。
0
95分析:
var score int 表示只声明了一个名为 score 的整型变量,并没有立即给它赋值。
在 Go 语言中,如果我们只声明了变量却没有赋初始值,编译器会自动给它赋一个默认的初始值,称为 “零值”。整数类型的默认零值是 0,所以第 1 次打印的结果是 0。随后执行 score = 95 重新赋值,第 2 次打印的结果就变成了 95。
使用 := 短变量声明(推荐)
除了使用 var 关键字之外,Go 语言还提供了一种更加简洁的变量声明方式,叫做 “短变量声明”。它使用 := 符号,连前面的 var 关键字和类型名都可以直接省掉。
语法:
变量名 := 值说明:
使用 := 声明变量,本质上是 var 声明并初始化的简写形式,编译器同样会根据右边的值自动推断出左边变量的类型。在实际开发中,只要是在函数内部定义并初始化变量,我们一般都优先使用 := 这种简写方式。
示例 3:使用 := 短变量声明
package main
import "fmt"
func main() {
count := 10 // 自动推断为 int 类型
city := "Beijing" // 自动推断为 string 类型
fmt.Println(count, city)
}运行结果如下。
10 Beijing分析:
count := 10 表示声明一个名为 count 的变量并赋值为 10,编译器会自动将其识别为 int 类型。对于这个例子来说,下面 2 种方式是等价的。
// 方式 1(推荐)
count := 10
city := "Beijing"
// 方式 2
var count int = 10
var city string = "Beijing"对比可以看出,方式 1 比方式 2 简洁不少。为了帮小伙伴们更好地区分 var 和 :=,我们梳理一下它们之间的 3 点区别:
- 使用位置不同:
var在函数内部和函数外部都可以使用;而:=只能在main()等函数内部使用。如果我们要在func main()外面定义包级变量,就必须使用var。 - 是否必须赋初值:使用
var可以先声明变量而不赋初值,此时变量会自动取默认零值;而使用:=时,我们必须在声明的同时赋初始值。 - 类型写法不同:使用
var既可以显式写出类型,也可以省略类型;而使用:=时固定省略类型,统一由编译器自动推断。
修改变量的值
既然叫做 “变量”,它的值在程序运行过程中自然是可以随时修改的。如果我们想要修改一个已经存在的变量,直接使用等号(=)给它重新赋一个新值就可以了。
示例 4:修改变量的值
package main
import "fmt"
func main() {
age := 20 // 声明变量并赋初值
age = 30 // 修改为 30
age = age + 1 // 在原值基础上加 1
fmt.Println(age)
}运行结果如下。
31分析:
age 一开始的值不是 20 吗,怎么最终输出 31 呢?我们可别忘了,age 是一个变量。当执行 age = 30 时,新的值 30 就会覆盖掉原来的 20。
接着执行 age = age + 1,表示先把右边 age + 1(即 30 + 1)算出来得到 31,再重新赋值给左边的 age,因此最终输出 31。下面代码中,age 的最终值是 16,小伙伴们可以思考一下为什么。
age := 20
age = age + 6
age = age - 10这里小伙伴们要特别注意,:= 只用于声明新变量。当后续修改同一个变量的值时,只能使用普通的等号(=),不能重复使用 :=。
// 正确方式
age := 20
age = 30
// 错误方式
age := 20
age := 30如果像错误方式那样对同一个变量连续使用两次 :=,Go 编译器会直接报错 no new variables on left side of :=,意思是 := 左边没有新变量。另外,如果某个值从定义开始就不希望被修改,那就应该使用常量来表示。
同时声明多个变量
在实际开发中,如果我们想要同时声明多个变量,不必每次都分多行逐个编写。Go 语言支持在同一行内同时为多个变量赋值,也可以使用 var 配合小括号块集中声明。
示例 5:一行声明多个变量
package main
import "fmt"
func main() {
var a, b int = 10, 20 // 声明多个同类型变量
c, d := 30, "Go" // 同时声明不同类型变量
fmt.Println(a, b, c, d)
}运行结果如下。
10 20 30 Go分析:
var a, b int = 10, 20 表示在同一行声明了两个整型变量,变量之间和值之间都使用英文逗号(,)隔开。当多个变量的类型相同时,我们只需要在最后写一次 int 即可。
而使用 c, d := 30, "Go" 时,编译器会分别推断右边每个值的类型,因此我们可以在同一行内声明不同类型的变量。
在实际开发中,多变量同时赋值还有两个很实用的技巧:直接交换两个变量的值,以及 “短变量重声明”。其中,交换两个变量的值可以直接写成 a, b = b, a,不需要像其他语言那样额外借用临时变量。
前面我们刚说过,对单个已有变量不能重复使用 :=。但在多变量赋值时有一个例外:在同一个函数内,只要 := 左边至少包含一个全新变量,其余已有变量就可以一起重新赋值,前提是新值的类型必须和原来保持一致。写法如下:
a, b := 10, 20
a, b = b, a // 直接交换 a 和 b 的值
a, e := 50, 60 // e 是新变量,同时更新已有变量 a在上面第 3 行代码中,因为 e 是全新的变量,所以这行代码可以正常通过编译,并顺带把 a 的值更新成了 50。
如果一组相关的变量比较多,挤在同一行不够直观,我们也可以使用 var 配合小括号将它们集中在一起声明。下面我们来看这个例子。
示例 6:批量声明多个变量
package main
import "fmt"
func main() {
var (
id int = 1001
title string = "Go 教程"
)
fmt.Println(id, title)
}运行结果如下。
1001 Go 教程分析:
在这个例子中,我们使用 var (...) 小括号块将 id 和 title 两个变量集中声明在了一起。这种写法省去了重复书写 var 关键字的麻烦,平时用来定义多条配置项或函数外部的包级变量时非常清晰。
匿名变量(_)
在 Go 语言中,还有一个非常特殊的变量,叫做 “匿名变量”,它使用单个下划线(_)来表示。
为什么需要匿名变量呢?因为 Go 语言有一条严格的语法规定:在函数内部声明的每一个普通变量,后面都必须被使用到,否则程序无法通过编译。如果我们同时接收多个值,其中某个值根本用不上,就可以使用匿名变量 _ 来接收并丢弃它。
示例 7:使用匿名变量 _
package main
import "fmt"
func main() {
a, _ := 10, 20 // 使用 _ 丢弃第 2 个值
fmt.Println(a)
}运行结果如下。
10分析:
a, _ := 10, 20 表示将第 1 个值 10 赋给变量 a,并将第 2 个不需要的值 20 赋给匿名变量 _。匿名变量 _ 就像一个 “回收桶”,任何赋给它的数据都会被直接丢弃,不占用内存空间,而且在同一个函数里可以重复使用无数次。
需要注意的是,匿名变量 _ 只能放在等号左边用来丢弃数据,不能把它当作普通变量去读取。下面这种写法就是错误的。
a, _ := 10, 20
fmt.Println(_)如果尝试读取 _ 的值,编译器会直接报错 cannot use _ as value,意思是不能将 _ 当作值来使用。
当然,单纯给普通变量赋值时,大家没必要故意多写一个 20 再通过 _ 丢掉,这里只是为了方便看清语法格式。在实际开发中,Go 语言的函数经常会同时返回 “计算结果” 和 “错误信息” 两个值,当我们只关心结果时,使用 _ 把多余的返回值忽略掉就非常实用了。
局部变量声明后必须使用
在许多编程语言中,即使先声明几个备用变量放着不用,程序也能正常编译。但在 Go 语言中,只要我们在函数内部声明了某个普通局部变量,却没有在后面的代码中读取它的值,编译器就会直接报错并拒绝编译。
比如在 main() 函数中定义了 var b int = 20,后面却没有读取它的值。编译时就会提示 b declared and not used,意思是变量 b 已声明但未使用。Go 语言这样设计,是为了从源头上清理无用的冗余变量,保持项目代码干净整洁。
