运算符

  在Go中运算符包括，逻辑运算符、 算术运算符、位运算符、接收运算符。根据运算符是不是要连接两个变量，我们把运算符分成一元运算符和二元运算符，一元运算符包括：

  1.  +        正号            var x int =-1; +x  --->  -1
  2.  -      负号            var x int =-1; -x  --->   1
  3.  !      逻辑非          !真     -----> 假      
  4.  ++     连加            与C语言不一样，++ 和 -- 操作只可以当成一个语句来使用。
  5.  --     连减            我在下面详细讲解这个
  6.  ^      按位异或
  7.  *      指针            *p表示 p所代表的数值的指针
  8.  &      地址操作符       &a 表示a的内存地址
  9.  <-     接收操作符       <-ch 从通道ch中取值

二元运算符包括：

  1.  +      加法             a+b
  2.  -      减法             a-b
  3.  *      乘法             a*b
  4.  /      除法             a/b a、b为整数的时候，b不可以为0，如果编译器可以检查到会显
  5.                          示division by zero a、b为float类型的时候， b==0，会得到无穷大，显示为+Inf
  6.  %      取模             10%3=1，计算余数
  7.  ||     逻辑或
  8.  &&     逻辑与
  9.  ==     判断等于
  10.  !=     判断不等于
  11.  <      判断小于
  12.  <=     判断小于等于
  13.  >      判断大于
  14.  >=     判断大于等于
  15.  <<     二进制左移位运算符   这个见下面的例子
  16.  >>     二进制右移位运算符  
  17.  &      按位与  
  18.  &^     按位清除          10 &^ 3  ---> 8

注意一件事情，就是Go不支持三元运算符，虽然笔者认为C语言里面的三元运算符使用起来很帅也很方便，但是确实对有些代码容易产生逻辑错误。

1）逻辑运算符

逻辑运算符||，&&，!代表逻辑或、与、非，==、!=、<、<=、>、>=是判断运算符。除了！是一元运算符以外都是二元运算符。二元逻辑运算符的两侧是布尔值或者是产生布尔值的表达式。此处千万注意，Go语言不同于C语言，C语言的布尔值是0和非0，在Go语言里面使用bool来表示布尔类型，值只能是true或者false，也就是“真”和“假”。

2）算数运算符

算数运算符包括：+、-、、/、%、++、—
用程序简单介绍一下+、-、、/、% 源程序

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var (
  7.         a, b int     = 3, 2
  8.         c    int     = 8
  9.         x, y float64 = 3.2, 8.0
  10.         z    float64 = 16.0
  11.     )
  12.     fmt.Printf("3 + 2 =%2d\r\n", a+b)
  13.     fmt.Printf("3 - 2 =%2d\r\n", a-b)
  14.     fmt.Printf("2 * 8 =%2d\r\n", b*c)
  15.     fmt.Printf("8 / 2 =%2d\r\n", c/b)
  16.     fmt.Printf("8 %% 2 =%2d\r\n", c%a)
  17.     fmt.Printf("3.2 + 8.0 =%4.2f\r\n", x+y)
  18.     fmt.Printf("3.2 - 8.0 =%4.2f\r\n", x-y)
  19.     fmt.Printf("3.2 * 8.0 =%4.2f\r\n", x*y)
  20.     fmt.Printf("16.0 / 8.0 =%4.2f\r\n", z/y)
  21.     //fmt.Println(z % x) //这个是错误的语句，取模只能是在整数里面
  23. }

结果
下面重点讲解一下++、—

在我的工作经验里面，一般 like C的语言，一般都支持++、—，而且都是支持i++,++i这种形式，也支持a=i++这种形式，唯有Go不同。首先，Go不支持++i、—i这种形式；其次，Go不支持这种形式的赋值。这么做是有好处的，所有学习C的人，几乎都遇到过，++i的值是多少的困惑，现在使用Go，你将完全不会遇到这个问题。

  1.     var i int =0 
  2.     i++               //合法
  3.     ++i                  //非法
  4.     i--               //合法
  5.     --i               //非法
  6.     a:=i++            //非法
  7.     fmt.Println(i++)  //非法
运算符的优先级
  1. 优先级           运算符
  2. 5             *  /  %  <<  >>  &  &^
  3. 4             +  -  |  ^
  4. 3             ==  !=  <  <=  >  >=
  5. 2             &&
  6. 1             ||

3）位运算符

& 、 | 、 ^ 、&^ 源程序

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var (
  7.         a, b int = 101, 142
  8.     )
  9.     c := a & b //按位与
  10.     fmt.Printf("a & b = %4d & %4d ===> %08b  & %08b ====>%4d 换成二进制是：%08b\r\n", a, b, a, b, c, c)
  12.     d := a | b //按位或
  13.     fmt.Printf("a | b = %4d & %4d ===> %08b  | %08b ====>%4d 换成二进制是：%08b\r\n", a, b, a, b, d, d)
  15.     e := a ^ b //按位异或
  16.     fmt.Printf("a ^ b = %4d & %4d ===> %08b  | %08b ====>%4d 换成二进制是：%08b\r\n", a, b, a, b, e, e)
  18.     f := a &^ b //按位清除，这个比较特殊，就是以后面的数字为准对前面的数字的二进制进行相应的清零操作。
  19.     //如果后面的数字的某个二进制位是1，那么前面数字相应的二进制位就变成0，反之保持原数不变。
  20.     fmt.Printf("a &^ b = %4d & %4d ===> %08b  | %08b ====>%4d 换成二进制是：%08b\r\n", a, b, a, b, f, f)
  21. }

结果

位移运算符

左位移<<、右位移>>源程序

  1. package main
  3. import "fmt"
  5. func main() {
  7.     fmt.Printf(" 8 << 2 = %2d\r\n", 8<<2)
  8.     fmt.Printf(" 2 << 5 = %2d\r\n", 2<<5)
  9.     fmt.Printf("64 >> 3 = %2d\r\n", 64>>3)
  10.     fmt.Printf("64 >> 6 = %2d\r\n", 64>>6)
  11.     fmt.Printf("64 >> 7 = %2d\r\n", 64>>7) //64换算成二进制是01000000，右位移7位就变成0
  12. }

结果

左位移N位，右侧空白部分使用 0 填充，相当于每位移一位在源数的基础上乘以2，左位移N位，相当于乘以2的N次幂。同理，右位移N位，左侧空白部分使用 0 填充，相当于每位移一位在源数的基础上除以2，右位移N位，相当于除以2的N次幂。不过，位移次数超过原数的二进制长度，结果就是0。