Modalità Strict di JavaScript ("use strict")

Cos'è "use strict"

JavaScript è stato progettato nel 1995 per non crashare mai su codice errato — gli errori venivano ignorati silenziosamente per mantenere le pagine web in funzione. Questo comportamento permissivo nasconde i bug. La modalità strict è una variante opt-in del linguaggio, introdotta in ECMAScript 5 (2009), che trasforma molti di quegli errori silenziosi in errori espliciti e rimuove alcune funzionalità legacy confuse.

Si attiva con una direttiva stringa letterale:

"use strict";

Questa pagina spiega dove inserire la direttiva, cosa cambia esattamente e perché il codice moderno (moduli e classi) è già in modalità strict senza che tu faccia nulla.

Come Abilitare la Modalità Strict

La direttiva deve essere la prima istruzione in assoluto — una stringa semplice, prima di qualsiasi altro codice. Se qualcosa la precede (anche un'espressione isolata), viene trattata come una stringa ordinaria e ignorata, senza alcun avviso.

Intero script o modulo

Inserisci "use strict"; in cima al file per applicarla a tutto ciò che segue:

"use strict";

// Every statement in this file now runs in strict mode.
function doStuff() {
  // strict here too
}

Una singola funzione

Puoi limitare la modalità strict a una sola funzione inserendo la direttiva in cima al suo corpo. Il resto del file rimane in modalità permissiva ("non-strict"). Questo è utile quando si vuole aggiungere il comportamento strict a un file legacy di grandi dimensioni una funzione alla volta.

function strictFn() {
  "use strict";
  return arguments; // strict behavior, just inside here
}

function sloppyFn() {
  return arguments; // legacy behavior
}

Non è possibile disattivare la modalità strict una volta che uno scope è strict. La direttiva è unidirezionale.

Cosa Cambia Effettivamente la Modalità Strict

Le differenze sono poche ma individuano bug reali. Ecco quelle che incontrerai più spesso.

L'assegnazione a una variabile non dichiarata genera un errore

In modalità permissiva, x = 10 senza var/let/const crea silenziosamente una variabile globale — una classica fonte di perdite di memoria e refusi. La modalità strict la rifiuta:

"use strict";
undeclaredVariable = 10; // ReferenceError: undeclaredVariable is not defined

Consulta l'oggetto globale e lo scope delle variabili per capire perché i globali accidentali sono così pericolosi.

Le assegnazioni errate generano un errore invece di fallire silenziosamente

Scrivere su una proprietà di sola lettura, una proprietà getter-only, o un object non estensibile fallisce in modo silenzioso in modalità permissiva. La modalità strict genera un TypeError, così lo scopri immediatamente:

"use strict";
const obj = {};
Object.defineProperty(obj, "x", { value: 1, writable: false });
obj.x = 2; // TypeError: Cannot assign to read only property 'x'

this è undefined nelle chiamate di funzione semplici

Quando si chiama una funzione normale direttamente (non come metodo), la modalità permissiva imposta this sull'object globale. La modalità strict lo lascia undefined, il che evidenzia gli errori in cui un metodo viene staccato dal suo object:

"use strict";
function whoAmI() {
  return this;
}
console.log(whoAmI()); // undefined  (in sloppy mode this would be the global object)

I nomi di parametri duplicati sono vietati

"use strict";
function add(a, a) { // SyntaxError: Duplicate parameter name not allowed in this context
  return a + a;
}

Altre restrizioni

• delete su una variabile, una funzione o un argomento di funzione è un SyntaxError.
• I letterali ottali come 010 non sono consentiti (usa 0o10).
• eval e arguments non possono essere assegnati o usati come nomi di variabile.
• Le parole riservate come implements, interface, private, public non possono essere usate come identificatori.

I Moduli e le Classi Sono Sempre in Modalità Strict

Spesso non è necessario scrivere "use strict"; affatto, perché due dei contesti moderni più comuni sono automaticamente in modalità strict:

• Moduli ES. Qualsiasi file caricato come modulo (<script type="module">, un file importato con import, o un file .mjs) viene eseguito in modalità strict. La direttiva è ridondante in quel caso.
• Corpi delle classi. Tutto il codice all'interno di una dichiarazione o espressione class { ... } è strict, indipendentemente dal file circostante.

class Counter {
  // This method is strict even with no directive anywhere in the file.
  bump() {
    return this; // undefined if called detached, like any strict function
  }
}

Per questo motivo, la maggior parte del codice scritto oggi è effettivamente già in modalità strict. La direttiva "use strict"; è rilevante principalmente per i file <script> classici non-module e per le codebase più vecchie.

Quando Usarla

• Nuovi script non-module: aggiungi "use strict"; in cima. È una garanzia gratuita contro i globali accidentali e i fallimenti silenziosi.
• Moduli e classi: nulla da fare — sei già in modalità strict.
• File legacy: adottala in modo incrementale, funzione per funzione, e ri-testa. Passare un intero file permissivo alla modalità strict può esporre codice che si basava segretamente su globali accidentali o su un this permissivo. Consulta il vecchio "var" per comportamenti legacy correlati che vale la pena correggere nello stesso momento.

Riepilogo

La modalità strict è un dialetto più rigoroso e sicuro di JavaScript, attivato con la direttiva "use strict"; in cima a uno script o a una funzione. Blocca i globali impliciti, genera errori sulle assegnazioni errate, imposta this a undefined nelle chiamate semplici e vieta i parametri duplicati e alcune sintassi legacy. I moduli ES e i corpi delle classi la abilitano automaticamente, quindi il motivo principale per scriverla manualmente è per i file script classici e il codice più vecchio.

Esercitazione