Récemment, j'ai exécuté une partie de mon code JavaScript via le JSLint de Crockford, et il a donné l'erreur suivante:

Problème à la ligne 1 caractère 1: instruction "use strict" manquante.

En faisant quelques recherches, j'ai réalisé que certaines personnes ajoutent "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é une grande partie de l'histoire derrière cette déclaration de chaîne. Cela doit certainement avoir quelque chose à voir avec la façon dont le JavaScript est interprété par le navigateur, mais je n'ai aucune idée de l'effet.

En quoi consiste "use strict";, qu'est-ce que cela implique et est-il toujours pertinent?

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

7482
Mark Rogers 26 août 2009 à 20:10

22 réponses

Meilleure réponse

Cet article sur le mode strict Javascript pourrait vous intéresser: John Resig - ECMAScript 5 Mode strict, JSON et plus

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 fonctionnement "strict". Ce contexte strict empêche certaines actions d'être prises et lève plus d'exceptions.

Et:

Le mode strict aide de plusieurs façons:

  • Il attrape quelques bêtises de codage courantes, levant des exceptions.
  • Il empêche ou génère des erreurs lorsque des actions relativement "dangereuses" sont prises (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 (toujours en citant 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" que vous pouvez utiliser en Perl (d'où le nom?) : il vous aide à faire moins d'erreurs, en détectant plus de choses qui pourraient conduire à des ruptures.

Le mode strict est désormais pris en charge par tous les principaux navigateurs.

À l'intérieur des modules ECMAScript natifs (avec des instructions import et export) et classes ES6, le mode strict est toujours activé et ne peut pas être désactivé.

4903
FZs 12 juil. 2019 à 10:12

Si les gens s'inquiètent de l'utilisation de use strict, il peut être utile 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 manière de 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.
*/
408
Community 22 janv. 2018 à 11:13

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

Toujours en mode strict, les choses tournent plus vite, certains avertissements ou avertissements silencieux génèrent 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 déclarations et exemples de MDN:

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 un expression littérale, ignorée par les versions antérieures de JavaScript. le "utilisation stricte" a pour but d'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.

Exemples d'utilisation de "use strict":
Mode strict pour les fonctions: De même, pour invoquer le mode strict pour un fonction, mettez la déclaration exacte "use strict"; (ou 'use strict';) dans le corps de la fonction avant toute autre instruction.

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 accessible en écriture

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

37
Palec 30 août 2018 à 15:16

Normalement, JavaScript ne suit pas de règles strictes, augmentant ainsi les risques d'erreurs. Après avoir utilisé "use strict", le code JavaScript 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 strict de règles, diminuant ainsi les risques d'erreurs et d'ambiguïtés.

11
Pang 4 janv. 2019 à 02:04

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

Ceux qui préfèrent ne pas utiliser de règles pour faire leurs lignes directement se retrouvent généralement dans ces pages demandant à d'autres de déboguer leur code.

Crois moi. La surcharge est négligeable par rapport à un code mal conçu. Doug Crockford, qui a été senior Développeur JavaScript depuis plusieurs années, a un article très intéressant ici. Personnellement, j'aime revenir tout le temps sur son site pour m'assurer de ne pas oublier ma bonne pratique.

La pratique JavaScript moderne devrait toujours évoquer le "Use Strict"; pragma. La seule raison pour laquelle le groupe ECMA a rendu le mode "Strict" facultatif est de permettre aux codeurs moins expérimentés d'accéder à JavaScript et de leur donner ensuite le temps de s'adapter aux nouvelles pratiques de codage plus sûres.

52
Peter Mortensen 26 oct. 2014 à 10:34

L'instruction "use strict"; indique au navigateur d'utiliser le mode strict, qui est un ensemble de fonctionnalités réduites et plus sûres de JavaScript.

Liste des fonctionnalités (non exhaustive)

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

  2. Les affectations silencieuses qui échouent génèrent une erreur en mode strict (affectation de NaN = 5;)

  3. Les tentatives de suppression de propriétés non supprimables lèveront (delete Object.prototype)

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

  5. Les noms des paramètres 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 fait rien pour changer le nombre.)

  7. Interdit le mot clé with

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

  9. Interdit la suppression de noms en clair (delete x;)

  10. Interdit la liaison ou l'attribution des noms eval et arguments sous quelque forme que ce soit

  11. Le mode strict n'aliase pas les propriétés de l'objet arguments avec les paramètres formels. (c'est-à-dire dans function sum (a,b) { return arguments[0] + b;} Cela fonctionne parce que arguments[0] est lié à a et ainsi de suite.)

  12. arguments.callee n'est pas pris en charge

[Ref: Mode strict, Développeur Mozilla Réseau ]

642
gprasant 22 janv. 2016 à 18:30

Si vous utilisez un navigateur sorti au cours de la dernière année, il prend probablement en charge le mode JavaScript Strict. Seuls les navigateurs plus anciens avant ECMAScript 5 sont devenus la norme actuelle ne le prennent pas en charge.

Les guillemets autour de la commande garantissent que le code fonctionnera également dans les anciens navigateurs (bien que les choses qui génèrent une erreur de syntaxe en mode strict provoquent généralement un dysfonctionnement du script d'une manière difficile à détecter dans ces anciens navigateurs).

62
Stephen 10 mars 2012 à 03:31

Le mode JavaScript "strict" a été introduit dans ECMAScript 5.

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

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

  1. affiche une erreur si vous essayez d'affecter à une variable non déclarée

  2. vous empêche d'écraser les bibliothèques système JS clés

  3. interdit certaines fonctionnalités linguistiques dangereuses ou sujettes aux erreurs

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

Problème de compatibilité du navigateur: les directives "use" sont censées être rétrocompatibles. Les navigateurs qui ne les prennent pas en charge verront simplement un littéral de chaîne qui n'est plus référencé. Alors, ils passeront dessus et continueront.

12
jkdev 6 févr. 2019 à 09:40

Je recommande fortement à chaque développeur de commencer à utiliser le mode strict maintenant. Il y a suffisamment de navigateurs qui le prennent en charge pour que le mode strict nous aide légitimement à éviter des erreurs que nous ne savions même pas dans votre code.

Apparemment, au stade initial, il y aura des erreurs que nous n'avons jamais rencontrées auparavant. Pour obtenir tous les avantages, nous devons effectuer des tests appropriés après le passage en mode strict pour nous assurer que nous avons tout pris. Certainement, nous ne jetons pas simplement use strict dans notre code et supposons qu'il n'y a pas d'erreur. Donc, le désabonnement est qu'il est temps de commencer à utiliser cette fonctionnalité 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. Collez simplement votre script et il recherchera rapidement tout problème ou erreur notable dans votre code.

137
Willi Mentzel 25 févr. 2016 à 15:54

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

11
SethO 13 janv. 2020 à 14:56

Le mode strict peut empêcher les fuites de mémoire.

Veuillez vérifier la fonction ci-dessous écrite en mode non strict:

function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); // Stack Overflow

Dans cette fonction, nous utilisons une variable appelée name à l'intérieur de la fonction. En interne, le compilateur vérifiera d'abord s'il existe une variable déclarée avec ce nom particulier dans cette portée de fonction particulière. Étant donné que le compilateur a compris qu'il n'y a pas une telle variable, il vérifiera la portée externe. Dans notre cas, c'est la portée mondiale. Encore une fois, le compilateur a compris qu'il n'y avait pas non plus de variable déclarée dans l'espace global avec ce nom, donc il crée une telle variable pour nous dans l'espace global. Conceptuellement, cette variable sera créée dans la portée globale et sera disponible dans toute l'application.

Un autre scénario est que, disons, la variable est déclarée dans une fonction enfant. Dans ce cas, le compilateur vérifie la validité de cette variable dans la portée externe, c'est-à-dire la fonction parent. Alors seulement, il vérifiera l'espace global et créera une variable pour nous là-bas. Cela signifie que des vérifications supplémentaires doivent être effectuées. Cela affectera les performances de l'application.


Écrivons maintenant la même fonction en mode strict.

"use strict"
function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); 

Nous obtiendrons l'erreur suivante.

Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5

Ici, le compilateur renvoie l'erreur de référence. En mode strict, le compilateur ne nous permet pas d'utiliser la variable sans la déclarer. Ainsi, les fuites de mémoire peuvent être évitées. De plus, nous pouvons écrire du code plus optimisé.

4
Pang 9 juil. 2019 à 06:01

Petits exemples à 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

Mode non strict:

String.prototype.test = function () {
  console.log(typeof this === 'string');
};

'a'.test();

// output
// false
String.prototype.test = function () {
  'use strict';
  
  console.log(typeof this === 'string');
};

'a'.test();

// output
// true
26
Tân 18 nov. 2018 à 16:31

Un mot d'avertissement, vous tous les programmeurs expérimentés: appliquer "use strict" au code existant peut être dangereux! Cette chose n'est pas un autocollant joyeux et joyeux que vous pouvez appliquer sur le code pour le rendre «meilleur». Avec le pragma "use strict", le navigateur LANCERA soudainement 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 par défaut / lâche autorise volontiers mais strictement abhorre! Vous pouvez avoir des violations de rigueur se cachant dans les 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 que vos clients payants utilisent!

Si vous allez franchir le pas, c'est une bonne idée d'appliquer "use strict" aux côtés de tests unitaires complets et d'une tâche de construction JSHint strictement configurée qui vous donnera une certaine assurance qu'aucun coin sombre de votre module ne soufflera horriblement juste parce que vous avez activé le mode strict. Ou, hé, voici une autre option: il suffit de ne pas ajouter "use strict" à aucun de vos codes hérités, c'est probablement plus sûr de cette façon, honnêtement. DÉFINITIVEMENT NE PAS ajouter "use strict" aux modules que vous ne possédez pas ou ne maintenez pas, comme les modules tiers.

Je pense que même s'il s'agit d'un animal mortellement mis en cage, "use strict" peut être une bonne chose, mais vous devez le faire correctement. Le meilleur moment pour devenir strict est lorsque votre projet est entièrement nouveau et que vous partez de zéro. Configurez JSHint/JSLint avec tous les avertissements et options montés aussi serrés que votre équipe peut l'estomac, obtenez un bon système du jour de build / test / assert truqué comme Grunt+Karma+Chai, et seulement ALORS commencez à marquer tous vos nouveaux modules comme "use strict". Soyez prêt à remédier à de nombreuses erreurs et avertissements. Assurez-vous que tout le monde comprend la gravité en configurant la version sur FAIL si JSHint/JSLint produit des violations.

Mon projet n'était pas un projet entièrement 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. C'est un rappel pour moi de ce que je devrais refactoriser à l'avenir. Mon objectif est d'être libre de toute marque rouge en raison de toutes mes déclarations "use strict" manquantes, mais c'est dans des années maintenant.

206
Ataur Rahman Munna 16 oct. 2016 à 09:10

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

Le but de "use strict" est 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é».

Le mode strict transforme les "mauvaises syntaxes" précédemment acceptées en erreurs réelles.

Par exemple, en JavaScript normal, une faute de frappe sur un nom de 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 affectant des valeurs à des propriétés non inscriptibles.

En mode strict, toute affectation à une propriété non accessible en écriture, une propriété getter uniquement, 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 savoir plus

42
Shog9 13 août 2018 à 03:15

"utiliser strict"; est l'effort de l'ECMA pour rendre JavaScript un peu plus robuste. Il apporte à JS une tentative de le rendre au moins un peu "strict" (d'autres langages implémentent des règles strictes depuis les années 90). En fait, cela "oblige" les développeurs JavaScript à suivre une sorte de bonnes pratiques de codage. Pourtant, JavaScript est très fragile. Il n'y a pas de variables typées, de méthodes typées, etc. déboguer.

12
hologram 14 juin 2016 à 23:18

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

  • élimine certaines erreurs silencieuses JavaScript en les modifiant pour lancer des erreurs.

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

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

Pour plus d'informations, visitez Strict Mode- Javascript

53
alexyorke 29 oct. 2014 à 17:34

Utiliser Strict est utilisé pour afficher les erreurs courantes et répétées afin qu'il soit traité différemment, et change la façon dont le script java s'exécute, ces modifications sont:

  • Empêche les globaux accidentels

  • Pas de doublons

  • Élimine avec

  • Élimine cette contrainte

  • Eval plus sûr ()

  • Erreurs pour les immuables

Vous pouvez également lire ce article pour les détails

11
Wesam 17 oct. 2016 à 14:09

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

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

  • Le code global est un code en mode strict s'il commence par un prologue de directive qui contient une directive d'utilisation stricte (voir 14.1.1).
  • Le code du module est toujours un code de mode strict.
  • Toutes les parties d'une ClassDeclaration ou d'une ClassExpression sont du code de mode strict.
  • Le code Eval est un code en mode strict s'il commence par un prologue de directive contenant une directive Use Strict ou si l'appel à eval est un eval direct (voir 12.3.4.1) contenu dans un code en mode strict.
  • Le code de fonction est un code de mode strict si la FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition ou ArrowFunction associée est contenue dans le code de mode strict ou si le code qui produit la valeur de la fonction [[ ECMAScriptCode]] l'emplacement interne commence par un prologue de directive qui contient une directive d'utilisation stricte.
  • Le code de fonction fourni comme arguments aux constructeurs de fonction et de générateur intégrés est un code de mode strict si le dernier argument est une chaîne qui, une fois traitée, est un FunctionBody qui commence par un prologue de directive qui contient une directive d'utilisation stricte.
19
Oriol 12 avril 2016 à 00:25

C'est une nouvelle fonctionnalité d'ECMAScript 5. John Resig a rédigé une belle résumé de celui-ci.

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 mettre dans votre code maintenant ne devrait pas poser de problème avec les navigateurs actuels car c'est juste une chaîne. Cela peut entraîner des problèmes avec votre code à l'avenir si votre code viole le pragma. Par exemple, si vous avez actuellement foo = "bar" sans définir foo d'abord, votre code commencera à échouer ... ce qui est une bonne chose à mon avis.

1235
Peter Mortensen 26 oct. 2014 à 10:31

Certains membres du comité ECMAScript ont bien discuté: Modifications apportées à JavaScript, partie 1: ECMAScript 5 " sur la façon dont l'utilisation incrémentielle du commutateur "use strict" permet aux implémenteurs JavaScript de nettoyer un grand nombre des fonctionnalités dangereuses de JavaScript sans casser subitement tous les sites Web du monde.

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

31
FutureNerd 29 mars 2014 à 19:39

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

46
Willi Mentzel 25 févr. 2016 à 15:55

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, 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 une instruction d'expression sans effets secondaires. Il est prévu que les futures versions des normes ECMAScript introduisent 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 n'est pas nécessaire que ce soit la première instruction dans un script de fonction: elle peut être précédée d'autres expressions d'instruction qui se composent de littéraux de chaîne (et les implémentations JavaScript peuvent les traiter comme des directives spécifiques à l'implémentation). Les instructions de littéraux 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 ils 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 au plus haut niveau d'un script (code qui n'est pas dans 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 un 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 du 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 propose une vérification des erreurs plus stricte et une sécurité plus élevée. Voici 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'instruction with - en mode strict.
  • En mode strict, toutes les variables doivent être déclarées: si vous affectez une valeur à un identifiant qui n'a pas été déclaré comme variable, fonction, paramètre de fonction, paramètre de clause catch ou propriété du global Object, alors vous obtiendrez un ReferenceError. En mode normal, l'identifiant est implicitement déclaré comme une variable globale (comme une propriété de la Object globale)
  • En mode strict, le mot clé this a la valeur undefined dans les fonctions qui ont été appelées en tant que fonctions (pas en tant que méthodes). (En mode normal, this pointe toujours vers le 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 plus, lorsqu'une fonction est invoquée avec call() ou apply en mode strict, this est exactement la valeur du premier argument de l'invocation call() ou apply() . (En mode normal, null et undefined sont remplacés par les Object globaux et les valeurs, qui ne sont pas des objets, sont converties en objets.)

  • En mode strict, vous obtiendrez un 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, lorsque vous passez du 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 étendue est créée pour eval() et les variables et fonctions sont dans cette étendue. Cette étendue est détruite une fois l'exécution eval() terminée.
  • 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'argument-objet a un comportement quelque peu "magique": les éléments du tableau et les paramètres de fonction nommés font référence à la même valeur.
  • En mode strict, vous obtiendrez un SyntaxError lorsque l'opérateur delete est suivi d'un identifiant non qualifié (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é non configurable. (En mode normal, la tentative échoue 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 littéral d'objet. (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éraux octaux ne sont pas autorisés (ce sont des littéraux qui commencent par 0x. (En mode normal, certaines implémentations autorisent les littéraux octaux.)
  • En mode strict, les identifiants eval et arguments sont traités comme des mots clés. Vous ne pouvez pas modifier leur valeur, ne pouvez pas leur attribuer une 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 y a plus de restrictions sur les possibilités d'examiner la pile d'appels. arguments.caller et arguments.callee provoquent un TypeError dans une fonction en mode strict. De plus, certaines propriétés d'appel et d'argument des fonctions en mode strict provoquent un TypeError lorsque vous essayez de les lire.
95
Ely 12 juil. 2015 à 20:31
1335851