介绍
在编程语言中,数据被保存到变量后,我们该如何处理它呢?
这时我们就需要运算符来对已保存的数据进行计算。在本节中,我们将学习以下内容:
知识点:
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值运算符
在编程语言中,数据被保存到变量后,我们该如何处理它呢?
这时我们就需要运算符来对已保存的数据进行计算。在本节中,我们将学习以下内容:
知识点:
算术运算符是最基础的运算符,代表了基本的计算方法。
运算符 | 功能 |
---|---|
+ |
加法 |
- |
减法 |
* |
乘法 |
/ |
除法 |
% |
取模(取余) |
在 home/project/
目录下创建一个名为 opePractice.go
的文件:
cd ~/project
touch opePractice.go
在其中编写以下代码:
package main
import "fmt"
func main() {
a := 10
b := 3
fmt.Println("a =", a, "b =", b)
fmt.Println("-----")
// 加法、减法和乘法
fmt.Println("a + b =", a+b)
fmt.Println("a - b =", a-b)
fmt.Println("b - a =", b-a)
fmt.Println("a * b =", a*b)
// 除法
// 在 Go 中,如果整数相除,结果会向下取整。
fmt.Println("a / b =", a/b)
// 但如果浮点数相除,则不会有这个问题。
fmt.Println("10.0 / 3 =", 10.0/3)
// 取模计算:一般形式
fmt.Println("a % b =", a%b)
// 带负数的取模计算
// 计算方法:余数 = 被除数 - (被除数 / 除数) * 除数
fmt.Println("10 % -3 =", 10%-3)
fmt.Println("-10 % 3 =", -10%3)
fmt.Println("-10 % -3 =", -10%-3)
}
运行代码,特别注意负数的取模计算方式。
cd ~/project
go run opePractice.go
a = 10 b = 3
-----
a + b = 13
a - b = 7
b - a = -7
a * b = 30
a / b = 3
10.0 / 3 = 3.3333333333333335
a % b = 1
10 % -3 = 1
-10 % 3 = -1
-10 % -3 = -1
在 Go 中,
++
(自增)和--
(自减)是独立的语句,只能单独使用;它们不是运算符。
以下代码是错误的:
var a int = 5
var i int = 0
a = i++ // 错误用法,自增只能单独使用
a = i-- // 错误用法,自减只能单独使用
a = ++i // 错误用法,Go 没有前置自增
a = --i // 错误用法,Go 没有前置自减
正确的语法是:
var i = 0
i++
i++
fmt.Println(i)
在 opePractice.go
中编写以下代码:
完成代码。使用自增运算符修改变量 i
的值,使得变量 a
的值变为 16:
package main
import "fmt"
func main() {
var a int = 15
var i int = 0
/* 在下方编写代码 */
a = a + i
fmt.Println(a)
// 完成代码,使得 a 的输出等于 16
}
什么是关系运算符?
关系运算符是一种比较形式,用于描述两个值之间的关系。它们判断两个值是否相等,或者一个值是否大于或小于另一个值。
运算符 | 关系 |
---|---|
== |
等于 |
!= |
不等于 |
> |
大于 |
>= |
大于或等于 |
< |
小于 |
<= |
小于或等于 |
如果条件成立,上述运算符会返回
true
,否则返回false
。
在 opePractice.go
中编写以下代码:
package main
import "fmt"
func main() {
// 使用关系运算符
var a int = 7
var b int = 6
// 检查是否相等
fmt.Println(a == b) //false
// 检查是否不相等
fmt.Println(a != b) //true
// 检查 a 是否大于 b
fmt.Println(a > b) //true
// 检查 a 是否大于或等于 b
fmt.Println(a >= b) //true
// 检查 a 是否小于 b
fmt.Println(a < b) //false
// 检查 a 是否小于或等于 b
fmt.Println(a <= b) //false
// 检查 1 是否等于 1
judgeValue := 1 == 1 //true
fmt.Println(judgeValue)
}
运行代码:
cd ~/project
go run opePractice.go
在上述代码中,我们基于变量 a
和 b
进行了关系比较。
学生可以修改变量的值来改变比较结果,从而更深入地理解关系运算符。
什么是逻辑运算符?
逻辑运算符是关系运算符的高级形式。它们主要用于组合关系运算符以进行进一步评估。
运算符 | 关系 | 解释 |
---|---|---|
&& |
与(And) | 如果两个操作数都为 true ,结果为 true |
|| |
或(Or) | 如果任一操作数为 true ,结果为 true |
! |
非(Not) | 如果条件为 false ,结果为 true |
在 opePractice.go
中编写以下代码:
package main
import (
"fmt"
)
func main() {
// 演示逻辑与运算符 &&
var age int = 18
if age > 15 && age < 30 {
fmt.Println("Age is between 15 and 30")
}
if age > 30 && age < 80 {
fmt.Println("Age is between 30 and 80")
}
// 演示逻辑或运算符 ||
if age > 15 || age < 30 {
fmt.Println("Age is greater than 15 or less than 30")
}
if age > 30 || age < 40 {
fmt.Println("Age is greater than 30 or less than 40")
}
// 演示逻辑非运算符 !
if age > 30 {
fmt.Println("Age is greater than 30")
}
if !(age > 30) {
fmt.Println("Age is not greater than 30")
}
}
在上述代码中,我们基于变量 age
的值为 18
进行了一系列逻辑评估。
运行代码:
cd ~/project
go run opePractice.go
学生可以修改 age
变量的值并运行代码,观察输出的变化。
在使用逻辑与(AND)和逻辑或(OR)运算符时,Go 需要确定运算符两侧的布尔值。但哪一侧会先被评估呢?
让我们一起来探索。
在 opePractice.go
中编写以下代码:
package main
import "fmt"
func leftFunc(flag bool) bool {
fmt.Println("Left function is called!")
return flag
}
func rightFunc(flag bool) bool {
fmt.Println("Right function is called!")
return true
}
func main() {
if leftFunc(true) && rightFunc(true) {
fmt.Println("Evaluation is complete")
}
}
运行代码:
cd ~/project
go run opePractice.go
Left function is called!
Right function is called!
Evaluation is complete
不难发现,在逻辑与操作中,左侧操作数会先被评估,然后才是右侧操作数。
那么逻辑或操作呢?在 opePractice.go
中编写以下代码:
package main
import "fmt"
func leftFunc(flag bool) bool {
fmt.Println("Left function is called!")
return flag
}
func rightFunc(flag bool) bool {
fmt.Println("Right function is called!")
return true
}
func main() {
if leftFunc(true) || rightFunc(true) {
fmt.Println("Logical OR evaluation is complete")
}
}
运行代码:
cd ~/project
go run opePractice.go
Left function is called!
Logical OR evaluation is complete
逻辑与和逻辑或操作的评估顺序都是从左到右。
然而,在逻辑或操作中,如果左侧操作数为 true
,则右侧操作数不会被评估。
因此,在实际开发中,我们应该将更可能为 true
的条件放在逻辑或运算符的左侧,以减少程序的执行时间。
在之前的实验中,我们经常使用赋值运算符。赋值运算符的核心功能是将表达式的值赋给左侧的操作数。
左侧操作数:赋值运算符(=)左侧的表达式或变量,可以被写入。
在实际开发中,我们经常需要将一个变量与另一个变量相加或相减。
根据我们所学的内容,我们可以编写如下代码:
x = x + 1
但这种代码在实际开发中非常常见,因此我们提供了它的简写形式:
x += 1
同样,常用的赋值运算符包括:
运算符 | 描述 |
---|---|
= |
基本赋值运算符 |
+= |
加并赋值 |
-= |
减并赋值 |
*= |
乘并赋值 |
/= |
除并赋值 |
%= |
取模并赋值(取余) |
在 opePractice.go
中编写以下代码:
package main
import "fmt"
func main() {
x := 11
fmt.Println("x 的初始值:", x)
x += 5 // x = x + 5
fmt.Println("x += 5 后的值:", x)
x -= 5 // x = x - 5
fmt.Println("x -= 5 后的值:", x)
x *= 5 // x = x * 5
fmt.Println("x *= 5 后的值:", x)
x /= 5
fmt.Println("x /= 5 后的值:", x)
x %= 3
fmt.Println("x %= 3 后的值:", x)
}
在上述代码中,我们为变量 x
赋初始值 11
,并执行基本的算术运算(加法、减法、乘法)、除法和取模计算。
运行代码:
cd ~/project
go run opePractice.go
你可以修改变量的值,观察赋值运算符的工作原理。
让我们回顾一下在本实验中学到的内容:
在本实验中,我们讨论了如何在 Go 中使用运算符。我们演示了各种运算符及其用法。