0Pricing
Swift Academy · Lección

try await y propagación de errores

Use try await con funciones async que generan errores, gestione los fallos con do/catch y propague los errores correctamente, incluido CancellationError .

try await y propagación de errores es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 3. 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 3 lecciones en total.

¿Por qué try await?

try await llama a una función asíncrona que lanza errores. Si lanza un error, este se propaga a menos que lo capture. También puede usar try? para convertirlo en un Optional.

async con errores + do/catch

Cree una función asíncrona que lance errores y llámela con try await dentro de do/catch para gestionar los fallos.

enum NetError: Error { case offline; case badStatus(Int) }

func fetchNumber(from ok: Bool) async throws -> Int {
    try await Task.sleep(nanoseconds: 100_000_000)
    if !ok { throw NetError.offline }
    return 7
}

Task {
    do {
        let n = try await fetchNumber(from: true)
        print("value:", n)          // 7
    } catch {
        print("failed:", error)     // handled here
    }
}

Conversión de errores

Use try? para obtener un Optional en lugar de lanzar un error. Evite try! a menos que tenga la certeza de que no puede fallar.

Task {
    // try? converts failure to nil
    let maybe = try? await fetchNumber(from: false)
    print("optional result:", String(describing: maybe)) // nil on error

    // ⚠️ try! will crash if an error is thrown — avoid in production
    // let forced = try! await fetchNumber(from: false)
}

Propagación de errores

Marque los llamadores como async throws para propagar los errores hacia arriba; pueden gestionarse en un límite superior.

func loadProfile(ok: Bool) async throws -> String {
    let id = try await fetchNumber(from: ok)   // propagate on error
    return "id:\\(id)"
}

Task {
    do {
        let s = try await loadProfile(ok: true)
        print(s) // "id:7"
    } catch {
        print("propagated:", error)
    }
}

Capturas específicas

Use bloques catch con coincidencia de patrones. Gestione CancellationError primero para mantener rápidas y silenciosas las rutas de cierre.

enum FileError: Error { case notFound }

func mightCancel() async throws {
    for _ in 0..<5 {
        try Task.checkCancellation()                 // throws CancellationError
        try await Task.sleep(nanoseconds: 30_000_000)
    }
}

Task {
    let t = Task { try await mightCancel() }
    t.cancel()
    do {
        try await t.value
    } catch is CancellationError {
        print("cancelled cleanly")                   // handle cancellation separately
    } catch {
        print("other error:", error)
    }
}

Pautas

Consejos:

  • Propague con try hasta un límite que pueda decidir (la UI, la CLI o un Task de nivel superior).
  • Prefiera errores de dominio (enumeraciones) para mayor claridad.
  • Convierta con try? solo cuando la ausencia sea aceptable.
  • Capture CancellationError de forma diferenciada.

Manejo de errores con try await

Comprobación rápida: ¿Qué hace try await f() con los errores?

Repaso

Repaso: Use try await con funciones asíncronas que lancen errores, propague los errores desde las funciones auxiliares, conviértalos con try? cuando un opcional sea suficiente y capture CancellationError explícitamente.

Preguntas frecuentes

¿La lección «try await y propagación de errores» es gratis?

Sí — el texto completo de «try await y propagación de errores» 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 3 lecciones en total.

¿Qué aprenderé en «try await y propagación de errores»?

Use try await con funciones async que generan errores, gestione los fallos con do/catch y propague los errores correctamente, incluido CancellationError . 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 3 de 3.

¿Cuánto tiempo toma la lección «try await y propagación de errores»?

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. Concurrencia estructurada y funciones async
  2. async let, Task y cancelación
  3. try await y propagación de errores
← Volver a Swift Academy