Go 语言中的运算符
本文主要介绍 Go语言中的各种运算符的使用以及其优先级的比较。Go 语言中运算符分为下面几大类:
- 算数运算符;
- 关系运算符;
- 逻辑运算符;
- 位运算符;
- 复制运算符。
下面我们就来一一看下这几种运算符如何使用。
1. Go 语言的算数运算符
Go语言中的算数运算符如表所示:
| 运算符 | 结合性 | 描述 |
|---|---|---|
| + | 从左到右 | 运算符左边的实体加上右边的实体 |
| - | 从左到右 | 运算符左边的实体减去右边的实体 |
| * | 从左到右 | 运算符左边的实体乘以右边的实体 |
| / | 从左到右 | 运算符左边的实体除以右边的实体 |
| % | 从左到右 | 运算符左边的实体对右边的实体取余 |
| ++ | 从右到左 | 左边的变量使用后自加一 |
| – | 从右到左 | 左边的变量使用后自减一 |
代码示例:
代码块
- 1
package main - 2
- 3
import ( - 4
"fmt" - 5
) - 6
- 7
func main() { - 8
var a = -7 - 9
var b = 4 - 10
- 11
fmt.Println("a + b =", a+b) - 12
fmt.Println("a - b =", a-b) - 13
fmt.Println("a * b =", a*b) - 14
fmt.Println("a / b =", a/b) - 15
fmt.Println("a % b =", a%b) - 16
- 17
//++和--只能独立为一条语句使用 - 18
a++ - 19
fmt.Println("a++:", a) - 20
b-- - 21
fmt.Println("b--:", b) - 22
}
执行结果:

2. Go 语言的关系运算符
Go语言中的关系运算符如表所示:
| 运算符 | 结合性 | 描述 |
|---|---|---|
| == | 从左到右 | 左右两边实体相等运算结果为true,否则为false |
| != | 从左到右 | 左右两边实体不等运算结果为true,否则为false |
| >= | 从左到右 | 左边的实体大于或等于右边运算结果为true,否则为false |
| > | 从左到右 | 左边的实体大于右边运算结果为true,否则为false |
| <= | 从左到右 | 左边的实体小****于或等于右边运算结果为true,否则为false |
| < | 从左到右 | 左边的实体小于右边运算结果为true,否则为false |
代码示例:
代码块
- 1
package main - 2
- 3
import ( - 4
"fmt" - 5
) - 6
- 7
func main() { - 8
var a = -7 - 9
var b = 4 - 10
- 11
fmt.Println("a == b :", a == b) - 12
fmt.Println("a != b :", a != b) - 13
fmt.Println("a >= b :", a >= b) - 14
fmt.Println(" a > b :", a > b) - 15
fmt.Println("a <= b :", a <= b) - 16
fmt.Println(" a < b :", a < b) - 17
}
执行结果:

3. Go 语言的逻辑运算符
Go语言中的逻辑运算符如表所示:
| 运算符 | 结合性 | 描述 |
|---|---|---|
| && | 从左到右 | 左右实体均为 true 运算结果为 true ,否则为 false |
| || | 从左到右 | 左右实体均为 false 运算结果为 false ,否则为 true |
| ! | 从右到左 | 右边实体为 false 运算结果为 true ,否则为 false |
代码示例:
代码块
- 1
package main - 2
- 3
import ( - 4
"fmt" - 5
) - 6
- 7
func main() { - 8
var a = true - 9
var b = false - 10
- 11
fmt.Println("a && b :", a && b) - 12
fmt.Println("a || b :", a || b) - 13
fmt.Println(" !a :", !a) - 14
}
运算结果:

4. Go 语言的位运算符
Go 语言的位运算符如表所示:
| 运算符 | 结合性 | 描述 |
|---|---|---|
| & | 从左到右 | 按位与 |
| | | 从左到右 | 按位或 |
| ^ | 从左到右 | 按位异或 |
| << | 从左到右 | 左位移 |
| >> | 从左到右 | 右位移 |
代码示例:
代码块
- 1
package main - 2
- 3
import ( - 4
"fmt" - 5
) - 6
- 7
func main() { - 8
var a = 28 //0001 1100 - 9
var b = 99 //0110 0011 - 10
- 11
fmt.Println(" a & b :", a&b) //0 : 0000 0000 - 12
fmt.Println(" a | b :", a|b) //127 : 0111 1111 - 13
fmt.Println(" a ^ b :", a^b) //127 : 0111 1111 - 14
fmt.Println("a >> 2 :", a>>2) //7 : 0000 0111 - 15
fmt.Println("b << 1 :", b<<1) //198 : 1100 0110 - 16
}
执行结果:

5.Go 语言的赋值运算符
Go语言赋值运算符如下表所示:
| 运算符 | 结合性 | 描述 |
|---|---|---|
| = | 从右到左 | 将左边的实体赋值给右边的变量 |
| += | 从右到左 | 将右边的变量与左边的实体进行加运算之后赋值给右边的变量 |
| -= | 从右到左 | 将右边的变量与左边的实体进行减****运算之后赋值给右边的变量 |
| *= | 从右到左 | 将右边的变量与左边的实体进行乘运算之后赋值给右边的变量 |
| /= | 从右到左 | 将右边的变量与左边的实体进行除运算之后赋值给右边的变量 |
| %= | 从右到左 | 将右边的变量与左边的实体进行取余运算之后赋值给右边的变量 |
| >>= | 从右到左 | 将右边的变量与左边的实体进行右位移运算之后赋值给右边的变量 |
| <<= | 从右到左 | 将右边的变量与左边的实体进行左位移运算之后赋值给右边的变量 |
| &= | 从右到左 | 将右边的变量与左边的实体进行与运算之后赋值给右边的变量 |
| |= | 从右到左 | 将右边的变量与左边的实体进行或运算之后赋值给右边的变量 |
| ^= | 从右到左 | 将右边的变量与左边的实体进行异或运算之后赋值给右边的变量 |
代码示例:
代码块
- 1
package main - 2
- 3
import ( - 4
"fmt" - 5
) - 6
- 7
func main() { - 8
var a = 28 - 9
var b = 99 - 10
a = b - 11
fmt.Println(" a = b :", a) - 12
a = 28 - 13
a += b - 14
fmt.Println(" a += b :", a) - 15
a = 28 - 16
a -= b - 17
fmt.Println(" a -= b :", a) - 18
a = 28 - 19
a *= b - 20
fmt.Println(" a *= b :", a) - 21
a = 28 - 22
a /= 2 - 23
fmt.Println(" a /= 2 :", a) - 24
a = 28 - 25
b %= 1 - 26
fmt.Println(" b %= 1 :", a) - 27
a = 28 - 28
a &= b - 29
fmt.Println(" a &= b :", a) - 30
a = 28 - 31
a |= b - 32
fmt.Println(" a |= b :", a) - 33
a = 28 - 34
a ^= b - 35
fmt.Println(" a ^= b :", a) - 36
a = 28 - 37
a >>= 2 - 38
fmt.Println("a >>= 2 :", a) - 39
a = 28 - 40
b <<= 1 - 41
fmt.Println("b <<= 1 :", a) - 42
}
执行结果:

6. 优先级
下表为各运算符的优先级示图,优先级从高到低:
| 优先级 | 类别 | 运算符 |
|---|---|---|
| 1 | 括号运算符 | () |
| 2 | 单目运算符 | !、++、– |
| 3 | 算数运算符 | *、/、% |
| 4 | +、- | |
| 5 | 位移运算符 | >>、<< |
| 6 | 关系运算符 | <、<=、>、>= |
| 7 | ==、!= | |
| 8 | 按位与 | & |
| 9 | 按位异或 | ^ |
| 10 | 按位或 | | |
| 11 | 逻辑与 | && |
| 12 | 逻辑或 | || |
| 13 | 赋值运算符 | =、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、|= |
代码示例:
代码块
- 1
package main - 2
- 3
import ( - 4
"fmt" - 5
) - 6
- 7
func main() { - 8
var a = 28 - 9
var b = 99 - 10
- 11
fmt.Println(" a + b * 2 =", a+b*2) //乘法优先级较高,先执行乘法 - 12
fmt.Println("(a + b) * 2 =", (a+b)*2) //括号优先级最高,先执行括号中的运算 - 13
}
执行结果:

7. 小结
Go 语言的运算符一般分为算数运算符、关系运算符、逻辑运算符、位运算符以及赋值运算符四大类。在使用过程中如果记不清楚运算符的优先级,可以使用特殊的运算符——括号运算符(),其优先级最高,使用它就可以随心所欲的控制优先级了。
文章来源于网络,侵删!
