web-dev-qa-db-fra.com

Que fait "use strict" en JavaScript et quel est le raisonnement derrière?

Récemment, j'ai utilisé une partie de mon code JavaScript dans le fichier JSLint de Crockford.

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é grand-chose de l'histoire 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.

Donc, 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 un usage futur?

javascriptsyntaxjslintuse-strict
7004
Mark Rogers

Cet article sur le mode Javascript strict peut vous intéresser: John Resig - Mode strict d'ECMAScript 5, JSON et autres

Pour citer quelques parties intéressantes:

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

Et:

Le mode strict aide de deux manières:

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

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

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code...

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

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

Actuellement, il s'agit de pris en charge par tous les principaux navigateurs(barre IE 9 et inférieure).

4608
Pascal MARTIN

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

C'est juste une chaîne que vous avez insérée 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 pas causer de problèmes 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'abord définir foo, votre code va commencer à échouer ... ce qui est une bonne chose à mon avis.

1157
seth

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

Liste de fonctionnalités (non exhaustive)

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

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

  3. (delete Object.prototype) tente de supprimer les propriétés non supprimables 

  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 mot clé with 

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

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

  10. Interdit la liaison ou l’attribution des noms eval et 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. (i.e. in function sum (a,b) { return arguments[0] + b;} Ceci fonctionne car arguments[0] est lié à a et ainsi de suite.)

  12. arguments.callee n'est pas supporté

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

575
gprasant

Si les gens s’inquiètent de l’utilisation de use strict, consultez cet article: 

ECMAScript 5 supporte le '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.
*/
386
Jamie Hutber

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

Si vous allez franchir le pas, il est judicieux d'appliquer "use strict" à côté de tests unitaires complets et d'une tâche de construction JSHint strictement configurée qui vous donnera l'assurance qu'il n'y a pas de coin sombre de votre module qui exploserait horriblement simplement parce que vous avez activé le mode strict. Ou bien, voici une autre option: il suffit de ne pas ajouter "use strict" à l'un de vos codes hérités, c'est probablement plus sûr ainsi, honnêtement. DEFINITELY NE PAS ajouter "use strict" à tous les modules que vous ne possédez ou ne maintenez pas, comme les modules tiers.

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

Mon projet n’était pas un projet nouveau lorsque j’ai adopté "use strict". En conséquence, mon IDE est plein de marques rouges 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 de ne pas avoir de marque rouge à cause de toutes mes déclarations "use strict" manquantes, mais cela ne prend que quelques années.

194
DWoldrich

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 commises 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 saisi. Décidément, nous ne jetons pas simplement use strict dans notre code et supposons qu’il n’ya pas d’erreurs. 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. Collez simplement dans votre script et il analysera rapidement tous les problèmes et erreurs notables de votre code.

128
Pank

Mes deux sous:

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

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

Empêche la déclaration de variable globale: 

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

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

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

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

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

Uncaught ReferenceError: le nom d'arbre n'est pas défini

Sample

élimine l'instruction with:

Les instructions with ne peuvent pas être réduites à l’aide d’outils tels que glify-js . Ils sont également obsolète et supprimés des futures versions de JavaScript.

Sample

Empêche les doublons:

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

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

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

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

80
Shubh

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

57
Stephen

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

  • Ouvrant la voie aux futures versions d'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 fonction en blocs 

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

  • Syntaxe octale 

    var n = 023;

  • this pointe 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();

  • Utilisation de delete sur un nom de variable delete myVariable;

  • Utilisation de 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:

51
zangw

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

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

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

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

pour plus d'informations vistit Strict Mode- Javascript

50
Renganathan M G

"Utilisez Strict"; 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 droit".

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

Crois moi. Les frais généraux sont négligeables par rapport à un code mal conçu. Doug Crockford, développeur senior de JavaScript depuis plusieurs années, a publié un article très intéressant ici . Personnellement, j'aime bien revenir sur son site tout le temps pour m'assurer de ne pas oublier mes bonnes pratiques.

La pratique JavaScript moderne doit toujours évoquer le "Use Strict"; pragma. Le groupe ECMA a rendu le mode "strict" facultatif pour la seule raison c’est pour permettre aux développeurs moins expérimentés d’avoir accès à JavaScript et au temps nécessaire pour s’adapter aux nouvelles pratiques de sécurité plus sûres.

48
user2436758

Inclure use strict au début de tous vos fichiers JavaScript sensibles 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.

44
Placeholder

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 précédents versions de JavaScript.

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

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

Pourquoi le mode strict?

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

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

Par exemple, en JavaScript normal, le typage incorrect d'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 attribution de valeurs à des propriétés non inscriptibles.

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

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

36
Mehul Singh

"use strict" fait que le code JavaScript s'exécute en mode strict, ce qui signifie que tout doit être défini avant utilisation. La principale raison d'utiliser le mode strict est d'éviter les utilisations accidentelles globales 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 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 "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, invoquer le mode strict pour un function, met la déclaration exacte "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 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 lire plus sur MDN .

32
Alireza

Certains membres du comité ECMAScript ont bien parlé: Modifications de JavaScript, partie 1: ECMAScript 5 " sur la manière dont l'utilisation incrémentielle du commutateur "use strict" permet aux développeurs JavaScript de nettoyer bon nombre des fonctionnalités dangereuses de JavaScript. sans casser soudainement tous les sites web du monde.

Bien sûr, il est également question de la nature de ces défauts et de la façon dont ECMAScript 5 les corrige.

29
FutureNerd

Notez que use strict a é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 d'un ClassDeclaration ou d'un 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 le FunctionDeclaration, la FunctionExpression, la GeneratorDeclaration, la GeneratorExpression, la MethodDefinition ou la ArrowFunction sont contenus dans un code de mode strict ou si le code qui produit la valeur de l'emplacement interne [[ECMAScriptCode]] avec un prologue de directive contenant une directive d'utilisation stricte.
  • Le code de fonction fourni en tant qu'arguments des constructeurs intégrés Function et Generator est un 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. .
18
Oriol

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

16
Foo

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

  1. Empêche la déclaration accidentelle de variables globales.L'utilisation de "use strict()" permet de s'assurer que les variables sont déclarées avec var avant 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ée en tant que 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 consulter ici .

11
Pritam Banerjee

"use strict"; L’ECMA s’efforce de rendre JavaScript un peu plus robuste. Il apporte à JS une tentative de le rendre 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 en matière de codage . Néanmoins, JavaScript est très fragile. Les variables typées, les méthodes typées, etc., n’existent pas. 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 mieux. être plus facile à déboguer.

10
PippoApps.com

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.

10
Просто программист

Utiliser Strict est utilisé pour afficher les erreurs courantes et répétées afin qu’il soit géré différemment et modifie le mode d’exécution du script Java. Ces modifications sont les suivantes:

  • Prévient les globales accidentelles

  • Pas de doublons

  • Élimine avec

  • Élimine cette contrainte

  • Eval plus sûr ()

  • Erreurs pour immuables

vous pouvez aussi lire ceci article pour les détails 

10
Wesam

Normalement, JavaScript ne suit pas de règles strictes, ce qui augmente les risques d'erreur. 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 initialisation, etc. 

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

9
Bikash Chapagain

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

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

Écrire "use strict"; tout en haut de votre fichier JS active la vérification stricte de la syntaxe Il fait 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 principales bibliothèques du système JS

  3. interdit certaines fonctionnalités linguistiques peu sûres ou sujettes aux erreurs

use strict fonctionne également à l'intérieur de 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 de chaîne non référencé. Alors, ils vont passer par-dessus et aller de l'avant.

8
Rabin Pantha

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 dans la fonction. En interne, le compilateur va d'abord vérifier s'il y a une variable déclarée avec ce nom particulier dans la portée de cette fonction particulière. Comme le compilateur a compris qu’il n’existait pas de variable de ce type, il vérifiera dans la portée externe. Dans notre cas, c'est la portée globale. Là encore, le compilateur a compris qu’il n’existait pas non plus de variable déclarée dans l’espace global portant ce nom; il a donc créé 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, par exemple, 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 parente. Ce n’est qu’alors qu’il va vérifier dans l’espace global et y créer une variable. 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 aurons 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 un code plus optimisé.

1
Jerin K Alexander

"use strict"; Définit que le code JavaScript doit être exécuté dans "mode strict".

  • La directive "use strict" était nouvelle dans la version 5 d'ECMAScript.
  • 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.

Tous les navigateurs modernes prennent en charge "use strict" sauf Internet Explorer 9 et inférieur.

Désavantage

Si un développeur utilise une bibliothèque en mode strict mais s’il est habitué à travailler en mode normal, il peut appeler sur la bibliothèque des actions qui ne fonctionneront pas comme prévu.

Pire, puisque le développeur est en mode normal, il ne bénéficie pas des erreurs supplémentaires générées. L’erreur peut donc échouer en silence.

En outre, comme indiqué ci-dessus, le mode strict vous empêche de faire certaines choses.

Les gens pensent généralement que vous ne devriez pas utiliser ces choses au départ, mais certains développeurs n’aiment pas la contrainte et veulent utiliser toutes les fonctionnalités du langage.

0
ashish

Pour être très simple "use strict"; tout en haut de votre fichier JS active la vérification de la syntaxe stricte.

1: -Il ne vous laissera pas déclarer d'essayer d'assigner à une variable non déclarée, une erreur s'affichera. 2: -Cela va prendre en charge interdit certaines fonctionnalités de langage dangereuses ou sujettes à erreur.

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

0
Abhijeet Singh