Чому я не можу просто закинути Errorвсередину зворотного виклику виклику і дозволити процесу обробляти помилку так, як ніби вона була в будь-якій іншій області застосування?

Якщо я нічого не роблю, я console.log(err)нічого не роздруковую і нічого не знаю про те, що сталося. Процес просто закінчується ...

Приклад:

function do1() {
    return new Promise(function(resolve, reject) {
        throw new Error('do1');
        setTimeout(resolve, 1000)
    });
}

function do2() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            reject(new Error('do2'));
        }, 1000)
    });
}

do1().then(do2).catch(function(err) {
    //console.log(err.stack); // This is the only way to see the stack
    throw err; // This does nothing
});

Якщо зворотні виклики виконуються в основному потоці, чому їх Errorпроковтує чорна діра?

Як пояснили інші, "чорна діра" полягає в тому, що кидання всередину .catchланцюга продовжує ланцюг із відхиленою обіцянкою, і у вас більше немає уловів, що призводить до неперерваного ланцюга, який проковтує помилки (погано!)

Додайте ще один улов, щоб побачити, що відбувається:

do1().then(do2).catch(function(err) {
    //console.log(err.stack); // This is the only way to see the stack
    throw err; // Where does this go?
}).catch(function(err) {
    console.log(err.stack); // It goes here!
});

Захоплення посередині ланцюга корисно, коли ви хочете, щоб ланцюг продовжувався, незважаючи на невдалий крок, але повторне кидання корисно продовжувати провалюватися після виконання таких речей, як реєстрація інформації чи кроки очищення, можливо, навіть змінюючи помилку кидається.

Трюк

Щоб помилка відображалася як помилка у веб-консолі, як ви спочатку мали намір, я використовую цей трюк:

.catch(function(err) { setTimeout(function() { throw err; }); });

Навіть номери рядків виживають, тому посилання у веб-консолі переносить мене прямо на файл та рядок, де сталася (оригінальна) помилка.

Чому це працює

Будь-який виняток у функції, яка називається обробником виконання або відхилення обіцянки, автоматично перетворюється на відхилення обіцянки, яку ви повинні повернути. Про це піклується код обіцянки, який викликає вашу функцію.

З іншого боку, функція, яку викликає setTimeout, завжди працює з стабільного стану JavaScript, тобто працює в новому циклі в циклі подій JavaScript. Винятки там нічим не застають, і внесіть його до веб-консолі. Оскільки errзберігається вся інформація про помилку, включаючи оригінальний стек, номер файлу та рядок, вона все ще надходить правильно.

Тут важливі речі для розуміння

1. І функції, thenі catchфункції повертають нові об'єкти обіцянки.

2. Або кидання, або явне відхилення, перенесе поточну обіцянку до відхиленого стану.

3. Оскільки thenі catchповертають нові об’єкти обіцянки, їх можна прикувати.

4. Якщо ви кинете або відхилите всередину обробника обіцянки ( thenабо catch), він буде оброблятися в наступному обробника відхилення вниз по ланцюговому шляху.

5. Як згадував jfriend00, обробники thenта catchобробники не виконуються синхронно. Коли обробник кине, це закінчиться негайно. Отже, стек буде розмотаний, а виняток буде втрачено. Ось чому кидання винятку відкидає поточну обіцянку.

У вашому випадку ви відкидаєте всередину do1, кидаючи Errorпредмет. Тепер поточна обіцянка буде у відхиленому стані, а контроль буде передано наступному обробнику, що є thenв нашому випадку.

Оскільки thenобробник не має обробника відхилення, він do2взагалі не буде виконаний. Ви можете підтвердити це, використовуючи console.logвсередині нього. Оскільки поточна обіцянка не має обробника відхилення, вона також буде відхилена зі значенням відхилення від попередньої обіцянки, і управління буде передано наступному оброблювачу, який є catch.

Як catchі обробник відхилень, коли ви робите console.log(err.stack);всередині нього, ви зможете побачити трасування стека помилок. Тепер ви кидаєте Errorз нього предмет, щоб обіцянка, повернута компанією catch, також буде у відхиленому стані.

Оскільки ви не приєднали жодного обробника відхилення до catch, ви не можете спостерігати за відхиленням.

Ви можете розколоти ланцюжок і зрозуміти це краще, як це

var promise = do1().then(do2);

var promise1 = promise.catch(function (err) {
    console.log("Promise", promise);
    throw err;
});

promise1.catch(function (err) {
    console.log("Promise1", promise1);
});

Вихід, який ви отримаєте, буде чимось на кшталт

Promise Promise { <rejected> [Error: do1] }
Promise1 Promise { <rejected> [Error: do1] }

Всередині catchобробника 1 ви отримуєте значення promiseоб'єкта як відхиленого.

Таким же чином, обіцянку, повернуту catchобробником 1, також відхиляють з тією ж помилкою, з якою promiseбуло відхилено, і ми спостерігаємо її у другому catchоброблювачі.

Я спробував setTimeout()метод, детально описаний вище ...

.catch(function(err) { setTimeout(function() { throw err; }); });

Прикро, я вважав, що це абсолютно непереборно. Оскільки це викидання асинхронної помилки, ви не можете зафіксувати її всередині try/catchоператора, тому що catchволя перестала слухати, коли помилка часу викидається.

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

return new Promise((resolve, reject) => {
    reject("err");
}).catch(err => {
    this.emit("uncaughtException", err);

    /* Throw so the promise is still rejected for testing */
    throw err;
});

Відповідно до специфікації (див. 3.III.d) :

г. Якщо дзвінок, то викидає виняток e,
  a. Якщо було викликано резольпроміз або відхилитиPromise, ігноруйте його.
  б. В іншому випадку відкиньте обіцянку із причиною e.

Це означає, що якщо ви кинете виняток у thenфункції, він буде спійманий, і ваша обіцянка буде відхилена. catchне має сенсу тут, це просто ярлик.then(null, function() {})

Напевно, ви хочете внести необроблені відхилення у свій код. Більшість обіцянок бібліотеки викликають unhandledRejectionце. Тут доречна суть з обговоренням.

Я знаю, що це трохи пізно, але я натрапив на цю тему, і жодне з рішень було для мене непростим у виконанні, тому я придумав своє:

Я додав трохи допоміжної функції, яка повертає обіцянку, як-от так:

function throw_promise_error (error) {
 return new Promise(function (resolve, reject){
  reject(error)
 })
}

Тоді, якщо я маю певне місце в будь-якому ланцюжку моїх обіцянок, де я хочу видалити помилку (і відхилити обіцянку), я просто повертаюся з вищевказаної функції зі своєю побудованою помилкою, наприклад:

}).then(function (input) {
 if (input === null) {
  let err = {code: 400, reason: 'input provided is null'}
  return throw_promise_error(err)
 } else {
  return noterrorpromise...
 }
}).then(...).catch(function (error) {
 res.status(error.code).send(error.reason);
})

Таким чином я контролюю викидання зайвих помилок всередині ланцюга обіцянок. Якщо ви також хочете впоратися з «нормальними» помилками обіцянки, ви розширите свій улов, щоб окремо обробляти «самозакинуті» помилки.

Сподіваюся, це допомагає, це моя перша відповідь stackoverflow!

Так, обіцяє помилок проковтування, і ви можете їх лише наздогнати .catch, як детальніше пояснено в інших відповідях. Якщо ви перебуваєте в Node.js і хочете відтворити нормальну throwповедінку, друкуючи стек стека для консолі та виходу з процесу, ви можете це зробити

...
  throw new Error('My error message');
})
.catch(function (err) {
  console.error(err.stack);
  process.exit(0);
});