算术运算符

Go语言没有前置的++，--，(++a)

比较运算符

用 == 比较数组

• 相同维数且含有相同个数元素的数组才可以比较
• 每个元素都相同的才相等
  举个栗子

这个栗子会报错，编译报错
package operator_test
import "testing"
func TestcompareArray(t *testing.T){
  a := [...] int{1,2,3,4}
  b := [...] int{1,3,2,4}
  c := [...] int{1,2,3,4,5}    // 如果想要编译成功，需要注释这一行
  d := [...] int{1,2,3,4}
  t.Log(a == b)
  t.Log(a == c)    // 如果想要编译成功，需要注释这一行
  t.Log(a == d)
 }

在Go语言中，你不适用的变量需要屏蔽，否则会在编译中报错

逻辑运算符

位运算符

&^按位置零
1 &^ 0 -- 1
1 &^ 1 -- 0
0 &^ 1 -- 0
0 &^ 0 -- 0
右边的操作数的二进制为1，左边的操作数的二进制上不管是任何数，其结果为0
右边的操作数的二进制为0，左边的操作数上不管是任何数，其结果是左边操作数上的值

package main

import "fmt"

func main() {

   var a uint = 60    /* 60 = 0011 1100 */  
   var b uint = 13    /* 13 = 0000 1101 */
   var c uint = 0          

   c = a & b       /* 12 = 0000 1100 */ 
   fmt.Printf("第一行 - c 的值为 %d\n", c )

   c = a | b       /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值为 %d\n", c )

   c = a ^ b       /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值为 %d\n", c )

   c = a << 2     /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值为 %d\n", c )

   c = a >> 2     /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %d\n", c )
}
// 运行结果：
第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

赋值运算符

其他运算符

举个栗子

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );

   /*  & 和 * 运算符实例 */
   ptr = &a    /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a);
   fmt.Printf("*ptr 为 %d\n", *ptr);
}
运行结果：
第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

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

func main() {
   var a int = 4
   var ptr *int
   ptr = &a
   println("a的值为", a);    // 4
   println("*ptr为", *ptr);  // 4
   println("ptr为", ptr);    // 824633794744
}

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