Каков наиболее лаконичный способ использования отложенного канала jQuery?

Я собираюсь оставить свою реализацию Person в покое, так как я думаю, что она в основном выполняет свою задачу:

function Person(o) {
  this.id = o.id;
  this.name = o.name;
}

Person.prototype.dad = function(done, fail) {
  var promise = $.getJSON('/people/' + this.id + '/dad').pipe(Person, null);
  promise.then(done, fail);
  return new Person.Chain(promise);  
};

Person.prototype.boss = function(done, fail) {
  var promise = $.getJSON('/people/' + this.id + '/boss').pipe(Person, null);
  promise.then(done, fail);
  return new Person.Chain(promise);  
};

Для реализации Person.Chain у нас есть две проблемы: каждый раз, когда вы вызываете метод-получатель, он действительно должен возвращать новый Person.Chain, и этот новый Person.Chain должен быть "вложенным": он должен связывать результаты вызовов AJAX вместе. Это должно решить обе проблемы.

Этот подход требует нескольких строк клея, поэтому сначала давайте удостоверимся, что нам не нужно дублировать его снова и снова:

Person.Chain = function(promise) {
  this.promise = promise;
};

Person.Chain.prototype.assistant = function(done, fail) {
  return this.pipe('assistant', done, fail);
};

Person.Chain.prototype.dad = function(done, fail) {
  return this.pipe('dad', done, fail);
};

Person.Chain.prototype.boss = function(done, fail) {
  return this.pipe('boss', done, fail);
};

Нам просто нужно определить столько этих методов-оболочек, сколько есть методов-геттеров на Person. Теперь, чтобы реализовать pipe:

Person.Chain.prototype.pipe = function(f, done, fail) {
  var defer = new $.Deferred();
  defer.then(done, fail);

  this.promise.pipe(function(person) {
    person[f](function(person) {
      defer.resolve(person);
    }, function() {
      defer.reject();
    });
  }, function() {
    defer.reject();
  });

  return new Person.Chain(defer.promise());
}

Во-первых, мы явно создаем новый объект Deferred и прикрепляем к нему обработчики done и fail (если есть). Затем мы прикрепляем функцию, которая будет вызывать любое переданное f (папу, помощника, начальника и т. д.) на Person, которое будет возвращено предыдущей функцией. Наконец, когда разрешается эта функция, мы явно разрешаем созданный нами объект Deferred. Теперь мы можем объединить последовательные вызовы следующим образом:

jake = new Person({id: 3, name: 'Jake'});

jake.dad().boss().assistant(function(person) {
  alert("Jake's dad's boss's assistant is " + person.name);
});

Обратите внимание, что обработка сбоев довольно многословна, но нам это нужно, чтобы, если вы соедините кучу вызовов вместе, ранний сбой все равно передал бы свои reject() вызовов по линии вплоть до обратного вызова сбоя, заданного в конце.

Это также совершенно законно:

jake.dad(function(person) {
  alert('Dad is ' + person.name);
}, function() {
  alert('Dad call failed');
}).boss(function(person) {
  alert('Jake dad boss is ' + person.name);
}, function() {
  alert('One of the calls failed');
});

Если первый вызов завершится ошибкой, оба обратных вызова будут вызваны по порядку. Если только последний терпит неудачу, будет вызван только тот.

Большое предостережение, ни один из этих кодов не тестировался. Но, теоретически, это рабочий подход.

Я думаю, что вам нужен построитель запросов, в котором методы, добавляющие критерии (такие как «папа» и «помощник», могут быть объединены в цепочку. Кроме того, вы хотите, чтобы в любой момент вы могли передать обратный вызов, а это означает выполнение запрос.

Поэтому я бы сделал это так:

function PersonQuery(personName) {
  this.criteria = [];
  criteria.push({name:personName});
}

PersonQuery.prototype.dad = function(doneCallback) {
    this.criteria.push({relationship:"dad"});
    _execute(doneCallback);
    return this;
}

PersonQuery.prototype.boss = function(doneCallback) {
    this.criteria.push({relationship:"boss"});
    _execute(doneCallback);
    return this;
}

PersonQuery.prototype.assistant = function(doneCallback) {
    this.criteria.push({relationship:"assistant"});
    _execute(doneCallback);
    return this;
}

PersonQuery.prototype._execute = function(doneCallback) {
    if (!doneCallback) {
       return;
    }
    $.ajax({"data": this.criteria}).success(function(responseData) {
       doneCallback(responseData);   
    });
}

Затем, чтобы использовать это, ваш пример станет:

   new PersonQuery("me").dad().boss().assistant(function(obj) { 
    alert(obj.phone); });

У меня это отлично работает с внутренним обещанием, поэтому я сразу же создаю объекты Person без данных. Все, что он содержит, — это обещание предоставить данные позже. Такой метод, как parent(), создает новое обещание, цепочка которого не соответствует текущему обещанию. Вероятно, есть способ сделать это проще, используя pipe(), но пока не совсем понял.

myLib = {
  find: function(id){
    var person = new Person();
    person.promise = $.ajax(.....);
  }
};

function Person(){
}
Person.prototype.parent(){
  var person = this;
  var parent = new Person();
  var deferred = $.Deferred();
  this.promise.then(function(data){
    var promise = $.ajax({url: '/person/'+data.parent+'/json'});
    promise.done(function(obj){
      person.data = obj.data;
      deferred.resolve(node);
    });
  }, function(error){
    deferred.fail();
  });
  parent.promise = deferred.promise();
  return parent;
}

Person.prototype.get(callback){
  this.promise.then(function(data){
    this.data = data;
    callback(this);
  });
}


Usage/Test:

myLib.find('12345').get(callback);
myLib.find('12345').parent().get(callback);