0Pricing
Swift Academy · Leçon

Stratégies de décodage des clés et des dates

Utilisez snake_case et des stratégies de date.

Stratégies de décodage des clés et des dates est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Présentation des stratégies de décodage

Plutôt que d’écrire une énumération CodingKeys pour chaque type, vous pouvez définir une stratégie globale sur le décodeur. Les stratégies transforment les clés et analysent les dates de manière uniforme pour tous les types décodés.

import Foundation

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

convertFromSnakeCase

En définissant keyDecodingStrategy = .convertFromSnakeCase, les clés comme first_name sont automatiquement associées à la propriété en camelCase firstName — sans avoir besoin de 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)

Encodage avec une notation à traits de soulignement

L’encodeur propose l’option inverse : keyEncodingStrategy = .convertToSnakeCase écrit les propriétés en camelCase sous forme de clés JSON utilisant une notation à traits de soulignement.

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 stratégie s’applique à toutes les clés

Une stratégie de clés s’applique uniformément à chaque propriété de chaque type imbriqué. C’est idéal lorsqu’une API entière utilise systématiquement une notation à traits de soulignement.

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)

Le problème des dates

JSON ne possède pas de type date. Les valeurs Date sont encodées sous forme de nombres ou de chaînes, et le décodeur doit connaître le format utilisé. Une dateDecodingStrategy lui indique comment procéder.

import Foundation

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

print("Date needs a strategy to parse")

Décodage des dates avec iso8601

dateDecodingStrategy = .iso8601 analyse les horodatages ISO-8601 standard comme 2020-01-01T00:00:00Z pour les convertir en valeurs 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)

Encodage des dates avec iso8601

L’équivalent côté encodeur est dateEncodingStrategy = .iso8601, qui écrit les valeurs Date sous forme de chaînes 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)!)

Stratégie secondsSince1970

Lorsqu’une API envoie des horodatages Unix sous forme de nombres, utilisez .secondsSince1970 pour les interpréter comme un nombre de secondes écoulées depuis l’époque 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)

Formats de date personnalisés

Pour les formats non standard, fournissez un DateFormatter via .formatted(_:). Cela permet de gérer des dates comme 2020-01-01 qui ne comportent aucune heure.

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)

Combiner les stratégies

Les stratégies de clés et de dates peuvent être définies ensemble sur le même décodeur, ce qui permet de gérer une API utilisant une notation à traits de soulignement et le format ISO-8601 sans code répétitif propre à chaque type.

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)

Stratégie ou CodingKeys

Une stratégie globale est concise pour les API uniformes. Lorsque seules quelques clés diffèrent ou que les noms sont irréguliers, une énumération CodingKeys explicite offre un contrôle précis sur chaque clé. Vous pouvez même combiner les deux approches.

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)

Vérification rapide : stratégies

Vérifiez votre compréhension des stratégies de décodage.

Récapitulatif : stratégies de clés et de dates

Vous avez appris à configurer globalement les codeurs :

  • keyDecodingStrategy = .convertFromSnakeCase convertit la notation à traits de soulignement en camelCase ; .convertToSnakeCase effectue l’encodage dans l’autre sens.
  • dateDecodingStrategy = .iso8601 analyse les horodatages ISO ; .secondsSince1970 et .formatted(_:) couvrent les autres formats.
  • Les stratégies s’appliquent uniformément à chaque type imbriqué.
  • Utilisez les stratégies pour les API uniformes et CodingKeys pour les API irrégulières.

Questions Fréquemment Posées

La leçon « Stratégies de décodage des clés et des dates » est-elle gratuite ?

Oui — le texte complet de « Stratégies de décodage des clés et des dates » 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 « Stratégies de décodage des clés et des dates » ?

Utilisez snake_case et des stratégies de date. 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 2 sur 4.

Combien de temps prend la leçon « Stratégies de décodage des clés et des dates » ?

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