第4章 运算符

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

• 演示 % 的使用特点

  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
  }
  

• ++和 --的使用

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

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

}

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

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

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

4.2.4.课堂练习 1

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

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

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

}

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

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

4.5.4 赋值运算符的特点

1 ) 运算顺序从右往左

package main
import (
	"fmt" 
)

func main() {
	var c int 
	c = a + 3 // 赋值运算的执行顺序是从右向左
	fmt.Println(c)
}

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

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

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

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

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

package main
import (
	"fmt" 
)
func main() {
	//求出三个数的最大值思路：先求出两个数的最大值，
	//然后让这个最大值和第三数比较，在取出最大值
	var n3 = 45
	if n3 > max {
		max = n3
	}
	fmt.Println("三个数中最大值是=", max)
}

4. 8 特别说明

举例说明，如果在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
}

4.9 运算符的优先级

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

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

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

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

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)

}

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

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 转成十进制

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

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 位运算的思考题

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

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

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 原码、反码、补码

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

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^2) //-4
  
  	a := 1 >> 2 //0
  	c := 1 << 2 //4
  	fmt.Println("a=", a, "c=", c)
  	
  }
  

  

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

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

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

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

• 案例演示

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

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