Visão geral  Na estrutura Combine, um publicador é um tipo que está em conformidade com o protocolo do   . É responsável por fornecer um fluxo de valores aos assinantes. O protocolo   define dois tipos associados:   e   , que indicam os tipos de valores que o editor pode emitir e os tipos de erros que pode lançar, respectivamente. Publisher Publisher Output Failure  Um editor pode emitir um ou mais valores ao longo do tempo e também pode concluir ou falhar. Quando um assinante assina um editor, o editor chama o método   do assinante e passa a ele um objeto   , que o assinante pode usar para controlar o fluxo de valores. O assinante também pode chamar o método   no publicador para receber novos valores. receive(subscription:) Subscription receive(_:)  A estrutura Combine fornece vários editores integrados, como   ,   ,   ,   e   , que podem ser usados para criar vários tipos de editores. Além disso, você pode criar seus próprios editores personalizados em conformidade com o protocolo   e implementando os métodos necessários. Just Fail Empty Deferred Sequence Publisher  Os editores também podem ser compostos juntos para criar pipelines mais complexos. A estrutura Combine fornece vários operadores integrados que podem ser usados para modificar e combinar editores, como   ,   ,   ,   ,   e   . Esses operadores são fornecidos pela extensão do protocolo   e podem ser chamados em qualquer editor. map filter reduce flatMap zip merge Publisher  Agora eu gostaria de oferecer a vocês alguns editores úteis que eu uso em meus projetos.  Editor de cronômetro repetitivo  Para implementar um editor que usa um cronômetro de repetição com um intervalo personalizado no Swift, você pode usar a classe   da estrutura Foundation. Aqui está um exemplo de como você pode fazer isso: Timer    está em conformidade com o protocolo de   : RepeatingTimeSubscription Subscription   private class RepeatingTimerSubscription<S: Subscriber>: Subscription where S.Input == Void { private let interval: TimeInterval private let queue: DispatchQueue private var subscriber: S? private var timer: Timer? init(interval: TimeInterval, queue: DispatchQueue, subscriber: S) { self.interval = interval self.queue = queue self.subscriber = subscriber } func request(_ demand: Subscribers.Demand) { timer?.invalidate() timer = Timer.scheduledTimer( withTimeInterval: interval, repeats: true ) { [weak self] _ in self?.queue.async { _ = self?.subscriber?.receive() } } } func cancel() { timer?.invalidate() timer = nil subscriber = nil } }    está em conformidade com o protocolo do   : RepeatingTimePublisher Publisher   import Foundation import Combine final class RepeatingTimerPublisher: Publisher { typealias Output = Void typealias Failure = Never private let interval: TimeInterval private let queue: DispatchQueue init(interval: TimeInterval, queue: DispatchQueue = .main) { self.interval = interval self.queue = queue } func receive<S>(subscriber: S) where S: Subscriber, Failure == S.Failure, Output == S.Input { let subscription = RepeatingTimerSubscription( interval: interval, queue: queue, subscriber: subscriber ) subscriber.receive(subscription: subscription) } }  Para usar este editor, você pode criar uma instância dele e assiná-lo usando o método   do protocolo   . sink Publisher  Por exemplo:   private var cancellable: AnyCancellable? func subscribeOnTimer(interval: TimeInterval) { let publisher = RepeatingTimerPublisher(interval: interval) cancellable = publisher.sink { print("Timer fired!") } } //TEST THE METHOD subscribeOnTimer(interval: 5.0)  Isso imprimirá "Temporizador disparado!" a cada 5 segundos. Você pode cancelar a assinatura chamando o método   no objeto   que é retornado pelo método   . cancel AnyCancellable sink  Por exemplo:   deinit { cancellable?.cancel() }  Publicador de sondagem longa  Para implementar a sondagem longa usando a estrutura Combine no Swift, você pode criar um editor que faça uma solicitação de rede em um intervalo especificado e retorne a resposta como saída. Aqui está um exemplo de como você pode fazer isso:  Enumeração de erro personalizada para casos com falha.   enum CustomError: Error { case invalidResponse case invalidDecoding case error }    está em conformidade com o protocolo de   : LongPollingSubscription Subscription   private class LongPollingSubscription<S: Subscriber, Output: Decodable>: Subscription where S.Input == Output, S.Failure == CustomError { private let url: URL private let interval: TimeInterval private let decoder: JSONDecoder private var subscriber: S? private var timer: Timer? private var task: URLSessionDataTask? init( url: URL, interval: TimeInterval, subscriber: S, decoder: JSONDecoder = JSONDecoder() ) { self.url = url self.interval = interval self.subscriber = subscriber self.decoder = decoder } func request(_ demand: Subscribers.Demand) { timer?.invalidate() timer = Timer.scheduledTimer( withTimeInterval: interval, repeats: true ) { [weak self] _ in self?.makeRequest() } makeRequest() } func cancel() { timer?.invalidate() timer = nil task?.cancel() task = nil subscriber = nil } private func makeRequest() { task = URLSession.shared.dataTask(with: url) { [weak self] data, response, error in guard let self else { return } if let error = error as? S.Failure { self.subscriber?.receive( completion: .failure(error) ) return } guard let data else { self.subscriber?.receive( completion: .failure(.invalidResponse) ) return } do { let output = try self.decoder.decode( Output.self, from: data ) _ = self.subscriber?.receive(output) } catch { self.subscriber?.receive( completion: .failure(.invalidDecoding) ) } } task?.resume() } }    está em conformidade com o protocolo do   : LongPollingPublisher Publisher   final class LongPollingPublisher<Output: Decodable>: Publisher { typealias Failure = CustomError private let url: URL private let interval: TimeInterval init(url: URL, interval: TimeInterval) { self.url = url self.interval = interval } func receive<S>(subscriber: S) where S: Subscriber, Failure == S.Failure, Output == S.Input { let subscription = LongPollingSubscription( url: url, interval: interval, subscriber: subscriber ) subscriber.receive(subscription: subscription) } }    significa que você pode usar qualquer tipo genérico de resposta que esteja em conformidade com o protocolo   . <Output: Decodable> Decodable  Para testar, você precisa criar um modelo que esteja em conformidade   . Eu uso uma API pública por   . Decodable https://pixabay.com/api  Que seja a estrutura PhotoResponse:   struct PhotoResponse: Decodable { struct Photo: Decodable { let user: String let id: Int let largeImageURL: String } let hits: [Photo] let total: Int }  Para usar este editor, você pode criar uma instância dele e assiná-lo usando o método   do protocolo   . Por exemplo: sink Publisher   private var cancellable: AnyCancellable? private func pollingTest() { let url = URL(string: "https://pixabay.com/api/?key={your_key}")! let publisher = LongPollingPublisher<PhotoResponse>( url: url, interval: 5.0 ) cancellable = publisher.sink(receiveCompletion: { completion in switch completion { case .finished: print("Completed") case .failure(let error): print("Error: \(error)") } }, receiveValue: { response in print("Received response: \(response)") }) } //TEST THE METHOD pollingTest()  Mais uma coisa  Há vários editores personalizados úteis que podem ser criados usando a estrutura Combine no Swift. Aqui estão alguns exemplos:    : Um publicador que emite valores quando uma notificação especificada é postada no   . Você pode usar este editor para reagir a eventos específicos do sistema ou do aplicativo, como uma rotação de dispositivo ou uma alteração de status da rede. NotificationCenterPublisher NotificationCenter    : Um editor que emite valores quando o teclado é mostrado ou oculto. Você pode usar este editor para ajustar o layout de suas exibições quando o teclado é apresentado ou dispensado. KeyboardPublisher    : um publicador que emite valores quando a localização do usuário é alterada. Este editor pode ser usado para rastrear a localização do usuário e executar ações com base em sua localização. CoreLocationPublisher    : um publicador que emite valores quando um evento especificado ocorre em um   , como UIButton ou UITextField. Isso pode ser usado para lidar com as interações do usuário de maneira reativa. UIControlEventPublisher UIControl  Esses são apenas alguns exemplos dos tipos de editores personalizados que podem ser criados usando a estrutura Combine. A chave é entender os requisitos de seu aplicativo e usar os blocos de construção disponíveis fornecidos pela estrutura para criar editores que atendam a esses requisitos.  Para concluir  Por fim, é importante observar que o framework Combine usa o paradigma de programação reativa funcional, que é um modelo de programação que lida com fluxos de eventos ao longo do tempo. Os editores, juntamente com os assinantes e operadores, são os principais blocos de construção desse paradigma e facilitam a criação de aplicativos complexos e responsivos.

This story contains new, firsthand information uncovered by the writer.

Read My Stories

Este áudio é produzido no idioma original da história!

Editores úteis em Swift: um guia essencial

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

Liberando o poder da IA. Uma revisão sistemática de técnicas de ponta: resumo e introdução

Crescimento de Criptomoedas: Criando Personas de Usuários Eficazes

Quer ganhar um concurso de redação do HackerNoon? Aqui está o que os vencedores do concurso #crypto-api recomendam

Vazamento do prompt do sistema Claude Sonnet 3.5: uma análise forense

Liberando o poder da IA. Uma revisão sistemática de técnicas de ponta: resumo e introdução

Crescimento de Criptomoedas: Criando Personas de Usuários Eficazes

Quer ganhar um concurso de redação do HackerNoon? Aqui está o que os vencedores do concurso #crypto-api recomendam

Vazamento do prompt do sistema Claude Sonnet 3.5: uma análise forense

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps