Swift Academy · Aula

Listas de Captura e Weak Self

Evite ciclos de retenção com [weak self].

Aula 3 de 413 etapas

Listas de Captura e Weak Self é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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 risco do ciclo de retenção

Quando um objeto armazena um fechamento escapante que captura self fortemente, cada um mantém o outro vivo para sempre — um ciclo de retenção que causa vazamento de memória.

Um ciclo forte

O fechamento captura self fortemente e self mantém o fechamento — nenhum dos dois é liberado:

class Owner {
    var onEvent: (() -> Void)?
    func setup() {
        onEvent = { print(self.describe()) }  // strong self -> cycle
    }
    func describe() -> String { "Owner" }
}
let o = Owner(); o.setup()
o.onEvent?()  // "Owner"  (but leaks)

Listas de captura

Uma lista de captura no início de um fechamento { [weak self] in ... } controla como cada referência capturada é mantida: weak ou unowned, em vez de fortemente.

Quebrando o ciclo com self fraco

[weak self] captura self como um opcional que não o mantém vivo:

class Owner {
    var onEvent: (() -> Void)?
    func setup() {
        onEvent = { [weak self] in
            print(self?.describe() ?? "gone")
        }
    }
    func describe() -> String { "Owner" }
}
let o = Owner(); o.setup()
o.onEvent?()  // "Owner"  (no cycle)

A captura fraca torna self opcional

Com [weak self], self se torna Self?, então você deve desembrulhá-lo:

class Worker {
    var tag = "W"
    lazy var job: () -> Void = { [weak self] in
        guard let self = self else { return }
        print(self.tag)
    }
}
let w = Worker()
w.job()  // "W"

O padrão de reatribuição segura de self

Reassocie self logo no início para que o restante do fechamento use uma referência forte e não opcional:

class Service {
    var name = "S"
    lazy var run: () -> Void = { [weak self] in
        guard let self else { return }
        print(self.name)
        print("still \(self.name)")
    }
}
Service().run()  // "S" / "still S"

Captura fraca versus captura sem proprietário

weak produz um opcional e é seguro se o objeto puder ter desaparecido. unowned não é opcional e é mais rápido, mas causa uma falha se for acessado depois que o objeto for desalocado — use-o somente quando houver garantia de que self viverá mais que o fechamento.

Usando captura sem proprietário

Escolha unowned quando o fechamento não puder viver mais que self:

class Timer2 {
    var ticks = 0
    lazy var tick: () -> Void = { [unowned self] in
        self.ticks += 1
    }
}
let t = Timer2()
t.tick(); t.tick()
print(t.ticks)  // 2

Capturando propriedades específicas

Capture somente o que você precisa, em vez de todo o self — às vezes isso evita completamente o ciclo:

class VM {
    let id = 42
    lazy var printer: () -> Void = { [id] in print(id) }
}
VM().printer()  // 42

Fechamentos não escapantes não precisam de captura fraca

Closures síncronos e não escapantes (como map) não causam ciclos, então capturar self fortemente nesse caso é adequado:

class Calc {
    let factor = 3
    func scale(_ xs: [Int]) -> [Int] {
        xs.map { $0 * self.factor }   // safe, non-escaping
    }
}
print(Calc().scale([1, 2]))  // [3, 6]

Regra prática

Use [weak self] para closures armazenados ou escapantes que façam referência a self. Escolha unowned somente quando houver garantia de que self estará vivo. Não use listas de captura em closures não escapantes.

class P {
    var n = "P"
    var stored: (() -> Void)?
    func arm() { stored = { [weak self] in print(self?.n ?? "-") } }
}
let p = P(); p.arm(); p.stored?()  // "P"

Verificação rápida

Por que usar [weak self] em um fechamento escapante armazenado?

Responda na aula interativa

Recapitulação

Você aprendeu sobre listas de captura:

self forte em um fechamento escapante armazenado cria um ciclo de retenção (vazamento)
[weak self] o interrompe; self se torna opcional — use guard let self
unowned não é opcional e é mais rápido, mas causa uma falha se self tiver desaparecido
Closures não escapantes não precisam de listas de captura

Próximo: autoclosures.

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Listas de Captura e Weak Self” é grátis?

Sim — o texto completo de “Listas de Captura e Weak Self” é 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 “Listas de Captura e Weak Self”?

Evite ciclos de retenção com [weak self]. 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 3 de 4.

Quanto tempo leva a aula “Listas de Captura e Weak Self”?

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