Swift Academy · Aula

Construção de Tipos Fáceis de Depurar

Combine descrições e reflexão de forma eficaz.

Construção de Tipos Fáceis de Depurar é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Combinando as ferramentas

Os melhores tipos são fáceis de inspecionar. Combine CustomStringConvertible, CustomDebugStringConvertible e Mirror para criar valores que sejam exibidos com clareza e revelem seus detalhes internos quando necessário.

Uma description limpa

Comece com a saída voltada ao usuário:

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

Adicionando uma debugDescription de diagnóstico

Acrescente detalhes para a depuração:

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)

Gerando description automaticamente com Mirror

Use a reflexão para criar uma description sem listar cada campo manualmente:

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)

Um auxiliar de reflexão reutilizável

Extraia a lógica de Mirror para uma função livre, para que vários tipos possam compartilhar um único formatador de depuração.

Auxiliar describe compartilhado

Um único auxiliar, reutilizado em todos os lugares:

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)

Implementação padrão de protocolo

Ofereça depuração reflexiva a toda uma família de tipos por meio de uma extensão de protocolo:

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]

Exibindo valores aninhados de forma legível

A reflexão recursa naturalmente quando os próprios filhos podem ser exibidos:

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

Usando o dump do Swift

O dump integrado usa Mirror para exibir uma árvore profunda e recuada — útil para uma inspeção rápida:

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

Reunindo tudo

Um tipo refinado: description limpa, informações detalhadas de depuração e fallback reflexivo — fácil de registrar e de depurar.

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)

Contando campos por reflexão

A reflexão também é útil para asserções estruturais rápidas, como contar propriedades:

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

Verificação rápida

Como você pode criar uma description sem listar manualmente cada propriedade?

Recapitulação

Você aprendeu a criar tipos fáceis de depurar:

Combine description (limpa) e debugDescription (detalhada)
Use Mirror para gerar descriptions automaticamente a partir dos filhos
Extraia a reflexão para um auxiliar ou uma implementação padrão de protocolo
dump exibe uma árvore refletida profunda para uma inspeção rápida

Curso concluído!

Perguntas Frequentes

A aula “Construção de Tipos Fáceis de Depurar” é grátis?

Sim — o texto completo de “Construção de Tipos Fáceis de Depurar” é 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 “Construção de Tipos Fáceis de Depurar”?

Combine descrições e reflexão de forma eficaz. 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 4 de 4.

Quanto tempo leva a aula “Construção de Tipos Fáceis de Depurar”?

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