为了账号安全,请及时绑定邮箱和手机立即绑定
首页 手记 【金秋打卡】第19天 Go开发工程师全新版 4-4

【金秋打卡】第19天 Go开发工程师全新版 4-4

2022.11.12 22:28 88浏览

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

点击查看更多内容
0人点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
Web前端工程师
手记
粉丝
1
获赞与收藏
0

关注TA,一起探索更多经验知识

同主题相似文章浏览排行榜

风间影月说签约讲师

51篇手记,涉及Java、MySQL、Redis、Spring等方向

进入讨论

Tony Bai 说签约讲师

151篇手记,涉及Go、C、Java、Python等方向

进入讨论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消