介绍

数字在编程中很常见,它们被用来表示诸如:屏幕大小的尺寸,地理位置,金钱和点,在视频中度过的时间,游戏动画的位置,通过分配数字代码的颜色等等。

有效地在编程中执行数学操作是要发展的重要技能,因为你会经常使用数字工作. 虽然对数学的高级别的理解可以帮助你成为一个更好的程序员,但这不是一个前提条件。

我们将使用 Go 最常用的两个数值类型(https://andsky.com/tech/tutorials/understanding-data-types-in-go), integers 和 floats:

• Integers是可以是正数,负数,或0(..., -1, 0, 1,...)的整数。

本教程将审查我们可以在Go中使用数字数据类型的操作员。

运营商

一个 operator 是一个符号或函数,表示一个操作.例如,在数学中,加符号或 + 是指加的操作器。

在Go中,我们将看到一些熟悉的运算符,这些运算符来自数学,但我们将使用的其他运算符是专门用于计算机编程的。

以下是Go中的数学相关运算器的快速参考表,我们将在本教程中涵盖以下所有操作。

行动 返回什么 返回什么 | -- -- -- -- -- x + y' x ' 和y ' 的合计 x-y' 与`y'的差别

• -x ' 更改了x'的标志 | ××××××××××××××××××××××××××××××××××××××××××年×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× | ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× x/y' x'和y'的引文 X% y' X'/y' 的剩余部分 X' /y' `| '

我们还将涵盖复合分配运算符,包括+=和*=,这些运算符将算术运算符与=运算符相结合。

添加和抽取

在Go中,加和减操作器就像在数学中一样运行,事实上,你可以使用Go编程语言作为计算机。

让我们看看一些例子,从整数开始:

1fmt.Println(1 + 5)

1[secondary_label Output]
26

而不是直接将整数传入fmt.Println语句中,我们可以使用如下语法来初始化变量来表示整数值:

1a := 88
2b := 103
3
4fmt.Println(a + b)

1[secondary_label Output]
2191

由于整数既可以是正数又可以是负数(以及0),我们可以将负数加上正数:

1c := -36
2d := 25
3
4fmt.Println(c + d)

1[secondary_label Output]
2-11

添加将与浮动行为类似:

1e := 5.5
2f := 2.5
3
4fmt.Println(e + f)

1[secondary_label Output]
28

由于我们一起添加了两个浮点,所以Go 返回了一个浮点值以十进制位置。然而,由于十进制位置在这种情况下为零,所以 `fmt.Println 放弃了十进制格式化。

1fmt.Printf("%.2f", e + f)

1[secondary_label Output]
28.00

提取语法与添加语法相同,除非我们从加号(+)更改为减号(-):

1g := 75.67
2h := 32.0
3
4fmt.Println(g - h)

1[secondary_label Output]
243.67

在 Go 中,我们只能在相同的 data types 上使用运算符. 我们不能添加一个 int 和一个 float64:

1i := 7
2j := 7.0
3fmt.Println(i + j)

1[secondary_label Output]
2i + j (mismatched types int and float64)

尝试在不相同的数据类型上使用运算符会导致编译器错误。

Unary 算法操作

一个统一的数学表达式仅由一个组件或元素组成,在Go中,我们可以使用加和减的符号作为一个单一的元素,并与一个值相配:返回值的身份(+),或者更改值的符号(-)。

虽然不常用,但加值符号表示值的身份,我们可以用加值符号用正值:

1i := 3.3
2fmt.Println(+i)

1[secondary_label Output]
23.3

当我们使用负值的加值符号时,它也会返回该值的身份,在这种情况下,它将是一个负值:

1j := -19
2fmt.Println(+j)

1[secondary_label Output]
2-19

负值时,加值表示返回相同的负值。

但是, minus 符号会改变一个值的符号,所以当我们通过一个正值时,我们会发现值之前的 minus 符号会返回一个负值:

1k := 3.3
2fmt.Println(-k)

1[secondary_label Output]
2-3.3

或者,当我们使用负值的减数符号 unary 运算符时,将返回一个正值:

1j := -19
2fmt.Println(-j)

1[secondary_label Output]
219

由加值符号和减值符号表示的单数算法操作将返回值的身份在+i的情况下,或值的相反符号在-i的情况下。

倍增和分裂

像增加和减去一样,倍增和分割将看起来非常类似于他们在数学中所做的事情,我们在Go中使用的符号是*,我们将使用的符号是/。

以下是使用两个浮动值在Go中执行倍增的例子:

1k := 100.2
2l := 10.2
3
4fmt.Println(k * l)

1[secondary_label Output]
21022.04

在Go中,分割有不同的特征,取决于我们正在分割的数字类型。

如果我们正在分整数,Go的 / 运算符执行地面分割,而对于数 x ,返回的数目是最大的整数小于或等于 ** x** 。

如果您运行下面的分割例子 80 / 6,则将收到 13 作为输出,数据类型将是 int:

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7func main() {
 8    m := 80
 9    n := 6
10
11    fmt.Println(m / n)
12}

1[secondary_label Output]
213

如果所需的输出是浮动,则必须在分割之前明确转换值。

您可以通过围绕您的值包装您想要的浮动类型 float32() 或 float64():

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7func main() {
 8    s := 80
 9    t := 6
10    r := float64(s) / float64(t)
11    fmt.Println(r)
12}

1[secondary_label Output]
213.333333333333334

◎ 模块

%运算符是 modulo,该运算符返回剩余值,而不是分裂后的量子数,这对于找到相同数的倍数是有用的。

让我们来看看模块的例子:

1o := 85
2p := 15
3
4fmt.Println(o % p)

1[secondary_label Output]
210

要打破这一点,‘85’分为‘15’返回‘5’的系数与‘10’的剩余值. 我们的程序在这里返回‘10’的值,因为模块运算器返回一个划分表达式的剩余值。

要使用「float64」数据类型进行模块数学,您将使用来自「math」包的「Mod」函数:

 1package main
 2
 3import (
 4    "fmt"
 5    "math"
 6)
 7
 8func main() {
 9    q := 36.0
10    r := 8.0
11
12    s := math.Mod(q, r)
13
14    fmt.Println(s)
15}

1[secondary_label Output]
24

操作员优先级

在Go中,就像在数学中一样,我们需要记住,操作员将以优先顺序进行评估,而不是从左到右或从右到左。

让我们来看看以下数学表达式:

1u = 10 + 10 * 5

我们可以从左到右读取它,但首先会进行倍数,所以如果我们打印u,我们会得到以下值:

1[secondary_label Output]
260

这是因为10 * 5评级为50,然后我们添加10,以返回60作为最终结果。

如果相反,我们想将值10添加到10,然后以5来倍数,我们在Go中会像在数学中那样使用关节:

1u := (10 + 10) * 5
2fmt.Println(u)

1[secondary_label Output]
2100

记住操作顺序的一种方式是通过缩写 PEMDAS :

您可能熟悉操作顺序的另一个缩写,例如 BEDMAS 或 ** BODMAS** . 无论缩写最适合您,请尝试在执行 Go 中的数学操作时记住这一点,以便返回您期望的结果。

分配运营商

最常见的分配运算器是您已经使用的运算器:等于字符 =. = 分配运算器将右侧的值分配给左侧的变量.例如, v = 23 将整数 23 的值分配给变量 v。

在编程时,通常使用复合分配操作器来执行变量值的操作,然后将结果的新值分配给该变量。这些复合操作器将一个算术操作器与=操作器相结合,因此,我们将加上+和=来获得+=复合操作器。

1w := 5
2w += 1
3fmt.Println(w)

1[secondary_label Output]
26

首先,我们将变量w设置为5的值,然后使用+=复合分配运算器将正确的数字添加到左变量的值,然后将结果分配到w。

在for循环中,常用复合分配运算器,当你想重复一个过程几次时,你会使用它们:

 1package main
 2
 3import "fmt"
 4
 5func main() {
 6
 7    values := []int{0, 1, 2, 3, 4, 5, 6}
 8
 9    for _, x := range values {
10
11    	w := x
12
13    	w *= 2
14
15    	fmt.Println(w)
16    }
17
18}

1[secondary_label Output]
20
32
44
56
68
710
812

通过使用for循环重复称为值的切片,您可以自动化*=运算符的过程,该运算符将变量w乘以数字2,然后将结果分配回变量w中。

Go 为本教程中讨论的每个算术运算符提供一个复合分配运算符。

添加后分配值:

1y += 1

然后将值分割到以下值:

1y -= 1

若要倍增,然后分配值:

1y *= 2

然后分割,分配值:

1y /= 3

返回剩余值,然后分配值:

1y %= 3

复合分配运算器在需要逐步增加或减少事物或需要在程序中自动化某些流程时可能有用。

结论

本教程涵盖了您将使用的整数和浮动数字数据类型中的许多运算符,您可以在 理解 Go 中的数据类型和 如何转换数据类型中了解有关不同数据类型的更多信息。