As 25 palavras reservadas do Go

4 min readJul 24, 2024

Uma das características do Go é sua simplicidade e clareza. Projetada para ser fácil de aprender e usar, a linguagem evita a complexidade excessiva encontrada em algumas outras linguagens de programação.

Parte dessa simplicidade é refletida no número limitado de palavras reservadas — apenas 25. Compreender essas palavras-chave é essencial para aproveitar ao máximo o poder e a eficiência do Go. Vamos explorar cada uma dessas palavras, divididas em quatro categorias principais, para entender melhor seus usos e funções.

Bora conhecer elas?!

Declaração

As palavras reservadas nesta categoria são usadas para declarar diferentes elementos de código.

1. const
A palavra-chave const é usada para declarar constantes, que são valores imutáveis conhecidos em tempo de compilação.

const Pi = 3.14

2. var
A palavra-chave var é usada para declarar variáveis.

var age int

3. func
A palavra-chave func é usada para declarar funções.

func add(a int, b int) int {
    return a + b
}

4. type
A palavra-chave type é usada para introduzir novos tipos, como structs.

type Person struct {
    Name string
    Age  int
}

5. import
A palavra-chave import é usada para importar pacotes.

import "fmt"

6. package
A palavra-chave package define o pacote ao qual o código pertence.

package main

Tipos compostos

Essas palavras-chave são usadas para definir tipos compostos.

7. chan
A palavra-chave chan é usada para definir canais, que permitem comunicação entre goroutines.

ch := make(chan int)

8. interface
A palavra-chave interface é usada para definir um conjunto de métodos que um tipo deve implementar.

type Speaker interface {
    Speak() string
}

9. map
A palavra-chave map define um tipo de mapa, uma coleção não ordenada de pares chave-valor.

m := make(map[string]int)

10. struct
A palavra-chave struct é uma coleção de campos. Podemos usar a palavra-chave ‘struct’ seguida pelas declarações de campo.

type Rectangle struct {
    Width, Height int
}

Controle de fluxo

Essas palavras-chave controlam o fluxo do código.

11. break
A palavra-chave break interrompe a execução de loops ou switch.

for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
}

12. case
A palavra-chave case é usada em instruções switch.

switch day {
case "Monday":
    ...
}

13. continue
A palavra-chave continue pula para a próxima iteração do loop.

for i := 0; i < 10; i++ {
    if i % 2 == 0 {
        continue
    }
    ...
}

14. default
A palavra-chave default especifica o bloco de código a ser executado se nenhum case for correspondido.

switch day {
default:
    fmt.Println("Dia desconhecido")
}

15. else
A palavra-chave else define um bloco alternativo para uma instrução if.

if x < 0 {
    fmt.Println("Número negativo")
} else {
    fmt.Println("Número não negativo")
}

16. fallthrough
A palavra-chave fallthrough transfere a execução para o próximo case em uma instrução switch.

switch day {
case "Monday":
    fmt.Println("Segunda-feira")
    fallthrough
case "Tuesday":
    fmt.Println("Terça-feira")
}

17. for
A palavra-chave for é usada para iniciar um loop.

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

18. goto
A palavra-chave goto permite saltar para um rótulo especificado.

func example() {
    if x > 0 {
        goto Label
    }
Label:
    fmt.Println("Label reached")
}

19. if
A palavra-chave if é usada para executar código condicionalmente.

if x > 0 {
    fmt.Println("Positivo")
}

20. range
A palavra-chave range é usada para iterar sobre arrays, slices, mapas e canais.

for index, value := range slice {
    fmt.Println(index, value)
}

21. return
A palavra-chave return termina a execução de uma função e retorna os valores especificados.

func add(a int, b int) int {
    return a + b
}

22. select
A palavra-chave select permite que uma goroutine espere em várias operações de comunicação.

select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
}

23. switch
A palavra-chave switch permite executar um bloco de código entre várias opções.

switch day {
case "Monday":
    fmt.Println("Segunda-feira")
}

Modificador de função

Essas palavras-chave controlam a execução de chamadas de função de maneiras específicas.

24. defer
A palavra-chave defer adia a execução de uma função até que a função circundante retorne.

func main() {
    defer fmt.Println("Executado por último")
    fmt.Println("Executado primeiro")
}

25. go
A palavra-chave go inicia uma nova goroutine.

go func() {
    fmt.Println("Executando em uma goroutine")
}()

Nomes Pré-declarados

Além das palavras reservadas, Go também possui nomes pré-declarados que encontramos frequentemente. Esses nomes não são reservados pela linguagem, o que significa que podemos usá-los (com moderação) em nosso código. Aqui estão alguns nomes pré-declarados importantes:

Constantes: true, false, iota, nil

Tipos: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex128, complex64, bool, byte, rune, string, error

Funções: make, len, cap, new, append, copy, close, delete, complex, real, imag, panic, recover

Esses nomes pré-declarados são fundamentais para escrever código idiomático em Go. Por exemplo, podemos usar len e make frequentemente para obter o comprimento de coleções e para criar novos slices, mapas e canais, respectivamente.

slice := make([]int, 5)
fmt.Println(len(slice))

Embora possamos usar esses nomes pré-declarados como variáveis ou nomes de função em nosso código, é uma prática recomendada evitar fazer isso para manter a clareza e evitar confusões. Por exemplo, usar if ou for como nomes de variáveis pode tornar o código difícil de ler e entender.

Bom, é isso, espero que tenha gostado! E se tiver alguma sugestão deixe aí nos comentários 💬

Se gostou, dê 1 ou 50 claps (Só clicar 50x na 👏)

Obrigado pela leitura!

Me acompanhe por aí! 😜

Portfólio: vinniciusgomes.com
GitHub: @vinniciusgomes
LinkedIn: @vinniciusgomes