Le mode strict JavaScript ("use strict")

Ce qu'est "use strict"

JavaScript a été conçu en 1995 pour ne jamais planter sur du code erroné — les erreurs étaient silencieusement ignorées afin de maintenir les pages web en vie. Ce comportement indulgent masque des bogues. Le mode strict est une variante optionnelle du langage, introduite dans ECMAScript 5 (2009), qui transforme nombre de ces erreurs silencieuses en erreurs explicites et supprime quelques fonctionnalités héritées prêtant à confusion.

On l'active avec une directive sous forme de chaîne littérale :

"use strict";

Cette page explique où placer la directive, ce qu'elle modifie exactement, et pourquoi le code moderne (modules et classes) est déjà strict sans que vous ayez à faire quoi que ce soit.

Comment activer le mode strict

La directive doit être la toute première instruction — une chaîne simple, avant tout autre code. Si quelque chose la précède (même une expression isolée), elle est traitée comme une string ordinaire et ignorée, sans avertissement.

Script ou module entier

Placez "use strict"; en haut du fichier pour l'appliquer à tout ce qui suit :

"use strict";

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

Une seule fonction

Vous pouvez limiter le mode strict à une seule fonction en plaçant la directive au début de son corps. Le reste du fichier reste en mode permissif ("non-strict"). C'est utile pour ajouter le comportement strict à un grand fichier hérité, fonction par fonction.

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

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

Il n'existe aucun moyen de désactiver le mode strict une fois qu'une portée est stricte. La directive est unidirectionnelle.

Ce que le mode strict change concrètement

Les différences sont peu nombreuses, mais elles permettent de détecter de véritables bogues. Voici celles que vous rencontrerez le plus souvent.

L'affectation à une variable non déclarée lève une erreur

En mode permissif, x = 10 sans var/let/const crée silencieusement une variable globale — une source classique de fuites et de fautes de frappe. Le mode strict le rejette :

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

Consultez l'objet global et la portée des variables pour comprendre pourquoi les variables globales accidentelles sont si néfastes.

Les mauvaises affectations lèvent une erreur au lieu d'échouer silencieusement

Écrire dans une propriété en lecture seule, une propriété à getter uniquement, ou un object non extensible échoue silencieusement en mode permissif. Le mode strict lève une TypeError, ce qui vous permet de le détecter immédiatement :

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

this est undefined dans les appels de fonctions simples

Quand vous appelez une fonction normale directement (pas en tant que méthode), le mode permissif attribue à this l'objet global. Le mode strict le laisse undefined, ce qui révèle les erreurs où une méthode est détachée de son object :

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

Les noms de paramètres en double sont interdits

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

Autres restrictions

• delete appliqué à une variable, une fonction ou un argument de fonction est une SyntaxError.
• Les littéraux octaux comme 010 sont interdits (utilisez 0o10).
• eval et arguments ne peuvent pas être réaffectés ni utilisés comme noms de variables.
• Les mots réservés comme implements, interface, private, public ne peuvent pas être utilisés comme identifiants.

Les modules et les classes sont toujours en mode strict

Vous n'avez souvent pas besoin d'écrire "use strict"; du tout, car deux des contextes modernes les plus courants sont automatiquement en mode strict :

• Les modules ES. Tout fichier chargé en tant que module (<script type="module">, un fichier importé via import, ou un fichier .mjs) s'exécute en mode strict. La directive y est redondante.
• Les corps de classes. Tout le code à l'intérieur d'une déclaration ou expression class { ... } est strict, indépendamment du fichier environnant.

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
  }
}

Pour cette raison, la plupart du code écrit aujourd'hui est déjà en mode strict. La directive "use strict"; est surtout utile pour les fichiers <script> classiques non-modules et les bases de code plus anciennes.

Quand l'utiliser

• Nouveaux scripts non-modules : ajoutez "use strict"; en haut. C'est une assurance gratuite contre les variables globales accidentelles et les échecs silencieux.
• Modules et classes : rien à faire — vous êtes déjà en mode strict.
• Fichiers hérités : adoptez-le progressivement, fonction par fonction, et retestez. Basculer tout un fichier permissif en mode strict peut exposer du code qui reposait secrètement sur des variables globales accidentelles ou un this permissif. Consultez l'ancien "var" pour les comportements hérités connexes qu'il vaut la peine de nettoyer en même temps.

Résumé

Le mode strict est un dialecte plus rigoureux et plus sûr de JavaScript, activé par la directive "use strict"; en haut d'un script ou d'une fonction. Il bloque les variables globales implicites, lève des erreurs sur les mauvaises affectations, attribue undefined à this dans les appels simples, et interdit les paramètres en double ainsi que quelques syntaxes héritées. Les modules ES et les corps de classes l'activent automatiquement, de sorte que la principale raison de l'écrire manuellement concerne les fichiers de script classiques et le code plus ancien.

Pratique