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

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

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

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

  • Целые числа – это числа, которые могут быть положительными, отрицательными или 0 (…, -1, 0, 1,…).
  • Числа с плавающей точкой – это действительные числа, содержащие десятичную точку, например 9,0 или -2,25.

Читайте также: Основные типы данных в Go

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

Операторы

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

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

Вот краткая справочная таблица математических операторов в Go. Мы рассмотрим в этом руководстве все следующие операции.

Операция Результат
x + y Сумма х и у
x — y Разница между х и у
-x Меняет знак х
+x Преобразование значения х в число
x * y Произведение х и у
x / y Отношение х к у
x % y Остаток х / у

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

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

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

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

fmt.Println(1 + 5)
6

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

a := 88
b := 103
fmt.Println(a + b)
191

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

c := -36
d := 25
fmt.Println(c + d)
-11

Сложение аналогично происходит и с числами с плавающей точкой:

e := 5.5
f := 2.5
fmt.Println(e + f)
8

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

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

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

g := 75.67
h := 32.0
fmt.Println(g - h)
43.67

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

i := 7
j := 7.0
fmt.Println(i + j)
i + j (mismatched types int and float64)

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

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

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

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

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

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

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

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

А унарный минус меняет знак значения. Итак, если мы передадим положительное значение, то знак минус перед значением вернет отрицательное значение:

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

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

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

Унарные арифметические операторы плюс и минус возвращают число и меняют знак на противоположный.

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

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

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

k := 100.2
l := 10.2
fmt.Println(k * l)
1022.04

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

При делении целых чисел оператор / выполняет деление floor, где для частного x возвращается наибольшее целое число, меньшее или равное x.

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

package main
import (
"fmt"
)
func main() {
m := 80
n := 6
fmt.Println(m / n)
}
13

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

Вы можете сделать это, заключив значения в float32() или float64():

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

Модуль

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

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

o := 85
p := 15
fmt.Println(o % p)
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)
}
4

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

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

К примеру:

u = 10 + 10 * 5

Сначала выполняется умножение (10*5=50), а затем сложение (10+50). Потому результат будет такой:

60

Чтобы сначала выполнить операцию сложения, а затем умножить полученный результат на 5, нужно взять сложение в скобки:

u = (10 + 10) * 5
print(u)
100

Математические операции имеют такой приоритет:

Порядок Буква Значение
1 P Parentheses (выражение в скобках)
2 E Exponent (экспоненты)
3 M Multiplication (умножение)
4 D Division (деление)
5 A Addition (сложение)
6 S Subtraction (вычитание)

Его можно запомнить по акрониму PEMDAS.

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

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

Наиболее распространённым оператором присваивания является знак равенства (=). Он присваивает переменной слева значение справа. К примеру, в выражении v = 23 переменной v было присвоено значение 23.

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

w := 5
w += 1
fmt.Println(w)
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)
}
}
0
2
4
6
8
10
12

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

В Go есть составные операторы присваивания для каждой математической операции:

  • y += 1 (сложение и присваивание)
  • y -= 1 (вычитание и присваивание)
  • y *= 2 (умножение и присваивание)
  • y /= 3 (деление и присваивание)
  • y %= 3 (вывод остатка и присваивание)

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

Заключение

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

Читайте также:

Tags: ,