C'è una buona ragione per avvolgere una funzione extra immedently-invoked attorno a una definizione del modulo requireJS?

Question

Stavo guardando i piatti lastre Backbone-requireJS in GitHub, vedo due diversi tipi di implementazioni.

https://github.com/david0178418/BackboneJS-AMD-Boilerplate/blob/master/src/js/views/viewStub.js ha la 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; 
       } 
      }); 
     } 
    ); 
})(); 

considerando che la visione a stub dall'altra boilerplate https://github.com/jcreamer898/RequireJS-Backbone-Starter/blob/master/js/views/view.js ha la 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é esiste una funzione auto-eseguibile attorno all'intero modulo RequireJS nel primo esempio?

Answer 1

In questo esempio non è necessario che sia presente una chiusura di contenimento. Crea un ambito in modo che le variabili dichiarate o le funzioni non perdano nello scope globale. Ma quando non si creano variabili o funzioni con nome, allora non c'è nulla da perdere. Quindi non ha molto senso.

La vera ragione potrebbe essere più semplice di quanto si pensi. Come usare l'indicatore di direzione anche se nessuno è in giro, racchiudere ogni file sorgente JS in una funzione autoesecutiva è una buona abitudine. Ti salva da errori stupidi. Quindi potrebbe essere solo un esempio di uno stile di programmazione difensivo.

In questo esempio non vi è alcun vantaggio, ma il relativo costo delle prestazioni in fase di esecuzione è del tutto trascurabile. Quindi, perché non farlo nel modo "giusto" nel caso in cui qualcuno di nuovo entri e "mantenga" questo modulo in modi funky?

Answer 2

Non c'è alcun punto in questo, perché hai già una funzione che crea i propri spazi dei nomi.

Inoltre, c'è uno svantaggio: si ottiene un rientro extra, quindi il codice diventa meno leggibile.