0Pricing
Swift Academy · Leçon

CodingKeys pour renommer

Faites correspondre des noms JSON et de propriétés différents.

CodingKeys pour renommer est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Pourquoi renommer les clés ?

Les API JSON utilisent souvent des noms différents de ceux de vos propriétés Swift, comme first_name et firstName. Une énumération CodingKeys fait le lien entre les deux sans modifier l’API de votre modèle.

import Foundation

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

print("CodingKeys maps firstName to first_name")

Anatomie de CodingKeys

CodingKeys est une énumération imbriquée conforme à String, CodingKey. Chaque cas correspond à un nom de propriété ; sa valeur brute est la clé JSON à utiliser.

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)

Décoder avec des clés renommées

Lors du décodage, le décodeur recherche chaque propriété à l’aide de la valeur brute définie dans CodingKeys. Ainsi, un JSON en snake_case remplit des propriétés 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)

Encoder avec des clés renommées

L’encodage utilise la même correspondance dans l’autre sens : le JSON produit contient les clés correspondant aux valeurs brutes, et non les noms des propriétés 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)!)

Répertorier toutes les propriétés

Une fois que vous avez ajouté une énumération CodingKeys, elle doit inclure un cas pour chaque propriété que vous voulez encoder ou décoder. Les cas conservés sans valeur brute utilisent le nom de la propriété tel quel.

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)!)

Omettre une propriété

En laissant une propriété hors de CodingKeys, vous l’excluez de l’encodage et du décodage. Cette propriété doit avoir une valeur par défaut pour que l’initialiseur généré puisse tout de même construire le type.

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)

Renommer plusieurs clés

Faites correspondre autant de clés que nécessaire. Chaque cas associe une propriété Swift à la clé JSON exacte attendue par le serveur.

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)

Associer des noms plus explicites

CodingKeys ne sert pas uniquement au snake_case. Utilisez-le pour transformer des clés d’API obscures en noms de propriétés Swift clairs.

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 avec des types imbriqués

Chaque type Codable possède ses propres CodingKeys. Une structure imbriquée peut renommer ses propres clés indépendamment du type parent.

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)

Aller-retour avec des clés renommées

Les mêmes CodingKeys dirigent les deux opérations, de sorte qu’une valeur est encodée en snake_case puis décodée pour retrouver la même valeur 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)

Quand utiliser CodingKeys

Utilisez une énumération CodingKeys explicite lorsque certaines clés nécessitent un contrôle précis, lorsque seules quelques clés diffèrent ou lorsque vous devez omettre une propriété. Pour une API uniformément en snake_case, une stratégie de décodage peut être plus simple.

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)

Vérification rapide : CodingKeys

Vérifiez votre compréhension du renommage des clés.

Récapitulatif : CodingKeys pour renommer les clés

Vous avez appris à contrôler précisément les clés :

  • Déclarez enum CodingKeys: String, CodingKey à l’intérieur du type.
  • La valeur brute de chaque cas est la clé JSON ; les cas dirigent à la fois l’encodage et le décodage.
  • Répertoriez chaque propriété à encoder ; en omettre une l’exclut, et elle doit alors avoir une valeur par défaut.
  • Les types imbriqués possèdent leurs propres CodingKeys, indépendantes.

Questions Fréquemment Posées

La leçon « CodingKeys pour renommer » est-elle gratuite ?

Oui — le texte complet de « CodingKeys pour renommer » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « CodingKeys pour renommer » ?

Faites correspondre des noms JSON et de propriétés différents. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « CodingKeys pour renommer » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. CodingKeys pour renommer
  2. Stratégies de décodage des clés et des dates
  3. encode(to:) et init(from:) manuels
  4. Décodage de JSON hétérogène
← Retour à Swift Academy