Como passar na entrevista de Go: principais perguntas e respostas

Como passar em uma entrevista de Go: principais perguntas

Go (Golang) é uma das linguagens mais requisitadas para criar aplicações server-side de alta carga e microsserviços. A entrevista para a posição de desenvolvedor Go geralmente testa não apenas o conhecimento da sintaxe, mas também a compreensão do funcionamento interno: goroutines, channels, interfaces e gerenciamento de memória. Neste artigo, vamos analisar as 10 principais perguntas mais frequentes em entrevistas, com exemplos de código e explicações.

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

Esta é uma pergunta clássica para testar a compreensão dos fundamentos do Go.

• Array — é uma sequência fixa de elementos do mesmo tipo. O tamanho do array faz parte do seu tipo.
• Slice — é uma estrutura dinâmica que faz referência a um array subjacente. O slice pode crescer e alterar seu tamanho.

// Array — tamanho fixovar arr [3]int = [3]int{1, 2, 3}// Slice — dinâmicovar slc []int = []int{1, 2, 3}

// Importante: arr e [4]int são tipos diferentes// Slices são passados por referência (ponteiro para o array subjacente)

Dica: Se precisar alterar o comprimento, use slice. Se precisar de garantia de tamanho fixo, use array.

2. O que são goroutines e como funcionam?

Uma goroutine é uma linha de execução leve, gerenciada pelo runtime do Go. Diferente das threads do sistema operacional (OS threads), as goroutines têm uma pilha menor (a partir de 2 KB) e alternam rapidamente.

• Iniciar uma goroutine: go func()
• As goroutines operam no mesmo espaço de endereçamento, portanto, o acesso a dados compartilhados precisa ser sincronizado (através de channels ou mutexes).

package main

import (    "fmt"    "time")

func printNumbers() {    for i := 1; i <= 5; i++ {        time.Sleep(100 * time.Millisecond)        fmt.Println(i)    }}

func main() {    go printNumbers() // inicia a goroutine    time.Sleep(1 * time.Second) // aguarda a conclusão    fmt.Println("Main done")}

Importante: A função principal não espera a conclusão das goroutines. Para sincronização, use sync.WaitGroup ou channels.

3. Como funcionam os channels?

Channels são "tubos" tipados através dos quais as goroutines trocam dados. Eles garantem a transferência segura de dados sem bloqueios explícitos.

• Channel não bufferizado: O remetente é bloqueado até que o destinatário leia os dados.
• Channel bufferizado: O remetente só é bloqueado quando o buffer está cheio.

ch := make(chan int)    // não bufferizadochBuf := make(chan int, 3) // bufferizado (capacidade 3)

// Enviogo func() {    ch <- 42}()

// Recebimentovalue := <-chfmt.Println(value)

// Fechar o channelclose(ch)// Ler de um channel fechado retorna o valor zero

Pergunta frequente: O que acontece se ler de um channel nil? — Resposta: A goroutine será bloqueada para sempre (deadlock).

4. O que são interfaces em Go e como diferem de outras linguagens?

Uma interface em Go é um conjunto de métodos. Diferente de Java ou C#, a implementação de interface em Go é implícita (duck typing): um tipo satisfaz automaticamente a interface se implementar todos os seus métodos.

type Speaker interface {    Speak() string}

type Dog struct{}func (d Dog) Speak() string { return "Woof!" }

type Cat struct{}func (c Cat) Speak() string { return "Meow!" }

func makeSound(s Speaker) {    fmt.Println(s.Speak())}

func main() {    makeSound(Dog{}) // Woof!    makeSound(Cat{}) // Meow!}

Por que isso é importante: Permite escrever código flexível e com baixo acoplamento. A interface vazia interface{} (ou any no Go 1.18+) pode armazenar um valor de qualquer