JavaScript
Modalità rigorosa

Sintassi

• 'usare rigoroso';
• "usare rigorosamente";
• `usare rigoroso`;

Osservazioni

Per interi script

La modalità rigorosa può essere applicata su interi script inserendo la frase "use strict"; prima di ogni altra affermazione.

"use strict";
// strict mode now applies for the rest of the script

La modalità rigorosa è abilitata solo negli script in cui si definisce "use strict" . È possibile combinare gli script con e senza la modalità rigorosa, poiché lo stato rigoroso non è condiviso tra diversi script.

Per le funzioni

La modalità rigorosa può essere applicata anche a singole funzioni anteponendo "use strict"; dichiarazione all'inizio della dichiarazione di funzione.

function strict() {
   "use strict";
   // strict mode now applies to the rest of this function
   var innerFunction = function () {
     // strict mode also applies here
   };
}

function notStrict() {
  // but not here
}

La modalità rigorosa si applica anche a tutte le funzioni con ambito interno.

Modifiche alle proprietà globali

In un ambito non rigoroso, quando una variabile viene assegnata senza essere inizializzata con la parola var , const o let , viene dichiarata automaticamente nell'ambito globale:

a = 12;
console.log(a); // 12

In modalità rigorosa, tuttavia, qualsiasi accesso a una variabile non dichiarata genererà un errore di riferimento:

"use strict";
a = 12; // ReferenceError: a is not defined
console.log(a);

Questo è utile perché JavaScript ha un numero di possibili eventi a volte inaspettati. In modalità non rigorosa, questi eventi spesso inducono gli sviluppatori a credere che siano bug o comportamenti imprevisti, consentendo in tal modo di attivare la modalità rigorosa, gli eventuali errori che vengono lanciati li impongono di sapere esattamente cosa viene fatto.

"use strict";
                       // Assuming a global variable mistypedVariable exists
mistypedVaraible = 17; // this line throws a ReferenceError due to the 
                       // misspelling of variable

Questo codice in modalità rigorosa visualizza uno scenario possibile: genera un errore di riferimento che punta al numero di riga dell'assegnazione, consentendo allo sviluppatore di rilevare immediatamente il tipo di errore nel nome della variabile.

In modalità non rigida, oltre al fatto che non viene generato alcun errore e che l'assegnazione è stata eseguita correttamente, il file mistypedVaraible verrà automaticamente dichiarato nell'ambito globale come variabile globale. Ciò implica che lo sviluppatore deve cercare manualmente questo specifico incarico nel codice.

Inoltre, forzando la dichiarazione delle variabili, lo sviluppatore non può dichiarare accidentalmente variabili globali all'interno delle funzioni. In modalità non rigorosa:

function foo() { 
   a = "bar"; // variable is automatically declared in the global scope
}
foo();
console.log(a); // >> bar

In modalità rigorosa, è necessario dichiarare esplicitamente la variabile:

function strict_scope() { 
   "use strict";
   var a = "bar"; // variable is local
}
strict_scope();
console.log(a); // >> "ReferenceError: a is not defined"

La variabile può anche essere dichiarata all'esterno e dopo una funzione, consentendone l'utilizzo, ad esempio, nell'ambito globale:

function strict_scope() { 
   "use strict";
   a = "bar"; // variable is global
}
var a;
strict_scope();
console.log(a); // >> bar

Modifiche alle proprietà

La modalità rigorosa impedisce anche di eliminare proprietà non cancellabili.

"use strict";
delete Object.prototype; // throws a TypeError

L'affermazione sopra sarebbe semplicemente ignorata se non si utilizza la modalità rigorosa, tuttavia ora si sa perché non viene eseguita come previsto.

Inoltre impedisce di estendere una proprietà non estendibile.

var myObject = {name: "My Name"}
Object.preventExtensions(myObject);

function setAge() {
    myObject.age = 25;   // No errors
}

function setAge() {
    "use strict";
    myObject.age = 25;  // TypeError: can't define property "age": Object is not extensible
}

Comportamento dell'elenco degli argomenti di una funzione

arguments oggetto comportarsi diverso in modalità rigorosa rigorosa e non. In modalità non rigida , l' argument rifletterà le modifiche nel valore dei parametri che sono presenti, tuttavia in modalità rigorosa tutte le modifiche al valore del parametro non verranno riflesse nell'oggetto argument .

function add(a, b){
    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 5,10
}

add(1, 2);

Per il codice precedente, l'oggetto arguments viene modificato quando si modifica il valore dei parametri. Tuttavia, per la modalità rigorosa , lo stesso non si rifletterà.

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 1,2
}

Vale la pena notare che, se uno qualsiasi dei parametri undefined è undefined , e proviamo a modificare il valore del parametro in modalità rigorosa o non rigida , l' arguments rimane invariato.

Modalità rigorosa

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // undefined,undefined 
                                             // 1,undefined
    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // undefined,undefined
                                             // 1, undefined
}
add();
// undefined,undefined 
// undefined,undefined

add(1)
// 1, undefined
// 1, undefined

Modalità non rigorosa

function add(a,b) {

    console.log(arguments[0],arguments[1]);

    a = 5, b = 10;

    console.log(arguments[0],arguments[1]);
}
add();
// undefined,undefined 
// undefined,undefined

add(1);
// 1, undefined
// 5, undefined

Parametri duplicati

La modalità rigorosa non consente di utilizzare nomi di parametri di funzione duplicati.

function foo(bar, bar) {}  // No error. bar is set to the final argument when called

"use strict";
function foo(bar, bar) {}; // SyntaxError: duplicate formal argument bar

Scope delle funzioni in modalità rigorosa

In modalità Strict, le funzioni dichiarate in un blocco locale sono inaccessibili al di fuori del blocco.

"use strict";
{
  f(); // 'hi'
  function f() {console.log('hi');}
}
f(); // ReferenceError: f is not defined

Per quanto riguarda le dichiarazioni di funzioni, nella modalità Strict hanno lo stesso tipo di binding di let o const .

Elenchi di parametri non semplici

function a(x = 5) {
  "use strict";
}

è un JavaScript non valido e genera un SyntaxError perché non è possibile utilizzare la direttiva "use strict" in una funzione con un elenco di parametri non semplici come quello sopra riportato - assegnazione predefinita x = 5

I parametri non semplici includono:

• Assegnazione predefinita

function a(x = 1) {
  "use strict";
}

• destrutturazione

function a({ x }) {
  "use strict";
}

• Parametri di riposo

function a(...args) {
  "use strict";
}