JavaScript reste l'un des langages de programmation les plus largement utilisés sur le web, qui alimente tout, des formes interactives simples aux applications complexes d'une page unique. Avec l'augmentation de la taille des projets et l'augmentation du nombre de membres de l'équipe, le besoin de code fiable et prévisible devient primordial. C'est là que le mode strict de JavaScript – une fonctionnalité introduite dans ECMAScript 5 – entre en jeu. Le mode strict permet aux développeurs d'opter pour une variante restreinte de la langue, aidant à attraper des erreurs communes, empêchant les actions dangereuses, et finalement produire un code plus sûr et plus durable.

Qu'est-ce que le mode strict?

Le mode Strict est une façon de choisir un sous-ensemble de JavaScript plus discipliné. Lorsque activé, le moteur JavaScript exécute le code sous un ensemble de contraintes qui éliminent certaines des fonctionnalités plus sensibles aux erreurs de la langue. L'idée derrière le mode strict est de fournir aux développeurs des commentaires plus tôt sur les problèmes potentiels. Par exemple, en mode non strict (souvent appelé «mode sloppy»), l'attribution d'une valeur à une variable non déclarée crée silencieusement une variable globale. En mode strict, ce mode lance une . De même, le mode strict empêche l'utilisation de certaines constructions dépréciées ou problématiques, telles que la déclaration et les littéraux numériques octal. L'objectif est de rendre JavaScript plus fiable, plus sûr et plus cohérent, en particulier dans les grandes bases de code.

ECMAScript 5 a introduit un mode strict en 2009 comme moyen d'évoluer le langage sans rompre la compatibilité avec l'arrière. Les développeurs pourraient opter pour le nouveau comportement plus strict en ajoutant simplement en haut d'un script ou d'une fonction. Depuis, le mode strict est devenu une pratique recommandée dans de nombreux guides de style et est automatiquement appliqué dans les constructions modernes de JavaScript comme les modules ES (import/export) et les corps de classe.

Comment activer le mode strict

Activer le mode strict est simple : vous insérez la chaîne de caractères (ou ) au début d'un script ou d'une fonction. Cette directive n'est pas une instruction mais un pragma qui indique au moteur d'analyser le code suivant en mode strict. Elle peut être appliquée à deux champs : global (pour un script entier) ou local (pour une fonction unique).

Mode strict de niveau Script

Pour activer le mode strict pour un fichier JavaScript entier ou un bloc , placez comme la toute première ligne du script (avant toute autre instruction). Par exemple :

// script.js
'use strict';

var x = 10;
console.log(x); // works normally

// Attempting to use undeclared variables throws an error
y = 20; // ReferenceError: y is not defined

Lorsqu'il est appliqué globalement, le mode strict affecte tous les codes de ce fichier de script. Si vous concaténez plusieurs scripts, seuls ceux qui commencent par s'exécuteront en mode strict. Il est important de noter qu'un script en mode strict ne peut pas se mélanger avec le code non-strict dans le même fichier à moins d'utiliser la scoping de niveau de fonction.

Mode strict de niveau de fonction

Vous pouvez également activer un mode strict à l'intérieur d'une fonction spécifique, laissant le reste du script en mode sloppy. Ceci est utile lorsque vous migrez progressivement une base de code ou lorsque vous voulez une vérification stricte uniquement pour certaines fonctions. Placez en haut du corps de la fonction, avant toute autre instruction:

function strictFunction() {
 'use strict';
 // Inside this function, strict mode applies
 var a = 1;
 b = 2; // ReferenceError: b is not defined
}

function sloppyFunction() {
 // Outside strictFunction, sloppy mode still applies
 c = 3; // creates global variable c
}

Le mode strict de niveau de fonction s'applique uniquement au code de la fonction, et non à aucune fonction imbriquée (à moins qu'ils ne déclarent également . Cependant, dans la pratique, il est courant de définir le mode strict au niveau du fichier pour assurer la cohérence.

Modules et classes

Avec l'arrivée d'ES6 (ES2015), JavaScript a introduit des modules et des classes. Les deux sont automatiquement en mode strict par défaut. Par conséquent, si vous écrivez votre code en utilisant / syntaxe ou définissez une , vous n'avez pas besoin d'ajouter – le mode strict est appliqué automatiquement. Par exemple:

// module.js (no 'use strict' needed)
export function add(a, b) {
 // strict mode is active here
 return a + b;
}

// class definition (strict mode active)
class MyClass {
 constructor(value) {
 this.value = value;
 }
}

Cette application automatique rend le code dans les modules et les classes intrinsèquement plus sûr et plus facile à raisonner.

Principaux avantages de l'utilisation d'un mode strict

Le mode strict offre une foule d'avantages qui améliorent directement la qualité du code, la sécurité et l'expérience du développeur. Examinons chaque avantage en détail.

Prévient les variables mondiales accidentelles

En mode non-strict, l'attribution d'une valeur à une variable non déclarée crée automatiquement une propriété sur l'objet global ( dans les navigateurs, dans Node.js). Cela peut facilement se produire en raison d'erreurs typographiques ou de déclarations oubliées, polluant l'espace de noms global et causant des bugs subtils.

// Non-strict: silently creates global variable
function setup() {
 developer = "Alice"; // accidentally global
}

// Strict: throws ReferenceError
function setup() {
 'use strict';
 developer = "Alice"; // ReferenceError: developer is not defined
}

Cette application oblige les développeurs à déclarer explicitement des variables avec , ou , réduisant les bogues liés à la portée.

Élimine les erreurs silencieuses

JavaScript est souvent pardonné lorsque les opérations échouent silencieusement. Par exemple, l'attribution à une propriété en lecture seule (comme ou un objet gelé) ne fait rien en mode gaspillé. En mode strict, de telles affectations lancent un . De même, des tentatives pour supprimer des propriétés non-élétables (par exemple, ) lancent une erreur au lieu de renvoyer silencieusement . Cela rend le débogage beaucoup plus facile parce que le développeur reçoit une rétroaction immédiate.

// Non-strict: assignment silently fails
var obj = Object.freeze({name: "Bob"});
obj.name = "Charlie"; // silently ignored

// Strict: TypeError thrown
'use strict';
var obj = Object.freeze({name: "Bob"});
obj.name = "Charlie"; // TypeError: Cannot assign to read-only property 'name'

Prévient le doublement des noms des paramètres

En mode non-strict, les fonctions peuvent avoir des noms de paramètres dupliqués, ce qui peut conduire à des comportements déroutants (le dernier duplicata écrase les précédents). Le mode strict interdit cela, jetant un à l'heure de l'analyse. Par exemple:

// Non-strict: allowed
function sum(a, a, c) {
 return a + a + c; // a equals the second argument passed
}

// Strict: SyntaxError
'use strict';
function sum(a, a, c) { // SyntaxError: Duplicate parameter name not allowed in strict mode
 return a + a + c;
}

Cette restriction permet d'éviter l'écrasement accidentel des paramètres, ce qui rend les signatures de fonction plus claires et moins sujettes aux erreurs.

Restricte la déclaration

La déclaration est depuis longtemps considérée comme nuisible parce qu'elle crée une ambiguïté sur la résolution variable et dégrade les performances. Le mode strict rejette complètement la déclaration , jetant un au moment de la compilation. Cette suppression encourage les développeurs à utiliser des modèles plus prévisibles, comme la déstructuration ou l'accès explicite à la propriété.

Marque Plus sûr

En mode non-strict, peut introduire de nouvelles variables dans la portée environnante, conduisant à des effets secondaires imprévisibles. Le mode strict modifie le comportement de de sorte qu'il crée des variables uniquement dans le code eval lui-même – elles ne fuient pas dans le contexte de fermeture.

// Non-strict: eval creates variable in outer scope
var x = 1;
eval("var x = 2;");
console.log(x); // 2

// Strict: eval has its own scope
'use strict';
var x = 1;
eval("var x = 2;");
console.log(x); // 1

Interdit les Littéraux Octaux Numeriques

Historiquement, JavaScript interprète les nombres avec un zéro de tête (par exemple, ) comme octal (base 8). Ce comportement provoque souvent confusion et bugs, surtout lorsqu'il s'agit de chaînes comme "010" étant analysées comme des nombres. Le mode strict interdit les littéraux numériques octal (sauf pour le préfixe ES6+ ) et lance un . Cela élimine toute une classe de bugs subtils.

// Non-strict: 010 means octal 8
console.log(010); // 8

// Strict: SyntaxError
'use strict';
console.log(010); // SyntaxError: Octal literals are not allowed in strict mode

Refuser les variables de la plaine

En mode non-strict, vous pouvez essayer de supprimer des variables ou des déclarations de fonction, mais l'opération échoue silencieusement (] retourne . Le mode Strict lance un si vous essayez de supprimer une variable, une fonction ou un paramètre de fonction.

// Non-strict: attempt silently fails
var a = 1;
delete a; // false; a still exists

// Strict: SyntaxError
'use strict';
var a = 1;
delete a; // SyntaxError: Delete of an unqualified identifier in strict mode

Améliorations supplémentaires en matière de sécurité et de rendement

Au-delà des restrictions spécifiques, le mode strict permet aux moteurs JavaScript d'effectuer certaines optimisations impossibles par ailleurs. Parce que le mode strict élimine certains comportements dynamiques (comme l'instruction et les globals implicites), le moteur peut mieux prédire comment les variables seront utilisées, ce qui conduit à une exécution plus rapide dans certains cas. De plus, le mode strict désactive la propriété et la propriété des fonctions, qui ont été utilisées historiquement pour l'introspection mais ont également posé des risques de sécurité en permettant l'accès à la pile d'appel.

Exemples pratiques de modes stricts en action

Pour solidifier la compréhension, nous allons à travers une série d'exemples qui contrastent mode brouillé avec mode strict. Ceux-ci démontrent le mode strict de rétroaction immédiat fournit.

Exemple 1: Attribution de variables non déclarée

// sloppy.js
function userInfo() {
 name = "John"; // silently creates global 'name'
}
userInfo();
console.log(window.name); // "John" (in browsers)

// strict.js
'use strict';
function userInfo() {
 name = "John"; // ReferenceError: name is not defined
}
userInfo();

Sans mode strict, une simple typo comme au lieu de peut polluer la portée globale. Avec mode strict, l'erreur est capturée instantanément.

Exemple 2: Attribution à une propriété mondiale en lecture seule

// sloppy mode
undefined = 5; // silently fails (undefined remains undefined)
NaN = 6; // silently fails
console.log(undefined, NaN); // undefined, NaN

// strict mode
'use strict';
undefined = 5; // TypeError: Cannot assign to read-only property 'undefined' of object '#<Window>'
NaN = 6; // TypeError

Le mode strict empêche l'écrasement accidentel des constantes mondiales qui ne devraient jamais changer, aidant à préserver l'intégrité de l'environnement d'exécution.

Exemple 3 : Doublon des noms de propriété d'objets

En mode strict, les noms de propriétés dupliqués dans les caractères littéraux de l'objet provoquent un . En mode sloppy, le dernier gagne. Ceci est particulièrement utile pour détecter les erreurs lors de l'édition d'objets de configuration ou lors de la copie de code.

// sloppy: works, last value wins
var config = {
 host: "example.com",
 host: "backup.com" // no error
};
console.log(config.host); // "backup.com"

// strict: SyntaxError
'use strict';
var config = {
 host: "example.com",
 host: "backup.com" // SyntaxError: Duplicate data property in object literal not allowed in strict mode
};

Pièges communs et migration vers un mode strict

Bien que le mode strict apporte de nombreux avantages, la migration d'une base de code existante importante peut présenter des défis. Certains modèles plus anciens qui ont été jugés acceptables dans ES3/5 peuvent maintenant échouer.

  • Attributions de variables non déclarées : Le code s'appuyant sur des globals implicites doit être mis à jour pour déclarer des variables.
  • Utilisation des énoncés : Ces énoncés doivent être reformulés en accès explicite à la propriété.
  • : Remplacer par ]][FLT:][F][F
  • Accès : Ceci est refusé; utilisez plutôt des expressions de fonction nommées.
  • Noms de paramètre dupliqués : Doit être supprimé ou renommé.
  • Utilisation sur des variables ou des fonctions: Cette opération est interdite.

Le processus de migration est souvent incrémentiel. Vous pouvez activer fonction par fonction en mode strict en utilisant la règle pragma à l'intérieur des fonctions, tester soigneusement, puis l'activer globalement une fois que vous êtes confiant. Des outils comme ESLint avec sa règle peuvent aider à identifier les violations automatiquement.

Il est également intéressant de noter que le mode strict n'est pas un tueur de performance. En fait, comme mentionné, certains moteurs peuvent optimiser le code de mode strict mieux. Le contrôle initial de l'exécution de la directive est négligeable, et la clarté et la sécurité du code global l'emportent largement sur tout coût marginal.

Conclusion et pratiques exemplaires

En optant pour ce sous-ensemble restreint de la langue, les développeurs acquièrent une détection précoce des erreurs courantes, évitent les constructions dangereuses et bénéficient de meilleures performances dans de nombreux cas. Activer le mode strict est aussi simple que d'ajouter au début d'un script ou d'une fonction, et il est automatiquement actif dans les modules et les classes ES. Les avantages – prévenir les globalités accidentelles, éliminer les erreurs silencieuses, restreindre les caractéristiques nocives comme et – se traduisent directement en moins de bugs et accélérer les cycles de débogage.

Pour tout projet, qu'il soit nouveau ou legs, adopter un mode strict doit être considéré comme une pratique exemplaire. Commencez par utiliser un linter pour identifier les violations, les corriger progressivement et tester fréquemment. Les outils et les cadres JavaScript modernes supposent souvent un mode strict (ou l'appliquer), de sorte que l'alignement avec cette convention assure la compatibilité et la cohérence.

Pour plonger plus profondément, reportez-vous à la documentation MDN en mode strict pour une liste complète des restrictions et des exemples. Pour le contexte historique, la spécification ECMAScript[ explique les règles formelles. De plus, la règle ESLint strict fournit un moyen automatisé pour faire respecter une utilisation cohérente dans votre projet.