Crear tipos fáciles de depurar
Combine descripciones y reflexión de forma eficaz.
Crear tipos fáciles de depurar es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 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.
Combinar las herramientas
Los mejores tipos son fáciles de inspeccionar. Combine CustomStringConvertible, CustomDebugStringConvertible y Mirror para crear valores que se impriman claramente y revelen sus componentes internos cuando sea necesario.
Una descripción limpia
Comience con una salida destinada al usuario:
struct Vector: CustomStringConvertible {
let x: Double
let y: Double
var description: String { "(\(x), \(y))" }
}
print(Vector(x: 1, y: 2)) // (1.0, 2.0)Añadir el diagnóstico debugDescription
Añada detalles para la depuración:
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)Generar automáticamente description con Mirror
Utilice la reflexión para crear una descripción sin enumerar manualmente cada campo:
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)Una utilidad de reflexión reutilizable
Extraiga la lógica de Mirror en una función independiente para que muchos tipos puedan compartir el mismo formateador de depuración.
Utilidad describe compartida
Una sola utilidad, reutilizada en todas partes:
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)Implementación predeterminada del protocolo
Proporcione depuración mediante reflexión a toda una familia de tipos con una extensión 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]Imprimir valores anidados con formato
La reflexión se aplica de forma natural de manera recursiva cuando los hijos también se pueden imprimir:
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))Usar Swift dump
El dump integrado utiliza Mirror para imprimir un árbol profundo con sangría — resulta práctico para una inspección rápida:
struct Node { let id = 1; let kids = [2, 3] }
dump(Node())
// - id: 1
// - kids: 2 elements ...Integrarlo todo
Un tipo refinado: una descripción limpia, información de depuración detallada y un mecanismo alternativo basado en reflexión — fácil de registrar y 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)Contar campos mediante reflexión
La reflexión también resulta útil para comprobaciones estructurales rápidas, como contar propiedades:
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 fieldsComprobación rápida
¿Cómo puede crear una description sin enumerar manualmente cada propiedad?
Resumen
Ha aprendido a crear tipos fáciles de depurar:
- Combine
description(limpia) ydebugDescription(detallada) - Utilice
Mirrorpara generar automáticamente descripciones a partir de los hijos - Extraiga la reflexión en una utilidad o en una implementación predeterminada de protocolo
dumpimprime un árbol reflejado profundo para una inspección rápida
¡Curso completado!
Preguntas frecuentes
¿La lección «Crear tipos fáciles de depurar» es gratis?
Sí — el texto completo de «Crear tipos fáciles de depurar» 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 «Crear tipos fáciles de depurar»?
Combine descripciones y reflexión de forma eficaz. 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 4 de 4.
¿Cuánto tiempo toma la lección «Crear tipos fáciles de depurar»?
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
- CustomStringConvertible
- CustomDebugStringConvertible
- Reflexión con Mirror
- Crear tipos fáciles de depurar