0Pricing
Swift Academy · Lección

Estrategias de decodificación de claves y fechas

Utilice snake_case y estrategias para fechas.

Estrategias de decodificación de claves y fechas 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.

Descripción general de las estrategias de decodificación

En lugar de escribir un enum CodingKeys para cada tipo, puede establecer una estrategia global en el decodificador. Las estrategias transforman las claves y analizan las fechas de forma uniforme en todos los tipos decodificados.

import Foundation

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
print("Strategy configured")

convertFromSnakeCase

Al establecer keyDecodingStrategy = .convertFromSnakeCase, las claves como first_name se asignan automáticamente a la propiedad camelCase firstName, sin necesidad de usar CodingKeys.

import Foundation

struct User: Codable {
    var firstName: String
    var lastName: String
}

let json = "{\"first_name\":\"Ada\",\"last_name\":\"Lovelace\"}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let u = try decoder.decode(User.self, from: json.data(using: .utf8)!)
print(u.firstName, u.lastName)

Codificación a snake_case

El codificador tiene la opción equivalente: keyEncodingStrategy = .convertToSnakeCase escribe las propiedades camelCase como claves JSON en snake_case.

import Foundation

struct User: Codable {
    var firstName: String
}

let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase
let data = try encoder.encode(User(firstName: "Ada"))
print(String(data: data, encoding: .utf8)!)

La estrategia se aplica a todas las claves

Una estrategia de claves se aplica uniformemente a todas las propiedades de todos los tipos anidados. Es ideal cuando una API completa utiliza snake_case de forma coherente.

import Foundation

struct Meta: Codable { var createdAt: String }
struct Doc: Codable { var docTitle: String; var docMeta: Meta }

let json = "{\"doc_title\":\"A\",\"doc_meta\":{\"created_at\":\"now\"}}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let d = try decoder.decode(Doc.self, from: json.data(using: .utf8)!)
print(d.docTitle, d.docMeta.createdAt)

El problema de las fechas

JSON no tiene un tipo de fecha. Los valores Date se codifican como números o cadenas, y el decodificador necesita conocer el formato. dateDecodingStrategy le indica cómo interpretarlos.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

print("Date needs a strategy to parse")

Decodificación de fechas con iso8601

dateDecodingStrategy = .iso8601 analiza marcas de tiempo ISO-8601 estándar como 2020-01-01T00:00:00Z y las convierte en valores Date.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

let json = "{\"name\":\"Launch\",\"date\":\"2020-01-01T00:00:00Z\"}"
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let e = try decoder.decode(Event.self, from: json.data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Codificación de fechas con iso8601

La opción equivalente del codificador es dateEncodingStrategy = .iso8601, que escribe los valores Date como cadenas ISO-8601.

import Foundation

struct Event: Codable {
    var name: String
    var date: Date
}

let e = Event(name: "Launch", date: Date(timeIntervalSince1970: 1577836800))
let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .iso8601
let data = try encoder.encode(e)
print(String(data: data, encoding: .utf8)!)

Estrategia secondsSince1970

Cuando una API envía marcas de tiempo Unix como números, use .secondsSince1970 para interpretarlas como segundos transcurridos desde el inicio de la época Unix.

import Foundation

struct Event: Codable {
    var date: Date
}

let json = "{\"date\":1577836800}"
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .secondsSince1970
let e = try decoder.decode(Event.self, from: json.data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Formatos de fecha personalizados

Para formatos no estándar, proporcione un DateFormatter mediante .formatted(_:). Esto permite gestionar fechas como 2020-01-01 que no incluyen un componente de hora.

import Foundation

struct Event: Codable { var date: Date }

let fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
fmt.timeZone = TimeZone(identifier: "UTC")
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .formatted(fmt)
let e = try decoder.decode(Event.self, from: "{\"date\":\"2020-01-01\"}".data(using: .utf8)!)
print(e.date.timeIntervalSince1970)

Combinación de estrategias

Puede establecer conjuntamente las estrategias de claves y fechas en el mismo decodificador, lo que permite gestionar una API en snake_case y con fechas ISO-8601 sin código repetitivo por tipo.

import Foundation

struct LogEntry: Codable {
    var eventName: String
    var occurredAt: Date
}

let json = "{\"event_name\":\"login\",\"occurred_at\":\"2020-01-01T00:00:00Z\"}"
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
decoder.dateDecodingStrategy = .iso8601
let entry = try decoder.decode(LogEntry.self, from: json.data(using: .utf8)!)
print(entry.eventName, entry.occurredAt.timeIntervalSince1970)

Estrategia frente a CodingKeys

Una estrategia global resulta concisa para las API uniformes. Cuando solo difieren unas pocas claves o los nombres son irregulares, un enum explícito CodingKeys proporciona un control preciso de cada clave. Incluso puede combinar ambas opciones.

import Foundation

struct Item: Codable {
    var itemName: String
}

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let i = try decoder.decode(Item.self, from: "{\"item_name\":\"Pen\"}".data(using: .utf8)!)
print(i.itemName)

Comprobación rápida: estrategias

Compruebe cuánto ha entendido sobre las estrategias de decodificación.

Resumen: estrategias de claves y fechas

Ha aprendido a configurar globalmente los codificadores:

  • keyDecodingStrategy = .convertFromSnakeCase asigna snake_case a camelCase; .convertToSnakeCase codifica en la dirección contraria.
  • dateDecodingStrategy = .iso8601 analiza marcas de tiempo ISO; .secondsSince1970 y .formatted(_:) cubren otros formatos.
  • Las estrategias se aplican uniformemente a todos los tipos anidados.
  • Use estrategias para API uniformes y CodingKeys para API irregulares.

Preguntas frecuentes

¿La lección «Estrategias de decodificación de claves y fechas» es gratis?

Sí — el texto completo de «Estrategias de decodificación de claves y fechas» 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 «Estrategias de decodificación de claves y fechas»?

Utilice snake_case y estrategias para fechas. 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 «Estrategias de decodificación de claves y fechas»?

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. CodingKeys para cambiar nombres
  2. Estrategias de decodificación de claves y fechas
  3. encode(to:) e init(from:) manuales
  4. Decodificación de JSON heterogéneo
← Volver a Swift Academy