Programación asíncrona en Swift: guía completa para principiantes

Introducción a la programación asíncrona en Swift

Las aplicaciones móviles y de escritorio modernas deben ser receptivas y rápidas. A nadie le gusta que la interfaz se congele al cargar datos de la red o procesar un archivo grande. Aquí es donde la programación asíncrona viene al rescate. En Swift, a partir de la versión 5.5, apareció un conjunto de herramientas potente e intuitivo para trabajar con asincronía: async/await, Task y Actor.

En esta guía, analizaremos los fundamentos de la programación asíncrona en Swift para iOS y macOS. Aprenderás a escribir código asíncrono sin callbacks (callback hell), gestionar correctamente los hilos y evitar condiciones de carrera. El material está dirigido a desarrolladores principiantes que ya conocen los conceptos básicos de la sintaxis de Swift.

¿Qué es la programación asíncrona y por qué es necesaria?

Imagina que tu aplicación es un chef en la cocina. Si el chef espera a que hierva la tetera y no hace nada, la comida se retrasará. La programación asíncrona permite que el "chef" (el hilo principal) ponga la tetera y, sin esperar a que hierva, se ponga a cortar la ensalada. Cuando la tetera hierva, el chef volverá a ella.

En el contexto de iOS, esto significa que las operaciones pesadas (cargar una imagen, parsear JSON, trabajar con la base de datos) se ejecutan en segundo plano, sin bloquear el hilo principal, que es responsable de actualizar la interfaz. Si no se hace esto, la aplicación se "congelará" y pronto será cerrada forzosamente por el sistema.

El problema del enfoque antiguo: callbacks y GCD

Antes de la llegada de async/await, los desarrolladores usaban Grand Central Dispatch (GCD) y closures (callbacks). Esto llevaba al llamado "infierno de los callbacks": bloques de código anidados que eran difíciles de leer, depurar y mantener.

// Estilo antiguo con GCD y closuresfunc fetchUserData(completion: @escaping (User?) -> Void) {    DispatchQueue.global().async {        // Operación larga        let user = User(name: "Iván")        DispatchQueue.main.async {            completion(user)        }    }}

fetchUserData { user in    guard let user = user else { return }    fetchUserPosts(userId: user.id) { posts in        // Otro callback anidado        print(posts)    }}

Swift moderno ofrece una solución mucho más elegante.

Fundamentos de Swift Concurrency: async/await

Declaración de una función asíncrona

Para hacer que una función sea asíncrona, agrega la palabra clave async después de la lista de parámetros. Para llamar a dicha función, debes usar la palabra clave await.

// Función asíncronafunc fetchImage(from url: URL) async throws -> UIImage {    let (data, _) = try await URLSession.shared.data(from: url)    guard let image = UIImage(data: data) else {        throw URLError(.badServerResponse)    }    return image}

// Llamada a la funciónTask {    do {        let image = try await fetchImage(from: url)        self.imageView.image = image    } catch {        print("Error de carga: \\(error)")    }}

Observa: URLSession.shared.data(from:) ya es una función asíncrona lista de Apple. Simplemente la llamamos con await, y el hilo se libera para otras tareas mientras se cargan los datos.

Llamadas secuenciales y paralelas

Puedes llamar a funciones asíncronas de forma secuencial o paralela.

// Llamada secuencial: la segunda solicitud espera a la primeralet user = try await fetchUser(id: 1)let posts = try await fetchPosts(for: user.id)

// Llamada paralela: ambas solicitudes se ejecutan simultáneamenteasync let user = fetchUser(id: 1)async let posts = fetchPosts(for: 1)let (resultUser, resultPosts) = try await (user, posts)

En el modo paralelo, ambas solicitudes se inician al mismo tiempo, lo que ```