Que fait "use strict" en JavaScript et quelles en sont les raisons?

J'ai récemment lancé mon code JavaScript par le biais de Crockford JSLint , qui a généré 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 votre code javascript. Dès que j'ai ajouté l'expression, l'erreur a cessé d'apparaître. Malheureusement, Google n'a pas révélé l'essentiel de l'historique de cette ligne d'opérateur. Bien sûr, cela devrait être lié à la façon dont JavaScript est interprété par le navigateur, mais je ne sais pas quel sera l'effet.

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

Tout navigateur actuel répond par "use strict"; chaîne ou est-ce pour une utilisation future?

6989
26 авг. établi par Mark Rogers le 26 août. 2009-08-26 19:10 '09 à 19:10 2009-08-26 19:10
@ 30 réponses

Cet article sur Javascript Strict Mode 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 de travail "strict". Ce contexte strict empêche certaines actions d'être exécutées et génère davantage d'exceptions.

Aussi:

Le mode strict aide de plusieurs manières:

  • Il attrape quelques bloopers de codage courants, en lançant des exceptions.
  • Il empêche ou crée des erreurs lorsque des actions relativement "peu sûres" sont entreprises (par exemple, accéder à un objet global).
  • Cela désactive les fonctionnalités déroutantes ou mal pensées.

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

 // Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code... 

Ce qui peut être utile si vous avez besoin de mé>

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

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

4587
26 авг. la réponse est donnée par Pascal MARTIN 26 août. 2009-08-26 19:15 '09 à 19:15 2009-08-26 19:15

Il s'agit d'une nouvelle fonctionnalité d'ECMAScript 5. John Resig a rédigé un bon résumé .

Ceci est juste une ligne que vous mettez dans vos fichiers JavaScript (soit en haut de votre fichier, soit dans une fonction), qui ressemble à ceci:

border=0
 "use strict"; 

L'activation de ce code ne devrait plus causer de problèmes avec les navigateurs actuels, car il ne s'agit que d'une chaîne. Cela peut causer des problèmes avec votre code à l'avenir si votre code rompt un pragma. Par exemple, si vous avez actuellement foo = "bar" sans d'abord définir foo , votre code va planter ... ce qui, à mon avis, est bon.

1152
26 авг. la réponse est donnée le 26 août. 2009-08-26 19:14 '09 à 19h14 2009-08-26 19:14

La déclaration "use strict"; indique au navigateur d’utiliser le mode Strict, qui est un ensemble de fonctions JavaScript réduit et plus sécurisé.

Liste de fonctions (non exhaustive)

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

  2. Les tâches en échec silencieuses provoqueront une erreur en mode strict (attribution de NaN = 5; )

  3. Les tentatives de suppression des propriétés à tolérance de pannes entraîneront ( delete Object.prototype )

  4. Requiert que tous les noms de propriété dans le 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. Interdictions - syntaxe octale ( var x = 023; certains développeurs pensent à tort que le zéro précédent ne modifie en rien le nombre.)

  7. Interdire with mot clé

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

  9. Désactiver la suppression de nom simple ( delete x; )

  10. Désactivation de la liaison ou de la désignation de eval et des arguments sous quelque forme que ce soit

  11. Le mode strict ne prend pas en charge les propriétés de l'objet arguments avec des paramètres formels. (c'est-à-dire en function sum (a,b) { return arguments[0] + b;} Ceci fonctionne car les arguments[0] sont associés à a , etc.)

  12. arguments.callee pas supporté

[Lien: Mode strict , réseau de développeurs Mozilla]

567
25 нояб. la réponse est donnée par gprasant le 25 novembre 2014-11-25 00:22 14 à 0:22 2014-11-25 00:22

Si les gens sont préoccupés par une use strict il est possible de consulter cet article:

ECMAScript 5 Prise en charge du mode strict 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 plus important encore, de la façon de la gérer:

 function isStrictMode(){ return !this; }  function isStrictMode(){ "use strict"; return !this; }  
385
16 июля '12 в 2:25 2012-07-16 02:25 La réponse est donnée par Jamie Hutber le 16 juillet 2012 à 02h25. 2012-07-16 02:25

Attention, tout ce que vous programmez avec une charge difficile: appliquer "use strict" au code existant peut être dangereux! Ce truc n’est pas une sorte d’autocollant joyeux et joyeux sur lequel on peut appuyer sur le code pour le rendre "meilleur". Avec "use strict" correct "use strict" pragmas, le navigateur jette soudainement des exceptions dans des endroits aléatoires qu'il n'a jamais lus auparavant, tout simplement parce que vous faites ce que JavaScript permet d'utiliser par défaut / gratuitement, mais pas comme JavaScript strict ! Vous pouvez avoir des violations strictes cachées dans des appels à votre code rarement utilisés, qui ne généreront une exception que lorsqu'ils seront exécutés - par exemple, dans un environnement de production utilisé par vos clients de paiement!

Si vous envisagez de franchir une étape décisive, nous vous recommandons d’utiliser "use strict" avec des tests unitaires complets et la tâche de construction JSHint configurée de manière stricte, ce qui vous donnera la certitude qu’aucun coin sombre de votre module n’explosera mal car vous avez activé le mode strict. Ou encore, voici une autre option: n’ajoutez pas l’ "use strict" à aucun de vos codes obsolètes, c’est probablement plus sûr, honnête. DÉFINITIVEMENT, n’ajoutez pas "use strict" aux modules que vous ne possédez ni ne supportez pas, tels que les modules tiers.

Je pense que même si c’est un estomac mortel dans une cage, "use strict" est bien, mais vous devez le faire correctement. Le meilleur moment pour rester strict est lorsque votre projet est nouveau et que vous partez de zéro. Configurez JSHint/JSLint avec tous les avertissements et toutes les options pliés aussi fort que votre équipe peut en grincer, procurez-vous un bon système de construction / test / approbation pouvant être configuré comme Grunt+Karma+Chai , et ALORS marquera 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 réglant l'assemblage sur JSHint/JSLint si JSHint/JSLint provoque des irrégularités.

Mon projet n'était pas un nouveau projet lorsque j'ai adopté "use strict" . En conséquence, mon IDE est plein de marques rouges, car 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 d’être une marque rouge gratuitement à cause de toutes mes déclarations "use strict" manquantes, mais cela fait depuis de nombreuses années.

193
03 марта '14 в 10:37 2014-03-03 10:37 La réponse est donnée par DWoldrich le 03 mars 14 à 10:37 2014-03-03 10:37

Utilisez 'use strict'; ne rend pas votre code meilleur.

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

 'use strict'; 

Lorsque le moteur JavaScript voit cette directive, il commence à interpréter le code dans un mode spécial. Dans ce mode, des erreurs surviennent lorsque certaines méthodes de codage sont détectées et peuvent constituer des erreurs potentielles (ce qui est un argument en faveur du mode strict).

Considérons cet exemple:

 var a = 365; var b = 030; 

Dans son obsession de construire des littéraux numériques, le développeur initialise par inadvertance la variable b huitième littéral. Un mode non strict interprétera cela comme un littéral numérique avec une valeur de 24 (en base 10). Cependant, le mode strict provoquera 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: Absolutely! Le mode strict peut être utilisé comme informateur 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 avez besoin du mode strict, vous devriez être prêt à déboguer et à corriger le code existant. C'est pourquoi l'utilisation de 'use strict'; ne rend pas votre code meilleur.


Comment utiliser le mode strict?

  1. Insérer 'use strict'; en haut de votre script:

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

    Veuillez noter que tout dans myscript.js sera interprété en mode strict.

  2. Ou coller 'use strict'; La déclaration au-dessus de votre corps fonctionne:

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

    Tout ce qui se trouve dans l'étendue lexicale de la fonction doSomething sera interprété en mode strict. La zone lexicale du mot est importante ici. Voir cette réponse pour une meilleure explication.


Quelles sont les choses strictement interdites?

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

Volume

Historiquement, JavaScript était confus quant à la manière dont les fonctions sont couvertes. Parfois, elles semblent capturées de manière statique, mais certaines fonctions les obligent à se comporter comme si elles étaient couvertes de manière dynamique par une région. C'est déroutant, ce qui rend difficile la lecture et la compréhension des programmes. Une mauvaise compréhension provoque des erreurs. C'est aussi un problème de performance. Une définition de domaine statique autoriserait une liaison variable au moment de la compilation, mais l'exigence d'un domaine dynamique signifie que la liaison doit être différée jusqu'au moment de l'exécution, ce qui est associé à une baisse significative des performances.

Le mode strict requiert que toutes les liaisons de variables soient exécutées de manière statique. Cela signifie que les fonctions qui nécessitaient auparavant une liaison dynamique doivent être supprimées ou modifiées. En particulier, l'opérateur with est exclu et la capacité des fonctions eval d'interférer avec l'environnement de l'appelant est strictement limitée.

L'un des avantages du code strict est que des outils tels que YUI Compressor peuvent être plus efficaces pour le traiter.

Variables globales implicites

JavaScript implique des variables globales. Si vous ne déclarez pas explicitement une variable, une variable globale est implicitement déclarée pour vous. Cela simplifie la programmation pour les débutants, car ils risquent de négliger certaines de leurs tâches principales. Mais cela rend difficile la gestion de programmes plus volumineux et réduit considérablement la fiabilité. Ainsi, en mode strict, les variables globales implicites ne sont plus créées. Vous devez déclarer explicitement toutes vos variables.

Fuites globales

Cela peut être associé à un objet global dans un certain nombre de situations. Par exemple, si vous avez oublié de fournir new préfixe lorsque vous appelez une fonction constructeur, le constructeur this sera associé de manière inattendue à un objet global. Ainsi, au lieu d'initialiser un nouvel objet, il se falsifiera silencieusement avec des variables globales. Dans ces situations, le mode strict lie plutôt this avec undefined , ce qui oblige le constructeur à lancer une exception à la place, lui permettant de détecter l'erreur plus tôt.

Erreur bruyante

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 n'est Object.createProperty ouverte. Object.createProperty est ouvert pour la fonction Object.createProperty . Si vous tentez d'affecter une valeur à une propriété en lecture seule, elle échouera. La cession ne changera pas la valeur de la propriété, mais votre programme agira comme s'il l'était. C'est un danger d'intégrité, qui peut conduire à la transition de programmes dans un état incohérent. En mode strict, toute tentative de modification de la propriété en lecture seule provoquera une exception.

octal

La représentation des nombres sur 8 bits est extrêmement utile pour la programmation sur des machines dont la taille de mot est un multiple de 3. Lorsque vous travaillez avec l’ordinateur central CDC 6600, d’une taille de mot de 60 bits, vous avez besoin d’un nombre octal. Si vous pouviez lire en octal, vous pourriez regarder le mot avec 20 chiffres. Deux chiffres représentaient le code opérationnel et un chiffre identifiait l'un des 8 registres. Au cours de la transition lente des codes machine aux >

En C, l’idée extrêmement malheureuse d’octalité a été retenue: le zéro non significatif. Donc, en C 0100 signifie 64, et non pas 100, et 08 est une erreur, pas 8. Même plus, malheureusement, cet anachronisme a été copié dans presque toutes les >

Et cetera

Les arguments de pseudo-tableaux deviennent un peu plus comme des tableaux dans ES5. En mode strict, il perd les propriétés de l' caller et de l' caller . Cela vous permet de passer vos arguments code non fiable, sans laisser beaucoup de contexte confidentiel. De plus, la propriété arguments des fonctions est exclue.

En mode strict, les clés en double dans un littéral de fonction génèrent une erreur de syntaxe. Le can can function a deux paramètres portant le même nom. La fonction can not a une variable portant le même nom que l'un de ses paramètres. La fonction can not delete a ses propres variables. Tenter de delete 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 en tant que variables ou arguments, le mode strict générera une erreur. Mots réservés:

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


Lectures complémentaires

144
29 янв. réponse donnée par sampathsris le 29 janvier 2016-01-29 14:35 '16 à 14:35 2016-01-29 14:35

Je recommande fortement à tous les développeurs de commencer à utiliser le mode strict. Il y a suffisamment de navigateurs qui le prennent en charge pour que le mode strict nous aide juridiquement à nous protéger d’erreurs que nous ne savions même pas se trouver 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 sommes tous pris. En définitive, nous n'utilisons tout simplement pas use strict dans notre code et pensons qu'il n'y a pas d'erreur. Le problème, c’est 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 le coller dans votre script pour qu'il analyse rapidement tous les problèmes et erreurs évidents dans votre code.

128
05 июля '13 в 22:38 2013-07-05 22:38 la réponse est donnée à Pank le 05 juillet '13 à 10:38 2013-07-05 22:38

J'aimerais proposer une réponse un peu plus détaillée et complète que les autres réponses. J'espérais modifier la réponse la plus populaire, mais je ne pouvais pas. J'ai essayé de le rendre aussi complet et complet que possible.

Pour plus d'informations, vous pouvez vous reporter à la documentation MDN .

"use strict" directive "use strict" entrée dans ECMAScript 5.

Les directives sont comme des déclarations, mais différentes.

  • use strict ne contient pas de mots-clés: une directive est une déclaration d'expression simple qui consiste en 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 l'expression sans effets secondaires. Les futures versions des normes ECMAScript devraient introduire l’ use tant que mot clé réel; Ainsi, les citations deviendront obsolètes.
  • use strict ne peut être utilisé qu’au début d’un script ou d’une fonction, c’est-à-dire doit précéder toute autre déclaration (réelle). Il ne doit pas s'agir de la première instruction d'un script de fonction: elle peut être précédée par d'autres expressions d'opérateur composées de littéraux de chaîne (les implémentations JavaScript peuvent être considérées comme des directives spécifiques à l'implémentation). Les littéraux de chaîne qui suivent le premier opérateur réel (dans un script ou une fonction) sont des expressions simples. Les interprètes ne doivent pas les interpréter comme des directives et elles n’ont aucun effet.

use strict directive use strict indique que le code suivant (dans un script ou une fonction) est un code strict. Le code au niveau le plus élevé du script (code qui n'est pas dans la fonction) est considéré comme un code strict lorsque le script contient la 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 la directive use strict . Le code transmis à la méthode eval() est considéré comme un code strict lorsque eval() est appelé à partir d'un code de chaîne ou contient la directive use strict .

Le mode strict ECMAScript 5 est un sous-ensemble limité du >

  • Vous ne pouvez pas l'utiliser with -atatement 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 de capture ou propriété d' Object global, vous obtiendrez une ReferenceError . En mode normal, un identifiant est déclaré implicitement en tant que variable globale (en tant que propriété d'un Object global)
  • En mode strict, le this a pour valeur les fonctions undefined appelées en tant que fonctions (et non en tant que méthodes). (В нормальном режиме this всегда указывает на глобальный Object ). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
 var hasStrictMode = (function() { "use strict"; return this===undefined }()); 
  • Также, когда функция вызывается с call() или apply в строгом режиме, this точно значение первого аргумента call() или apply() . (В нормальном режиме null и undefined заменяются глобальным Object а значения, которые не являются объектами, преобразуются в объекты.)

  • В строгом режиме вы получите TypeError , когда вы пытаетесь назначить свойства readonly или определить новые свойства для не растяжимого объекта. (В обычном режиме оба просто обходятся без сообщения об ошибке.)

  • В строгом режиме при передаче кода в eval() вы не можете объявлять или определять переменные или функции в области вызывающего (как это можно сделать в обычном режиме). Вместо этого для eval() создается новая область, и переменные и функции находятся в пределах этой области. Эта область уничтожается после того, как eval() завершает выполнение.
  • В строгом режиме аргумент-объект функции содержит статическую копию значений, которые передаются этой функции. В нормальном режиме аргумент-объект имеет несколько "магическое" поведение: элементы массива и именованные функциональные параметры ссылаются на одно и то же значение.
  • В строгом режиме вы получите SyntaxError когда за оператором delete следует неквалифицированный идентификатор (переменная, функция или параметр функции). В нормальном режиме выражение delete ничего не сделает и будет оценено как false .
  • В строгом режиме вы получите TypeError при попытке удалить неконфигурируемое свойство. (В обычном режиме попытка просто терпит неудачу, а выражение delete - false ).
  • В строгом режиме это считается синтаксической ошибкой при попытке определить несколько свойств с тем же именем для литерала объекта. (В нормальном режиме ошибки нет.)
  • В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с тем же именем. (В нормальном режиме ошибки нет.)
  • В строгом режиме не допускаются восьмеричные литералы (это литералы, начинающиеся с 0x . (В нормальном режиме некоторые реализации позволяют делать восьмеричные литералы).
  • В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение, и вы не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
  • В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают TypeError в функции в строгом режиме. Кроме того, некоторые свойства caller- и аргументы функций в строгом режиме вызывают TypeError при попытке их прочитать.
88
ответ дан Ely 15 мая '15 в 9:58 2015-05-15 09:58

Mes deux centimes:

Одна из целей строгого режима - обеспечить более быструю отладку проблем. Это помогает разработчикам, бросая исключение, когда происходят некоторые неправильные вещи, которые могут вызвать тихое и странное поведение вашей веб-страницы. В тот момент, когда мы используем use strict , код выкидывает ошибки, которые помогают разработчику исправлять его заранее.

Немного важных вещей, которые я узнал после use strict :

Предотвращает глобальную декларацию переменных:

 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); 

Теперь этот код создает nameoftree в глобальной области видимости, доступ к которому можно получить с помощью window.nameoftree . Когда мы реализуем use strict использование кода, код будет вызывать ошибку.