Swift Academy · Lección

CodingKeys para cambiar nombres

Asigne nombres diferentes entre JSON y las propiedades.

CodingKeys para cambiar nombres 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.

¿Por qué cambiar el nombre de las claves?

Las API JSON suelen utilizar nombres distintos de los nombres de sus propiedades de Swift, como first_name frente a firstName. Un enum CodingKeys conecta ambos nombres sin cambiar la API de su modelo.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

print("CodingKeys maps firstName to first_name")

Anatomía de CodingKeys

CodingKeys es un enum anidado que conforma a String, CodingKey. Cada caso coincide con el nombre de una propiedad; su valor raw es la clave JSON que se utilizará.

import Foundation

struct Product: Codable {
    var productName: String
    var unitPrice: Double
    enum CodingKeys: String, CodingKey {
        case productName = "product_name"
        case unitPrice = "unit_price"
    }
}

print(Product.CodingKeys.productName.rawValue)

Decodificación con claves renombradas

Al decodificar, el decoder busca cada propiedad utilizando el valor raw de CodingKeys, por lo que el JSON en snake_case rellena las propiedades en camelCase.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

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

Codificación con claves renombradas

La codificación utiliza la misma correspondencia en sentido inverso: el JSON de salida contiene las claves de los valores raw, no los nombres de las propiedades de Swift.

import Foundation

struct User: Codable {
    var firstName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
    }
}

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

Listado de todas las propiedades

Una vez que añade un enum CodingKeys, debe incluir un caso para cada propiedad que quiera codificar o decodificar. Los casos que conserve sin valor raw utilizan el nombre de la propiedad tal cual.

import Foundation

struct Item: Codable {
    var id: Int
    var displayName: String
    enum CodingKeys: String, CodingKey {
        case id
        case displayName = "display_name"
    }
}

let data = try JSONEncoder().encode(Item(id: 1, displayName: "Pen"))
print(String(data: data, encoding: .utf8)!)

Omisión de una propiedad

Dejar una propiedad fuera de CodingKeys la excluye de la codificación y la decodificación. Esa propiedad debe tener un valor predeterminado para que el inicializador sintetizado pueda seguir creando el tipo.

import Foundation

struct User: Codable {
    var name: String
    var cachedToken: String = "none"
    enum CodingKeys: String, CodingKey {
        case name
    }
}

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

Renombrado de varias claves

Asigne tantas claves como necesite. Cada caso vincula una propiedad de Swift con la clave JSON exacta que espera el servidor.

import Foundation

struct Account: Codable {
    var userId: Int
    var isVerified: Bool
    enum CodingKeys: String, CodingKey {
        case userId = "user_id"
        case isVerified = "is_verified"
    }
}

let json = "{\"user_id\":7,\"is_verified\":true}"
let a = try JSONDecoder().decode(Account.self, from: json.data(using: .utf8)!)
print(a.userId, a.isVerified)

Asignación de nombres más claros

CodingKeys no sirve únicamente para snake_case. Utilícelo para cambiar claves crípticas de una API por nombres claros de propiedades de Swift.

import Foundation

struct Reading: Codable {
    var temperature: Double
    enum CodingKeys: String, CodingKey {
        case temperature = "t"
    }
}

let json = "{\"t\":19.5}"
let r = try JSONDecoder().decode(Reading.self, from: json.data(using: .utf8)!)
print(r.temperature)

CodingKeys con tipos anidados

Cada tipo Codable tiene su propio CodingKeys. Un struct anidado puede cambiar el nombre de sus propias claves independientemente del tipo principal.

import Foundation

struct Meta: Codable {
    var createdAt: String
    enum CodingKeys: String, CodingKey { case createdAt = "created_at" }
}
struct Doc: Codable { var title: String; var meta: Meta }

let json = "{\"title\":\"A\",\"meta\":{\"created_at\":\"today\"}}"
let d = try JSONDecoder().decode(Doc.self, from: json.data(using: .utf8)!)
print(d.meta.createdAt)

Conversión de ida y vuelta con claves renombradas

El mismo CodingKeys controla ambas direcciones, por lo que un valor se codifica en snake_case y se vuelve a decodificar como el mismo valor de Swift.

import Foundation

struct User: Codable {
    var firstName: String
    var lastName: String
    enum CodingKeys: String, CodingKey {
        case firstName = "first_name"
        case lastName = "last_name"
    }
}

let u = User(firstName: "Ada", lastName: "Lovelace")
let data = try JSONEncoder().encode(u)
let back = try JSONDecoder().decode(User.self, from: data)
print(back.firstName, back.lastName)

Cuándo utilizar CodingKeys

Utilice un enum CodingKeys explícito cuando necesite un control preciso sobre claves individuales, cuando solo algunas claves sean diferentes o cuando deba omitir una propiedad. Para una API con un formato snake_case uniforme, una estrategia de decodificación puede ser más sencilla.

import Foundation

struct Event: Codable {
    var eventName: String
    var startTime: String
    enum CodingKeys: String, CodingKey {
        case eventName = "name"
        case startTime = "start_time"
    }
}

let json = "{\"name\":\"Launch\",\"start_time\":\"10:00\"}"
let e = try JSONDecoder().decode(Event.self, from: json.data(using: .utf8)!)
print(e.eventName, e.startTime)

Comprobación rápida: CodingKeys

Compruebe su comprensión del renombrado de claves.

Resumen: CodingKeys para renombrar claves

Ha aprendido a controlar las claves con precisión:

Declare enum CodingKeys: String, CodingKey dentro del tipo.
El valor raw de cada caso es la clave JSON; los casos controlan tanto la codificación como la decodificación.
Incluya cada propiedad que quiera codificar; omitir una la excluye y requiere que tenga un valor predeterminado.
Los tipos anidados tienen sus propios CodingKeys independientes.

Preguntas frecuentes

¿La lección «CodingKeys para cambiar nombres» es gratis?

Sí — el texto completo de «CodingKeys para cambiar nombres» 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 «CodingKeys para cambiar nombres»?

Asigne nombres diferentes entre JSON y las propiedades. 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 «CodingKeys para cambiar nombres»?

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

CodingKeys para cambiar nombres
Estrategias de decodificación de claves y fechas
encode(to:) e init(from:) manuales
Decodificación de JSON heterogéneo

← Volver a Swift Academy