Swift Academy · Lekcja

CustomDebugStringConvertible

Udostępnianie bogatszych informacji debugowania.

CustomDebugStringConvertible to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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.

Osobny widok debugowania

CustomDebugStringConvertible udostępnia debugDescription — reprezentację używaną przez debugPrint, polecenie po w LLDB i debuger. Może ona zawierać więcej szczegółów niż description.

Dodawanie debugDescription

Należy zapewnić zgodność z protokołem i udostępnić tę właściwość:

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 a print

print używa description, a debugPrint używa 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)

Kiedy udostępnić obie właściwości

Właściwości description należy używać do tworzenia przejrzystych danych wyjściowych dla użytkownika, a debugDescription do szczegółów diagnostycznych (wartości surowych i stanu wewnętrznego). Udostępnienie obu zapewnia najlepszy efekt w każdym kontekście.

Więcej szczegółów w debugowaniu

Należy ujawnić szczegóły wewnętrzne, których użytkownicy nie powinni widzieć:

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)

Dane debugowania w kolekcjach

debugPrint kolekcji używa właściwości debugDescription każdego elementu:

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

String(reflecting:)

Podobnie jak String(describing:) używa description, tak String(reflecting:) używa debugDescription:

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

Zachowanie zastępcze

Jeśli typ udostępnia tylko description, debugPrint używa jej jako rozwiązania zastępczego. Jeśli udostępnia tylko debugDescription, zwykłe print nadal używa domyślnej postaci mirror:

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

Cudzysłowy w danych debugowania

Należy zauważyć, że debugPrint ciągu znaków dodaje cudzysłowy, co odzwierciedla jego przeznaczenie do debugowania:

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

Diagnostyka bez ujawniania danych

Nie należy umieszczać danych poufnych w description, ale można umieścić je w debugDescription, jeśli logi są bezpieczne. Należy świadomie wybrać, jakie informacje ujawnia każda z tych właściwości.

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

Szczegóły debugowania typu wyliczeniowego

Typy wyliczeniowe mogą korzystać z właściwości debugDescription ujawniającej surowy przypadek i dane:

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)

Szybkie sprawdzenie

Która funkcja używa debugDescription zamiast description?

Podsumowanie

Poznali Państwo CustomDebugStringConvertible:

Należy udostępnić var debugDescription: String na potrzeby danych diagnostycznych
Właściwość jest używana przez debugPrint, String(reflecting:) i debuger
print używa description, a debugPrint używa debugDescription
Szczegóły wewnętrzne należy umieszczać w danych debugowania, a przejrzysty tekst w description

Następnie: refleksja z użyciem Mirror.

Często zadawane pytania

Czy lekcja „CustomDebugStringConvertible” jest bezpłatna?

Tak — pełny tekst „CustomDebugStringConvertible” 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 „CustomDebugStringConvertible”?

Udostępnianie bogatszych informacji debugowania. Ć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 2 z 4.

Ile czasu zajmuje lekcja „CustomDebugStringConvertible”?

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