Opcionales: el corazón de Swift

Si hay UNA idea que define a Swift, es esta. Los opcionales resuelven el error del billón de dólares —el “null pointer”— haciendo explícito qué valores pueden faltar. Al principio parece raro; en cuanto lo interiorizas, no quieres programar sin ello.

• Qué es un opcional y por qué existe.
• Desenvolver de forma segura con if let y guard let.
• El operador ?? (nil-coalescing).
• Optional chaining y por qué evitar el !.

El problema que resuelven

En muchos lenguajes, cualquier variable puede ser null sin avisar, y acceder a ella revienta la app. Swift le da la vuelta: un valor normal nunca puede ser nil. Si algo puede faltar, tiene que ser un opcional, marcado con ?:

var nombre: String = "Ana"     // NUNCA puede ser nilvar apodo: String? = nil       // opcional: puede tener String o nilapodo = "La jefa"              // ahora tiene valorapodo = nil                    // y puede volver a estar vacío

Un String? no es un String: es “un String o nada”. Y Swift te obliga a comprobar cuál de los dos es antes de usarlo. Ahí está la seguridad.

El compilador es tu red de seguridad

En otros lenguajes, olvidar comprobar un null es un crash en producción a las 3 de la madrugada. En Swift, es un error de compilación que ves al instante. El compilador no te deja usar un opcional sin desenvolverlo. Esa fricción del principio es exactamente lo que hace que las apps de Swift casi nunca fallen por valores nulos. Aprende a amarla.

if let: desenvolver de forma segura

if let comprueba si el opcional tiene valor y, si lo tiene, te da una constante no-opcional dentro del bloque:

let apodo: String? = "La jefa"if let apodo {    // aquí 'apodo' es String (no opcional), garantizado con valor    print("Su apodo es \(apodo)")} else {    print("No tiene apodo")}

La forma corta if let apodo (sin = apodo) funciona desde Swift moderno. Puedes desenvolver varios a la vez separándolos por comas.

guard let: salir temprano

guard let es como if let al revés: desenvuelve y, si es nil, sale de la función. El valor queda disponible en el resto de la función, no solo en un bloque:

func saludar(a nombre: String?) {    guard let nombre else {        print("No hay nombre, salgo")        return    }    // a partir de aquí 'nombre' es String, en toda la función    print("Hola, \(nombre)")}

guard para las precondiciones

Usa guard al inicio de tus funciones para validar entradas y salir pronto si algo falta. Deja el “camino feliz” del código sin anidar en un montón de if. Es el patrón que verás en casi todo el código Swift profesional: comprueba lo que necesitas arriba, y luego trabaja tranquilo.

?? : un valor por defecto

El operador nil-coalescing ?? da un valor de reemplazo cuando el opcional es nil:

let apodo: String? = nillet mostrar = apodo ?? "Anónimo"   // "Anónimo" porque apodo es nilprint("Bienvenido, \(mostrar)")

Perfecto para “usa esto, o si no hay, usa aquello”.

Optional chaining

Con ?. accedes a propiedades o métodos de un opcional: si es nil, toda la cadena devuelve nil sin reventar:

let texto: String? = "hola"let mayus = texto?.uppercased()    // "HOLA" (o nil si texto fuera nil)let largo = texto?.count ?? 0      // 4, o 0 si fuera nil

El force unwrap (!) y por qué evitarlo

Puedes forzar un opcional con !, prometiéndole a Swift que tiene valor. Pero si te equivocas y es nil, la app crashea:

let apodo: String? = nil// let x = apodo!    // crash en tiempo de ejecución

El ! es una promesa que puede matarte

! desactiva justo la protección que hace seguro a Swift. Úsalo solo cuando sea 100% imposible que sea nil (y casi nunca lo es). El 99% del tiempo, if let, guard let o ?? hacen lo mismo sin riesgo de crash. Si ves muchos ! en tu código, es una señal de alarma.

Domina lo que puede faltar

1. Declara un String? con un nombre y otro con nil.
2. Desenvuelve el primero con if let e imprímelo.
3. Escribe una función con guard let que salga si el parámetro es nil.
4. Usa ?? para mostrar “Invitado” cuando un nombre opcional sea nil.
5. Encadena con ?. para obtener el .count de un string opcional.