Operadores Go

1 Visão geral dos operadores em Golang

Na linguagem Go, os operadores são utilizados para realizar operações de código do programa, incluindo operações aritméticas, comparações relacionais, operações lógicas e muito mais. Diferentes operadores correspondem a diferentes funcionalidades e cenários de uso. Compreender e dominar esses operadores é a base para uma programação eficaz.

2 Operadores Aritméticos

A linguagem Go fornece um conjunto de operadores aritméticos:

• Adição (+): Operação de adição
• Subtração (-): Operação de subtração
• Multiplicação (*): Operação de multiplicação
• Divisão (/): Operação de divisão
• Resto (%): Operação de módulo

Exemplos:

package main

import "fmt"

func main() {
    // Operação de adição
    soma := 10 + 5
    fmt.Println("10 + 5 =", soma) // Retorna 15

    // Operação de subtração
    dif := 10 - 5
    fmt.Println("10 - 5 =", dif) // Retorna 5

    // Operação de multiplicação
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // Retorna 50

    // Operação de divisão
    quoc := 10 / 5
    fmt.Println("10 / 5 =", quoc) // Retorna 2

    // Operação de módulo (resto)
    rest := 10 % 5
    fmt.Println("10 % 5 =", rest) // Retorna 0
}

3 Operadores Lógicos

Os operadores lógicos na linguagem Go são usados para conectar múltiplas condições (geralmente usadas para valores booleanos). Eles incluem três tipos: E (&&), OU (||) e NÃO (!).

3.1 E (&&)

Quando todas as condições são verdadeiras, o resultado da operação "E" é verdadeiro.

Exemplos:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Retorna verdadeiro
    fmt.Println(true && false)  // Retorna falso
    fmt.Println(false && false) // Retorna falso
    // O resultado é verdadeiro apenas quando ambas as condições são verdadeiras
}

3.2 OU (||)

Se pelo menos uma condição for verdadeira, o resultado da operação "OU" é verdadeiro.

Exemplos:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Retorna verdadeiro
    fmt.Println(true || false)  // Retorna verdadeiro
    fmt.Println(false || false) // Retorna falso
    // O resultado é verdadeiro se pelo menos uma condição for verdadeira
}

3.3 NÃO (!)

Usado para inverter o valor booleano de uma condição.

Exemplos:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Retorna falso
    fmt.Println(!false) // Retorna verdadeiro
    // Inverte o valor booleano
}

4 Operadores de Comparação

Os operadores de comparação na linguagem Go são utilizados para comparar duas variáveis ou valores:

• Igual a (==)
• Diferente de (!=)
• Maior que (>)
• Menor que (<)
• Maior ou igual a (>=)
• Menor ou igual a (<=)

O resultado das operações de comparação é um valor booleano: true ou false.

5 Operadores Bit a Bit

Em Go, os operadores bit a bit permitem manipular diretamente os bits binários dos dados:

• E bit a bit (&)
• OU bit a bit (|)
• XOR bit a bit (^)
• Deslocamento de bits para a esquerda (<<)
• Deslocamento de bits para a direita (>>)

Os operadores bit a bit são principalmente utilizados em programação de baixo nível, como operações de hardware diretas, criptografia e outros cenários.

6 Operadores de Atribuição

Os operadores de atribuição são utilizados para atribuir valores às variáveis. Na linguagem Go, existem várias formas de operadores de atribuição:

• Atribuição simples (=)
• Atribuição de adição (+=)
• Atribuição de subtração (-=)
• Atribuição de multiplicação (*=)
• Atribuição de divisão (/=)
• Atribuição de módulo (%=)

Esses operadores tornam o código mais conciso. Por exemplo, x += 1 é equivalente a x = x + 1.

7 Operadores Especiais

7.1 Operadores de Incremento (++) e Decremento (--)

O operador de incremento (++) e o operador de decremento (--) são utilizados para adicionar 1 e subtrair 1 do valor de uma variável, respectivamente. Eles são os únicos operadores na linguagem Go que podem atuar diretamente na própria variável (não em uma expressão).

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // Mostra 2

    y := 10
    y--
    fmt.Println("y-- =", y) // Mostra 9
}

Observe que na linguagem Go, x++ ou x-- não pode fazer parte de uma expressão. Por exemplo, z := x++ não é permitido.

7.2 Conversão de Tipos

A linguagem Go é tipada estaticamente, o que significa que uma vez que uma variável é declarada, seu tipo não pode ser alterado. Portanto, às vezes é necessário converter uma variável de um tipo para outro. Go não possui conversão de tipo automática; é necessária uma conversão de tipo explícita.

Exemplo:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // Converte int para float64

	var f float64 = 3.14
	fmt.Println(int(f)) // Converte float64 para int, parte decimal será descartada
}

Ao realizar conversão de tipo, é importante garantir que os dados estejam seguros durante o processo de conversão, como a possível perda de precisão ao converter um número de ponto flutuante para um número inteiro.