在 Go 语言中,运算符指的是对 “变量” 或 “值” 进行计算和比较的符号。就像数学里需要加减乘除才能算出结果一样,我们编写程序也需要借助各种运算符来处理数据。
常用的 Go 运算符主要分为以下 5 大类:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
除了上面这 5 类之外,Go 语言还有用于操作内存地址的 & 和 * 符号,它们属于指针的专属操作,这里先不做展开。
Go 算术运算符
在 Go 语言中,算术运算符主要用于日常的数学四则运算,以及让变量自身加 1 或减 1。假设变量 a 的值为 10、b 的值为 3,常用的算术运算符如下表所示。
| 运算符 | 说明 | 示例结果 |
|---|---|---|
| + | 相加 | a + b 结果为 13 |
| - | 相减 | a - b 结果为 7 |
| * | 相乘 | a * b 结果为 30 |
| / | 相除 | a / b 结果为 3 |
| % | 求余(取模) | a % b 结果为 1 |
| ++ | 自增(加 1) | a++ 后 a 变为 11 |
| -- | 自减(减 1) | a-- 后 a 变为 9 |
跟其他编程语言一样,Go 语言中的乘号是 “*” 而不是 “×”,除号是 “/” 而不是 “÷”。这是因为标准键盘上没有 “×” 和 “÷”,直接使用键盘上已有的符号敲代码更加方便。
另外,加号 + 除了用于数值相加之外,还可以直接把两个字符串拼接在一起(如 "Hello, " + "Go")。
示例 1:算术运算符的使用
package main
import "fmt"
func main() {
a := 10
b := 3
fmt.Println(a + b) // 相加
fmt.Println(a - b) // 相减
fmt.Println(a * b) // 相乘
fmt.Println(a / b) // 整数相除
fmt.Println(a % b) // 求余
}运行结果如下。
13
7
30
3
1分析:
从运行结果可以看出,加、减、乘的结果都很直观,唯独除法 a / b(即 10 / 3)输出的结果是 3 而不是 3.333...。
这里小伙伴们要特别注意:在 Go 语言中,如果除号 / 两边都是整数,计算出来的结果也一定是整数,小数部分会被直接截断舍弃。如果我们希望保留小数结果,可以让浮点数参与运算(如 10.0 / 3.0),或者先通过类型转换将整数转为 float64 再相除。
求余运算符 % 用于计算两个整数相除后的余数,要求两边都必须是整数。10 除以 3 商 3 余 1,因此 a % b 的结果是 1,平时判断一个整数是奇数还是偶数就经常用到它。注意在进行除法 / 或求余 % 运算时,右边的除数不能为 0,否则程序会直接报错。
接下来我们再看自增(++)和自减(--)。所谓的自增和自减,指的就是在变量原有数值的基础上加 1 或减 1。
示例 2:自增与自减
package main
import "fmt"
func main() {
n := 10
n++ // 自增 1
fmt.Println(n)
n-- // 自减 1
fmt.Println(n)
}运行结果如下。
11
10分析:
n++ 等价于 n = n + 1,执行后变量 n 的值从 10 变成了 11;随后的 n-- 等价于 n = n - 1,执行后 n 的值又从 11 变回了 10。
如果小伙伴们之前接触过 C 或 Java,在使用 Go 语言的 ++ 和 -- 时要特别留意:Go 语言规定 n++ 和 n-- 是一条独立的语句,而不是表达式,必须单独占一行写。
// 正确方式
n++
a := n
// 错误方式
a := n++
fmt.Println(n++)
++n因为 n++ 必须单独占一行,所以我们既不能写成 a := n++ 赋值给别的变量,也不能写成 fmt.Println(n++) 放进函数参数里。同时,Go 语言只有写在变量后面的 n++ 和 n--,没有写在变量前面的 ++n 和 --n。
Go 关系运算符
在 Go 语言中,关系运算符也叫做 “比较运算符”,用来比较两边的值或表达式。如果比较成立就返回布尔值 true,不成立就返回 false。假设 x = 10、y = 20,常用的关系运算符如下表所示。
| 运算符 | 说明 | 示例结果 |
|---|---|---|
| == | 等于 | x == y 为 false |
| != | 不等于 | x != y 为 true |
| > | 大于 | x > y 为 false |
| < | 小于 | x < y 为 true |
| >= | 大于或等于 | x >= y 为 false |
| <= | 小于或等于 | x <= y 为 true |
当我们使用关系运算符时,要注意像 ==、!=、>=、<= 这些由两个字符组成的符号,中间不能留空格。
示例 3:关系运算符的使用
package main
import "fmt"
func main() {
x := 10
y := 20
fmt.Println(x == y) // 判断是否相等
fmt.Println(x != y) // 判断是否不相等
fmt.Println(x < y) // 判断 x 是否小于 y
}运行结果如下。
false
true
true分析:
x == y 表示判断 x 和 y 是否相等,因为 10 不等于 20,所以返回 false。而 x != y 和 x < y 都成立,因此均返回 true。
此外,== 和 != 除了可以比较数字之外,还能直接判断两个字符串的内容是否相同(如 "go" == "go" 返回 true)。
平时写代码时,我们要注意区分单个等号 = 和双等号 ==:单个等号表示赋值,双等号才表示判断相等。好在 Go 语言非常严格,如果我们不小心在条件判断里把 == 写成 =,编译器会直接报错提醒,不用担心留下隐蔽隐患。
Go 逻辑运算符
在 Go 语言中,逻辑运算符用于对布尔值进行组合或取反运算,在实际开发中常与关系运算符配合使用。Go 语言的逻辑运算符共有 3 个,如下表所示。
| 运算符 | 名称 | 说明 |
|---|---|---|
| && | 逻辑与 | 两边都为真才返回 true |
| || | 逻辑或 | 有一边为真就返回 true |
| ! | 逻辑非 | 对布尔值取反(真变假、假变真) |
下面我们通过一个例子,看看这 3 个逻辑运算符是如何配合关系运算使用的。
示例 4:逻辑运算符的使用
package main
import "fmt"
func main() {
a := 20
b := 10
c := 10
r1 := (a < b) && (b == c) // 逻辑与运算
r2 := (a < b) || (b == c) // 逻辑或运算
r3 := !(a < b) // 逻辑非运算
fmt.Println(r1)
fmt.Println(r2)
fmt.Println(r3)
}运行结果如下。
false
true
true分析:
在这个例子中,a < b(即 20 小于 10)不成立,结果为 false;b == c(即 10 等于 10)成立,结果为 true。
因此第 1 个表达式 r1 相当于计算 false && true,按照 “两边都为真才为真” 的规则,结果为 false。第 2 个表达式 r2 相当于计算 false || true,只要有一边为真就返回 true,所以结果为 true。
第 3 个表达式 r3 也就是 !(a < b),它对 false 做了取反操作,因此结果也是 true。
此外,&& 和 || 还具有 “短路求值” 的特性。拿 (a < b) && (b == c) 来说,左边 a < b 已经算出了 false,结果必定为 false,程序会直接跳过右边不再计算。同理,使用 || 时只要左边为 true,也会直接跳过右边。
短路求值在实际开发中非常实用。比如我们要判断除法结果时,通常会写成 b != 0 && a / b > 2。当 b 为 0 时,左边的 b != 0 直接返回 false,右边的 a / b 根本不会执行,这样就巧妙避开了 “除以 0” 导致的程序报错。
Go 位运算符(了解)
在 Go 语言中,位运算符直接对整数在内存中的二进制位(0 和 1)进行操作。常用的位运算符如下表所示。
| 运算符 | 名称 | 说明 |
|---|---|---|
| & | 按位与 | 对应位都为 1 时结果位为 1 |
| | | 按位或 | 对应位含 1 时结果位为 1 |
| ^ | 按位异或 | 对应位不同为 1,相同为 0 |
| << | 左移 | 二进制位左移,右侧空位补 0 |
| >> | 右移 | 二进制位整体向右移动 |
提示: 位运算符通常用于底层协议解析或权限控制,在日常业务开发中用得很少。小伙伴们对下面这个例子简单看一遍有个印象即可,不需要花太多时间深究二进制换算。
示例 5:位运算符的使用
package main
import "fmt"
func main() {
a := 3 // 二进制为 0011
b := 5 // 二进制为 0101
fmt.Println(a & b) // 按位与
fmt.Println(a | b) // 按位或
fmt.Println(a ^ b) // 按位异或
fmt.Println(1 << 3) // 左移 3 位
fmt.Println(8 >> 2) // 右移 2 位
}运行结果如下。
1
7
6
8
2分析:
十进制数 3 用 4 位二进制表示为 0011,十进制数 5 表示为 0101。我们把它们的二进制位逐位对齐比较,前 3 个运算的计算过程如下:
0011 & 0101 -> 0001
0011 | 0101 -> 0111
0011 ^ 0101 -> 0110其中,按位与 a & b 只有最后一位同时为 1,结果为 0001(即十进制 1)。按位或 a | b 的后 3 位都包含 1,结果为 0111(即十进制 7)。按位异或 a ^ b 的中间两位不同,结果为 0110(即十进制 6)。
对于正整数的移位运算来说,每左移 1 位相当于乘以 2,每右移 1 位相当于除以 2。因此 1 << 3 相当于 1 × 2³,结果为 8;而 8 >> 2 相当于 8 ÷ 2²,结果为 2。
Go 赋值运算符
在 Go 语言中,赋值运算符用于将右边表达式的值保存到左边的变量中。除了最基本的等号(=)之外,Go 语言还提供了一系列将算术运算与赋值合并起来的 “复合赋值运算符”,如下表所示。
| 运算符 | 说明 | 等价写法 |
|---|---|---|
| = | 普通赋值 | a = b |
| += | 相加后赋值 | a = a + b |
| -= | 相减后赋值 | a = a - b |
| *= | 相乘后赋值 | a = a * b |
| /= | 相除后赋值 | a = a / b |
| %= | 求余后赋值 | a = a % b |
a += b 其实就是 a = a + b 的简写形式。在实际开发中我们经常会用到这种简写,小伙伴们要熟悉一下,方便阅读和编写代码。
示例 6:使用复合赋值运算符
package main
import "fmt"
func main() {
num := 10
num += 5 // 在 10 的基础上加 5
fmt.Println(num)
num *= 2 // 在 15 的基础上乘 2
fmt.Println(num)
}运行结果如下。
15
30分析:
变量 num 的初始值为 10。对于上面两步复合赋值运算来说,下面 2 种方式是等价的。
// 方式 1(推荐)
num += 5
num *= 2
// 方式 2
num = num + 5
num = num * 2由于程序是从上往下依次执行的,执行完 num += 5 后,num 的值已经变成了 15。接着再执行 num *= 2,就是在 15 的基础上乘以 2,因此最终输出 30。当一行代码里同时包含多种运算符时,它们的计算先后顺序则由运算符优先级决定。
常见问题
1. 为什么 Go 语言没有三元条件运算符(? :)?
在 C、Java 等语言中,常用 max = a > b ? a : b 这种三元运算符来简化条件赋值。但在 Go 语言中,官方明确取消了三元运算符。
这是因为 Go 语言的设计者认为,三元运算符很容易被层层嵌套,写出像 a > b ? (c > d ? x : y) : z 这样绕好几个弯、很难看懂的代码。为了保持代码清晰直观,Go 语言规定所有条件判断统一使用 if 语句来实现。
2. 为什么 Go 语言规定 a++ 必须单独占一行,不能写在表达式里?
如果允许把 a++ 和 ++a 写进算术表达式里,就容易出现像 b = a++ + ++a 这种让人摸不着头脑的代码,不仅容易算错,阅读起来也很费劲。
Go 语言直接把 a++ 和 a-- 设计成独立的语句,要求单独占一行写,从根源上消除了自增自减与其他运算符混在一起带来的歧义。
