Jquery promette: esiste un'alternativa riutilizzabile?

Question

Sto costruendo una web app che ha un insieme di funzioni che l'utente può eseguire alcune volte ma coinvolge abbastanza azioni asincrone per i callback da risultare un po 'fuori mano.

Quali sono alternative realistiche a $.Deffered e $.when che possono essere "utilizzate" più volte?

• Io non sto cercando un quadro in piena regola
• Non voglio usare callback (direttamente)

Grazie!

Answer 1

Qui ci sono 3 tali librerie:

1. Q
2. rsvp.js
3. when.js

Queste librerie non sono "in piena regola". Attuano solo promesse.

Answer 2

Invece di attaccare alla promessa direttamente, è possibile effettuare un wrapper la promessa che consente a un callback di sottoscrivere una promessa ricorrente o chiamata Ajax fatto a intervalli regolari:

var cycle = function(func, interval){ 
    var _this = this; 

    // Use jQuery's triggers to manage subscriptions 
    var o = $({}); 
    this.publish = o.trigger.bind(o); 
    this.subscribe = o.on.bind(o); 
    this.unsubscribe = o.off.bind(o); 

    var call = function(func){ 

     clearTimeout(_this.timeout); 

     func().done(function(response){ 
      _this.publish('ajax:update', response); 
      _this.timeout = setTimeout(function(){ 
       call(func); 
      }, interval); 
     }); 
    }; 
    call(func); 

    return this; 
}; 

var ajax_promise = function(){ 
    return $.getJSON('http://localhost/some/data.json'); 
}; 

var my_callback = function(response){ 
    // Do stuff 
}; 

cycle(ajax_promise, 10000).subscribe('ajax:update', my_callback); 

Answer 3

Penso che quello che stai cercando sono eventi. Un esempio in jQuery utilizzando on e trigger:

var data_handler = $({}); 

function get_data(new_foo) { 
    // Do stuff, then send the event 
    data_handler.trigger('new_data', {foo: new_foo}); 
} 

data_handler.on('new_data', function(e, data) { 
    console.log('Handler 1: ' + data.foo); 
}); 

data_handler.on('new_data', function(e, data) { 
    console.log('Handler 2: ' + data.foo); 
}); 

get_data(1); 
get_data(2); 

uscita:

Handler 1: 1 
Handler 2: 1 
Handler 1: 2 
Handler 2: 2