Swift Academy · Aula

Referências weak e unowned

Escolha entre weak (Optional) e unowned (não Optional) para quebrar ciclos.

Referências weak e unowned é 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.

Boas-vindas

Romper ciclos de retenção exige referências que não incrementem a contagem do ARC. Swift oferece duas: `weak` (opcional, zerada automaticamente) e `unowned` (não opcional, insegura se for nula).

Referências fracas

```swift class Owner { var pet: Pet? } class Pet { weak var owner: Owner? } // does not retain var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p p?.owner = o o = nil // Owner deinit — p.owner becomes nil automatically ```

Referências fracas são sempre opcionais

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` deve ser `var` e opcional — Swift o zera automaticamente quando o objeto referenciado é desalocado.

Referências não proprietárias

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` não retém o objeto e não é opcional — você garante que o objeto referenciado sobreviverá a este objeto.

Escolhendo entre referências fracas e não proprietárias

| Cenário | Uso | |---|---| | O objeto referenciado pode se tornar nulo | `weak` | | O objeto referenciado sempre sobrevive a este objeto | `unowned` | | Não tem certeza | `weak` (mais seguro) |

Acessando uma referência não proprietária após a desalocação

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` Nunca acesse `unowned` depois que o objeto referenciado for desalocado.

Referência fraca de self em fechamentos

```swift class VC { func load() { api.fetch { [weak self] data in guard let self else { return } self.render(data) } } } ``` `[weak self]` é a correção mais comum para ciclos de retenção em Swift.

Referência não proprietária de self em fechamentos

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` Use `[unowned self]` somente quando tiver certeza de que `self` não será nulo quando o fechamento for executado.

Zeragem automática observada

```swift class Timer { weak var delegate: TimerDelegate? } var d: TimerDelegate? = ConcreteDelegate() let t = Timer() t.delegate = d d = nil print(t.delegate) // nil — automatically zeroed ```

Boa prática para o padrão de delegado

Sempre declare as propriedades de delegado como `weak`: ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` A restrição `AnyObject` é necessária para usar `weak` com protocolos.

Verificação rápida

Qual tipo de referência é definido automaticamente como `nil` quando o objeto referenciado é desalocado?

Recapitulação

Principais conclusões: • `weak` — opcional, zerada automaticamente e segura • `unowned` — não opcional, garante que o objeto sobreviva e causa uma falha se essa garantia estiver errada • Padrões de delegado: sempre `weak var delegate: Protocol?` com restrição `AnyObject` • Fechamentos: `[weak self]` é o padrão; use `guard let self` internamente • Em caso de dúvida, escolha `weak` em vez de `unowned` Próximo: listas de captura de fechamentos.

Perguntas Frequentes

A aula “Referências weak e unowned” é grátis?

Sim — o texto completo de “Referências weak e unowned” é 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 “Referências weak e unowned”?

Escolha entre weak (Optional) e unowned (não Optional) para quebrar ciclos. 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 “Referências weak e unowned”?

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