"use strict"; Definisce che il codice JavaScript deve essere eseguito in “strict mode”.
La direttiva “use strict”
La direttiva "use strict" era nuova nella versione 5 di ECMAScript.
Non è una dichiarazione, ma un’espressione letterale, ignorata dalle versioni precedenti di JavaScript.
Lo scopo di "use strict" è quello di indicare che il codice deve essere eseguito in “strict mode”.
Con strict mode, non si possono, per esempio, usare variabili non dichiarate.
Tutti i browser moderni supportano “use strict” tranne Internet Explorer 9 e inferiore:
| Direttiva | |||||
|---|---|---|---|---|---|
| “use strict” | 13.0 | 10.0 | 4.0 | 6.0 | 12.1 |
I numeri nella tabella specificano la prima versione del browser che supporta pienamente la direttiva.
È possibile utilizzare la modalità strict in tutti i programmi. Ti aiuta a scrivere un codice più pulito, impedendoti di usare variabili non dichiarate.
"use strict" è solo una stringa, quindi IE 9 non darà un errore anche se non la capisce.
Dichiarare la modalità strict
La modalità strict viene dichiarata aggiungendo “use strict”; all’inizio di uno script o di una funzione.
Dichiarata all’inizio di uno script, ha portata globale (tutto il codice nello script verrà eseguito in modalità strict):
esempio
x = 3.14; // Questo causerà un errore perché x non è dichiarato
Prova tu stesso ”
Esempio
myFunction();
funzione myFunction() {
y = 3.14; // Anche questo causerà un errore perché y non è dichiarato
}
Provate voi stessi ”
Dichiarato all’interno di una funzione, ha scope locale (solo il codice all’interno della funzione è in modalità strict):
myFunction();
funzione myFunction() {
“use strict”;
y = 3.14; // Questo causerà un errore
}
Prova tu stesso ”
La sintassi “use strict”;
La sintassi, per dichiarare la modalità strict, è stata progettata per essere compatibile con le vecchie versioni di JavaScript.
Compilare un letterale numerico (4 + 5;) o un letterale di stringa (“John Doe”;) in un programma JavaScript non ha effetti collaterali. Semplicemente compila in una variabile non esistente e muore.
Quindi "use strict"; conta solo per i nuovi compilatori che ne “capiscono” il significato.
Perché la modalità rigorosa?
La modalità rigorosa rende più facile scrivere JavaScript “sicuro”.
La modalità rigorosa cambia la “cattiva sintassi” precedentemente accettata in errori reali.
Per esempio, in JavaScript normale, sbagliare il nome di una variabile crea una nuova variabile globale. In modalità rigorosa, questo lancerà un errore, rendendo impossibile creare accidentalmente una variabile globale.
In JavaScript normale, uno sviluppatore non riceverà alcun feedback di errore assegnando valori a proprietà non scrivibili.
In modalità strict, qualsiasi assegnazione ad una proprietà non scrivibile, una proprietà getter-only, una proprietà non esistente, una variabile non esistente, o un oggetto non esistente, darà un errore.
Non è permesso in modalità Strict
Utilizzare una variabile, senza dichiararla, non è permesso:
x = 3.14; // Questo causerà un errore
Prova tu stesso”
Anche gli oggetti sono variabili.
Utilizzare un oggetto, senza dichiararlo, non è permesso:
x = {p1:10, p2:20}; // Questo causerà un errore
Prova tu stesso”
Eliminare una variabile (o un oggetto) non è permesso.
var x = 3.14;
delete x; // Questo causerà un errore
Prova tu stesso “
Eliminare una funzione non è permesso.
funzione x(p1, p2) {};
cancella x; // Questo causerà un errore
Prova tu stesso “
La duplicazione del nome di un parametro non è permessa:
funzione x(p1, p1) {}; // Questo causerà un errore
Prova tu stesso “
I letterali numerici ottali non sono ammessi:
var x = 010; // Questo causerà un errore
Prova tu stesso “
I caratteri di escape ottali non sono ammessi:
var x = “\010”; // Questo causerà un errore
Prova tu stesso”
La scrittura di una proprietà di sola lettura non è permessa:
var obj = {};
Object.defineProperty(obj, “x”, {value:0, writable:false});
obj.x = 3.14; // Questo causerà un errore
Prova tu stesso”
Scrivere su una proprietà get-only non è permesso:
var obj = {get x() {return 0} };
obj.x = 3.14; // Questo causerà un errore
Prova da solo”
L’eliminazione di una proprietà undeletable non è consentita:
delete Object.prototype; // Questo causerà un errore
Prova tu stesso”
La parola eval non può essere usata come variabile:
var eval = 3.14; // Questo causerà un errore
Prova tu stesso”
La parola arguments non può essere usata come variabile:
var arguments = 3.14; // Questo causerà un errore
Prova tu stesso “
L’istruzione with non è consentita:
with (Math){x = cos(2)}; // Questo causerà un errore
Prova tu stesso”
Per ragioni di sicurezza, eval() non è permesso creare variabili nello scope da cui è stato chiamato:
eval (“var x = 2”);
alert (x); // Questo causerà un errore
Prova tu stesso”
La parola chiave this nelle funzioni si comporta diversamente in modalità strict.
La parola chiave this si riferisce all’oggetto che ha chiamato la funzione.
Se l’oggetto non è specificato, le funzioni in modalità strict restituiranno undefined e le funzioni in modalità normale restituiranno l’oggetto globale (window):
funzione myFunction() {
alert(this); // avviserà “undefined”
}
myFunction();
Prova tu stesso”
Prova futura!
Le parole chiave riservate alle future versioni di JavaScript NON possono essere usate come nomi di variabili in modalità strict.
Queste sono:
- implements
- interface
- let
- package
- private
- protected
- public
- static
- yield
var public = 1500; // Questo causerà un errore
Prova tu stesso”
Attenzione!
La direttiva “use strict” è riconosciuta solo all’inizio di uno script o di una funzione.