Swift Academy · Aula

defer com Erros e Retornos Antecipados

Garanta a limpeza mesmo ao lançar um erro ou retornar antecipadamente.

defer com Erros e Retornos Antecipados é uma aula grátis de Swift 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 Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O adiamento é executado ao retornar

Um bloco defer é executado mesmo quando a função termina antecipadamente por meio de return.

func check(_ value: Int) {
    defer { print("cleanup ran") }
    if value < 0 {
        print("negative, returning early")
        return
    }
    print("value is", value)
}
check(-5)

Limpeza em todos os caminhos

Independentemente de qual return seja executado, a limpeza adiada é executada exatamente uma vez.

func classify(_ n: Int) {
    defer { print("done classifying") }
    if n == 0 { print("zero"); return }
    if n > 0 { print("positive"); return }
    print("negative")
}
classify(0)

O adiamento é executado ao lançar um erro

Quando uma função lança um erro, os adiamentos registrados ainda são executados enquanto o escopo é desfeito.

enum MyError: Error { case bad }
func risky(_ fail: Bool) throws {
    defer { print("cleanup on the way out") }
    if fail { throw MyError.bad }
    print("no failure")
}
try? risky(true)

Combinando retorno e lançamento de erro

Independentemente de a função retornar normalmente ou lançar um erro, o mesmo adiamento é executado.

enum E: Error { case oops }
func op(_ flag: Bool) throws -> Int {
    defer { print("op finishing") }
    if flag { throw E.oops }
    return 42
}
let r = try? op(false)
print(r ?? -1)

Limpeza antes da propagação do erro

O adiamento é executado antes de o erro lançado chegar ao chamador, portanto os recursos são liberados primeiro.

enum E: Error { case fail }
func load(_ broken: Bool) throws {
    print("open")
    defer { print("close") }
    if broken { throw E.fail }
    print("read")
}
do {
    try load(true)
} catch {
    print("caught:", error)
}

Proteção com adiamento

Um padrão comum: adquirir, adiar a limpeza e então usar guard, com retornos antecipados que ainda acionam a limpeza.

func process(_ items: [Int]) {
    print("start")
    defer { print("finished") }
    guard !items.isEmpty else {
        print("nothing to do")
        return
    }
    print("processing", items.count, "items")
}
process([])

Adiamento e laços que lançam erros

Um adiamento dentro de um laço é executado ao final de cada iteração, mesmo que uma instrução posterior lance um erro.

enum E: Error { case stop }
func loop() throws {
    for i in 1...3 {
        defer { print("end", i) }
        if i == 2 { throw E.stop }
        print("body", i)
    }
}
try? loop()

Ordem com retorno antecipado

Vários adiamentos ainda são executados na ordem LIFO em um retorno antecipado.

func multi(_ skip: Bool) {
    defer { print("A") }
    defer { print("B") }
    if skip { return }
    print("body")
}
multi(true)

Registro em caso de falha

Utilize o adiamento para fazer log de conclusão ou falha de forma consistente em todos os caminhos de saída.

enum E: Error { case bad }
func attempt(_ fail: Bool) throws {
    var success = false
    defer { print("attempt success:", success) }
    if fail { throw E.bad }
    success = true
}
try? attempt(true)

Restaurando o estado ao lançar um erro

O adiamento é ideal para reverter um estado temporário quando uma operação lança um erro.

enum E: Error { case fail }
func transaction(_ fail: Bool) throws {
    var inProgress = true
    defer { inProgress = false; print("inProgress:", inProgress) }
    if fail { throw E.fail }
    print("committed")
}
try? transaction(true)

Prática recomendada

Confie em defer para a limpeza que precisa sobreviver a retornos antecipados e erros lançados, para que nenhum caminho de saída cause vazamentos de recursos.

enum E: Error { case x }
func safe(_ fail: Bool) throws {
    print("acquire")
    defer { print("release") }
    if fail { throw E.x }
    print("use")
}
try? safe(true)

Verificação rápida

Teste o adiamento com erros e retornos.

Recapitulação

defer é executado em toda saída de escopo, incluindo um return antecipado e um erro lançado, antes de o erro se propagar. Isso faz dele o local confiável para limpeza e restauração do estado em todos os caminhos de saída, preservando a ordenação LIFO.

func f(_ skip: Bool) {
    defer { print("cleanup") }
    if skip { return }
    print("work")
}
f(true)

Perguntas Frequentes

A aula “defer com Erros e Retornos Antecipados” é grátis?

Sim — o texto completo de “defer com Erros e Retornos Antecipados” é 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 Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “defer com Erros e Retornos Antecipados”?

Garanta a limpeza mesmo ao lançar um erro ou retornar antecipadamente. Você pratica Swift 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 Swift Academy?

Nenhuma experiência prévia é necessária. Swift 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 com Erros e Retornos Antecipados”?

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 Swift Academy?

Sim. Cada aula de Swift 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 Swift Academy