运算符用于在程序运行时执行数学或逻辑运算,Go 语言内置的运算符有：

  • 算术运算符
  • 赋值运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 其他运算符

算术运算符

下表列出了所有Go语言的算术运算符,假定 A 值为 10，B 值为 20

运算符 描述 实例 运算结果
+ 相加 A + B 30
- 相减 A - B -10
* 相乘 A * B 200
/ 相除 A / B 0
% 求余 A % B 10
++ 自增 A++ 11
— 自减 B— 19 
  1. package main
  2. import "fmt"
  4. func main() {
  5.     var a int = 10
  6.     var b int = 20
  7.     var c int
  9.     c = a + b
  10.     fmt.Printf("第一行: c的值为 %d\n", c ) //30
  12.     c = a - b
  13.     fmt.Printf("第二行: c的值为 %d\n", c ) //-10
  15.     c = a * b
  16.     fmt.Printf("第三行: c的值为 %d\n", c ) //200
  18.     c = a / b
  19.     fmt.Printf("第四行: c的值为 %d\n", c ) //0
  21.     c = a % b
  22.     fmt.Printf("第五行: c的值为 %d\n", c ) //10
  24.     a++
  25.     fmt.Printf("第六行: a的值为 %d\n", a ) //11
  27.     b=20
  28.     b--
  29.     fmt.Printf("第七行: b的值为 %d\n", b ) //19
  30. }

Go 的自增，自减只能作为表达式使用，而不能用于赋值语句

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var a int =10
  6.     a++      // 这是允许的，类似 a = a + 1
  7.     a--      
  8.     a = a++  // 这是不允许的，会出现变异错误 syntax error: unexpected ++ at end of statement
  9.     fmt.Println(a)
  10. }

赋值运算符

下表列出了所有Go语言的赋值运算符

运算符 描述 实例 等价与
= 简单的赋值运算符
将一个表达式的值赋给一个左值		 C = A + B 将 A + B 表达式结果赋值给 C
:= 海象运算符
+= 相加后再赋值 C += A C = C + A
-= 相减后再赋值 C -= A C = C - A
*= 相乘后再赋值 C *= A C = C * A
/= 相除后再赋值 C /= A C = C / A
%= 求余后再赋值 C %= A C = C % A
<<= 左移后赋值 C <<= 2 C = C << 2
>>= 右移后赋值 C >>= 2 C = C >> 2
&= 按位与后赋值 C &= 2 C = C & 2
^= 按位异或后赋值 C ^= 2 C = C ^ 2
|= 按位或后赋值 C |= 2 C = C | 2 
  1. package main
  2. import "fmt"
  3. func main() {
  4.    var a int = 21
  5.    var c int
  6.    c =  a
  7.    fmt.Printf("第1行:  =  运算符实例，c 值为 = %d\n", c )
  8.    c +=  a
  9.    fmt.Printf("第2行:  += 运算符实例，c 值为 = %d\n", c )
  10.    c -=  a
  11.    fmt.Printf("第3行:  -= 运算符实例，c 值为 = %d\n", c )
  12.    c *=  a
  13.    fmt.Printf("第4行:  *= 运算符实例，c 值为 = %d\n", c )
  14.    c /=  a
  15.      fmt.Printf("第5行:  /= 运算符实例，c 值为 = %d\n", c )
  17.    c  = 200; 
  18.    c <<=  2
  19.    fmt.Printf("第6行:  <<= 运算符实例，c 值为 = %d\n", c )
  20.    c >>=  2
  21.    fmt.Printf("第7行:  >>= 运算符实例，c 值为 = %d\n", c )
  22.    c &=  2
  23.    fmt.Printf("第8行:  &= 运算符实例，c 值为 = %d\n", c )
  24.    c ^=  2
  25.    fmt.Printf("第9行:  ^= 运算符实例，c 值为 = %d\n", c )
  26.    c |=  2
  27.    fmt.Printf("第0行:  = 运算符实例，c 值为 = %d\n", c )
  28. }
  29. /* 
  30. 第1行:  =  运算符实例，c 值为 = 21
  31. 第2行:  += 运算符实例，c 值为 = 42
  32. 第3行:  -= 运算符实例，c 值为 = 21
  33. 第4行:  *= 运算符实例，c 值为 = 441
  34. 第5行:  /= 运算符实例，c 值为 = 21
  35. 第6行:  <<= 运算符实例，c 值为 = 800
  36. 第7行:  >>= 运算符实例，c 值为 = 200
  37. 第8行:  &= 运算符实例，c 值为 = 0
  38. 第9行:  ^= 运算符实例，c 值为 = 2
  39. 第0行:  = 运算符实例，c 值为 = 2
  40. */

关系运算符

下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20

运算符 描述 实例 运行结果

==

| 检查两个值是否相等
如果相等返回 True 否则返回 False | A == B | False | |

!=

| 检查两个值是否不相等
如果不相等返回 True 否则返回 False | A != B | True | |

>

| 检查左边值是否大于右边值
如果是返回 True 否则返回 False | A > B | False | |

<

| 检查左边值是否小于右边值

如果是返回 True 否则返回 False | A < B | True | |

>=

| 检查左边值是否大于等于右边值
如果是返回 True 否则返回 False | A >= B | False | |

<=

| 检查左边值是否小于等于右边值
如果是返回 True 否则返回 False | A <= B | True | | ~~ ? : ~~ | Go语言中无 三元表达式 | | |

  1. package main
  2. import "fmt"
  4. func main() {
  5.    var a int = 10
  6.    var b int = 20
  8.    if( a == b ) {
  9.       fmt.Printf("第一行: a等于b\n" )
  10.    } else {
  11.       fmt.Printf("第一行: a不等于b\n" )
  12.      }
  14.    if ( a < b ) {
  15.       fmt.Printf("第二行: a小于b\n" )
  16.    } else {
  17.       fmt.Printf("第二行: a不小于b\n" )
  18.    } 
  20.    if ( a > b ) {
  21.       fmt.Printf("第三行: a大于b\n" )
  22.    } else {
  23.       fmt.Printf("第三行: a不大于b\n" )
  24.    }
  26.    if ( a <= b ) {
  27.       fmt.Printf("第四行: a小于等于b\n" )
  28.    }
  29.    if ( b >= a ) {
  30.       fmt.Printf("第五行: b大于等于a\n" )
  31.    }
  32. }
  34. /* 
  35. 第一行: a不等于b
  36. 第二行: a小于b
  37. 第三行: a不大于b
  38. 第四行: a小于等于b
  39. 第五行: b大于等于a
  40. */

逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False

运算符 描述 实例 结果
&& 逻辑与 (and)
如果两边的操作数都是 True，则条件 True，否则为 False		 A && B False
|| 逻辑或 (or)
如果两边的操作数有一个 True，则条件 True，否则为 False		 A || B) True
! 逻辑非 (not)
如果条件为 True，则逻辑 NOT 条件 False，否则为 True		 !(A && B) True 
  1. package main
  2. import "fmt"
  4. func main() {
  5.    var a bool = true
  6.    var b bool = false
  7.    if ( a && b ) {
  8.       fmt.Printf("第一行: 条件为 true\n" )
  9.    }
  10.    if ( a || b ) {
  11.       fmt.Printf("第二行: 条件为 true\n" )
  12.      }
  14.    /* 修改 a 和 b 的值 */
  15.    a = false
  16.    b = true
  17.    if ( a && b ) {
  18.       fmt.Printf("第三行: 条件为 true\n" )
  19.    } else {
  20.       fmt.Printf("第三行: 条件为 false\n" )
  21.    }
  22.    if ( !(a && b) ) {
  23.       fmt.Printf("第四行: 条件为 true\n" )
  24.    }
  25. }
  27. /* 
  28. 第二行: 条件为 true
  29. 第三行: 条件为 false
  30. 第四行: 条件为 true 
  31. */

位运算符

位运算符对整数在内存中的二进制位进行操作,下表列出了位运算符 & | ^ << >>的功能 以下涉及到的运算全部都是假定 A = 60; B = 13

运算符 描述 实例 运行结果
& 按位与运算符”&”是双目运算符
其功能是参与运算的两数各对应的二进位相与		 A & B 12
二进制 0000 1100
| 按位或运算符”|”是双目运算符
其功能是参与运算的两数各对应的二进位相或		 A | B 61
二进制 0011 1101
^ 按位异或运算符”^”是双目运算符
其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1		 A ^ B 49
二进制 0011 0001
<< 左移运算符”<<”是双目运算符。左移n位就是乘以2的n次方
其功能把”<<”左边的运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0		 A << 2 240
二进制 1111 0000
>> 右移运算符”>>”是双目运算符。右移n位就是除以2的n次方
其功能是把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数		 A >> 2 15
二进制 0000 1111
p q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0
A B A&B A|B A^B
0011 1100 0000 1101 0000 1100 0011 1101 0011 0001
对应的十进制整数
60 13 12 61 49 
  1. package main
  2. import "fmt"
  4. func main() {
  6.    var a uint = 60      // 60 = 0011 1100  
  7.    var b uint = 13      // 13 = 0000 1101
  8.    var c uint = 0          
  10.    c = a & b       // 12 = 0000 1100 
  11.    fmt.Printf("第一行: c 的值为 %d\n", c )
  13.    c = a | b       // 61 = 0011 1101
  14.    fmt.Printf("第二行: c 的值为 %d\n", c )
  16.    c = a ^ b       // 49 = 0011 0001
  17.    fmt.Printf("第三行: c 的值为 %d\n", c )
  19.    c = a << 2     // 240 = 1111 0000
  20.    fmt.Printf("第四行: c 的值为 %d\n", c )
  22.    c = a >> 2     // 15 = 0000 1111
  23.    fmt.Printf("第五行: c 的值为 %d\n", c )
  24. }
  27. /* 
  28. 第一行: c 的值为 12
  29. 第二行: c 的值为 61
  30. 第三行: c 的值为 49
  31. 第四行: c 的值为 240
  32. 第五行: c 的值为 15
  33. */

指针运算符

下表列出了Go语言的其他运算符

运算符 描述 实例
& 返回变量存储地址 &a

将给出变量的实际地址
* 指针变量 *a

是一个指针变量		 
  1. package main
  2. import "fmt"
  3. func main() {
  4.    var a int = 4
  5.    var b int32
  6.    var c float32
  7.    var ptr *int
  8.    /* 运算符实例 */
  9.    fmt.Printf("第1行: a变量类型为 = %T\n", a );
  10.    fmt.Printf("第2行: b变量类型为 = %T\n", b );
  11.    fmt.Printf("第3行: c变量类型为 = %T\n\n", c );
  13.    /*  & 和 * 运算符实例 */
  14.    ptr = &a     /* 'ptr' 包含了 'a' 变量的地址 */
  15.      fmt.Printf("a的值为 %d\n", a);
  16.    fmt.Printf("ptr的值为 %d\n", ptr);
  17.    fmt.Printf("*ptr为 %d\n", *ptr);
  18. }
  19. /* 
  20. 第1行: a变量类型为 = int
  21. 第2行: b变量类型为 = int32
  22. 第3行: c变量类型为 = float32
  24. a的值为 4
  25. ptr的值为 824633819264
  26. *ptr为 4
  27. */

指针变量 * 和地址值 & 的区别*
指针变量保存的是一个地址值，会分配独立的内存来存储一个整型数字。当变量前面有 标识时，才等同于 & 的用法，否则会直接输出一个整型数字

  1. package main
  2. import "fmt"
  4. func main() {
  5.    var a int = 4
  6.    var ptr *int
  7.    ptr = &a
  8.    fmt.Println("a的值为", a);    // 4
  9.    fmt.Println("*ptr为", *ptr);  // 4
  10.    fmt.Println("ptr为", ptr);    // 0xc000018080
  11. }

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

优先级 运算符
5 * / % << >> & &^
4 + - | ^
3 == != < <= > >=
2 &&
1 ||

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

  1. package main
  3. import "fmt"
  5. func main() {
  6.    var a int = 20
  7.    var b int = 10
  8.    var c int = 15
  9.    var d int = 5
  10.    var e int;
  12.    e = (a + b) * c / d;      // ( 30 * 15 ) / 5
  13.    fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );
  15.    e = ((a + b) * c) / d;    // (30 * 15 ) / 5
  16.    fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );
  18.    e = (a + b) * (c / d);   // (30) * (15/5)
  19.    fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );
  21.    e = a + (b * c) / d;     //  20 + (150/5)
  22.    fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );  
  23. }
  25. /* 
  26. (a + b) * c / d 的值为 : 90
  27. ((a + b) * c) / d 的值为  : 90
  28. (a + b) * (c / d) 的值为  : 90
  29. a + (b * c) / d 的值为  : 50
  30.  */