Swift Academy · Aula

Alternativas ao Padrão Observer

Compare-o com delegados e publishers do Combine.

Alternativas ao Padrão Observer é 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.

Alternativas ao padrão de observador

O NotificationCenter é uma forma de reagir a eventos. O Swift oferece outras: delegação, Combine e fluxos assíncronos. Cada opção se adapta a uma forma diferente de comunicação.

O padrão de observador

O padrão de observador permite que objetos se inscrevam em eventos de um subject. O NotificationCenter é uma implementação global e pouco acoplada desse padrão.

import Foundation

// Subject posts, observers react, neither holds the other.
NotificationCenter.default.post(name: Notification.Name("tick"), object: nil)
print("Broadcast an event")

Delegação

Um delegate é um vínculo de um para um: um objeto encaminha eventos específicos a um único delegate por meio de um protocolo. A relação é explícita e segura quanto ao tipo.

protocol DownloadDelegate: AnyObject {
    func didFinish(_ bytes: Int)
}
class Downloader {
    weak var delegate: DownloadDelegate?
    func finish() { delegate?.didFinish(1024) }
}
print("Delegate is one-to-one and typed")

Delegate versus notificação

Use um delegate quando exatamente um objeto se importar e a relação for clara. Use o NotificationCenter quando muitos observadores desconhecidos puderem reagir.

import Foundation

// One listener -> delegate. Many/unknown listeners -> NotificationCenter.
print("Cardinality guides the choice")

Publicadores do Combine

O Combine representa eventos como publicadores aos quais você se inscreve com sink, oferecendo operadores de transformação como map e filter.

import Combine

let subject = PassthroughSubject<Int, Never>()
let c = subject.sink { print("Got \($0)") }
subject.send(5)
_ = c

Publicador do NotificationCenter

O Combine integra o NotificationCenter: publisher(for:) transforma notificações em um fluxo que você pode transformar.

import Foundation
import Combine

let name = Notification.Name("ping")
let c = NotificationCenter.default.publisher(for: name)
    .sink { _ in print("Combine got notification") }
NotificationCenter.default.post(name: name, object: nil)
_ = c

Operadores do Combine

O ponto forte do Combine é compor fluxos de eventos: filtrar, aplicar debounce, combinar e transformar valores de forma declarativa.

import Combine

let subject = PassthroughSubject<Int, Never>()
let c = subject
    .filter { $0 > 0 }
    .map { $0 * 2 }
    .sink { print($0) }
subject.send(-1)
subject.send(3)
_ = c

Sequências assíncronas

O Swift moderno oferece AsyncStream e sequências assíncronas de notificações, permitindo consumir eventos com for await em concorrência estruturada.

import Foundation

func listen() async {
    let name = Notification.Name("ping")
    for await _ in NotificationCenter.default.notifications(named: name) {
        print("Async observed")
        break
    }
}
print("Can await notifications")

Fechamentos e retornos de chamada

Para um único retorno de chamada local, um fechamento armazenado é a opção mais simples, sem qualquer mecanismo de observação.

struct Button {
    var onTap: () -> Void
    func tap() { onTap() }
}
Button(onTap: { print("tapped") }).tap()

Escolha de uma abordagem

Delegate: um para um, explícito. NotificationCenter: muitos para muitos, desacoplado. Combine/assíncrono: fluxos que precisam de transformação. Fechamento: retornos de chamada locais simples.

import Foundation

// Match the tool to the communication shape.
print("Delegate, Notification, Combine, async, closure")

Compensações

O NotificationCenter é flexível, mas não é tipado e pode facilmente causar vazamentos. A delegação e o Combine são seguros quanto ao tipo; o Combine e o assíncrono oferecem mais recursos ao custo de mais conceitos.

import Foundation

// Prefer typed approaches when the relationship is known.
print("Type safety vs flexibility tradeoff")

Verificação rápida

Qual mecanismo é melhor para uma relação clara de um para um e segura quanto ao tipo?

Recapitulação

O padrão de observador tem várias formas no Swift: NotificationCenter para eventos desacoplados de muitos para muitos, delegação para vínculos tipados de um para um, Combine e sequências assíncronas para fluxos combináveis e fechamentos para retornos de chamada simples. Escolha de acordo com a forma da comunicação e as necessidades de segurança de tipos. Isso conclui o curso.

Perguntas Frequentes

A aula “Alternativas ao Padrão Observer” é grátis?

Sim — o texto completo de “Alternativas ao Padrão Observer” é 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 “Alternativas ao Padrão Observer”?

Compare-o com delegados e publishers do Combine. 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 “Alternativas ao Padrão Observer”?

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