c'est une nouvelle caractéristique D'ECMAScript 5. John Resig a écrit un résumé agréable de celui-ci.

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

"use strict";

mettre dans votre code maintenant ne devrait pas causer de problèmes avec les navigateurs actuels comme il est juste une chaîne de caractères. Il peut causer des problèmes avec votre code dans le futur si votre code viole les pragma. Par exemple, si vous avez actuellement foo = "bar" sans définir d'abord foo , votre code va commencer à échouer...ce qui est une bonne chose à mon avis.

l'instruction "use strict"; indique au navigateur D'utiliser le mode Strict, qui est un ensemble réduit et plus sûr de fonctionnalités de JavaScript.

liste des caractéristiques (non exhaustive)

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

1519220920 1519170920 NaN = 5; )

2. les tentatives pour supprimer les propriétés indélébiles vont jeter ( delete Object.prototype )

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

4. les noms des paramètres de fonction doivent être uniques ( function sum (x, x) {...} )

5. Interdit octal syntaxe ( var x = 023; certains devs assumer à tort, qu'un précédent zéro ne fait rien pour changer le nombre.)

6. interdit le with mot-clé

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

8. interdit de supprimer des noms simples ( delete x; )

9. interdit de lier ou de céder les noms eval et arguments sous quelque forme que ce soit

10. mode Strict ne permet pas d'alias des propriétés de l'objet arguments avec les paramètres formels. (c'est à dire en function sum (a,b) { return arguments[0] + b;} Cela fonctionne parce que arguments[0] est lié à a et ainsi de suite. )

11. arguments.callee n'est pas supporté

[Réf: mode Strict , Mozilla Developer Réseau ]

si les gens sont préoccupés par l'utilisation de use strict il pourrait être intéressant de vérifier cet article:

ECMAScript 5 'mode Strict' support dans les navigateurs. Qu'est-ce que cela signifie?

NovoGeek.com -le blog de Krishna

il parle de la prise en charge du navigateur, mais surtout comment le 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.
*/

un mot de prudence, tous les programmeurs qui chargent dur: appliquer "use strict" au code existant peut être dangereux! Cette chose n'est pas un sticker se sentir-bien, visage-heureux que vous pouvez gifler sur le code pour le rendre "meilleur". Avec le "use strict" pragma, le navigateur va soudainement jeter des exceptions dans des endroits aléatoires qu'il n'a jamais jeté avant juste parce qu'à cet endroit vous faites quelque chose que par défaut/JavaScript lâche heureusement permet mais JavaScript strict abhorre! Vous pouvez avoir violations de la rigueur se cacher dans les appels rarement utilisés dans votre code qui ne fera que jeter une exception quand ils font éventuellement courir-disons, dans l'environnement de production que vos clients payeurs utilisent!

si vous allez plonger, c'est une bonne idée d'appliquer "use strict" aux côtés des tests complets de l'unité et une tâche de construction JSHint strictement configurée qui vous donnera une certaine confiance qu'il n'y a pas de coin sombre de votre module qui va exploser horriblement juste parce que vous avez activé le mode Strict. Ou, Hey, voici une autre option: Ne pas ajouter "use strict" à l'un de vos codes d'héritage, c'est probablement plus sûr de cette façon, honnêtement. certainement pas ajouter "use strict" à tous les modules que vous ne possédez pas ou ne maintenez pas, comme les modules tiers.

je pense que même si c'est un animal en cage mortelle, "use strict" peut être une bonne chose, mais vous devez le faire correctement. Le meilleur moment pour devenir strict est quand votre projet est greenfield et vous partez de zéro. Configurer JSHint/JSLint avec tous les avertissements et options activés aussi serrés que votre équipe peut le supporter, obtenir un bon build/test/assert système du jour réglé comme Grunt+Karma+Chai , et seulement alors commencer à marquer tous vos nouveaux modules comme "use strict" . Préparez-vous à corriger un grand nombre d'erreurs et de mises en garde. Assurez-vous que tout le monde comprend la gravité en configurant la construction pour QU'elle échoue si JSHint/JSLint produit des violations.

My project n'était pas un projet entièrement nouveau lorsque j'ai adopté "use strict" . Par conséquent, mon IDE est rempli de marques rouges parce que je n'ai pas "use strict" sur la moitié de mes modules, et JSHint s'en plaint. C'est un rappel de ce que je devrais faire à l'avenir. Mon but est d'être sans marque rouge à cause de toutes mes déclarations manquantes "use strict" , mais c'est dans des années.

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

le mode strict JavaScript est une caractéristique dans ECMAScript 5 . Vous pouvez activer le mode strict en le déclarant en haut de votre script/fonction.

'use strict';

quand un moteur JavaScript voit cette directive , il commencera à interpréter le code dans un mode spécial. Dans ce mode, les erreurs sont lancés lorsque certaines pratiques de codage qui pourraient finir par être des bogues potentiels sont détectés (ce qui est le raisonnement derrière le mode strict).

considérons cet exemple:

var a = 365;
var b = 030;

dans leur obsession à aligner les littérales numériques, le développeur a par inadvertance initialisé la variable b avec un octal littéral. Le mode Non-strict interprétera cela comme un littéral numérique avec la valeur 24 (en base 10). Cependant, la stricte mode lèvera une erreur.

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

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

• dans mon nouveau application JavaScript: absolument! mode Strict peut être utilisé comme un lanceur d'alerte lorsque vous faites quelque chose de stupide avec votre code.

• dans mon existant code JavaScript: probablement pas! si votre code JavaScript existant contient des affirmations qui sont interdites en mode strict, l'application se brisera tout simplement. Si vous voulez le mode strict, vous devriez être prêt à déboguer et corriger votre code existant. C'est pourquoi en utilisant 'use strict'; ne rend pas soudainement votre code mieux .

comment utiliser le mode strict?

1. insérez une déclaration 'use strict'; en haut de 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 haut de votre corps de la fonction:

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

   tout dans le portée 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 qui sont interdites en mode strict (notez qu'il ne s'agit pas d'une liste exclusive):

domaine d'application

historiquement, JavaScript a été confondu sur la façon dont les fonctions sont passées en revue. Parfois, ils semblent avoir une portée statique, mais certains les traits les font se comporter comme ils sont dynamiquement scoped. C'est confus, ce qui rend les programmes difficiles à lire et à comprendre. Les malentendus causent des bugs. C'est aussi un problème pour la performance. La détermination statique de la portée permettrait une liaison variable au moment de la compilation. le temps, mais l'exigence de portée dynamique signifie que la liaison doit être différé à l'exécution, qui s'accompagne d'une performance significative pénalité.

mode Strict exige que toutes les variables de liaison être fait de manière statique. Cela signifie que les caractéristiques qui exigeaient auparavant une liaison dynamique doit être éliminé ou modifié. Plus précisément, l'instruction éliminé, et le la capacité de la fonction eval à modifier l'environnement de son interlocuteur est sévèrement restreint.

L'un des avantages du code strict est que des outils comme compresseur YUI peut faire un meilleur travail lors du traitement.

Variables Globales Implicites

JavaScript a impliqué des variables globales. Si vous n'avez pas explicitement déclarer une variable, une variable globale est implicitement déclarée pour vous. Cela rend la programmation plus facile pour débutants parce qu'ils peuvent négliger certaines de leurs tâches ménagères de base corvée. Mais il rend la gestion des grands programmes beaucoup plus difficile, et il dégrade la fiabilité. Donc, dans le strict mode, les variables globales implicites ne sont plus créées. Vous devriez déclarez explicitement toutes vos variables.

"1519580920 Globale" Fuite

il y a un certain nombre de situations qui pourraient causer this d'être lié à l'objet global. Par exemple, si vous oubliez de fournir le préfixe new lors de l'appel d'une fonction de constructeur, le le this du constructeur sera lié de manière inattendue à l'objet global, donc au lieu d'initialiser un nouvel objet, il sera plutôt silencieux falsification de variables globales. Dans ces situations, le mode strict liez plutôt this à undefined , ce qui fera que le constructeur jeter une exception à la place, en permettant l'erreur pour être détecté beaucoup bientôt.

Bruyant "Échec 1519590920"

JavaScript a toujours eu des propriétés en lecture seule, mais vous ne pouvait pas les créer vous-même jusqu'à ES5's Object.createProperty fonction a exposé cette capacité. Si vous avez tenté d'attribuer une valeur pour une propriété en lecture seule, elle échouerait silencieusement. La mission ne modifiez pas la valeur de la propriété, mais votre programme si elle avait. C'est un danger d'intégrité qui peut causer les programmes de aller dans un état incohérent. En mode strict, en essayant de changer un propriété en lecture seule lèvera une exception.

Octal

la représentation octale (ou base 8) des nombres était extrêmement utile pour la programmation au niveau de la machine sur les machines dont le mot les tailles étaient un multiple de 3. Tu avais besoin d'octal quand tu travaillais avec le CDC. 6600 mainframe, qui avait une taille de mot de 60 bits. Si vous avez pu lire octal, tu pourrais regardez un mot comme 20 chiffres. Deux chiffres représentés le code op et un chiffre identifient l'un des huit registres. Au cours de la transition lente des codes machines aux langages de haut niveau, il a été jugé utile pour fournir des formes octales dans les langages de programmation.

En C, une très malheureux de la représentation de octalness a été sélectionné: zéro. Ainsi, en C, 0100 signifie 64, pas 100, et 08 est un erreur, pas 8. Encore plus malheureusement, cet anachronisme a été copié dans presque toutes les langues modernes, y compris le JavaScript, où il est seulement utilisé pour créer des erreurs. Il n'a pas d'autre but. Donc, en mode strict, les formes octales ne sont plus autorisées.

et cetera

les arguments pseudo array devient un peu plus comme un tableau dans ES5. En mode strict, il perd ses callee et caller propriété. Cela permet de passer votre arguments à non approuvés code sans donner beaucoup de confidentiel. Aussi, l' arguments la propriété des fonctions est éliminée.

en mode strict, dupliquer des touches dans une fonction littérale produira un erreur de syntaxe. Une fonction ne peut pas avoir deux paramètres avec le même nom. Une fonction ne peut pas avoir une variable avec le même nom que l'une de ses paramètre. Une fonction ne peut pas delete ses propres variables. Une tentative de delete une propriété non configurable maintenant jette une exception. Primitif les valeurs ne sont pas implicitement enveloppé.

mots réservés pour les futures versions JavaScript

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

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

Lectures Complémentaires

• mode Strict-JavaScript | MDN
• prise en charge du mode strict par le navigateur
• passage au mode strict

je recommande fortement à chaque développeur de commencer à utiliser le mode strict maintenant. Il y a suffisamment de navigateurs qui le supportent que le mode strict nous aidera légitimement à nous sauver des erreurs que nous ne savions même pas être dans votre code.

Apparemment, au stade initial, il y aura des erreurs que nous n'avons jamais rencontré avant. Pour obtenir le plein bénéfice, nous devons faire des tests appropriés après avoir commuté en mode strict pour s'assurer que nous avons tout pris. Certainement nous n'avons pas de simplement jeter use strict dans notre code et supposons qu'il n'y a pas d'erreurs. Donc, le roulement est qu'il est temps de commencer à utiliser cette fonction de langage incroyablement 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 suffit de coller dans votre script, et il va rapidement scanner tous les problèmes et les erreurs perceptibles dans votre code.

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

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

"use strict" une directive introduite en ECMAScript 5.

Directives sont similaires à des déclarations, pourtant différent.

• use strict ne contient pas de mots clés: la directive est une simple déclaration d'expression, qui se compose d'une chaîne spéciale littérale (en guillemets simples ou doubles). Les moteurs JavaScript, qui n'implémentent pas ECMAScript 5, voient simplement une déclaration d'expression sans effets secondaires. On s'attend à ce que les futures versions des normes ECMAScript introduisent use comme un vrai 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 déclaration (réelle). Elle ne doit pas nécessairement être la première instruction d'un script de fonction: elle peut être précédée par d'autres expressions de déclaration qui consistent en des lignes littérales ( et les implémentations JavaScript peuvent les traiter comme des directives spécifiques d'implémentation). Les énoncés littéraux de chaîne, qui suivent une première vraie déclaration (dans un script ou une fonction) sont des expressions simples déclaration. 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 du code strict. Le code au plus haut niveau d'un script (code qui n'est pas dans une fonction) est considéré comme code strict lorsque le script contient une directive use strict . Le contenu d'une fonction est considéré comme 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 qui est passé à une méthode eval() est considéré comme un code strict lorsque eval() a été appelé à partir d'un code strict ou contient la directive use strict elle-même.

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

• vous ne pouvez pas utiliser la with - déclaration en mode strict.
• en mode strict toutes les variables doivent être déclarées: si vous assignez une valeur à un identifiant qui n'a pas été déclaré comme variable, fonction, paramètre de fonction, paramètre de clause générale ou propriété du global Object , alors vous obtiendrez un ReferenceError . En mode normal, l' identifier est implicitement déclaré comme une variable globale (en tant que propriété du global Object )
• dans le mode strict le mot-clé this a la valeur undefined dans les fonctions qui ont été invoquées en tant que fonctions (et non en tant que méthodes). (En mode normal this indique toujours le global Object ). Cette différence peut être utilisée pour tester si une implémentation supporte le mode strict:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

• même lorsqu'une fonction est invoquée avec call() ou apply en mode strict, alors this est exactement la valeur du premier argument de l'invocation call() ou apply() . (En mode normal null et undefined sont remplacés par le global Object et les valeurs, qui ne sont pas des objets, sont jetées dans des objets.)

• en mode strict vous obtiendrez un TypeError , quand vous essayez d'assigner des propriétés à readonly ou de définir de nouvelles propriétés pour un objet non extensible. (Dans le mode normal les deux échouent simplement sans message d'erreur.)

• en mode strict, en passant le code à eval() , vous ne pouvez pas déclarer ou définir des variables ou des fonctions dans la portée 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 les fonctions sont dans cette portée. Cette portée est détruite après eval() termine l'exécution.
• en mode strict l'objet arguments d'une fonction contient une copie statique des valeurs, qui sont passées à cette fonction. En mode normal, l'objet arguments a un comportement un peu "magique": les éléments du tableau et les paramètres nommés de la fonction font référence à la fois à la même valeur.
• en mode strict, vous obtiendrez un SyntaxError lorsque l'opérateur delete est suivi d'un identifiant non qualifié (un variable, Fonction Ou paramètre de fonction). En mode normal, l'expression delete ne ferait rien et est évaluée à false .
• En mode strict, vous obtiendrez un TypeError lorsque vous essayez de supprimer une propriété configurable. (En mode normal, la tentative échoue tout simplement et l'expression delete est évaluée à false ).
• en mode strict, il est considéré comme une erreur syntaxique lorsque vous essayez de définir plusieurs propriétés avec le même nom pour un objet littéral. (En mode normal, il n'y a pas d'erreur.)
• en mode strict, il est considéré comme une erreur syntaxique lorsqu'une déclaration de fonction a plusieurs paramètres avec le même nom. (En mode normal, il n'y a pas d'erreur.)
• en mode strict les littérales octales ne sont pas permises (ce sont des littérales qui commencent par 0x . (En mode normal, certaines implémentations permettent des littérales octales.)
• en mode strict les identificateurs eval et arguments sont traités comme des mots clés. Vous ne pouvez pas changer leur valeur, ne pouvez pas leur assigner une valeur, et vous ne pouvez pas les utiliser comme noms pour les variables, les fonctions, les paramètres de fonction ou les identificateurs d'un bloc de capture.
• En mode strict sont plus de restrictions sur les possibilités d'examiner la pile d'appel. arguments.caller et arguments.callee causent un TypeError dans une fonction en mode strict. En outre, certains interlocuteurs et arguments les propriétés des fonctions en mode strict causent un TypeError quand vous essayez de les lire.

mes deux cents:

l'un des objectifs du mode strict est de permettre un débogage plus rapide des problèmes. Il aide les développeurs en jetant l'exception quand certaines mauvaises choses se produisent qui peuvent causer le comportement silencieux et étrange de votre page web. Au moment où nous utiliserons use strict , le code jettera des erreurs qui aideront 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 Des Variables Globales:

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 la portée globale qui pourrait être accessible en utilisant window.nameoftree . Lorsque nous implémentons use strict le code lancerait l'erreur.

Uncaught Referenceeror: nameoftree is not defined

échantillon

élimine with déclaration:

with les déclarations ne peuvent pas être minimisées en utilisant des outils comme uglify-js . Ils sont aussi dépréciés et supprimés des futures versions JavaScript.

échantillon

Empêche Les Doublons:

quand nous avons des propriétés dupliquées, il lance une exception

Uncaught SyntaxError: Dupliquer les données de propriété dans l'objet littéral pas autorisé en mode strict

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

il y en a peu d'autres, mais j'ai besoin d'en savoir plus à ce sujet.

si vous utilisez un navigateur libéré dans la dernière année ou alors il soutient très probablement le mode Strict JavaScript. Seuls les navigateurs plus anciens avant que ECMAScript 5 ne devienne la norme actuelle ne le supportent pas.

les guillemets autour de la commande s'assurent que le code fonctionnera toujours dans les navigateurs plus anciens aussi bien (bien que les choses qui génèrent une erreur de syntaxe en mode strict causeront généralement juste le script de dysfonctionnement d'une certaine manière difficile à détecter dans les plus anciens navigateur.)

le mode Strict apporte plusieurs modifications à la sémantique JavaScript normale:

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

• corrige des erreurs qui rendent JavaScript difficile moteurs pour effectuer des optimisations.

• interdit une syntaxe susceptible d'être définie à l'avenir versions D'ECMAScript.

pour plus d'information visitez mode Strict-Javascript

en ajoutant "use strict"; , les cas suivants lanceront un SyntaxError avant l'exécution du script:

• ouvrant la voie à de futures versions ECMAScript , en utilisant l'un des nouveaux mots-clés réservés (en prévision de ECMAScript 6 ): implements , interface , let , package , private , protected , public , static , et yield .

• déclaration de la fonction dans les blocs

  if(a<b){ function f(){} }
  

• syntaxe Octal

  var n = 023;
  

• this pointez vers 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 objet littéral

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

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

• Déclarant deux arguments de la fonction avec le même nom de fonction

  f(a, b, b){}
  

• fixer une valeur à une variable non déclarée

  function f(x){
     "use strict";
     var a = 12;
     b = a + x*35; // error!
  }
  f();
  

• utilisant delete sur un nom variable delete myVariable;

• utilisant eval ou arguments comme nom d'argument de variable ou de fonction

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

Sources:

• passage au mode strict on MDN

• mode Strict on MDN

• le mode Strict de JavaScript et pourquoi Vous devez L'utiliser sur le blog de Colin J. Ihrig (version archivée)

"use Strict"; c'est une assurance que le programmeur n'utilisera pas les lâches ou les mauvaises propriétés de JavaScript. C'est un guide, tout comme une règle vous aidera à faire des lignes droites. "Utiliser Strict" vous aidera à faire "Straight coding".

ceux qui préfèrent ne pas utiliser de règles pour faire leurs lignes droites finissent généralement dans ces pages demandant aux autres de déboguer leur code.

croyez-moi. Les frais généraux sont négligeables par rapport au code mal conçu. Doug Crockford, qui a été un développeur JavaScript senior pendant plusieurs années, a un poste très intéressant ici . Personnellement, j'aime retourner sur son site tout le temps pour m'assurer que je n'oublie pas ma bonne pratique.

la pratique moderne du JavaScript devrait toujours évoquer l '"utilisation stricte"; pragma. la seule raison pour laquelle le groupe ECMA a rendu le mode "Strict" optionnel est de permettre aux codeurs moins expérimentés l'accès à JavaScript et donner ensuite le temps de s'adapter aux nouvelles pratiques de codage plus sûres.

y compris use strict au début de vos fichiers JavaScript sensibles à partir de ce point est un petit moyen d'être un meilleur programmeur JavaScript et éviter que les variables aléatoires deviennent globales et les choses changent silencieusement.

citant w3schools :

Le "use strict" Directive

la directive "utiliser strictement" est nouvelle en Javascript 1.8.5 (ECMAScript la version 5).

il ne s'agit pas d'une déclaration, mais d'une expression littérale, ignorée par versions de JavaScript.

Le but de "use strict" est pour indiquer que le code doit être exécuté en "mode strict".

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

Pourquoi Le Mode Strict?

le mode Strict rend plus facile d'écrire" secure " JavaScript.

le mode Strict change la "mauvaise syntaxe" précédemment acceptée en erreurs réelles.

par exemple, dans JavaScript normal, un nom de variable créé par erreur une nouvelle variable globale. Dans mode strict, cela lancera une erreur, rendant impossible accidentellement créer une variable globale.

dans JavaScript normal, un développeur ne recevra pas de rétroaction d'erreur l'affectation de valeurs à des non-inscriptible propriétés.

au sens strict, toute cession à un bien non cessible, de lecture-seule propriété, un non-existant de la propriété, un non-existant une variable ou un objet inexistant, lèvera une erreur.

consultez http://www.w3schools.com/js/js_strict.asp pour en savoir plus

il y a une bonne discussion de la part de certaines personnes qui faisaient partie du Comité ECMAScript: modifications à JavaScript, Partie 1: ECMAScript 5" sur la façon dont l'utilisation progressive du commutateur "use strict" permet aux responsables de la mise en œuvre JavaScript de nettoyer un grand nombre des caractéristiques dangereuses de JavaScript sans briser soudainement tous les sites web dans le monde.

bien sûr, il parle aussi de ce que beaucoup de ces erreurs sont (étaient) et comment ECMAScript 5 les corrige.

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

aussi en mode strict, les choses vont plus vite, certains avertissements ou avertissements silencieux lancent des erreurs fatales, il est préférable de toujours l'utiliser pour faire 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 d'être ajouté si vous utilisez ES6.

regardez ces énoncés et les exemples de MDN:

la directive "utilisation stricte

la directive" utilisation stricte " est nouvelle en JavaScript 1.8.5 (ECMAScript version 5). Ce n'est pas une affirmation, mais une expression littérale, ignorée par versions de JavaScript. Le le but de "use strict" est d'indiquer que le code devrait être exécuté en "mode strict". Avec le mode strict, vous ne pouvez pas, par exemple, utilisez des variables non déclarées.

exemples d'utilisation "":

Mode Strict pour les fonctions: de même, pour invoquer le mode strict pour un fonction, Mettre la déclaration exacte "utiliser strict"; (ou "utiliser strict";) dans la fonction du corps avant toute autre déclaration.

1) mode strict en fonction

 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) script entier mode strict

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

3) cession à un non-writable global

'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 pour en savoir plus sur MDN .

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

ci-dessous sont les conditions pour déclencher le mode strict dans ES6 et ES7 :

• code Mondial est en mode strict code s'il commence par une Directive Prologue qui contient une Utilisation Stricte de la Directive (voir 14.1.1).
Le code du Module
• est toujours le mode strict code.
• toutes les parties d'un Classdéclaration ou un ClassExpression sont des codes de mode stricts.
• code Eval est code mode strict s'il commence par un Prologue de Directive qui contient une directive Use Strict ou si l'appel à eval est une eval directe (voir 12.3.4.1) qui est contenue dans le code mode strict.
• code de fonction est le code de mode strict si l'associé FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, ou ArrowFunction est contenue dans le strict code de mode ou si le code qui produit de la valeur de la fonction [[ECMAScriptCode]] fente interne commence par une Directive Prologue qui contient une Utilisation Stricte de la Directive.
• code de fonction qui est fourni comme arguments à la fonction intégrée et les constructeurs de générateur est le code de mode strict si le dernier argument est une chaîne de caractères qui, lorsqu'elle est traitée, est une FunctionBody qui commence par un Prologue de Directive qui contient une directive D'utilisation stricte.

petit exemple à comparer:

Non-mode 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

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 de "use strict()" permettra de s'assurer que les variables sont déclarées avec var avant l'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. N. B: la directive "use strict" n'est reconnue qu'au début d'un script ou d'une fonction.

3. La chaîne "arguments" ne peut pas être utilisé comme variable:

   "use strict";
   var arguments = 3.14;    // This will cause an error
   

4. limitera l'utilisation des mots-clés comme variables. Essayer de les utiliser lancera des erreurs.

en bref fera de votre code moins d'erreur et à son tour vous fera écrire du bon code.

pour en savoir plus, vous pouvez vous référer à ici .

use strict est un moyen de rendre votre code plus sûr, parce que vous ne pouvez pas utiliser des caractéristiques dangereuses qui ne peuvent pas fonctionner comme vous l'attendez.Et comme il a été écrit avant il rend le code plus strict.

"use strict"; c'est l'ECMA effort de faire du JavaScript un peu plus robuste. Il apporte à JS une tentative de le rendre au moins un peu "strict" (d'autres langues appliquent des règles strictes depuis les années 90). En fait, cela" force " les développeurs JavaScript à suivre une sorte de meilleures pratiques de codage. Néanmoins, le JavaScript est très fragile. Il n'existe pas de variables dactylographiées, de méthodes dactylographiées, etc. Je recommande fortement aux développeurs JavaScript d'apprendre un langage plus robuste comme Java ou ActionScript3, et mettre en œuvre les mêmes pratiques exemplaires dans votre code JavaScript, il fonctionnera mieux et sera plus facile à déboguer.

utiliser Strict est utilisé pour montrer les erreurs communes et répétées de sorte qu'il est traité différemment , et modifie la façon dont le script java tourne, ces changements sont:

• empêche les globals accidentels

• Pas de doublons

• élimine avec

• élimine cette coercition

• plus Sûr eval()

• Erreurs pour immutables

vous pouvez aussi lire ce article pour les détails

normalement le script java ne suit pas les règles strictes augmentant ainsi les chances d'erreurs. Après avoir utilisé "use strict" , le code de script java doit suivre des 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é alors le code doit être écrit en suivant un ensemble de règles strictes réduisant ainsi les chances d'erreurs et d'ambiguïtés.

JavaScript le mode" strict " introduit dans ECMAScript 5.

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

écrit "use strict"; tout en haut de votre fichier JS tourne sur le strict vérification de la syntaxe. Il s'acquitte pour nous des tâches suivantes :

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

(ii) vous empêche de remplacer la clé JS système de bibliothèques

(ii) interdit certaines caractéristiques linguistiques dangereuses ou sujettes à des erreurs

"use strict" fonctionne également à l'intérieur des fonctions individuelles. Il est toujours préférable d'inclure "l'utilisation stricte dans votre code.

Problème De Compatibilité Du Navigateur: Les directives" utilisation " sont censées être rétrocompatibles. Les navigateurs qui ne les supportent pas verront juste une chaîne de caractères littérale qui n'est pas référencée plus loin. Donc, ils vont passer au-dessus et d'avancer.