javascript '; angularjs - Che cosa fa "use strict" in JavaScript e qual è il ragionamento che sta dietro?




13 Answers

Questo articolo sulla modalità Strict Javascript potrebbe interessarti: John Resig - ECMAScript 5 Modalità rigorosa, JSON e altro

Per citare alcune parti interessanti:

La modalità rigorosa è una nuova funzionalità di ECMAScript 5 che consente di posizionare un programma o una funzione in un contesto operativo "rigoroso". Questo contesto rigoroso impedisce che alcune azioni vengano prese e genera più eccezioni.

E:

La modalità rigorosa aiuta in un paio di modi:

  • Cattura alcuni comuni blooper in codice, generando eccezioni.
  • Previene, o genera errori, quando vengono intraprese azioni relativamente "non sicure" (come ottenere l'accesso all'oggetto globale).
  • Disattiva le funzionalità che sono confuse o mal concepite.

Nota inoltre che puoi applicare la "modalità rigorosa" all'intero file ... Oppure puoi usarlo solo per una funzione specifica (continuando a citare l'articolo di John Resig) :

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

Quale potrebbe essere utile se devi mescolare il vecchio e il nuovo codice ;-)

Quindi, suppongo che sia un po 'come "use strict" che puoi usare in Perl (da cui il nome?) : Ti aiuta a fare meno errori, rilevando più cose che potrebbero portare a rotture.

Attualmente è supportato da tutti i principali browser (barra IE 9 e seguenti) .

declare variable

Recentemente, ho eseguito un po 'del mio codice JavaScript tramite JSLint di Crockford, e ha dato il seguente errore:

Problema alla riga 1 carattere 1: manca la frase "use strict".

Facendo qualche ricerca, ho capito che alcune persone aggiungono "use strict"; nel loro codice JavaScript. Una volta aggiunta la dichiarazione, l'errore ha smesso di apparire. Sfortunatamente, Google non ha rivelato gran parte della storia dietro questa dichiarazione di stringa. Certamente deve avere qualcosa a che fare con il modo in cui il JavaScript viene interpretato dal browser, ma non ho idea di quale sarebbe l'effetto.

Quindi cos'è "use strict"; tutto ciò, cosa implica, ed è ancora rilevante?

Qualcuno dei browser attuali risponde "use strict"; stringa o è per uso futuro?




La frase "use strict"; indica al browser di utilizzare la modalità Strict, che è una serie di JavaScript ridotta e più sicura.

Elenco delle caratteristiche (non esaustivo)

  1. Non consente le variabili globali. (Catture mancano dichiarazioni var e errori di battitura nei nomi delle variabili)

  2. Assegnazioni non riuscite silenziose generano errori in modalità rigorosa (assegnando NaN = 5; )

  3. Tentativi di eliminare proprietà non delete Object.prototype ( delete Object.prototype )

  4. Richiede che tutti i nomi di proprietà in un oggetto letterale siano univoci ( var x = {x1: "1", x1: "2"} )

  5. I nomi dei parametri delle funzioni devono essere univoci ( function sum (x, x) {...} )

  6. Proibisce la sintassi ottale ( var x = 023; alcuni sviluppatori assumono erroneamente che uno zero precedente non modifichi il numero).

  7. Proibisce la parola chiave with

  8. eval in modalità rigorosa non introduce nuove variabili

  9. Proibisce l'eliminazione di nomi semplici ( delete x; )

  10. Proibisce l'associazione o l'assegnazione dei nomi eval e gli arguments in qualsiasi forma

  11. La modalità rigorosa non alias le proprietà dell'oggetto arguments con i parametri formali. (cioè nella function sum (a,b) { return arguments[0] + b;} Questo funziona perché gli arguments[0] sono associati a a e così via.)

  12. arguments.callee non è supportato

[Ref: Modalità rigorosa , Mozilla Developer Network ]




Una parola di cautela, tutti voi programmatori che caricano duramente: applicare "use strict" al codice esistente può essere pericoloso! Questa cosa non è un adesivo di buon gusto, faccia felice che puoi dare uno schiaffo al codice per renderlo 'migliore'. Con il pragma "use strict" , il browser improvvisamente LANCIA eccezioni in posti casuali che non ha mai gettato prima solo perché in quel punto stai facendo qualcosa che default / loose JavaScript consente felicemente, ma rigidi aborti su JavaScript! Potresti avere violazioni di rigore che si nascondono nelle chiamate usate raramente nel tuo codice che generano solo un'eccezione quando alla fine vengono eseguite, ad esempio nell'ambiente di produzione utilizzato dai tuoi clienti paganti!

Se hai intenzione di fare il grande passo, è una buona idea applicare "use strict" insieme a test unitari completi e un'attività di compilazione JSHint strettamente configurata che ti darà la certezza che non c'è un angolo scuro del tuo modulo che esploderà orribilmente solo perché hai attivato la modalità rigorosa. Oppure, hey, ecco un'altra opzione: non aggiungere "use strict" a nessuno dei tuoi codici legacy, è probabilmente più sicuro in questo modo, onestamente. DEFINITAMENTE NON aggiungere "use strict" a tutti i moduli che non possiedi o gestisci, come i moduli di terze parti.

Penso che anche se è un animale in gabbia mortale, "use strict" può essere una buona roba, ma devi farlo bene. Il momento migliore per andare rigorosi è quando il tuo progetto è greenfield e stai partendo da zero. Configura JSHint/JSLint con tutti gli avvertimenti e le opzioni alzati così forte come la tua squadra può sopportare, ottenere una buona build / test / asserire system du jour truccato come Grunt+Karma+Chai , e solo POI iniziare a marcare tutti i tuoi nuovi moduli come "use strict" . Preparati a curare molti errori e avvertimenti. Assicurati che tutti comprendano la gravità configurando la build su FAIL se JSHint/JSLint produce violazioni.

Il mio progetto non era un progetto greenfield quando ho adottato "use strict" . Di conseguenza, il mio IDE è pieno di segni rossi perché non ho "use strict" su metà dei miei moduli, e JSHint si lamenta di ciò. È un promemoria per me su cosa dovrei rifare in futuro. Il mio obiettivo è quello di essere libero dal marchio rosso a causa di tutte le mie dichiarazioni "use strict" mancano, ma sono lontani anni.




Consiglio vivamente a tutti gli sviluppatori di iniziare a utilizzare la modalità rigorosa ora. Ci sono abbastanza browser che lo supportano che la modalità rigorosa ci aiuterà legittimamente a salvarci da errori che non sapevamo nemmeno che fossero nel tuo codice.

Apparentemente, nella fase iniziale ci saranno errori che non abbiamo mai incontrato prima. Per ottenere il massimo beneficio, dobbiamo eseguire test appropriati dopo aver attivato la modalità rigorosa per assicurarci di aver catturato tutto. Sicuramente non usiamo solo use strict nel nostro codice e assumiamo che non ci siano errori. Quindi, il churn è che è ora di iniziare a utilizzare questa caratteristica del linguaggio incredibilmente utile per scrivere codice migliore.

Per esempio,

var person = {
    name : 'xyz',
    position : 'abc',
    fullname : function () {  "use strict"; return this.name; }
};

JSLint è un debugger scritto da Douglas Crockford. Basta incollare il tuo script e scansionerà rapidamente eventuali problemi e errori evidenti nel tuo codice.




I miei due centesimi:

Uno degli obiettivi della modalità rigorosa è consentire un più rapido debug dei problemi. Aiuta gli sviluppatori a generare eccezioni quando si verificano determinate cose sbagliate che possono causare un comportamento silenzioso e strano della tua pagina web. Nel momento in cui usiamo l' use strict , il codice genererà errori che aiutano lo sviluppatore a risolverlo in anticipo.

Poche cose importanti che ho imparato dopo aver usato use strict :

Previene la dichiarazione delle variabili globali:

var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};

function Tree(typeOfTree) {
    var age;
    var leafCount;

    age = typeOfTree.age;
    leafCount = typeOfTree.leafCount;
    nameoftree = typeOfTree.name;
};

var tree1 = new Tree(tree1Data);
console.log(window);

Ora, questo codice crea nameoftree nell'ambito globale a cui è possibile accedere usando window.nameoftree . Quando implementiamo l' use strict il codice genererebbe un errore.

Uncaught ReferenceError: nameoftree non è definito

Sample

Elimina with dichiarazione:

with dichiarazioni non può essere minimizzato utilizzando strumenti come uglify-js . Sono anche deprecated e rimossi dalle versioni future di JavaScript.

Sample

Previene i duplicati:

Quando abbiamo la proprietà duplicata, genera un'eccezione

Uncaught SyntaxError: proprietà dei dati duplicati nel letterale dell'oggetto non consentita in modalità rigorosa

"use strict";
var tree1Data = {
    name: 'Banana Tree',
    age: 100,
    leafCount: 100000,
    name:'Banana Tree'
};

Ce ne sono alcuni di più, ma ho bisogno di acquisire più conoscenza al riguardo.




La modalità rigorosa apporta diverse modifiche alla normale semantica di JavaScript:

  • elimina alcuni errori JavaScript JavaScript modificandoli per generare errori.

  • corregge gli errori che rendono difficile per i motori JavaScript eseguire ottimizzazioni.

  • proibisce alcune sintassi che potrebbero essere definite nelle versioni future di ECMAScript.

per maggiori informazioni vistit Strict Mode- Javascript




"Usa rigorosamente"; è un'assicurazione che il programmatore non utilizzerà le proprietà libere o errate di JavaScript. È una guida, proprio come un righello ti aiuterà a fare linee rette. "Usa Strict" ti aiuterà a fare "Codifica Diretta".

Coloro che preferiscono non usare i righelli per fare le loro linee dritte di solito finiscono in quelle pagine per chiedere agli altri di eseguire il debug del loro codice.

Credimi.Il sovraccarico è trascurabile rispetto al codice mal progettato. Doug Crockford, che è stato sviluppatore senior di JavaScript per diversi anni, ha un post molto interessante qui . Personalmente, mi piace tornare sul suo sito tutto il tempo per assicurarmi di non dimenticare le mie buone pratiche.

La pratica moderna di JavaScript dovrebbe sempre evocare il "Use Strict"; pragma. L'unica ragione per cui il gruppo ECMA ha reso facoltativa la modalità "Strict" è quella di consentire ai codificatori meno esperti di accedere a JavaScript e dare quindi il tempo di adattarsi alle nuove e più sicure pratiche di codifica.




Citando da w3schools :

La direttiva "use strict"

La direttiva "use strict" è nuova in JavaScript 1.8.5 (ECMAScript versione 5).

Non è un'affermazione, ma un'espressione letterale, ignorata dalle precedenti versioni di JavaScript.

Lo scopo di "use strict" è indicare che il codice deve essere eseguito in "strict mode".

Con la modalità rigorosa, non è possibile, ad esempio, utilizzare variabili non dichiarate.

Perché la modalità rigorosa?

La modalità rigorosa semplifica la scrittura di JavaScript "sicuro".

La modalità rigorosa modifica la "sintassi errata" precedentemente accettata in errori reali.

Ad esempio, in JavaScript normale, l'errata digitazione di un nome di variabile crea una nuova variabile globale. In modalità rigorosa, questo genera un errore, rendendo impossibile creare accidentalmente una variabile globale.

In JavaScript normale, uno sviluppatore non riceverà alcuna risposta di errore che assegna valori a proprietà non modificabili.

In modalità rigorosa, qualsiasi assegnazione a una proprietà non scrivibile, una proprietà getter-only, una proprietà non esistente, una variabile non esistente o un oggetto non esistente genererà un errore.

Si prega di fare riferimento a http://www.w3schools.com/js/js_strict.asp per saperne di più




"use strict"rende il codice JavaScript da eseguire in modalità rigorosa , il che significa che tutto deve essere definito prima dell'uso. Il motivo principale per utilizzare la modalità rigorosa è evitare usi globali accidentali di metodi non definiti.

Anche in modalità rigorosa, le cose girano più velocemente, alcuni avvisi o avvisi silenziosi generano errori fatali, è sempre meglio usarlo per creare un codice più ordinato.

"use strict"è ampiamente necessario per essere utilizzato in ECMA5, in ECMA6 è parte di JavaScript per impostazione predefinita , quindi non è necessario aggiungerlo se si utilizza ES6.

Guarda queste dichiarazioni ed esempi da MDN:

La direttiva "use strict"
La direttiva "use strict" è nuova in JavaScript 1.8.5 (ECMAScript versione 5). Non è un'affermazione, ma un'espressione letterale, ignorata dalle precedenti versioni di JavaScript. Lo scopo di "use strict" è indicare che il codice deve essere eseguito in "strict mode". Con la modalità rigorosa, non è possibile, ad esempio, utilizzare variabili non dichiarate.

Esempi di utilizzo di "use strict":
modalità rigorosa per le funzioni: allo stesso modo, per richiamare la modalità strict per una funzione, inserire l'espressione esatta "use strict"; (o 'usa strict';) nel corpo della funzione prima di ogni altra dichiarazione.

1) modalità rigorosa nelle funzioni

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) modalità rigorosa di intero script

'use strict';
var v = "Hi! I'm a strict mode script!";
console.log(v);

3) Assegnazione a un globale non scrivibile

'use strict';

// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError

Puoi leggere di più su MDN .




Piccolo esempio da confrontare:

Modalità non rigorosa:

for (i of [1,2,3]) console.log(i)

// output:
// 1
// 2
// 3

Modalità rigorosa:

'use strict';
for (i of [1,2,3]) console.log(i)

// output:
// Uncaught ReferenceError: i is not defined



use strict è un modo per rendere più sicuro il tuo codice, perché non puoi utilizzare funzioni pericolose che non funzionano come ti aspetti.E come è stato scritto prima, rende il codice più rigido.




Usa rigoroso è usato per mostrare errori comuni e ripetuti in modo che siano gestiti in modo diverso, e cambia il modo in cui viene eseguito lo script java, tali cambiamenti sono:

  • Previene i globali accidentali

  • Nessun duplicato

  • Elimina con

  • Elimina questa coercizione

  • Più sicuro ()

  • Errori per immutables

puoi anche leggere questo article per i dettagli




La modalità "strict" di JavaScript viene introdotta in ECMAScript 5.

  (function() {
  "use strict";
   your code...
   })();

scrivere "usare rigorosamente"; all'inizio del tuo file JS attiva il controllo rigoroso della sintassi. Svolge i seguenti compiti per noi:

(i) mostra un errore se si tenta di assegnare a una variabile non dichiarata

(ii) ti impedisce di sovrascrivere le librerie di sistema JS chiave

(ii) proibisce alcune caratteristiche linguistiche non sicure o soggette a errori

"use strict" funziona anche all'interno delle singole funzioni. È sempre una buona pratica includere "usa rigorosamente il tuo codice.

Problema di compatibilità del browser: le direttive "uso" sono pensate per essere compatibili con le versioni precedenti. I browser che non li supportano vedranno solo un letterale String che non viene ulteriormente referenziato. Quindi lo passeranno sopra e andranno avanti.




Related