Swift Academy · Lección

Operador de optional chaining ?.

Llame a métodos y acceda a propiedades de optionals sin provocar un fallo.

Operador de optional chaining ?. es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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 encadenamiento de opcionales permite llamar a métodos, acceder a propiedades y usar subíndices a través de una cadena de opcionales, de forma segura. Si algún eslabón de la cadena es nil, toda la expresión devuelve nil sin provocar un error.

El operador ?.

```swift struct Address { var city: String } struct Person { var address: Address? } let alice = Person(address: Address(city: "Istanbul")) let bob = Person(address: nil) print(alice.address?.city) // Optional("Istanbul") print(bob.address?.city) // nil ```

Encadenar varios niveles

Las cadenas pueden tener una profundidad arbitraria: ```swift struct Company { var ceo: Person? } let company = Company(ceo: alice) let city = company.ceo?.address?.city print(city ?? "Unknown") // "Istanbul" ``` Si `ceo` o `address` es nil, `city` pasa a ser nil.

Llamar a métodos mediante el encadenamiento

También puede llamar a métodos mediante el encadenamiento de opcionales: ```swift var name: String? = "alice" let upper = name?.uppercased() // Optional("ALICE") name = nil let upper2 = name?.uppercased() // nil ``` El tipo de retorno se convierte en opcional: `String` se convierte en `String?`.

Subíndices mediante el encadenamiento

```swift var dict: [String: [Int]]? = ["scores": [10, 20, 30]] let first = dict?["scores"]?[0] // Optional(10) dict = nil let none = dict?["scores"]?[0] // nil ``` Los subíndices funcionan igual que las propiedades y los métodos dentro de una cadena.

El encadenamiento produce un Optional

Incluso si el resultado final no es opcional, el encadenamiento lo envuelve en un Optional: ```swift struct Cat { var lives: Int = 9 } var cat: Cat? = Cat() let lives = cat?.lives // Int? not Int ``` Desempaquételo con `??`, `if let` o `guard let` según sea necesario.

Establecer valores mediante encadenamiento

Puede establecer propiedades mediante encadenamiento opcional: ```swift var profile: UserProfile? = UserProfile() profile?.name = "Alice" ``` Si `profile` es nil, la asignación se ignora silenciosamente (sin provocar un error).

Llamar a métodos Void mediante encadenamiento

```swift var manager: SoundManager? manager?.play() // silently ignored if nil ``` La llamada devuelve `Void?`: `()` si no es nil, y `nil` si el opcional era nil. Puede comprobar el resultado para saber si la llamada se realizó.

Encadenamiento opcional frente a desempaquetado forzado

```swift // Forced unwrap — crashes if nil: let city = alice.address!.city // Optional chaining — safe: let city = alice.address?.city ``` Prefiera siempre el encadenamiento opcional. Use `!` solo cuando tenga la certeza de que nil no puede ocurrir.

Combinar con ?? para usar valores predeterminados

Encadene `??` después del encadenamiento opcional para definir valores predeterminados de forma clara: ```swift let displayCity = user.profile?.address?.city ?? "Unknown City" let count = database?.records?.count ?? 0 ``` Toda la cadena se resuelve en un valor o recurre al valor predeterminado.

Comprobación rápida

Si algún eslabón de una cadena opcional es `nil`, ¿qué devuelve la expresión completa?

Resumen

Puntos clave: • `?.` accede de forma segura a propiedades, llama a métodos y usa subíndices con opcionales • Si algún eslabón es nil, toda la cadena devuelve nil • El tipo del resultado siempre es opcional (aunque el valor final normalmente no lo sea) • Combine `?.` con `??` para crear patrones claros de acceso seguro con valores predeterminados • Prefiera `?.` en lugar de `!` para evitar errores irrecuperables A continuación: opcionales desempaquetados implícitamente.

Preguntas frecuentes

¿La lección «Operador de optional chaining ?. » es gratis?

Sí — el texto completo de «Operador de optional chaining ?. » 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 «Operador de optional chaining ?. »?

Llame a métodos y acceda a propiedades de optionals sin provocar un fallo. 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 3 de 4.

¿Cuánto tiempo toma la lección «Operador de optional chaining ?. »?

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