Cosa fa "use strict" in JavaScript e qual è il ragionamento alla base?

https://stackoverflow.com/questions/1335851

20-09-2019
|

Domanda

Recentemente, ho eseguito parte del mio codice JavaScript tramite Crockford JSLint, e ha dato il seguente errore:

Problema alla riga 1 carattere 1:Manca l'istruzione "usa rigoroso".

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

Allora, cos'è? "use strict"; tutto, cosa implica ed è ancora rilevante?

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

Soluzione

Questo articolo su modalità Strict Javascript potuto interessarli: John Resig - ECMAScript 5 modalità Strict, JSON, e più

Per citare alcune parti interessanti:

Modalità rigorosa è una nuova funzionalità di ECMAScript 5 che permette di inserire un programma, o di una funzione, in un contesto operativo "rigorosa". Questo contesto rigoroso impedisce determinate azioni vengano intraprese e getta più eccezioni.

modalità Strict aiuta in un paio di modi:


Si coglie alcuni bloopers di codifica comuni, generare eccezioni.

Previene, o genera errori, quando relativamente azioni "non sicuri" vengono presi (come ad esempio l'accesso all'oggetto globale).

Si disabilita caratteristiche che sono fonte di confusione o mal pensata.

Si noti inoltre è possibile applicare "strict mode" per l'intero file ... Oppure si può usare solo per una specifica funzione (ancora citando l'articolo di John Resig) :

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code...

Il che potrebbe essere utile se si deve mescolare il codice vecchio e nuovo; -)

Quindi, suppongo che sia un po 'come il "use strict" è possibile utilizzare in Perl (da qui il nome?): Ti aiuta a fare meno errori, rilevando altre cose che potrebbero portare a rotture <. / p>

modalità Strict è ormai supportata da tutti i principali browser .

moduli ECMAScript nativi (con le dichiarazioni import e export) e classi ES6 , strict mode è sempre abilitata e non può essere disattivata.

Altri suggerimenti

Si tratta di una nuova funzionalità di ECMAScript 5. John Resig ha scritto su un bel sintesi di esso.

E 'solo una stringa che si mette in file JavaScript (sia nella parte superiore del file o all'interno di una funzione) che assomiglia a questo:

"use strict";

Mettere nel codice ora non dovrebbe causare problemi con i browser attuali in quanto è solo una stringa. Essa può causare problemi con il codice in futuro, se il codice viola il pragma. Per esempio, se attualmente avete foo = "bar" senza definire foo prima, il codice inizierà in mancanza ... che è una buona cosa a mio parere.

La dichiarazione "use strict"; indica al browser di utilizzare la modalità Strict, che è un insieme di funzionalità ridotte e più sicure di JavaScript.

Elenco delle funzionalità (non esaustivo)

Non consente variabili globali.(Le catture mancano var dichiarazioni ed errori di battitura nei nomi delle variabili)
Le assegnazioni con errore silenzioso genereranno errori in modalità rigorosa (assigning NaN = 5;)
I tentativi di eliminare le proprietà non eliminabili genereranno (delete Object.prototype)
Richiede che tutti i nomi di proprietà in un oggetto letterale siano univoci (var x = {x1: "1", x1: "2"})
I nomi dei parametri della funzione devono essere univoci (function sum (x, x) {...})
Vieta la sintassi ottale (var x = 023; alcuni sviluppatori presumono erroneamente che uno zero precedente non faccia nulla per modificare il numero.)
Vieta il with parola chiave
eval in modalità rigorosa non introduce nuove variabili
Vieta la cancellazione dei nomi semplici (delete x;)
Vieta l'associazione o l'assegnazione dei nomi eval E arguments in qualsiasi forma
La modalità rigorosa non esegue l'alias delle proprietà del file arguments oggetto con i parametri formali.(cioè.In function sum (a,b) { return arguments[0] + b;} Funziona perché arguments[0] è obbligato a a e così via.)
arguments.callee non è supportato

[Rif: Modalità rigorosa, Rete di sviluppatori Mozilla]

Se le persone sono preoccupati sull'utilizzo use strict potrebbe essere la pena di verificare questo articolo:

supporto 'modalità Strict' ECMAScript 5 nei browser. Che cosa significa questo?
NovoGeek.com - weblog di Krishna

Si parla di supporto del browser, ma soprattutto come affrontare in modo sicuro:

function isStrictMode(){
    return !this;
} 
/*
   returns false, since 'this' refers to global object and 
   '!this' becomes false
*/

function isStrictMode(){   
    "use strict";
    return !this;
} 
/* 
   returns true, since in strict mode the keyword 'this'
   does not refer to global object, unlike traditional JS. 
   So here, 'this' is 'undefined' and '!this' becomes true.
*/

Una parola di cautela, tutto quello che i programmatori hard-ricarica: applicando "use strict" al codice esistente può essere pericoloso! Questa cosa non è certa, l'autoadesivo felice faccia sensazione di benessere che si può schiaffo sul codice per renderlo 'meglio'. Con il pragma "use strict", il browser improvvisamente generare eccezioni in luoghi casuali che non è mai gettato prima solo perché in quel punto si sta facendo qualcosa che default / sciolti JavaScript permette felicemente aborrisce ma rigorosa Javascript! Si può avere violazioni severità si nasconde nelle chiamate raramente utilizzati nel codice che si gettano solo un'eccezione quando lo fanno alla fine si corrono - per esempio, in un ambiente di produzione che i vostri clienti paganti utilizzano

Se avete intenzione di fare il grande passo, è una buona idea di applicare "use strict" al fianco di test di unità complete e strettamente configurato JSHint costruire compito che vi darà una certa sicurezza che non c'è angolo buio del modulo che farà saltare in aria orribilmente solo perché hai attivato la modalità Strict. Oppure, ehi, ecco un'altra opzione: basta non aggiungere "use strict" a qualsiasi del codice legacy, è probabilmente più sicuro in questo modo, onestamente. Sicuramente non aggiungi "use strict" per tutti i moduli che non si possiede o mantenere, come moduli di terze parti.

Credo che, anche se si tratta di un animale in gabbia mortale, "use strict" può essere roba buona, ma bisogna farlo bene. Il momento migliore per andare rigorosa è quando il progetto è greenfield e si stanno iniziando da zero. Configurare JSHint/JSLint con tutte le avvertenze e le opzioni di gomito fino stretto come la tua squadra può digerire, ottenere un buon / sistema di assert test build / du jour truccate come Grunt+Karma+Chai, e solo allora iniziare segnando tutti i nuovi moduli come "use strict". Siate pronti a curare un sacco di errori e gli avvisi alle questioni più spinose. Assicurarsi che tutti comprendano la gravità configurando l'accumulo di fallire se JSHint/JSLint produce eventuali violazioni.

Il mio progetto non era un progetto greenfield quando ho adottato "use strict". Di conseguenza, il mio IDE è piena di segni rossi, perché non ho "use strict" sulla metà dei miei moduli, e JSHint si lamenta di questo. E 'un richiamo a me di quello che refactoring devo fare in futuro. Il mio obiettivo è quello di essere segno rosso libero a causa di tutte le mie affermazioni "use strict" mancanti, ma che è lontano anni ormai.

Uso `'use strict';` non improvvisamente rendere il codice migliore.

Il JavaScript modalità rigorosa è una funzionalità di ECMAScript 5 . È possibile attivare la modalità rigorosa dichiarando questo nella parte superiore dello script / funzioni.

'use strict';

Quando un motore JavaScript vede questo di direttiva , si inizierà a interpretare il codice in una modalità speciale. In questo modo, gli errori sono gettati quando vengono rilevati in fase di certe pratiche di codifica che potrebbero finire potenziali bug (che è il ragionamento alla base della modalità rigorosa).

Si consideri questo esempio:

var a = 365;
var b = 030;

Nella loro ossessione per allineare le costanti numeriche, lo sviluppatore ha inavvertitamente inizializzata b variabile con un ottale letterale. Modalità non rigorosa interpreterà questo come un letterale numerico con 24 valore (in base 10). Tuttavia, la modalità rigorosa genera un errore.

Per un elenco non esaustivo di specialità in modalità rigorosa, vedere questa risposta .

Dove dovrei usare `'use strict';`?

Nel mio nuovo applicazione JavaScript:!. Assolutamente modalità Strict può essere usato come un informatore quando si sta facendo qualcosa di stupido con il codice
Nel mio esistente Il codice JavaScript: Probabilmente no Se il codice JavaScript esistente ha dichiarazioni vietate in rigorosa modalità, l'applicazione verrà semplicemente rompere. Se si vuole modalità rigorosa, si dovrebbe essere pronti per eseguire il debug e correggere il codice esistente. Questo è il motivo per cui usando 'use strict'; non improvvisamente rendere il codice più .

Come si usa la modalità rigorosa?

Inserisci una dichiarazione 'use strict'; sulla parte superiore dello script:
```
// File: myscript.js

'use strict';
var a = 2;
....
```
Si noti che tutto nel file myscript.js verrà interpretato in modalità rigorosa.
In alternativa, inserire una dichiarazione 'use strict'; sulla parte superiore del corpo della funzione:
```
function doSomething() {
    'use strict';
    ...
}
```
Tutto in scope lessicale della funzione doSomething sarà interpretato in modalità rigorosa. La parola scope lessicale è importante qui. Vedi questa risposta per una spiegazione migliore.

Quali cose sono vietate in modalità rigorosa?

Ho trovato un bell'articolo che descrive diverse cose che sono proibite in modalità rigorosa (notare che questo non è un elenco esclusivo):

Ambito

Storicamente, JavaScript è stato confuso su come funziona   vengono ambito. A volte sembrano essere ambito statico, ma un po '   caratteristiche li rendono comportano come essi hanno un ambito in modo dinamico. Questo è   confusione, rendendo i programmi difficili da leggere e capire.   Incomprensione provoca bug. E 'anche un problema per le prestazioni.   scoping statico permetterebbe vincolante per accadere in fase di compilazione variabile   tempo, ma la richiesta di portata dinamica significa il legame deve essere   rinviata al runtime, che viene fornito con una performance significativa   penalità.

modalità Strict richiede che tutte le variabili vincolanti essere fatto in modo statico.   Ciò significa che le caratteristiche che precedentemente richiedevano binding dinamico   deve essere eliminato o modificato. In particolare, l'istruzione with è   eliminato, e la capacità della funzione eval per manomettere la   ambiente del suo chiamante è fortemente limitata.

Uno dei vantaggi di rigoroso codice è che strumenti come YUI Compressor   può fare un lavoro migliore quando processing esso.

Presenza di variabili globali

JavaScript ha comportato variabili globali. Se   non si dichiara esplicitamente una variabile, una variabile globale è   implicitamente dichiarato per voi. Questo rende più facile per la programmazione   principianti perché possono trascurare alcuni di loro giornaliere di base   faccende. Ma rende la gestione dei programmi più grandi molto di più   difficile e degrada significativamente l'affidabilità. Quindi, in stretta   modalità, non sono più creati variabili globali implicite. Dovresti   dichiarare esplicitamente tutte le variabili.

globale di dispersione

Ci sono una serie di situazioni che potrebbero causare this   di essere vincolato all'oggetto globale. Ad esempio, se si dimentica di   fornire il prefisso new quando si chiama una funzione di costruzione, il   this del costruttore sarà legato in modo imprevisto all'oggetto globale, in modo da   invece di inizializzare un nuovo oggetto, esso sarà invece silenziosamente   manomissione variabili globali. In queste situazioni, la modalità rigorosa sarà   invece legarsi this a undefined, che farà sì che il costruttore di   un'eccezione invece, permettendo l'errore da rivelare molto   prima.

La mancata Noisy

JavaScript ha sempre avuto le proprietà di sola lettura, ma si   non poteva creare da soli fino Object.createProperty di ES5   Funzione esposto questa capacità. Se si è tentato di assegnare un valore   a una proprietà di sola lettura, fallirebbe in silenzio. L'assegnazione sarebbe   Non modificare il valore della proprietà, ma il programma procederà come   se avesse. Questo è un pericolo che può causare integrità programmi ai   entrare in uno stato incoerente. In modalità rigorosa, il tentativo di cambiare un   di sola lettura proprietà sarà un'eccezione.

ottale

L'ottale (o base 8) rappresentazione dei numeri era estremamente   utile quando si fa programmazione a livello di macchina su macchine la cui parola   dimensioni erano un multiplo di 3. È necessario ottale quando si lavora con il CDC   6600 mainframe, che aveva una dimensione di parola di 60 bit. Se si poteva leggere   ottale, si poteva guardare una parola come 20 cifre. Due cifre rappresentate   il codice operativo, ed un numero identificato uno degli 8 registri. Durante   lenta transizione da codici macchina a linguaggi di alto livello, è stato   pensato per essere utile fornire forme ottali nei linguaggi di programmazione.

In C, una rappresentazione estremamente sfavorevole di octalness era   selezionato: zero. Quindi, in C, 0100 significa 64, non 100, ed è un 08   errore, non 8. Ancor più, purtroppo, questo anacronismo è stata   copiato in quasi tutte le lingue moderne, tra cui JavaScript, dove   è utilizzato solo per creare errori. Essa non ha altro scopo. Quindi, in   modalità rigorosa, forme ottale non sono più ammessi.

Et cetera

La matrice pseudo argomentazioni diventa un po 'più   array come in ES5. In modalità rigorosa, perde la sua callee e caller   proprietà. In questo modo è possibile passare il vostro arguments a non attendibile   codice senza rinunciare a un sacco di contesto riservate. Anche il   struttura arguments di funzioni viene eliminato.

In modalità rigorosa, chiavi duplicate in un letterale funzione produrrà un   Errore di sintassi. Una funzione non può avere due parametri con lo stesso nome.   Una funzione non può avere una variabile con lo stesso nome di uno dei suoi   parametri. Una funzione non può delete sue variabili. Un tentativo di   delete una proprietà non configurabile ora genera un'eccezione. Primitivo   I valori non sono implicitamente avvolti.

Le parole riservate per le future versioni JavaScript

ECMAScript 5 aggiunge un elenco di parole riservate. Se li usate come variabili o argomenti, modalità rigorosa viene generato un errore. Le parole riservate sono:

implements, interface, let, package, private, protected, public, static, e yield

Bibliografia

Consiglio vivamente ogni sviluppatore per iniziare a utilizzare la modalità rigorosa ora. Ci sono abbastanza i browser che supportano in modo che la modalità rigorosa sarà legittimamente aiutarci a salvare da errori che non sapeva nemmeno erano in codice.

A quanto pare, nella fase iniziale, ci saranno errori che non abbiamo mai incontrato prima. Per ottenere il beneficio completo, abbiamo bisogno di fare corretta sperimentazione, dopo il passaggio alla modalità rigorosa per assicurarsi che abbiamo preso tutto. Sicuramente non ci limitiamo a buttare use strict nel nostro codice e assumiamo non ci sono errori. Così il tasso di abbandono è che è il momento di iniziare a utilizzare questo caratteristica del linguaggio incredibilmente utile di scrivere un codice migliore.

Ad esempio,

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

JSLint è un debugger scritto da Douglas Crockford. Basta incollare nello script, e sarà scansione rapidamente eventuali problemi evidenti e gli errori nel codice.

Vorrei offrire una risposta un po 'più fondata a complemento delle altre risposte. Speravo di modificare la risposta più popolare, ma non è riuscito. Ho cercato di renderlo il più ampia e completa come ho potuto.

È possibile consultare la MDN documentazione per ulteriori informazioni.

"use strict" direttiva introdotta nel ECMAScript 5.

direttive sono simili alle dichiarazioni, ma diverse.

use strict non contiene parole chiave: La direttiva è una semplice istruzione di espressione, che è costituito da una stringa speciale letterale (tra virgolette singole o doppie). motori JavaScript, che non implementano ECMAScript 5, semplicemente vedere una dichiarazione di espressione senza effetti collaterali. Si prevede che le future versioni di standard ECMAScript introducono use come una vera e propria parola d'ordine; le quotazioni sarebbero in tal modo diventare obsoleti.
use strict può essere utilizzato solo all'inizio di uno script o di una funzione, vale a dire che deve precedere ogni altro (reale) dichiarazione. Non deve essere la prima istruzione in uno script della funzione: può essere preceduta da altre espressioni dichiarazione che consistono di stringhe letterali (e implementazioni JavaScript li può trattare come direttive specifiche di implementazione). String affermazioni letterali, che seguono una prima dichiarazione reale (in uno script o funzione) sono semplici dichiarazioni di espressione. Gli interpreti non li devono interpretare le direttive e non hanno alcun effetto.

La direttiva use strict indica che il seguente codice (in uno script o una funzione) è rigoroso codice. Il codice nel più alto livello di uno script (codice che non è in funzione) è considerato rigido codice quando lo script contiene una direttiva use strict. Il contenuto di una funzione è considerato rigido codice quando la funzione stessa è definita in un rigoroso codice o quando la funzione contiene una direttiva use strict. Il codice che viene passato a un metodo di eval() è considerato rigido codice quando eval() è stato chiamato da un rigoroso codice o contiene la direttiva use strict stesso.

La modalità rigorosa di ECMAScript 5 è un sottoinsieme limitato del linguaggio JavaScript, che elimina i deficit rilevanti del linguaggio e le caratteristiche più rigoroso controllo degli errori e maggiore sicurezza. Di seguito sono elencate le differenze tra modalità rigorosa e modalità normale (di cui i primi tre sono particolarmente importanti):

Non è possibile utilizzare il with-dichiarazione in modalità rigorosa.
In modalità rigorosa tutte le variabili devono essere dichiarati: se si assegna un valore a un identificatore che non è stata dichiarata come variabile, funzione, parametro di funzione, catch-clausola di parametro o di proprietà del Object globale, allora si otterrà un ReferenceError. In modalità normale l'identificatore è implicitamente dichiarato come una variabile globale (come una proprietà della Object globale)
Nella modalità rigorosa la parola this ha il undefined valore funzioni che sono state invocate come funzioni (non come metodi). (Nella normale modalità this punta sempre al Object globale). Questa differenza può essere utilizzato per verificare se l'applicazione supporta la modalità rigorosa:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

Anche quando una funzione viene richiamata con call() o apply in modalità rigorosa, quindi this è esattamente il valore del primo argomento dell'invocazione call()or apply(). (Nella normale modalità null e undefined sono sostituiti dai Object globale e valori, che non sono oggetti, sono espressi in oggetti.)
In modalità rigorosa si otterrà un TypeError, quando si tenta di assegnare alle proprietà di sola lettura o per definire neproprietà W per un oggetto non estensibile. (In modalità normale sia semplicemente non riescono senza messaggio di errore.)
In modalità rigorosa, quando si passa il codice a eval(), non è possibile dichiarare o definire variabili o funzioni nel campo di applicazione del chiamante (come si può fare in modalità normale). Invece, un nuovo ambito è stato creato per eval() e le variabili e le funzioni sono in tale ambito. Tale ambito viene distrutto dopo eval() termine dell'esecuzione.
Nella modalità rigorosa gli argomenti oggetto di una funzione contiene una copia statica dei valori, che vengono passati alla funzione. In modalità normale l'argomento oggetto ha un comportamento piuttosto "magico". Gli elementi della matrice ei parametri funzione denominata riferimento sia lo stesso valore
In modalità rigorosa avrete una SyntaxError quando l'operatore delete è seguito da un identificatore qualificato non (una variabile, funzione o parametro di funzione). In modalità normale l'espressione delete non avrebbe fatto nulla ed è valutato a false.
In modalità rigorosa avrete una TypeError quando si tenta di eliminare una proprietà non configurabile. (In modalità normale il tentativo fallisce semplicemente e l'espressione delete viene valutata per false).
In modalità rigorosa è considerato un errore sintattico quando si tenta di definire le diverse proprietà con lo stesso nome per un oggetto letterale. (In modalità normale non c'è nessun errore.)
In modalità rigorosa viene considerato un errore sintattico quando una dichiarazione di funzione ha parametri multipli con lo stesso nome. (In modalità normale non c'è nessun errore.)
In letterali ottale modalità rigorosa non sono ammessi (questi sono letterali che iniziano con 0x. (In modalità normale alcune implementazioni Impedire letterali ottale.)
Nella modalità rigorosa l'identificatori eval e arguments sono trattati come parole chiave. Non è possibile modificare il loro valore, non può assegnare un valore a loro, e non è possibile utilizzare come nomi per le variabili, le funzioni, i parametri di funzione o gli identificatori di un blocco catch.
In modalità rigorosa sono più restrizioni alle possibilità di esaminare lo stack di chiamate. arguments.caller e arguments.callee causano un TypeError in una funzione in modalità rigorosa. Inoltre, alcune proprietà I dati del chiamante e gli argomenti delle funzioni in modalità rigorosa provocano una TypeError quando si tenta di leggerli.

I miei due centesimi:

Uno degli obiettivi della modalità rigorosa è quello di consentire una più rapida messa a punto di problemi. Esso aiuta gli sviluppatori lanciando un'eccezione quando certe cose sbagliate si verificano che può causare un comportamento silenzioso e strano della pagina web. Nel momento in cui usiamo use strict, il codice getterà gli errori che aiuta gli sviluppatori a risolvere il problema in anticipo.

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

Impedisce 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 in ambito globale che potrebbe essere accessibile tramite window.nameoftree. Quando implementiamo use strict il codice getterebbe di errore.

ReferenceError Uncaught: nameoftree non è definito

Esempio

Elimina dichiarazione with:

dichiarazioni with non possono essere ridotte di utilizzare strumenti come uglify-js . Sono anche deprecato e rimossi da future versioni JavaScript.

Esempio

Impedisce Duplicati:

Quando abbiamo proprietà duplicato, viene generata un'eccezione

SyntaxError Uncaught: proprietà data duplicata nell'oggetto letterale non consentito in modalità rigorosa

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

Ci sono pochi di più, ma ho bisogno di acquisire maggiori conoscenze su questo.

Se si utilizza un browser rilasciato nel corso dell'ultimo anno o giù di lì, allora è molto probabile che supporta la modalità Strict JavaScript. Solo i browser meno recenti in giro prima di ECMAScript 5 è diventato lo standard attuale non lo supportano.

Le virgolette attorno al comando assicurarsi che il codice continuerà a funzionare nei browser meno recenti come pure (anche se le cose che generano un errore di sintassi in modalità rigorosa generalmente giusta causa lo script per un malfunzionamento in alcuni difficili da rilevare modo in quelli più anziani i browser).

Quando si aggiunge "use strict";, i seguenti casi genereranno a Errore di sintassi prima che lo script venga eseguito:

Aprendo la strada alle future versioni di ECMAScript, utilizzando una delle nuove parole chiave riservate (in previsione ECMAScript 6): implements, interface, let, package, private, protected, public, static, E yield.
Dichiarare la funzione in blocchi
```
if(a<b){ function f(){} }
```
Sintassi ottale
```
var n = 023;
```

this puntare all'oggetto globale.

 function f() {
      "use strict";
      this.a = 1;
 };
 f();

Dichiarare due volte lo stesso nome per il nome di una proprietà in un oggetto letterale
```
 {a: 1, b: 3, a: 7} 
```
Questo non è più il caso in ECMAScript 6 (errore 1041128).
Dichiarare due argomenti di funzione con lo stesso nome funzione
```
f(a, b, b){}
```

Impostazione di un valore su una variabile non dichiarata

function f(x){
   "use strict";
   var a = 12;
   b = a + x*35; // error!
}
f();

Utilizzando delete su un nome di variabile delete myVariable;

Utilizzando eval O arguments come nome di argomento di variabile o funzione

"use strict";
arguments++;
var obj = { set p(arguments) { } };
try { } catch (arguments) { }
function arguments() { }

Fonti:

Transizione alla modalità rigorosa su MDN
Modalità rigorosa su MDN
La modalità rigorosa di JavaScript e perché dovresti usarla su Colin J.Blog di Ihrig (versione archiviata)

modalità Strict rende diversi cambiamenti alle normali semantica JavaScript:

elimina alcuni errori silenti JavaScript per cambiarli gettare errori.
corregge gli errori che rendono difficile per JavaScript motori per eseguire le ottimizzazioni.
vieta una sintassi probabilità di essere definito in futuro versioni di ECMAScript.

Per ulteriori informazioni vistit Strict Mode-Javascript

"use strict"; è un'assicurazione che programmatore non utilizzerà il allentato o le cattive caratteristiche di JavaScript. Si tratta di una guida, proprio come un righello vi aiuterà a fare linee rette. "Use strict" vi aiuterà a farlo "codifica dritto".

Quelli che preferiscono non usare i governanti di fare le loro linee di dritto di solito finiscono in quelle pagine per chiedere ad altri di eseguire il debug del codice.

Mi creda. L'overhead è trascurabile rispetto al codice mal progettato. Doug Crockford, che è stato un anziano sviluppatore JavaScript per diversi anni, ha un post molto interessante qui . Personalmente, mi piace tornare al suo sito tutto il tempo per assicurarsi che io non dimentico la mia buona pratica.

La moderna prassi JavaScript deve sempre evocare la "use strict"; pragma. L'unico motivo che il Gruppo ECMA ha fatto la modalità "Strict" opzionale è quello di permettere programmatori meno esperti l'accesso a Javascript e dare poi il tempo per adeguarsi alle nuove e più sicure pratiche di programmazione.

Tra cui use strict all'inizio di tutti i vostri file JavaScript sensibili da questo punto è un piccolo modo per essere una migliore programmatore JavaScript ed evitare variabili casuali diventando globale e le cose cambiano in silenzio.

Citando w3schools :

Il "use strict" direttiva

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

Non è una dichiarazione, ma espressioni letterali, ignorato dai precedenti   versioni di JavaScript.

Lo scopo di "use strict" sta ad indicare che il codice dovrebbe essere   eseguito in "modalità rigorosa".

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

Modalità Perché rigorosa?

modalità Strict rende più facile scrivere "sicuro" JavaScript.

cambia modalità rigorosa precedentemente accettate "cattivo sintassi" in veri e propri errori.

A titolo di esempio, nel normale JavaScript, errori di digitazione di un nome di variabile crea   una nuova variabile globale. In modalità rigorosa, ciò genera un errore,   rendendo impossibile creare accidentalmente una variabile globale.

Nel normale JavaScript, uno sviluppatore non ricevere alcun riscontro positivo errore   l'assegnazione di valori alle proprietà non scrivibili.

In modalità rigorosa, qualsiasi incarico a una proprietà non-scrivibile, una   getter struttura per soli, un non-esistente di proprietà, un non-esistente   variabile o un oggetto non esistente, verrà generato 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 per funzionare in modalità rigorosa , che in pratica significa tutto deve essere definito prima dell'uso. Il motivo principale per utilizzare la modalità rigorosa è quello di evitare accidentali usi globali di metodi non definiti.

Anche in modalità rigorosa, le cose più veloci, alcuni avvisi o avvisi silenziosi gettano errori fatali, è meglio utilizzare sempre per fare un codice più ordinato.

"use strict" è ampiamente necessaria per essere utilizzato in ECMA5, in ECMA6 fa parte del JavaScript di default , in modo che non ha bisogno di essere aggiunto se si sta utilizzando ES6.

Ecco le dichiarazioni e gli esempi da MDN:

Il "use strict" direttiva
Il "use strict" direttiva è di nuovo in   JavaScript 1.8.5 (ECMAScript versione 5). E non è una dichiarazione, ma un   espressioni letterali, ignorato dalle versioni precedenti di JavaScript. Il   scopo di "use strict" sta ad indicare che il codice dovrebbe essere   eseguito in "strict mode". Con la modalità rigorosa, non è possibile, per esempio,   utilizzare le variabili non dichiarate.

Esempi di utilizzo "use strict":
  modalità rigorosa per le funzioni: Allo stesso modo, per invocare modalità rigorosa per un   la funzione, mettere la dichiarazione esatta "use strict"; (O 'use strict';) in   il corpo della funzione prima di qualsiasi 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) intero script modalità rigorosa

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

3) Assegnazione a un non-scrivibile globale

'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

È possibile leggere di più su MDN .

C'è una bella chiacchierata da alcune persone che erano parte del comitato ECMAScript: Modifiche a JavaScript, parte 1 :. ECMAScript 5" circa l'uso come incrementale dello switch "use strict" permette implementatori JavaScript per ripulire un sacco di caratteristiche pericolose di JavaScript senza improvvisamente rompere ogni sito web in tutto il mondo

Naturalmente si parla anche di solo ciò che un sacco di quei ineleganti sono (erano) e come ECMAScript 5 li fissa.

Piccoli esempi da confrontare:

Non rigorosa modalità:

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

modalità Strict:

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

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

Non rigorosa modalità:

String.prototype.test = function () {
  console.log(typeof this === 'string');
};

'a'.test();

// output
// false

String.prototype.test = function () {
  'use strict';
  
  console.log(typeof this === 'string');
};

'a'.test();

// output
// true

Si noti che use strict è stato introdotto nel EcmaScript 5 ed è stato mantenuto da allora.

Di seguito sono elencate le condizioni per attivare la modalità rigorosa in ES6 e ES7 :

Global code è severo codice di modalità se si inizia con una direttiva Prologo che contiene una direttiva Strict Usa (vedi 14.1.1).

codice del modulo è sempre rigoroso codice modalità.

Tutte le parti di un ClassDeclaration o ClassExpression sono rigido codice modalità.

codice Eval è severo codice di modalità se si inizia con una direttiva Prologo che contiene una direttiva rigorosa Usare o se la chiamata a eval è un'eval diretta (vedi 12.3.4.1) che è contenuta in stretta codice modalità.

Codice funzione è severo codice di modalità se l'associato FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, o ArrowFunction è contenuto nel rigoroso codice di modalità o se il codice che produce il valore del [[funzione ECMAScriptCode]] slot interno inizia con una direttiva Prologo che contiene una direttiva rigorosa Usa.

Codice funzione che viene fornito come gli argomenti della funzione built-in e costruttori Generator è rigido codice modalità se l'ultimo argomento è una stringa che quando elaborato è un FunctionBody che inizia con una direttiva Prologo che contiene una direttiva rigorosa Usa.

I motivi principali per cui gli sviluppatori devono utilizzare "use strict" sono:

Impedisce dichiarazione accidentale di "use strict()" variables.Using globale farà in modo che le variabili sono dichiarate con var prima dell'uso. Ad esempio:

function useStrictDemo(){
 'use strict';
 //works fine
 var a = 'No Problem';

 //does not work fine and throws error
 k = "problem"

 //even this will throw error
 someObject = {'problem': 'lot of problem'};
}

NB:. La direttiva "use strict" è riconosciuta solo all'inizio di uno script o una funzione

Il "arguments" stringa non può essere utilizzata come una variabile:

"use strict";
var arguments = 3.14;    // This will cause an error

Sarà limitare l'uso di parole chiave come variabili. Cercando di usarli getterà errori.

In breve renderà il vostro codice meno soggetta ad errori e, a sua volta vi farà scrivere buon codice.

Per saperne di più su di esso è possibile consultare qui .

"use strict"; è lo sforzo per rendere ECMA JavaScript un po 'più robusto. Essa porta in JS tentativo di rendere almeno un po ' "severe" (altre lingue implementare regole severe a partire dagli anni '90). In realtà "forze" sviluppatori JavaScript di seguire una sorta di codifica migliori pratiche. Eppure, JavaScript è molto fragile. Non esiste una cosa come variabili digitati, i metodi digitati, ecc Consiglio vivamente sviluppatori JavaScript di imparare una lingua più robusta come Java o ActionScript3, e implementare la stessa best practice nel codice JavaScript, funzionerà meglio e più facile da mettere a punto.

La modalità “rigorosa” di JavaScript è stata introdotta in ECMAScript 5.

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

Scrivere "use strict"; Nella parte superiore del file JS accende il rigoroso controllo della sintassi.Svolge per noi i seguenti compiti:

mostra un errore se si tenta di assegnare a una variabile non dichiarata
ti impedisce di sovrascrivere le librerie di sistema JS chiave
vieta alcune funzionalità linguistiche non sicure o soggette a errori

use strict funziona anche all'interno delle singole funzioni.È sempre una pratica migliore includere use strict nel tuo codice

Problema di compatibilità del browser:Le direttive "use" sono pensate per essere compatibili con le versioni precedenti.I browser che non li supportano vedranno semplicemente una stringa letterale a cui non viene fatto ulteriore riferimento.Quindi, lo supereranno e andranno avanti.

use strict è un modo per rendere il codice più sicuro, perché non è possibile utilizzare le funzioni pericolose che possono non funzionare come si expect.and come è stato writed prima che rende il codice più severo.

Utilizzare Strict viene utilizzato per mostrare gli errori più comuni e ripetute in modo che sia gestita in modo diverso, e cambia il modo in java script viene eseguito, tali cambiamenti sono:

Impedisce globali accidentali
Non ci sono duplicati
Elimina con
Elimina questa coercizione
Safer eval ()
Gli errori per immutabili

si può anche leggere questo articolo per i dettagli

Normalmente, JavaScript non segue regole rigide, aumentando così le possibilità di errori. Dopo aver utilizzato "use strict", il codice JavaScript deve seguire rigida serie di regole come in altri linguaggi di programmazione come l'uso di Terminator, dichiarazione prima inizializzazione, ecc

Se si utilizza "use strict", il codice dovrebbe essere scritto seguendo una rigida serie di regole, e quindi diminuendo la probabilità di errori e ambiguità.

"use strict"; Definisce che il codice JavaScript deve essere eseguito in "Strict mode".

Il "use strict" direttiva era nuovo in ECMAScript versione 5.
Non è una dichiarazione, ma espressioni letterali, ignorato dai precedenti versioni di JavaScript.
Lo scopo di "use strict" sta ad indicare che il codice dovrebbe essere eseguito in "modalità rigorosa".
Con la modalità rigorosa, non è possibile, ad esempio, utilizzare le variabili non dichiarate.

Tutti i browser moderni supportano "usano rigorosa" ad eccezione di Internet Explorer 9 e inferiore .

Svantaggi

Se uno sviluppatore utilizza una libreria che era in modalità rigorosa, ma lo sviluppatore è stato utilizzato per lavorare in modalità normale, si potrebbe definire alcune azioni sulla libreria che non avrebbe funzionato come previsto.

Peggio ancora, dal momento che lo sviluppatore è in modalità normale, non hanno i vantaggi di errori in più di essere gettati, quindi l'errore potrebbe non riuscire in silenzio.

Inoltre, come riportato sopra, la modalità rigorosa vi impedisce di fare certe cose.

In genere la gente pensa che non si dovrebbe usare queste cose, in primo luogo, ma alcuni sviluppatori non piace il vincolo e si desidera utilizzare tutte le funzionalità del linguaggio.

Ad esempio di base e di riferimento passare attraverso:

https://www.tutorialsteacher.com/javascript/javascript-strict

Modalità rigorosa può prevenire perdite di memoria.

Si prega di verificare la funzione qui sotto scritto in modo non rigoroso:

function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); // Stack Overflow

In questa funzione, stiamo usando una variabile denominata name all'interno della funzione. Internamente, il compilatore prima verificare se c'è qualche variabile dichiarata con quel particolare nome in quel particolare ambito delle funzioni. Poiché il compilatore inteso che non v'è tale variabile, controllerà nell'ambito esterno. Nel nostro caso, è l'ambito globale. Anche in questo caso, il compilatore capito che non v'è inoltre alcuna variabile dichiarata nello spazio globale con quel nome, così crea un tale variabile per noi nello spazio globale. Concettualmente, questa variabile verrà creata nell'ambito globale e sarà disponibile in tutta l'applicazione.

Un altro scenario è che, per esempio, la variabile è dichiarata in una funzione bambino. In tal caso, il compilatore verifica la validità di tale variabile nell'ambito esterno, cioè, la funzione principale. Solo allora sarà il check-in spazio globale e creare una variabile per noi lì. Ciò significa che ulteriori controlli devono essere fatte. Questo influenzerà le prestazioni dell'applicazione.

Ora scriviamo la stessa funzione in modalità rigorosa.

"use strict"
function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name);

Ci metteremo il seguente errore.

Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5

Qui, il compilatore genera l'errore di riferimento. In modalità rigorosa, il compilatore non ci permettono di utilizzare la variabile senza dichiararlo. Quindi, le perdite di memoria possono essere prevenute. Inoltre, siamo in grado di scrivere codice più ottimizzato.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow

Cosa fa "use strict" in JavaScript e qual è il ragionamento alla base?

Elenco delle funzionalità (non esaustivo)

Uso 'use strict'; non improvvisamente rendere il codice migliore.

Dove dovrei usare 'use strict';?

Come si usa la modalità rigorosa?

Quali cose sono vietate in modalità rigorosa?

Ambito

Presenza di variabili globali

globale di dispersione

La mancata Noisy

ottale

Et cetera

Le parole riservate per le future versioni JavaScript

Bibliografia

Il "use strict" direttiva

Modalità Perché rigorosa?

Uso `'use strict';` non improvvisamente rendere il codice migliore.

Dove dovrei usare `'use strict';`?