Operadores são símbolos que permitem realizar operações em variáveis e valores. Em Go, eles são divididos em categorias: aritméticos, de comparação, lógicos, bitwise e outros. Compreender seu funcionamento e precedência é essencial para escrever código correto e eficiente.

Go é uma linguagem tipada estaticamente, o que significa que operadores geralmente exigem operandos do mesmo tipo. Além disso, Go não possui operador ternário e trata a precedência de forma clara, evitando ambiguidades.

Aritméticos, comparação, lógicos

Os operadores aritméticos em Go são: + (adição), - (subtração), * (multiplicação), / (divisão), % (resto da divisão). Eles funcionam com tipos numéricos (int, float64, etc.). Importante: a divisão entre inteiros resulta em inteiro (truncado).

Operadores de comparação: ==, !=, <, >, <=, >=. Retornam um valor booleano (bool). Podem ser usados com tipos comparáveis, como números, strings e booleanos.

Operadores lógicos: && (E), || (OU), ! (NÃO). São usados com operandos booleanos e realizam curto-circuito.

package main

import "fmt"

func main() {
    a := 10
    b := 3
    fmt.Println("Soma:", a+b)       // 13
    fmt.Println("Divisão:", a/b)    // 3 (inteiro)
    fmt.Println("Resto:", a%b)      // 1
    fmt.Println("Igual:", a == b)   // false
    fmt.Println("Lógico:", a > 5 && b < 5) // true
}

Bitwise

Operadores bitwise atuam diretamente nos bits dos números inteiros. Go oferece: & (E bit a bit), | (OU bit a bit), ^ (XOR), &^ (AND NOT), << (deslocamento à esquerda), >> (deslocamento à direita).

Esses operadores são úteis em programação de sistemas, manipulação de flags e otimizações. O operador &^ (bit clear) zera os bits do primeiro operando onde o segundo tem bits 1.

package main

import "fmt"

func main() {
    x := 0b1100 // 12
    y := 0b1010 // 10
    fmt.Println("E:", x&y)     // 8 (1000)
    fmt.Println("OU:", x|y)    // 14 (1110)
    fmt.Println("XOR:", x^y)   // 6 (0110)
    fmt.Println("AND NOT:", x&^y) // 4 (0100)
    fmt.Println("Deslocamento:", x<<1) // 24 (11000)
}

Precedência

Go define uma precedência clara de operadores, listada da maior para a menor:

  • Unários: !, ^, -, +, &, *, etc.
  • Multiplicativos: *, /, %, <<, >>, &, &^
  • Aditivos: +, -, |, ^
  • Comparação: ==, !=, <, >, <=, >=
  • Lógicos: && (E), || (OU)

Use parênteses para alterar a ordem de avaliação. Exemplo: a + b * c é avaliado como a + (b * c).

package main

import "fmt"

func main() {
    a := 2
    b := 3
    c := 4
    fmt.Println("Sem parênteses:", a+b*c)   // 14
    fmt.Println("Com parênteses:", (a+b)*c) // 20
}

Particularidades

Go não possui operador ternário (cond ? a : b). Recomenda-se usar um if-else. Também não permite incremento/decremento como expressão (++ e -- são statements, não expressions).

Outra particularidade: operadores de comparação só podem ser usados entre operandos do mesmo tipo. Go não faz coerção implícita. Além disso, o operador == e != podem ser usados em structs e arrays se todos os campos/elementos forem comparáveis.

package main

import "fmt"

func main() {
    // Erro: tipos diferentes
    // var x int = 5
    // var y float64 = 5.0
    // fmt.Println(x == y) // compilação falha

    // Incremento é statement
    i := 0
    i++ // ok
    // j := i++ // erro
    fmt.Println(i)

    // Comparação de structs
    type Ponto struct { X, Y int }
    p1 := Ponto{1, 2}
    p2 := Ponto{1, 2}
    fmt.Println(p1 == p2) // true
}

Referências

Exercícios

  1. Escreva um programa que declare duas variáveis inteiras (a=15, b=4) e imprima o resultado da divisão inteira e o resto.

    2. ✓ Resposta:
    package main

import "fmt"

func main() {
    a := 15
    b := 4
    fmt.Println("Divisão:", a/b) // 3
    fmt.Println("Resto:", a%b)   // 1
}
  2. Use operadores bitwise para verificar se o bit 2 (posição 2, contando de 0) de um número é 1. Exemplo: número 13 (1101) deve retornar true.

    3. ✓ Resposta:
    package main

import "fmt"

func main() {
    n := 13 // 1101
    bit2 := (n >> 2) & 1
    fmt.Println(bit2 == 1) // true
}
  3. Corrija o erro no código a seguir: var x int = 5; var y float64 = 5.0; fmt.Println(x == y)

    4. ✓ Resposta:Converter explicitamente: fmt.Println(float64(x) == y) ou fmt.Println(x == int(y)).
    package main

import "fmt"

func main() {
    var x int = 5
    var y float64 = 5.0
    fmt.Println(float64(x) == y) // true
}
  4. Explique por que o código a := 0; b := a++ não compila.

    5. ✓ Resposta:Em Go, ++ e -- são statements, não expressions. Portanto, não podem ser usados como parte de uma atribuição. O correto é escrever a++ em uma linha separada.
  5. Escreva uma expressão usando operadores lógicos que retorne true se uma variável idade estiver entre 18 e 60 inclusive.

    6. ✓ Resposta:idade >= 18 && idade <= 60