0Pricing
Swift Academy · Lección

Puente entre Result y async/await

Convierta APIs de Result basadas en callbacks en funciones async que puedan lanzar errores.

Puente entre Result y async/await es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Introducción

Las APIs antiguas basadas en callbacks devuelven `Result`. El código moderno usa async/await. Conectar ambos enfoques es una tarea habitual; Swift ofrece patrones sencillos para hacerlo en ambas direcciones.

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)` acepta directamente un `Result`.

withCheckedContinuation (sin lanzamiento de errores)

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

Convertir async a Result

```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() en un contexto async

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

Task { } para conectar APIs

```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) } } } ```

Reglas de seguridad para continuations

• Llame a `resume` exactamente una vez; llamarlo dos veces produce un comportamiento indefinido • No llame a `resume` después de que la función haya retornado • Use `withCheckedContinuation` en depuración (detecta errores); use `withUnsafeContinuation` en producción si necesita mejorar el rendimiento

MainActor para actualizar la interfaz

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

Pruebas de Async+Result

```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) } } ```

Comprobación rápida

¿Qué tipo de continuación detecta usos incorrectos, como reanudarla dos veces, en las compilaciones de depuración?

Repaso

Ideas clave: • `withCheckedThrowingContinuation` conecta los callbacks con async throws • `cont.resume(with: result)` acepta directamente un Result • Envuelva `async throws` en un `Result` mediante una función auxiliar • Llame a `resume` exactamente una vez • `MainActor.run { }` permite actualizar la interfaz de usuario de forma segura desde un contexto asíncrono ¡Curso completado! Siguiente: fundamentos de SwiftUI.

Preguntas frecuentes

¿La lección «Puente entre Result y async/await» es gratis?

Sí — el texto completo de «Puente entre Result y async/await» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Puente entre Result y async/await»?

Convierta APIs de Result basadas en callbacks en funciones async que puedan lanzar errores. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Puente entre Result y async/await»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Fundamentos de Result
  2. map y flatMap en Result
  3. Tipos de error personalizados con LocalizedError
  4. Puente entre Result y async/await
← Volver a Swift Academy