Debug-freundliche Typen erstellen

Werkzeuge kombinieren

Eine klare description

struct Vector: CustomStringConvertible {
    let x: Double
    let y: Double
    var description: String { "(\(x), \(y))" }
}
print(Vector(x: 1, y: 2))  // (1.0, 2.0)

Diagnostische debugDescription hinzufügen

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)

description mit Mirror automatisch erzeugen

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)

Eine wiederverwendbare Reflexionshilfe

Gemeinsame describe-Hilfsfunktion

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)

Standardimplementierung per Protocol

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]

Verschachtelte Werte formatiert ausgeben

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))

Swift dump verwenden

struct Node { let id = 1; let kids = [2, 3] }
dump(Node())
// - id: 1
// - kids: 2 elements ...

Alles zusammenführen

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)

Felder reflektierend zählen

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 fields

Kurze Überprüfung

Zusammenfassung