Swift Academy · Lektion

CustomDebugStringConvertible

Stellen Sie eine ausführlichere Debug-Ausgabe bereit.

CustomDebugStringConvertible ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Eine separate Debug-Darstellung

CustomDebugStringConvertible stellt debugDescription bereit — die Darstellung, die von debugPrint, dem LLDB-Befehl po und dem Debugger verwendet wird. Sie kann ausführlicher sein als description.

debugDescription hinzufügen

Stellen Sie die Konformität her und geben Sie die Eigenschaft an:

struct Point: CustomDebugStringConvertible {
    let x: Int
    let y: Int
    var debugDescription: String { "Point(x: \(x), y: \(y))" }
}
debugPrint(Point(x: 1, y: 2))  // Point(x: 1, y: 2)

debugPrint im Vergleich zu print

print verwendet description; debugPrint verwendet debugDescription:

struct Money: CustomStringConvertible, CustomDebugStringConvertible {
    let cents: Int
    var description: String { "$\(Double(cents)/100)" }
    var debugDescription: String { "Money(cents: \(cents))" }
}
let m = Money(cents: 250)
print(m)       // $2.5
debugPrint(m)  // Money(cents: 250)

Wann beide bereitgestellt werden sollten

Verwenden Sie description für eine klare Benutzerausgabe und debugDescription für diagnostische Details (Rohwerte, interner Zustand). Wenn Sie beide bereitstellen, erhalten Sie das Beste für den jeweiligen Kontext.

Mehr Details im Debug-Modus

Machen Sie interne Details sichtbar, die Benutzerinnen und Benutzer nicht sehen sollten:

struct Session: CustomStringConvertible, CustomDebugStringConvertible {
    let user: String
    let token: String
    var description: String { "Session(\(user))" }
    var debugDescription: String { "Session(user: \(user), token: \(token))" }
}
let s = Session(user: "ann", token: "xyz")
print(s)       // Session(ann)
debugPrint(s)  // Session(user: ann, token: xyz)

Debug-Ausgabe in Collections

debugPrint einer Collection verwendet die debugDescription jedes Elements:

struct Tag: CustomDebugStringConvertible {
    let name: String
    var debugDescription: String { "Tag(\(name))" }
}
debugPrint([Tag(name: "a"), Tag(name: "b")])  // [Tag(a), Tag(b)]

String(reflecting:)

So wie String(describing:) description verwendet, verwendet String(reflecting:) debugDescription:

struct Code: CustomDebugStringConvertible {
    let n: Int
    var debugDescription: String { "Code<\(n)>" }
}
print(String(reflecting: Code(n: 7)))  // Code<7>

Fallback-Verhalten

Wenn ein Typ nur description bereitstellt, greift debugPrint darauf zurück. Wenn er nur debugDescription bereitstellt, verwendet das einfache print weiterhin die standardmäßige Mirror-Darstellung:

struct Only: CustomStringConvertible {
    let v: Int
    var description: String { "Only(\(v))" }
}
debugPrint(Only(v: 3))  // Only(3)  -- falls back to description

Anführungszeichen in der Debug-Ausgabe

Beachten Sie, dass debugPrint eines Strings Anführungszeichen hinzufügt, was seinem Debug-Charakter entspricht:

print("hi")        // hi
debugPrint("hi")   // "hi"

Diagnose ohne Daten preiszugeben

Halten Sie Geheimnisse aus description heraus, und erlauben Sie sie in debugDescription nur, wenn die Protokolle sicher sind. Entscheiden Sie bewusst, welche Informationen die beiden Darstellungen offenlegen.

struct Key: CustomStringConvertible {
    let secret: String
    var description: String { "Key(***)" }
}
print(Key(secret: "abc"))  // Key(***)

Debug-Details für ein Enum

Enums profitieren von einer debugDescription, die den Rohwert des Falls und die Nutzdaten offenlegt:

enum Load: CustomDebugStringConvertible {
    case idle
    case progress(Int)
    var debugDescription: String {
        switch self {
        case .idle: return "Load.idle"
        case .progress(let p): return "Load.progress(\(p))"
        }
    }
}
debugPrint(Load.progress(40))  // Load.progress(40)

Schnelltest

Welche Funktion verwendet debugDescription statt description?

Zusammenfassung

Sie haben CustomDebugStringConvertible kennengelernt:

Stellen Sie var debugDescription: String für diagnostische Ausgaben bereit
Wird von debugPrint, String(reflecting:) und dem Debugger verwendet
print verwendet description; debugPrint verwendet debugDescription
Platzieren Sie zusätzliche interne Details im Debug-Text und klaren Text in description

Als Nächstes: Reflexion mit Mirror.

Häufig gestellte Fragen

Ist die Lektion „CustomDebugStringConvertible“ kostenlos?

Ja — der vollständige Text von „CustomDebugStringConvertible“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „CustomDebugStringConvertible“?

Stellen Sie eine ausführlichere Debug-Ausgabe bereit. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „CustomDebugStringConvertible“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy