Swift Academy · Lekcja

Budowanie typów przyjaznych debugowaniu

Skuteczne łączenie opisów i refleksji.

Lekcja 4 z 413 kroki

Budowanie typów przyjaznych debugowaniu to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Łączenie narzędzi

Najlepsze typy są łatwe do sprawdzania. Należy połączyć CustomStringConvertible, CustomDebugStringConvertible i Mirror, aby wartości były czytelnie drukowane i na żądanie ujawniały swoje elementy wewnętrzne.

Przejrzysty description

Najpierw należy zadbać o dane wyjściowe przeznaczone dla użytkownika:

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

Dodawanie diagnostycznego debugDescription

Następnie należy dodać szczegóły przydatne podczas debugowania:

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)

Automatyczne generowanie description za pomocą Mirror

Należy użyć refleksji, aby utworzyć opis bez ręcznego wymieniania każdego pola:

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)

Wielokrotnego użytku pomocnik refleksji

Należy wydzielić logikę Mirror do funkcji globalnej, aby wiele typów mogło współdzielić jeden formater danych debugowania.

Współdzielony pomocnik describe

Jeden pomocnik używany w całym kodzie:

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)

Implementacja domyślna protokołu

Należy zapewnić całej rodzinie typów debugowanie oparte na refleksji za pomocą rozszerzenia protokołu:

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]

Czytelne drukowanie zagnieżdżonych wartości

Refleksja naturalnie działa rekurencyjnie, gdy dzieci same obsługują drukowanie:

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

Używanie Swift dump

Wbudowana funkcja dump używa Mirror do drukowania głębokiego, wciętego drzewa — jest przydatna do szybkiego sprawdzania:

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

Połączenie wszystkich elementów

Dopracowany typ: przejrzysty description, bogate informacje debugowania i odwołanie awaryjne oparte na refleksji — łatwy do rejestrowania i debugowania.

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)

Refleksyjne zliczanie pól

Refleksja przydaje się również do szybkich asercji strukturalnych, takich jak zliczanie właściwości:

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

Szybkie sprawdzenie

Jak można utworzyć description bez ręcznego wymieniania każdej właściwości?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznano sposób tworzenia typów przyjaznych debugowaniu:

Łączenie description (przejrzystego) i debugDescription (szczegółowego)
Używanie Mirror do automatycznego generowania opisów na podstawie dzieci
Wydzielanie refleksji do pomocnika lub domyślnej implementacji protokołu
dump drukuje głębokie drzewo oparte na refleksji, przydatne do szybkiego sprawdzania

Kurs ukończony!

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Budowanie typów przyjaznych debugowaniu” jest bezpłatna?

Tak — pełny tekst „Budowanie typów przyjaznych debugowaniu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Budowanie typów przyjaznych debugowaniu”?

Skuteczne łączenie opisów i refleksji. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Budowanie typów przyjaznych debugowaniu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Swift Academy