Что такое необработанное обещание?

Ответ 1

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

например, функция PTest() разрешит или отклонит обещание на основе значения глобальной переменной somevar

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
}).catch(function () {
     console.log("Promise Rejected");
});

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

var somevar = false;
var PTest = function () {
    return new Promise(function (resolve, reject) {
        if (somevar === true)
            resolve();
        else
            reject();
    });
}
var myfunc = PTest();
myfunc.then(function () {
     console.log("Promise Resolved");
});
// See the Difference here
myfunc.catch(function () {
     console.log("Promise Rejected");
});

Разница в том, что вы обрабатываете .catch(...) как цепочку, а как отдельный .catch(...). По какой-то причине движок JavaScript воспринимает это как обещание без необоснованного отклонения обещания.

Ответ 2

Это когда Promise завершается с помощью .reject() или в async исполняемом коде .catch() исключение, и никакой .catch() не обрабатывает отклонение.

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

Смотрите также

• https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch

Ответ 3

Promises можно "обрабатывать" после отклонения. То есть, можно вызвать отказ от отзыва, прежде чем предоставить обработчик catch. Такое поведение немного надоедает мне, потому что можно писать...

var promise = new Promise(function(resolve) {
kjjdjf(); // this function does not exist });

... и в этом случае обещание отвергается молча. Если кто-то забывает добавить обработчик catch, код будет продолжать бесшумно запускаться без ошибок. Это может привести к затяжным и труднодоступным ошибкам.

В случае Node.js есть разговоры об обработке этих необработанных отказов Promise и сообщения о проблемах. Это приводит меня к ES7 async/await. Рассмотрим этот пример:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  let temp = await tempPromise;
  // Assume `changeClothes` also returns a Promise
  if(temp > 20) {
    await changeClothes("warm");
  } else {
    await changeClothes("cold");
  }

  await teethPromise;
}

В приведенном выше примере предположим, что зубы были пропущены (ошибка: из зубной пасты!) до того, как была выполнена функция getRoomTemperature. В этом случае будет необработанное отклонение Обещания до тех пор, пока вы не пропустите зубы.

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

Мысли об этом?

Это связано с обсуждением, найденным в проекте Node.js:

По умолчанию необработанное поведение обнаружения отказа

если вы пишете код следующим образом:

function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  return Promise.resolve(tempPromise)
    .then(temp => {
      // Assume `changeClothes` also returns a Promise
      if (temp > 20) {
        return Promise.resolve(changeClothes("warm"));
      } else {
        return Promise.resolve(changeClothes("cold"));
      }
    })
    .then(teethPromise)
    .then(Promise.resolve()); // since the async function returns nothing, ensure it a resolved promise for `undefined`, unless it previously rejected
}

При вызове метода getReadyForBed он будет синхронно создавать окончательное (не возвращенное) обещание, которое будет иметь ту же ошибку "необработанного отклонения", что и любое другое обещание (может быть, конечно, ничего, в зависимости от движка). (Я нахожу очень странным, что ваша функция ничего не возвращает, что означает, что ваша функция async дает обещание для undefined.

Если я сделаю обещание прямо сейчас без улова и добавлю его позже, большинство реализаций "необработанной ошибки отклонения" фактически отменит предупреждение, когда я его обработаю позже. Другими словами, async/await не изменяет дискуссию "необработанное отклонение" любым способом, который я могу видеть.

чтобы избежать этой ошибки, напишите код следующим образом:

async function getReadyForBed() {
  let teethPromise = brushTeeth();
  let tempPromise = getRoomTemperature();

  // Change clothes based on room temperature
  var clothesPromise = tempPromise.then(function(temp) {
    // Assume `changeClothes` also returns a Promise
    if(temp > 20) {
      return changeClothes("warm");
    } else {
      return changeClothes("cold");
    }
  });
  /* Note that clothesPromise resolves to the result of `changeClothes`
     due to Promise "chaining" magic. */

  // Combine promises and await them both
  await Promise.all(teethPromise, clothesPromise);
}

Обратите внимание, что это должно предотвратить любое необработанное обещание.

Ответ 4

" Предупреждение об устаревании: отклонение необработанного обещания устарело"

TL;DR: Обещание имеет resolve и reject, выполнение reject без улова для его обработки не рекомендуется, так что вам придется, по крайней мере, иметь catch на верхнем уровне.

Ответ 5

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

for() {}

Затем я проверил эти данные, изменил эти недействительные, он исчез.

Ответ 6

Когда я создаю экземпляр обещания, я собираюсь сгенерировать асинхронную функцию. Если функция идет хорошо, я вызываю RESOLVE, тогда поток продолжается в обработчике RESOLVE, в THEN. Если функция завершается ошибкой, завершите функцию, вызвав REJECT, и поток продолжится в CATCH.

В NodeJs устарел обработчик отклонения. Ваша ошибка - просто предупреждение, и я прочитал ее в github node.js. Я нашел это.

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

Тип: Время выполнения

Необработанные обещания отклоняются. В будущем отклонения обещаний, которые не обрабатываются, завершат процесс Node.js с ненулевым кодом завершения.

Ответ 7

В моем случае было Promise без отклонения и разрешения, потому что моя функция Promise вызвала исключение. Эта ошибка вызывает сообщение UnhandledPromiseRejectionWarning.