Как обрабатывать ошибки асинхронного кода в Node.js?

Как реализовать простую очередь задач в Node Изучение

Асинхронная операция в JavaScript — это операция, которая не блокирует дальнейшие операции. Это означает, что если мы выполняем асинхронную операцию в определенной точке кода, то код после этого выполняется и не ждет завершения этой асинхронной операции. Пример асинхронной операции в Node.js — это когда мы запрашиваем некоторые данные с веб-сервера.

Если мы хотим обработать ошибку асинхронного кода в Node.js, мы можем сделать это двумя следующими способами.

  • Обработка ошибки с помощью обратного вызова
  • Обработка отклонения обещаний

Обработка ошибки с помощью обратного вызова

Функция обратного вызова должна выполнить некоторую операцию после завершения выполнения функции. Мы можем вызвать нашу функцию обратного вызова после завершения асинхронной операции. Если есть какая-то ошибка, мы можем вызвать функцию обратного вызова с этой ошибкой, в противном случае мы можем вызвать ее с ошибкой как null и результатом асинхронной операции в качестве аргументов.

Настройка проекта:

Шаг 1. Установите Node.js, если вы еще этого не сделали.

Шаг 2: Создайте папку для вашего проекта и cd (смените каталог) в нее. Создайте в этой папке новый файл с именем app.js.

Структура проекта: после выполнения этих шагов структура вашего проекта будет выглядеть следующим образом.

после выполнения этих шагов структура вашего проекта будет

В примере кода, упомянутом ниже, мы смоделировали асинхронную операцию с помощью метода setTimeout (). Мы выполняем операцию деления, которая возвращает результат деления через 1 секунду, и если делитель равен нулю, мы передаем экземпляр ошибки методу обратного вызова. Если ошибки нет, мы вызываем функцию обратного вызова с ошибкой как null и результатом деления в качестве аргументов. Ошибка и результат обрабатываются внутри нашей функции обратного вызова.

const divide = (a, b, callback) => {
  setTimeout(() => {
    if (b == 0) {
      callback(new Error('Division by zero error'));
    } else {
      callback(null, a / b);
    }
  }, 1000);
};
 
divide(10, 2, (err, res) => {
  if (err) {
    console.log(err.message);
  } else {
    console.log(`The result of division = ${res}`);
  }
});
 
divide(5, 0, (err, res) => {
  if (err) {
    console.log(err.message);
  } else {
    console.log(`The result of division = ${res}`);
  }
});

Шаг для запуска приложения: вы можете запустить файл app.js, используя следующую команду в командной строке.

node app.js

Выход:

Шаг для запуска приложения вы можете запустить файл app

Обработка отклонения обещания

Обещание в Node.js — это способ обработки асинхронных операций. Если мы возвращаем обещание из асинхронной функции, его можно позже использовать с помощью метода then () или async / await для получения окончательного значения. Когда мы используем метод then () для использования обещания и нам нужно обрабатывать отклонения обещания, тогда мы можем вызвать catch () для вызова метода then (). Promise.catch () — это метод, который возвращает обещание, и его задача — иметь дело с отклоненным обещанием.

Синтаксис:

// func is an async function
func().then(res => {   
    // code logic
}).catch(err => {
    // promise rejection handling logic
})

Теперь, если мы хотим обрабатывать отклонения Promise с помощью async / await, мы можем легко сделать это с помощью простого блока try / catch, как показано в синтаксисе, приведенном ниже.

const hello = async () => {
    try {
        // func is an async function
        const res = await func();
    } catch(err) {
        // error handling logic
    }
}

В приведенном ниже примере мы моделируем асинхронную функцию с помощью метода setTimeout () и выполняем операцию деления внутри асинхронной функции, которая возвращает обещание. Если делитель равен нулю, мы отклоняем обещание с ошибкой, в противном случае мы разрешаем его с результатом деления.

const divide = async (a, b) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (b == 0) {
        reject(new Error('Division by zero error'));
      } else {
        resolve(a / b);
      }
    }, 1000);
  });
};
 
// Consuming the promise using then() method
// and handling the rejected promise using
// catch() method
divide(5, 0)
  .then((res) => {
    console.log(`The result of division is ${res}`);
  })
  .catch((err) => {
    console.log(err.message);
  });
 
// This function is immedietly invoked after
// its execution. In this case we consume the
// promise returned by divide function() using
// async/await and handle the error using
// try/catch block
(async () => {
  try {
    const res = await divide(10, 5);
    console.log(`The result of division is ${res}`);
  } catch (err) {
    console.log(err);
  }
})();

 

Оцените статью
bestprogrammer.ru
Добавить комментарий