Swift Academy · Lección

CustomDebugStringConvertible

Proporcione información de depuración más detallada.

CustomDebugStringConvertible es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Una vista de depuración independiente

CustomDebugStringConvertible proporciona debugDescription, la representación utilizada por debugPrint, el comando po de LLDB y el depurador. Puede ser más detallada que description.

Añadir debugDescription

Adopte el protocolo y proporcione la propiedad:

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

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

Cuándo proporcionar ambas

Utilice description para una salida limpia dirigida al usuario y debugDescription para detalles de diagnóstico (valores sin procesar y estado interno). Proporcionar ambas ofrece lo mejor de cada contexto.

Más detalles en la depuración

Exponga detalles internos que los usuarios no deberían 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)

Salida de depuración en colecciones

debugPrint de una colección utiliza la 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:)

Al igual que String(describing:) utiliza description, String(reflecting:) utiliza debugDescription:

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

Comportamiento de reserva

Si un tipo proporciona únicamente description, debugPrint recurre a ella. Si solo proporciona debugDescription, un print normal sigue utilizando la forma predeterminada de Mirror:

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

Comillas en la salida de depuración

Tenga en cuenta que debugPrint de un String añade comillas, lo que refleja su naturaleza de depuración:

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

Diagnósticos sin filtrar información

Mantenga los secretos fuera de description, pero puede permitirlos en debugDescription únicamente si los registros son seguros. Decida deliberadamente qué revela cada una.

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

Detalles de depuración para una enumeración

Las enumeraciones se benefician de un debugDescription que exponga el caso sin procesar y la carga útil:

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)

Comprobación rápida

¿Qué función utiliza debugDescription en lugar de description?

Resumen

Ha aprendido CustomDebugStringConvertible:

Proporcione var debugDescription: String para la salida de diagnóstico
Lo utilizan debugPrint, String(reflecting:) y el depurador
print utiliza description; debugPrint utiliza debugDescription
Coloque los detalles internos adicionales en la depuración y el texto limpio en description

Siguiente: reflexión con Mirror.

Preguntas frecuentes

¿La lección «CustomDebugStringConvertible» es gratis?

Sí — el texto completo de «CustomDebugStringConvertible» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «CustomDebugStringConvertible»?

Proporcione información de depuración más detallada. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «CustomDebugStringConvertible»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Swift Academy