5.Go运算符
5.Go运算符
前言
在前面的篇章中，我们已经学习了变量，常量，那么接下来我们学习一下运算符。
GO语言中常见的运算符有算术运算符，赋值运算符，关系运算符，逻辑运算符等。
1：算术运算符
(1) 算术运算符
运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
+ | 加 | 10 + 5 | 15 |
- | 减 | 10 - 5 | 5 |
* | 乘 | 10 * 5 | 50 |
/ | 除 | 10 / 5 | 2 |
% | 取模(取余) | 10 % 3 | 1 |
++ | 后自增，没有前自增 | a=0; a++ | a=1 |
-- | 后自减，没有前自减 | a=2; a-- | a=1 |
算术表达式:由算术运算符连接起来的式子.如:1+1 a-b(变量ab前面已声明并赋初值)
下面以a=10 ,b=20为例进行计算
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
// 求和
fmt.Printf("a+b=%d\n", a+b)
// 减法
fmt.Printf("b-a=%d\n", b-a)
// 乘法
fmt.Printf("b*a=%d\n", b*a)
// 除法
fmt.Printf("b/a=%d\n", b/a)
// 取余
fmt.Println("b%a=", b%a)
}
执行如下：
a+b=30
b-a=10
b*a=200
b/a=2
b%a= 0
自增与自减操作
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
a++ // 自增，GO没有前自增 ++a
b-- // 自减，GO没有前自减 --b
fmt.Printf("a=%d, b=%d", a, b)
}
执行如下：
a=11, b=19
a++等价于a=a+1
注意：GO语言中没有前自增，这是与其它编程语言不同的地方。
(2)演示:某学生三门课成绩为,语文:90 数学:80 英语:67,编程求总分和平均分.
package main
import "fmt"
func main() {
var chinese int = 90 // 语文分数
var math int = 80 // 数学分数
var english int = 67 // 英语分数
var sum, avg int // 总分、平均分
// 求总分
sum = chinese + math + english
// 求平均分
avg = sum / 3
fmt.Printf("总分是: %d, 平均分是: %d", sum, avg)
}
执行如下：
总分是: 237, 平均分是: 79
虽然已经计算出总分与平均分了，但是我们可以对上面的程序进行优化，怎么优化呢？示例如下：
func main() {
var chinese int = 90 // 语文分数
var math int = 80 // 数学分数
var english int = 67 // 英语分数
fmt.Printf("总分是: %d, 平均分是: %d", chinese + math + english, (chinese + math + english)/3)
}
以上程序大家需要注意几点：
（2.1）该程序比第一种实现减少了变量的定义，可以减少对内存的占用，所以变量不是定义越多越好。
（2.2） 注意运算优先级：
先乘除,后加减,有括号先算括号里的,相同级别的从左至右运算 int a=((1+5)+3)*2
（2.3） 小括号可以无限制的套用,但一定要成对出现
(3) 类型转换：
现在我们把上面提的需求修改一下：语文:90 数学:80 英语:69,编程求总分和平均分.
只是将英语的成绩进行了修改，还是计算总分和平均分
image-20210421081350888
但是平均分的计算结果还是79分，为什么没有小数呢？
现在将程序进行如下修改：
image-20210421081516019
Go语言中不允许隐式转换，所有类型转换必须显式声明（强制转换），而且转换只能发生在两种相互兼容的类型之间
var ch byte = 97
var a int = int(ch) // 类型转换必须显示声明（强制转换）
fmt.Println("a = ", a)
(4) 思考题：
（4.1）请阅读以下程序，如果该程序正确，请说出程序运行的结果，如果有错误，请说出错误原因，并指明怎样进行修改？
// 思考题一
var num1 int = 35
var num2 int = 40
var avg float64
avg = (num1 + num2) / 2
fmt.Printf("avg=%f", avg)
（4.2）以下程序，如果正确请说出程序运行的结果，如果错误，请说出错误原因，并指明怎样进行修改？
// 思考题二
var num1 int = 10
var num2 int = 3
var mod float64
mod = float64(num1 / num2)
fmt.Printf("mod=%.2f", mod)
（4.3）以下程序，如果正确请说出程序运行的结果，如果错误，请说出错误原因，并指明怎样进行修改？
// 思考题三
var num1 int = 35
var num2 int = 40
var num3 int = 2
var avg float64
avg = float64(num1+num2) / num3
fmt.Printf("avg=%f", avg)
(5) 练习：
练习1：定义两个数分别为100和20，打印出两个数的和。
// 练习1：定义两个数分别为100和20，打印出两个数的和。
var num1 int = 100
var num2 int = 20
fmt.Printf("两个数的和： %d", num1 + num2)
运行：
两个数的和：120
练习2：计算半径为5的圆的面积和周长并打印出来.（pi为3.14）面积:pirr; Perimeter(周长)
// 练习2：计算半径为5的圆的面积和周长并打印出来.（pi为3.14）面积:pi*r*r; Perimeter(周长)
const PI = 3.14
var r float64 = 5.0 // 半径
fmt.Printf("面积: %.2f, 周长: %.2f", PI*r*r, PI*2*r)
运行：
面积: 78.50, 周长: 31.40
练习3:某商店T恤(T-shirt)的价格为35元/件,裤子(trousers)的价格为120元/条.小明在该店买了3件T恤和2条裤子,请计算并显示小明应该付多少钱?
打8.8折后呢？
// 练习3:某商店T恤(T-shirt)的价格为35元/件,裤子(trousers)的价格为120元/条.小明在该店买了3件T恤和2条裤子,请计算并显示小明应该付多少钱?
var shirt_price int = 35
var trousers_price int = 120
fmt.Printf("小明在该店买了3件T恤和2条裤子, 应该付: %d\n", shirt_price * 3 + trousers_price *2)
fmt.Printf("打8.8折: %.2f", 0.88 * float64(shirt_price * 3 + trousers_price *2))
运行：
小明在该店买了3件T恤和2条裤子, 应该付: 345
打8.8折: 303.60
练习4：如上题中打完8.8折后出现小数,商店为了结算方便,只收用户整数部分的钱,如本应收用户303.6,现在只收用户303元,应该如何做?
image-20210421083912216
(6) 强制类型转换总结
强制类型转换的语法格式：
数据类型名(待转换的值)
例如：
var a float64 = 3.123
var b int
b = int(a)
fmt.Printf("b=%d", b)
强制类型转换,数据类型一定要相兼容下面的写法对吗？
var a string
var b int
a = "3.14"
b = int(a)
fmt.Printf("b=%d", b)
谨记:int 转float强制转换,多小数
float转int强制转换,丢精度.
(7) 补充：关于“+”运算符，除了可以完成两个数字相加以外，也可以链接两个字符串，如下：
var str1 string = "abc"
var str2 string = "def"
fmt.Printf("%s", str1 + str2)
2：赋值运算符
关于赋值运算符前面我们已经使用过多次，赋值运算符 = ，
var num int =9
num = num + 1
这里的=号是赋值运算符,不是数学义意上的相等.
常见的赋值运算符如下，前面我们使用的=是普通赋值，+=，-=等我们称为“复合赋值运算符”
运算符 | 说明 | 示例 |
|---|---|---|
= | 普通赋值 | 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 |
3：关系运算符
关系运算符我们又称为比较运算符，听到比较这个词，大家想到的就是比较大小，例如：
大象的重量(1500)>老鼠的重量(1)
兔子的寿命(3)>乌龟的寿命(1000)
我的年龄(20)==你的年龄(20)
提问：比大比小的结果是什么？
结果是对或者是错，在GO语言中，怎样表示对于错呢？
关系运算的结果是布尔类型的。
bool值只有两个
- 真:true
- 假:false
GO语言中常见的关系运算符如下：
运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
== | 相等于 | 4 == 3 | false |
!= | 不等于 | 4 != 3 | true |
< | 小于 | 4 < 3 | false |
> | 大于 | 4 > 3 | true |
<= | 小于等于 | 4 <= 3 | false |
>= | 大于等于 | 4 >= 1 | true |
由以上关系运算符链接的表达式我们称为关系表达式。
关系运算符具体使用方式如下：
package main
import "fmt"
func main() {
var b bool
// 大象的重量(1500)>老鼠的重量(1)
b = 1500 > 1
fmt.Printf("大象的重量(1500)>老鼠的重量(1) 结果为： %t\n", b)
// 兔子的寿命(3)>乌龟的寿命(1000)
b = 3 > 1000
fmt.Printf("兔子的寿命(3)>乌龟的寿命(1000) 结果为： %t\n", b)
// 我的年龄(20)==你的年龄(20)
b = 20 == 20
fmt.Printf("我的年龄(20)==你的年龄(20) 结果为： %t\n", b)
}
执行如下：
大象的重量(1500)>老鼠的重量(1) 结果为： true
兔子的寿命(3)>乌龟的寿命(1000) 结果为： false
我的年龄(20)==你的年龄(20) 结果为： true
4：逻辑运算符
（1）常见的逻辑运算符如下：
运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
! | 非 | !a | 如果a为假，则!a为真；如果a为真，则!a为假。 |
&& | 与 | a && b | 如果a和b都为真，则结果为真，否则为假。 |
|| | 或 | a || b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。 |
有逻辑运算符连接的表达式叫做逻辑表达式
通过以上表格我们发现：逻辑表达式的结果同样也是bool类型
逻辑运算符两边放的一般都是关系表达式或者bool类型的值。
例如：
5>3 &&true
3>5||false
（2） 案例演示：
让用户输入老王的语文和数学成绩,输出以下判断是否正确,正确输出True,错误输出False
2.1) 老王的语文和数学成绩都大于90分
2.2) 语文和数学有一门是大于90分的
package main
import "fmt"
func main() {
// 让用户输入老王的语文和数学成绩,输出以下判断是否正确,正确输出True,错误输出False
var chinese, mathematics float64
fmt.Println("输入老王的语文成绩:")
fmt.Scan(&chinese)
fmt.Println("输入老王的数学成绩:")
fmt.Scan(&mathematics)
//2.1) 老王的语文和数学成绩都大于90分
if chinese > 90 && mathematics > 90 {
fmt.Println("老王的语文和数学成绩都大于90分")
}
//2.2) 语文和数学有一门是大于90分的
if chinese > 90 || mathematics > 90 {
println("语文和数学有一门是大于90分的")
}
}
执行如下：
image-20210422002732306
（3） 总结：
（3.1）逻辑与 &&
表达式1&&表达式2
表达式1 | 表达式2 | 表达式1&&表达式2 |
|---|---|---|
True | True | True |
False | True | False |
True | False | False |
False | False | false |
（3.2）逻辑或 ||
表达式1||表达式2
表达式1 | 表达式2 | 表达式1||表达式2 |
|---|---|---|
True | True | True |
True | False | True |
False | True | True |
False | False | false |
（3.3）逻辑非 !
!表达式
表达式 | !表达式 |
|---|---|
True | False |
False | true |
5：其他运算符
运算符 | 术语 | 示例 | 说明 |
|---|---|---|---|
& | 取地址运算符 | &a | 变量a的地址 |
* | 取值运算符 | *a | 指针变量a所指向内存的值 |
关于指针的应用，我们后面会重点给大家讲解，目前大家只需要掌握&
6：运算符优先级
（1）上面我们已经将运算符介绍完了，下面说一下它们的运算符优先级。
在Go语言中，一元运算符（一些只需要一个操作数的运算符称为一元运算符（或单目运算符）。）拥有最高的优先级，二元运算符的运算方向均是从左至右。
下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：
如下图所示：
优先级 | 运算符 |
|---|---|
7 | ^ ! |
6 | * / % << >> && ^ |
5 | + - | ^ |
4 | == != < <= >= > |
3 | <- |
2 | && |
1 | || |
上图中部分运算符现在没有讲解到，后期用到时再给大家具体讲解，目前大家需要掌握的是算术，赋值，关系，逻辑，取地址运算符。
（2）案例练习: 判断年份是否为闰年？
写下判断闰年的表达式,设待判断的年份变量为year.
闰年的判定(符合下面两个条件之一):
- 年份能够被400整除.(2000)
- 年份能够被4整除但不能被100整除.(2008)
让用户输入一个年份,如果是润年,则输出true,如果不是,则输出false.
2100/1600/1800/2009年是闰年吗？
package main
import "fmt"
func main() {
/**
写下判断闰年的表达式,设待判断的年份变量为year.
闰年的判定(符合下面两个条件之一):
- 年份能够被400整除.(2000)
- 年份能够被4整除但不能被100整除.(2008)
让用户输入一个年份,如果是润年,则输出true,如果不是,则输出false.
*/
var year int
fmt.Println("请输入年份：")
fmt.Scan(&year)
if year%400 == 0 || (year%4 == 0 && year%100 != 0) {
fmt.Printf("当前年份%d是闰年", year)
} else {
fmt.Printf("当前年份%d不是闰年", year)
}
}
执行如下：
image-20210422003734399
image-20210422003719092
注意：逻辑与的优先级要高于逻辑或。