0Pricing
Swift Academy · Aula

Operadores de Tratamento de Erros

Recupere-se com catch, retry e replaceError.

Operadores de Tratamento de Erros é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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.

Erros no Combine

Os publishers do Combine têm um tipo de falha. Quando um publisher falha, ele encerra o fluxo — nenhum outro valor é emitido. Para criar fluxos resilientes, você precisa de operadores que tratem, transformem ou recuperem os fluxos após erros.

O tipo de falha

Todo publisher declara um Output e um Failure. Um fluxo só é compilado quando os tipos de erro são compatíveis; por isso, são comuns os operadores que alteram as falhas.

let publisher: AnyPublisher<Data, URLError> = apiClient.request()
// Output = Data, Failure = URLError

capturar

capturar intercepta uma falha e substitui o publisher que falhou por um novo. Isso permite fornecer valores alternativos quando algo dá errado.

apiClient.fetchUser()
    .catch { error in
        Just(User.guest)
    }
    .sink { user in
        print("Got", user.name)
    }
    .store(in: &cancellables)

replaceError

replaceError(with:) é uma forma mais simples de capturar: troca qualquer falha por um único valor alternativo e é concluído com sucesso.

apiClient.fetchCount()
    .replaceError(with: 0)
    .sink { count in
        self.badge.text = "\(count)"
    }
    .store(in: &cancellables)

retry

retry(n) faz uma nova inscrição no fluxo a montante até n vezes quando ele falha. É ideal para erros de rede temporários.

apiClient.fetchData()
    .retry(3)
    .sink(receiveCompletion: { print($0) },
          receiveValue: { print($0) })
    .store(in: &cancellables)

Combinando retry e captura

Um padrão comum de resiliência: execute retry algumas vezes e, depois, use catch como alternativa se todas as tentativas falharem.

apiClient.fetchData()
    .retry(2)
    .catch { _ in
        Just(Data())
    }
    .sink { data in
        self.process(data)
    }
    .store(in: &cancellables)

mapError

mapError transforma um tipo de erro em outro. Isso é essencial para unificar diferentes falhas das fontes anteriores em um único tipo de erro no nível do aplicativo.

enum AppError: Error { case network }

apiClient.request()
    .mapError { _ in AppError.network }
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    .store(in: &cancellables)

Por que mapError é importante

Quando combina publicadores, seus tipos de Failure precisam ser iguais. mapError normaliza erros incompatíveis para que operadores como merge e zip sejam compilados e para que seu sink trate um único tipo de erro.

setFailureType

Alguns publicadores, como Just, têm o tipo de falha Never. setFailureType(to:) faz a ponte para que eles possam ser combinados com publicadores que falham.

Just(42)
    .setFailureType(to: AppError.self)
    .merge(with: failablePublisher)
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    .store(in: &cancellables)

Tratando a conclusão

Em sink, a função de conclusão informa se o fluxo terminou ou falhou. Inspecione-a para reagir a erros que não foram recuperados nas fontes anteriores.

publisher.sink(
    receiveCompletion: { completion in
        if case .failure(let error) = completion {
            self.showAlert(error)
        }
    },
    receiveValue: { value in
        self.update(value)
    }
).store(in: &cancellables)

Projetando fluxos resilientes

Boas práticas para o tratamento de erros:

  • Use retry para falhas temporárias
  • Use captura ou replaceError para fornecer alternativas
  • Use mapError para unificar os tipos de erro
  • Sempre trate o caso de failure em sink

Verificação rápida

Teste seus conhecimentos sobre tratamento de erros.

Recapitulação

Você aprendeu os operadores de tratamento de erros do Combine:

  • captura / replaceError — fornecem alternativas
  • retry — tenta novamente em caso de falha
  • mapError / setFailureType — unificam os tipos de erro

Juntos, eles permitem criar fluxos que continuam funcionando de forma controlada, em vez de falharem ao primeiro erro.

Perguntas Frequentes

A aula “Operadores de Tratamento de Erros” é grátis?

Sim — o texto completo de “Operadores de Tratamento de Erros” é 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 “Operadores de Tratamento de Erros”?

Recupere-se com catch, retry e replaceError. 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 3 de 4.

Quanto tempo leva a aula “Operadores de Tratamento de Erros”?

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

  1. Transformação e Combinação de Fluxos
  2. Agendadores e Execução em Threads
  3. Operadores de Tratamento de Erros
  4. Publishers e Subscribers Personalizados
← Voltar para Swift Academy