El manejo de errores es un aspecto crucial al escribir software robusto y confiable. Sin embargo, no hacerlo con cuidado puede generar un código desordenado que sea difícil de leer y mantener.

El capítulo 7 de Clean Code profundiza en técnicas para manejar errores que no saturan su código, enfatizando la claridad y la simplicidad.

En este artículo, exploraremos conceptos clave de este capítulo y cómo aplicarlos en JavaScript para mantener su código base limpio y fácil de mantener.

? 1. Utilice excepciones en lugar de códigos de error

Uno de los principios clave de Clean Code es preferir excepciones a códigos de error.

Las excepciones te permiten separar la lógica de manejo de errores de tu lógica principal, lo que hace que tu código sea más legible.

Ejemplo: evitar códigos de error

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return -1;  // Error code for user not found
    }
    return user;
}

const result = getUser(123);
if (result === -1) {
    console.error('User not found');
} else {
    console.log(result);
}

En este ejemplo, el manejo de errores está entrelazado con la lógica principal, lo que hace que sea más difícil de seguir.

Ejemplo: usar excepciones

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error('User not found');
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);
}

Al usar excepciones, separamos la lógica de manejo de errores de la lógica principal, lo que hace que el código sea más limpio y más fácil de entender.

? 2. Proporcione contexto con mensajes significativos

Al generar excepciones, es importante proporcionar mensajes de error significativos que brinden contexto sobre el error.

Esto ayuda a diagnosticar problemas rápidamente sin necesidad de profundizar en el código.

Ejemplo: proporcionar contexto en mensajes de error

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);  // Outputs: User with ID 123 not found
}

Un mensaje de error descriptivo proporciona el contexto necesario para comprender el problema de inmediato.

? 3. No devuelvas nulo

Devolver un valor nulo puede generar errores de referencia nulos que son difíciles de rastrear.

En lugar de devolver un valor nulo, considere lanzar una excepción o utilizar un patrón de caso especial que proporcione un comportamiento predeterminado.

Ejemplo: evitar devolver valor nulo

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return null;  // This can lead to null reference errors
    }
    return user;
}

const user = getUser(123);
if (user !== null) {
    console.log(user.name);
}

Devolver nulo requiere comprobaciones adicionales y puede saturar tu código.

Ejemplo: lanzar una excepción o utilizar un caso especial

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

// OR

class NullUser {
    get name() {
        return 'Guest';
    }
}

function getUser(id) {
    const user = database.findUserById(id);
    return user || new NullUser();
}

Lanzar una excepción o usar un objeto de caso especial (como NullUser) ayuda a evitar errores de referencia nula y mantiene el código limpio.

? 4. Utilice Try-Catch-Finally con moderación

Si bien los bloques try-catch-finally son esenciales para manejar excepciones, su uso excesivo puede saturar su código.

Úselos solo cuando sea necesario y evite los bloques profundamente anidados.

Ejemplo: evitar intentos de captura excesivos

try {
    const data = JSON.parse(input);
    try {
        const user = getUser(data.id);
        try {
            sendEmail(user.email);
        } catch (error) {
            console.error('Failed to send email:', error.message);
        }
    } catch (error) {
        console.error('User retrieval failed:', error.message);
    }
} catch (error) {
    console.error('Invalid JSON:', error.message);
}

Este código es difícil de seguir debido a múltiples bloques try-catch anidados.

Ejemplo: Refactorizar para reducir el desorden

function parseInput(input) {
    try {
        return JSON.parse(input);
    } catch (error) {
        throw new Error('Invalid JSON');
    }
}

function retrieveUser(data) {
    return getUser(data.id);
}

function notifyUser(user) {
    sendEmail(user.email);
}

try {
    const data = parseInput(input);
    const user = retrieveUser(data);
    notifyUser(user);
} catch (error) {
    console.error(error.message);
}

Al dividir la lógica en funciones separadas, reducimos el anidamiento y mejoramos la legibilidad.

? 5. No ignore las excepciones detectadas

Si detecta una excepción, asegúrese de manejarla correctamente.

Ignorar excepciones silenciosamente puede provocar un comportamiento inesperado y dificultar la depuración.

Ejemplo: No ignorar excepciones

try {
    const user = getUser(123);
} catch (error) {
    // Ignoring the exception
}

Ignorar excepciones puede enmascarar posibles problemas en tu código.

Ejemplo: gestionar o registrar la excepción

try {
    const user = getUser(123);
} catch (error) {
    console.error('An error occurred:', error.message);
}

Manejar o registrar la excepción garantiza que usted esté al tanto de cualquier problema y pueda solucionarlo en consecuencia.

⚡ Conclusión

El manejo eficaz de errores es esencial para escribir código JavaScript limpio y fácil de mantener.

Al seguir los principios de Clean Code, como usar excepciones en lugar de códigos de error, proporcionar contexto en los mensajes de error, evitar devoluciones nulas, usar try-catch con moderación y no ignorar las excepciones detectadas, puedes asegurarte de que tu lógica de manejo de errores es a la vez robusto y discreto.

¡Feliz codificación!