Go 运算符

在 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-- 设计成独立的语句,要求单独占一行写,从根源上消除了自增自减与其他运算符混在一起带来的歧义。

上一篇:

下一篇:

给站长反馈

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

邮箱:lvyenet@vip.qq.com

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