PricingLoginStart free
Swift Academy · Lección

Gestión de tipos opcionales y anidados

Decodifique opcionales y estructuras anidadas de forma segura.

Lección 4 de 413 pasos

Gestión de tipos opcionales y anidados es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 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.

Propiedades opcionales

Una propiedad optional es naturalmente Codable cuando lo es el tipo que contiene. Una clave JSON ausente se decodifica como nil; una presente se decodifica normalmente.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

let json = "{\"name\":\"Ada\"}"
let u = try JSONDecoder().decode(User.self, from: json.data(using: .utf8)!)
print(u.name, u.nickname ?? "-")

Codificación de optionals nil

De forma predeterminada, un optional nil se omite por completo del JSON codificado, lo que produce una carga útil más pequeña.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

let data = try JSONEncoder().encode(User(name: "Ada", nickname: nil))
print(String(data: data, encoding: .utf8)!)

El null explícito se decodifica como nil

Si el JSON contiene un null explícito para una propiedad optional, se decodifica como nil en lugar de lanzar un error.

import Foundation

struct User: Codable {
    var name: String
    var age: Int?
}

let json = "{\"name\":\"Ada\",\"age\":null}"
let u = try JSONDecoder().decode(User.self, from: json.data(using: .utf8)!)
print(u.age == nil)

Structs Codable anidados

Componga modelos anidando tipos Codable. El tipo externo codifica y decodifica automáticamente el tipo interno.

import Foundation

struct Address: Codable { var city: String; var zip: String }
struct Person: Codable { var name: String; var address: Address }

let p = Person(name: "Lee", address: Address(city: "Rome", zip: "00100"))
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Decodificación de structs anidados

El proceso inverso también funciona: los objetos JSON anidados se decodifican en las propiedades del struct anidado.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address }

let json = "{\"name\":\"Lee\",\"address\":{\"city\":\"Rome\"}}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address.city)

Tipos anidados opcionales

Un struct anidado también puede ser optional. Si falta la clave, todo el valor anidado se convierte en nil.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address? }

let json = "{\"name\":\"Lee\"}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address?.city ?? "no address")

Arrays de elementos Codable

Un array cuyo tipo de elemento es Codable también es Codable. Se corresponde directamente con un array JSON de objetos.

import Foundation

struct Tag: Codable { var name: String }
struct Post: Codable { var title: String; var tags: [Tag] }

let p = Post(title: "Hi", tags: [Tag(name: "swift"), Tag(name: "json")])
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Decodificación de arrays de structs

Decodificar un array JSON de objetos produce un array de Swift con valores tipados que puede recorrer.

import Foundation

struct Tag: Codable { var name: String }

let json = "[{\"name\":\"a\"},{\"name\":\"b\"}]"
let tags = try JSONDecoder().decode([Tag].self, from: json.data(using: .utf8)!)
for t in tags { print(t.name) }

Arrays opcionales

Un array optional distingue entre «clave ausente» (nil) y «presente, pero vacío» ([]). Ambos son estados válidos y significativos.

import Foundation

struct Box: Codable { var items: [String]? }

let a = try JSONDecoder().decode(Box.self, from: "{}".data(using: .utf8)!)
let b = try JSONDecoder().decode(Box.self, from: "{\"items\":[]}".data(using: .utf8)!)
print(a.items == nil, b.items == [])

Estructuras profundamente anidadas

El anidamiento puede alcanzar varios niveles: structs dentro de arrays dentro de structs. Codable gestiona cada capa de forma recursiva.

import Foundation

struct Comment: Codable { var text: String }
struct Article: Codable { var title: String; var comments: [Comment] }
struct Feed: Codable { var articles: [Article] }

let feed = Feed(articles: [Article(title: "A", comments: [Comment(text: "hi")])])
let data = try JSONEncoder().encode(feed)
print(String(data: data, encoding: .utf8)!)

Conversión de ida y vuelta con optionals y anidamiento

Al combinarlo todo, los campos opcionales, los structs anidados y los arrays superan intactos una conversión completa de codificación y decodificación.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable {
    var name: String
    var address: Address?
    var hobbies: [String]
}

let p = Person(name: "Mo", address: Address(city: "Cairo"), hobbies: ["chess"])
let data = try JSONEncoder().encode(p)
let back = try JSONDecoder().decode(Person.self, from: data)
print(back.address?.city ?? "-", back.hobbies.first ?? "-")

Comprobación rápida: optionals y anidamiento

Compruebe su comprensión de los tipos Codable opcionales y anidados.

Responde en la lección interactiva

Resumen: tipos opcionales y anidados

Ha aprendido cómo gestiona Codable las estructuras más complejas:

  • Las propiedades opcionales toleran claves ausentes y null explícitos, que se decodifican como nil.
  • Los optionals nil se omiten de forma predeterminada al codificar.
  • Los structs y arrays Codable anidados se codifican y decodifican de forma recursiva.
  • Los arrays opcionales distinguen entre ausente (nil) y vacío ([]).
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 gratisVer el curso completo

Preguntas frecuentes

¿La lección «Gestión de tipos opcionales y anidados» es gratis?

Sí — el texto completo de «Gestión de tipos opcionales y anidados» 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 «Gestión de tipos opcionales y anidados»?

Decodifique opcionales y estructuras anidadas de forma segura. 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 4 de 4.

¿Cuánto tiempo toma la lección «Gestión de tipos opcionales y anidados»?

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

  1. Conformidad con Codable
  2. Codificación con JSONEncoder
  3. Decodificación con JSONDecoder
  4. Gestión de tipos opcionales y anidados
← Volver a Swift Academy