Y at-il une bonne raison pour envelopper une fonction supplémentaire immédiatement-Invoqué autour d'une définition du module requireJS?

Question

Je regardais les Backbone-requireJS boilerplates à GitHub, je vois deux types d'implémentations différentes.

https: // GitHub. com / david0178418 / backbone.js-AMD-boilerplate / blob / maître / src / js / vues / viewStub.js a ce qui suit comme viewStub:

function() {
    "use strict";

    define([
            'jqueryLoader',
            'underscore',
            'backbone',
        ],
        function($, _, Backbone) {

            return Backbone.View.extend({
                template : _.template(/*loaded template*/),

                initialize : function() {
                    this.render();
                },

                render : function() {
                    $(this.el).append(this.template(/*model/collection*/));

                    return this;
                }
            });
        }
    );
})();

Alors que la vue stub de l'autre passe-partout https://github.com/jcreamer898/RequireJS -Backbone-démarreur / blob / maître / js / vues / view.js a ce qui suit:

define([
        'jquery', 
        'backbone',
        'underscore', 
        'models/model',
        'text!templates/main.html'], 
function($, Backbone, _, model, template){
    var View = Backbone.View.extend({
        el: '#main',
        initialize: function(){
            this.model = new model({
                message: 'Hello World'
            });
            this.template = _.template( template, { model: this.model.toJSON() } );
        },
        render: function(){
            $(this.el).append( this.template );
        }
    });

    return new View();
}); 

Ma question est ici: Pourquoi est-il une fonction d'auto-exécution dans l'ensemble RequireJS module dans le premier exemple?

Answer 1

Il n'a pas besoin d'être une fermeture contenant dans cet exemple. Il crée un champ d'application de sorte que les variables déclarées ou fonctions ne fuient pas dans la portée globale. Mais lorsque vous n'êtes pas en train de créer des variables ou des fonctions nommées, alors il n'y a rien à fuir. Donc, il n'y a pas beaucoup.

La vraie raison peut être plus simple que vous le pensez. Comme en utilisant le signal de tour même si Noone est autour, entourant chaque fichier source JS dans une fonction d'auto exécution est une bonne habitude à prendre. Il vous évite d'erreurs stupides. Ainsi, il peut juste être un exemple d'un style de programmation défensive.

Il n'y a aucun avantage dans cet exemple, mais le coût de la performance liée à l'exécution est tout à fait négligeable. Alors pourquoi ne pas le faire la « bonne » dans le cas où quelqu'un vient nouvelle et « maintient » ce module à certains égards, de funk?

Answer 2

Il est tout à fait inutile de le faire, parce que vous avez déjà une fonction qui crée ses propres espaces de noms.

En outre il y a un inconvénient -. Vous obtenez un retrait supplémentaire, de sorte que votre code devient moins lisible