0Pricing
Swift Academy · Leçon

Décodage avec JSONDecoder

Analysez des données JSON en valeurs Swift typées.

Décodage avec JSONDecoder est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Créer un JSONDecoder

JSONDecoder reconstruit une valeur Swift à partir de Data JSON. Indiquez-lui le type à produire et transmettez-lui les octets.

import Foundation

struct City: Codable {
    var name: String
    var population: Int
}

let json = "{\"name\":\"Oslo\",\"population\":700000}"
let data = json.data(using: .utf8)!
let city = try JSONDecoder().decode(City.self, from: data)
print(city.name, city.population)

Transmettre le type avec .self

Le premier argument est le métatype, écrit MyType.self. Il indique au décodeur quelle structure construire à partir des données.

import Foundation

struct Flag: Codable { var ok: Bool }

let data = "{\"ok\":true}".data(using: .utf8)!
let result = try JSONDecoder().decode(Flag.self, from: data)
print(result.ok)

Décoder des tableaux

Pour décoder un tableau JSON, demandez un type de tableau tel que [Int].self ou [MyStruct].self.

import Foundation

let json = "[10, 20, 30]"
let data = json.data(using: .utf8)!
let numbers = try JSONDecoder().decode([Int].self, from: data)
print(numbers.reduce(0, +))

Décoder des objets imbriqués

Les objets JSON imbriqués correspondent à des structures Codable imbriquées. Le décodeur parcourt l’arbre et remplit chaque niveau à votre place.

import Foundation

struct Coord: Codable { var lat: Double; var lon: Double }
struct Place: Codable { var name: String; var coord: Coord }

let json = "{\"name\":\"X\",\"coord\":{\"lat\":1.0,\"lon\":2.0}}"
let p = try JSONDecoder().decode(Place.self, from: json.data(using: .utf8)!)
print(p.coord.lat, p.coord.lon)

Intercepter les erreurs de décodage

decode génère une erreur lorsque les données ne correspondent pas au type. Encadrez l’appel avec do/catch pour traiter correctement les données mal formées.

import Foundation

struct User: Codable { var name: String }

let bad = "{\"wrong\":1}".data(using: .utf8)!
do {
    let u = try JSONDecoder().decode(User.self, from: bad)
    print(u.name)
} catch {
    print("Failed:", error)
}

Erreurs keyNotFound

Une erreur fréquente est DecodingError.keyNotFound, générée lorsqu’une clé obligatoire est absente. Faites correspondre le motif de l’erreur pour signaler précisément ce qui s’est mal passé.

import Foundation

struct User: Codable { var name: String }

let bad = "{}".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch let DecodingError.keyNotFound(key, _) {
    print("Missing key:", key.stringValue)
} catch {
    print("Other error:", error)
}

Erreurs typeMismatch

Si une valeur possède le mauvais type JSON, par exemple une chaîne à la place d’un Int, le décodeur génère DecodingError.typeMismatch.

import Foundation

struct Count: Codable { var n: Int }

let bad = "{\"n\":\"oops\"}".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(Count.self, from: bad)
} catch let DecodingError.typeMismatch(type, _) {
    print("Type mismatch, expected:", type)
} catch {
    print("Other:", error)
}

Erreurs dataCorrupted

Une syntaxe JSON invalide déclenche DecodingError.dataCorrupted. Cela signifie généralement que les octets ne constituent pas du JSON valide.

import Foundation

struct User: Codable { var name: String }

let bad = "not json".data(using: .utf8)!
do {
    _ = try JSONDecoder().decode(User.self, from: bad)
} catch is DecodingError {
    print("Decoding failed: data corrupted")
} catch {
    print("Other:", error)
}

Décoder des valeurs optionnelles

Si une propriété est optionnelle, une clé absente est décodée en nil sans générer d’erreur. Les champs optionnels tolèrent ainsi l’absence de données.

import Foundation

struct Profile: Codable {
    var name: String
    var bio: String?
}

let json = "{\"name\":\"Kai\"}"
let p = try JSONDecoder().decode(Profile.self, from: json.data(using: .utf8)!)
print(p.name, p.bio ?? "no bio")

Réutiliser un décodeur

Comme l’encodeur, un JSONDecoder configuré peut être réutilisé pour de nombreuses charges utiles. Conservez une seule instance et décodez différentes données avec celle-ci.

import Foundation

struct Word: Codable { var text: String }

let decoder = JSONDecoder()
let inputs = ["{\"text\":\"hi\"}", "{\"text\":\"bye\"}"]
for s in inputs {
    let w = try decoder.decode(Word.self, from: s.data(using: .utf8)!)
    print(w.text)
}

Décoder, examiner, utiliser

Le déroulement complet consiste à recevoir des Data, à décoder une valeur typée dans un bloc do/catch, puis à utiliser le résultat fortement typé en toute sécurité.

import Foundation

struct Weather: Codable {
    var city: String
    var temp: Double
}

let json = "{\"city\":\"Rome\",\"temp\":21.5}"
do {
    let w = try JSONDecoder().decode(Weather.self, from: json.data(using: .utf8)!)
    print("\(w.city): \(w.temp)C")
} catch {
    print("Decode error:", error)
}

Vérification rapide : JSONDecoder

Vérifiez vos connaissances sur le décodage.

Récapitulatif : décodage avec JSONDecoder

Vous avez appris à reconstruire des valeurs Swift à partir de JSON :

  • decode(MyType.self, from: data) produit une valeur typée.
  • Les tableaux, les objets imbriqués et les valeurs optionnelles sont décodés automatiquement.
  • decode génère les cas de DecodingError suivants : keyNotFound, typeMismatch, dataCorrupted et valueNotFound.
  • Encadrez les appels avec do/catch pour traiter les données mal formées.

Questions Fréquemment Posées

La leçon « Décodage avec JSONDecoder » est-elle gratuite ?

Oui — le texte complet de « Décodage avec JSONDecoder » 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 « Décodage avec JSONDecoder » ?

Analysez des données JSON en valeurs Swift typées. 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 3 sur 4.

Combien de temps prend la leçon « Décodage avec JSONDecoder » ?

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. Se conformer à Codable
  2. Encodage avec JSONEncoder
  3. Décodage avec JSONDecoder
  4. Gestion des types optionnels et imbriqués
← Retour à Swift Academy