Processamento de Dados com Operadores em Golang

Introdução

Após os dados serem salvos em variáveis em uma linguagem de programação, como devemos processá-los?

É neste momento que precisamos de operadores para realizar cálculos sobre os dados armazenados. Nesta seção, aprenderemos o seguinte:

Pontos de Conhecimento:

• Operadores Aritméticos
• Operadores Relacionais
• Operadores Lógicos
• Operadores de Atribuição

Forma Básica

Os operadores aritméticos são os mais fundamentais, representando os métodos básicos de cálculo.

Crie um arquivo chamado opePractice.go no diretório home/project/:

cd ~/project
touch opePractice.go

Escreva o seguinte código nele:

package main

import "fmt"

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

    // Addition, subtraction, and multiplication
    fmt.Println("a + b =", a+b)
    fmt.Println("a - b =", a-b)
    fmt.Println("b - a =", b-a)
    fmt.Println("a * b =", a*b)

    // Division
    // In Go, if an integer is divided, it will be rounded down.
    fmt.Println("a / b =", a/b)
    // But if a floating-point number is divided, there will be no such problem.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Modulus calculation: general form
    fmt.Println("a % b =", a%b)
    // Modulus calculation with negative numbers
    // Calculation method: remainder = dividend - (dividend / divisor) * divisor
    fmt.Println("10 % -3 =", 10%-3)
    fmt.Println("-10 % 3 =", -10%3)
    fmt.Println("-10 % -3 =", -10%-3)
}

Execute o código e preste atenção especial em como o resto negativo é calculado.

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

Operadores de Incremento e Decremento

Em Go, ++ (incremento) e -- (decremento) são instruções independentes e só podem ser usadas de forma isolada; eles não são operadores que retornam valores em expressões.

O código a seguir está incorreto:

var a int = 5
var i int = 0
a = i++ // Uso incorreto, o incremento só pode ser usado de forma independente
a = i-- // Uso incorreto, o decremento só pode ser usado de forma independente
a = ++i // Uso incorreto, Go não possui pré-incremento
a = --i // Uso incorreto, Go não possui pré-decremento

A sintaxe correta é:

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

Escreva o seguinte código em opePractice.go:

Complete o código. Altere o valor da variável i usando o operador de incremento, para que o valor da variável a se torne 16:

package main

import "fmt"

func main() {
    var a int = 15
    var i int = 0
    /* Write code below */

    a = a + i
    fmt.Println(a)
    // Complete the code to make the output of a equal 16
}

Operadores Relacionais

O que são operadores relacionais?

Operadores relacionais são uma forma de comparação, descrevendo a relação entre dois valores. Eles determinam se dois valores são iguais, ou se um é maior ou menor que o outro.

Os operadores acima retornam true se a condição for atendida e false caso contrário.

Escreva o seguinte código em opePractice.go:

package main

import "fmt"

func main() {
    // Use of relational operators
    var a int = 7
    var b int = 6
    // Check if equal
    fmt.Println(a == b)  //false
    // Check if not equal
    fmt.Println(a != b)  //true
    // Check if a is greater than b
    fmt.Println(a > b)   //true
    // Check if a is greater than or equal to b
    fmt.Println(a >= b)  //true
    // Check if a is less than b
    fmt.Println(a < b)   //false
    // Check if a is less than or equal to b
    fmt.Println(a <= b)  //false
    // Check if 1 is equal to 1
    judgeValue := 1 == 1 //true
    fmt.Println(judgeValue)
}

Execute o código:

cd ~/project
go run opePractice.go

No código acima, realizamos comparações relacionais baseadas nas variáveis a e b.

Você pode modificar os valores das variáveis para alterar os resultados das comparações e obter uma compreensão mais profunda dos operadores relacionais.

Operadores Lógicos

O que são operadores lógicos?

Os operadores lógicos são uma forma avançada de operadores relacionais. Eles são usados principalmente para combinar operadores relacionais para avaliações mais complexas.

Escreva o seguinte código em opePractice.go:

package main

import (
    "fmt"
)

func main() {
    // Demonstrating logical AND operator &&
    var age int = 18
    if age > 15 && age < 30 {
        fmt.Println("Age is between 15 and 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("Age is between 30 and 80")
    }
    // Demonstrating logical OR operator ||
    if age > 15 || age < 30 {
        fmt.Println("Age is greater than 15 or less than 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("Age is greater than 30 or less than 40")
    }
    // Demonstrating logical NOT operator !
    if age > 30 {
        fmt.Println("Age is greater than 30")
    }
    if !(age > 30) {
        fmt.Println("Age is not greater than 30")
    }
}

No código acima, realizamos uma série de avaliações lógicas baseadas no valor 18 da variável age.

Execute o código:

cd ~/project
go run opePractice.go

Você pode modificar o valor da variável de idade e executar o código para observar as mudanças na saída.

Ordem de Execução dos Operadores Lógicos

Ao usar os operadores lógicos E (AND) e OU (OR), o Go precisa determinar os valores booleanos em ambos os lados do operador. Mas qual lado é avaliado primeiro?

Vamos explorar isso juntos.

Escreva o seguinte código em 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")
    }
}

Execute o código:

cd ~/project
go run opePractice.go

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

Não é difícil perceber que na operação lógica AND, o operando da esquerda é avaliado primeiro e, em seguida, o operando da direita é avaliado.

E quanto à operação lógica OR? Escreva o seguinte código em 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")
    }
}

Execute o código:

cd ~/project
go run opePractice.go

Left function is called!
Logical OR evaluation is complete

A ordem de avaliação de ambas as operações lógicas AND e OR é da esquerda para a direita.

No entanto, na operação lógica OR, se o operando da esquerda for verdadeiro, o operando da direita não é avaliado. Isso é conhecido como avaliação de curto-circuito.

Portanto, no desenvolvimento real, devemos colocar as condições que têm maior probabilidade de serem verdadeiras no lado esquerdo do operador lógico OR, reduzindo o tempo de execução do programa.

Operadores de Atribuição

Nos laboratórios anteriores, usamos frequentemente operadores de atribuição. A função principal dos operadores de atribuição é atribuir o valor de uma expressão a um operando do lado esquerdo.

Operando do Lado Esquerdo: A expressão ou variável à esquerda do operador de atribuição (=) que pode receber um valor.

No desenvolvimento real, muitas vezes precisamos somar ou subtrair um valor de uma variável e salvar o resultado nela mesma.

Com base no que aprendemos, poderíamos escrever o código assim:

x = x + 1

Mas como esse tipo de código é muito comum, fornecemos uma forma abreviada para ele:

x += 1

Da mesma forma, os operadores de atribuição comumente usados incluem:

Escreva o seguinte código em 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)
}

No código acima, atribuímos um valor inicial de 11 à variável x e realizamos operações aritméticas básicas (adição, subtração, multiplicação), divisão e cálculos de módulo.

Execute o código:

cd ~/project
go run opePractice.go

Você pode modificar o valor da variável para ver como os operadores de atribuição funcionam.

Resumo

Vamos revisar o que aprendemos neste laboratório:

• O uso de operadores aritméticos
• O uso de operadores relacionais
• O uso de operadores lógicos
• O uso de operadores de atribuição

Neste laboratório, discutimos como usar operadores em Go. Demonstramos vários operadores e suas formas de aplicação.