即使处理了被拒绝的承诺，仍收到“UnhandledPromiseRejectionWarning”

我构建了一个迭代的函数Generator包含同步代码和Promises:

module.exports = {


    isPromise (value) {
            return typeof value === 'object' && value !== null && 'then' in value;
        },

    runGen (generatorFunc, startValue) {

            let that = this,
                i = 0;

            function *iterator(resolve, reject) {

                let runGeneratorFunc = generatorFunc(startValue),
                    yieldedOut = {done: false},
                    yieldIn;

                while (!yieldedOut.done) {
                    console.log(i++, 'Ready for next iteration');
                    if (that.isPromise(yieldedOut.value)) {
                        console.log(i++, 'Pass promise to KeepIterating');
                        yieldIn = yield yieldedOut.value;
                        console.log(i++, 'Received value from promise');

                        if(yieldIn instanceof Error){
                            console.log(i++, 'Value was instance of Error');
                            try {
                                yieldedOut = runGeneratorFunc.throw(yieldIn)
                            }
                            catch(err){
                                console.log(i++, 'Throw Error');
                                throw(yieldIn);
                            }
                        } else {
                            yieldedOut = runGeneratorFunc.next(yieldIn);
                        }
                    } else {
                        try {
                            yieldIn = yieldedOut.value;
                            yieldedOut = runGeneratorFunc.next(yieldIn);
                        }
                        catch(err) {
                            runGeneratorFunc.throw(err);
                            reject(err);
                        }
                    }
                }
                resolve(yieldedOut.value);
            }

            return new Promise(function (resolve, reject) {
                var runIterator = iterator(resolve, reject);
                (function keepIterating(yieldIn) {
                    let yieldedOutPromise = runIterator.next(yieldIn);

                    if (!yieldedOutPromise.done) {

                        yieldedOutPromise.value.then(function (fulfilledValue) {
                            console.log('never gets here');
                            keepIterating(fulfilledValue);
                        });

                        yieldedOutPromise.value.catch(function (err) {
                            console.log(i++, 'Rejected promise catched');
                            if (err instanceof Error) {
                                try {
                                    console.log(i++, 'Rejected promise is instance of Error');
                                    let yieldedOut = runIterator.next(err);
                                    keepIterating(yieldedOut);
                                }
                                catch (err) {
                                    console.log(i++, 'Error propagated back out');
                                    yieldedOutPromise.value.catch(() => {})
                                    reject(err);
                                }
                            } else {
                                try {
                                    let yieldedOut = runIterator.next(new Error(err));
                                    keepIterating(yieldedOut);
                                }
                                catch (err) {
                                    reject(err);
                                }
                            }
                        })
                    }
                })();
            });
        }
    }

现在，当我使用以下代码导入并运行它时：

const md = require('./module');

function* dummy () {
    yield Promise.reject(new Error('error1'));
}

md.runGen(dummy)
.catch(err => {
    console.log(9, 'Finished!');
})

我将其记录到控制台：

0 'Ready for next iteration'
1 'Ready for next iteration'
2 'Promise yielded out'
3 'Rejected promise handled'
4 'Rejected promise instance of Error'
5 'Ready to handle promise value'
6 'Value was instance of Error'
7 'Throw Error'
8 'Error propagated back out'
9 'Finished!'
(node:9904) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): Error: error1
(node:9904) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

除了警告之外，这一切都符合预期UnhandledPromiseRejectionWarning。我很困惑为什么我会收到此警告作为被拒绝的Promise 被处理据我所知在代码中。

我在忽略什么？

我在忽略什么？

Your yieldedOutPromise.value.then调用正在创建一个新的承诺，并且如果yieldedOutPromise.value拒绝，那么它也会被拒绝。通过以下方式处理错误并不重要.catch on yieldedOutPromise.value，仍然有一个被拒绝的承诺，这就是将被报告的一个。

您基本上是在分割您的承诺链，这导致每一端都需要一个错误处理程序。但是，您根本不应该分割任何东西。而不是

promise.then(onSuccess);
promise.catch(onError);

你应该使用的反模式

promise.then(onSuccess, onError).…

哦，当你这样做的时候，避免Promise构造函数反模式。做就是了

module.exports = function runGen (generatorFunc, startValue) {
    return Promise.resolve(startValue).then(generatorFunc).then(generator => {
        return keepIterating({done: false, value: undefined});
        function keepIterating({done, value}) {
            if (done) return value;
            return Promise.resolve(value).then(fulfilledValue =>
                generator.next(fulfilledValue)
            , err =>
                generator.throw(err)
            ).then(keepIterating);
        }
    });
};