【Go笔记】第 4 章 运算符
Suriski 9/20/2022 韩顺平尚硅谷golang笔记
# 4.1 运算符的基本介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
- 算术运算符
- 赋值运算符
- 比较运算符/关系运算符
- 逻辑运算符
- 位运算符
- 其它运算符
# 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 |
| + | 字符串相加 | "ME"+"TO" | METO |
# 4.2.2案例演示
🏷案例演示算术运算符的使用。 +, - , * , / , %, ++, -- , 重点讲解 /、% 自增：++ 自减：--
🏷 演示 / 的使用的特点
//重点讲解 / 、 %
//说明，如果运算的数都是证书，那么除后，去掉小数部分，保留整数部分
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
2
3
4
5
6
7
8
9
10
🏷演示 % 的使用特点
// 演示 % 的使用
// 看一个公式 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
2
3
4
5
6
🏷++ 和 --的使用
var i int = 10
i++ //等价 i = i + 1
fmt.Println("i=",i) //11
i== //等价 i = i - 1
fmt.Println（"i=",i） //10
1
2
3
4
5
2
3
4
5
# 4.2.3算术运算符使用的注意事项
- 对于除号 "/"，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃 小数部分。 例如： x := 19/5 ,结果是 3
- 当对一个数取模时，可以等价
a%b=a-a/b*b， 这样我们可以看到 取模的一个本质运算。 - Golang 的自增自减只能当做一个独立语言使用时，不能这样使用
package main
func main() {
//在Go中，++和--只能独立使用
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
2
3
4
5
6
7
8
9
10
11
12
13
14
- Golang 的++ 和 -- 只能写在变量的后面，不能写在变量的前面，即：只有 a++ a-- 没有 ++a、--a
- Golang 的设计者去掉 c / java 中的 自增自减的容易混淆的写法，让 Golang 更加简洁，统一。(强制性的)
# 4.2.4课堂练习 1
//var i int = 1
//i = i++
//fmt.Println(i)
//问：结果是什么？为什么
//上面的代码时错误，编译不通过，i=i++
//var i int = 10
//if i++ > 10{
// fmt.Println("ok")
//}
//问：结果是多少？为什么？
//上面代码运行时错误，编译不通过，i++ > 10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 4.2.5课堂练习 2
- 假如还有 97 天放假，问：xx 个星期零 xx 天
- 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*(华氏温度-100),请求出华氏温度对应的摄氏温度。
package main
import "fmt"
func main() {
//加入还有97天放假，问：xxx个星期零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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 4.3 关系运算符(比较运算符)
# 4.3.1 基本介绍
- 关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false
- 关系表达式 经常用在 if 结构的条件中或 循环结构的条件中
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | false |
| != | 不等于 | 4 != 3 | true |
| < | 小于 | 4《 3 | false |
| > | 大于 | 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) //false
fmt.Println(n1 <= n2) //false
flag := n1 > n2
fmt.Println("flag=", flag) //false
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 4.3.4关系运算符的细节说明
细节说明
- 关系运算符的结果都是 bool 型，也就是要么是 true，要么是 false。
- 关系运算符组成的表达式，我们称为关系表达式： a > b
- 比较运算符"=="不能误写成 "=" !!
# 4.4 逻辑运算符
# 4.4.1基本介绍
用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个 bool 值
# 4.4.2逻辑运算的说明
假定 A 值为True ,B 值为false
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 逻辑与运算符，如果两边的操作数都是True则为True,否则为False | (A && B) 为 False |
| ll | 逻辑或运算符，如果两边的操作数有一个True，则为True,否则为False | （A ll B） 为 True |
| ! | 逻辑非运算符，如果条件为True，则逻辑为False，否则为True | ！（A && B）为True |
# 4.4.4注意事项和细节说明
- &&也叫 短路与： 如果第一个条件为 false，则 第二个条件不会判断，最终结果为 false
- ||也叫 短路或：如果 第一个条件为 true，则 第二个条件不会判断，最终结果为true
- 案例演示
func test() bool {
fmt.Println("true...")
return true
}
func main() {
var i int = 10
//短路与
//说明 因为 i < 9 为False，因此后面的test()就不知晓
if i < 9 && test() {
fmt.Println("ok")
}
//说明 因为 i > 9 为true，因此后面的test()就不执行
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 4.5 赋值运算符
# 4.5.1基本的介绍
赋值运算符就是将某个运算后的值，赋给指定的变量。
# 4.5.2赋值运算符的分类
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C = A + B 表达式结果赋值给C |
| += | 相加后再赋值 | 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 |
| l= | 按位或后赋值 | C != 2 等于 C = C l 2 |
说明：这部分的赋值运算涉及到二进制相关知识，我们放在二进制的时候再回头讲解
# 4.5.3赋值运算的案例演示
案例演示赋值运算符的基本使用。
- 赋值基本案例
- 有两个变量，a 和 b，要求将其进行交换，最终打印结果
- += 的使用案例
- 案例
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", a, b)
//定义一个临时变量
t := a
a = b
b = t
fmt.Printf("交换后的情况是a=%v,b=%v", 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 4.5.4赋值运算符的特点
- 运算顺序从右往左
var c int
c = a + 3 //赋值运算的执行顺序从右向左
1
2
2
- 赋值运算符的左边 只能是 变量,右边 可以是 变量、表达式、常量值
//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
2
3
4
5
6
7
8
- 复合赋值运算符等价于下面的效果 比如：a += 3 等价于 a = a + 3
# 4.5.5面试题
有两个变量，a 和 b，要求将其进行交换，但是不允许使用中间变量，最终打印结果
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
2
3
4
5
6
7
8
9
# 4.6
| 运算符 | 描述 |
|---|---|
| & | 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。运算规则是：同时为1，结果为1，否则为0 |
| l | 按位或运算符""是双目运算符。其功能是参与运算的两数各对应的二进位相或运算规则是：有一个为1，结果为1，否则为0 |
| ^ | 按位异或运算符""是双目运算符。其功能是参与运算的两数各对应的二进位相异或运算规则是：当二进位不同时，结果为1，否则为0 |
| << | 左移运算符"<"是双目运算符。其功能把"<"左边的运算数的各二进位全部左移若干位，高位丢弃，低位补0。左移n位就是乘以2的n次方。 |
| >> | 右移运算符”>"是双目运算符。其功能是把">"左边的运算数的各二进位全部右移若干位右移n位就是除以2的n次方 |
说明：因为位运算涉及到二进制相关知识，我们仍然放到讲二进制时，在详细讲解
# 4.7 其它运算符说明
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a; 将给出变量的实际地址 |
| * | 指针变量 | *a 是一个指针变量 |
举例说明：
func mian(){
//演示一把 & 和 * 的使用
a := 100
fmt.Println("a 的地址=",&a)
var ptr *int = &a
fmt.Println("ptr 指向的值是=",*ptr)
}
1
2
3
4
5
6
7
2
3
4
5
6
7
# 4.7.1课堂案例
func mian(){
//求两个数的最大值
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
2
3
4
5
6
7
8
9
10
11
12
# 4.8 特别说明
举例说明，如果在 golang 中实现三元运算的效果。
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)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 4.9 运算符的优先级
# 4.9.1运算符的优先级的一览表
# 4.9.2对上图的说明
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
- 只有单目运算符、赋值运算符是从右向左运算的。
- 梳理了一个大概的优先级 1：括号，++, -- 2: 单目运算 3：算术运算符 4：移位运算 5：关系运算符 6：位运算符 7：逻辑运算符 8：赋值运算符 9：逗号
# 4.10 键盘输入语句
# 4.10.1 介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。InputDemo.go
# 4.10.2 步骤 ：
- 导入 fmt 包
- 调用 fmt 包的 fmt.Scanln() 或者 fmt.Scanf()
# 4.10.3 案例演示：
要求：可以从控制台接收用户信息，【姓名，年龄，薪水, 是否通过考试 】。
- 使用 fmt.Scanln() 获取
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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
- 使用 fmt.Scanf() 获取
//方式2 fmt.Scanf,可以按指定的格式输入
fmt.Println("请输入你的姓名，年龄，薪水，是否通过考试，使用空格隔开")
fmt.Scanf("%s %d %f %t",&name,&age,&sak,&isPass)
fmt.Printf("请输入你的姓名 %v\n，年龄 %v\n，薪水 %v \n，是否通过考试 &v \n",name,age,sak,isPass)
1
2
3
4
5
2
3
4
5
# 4.11 进制
对于整数，有四种表示方式：
- 二进制：0,1 ，满 2 进 1。 在 golang 中，不能直接使用二进制来表示一个整数，它沿用了 c 的特点。
- 十进制：0-9 ，满 10 进 1。
- 八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。
- 十六进制：0-9 及 A-F，满 16 进 1. 以 0x 或 0X 开头表示。 此处的 A-F 不区分大小写。
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 //ox11 => 16 + 1 = 17
fmt.Println("k=",k)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
# 4.11.1 进制的图示
# 4.11.2 进制转换的介绍
# 4.11.3 其它进制转十进制
# 4.11.4 二进制如何转十进制
# 4.11.5 八进制转换成十进制示例
# 4.11.6 16 进制转成 10 进制
# 4.11.7 其它进制转 10 进制的课堂练习
🏷 课堂练习：请将 二进制： 110001100 转成 十进制 八进制： 02456 转成十进制 十六进制： 0xA45 转成十进制
# 4.11.8 十进制如何转成其它进制
# 4.11.9 十进制如何转二进制
# 4.11.10 十进制转成八进制
# 4.11.11 十进制转十六进制
# 4.11.12 课堂练习
课堂练习：请将 123 转成 二进制 678 转成八进制 8912 转成十六进制
# 4.11.13 二进制转换成八进制、十六进制
# 4.11.14 二进制转换成八进制
# 4.11.15 二进制转成十六进制
🏷 课堂练习 课堂练习：请将 二进制：11100101 转成 八进制 二进制：1110010110 转成 十六进制
# 4.11.16 八进制、十六进制转成二进制
# 4.11.17 八进制转换成二进制
# 4.11.18 十六进制转成二进制
# 4.12 位运算
# 4.12.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
3
4
5
6
7
8
9
10
11
- 请回答在 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
2
3
4
5
6
7
# 4.12.2 二进制在运算中的说明
二进制是逢 2 进位的进位制，0、1 是基本算符。 现代的电子计算机技术全部采用的是二进制，因为它只使用 0、1 两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用 0和 1 两个数字及其组合来表示任何数。进位规则是“逢 2 进 1”，数字 1 在不同的位上代表不同的值，按从右至左的次序，这个值以二倍递增。
在计算机的内部，运行各种运算时，都是以二进制的方式来运行。
# 4.12.3 原码、反码、补码
# 4.12.4 位运算符和移位运算符
🏷 Golang 中有 3 个位运算 分别是”按位与&、按位或|、按位异或^,它们的运算规则是： 按位与& ： 两位全为１，结果为 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 ^ 3) //-4
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
🏷 Golang 中有 2 个移位运算符：
>>、<< 右移和左移,运算规则:
右移运算符 >>： 低位溢出, 符号位不变, 并用符号位补溢出的高位
左移运算符 <<: 符号位不变, 低位补 0
🏷 案例演示 a := 1 >> 2 // 0000 0001 =>0000 0000 = 0 c := 1 << 2 // 0000 0001 ==> 0000 0100 => 4