课程名称： Go开发工程师全新版

课程章节： 4-4 运算符和表达式

课程讲师： bobby

课程内容：

算数运算符

• 加：+

• 减：-

• 乘：*

• 除：/

• 取余：%

• 加加：++

  这里的 ++ 相当于在原有的基础上 +1

• 减减：–

  这里的 – 相当于在原有的基础上 -1

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 加：+ 
    fmt.Println(20 + 20)	// 40
    // 加号运算符可以两个字符串相加，表示拼接，但不能相减
    fmt.Println('hello ' + 'world')	// hello world
    
    // 减：-
    fmt.Println(20 - 10) // 10
    
    // 乘：*
    fmt.Println(20 * 10) // 200
    
    // 除：/
    fmt.Println(20 / 10) // 2
    
    // 取余：%
    fmt.Println(20 % 3) // 
    
    // 加加：++
    var a = 0;
	    
    a++ // a++ 和 a += 1、a = a+1 相等
    fmt.Println(a) // 1
    
    // 减减：--
    var b = 1;
	    
    b-- // b-- 和 b -= 1、b = b-1 相等
    fmt.Println(b) // 0
    
}

关系运算符

关系运算符用于判断，得到是 bool 类型

• 大于：>

• 大于等于：>=

• 小于：<

• 小于等于：<=

• 等于：==

  这里的表示等于需要两个 等号，一个等号表示 赋值

• 不等于：!=

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 大于：>
    fmt.Println(20 > 20)  // false，20不大于20，所以返回 false(假)
    
	// 大于等于：>=
    fmt.Println(20 >= 20)  // true，20不大于20，但是 等于 20，所以返回 true(真)
    
	// 小于：<
    fmt.Println(20 < 20)  // false
    
	// 小于等于：<=
    fmt.Println(20 <= 20)  // true，20不小于20，但是 等于 20，所以返回 true(真)
    
	// 等于：==
    fmt.Println(20 == 20)  // true，20等于20
    
	// 不等于：!=
    fmt.Println(20 != 20)  // false，判断20是否不等于20，很明显这里20等于20，所以返回 false(假)
}

逻辑运算符

• 与：&&

  所谓逻辑与运算符。如果两个操作数都非零，则条件变为真

• 或：||

  所谓的逻辑或运算符。如果任何两个操作数是非零，则条件变为真

• 非：!

  所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假

package main

import (
	"fmt"
	"strconv"
)

func main() {
    // 这里 true 表示 真，false 表示 假
	// 与：&&
    fmt.Println(true && false)  // false，有一边不是 true，所以返回 false
    fmt.Println(false && true)  // false，有一边不是 true，所以返回 false
    fmt.Println(true && true)  // true，两边都是 true，所以返回 true
    
	// 或：||
    fmt.Println(false || false)  // false，两边都不是 false 所以返回 false
    fmt.Println(false || true)  // true，有一边是 true，所以返回 true
    
	// 非：!
    fmt.Println(!true)  // false，非真，这里会进行取反 true 反向就是 false，所以返回 false
    fmt.Println(!false)  // true，false取反就是 true
  
}

位运算符

• 与位运算：&

  两个数进行二进制 对比，一位的一位比较，都为 1 时返回 1，其余返回 0

• 或位运算：|

  两个数进行二进制对比，一位的一位比较，一边为 1 时返回 1，其余返回 0

• 异或位运算：^

  两个数进行二进制对比，一位的一位比较，两边都为 1 或 0 时返回 0， 其余返回 1

• 左移运算符：<<

  一个数的 二进制 整体 向左移动 n 位

• 右移运算符：>>

  一个数的 二进制 整体 向右移动 n 位

package main

import (
	"fmt"
	"strconv"
)

func main() {
    var A = 00111100
    var B = 00001101
    
	// 与位运算：&
    fmt.Println(A & B)  // 576，二进制为 00001100
    
	// 或位运算：|
    fmt.Println(A | B)  // 37441,二进制为 00111101
    
	// 异或位运算：^
    fmt.Println(A ^ B)  // 36865，二进制为 00110001
    
	// 左移运算符：<<
    fmt.Println(A << 1)  // 74880
    
	// 右移运算符：>>
    fmt.Println(A >> 1)  // 18720
  
}

赋值运算符

package main

import "fmt"

func main() {
   var a int = 21
   var c int

   c =  a
   fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c )

   c +=  a
   fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )

   c -=  a
   fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )

   c *=  a
   fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )

   c /=  a
   fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )

   c  = 200;

   c <<=  2
   fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %d\n", c )

   c >>=  2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )

   c &=  2
   fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )

   c ^=  2
   fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c )

   c |=  2
   fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c )

}

其他运算符

此处讲解一下什么是地址

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);
}

运算符优先级

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

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

package main

import "fmt"

func main() {
   var a int = 20
   var b int = 10
   var c int = 15
   var d int = 5
   var e int;

   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );  
}

课程收获：
对go 中的 运算符 有一定的了解