Backbone récupère le rappel de la bonne façon

Ma colonne vertébrale application dispose d'une vue appelée annexeje suis un peu confus au sujet de la différence de l'appel de la fonction appropriée sur la réussite et l'erreur, je me suis essayé à la fois de remorquage possible énumérés ci-dessous, mais je n'avais pas quelle est la différence et qu'est-ce que le droit d'appeler une fonction de routeur placé en vue de l'extérieur:

Le premier moyen:

        require([
            'app/collections/schedule',
            'app/views/schedule'
        ], function(ScheduleCollection, ScheduleView) {

           var scheduleCollection = new ScheduleCollection(),
            scheduleView = new ScheduleView({
                model: scheduleCollection
            });

            scheduleCollection.fetch({
                reset: true,                
                success: function(){
                    scheduleView.successHandler();
                },
                error: function(){
                    scheduleView.errorHandler()
                }
            });
        });

La deuxième façon

        require([
            'app/collections/schedule',
            'app/views/schedule'
        ], function(ScheduleCollection, ScheduleView) {

           var scheduleCollection = new ScheduleCollection(),
            scheduleView = new ScheduleView({
                model: scheduleCollection
            });

            scheduleCollection.fetch({
                reset: true,                
                success: scheduleView.successHandler(),
                error: scheduleView.errorHandler()                  
            });
        });

dans le scheduleView

successHandler: function(){
   console.log('success');
}


erroHandler: function(){
   console.log('error');
}

source d'informationauteur ahmedsaber111

Il y a une autre option: plutôt que de référencer les points de vue directement, fournir la collection comme une référence à l'concernés points de vue et écouter les événements pertinents. Par exemple, écouter de nouveau sur la collection de la vue. Si ce n'est pas l'événement que vous souhaitez raccorder, puis déclencher un événement personnalisé de la réussite ou de l'erreur de rappels que votre vue peut écouter.

Voici un exemple de manipulation de réinitialisation de prolonger votre ScheduleView:

var ScheduleView = Backbone.View.extend({ 

    initialize: function () {

        this.listenTo(this.collection, 'reset', this.handleReset);
    },

    handleReset: function () {
        //do whatever you need to do here
    }
};

var scheduleCollection = new ScheduleCollection();
var scheduleView = new ScheduleView({ collection: scheduleCollection });

voici un exemple de personnalisation des événements liés à la réussite/gestionnaires d'erreur à partir de la collection:

var ScheduleCollection = Backbone.Collection.extend({

    getResults: function () {

        var self = this;

        this.fetch({
            reset: true,
            success: function (collection, response, options) {
                //you can pass additional options to the event you trigger here as well
                self.trigger('successOnFetch');
            },
            error: function (collection, response, options) {
                //you can pass additional options to the event you trigger here as well
                self.trigger('errorOnFetch');
            }
        });
    }
 };

var ScheduleView = Backbone.View.extend({

    initialize: function () {

        this.listenTo(this.collection, 'successOnFetch', this.handleSuccess);
        this.listenTo(this.collection, 'errorOnFetch', this.handleError);
    },

    handleSuccess: function (options) {
        //options will be any options you passed when triggering the custom event
    },

    handleError: function (options) {
        //options will be any options you passed when triggering the custom event
    }
};

var scheduleCollection = new ScheduleCollection();
var scheduleView = new ScheduleView({ collection: scheduleCollection });
scheduleCollection.getResults();

L'avantage de câblage de cette manière est que vous retirez la dépendance de la collection est sur le point de vue. C'est particulièrement essentielle si vous voulez plus d'une vue à écouter les événements qui se passe sur votre collection (ou les modèles de la collection) et plus faiblement couplé pour l'architecture de votre épine Dorsale de l'application.

5

La première voie est correcte, la seconde est incorrect. Mais de cette façon pourrait être plus concis:
```
scheduleCollection.fetch({
    reset: true,                
    success: scheduleView.successHandler,
    error: scheduleView.errorHandler
});
```
(Bien que ... de l'OP, la fonction scheduleView.successHandler n'existe pas, de sorte que pourrait être un problème.)
2

La raison pour laquelle le deuxième ne fonctionne pas, c'est que vous avez besoin pour passer un référence à une fonction plutôt que de l'exécuter immédiatement.
```
var foo = myFunction(); //foo is set to myFunction's return value
var bar = myFunction; //bar is set to a REFERENCE to myFunction

foo === bar //FALSE
bar === myFunction //TRUE
```
Code corrigé:
```
scheduleCollection.fetch({
    reset: true,                
    success: scheduleView.successHandler,
    error: scheduleView.errorHandler                  
});
```
Maintenant, si vous souhaitez obtenir des avancées, à l'aide de la jQuery promesse de l'API hors de le retour de l'objet XHR est supérieure dans tous les sens et les rappels ne devrait jamais être nécessaire plus.
```
scheduleCollection.fetch({ reset: true })
    .then(scheduleView.successHandler, scheduleView.errorHandler);
```
La différence est que vous obtenez une promesse de retour qui peut être transmise... mais c'est un sujet pour un autre post. (Shameless plug) découvrez adamterlson.com pour ma série en trois parties sur des promesses....
0

Ce que vous devez faire est d'attribuer la fonction de l'objet de la "réussite" et "erreur" et non pas la valeur de retour de la fonction.
Lorsque vous faites:
```
function(){...}
```
elle renvoie un objet de fonction et donc
success: function(){...}

est juste, mais si
```
a = function(){...}
```
et vous ne a() il exécute la fonction et renvoie la valeur de retour et donc
success: a() est mal, mais success: a est droit.

Vous devez vous connecter pour publier un commentaire.