Обработка данных с помощью операторов в Golang

Введение

После того как данные сохранены в переменных, как нам их обрабатывать?

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

Основные темы:

Арифметические операторы
Операторы сравнения (реляционные)
Логические операторы
Операторы присваивания

Базовые арифметические операции

Арифметические операторы являются самыми фундаментальными и представляют собой основные методы вычислений.

Оператор	Функция
`+`	Сложение
`-`	Вычитание
`*`	Умножение
`/`	Деление
`%`	Остаток от деления

Создайте файл с именем opePractice.go в директории home/project/:

cd ~/project
touch opePractice.go

Напишите в нем следующий код:

package main

import "fmt"

func main() {
    a := 10
    b := 3
    fmt.Println("a =", a, "b =", b)
    fmt.Println("-----")

    // Сложение, вычитание и умножение
    fmt.Println("a + b =", a+b)
    fmt.Println("a - b =", a-b)
    fmt.Println("b - a =", b-a)
    fmt.Println("a * b =", a*b)

    // Деление
    // В Go при делении целых чисел результат округляется вниз.
    fmt.Println("a / b =", a/b)
    // Но если делится число с плавающей точкой, такой проблемы не возникнет.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Вычисление остатка: общая форма
    fmt.Println("a % b =", a%b)
    // Вычисление остатка с отрицательными числами
    // Метод расчета: остаток = делимое - (делимое / делитель) * делитель
    fmt.Println("10 % -3 =", 10%-3)
    fmt.Println("-10 % 3 =", -10%3)
    fmt.Println("-10 % -3 =", -10%-3)
}

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

cd ~/project
go run opePractice.go

a = 10 b = 3
-----
a + b = 13
a - b = 7
b - a = -7
a * b = 30
a / b = 3
10.0 / 3 = 3.3333333333333335
a % b = 1
10 % -3 = 1
-10 % 3 = -1
-10 % -3 = -1

Операторы инкремента и декремента

В Go ++ (инкремент) и -- (декремент) являются самостоятельными инструкциями и могут использоваться только независимо; они не являются операторами в составе выражений.

Следующий код является некорректным:

var a int = 5
var i int = 0
a = i++ // Ошибка: инкремент можно использовать только как отдельную инструкцию
a = i-- // Ошибка: декремент можно использовать только как отдельную инструкцию
a = ++i // Ошибка: в Go нет префиксного инкремента
a = --i // Ошибка: в Go нет префиксного декремента

Правильный синтаксис:

var i = 0
i++
i++
fmt.Println(i)

Напишите следующий код в opePractice.go:

Дополните код. Измените значение переменной i с помощью оператора инкремента так, чтобы значение переменной a стало равным 16:

package main

import "fmt"

func main() {
    var a int = 15
    var i int = 0
    /* Напишите код ниже */

    a = a + i
    fmt.Println(a)
    // Дополните код, чтобы вывод переменной a был равен 16
}

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

Что такое операторы сравнения (реляционные операторы)?

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

Оператор	Отношение
`==`	Равно
`!=`	Не равно
`>`	Больше
`>=`	Больше или равно
`<`	Меньше
`<=`	Меньше или равно

Вышеуказанные операторы возвращают true, если условие выполняется, и false в противном случае.

Напишите следующий код в opePractice.go:

package main

import "fmt"

func main() {
    // Использование операторов сравнения
    var a int = 7
    var b int = 6
    // Проверка на равенство
    fmt.Println(a == b)  //false
    // Проверка на неравенство
    fmt.Println(a != b)  //true
    // Проверка: a больше b
    fmt.Println(a > b)   //true
    // Проверка: a больше или равно b
    fmt.Println(a >= b)  //true
    // Проверка: a меньше b
    fmt.Println(a < b)   //false
    // Проверка: a меньше или равно b
    fmt.Println(a <= b)  //false
    // Проверка: 1 равно 1
    judgeValue := 1 == 1 //true
    fmt.Println(judgeValue)
}

Запустите код:

cd ~/project
go run opePractice.go

В приведенном выше коде мы выполнили сравнения на основе переменных a и b.

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

Логические операторы

Что такое логические операторы?

Логические операторы — это продвинутая форма работы с условиями. В основном они используются для объединения нескольких результатов сравнения для дальнейшей оценки.

Оператор	Отношение	Пояснение
`&&`	И (AND)	Если оба операнда `true`, результат — `true`
`\|\|`	Или (OR)	Если хотя бы один операнд `true`, результат — `true`
`!`	Не (NOT)	Если условие `false`, результат — `true`

Напишите следующий код в opePractice.go:

package main

import (
    "fmt"
)

func main() {
    // Демонстрация логического И (&&)
    var age int = 18
    if age > 15 && age < 30 {
        fmt.Println("Возраст от 15 до 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("Возраст от 30 до 80")
    }
    // Демонстрация логического ИЛИ (||)
    if age > 15 || age < 30 {
        fmt.Println("Возраст больше 15 или меньше 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("Возраст больше 30 или меньше 40")
    }
    // Демонстрация логического НЕ (!)
    if age > 30 {
        fmt.Println("Возраст больше 30")
    }
    if !(age > 30) {
        fmt.Println("Возраст не больше 30")
    }
}

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

Запустите код:

cd ~/project
go run opePractice.go

Попробуйте изменить значение переменной возраста и запустите код снова, чтобы увидеть, как меняется вывод.

Порядок выполнения логических операторов

При использовании логических операторов И (AND) и ИЛИ (OR) Go должен определить логические значения с обеих сторон. Но какая сторона вычисляется первой?

Давайте исследуем это.

Напишите следующий код в opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Вызвана левая функция!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Вызвана правая функция!")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("Вычисление завершено")
    }
}

Запустите код:

cd ~/project
go run opePractice.go

Вызвана левая функция!
Вызвана правая функция!
Вычисление завершено

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

А что насчет логического ИЛИ? Напишите следующий код в opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Вызвана левая функция!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Вызвана правая функция!")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("Вычисление логического ИЛИ завершено")
    }
}

Запустите код:

cd ~/project
go run opePractice.go

Вызвана левая функция!
Вычисление логического ИЛИ завершено

Порядок вычисления как для логического И, так и для логического ИЛИ — слева направо.

Однако в операции логического ИЛИ, если левый операнд равен true, правый операнд вообще не вычисляется (это называется "короткое замыкание").

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

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

В предыдущих работах мы часто использовали операторы присваивания. Их основная функция — присвоить значение выражения левому операнду.

Левый операнд (L-value): Это выражение или переменная слева от оператора присваивания (=), в которую можно произвести запись.

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

Обычно мы пишем так:

x = x + 1

Но поскольку такие операции встречаются повсеместно, предусмотрена сокращенная форма записи:

x += 1

Аналогично существуют и другие сокращенные операторы присваивания:

Оператор	Описание
`=`	Базовое присваивание
`+=`	Сложение с присваиванием
`-=`	Вычитание с присваиванием
`*=`	Умножение с присваиванием
`/=`	Деление с присваиванием
`%=`	Остаток от деления с присваиванием

Напишите следующий код в opePractice.go:

package main

import "fmt"

func main() {
    x := 11
    fmt.Println("Начальное значение x:", x)
    x += 5 // x = x + 5
    fmt.Println("Значение после x += 5:", x)
    x -= 5 // x = x - 5
    fmt.Println("Значение после x -= 5:", x)
    x *= 5 // x = x * 5
    fmt.Println("Значение после x *= 5:", x)
    x /= 5
    fmt.Println("Значение после x /= 5:", x)
    x %= 3
    fmt.Println("Значение после x %= 3:", x)
}

В этом коде мы присваиваем переменной x начальное значение 11 и выполняем базовые арифметические операции с использованием сокращенного присваивания.

Запустите код:

cd ~/project
go run opePractice.go

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

Резюме

Давайте вспомним, что мы изучили в этой лабораторной работе:

Использование арифметических операторов
Использование операторов сравнения
Использование логических операторов
Использование операторов присваивания

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