Обработка ошибок — важнейший аспект написания надежного и надежного программного обеспечения. Однако несоблюдение осторожности может привести к загромождению кода, который будет трудно читать и поддерживать.

Глава 7 книги «Чистый код» посвящена методам обработки ошибок, которые не загромождают ваш код, подчеркивая ясность и простоту.

В этой статье мы рассмотрим ключевые понятия из этой главы и способы их применения в JavaScript, чтобы поддерживать чистоту и удобство поддержки вашей кодовой базы.

? 1. Используйте исключения, а не коды ошибок

Один из ключевых принципов чистого кода — отдавать предпочтение исключениям над кодами ошибок.

Исключения позволяют отделить логику обработки ошибок от основной логики, что делает ваш код более читабельным.

Пример: избегайте кодов ошибок

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

В этом примере обработка ошибок переплетается с основной логикой, что затрудняет отслеживание.

Пример: используйте исключения

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

Используя исключения, мы отделяем логику обработки ошибок от основной логики, делая код чище и понятнее.

? 2. Обеспечьте контекст значимыми сообщениями

При создании исключений важно предоставлять осмысленные сообщения об ошибках, которые дают контекст ошибки.

Это помогает быстро диагностировать проблемы без необходимости копаться в коде.

Пример: предоставление контекста в сообщениях об ошибках

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
}

Описательное сообщение об ошибке предоставляет контекст, необходимый для немедленного понимания проблемы.

? 3. Не возвращайте ноль

Возврат значения null может привести к ошибкам нулевой ссылки, которые трудно отследить.

Вместо возврата значения null рассмотрите возможность создания исключения или использования специального шаблона случая, обеспечивающего поведение по умолчанию.

Пример: избегайте возврата нуля

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

Возврат значения null требует дополнительных проверок и может загромождать ваш код.

Пример: создание исключения или использование особого случая

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();
}

Создание исключения или использование объекта особого случая (например, NullUser) помогает избежать ошибок нулевых ссылок и сохраняет ваш код чистым.

? 4. Используйте Try-Catch-Finally экономно

Хотя блоки try-catch-finally необходимы для обработки исключений, чрезмерное их использование может засорить ваш код.

Используйте их только при необходимости и избегайте глубоко вложенных блоков.

Пример: избегайте чрезмерного количества попыток Try-Catch

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

Этот код сложно понять из-за множества вложенных блоков try-catch.

Пример: рефакторинг для уменьшения беспорядка

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

Разбивая логику на отдельные функции, мы уменьшаем вложенность и улучшаем читаемость.

? 5. Не игнорируйте перехваченные исключения

Если вы поймали исключение, обязательно обработайте его правильно.

Игнорирование исключений без уведомления может привести к неожиданному поведению и затруднить отладку.

Пример: не игнорировать исключения

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

Игнорирование исключений может скрыть потенциальные проблемы в вашем коде.

Пример: обработка или регистрация исключения

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

Обработка или регистрация исключения гарантирует, что вы будете в курсе любых проблем и сможете их устранить соответствующим образом.

⚡Вывод

Эффективная обработка ошибок необходима для написания чистого и поддерживаемого кода JavaScript.

Следуя принципам чистого кода, например, используя исключения вместо кодов ошибок, предоставляя контекст в сообщениях об ошибках, избегая нулевых возвратов, экономно используя try-catch и не игнорируя перехваченные исключения, вы можете гарантировать, что ваша логика обработки ошибок одновременно надежный и ненавязчивый.

Удачного программирования!