Swift Academy · Lección

Conformidad con Codable

Haga que los tipos se codifiquen y decodifiquen automáticamente.

Conformidad con Codable es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 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.

¿Qué es Codable?

Codable es un alias de tipo para Encodable & Decodable. Cuando un tipo conforma con él, Swift puede convertir sus instancias en datos externos, como JSON, y reconstruirlas de nuevo, sin necesidad de escribir código de análisis manual.

import Foundation

struct Book: Codable {
    var title: String
    var pages: Int
}

print("Book conforms to Codable")

Síntesis automática

Si cada propiedad almacenada es Codable, el compilador sintetiza la lógica de codificación y decodificación por usted. Solo tiene que escribir la lista de propiedades; Swift se encarga del resto.

import Foundation

struct User: Codable {
    var name: String
    var age: Int
    var isActive: Bool
}

let u = User(name: "Ada", age: 36, isActive: true)
print(u)

Codificación en datos JSON

Puede pasar un valor Codable a un JSONEncoder, que produce un bloque de Data. Convierta esos Data en un String para inspeccionar el texto JSON.

import Foundation

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

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

Decodificación desde datos JSON

El proceso inverso utiliza JSONDecoder. Indíquele el tipo de destino y los Data sin procesar, y reconstruirá un valor de Swift completamente tipado.

import Foundation

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

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

Conversión de ida y vuelta de un valor

La codificación seguida de la decodificación debería devolver un valor igual al original. Esta conversión de ida y vuelta es una forma rápida de confirmar que la conformidad de un tipo con Codable funciona como se espera.

import Foundation

struct Point: Codable {
    var x: Int
    var y: Int
}

let p = Point(x: 3, y: 7)
let data = try JSONEncoder().encode(p)
let back = try JSONDecoder().decode(Point.self, from: data)
print(back.x, back.y)

Solo Encodable

Puede conformar un tipo únicamente con una de las dos partes. Encodable significa que un tipo se puede escribir, pero no volver a leer; resulta útil para modelos de respuesta que nunca necesita analizar.

import Foundation

struct Receipt: Encodable {
    var item: String
    var total: Double
}

let r = Receipt(item: "Coffee", total: 4.5)
let data = try JSONEncoder().encode(r)
print(String(data: data, encoding: .utf8)!)

Solo Decodable

Del mismo modo, Decodable permite crear un tipo a partir de datos externos sin que sea codificable. Resulta útil para cargas de API de solo lectura que únicamente consume.

import Foundation

struct Config: Decodable {
    var version: Int
    var debug: Bool
}

let json = "{\"version\":2,\"debug\":true}"
let data = json.data(using: .utf8)!
let c = try JSONDecoder().decode(Config.self, from: data)
print(c.version, c.debug)

Tipos de propiedades compatibles

Los tipos de la biblioteca estándar, como String, Int, Double, Bool, Date, Data y URL, además de los arrays y diccionarios cuyos elementos son Codable, son todos Codable de forma predeterminada.

import Foundation

struct Profile: Codable {
    var name: String
    var tags: [String]
    var scores: [String: Int]
}

let p = Profile(name: "Sam", tags: ["a", "b"], scores: ["math": 90])
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Los enums también pueden conformar

Un enum con valores raw, como String o Int, se convierte automáticamente en Codable. En JSON, se codifica como su valor raw.

import Foundation

enum Status: String, Codable {
    case active, paused, done
}

struct Task: Codable {
    var title: String
    var status: Status
}

let t = Task(title: "Ship", status: .active)
let data = try JSONEncoder().encode(t)
print(String(data: data, encoding: .utf8)!)

Una propiedad debe ser Codable

La síntesis solo funciona cuando todas las propiedades almacenadas son Codable. Si se utiliza un tipo personalizado como propiedad, ese tipo también debe conformar; de lo contrario, el compilador se niega a sintetizar la conformidad.

import Foundation

struct Address: Codable {
    var city: String
}

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

let p = Person(name: "Lee", address: Address(city: "Rome"))
print(try JSONEncoder().encode(p).count, "bytes")

Por qué importa Codable

Codable elimina el código repetitivo de serialización escrito manualmente, mantiene el tipo como única fuente de verdad y detecta las incompatibilidades en tiempo de compilación. Es la forma estándar de trasladar datos hacia dentro y fuera de las apps de Swift.

import Foundation

struct Settings: Codable {
    var theme: String
    var fontSize: Int
}

let s = Settings(theme: "dark", fontSize: 14)
let data = try JSONEncoder().encode(s)
let back = try JSONDecoder().decode(Settings.self, from: data)
print(back.theme, back.fontSize)

Comprobación rápida: conformidad con Codable

Compruebe lo que ha aprendido sobre la conformidad.

Resumen: conformidad con Codable

Ha aprendido los fundamentos de la serialización en Swift:

Codable = Encodable & Decodable.
La conformidad se sintetiza cuando todas las propiedades son Codable.
JSONEncoder produce Data; JSONDecoder reconstruye el valor.
Los tipos estándar, los enums con valores raw y los tipos Codable anidados son compatibles.

Preguntas frecuentes

¿La lección «Conformidad con Codable» es gratis?

Sí — el texto completo de «Conformidad con Codable» 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 «Conformidad con Codable»?

Haga que los tipos se codifiquen y decodifiquen automáticamente. 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 1 de 4.

¿Cuánto tiempo toma la lección «Conformidad con Codable»?

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

← Volver a Swift Academy