使用 Go 语言运算符进行数据处理

GolangGolangBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

在编程语言中,数据被保存到变量后,我们该如何处理它呢?

这时我们就需要运算符来对已保存的数据进行计算。在本节中,我们将学习以下内容:

知识点:

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

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL go(("`Golang`")) -.-> go/BasicsGroup(["`Basics`"]) go(("`Golang`")) -.-> go/FunctionsandControlFlowGroup(["`Functions and Control Flow`"]) go/BasicsGroup -.-> go/variables("`Variables`") go/FunctionsandControlFlowGroup -.-> go/for("`For`") go/FunctionsandControlFlowGroup -.-> go/if_else("`If Else`") go/FunctionsandControlFlowGroup -.-> go/functions("`Functions`") subgraph Lab Skills go/variables -.-> lab-149066{{"`使用 Go 语言运算符进行数据处理`"}} go/for -.-> lab-149066{{"`使用 Go 语言运算符进行数据处理`"}} go/if_else -.-> lab-149066{{"`使用 Go 语言运算符进行数据处理`"}} go/functions -.-> lab-149066{{"`使用 Go 语言运算符进行数据处理`"}} end

基本形式

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

运算符 功能
+ 加法
- 减法
* 乘法
/ 除法
% 取模(取余)

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

在上述代码中,我们基于变量 ab 进行了关系比较。

学生可以修改变量的值来改变比较结果,从而更深入地理解关系运算符。

逻辑运算符

什么是逻辑运算符?

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

运算符 关系 解释
&& 与(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 中使用运算符。我们演示了各种运算符及其用法。

您可能感兴趣的其他 Golang 教程