Linguagem Go: o que é Golang, para que serve e exemplos

Go é uma linguagem de programação compilada e de tipagem estática criada no Google. Ela gera um único binário nativo, compila em segundos, tem coleta de lixo e traz concorrência embutida na própria linguagem, com goroutines e channels. Seu habitat principal é o software de servidor: APIs, serviços de rede e as ferramentas de linha de comando e de nuvem que os operam.

Aqui está um programa Go completo. Clique em Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Todo programa Go começa em package main, na func main(). := declara uma variável e infere o tipo (aqui []string, um slice de strings). range percorre o slice e entrega um índice e um valor. fmt e strings vêm da biblioteca padrão, que é grande o bastante para muitos programas não importarem mais nada.

Go ou Golang: o nome

A linguagem se chama Go. "Golang" é um apelido que veio do primeiro site do projeto, golang.org (hoje o site fica em go.dev). As pessoas continuaram usando porque buscar "go" na web devolve de tudo, menos a linguagem. A documentação oficial diz "Go", mas "golang" é o termo que quase todo mundo digita na busca, e os dois significam a mesma coisa. Não existe um produto ou dialeto separado chamado "Golang".

Quem criou Go e por quê

Robert Griesemer, Rob Pike e Ken Thompson começaram a projetar Go no Google em 2007. Ela foi lançada como código aberto em novembro de 2009, e o Go 1.0 saiu em março de 2012.

A motivação era prática. As grandes bases de código em C++ e Java do Google demoravam muito para compilar, os grafos de dependência eram difíceis de gerenciar, e máquinas multicore e serviços em rede já eram a norma, mas escrever código concorrente era fácil de errar. O design do Go responde diretamente a esses problemas:

• Builds rápidos. Os imports são explícitos, import sem uso é erro de compilação e o compilador não reprocessa headers, então programas grandes compilam em segundos.
• Linguagem simples. Poucas palavras-chave, um só laço (for), sem herança, sem exceções. Código escrito por pessoas diferentes tende a ficar parecido, o que ajuda nas revisões em times grandes.
• Concorrência como recurso da linguagem. Iniciar uma tarefa concorrente é uma palavra-chave, go, e os channels permitem que as tarefas se comuniquem.
• Deploy simples. O resultado é um binário que você copia para o servidor. Normalmente ele é linkado estaticamente; com o cgo habilitado, pacotes como net podem linkar com a biblioteca C do sistema, e CGO_ENABLED=0 desliga isso.

O Go 1.0 também trouxe a promessa de compatibilidade do Go 1: programas escritos para o Go 1.0 continuam compilando e rodando nas versões 1.x seguintes. Na prática, atualizar a toolchain raramente quebra o seu código, e esse é um dos grandes motivos para times confiarem em Go para serviços de longa duração.

Para que o Golang é usado

Go se sai melhor quando o programa conversa com a rede, roda por muito tempo e precisa ser fácil de distribuir:

Ela é uma escolha mais fraca para apps desktop com interface gráfica, apps mobile, front ends de navegador e trabalho numérico ou de machine learning, áreas em que outros ecossistemas têm bibliotecas muito melhores.

Principais recursos, com código

Tipos estáticos com inferência

Toda variável tem um tipo fixado em tempo de compilação, mas você raramente o escreve. := infere o tipo:

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go nunca converte entre tipos numéricos em silêncio. count * price não compila, porque um é int e o outro float64; você mesmo escreve float64(count). Isso elimina bugs silenciosos de truncamento e de precisão.

Erros são valores

Go não tem exceções. Uma função que pode falhar retorna um error como último resultado, e quem chama verifica:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

O padrão if err != nil é a linha mais reconhecível de código Go. É verboso, e a ideia é justamente essa: todo ponto em que o programa pode falhar fica visível onde acontece. Veja tratamento de erros para empacotar e inspecionar erros.

Goroutines e channels

Uma goroutine é uma função rodando de forma concorrente com o resto do programa. Ela custa alguns kilobytes de pilha, então rodar milhares delas é normal. Channels passam valores entre goroutines com segurança:

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

As três goroutines rodam de forma concorrente, então as três linhas podem sair em qualquer ordem. Execute algumas vezes e talvez você veja ordens diferentes. main recebe exatamente três valores, então espera por todos antes de terminar.

Interfaces sem "implements"

Um tipo satisfaz uma interface só por ter os métodos certos. Não existe a palavra-chave implements:

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect e Circle nunca mencionam Shape, e mesmo assim os dois podem ser guardados em um []Shape. Isso permite definir uma interface no pacote que a usa, muito depois de os tipos concretos terem sido escritos.

Uma única toolchain

O comando go faz tudo: go run compila e executa, go build gera um binário, go test roda os testes, go fmt formata o código, go vet aponta construções suspeitas e go mod gerencia dependências. Existe um único estilo oficial de formatação, aplicado pelo gofmt, então projetos Go não discutem sobre chaves ou indentação.

O que Go deixa de fora de propósito

Alguns recursos comuns em outras linguagens faltam de propósito:

• Sem classes nem herança. Você usa structs, métodos, interfaces e embedding.
• Sem exceções. Erros são valores retornados. panic existe, mas é para bugs, não para falhas comuns.
• Sem operador ternário. Você escreve um if/else.
• Sem a palavra-chave while. for cobre todos os laços.
• Sem sobrecarga de funções nem argumentos padrão.
• Generics só a partir do Go 1.18, e limitados de propósito em comparação com templates de C++ ou generics de Java.

Limitações reais

Verbosidade. As verificações explícitas de erro e a falta de atalhos como o operador ternário deixam o código Go mais longo que o equivalente em Python ou Kotlin. Ler é fácil; escrever leva mais linhas.

Coleta de lixo. O coletor do Go tem pausas curtas, mas continua sendo um coletor de lixo. Para sistemas de tempo real rígido ou código em que cada alocação importa, C, C++ ou Rust dão mais controle.

Valores nil. Go tem ponteiros, maps, slices e interfaces nil. Desreferenciar um ponteiro nil é um panic em tempo de execução, e o compilador não impede isso como o sistema de tipos do Rust impede.

Um sistema de tipos pequeno. Sem tipos soma, sem enums (você os monta com constantes e iota) e com generics que cobrem os casos comuns, mas não programação avançada em nível de tipos.

Lacunas no ecossistema. As bibliotecas para serviços web, bancos de dados e APIs de nuvem são excelentes. Para interfaces gráficas, computação científica e machine learning, Python, C++ ou Julia têm muito mais.

Go comparada com outras linguagens

Escolha Go quando quiser desempenho de linguagem compilada e deploy simples, sem a curva de aprendizado do Rust nem a cerimônia do Java.

Vale a pena aprender Go?

Se você escreve serviços de backend, ferramentas de linha de comando ou qualquer coisa na área de infraestrutura de nuvem, sim. Go é a linguagem em que boa parte desse ecossistema foi escrita, e ler o código-fonte dele faz parte do trabalho. A linguagem é pequena, então o investimento é modesto: a sintaxe básica leva dias, e concorrência e tratamento de erros idiomáticos levam algumas semanas de prática.

Para começar a escrever Go na sua máquina, instale o Go e depois siga a página de hello world, que explica cada linha de um primeiro programa.