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




nodejs mode (21)

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?


Answers

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

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.


Inclure use strictau début de vos fichiers JavaScript sensibles à partir de ce point est un moyen simple d’être un meilleur programmeur JavaScript et d’éviter que des variables aléatoires ne deviennent globales et que les choses changent en silence.


C'est une nouvelle fonctionnalité d'ECMAScript 5. John Resig en a rédigé un beau résumé .

C'est juste une chaîne que vous mettez dans vos fichiers JavaScript (en haut de votre fichier ou à l'intérieur d'une fonction) qui ressemble à ceci:

"use strict";

Le placer dans votre code maintenant ne devrait poser aucun problème avec les navigateurs actuels, car il ne s'agit que d'une chaîne. Cela pourrait causer des problèmes avec votre code à l'avenir si votre code violait le pragma. Par exemple, si vous avez actuellement foo = "bar" sans définir foo préalable, votre code va commencer à échouer ... ce qui est une bonne chose à mon avis.


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.


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.


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.

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.
*/

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:


Je voudrais offrir une réponse un peu plus fondée complétant les autres réponses. J'espérais modifier la réponse la plus populaire, mais j'ai échoué. J'ai essayé de le rendre aussi complet et complet que possible.

Vous pouvez vous référer à la documentation MDN pour plus d'informations.

"use strict" une directive introduite dans ECMAScript 5.

Les directives sont similaires aux déclarations, mais différentes.

  • use strict ne contient pas de mots clés: La directive est une instruction d'expression simple, composée d'un littéral de chaîne spécial (entre guillemets simples ou doubles). Les moteurs JavaScript, qui n'implémentent pas ECMAScript 5, voient simplement une expression sans effets secondaires. On s'attend à ce que les futures versions des normes ECMAScript introduisent l' use comme un véritable mot clé. les citations deviendraient ainsi obsolètes.
  • use strict ne peut être utilisé qu'au début d'un script ou d'une fonction, c'est-à-dire qu'il doit précéder toute autre instruction (réelle). Il ne doit pas nécessairement s'agir de la première instruction d'un script de fonction: elle peut être précédée par d'autres expressions d'instruction constituées de littéraux de chaîne (et les implémentations JavaScript peuvent les traiter comme des directives spécifiques à l'implémentation). Les instructions littérales de chaîne, qui suivent une première instruction réelle (dans un script ou une fonction), sont des instructions d'expression simples. Les interprètes ne doivent pas les interpréter comme des directives et elles n’ont aucun effet.

La directive use strict indique que le code suivant (dans un script ou une fonction) est un code strict. Le code situé au plus haut niveau d'un script (code qui ne fait pas partie d'une fonction) est considéré comme un code strict lorsque le script contient une directive use strict . Le contenu d'une fonction est considéré comme du code strict lorsque la fonction elle-même est définie dans un code strict ou lorsque la fonction contient une directive use strict . Le code transmis à une méthode eval() est considéré comme un code strict lorsque eval() été appelé à partir d'un code strict ou contient la directive use strict elle-même.

Le mode strict de ECMAScript 5 est un sous-ensemble restreint du langage JavaScript, qui élimine les déficits pertinents du langage, offre une vérification des erreurs plus stricte et une sécurité accrue. La liste suivante répertorie les différences entre le mode strict et le mode normal (dont les trois premiers sont particulièrement importants):

  • Vous ne pouvez pas utiliser l'option with -statement en mode strict.
  • En mode strict, toutes les variables doivent être déclarées: si vous affectez une valeur à un identificateur qui n'a pas été déclaré en tant que variable, fonction, paramètre de fonction, paramètre de clause catch ou propriété de l' Object global, vous obtiendrez une ReferenceError . En mode normal, l'identifiant est implicitement déclaré en tant que variable globale (en tant que propriété de l' Object global).
  • En mode strict, le mot clé this a la valeur undefined dans les fonctions appelées en tant que fonctions (et non en tant que méthodes). (En mode normal, this pointe toujours sur l' Object global). Cette différence peut être utilisée pour tester si une implémentation prend en charge le mode strict:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • De même, lorsqu'une fonction est appelée avec call() ou apply en mode strict, il s'agit exactement de la valeur du premier argument de l' call() ou apply() . (En mode normal, null et undefined sont remplacés par l' Object global et les valeurs, qui ne sont pas des objets, sont converties en objets.)

  • En mode strict, vous obtenez une TypeError lorsque vous essayez d'affecter des propriétés en lecture seule ou de définir de nouvelles propriétés pour un objet non extensible. (En mode normal, les deux échouent simplement sans message d'erreur.)

  • En mode strict, lors du passage du code à eval() , vous ne pouvez pas déclarer ou définir des variables ou des fonctions dans le périmètre de l'appelant (comme vous pouvez le faire en mode normal). Au lieu de cela, une nouvelle portée est créée pour eval() et les variables et fonctions se trouvent dans cette portée. Cette étendue est détruite après l'exécution de eval() .
  • En mode strict, l'objet arguments d'une fonction contient une copie statique des valeurs qui sont transmises à cette fonction. En mode normal, l'objet arguments a un comportement quelque peu "magique": les éléments du tableau et les paramètres de la fonction nommée font référence à la même valeur.
  • En mode strict, vous obtenez une SyntaxError lorsque l'opérateur de delete est suivi d'un identifiant non qualifié (une variable, une fonction ou un paramètre de fonction). En mode normal, l'expression delete ne ferait rien et est évaluée à false .
  • En mode strict, vous obtenez une TypeError lorsque vous essayez de supprimer une propriété non configurable. (En mode normal, la tentative échoue et l'expression de delete est évaluée à false ).
  • En mode strict, une erreur de syntaxe est considérée lorsque vous essayez de définir plusieurs propriétés portant le même nom pour un littéral d'objet. (En mode normal, il n'y a pas d'erreur.)
  • En mode strict, une erreur de syntaxe est considérée lorsqu'une déclaration de fonction a plusieurs paramètres portant le même nom. (En mode normal, il n'y a pas d'erreur.)
  • En mode strict, les littéraux octaux ne sont pas autorisés (il s'agit de littéraux commençant par 0x . (En mode normal, certaines implémentations autorisent les littéraux octaux.)
  • En mode strict, les identifiants eval et les arguments sont traités comme des mots-clés. Vous ne pouvez pas modifier leur valeur, vous ne pouvez pas leur attribuer de valeur et vous ne pouvez pas les utiliser comme noms pour des variables, des fonctions, des paramètres de fonction ou des identificateurs d'un bloc catch.
  • En mode strict, il existe davantage de restrictions sur les possibilités d’examen de la pile d’appels. arguments.caller et arguments.callee provoquent une TypeError dans une fonction en mode strict. De plus, certaines propriétés des fonctions appelant et arguments en mode strict provoquent une TypeError lorsque vous essayez de les lire.

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 ]


Normalement, java script ne suit pas de règles strictes, ce qui augmente les risques d'erreur. Après utilisation "use strict", le code de script java doit suivre un ensemble de règles strictes, comme dans d'autres langages de programmation tels que l'utilisation de terminateurs, la déclaration avant l'initialisation, etc.

Si "use strict"est utilisé, le code doit être écrit en suivant un ensemble de règles strictes, ce qui diminue les risques d'erreurs et d'ambiguïtés.


Si vous utilisez un navigateur publié au cours de la dernière année environ, il prend probablement en charge le mode JavaScript strict. Seuls les anciens navigateurs avant qu'ECMAScript 5 ne devienne la norme actuelle ne la prennent pas en charge.

Les guillemets autour de la commande permettent de s’assurer que le code fonctionnera toujours dans les navigateurs plus anciens (bien que les choses qui génèrent une erreur de syntaxe en mode strict causent généralement un dysfonctionnement du script de manière assez difficile à détecter dans ces navigateurs plus anciens).


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.


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


"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 .


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 .


use strict est un moyen de rendre votre code plus sûr, car vous ne pouvez pas utiliser de fonctionnalités dangereuses qui ne fonctionnent pas comme prévu. Et comme cela a été écrit avant de rendre le code plus strict.


Le mode strict apporte plusieurs modifications à la sémantique JavaScript normale:

  • élimine certaines erreurs silencieuses JavaScript en les changeant pour générer des erreurs.

  • corrige les erreurs qui rendent difficile l'optimisation pour les moteurs JavaScript.

  • interdit certaines syntaxes susceptibles d'être définies dans les futures versions d'ECMAScript.

pour plus d'informations vistit Strict Mode- Javascript


Chaque fois que vous voyez le mot-clé de fonction dans une autre fonction, la fonction interne a accès aux variables de la fonction externe.

function foo(x) {
  var tmp = 3;

  function bar(y) {
    console.log(x + y + (++tmp)); // will log 16
  }

  bar(10);
}

foo(2);

Cela consignera toujours 16, car bar peut accéder au x défini comme argument de foo et à tmp de foo .

C'est une fermeture. Une fonction n'a pas à retourner pour s'appeler une fermeture. Accéder simplement à des variables en dehors de votre portée lexicale immédiate crée une fermeture .

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + (++tmp)); // will also log 16
  }
}

var bar = foo(2); // bar is now a closure.
bar(10);

La fonction ci-dessus consignera également le journal 16, car bar peut toujours se référer à x et à tmp , même s’il ne se trouve plus directement dans la portée.

Cependant, étant donné que tmp traîne toujours à l'intérieur de la fermeture du bar , il est également incrémenté. Il sera incrémenté chaque fois que vous appelez bar .

L'exemple le plus simple d'une fermeture est le suivant:

var a = 10;

function test() {
  console.log(a); // will output 10
  console.log(b); // will output 6
}
var b = 6;
test();

Lorsqu'une fonction JavaScript est appelée, un nouveau contexte d'exécution est créé. Avec les arguments de la fonction et l'objet parent, ce contexte d'exécution reçoit également toutes les variables déclarées en dehors de celui-ci (dans l'exemple ci-dessus, les deux expressions "a" et "b").

Il est possible de créer plusieurs fonctions de fermeture, soit en renvoyant une liste de celles-ci, soit en les définissant comme variables globales. Tous feront référence au même x et au même tmp , ils ne font pas leurs propres copies.

Ici, le nombre x est un nombre littéral. Comme avec les autres littéraux en JavaScript, lorsque foo est appelé, le nombre x est copié dans foo tant qu'argument x .

D'autre part, JavaScript utilise toujours des références lorsqu'il traite des objets. Si par exemple, vous avez appelé foo avec un objet, la fermeture qu'il renvoie fera référence à cet objet d'origine!

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + tmp);
    x.memb = x.memb ? x.memb + 1 : 1;
    console.log(x.memb);
  }
}

var age = new Number(2);
var bar = foo(age); // bar is now a closure referencing age.
bar(10);

Comme prévu, chaque appel à la bar(10) incrémentera x.memb . Ce qui pourrait ne pas être attendu, c'est que x fait simplement référence au même objet que la variable age ! Après quelques appels au bar , age.memb sera 2! Ce référencement constitue la base des fuites de mémoire avec les objets HTML.





javascript syntax jslint use-strict