ember.js - 如何在 Ember.RSVP.hash 之后注册自定义回调

Question

我有一条使用 RSVP 引入 2 个不同 promise 的路线，就像这样

model: function() {
  return Ember.RSVP.hash(function() {
    stuff: App.Thing.find(),
    other: this.store.find('appointments', {day: day})    
  });
}

挑战在于我有一个自定义函数，我在上面显示的第二个 promise 的“then”中绑定(bind)/调用。当回调与另一个使用 RSVP 的 promise 一起发生时，我如何调用它？

这是今天的自定义回调(还没有在 RSVP.hash 中)

    function bindContextAndGenerateAvailable(employee, other, appointments) {
        return function(filteredAppointments) {
            //will take the filtered collection and do something w/ it
            //to populate the bound appointments array passed in
        }
    }

    var appointments = Ember.A([]);
    this.store.find('appointment', {day: day}).then(function(response) {
        Ember.RSVP.all(response.getEach('employee')).then(function(empls){
          var filtered = response.filterBy('employee.id', employee);
          Ember.RSVP.resolve(filtered).then(bindContextAndGenerateAvailable(employee, other, appointments));
        });
    });
    return appointments;

Answer 1

好的，我不确定我是否完全理解，但我会尝试一下，如果我错了，我会快速编辑，因为你说我的猜测是错误的。
当你链接它们时，Promise 非常棒(.then)。让我看看我是否可以做一些简单的例子，看看这是否适用于你正在做的事情。
链接返回最后一个结果。

var foo = new Ember.RSVP.Promise(function(resolve){
  resolve(1);
}).then(function(result){
  return result + 2;
});

foo.then(function(result){
  alert(result); // this will alert 3, not 1
});

http://emberjs.jsbin.com/levoyama/1/edit
链接返回最深的结果。如果你返回一个 promise 作为 then 的结果，它会等待它解决，并返回它的结果。快速说明: cast 是一种将任何内容转换为 promise 的快速方法。 ，使其成为可能。

var bar = Ember.RSVP.Promise.cast(1).then(function(result){
  return new Ember.RSVP.Promise(function(resolve){
    resolve(2 + result);
  });
});

bar.then(function(result){
  alert(result); // this will alert 3, not 1
});

http://emberjs.jsbin.com/voxevucu/1/edit
哈希采用最新和最伟大的
哈希将获取发送给它的任何 promise 的最深/最后一个结果，并在其结果哈希中使用该结果。在下面的例子中，promise 1 和 promise 2 都会产生 5，尽管它们的初始值是 1/2。

var promise1 = Em.RSVP.Promise.cast(1)
                 .then(function(result){ return result + 1; })
                 .then(function(result){ return result + 1; })
                 .then(function(result){ return result + 1; })
                 .then(function(result){ return result + 1; });

var promise2 = Em.RSVP.Promise.cast(2)
                 .then(function(result){
                  return new Ember.RSVP.Promise(function(resolve){
                    resolve(result + 3);
                  });
                 });
           

var hash = Em.RSVP.hash({
   p1: promise1,
   p2: promise2
});

hash.then(function(result){
  alert(result.p1 + ' + ' + result.p2 + ' = ' + (result.p1 + result.p2) + ', alert the presses!!!!');
});

http://emberjs.jsbin.com/vevaruta/1/edit
共享 promise /多个观察者
我重读了这个问题并有另一个猜测。如果您需要将一个 Promise 用于两个不同的目的，Promise 可以有无限数量的观察者，当 Promise 被解决时这些观察者都会触发。

var promise1 = Em.RSVP.Promise.cast('of warcraft');

promise1.then(function(result){
  alert('hello world ' + result);
});

promise1.then(function(result){
  alert('stop playing world ' + result);
});

Em.RSVP.hash({
  p: promise1
}).then(function(hash){
  alert('hash result p is: ' + hash.p);
});

http://emberjs.jsbin.com/sovolibo/1/edit
在您希望在解决两个 promise 后修改结果(模型)的情况下，您将执行类似的操作。

model: function(){
  var promise1 = Ember.RSVP.Promise.cast(1);
  var promise2 = Ember.RSVP.Promise.cast(2);

  return Ember.RSVP.hash({
    p1 = promise1,
    p2 = promise2
  }).then(function(result){
      return result.p1 + result.p2;
  });
}

模型的结果最终是 3，而不是散列，因为我们对散列的结果进行了一些后期处理。
但是如果你想做一些异步的事情，因为它对模型来说并不重要，它会是这样的:

model: function(){
  var promise1 = Ember.RSVP.Promise.cast(1);
  var promise2 = Ember.RSVP.Promise.cast(2);

  var hash = Ember.RSVP.hash({
    p1 = promise1,
    p2 = promise2
  });
  
  var randomPromise = hash.then(function(result){
    return result.p1 + result.p2;
  });

  randomPromise.then(function(result){
    alert(result);
  });

  return hash;
}

在这种情况下，模型钩子(Hook)需要散列，但是当它完成后你想对结果做一些不同的事情，模型钩子(Hook)不需要在事后等待随机 promise 。