Por que esses operadores são importantes?

Programação reativa com combine

• Publishers: são fontes de dados que podem emitir valores ao longo do tempo.

• Subscribers: consomem os dados emitidos pelos publishers, permitindo a manipulação ou apresentação.

Com essa estrutura, você pode transformar, combinar e operar sobre os dados de formas sofisticadas. Agora, vamos aos operadores.

Operador flatMap: transformação e concatenamento de fluxos

O operador flatMap permite transformar um publisher em outro. Isso é útil quando o fluxo original precisa ser transformado em vários subfluxos e, em seguida, concatenado em um único fluxo.

Exemplo prático: consulta de dados da Rocketseat

let cursosPublisher = PassthroughSubject<String, Never>()

cursosPublisher
    .flatMap { curso in
        fetchDetalhesDoCurso(curso) // Função que retorna um Publisher
    }
    .sink(receiveValue: { detalhes in
        print("Detalhes do curso: \(detalhes)")
    })

cursosPublisher.send("Swift Avançado")

Aqui, cada curso enviado pelo cursosPublisher desencadeia uma consulta para buscar detalhes, e o flatMap combina os resultados em um único fluxo.

Operador merge: fluxos em paralelo

O operador merge permite combinar vários publishers em um único, emitindo os valores à medida que eles chegam.

Exemplo prático: notificações em múltiplos canais

let slackPublisher = PassthroughSubject<String, Never>()
let discordPublisher = PassthroughSubject<String, Never>()

slackPublisher
    .merge(with: discordPublisher)
    .sink(receiveValue: { mensagem in
        print("Nova mensagem: \(mensagem)")
    })

slackPublisher.send("Nova mensagem no Slack")
discordPublisher.send("Nova mensagem no Discord")

Com o merge, você cria um único fluxo que consolida as mensagens dos dois canais.

Operador combineLatest: combinação de últimos valores

O combineLatest combina os valores mais recentes de dois (ou mais) publishers em um único fluxo, emitindo um valor sempre que qualquer um dos publishers atualiza seus dados.

Exemplo prático: dados combinados de cursos e eventos

let cursoPublisher = CurrentValueSubject<String, Never>("Swift Avançado")
let eventoPublisher = CurrentValueSubject<String, Never>("NLW 2025")

cursoPublisher
    .combineLatest(eventoPublisher)
    .sink { curso, evento in
        print("Curso: \(curso) | Evento: \(evento)")
    }

cursoPublisher.send("Node.js Completo")
eventoPublisher.send("Next Level Week")

Aqui, a combinação dos últimos valores dos dois publishers permite exibir informações atualizadas para o usuário.

Boas práticas ao usar esses operadores

1. Mantenha a simplicidade:
Embora poderosos, esses operadores podem tornar o código confuso se mal utilizados. Mantenha as transformações e combinações simples, dividindo operações mais complexas em etapas menores. Isso torna o código mais legível e fácil de depurar.

2. Use nomes descritivos:
Nomeie bem seus publishers, subscribers e closures. Por exemplo, em vez de publisher1, use algo como cursosPublisher. Nomes descritivos ajudam a identificar rapidamente o que cada fluxo de dados representa, facilitando o entendimento do código, especialmente em equipes maiores.

3. Teste exaustivamente:
Fluxos assíncronos podem gerar comportamentos inesperados, especialmente quando combinados. Crie testes unitários para validar as transformações e combinações. Teste cenários como falhas, ausência de dados e múltiplas emissões simultâneas.

4. Gerencie assinaturas com cuidado:
Certifique-se de que suas assinaturas sejam gerenciadas corretamente para evitar vazamento de memória. Use ferramentas como o Cancellable do Combine para cancelar assinaturas quando não forem mais necessárias.

5. Evite loops infinitos:
Quando publishers dependem de outros publishers para emitir dados, pode ocorrer um ciclo de dependência, gerando um loop infinito. Certifique-se de que os operadores sejam configurados para evitar esses cenários.

6. Comente intenções complexas:
Se uma combinação ou transformação for especialmente intrincada, adicione comentários explicando o objetivo do código. Isso facilita a manutenção e ajuda outros desenvolvedores a compreenderem a lógica por trás dos operadores.

7. Aproveite o playground do Swift:
Antes de implementar os operadores em um projeto maior, experimente-os no Swift Playground. Essa abordagem permite testar e refinar sua lógica sem interferir diretamente no código do projeto.

8. Documente padrões de fluxo de dados:
Se o projeto utiliza padrões reativos extensivamente, documente como os fluxos de dados são organizados e manipulados. Isso cria um guia útil para novos desenvolvedores que se juntarem à equipe.

9. Use ferramentas de depuração do Combine:
O framework Combine oferece recursos de depuração que ajudam a monitorar o comportamento de publishers e subscribers. Utilize métodos como .print() para rastrear a emissão de eventos durante o desenvolvimento.

10. Adote boas práticas de design reativo:
Projete fluxos de dados que sejam previsíveis e fáceis de acompanhar. Evite criar dependências excessivas entre publishers, pois isso pode dificultar a compreensão e manutenção do sistema.

Ao aplicar essas práticas, você não apenas aproveita o máximo do poder dos operadores flatMap, merge e combineLatest, mas também garante que seu código será robusto, legível e sustentável a longo prazo.

Próximos passos

Para avançar ainda mais, confira a formação Swift da Rocketseat. Além disso, participe da nossa comunidade no Discord para trocar ideias com outros devs.

Material extra

• flatMap: Documentação Apple - flatMap

• merge: Documentação Apple - merge

• combineLatest: Documentação Apple - combineLatest

Essas referências fornecem detalhes adicionais, exemplos e casos de uso avançados, ajudando você a dominar completamente esses operadores no seu fluxo de desenvolvimento.

Conclusão