JavaScript
Mode strict

Syntaxe

• 'use strict';
• "use strict";
• `use strict`;

Remarques

Pour les scripts entiers

Le mode strict peut être appliqué à des scripts entiers en plaçant l'instruction "use strict"; avant toute autre déclaration.

"use strict";
// strict mode now applies for the rest of the script

Le mode strict n'est activé que dans les scripts où vous définissez "use strict" . Vous pouvez combiner des scripts avec et sans mode strict, car l'état strict n'est pas partagé entre les différents scripts.

Pour les fonctions

Le mode strict peut aussi être appliqué à des fonctions uniques en ajoutant au préalable "use strict"; déclaration au début de la déclaration de fonction.

function strict() {
   "use strict";
   // strict mode now applies to the rest of this function
   var innerFunction = function () {
     // strict mode also applies here
   };
}

function notStrict() {
  // but not here
}

Le mode strict s'appliquera également à toutes les fonctions internes.

Modification des propriétés globales

Dans une portée de mode non strict, lorsqu'une variable est affectée sans être initialisée avec le mot let clé var , const ou let , elle est automatiquement déclarée dans la portée globale:

a = 12;
console.log(a); // 12

En mode strict, tout accès à une variable non déclarée provoquera une erreur de référence:

"use strict";
a = 12; // ReferenceError: a is not defined
console.log(a);

Cela est utile car JavaScript peut comporter un certain nombre d'événements parfois inattendus. En mode non strict, ces événements amènent souvent les développeurs à penser qu’il s’agit de bogues ou d’un comportement inattendu. Par conséquent, en activant le mode strict, toute erreur qui leur est imposée les oblige à savoir exactement ce qui est fait.

"use strict";
                       // Assuming a global variable mistypedVariable exists
mistypedVaraible = 17; // this line throws a ReferenceError due to the 
                       // misspelling of variable

Ce code en mode strict affiche un scénario possible: il génère une erreur de référence qui pointe vers le numéro de ligne de l'affectation, permettant au développeur de détecter immédiatement le type de faute dans le nom de la variable.

En mode non strict, outre le fait qu'aucune erreur ne soit émise et que l'assignation a été effectuée avec succès, le mistypedVaraible sera automatiquement déclaré dans la portée globale en tant que variable globale. Cela implique que le développeur doit rechercher manuellement cette affectation spécifique dans le code.

De plus, en forçant la déclaration de variables, le développeur ne peut pas déclarer accidentellement des variables globales à l’intérieur de fonctions. En mode non strict:

function foo() { 
   a = "bar"; // variable is automatically declared in the global scope
}
foo();
console.log(a); // >> bar

En mode strict, il est nécessaire de déclarer explicitement la variable:

function strict_scope() { 
   "use strict";
   var a = "bar"; // variable is local
}
strict_scope();
console.log(a); // >> "ReferenceError: a is not defined"

La variable peut également être déclarée en dehors et après une fonction, ce qui lui permet d'être utilisée, par exemple, dans la portée globale:

function strict_scope() { 
   "use strict";
   a = "bar"; // variable is global
}
var a;
strict_scope();
console.log(a); // >> bar

Modification des propriétés

Le mode strict vous empêche également de supprimer les propriétés indélébiles.

"use strict";
delete Object.prototype; // throws a TypeError

L'instruction ci-dessus serait simplement ignorée si vous n'utilisez pas le mode strict, mais vous savez maintenant pourquoi elle ne s'exécute pas comme prévu.

Cela vous empêche également d'étendre une propriété non extensible.

var myObject = {name: "My Name"}
Object.preventExtensions(myObject);

function setAge() {
    myObject.age = 25;   // No errors
}

function setAge() {
    "use strict";
    myObject.age = 25;  // TypeError: can't define property "age": Object is not extensible
}

Comportement de la liste d'arguments d'une fonction

arguments objets objet se comportent différemment en mode strict et non strict . En mode non strict , l'objet argument reflètera les modifications de la valeur des paramètres présents, mais en mode strict , toute modification de la valeur du paramètre ne sera pas répercutée dans l'objet argument .

function add(a, b){
    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 5,10
}

add(1, 2);

Pour le code ci-dessus, l'objet arguments est modifié lorsque nous modifions la valeur des paramètres. Cependant, pour le mode strict , le même ne sera pas reflété.

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 1,2
}

Il est intéressant de noter que si l'un des paramètres n'est undefined , et que nous essayons de modifier la valeur du paramètre en mode strict ou non strict , l'objet arguments reste inchangé.

Mode strict

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // undefined,undefined 
                                             // 1,undefined
    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // undefined,undefined
                                             // 1, undefined
}
add();
// undefined,undefined 
// undefined,undefined

add(1)
// 1, undefined
// 1, undefined

Mode non strict

function add(a,b) {

    console.log(arguments[0],arguments[1]);

    a = 5, b = 10;

    console.log(arguments[0],arguments[1]);
}
add();
// undefined,undefined 
// undefined,undefined

add(1);
// 1, undefined
// 5, undefined

Paramètres dupliqués

Le mode strict ne vous permet pas d'utiliser des noms de paramètres de fonction en double.

function foo(bar, bar) {}  // No error. bar is set to the final argument when called

"use strict";
function foo(bar, bar) {}; // SyntaxError: duplicate formal argument bar

Fonction de cadrage en mode strict

En mode strict, les fonctions déclarées dans un bloc local sont inaccessibles en dehors du bloc.

"use strict";
{
  f(); // 'hi'
  function f() {console.log('hi');}
}
f(); // ReferenceError: f is not defined

En termes de portée, les déclarations de fonction en mode strict ont le même type de liaison que let ou const .

Listes de paramètres non simples

function a(x = 5) {
  "use strict";
}

JavaScript n'est pas valide et lancera une SyntaxError parce que vous ne pouvez pas utiliser la directive "use strict" dans une fonction avec une liste de paramètres non simples comme celle ci-dessus - affectation par défaut x = 5

Les paramètres non simples incluent -

• Affectation par défaut

function a(x = 1) {
  "use strict";
}

• La destruction

function a({ x }) {
  "use strict";
}

• Reste les paramètres

function a(...args) {
  "use strict";
}