第4章 运算符

4.1 运算符的基本介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
1）算数运算符
2）赋值运算符
3）比较运算符/关系运算符
4）逻辑运算符
5）位运算符
6）其它运算符

4.2 算术运算符

算术运算符是对数值类型的变量进行运算的，比如：加减乘除。在GO程序章使用的非常多

4.2.1算数运算符的一览表

1.演示 / 的使用：

func main() {
	//如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
	fmt.Printf("直接值为：%v\n", 10/4)
	var n1 float32 = 10 / 4
	fmt.Printf("不保留小数：%v \n", n1)

	var n2 float32 = 10.0 / 4
	//若希望保留小数部分，则需要有浮点小数参与运算
	fmt.Printf("保留小数：%v", n2)
}

2.演示 % 的使用

func main() {
	// 看一个公式 a% b =a-b / b*b

	fmt.Println("10 % 3 =", 10%3)
	fmt.Println("-10 % 3 =", -10%3)
	fmt.Println("10 % -3 =", 10&-3)
	fmt.Println("-10 % -3 = ", -10%-3)

}

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

	i-- //注，此时的i =11，在i++ 的基础上进行运算的
	fmt.Println("i-- =", i)

}

4.2.2 算数运算符使用的注意事项

1. 对于除号 “/”，它的整数除和小数除是由区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。列如：x:=19/5，结果是3
   2) 当对一个数取模时，可以等价 a%b = a-a/b*b,这样我们可以看到取模的一个本质运算。
   3）Golang 的自增自减只能当作一个独立语言使用时，不能这样使用

func main() {
	//在golang中，++ 和 -- 只能独立使用
	var i int = 8
	var a int

	// a = i++  //错误，i++ 只能独立使用
	// a = i--	 //错误，i-- 只能独立使用
	
	i++ //这样正确

	if i ++ >0{       //这样也是错误的
		fmt.Println("ok")
	}

}

4) Golamg 的++ 和 --只能写在变量的后面，不能写在变量的前面，即：只有 a++a-- 没有++a --a
5) Golang 的设计者去掉c/ java中的自增自减的容易混淆的写法，让Golang更加简洁，统一。

4.2.3练习题

func main() {
	var oF float32 = 134.2
	var oC float32

	// 1、摄氏温度（C）与华氏温度（F）的换算式是：
	// C = 5×（F- 32）/9，F = 9×C /5+32

	oC = 5.0 * (oF - 100) / 9

	//fmt.Printf("当%v华氏温度时，摄氏温度为%v", oF, oC)
	fmt.Println(oC)

}

4.3 关系运算符（比较运算符）

4.3.1 基本介绍

1）关系运算符的结果都是bool型，只能时true或false
2）关系表达式 ，经常用在if结构的条件中或循环结构的条件中

4.3.2 关系运算符一览图

4.3.3 案例

func main() {
	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1 == n2)
	fmt.Println(n1 != n2)
	fmt.Println(n1 > n2)
	fmt.Println(n1 >= n2)
	fmt.Println(n1 < n2)
	fmt.Println(n1 <= n2)
	flag := n1 > n2
	fmt.Println("flag=", flag)
}

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

1）关系运算符的结果都是bool型，也就是要么是true，要么是flase。
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,否则为True.	!(A && B) 为 True

4.4.3 案例演示

//演示逻辑与运算符的使用  &&
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")

    }

4.4.4注意事项和细节说明

1.&&也叫短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false
2.|| 也叫短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true
3.案例展示：

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....")

	}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wkUUagcw-1675823571012)(https://cdn.nlark.com/yuque/0/2022/png/26226221/1670819729657-012225a7-0f67-46cf-8852-b809c6c34c5d.png#averageHue=%23fdfdfd&clientId=u44faad44-0fa9-4&from=paste&height=585&id=u80ba5631&name=image.png&originHeight=1024&originWidth=1403&originalType=binary&ratio=1&rotation=0&showTitle=false&size=115645&status=done&style=none&taskId=u5727e7e5-c4ee-4ff6-a5df-03b58206478&title=&width=801.7142857142857)]

4.5 赋值运算

4.5.1基本介绍

赋值运算就是将某个运输后的值，赋给指定的变量

4.5.2赋值运算符的分类

运算符	描述	实例
=	简单的赋值运算符，将一个表达式的值赋给一个左值	C=A+B将A的表达是结果赋值给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=&2
^=	按位异后或后赋值	C=2等于C=C2
|=	按位或后赋值	C|=2等于C=C | 2

说明：涉及到二级制知识

4.5.3赋值运算的案例演示

1)赋值基本案例
2)有两个变量，a和b，要求将其进行交换，最终打印结果
3)+=的使用案例
4)案例

func main() {
	//4.5.3 赋值运算符的使用演示
	//var i = 10
	//i = 10 基本赋值
	//有两个变量，a 和b，要求将其进行交换，最终打印结果

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

4.5.4 赋值运算符的特点

func main() {
	//4.5.4 赋值运算符的特点
	//1.运算符顺序从左往右
	a := 2
	var c int
	c = a + 3 //赋值原始的执行顺序是从右向左
	fmt.Printf("c的值为：%v", c)

	//2.赋值运算符的左边，只能是变量，右边可以是变量、表达式、常量值
	//表达式：任何值都可以看作表达式
	var d int
	d = a //
	d = 8 + 2*8
	//d = test() + 90
	d = 890 //890常量
	fmt.Printf("\nd的值为：%v", d)
	//3复合赋值运算符等价与下面的效果
	a += 3
	a = a + 3

}

4.5.5面试题

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

func main() {
	//4.4.5面试题
	//有两个变量，a和b，要求将其进行交换，但是不允许使用中间变量，最终打印结果
	a := 2
	b := 5

	a = a + b //a = 7
	b = a - b //b = 2
	a = a - b //a = 5

	fmt.Printf("a的值为：%v,b的值为：%v", a, b)
}

4.6 位运算符

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

4.7 其它运算符说明

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

func main() {
	//4.7.1 演示 & 和 * 的使用

	a := 100
	fmt.Println("a的地址=", &a)

	var ptr *int = &a

	fmt.Println("\nptr指向的值是=", *ptr)

}

4.7.1课堂案例

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

func main() {
	//4.7.1练习题
	//求两个数的最大值
	var n1 int = 10
	var n2 int = 40
	var max int
	if n1 > n2 {
		max = n1
	} else {
		max = n2
	}
	fmt.Println("max=", max)
}

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

func main() {
	//4.7.1练习题
	//求两个数的最大值
	var n1 int = 10
	var n2 int = 40
	var max int
	if n1 > n2 {
		max = n1
	} else {
		max = n2
	}
	fmt.Println("max=", max)

	var n3 = 45
	if n3 > max {
		max = n3
	}
	fmt.Println("三个数比较最大为：", max)
}

4.8 go不支持三元运算

package main

import "fmt"

func main() {
	//4.8 go不支持三元运算
	var n int
	var i int = 10
	var j int = 12
	//传统的三元运算
	//n = i > j ? i:j
	//go实现三元运算
	if i > j {
		n = i

	} else {
		n = j
	}
	fmt.Println("n=", n)
}

4.9 运算符的优先级

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

分类	描述	关联性
后缀	()[]->.++ –	左到右
单目	± !~(type)*&sizeof	右到左
乘法	*/%	左到右
加法	±	左到右
移位	<< >>	左到右
关系	< <= > >=	左到右
相等（关系）	== !=	左到右
按位AND	&	左到右
按位XOR	^	左到右
按位OR	|	左到右
逻辑AND	&&	左到右
逻辑OR	||	左到右
赋值运算符	= += -= *= /= %= >>= <<= &= ^= |=	右到左
逗号	,	左到右

4.9.2 对上表的说明

1.运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。上一行运算符总优先与下一行
2.只有单目运算符、赋值运算符是从右向左运算的。
3.优先级
1：括号，++，–
2：单目运算
3：算术运算符
4：移位运算
5：关系运算符
6：位运算符
7：逻辑运算符
8：赋值运算符
9：逗号

4.10键盘输入

4.10.1 介绍

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

4.10.2 使用函数

fmt包的fmt.Scanln()或者fmt.Scanf()

4.10.3 案例展示

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

1.使用 fmt.Scaln()获取

func main() {
	//要求：可以从控制台接收用户信息，【姓名，年龄，薪水,是否通过考试】。
	//1)使用fmt.Scanln()获取
	var name string
	var age byte
	var sal float32
	var isPass bool
	fmt.Println("请输入姓名")
	//当程序执行到fmt.Sscanle(&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", name, age, sal, isPass)
}

2.使用fmt.Scanf()获取

func main() {
	//2)使用fmt.Scanf()获取
	var name string
	var age byte
	var sal float32
	var isPass bool
	fmt.Println("请输入你的姓名，年龄，薪水，是否通过考试，使用空格隔开")
	fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)
	fmt.Printf("名字是%v\n年龄是%d\n薪水是%f\n是否通过考试%t", name, age, sal, isPass)

}

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。以0x或0X开头表示。
此处的A-F不区分大小写。
进制图表示：

4.11.2进制转换的介绍

第一组（其它进制转十进制）：
1）二进制转十进制
2）八进制转十进制
3）十六进制转十进制
4）示意图
第二组：（十进制转其它进制）
1）十进制转二进制
2）十进制转八进制
3）十进制转十六进制
4）示意图
第三组：（二进制转其它进制）
1）二进制转八进制
2）二进制转十六记住你hi
3）示意图
第四组：（其它进制转二进制）
1）八进制转二进制
2）十六进制转二进制

4.12 位运算

package main

import "fmt"

func main1() {
	var a int = 1 >> 2
	var b int = -1 >> 2
	var c int = 1 << 2
	var d int = -1 << 2

	fmt.Println("a=", a)
	fmt.Println("b=", b)
	fmt.Println("c=", c)
	fmt.Println("d=", d)
}
func main() {
	fmt.Println(2 & 3)
	fmt.Println(2 | 3)
	fmt.Println(13 & 7)
	fmt.Println(5 | 4)
	fmt.Println(-3 ^ 3)
}

4.12.2 二进制在运算中的说明

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

4.12.3 原码、反码、补码

1.对于有符号的而言：
1）二进制的最高位是符号位：0表示正数，1表示负数
1==>[00000001]
-1==>[10000001]
2.正数的原码，反码，补码都一样
3.负数的反码等于它的 原码的符号位不变，其它位取反[0->1,1->0]
4.负数的补码=它的反码+1
1==>原码：[00000001] 反码：[00000001]补码：[00000001]
-1==>源码：[10000001]反码：[11111110]补码：[11111111]
5.0的反码和补码都是0
6.在计算机运行运算的时候，都是以补码的方式来运算的
1+1 1-1 = 1+（-1）

4.12.4 位运算符和移位运算符

1.Golang中有3个位运算
分别是按位与&、按位或|、按位异或^，他们的运算规则是：
按位与& ：两位全位1，结果位1，否则为0
按位或|：两位有一个为1，结果为1，否则为0
按位异或^:两位一个为0，一个为1，结果为1，否则为0

2.Golang中有2个移位运算符
>>和<< 右移和左移动，运算规则：
右移运算符 >>：低位溢出，符和位不变，并用符号位补溢出的高位
左移运算符<<：符号位不变，低位补0
3.案例演示
a:=1 >>2 //0000 0001=>0000 0000 =>0
b:=1 <<2 //0000 0001 =>0000 0100 =>4