Processamento de Dados com Operadores em Golang

Introdução

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

É aqui que precisamos de operadores para realizar cálculos sobre os dados que foram salvos. Nesta seção, aprenderemos o seguinte:

Pontos de Conhecimento:

• Operadores Aritméticos (Arithmetic Operators)
• Operadores Relacionais (Relational Operators)
• Operadores Lógicos (Logical Operators)
• Operadores de Atribuição (Assignment Operators)

Skills Graph

Forma Básica

Os operadores aritméticos são os operadores 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("-----")

    // Adição, subtração e multiplicação
    fmt.Println("a + b =", a+b)
    fmt.Println("a - b =", a-b)
    fmt.Println("b - a =", b-a)
    fmt.Println("a * b =", a*b)

    // Divisão
    // Em Go, se um inteiro é dividido, ele será arredondado para baixo.
    fmt.Println("a / b =", a/b)
    // Mas se um número de ponto flutuante é dividido, não haverá tal problema.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Cálculo do módulo: forma geral
    fmt.Println("a % b =", a%b)
    // Cálculo do módulo com números negativos
    // Método de cálculo: resto = dividendo - (dividendo / 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 independente; eles não são operadores.

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, de modo que o valor da variável a se torne 16:

package main

import "fmt"

func main() {
    var a int = 15
    var i int = 0
    /* Escreva o código abaixo */

    a = a + i
    fmt.Println(a)
    // Complete o código para fazer a saída de a igual a 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, se um é maior ou menor que o outro.

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

Escreva o seguinte código em opePractice.go:

package main

import "fmt"

func main() {
    // Uso de operadores relacionais
    var a int = 7
    var b int = 6
    // Verifique se é igual
    fmt.Println(a == b)  //false
    // Verifique se é diferente
    fmt.Println(a != b)  //true
    // Verifique se a é maior que b
    fmt.Println(a > b)   //true
    // Verifique se a é maior ou igual a b
    fmt.Println(a >= b)  //true
    // Verifique se a é menor que b
    fmt.Println(a < b)   //false
    // Verifique se a é menor ou igual a b
    fmt.Println(a <= b)  //false
    // Verifique se 1 é igual a 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 com base nas variáveis a e b.

Os alunos podem modificar os valores das variáveis para alterar os resultados da comparação e obter uma compreensão mais profunda dos operadores relacionais.

Operadores Lógicos

O que são operadores lógicos?

Operadores lógicos são uma forma avançada de operadores relacionais. Eles são usados principalmente para combinar operadores relacionais para avaliação adicional.

Escreva o seguinte código em opePractice.go:

package main

import (
    "fmt"
)

func main() {
    // Demonstrando o operador lógico E &&
    var age int = 18
    if age > 15 && age < 30 {
        fmt.Println("A idade está entre 15 e 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("A idade está entre 30 e 80")
    }
    // Demonstrando o operador lógico OU ||
    if age > 15 || age < 30 {
        fmt.Println("A idade é maior que 15 ou menor que 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("A idade é maior que 30 ou menor que 40")
    }
    // Demonstrando o operador lógico NÃO !
    if age > 30 {
        fmt.Println("A idade é maior que 30")
    }
    if !(age > 30) {
        fmt.Println("A idade não é maior que 30")
    }
}

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

Execute o código:

cd ~/project
go run opePractice.go

Os alunos podem modificar o valor da variável 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 e OU, 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("Função da esquerda é chamada!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Função da direita é chamada!")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("Avaliação completa")
    }
}

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 descobrir que, na operação lógica E, o operando esquerdo é avaliado primeiro e, em seguida, o operando direito é avaliado.

E quanto à operação lógica OU? Escreva o seguinte código em opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("Função da esquerda é chamada!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("Função da direita é chamada!")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("Avaliação lógica OU completa")
    }
}

Execute o código:

cd ~/project
go run opePractice.go

Left function is called!
Logical OR evaluation is complete

A ordem de avaliação das operações lógicas E e OU é da esquerda para a direita.

No entanto, na operação lógica OU, se o operando esquerdo for verdadeiro, o operando direito não é avaliado.

Portanto, no desenvolvimento real, devemos colocar as condições que são mais propensas a serem verdadeiras no lado esquerdo do operador lógico OU, reduzindo o tempo de execução do programa.

Operadores de Atribuição

Nos laboratórios anteriores, frequentemente usamos 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 (Left-hand Operand): A expressão ou variável à esquerda do operador de atribuição (=) que pode receber um valor.

No desenvolvimento real, muitas vezes precisamos adicionar ou subtrair uma variável de outra.

Com base no que aprendemos, poderíamos escrever um código como este:

x = x + 1

Mas esse tipo de código é muito comum no desenvolvimento real, então 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("O valor inicial de x:", x)
    x += 5 // x = x + 5
    fmt.Println("Valor após x += 5:", x)
    x -= 5 // x = x - 5
    fmt.Println("Valor após x -= 5:", x)
    x *= 5 // x = x * 5
    fmt.Println("Valor após x *= 5:", x)
    x /= 5
    fmt.Println("Valor após x /= 5:", x)
    x %= 3
    fmt.Println("Valor após x %= 3:", x)
}

No código acima, atribuímos um valor inicial de 11 à variável x e realizamos cálculos aritméticos básicos (adição, subtração, multiplicação), divisão e 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 seu uso.