0Pricing
Swift Academy · Aula

Integração de Result com async/await

Converta APIs de Result baseadas em callbacks em funções assíncronas que lançam erros.

Integração de Result com async/await é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Boas-vindas

APIs legadas baseadas em callbacks retornam `Result`. O código moderno usa async/await. Fazer a ponte entre os dois é uma tarefa comum — o Swift oferece padrões simples para ambas as direções.

withCheckedThrowingContinuation

```swift func fetchAsync(url: URL) async throws -> Data { try await withCheckedThrowingContinuation { cont in fetchCallback(url) { result in cont.resume(with: result) } } } ``` `cont.resume(with: result)` aceita um `Result` diretamente.

withCheckedContinuation (sem lançamento de erros)

```swift func fetchAsync(url: URL) async -> Result { await withCheckedContinuation { cont in fetchCallback(url) { result in cont.resume(returning: result) } } } ```

Convertendo código assíncrono em resultado

```swift func asResult(of operation: () async throws -> T) async -> Result { do { return .success(try await operation()) } catch { return .failure(error) } } let r = await asResult { try await fetch(url) } ```

Result.get() em contexto assíncrono

```swift func process() async { let result: Result = await fetchAsync(url) do { let data = try result.get() handle(data) } catch { handle(error) } } ```

Task { } para fazer a ponte

```swift func load() { Task { let data = try await fetchAsync(url) await MainActor.run { self.render(data) } } } ```

AsyncStream a partir de callbacks

```swift func events() -> AsyncStream { AsyncStream { cont in let token = subscribe { event in cont.yield(event) } cont.onTermination = { _ in unsubscribe(token) } } } ```

Regras de segurança para continuations

• Chame `resume` exatamente uma vez — chamá-lo duas vezes resulta em comportamento indefinido • Não chame `resume` depois que a função tiver retornado • Use `withCheckedContinuation` na depuração (detecta erros); use `withUnsafeContinuation` em versões de produção, se necessário para obter desempenho

MainActor para atualizações da interface

```swift await MainActor.run { label.text = data.description } // or: @MainActor func updateUI(_ d: Data) { label.text = ... } await updateUI(data) ```

Testando o assíncrono + resultado

```swift func testFetch() async throws { let result = await asResult { try await fetchAsync(url) } switch result { case .success(let d): XCTAssertFalse(d.isEmpty) case .failure(let e): XCTFail(e.localizedDescription) } } ```

Verificação rápida

Que tipo de continuação detecta usos incorretos, como retomar duas vezes, em compilações de depuração?

Recapitulação

Principais conclusões: • `withCheckedThrowingContinuation` faz a ponte entre retornos de chamada e operações assíncronas que lançam erros • `cont.resume(with: result)` aceita um resultado diretamente • Envolva `async throws` em `Result` usando uma função auxiliar • Chame `resume` exatamente uma vez • Use `MainActor.run { }` para atualizar a interface com segurança em um contexto assíncrono Curso concluído! A seguir: fundamentos do SwiftUI.

Perguntas Frequentes

A aula “Integração de Result com async/await” é grátis?

Sim — o texto completo de “Integração de Result com async/await” é 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 “Integração de Result com async/await”?

Converta APIs de Result baseadas em callbacks em funções assíncronas que lançam erros. 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 4 de 4.

Quanto tempo leva a aula “Integração de Result com async/await”?

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. Fundamentos de Result
  2. map e flatMap em Result
  3. Tipos de erro personalizados com LocalizedError
  4. Integração de Result com async/await
← Voltar para Swift Academy