the Que fait «use strict» en JavaScript et quel est le raisonnement derrière?




use the function form of use strict (17)

Utiliser 'use strict'; ne rend pas votre code meilleur soudainement.

Le mode strict JavaScript est une fonctionnalité d' ECMAScript 5 . Vous pouvez activer le mode strict en le déclarant en haut de votre script / fonction.

'use strict';

Lorsqu'un moteur JavaScript voit cette directive , il commence à interpréter le code dans un mode spécial. Dans ce mode, des erreurs sont générées lorsque certaines pratiques de codage susceptibles de devenir des bogues potentiels sont détectées (ce qui est le raisonnement derrière le mode strict).

Considérons cet exemple:

var a = 365;
var b = 030;

Dans leur obsession d'aligner les littéraux numériques, le développeur a par inadvertance initialisé la variable b avec un littéral octal. Le mode non strict interprétera cela comme un littéral numérique de valeur 24 (en base 10). Cependant, le mode strict génère une erreur.

Pour une liste non exhaustive de spécialités en mode strict, voir cette réponse .

Où devrais-je utiliser 'use strict'; ?

  • Dans ma nouvelle application JavaScript: Absolument! Le mode strict peut être utilisé comme un lanceur d'alerte lorsque vous faites quelque chose de stupide avec votre code.

  • Dans mon code JavaScript existant : Probablement pas! Si votre code JavaScript existant contient des instructions interdites en mode strict, l'application sera simplement interrompue. Si vous voulez le mode strict, vous devez être prêt à déboguer et à corriger votre code existant. C'est pourquoi utiliser 'use strict'; ne rend pas votre code meilleur soudainement .

Comment utiliser le mode strict?

  1. Insérez un 'use strict'; déclaration sur votre script:

    // File: myscript.js
    
    'use strict';
    var a = 2;
    ....
    

    Notez que tout dans le fichier myscript.js sera interprété en mode strict.

  2. Ou, insérez un 'use strict'; déclaration sur le corps de votre fonction:

    function doSomething() {
        'use strict';
        ...
    }
    

    Tout dans l' étendue lexicale de la fonction doSomething sera interprété en mode strict. Le mot portée lexicale est important ici. Voir cette réponse pour une meilleure explication.

Quelles sont les choses interdites en mode strict?

J'ai trouvé un bel article décrivant plusieurs choses interdites en mode strict (notez qu'il ne s'agit pas d'une liste exclusive):

Portée

Historiquement, JavaScript a été confondu sur la façon dont les fonctions sont étendues. Parfois, elles semblent avoir une portée statique, mais certaines caractéristiques les font se comporter comme si elles avaient une portée dynamique. C'est déroutant, rendant les programmes difficiles à lire et à comprendre. Une incompréhension provoque des bugs. C'est aussi un problème de performance. La portée statique permettrait la liaison de variable au moment de la compilation, mais l'exigence de portée dynamique signifie que la liaison doit être reportée à l'exécution, ce qui entraîne une pénalité de performance significative.

Le mode strict requiert que toutes les liaisons de variables soient effectuées de manière statique. Cela signifie que les fonctionnalités qui nécessitaient auparavant une liaison dynamique doivent être supprimées ou modifiées. Plus précisément, l'instruction with est éliminée et la capacité de la fonction eval à altérer l'environnement de l'appelant est sévèrement restreinte.

L'un des avantages du code strict est que des outils tels que YUI Compressor peuvent faire un meilleur travail lors du traitement.

Variables globales impliquées

JavaScript a impliqué des variables globales. Si vous ne déclarez pas explicitement une variable, une variable globale est implicitement déclarée pour vous. Cela facilite la programmation pour les débutants, car ils peuvent négliger certaines de leurs tâches ménagères de base. Mais cela rend la gestion de programmes plus importants beaucoup plus difficile et dégrade considérablement la fiabilité. Donc, en mode strict, les variables globales implicites ne sont plus créées. Vous devez déclarer explicitement toutes vos variables.

Fuite globale

Cela pourrait être lié à un objet global dans un certain nombre de situations. Par exemple, si vous oubliez de fournir le new préfixe lorsque vous appelez une fonction constructeur, this ci sera liée de manière inattendue à l'objet global. Ainsi, au lieu d'initialiser un nouvel objet, il modifiera les variables globales de manière silencieuse. Dans ces situations, le mode strict liera this undefined à undefined , ce qui obligera le constructeur à lever une exception et à permettre la détection de l'erreur beaucoup plus tôt.

Échec bruyant

JavaScript a toujours eu des propriétés en lecture seule, mais vous ne pouvez pas les créer vous-même tant que la fonction Object.createProperty d'ES5 n'a Object.createProperty exposé cette possibilité. Si vous tentiez d'affecter une valeur à une propriété en lecture seule, la tentative échouait de manière silencieuse. La cession ne changerait pas la valeur de la propriété, mais votre programme se déroulerait comme s'il l'avait été. Il s’agit d’un risque d’intégrité qui peut entraîner l’incohérence des programmes. En mode strict, toute tentative de modification d'une propriété en lecture seule lève une exception.

Octal

La représentation octale (ou base 8) des nombres était extrêmement utile lors de la programmation au niveau de la machine sur des machines dont la taille des mots était un multiple de 3. Vous aviez besoin de l’aide octal pour travailler avec le système central CDC 6600, dont la taille de mot était de 60 bits. Si vous pouviez lire en octal, vous pourriez regarder un mot de 20 chiffres. Deux chiffres représentaient le code opérationnel et un chiffre identifiait l'un des 8 registres. Lors de la transition lente des codes machine aux langages de haut niveau, il a été jugé utile de fournir des formes octales dans les langages de programmation.

En C, une représentation extrêmement malheureuse de l’octalité a été choisie: zéro non significatif. Donc, en C, 0100 signifie 64 et non pas 100, et 08 est une erreur et non pas 8. Encore plus malheureusement, cet anachronisme a été copié dans presque toutes les langues modernes, y compris JavaScript, où il n'est utilisé que pour créer des erreurs. Cela n'a pas d'autre but. Donc, en mode strict, les formes octales ne sont plus autorisées.

Etc

Le pseudo-tableau arguments devient un peu plus semblable à un tableau dans ES5. En mode strict, il perd ses propriétés callee et caller . Cela permet de passer vos arguments à du code non fiable sans renoncer à beaucoup de contexte confidentiel. De plus, la propriété arguments des fonctions est éliminée.

En mode strict, les clés dupliquées dans un littéral de fonction génèrent une erreur de syntaxe. Une fonction ne peut pas avoir deux paramètres portant le même nom. Une fonction ne peut pas avoir une variable portant le même nom que l'un de ses paramètres. Une fonction ne peut pas delete ses propres variables. Une tentative de delete une propriété non configurable lève maintenant une exception. Les valeurs primitives ne sont pas implicitement encapsulées.

Mots réservés pour les futures versions de JavaScript

ECMAScript 5 ajoute une liste de mots réservés. Si vous les utilisez comme variables ou arguments, le mode strict lève une erreur. Les mots réservés sont:

implements , interface , let , package , private , protected , public , static et yield

Lectures complémentaires

https://code.i-harness.com

Récemment, j'ai utilisé une partie de mon code JavaScript dans JSLint de Crockford, qui a JSLint l'erreur suivante:

Problème à la ligne 1, caractère 1: Manque l'énoncé "use strict".

En faisant des recherches, je me suis rendu compte que certaines personnes ajoutaient "use strict"; dans leur code JavaScript. Une fois que j'ai ajouté la déclaration, l'erreur a cessé d'apparaître. Malheureusement, Google n'a pas révélé beaucoup de choses derrière cette déclaration. Cela doit certainement avoir quelque chose à voir avec la façon dont le navigateur interprète le code JavaScript, mais je n'ai aucune idée de l'effet que cela pourrait avoir.

Alors, qu'est-ce que "use strict"; Qu'est-ce que cela implique et est-il toujours d'actualité?

Est-ce que l'un des navigateurs actuels répond au "use strict"; chaîne ou est-ce pour une utilisation future?


Attention, vous tous, programmeurs assidus: appliquer "use strict" au code existant peut être dangereux! Ce truc n'est pas un autocollant de gaieté ou de visage joyeux que vous pouvez coller sur le code pour le rendre «meilleur». Avec le pragma "use strict" , le navigateur va soudainement JETER des exceptions dans des endroits aléatoires qu'il n'a jamais lancés auparavant, simplement parce qu'à cet endroit, vous faites quelque chose que JavaScript / le défaut de lire permet joliment mais que le JavaScript est abominable! Vous pouvez avoir des violations de la rigueur cachées dans des appels rarement utilisés dans votre code, qui ne lèveront une exception que lorsqu'ils seront finalement exécutés - par exemple, dans l'environnement de production utilisé par vos clients payants!

Si vous allez franchir le pas, il est judicieux d'appliquer "use strict" côté de tests unitaires complets et d'une tâche de construction JSHint configurée de manière stricte, qui vous donnera l'assurance qu'il n'y a pas de coin sombre de votre module qui explose. horriblement juste parce que vous avez activé le mode strict. Ou bien, voici une autre option: n'ajoutez simplement pas "use strict" à l'un de vos codes hérités, c'est probablement plus sûr de cette façon, honnêtement. DÉFINITIVEMENT, n’ajoutez pas "use strict" aux modules que vous ne possédez ni ne maintenez, comme les modules tiers.

Je pense que même s’il s’agit d’un animal en cage mortel, "use strict" peut être une bonne chose, mais vous devez le faire correctement. Le meilleur moment pour appliquer les règles strictes est lorsque votre projet est en chantier et que vous partez de zéro. Configurez JSHint/JSLint avec tous les avertissements et toutes les options que votre équipe peut supporter, obtenez un bon système de construction / test / affirmation du jour configuré comme Grunt+Karma+Chai , puis commencez à marquer tous vos nouveaux modules comme "use strict" . Préparez-vous à remédier à de nombreuses erreurs et avertissements. Assurez-vous que tout le monde comprend la gravité en configurant la construction sur FAIL si JSHint/JSLint génère des violations.

Mon projet n’était pas un projet nouveau lorsque j’ai adopté "use strict" . En conséquence, mon IDE est plein de marques rouges parce que je n'ai pas "use strict" sur la moitié de mes modules, et JSHint s'en plaint. Cela me rappelle ce que je devrais refactoriser à l'avenir. Mon objectif est de ne pas avoir de marque rouge en raison de toutes mes déclarations manquantes "use strict" , mais c’est dans des années.


Cet article sur le mode Javascript strict peut vous intéresser: John Resig - Mode strict ECMAScript 5, JSON, etc.

Pour citer quelques parties intéressantes:

Le mode strict est une nouvelle fonctionnalité d'ECMAScript 5 qui vous permet de placer un programme ou une fonction dans un contexte d'exploitation "strict". Ce contexte strict empêche certaines actions d'être exécutées et génère davantage d'exceptions.

Et:

Le mode strict aide de deux manières:

  • Il intercepte certaines erreurs de codage courantes, en lançant des exceptions.
  • Il empêche ou génère des erreurs lorsque des actions relativement "peu sûres" sont entreprises (telles que l'accès à l'objet global).
  • Il désactive les fonctionnalités déroutantes ou mal pensées.

Notez également que vous pouvez appliquer le "mode strict" à l'ensemble du fichier ... ou vous pouvez l'utiliser uniquement pour une fonction spécifique (citant toujours l'article de John Resig) :

// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code... 

Ce qui pourrait être utile si vous devez mélanger l'ancien et le nouveau code ;-)

Donc, je suppose que c'est un peu comme le "use strict" vous pouvez utiliser en Perl (d'où son nom?) : Cela vous aide à faire moins d'erreurs, en détectant plus de choses qui pourraient conduire à des ruptures.

Actuellement, il est supporté par tous les principaux navigateurs (sauf IE 9 et inférieur) .


Je recommande fortement à tous les développeurs de commencer à utiliser le mode strict dès maintenant. Il y a suffisamment de navigateurs qui le prennent en charge pour que le mode strict nous aide légitimement à nous préserver d’erreurs que nous ne savions même pas dans votre code.

Apparemment, au début, il y aura des erreurs que nous n'avons jamais rencontrées auparavant. Pour obtenir tous les avantages, nous devons effectuer les tests appropriés après le passage au mode strict afin de nous assurer que nous avons tout capturé. En définitive, nous ne jetons pas simplement use strict dans notre code et supposons qu’il n’ya pas d’erreur. Le problème est donc qu'il est temps de commencer à utiliser cette fonctionnalité linguistique extrêmement utile pour écrire un meilleur code.

Par exemple,

var person = {
    name : 'xyz',
    position : 'abc',
    fullname : function () {  "use strict"; return this.name; }
};

JSLint est un débogueur écrit par Douglas Crockford. Il vous suffit de coller votre script et il analysera rapidement tous les problèmes et erreurs évidents dans votre code.


La déclaration "use strict"; indique au navigateur d'utiliser le mode strict, qui est un ensemble de fonctionnalités réduites et sécurisées de JavaScript.

Liste de fonctionnalités (non exhaustive)

  1. Interdit les variables globales. (Attrape les déclarations var manquantes et les fautes de frappe dans les noms de variables)

  2. Les assignations qui échouent silencieusement jetteront l'erreur en mode strict (assigner NaN = 5; )

  3. Les tentatives de suppression des propriétés non effaçables vont générer ( delete Object.prototype )

  4. Requiert que tous les noms de propriété d'un littéral d'objet soient uniques ( var x = {x1: "1", x1: "2"} )

  5. Les noms de paramètre de fonction doivent être uniques ( function sum (x, x) {...} )

  6. Interdit la syntaxe octale ( var x = 023; certains développeurs supposent à tort qu’un zéro précédent ne change rien au nombre.)

  7. Interdit le with mot clé

  8. eval en mode strict n'introduit pas de nouvelles variables

  9. Interdire la suppression de noms simples ( delete x; )

  10. Interdit la liaison ou l'attribution des noms eval et des arguments sous n'importe quelle forme

  11. Le mode strict n'alias pas les propriétés de l'objet arguments avec les paramètres formels. (ie en function sum (a,b) { return arguments[0] + b;} Ceci fonctionne car les arguments[0] sont liés à a et ainsi de suite.)

  12. arguments.callee n'est pas supporté

[Ref: Mode strict , Réseau de développeurs Mozilla ]


Si les gens sont inquiets à propos de l' use strict consultez cet article:

ECMAScript 5 Prise en charge du «mode strict» dans les navigateurs. Qu'est-ce que ça veut dire?
NovoGeek.com - le blog de Krishna

Il parle de la prise en charge du navigateur, mais surtout de la manière de la gérer en toute sécurité:

function isStrictMode(){
    return !this;
} 
/*
   returns false, since 'this' refers to global object and 
   '!this' becomes false
*/

function isStrictMode(){   
    "use strict";
    return !this;
} 
/* 
   returns true, since in strict mode the keyword 'this'
   does not refer to global object, unlike traditional JS. 
   So here, 'this' is 'undefined' and '!this' becomes true.
*/

Citant de w3schools :

La directive "use strict"

La directive "use strict" est nouvelle dans JavaScript 1.8.5 (ECMAScript version 5).

Ce n'est pas une déclaration, mais une expression littérale, ignorée par les versions antérieures de JavaScript.

"Use strict" a pour but d'indiquer que le code doit être exécuté en "mode strict".

En mode strict, vous ne pouvez pas, par exemple, utiliser des variables non déclarées.

Pourquoi le mode strict?

Le mode strict facilite l'écriture de code JavaScript "sécurisé".

Les changements de mode stricts acceptés précédemment "mauvaise syntaxe" dans de vraies erreurs.

Par exemple, en JavaScript normal, une erreur de frappe dans le nom d'une variable crée une nouvelle variable globale. En mode strict, cela générera une erreur rendant impossible la création accidentelle d'une variable globale.

En JavaScript normal, un développeur ne recevra aucun retour d'erreur attribuant des valeurs à des propriétés non inscriptibles.

En mode strict, toute affectation à une propriété non-inscriptible, à une propriété getter only, à une propriété non-existante, à une variable non-existante ou à un objet non-existant générera une erreur.

Veuillez vous référer à http://www.w3schools.com/js/js_strict.asp pour en savoir plus.


"use strict"fait que le code JavaScript s'exécute en mode strict , ce qui signifie fondamentalement que tout doit être défini avant utilisation. La principale raison d'utiliser le mode strict est d'éviter les utilisations globales accidentelles de méthodes non définies.

Également en mode strict, les choses vont plus vite, certains avertissements ou avertissements silencieux génèrent des erreurs fatales, il est préférable de toujours l'utiliser pour créer un code plus net.

"use strict"est largement nécessaire pour être utilisé dans ECMA5, dans ECMA6 il fait partie de JavaScript par défaut , il n’a donc pas besoin de l’ajouter si vous utilisez ES6.

Regardez ces déclarations et exemples de MDN:

La directive "use strict"
La directive "use strict" est une nouveauté de JavaScript 1.8.5 (ECMAScript version 5). Ce n'est pas une déclaration, mais une expression littérale, ignorée par les versions antérieures de JavaScript. "Use strict" a pour but d'indiquer que le code doit être exécuté en "mode strict". En mode strict, vous ne pouvez pas, par exemple, utiliser des variables non déclarées.

Exemples d'utilisation de "use strict":
Mode strict pour les fonctions: De même, pour appeler le mode strict d'une fonction, placez l'énoncé exact "use strict"; (ou 'use strict';) dans le corps de la fonction avant toute autre déclaration.

1) mode strict dans les fonctions

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) mode strict de script entier

'use strict';
var v = "Hi! I'm a strict mode script!";
console.log(v);

3) Affectation à un global non-inscriptible

'use strict';

// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError

Vous pouvez en savoir plus sur MDN .


Mes deux centimes:

L'un des objectifs du mode strict est de permettre un débogage plus rapide des problèmes. Il aide les développeurs en générant une exception lorsque certaines choses fausses peuvent provoquer un comportement silencieux et étrange de votre page Web. Dès que nous utiliserons use strict , le code générera des erreurs, ce qui aidera le développeur à le corriger à l'avance.

Peu de choses importantes que j'ai apprises après avoir utilisé use strict :

Empêche la déclaration de variable globale:

var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};

function Tree(typeOfTree) {
    var age;
    var leafCount;

    age = typeOfTree.age;
    leafCount = typeOfTree.leafCount;
    nameoftree = typeOfTree.name;
};

var tree1 = new Tree(tree1Data);
console.log(window);

Maintenant, ce code crée nameoftree dans une portée globale accessible à l’aide de window.nameoftree . Lorsque nous implémentons use strict le code génère une erreur.

Uncaught ReferenceError: nameoftree n'est pas défini

Sample

Élimine with déclaration:

with déclarations ne peuvent pas être minifiées en utilisant des outils tels que uglify-js . Ils sont également deprecated et supprimés des futures versions de JavaScript.

Sample

Empêche les doublons:

Lorsque nous avons la propriété duplicate, il lève une exception

Uncaught SyntaxError: propriété de données en double dans le littéral d'objet non autorisée en mode strict

"use strict";
var tree1Data = {
    name: 'Banana Tree',
    age: 100,
    leafCount: 100000,
    name:'Banana Tree'
};

Il en reste peu, mais je dois acquérir plus de connaissances à ce sujet.


Le mode JavaScript «strict» est introduit dans ECMAScript 5.

  (function() {
  "use strict";
   your code...
   })();

écrire "use strict"; tout en haut de votre fichier JS active la vérification de la syntaxe stricte. Il effectue les tâches suivantes pour nous:

(i) affiche une erreur si vous essayez d'affecter une variable non déclarée

(ii) vous empêche d'écraser les principales bibliothèques du système JS

(ii) interdit certaines fonctionnalités linguistiques peu sûres ou sujettes à erreur

"use strict" fonctionne également dans les fonctions individuelles. Il est toujours préférable d’inclure "use strict" dans votre code.

Problème de compatibilité de navigateur: Les directives "use" sont censées être rétro-compatibles. Les navigateurs qui ne les prennent pas en charge ne verront qu'un littéral String non référencé. Alors, ils vont passer par-dessus et aller de l'avant.


Petit exemple à comparer:

Mode non strict:

for (i of [1,2,3]) console.log(i)

// output:
// 1
// 2
// 3

Mode strict:

'use strict';
for (i of [1,2,3]) console.log(i)

// output:
// Uncaught ReferenceError: i is not defined

Utiliser Strict est utilisé pour afficher les erreurs courantes et répétées de sorte qu'il soit traité différemment et modifie la façon dont le script Java s'exécute. Ces modifications sont les suivantes:

  • Empêche les globaux accidentels

  • Pas de doublons

  • Élimine avec

  • Élimine cette contrainte

  • Eval plus sûr ()

  • Erreurs pour immuables

vous pouvez également lire cet article pour les détails


"use strict"; L’ECMA s’efforce de rendre JavaScript un peu plus robuste. JS tente de le rendre au moins un peu "strict" (d'autres langages appliquent des règles strictes depuis les années 90). En fait, cela "oblige" les développeurs JavaScript à suivre une sorte de meilleure pratique de codage. Pourtant, JavaScript est très fragile. Il n’existe pas de variables typées, de méthodes typées, etc. Je recommande vivement aux développeurs JavaScript d’apprendre un langage plus robuste tel que Java ou ActionScript3, et d’implémenter les mêmes meilleures pratiques dans votre code JavaScript: cela fonctionnera mieux et sera plus facile à utiliser. déboguer.


Certaines personnes siégeant au comité ECMAScript ont parlé de: Modifications apportées à JavaScript, Partie 1: ECMAScript 5 " sur la manière dont l'utilisation incrémentielle du "use strict"commutateur permet aux développeurs JavaScript de nettoyer une grande partie des fonctionnalités dangereuses de JavaScript sans casser subitement chaque site Web. dans le monde.

Bien sûr, il est également question de la nature de ces dysfonctionnements et de la manière dont ECMAScript 5 les corrige.


Les principales raisons pour lesquelles les développeurs devraient utiliser "use strict"sont:

  1. Empêche la déclaration accidentelle de variables globales.L'utilisation "use strict()"permettra de s'assurer que les variables sont déclarées varavant leur utilisation. Par exemple:

    function useStrictDemo(){
     'use strict';
     //works fine
     var a = 'No Problem';
    
     //does not work fine and throws error
     k = "problem"
    
     //even this will throw error
     someObject = {'problem': 'lot of problem'};
    }
    
  2. NB: La "use strict"directive n'est reconnue qu'au début d'un script ou d'une fonction.
  3. La chaîne "arguments"ne peut pas être utilisée comme variable:

    "use strict";
    var arguments = 3.14;    // This will cause an error
    
  4. Limitera l'utilisation des mots-clés en tant que variables. Essayer de les utiliser va provoquer des erreurs.

En bref, votre code sera moins sujet aux erreurs et vous fera écrire un bon code.

Pour en savoir plus à ce sujet, vous pouvez vous référer ici .


Lors de l'ajout "use strict";, les cas suivants génèreront une SyntaxError avant l'exécution du script:

  • Préparant le terrain pour les futures versions de ECMAScript , en utilisant l' un des mots - clés nouvellement réservés (pour en prevision ECMAScript 6 ): implements, interface, let, package, private, protected, public, staticet yield.

  • Déclaration de fonction en blocs

    if(a<b){ function f(){} }
    
  • Syntaxe octale

    var n = 023;
    
  • this pointez sur l'objet global.

     function f() {
          "use strict";
          this.a = 1;
     };
     f(); 
    
  • Déclarer deux fois le même nom pour un nom de propriété dans un littéral d'objet

     {a: 1, b: 3, a: 7} 
    

    Ce n'est plus le cas dans ECMAScript 6 ( bug 1041128 ).

  • Déclarer deux arguments de fonction avec le même nom function

    f(a, b, b){}
    
  • Définition d'une valeur sur une variable non déclarée

    function f(x){
       "use strict";
       var a = 12;
       b = a + x*35; // error!
    }
    f();
    
  • Utiliser deletesur un nom de variabledelete myVariable;

  • Utiliser evalou argumentscomme nom d'argument de variable ou de fonction

    "use strict";
    arguments++;
    var obj = { set p(arguments) { } };
    try { } catch (arguments) { }
    function arguments() { } 
    

Sources:


Notez que cela a use strictété introduit dans EcmaScript 5 et a été conservé depuis.

Voici les conditions pour déclencher le mode strict dans ES6 et ES7 :

  • Le code global est un code de mode strict s'il commence par un prologue de directive contenant une directive d'utilisation stricte (voir 14.1.1).
  • Le code de module est toujours un code de mode strict.
  • Toutes les parties de ClassDeclaration ou de ClassExpression sont du code en mode strict.
  • Le code d'évaluation est un code de mode strict s'il commence par un directive Prologue contenant une directive d'utilisation stricte ou si l'appel à eval est une évaluation directe (voir 12.3.4.1) contenue dans un code de mode strict.
  • Le code de fonction est un code de mode strict si la fonction correspondante FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition ou ArrowFunction est contenue dans un code de mode strict ou si le code qui produit la valeur de l'emplacement interne de la fonction [[ECMAScriptCode]] commence par une directive prologue. qui contient une directive d'utilisation stricte.
  • Le code de fonction fourni en tant qu'arguments des constructeurs intégrés Function et Generator correspond au code de mode strict si le dernier argument est une chaîne qui, une fois traitée, est un FunctionBody commençant par un prologue de directive contenant une directive d'utilisation stricte.




use-strict