¿Qué es un opcional?

Los opcionales son uno de los conceptos más característicos de Swift y una de las razones por las que las apps escritas en Swift tienden a tener menos crashes. Un opcional representa un valor que puede o no existir — y el compilador te obliga a manejar ambos casos antes de usar el valor.

¿Qué es un opcional?

En Swift, una variable normal nunca puede ser nil. Si quieres que un valor pueda estar ausente, debes declararlo explícitamente como opcional usando ?. Esto hace que el compilador te recuerde siempre que ese valor podría no existir.

// Variable normal — nunca puede ser nil
let nombre: String = "Swift"

// Opcional — puede ser String o nil
var nombreUsuario: String? = "Usuario1"
nombreUsuario = nil  // perfectamente válido

// El compilador no te deja usar un opcional directamente
// print(nombreUsuario.count)  ❌ error: value of optional type must be unwrapped

// Antes de usarlo, debes "desenvolverlo" (unwrap)
print(nombreUsuario)  // Optional("Usuario1") o nil

Optional binding — if let

La forma más segura y común de usar un opcional. Comprueba si tiene valor y, si es así, lo extrae en una constante local para usarlo con seguridad.

let entrada: String? = "42"

if let valor = entrada {
    // Aquí 'valor' es un String, no un opcional
    print("El valor es: \(valor)")
} else {
    print("No hay valor")
}

// Swift 5.7+: puedes reusar el mismo nombre (shadow binding)
var codigo: String? = "ABC123"
if let codigo {
    print("Código válido: \(codigo)")
}

// Múltiples opcionales en un solo if let
let usuario: String? = "admin"
let clave: String?   = "1234"

if let usuario, let clave {
    print("Login: \(usuario) / \(clave)")
}

guard let — opcional binding con salida temprana

Cuando un opcional es indispensable para continuar, guard let es la herramienta correcta. Si el valor es nil, sale de la función inmediatamente. El valor desenvuelto queda disponible en el resto del scope.

func mostrarPerfil(nombre: String?) {
    guard let nombre = nombre else {
        print("No se puede mostrar el perfil sin nombre")
        return
    }
    // A partir de aquí, 'nombre' es un String no opcional
    print("Perfil de: \(nombre)")
}

mostrarPerfil(nombre: "Usuario1")  // "Perfil de: Usuario1"
mostrarPerfil(nombre: nil)         // "No se puede mostrar el perfil sin nombre"

Optional chaining — el operador ?.

Permite acceder a propiedades o métodos de un opcional de forma segura. Si el opcional es nil, toda la cadena devuelve nil sin crashear.

struct Direccion {
    var ciudad: String
}

struct Perfil {
    var direccion: Direccion?
}

let perfil = Perfil(direccion: Direccion(ciudad: "Madrid"))
let perfilSinDireccion = Perfil(direccion: nil)

// Optional chaining — no crashea si algún valor es nil
print(perfil.direccion?.ciudad)            // Optional("Madrid")
print(perfilSinDireccion.direccion?.ciudad) // nil — sin crash

// Combinado con ?? para un valor por defecto
let ciudad = perfil.direccion?.ciudad ?? "Ciudad desconocida"
print(ciudad)  // "Madrid"

Nil-coalescing ??

Ya lo vimos en operadores, pero merece repetirse en contexto de opcionales: proporciona un valor por defecto cuando el opcional es nil, y el resultado nunca es opcional.

let idioma: String? = nil
let idiomaFinal = idioma ?? "es"  // "es"

// Se puede encadenar
let config1: String? = nil
let config2: String? = nil
let config3: String? = "produccion"

let entorno = config1 ?? config2 ?? config3 ?? "desarrollo"
print(entorno)  // "produccion"

Forced unwrapping ! — úsalo con cuidado

El operador ! extrae el valor de un opcional de forma forzada. Si el opcional es nil, la app se rompe en runtime. Úsalo solo cuando tienes certeza absoluta de que el valor existe — en la práctica, casi nunca.

let texto: String? = "Hola"
print(texto!)  // "Hola" — funciona porque sabemos que tiene valor

let vacio: String? = nil
// print(vacio!)  ❌ CRASH en runtime: Fatal error: Unexpectedly found nil

// En la práctica, prefiere siempre if let o guard let
// El ! es una señal de que algo puede estar mal en el diseño

Cuándo aparecen los opcionales en el día a día

Los opcionales no son solo un concepto teórico — aparecen constantemente al trabajar con APIs de Apple y datos externos.

// Convertir String a Int puede fallar — devuelve Int?
let entrada = "123"
if let numero = Int(entrada) {
    print("Número válido: \(numero)")
}

let entradaInvalida = "abc"
if let numero = Int(entradaInvalida) {
    print("Número: \(numero)")
} else {
    print("No es un número válido")  // se imprime esto
}

// Buscar en un diccionario devuelve un opcional
let precios = ["Manzana": 1.5, "Pera": 2.0]
if let precio = precios["Uva"] {
    print("Precio: \(precio)")
} else {
    print("Producto no encontrado")  // se imprime esto
}

Resumen: elige la herramienta correcta

• if let: cuando el valor opcional es útil pero no indispensable para continuar.
• guard let: cuando sin ese valor no tiene sentido seguir ejecutando — la opción preferida en funciones.
• ?. (optional chaining): para acceder a propiedades o métodos de un opcional de forma segura.
• ?? (nil-coalescing): cuando quieres un valor por defecto si el opcional es nil.
• ! (forced unwrap): casi nunca — solo si tienes certeza absoluta. Preferir las opciones anteriores.

En el siguiente post veremos Funciones en Swift moderno — etiquetas de parámetros, valores por defecto, múltiples retornos y una introducción a los closures.