As entrevistas técnicas de Go avaliam o domínio dos conceitos centrais da linguagem: concorrência, gerenciamento de memória e padrões idiomáticos. Este guia cobre as 25 perguntas mais frequentes com respostas detalhadas e exemplos de código.

Dica para a entrevista

Go valoriza a simplicidade e a legibilidade. Os entrevistadores preferem respostas concisas que mostrem entendimento profundo em vez de soluções excessivamente complexas.

Fundamentos da linguagem Go

1. Qual é a diferença entre `var` e `:=`?

A declaração var permite especificar o tipo de forma explícita e funciona em nível de pacote. O operador := infere o tipo automaticamente, mas só funciona dentro de funções.

declaration.gogo

package main

// Package level - var required
var globalConfig = "production"

func main() {
    // var with explicit type
    var count int = 10

    // var with type inference
    var name = "Alice"

    // Short declaration - functions only
    age := 25

    // Multiple declarations
    var (
        host = "localhost"
        port = 8080
    )
}

A declaração curta := é a preferida dentro das funções pela concisão, enquanto var continua necessária para variáveis em nível de pacote.

2. Como funciona o sistema de tipos do Go?

Go usa tipagem estática com inferência de tipos. A linguagem distingue tipos por valor (copiados na atribuição) de tipos por referência (compartilham a estrutura subjacente).

types.gogo

package main

import "fmt"

func main() {
    // Value types - full copy
    a := [3]int{1, 2, 3}
    b := a          // Copies the array
    b[0] = 100      // Doesn't modify a
    fmt.Println(a)  // [1 2 3]

    // Reference types - share data
    slice1 := []int{1, 2, 3}
    slice2 := slice1    // Same underlying array
    slice2[0] = 100     // Also modifies slice1
    fmt.Println(slice1) // [100 2 3]

    // Maps are also references
    m1 := map[string]int{"a": 1}
    m2 := m1
    m2["a"] = 100
    fmt.Println(m1["a"]) // 100
}

Arrays são tipos por valor, enquanto slices, maps e channels são tipos por referência.

3. Explique a diferença entre arrays e slices

Arrays têm tamanho fixo definido em tempo de compilação. Slices são visões dinâmicas sobre um array subjacente, com três componentes: ponteiro, comprimento e capacidade.

arrays_slices.gogo

package main

import "fmt"

func main() {
    // Array - fixed size, value type
    arr := [5]int{1, 2, 3, 4, 5}

    // Slice - view over the array
    slice := arr[1:4]  // [2 3 4]
    fmt.Printf("len=%d, cap=%d\n", len(slice), cap(slice))
    // len=3, cap=4

    // Modifications affect original array
    slice[0] = 20
    fmt.Println(arr) // [1 20 3 4 5]

    // Direct creation with make
    dynamic := make([]int, 3, 10)
    // len=3, cap=10

    // Append may reallocate
    dynamic = append(dynamic, 1, 2, 3, 4, 5)
}

Slices são o tipo preferido para coleções dinâmicas em Go.

4. Como funciona a instrução `defer`?

defer agenda a chamada de uma função para o final da função que a contém. As chamadas adiadas são empilhadas e executadas em ordem LIFO (último a entrar, primeiro a sair).

defer.gogo

package main

import (
    "fmt"
    "os"
)

func main() {
    // LIFO order
    defer fmt.Println("1")
    defer fmt.Println("2")
    defer fmt.Println("3")
    // Prints: 3, 2, 1
}

// Typical use case: resource cleanup
func readFile(path string) ([]byte, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close() // Always executes

    // Read file...
    return os.ReadFile(path)
}

// Caution: arguments are evaluated immediately
func deferArgs() {
    x := 10
    defer fmt.Println(x) // Captures 10
    x = 20
    // Prints: 10
}

defer garante a execução mesmo durante um panic, o que o torna ideal para liberar recursos.

5. O que é uma interface em Go?

Uma interface define um conjunto de métodos. Qualquer tipo que implemente esses métodos satisfaz a interface implicitamente, sem necessidade de declaração explícita.

interfaces.gogo

package main

import "fmt"

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

// Type that implicitly implements Writer
type FileLogger struct {
    path string
}

func (f *FileLogger) Write(data []byte) (int, error) {
    // Write to file
    fmt.Println("Writing to", f.path)
    return len(data), nil
}

// Empty interface - accepts any type
func printAny(v interface{}) {
    fmt.Printf("Type: %T, Value: %v\n", v, v)
}

// Type assertion
func process(w Writer) {
    // Type check
    if fl, ok := w.(*FileLogger); ok {
        fmt.Println("FileLogger with path:", fl.path)
    }
}

A implementação implícita de interfaces permite um forte desacoplamento entre pacotes.

Concorrência e goroutines

6. O que é uma goroutine e como ela difere de uma thread?

Uma goroutine é uma thread leve gerenciada pelo runtime de Go. Ela usa alguns KB de stack (contra vários MB de uma thread do sistema) e o scheduler do Go multiplexa milhares de goroutines em poucas threads do sistema.

goroutines.gogo

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    // Launch 1000 goroutines
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            time.Sleep(100 * time.Millisecond)
            fmt.Printf("Goroutine %d finished\n", id)
        }(i) // Pass i by value
    }

    wg.Wait()
    fmt.Println("All goroutines completed")
}

Armadilha comum

Vale sempre passar por valor as variáveis de loop para as goroutines. Caso contrário, todas podem capturar o mesmo valor final.

7. Explique como funcionam os channels

Channels permitem comunicação e sincronização entre goroutines. Podem ser com buffer (com capacidade) ou sem buffer (síncronos).

channels.gogo

package main

import "fmt"

func main() {
    // Unbuffered channel - blocks until received
    ch := make(chan int)

    go func() {
        ch <- 42 // Blocks until read
    }()

    value := <-ch // Receives value
    fmt.Println(value)

    // Buffered channel - doesn't block until full
    buffered := make(chan string, 2)
    buffered <- "first"
    buffered <- "second"
    // buffered <- "third" // Would block

    fmt.Println(<-buffered) // "first"
    fmt.Println(<-buffered) // "second"
}

Channels sem buffer garantem sincronização, enquanto channels com buffer permitem desacoplamento temporal.

8. Como usar `select` com vários channels?

select aguarda várias operações de channel ao mesmo tempo. A primeira operação pronta é executada, com escolha aleatória em caso de empate.

select.gogo

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "from ch1"
    }()

    go func() {
        time.Sleep(200 * time.Millisecond)
        ch2 <- "from ch2"
    }()

    // Wait with timeout
    for i := 0; i < 2; i++ {
        select {
        case msg := <-ch1:
            fmt.Println(msg)
        case msg := <-ch2:
            fmt.Println(msg)
        case <-time.After(500 * time.Millisecond):
            fmt.Println("Timeout")
        }
    }

    // Non-blocking select with default
    select {
    case msg := <-ch1:
        fmt.Println(msg)
    default:
        fmt.Println("No message available")
    }
}

select é a ferramenta fundamental para gerenciar concorrência em Go com elegância.

9. Como evitar race conditions?

Race conditions ocorrem quando várias goroutines acessam dados compartilhados sem sincronização. Go oferece vários mecanismos de proteção.

race_conditions.gogo

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// Solution 1: Mutex
type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// Solution 2: RWMutex for read-heavy workloads
type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

func (c *Cache) Get(key string) string {
    c.mu.RLock()         // Multiple readers allowed
    defer c.mu.RUnlock()
    return c.data[key]
}

func (c *Cache) Set(key, value string) {
    c.mu.Lock()          // Single writer
    defer c.mu.Unlock()
    c.data[key] = value
}

// Solution 3: atomic for simple counters
var atomicCounter int64

func incrementAtomic() {
    atomic.AddInt64(&atomicCounter, 1)
}

func main() {
    // Detection: go run -race main.go
    counter := SafeCounter{}
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }

    wg.Wait()
    fmt.Println("Count:", counter.count)
}

A flag -race do compilador detecta race conditions em tempo de execução.

10. Explique o padrão worker pool

O padrão worker pool limita a concorrência criando um número fixo de goroutines que processam tarefas a partir de uma fila.

worker_pool.gogo

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        time.Sleep(100 * time.Millisecond) // Simulate work
        results <- job * 2
    }
}

func main() {
    const numJobs = 10
    const numWorkers = 3

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    var wg sync.WaitGroup

    // Start workers
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // Send jobs
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // Wait and close results
    go func() {
        wg.Wait()
        close(results)
    }()

    // Collect results
    for result := range results {
        fmt.Println("Result:", result)
    }
}

Esse padrão evita o consumo excessivo de memória e CPU causado por criar goroutines demais.

Pronto para mandar bem nas entrevistas de Go?

Pratique com nossos simuladores interativos, flashcards e testes tecnicos.

Explorar Go

Tratamento de erros e panic/recover

11. Como tratar erros em Go?

Go usa valores de retorno explícitos para erros, sem exceções. Por convenção, error é o último parâmetro retornado.

errors.gogo

package main

import (
    "errors"
    "fmt"
)

// Sentinel errors for comparison
var (
    ErrNotFound     = errors.New("resource not found")
    ErrUnauthorized = errors.New("access unauthorized")
)

// Custom error type
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation %s: %s", e.Field, e.Message)
}

func validateAge(age int) error {
    if age < 0 {
        return &ValidationError{
            Field:   "age",
            Message: "must be positive",
        }
    }
    return nil
}

func main() {
    // Basic check
    if err := validateAge(-5); err != nil {
        // Type assertion for custom error
        var valErr *ValidationError
        if errors.As(err, &valErr) {
            fmt.Printf("Field: %s\n", valErr.Field)
        }
    }

    // Sentinel error comparison
    err := findUser("unknown")
    if errors.Is(err, ErrNotFound) {
        fmt.Println("User not found")
    }
}

func findUser(id string) error {
    // Error wrapping with context
    return fmt.Errorf("findUser %s: %w", id, ErrNotFound)
}

Encapsular com %w encadeia os erros mantendo a possibilidade de testar o erro original.

12. Quando usar panic e recover?

panic interrompe o fluxo normal e desempilha a chamada. recover captura o panic em um defer e permite que a execução continue.

panic_recover.gogo

package main

import "fmt"

func safeOperation() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()

    riskyOperation()
    return nil
}

func riskyOperation() {
    // Simulates an operation that can panic
    panic("something went wrong")
}

// Legitimate use case: initialization validation
func MustCompileRegex(pattern string) *Regexp {
    r, err := regexp.Compile(pattern)
    if err != nil {
        panic(err) // Programming error
    }
    return r
}

func main() {
    err := safeOperation()
    if err != nil {
        fmt.Println("Recovered error:", err)
    }
    fmt.Println("Program continues")
}

Regra de ouro

Use panic apenas para erros de programação (invariantes violadas). Para erros previstos (arquivo ausente, falha de rede), o ideal é sempre retornar um error.

Structs, métodos e embedding

13. Qual é a diferença entre receivers por valor e por ponteiro?

Um receiver por valor recebe uma cópia do struct, enquanto um receiver por ponteiro recebe uma referência e pode modificar o original.

receivers.gogo

package main

import "fmt"

type Counter struct {
    value int
}

// Value receiver - works on copy
func (c Counter) GetValue() int {
    return c.value
}

// Pointer receiver - modifies original
func (c *Counter) Increment() {
    c.value++
}

// Pointer receiver for large structs (avoids copy)
type LargeStruct struct {
    data [1000]int
}

func (l *LargeStruct) Process() {
    // Avoids copying 8000 bytes
}

func main() {
    c := Counter{value: 0}
    c.Increment() // Go automatically converts
    fmt.Println(c.GetValue()) // 1

    // Careful with interfaces
    var _ fmt.Stringer = &c // OK if method on *Counter
}

Regra: se um método usa receiver por ponteiro, todos os métodos do tipo deveriam usar receiver por ponteiro por consistência.

14. Como funciona o embedding em Go?

O embedding inclui um tipo dentro de outro, herdando seus métodos e campos. Não é herança clássica, e sim composição.

embedding.gogo

package main

import "fmt"

type Logger struct {
    prefix string
}

func (l *Logger) Log(msg string) {
    fmt.Printf("[%s] %s\n", l.prefix, msg)
}

// Embedding Logger
type Service struct {
    *Logger // Pointer embedding
    name    string
}

func NewService(name string) *Service {
    return &Service{
        Logger: &Logger{prefix: name},
        name:   name,
    }
}

func main() {
    svc := NewService("API")

    // Promoted method - direct access
    svc.Log("Starting")

    // Explicit access also works
    svc.Logger.Log("Explicit")

    // Promoted field
    fmt.Println(svc.prefix) // "API"
}

O embedding permite composições flexíveis evitando a rigidez da herança.

15. Como implementar o padrão singleton em Go?

O pacote sync oferece sync.Once para garantir uma única execução da inicialização, mesmo com goroutines concorrentes.

singleton.gogo

package main

import (
    "fmt"
    "sync"
)

type Database struct {
    connectionString string
}

var (
    instance *Database
    once     sync.Once
)

func GetDatabase() *Database {
    once.Do(func() {
        fmt.Println("Single initialization")
        instance = &Database{
            connectionString: "postgres://...",
        }
    })
    return instance
}

func main() {
    // Concurrent calls - single initialization
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            db := GetDatabase()
            fmt.Printf("Instance: %p\n", db)
        }()
    }
    wg.Wait()
}

sync.Once é seguro em concorrência e mais elegante do que usar mutex com double-check locking.

Context e cancelamento

16. Para que serve o pacote context?

O pacote context gerencia deadlines, sinais de cancelamento e valores associados a uma requisição ao longo da árvore de chamadas.

context.gogo

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // Context with timeout
    ctx, cancel := context.WithTimeout(
        context.Background(),
        2*time.Second,
    )
    defer cancel() // Always call cancel

    result := make(chan string, 1)

    go func() {
        // Simulate long operation
        time.Sleep(3 * time.Second)
        result <- "completed"
    }()

    select {
    case res := <-result:
        fmt.Println(res)
    case <-ctx.Done():
        fmt.Println("Timeout:", ctx.Err())
    }
}

// Propagation through functions
func fetchData(ctx context.Context, url string) ([]byte, error) {
    // Early check
    if ctx.Err() != nil {
        return nil, ctx.Err()
    }

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }

    // HTTP client respects context
    resp, err := http.DefaultClient.Do(req)
    // ...
}

Toda função potencialmente longa deveria aceitar um context.Context como primeiro parâmetro.

17. Como fazer um graceful shutdown do programa?

Sinais do sistema, como SIGINT e SIGTERM, podem ser capturados para permitir um encerramento limpo.

graceful_shutdown.gogo

package main

import (
    "context"
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // Context cancelled on signal
    ctx, stop := signal.NotifyContext(
        context.Background(),
        syscall.SIGINT,
        syscall.SIGTERM,
    )
    defer stop()

    // Start server
    server := startServer()

    // Wait for signal
    <-ctx.Done()
    fmt.Println("\nShutting down...")

    // Timeout for graceful shutdown
    shutdownCtx, cancel := context.WithTimeout(
        context.Background(),
        5*time.Second,
    )
    defer cancel()

    if err := server.Shutdown(shutdownCtx); err != nil {
        fmt.Println("Shutdown error:", err)
    }

    fmt.Println("Shutdown complete")
}

Esse padrão garante que conexões ativas terminem corretamente antes do encerramento.

Testes e benchmarks

18. Como escrever testes em Go?

O pacote integrado testing fornece a funcionalidade básica. Os testes ficam em arquivos *_test.go.

calculator_test.gogo

package calculator

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", result)
    }
}

// Table-driven tests
func TestAddTableDriven(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive", 2, 3, 5},
        {"negative", -1, -1, -2},
        {"mixed", -1, 5, 4},
        {"zero", 0, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; want %d",
                    tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

Os table-driven tests são o padrão idiomático em Go para testar vários casos.

19. Como escrever benchmarks?

Benchmarks usam testing.B e são executados com go test -bench.

benchmark_test.gogo

package main

import (
    "strings"
    "testing"
)

func BenchmarkStringConcat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var s string
        for j := 0; j < 100; j++ {
            s += "a"
        }
    }
}

func BenchmarkStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        var sb strings.Builder
        for j := 0; j < 100; j++ {
            sb.WriteString("a")
        }
        _ = sb.String()
    }
}

// Typical results:
// BenchmarkStringConcat-8      50000    28000 ns/op
// BenchmarkStringBuilder-8   1000000     1200 ns/op

Benchmarks revelam diferenças de desempenho entre implementações.

Generics (Go 1.18+)

20. Como usar generics em Go?

O Go 1.18 introduziu parâmetros de tipo, permitindo escrever código genérico mantendo a segurança de tipos.

generics.gogo

package main

import "fmt"

// Generic function
func Map[T, U any](slice []T, fn func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

// Custom type constraint
type Number interface {
    int | int64 | float64
}

func Sum[T Number](values []T) T {
    var sum T
    for _, v := range values {
        sum += v
    }
    return sum
}

// Generic type
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

func main() {
    // Usage
    doubled := Map([]int{1, 2, 3}, func(n int) int {
        return n * 2
    })
    fmt.Println(doubled) // [2 4 6]

    fmt.Println(Sum([]int{1, 2, 3, 4, 5})) // 15

    stack := &Stack[string]{}
    stack.Push("hello")
    stack.Push("world")
    val, _ := stack.Pop()
    fmt.Println(val) // "world"
}

Os generics eliminam a necessidade de duplicar código ou usar interface{}.

Módulos e dependências

21. Como funciona o sistema de módulos do Go?

Os módulos do Go gerenciam dependências com versionamento semântico. O arquivo go.mod define o módulo e suas dependências.

go.mod examplego

module github.com/user/myproject

go 1.21

require (
    github.com/gin-gonic/gin v1.9.1
    github.com/lib/pq v1.10.9
)

// Essential commands:
// go mod init github.com/user/project
// go mod tidy        - clean dependencies
// go get package@v1.2.3 - add/update
// go mod vendor      - copy locally

bash

# Updating dependencies
go get -u ./...           # All dependencies
go get -u=patch ./...     # Patches only

O arquivo go.sum contém os checksums criptográficos para garantir a integridade das dependências.

22. Como estruturar um projeto Go?

A estrutura padrão segue convenções da comunidade sem impor regras estritas.

text

myproject/
├── cmd/
│   └── api/
│       └── main.go      # Entry point
├── internal/            # Private to module
│   ├── handler/
│   ├── service/
│   └── repository/
├── pkg/                 # Reusable external code
├── go.mod
├── go.sum
└── README.md

A pasta internal é especial: seu conteúdo não pode ser importado por outros módulos.

Perguntas avançadas

23. Como funciona o garbage collector em Go?

Go usa um garbage collector concorrente, do tipo tricolor mark-and-sweep, otimizado para baixa latência.

gc_optimization.gogo

package main

import "runtime"

func main() {
    // GC configuration
    // GOGC=100 (default) - triggers GC when heap doubles

    // Force GC
    runtime.GC()

    // Memory statistics
    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)

    println("Alloc:", stats.Alloc)
    println("NumGC:", stats.NumGC)
    println("PauseTotalNs:", stats.PauseTotalNs)
}

// Optimization techniques
// 1. Reuse allocations with sync.Pool
// 2. Pre-allocate slices with make([]T, 0, cap)
// 3. Avoid repeated string/[]byte conversions
// 4. Use pointers for large structs

A variável de ambiente GODEBUG=gctrace=1 exibe traços do GC.

24. Explique o scheduler do Go

O scheduler do Go usa um modelo M:N, mapeando N goroutines em M threads do sistema, com três entidades: G (goroutine), M (thread) e P (processador lógico).

scheduler.gogo

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // Number of logical processors (P)
    fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0))

    // Number of active goroutines
    fmt.Println("NumGoroutine:", runtime.NumGoroutine())

    // Yield processor to other goroutines
    runtime.Gosched()

    // M:P:G model
    // - G: goroutine (lightweight stack ~2KB)
    // - M: OS thread (machine)
    // - P: logical processor (execution context)
    //
    // Each P has a local queue of Gs
    // Work stealing when queue is empty
}

O scheduler é preemptivo desde a versão 1.14, evitando que uma goroutine monopolize um P.

25. Como otimizar o desempenho em Go?

A otimização começa com o profiling para identificar gargalos.

profiling.gogo

package main

import (
    "os"
    "runtime/pprof"
)

func main() {
    // CPU profiling
    f, _ := os.Create("cpu.prof")
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()

    // Code to profile...

    // Memory profiling
    mf, _ := os.Create("mem.prof")
    defer mf.Close()
    pprof.WriteHeapProfile(mf)
}

// Analysis: go tool pprof cpu.prof

// Common optimization techniques:
// 1. Avoid allocations in hot loops
// 2. Use sync.Pool for reusable objects
// 3. Prefer []byte over string for mutations
// 4. Use bufio for I/O
// 5. Batch database operations

Regra de otimização

O ideal é medir antes de otimizar. O profiling costuma revelar surpresas sobre os gargalos reais.

Conclusão

Estas 25 perguntas cobrem os conceitos fundamentais avaliados em entrevistas de Go:

Checklist de preparação:

✅ Domínio de goroutines e channels
✅ Compreensão das interfaces implícitas
✅ Tratamento idiomático de erros
✅ Uso adequado do context
✅ Padrões de concorrência (mutex, worker pool)
✅ Testes e benchmarks
✅ Conhecimento dos generics do Go 1.18+

A chave para se sair bem em uma entrevista de Go: demonstrar entendimento dos trade-offs entre simplicidade e desempenho, e saber quando aplicar cada padrão de concorrência.

Comece a praticar!

Teste seus conhecimentos com nossos simuladores de entrevista e testes tecnicos.

Criar minha conta gratis