Golang 运算符与数据处理

介绍

在编程语言中将数据保存到变量之后，我们应该如何处理这些数据呢？

这时我们就需要运算符（operators）对已保存的数据执行计算。在本节中，我们将学习以下内容：

知识点：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 赋值运算符

基本形式

算术运算符是最基础的运算符，代表了基本的计算方法。

在 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 进行了关系比较。

你可以修改变量值来改变比较结果，从而加深对关系运算符的理解。

逻辑运算符

什么是逻辑运算符？

逻辑运算符是关系运算符的高级形式。它们主要用于组合多个关系运算以进行进一步的评估。

在 opePractice.go 中编写以下代码：

package main

import (
    "fmt"
)

func main() {
    // 演示逻辑与运算符 &&
    var age int = 18
    if age > 15 && age < 30 {
        fmt.Println("年龄在 15 到 30 岁之间")
    }
    if age > 30 && age < 80 {
        fmt.Println("年龄在 30 到 80 岁之间")
    }
    // 演示逻辑或运算符 ||
    if age > 15 || age < 30 {
        fmt.Println("年龄大于 15 或小于 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("年龄大于 30 或小于 40")
    }
    // 演示逻辑非运算符 !
    if age > 30 {
        fmt.Println("年龄大于 30")
    }
    if !(age > 30) {
        fmt.Println("年龄不大于 30")
    }
}

在上面的代码中，我们基于变量 age 的值 18 执行了一系列逻辑评估。

运行代码：

cd ~/project
go run opePractice.go

你可以修改年龄变量的值并运行代码，观察输出的变化。

逻辑运算符的执行顺序

在使用逻辑与和逻辑或运算符时，Go 需要确定运算符两侧的布尔值。但哪一侧会先被评估呢？

让我们一起探索一下。

在 opePractice.go 中编写以下代码：

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("左侧函数被调用！")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("右侧函数被调用！")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("评估完成")
    }
}

运行代码：

cd ~/project
go run opePractice.go

左侧函数被调用！
右侧函数被调用！
评估完成

不难发现，在逻辑与运算中，先评估左侧操作数，然后再评估右侧操作数。

那么逻辑或运算呢？在 opePractice.go 中编写以下代码：

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("左侧函数被调用！")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("右侧函数被调用！")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("逻辑或评估完成")
    }
}

运行代码：

cd ~/project
go run opePractice.go

左侧函数被调用！
逻辑或评估完成

逻辑与和逻辑或运算的评估顺序都是从左到右。

然而，在逻辑或运算中，如果左侧操作数为真，则不会评估右侧操作数。这被称为「短路评估」。

因此，在实际开发中，我们应该将更有可能为真的条件放在逻辑或运算符的左侧，以减少程序的执行时间。

赋值运算符

在之前的实验中，我们经常使用赋值运算符。赋值运算符的核心功能是将表达式的值赋给左侧操作数。

左侧操作数（Left-hand Operand）：赋值运算符（=）左侧的表达式或变量，是可以被写入的。

在实际开发中，我们经常需要对一个变量进行加减操作。

根据我们所学的知识，我们可以这样写代码：

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 中使用运算符。我们演示了各种运算符及其用法。