Créer des types adaptés au débogage
Combinez efficacement descriptions et réflexion.
Créer des types adaptés au débogage 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.
Combiner les outils
Les meilleurs types sont faciles à inspecter. Combinez CustomStringConvertible, CustomDebugStringConvertible et Mirror pour que les valeurs s’affichent clairement et révèlent leurs détails internes à la demande.
Une description claire
Commencez par la sortie destinée à l’utilisateur :
struct Vector: CustomStringConvertible {
let x: Double
let y: Double
var description: String { "(\(x), \(y))" }
}
print(Vector(x: 1, y: 2)) // (1.0, 2.0)Ajouter des informations de diagnostic avec debugDescription
Ajoutez des détails pour le débogage :
struct Vector: CustomStringConvertible, CustomDebugStringConvertible {
let x: Double
let y: Double
var description: String { "(\(x), \(y))" }
var debugDescription: String { "Vector(x: \(x), y: \(y), len: \(length))" }
var length: Double { (x * x + y * y).squareRoot() }
}
debugPrint(Vector(x: 3, y: 4)) // Vector(x: 3.0, y: 4.0, len: 5.0)Générer automatiquement la description avec Mirror
Utilisez la réflexion pour construire une description sans énumérer chaque champ manuellement :
struct Auto: CustomStringConvertible {
let a = 1
let b = "x"
var description: String {
let fields = Mirror(reflecting: self).children
.map { "\($0.label ?? "_")=\($0.value)" }
.joined(separator: ", ")
return "Auto(\(fields))"
}
}
print(Auto()) // Auto(a=1, b=x)Un utilitaire de réflexion réutilisable
Regroupez la logique de Mirror dans une fonction libre afin que plusieurs types puissent partager un même formateur de débogage.
Un assistant partagé de description
Un seul assistant, réutilisé partout :
func reflectiveDescription(_ value: Any) -> String {
let name = String(describing: type(of: value))
let parts = Mirror(reflecting: value).children
.map { "\($0.label ?? "_"): \($0.value)" }
.joined(separator: ", ")
return "\(name)(\(parts))"
}
struct P { let id = 7; let tag = "z" }
print(reflectiveDescription(P())) // P(id: 7, tag: z)Implémentation par défaut du protocole
Faites bénéficier toute une famille de types d’un débogage par réflexion grâce à une extension de protocole :
protocol Inspectable: CustomStringConvertible {}
extension Inspectable {
var description: String {
let parts = Mirror(reflecting: self).children
.map { "\($0.label ?? "_")=\($0.value)" }
.joined(separator: ", ")
return "\(type(of: self))[\(parts)]"
}
}
struct Widget: Inspectable { let w = 10; let h = 20 }
print(Widget()) // Widget[w=10, h=20]Affichage soigné des valeurs imbriquées
La réflexion se propage naturellement lorsque les enfants sont eux-mêmes affichables :
struct Inner: CustomStringConvertible { let v = 1; var description: String { "Inner(\(v))" } }
struct Outer: CustomStringConvertible {
let inner = Inner()
var description: String { "Outer(\(inner))" }
}
print(Outer()) // Outer(Inner(1))Utiliser dump de Swift
La fonction intégrée dump utilise Mirror pour afficher un arbre détaillé et indenté — pratique pour une inspection rapide :
struct Node { let id = 1; let kids = [2, 3] }
dump(Node())
// - id: 1
// - kids: 2 elements ...Tout assembler
Un type abouti : une description claire, des informations de débogage détaillées et une solution de repli fondée sur la réflexion — facile à journaliser et à déboguer.
struct Order: CustomStringConvertible, CustomDebugStringConvertible {
let id: Int
let total: Double
var description: String { "Order #\(id)" }
var debugDescription: String { "Order(id: \(id), total: \(total))" }
}
let o = Order(id: 5, total: 9.99)
print(o) // Order #5
debugPrint(o) // Order(id: 5, total: 9.99)Compter les champs par réflexion
La réflexion est également pratique pour effectuer rapidement des assertions structurelles, comme compter les propriétés :
struct Profile { let name = "A"; let age = 1; let city = "X" }
let fieldCount = Mirror(reflecting: Profile()).children.count
print("Profile has \(fieldCount) fields") // Profile has 3 fieldsVérification rapide
Comment construire une description sans énumérer manuellement chaque propriété ?
Récapitulatif
Vous avez appris à créer des types faciles à déboguer :
- Combiner
description(claire) etdebugDescription(détaillée) - Utiliser
Mirrorpour générer automatiquement des descriptions à partir des enfants - Regrouper la réflexion dans un utilitaire ou une implémentation par défaut de protocole
dumpaffiche un arbre réfléchi détaillé pour une inspection rapide
Cours terminé !
Questions Fréquemment Posées
La leçon « Créer des types adaptés au débogage » est-elle gratuite ?
Oui — le texte complet de « Créer des types adaptés au débogage » 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 « Créer des types adaptés au débogage » ?
Combinez efficacement descriptions et réflexion. 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 « Créer des types adaptés au débogage » ?
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
- CustomStringConvertible
- CustomDebugStringConvertible
- Réflexion avec Mirror
- Créer des types adaptés au débogage