Modalità rigorosa in un namespace con Javascript

Question

Recentemente, mentre leggevo un ottimo libro; 'Maintainable Javascript', ho scoperto l'uso del pragma "use strict".

"use strict" sembra essere una cattiva pratica se è dichiarata nell'ambito globale. Il metodo consigliato è quello di utilizzare la modalità rigorosa direttamente in ogni funzione come questa:

// Non-strict code... 

(function(){ 
    "use strict"; 

    // Define your library strictly... 
})(); 

// Non-strict code... 

E 'possibile definire la modalità rigorosa per un intero spazio dei nomi invece di definire in ogni funzione? Se sì, posso avere uno o due esempi di codice?

Grazie.

Answer 1

modalità Strict si applica al contesto di esecuzione in cui viene dichiarata e tutti i contesti tale contesto contiene (con qualche squidginess intorno contesti creati tramite eval, ma evitare di usare eval e si evita la squidginess), quindi di solito devi usare il modello di modulo da applicare a tutti il ​​codice:

(function() { 
    "use strict"; 

    function foo() { 
    } 

    function bar() { 
    } 

    // ...presumably code hooking up `foo` and `bar` to events 
    // or otherwise using them -- or of course, you could export 
    // them from the scope... 
})(); 

In, modalità rigorosa sopra vale non solo per la funzione anonima, ma per foo e bar pure. Così, per esempio, dove il codice sarebbe "lavoro" (creare una variabile globale tramite The Horror of Implicit Globals):

(function() { 
    function foo() { 
     someNameThatIsntDefined = 42; // Blech, creates implicit global 
    } 

    foo(); 
})(); 

... questo codice fallisce con un ReferenceError (l'unico cambiamento è il "use strict"):

... perché una delle tante cose utili che la modalità rigorosa fa è eliminare l'orrore delle global implicite.

Ecco un altro esempio, dove esportiamo una funzione che viene eseguito in modalità rigorosa anche quando chiamato da codice non-strict:

var MyModule; 
MyModule = MyModule || {}; 
(function(mod) { 
    "use strict"; 

    mod.doSomethingUseful = doSomethingUseful; 
    function doSomethingUseful() { 
     // ... 
    } 

})(MyModule); 

codice "Loose" può chiamare MyModule.doSomethingUseful, che corre sempre in modalità rigorosa. Il risultato è che puoi applicare la modalità rigorosa a il tuo codice senza richiedere a tutti il ​​numero di utilizzare il codice. Molto utile, quello.

Answer 2

Il primo modo è quando si inserisce il pragma "use strict"; nella prima riga del file .js. Quindi TUTTO in quel file sarà valutato rigorosamente.
Non c'è niente di intrinsecamente sbagliato in questo. Prima o poi tutti i browser renderanno obsoleto il 'vecchio codice js'. Solo il vero svantaggio potrebbe potenzialmente infrangere il vecchio codice se lo si utilizza.

Secondo modo potrebbe essere un oggetto come questo:

tmp = new o.Pixel (300, 300);

} // end 

Questo codice consente di avere variabili "private". Nota che f è anche una var "privata".

L'uso è semplice:

var rvar = contName.rnd(5); 
var obj = new contName.Pixel(300, 300) 

---

Terza via potrebbe essere T.J.Crowder di, quarto è Doug Crockford di ... Questi sono modi solo diversi per emulare qualcosa che non è ancora ufficialmente presente in una lingua.

Answer 3

var Module = (function() { 
    "use strict"; 

    var f = function() { 
     // do stuff 
    } 

    return { // return your namespace 
     "myModuleFunction": f 
    } 
})(); 

Penso che questo dovrebbe funzionare anche.