Question

这不是＆＃34;它是如何工作的＆＃34;但是＆＃34;为什么会这样 - 我缺少什么＆＃34;问题：

我认为我已经掌握了javascript Promise构造的内容 - 非常聪明，简单而且很好。我喜欢它。但我确实想知道 - 我确信有人可以给我一个很好的答案 - 为什么Promise构造函数与.then（）方法不同？

some_promise.then(
    function(){
        if (some_condition) {
            return 'It works!';
        } else {
            throw Error('Noooooo!');
        }
).then(
    function(message){
        console.log('I was told: '+message);
    }
).catch(
    function(err) {
        console.log('Dang, it broke!');
    }
)

就像一个魅力，但为了获得最初的承诺，你必须这样做：

var some_promise = new Promise(function(resolve, reject){
    if (some_condition) {
        resolve('It works!');
    } else {
        reject(Error('Noooooo!'));
    }
});

我很难在开头就把承诺包裹在承诺中。这个概念很简单，但是这些例子（如上所述）让我非常困惑，我发现正是这种差异让我 - 这似乎与我不一致。是否有任何理由说明该标准不再符合以下原则：

//Modification to the standard
Promise.to = function(action){
    return new Promise(function(resolve, reject){
        resolve(true);
    }).then(action);
}

//Would result in a new Promise being constructed / used like this:
var some_promise = Promise.to(function(){
    if (some_condition) {
        return 'It works!';
    } else {
        throw Error('Noooooo!');
    }
}).then(
    function(message){
        console.log('I was told: '+message);
    }
).catch(
    function(err) {
        console.log('Dang, it broke!');
    }
)

我不这样做，因为我认为修改基础＆＃34;类＆＃34;是一个坏主意。在javascript中，但上面的示例似乎正在运行。

如果标准以这种方式运作会丢失什么？我猜想有什么，但我没有得到什么？在掌握这个概念时，它似乎更容易掌握，而且不那么冗长。

Answer 1

resolve和reject回调的全部目的是即使在构造函数完成后也可以随时调用它们。这对于异步操作很有用，它们可以在构造时启动但在构造函数完成之前没有完成。由于您的示例仅处理同步情况，因此丢失了此优势。（......实际上，这不仅仅是一种优势......这是Promises存在的全部原因）。

您还可以从延续中返回promise，以便后续的continuation（或.then子句）仅在先前返回的Promise完成时运行。一切都很好，但是在没有原始界面的情况下，首先要解决如何制作异步承诺的问题。

Answer 2

promise构造函数确实允许异步承诺完成。

但是，如果您不这样做，那么您所描述的内容存在于许多promise库中。例如，在蓝鸟中它是Promise.try：

var some_promise = Promise.try(function(){
    if (some_condition) {
        return 'It works!';
    } else {
        throw Error('Noooooo!');
    }
}).then(
    function(message){
        console.log('I was told: '+message);
    }
).catch(
    function(err) {
        console.log('Dang, it broke!');
    }
)

此外，如果您想使用then，您可以使用Promise.resolve开始使用已经解决的承诺：

Promise.resolve(undefined).then(
    function(){
        if (some_condition) {
            return 'It works!';
        } else {
            throw Error('Noooooo!');
        }
).then(
    function(message){
        console.log('I was told: '+message);
    }
).catch(
    function(err) {
        console.log('Dang, it broke!');
    }
)

但是，重申一下，如果您实际上并不需要promise构造函数的异步性质，那么这只是相关的 - 就像您在上面给出的示例中一样。使Promise构造函数与它有什么不同是不合理的，因为它有明确的目的和需要。

为什么Promise构造函数如此冗长？

2 个答案: