As 25 palavras reservadas do Go

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.

const

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

1const Pi = 3.14

var

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

1var age int

func

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

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

type

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

1type Person struct {
2  Name string
3  Age  int
4}

import

A palavra-chave import é usada para importar pacotes.

1import "fmt"

package

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

1package main

Tipos compostos

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

chan

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

1ch := make(chan int)

interface

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

1type Speaker interface {
2  Speak() string
3}

map

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

1m := make(map[string]int)

struct

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

1type Rectangle struct {
2  Width, Height int
3}

Controle de fluxo

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

break

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

1for i := 0; i < 10; i++ {
2  if i == 5 {
3    break
4  }
5}

case

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

1switch day {
2  case "Monday":
3    ...
4  }
5}

continue

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

1for i := 0; i < 10; i++ {
2  if i % 2 == 0 {
3    continue
4  }
5  ...
6}

default

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

1switch day {
2  default:
3    fmt.Println("Dia desconhecido")
4}

if

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

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

else

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

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

fallthrough

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

1switch day {
2  case "Monday":
3    fmt.Println("Segunda-feira")
4    fallthrough
5  case "Tuesday":
6    fmt.Println("Terça-feira")
7}

for

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

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

goto

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

1func example() {
2  if x > 0 {
3    goto Label
4  }
5Label:
6  fmt.Println("Label reached")
7}

range

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

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

return

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

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

select

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

1select {
2  case msg1 := <-ch1:
3    fmt.Println(msg1)
4  case msg2 := <-ch2:
5    fmt.Println(msg2)
6}

switch

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

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

Modificador de função

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

defer

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

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

go

A palavra-chave go inicia uma nova goroutine.

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

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, else, 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.

1slice := make([]int, 5)
2fmt.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!