Как сделать математику в Go с операторами

Вступление

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

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

Мы будем работать с двумя наиболее часто используемыми в Go числовыми значениямиdata types,integers иfloats:

Integers - целые числа, которые могут быть положительными, отрицательными или 0 (…,-1,0,1,…).
Floats - это действительные числа, содержащие десятичную точку, например9.0 или-2.25 ..

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

операторы

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

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

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

операция Что это возвращает

операция	Что это возвращает
`x + y`	Сумма`x` и`y`
`x - y`	Разница`x` и`y`
`-x`	Изменен знак`x`
`+x`	Идентичность`x`
`x * y`	Произведение`x` и`y`
`x / y`	Соотношение`x` и`y`
`x % y`	Остаток`x` /`y`

x + y

Суммаx иy

x - y

Разницаx иy

-x

Изменен знакx

+x

Идентичностьx

x * y

Произведениеx иy

x / y

Соотношениеx иy

x % y

Остатокx /y

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

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

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

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

fmt.Println(1 + 5)

Output6

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

a := 88
b := 103

fmt.Println(a + b)

Output191

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

c := -36
d := 25

fmt.Println(c + d)

Output-11

Дополнение будет вести себя аналогично с поплавками:

e := 5.5
f := 2.5

fmt.Println(e + f)

Output8

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

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

Output8.00

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

g := 75.67
h := 32.0

fmt.Println(g - h)

Output43.67

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

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

Outputi + j (mismatched types int and float64)

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

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

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

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

i := 3.3
fmt.Println(+i)

Output3.3

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

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

Output-19

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

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

k := 3.3
fmt.Println(-k)

Output-3.3

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

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

Output19

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

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

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

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

k := 100.2
l := 10.2

fmt.Println(k * l)

Output1022.04

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

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

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

package main

import (
    "fmt"
)

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

    fmt.Println(m / n)
}

Output13

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

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

package main

import (
    "fmt"
)

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

Output13.333333333333334

Модульное

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

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

o := 85
p := 15

fmt.Println(o % p)

Output10

Чтобы разбить это,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)
}

Output4

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

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

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

u = 10 + 10 * 5

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

Output60

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

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

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

Output100

Один из способов запомнить порядок действий - использовать акронимPEMDAS:

порядок	Письмо	Стенды для
1	P	Скобки
2	E	экспонент
3	M	умножение
4	D	разделение
5	A	прибавление
6	S	Вычитание

порядок

Письмо

Стенды для

Скобки

экспонент

умножение

разделение

прибавление

Вычитание

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

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

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

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

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

Output6

Сначала мы устанавливаем переменную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)
    }

}

Output0
2
4
6
8
10
12

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

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

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

y += 1

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

y -= 1

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

y *= 2

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

y /= 3

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

y %= 3

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

Заключение

В этом руководстве рассматриваются многие операторы, которые вы будете использовать с целочисленными и числовыми типами данных с плавающей запятой. Вы можете узнать больше о различных типах данных вUnderstanding Data Types in Go иHow To Convert Data Types.

TOC