Processamento de Dados com Operadores em Golang

GolangGolangBeginner
Pratique Agora

💡 Este tutorial foi traduzido do inglês com assistência de IA. Para ver o original, você pode mudar para a versão em inglês

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)
Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 97.22%.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL go(("Golang")) -.-> go/BasicsGroup(["Basics"]) go(("Golang")) -.-> go/FunctionsandControlFlowGroup(["Functions and Control Flow"]) go/BasicsGroup -.-> go/variables("Variables") go/FunctionsandControlFlowGroup -.-> go/for("For") go/FunctionsandControlFlowGroup -.-> go/if_else("If Else") go/FunctionsandControlFlowGroup -.-> go/functions("Functions") subgraph Lab Skills go/variables -.-> lab-149066{{"Processamento de Dados com Operadores em Golang"}} go/for -.-> lab-149066{{"Processamento de Dados com Operadores em Golang"}} go/if_else -.-> lab-149066{{"Processamento de Dados com Operadores em Golang"}} go/functions -.-> lab-149066{{"Processamento de Dados com Operadores em Golang"}} end

Forma Básica

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

Operador Função
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo (Resto)

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
}
✨ Verificar Solução e Praticar

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.

Operador Relação
== Igual a
!= Diferente de
> Maior que
>= Maior ou igual a
< Menor que
<= Menor ou igual a

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.

Operador Relação Explicação
&& E Se ambos os operandos forem true, o resultado é true
|| Ou Se qualquer um dos operandos for true, o resultado é true
! Não Se a condição for false, o resultado é true

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:

Operador Descrição
= Operador de atribuição básico
+= Adiciona e atribui
-= Subtrai e atribui
*= Multiplica e atribui
/= Divide e atribui
%= Módulo e atribui (resto da divisão)

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.

OSZAR »