Combine para Swift: guia completo com exemplos

O que é Combine e para que serve?

Combine é um framework da Apple para programação reativa, apresentado em 2019 junto com o iOS 13. Ele fornece uma API declarativa em Swift para processar eventos ao longo do tempo. O Combine permite combinar operadores de processamento de eventos assíncronos em cadeias de processamento de dados (pipeline).

A principal tarefa do Combine é simplificar o trabalho com operações assíncronas: requisições de rede, notificações, KVO (Key-Value Observing), temporizadores, delegados e funções de callback. Em vez de mecanismos dispersos, o Combine oferece uma interface unificada baseada em Publisher (publicador) e Subscriber (assinante).

Conceitos-chave:

\n
• Publisher — fonte de dados que pode enviar valores e ser finalizada (com sucesso ou erro).
\n
• Subscriber — receptor de dados que reage a eventos do Publisher.
\n
• Operator — método que transforma, filtra ou combina fluxos de dados.
\n
• Subscription — conexão entre Publisher e Subscriber que gerencia o fluxo de dados.
\n

O Combine é fortemente integrado com SwiftUI e Foundation, tornando-o indispensável para aplicativos iOS modernos.

Instalação

Combine é um framework embutido da Apple. Para usá-lo, não é necessário instalar pacotes adicionais via CocoaPods, SPM ou Carthage. Ele está disponível a partir do iOS 13, macOS 10.15, tvOS 13 e watchOS 6.

Para começar a usar o Combine, basta importá-lo em um arquivo Swift:

import Combine

Se você usa o Swift Package Manager para gerenciar dependências, o Combine já está incluído na biblioteca padrão. Para projetos que suportam versões mais antigas do SO, você pode usar o OpenCombine — uma implementação open-source do Combine.

Instalação do OpenCombine via SPM:

// Em Package.swift\ndependencies: [\n    .package(url: "https://github.com/CombineOpenSource/Combine.git", from: "0.5.0")\n]

Início rápido com exemplo de código

Vamos considerar um exemplo simples: criar um Publisher a partir de um array e assinar ele.

import Combine\n\n// 1. Criando um Publisher a partir de um array\nlet publisher = [1, 2, 3, 4, 5].publisher\n\n// 2. Criando um Subscriber\nlet subscriber = Subscribers.Sink<Int, Never>(\n    receiveCompletion: { completion in\n        print("Finalizado: \\(completion)")\n    },\n    receiveValue: { value in\n        print("Valor recebido: \\(value)")\n    }\n)\n\n// 3. Assinando\npublisher.subscribe(subscriber)

Saída no console:

Valor recebido: 1\nValor recebido: 2\nValor recebido: 3\nValor recebido: 4\nValor recebido: 5\nFinalizado: finished

Uma forma mais idiomática usando o operador sink:

import Combine\n\nlet cancellable = [1, 2, 3, 4, 5].publisher\n    .sink(receiveCompletion: { print($0) },\n          receiveValue: { print($0) })

Observe: sink retorna um AnyCancellable. Ele precisa ser mantido, caso contrário a assinatura será cancelada imediatamente após sair do escopo.

Métodos/funções principais

1. sink(receiveCompletion:receiveValue:)

O que faz: Cria um assinante que recebe todos os valores e a finalização do Publisher. Esta é a maneira mais simples de assinar um fluxo.

Parâmetros:

\n
• receiveCompletion — closure chamada na finalização (com sucesso ou erro). Recebe Subscribers.Completion<Failure>.
\n
• receiveValue — closure chamada ao receber cada novo valor.
\n

Exemplo:

let cancellable = Just("Hell