Errores personalizados en Swift: creación y manejo eficaz

¿Cómo se crean errores personalizados en Swift?

Crear errores personalizados en Swift es esencial para mejorar la gestión de errores en tus aplicaciones. Esto te permite proporcionar mensajes de error más descriptivos que benefician tanto a desarrolladores como a usuarios finales. Empecemos definiendo un error personalizado en Swift. Usaremos la palabra clave enum para crear estos errores, y haremos que implementen los protocolos Error y LocalizedError.

Definición de un enum de error personalizado

Para crear un grupo de errores personalizados, comienza con la definición de un enum que implemente los protocolos adecuados. Esto te permitirá especificar diferentes casos de error que quieras manejar en tu aplicación.

public enum ManagerError: Error, LocalizedError {
    case studentNotAddError
    case subjectNotAssignedError
    case reportNotFoundError
    case maxStudentsReachedError(max: Int)

    public var errorDescription: String? {
        switch self {
        case .studentNotAddError:
            return "El estudiante no se pudo agregar."
        case .subjectNotAssignedError:
            return "No se pudo asignar la materia."
        case .reportNotFoundError:
            return "El reporte no se pudo encontrar, puesto que la lista de estudiantes está vacía."
        case .maxStudentsReachedError(let max):
            return "La cantidad máxima de estudiantes \(max) ha sido alcanzada."
        }
    }
}

Implementación de error description

El protocolo LocalizedError permite definir una propiedad opcional errorDescription. Esta propiedad proporciona descripciones más detalladas de los errores, las cuales pueden ser utilizadas en la interfaz de usuario o en el feedback del sistema. Utilizamos un switch para retornar descripciones basadas en cada caso del enum.

¿Cómo lanzar errores en los métodos de Swift?

Una vez definidos los errores, es crucial saber cuándo y cómo lanzarlos en tus métodos. En Swift, utilizamos la palabra clave throws para indicar que un método puede lanzar un error.

Especificación de métodos que lanzan errores

Antes de lanzar errores, define qué métodos de tu protocolo pueden provocar errores. Aquí usamos el modificador throws en la declaración del método. Observa un ejemplo en el que un método para insertar estudiantes lanza un error si algo sale mal.

func insertStudent(_ student: Student) throws {
    if student == nil {
        throw ManagerError.studentNotAddError
    }
    // Verifica la cantidad máxima de estudiantes antes de agregar uno nuevo
    if students.count >= maxStudents {
        throw ManagerError.maxStudentsReachedError(max: maxStudents)
    }
    students.append(student)
}

Ejemplo de uso en la gestión de estudiantes

En nuestro ejemplo del gestor de estudiantes (StudentsManager), lanzamos errores específicos dependiendo de las operaciones que se intenten realizar.

func assignSubjectToStudent(_ subject: Subject, student: Student) throws {
    guard student.subjects.contains(subject) else {
        throw ManagerError.subjectNotAssignedError
    }
    student.subjects.append(subject)
}

func generateReport() throws -> String {
    guard !students.isEmpty else {
        throw ManagerError.reportNotFoundError
    }
    // Generar e imprimir reportes
}

¿Cómo mejorar la gestión de errores?

Manipular y capturar errores lanzados mejorará la estabilidad y experiencia del usuario en tu aplicación. La correcta implementación de estas técnicas te permitirá capturar errores específicos de manera eficiente.

1. Usa do-catch para manejar errores: Captura y maneja los errores en el bloque catch, ofreciendo un flujo controlado de ejecución.
2. Descripciones claras: Facilita una descripción clara y concisa de cada error, como hemos hecho con errorDescription.
3. Monitorea el rendimiento: Realiza pruebas y perfila tu aplicación para identificar áreas que podrían causar errores con más frecuencia.