21.11.2024

Aula 92: Introdução ao Combine

Combine é uma poderosa estrutura introduzida pela Apple para trabalhar com eventos assíncronos. Ela permite que os desenvolvedores lidem com eventos e mudanças ao longo do tempo de maneira funcional e declarativa. Nesta aula, exploraremos os conceitos fundamentais do Combine, incluindo publishers, subscribers e operators, com exemplos práticos de código.

O que é Combine?

Combine foi projetado para funcionar perfeitamente com Swift e oferece uma maneira de lidar com tarefas assíncronas usando uma abordagem funcional. Ele nos permite compor fluxos de trabalho complexos de processamento de eventos e gerenciar fluxos de dados assíncronos com facilidade.

Componentes Principais

1. Publishers

Um publisher é responsável por emitir uma sequência de valores ao longo do tempo. Ele define um fluxo de dados que pode ser observado.

2. Subscribers

Um subscriber escuta os valores de um publisher. Ele pode reagir a esses valores, erros ou eventos de conclusão.

3. Operators

O Combine oferece diversos operators que permitem transformar, filtrar e combinar os valores emitidos pelos publishers.

Configurando o Combine

Para usar o Combine em seu projeto Swift, certifique-se de importar a estrutura Combine:

import Combine

Criando um Publisher Simples

Vamos começar criando um publisher simples que emite valores inteiros:

import Combine

let publisher = [1, 2, 3, 4, 5].publisher

Aqui, criamos um publisher a partir de um array de inteiros. Esse publisher irá emitir cada inteiro do array sequencialmente.

Inscrevendo-se em um Publisher

Em seguida, precisamos de um subscriber para escutar os valores emitidos pelo nosso publisher. Podemos criar um subscriber usando o método sink:

let cancellable = publisher.sink { value in
    print("Recebido \(value)")
}

Neste exemplo, o subscriber imprime cada valor recebido no console. O cancellable é uma referência à assinatura que podemos usar para cancelá-la mais tarde, se necessário.

Tratando Conclusões e Erros

Além de receber valores, também podemos tratar conclusões e erros usando o método sink:

let publisherWithCompletion = Just("Olá, Combine!")
    .handleEvents(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Fluxo concluído com sucesso.")
        case .failure(let error):
            print("Fluxo falhou com erro: \(error)")
        }
    })
    .sink(receiveValue: { value in
        print("Recebido: \(value)")
    })

Neste exemplo, usamos o publisher Just, que emite um único valor e, em seguida, completa. Tratamos o evento de conclusão imprimindo se o fluxo foi concluído com sucesso ou se falhou com um erro.

Usando Operators

Os operators são um recurso essencial do Combine que nos permite manipular os valores emitidos pelos publishers. Vamos ver alguns operators comuns.

map

O operator map transforma os valores emitidos pelo publisher.

let numbersPublisher = [1, 2, 3, 4, 5].publisher

let mappedPublisher = numbersPublisher
    .map { $0 * 2 } // Dobrar cada número
    .sink { value in
        print("Valor mapeado: \(value)")
    }

Esse código imprime cada número do array multiplicado por dois.

filter

O operator filter permite que você receba apenas os valores que atendem a certos critérios.

let filteredPublisher = numbersPublisher
    .filter { $0 % 2 == 0 } // Apenas números pares
    .sink { value in
        print("Valor filtrado: \(value)")
    }

Aqui, apenas os números pares do array original serão impressos.

combineLatest

O operator combineLatest permite combinar múltiplos publishers e receber os últimos valores emitidos por cada um.

let firstPublisher = ["A", "B", "C"].publisher
let secondPublisher = [1, 2, 3].publisher

let combinedPublisher = Publishers.CombineLatest(firstPublisher, secondPublisher)
    .sink { (letter, number) in
        print("Valor combinado: \(letter) e \(number)")
    }

Neste exemplo, o publisher combinado irá emitir tuplas do último letra e número toda vez que um deles mudar.

Cancellables

Os cancellables são usados para gerenciar o ciclo de vida de uma assinatura. Quando você cria uma assinatura, deve mantê-la para preservar a assinatura. Se você não armazenar o cancellable, a assinatura será cancelada imediatamente.

var cancellables = Set<AnyCancellable>()

let cancellable = publisher
    .sink { value in
        print("Valor: \(value)")
    }
cancellables.insert(cancellable)

Neste caso, armazenamos o cancellable em um Set, que permite gerenciar múltiplas assinaturas facilmente.

Conclusão

O Combine fornece uma maneira poderosa e expressiva de lidar com eventos assíncronos em aplicações Swift. Seus publishers e subscribers, juntamente com uma variedade de operators, permitem que os desenvolvedores criem códigos robustos e fáceis de manter para lidar com fluxos de dados. À medida que você se familiariza mais com o Combine, descobrirá que ele é extremamente útil para tarefas envolvendo requisições de rede, entradas de usuário e gerenciamento do estado da aplicação.

Nesta aula, abordamos os componentes principais do Combine, como criar publishers e subscribers e alguns dos operators comuns disponíveis. Pratique experimentando com diferentes publishers e operators para aprofundar sua compreensão desta poderosa estrutura.

Video

Navigation