Optimización del rendimiento de aplicaciones Swift para principiantes

Introducción: por qué el rendimiento es importante desde el primer día

Cuando empiezas a escribir en Swift, es fácil concentrarse solo en la funcionalidad: "con tal de que funcione". Sin embargo, los desarrolladores experimentados saben: la optimización del rendimiento no es un toque final, sino una base que se establece desde las primeras líneas de código. Una aplicación lenta pierde usuarios, agota la batería y recibe malas reseñas.

En este artículo, analizaremos los aspectos clave de la optimización de aplicaciones Swift para iOS y macOS. Aprenderás cómo evitar los errores típicos de los principiantes, dominarás el manejo de memoria, hilos y la creación de perfiles. Cada sección contiene ejemplos prácticos de código que puedes aplicar de inmediato en tus proyectos.

1. Gestión de memoria: ARC y cómo evitar retain cycles

Swift utiliza Automatic Reference Counting (ARC) para gestionar la memoria. Esto significa que los objetos se liberan cuando ya no tienen referencias fuertes. Pero si creas una referencia cíclica (retain cycle), la memoria nunca se liberará: se producirá una fuga.

Referencias débiles y no poseídas

Usa weak y unowned para romper los ciclos. Esto se necesita con mayor frecuencia en closures y delegados.

class ViewController: UIViewController {    var networkManager: NetworkManager?        func fetchData() {        networkManager?.fetch { [weak self] result in            guard let self = self else { return }            // Procesamiento del resultado            self.updateUI(with: result)        }    }}

Cuándo usar:

• weak — si la referencia puede volverse nil (por ejemplo, un delegado).
• unowned — si estás seguro de que el objeto vivirá más que el closure (por ejemplo, el controlador padre).

Evita copias innecesarias

Los value types (estructuras, enumeraciones) se copian al asignarse. Para datos grandes, usa class o pásalos por referencia mediante inout.

// Malo: copia de un array grandefunc processLargeArray(_ array: [Int]) {    // array es una copia}

// Bueno: paso por referenciafunc processLargeArray(_ array: inout [Int]) {    // array es una referencia al original}

2. Trabajo con multihilo: GCD y async/await

iOS y macOS son sistemas multihilo. Si ejecutas operaciones pesadas (carga de datos, procesamiento de imágenes) en el hilo principal, la interfaz se "congela". Usa Grand Central Dispatch (GCD) o el moderno async/await.

GCD: patrones básicos

DispatchQueue.global(qos: .userInitiated).async {    // Trabajo pesado en segundo plano    let result = performHeavyCalculation()        DispatchQueue.main.async {        // Actualización de la UI en el hilo principal        self.label.text = "\\(result)"    }}

QoS (Quality of Service):

• .userInteractive — para la UI (casi instantáneo).
• .userInitiated — para acciones del usuario (segundos).
• .utility — para tareas largas (barras de progreso).
• .background — para sincronización en segundo plano (no urgente).

Async/await (Swift 5.5+)

Una forma más legible de trabajar con asincronía:

func 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 en TaskTask {    do {        let image = try await fetchImage(from: url)        self.imageView.image = image    } catch {        print("Error de carga: \\(er")