Go 变量

Go 变量是什么?

学习一门编程语言,最先要了解的是什么?当然是词汇。就像学英语一样,再简单的一句话,我们也得先弄清楚每一个单词是什么意思,才能明白整句话表达的含义。

学习 Go 语言也是如此。我们先来看一句简单的代码:

var age int = 20

上面这行代码就相当于 Go 语言中的 “一句话”,我们称之为 “语句”。其中,age 就是 Go 语言中的变量。所谓的变量,指的就是在程序运行过程中,值可以发生改变的量。

想要使用变量,我们就得先给它起一个名字(即变量名),就像每个人都有自己的名字一样。当别人喊你的名字时,你就知道喊的是你。当程序需要使用某个变量时,直接通过变量名就能找到它。

变量的名字一般是固定不变的,但它里面存放的值却可以随时改变。这就像人一样,名字从出生起就固定下来了,但年龄却会一年一年地增长。

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 语言这样设计,是为了从源头上清理无用的冗余变量,保持项目代码干净整洁。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号