0Pricing
Swift Academy · Lección

async let y tareas hijas concurrentes

Ejecute trabajo async independiente de forma simultánea mediante bindings async let.

async let y tareas hijas concurrentes es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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

`async let` ejecuta varias operaciones asíncronas de forma concurrente: todas comienzan de inmediato y `await` espera sus resultados cuando son necesarios.

Secuencial frente a concurrente

```swift // Sequential — slow: let a = try await fetchA() let b = try await fetchB() // Concurrent with async let — fast: async let a = fetchA() async let b = fetchB() let (resultA, resultB) = try await (a, b) ```

Sintaxis de async let

```swift async let title = fetchTitle(id) async let author = fetchAuthor(id) async let content = fetchContent(id) let article = Article( title: try await title, author: try await author, content: try await content ) ```

Todo o nada

Si alguna vinculación `async let` lanza un error, este se propaga. El sistema cancela automáticamente las tareas hermanas.

async let en bucles

```swift var results: [Data] = [] await withTaskGroup(of: Data.self) { group in for url in urls { group.addTask { try await URLSession.shared.data(from: url).0 } } for await data in group { results.append(data) } } ```

TaskGroup

```swift await withTaskGroup(of: Int.self) { group in for i in 1...5 { group.addTask { i * i } } var squares: [Int] = [] for await square in group { squares.append(square) } print(squares.sorted()) // [1,4,9,16,25] } ```

ThrowingTaskGroup

```swift try await withThrowingTaskGroup(of: User.self) { group in for id in ids { group.addTask { try await fetchUser(id: id) } } for try await user in group { process(user) } } ```

Árbol de concurrencia estructurada

`async let` y TaskGroup forman un árbol de tareas. Las tareas principales esperan a todos sus elementos secundarios. Al cancelar la tarea principal, se cancelan todos sus elementos secundarios.

Cuándo usar async let frente a TaskGroup

• `async let` — número fijo de operaciones concurrentes conocido en tiempo de compilación • `TaskGroup` — número dinámico de tareas, por ejemplo, al procesar un array

Limitar la concurrencia con TaskGroup

```swift await withTaskGroup(of: Void.self) { group in let concurrency = 4 var running = 0 for url in urls { if running >= concurrency { await group.next() } group.addTask { await process(url) } running += 1 } } ```

Comprobación rápida

¿Qué sucede con las tareas hermanas `async let` si una lanza un error?

Repaso

Conceptos clave: • `async let x = asyncWork()` — comienza de inmediato y se ejecuta de forma concurrente • `try await x` — espera el resultado • Todo o nada: un error cancela las tareas hermanas • `withTaskGroup` — conjunto dinámico de tareas concurrentes • Concurrencia estructurada = gestión automática de las tareas secundarias Siguiente: Actores.

Preguntas frecuentes

¿La lección «async let y tareas hijas concurrentes» es gratis?

Sí — el texto completo de «async let y tareas hijas concurrentes» 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 «async let y tareas hijas concurrentes»?

Ejecute trabajo async independiente de forma simultánea mediante bindings async let. 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 4.

¿Cuánto tiempo toma la lección «async let y tareas hijas concurrentes»?

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. Sintaxis de async/await y llamadas a funciones asíncronas
  2. Task y cancelación de tareas
  3. async let y tareas hijas concurrentes
  4. Actores: protección del estado mutable compartido
← Volver a Swift Academy