0Pricing
Swift Academy · Leçon

Gestion des types optionnels et imbriqués

Décodez les valeurs optionnelles et les structures imbriquées en toute sécurité.

Gestion des types optionnels et imbriqués est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Propriétés optionnelles

Une propriété optionnelle est naturellement Codable lorsque le type qu’elle contient l’est. Une clé JSON absente est décodée en nil ; une clé présente est décodée normalement.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

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

Encoder les valeurs optionnelles nil

Par défaut, une valeur optionnelle nil est entièrement exclue du JSON encodé, ce qui produit une charge utile plus petite.

import Foundation

struct User: Codable {
    var name: String
    var nickname: String?
}

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

Une valeur null explicite est décodée en nil

Si le JSON contient un null explicite pour une propriété optionnelle, celle-ci est décodée en nil au lieu de générer une erreur.

import Foundation

struct User: Codable {
    var name: String
    var age: Int?
}

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

Structures Codable imbriquées

Composez vos modèles en imbriquant des types Codable. Le type externe encode et décode automatiquement le type interne.

import Foundation

struct Address: Codable { var city: String; var zip: String }
struct Person: Codable { var name: String; var address: Address }

let p = Person(name: "Lee", address: Address(city: "Rome", zip: "00100"))
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Décoder des structures imbriquées

Le processus inverse fonctionne également : les objets JSON imbriqués sont décodés dans les propriétés de la structure imbriquée.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address }

let json = "{\"name\":\"Lee\",\"address\":{\"city\":\"Rome\"}}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address.city)

Types imbriqués optionnels

Une structure imbriquée peut elle-même être optionnelle. Si la clé est absente, la valeur imbriquée entière devient nil.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable { var name: String; var address: Address? }

let json = "{\"name\":\"Lee\"}"
let p = try JSONDecoder().decode(Person.self, from: json.data(using: .utf8)!)
print(p.address?.city ?? "no address")

Tableaux de valeurs Codable

Un tableau dont les éléments sont d’un type Codable est lui-même Codable. Il correspond directement à un tableau JSON d’objets.

import Foundation

struct Tag: Codable { var name: String }
struct Post: Codable { var title: String; var tags: [Tag] }

let p = Post(title: "Hi", tags: [Tag(name: "swift"), Tag(name: "json")])
let data = try JSONEncoder().encode(p)
print(String(data: data, encoding: .utf8)!)

Décoder des tableaux de structures

Le décodage d’un tableau JSON d’objets produit un tableau Swift de valeurs typées que vous pouvez parcourir.

import Foundation

struct Tag: Codable { var name: String }

let json = "[{\"name\":\"a\"},{\"name\":\"b\"}]"
let tags = try JSONDecoder().decode([Tag].self, from: json.data(using: .utf8)!)
for t in tags { print(t.name) }

Tableaux optionnels

Un tableau optionnel distingue « clé absente » (nil) et « clé présente mais vide » ([]). Les deux états sont valides et ont une signification.

import Foundation

struct Box: Codable { var items: [String]? }

let a = try JSONDecoder().decode(Box.self, from: "{}".data(using: .utf8)!)
let b = try JSONDecoder().decode(Box.self, from: "{\"items\":[]}".data(using: .utf8)!)
print(a.items == nil, b.items == [])

Structures profondément imbriquées

L’imbrication peut s’étendre sur plusieurs niveaux : des structures dans des tableaux, eux-mêmes dans des structures. Codable gère chaque niveau récursivement.

import Foundation

struct Comment: Codable { var text: String }
struct Article: Codable { var title: String; var comments: [Comment] }
struct Feed: Codable { var articles: [Article] }

let feed = Feed(articles: [Article(title: "A", comments: [Comment(text: "hi")])])
let data = try JSONEncoder().encode(feed)
print(String(data: data, encoding: .utf8)!)

Aller-retour avec des valeurs optionnelles et imbriquées

En combinant tous ces éléments, les champs optionnels, les structures imbriquées et les tableaux restent intacts après un aller-retour complet d’encodage et de décodage.

import Foundation

struct Address: Codable { var city: String }
struct Person: Codable {
    var name: String
    var address: Address?
    var hobbies: [String]
}

let p = Person(name: "Mo", address: Address(city: "Cairo"), hobbies: ["chess"])
let data = try JSONEncoder().encode(p)
let back = try JSONDecoder().decode(Person.self, from: data)
print(back.address?.city ?? "-", back.hobbies.first ?? "-")

Vérification rapide : valeurs optionnelles et imbrication

Vérifiez votre compréhension des types Codable optionnels et imbriqués.

Récapitulatif : types optionnels et imbriqués

Vous avez appris comment Codable gère des structures de données plus riches :

  • Les propriétés optionnelles tolèrent les clés absentes et la valeur null explicite, qui est décodée en nil.
  • Par défaut, les valeurs optionnelles nil sont omises lors de l’encodage.
  • Les structures et tableaux Codable imbriqués sont encodés et décodés récursivement.
  • Les tableaux optionnels distinguent l’absence (nil) du tableau vide ([]).

Questions Fréquemment Posées

La leçon « Gestion des types optionnels et imbriqués » est-elle gratuite ?

Oui — le texte complet de « Gestion des types optionnels et imbriqués » 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 « Gestion des types optionnels et imbriqués » ?

Décodez les valeurs optionnelles et les structures imbriquées en toute sécurité. 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 4 sur 4.

Combien de temps prend la leçon « Gestion des types optionnels et imbriqués » ?

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