Swift Academy · Aula

Listas de captura de closures e [weak self]

Use listas de captura para impedir que closures mantenham objetos fortemente capturados.

Listas de captura de closures e [weak self] é 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.

Boas-vindas

Os fechamentos capturam variáveis do escopo ao redor. As listas de captura (`[weak self]`, `[unowned self]`, `[value]`) controlam exatamente como essas capturas são feitas.

Captura forte padrão

```swift var name = "Alice" let greet = { print("Hello, \(name)") } name = "Bob" greet() // "Hello, Bob" — closure sees current value ``` Por padrão, os fechamentos capturam *referências* a variáveis.

Noções básicas das listas de captura

```swift var count = 10 let snapshot = { [count] in print(count) } // captures value count = 99 snapshot() // 10 — snapshot of count at capture time ``` Listar um tipo de valor em `[]` copia o valor no momento em que o fechamento é criado.

Padrão de referência fraca de self

```swift class API { func fetch(completion: @escaping () -> Void) { ... } } class VC { func load() { api.fetch { [weak self] in guard let self else { return } // self might be nil by now self.updateUI() } } } ```

guard let self com tempo de vida estendido

Swift 5.3+: redefina `self` dentro do guard sem ocultá-lo: ```swift { [weak self] in guard let self else { return } // 'self' is now strong within this block doA() doB() doC() } ```

Quando [unowned self] é seguro

```swift button.addTarget(self, action: #selector(tap), for: .touchUpInside) // If the button's closure is guaranteed not to outlive self: let action: () -> Void = { [unowned self] in self.handleTap() } ```

Capturando vários valores

```swift let base = 100 let multiplier = 2 let compute = { [base, multiplier] in base * multiplier } print(compute()) // 200 ``` Capture vários valores na mesma lista, separando-os por vírgulas.

Lista de captura com associações nomeadas

```swift let myService = service // rename in capture list: let handler = { [service = myService] in service.process() } ``` Útil para capturar um instantâneo específico com um novo nome.

Com escape versus sem escape

• Um fechamento `@escaping` pode ser armazenado e chamado depois que a função retorna → risco de ciclos • Um fechamento que não escapa é chamado antes que a função retorne → não há risco de ciclos ```swift func apply(_ f: () -> Void) { f() } // non-escaping, no [weak] needed func later(_ f: @escaping () -> Void) { queue.async { f() } } // escaping ```

Depurando problemas de captura

Se suspeitar de um ciclo: 1. Adicione `deinit { print("deallocated") }` à classe 2. Navegue para outra tela ou defina a instância como nil 3. Se deinit não imprimir nada → existe um ciclo Depois, adicione `[weak self]` aos fechamentos dessa classe.

Verificação rápida

O que `[weak self]` em uma lista de captura faz?

Recapitulação

Principais conclusões: • Os fechamentos capturam referências por padrão • A lista de captura `[value]` copia tipos de valor no momento da criação • `[weak self]` — não retém, torna-se nulo automaticamente; use `guard let self` • `[unowned self]` — não retém e não é segura contra nulos • Fechamentos `@escaping` precisam de listas de captura; os que não escapam geralmente não precisam Curso concluído! Próximo: programação funcional em Swift.

Perguntas Frequentes

A aula “Listas de captura de closures e [weak self]” é grátis?

Sim — o texto completo de “Listas de captura de closures 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 de closures e [weak self]”?

Use listas de captura para impedir que closures mantenham objetos fortemente capturados. 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 “Listas de captura de closures 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

Como o ARC conta referências
Ciclos de retenção: causas e detecção
Referências weak e unowned
Listas de captura de closures e [weak self]

← Voltar para Swift Academy