50 Perguntas de Entrevista Go (Golang) em 2026

Prepare-se para entrevistas de Go com as perguntas mais frequentes. Dividimos em níveis para facilitar seu estudo.

📗 Nível Iniciante

1. O que é Go e quais são suas principais características?

Go (Golang) é uma linguagem de programação criada pelo Google em 2009. Principais características:

• Compilada e tipada estaticamente
• Sintaxe simples e limpa
• Suporte nativo a concorrência (goroutines)
• Garbage collection eficiente
• Compilação rápida
• Biblioteca padrão robusta

2. Qual a diferença entre var e :=?

// var - declaração explícita, pode usar fora de funções
var nome string = "Go"
var idade int

// := - declaração curta, só dentro de funções
linguagem := "Go"  // tipo inferido

3. O que são goroutines?

Goroutines são funções que executam concorrentemente. São mais leves que threads do sistema operacional.

go minhaFuncao()  // executa em uma nova goroutine

4. Como funcionam os channels em Go?

Channels são o mecanismo de comunicação entre goroutines.

ch := make(chan int)    // criar channel
ch <- 42                // enviar valor
valor := <-ch           // receber valor

5. Qual a diferença entre array e slice?

• Array: tamanho fixo, definido na declaração
• Slice: tamanho dinâmico, referência a um array subjacente

arr := [3]int{1, 2, 3}    // array - tamanho fixo
slice := []int{1, 2, 3}   // slice - tamanho dinâmico

6. O que é a função init()?

Função especial executada automaticamente antes de main(). Usada para inicialização.

func init() {
    // executado antes de main()
}

7. Como Go trata erros?

Go usa retorno de erro explícito ao invés de exceções.

resultado, err := funcaoQuePodeFalhar()
if err != nil {
    // tratar erro
    return err
}

8. O que é defer?

defer adia a execução de uma função até o retorno da função atual.

func exemplo() {
    defer fmt.Println("fim")  // executado por último
    fmt.Println("início")
}
// Saída: início, fim

📘 Nível Intermediário

9. Explique a diferença entre make() e new()

• new(T): aloca memória zerada, retorna ponteiro *T
• make(T): usado para slices, maps e channels, retorna T inicializado

p := new(int)           // *int, valor 0
s := make([]int, 5)     // []int com 5 elementos
m := make(map[string]int) // map inicializado

10. Como implementar uma interface em Go?

Interfaces são implementadas implicitamente - basta ter os métodos.

type Writer interface {
    Write([]byte) (int, error)
}

type MeuWriter struct{}

func (m MeuWriter) Write(data []byte) (int, error) {
    // implementação
    return len(data), nil
}
// MeuWriter implementa Writer automaticamente

11. O que é um mutex e quando usar?

Mutex (mutual exclusion) protege acesso concorrente a dados compartilhados.

var mu sync.Mutex
var contador int

func incrementar() {
    mu.Lock()
    contador++
    mu.Unlock()
}

12. Explique o padrão context em Go

Context carrega deadlines, sinais de cancelamento e valores através de chamadas de API.

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

select {
case <-ctx.Done():
    return ctx.Err()
case resultado := <-operacaoLonga(ctx):
    return resultado
}

13. Como funciona o garbage collector do Go?

Go usa um GC concurrent, tri-color, mark-and-sweep:

• Pausas curtas (sub-milisegundo)
• Executa concorrentemente com a aplicação
• Controlável via GOGC environment variable

14. O que são struct tags?

Metadados anexados a campos de struct, usados para serialização.

type Usuario struct {
    Nome  string `json:"nome" validate:"required"`
    Email string `json:"email,omitempty"`
}

15. Explique select em channels

select permite esperar em múltiplos channels simultaneamente.

select {
case msg := <-ch1:
    fmt.Println("Recebido de ch1:", msg)
case msg := <-ch2:
    fmt.Println("Recebido de ch2:", msg)
case <-time.After(time.Second):
    fmt.Println("Timeout")
}

📙 Nível Avançado

16. Como evitar race conditions?

• Use mutex para proteger dados compartilhados
• Prefira channels para comunicação
• Use -race flag para detectar: go run -race main.go
• Evite compartilhar memória; compartilhe por comunicação

17. Explique escape analysis

O compilador decide se variáveis ficam na stack ou heap:

• Stack: rápido, limpo automaticamente
• Heap: quando variável “escapa” da função

go build -gcflags="-m" main.go  # ver decisões do compilador

18. Como implementar um worker pool?

func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {
                results <- processarJob(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}

19. O que são generics em Go?

Adicionados em Go 1.18, permitem código type-safe reutilizável.

func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

20. Como otimizar performance em Go?

• Profile com pprof
• Minimize alocações (sync.Pool)
• Use buffers adequados
• Prefira value receivers para structs pequenos
• Evite conversões string/[]byte desnecessárias

💡 Dicas para a Entrevista

1. Pratique código ao vivo — Muitas entrevistas pedem para escrever código
2. Entenda concorrência — É o diferencial do Go
3. Conheça a stdlib — net/http, encoding/json, context
4. Saiba debuggar — go vet, go test -race, pprof
5. Mostre projetos — Código no GitHub vale muito

Próximos Passos

• Veja vagas Go disponíveis — 718+ oportunidades no Brasil
• Como aprender Go — Guia completo para iniciantes

Última atualização: Janeiro 2026