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




13 Answers

Cet article sur le mode Javascript strict 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 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, en lançant 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 pouvez l'utiliser uniquement 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" vous pouvez utiliser en 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 est supporté par tous les principaux navigateurs (sauf IE 9 et inférieur) .

mode the

Récemment, j'ai utilisé une partie de mon code JavaScript dans JSLint de Crockford, qui a JSLint l'erreur suivante:

Problème à la ligne 1, caractère 1: Manque l'énoncé "use strict".

En faisant des recherches, je me suis rendu compte que certaines personnes ajoutaient "use strict"; dans leur code JavaScript. Une fois que j'ai ajouté la déclaration, l'erreur a cessé d'apparaître. Malheureusement, Google n'a pas révélé beaucoup de choses derrière cette déclaration. Cela doit certainement avoir quelque chose à voir avec la façon dont le navigateur interprète le code JavaScript, mais je n'ai aucune idée de l'effet que cela pourrait avoir.

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

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




La déclaration "use strict"; indique au navigateur d'utiliser le mode strict, qui est un ensemble de fonctionnalités réduites et sécurisées de JavaScript.

Liste de fonctionnalités (non exhaustive)

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

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

  3. Les tentatives de suppression des propriétés non effaçables vont générer ( delete Object.prototype )

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

  5. Les noms de paramètre de fonction doivent être uniques ( function sum (x, x) {...} )

  6. Interdit la syntaxe octale ( var x = 023; certains développeurs supposent à tort qu’un zéro précédent ne change rien au nombre.)

  7. Interdit le with mot clé

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

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

  10. Interdit la liaison ou l'attribution des noms eval et des arguments sous n'importe quelle forme

  11. Le mode strict n'alias pas les propriétés de l'objet arguments avec les paramètres formels. (ie en function sum (a,b) { return arguments[0] + b;} Ceci fonctionne car les arguments[0] sont liés à a et ainsi de suite.)

  12. arguments.callee n'est pas supporté

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




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 visage joyeux 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 défaut de lire permet joliment mais que le JavaScript est abominable! 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 configurée de manière stricte, qui vous donnera l'assurance qu'il n'y a pas de coin sombre de votre module qui explose. horriblement juste parce que vous avez activé le mode strict. Ou bien, voici une autre option: n'ajoutez simplement pas "use strict" à l'un de vos codes hérités, c'est probablement plus sûr de cette façon, honnêtement. DÉFINITIVEMENT, n’ajoutez pas "use strict" aux modules que vous ne possédez ni ne maintenez, 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 chantier 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 / affirmation du jour configuré comme Grunt+Karma+Chai , puis commencez à marquer 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 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 parce que 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 en raison de toutes mes déclarations manquantes "use strict" , mais c’est dans des années.




Je recommande fortement à tous les développeurs de commencer à utiliser le mode strict dès maintenant. Il y a suffisamment de navigateurs qui le prennent en charge pour que le mode strict nous aide légitimement à nous préserver d’erreurs que nous ne savions même pas dans votre code.

Apparemment, au début, il y aura des erreurs que nous n'avons jamais rencontrées auparavant. Pour obtenir tous les avantages, nous devons effectuer les tests appropriés après le passage au mode strict afin de nous assurer que nous avons tout capturé. En définitive, nous ne jetons pas simplement use strict dans notre code et supposons qu’il n’ya pas d’erreur. Le problème est donc qu'il est temps de commencer à utiliser cette fonctionnalité linguistique extrêmement utile pour écrire un meilleur code.

Par exemple,

var person = {
    name : 'xyz',
    position : 'abc',
    fullname : function () {  "use strict"; return this.name; }
};

JSLint est un débogueur écrit par Douglas Crockford. Il vous suffit de coller votre script et il analysera rapidement tous les problèmes et erreurs évidents dans votre code.




Mes deux centimes:

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. Dès que nous utiliserons 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);

Maintenant, 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: nameoftree n'est pas défini

Sample

Élimine with déclaration:

with déclarations ne peuvent pas être minifiées en utilisant des outils tels que uglify-js . Ils sont également deprecated 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.




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

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

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

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

pour plus d'informations vistit Strict Mode- Javascript




"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 moderne de JavaScript devrait toujours évoquer le "Use Strict"; pragma. Le groupe ECMA a rendu le mode «strict» facultatif uniquement pour permettre aux codeurs moins expérimentés d’avoir accès à JavaScript et de donner ensuite le temps de s’adapter aux nouvelles pratiques de codage plus sûres.




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

"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 code JavaScript "sécurisé".

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

Par exemple, en JavaScript normal, une erreur de frappe dans le nom d'une 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 attribuant des valeurs à des propriétés non inscriptibles.

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




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

Également en mode strict, les choses vont plus vite, certains avertissements ou avertissements silencieux génèrent des erreurs fatales, il est préférable de toujours l'utiliser pour créer un code plus net.

"use strict"est largement nécessaire pour être utilisé dans ECMA5, dans ECMA6 il fait partie de JavaScript par défaut , il n’a donc pas besoin de l’ajouter si vous utilisez ES6.

Regardez ces déclarations et exemples de MDN:

La directive "use strict"
La directive "use strict" est une nouveauté de JavaScript 1.8.5 (ECMAScript version 5). Ce n'est pas une déclaration, mais une expression littérale, ignorée par les versions antérieures de JavaScript. "Use strict" a pour but d'indiquer que le code doit être exécuté en "mode strict". En mode strict, vous ne pouvez pas, par exemple, utiliser des variables non déclarées.

Exemples d'utilisation de "use strict":
Mode strict pour les fonctions: De même, pour appeler le mode strict d'une fonction, placez l'énoncé exact "use strict"; (ou 'use strict';) dans le corps de la fonction avant toute autre déclaration.

1) mode strict dans les fonctions

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) mode strict de script entier

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

3) Affectation à un global non-inscriptible

'use strict';

// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError

Vous pouvez en savoir plus sur MDN .




Petit exemple à comparer:

Mode non strict:

for (i of [1,2,3]) console.log(i)

// output:
// 1
// 2
// 3

Mode strict:

'use strict';
for (i of [1,2,3]) console.log(i)

// output:
// Uncaught ReferenceError: i is not defined



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




Utiliser Strict est utilisé pour afficher les erreurs courantes et répétées de sorte qu'il soit traité différemment et modifie la façon dont le script Java s'exécute. Ces modifications sont les suivantes:

  • Empêche les globaux accidentels

  • Pas de doublons

  • Élimine avec

  • Élimine cette contrainte

  • Eval plus sûr ()

  • Erreurs pour immuables

vous pouvez également lire cet article pour les détails




Le mode JavaScript «strict» est introduit dans ECMAScript 5.

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

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

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

(ii) vous empêche d'écraser les principales bibliothèques du système JS

(ii) interdit certaines fonctionnalités linguistiques peu sûres ou sujettes à erreur

"use strict" fonctionne également dans les fonctions individuelles. Il est toujours préférable d’inclure "use strict" dans votre code.

Problème de compatibilité de navigateur: Les directives "use" sont censées être rétro-compatibles. Les navigateurs qui ne les prennent pas en charge ne verront qu'un littéral String non référencé. Alors, ils vont passer par-dessus et aller de l'avant.




Related