相关疑难解决方法(0)

我想使用promises,但我有一个回调API,格式如下:

1. DOM加载或其他一次性事件:

window.onload; // set to callback
...
window.onload = function() {

};

2.平原回调:

function request(onChangeHandler) {
    ...
}
request(function() {
    // change happened
    ...
});

3.节点样式回调("nodeback"):

function getStuff(dat, callback) {
    ...
}
getStuff("dataParam", function(err, data) {
    ...
})

4.具有节点样式回调的整个库:

API;
API.one(function(err, data) {
    API.two(function(err, data2) {
        API.three(function(err, data3) {
            ...
        });
    });
});

如何在promises中使用API​​,我该如何"宣传"它？

我对被抛出的不同术语感到困惑.根据我的理解,承诺可以是:

fulfilled
rejected
pending 
settled
resolved
defer

解决意味着解决了吗？还是意味着它实现了？什么是推迟的？

我在工作中继承了一个包含以下模式的十几个示例的代码库:

var promise = null;
try {
    promise = backendService.getResults(input);
}
catch (exception) {
    console.err(exception);
}
if (promise !== null) {
    promise.then(function (response) {
        // do stuff
    })
    .catch(function (error) {
        console.err(error);
    });
}

backendServiceAngular服务在哪里通过调用REST服务$http.

所以这是我的问题:try/catch真的有必要吗？是否会出现任何抛出特定错误/异常的情况,承诺.catch无法捕获？

这已经有点对球队辩论的整个上午的主题,我们已经拿出了唯一的解决办法是,我们不认为这是必要的,但(一)改变它打破写沿着它的测试(这也需要改变),(b)嗯......这是防御性编码,对吧？这不是一件坏事.

然而,当有更重要的事情要做的时候,实际上有必要将它重构为遗忘的优点并不是我所要求的.我只是想知道这是一个合理的模式,当承诺被传递这样时(特别是在AngularJS中,如果这有所不同),或者只是偏执狂.

我正在试图找出如何正确使用蓝鸟库的promises.我在我的代码中遇到了一些嵌套的promise,我注意到在bluebird文档中它的内容如下:

如果您正在使用完整的bluebird API产品,那么您几乎不需要首先采用嵌套承诺.

关于承诺被滥用的许多其他博客文章和嵌套是一种常规的反模式.

loadCar(someUri) // jqXHR
    .then(function (car) {
        if (carHasFourDoors(car)) {
            loadMake(car.make)
                .then(function (make) {
                    loadModel(make.model)
                        .then(function (model) {
                            loadCarDetails(model)
                        });
                });
        }
        else if (carHasTwoDoors(car)) {
            loadModel(make.model)
                .then(function (model) {
                    loadCarDetails(model)
                });
        }
    });

我的所有函数都返回对象.看看蓝鸟文档,似乎有多种帮助方法:all(),join(),props().

所以,我的问题是:如果存在依赖关系,我怎么能避免嵌套？也许这是我对承诺的异步性质的误解.这样的事可以吗？

Promise.all(loadCar(someUri), loadMake(car.make), loadModel(make.model))
    .then(function(car, make, model) {
        // do logic
    });

我正在使用AWS JS SDK提供的承诺.当我创建包装AWS SDK的异步函数时,我正在做的事情的主旨如下所示:

module.exports.myCustomFunction = input => {

    if (badInput) {
        throw new Error('failed') // <-- This is they key line
    }

    return sns.createTopic(someParams).promise()
}

// The caller looks like this:
myModule.myCustomFunction(someInput).then(result => {
    // carry on
})
.catch(err => {
    // do something with the error
})

有人说我不应该在这些基于承诺的函数中抛出错误.他们建议返回Promise.reject('failed').说实话,我不是那么精通承诺,所以他们的解释有点过了我的脑袋.

我所指的规范是http://promises-aplus.github.io/promises-spec/.

使用时then(),您可以返回一个承诺,并在您希望时拒绝承诺,或者您可以抛出异常拒绝承诺.

为什么api不是以这种方式设计的,对于then函数来说,它是像原始的promise构造函数一样传递一个解析和拒绝函数？

许多语言中的异常都很繁重(我也假设在javascript中),所以看起来很奇怪他们将它们用作流控制的选择.创建一个全新的promise对象并返回它,只是为了拒绝它,增加了代码膨胀IMO.如果抛出异常(例如语法错误,或者在未定义的对象上调用函数等),调试也会变得更难.