扫码订阅《 》或入驻星球,即可阅读文章!

GOLANG ROADMAP

阅读模式

  • 沉浸
  • 自动
  • 日常
首页
Go友会
  • 城市
  • 校园
Go学院
  • Go小课
  • Go小考
  • Go实战
  • 精品课
Go求职
  • 求职辅导🔥
  • Offer收割社群
  • 企业题库
  • 面试宝典
Go宝典
  • 在线宝典
  • B站精选
  • 推荐图书
  • 每日博文
Go仓库
实验区
  • Go周边
  • Go下载
  • Go月刊
消息
更多
  • 用户中心

    • 我的信息
    • 推广返利
  • 玩转星球

    • 星球介绍
    • 角色体系
    • 星主权益
  • 支持与服务

    • 联系星主
    • 成长记录
    • 常见问题
    • 吐槽专区
  • 合作交流

    • 渠道合作
    • 课程入驻
    • 友情链接
author-avatar

GOLANG ROADMAP


首页
Go友会
  • 城市
  • 校园
Go学院
  • Go小课
  • Go小考
  • Go实战
  • 精品课
Go求职
  • 求职辅导🔥
  • Offer收割社群
  • 企业题库
  • 面试宝典
Go宝典
  • 在线宝典
  • B站精选
  • 推荐图书
  • 每日博文
Go仓库
实验区
  • Go周边
  • Go下载
  • Go月刊
消息
更多
  • 用户中心

    • 我的信息
    • 推广返利
  • 玩转星球

    • 星球介绍
    • 角色体系
    • 星主权益
  • 支持与服务

    • 联系星主
    • 成长记录
    • 常见问题
    • 吐槽专区
  • 合作交流

    • 渠道合作
    • 课程入驻
    • 友情链接
  • 尚硅谷Go语言核心编程教程

    • 课程说明
    • 第1章 GOLANG 开山篇
    • 第2章 GOLANG 的概述
    • 第3章 GOLANG 变量
    • 第4章 运算符
    • 第5章 程序流程控制
    • 第6章 函数、包和错误处理
    • 第7章 数组与切片
    • 第8章 排序和查找
    • 第9章 map
    • 第10章 面向对象编程 ( 上 )
    • 第11章 面向对象编程 ( 下 )
    • 第12章 项目1:家庭收支记账软件项目
    • 第13章 项目2:客户信息关系系统
    • 第14章 文件操作
    • 第15章 单元测试
    • 第16章 goroutine和channel
    • 第17章 反射
    • 第18章 TCP 编程
    • 第19章 REDIS 的使用
    • 第20章 数据结构

扫码订阅《 》或入驻星球,即可阅读文章!

第4章 运算符


GOLANG ROADMAP

# 4.1 运算符的基本介绍

【点击观看视频】 运算符基本介绍

运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等

1 ) 算术运算符

2 ) 赋值运算符

3 ) 比较运算符/关系运算符

4.) 逻辑运算符

5 ) 位运算符

6 ) 其它运算符

# 4.2 算术运算符

【点击观看视频】 算术运算符基本使用

算术运算符是对数值类型的变量进行运算的,比如:加减乘除。在Go程序中使用的非常多

# 4.2.1 算术运算符的一览表

运算符 运算 范例 结果
+ 正号 +3 3
- 负号 -4 -4
+ 加 5+5 10
- 减 6-4 2
* 乘 3*4 12
/ 除 5/5 1
% 取模(取余) 7%5 2
++ 自增 a=2 a++ a=3
-- 自减 a=2 a-- a=1
+ 字符串相加 "he"+"llo" "hello"

# 4.2.2 案例演示

  • 案例演示算术运算符的使用。

    +,-,*,/,%,++,-- , 重点讲解 /、%

    自增:++

    自减:--

  • 演示 / 的使用的特点

    package main
    import (
    	"fmt" 
    )
    
    func main() {
    
    	//重点讲解 /、%
    	//说明,如果运算的数都是整数,那么除后,去掉小数部分,保留整数部分
    	fmt.Println(10 / 4) 
    	
    	var n1 float32 = 10 / 4 //
    	fmt.Println(n1)
    
    	//如果我们希望保留小数部分,则需要有浮点数参与运算
    	var n2 float32 = 10.0 / 4
    	fmt.Println(n2)	
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
  • 演示 % 的使用特点

    package main
    import (
    	"fmt" 
    )
    
    func main() {
    	// 演示  % 的使用 
    	// 看一个公式 a % b = a - a / b * b
    	fmt.Println("10%3=", 10 % 3) // =1
    	fmt.Println("-10%3=", -10 % 3) // = -10 - (-10) / 3 * 3 = -10 - (-9) = -1
    	fmt.Println("10%-3=", 10 % -3) // =1
    	fmt.Println("-10%-3=", -10 % -3) // =-1
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
  • ++和 --的使用

package main
import (
	"fmt" 
)

func main() {
	// ++ 和 --的使用
	var i int = 10
	i++ // 等价 i = i + 1
	fmt.Println("i=", i) // 11
	i-- // 等价 i = i - 1
	fmt.Println("i=", i) // 10

	if i > 0 {
		fmt.Println("ok")
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 4.2.3 算术运算符使用的注意事项

【点击观看视频】 算术运算符细节讨论

1 ) 对于除号 "/",它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分。 例如: x:= 19 / 5 ,结果是 3

2 ) 当对一个数取模时,可以等价 a%b=a-a/b*b , 这样我们可以看到 取模的一个本质运算。

3 ) Golang的自增自减只能当做一个独立语言使用时,不能这样使用

package main
import (
	_ "fmt" 
)
func main() {

	//在golang中,++ 和 -- 只能独立使用.
	var i int = 8
	var a int 
	a = i++ //错误,i++只能独立使用 
	a = i-- //错误, i--只能独立使用

	if i++ > 0 { //错误
		fmt.Println("ok")
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.) Golang 的++ 和 -- 只能写在变量的后面,不能写在变量的前面,即:只有 a++a-- 没有 ++a --a

package main
import (
	_ "fmt" 
)
func main() {
	var i int = 1
	i++
	++i // 错误,在golang没有 前++
	i-- 
	--i // 错误,在golang没有 前--
	fmt.Println("i=", i)
}
1
2
3
4
5
6
7
8
9
10
11
12

5 ) Golang的设计者去掉 c/java 中的 自增自减的容易混淆的写法,让Golang更加简洁,统一。(强制性的)

【点击观看视频】 算术运算符课堂练习

# 4.2.4.课堂练习 1

image-20210112171944536

# 4.2.5 课堂练习 2

1 ) 假如还有 97 天放假,问:xx个星期零xx天

2 ) 定义一个变量保存华氏温度,华氏温度转换摄氏温度的公式为: 5 / 9 *(华氏温度- 100 ),请求出华氏温度对应的摄氏温度。

package main
import (
	"fmt" 
)
func main() {

	//假如还有97天放假,问:xx个星期零xx天
	var days int = 97
	var week int = days / 7
	var day int = days % 7
	fmt.Printf("%d个星期零%d天\n", week, day)


	//定义一个变量保存华氏温度,华氏温度转换摄氏温度的公式为:
	//5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度
	var huashi float32 = 134.2
	var sheshi float32 = 5.0 / 9 * (huashi - 100)
	fmt.Printf("%v 对应的摄氏温度=%v \n", huashi, sheshi)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 4.3 关系运算符(比较运算符)

【点击观看视频】 关系运算符

# 4.3.1 基本介绍

1 ) 关系运算符的结果都是bool型,也就是要么是true,要么是false

2 ) 关系表达式 经常用在 if 结构的条件中或循环结构的条件中

# 4.3.2 关系运算符一览图

运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 true
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true

# 4.3.3 案例演示

package main
import (
	"fmt" 
)

func main() {
	//演示关系运算符的使用
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2) //false
	fmt.Println(n1 != n2) //true
	fmt.Println(n1 > n2) //true
	fmt.Println(n1 >= n2) //true
	fmt.Println(n1 < n2) //flase
	fmt.Println(n1 <= n2) //flase
	flag := n1 > n2
	fmt.Println("flag=", flag)	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 4.3.4 关系运算符的细节说明

细节说明

1 ) 关系运算符的结果都是bool型,也就是要么是true,要么是false。

2 ) 关系运算符组成的表达式,我们称为关系表达式: a>b

3 ) 比较运算符"=="不能误写成 "="!!

# 4.4 逻辑运算符

【点击观看视频】 逻辑运算符基本使用

# 4.4.1 基本介绍

用于连接多个条件(一般来讲就是关系表达式),最终的结果也是一个bool值

# 4.4.2 逻辑运算的说明

假定A为true B为false

运算符 描述 实例
&& 逻辑与 运算符,两边为true则为true 否在false A&&B 为false
|| 逻辑或,两边一个为true 则为true,否在false A || B 为true
! 逻辑非 运算符,如果条件true 则结果为false !(A&&B)为true

# 4.4.3 案例演示

package main
import (
	"fmt" 
)

func main() {

	//演示逻辑运算符的使用  &&
	var age int = 40
	if age > 30 && age < 50 {
		fmt.Println("ok1")
	}

	if age > 30 && age < 40 {
		fmt.Println("ok2")
	}

	//演示逻辑运算符的使用  ||

	if age > 30 || age < 50 {
		fmt.Println("ok3")
	}

	if age > 30 || age < 40 {
		fmt.Println("ok4")
	}

	//演示逻辑运算符的使用  !

	if age > 30 {
		fmt.Println("ok5")
	}

	if !(age > 30) {
		fmt.Println("ok6")
	} 

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 4.4.4 注意事项和细节说明

【点击观看视频】 短路与和短路或

1 ) &&也叫短路与:如果第一个条件为 false ,则第二个条件不会判断,最终结果为 false

2 ) ||也叫短路或:如果第一个条件为 true ,则第二个条件不会判断,最终结果为 true

3 ) 案例演示

package main
import (
	"fmt" 
)

//声明一个函数(测试)
func test() bool {
	fmt.Println("test....")
	return true
}

func main() {

	var i int = 10
	//短路与
	//说明 因为  i < 9 为 false ,因此后面的 test() 就不执行
	if i < 9 && test() {
		fmt.Println("ok...")
	}

	if i > 9 || test() {
		fmt.Println("hello...")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 4.5 赋值运算符

【点击观看视频】 赋值运算符基本使用

# 4.5.1 基本的介绍

赋值运算符就是将某个运算后的值,赋给指定的变量。

# 4.5.2 赋值运算符的分类

运算符 描述 实例
= 简单的赋值运算符,将一个表达式的值赋给一个左值 C=A+B
+= 相加后再赋值 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

# 4.5.3 赋值运算的案例演示

案例演示赋值运算符的基本使用。

1 ) 赋值基本案例

2 ) 有两个变量,a和b,要求将其进行交换,最终打印结果

3 ) +=的使用案例

4.) 案例

package main
import (
	"fmt" 
)

func test() int {
	return 90
}

func main() {
	//赋值运算符的使用演示
	var i int 
	i = 10 //基本赋值

	//有两个变量,a和b,要求将其进行交换,最终打印结果
	// a = 9 , b = 2 ==> a = 2 b = 9
	a := 9
	b := 2
	fmt.Printf("交换前的情况是 a = %v , b=%v \n", a, b)
	//定义一个临时变量
	t := a
	a = b //
	b = t //
	fmt.Printf("交换后的情况是 a = %v , b=%v \n", a, b)

	//复合赋值的操作
	a += 17 // 等价 a = a + 17
	fmt.Println("a=", a)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 4.5.4 赋值运算符的特点

1 ) 运算顺序从右往左

package main
import (
	"fmt" 
)

func main() {
	var c int 
	c = a + 3 // 赋值运算的执行顺序是从右向左
	fmt.Println(c)
}
1
2
3
4
5
6
7
8
9
10

2 ) 赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值

package main
import (
	"fmt" 
)

func test() int {
	return 90
}

func main() {
	//2)赋值运算符的左边 只能是变量,右边 可以是变量、表达式、常量值
	// 表达式:任何有值都可以看做表达式
	var d int
	d = a //  
	d = 8 + 2 * 8 // =的右边是表达式
	d = test() + 90 //  =的右边是表达式
	//d = 890 // 890常量
	fmt.Println(d)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3 ) 复合赋值运算符等价于下面的效果

比如:a+= 3 等价于 a=a+ 3

# 4.5.5 面试题

【点击观看视频】 赋值运算经典面试题

有两个变量,a和b,要求将其进行交换,但是不允许使用中间变量,最终打印结果

package main
import (
	"fmt" 
)
func main() {

	//有两个变量,a和b,要求将其进行交换,但是不允许使用中间变量,最终打印结果
	var a int = 10
	var b int = 20

	a = a + b //
	b = a - b // b = a + b - b ==> b = a
	a = a - b // a = a + b - a ==> a = b

	fmt.Printf("a=%v b=%v", a, b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 4.6 位运算符

运算符 描述
& 按位与运算符”&“是双目运算符。其功能是参与运算的两位数对应的二进制位相与。运算按规则是:同时为1,结果为1,否在为0
| 按位或运算符”|“是双目运算符,其功能是参与运算的两位数各对应的二进位相或。运算规则是:有一个为1,结果为1,否在为0
^ 按位异或运算符”^“是双目运算符。其功能是参与运算的两位数各对应的二进位相异或。运算规则是:当二进位不同时,结果为1,否在为0
<< 左移运算符”<<“是双目运算符。其功能把”<<“左边的运算数的各二进位全部左移若干位,高位丢弃,低位补0.左移n位就是乘以2的n次方
>> 右移运算符">>"是双目运算符。其功能是把”>>“左边的运算数的各二进位全部右移若干位,右移n位就是除以2的n次方

# 4.7 其它运算符说明

【点击观看视频】 其它运算符
运算符 描述 实例
& 返回变量存储地址 &a;将给出变量的实际地址
* 指针变量 *a;是一个指针变量

举例说明:

package main
import (
	"fmt" 
)
func main() {
	//演示一把 & 和 *的使用
	a := 100
	fmt.Println("a 的地址=", &a)
}
1
2
3
4
5
6
7
8
9

# 4.7.1 课堂案例

案例 1 :求两个数的最大值

package main
import (
	"fmt" 
)
func main() {

	//求两个数的最大值
	var n1 int = 10
	var n2 int = 40
	var max int
	if n1 > n2 {
		max = n1
	} else {
		max = n2
	}
	fmt.Println("max=", max)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

案例 2 :求三个数的最大值

package main
import (
	"fmt" 
)
func main() {
	//求出三个数的最大值思路:先求出两个数的最大值,
	//然后让这个最大值和第三数比较,在取出最大值
	var n3 = 45
	if n3 > max {
		max = n3
	}
	fmt.Println("三个数中最大值是=", max)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

# 4. 8 特别说明

image-20210112175249717

举例说明,如果在golang中实现三元运算的效果。

package main
import (
	"fmt" 
)
func main() {
	var n int 
	var i int = 10
	var j int = 12
	//传统的三元运算
	//n = i > j ? i : j
	if i > j {
		n = i
	} else {
		n = j
	}
	fmt.Println("n=", n) // 12
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 4.9 运算符的优先级

【点击观看视频】 运算符优先级

# 4.9.1 运算符的优先级的一览表

image-20210112175454579

# 4.9.2 对上图的说明

1 ) 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序。如右表,上一行运算符总

优先于下一行。

2 ) 只有单目运算符、赋值运算符是从右向左运算的。

3 ) 梳理了一个大概的优先级

  • 1 :括号,++,--
  • 2 : 单目运算
  • 3 :算术运算符
  • 4.:移位运算
  • 5 :关系运算符
  • 6 :位运算符
  • 7 :逻辑运算符
  • 8 :赋值运算符
  • 9 :逗号

# 4.10 键盘输入语句

【点击观看视频】 获取用户终端输入

# 4.10.1 介绍

在编程中,需要接收用户输入的数据,就可以使用键盘输入语句来获取。InputDemo.go

# 4.10.2 步骤 :

1 ) 导入fmt包

2 ) 调用fmt包的 fmt.Scanln () 或者 fmt.Scanf ()

image-20210112175611604

image-20210112175654292

# 4.10.3 案例演示:

要求:可以从控制台接收用户信息,【姓名,年龄,薪水, 是否通过考试 】。

1 ) 使用 fmt.Scanln() 获取

package main
import (
	"fmt" 
)


func main() {

	//要求:可以从控制台接收用户信息,【姓名,年龄,薪水, 是否通过考试 】。
	//方式1 fmt.Scanln
	//1先声明需要的变量
	var name string
	var age byte
	var sal float32
	var isPass bool
	fmt.Println("请输入姓名 ")
	//当程序执行到 fmt.Scanln(&name),程序会停止在这里,等待用户输入,并回车 
	fmt.Scanln(&name)
	fmt.Println("请输入年龄 ")
	fmt.Scanln(&age)
	fmt.Println("请输入薪水 ")
	fmt.Scanln(&sal)

	fmt.Println("请输入是否通过考试 ")
	fmt.Scanln(&isPass)

	fmt.Printf("名字是 %v \n 年龄是 %v \n 薪水是 %v \n 是否通过考试 %v \n", name, age, sal, isPass)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2 ) 使用 fmt.Scanf() 获取

package main
import (
	"fmt" 
)
func main() {
	//要求:可以从控制台接收用户信息,【姓名,年龄,薪水, 是否通过考试 】。
	//方式2:fmt.Scanf,可以按指定的格式输入
	fmt.Println("请输入你的姓名,年龄,薪水, 是否通过考试, 使用空格隔开")
	fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)
	fmt.Printf("名字是 %v \n年龄是 %v \n 薪水是 %v \n 是否通过考试 %v \n", name, age, sal, isPass)

}
1
2
3
4
5
6
7
8
9
10
11
12

# 4.11 进制

【点击观看视频】 计算机进制的介绍

对于整数,有四种表示方式:

1 ) 二进制: 0 , 1 ,满 2 进 1 。

  • 在golang中,不能直接使用二进制来表示一个整数,它沿用了c的特点。

2 ) 十进制: 0 - 9 ,满 10 进 1 。

3 ) 八进制: 0 - 7 ,满 8 进 1. 以数字 0 开头表示。

4.) 十六进制: 0 - 9 及A-F,满 16 进 1. 以 0 x或 0 X开头表示。

  • 此处的A-F不区分大小写。
package main
import (
	"fmt" 
)
func main() {
	var i int = 5
	//二进制输出 
	fmt.Printf("%b \n", i)

	//八进制:0-7 ,满8进1. 以数字0开头表示
	var j int = 011 // 011=> 9
	fmt.Println("j=", j)

	//0-9及A-F,满16进1. 以0x或0X开头表示
	var k int = 0x11 // 0x11=> 16 + 1 = 17
	fmt.Println("k=", k)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 4.11.1 进制的图示

image-20210112214944931

image-20210112214958675

# 4.11.2 进制转换的介绍

image-20210112215027509

# 4.11.3 其它进制转十进制

【点击观看视频】 其它进制转十进制

image-20210112215039240

# 4.11.4.二进制如何转十进制

image-20210112215112556

# 4.11.5 八进制转换成十进制示例

image-20210112215128488

# 4.11.6 16 进制转成 10 进制

image-20210112215139694

# 4.11.7 其它进制转 10 进制的课堂练习

课堂练习:请将

二进制: 110001100 转成 十进制

八进制: 02456 转成十进制

十六进制: 0 xA 45 转成十进制

# 4.11.8 十进制如何转成其它进制

【点击观看视频】 十进制转其它进制

image-20210112215210370

# 4.11.9 十进制如何转二进制

image-20210112215228133

# 4.11.10 十进制转成八进制

image-20210112215243704

# 4.11.11 十进制转十六进制

image-20210112215258207

# 4.11.12 课堂练习

课堂练习:请将

123 转成 二进制

678 转成八进制

8912 转成十六进制

# 4.11.13 二进制转换成八进制、十六进制

【点击观看视频】 二进制转其它进制

image-20210112215314000

# 4.11.14.二进制转换成八进制

image-20210112215323718

# 4.11.15 二进制转成十六进制

image-20210112215336725

课堂练习

课堂练习:请将

二进制: 11100101 转成 八进制

二进制: 1110010110 转成 十六进制

# 4.11.16 八进制、十六进制转成二进制

【点击观看视频】 其它进制转二进制

image-20210112215359026

# 4.11.17 八进制转换成二进制

image-20210112215409530

# 4.11.18 十六进制转成二进制

image-20210112215418081

# 4.12 位运算

# 4.12.1 位运算的思考题

1 ) 请看下面的代码段,回答a,b,c,d结果是多少?

func main(){
    var a int = 1 >> 2
    var b int = -1 >> 2
    var c int= 1 << 2
    var d int= -1 << 2
    //a,b,c,d结果是多少
    fmt.Println("a=",a)
    fmt.Println("b=",b)
    fmt.Println("c=",c)
    fmt.Println("d=",d)
}
1
2
3
4
5
6
7
8
9
10
11

2 ) 请回答在Golang中,下面的表达式运算的结果是:

func main(){
    fmt.Println( 2 & 3 )
    fmt.Println( 2 | 3 )
    fmt.Println( 13 & 7 )
    fmt.Println( 5 | 4.)//?
    fmt.Println(- 3 ^ 3 )//?
}
1
2
3
4
5
6
7

# 4.12.2 二进制在运算中的说明

二进制是逢 2 进位的进位制, 0 、 1 是基本算符。

现代的电子计算机技术全部采用的是二进制,因为它只使用 0 、 1 两个数字符号,非常简单方便,易于用电子方式实现。计算机内部处理的信息,都是采用二进制数来表示的。二进制(Binary)数用 0和 1 两个数字及其组合来表示任何数。进位规则是“逢 2 进 1 ”,数字 1 在不同的位上代表不同的值,按从右至左的次序,这个值以二倍递增。

在计算机的内部,运行各种运算时,都是以二进制的方式来运行。

# 4.12.3 原码、反码、补码

【点击观看视频】 原码 反码 补码

image-20210112215827361

# 4.12.4 位运算符和移位运算符

【点击观看视频】 位运算深度讲解
  • Golang中有 3 个位运算

    分别是”按位与&、按位或|、按位异或^,它们的运算规则是:

    按位与 & : 两位全为1,结果为 1 ,否则为 0

    按位或 | : 两位有一个为 1 ,结果为 1 ,否则为 0

    按位异或 ^ : 两位一个为 0 , 一个为 1 ,结果为 1 ,否则为 0

  • 案例练习

    比如: 2 & 3 =? 2 | 3 =? 2 ^ 3 =?

    package main
    import (
    	"fmt" 
    )
    func main() {
    
    	//位运算的演示
    	fmt.Println(2&3) // 2
    	fmt.Println(2|3) // 3
    	fmt.Println(2^3) // 3
    	fmt.Println(-2^2) //-4
    
    	a := 1 >> 2 //0
    	c := 1 << 2 //4
    	fmt.Println("a=", a, "c=", c)
    	
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    image-20210112215949764

  • Golang中有 2 个移位运算符:

    、>> << 右移和左移,运算规则:

    右移运算符 >>:低位溢出 , 符号位不变 , 并用符号位补溢出的高位

    左移运算符 <<: 符号位不变 , 低位补 0

  • 案例演示

    a:= 1 >> 2 // 00000001 => 00000000 = 0

    c:= 1 << 2 // 00000001 ==> 00000100 => 4

  • 4.1 运算符的基本介绍
  • 4.2 算术运算符
  • 4.2.1 算术运算符的一览表
  • 4.2.2 案例演示
  • 4.2.3 算术运算符使用的注意事项
  • 4.2.4.课堂练习 1
  • 4.2.5 课堂练习 2
  • 4.3 关系运算符(比较运算符)
  • 4.3.1 基本介绍
  • 4.3.2 关系运算符一览图
  • 4.3.3 案例演示
  • 4.3.4 关系运算符的细节说明
  • 4.4 逻辑运算符
  • 4.4.1 基本介绍
  • 4.4.2 逻辑运算的说明
  • 4.4.3 案例演示
  • 4.4.4 注意事项和细节说明
  • 4.5 赋值运算符
  • 4.5.1 基本的介绍
  • 4.5.2 赋值运算符的分类
  • 4.5.3 赋值运算的案例演示
  • 4.5.4 赋值运算符的特点
  • 4.5.5 面试题
  • 4.6 位运算符
  • 4.7 其它运算符说明
  • 4.7.1 课堂案例
  • 4. 8 特别说明
  • 4.9 运算符的优先级
  • 4.9.1 运算符的优先级的一览表
  • 4.9.2 对上图的说明
  • 4.10 键盘输入语句
  • 4.10.1 介绍
  • 4.10.2 步骤 :
  • 4.10.3 案例演示:
  • 4.11 进制
  • 4.11.1 进制的图示
  • 4.11.2 进制转换的介绍
  • 4.11.3 其它进制转十进制
  • 4.11.4.二进制如何转十进制
  • 4.11.5 八进制转换成十进制示例
  • 4.11.6 16 进制转成 10 进制
  • 4.11.7 其它进制转 10 进制的课堂练习
  • 4.11.8 十进制如何转成其它进制
  • 4.11.9 十进制如何转二进制
  • 4.11.10 十进制转成八进制
  • 4.11.11 十进制转十六进制
  • 4.11.12 课堂练习
  • 4.11.13 二进制转换成八进制、十六进制
  • 4.11.14.二进制转换成八进制
  • 4.11.15 二进制转成十六进制
  • 4.11.16 八进制、十六进制转成二进制
  • 4.11.17 八进制转换成二进制
  • 4.11.18 十六进制转成二进制
  • 4.12 位运算
  • 4.12.1 位运算的思考题
  • 4.12.2 二进制在运算中的说明
  • 4.12.3 原码、反码、补码
  • 4.12.4 位运算符和移位运算符