Javascript node.js promise:then（）的promise嵌套在then（）链中，不'；无法解决

编写演示脚本以理解承诺我在then（）中嵌套了多个承诺（使用promissions.all（）在解决所有承诺后继续）。嵌套承诺的then（）未得到解析：

var Promise = require("bluebird");

var array = [];

// push promises onto array
new Promise(function(resolve, reject) {
    setTimeout(function() { 
        for (var i = 5 - 1; i >= 0; i--) {
            array.push(returnapromise());
            console.log("pushed promise number", i, "onto array");
        }
        resolve();
    }, 300);
})

.then(function() {
    new Promise.all(array).then(function() {
        console.log("\nall done\n");
    });
});

// function that returns a promise
var returnapromise = function() {
    return new Promise(function(yolo) {

        new Promise(function() {
            setTimeout(function() { 
                console.log("async function within nested promise");
            }, 200);
        })

        .then(function() {
            setTimeout(function() { 
                console.log("async function within then one")
            }, 100);
        })

        .then(function() {
            setTimeout(function() { 
                console.log("async function within then two")
                yolo();
            }, 50);
        });

    }) // eof returned promise

}; // eof returnapromise()

但是，使用嵌套承诺中的回调可以实现期望的目标，如下所示：

var Promise = require("bluebird");

var array = [];

// push promises onto array
new Promise(function(resolve, reject) {
    setTimeout(function() { 
        for (var i = 5 - 1; i >= 0; i--) {
            array.push(returnapromise());
            console.log("pushed promise number", i, "onto array");
        }
        resolve();
    }, 300);
})

.then(function() {
    new Promise.all(array).then(function() {
        console.log("\nall done\n");
    });
});

// function that returns a promise
var returnapromise = function() {
    return new Promise(function(yolo) {

        new Promise(function() {
            setTimeout(function() { 
                console.log("async function within nested promise");
                one()
            }, 200);

            var one = function() {
                setTimeout(function() { 
                    console.log("cb one")
                    two();
                }, 100);
            };

            var two = function() {
                setTimeout(function() { 
                    console.log("cb two")
                    yolo();
                }, 50);
            };

        }) // eof nested promise

    }) // eof returned promise

}; // eof returnapromise()

function delay(t, val) {
    return new Promise(function(resolve) {
        setTimeout(function() {
            console.log(val);
            resolve(val);
        }, t);
    });
}

// function that returns a promise
var returnapromise = function() {
    return delay(200, "async function within nested promise").then(function() {
        return delay(100, "async function within then one");
    }).then(function() {
        return delay(50, "async function within then two");
    });
}; // eof returnapromise()

---

如何编写嵌套的承诺，然后才能真正解决这些问题？

在第一个版本的

returnapromise（）

中，您创建了两个承诺，一个嵌套在另一个内

内部承诺永远不会得到解决（没有代码可以解决它）。因此，它从不调用其

.then（）

处理程序，这意味着永远不会调用

yolo（）

函数，这意味着永远不会解析外部承诺。所以，它永远被卡住了

您可以通过解析第一个

setTimeout（）

中的内部承诺来解决这个问题，然后第二个

setTimeout（）

仍然与整个承诺链断开连接

您可以像这样重写

returnapromise（）

：

var Promise = require("bluebird");

var array = [];

// push promises onto array
new Promise(function(resolve, reject) {
    setTimeout(function() { 
        for (var i = 5 - 1; i >= 0; i--) {
            array.push(returnapromise());
            console.log("pushed promise number", i, "onto array");
        }
        resolve();
    }, 300);
})

.then(function() {
    new Promise.all(array).then(function() {
        console.log("\nall done\n");
    });
});

// function that returns a promise
var returnapromise = function() {
    return new Promise(function(yolo) {

        new Promise(function() {
            setTimeout(function() { 
                console.log("async function within nested promise");
                one()
            }, 200);

            var one = function() {
                setTimeout(function() { 
                    console.log("cb one")
                    two();
                }, 100);
            };

            var two = function() {
                setTimeout(function() { 
                    console.log("cb two")
                    yolo();
                }, 50);
            };

        }) // eof nested promise

    }) // eof returned promise

}; // eof returnapromise()

function delay(t, val) {
    return new Promise(function(resolve) {
        setTimeout(function() {
            console.log(val);
            resolve(val);
        }, t);
    });
}

// function that returns a promise
var returnapromise = function() {
    return delay(200, "async function within nested promise").then(function() {
        return delay(100, "async function within then one");
    }).then(function() {
        return delay(50, "async function within then two");
    });
}; // eof returnapromise()

---

正在工作的演示：

您实际上想在这里做什么？

处理程序中的异步函数。然后（）

处理程序本身不会从

返回承诺。然后（）

处理程序完全与承诺链断开连接，根本不会影响它。这里似乎有很多错误，但我不知道您真正想要实现什么，所以我不确定具体建议是什么。此外，您不执行新承诺。所有（数组），您只需执行

返回承诺。所有（数组）

。在

返回承诺（）的内部，有多个异步操作彼此断开连接，所有操作都并行运行，只有一个实际调用父承诺的resolve函数。这么多事情都错了，不知道实际目标就不知道从哪里开始。@jfriend00这就是我问的原因：）谢谢！当我向最内部的promise添加一个resolve函数，然后调用
yolo（）
来解析
returnapromise（）
返回的promise时，所有操作都会执行。不幸的是，
promise.all（）
在最内在的承诺的
then（）
s之前得到解决。如何解决此问题？@r0bs-如果将
resolve（）
放在第一个
setTimeout（）
内，则第二个
setTimeout（）
将执行，但第三个不会等待，因为第二个未以任何方式连接到您的承诺链。您不应该在一个
.then（）
处理程序中运行异步操作，该处理程序不会返回处理程序的承诺，因为这会使这些异步操作与它们周围发生的事情不协调。请注意，在我的代码示例中，每个包含另一个异步操作的
.then（）
处理程序都会从该异步操作返回一个承诺。@r0bs-我无法对您更改的代码进行注释，也看不见。我已经在我的回答和之前的评论中解释了如何在
.then（）
处理程序中协调异步操作。刚刚看到您的编辑！-谢谢！那应该对我有用@JaromandaX-是的，但我试图向OP展示如何创建自己的函数来返回承诺，然后在
.then（）
处理程序中使用它们。