Pourquoi avons-nous besoin du mode strict en JavaScript ?

Conversion des erreurs en fautes

Les fautes sont converties en erreurs. Elles étaient auparavant acceptées en mode non strict. Le mode strict restreint l’utilisation de la syntaxe d’erreur et ne laissera pas le code s’exécuter avec des erreurs en place.

Il rend difficile la création de variables globales en ne nous laissant pas déclarer des variables avec varlet, ou const, donc créer des variables sans les déclarer avec ces mots-clés ne fonctionnera pas. Par exemple, le code suivant lancera un ReferenceError:

'use strict';
badVariable = 1;

Nous ne pouvons pas exécuter le code ci-dessus en mode strict car ce code créera une variable globale badVariable si le mode strict est désactivé. Le mode strict empêche cela pour éviter la création de variables globales par accident.

Tout code qui échoue silencieusement lèvera désormais une exception. Cela inclut toute syntaxe invalide qui était ignorée silencieusement auparavant.

Par exemple, nous ne pouvons pas ne pas assigner à des variables en lecture seule comme argumentsNaN, ou eval avec le mode strict activé.

Toute affectation à des propriétés en lecture seule comme les propriétés globales non réinscriptibles, l’affectation de propriétés en getter seul et l’affectation de choses à des propriétés sur des objets non extensibles lancera une exception en mode strict.

Voici quelques exemples de syntaxe qui échouera avec le mode strict activé :

Tous les exemples ci-dessus lanceront une TypeErrorundefined et Infinity sont des objets globaux non réinscriptibles. obj est une propriété non inscriptible.

obj2‘s foo property is a getter only property and so cannot be set. fixedObj a été empêché d’y ajouter d’autres propriétés avec la méthode Object.preventExtensions.

Aussi, la suppression de propriétés indélébiles lancera un TypeError lorsqu’il y a du code qui tente de le faire. Par exemple :

'use strict';
delete Array.prototype

Ceci lancera une TypeError.

Le mode strict interdit également les noms de propriétés dupliqués dans un objet avant l’introduction de l’ES6, de sorte que l’exemple suivant lancera une erreur de syntaxe:

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

Le mode strict exige que les noms des paramètres de fonction soient uniques. Sans le mode strict, si deux paramètres ont le nom un, alors celui défini plus tard sera accepté comme valeur du paramètre lorsque les arguments sont passés.

Avec le mode strict, avoir plusieurs paramètres de fonction avec le même nom n’est plus autorisé, donc l’exemple suivant échouera à s’exécuter avec une erreur de syntaxe:

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

La syntaxe octale n’est pas non plus autorisée en mode strict. Elle ne fait pas partie de la spécification, mais elle est prise en charge dans les navigateurs en préfixant les nombres octaux par un 0.

Cela perturbe les développeurs car certains peuvent penser que le 0 précédant le nombre n’a pas de sens. Par conséquent, le mode strict interdit cette syntaxe et lancera une erreur de syntaxe.

Le mode strict empêche également l’utilisation d’une syntaxe qui rend les optimisations difficiles. Il doit savoir qu’une variable est réellement stockée à l’endroit où il pense qu’elle est stockée avant de faire l’optimisation, donc nous devons empêcher le type de syntaxe qui empêche les optimisations de se produire.

Un exemple de ceci est l’instruction with. Si nous l’utilisons, cela empêche l’interprète JavaScript de savoir à quelle variable ou propriété vous faites référence, car il est possible d’avoir une variable avec le même nom à l’intérieur ou à l’extérieur de l’instruction with.

Si nous avons quelque chose comme le code suivant :

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

Alors, JavaScript ne saurait pas si la x à l’intérieur de l’instruction with fait référence à la variable x ou à la propriété de objobj.x.

Par conséquent, l’emplacement mémoire de x est ambigu. Ainsi, le mode strict empêche l’utilisation de l’instruction with. Si nous avons un mode strict comme le suivant :

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

Alors le code ci-dessus aura une erreur de syntaxe.

Une autre chose que le mode strict empêche est la déclaration de variables à l’intérieur d’une déclaration eval.

Par exemple, sans le mode strict, eval('let x') déclarerait la variable x dans le code. Cela permet aux gens de cacher des déclarations de variables dans des chaînes de caractères qui pourraient remplacer la même déclaration de variable qui se trouve en dehors de la déclaration eval.

Pour empêcher cela, le mode strict interdit les déclarations de variables dans l’argument chaîne de caractères que l’on passe dans une déclaration eval.

Le mode strict interdit également la suppression des noms de variables simples, de sorte que ce qui suit lancera une erreur de syntaxe:

'use strict';
let x;
delete x;

.