Go Academy · Aula

defer, funções anônimas e closures

Chamadas adiadas e valores de função

defer, funções anônimas e closures é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

defer: execução adiada

defer agenda uma chamada de função para ser executada quando a função envolvente retornar — independentemente de como ela retorne (normalmente, com erro ou por pânico):

func readFile(path string) {
    f, err := os.Open(path)
    if err != nil { return }
    defer f.Close() // runs when readFile returns
    // read from f...
}

Ordem de avaliação de defer

As chamadas adiadas são empilhadas em uma pilha e executadas na ordem LIFO (último a entrar, primeiro a sair):

func main() {
    defer fmt.Println("third")
    defer fmt.Println("second")
    defer fmt.Println("first")
    // Output: first, second, third
}

defer para limpeza

defer é a forma idiomática de garantir que os recursos sejam liberados:

Aplique Unlock a um mutex depois de bloqueá-lo
Aplique Close a um arquivo depois de abri-lo
Confirme ou desfaça uma transação do banco de dados
Chame WaitGroup.Done() depois de WaitGroup.Add()

defer com argumentos

Os argumentos de uma chamada adiada são avaliados imediatamente, quando defer é chamado, e não quando ele é executado:

x := 10
defer fmt.Println(x) // prints 10, not 20
x = 20
fmt.Println(x)       // prints 20

Funções anônimas

Funções anônimas (literais de função) são definidas diretamente, sem um nome:

double := func(n int) int {
    return n * 2
}
fmt.Println(double(5)) // 10

// Immediately invoked:
result := func(a, b int) int { return a + b }(3, 4)

Fechamentos

Um fechamento é uma função que captura variáveis do escopo ao seu redor:

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

ctr := makeCounter()
fmt.Println(ctr(), ctr(), ctr()) // 1 2 3

Armadilha da captura de fechamentos em laços

Fechamentos capturam variáveis por referência — um erro comum em laços de gorrotinas:

for i := 0; i < 3; i++ {
    i := i // create a new variable per iteration
    go func() { fmt.Println(i) }()
}

defer com retornos nomeados

Funções adiadas podem modificar valores de retorno nomeados — algo útil para adicionar informações aos erros:

func doWork() (err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("doWork: %w", err)
        }
    }()
    return riskyOp()
}

Padrões funcionais com fechamentos

Fechamentos permitem padrões funcionais, como a memoização:

func memoize(f func(int) int) func(int) int {
    cache := map[int]int{}
    return func(n int) int {
        if v, ok := cache[n]; ok {
            return v
        }
        v := f(n)
        cache[n] = v
        return v
    }
}

Fechamentos como intermediários

Fechamentos são os blocos fundamentais para intermediários em servidores HTTP do Go — eles envolvem um manipulador e adicionam comportamento ao redor dele:

func withLogging(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL)
        next(w, r)
    }
}

Verificação rápida

Quando os argumentos de uma chamada de função adiada são avaliados?

Recapitulação: defer, fechamentos e funções anônimas

Esses recursos tornam o código Go expressivo e seguro:

defer garante a limpeza ao sair da função — na ordem LIFO
Os argumentos de defer são avaliados imediatamente
Funções anônimas podem ser atribuídas a variáveis ou chamadas diretamente
Fechamentos capturam variáveis ao redor por referência
Fique atento a erros de captura de variáveis de laço em gorrotinas

Próximo curso: vetores, fatias e mapas.

Perguntas Frequentes

A aula “defer, funções anônimas e closures” é grátis?

Sim — o texto completo de “defer, funções anônimas e closures” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “defer, funções anônimas e closures”?

Chamadas adiadas e valores de função Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “defer, funções anônimas e closures”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy