Операции с числами – неотъемлемая часть программирования. Числа используются для представления многих вещей: размеров экрана, географического положения, суммы денег, продолжительности видео, позиции игровых аватаров, цвета при назначении числовых кодов и т. д.
Эффективное выполнение математических операций в программировании – это важный навык, который необходимо развивать, потому что с числами вы будете работать часто. Хорошие знания математики, безусловно, пригодятся вам, чтобы стать хорошим программистом, но это условие не является обязательным. Если в математике вы не так сильны, как хотелось бы, постарайтесь думать о математике как о инструменте для достижения вашей цели и как о способе улучшить ваше логическое мышление.
В этом мануале мы будем работать с двумя наиболее используемыми числовыми типами данных 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 (вывод остатка и присваивание)
Составные операторы присваивания могут быть полезны, когда значения нужно постепенно увеличивать или уменьшать или если вам нужно автоматизировать определенные процессы в программе.
Заключение
В этом мануале рассматриваются многие операторы, которые можно использовать с числовыми типами данных.
Читайте также: