Qu'est-ce que le "mode strict" et comment est-il utilisé?
J'ai parcouru la référence JavaScript sur le réseau de développeurs Mozilla et je suis tombé sur quelque chose appelé "strict mode". Je l'ai relue et j'ai du mal à comprendre ce que ça fait. Quelqu'un peut-il expliquer brièvement (en général) quel est son but et comment il est utile?
Son but principal est de faire plus de vérification.
Ajoutez simplement "use strict"; en haut de votre code, avant toute chose.
Par exemple, blah = 33; est valide JavaScript. Cela signifie que vous créez une variable complètement globale blah.
Mais en mode strict, c'est une erreur car vous n'avez pas utilisé le mot clé "var" pour déclarer la variable.
La plupart du temps vous ne voulez pas créer de variables globales au milieu d'une portée arbitraire, donc la plupart du temps que blah = 33 est écrit, c’est une erreur et le programmeur ne voulait pas que ce soit une variable globale, ils voulaient écrire var blah = 33.
De même, il interdit beaucoup de choses techniquement valables à faire. NaN = "lol" ne produit pas d'erreur. Cela ne change pas non plus la valeur de NaN. en utilisant strict ceci (et des déclarations étranges similaires) produisent des erreurs. La plupart des gens l’apprécient car il n’ya aucune raison de ne jamais écrire NaN = "lol", il y avait donc probablement une faute de frappe.
Un aspect du mode strict qui n'a pas déjà été mentionné dans la réponse de Simon est que le mode strict définit this sur undefined dans les fonctions invoquées via l'invocation de fonction.
Alors des choses comme ça
function Obj() {
this.a = 12;
this.b = "a";
this.privilegedMethod = function () {
this.a++;
privateMethod();
};
function privateMethod() {
this.b = "foo";
}
}
provoquera une erreur lorsque privateMethod sera appelé (étant donné que vous ne pouvez pas ajouter une propriété à undefined), plutôt que d'ajouter inutilement une propriété b à l'objet global.
Le mode strict a été ajouté pour créer un sous-ensemble d'EcmaScript facilement analysable statiquement, qui constituerait une bonne cible pour les versions futures du langage. Le mode strict a également été conçu dans l’espoir que les développeurs qui se limitent au mode strict commettent moins d’erreurs et que les bugs qu’ils commettent se manifestent de manière plus évidente.
Harmony , qui, espérons-le, deviendra la prochaine version majeure d'EcmaScript sera construit sur ES5 strict.
Harmony s'appuie sur le mode strict ES5 pour éviter de trop nombreux modes.
Certaines autres expériences linguistiques dépendent également du mode strict. SES dépend de l'analysabilité du mode strict ES5.
Expérience de conception SES (Secure ECMAScript)
Concevez un langage de programmation de capacité d'objet en supprimant ou en réparant des fonctionnalités dans ES5/Strict.
Il devrait y avoir une traduction simple de SES vers ES5/Strict.
Annexe C de la norme explique les différences entre le mode strict et le mode normal.
La restriction de mode strict et les exceptions
- Les identificateurs "implémente", "interface", "let", "package", "privé", "protégé", "public", "statique" et "rendement" sont classés en tant que jetons FutureReservedWord dans le code en mode strict. (7.6.12 [?]).
- Une implémentation conforme, lors du traitement de code en mode strict, peut ne pas étendre la syntaxe de NumericLiteral (7.8.3) pour inclure OctalIntegerLiteral, comme décrit au paragraphe B.1.1.
- Une implémentation conforme, lors du traitement de code en mode strict (voir 10.1.1), peut ne pas étendre la syntaxe de EscapeSequence pour inclure OctalEscapeSequence comme décrit dans B.1.2.
- L'affectation à un identificateur non déclaré ou à une référence impossible à résoudre ne crée pas de propriété dans l'objet global. Lorsqu'une affectation simple se produit dans un code en mode strict, son LeftHandSide ne doit pas être évalué en tant que référence insoluble. Si c'est le cas, une exception ReferenceError est levée (8.7.2). LeftHandSide peut également ne pas être une référence à une propriété de données avec la valeur d'attribut {[[Writable]]: false}, à une propriété d'accesseur avec la valeur d'attribut {[[Set]]: undefined}, ni à une propriété non existante propriété d'un objet dont la propriété [[Extensible]] internal a la valeur false. Dans ces cas, une exception TypeError est levée (11.13.1).
- L'identificateur eval ou les arguments peuvent ne pas apparaître en tant qu'expression LeftHandSideExpression d'un opérateur Assignment (11.13) ou PostfixExpression (11.3), ni sous la forme UnaryExpression opérée par un opérateur Prefix Increment (11.4.4) ou Prefix Decrement (11.4.5). . Les objets arguments des fonctions en mode strict définissent des propriétés d'accesseur non configurables, appelées "appelant" et "appelées", qui déclenchent une exception TypeError sur l'accès (10.6).
- Les objets arguments des fonctions en mode strict ne partagent pas de manière dynamique les valeurs de leurs propriétés indexées avec des tableaux avec les liaisons de paramètres formelles correspondantes de leurs fonctions. (10,6). Pour les fonctions en mode strict, si un objet arguments est créé, la liaison des arguments de l'identificateur local à l'objet arguments est immuable et ne peut donc pas être la cible d'une expression d'affectation. (10,5).
- Il s'agit d'une SyntaxError si le code en mode strict contient un ObjectLiteral avec plus d'une définition d'une propriété de données (11.1.5). Il s'agit d'une SyntaxError si l'identifiant "eval" ou les arguments "Identifier" apparaissent comme identifiant dans un PropertySetParameterList d'un PropertyAssignment contenu dans un code strict ou si son FunctionBody est un code strict (11.1.5).
- Le code eval en mode strict ne peut pas instancier des variables ou des fonctions dans l'environnement de variable de l'appelant à eval. Au lieu de cela, un nouvel environnement de variable est créé et utilisé pour l'instanciation des liaisons de déclaration pour le code eval (10.4.2).
- Si ceci est évalué dans un code de mode strict, la valeur de cette valeur n'est pas forcée sur un objet. Une valeur nulle ou indéfinie n'est pas convertie en objet global et les valeurs primitives ne sont pas converties en objets wrapper. Cette valeur transmise via un appel de fonction (y compris les appels effectués à l'aide de Function.prototype.apply et Function.prototype.call) ne contraint pas la valeur transmise à un objet (10.4.3, 11.1.1, 15.3.4.3, 15.3. 4.4).
- Lorsqu'un opérateur de suppression se produit dans un code en mode strict, une syntaxeError est renvoyée si son expression UnaryExpression est une référence directe à une variable, un argument de fonction ou un nom de fonction (11.4.1).
- Lorsqu'un opérateur de suppression se produit dans un code en mode strict, une erreur TypeError est générée si la propriété à supprimer possède l'attribut {[[[Configurable]]]: false} (11.4.1). Il s'agit d'une SyntaxError si une VariableDeclaration ou une VariableDeclarationNoIn se produit dans un code strict et que son identifiant est eval ou des arguments (12.2.1).
- Le code de mode strict peut ne pas inclure un WithStatement. L'occurrence d'un WithStatement dans un tel contexte est une SyntaxError (12.10).
- C'est une SyntaxError si un TryStatement avec un Catch se produit dans un code strict et si l'identifiant de la production Catch est eval ou des arguments (12.14.1)
- Il s'agit d'une SyntaxError si l'identificateur eval ou les arguments apparaissent dans une liste FormalParameterList d'un mode strict FunctionDeclaration ou FunctionExpression (13.1).
- Une fonction en mode strict ne peut pas avoir deux paramètres formels ou plus ayant le même nom. Une tentative de création d'une telle fonction à l'aide d'un constructeur FunctionDeclaration, FunctionExpression ou Function est une syntaxe SyntaxError (13.1, 15.3.2).
- Une implémentation ne peut pas étendre, au-delà de celle définie dans la présente spécification, les significations au sein de fonctions en mode strict de propriétés appelées ou d'arguments d'instances de fonctions. Le code ECMAScript ne peut pas créer ou modifier des propriétés avec ces noms sur des objets fonction correspondant à des fonctions en mode strict (10.6, 13.2, 15.3.4.5.3).
- SyntaxError consiste à utiliser dans le code en mode strict les identificateurs eval ou les arguments en tant qu'identificateur d'une FunctionDeclaration ou FunctionExpression ou en tant que nom de paramètre formel (13.1). Tenter de définir de manière dynamique une telle fonction en mode strict à l'aide du constructeur Function (15.3.2) lève une exception SyntaxError.
ECMAScript 5 a introduit le concept de mode strict.
Invocation du mode strict dans le code
Le mode strict s’applique à des scripts entiers ou à des fonctions individuelles. Il ne s’applique pas à bloquer une instruction entre accolades {}, tenter de l’appliquer à de tels contextes ne fait rien.
Script complet:
Supposons que nous créons app.js. Ainsi, l'ajout du premier script d'utilisation des instructions appliquera le mode strict à l'ensemble du code.
// app.js whole script in strict mode syntax
“use strict”;
// Now you can start writing your code
Mode strict pour la fonction:
Pour invoquer le mode strict pour une fonction, mettez l'énoncé exact "use strict"; dans le début du corps de la fonction avant toute autre déclaration.
function yourFunc(){
"use strict";
// Your function code logic
}
Le mode strict incorpore plusieurs modifications à la sémantique Javascript normale. Le premier mode strict élimine certaines erreurs silencieuses JavaScript en les changeant en erreurs générées.
Par exemple: Code utilisant le mode strict
Dans l'exemple de code ci-dessus sans utiliser le mode strict dans le code, aucune erreur ne sera générée. Comme nous accédons à la variable x sans la déclarer. Donc, en mode strict, l'accès à une variable non déclarée génère une erreur.
Essayons maintenant d’accéder à la variable x sans la déclarer sans mode strict.
(function(){
x = 3;
})();
// Will not throw an error
Avantage d'utiliser le mode strict:
- Éliminez les erreurs silencieuses JavaScript en générant une erreur.
- Corrige les erreurs qui rendent difficile l'optimisation du moteur JavaScript.
- Faire en sorte que le code soit exécuté plus rapidement que le code identique qui n’est pas en mode strict
- Interdit certaines syntaxes susceptibles d'être définies dans les futures versions d'ECMAScript.
Le mode strict apporte plusieurs modifications à la sémantique JavaScript normale.
le mode strict élimine certaines erreurs silencieuses JavaScript en les changeant en erreurs générées.
le mode strict corrige les erreurs qui rendent difficile l'optimisation des moteurs JavaScript.
le mode strict interdit certaines syntaxes susceptibles d'être définies dans les futures versions d'ECMAScript.
2017 et j'ai enfin trouvé la documentation:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
Le mode strict est un moyen de choisir une variante restreinte de JavaScript. Le mode strict n'est pas qu'un sous-ensemble: il a intentionnellement une sémantique différente du code normal. Les navigateurs ne prenant pas en charge le mode strict exécuteront du code en mode strict avec un comportement différent de celui des navigateurs qui le font. Ne vous fiez donc pas au mode strict sans test de fonctionnalité pour prendre en charge les aspects pertinents du mode strict. Le code en mode strict et le code en mode non strict peuvent coexister, ce qui permet aux scripts de passer en mode strict de manière incrémentielle.
Le mode strict apporte plusieurs modifications à la sémantique JavaScript normale. Premièrement, le mode strict élimine certaines erreurs silencieuses JavaScript en les modifiant en erreurs générées. Deuxièmement, le mode strict corrige les erreurs qui rendent difficile l'optimisation des moteurs JavaScript: le code en mode strict peut parfois être exécuté plus rapidement que le code identique, mais pas en mode strict. Troisièmement, le mode strict interdit certaines syntaxes susceptibles d'être définies dans les futures versions d'ECMAScript.
ECMAScript5 introduit de nouveaux objets et propriétés, ainsi que le soi-disant "strict mode".
Le mode strict est un sous-ensemble du langage qui exclut les fonctionnalités obsolètes. Le mode strict est opt-in et non requis, ce qui signifie que si vous souhaitez que votre code soit exécuté en mode strict, vous déclarez votre intention en utilisant (une fois par fonction ou une fois pour l'ensemble du programme) la chaîne suivante:
"use strict";
Question:
Voici le problème que j'ai rencontré, je suivais un tutoriel et il a fini par essayer de compiler le fichier suivant scss et d'essayer de générer du code CSS à partir de celui-ci,
.fatty{
width: percentage(6/7);
}
en utilisant la tâche gulpfile.js suivante:
var gulp = require('gulp');
var sass = require('gulp-sass');
gulp.task('sass', function () {
return gulp.src('app/scss/styles.scss')
.pipe(sass())
.pipe(gulp.dest('app/css'))
});
Donc l'erreur que j'obtiens est la suivante:
~/htdocs/Learning/gulp1/node_modules/gulp-sass/index.js:66
let sassMap;
^^^
SyntaxError: Block-scoped declarations (let, const, function, class) not yet supported outside strict mode
at exports.runInThisContext (vm.js:53:16)
at Module._compile (module.js:373:25)
// stacktrace here...
Solution:
Donc, il me montre le fichier index.js Qui se trouve dans mon module gulp-sass (qui est fondamentalement verrouillé et ne devrait pas être modifié). Mais si j'y vais avec force et que j'ajoute le "use_strict" Au-dessus de ce fichier index.js, La tâche se déroulera sans heurts.
J'étais impuissant, je continue donc à l'utiliser comme solution! Mais ensuite, après avoir traversé un autre SO les questions et réponses que j'ai vues ci-après) comme suit:
Sudo npm install -g n
Sudo n stable
et plus tôt, j'ai mis à jour mes NodeJs (avec Version10.x), puis j'ai reconstruit Gulp en exécutant les commandes suivantes, comme Terminal me l'avait indiqué:
npm rebuild node-sass --force
Et tout va bien. Alors c'est comme ça que ça s'est résolu. J'ai annulé les modifications apportées au fichier de module gulp index.js. Et maintenant, tout se passe bien.
J'espère que cette réponse sera utile à quelqu'un!