Swift Academy · Leçon

Réflexion avec Mirror

Inspectez les propriétés de n’importe quelle valeur à l’exécution.

Réflexion avec Mirror 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.

Qu’est-ce que Mirror ?

Mirror est le mécanisme de réflexion de l’environnement d’exécution de Swift : il permet d’inspecter la structure d’une valeur — ses propriétés et leurs valeurs — sans connaître le type concret à la compilation.

Créer un Mirror

Transmettez n’importe quelle valeur à Mirror(reflecting:) :

struct Point { let x: Int; let y: Int }
let m = Mirror(reflecting: Point(x: 1, y: 2))
print(m.children.count)  // 2

Parcourir les enfants

Chaque enfant est une paire étiquette/valeur :

struct User { let name: String; let age: Int }
let m = Mirror(reflecting: User(name: "Ann", age: 30))
for child in m.children {
    print("\(child.label ?? "?") = \(child.value)")
}
// name = Ann
// age = 30

Construire un dictionnaire de champs

La réflexion peut aplatir une structure en dictionnaire :

struct Config { let host: String; let port: Int }
let m = Mirror(reflecting: Config(host: "x", port: 80))
var dict: [String: Any] = [:]
for c in m.children { if let l = c.label { dict[l] = c.value } }
print(dict["port"]!)  // 80

displayStyle

Mirror indique un displayStyle — .struct, .class, .enum, .tuple, .collection, etc. — afin que vous puissiez choisir une branche selon le type de valeur.

Inspecter le mode d’affichage

Détectez le type de valeur que vous inspectez par réflexion :

struct S { let a = 1 }
let m = Mirror(reflecting: S())
if m.displayStyle == .struct {
    print("it is a struct with \(m.children.count) field(s)")
}
// it is a struct with 1 field(s)

Réfléchir sur un tuple

Les tuples exposent des enfants positionnels :

let m = Mirror(reflecting: (10, "hi", true))
for c in m.children { print(c.value) }
// 10
// hi
// true

Réfléchir sur des énumérations

Pour les cas d’énumération comportant des valeurs associées, l’enfant contient la charge utile :

enum Result2 { case ok(Int); case fail(String) }
let m = Mirror(reflecting: Result2.ok(42))
print(m.children.first?.value ?? "none")  // 42

Un afficheur de champs générique

La réflexion permet de créer des utilitaires indépendants du type :

func dump2(_ value: Any) {
    for c in Mirror(reflecting: value).children {
        print("\(c.label ?? "_"): \(c.value)")
    }
}
struct Car { let make: String; let year: Int }
dump2(Car(make: "Mini", year: 2020))
// make: Mini
// year: 2020

Coûts et limites de la réflexion

Mirror est plus lent que l’accès direct et fonctionne en lecture seule — vous ne pouvez pas définir de propriétés avec cet outil. Utilisez-le pour le débogage, la journalisation et les utilitaires de sérialisation, mais pas dans les chemins critiques.

struct P { let v: Int }
let m = Mirror(reflecting: P(v: 5))
print(m.children.first!.value)  // 5  (read only)

Convertir les valeurs réfléchies

Les valeurs des enfants sont typées comme Any ; reconvertissez-les vers leur type concret lorsque vous en avez besoin :

struct Box { let count: Int; let label: String }
let m = Mirror(reflecting: Box(count: 3, label: "hi"))
for c in m.children {
    if let n = c.value as? Int { print("int: \(n)") }
    if let s = c.value as? String { print("str: \(s)") }
}
// int: 3
// str: hi

Vérification rapide

Que vous renvoie l’itération sur Mirror(reflecting: value).children ?

Récapitulatif

Vous avez appris à utiliser Mirror :

Mirror(reflecting:) inspecte une valeur à l’exécution
children fournit des paires étiquette/valeur
displayStyle indique s’il s’agit d’une structure, d’une classe, d’une énumération, d’un tuple ou d’une collection
En lecture seule et plus lent — idéal pour le débogage et la sérialisation, mais pas dans les chemins critiques

Ensuite : créer des types faciles à déboguer.

Questions Fréquemment Posées

La leçon « Réflexion avec Mirror » est-elle gratuite ?

Oui — le texte complet de « Réflexion avec Mirror » 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 « Réflexion avec Mirror » ?

Inspectez les propriétés de n’importe quelle valeur à l’exécution. 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 « Réflexion avec Mirror » ?

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

← Retour à Swift Academy