Swift Academy · Aula

CustomDebugStringConvertible

Forneça uma saída de depuração mais detalhada.

CustomDebugStringConvertible é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Uma visualização de depuração separada

CustomDebugStringConvertible fornece debugDescription — a representação usada por debugPrint, pelo comando po do LLDB e pelo depurador. Ela pode ser mais detalhada que description.

Adicionando debugDescription

Conforme o tipo e forneça a propriedade:

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

print usa description; debugPrint usa 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)

Quando fornecer ambas

Use description para uma saída limpa voltada ao usuário e debugDescription para detalhes de diagnóstico (valores brutos e estado interno). Fornecer ambas oferece o melhor para cada contexto.

Mais detalhes na depuração

Exponha elementos internos que os usuários não devem ver:

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)

Saída de depuração em coleções

debugPrint de uma coleção usa a debugDescription de cada elemento:

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

String(reflecting:)

Assim como String(describing:) usa description, String(reflecting:) usa debugDescription:

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

Comportamento de fallback

Se um tipo fornecer apenas description, debugPrint recorrerá a ela. Se fornecer apenas debugDescription, um print simples ainda usará a representação padrão do espelho:

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

Aspas na saída de depuração

Observe que debugPrint de uma String adiciona aspas, refletindo sua natureza de depuração:

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

Diagnósticos sem vazamento de informações

Mantenha segredos fora de description, mas permita-os em debugDescription somente se os registros forem seguros. Escolha deliberadamente o que cada uma revela.

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

Detalhes de depuração para uma enumeração

Enumerações se beneficiam de uma debugDescription que expõe o caso bruto e os dados associados:

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)

Verificação rápida

Qual função usa debugDescription em vez de description?

Recapitulação

Você aprendeu sobre CustomDebugStringConvertible:

Forneça var debugDescription: String para saída de diagnóstico
É usado por debugPrint, String(reflecting:) e pelo depurador
print usa description; debugPrint usa debugDescription
Coloque detalhes internos adicionais na depuração e texto limpo em description

Próximo tópico: reflexão com Mirror.

Perguntas Frequentes

A aula “CustomDebugStringConvertible” é grátis?

Sim — o texto completo de “CustomDebugStringConvertible” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “CustomDebugStringConvertible”?

Forneça uma saída de depuração mais detalhada. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “CustomDebugStringConvertible”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy