关于Node.js的承诺然后回来？

Question

我对承诺感到困惑！

我使用承诺，然后不返回，如下所示：

new Promise((resolve, reject) => {
    resolve("1");
}).then((v1) => {
    console.log("v1");
    new Promise((resolve, reject) => {
        //Time-consuming operation, for example: get data from database;
        setTimeout(() => {
            resolve(2)
        }, 3000);
    }).then((v11) => {
        console.log("v11");
    })
}).then((v2) => {
    console.log("v2")
});

我得到了这个结果，v1 v2 v11。然后，我使用另一种写作方式，如下所示：

 new Promise((resolve, reject) => {
    resolve("1");
}).then((v1) => {
    console.log("v1");
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(2)
        }, 3000)
    }).then((v11) => {
        console.log("v11");
    })
}).then((v2) => {
    console.log("v2")
});

我得到了另一个结果，v1 v11 v2。

也许还有另外一种情况：

new Promise((resolve, reject) => {
resolve("1");
}).then((v1) => {
console.log("v1");
return new Promise((resolve, reject) => {
    setTimeout(() => {resolve(2)}, 3000)
}).then((v11) => {
    console.log("v11");
    return new Promise((resolve, reject) => {
        setTimeout(() => {resolve(2)}, 4000)
    }).then(() => {
        console.log("v12")
    })
})
}).then((v2) => {
console.log("v2")
});

我得到了这个结果v1 v11 v12 v2

我不明白第二个返回，我想知道为什么会得到这个结果？

Answer 1

如果实际打印已解析的承诺的值，而不仅仅是变量的名称，将更容易理解控制流：

版本1

new Promise((resolve, reject) => {
    resolve("1");
}).then((v1) => {
    console.log("v1:", v1);
    new Promise((resolve, reject) => {
        //Time-consuming operation, for example: get data from database;
        setTimeout(() => {
            resolve(2)
        }, 3000);
    }).then((v11) => {
        console.log("v11:", v11);
    })
}).then((v2) => {
    console.log("v2:", v2)
});

第2版

new Promise((resolve, reject) => {
    resolve("1");
}).then((v1) => {
    console.log("v1:", v1);
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(2)
        }, 3000)
    }).then((v11) => {
        console.log("v11:", v11);
    })
}).then((v2) => {
    console.log("v2:", v2)
});

第3版

new Promise((resolve, reject) => {
        resolve("1");
}).then((v1) => {
       console.log("v1:", v1);
       return new Promise((resolve, reject) => {
           setTimeout(() => {resolve(2)}, 3000)
       }).then((v11) => {
           console.log("v11:", v11);
           return new Promise((resolve, reject) => {
               setTimeout(() => {resolve(2)}, 4000)
           }).then((v12) => {
              console.log("v12:", v12)
           })
       })
 }).then((v2) => {
      console.log("v2:", v2)
 });

现在，您可以看到传递给回调的内容：

结果1

v1: 1
v2: undefined
v11: 2

结果2

v1: 1
v11: 2
v2: undefined

结果3

v1: 1
v11: 2
v12: 2
v2: undefined

解释

正如您可以看到，在.then()处理程序中，当您不返回一个承诺时，它的作用就好像您返回了一个带有值undefined的已解析的承诺--就像您返回了这样的承诺：

return Promise.resolve(undefined);

因此，可以立即调用下一个.then()处理程序。

另一方面，如果您返回一个尚未解决的承诺，那么下一个.then()处理程序将不会立即被调用，而只有在返回的诺言被解决之后。

这就解释了当你不回承诺的时候，执行的顺序是不同的--而发生的事情就好像一个已经解决的承诺被隐式地回报给你一样。

Answer 2

    function one() {
    return new Promise((resolve,reject) => {
        setTimeout(function () {
            console.log("one 1 ");
            resolve('one one');
        }, 2000);
    });
}

function two() {
    return new Promise((resolve,reject) => {
        setTimeout(function () {
            console.log("two 2 ");
            resolve('two two');
        }, 10000);
    });
}

function three(){
    setTimeout(function () {
        console.log("three 3 ");
    }, 5000);
}

one().then((msg) => {
        console.log('one : ', msg);
        return two();
    }).then((msg) => {
        console.log('two :', msg);
        return three();
    }).then((msg) => {
        console.log('three :', msg);
    })
    .catch((error) => {
        console.error('Something bad happened:', error.toString());
    });

控制台三显示未定义，因为三个不解析解析