Swift Academy · Aula

Remoção Segura de Observadores

Evite vazamentos e falhas causados por observadores obsoletos.

Remoção Segura de Observadores é 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.

Remoção segura de observadores

Os observadores devem ser removidos quando não forem mais necessários. Um observador pendente pode ser acionado depois que seu proprietário desaparecer, causando erros ou, com APIs antigas, falhas.

Por que a remoção é importante

Historicamente, os observadores baseados em seletor precisavam ser removidos em deinit para evitar o envio de mensagens a um objeto desalocado.

import Foundation

class Watcher: NSObject {
    override init() { super.init() }
    deinit { NotificationCenter.default.removeObserver(self) }
}
print("Removes itself on deinit")

removeObserver(self)

Chamar removeObserver(self) cancela, em uma única chamada, todas as observações feitas por esse objeto.

import Foundation

class VM: NSObject {
    func stop() { NotificationCenter.default.removeObserver(self) }
}
VM().stop()
print("Removed all observations for self")

Remoção de um nome específico

Você pode remover apenas uma observação passando o nome e o objeto, deixando as outras intactas.

import Foundation

let center = NotificationCenter.default
let obj = NSObject()
let name = Notification.Name("ping")
center.removeObserver(obj, name: name, object: nil)
print("Removed a specific observation")

Observadores baseados em token

O addObserver baseado em fechamento retorna um token opaco. Guarde-o e remova o observador usando esse token.

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("ping")
let token = center.addObserver(forName: name, object: nil, queue: nil) { _ in }
center.removeObserver(token)
print("Removed via token")

Armazenamento do token

Armazene o token em uma propriedade para que ele permaneça enquanto você quiser a observação e remova-o quando terminar.

import Foundation

class Model {
    var token: NSObjectProtocol?
    func start() {
        token = NotificationCenter.default.addObserver(
            forName: Notification.Name("x"), object: nil, queue: nil) { _ in }
    }
    func stop() {
        if let t = token { NotificationCenter.default.removeObserver(t) }
    }
}
let m = Model(); m.start(); m.stop()
print("Lifecycle managed")

Limpeza automática com deinit

Remova o token em deinit para que a observação termine quando o proprietário for desalocado.

import Foundation

class Owner {
    var token: NSObjectProtocol?
    deinit { if let t = token { NotificationCenter.default.removeObserver(t) } }
}
print("Token removed on deinit")

Observação sobre o ciclo de vida moderno

Em ambientes de execução recentes, os observadores adicionados com a API baseada em bloco são removidos automaticamente quando o token é desalocado, mas a remoção explícita ainda é a opção segura e clara.

import Foundation

// Holding the token in a property controls its lifetime.
class C { var token: NSObjectProtocol? }
print("Token lifetime equals observation lifetime")

Como evitar ciclos de retenção

Se um observador baseado em fechamento capturar self fortemente, use [weak self] para evitar um ciclo de retenção que impeça a desalocação.

import Foundation

class VM {
    var token: NSObjectProtocol?
    func start() {
        token = NotificationCenter.default.addObserver(
            forName: Notification.Name("x"), object: nil, queue: nil) { [weak self] _ in
            self?.handle()
        }
    }
    func handle() { print("handled") }
}
VM().start()

A remoção dupla é segura

Remover um observador que já foi eliminado não causa problemas, portanto a limpeza preventiva não provocará uma falha.

import Foundation

let center = NotificationCenter.default
let obj = NSObject()
center.removeObserver(obj)
center.removeObserver(obj) // no harm
print("Safe to remove twice")

Resumo das práticas recomendadas

Prefira fechamentos baseados em token, armazene o token, remova-o em deinit e capture self fracamente. Isso mantém corretos os ciclos de vida das observações.

import Foundation

class Best {
    var token: NSObjectProtocol?
    deinit { token.map { NotificationCenter.default.removeObserver($0) } }
}
print("Followed best practices")

Verificação rápida

Como você remove um observador baseado em fechamento adicionado com addObserver(forName:...)?

Recapitulação

Sempre remova os observadores de que você não precisa mais. Use removeObserver(self) para observadores baseados em seletor e o token retornado para observadores baseados em fechamento; armazene o token, faça a limpeza em deinit e capture self fracamente. Próximo: como o padrão de observador se compara às alternativas.

Perguntas Frequentes

A aula “Remoção Segura de Observadores” é grátis?

Sim — o texto completo de “Remoção Segura de Observadores” é 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 “Remoção Segura de Observadores”?

Evite vazamentos e falhas causados por observadores obsoletos. 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 “Remoção Segura de Observadores”?

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