【金秋打卡】第19天 Go开发工程师全新版 4-4-原创手记-慕课网

课程名称： 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 位

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

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
  
}

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	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

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 )

}

其他运算符

此处讲解一下什么是地址

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量

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	逗号运算符	,	从左到右
2	赋值运算符	=、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、\|=	从右到左
3	逻辑或	\|\|	从左到右
4	逻辑与	&&	从左到右
5	按位或	\|	从左到右
6	按位异或	^	从左到右
7	按位与	&	从左到右
8	相等/不等	==、!=	从左到右
9	关系运算符	<、<=、>、>=	从左到右
10	位移运算符	<<、>>	从左到右
11	加法/减法	+、-	从左到右
12	乘法/除法/取余	*（乘号）、/、%	从左到右
13	单目运算符	!、*（指针）、& 、++、–、+（正号）、-（负号）	从右到左
14	后缀运算符	( )、[ ]、->	从左到右

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

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 中的运算符有一定的了解
图片描述