Ho controllato il riferimento JavaScript su Mozilla Developer Network e mi sono imbattuto in qualcosa chiamato "strict mode". L'ho letto e ho difficoltà a capire cosa fa. Qualcuno può spiegare brevemente (in generale) quale sia il suo scopo e come sia utile?cos'è la "modalità rigorosa" e come viene utilizzata?
Il suo scopo principale è quello di fare più controllo.
Basta aggiungere "use strict"; nella parte superiore del codice, prima di qualsiasi altra cosa.
Ad esempio, blah = 33; è JavaScript valido. Significa che crei una variabile completamente globale blah.
Ma in modalità rigorosa è un errore perché non hai usato la parola chiave "var" per dichiarare la variabile.
maggior parte del tempo non si intende creare variabili globali nel bel mezzo di un certo margine arbitrario, quindi la maggior parte del tempo che blah = 33 è scritto è un errore e il programmatore non ha in realtà vuole che essere una variabile globale, intendevano scrivere var blah = 33.
Analogamente, non consente molte cose che sono tecnicamente valide. NaN = "lol" non produce un errore. Inoltre non cambia il valore di NaN. usando rigorosamente questo (e simili dichiarazioni strane) produci errori. La maggior parte della gente apprezza questo perché non c'è motivo di scrivere mai NaN = "lol", quindi c'era probabilmente un refuso.
questo è un duplicato esatto della documentazione sopra a MDN – nkcmr
Che non capisci circa la sua utilità, allora? Ha lo scopo di aiutare lo sviluppo catturando cose che sono errori validi ma più verosimili. –
modalità Strict è stato aggiunto in modo che ci sarebbe un sottoinsieme facilmente statico-analizzabile di EcmaScript che sarebbe un buon obiettivo per le future versioni del linguaggio. La modalità rigorosa è stata progettata anche nella speranza che gli sviluppatori che si limitano alla modalità rigorosa farebbero meno errori e che i bug che fanno si manifesterebbero in modi più ovvi.
Harmony, che si spera diventino la prossima versione principale di EcmaScript che verrà costruita su ES5 strict.
L'armonia si basa sulla modalità rigorosa ES5 per evitare troppe modalità.
Alcuni altri esperimenti linguistici dipendono anche dalla modalità rigorosa. SES dipende dall'analizzabilità della modalità rigorosa ES5.
SES (ECMAScript sicuro) Design Esperimento
progettare un oggetto Capability linguaggio di programmazione per la rimozione o la riparazione di funzionalità in ES5/Strict.
Ci dovrebbe essere una traduzione diretta da SES a ES5/Strict.
Annex C dello standard spiega le differenze tra modalità rigorosa e modalità normale.
La rigida restrizione modalità e le eccezioni
- gli identificatori "attrezzi", "interfaccia", "lasciare", "pacchetto", "privato", "protetto", "pubblico", "statici "e" rendimento "sono classificati come token FutureReservedWord all'interno di un codice di modalità rigoroso. (7.6.12 [?]).
- Un'implementazione conforme, durante l'elaborazione del codice della modalità rigorosa, potrebbe non estendere la sintassi di NumericLiteral (7.8.3) per includere OctalIntegerLiteral come descritto in B.1.1.
- Un'implementazione conforme, durante l'elaborazione del codice di modalità rigoroso (vedere 10.1.1), non può estendere la sintassi di EscapeSequence per includere OctalEscapeSequence come descritto in B.1.2.
- L'assegnazione a un identificatore non dichiarato o a un riferimento altrimenti non risolvibile non crea una proprietà nell'oggetto globale. Quando si verifica un semplice assegnamento all'interno di un codice di modalità rigoroso, il suo LeftHandSide non deve valutare un riferimento irrisolvibile. Se viene generata un'eccezione ReferenceError (8.7.2). Anche LeftHandSide potrebbe non essere un riferimento a una proprietà dati con il valore dell'attributo {[[Writable]]: false}, a una proprietà accessor con il valore dell'attributo {[[Set]]: indefinito}, né a un inesistente proprietà di un oggetto la cui proprietà interna [[Extensible]] ha il valore false. In questi casi viene generata un'eccezione TypeError (11.13.1).
- L'identificativo eval o gli argomenti non possono apparire come LeftHandSideExpression di un operatore di Assegnazione (11.13) o di PostfixExpression (11.3) o come UnaryExpression su cui opera un Prefix Increment (11.4.4) o un Prefix Decrement (11.4. 5) operatore. Gli oggetti degli argomenti per le funzioni in modalità rigorosa definiscono proprietà accessorie non configurabili denominate "chiamante" e "callee" che generano un'eccezione TypeError all'accesso (10.6).
- Gli oggetti degli argomenti per le funzioni in modalità rigorosa non condividono dinamicamente i valori delle proprietà indicizzate con l'array con i corrispondenti binding di parametri formali delle loro funzioni. (10.6). Per le funzioni in modalità rigorosa, se viene creato un oggetto arguments il binding degli argomenti dell'identificatore locale all'oggetto arguments è immutabile e quindi potrebbe non essere la destinazione di un'espressione di assegnazione. (10.5).
- È un errore SyntaxError se il codice della modalità strict contiene un ObjectLiteral con più di una definizione di qualsiasi proprietà data (11.1.5). È un errore SyntaxError se l'identificatore "eval" o l'identificatore "argomenti" si verifica come identificativo in un oggetto PropertySetParameterList di un oggetto PropertyAssignment contenuto nel codice strict o se il suo FunctionBody è un codice rigoroso (11.1.5).
- Il codice eval in modalità rigorosa non può istanziare variabili o funzioni nell'ambiente variabile del chiamante per la valutazione. Invece, viene creato un nuovo ambiente variabile e tale ambiente viene utilizzato per l'istanza del binding di dichiarazione per il codice eval (10.4.2).
- Se questo viene valutato all'interno di un codice di modalità rigoroso, il valore non viene forzato a un oggetto. Un valore null o undefined non viene convertito nell'oggetto globale e i valori primitivi non vengono convertiti in oggetti wrapper. Il valore passato tramite una chiamata di funzione (comprese le chiamate effettuate usando Function.prototype.apply e Function.prototype.call) non costringe il valore passato a questo oggetto (10.4.3, 11.1.1, 15.3.4.3, 15.3. 4.4).
- Quando un operatore di eliminazione si verifica all'interno del codice di modalità rigoroso, viene generato un SyntaxError se la sua espressione unaria è un riferimento diretto a una variabile, un argomento di funzione o un nome di funzione (11.4.1).
- Quando un operatore di eliminazione si verifica all'interno del codice della modalità rigorosa, viene generato un errore TypeE se la proprietà da eliminare ha l'attributo {[[Configurable]]: false} (11.4.1). È un errore SyntaxError se una VariableDeclaration o VariableDeclarationNoIn si verifica all'interno di un codice strict e il suo Identificatore è eval o argomenti (12.2.1).
- Il codice della modalità rigorosa potrebbe non includere un WithStatement. L'occorrenza di un WithStatement in tale contesto è un SyntaxError (12.10).
- Si tratta di uno SyntaxError se un TryStatement con una cattura si verifica all'interno rigoroso codice e l'identificatore della produzione Catch è eval o argomenti (12.14.1)
- Si tratta di uno SyntaxError se l'eval identificatore o argomenti appare all'interno di un FormalParameterList di una modalità strict FunctionDeclaration o FunctionExpression (13.1)
- Una funzione di modalità rigorosa potrebbe non avere due o più parametri formali con lo stesso nome. Un tentativo di creare tale funzione utilizzando un costruttore FunctionDeclaration, FunctionExpression o Function è un SyntaxError (13.1, 15.3.2).
- Un'implementazione non può estendere, oltre a quella definita in questa specifica, significati all'interno delle funzioni di modalità rigorose di proprietà denominate chiamante o argomenti di istanze di funzione. Il codice ECMAScript non può creare o modificare proprietà con questi nomi su oggetti funzione che corrispondono a funzioni in modalità rigorosa (10.6, 13.2, 15.3.4.5.3).
- È un errore SyntaxError da utilizzare all'interno del codice della modalità strict gli identificatori eval o argomenti come Identificatore di una FunctionDeclaration o FunctionExpression o come un nome di parametro formale (13.1). Il tentativo di definire dinamicamente una funzione di modalità così rigorosa utilizzando la funzione Costruttore (15.3.2) genererà un'eccezione SyntaxError.
Un aspetto della modalità rigorosa non già menzionato nella risposta di Simon è che la modalità rigorosa imposta this a undefined nelle funzioni invocate attraverso la funzione di invocazione.
le cose così come questo
function Obj() {
this.a = 12;
this.b = "a";
this.privilegedMethod = function() {
this.a++;
privateMethod();
};
function privateMethod() {
this.b = "foo";
}
}
causerà un errore quando si chiama privateMethod (perché non si può aggiungere un alloggio ai undefined), piuttosto che aggiungere inutilmente una proprietà b all'oggetto globale.
sì, è necessario aggiungere 'privateMethod.bind (this)();' e chiamare con 'new' [' jsbin.com'] (https://jsbin.com/foyomo/edit?html,js,console) – hlcs
La modalità rigorosa apporta numerose modifiche alla normale semantica di JavaScript.
modalità rigorosa elimina alcuni errori JavaScript JavaScript modificandoli per generare errori.
modalità rigorosa risolve errori che rendono difficile per i motori JavaScript eseguire ottimizzazioni.
modalità rigorosa proibisce alcune sintassi che potrebbero essere definite nelle versioni future di ECMAScript.
ECMAScript5 introduce alcuni nuovi oggetti e proprietà e anche la cosiddetta "strict mode".
La modalità rigorosa è un sottoinsieme della lingua che esclude le funzionalità deprecate.La modalità strict è facoltativa e non è necessaria, il che significa che se vuoi che il tuo codice funzioni nella modalità rigorosa , dichiari l'intenzione usando (una volta per funzione, o una volta per l'intero programma ) la seguente stringa:
"use strict";
ECMAScript 5 ha introdotto il concetto di rigorosa modalità.
Invocare la modalità rigorosa in codice
modalità Strict vale per intere script o per singola funzione. Non si applica alla dichiarazione di blocco racchiusa tra parentesi graffe, il tentativo di applicarlo a tali contesti non fa nulla.
intero script:
diciamo che stiamo creando app.js quindi l'aggiunta di primo script utilizzo dichiarazione imporrà modalità rigorosa per intero codice.
// app.js whole script in strict mode syntax
“use strict”;
// Now you can start writing your code
modalità Strict per la funzione:
per invocare modalità rigorosa per una funzione, mettere la dichiarazione esatta “use strict”; all'inizio del corpo della funzione prima di ogni altra affermazione.
function yourFunc(){
"use strict";
// Your function code logic
}
La modalità rigorosa incorpora diverse modifiche alla normale semantica di JavaScript. La prima modalità rigorosa elimina alcuni errori JavaScript JavaScript modificandoli per generare errori.
Per esempio: codice utilizzando la modalità Strict
Nel esempio di codice di cui sopra senza utilizzare la modalità rigorosa nel codice non viene generato un errore. Mentre stiamo accedendo alla variabile x senza dichiararla. Quindi, in modalità rigorosa, l'accesso alla variabile non dichiarata genera un errore.
Ora proviamo ad accedere alla variabile x senza dichiararla senza la modalità rigorosa.
(function(){
x = 3;
})();
// Will not throw an error
vantaggio di utilizzare modalità rigorosa:
2017 e alla fine ho trovato la documentazione:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
modalità Strict è un modo per optare per una variante ristretta di JavaScript. La modalità rigorosa non è solo un sottoinsieme: ha intenzionalmente una diversa semantica dal codice normale. I browser che non supportano la modalità rigorosa eseguiranno il codice di modalità rigoroso con comportamento diverso dai browser che eseguono, pertanto non si basa sulla modalità rigorosa senza test delle funzionalità per il supporto degli aspetti rilevanti della modalità rigorosa . Codice di modalità rigoroso e modalità non rigida Il codice può coesistere, pertanto gli script possono attivare la modalità rigorosa in modo incrementale.
modalità Strict rende diverse modifiche alla normale semantica JavaScript. Innanzitutto, la modalità rigorosa elimina alcuni errori JavaScript JavaScript di modificandoli per generare errori. In secondo luogo, la modalità rigorosa corregge gli errori che rendono il difficile per i motori JavaScript eseguire le ottimizzazioni: il codice della modalità rigorosa può talvolta essere eseguito più velocemente del codice identico che non è una modalità rigorosa. In terzo luogo, la modalità rigorosa proibisce che alcune sintassi possano essere definite nelle versioni future di ECMAScript.
correlati: http://stackoverflow.com/q/1335851/1461424 – Krumia