Обработка данных с использованием операторов в Golang

Введение

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

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

Точки знания:

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

Skills Graph

Базовая форма

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

Создайте файл с именем 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
}

Относительные операторы (Relational Operators)

Что такое относительные операторы?

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

Вышеперечисленные операторы возвращают 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 единице
    judgeValue := 1 == 1 //true
    fmt.Println(judgeValue)
}

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

cd ~/project
go run opePractice.go

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

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

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

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

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

| Оператор | Отношение | Объяснение |
| -------- | --------- | ------------------------------------------------------ | --- | -------------------------------------------------------------- |
| && | И | Если оба операнда равны true, результат равен true |
| | | | Или | Если хотя бы один операнд равен true, результат равен true |
| ! | Не | Если условие равно 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

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

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

При использовании логических операторов "И" (&&) и "ИЛИ" (||) в Go необходимо определить булевые значения по обе стороны от оператора. Но какую сторону оценивается первой?

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

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

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Left function is called!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Right function is called!")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("Evaluation is complete")
    }
}

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

cd ~/project
go run opePractice.go

Left function is called!
Right function is called!
Evaluation is complete

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

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

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Left function is called!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Right function is called!")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("Logical OR evaluation is complete")
    }
}

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

cd ~/project
go run opePractice.go

Left function is called!
Logical OR evaluation is complete

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

Однако, в операции логического "ИЛИ", если левый операнд равен true, правый операнд не оценивается.

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

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

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

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

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

Исходя из того, что мы уже знаем, мы могли бы написать такой код:

x = x + 1

Но такой код очень часто встречается в реальной разработке, поэтому для него существует сокращенная форма:

x += 1

Аналогично, часто используемые операторы присваивания включают:

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

package main

import "fmt"

func main() {
    x := 11
    fmt.Println("The initial value of x:", x)
    x += 5 // x = x + 5
    fmt.Println("Value after x += 5:", x)
    x -= 5 // x = x - 5
    fmt.Println("Value after x -= 5:", x)
    x *= 5 // x = x * 5
    fmt.Println("Value after x *= 5:", x)
    x /= 5
    fmt.Println("Value after x /= 5:", x)
    x %= 3
    fmt.Println("Value after x %= 3:", x)
}

В приведенном выше коде мы присваиваем переменной x начальное значение 11 и выполняем базовые арифметические операции (сложение, вычитание, умножение), деление и взятие остатка от деления.

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

cd ~/project
go run opePractice.go

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

Итог

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

• Использование арифметических операторов
• Использование относительных операторов (Relational operators)
• Использование логических операторов
• Использование операторов присваивания

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