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

    关系运算符

    2. import "fmt"
    3. func main() {
    4.    var a int = 21
    5.    var b int = 10
    6.    if( a == b ) {
    7.       fmt.Printf("第一行 - a 等于 b\n" )
    8.    } else {
    9.       fmt.Printf("第一行 - a 不等于 b\n" )
    10.    }
    11.    if ( a < b ) {
    12.       fmt.Printf("第二行 - a 小于 b\n" )
    13.    } else {
    14.       fmt.Printf("第二行 - a 不小于 b\n" )
    15.    } 
    17.    if ( a > b ) {
    18.       fmt.Printf("第三行 - a 大于 b\n" )
    19.    } else {
    20.       fmt.Printf("第三行 - a 不大于 b\n" )
    21.    }
    22.    /* 让我们改变a和b的值 */
    23.    a = 5
    25.       fmt.Printf("第四行 - a 小于等于 b\n" )
    26.    }
    27.    if ( b >= a ) {
    28.       fmt.Printf("第五行 - b 大于等于 a\n" )
    29.    }
    30. }

    下表列出了所有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语言的逻辑运算符。假定 A 值为 True，B 值为 False d。

    位运算符

    1. package main
    2. import "fmt"
    3. func main() {
    5.   var a uint = 60    /* 60 = 0011 1100 */  
    6.   var b uint = 13    /* 13 = 0000 1101 */
    7.   var c uint = 0          
    9.   c = a & b       /* 12 = 0000 1100 */ 
    10.   fmt.Printf("第一行 - c 的值为 %d\n", c ) // 第一行 - c 的值为 12
    12.   c = a | b       /* 61 = 0011 1101 */
    13.   fmt.Printf("第二行 - c 的值为 %d\n", c )  // 第二行 - c 的值为 61
    15.   c = a ^ b       /* 49 = 0011 0001 */
    17.   c = a << 2     /* 240 = 1111 0000 */
    18.   fmt.Printf("第四行 - c 的值为 %d\n", c ) // 第四行 - c 的值为 240
    20.   c = a >> 2     /* 15 = 0000 1111 */
    21.   fmt.Printf("第五行 - c 的值为 %d\n", c )  // 第五行 - c 的值为 15
    22. }

    Go 语言支持的位运算符如下表所示。假定 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

    其他运算符

    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
    9.   /* 运算符实例 */
    10.   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a ); // 第 1 行 - a 变量类型为 = int
    11.   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); // 第 2 行 - b 变量类型为 = int32
    12.   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c ); // 第 3 行 - c 变量类型为 = float32
    14.   /*  & 和 * 运算符实例 */
    15.   ptr = &a    /* 'ptr' 包含了 'a' 变量的地址 */
    16.   fmt.Printf("a 的值为  %d\n", a);   // a 的值为  4
    运算符 描述 实例
    & 返回变量存储地址 &a; 将给出变量的实际地址。
    * 指针变量。 *a; 是一个指针变量

    运算符优先级

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