首页 > 编程笔记 > Go语言笔记 阅读：14

Go语言运算符的用法和优先级（附带实例）

各个编程语言中的运算符作用基本相同，即在程序运行时执行数学或逻辑运算。

Go语言中包含算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符等 6 种运算符，下面分别讲解这 6 种运算符。

Go语言算术运算符

下表列出了 Go 语言中所有算术运算符及其说明，并且通过示例及其运算结果展示各个算术运算符的使用方法。其中，变量 a、b 和 c 的类型是 int，变量 a 的初始值为 7，变量 b 的初始值为 11。

表 1 Go语言中的算术运算符及其说明
运算符 说明 示例 运算结果
+ 相加 c = a + b 18
- 相减 c = a - b -4
* 相乘 c = a * b 77
/ 相除 c = a / b 0
% 求余 c = a % b 7
++ 自增 a++ 8
-- 自减 a-- 6

Go语言关系运算符

下表列出了 Go 语言中的关系运算符及其说明，并且通过示例及其运算结果展示各个关系运算符的使用方法。其中，变量 a 和 b 的类型是 int，变量 a 的初始值为 7，变量 b 的初始值为 11。

表 2 Go语言中的关系运算符及其说明
运算符 说明 示例 运算结果
== 检查左边值是否等于右边值 fmt.Println(a == b) false
!= 检查左边值是否不等于右边值 fmt.Println(a != b) true
> 检查左边值是否大于右边值 fmt.Println(a > b) false
< 检查左边值是否小于右边值 fmt.Println(a < b) true
>= 检查左边值是否大于或等于右边值 fmt.Println(a >= b) false
<= 检查左边值是否小于或等于右边值 fmt.Println(a <= b) true

Go语言逻辑运算符

下表列出了 Go 语言中的逻辑运算符及其说明，并且通过示例及其运算结果展示各个逻辑运算符的使用方法。其中，有两个操作数（布尔类型的变量或返回布尔类型的值的表达式）a 和 b。

表 3 Go语言中的所有逻辑运算符及其说明
运算符 说明 示例 运算结果
&& 逻辑与运算符：如果操作数 a 和 b 的值都是 true，那么 a && b 的值为 true，否则 a && b 的值为 false var a = true
var b = false
fmt.Println(a && b)		 false
|| 逻辑或运算符：如果操作数 a 和 b 的值有一个是 true，那么 a || b 的值为 true，否则 a || b 的值为 false var a = false
var b = true
fmt.Println(a || b)		 true
! 逻辑非运算符：如果操作数 a 的值为 true，那么 !a 的值为 false，否则为 true var a = false
fmt.Println(!a)		 true

Go语言位运算符

下表列出了 Go 语言中的位运算符及其说明，这些位运算符都是双目运算符。

表 4 Go语言中的位运算符及其说明
运算符 说明
& 按位与运算符
| 按位或运算符
^ 按位异或运算符
<< 左移运算符。左移n位就是乘以2的n次方
>> 右移运算符。右移n位就是除以2的n次方

位运算符“&”、“|”和“^”能够对整数在内存中的二进制位进行操作，操作的结果如下表所示

表 5 位运算符对整数在内存中的二进制位进行操作及其结果
A B A & B A | B A ^ B
0 0 0 0 0
1 0 0 1 1
0 1 0 1 1
1 1 1 1 0

“&”运算符的使用方法是先将两个操作数转换成二进制数，再将两个二进制操作数的最低位对齐（右对齐），然后让两个二进制数的每一位都做按位与运算。若同一位的两个值都为 1，则对应位的结果为 1，否则对应位的结果为 0。

例如，12 和 8 经按位与运算后的结果是 8。运算过程如下： 
  0000 0000 0000 1100  (十进制 12 的二进制数)
& 0000 0000 0000 1000  (十进制 8 的二进制数)
-------------------
  0000 0000 0000 1000  (十进制 8 的二进制数)

“|”运算符的使用方法是先将两个操作数转换成二进制数，再将两个二进制操作数的最低位对齐（右对齐），然后让两个二进制数的每一位都做按位或运算。若同一位的两个值都为 0，则对应位的结果为 0，否则对应位的结果为 1。

例如，4 和 8 经按位或运算后的结果是 12。运算过程如下： 
  0000 0000 0000 0100  (十进制 4 的二进制数)
| 0000 0000 0000 1000  (十进制 8 的二进制数)
-------------------
  0000 0000 0000 1100  (十进制 12 的二进制数)

“^”运算符的使用方法是先将两个操作数转换成二进制数，再将两个二进制操作数的最低位对齐（右对齐），然后让两个二进制数的每一位都做按位异或运算。若同一位的两个值相同，则对应位的结果为 0；若同一位的两个值不同，则对应位的结果为 1。

例如，31 和 22 经按位异或运算后的结果是 9。运算过程如下： 
  0000 0000 0001 1111  (十进制 31 的二进制数)
^ 0000 0000 0001 0010  (十进制 22 的二进制数)
-------------------
  0000 0000 0001 1011  (十进制 9 的二进制数)

位运算符“<<”和“>>”能够对变量进行左移或右移运算，代码如下： 
a := 24
b := -16
fmt.Println("右移两位的结果是：", (a >> 2))
fmt.Println("左移三位的结果是：", (b << 3))
运行结果如下：

24右移2位后的结果是：6
-16左移3位后的结果是：-128

Go语言复合赋值运算符

所谓复合赋值运算符，就是把赋值运算符与其他运算符合并成一个运算符，进而同时实现两种运算符的效果。

Go 语言中的复合赋值运算符及其说明如下表所示：

表 6 Go语言中的复合赋值运算符及其说明
运算符 说明 示例 等价效果
+= 相加结果赋予左侧 a += b; a = a + b;
-= 相减结果赋予左侧 a -= b; a = a - b;
*= 相乘结果赋予左侧 a *= b; a = a * b;
/= 相除结果赋予左侧 a /= b; a = a / b;
%= 取余结果赋予左侧 a %= b; a = a % b;
&= 与结果赋予左侧 a &= b; a = a & b;
|= 或结果赋予左侧 a |= b; a = a | b;
^= 异或结果赋予左侧 a ^= b; a = a ^ b;
<<= 左移结果赋予左侧 a <<= b; a = a << b;
>= 右移结果赋予左侧 a >>= b; a = a >> b;

【实例】使用“短变量声明”的语法格式分别声明并初始化 int 类型的变量 a 和 b；其中，变量 a 的初始值为 7，变量 b 的初始值为 11。分别使用上表中的复合赋值运算符对这两个整数进行运算，代码如下： 
package main

import "fmt"

func main(){
    a := 7  //使用“短变量声明”的语法格式声明并初始化int类型变量a
    b := 11 //使用“短变量声明”的语法格式声明并初始化int类型变量b
    fmt.Println("a+=", a, "的结果是")
    b += a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a-=", a, "的结果是")
    b -= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a*=", a, "的结果是")
    b *= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a/=", a, "的结果是")
    b /= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a%=", a, "的结果是")
    b %= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a&=", a, "的结果是")
    b &= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a|=", a, "的结果是")
    b |= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a^=", a, "的结果是")
    b ^= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a<<=", a, "的结果是")
    b <<= a
    fmt.Println(b)
    b = 11  //修改变量b的值为11
    fmt.Println("a>>=", a, "的结果是")
    b >>= a
    fmt.Println(b)
}
运行结果如下：

a+=7的结果是 18
11+=7的结果是 18
11-=7的结果是 4
11*=7的结果是 77
11/=7的结果是 1
11%=7的结果是 4
11&=7的结果是 3
11|=7的结果是 15
11^=7的结果是 12
11<<=7的结果是 1408
11>>=7的结果是 0

Go语言运算符优先级

运算符的优先级决定表达式中运算执行的先后顺序。通常优先级由高到低的顺序依次是：自增和自减运算、算术运算、比较运算、逻辑运算及赋值运算。

如果两个运算符具有相同的优先级，那么左边的表达式比右边的表达式先被处理。

下表显示 Go 语言中各个运算符的优先级：

表 6 Go语言中各个运算符的优先级
优先级 描述 运算符
1 括号 ()
2 正负号 +、-
3 单目运算 ++、--、!
4 乘、除、求余 *、/、%
5 加、减 +、-
6 位移运算 >>、<<
7 关系运算 <、>、>=、<=
8 比较是否相等 ==、!=
9 按位与运算 &
10 按位异或运算 ^
11 按位或运算 |
12 逻辑与运算 &&
13 逻辑或运算 ||
14 赋值运算符 =、+=、-=、*=、/=、%=、>>=、<<=、&=、^=、|=

相关文章