Выполнение математических операций в Go с помощью операторов

Введение

Числа используются повсюду в программировании. Они используются для представления таких вещей, как размеры экрана, географическое местоположение, денежные средства и баллы, количество времени, передаваемого в видео, расположение игровых аватаров, отображение цветов через присвоение числовых кодов и т. д.

Эффективное выполнение математических операций в программировании является важным навыком, который необходимо развивать, поскольку вы очень часто будете работать с числами. Хотя понимание математических операций на высоком уровне может помочь вам стать более профессиональным программистом, это не является обязательным условием. Если у вас нет опыта работы с математическими операциями, попробуйте посмотреть на математику как на инструмент, с помощью которого вы можете добиться того, чего хотите, и как на способ улучшить ваше логическое мышление.

Мы будем работать с двумя наиболее используемыми типами данных Go, int и float:

• Int — это целое число, которое может быть положительным, отрицательным или 0 (… -1,0, 1…).
• Float — вещественные числа с десятичными дробями, например, 9,0 или -2,25.

В этом обучающем руководстве мы изучим операторы, которые мы можем использовать с числовыми типами данных в Go.

Операторы

Оператор — это символ или функция, указывающая операцию. Например, в математике значок плюс или + — это оператор сложения.

В Go мы увидим несколько похожих операторов, которые взяты из математики. Однако другие операторы, которые мы будем использовать, принадлежат только к компьютерному программированию.

Здесь вы можете найти таблицу с математическими операторами в Go. Мы рассмотрим все эти операторы в рамках данного руководства.

Также мы рассмотрим составные операторы присваивания, включая += и *=, которые совмещают арифметический оператор с оператором =.

Сложение и вычитание

В Go операторы сложения и вычитания работают так же, как и в математике. По сути, вы можете использовать язык программирования Go как калькулятор.

Давайте рассмотрим несколько примеров, начиная с целых чисел:

fmt.Println(1 + 5)

Output
6

Вместо передачи целых чисел прямо в оператор fmt.Println мы можем инициализировать переменные для хранения целочисленных значений, используя следующий синтаксис:

a := 88
b := 103

fmt.Println(a + b)

Output
191

Поскольку целые числа могут быть как положительными, так и отрицательными (как и 0), мы можем добавить отрицательное число к положительному:

c := -36
d := 25

fmt.Println(c + d)

Output
-11

Сложение будет работать аналогичным образом для чисел с плавающей точкой:

e := 5.5
f := 2.5

fmt.Println(e + f)

Output
8

Поскольку мы складывали два числа с типом float, Go возвращает float с дробной частью. Однако, поскольку в этом случае десятичная часть равна 0, fmt.Println опускает десятичную часть. Чтобы надлежащим образом настроить формат вывода, мы будем использовать fmt.Printf​​​ с %.2f для форматирования числа с двумя знаками после запятой, как это показано в данном примере:

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

Output
8.00

Синтаксис для вычитания аналогичен сложению, кроме того, что мы изменяем оператор со знака плюс (+) на знак минус (-):

g := 75.67
h := 32.0

fmt.Println(g - h)

Output
43.67

В Go мы можем использовать операторы только для одинаковых типов данных. Мы не можем складывать int и float64:

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

Output
i + j (mismatched types int and float64)

При попытке использовать операторы с типами данных, не являющимися одинаковыми, вы получите ошибку компиляции.

Унарные арифметические операторы

Унарные математические выражения включают только один компонент или элемент. В Go мы можем использовать знаки плюс и минус как один элемент со значением, в частности, для возврата тождественности значения (+) или изменения знака значения (-).

Хотя обычно это не используется, значок плюс указывает тождественность значения. Мы можем использовать знак плюс с положительными значениями:

i := 3.3
fmt.Println(+i)

Output
3.3

Когда мы используем знак плюс с отрицательным значением, он будет возвращать тождественность этого значения, а в данном случае это будет отрицательное значение:

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

Output
-19

При отрицательном значении знак плюс возвращает то же самое отрицательное значение.

Знак минус, однако, изменяет знак значения. Поэтому при передаче положительного значения мы обнаружим, что знак минус, который идет перед значением, будет возвращать отрицательное значение:

k := 3.3
fmt.Println(-k)

Output
-3.3

Также, когда мы используем унарный минус с отрицательным значением, будет возвращаться положительное значение:

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

Output
19

Унарные арифметические операции со знаком плюс и знаком минус возвращают либо тождественность значения в случае +i или значение с противоположным знаком в случае -i​​​.

Умножение и деление

Как и сложение и вычитание, умножение и деление будут выглядеть примерно так, как в математике. Знак, который мы используем в Go для умножения — это *, а знак, который мы используем для деления — это /.

Здесь приведен пример выполнения умножения в Go двух чисел с плавающей запятой:

k := 100.2
l := 10.2

fmt.Println(k * l)

Output
1022.04

В Go деление имеет разные характеристики в зависимости от типа числового значения, на которое мы делим.

Если мы делим целые числа, оператор / Go выполняет обычное деление, где для целой части x возвращаемое число — это самое большое число, которое меньше или равно x.

Если вы запустите следующий пример с делением 80 / 6, вы получите 13 в качестве результата, а типом данных будет int:

package main

import (
	"fmt"
)

func main() {
	m := 80
	n := 6

	fmt.Println(m / n)
}

Output
13

Если желаемый результат вывода — float, вы должны явно преобразовывать значения, прежде чем выполнять деление.

Вы можете сделать это, обернув желаемый тип float32()​​​ или float64() вокруг ваших значений:

package main

import (
	"fmt"
)

func main() {
	s := 80
	t := 6
	r := float64(s) / float64(t)
	fmt.Println(r)
}

Output
13.333333333333334

Модуль

Оператор % — это модуль, который возвращает остаток, а не целую часть после деления. Это полезно для получения чисел, умножающихся на одно и то же число.

Давайте рассмотрим пример модуля:

o := 85
p := 15

fmt.Println(o % p)

Output
10

Например, 85 при делении на 15 возвращает целое число 5 с остатком 10. Наша программа возвращает значение 10, поскольку оператор модуля возвращает остаток от деления.

Для выполнения вычисления модуля с типом данных float64 вы будете использовать функцию Mod из пакета math:

package main

import (
	"fmt"
	"math"
)

func main() {
	q := 36.0
	r := 8.0

	s := math.Mod(q, r)

	fmt.Println(s)
}

Output
4

Приоритет операций

В Go, как и в математике, мы должны помнить, что операторы будут оцениваться по порядку приоритета, а не в порядке слева направо или справа налево.

Если мы рассмотрим следующее математическое выражение:

u = 10 + 10 * 5

Мы можем прочитать его слева направо, но сначала будет выполняться умножение, так что если бы мы выводили u, то получили бы следующее значение:

Output
60

Это объясняется тем, что 10 * 5 дает 50, а затем мы добавляем 10 для получения 60 в качестве результата.

Если же мы хотим добавить значение 10 к 10, а затем умножить сумму на 5, нужно использовать скобки в Go, как это делается в математике:

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

Output
100

Одним из способов, с помощью которого можно запомнить порядок операций, является акроним PEMDAS:

Вы можете быть знакомы с другим акронимом для порядка операций, например, BEDMAS или BODMAS. Какой бы акроним вам ни подошел, попробуйте держать его в уме, когда вы будете выполнять математические операции в Go, чтобы получить результаты, которые вы ожидаете.

Операторы присвоения

Самый распространенный оператор присвоения — это тот, который вы уже использовали: знак равенства =. Оператор присвоения = присваивает значение справа переменной слева. Например, v = 23 присваивает значение 23 переменной v.

При программировании обычно используются составные операторы присвоения, выполняющие операцию со значением переменной, а затем присваивают новое полученное значение этой переменной. Эти составные операторы объединяют арифметические операторы с опертором =. Поэтому для сложения мы соединим + и = для получения составного оператора +=. Давайте посмотрим, как это выглядит:

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

Output
6

Во-первых, мы зададим переменную w равной 5, а затем используем составной оператор += для добавления нужного числа переменной слева, а затем присвоим результат переменной w.

Составные операторы присвоения используются в циклах for, которые вы используете, когда хотите повторить процесс несколько раз:

package main

import "fmt"

func main() {

	values := []int{0, 1, 2, 3, 4, 5, 6}

	for _, x := range values {

		w := x

		w *= 2

		fmt.Println(w)
	}

}

Output
0
2
4
6
8
10
12

Используя цикл for для прохождения по срезу values, вы можете автоматизировать процесс для оператора *=, который умножает переменную w на число 2, а затем присваивает результат переменной w.

Go имеет составной оператор присвоения для каждого из арифметических операторов, описанных в этом обучающем руководстве.

Чтобы добавить, а затем присвоить значение:

y += 1

Чтобы вычесть, а затем присвоить значение:

y -= 1

Чтобы умножить, а затем присвоить значение:

y *= 2

Чтобы разделить, а затем присвоить значение:

y /= 3

Чтобы вернуть остаток, а затем присвоить значение:

y %= 3

Составные операторы присвоения могут быть полезными, когда нужно инкрементировать или декрементировать значение, или при необходимости автоматизировать определенные процессы в вашей программе.

Заключение

В этом обучающем руководстве мы познакомились с множеством операторов, которые вы будете использовать с целыми числами или числами с плавающей точкой. Вы можете узнать больше о разных типах данных в статьях Знакомство с типами данных в Go и Конвертация типов данных.