Código limpio en Swift: cómo escribir para que tus colegas no te maldigan

Cómo escribir código limpio en Swift: guía para quienes se respetan a sí mismos y a sus colegas

Cada desarrollador al menos una vez ha abierto un proyecto escrito hace seis meses y no ha podido entender qué está pasando allí. O ha recibido en la revisión de código un comentario: «Esto se podría haber escrito más simple». ¿Te suena? Si es así, este artículo es para ti.

El código limpio en Swift no es solo un capricho de perfeccionista. Es una herramienta que ahorra horas de depuración y nervios. Cuando escribes de manera ordenada, no solo aceleras tu trabajo, sino que también haces el proyecto transparente para el equipo. Analicemos cómo convertir tu código Swift en una obra de arte.

Regla n.º 1: La nomenclatura es lo primero

El pecado más común es nombrar una variable x o temp. Luego llega otro desarrollador y se pregunta: «¿Qué es x? ¿Una coordenada? ¿Una cantidad?»

En Swift se acostumbra dar nombres que se lean como oraciones. Esto no solo es estético, sino que ayuda a entender de inmediato qué hace el código.

// Mal\nlet a = 5.0\nvar b = "John"\n\n// Bien\nlet discountRate = 5.0\nvar userName = "John"

Para funciones y métodos aplica la misma regla. El nombre debe responder a la pregunta «¿Qué hace este método?». Usa verbos en modo imperativo:

// Mal\nfunc data() -> [String] { ... }\n\n// Bien\nfunc fetchUsers() -> [String] { ... }

Y si la función devuelve un valor booleano, comienza el nombre con is, has o contains:

func isUserLoggedIn() -> Bool\nfunc hasValidEmail() -> Bool

Regla n.º 2: Los opcionales no son enemigos, sino herramientas

Muchos principiantes temen a los opcionales e intentan deshacerse de ellos a cualquier precio. Escriben if let en todas partes o, peor aún, fuerzan el desempaquetado. Pero el código limpio en Swift es código que trabaja de forma segura con nil.

Recuerda: ! es un grito de auxilio. Úsalo solo si estás absolutamente seguro de que el valor no es nil (por ejemplo, al trabajar con IBOutlet).

// Código peligroso\nlet name = optionalName!\n\n// Opción segura\nguard let name = optionalName else {\n    return\n}\nprint(name)

Y para cadenas de opcionales usa ? y nil-coalescing:

let userCity = user?.address?.city ?? "Desconocido"

Este código no fallará, incluso si user o address resultan ser nil. Y se lee como una oración normal: «La ciudad del usuario o "Desconocido"».

Regla n.º 3: Estructuras en lugar de clases (donde sea posible)

En Swift existen tanto clases como estructuras. Pero muchos por costumbre usan clases en todas partes. Y es una lástima. Las estructuras son tipos de valor (value types) y son más seguras en código concurrente. Además, se copian, no se referencian, lo que reduce el riesgo de efectos secundarios.

Usa una estructura si:

\n
• Necesitas almacenar datos sin lógica compleja
\n
• No hay necesidad de herencia
\n
• El objeto no debe ser mutable después de su creación
\n

// Mejor una estructura\nstruct User {\n    let id: Int\n    var name: String\n}\n\n// Clase solo si se necesita herencia o semántica de referencia\nclass ViewController: UIViewController { ... }

Por cierto, Apple recomienda usar estructuras para modelos de datos. Este es uno de los principios principales del código limpio en Swift.

Regla n.º 4: Los protocolos son tus mejores amigos

Los protocolos en Swift no son solo interfaces. Son una forma de hacer el código flexible y testeable. En lugar de atarte a una clase concreta, trabaja a través de un protocolo.

protocol NetworkServiceProtocol {\n    func fetchData(completion: @escaping (Result<Data, Error>) -> Void)\n}\n\nclass APIService: NetworkServiceProtocol { ... }\nclass MockService: NetworkServiceProtocol { ... }

Ahora puedes reemplazar fácilmente el servicio real por un mock para las pruebas. Y no necesitas cambiar el código en otro