JavaScript usa rigorosamente
"use strict";
Definisce che il codice JavaScript deve essere eseguito in "modalità rigorosa".
La direttiva "uso rigoroso".
La "use strict"
direttiva era nuova in ECMAScript versione 5.
Non è un'istruzione, ma un'espressione letterale, ignorata dalle versioni precedenti di JavaScript.
Lo scopo di "use strict"
è indicare che il codice deve essere eseguito in "modalità rigorosa".
Con la modalità rigorosa, ad esempio, non è possibile utilizzare variabili non dichiarate.
Tutti i browser moderni supportano "use strict" tranne Internet Explorer 9 e versioni precedenti:
Directive | |||||
---|---|---|---|---|---|
"use strict" | 13.0 | 10.0 | 4.0 | 6.0 | 12.1 |
I numeri nella tabella specificano la prima versione del browser che supporta completamente la direttiva.
Puoi usare la modalità rigorosa in tutti i tuoi programmi. Ti aiuta a scrivere codice più pulito, ad esempio impedendoti di utilizzare variabili non dichiarate.
"use strict"
è solo una stringa, quindi IE 9 non genererà un errore anche se non lo comprende.
Dichiarazione della modalità rigorosa
La modalità Strict viene dichiarata aggiungendo "use strict"; all'inizio di uno script o di una funzione.
Dichiarato all'inizio di uno script, ha un ambito globale (tutto il codice nello script verrà eseguito in modalità rigorosa):
Esempio
"use strict";
x = 3.14; // This will cause an error
because x is not declared
Esempio
"use strict";
myFunction();
function myFunction() {
y = 3.14; // This will also cause an error
because y is not declared
}
Dichiarato all'interno di una funzione, ha ambito locale (solo il codice all'interno della funzione è in modalità rigorosa):
x = 3.14; // This will not cause an error.
myFunction();
function
myFunction() {
"use strict";
y = 3.14; // This will cause an error
}
L'"uso rigoroso"; Sintassi
La sintassi, per dichiarare la modalità rigorosa, è stata progettata per essere compatibile con le versioni precedenti di JavaScript.
La compilazione di un valore letterale numerico (4 + 5;) o di una stringa letterale ("John Doe";) in un programma JavaScript non ha effetti collaterali. Si compila semplicemente in una variabile non esistente e muore.
Quindi "use strict";
conta solo per i nuovi compilatori che "capiscono" il significato di esso.
Perché la modalità rigorosa?
La modalità Strict semplifica la scrittura di JavaScript "sicuro".
La modalità Strict cambia la "sintassi errata" precedentemente accettata in errori reali.
Ad esempio, in JavaScript normale, digitando in modo errato il nome di una variabile si crea una nuova variabile globale. In modalità rigorosa, questo genererà un errore, rendendo impossibile la creazione accidentale di una variabile globale.
In JavaScript normale, uno sviluppatore non riceverà alcun feedback di errore durante l'assegnazione di valori a proprietà non scrivibili.
In modalità rigorosa, qualsiasi assegnazione a una proprietà non scrivibile, una proprietà solo getter, una proprietà non esistente, una variabile non esistente o un oggetto non esistente genererà un errore.
Non consentito in modalità rigorosa
L'utilizzo di una variabile, senza dichiararla, non è consentito:
"use strict";
x = 3.14; // This will cause an error
Anche gli oggetti sono variabili.
L'utilizzo di un oggetto, senza dichiararlo, non è consentito:
"use strict";
x = {p1:10, p2:20}; // This will cause an error
L'eliminazione di una variabile (o oggetto) non è consentita.
"use strict";
let x = 3.14;
delete x; // This
will cause an error
L'eliminazione di una funzione non è consentita.
"use strict";
function x(p1, p2) {};
delete x;
// This will cause an error
Non è consentito duplicare il nome di un parametro:
"use strict";
function x(p1, p1) {}; // This will cause an error
I letterali numerici ottali non sono consentiti:
"use strict";
let x = 010; // This
will cause an error
I caratteri di escape ottali non sono consentiti:
"use strict";
let x = "\010"; // This will cause an error
La scrittura su una proprietà di sola lettura non è consentita:
"use strict";
const obj = {};
Object.defineProperty(obj, "x", {value:0, writable:false});
obj.x = 3.14; // This
will cause an error
Non è consentito scrivere su una proprietà get-only:
"use strict";
const obj = {get x()
{return 0} };
obj.x = 3.14; // This
will cause an error
L'eliminazione di una proprietà non eliminabile non è consentita:
"use strict";
delete Object.prototype; // This will cause an error
La parola eval
non può essere utilizzata come variabile:
"use strict";
let eval = 3.14; // This will cause an error
La parola arguments
non può essere utilizzata come variabile:
"use strict";
let arguments = 3.14; // This will cause an error
La with
dichiarazione non è consentita:
"use strict";
with (Math){x = cos(2)}; // This will cause an error
Per motivi di sicurezza, eval()
non è consentito creare variabili nell'ambito da cui è stato chiamato:
"use strict";
eval ("let x = 2");
alert (x); // This
will cause an error
La this
parola chiave in functions si comporta in modo diverso in modalità rigorosa.
La this
parola chiave si riferisce all'oggetto che ha chiamato la funzione.
Se l'oggetto non è specificato, le funzioni in modalità rigorosa verranno restituite undefined
e le funzioni in modalità normale restituiranno l'oggetto globale (finestra):
"use strict";
function myFunction() {
alert(this); // will alert "undefined"
}
myFunction();
Prova futura!
Le parole chiave riservate alle versioni future di JavaScript NON possono essere utilizzate come nomi di variabili in modalità rigorosa.
Questi sono:
- implementa
- interfaccia
- permettere
- pacchetto
- privato
- protetto
- pubblico
- statico
- prodotto
"use strict";
let public = 1500; // This will cause an error
Attento!
La direttiva "use strict" viene riconosciuta solo all'inizio di uno script o di una funzione.