Il trigger di Backbone() sincrono o asincrono?

Question

Sto costruendo una vista Backbone generica per la gestione di più viste secondarie. A volte ho bisogno di eseguire la logica per preparare queste viste prima che vengano renderizzate. Sto pensando di utilizzare gli eventi spina dorsale per consentire un gancio pre_render, in questo modo:

view = new (this.child_view); 
this.trigger('pre_render', view); 
view.render(); 

Saranno gli eventi chiamati da trigger() avvenire in modo sincronizzato, garantendo così che essi saranno tutti traguardo prima linea render() si chiama?

Answer 1

Fondamentalmente, sì, è sincrono.

Ecco la relativa sezione dalla fonte:

trigger: function(name) { 
    if (!this._events) return this; 
    var args = slice.call(arguments, 1); 
    if (!eventsApi(this, 'trigger', name, args)) return this; 
    var events = this._events[name]; 
    var allEvents = this._events.all; 
    if (events) triggerEvents(this, events, args); 
    if (allEvents) triggerEvents(this, allEvents, arguments); 
    return this; 
}, 

La funzione di importazione è triggerEvents, che chiama in realtà i gestori. Secondo lo comments, è solo un dispatcher ottimizzato. Si noti che tutti chiamano .call() e .apply(), quindi la richiamata verrà completata prima che il controllo venga restituito al chiamante.

var triggerEvents = function(obj, events, args) { 
    var ev, i = -1, l = events.length; 
    switch (args.length) { 
    case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); 
    return; 
    case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]); 
    return; 
    case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]); 
    return; 
    case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]); 
    return; 
    default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); 
    } 
}; 

Come altri hanno già detto, però, i gestori di innesco sono liberi di programmare le proprie callback se sono così inclinato. Quindi, indipendentemente dal fatto che gli handler abbiano finito il loro lavoro prima di tornare dipende dal codice del gestore stesso.

Answer 2

Sì, sono sincroni. Tuttavia, una funzione attivata da questo evento è gratuita per utilizzare setTimeout o effettuare richieste ajax e, in tal caso, tali richieste non saranno completate quando la chiamata trigger restituirà e il codice procederà a chiamare render. Quindi sì, ogni gestore di eventi associato sarà stato invocato ma non necessariamente completato l'intero set di elaborazione. Poiché la stessa API di trigger non utilizza callback o promesse, non esiste un modo diretto per sapere quando tutti i gestori di eventi sono completi. Se necessario, dovresti implementare personalmente una tale API e generare un evento distinto quando tutto è stato eseguito, inclusa l'elaborazione asincrona. Tuttavia, nella programmazione giorno per giorno, la maggior parte di questi gestori di eventi sono sincroni e, in caso contrario, il codice è solitamente strutturato in modo tale che il procedimento non causerà il comportamento anomalo dell'applicazione. Se hai bisogno di cambiare questo contratto, è un odore di codice che il tuo design dell'applicazione non stia armoniosamente usando il sistema degli eventi e potresti voler pensare a diversi approcci al tuo problema.

Answer 3

trigger è sincrono in base al codice sorgente, non significa che tutte le funzioni che ascoltano l'evento "pre_render" eseguiranno le operazioni sincrone tramite . PS: il codice sorgente è davvero facile da leggere, si dovrebbe davvero dare un'occhiata a esso:

http://backbonejs.org/docs/backbone.html