相关疑难解决方法(0)

我已经将我的代码重组为承诺,并构建了一个由多个回调组成的精彩长扁平承诺链.then().最后我想返回一些复合值,并且需要访问多个中间承诺结果.但是,序列中间的分辨率值不在最后一个回调的范围内,我该如何访问它们？

function getExample() {
    return promiseA(…).then(function(resultA) {
        // Some processing
        return promiseB(…);
    }).then(function(resultB) {
        // More processing
        return // How do I gain access to resultA here?
    });
}

我编写的代码看起来像:

function getStuffDone(param) {           | function getStuffDone(param) {
    var d = Q.defer(); /* or $q.defer */ |     return new Promise(function(resolve, reject) {
    // or = new $.Deferred() etc.        |     // using a promise constructor
    myPromiseFn(param+1)                 |         myPromiseFn(param+1)
    .then(function(val) { /* or .done */ |         .then(function(val) {
        d.resolve(val);                  |             resolve(val);
    }).catch(function(err) { /* .fail */ |         }).catch(function(err) {
        d.reject(err);                   |             reject(err);
    });                                  |         });
    return d.promise; /* or promise() */ |     });
}                                        | }

有人告诉我这个被称为" 延迟反模式 "或" Promise构造函数反模式 ",这个代码有什么不好,为什么这被称为 …

更新:

为了帮助这篇文章的未来观众,我创建了这个pluma答案的演示.

题:

我的目标似乎相当简单.

  step(1)
  .then(function() {
    return step(2);
  }, function() {
    stepError(1);
    return $q.reject();
  })
  .then(function() {

  }, function() {
    stepError(2);
  });

  function step(n) {
    var deferred = $q.defer();
    //fail on step 1
    (n === 1) ? deferred.reject() : deferred.resolve();
    return deferred.promise;
  }
  function stepError(n) {
    console.log(n); 
  }

这里的问题是,如果我在第1步失败,两个stepError(1)AND都会stepError(2)被解雇.如果我不return $q.reject那么stepError(2)就不会被解雇,但step(2)会,我明白了.除了我想做的事以外,我已经完成了所有的事情.

如何编写promises以便我可以在拒绝时调用函数,而无需调用错误链中的所有函数？或者还有另一种方法来实现这一目标吗？

这是一个现场演示,所以你有一些工作.

更新:

我有点解决了.在这里,我在链的末尾捕获错误并传递数据,reject(data)以便我知道错误函数中要处理的问题.这实际上不符合我的要求,因为我不想依赖于数据.它会很蹩脚,但在我的情况下,将错误回调传递给函数会更加清晰,而不是依赖于返回的数据来确定要做什么.

现场演示(点击).

step(1)
  .then(function() {
    return step(2);
  })
  .then(function() …

基于这里的问题:jQuery链接和级联然后是什么时候和接受的答案.

我想在某个时刻打破承诺链,但还没有找到正确的方法.有多个 职位 有关这一点,但我还是输了.

从原始问题中获取示例代码:

Menus.getCantinas().then(function(cantinas){ // `then` is how we chain promises
    Menus.cantinas = cantinas;
    // if we need to aggregate more than one promise, we `$.when`
    return $.when(Menus.getMeals(cantinas), Menus.getSides(cantinas));
}).then(function(meals, sides){ // in jQuery `then` can take multiple arguments
    Menus.sides = sides; // we can fill closure arguments here
    Menus.meals = meals;
    return Menus.getAdditives(meals, sides); // again we chain
}).then(function(additives){
    Menus.additives = additives;
    return Menus; // we can also return non promises and chain …

假设我们有一个返回承诺3项异步任务:A,B和C.我们希望将它们链接在一起(也就是说,为了清楚起见,获取返回的值A并B使用它调用),但是也希望正确处理每个错误,并在第一次失败时突破.目前,我看到了两种方法:

A
.then(passA)
.then(B)
.then(passB)
.then(C)
.then(passC)
.catch(failAll)

这里,passX函数处理每次调用成功X.但在failAll功能,我们不得不处理所有的错误A,B并且C,这可能是复杂的,不容易读,特别是如果我们有超过3个异步任务.所以另一种方式考虑到这一点:

A
.then(passA, failA)
.then(B)
.then(passB, failB)
.then(C)
.then(passC, failC)
.catch(failAll)

在这里,我们分离出的原始的逻辑failAll为failA,failB和failC,这看似简单易读,因为所有的错误都紧挨着它的源处理.但是,这不符合我的要求.

让我们看看是否A失败(拒绝),failA不得继续调用B,因此必须抛出异常或拒绝调用.但是,这两个被抓的failB和failC,也就是说,failB和failC需要知道,如果我们已经失败与否,大概是通过保持状态(即变量).

而且,似乎我们拥有的异步任务越多,要么我们的failAll函数在大小上增长(方式1),要么failX调用更多函数(方式2).这让我想到了我的问题:

有一个更好的方法吗？

考虑:由于异常 …

PromiseA().then(function(dataA){
    if (dataA.foo == "skip me")
        return ?? //break promise early - don't perform next then()
    else
        return PromiseB()
}).then(function(dataB){
    console.log(dataB)
}).catch(function (e) {
    //Optimal solution will not cause this method to be invoked
})

如何修改上面的代码以提前破解(跳过第二个然后())？