C'è una ragione buona per il confezionamento di una funzione extra-immedeately Richiamato intorno ad una definizione del modulo requireJS?

Question

Stavo guardando la spina dorsale-requireJS boilerplates in GitHub, vedo due diversi tipi di implementazioni.

https: // GitHub. com / david0178418 / BackboneJS-AMD-Boilerplate / blob / master / src / js / views / viewStub.js è il seguente come 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;
                }
            });
        }
    );
})();

Mentre la vista-stub dall'altra boilerplate https://github.com/jcreamer898/RequireJS -Backbone-Starter / blob / master / js / views / view.js ha il seguente:

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();
}); 

La mia domanda è: Perché c'è una funzione di self-executing intorno modulo tutto il RequireJS nel primo esempio?

Answer 1

Ci non ha bisogno di essere una chiusura contenente, in questo esempio. Si crea un ambito in modo che le variabili o funzioni dichiarate non perdano nel campo di applicazione globale. Ma quando non si sta creando variabili o funzioni denominate, allora non c'è nulla da perdere. Quindi non c'è più molto senso.

La vera ragione potrebbe essere più semplice di quanto si pensi. Come utilizzare il segnale di svolta, anche se nessuno è intorno, che racchiude tutti i file sorgente JS in una funzione di auto esecuzione è una buona abitudine per entrare. Esso consente di risparmiare da errori stupidi. Quindi, potrebbe essere solo un esempio di uno stile di programmazione difensiva.

Non v'è alcun beneficio in questo esempio, ma il costo delle prestazioni relative a tempo di esecuzione è del tutto trascurabile. Allora perché non farlo nel modo "giusto" nel caso in cui qualcuno viene in nuova e "mantiene" questo modulo in un certo senso funky?

Answer 2

Non c'è assolutamente nessun punto nel fare questo, perché avete già una funzione che crea i propri spazi dei nomi.

Inoltre v'è uno svantaggio -. Si stanno ottenendo un rientro in più, in modo che il codice diventa meno leggibile