Swift Academy · Lección

Nil coalescing y operador ternario con optionals

Use ?? para valores predeterminados y encadene operadores de nil coalescing.

Lección 2 de 412 pasos

Nil coalescing y operador ternario con optionals es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Bienvenida

El operador de coalescencia de nil `??` proporciona un valor predeterminado cuando un opcional es nil. Combinado con el operador ternario, permite gestionar opcionales de forma concisa y expresiva.

El operador ??

```swift let name: String? = nil let display = name ?? "Guest" print(display) // "Guest" let known: String? = "Alice" print(known ?? "Guest") // "Alice" ``` Si el opcional no es nil, se usa su valor desempaquetado. En caso contrario, se usa el valor predeterminado.

Evaluación de cortocircuito

El lado derecho de `??` solo se evalúa cuando el lado izquierdo es nil: ```swift func expensiveDefault() -> String { print("Computing...") return "Default" } let val: String? = "Existing" let result = val ?? expensiveDefault() // expensiveDefault not called ```

Encadenar ??

Encadene varios operadores `??` para probar varias alternativas: ```swift let primary: String? = nil let secondary: String? = nil let fallback = "Anonymous" let user = primary ?? secondary ?? fallback print(user) // "Anonymous" ``` La evaluación se detiene en el primer valor que no sea nil.

?? con propiedades calculadas

```swift struct Config { var theme: String? var displayTheme: String { theme ?? "light" } } var c = Config() print(c.displayTheme) // "light" c.theme = "dark" print(c.displayTheme) // "dark" ``` Un patrón limpio para valores predeterminados en propiedades calculadas.

Operador ternario con opcionales

El ternario `condition ? a : b` puede usarse con comprobaciones de opcionales: ```swift let score: Int? = 85 let label = score != nil ? "\(score!)" : "No score" ``` Pero `??` suele ser más claro: ```swift let label = score.map { "\($0)" } ?? "No score" ```

Optional.map para transformar

Transforme el valor envuelto de un opcional sin desempaquetarlo: ```swift let maybeInt: Int? = 42 let maybeStr = maybeInt.map { "Value: \($0)" } // Optional("Value: 42") let nilInt: Int? = nil let nilStr = nilInt.map { "Value: \($0)" } // nil ```

flatMap para encadenar opcionales

Use `flatMap` cuando la propia transformación devuelva un opcional: ```swift let str: String? = "123" let num = str.flatMap { Int($0) } // Optional(123) let bad: String? = "abc" let nil2 = bad.flatMap { Int($0) } // nil ```

Operador de asignación ??= (no integrado)

Swift no incluye `??=` de forma integrada, pero puede simularlo: ```swift var cache: [String: Int] = [:] // Assign only if nil: if cache["key"] == nil { cache["key"] = expensiveCompute() } // Or with a helper: func ??= (lhs: inout T?, rhs: @autoclosure () -> T) { if lhs == nil { lhs = rhs() } } ```

Pautas de legibilidad

Elija la herramienta adecuada: • `??` — valores predeterminados sencillos • `if let` — cuando necesite el valor desempaquetado en varias instrucciones • `guard let` — precondición y salida anticipada • `.map` / `.flatMap` — transformación sin desempaquetar Evite `!`, el desempaquetado forzado, salvo que el caso nil realmente no pueda producirse.

Comprobación rápida

¿Qué devuelve `optional ?? default` cuando `optional` es `nil`?

Responde en la lección interactiva

Resumen

Puntos clave: • `a ?? b` — devuelve el valor de `a` si no es nil; en caso contrario, `b` • Hace cortocircuito: `b` solo se evalúa cuando `a` es nil • Encadene: `a ?? b ?? c` • `.map` transforma el valor envuelto; `.flatMap` gestiona transformaciones que devuelven un Optional • Prefiera `??` en lugar de un ternario con desempaquetado forzado Siguiente: encadenamiento de opcionales con `?.`

Gratis para empezar

Aprende Swift con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 122
Lecciones: 409

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Nil coalescing y operador ternario con optionals» es gratis?

Sí — el texto completo de «Nil coalescing y operador ternario con optionals» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Nil coalescing y operador ternario con optionals»?

Use ?? para valores predeterminados y encadene operadores de nil coalescing. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Nil coalescing y operador ternario con optionals»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Asignación con if let y guard let
Nil coalescing y operador ternario con optionals
Operador de optional chaining ?.
Optionals desempaquetados implícitamente y cuándo evitarlos

← Volver a Swift Academy