Czy mogę użyć metody deferred.pipe jQuery w celu zmodyfikowania argumentów dostarczonych do odwołanych/odrzuconych wywołań zwrotnych?

Question

Chciałbym móc użyć obiektu odroczonego jQuery do obsługi ładowania danych przez kolekcje i modele szkieletu. Czy istnieje sposób, w jaki mogę zmodyfikować argumenty dostarczone do wykonanych i niepowodzeniem wywołań zwrotnych, aby uwzględnić wystąpienie modelu lub kolekcji? Ja przewidując coś jak następuje:

var _sync = Backbone.sync; 

Backbone.sync = function() { 
    var jqXhr = _sync.apply(this, arguments); 

    var self = this; 
    return jqXhr.pipe(function() { 
     var cbArgs = [self]; 
     cbArgs.push.apply(cbArgs, arguments); 
     return cbArgs; 
    } 
} 

... 
var c = new Backbone.Collection(); 
c.url = "/path/to/resources"; 
c.fetch().then(function(collection, data, textStatus, jqXhr) { 
    // do stuff with collection 
}); 

oczywiście, ponieważ filtr jest zwrócenie tablicy, wykonane zwrotna jest wywoływana z tablicy, zamiast wymienionych argumentów. O ile widzę, potok może jedynie modyfikować dostarczone argumenty, a nie dodawać. Wszelkie sugestie będą mile widziane.

Edytuj: To jest bardzo uproszczony przykład; odkąd zostało stworzone zamknięcie nad oryginalną kolekcją, mógłbym po prostu operować na tym. Jednak przypadek użycia jest taki, że wiele widoków kręgosłupa może opierać się na tych samych pobieranych danych, więc chciałbym móc po prostu dostarczyć obiekt odroczony jQuery do tych widoków, zamiast zarówno instancji Odroczona, jak i kolekcji.

Kolejna edycja: wysłano poniżej rozwiązanie, ale wszelkie inne sugestie są mile widziane.

Answer 1

Znalazłem sposób można to osiągnąć poprzez metodę .pipe powrócić nowy $ .Deferred że natychmiast rozwiązany przy użyciu zmodyfikowanych argumenty:

var _sync = Backbone.sync; 

Backbone.sync = function() { 
    var jqXhr = _sync.apply(this, arguments); 

    var self = this; 
    var deferred = jqXhr.pipe(function() { 
     var cbArgs = [self]; 
     cbArgs.push.apply(cbArgs, arguments); 
     var deferred = new $.Deferred(); 
     return deferred.resolve.apply(deferred, cbArgs); 
    }); 
    return $.extend(true, jqXhr, deferred); 
}; 

Answer 2

Rozwiązanie bardzo podobna do swojej odpowiedzi, ale bez rury, ponieważ w rzeczywistości nie trzeba filtrować wyniki: I bezpośrednio powrócić nowy odroczony od Backbone.sync zamiast rurociągów zdecydowanym odroczone

Backbone.originalSync = Backbone.sync; 
Backbone.sync = function(method, model, options) { 
    var xhr = Backbone.originalSync.call(this, method, model, options); 

    var dfd = $.Deferred(); 
    xhr.done(function() { 
     var cbArgs = [model].concat(_.toArray(arguments)); 
     dfd.resolve.apply(dfd, cbArgs); 
    }); 
    xhr.fail(function() { 
     var cbArgs = [model].concat(_.toArray(arguments)); 
     dfd.reject.apply(dfd, cbArgs); 
    }); 

    return dfd; 
}; 

a Fiddle http://jsfiddle.net/d8FqA/

Prostszy wariant, jeśli jesteś gotów mieć this związany z modelu/odbioru w swoich wywołań zwrotnych, które pozostawia nietknięte podpisów funkcyjne:

Backbone.originalSync = Backbone.sync; 
Backbone.sync = function(method, model, options) { 
    var xhr = Backbone.originalSync.call(this, method, model, options); 

    var dfd = $.Deferred(); 
    xhr.done(function() { 
     dfd.resolveWith(model, arguments); 
    }); 
    xhr.fail(function() { 
     dfd.rejectWith(model, arguments); 
    }); 

    return dfd; 
}; 

var c=new Backbone.Collection(); 
c.fetch().done(function() { 
    console.log(this); 
    console.log(arguments); 
}); 

http://jsfiddle.net/d8FqA/1/

który prowadzi nas do zabicia model jako Ramy do żądania Ajax:

Backbone.originalSync = Backbone.sync; 
Backbone.sync = function(method, model, options) { 
    options || (options={}) ; 
    options.context = model; 
    return Backbone.originalSync.call(this, method, model, options); 
}; 

var c=new Backbone.Collection(); 
c.fetch().done(function() { 
    console.log(this); 
}); 

http://jsfiddle.net/d8FqA/2/