Perché abbiamo bisogno della modalità rigorosa in JavaScript?

Convertire gli errori in errori

Gli errori sono convertiti in errori. Prima erano accettati in modalità non rigorosa. La modalità rigorosa limita l’uso della sintassi degli errori e non permette al codice di essere eseguito con gli errori in atto.

Rende difficile la creazione di variabili globali non permettendoci di dichiarare variabili con varlet, o const, quindi la creazione di variabili senza dichiararle con queste parole chiave non funzionerà. Per esempio, il seguente codice lancerà un ReferenceError:

'use strict';
badVariable = 1;

Non possiamo eseguire il codice sopra in modalità strict perché questo codice creerà una variabile globale badVariable se la modalità strict è off. La modalità rigorosa impedisce questo per prevenire la creazione di variabili globali accidentalmente.

Tutto il codice che fallisce silenziosamente ora lancerà un’eccezione. Questo include qualsiasi sintassi non valida che prima veniva ignorata silenziosamente.

Per esempio, non possiamo non assegnare a variabili di sola lettura come argumentsNaN, o eval con la modalità strict attiva.

Qualsiasi assegnazione a proprietà di sola lettura come le proprietà globali non scrivibili, l’assegnazione di proprietà getter-only, e l’assegnazione di cose a proprietà su oggetti non estendibili lancerà un’eccezione in modalità strict.

Di seguito ci sono alcuni esempi di sintassi che falliranno con la modalità strict attiva:

Tutti gli esempi precedenti lanceranno un TypeErrorundefined e Infinity sono oggetti globali non scrivibili. obj è una proprietà non scrivibile.

obj2 la proprietà foo è una proprietà getter only e quindi non può essere impostata. A fixedObj è stato impedito di aggiungere altre proprietà con il metodo Object.preventExtensions.

Inoltre, l’eliminazione delle proprietà undeletable lancia un TypeError quando c’è del codice che cerca di farlo. Per esempio:

'use strict';
delete Array.prototype

Questo lancerà un TypeError.

La modalità rigorosa non permette anche di duplicare i nomi delle proprietà in un oggetto prima dell’introduzione di ES6, quindi il seguente esempio darà un errore di sintassi:

'use strict';
var o = { a: 1, a: 2 };

La modalità rigorosa richiede che i nomi dei parametri delle funzioni siano unici. Senza la modalità rigorosa, se due parametri hanno il nome uno, allora quello definito più tardi sarà accettato come valore del parametro quando gli argomenti vengono passati.

Con la modalità rigorosa, avere più parametri di funzione con lo stesso nome non è più permesso, quindi il seguente esempio fallirà con un errore di sintassi:

const multiply = (x, x, y) => x*x*y;

Anche la sintassi ottale non è permessa in modalità rigorosa. Non fa parte delle specifiche, ma è supportata nei browser facendo precedere i numeri ottali da uno 0.

Questo confonde gli sviluppatori perché alcuni possono pensare che lo 0 che precede il numero sia privo di significato. Pertanto, la modalità rigorosa non permette questa sintassi e lancia un errore di sintassi.

La modalità rigorosa impedisce anche l’uso di una sintassi che rende difficili le ottimizzazioni. Ha bisogno di sapere che una variabile è effettivamente memorizzata nella posizione in cui pensa sia memorizzata prima di fare l’ottimizzazione, quindi dobbiamo prevenire il tipo di sintassi che impedisce le ottimizzazioni.

Un esempio di questo è l’istruzione with. Se la usiamo, impedisce all’interprete JavaScript di sapere a quale variabile o proprietà si sta facendo riferimento, poiché è possibile avere una variabile con lo stesso nome dentro o fuori l’istruzione with.

Se abbiamo qualcosa come il seguente codice:

let x = 1;
with (obj) {
x;
}

Allora, JavaScript non saprebbe se il x all’interno della dichiarazione with si riferisce alla variabile x o alla proprietà di objobj.x.

Quindi, la posizione in memoria di x è ambigua. Quindi, la modalità strict impedisce l’uso dell’istruzione with. Se abbiamo una modalità strict come la seguente:

'use strict';
let x = 1;
with (obj) {
x;
}

Allora il codice sopra avrà un errore di sintassi.

Un’altra cosa che la modalità strict impedisce è la dichiarazione di variabili dentro una dichiarazione eval.

Per esempio, senza la modalità strict, eval('let x') dichiarerebbe la variabile x nel codice. Questo permette alle persone di nascondere le dichiarazioni delle variabili nelle stringhe che potrebbero sovrascrivere la stessa dichiarazione di variabile che è al di fuori della dichiarazione eval.

Per prevenire questo, la modalità strict non permette dichiarazioni di variabili nell’argomento stringa che passiamo in una dichiarazione eval.

La modalità strict proibisce anche la cancellazione di nomi di variabili semplici, quindi quanto segue darà un errore di sintassi:

'use strict';
let x;
delete x;