这篇关于Javascript严格模式的文章可能会引起您的兴趣: John Resig - ECMAScript 5 Strict Mode, JSON, and More

严格模式是ECMAScript 5中的一项新功能,允许您将程序或函数置于“严格”操作上下文中。这种严格的上下文阻止执行某些操作,并引发更多异常。

以及:

严格模式有两种帮助:

• 当采取相对“不安全”的操作(例如访问全局对象)时,它可以防止或抛出错误。
• 它会禁用令人困惑或考虑不周的功能。

另外请注意,您可以对整个文件应用“严格模式”。。。或者,您只能将其用于特定功能 (仍引用约翰·雷斯格的文章)

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code...

所以,我想这有点像 "use strict" 您可以在Perl中使用 (因此得名?) :通过检测更多可能导致损坏的东西,它可以帮助您减少错误。

supported by all major browsers .

在…内 native ECMAScript modules (有 import 和 export ES6 classes ,严格模式始终处于启用状态,不能禁用。

这是ECMAScript 5的一个新特性。约翰·雷西格写了一篇文章 a nice summary 当然。

"use strict";

现在将它放入代码中不会对当前浏览器造成任何问题,因为它只是一个字符串。如果您的代码违反pragma,将来可能会导致代码出现问题。例如,如果您当前有 foo = "bar" 没有定义 foo 首先,您的代码将开始失败…在我看来这是一件好事。

"use strict"; 指示浏览器使用严格模式,这是JavaScript的一个简化且更安全的功能集。

功能列表(非详尽)

1. 不允许全局变量。(失踪 var 变量名中的声明和输入错误)

2. NaN = 5; )

3. 尝试删除不可删除的属性将引发( delete Object.prototype )

4. 要求对象文字中的所有属性名称都是唯一的( var x = {x1: "1", x1: "2"}

5. 函数参数名称必须是唯一的( function sum (x, x) {...} )

6. 禁止八进制语法( var x = 023; 一些开发人员错误地认为前面的零不会改变数字。)

7. 禁止 with

8. eval 在严格模式下,不会引入新变量

9. delete x; )

10. 评估 arguments 以任何形式

11. 严格模式不别名的属性 对象的形式参数。(例如在 function sum (a,b) { return arguments[0] + b;} 这是因为 arguments[0] a

12. arguments.callee

Strict mode , Mozilla开发者网络 ]

如果人们担心使用 use strict 这篇文章可能值得一看:

ECMAScript 5 'Strict mode' support in browsers. What does this mean?

它谈到了浏览器支持,但更重要的是如何安全地处理它:

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.
*/

一句警告的话,你们所有努力收费的程序员:申请 "use strict" 对现有代码的修改可能是危险的!这个东西不是一些感觉良好、开心的贴纸,你可以贴在代码上使它“更好”。和 “严格使用” pragma,浏览器会突然在它以前从未抛出的随机位置抛出异常,只是因为在那个位置,您正在做一些默认/松散JavaScript允许但严格JavaScript厌恶的事情!您的代码中很少使用的调用中可能隐藏着严格性冲突,这些调用只有在它们最终运行时才会抛出异常—例如,在付费客户使用的生产环境中!

如果你打算冒险,申请是个好主意 “严格使用” “严格使用” 绝对不会 添加 任何您不拥有或维护的模块,如第三方模块。

JSHint/JSLint Grunt+Karma+Chai ,然后才开始将所有新模块标记为 “严格使用” . 准备好纠正许多微小的错误和警告。通过将构建配置为在以下情况下失败,确保每个人都理解其重要性 JSHint/JSLint 产生任何违规行为。

当我采用时,我的项目不是一个绿地项目 “严格使用” “严格使用” 在我的一半模块上,JSHint对此表示不满。这提醒了我今后应该做什么重构。我的目标是,由于我所有的缺失,我的目标是成为自由的红色标记 “严格使用” 声明,但这是几年后的事了。

使用 'use strict'; 不会突然使代码变得更好。

这个 JavaScript strict mode 是中的一个功能 ECMAScript 5 . 通过在脚本/函数的顶部声明,可以启用严格模式。

'use strict';

,它将开始以特殊模式解释代码。在这种模式下,当检测到某些可能最终成为潜在bug的编码实践时(这就是严格模式背后的原因),就会抛出错误。

考虑这个例子:

var a = 365;
var b = 030;

b 使用八进制文字。非严格模式会将其解释为带值的数值文字 24

有关严格模式下专业的非详尽列表,请参阅 this answer .

我应该在哪里使用 ?

• 刚出现的 JavaScript应用程序: 当你用你的代码做一些愚蠢的事情时,严格模式可以用作告密者。

• 现有的 JavaScript代码: 可能不会! 如果您现有的JavaScript代码包含在严格模式下被禁止的语句,那么应用程序将简单地中断。如果您想要严格模式,您应该准备调试和更正现有代码。这就是为什么 使用 "严格使用",; 不会突然使代码变得更好 .

1. 插入 "严格使用",; 脚本顶部的语句:

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

   请注意,文件中的所有内容 myscript.js 将以严格模式进行解释。

2. 或者,插入 函数体顶部的语句:

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

   词汇范围 功能 doSomething 将以严格模式进行解释。字眼 词汇范围 这一点很重要。例如,如果您的 严格的 代码调用的库函数是 ,只有您的代码在严格模式下执行,而不是被调用的函数。看见 this answer 为了更好的解释。

什么东西在严格模式下是禁止的?

nice article 描述严格模式下禁止的几件事情(注意,这不是排他的列表):

从历史上看,JavaScript一直对其功能感到困惑 它们的作用域是有限的。有时它们似乎是静态范围的,但有些 令人困惑,使程序难以阅读和理解。 误解导致错误。这也是一个性能问题。 延迟到运行时,这会带来显著的性能 处罚

这意味着以前需要动态绑定的特性 必须删除或修改。具体来说,with语句是 消除了,eval函数能够篡改 其调用者的环境受到严格限制。

严格代码的好处之一是 YUI Compressor

隐含全局变量

如果不显式声明变量,则可以使用全局变量 隐式地为您声明。这使得编程更容易 家务活。但它使大型项目的管理变得更加复杂 这很困难,而且会显著降低可靠性。严格地说 显式声明所有变量。

有许多情况可能导致 this 提供 new 前缀调用构造函数时 建造师的 将意外绑定到全局对象,因此 它不是初始化新对象,而是静默地初始化 篡改全局变量。在这些情况下,将使用严格模式 相反,绑定 这 undefined ,这将导致构造函数 而是抛出一个异常,允许错误被检测到 早一点。

Object.createProperty 函数公开了该功能。如果您试图分配一个值 对于只读属性,它将以静默方式失败。这项任务将 不更改Property的值,但您的程序将按 虽然有。这是一种完整性危害,可能导致程序 进入不一致的状态。在严格模式下,尝试更改

八进制

数字的八进制(或以8为基数)表示法极其复杂 在具有word的机器上执行机器级编程时非常有用 大小是3的倍数。你在CDC工作时需要八进制 6600大型机,字大小为60位。如果你能阅读 八进制,你可以把一个单词看作20位数字。表示两位数字 操作码和一个数字标识了8个寄存器中的一个。在 从机器代码到高级语言的缓慢转换,是

在C中,一个非常不幸的八度表示是 选中:前导零。所以在C中, 0100 08 是一个 错误,不是8。更不幸的是,这种不合时宜的做法已经过时 复制到几乎所有现代语言中,包括JavaScript 它仅用于创建错误。它没有其他用途。所以在 严格模式下,八进制形式不再允许。

伪数组的参数变得稍微多了一点 类似于ES5中的数组。在严格模式下,它会丢失其 callee 和 caller 财产。这使得通过考试成为可能 arguments 在不放弃大量机密上下文的情况下编写代码。此外,

在严格模式下,函数文本中的重复键将产生 参数。函数超调 delete 删去 一个不可配置的属性现在抛出一个异常。原始的 值不是隐式包装的。

未来JavaScript版本的保留字

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

• Strict Mode - JavaScript | MDN
• Browser support for strict mode
• Transitioning to strict mode

我强烈建议每个开发人员现在就开始使用严格模式。有足够多的浏览器支持它,严格模式将合法地帮助我们避免我们甚至不知道代码中存在的错误。

显然,在最初阶段会出现我们从未遇到过的错误。为了获得充分的好处,我们需要在切换到严格模式后进行适当的测试,以确保捕获了所有内容。当然,我们不只是扔 use strict

例如

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

JSLint 是Douglas Crockford编写的调试器。只需粘贴到脚本中,它就会快速扫描代码中任何明显的问题和错误。

我想提供一个更有根据的答案来补充其他答案。我希望编辑最流行的答案,但失败了。我试图使它尽可能全面和完整。

你可以参考 MDN documentation

"use strict" ECMAScript 5中引入的指令。

指令与语句相似,但不同。

• use strict 不包含关键字:该指令是一个简单的表达式语句,由一个特殊的字符串文字(单引号或双引号)组成。不实现ECMAScript 5的JavaScript引擎只看到表达式语句,没有副作用。预计ECMAScript标准的未来版本将引入 use 作为一个真正的关键词;因此,这些引文将变得过时。
• 只能在脚本或函数的开头使用,即它必须位于其他(实)语句之前。它不必是函数脚本中的第一条指令:它前面可以是由字符串组成的其他语句表达式(JavaScript实现可以将它们视为特定于实现的指令)。在第一个实数语句(在脚本或函数中)之后的字符串文字语句是简单的表达式语句。口译员不得将其解释为指令,且不起任何作用。

这个 指令指示以下代码(在脚本或函数中)是严格的代码。 严格使用 当函数本身在严格代码中定义或函数包含 严格使用 指令。 传递给 eval() eval() 严格使用 指令本身。

• 您不能使用 with -严格模式下的语句。
• 在严格模式下,必须声明所有变量:如果您为尚未声明为变量、函数、函数参数、catch子句参数或全局变量属性的标识符赋值 Object ,那么您将获得 ReferenceError . 在正常模式下,标识符隐式声明为全局变量(作为全局变量的属性) 对象 )
• 在严格模式下,关键字 this 有价值 undefined 在作为函数(而不是方法)调用的函数中。(在正常模式下) 这 始终指向全球 )。此差异可用于测试实现是否支持严格模式:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

• 当使用调用函数时也是如此 call() 或 apply 在严格模式下,然后 正是的第一个参数的值 或 apply() null 和 被全球金融体系所取代 对象 而不是对象的值将被强制转换到对象中。)

• 在严格模式下,您将获得 TypeError ,当您尝试为非可扩展对象指定只读属性或定义新属性时。(在正常模式下,两者都会简单地失败,而不会出现错误消息。)

• 在严格模式下,将代码传递给 eval() ,您不能在调用者的作用域中声明或定义变量或函数(您可以在正常模式下这样做)。相反,将为创建一个新的作用域 eval() 变量和函数都在这个范围内。该范围在 eval()
• 在严格模式下,函数的arguments对象包含传递给该函数的值的静态副本。在正常模式下,arguments对象具有某种“神奇”的行为:数组元素和命名函数参数引用相同的值。
• 在严格模式下,您将获得 SyntaxError 当 delete 删去 false .
• 尝试删除不可配置的属性时。(在正常模式下,尝试失败,并且 删去 表达式的计算结果为 错误的 ).
• 在严格模式下,当函数声明具有多个同名参数时,会将其视为语法错误。(在正常模式下,没有错误。)
• 在严格模式下,不允许使用八进制文字(这些文字以 0x . (在正常模式下,某些实现确实允许八进制文字。)
• 在严格模式下,标识符 eval 和 arguments 被视为关键字。不能更改它们的值,不能为它们赋值,也不能将它们用作catch块的变量、函数、函数参数或标识符的名称。
• 在严格模式下,对检查调用堆栈的可能性有更多限制。 arguments.caller 和 arguments.callee 引起 打字错误 打字错误

我的两分钱:

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 . 当我们实施 代码将抛出错误。

未捕获引用错误:未定义树的名称

Sample

消除 with

具有 不能使用诸如 uglify-js deprecated 并从未来的JavaScript版本中删除。

Sample

防止重复:

当我们有重复的属性时,它抛出一个异常

未捕获的SyntaxError:对象文字中的重复数据属性不存在 在严格模式下允许

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

如果您使用的是去年左右发布的浏览器,那么它很可能支持JavaScript严格模式。只有ECMAScript 5成为当前标准之前的旧浏览器不支持它。

命令周围的引号确保代码在较旧的浏览器中也能工作(尽管在严格模式下生成语法错误的东西通常只会导致脚本在较旧的浏览器中以某种难以检测的方式出现故障)。

添加时 "use strict"; 语法错误 在执行脚本之前:

• 为将来的ECMAScript版本铺平道路 ,使用新保留的关键字之一(在 ECMAScript 6 implements interface , let package , private protected , public static 和 yield .

• 在块中声明函数

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

• 八进制语法

  var n = 023;
  

• this 指向全局对象。

   function f() {
        "use strict";
        this.a = 1;
   };
   f(); 
  

•  {a: 1, b: 3, a: 7} 
  

  ECMAScript 6中不再是这种情况( bug 1041128 ).

• 声明两个同名函数的函数参数

  f(a, b, b){}
  

• function f(x){
     "use strict";
     var a = 12;
     b = a + x*35; // error!
  }
  f();
  

• 使用 delete 关于变量名 delete myVariable;

• 使用 eval 或 arguments 作为变量或函数参数名

  "use strict";
  arguments++;
  var obj = { set p(arguments) { } };
  try { } catch (arguments) { }
  function arguments() { } 
  

资料来源:

• Transitioning to strict mode 关于MDN

• Strict mode 关于MDN

• JavaScript’s Strict Mode and Why You Should Use It 在Colin J.Ihrig的博客上(存档版)

Strict模式对普通JavaScript语义进行了一些更改:

• 通过更改JavaScript静默错误来消除这些错误 抛出错误。

• 修复了使JavaScript变得困难的错误

• 禁止将来可能定义的某些语法 ECMAScript的版本。

欲了解更多信息,请访问vistit Strict Mode- Javascript

“严格使用”;是一种保证,程序员不会使用JavaScript的松散或不良属性。它是一个向导,就像一把尺子可以帮你画直线一样。“使用严格”将帮助您进行“直接编码”。

那些不喜欢使用标尺直接执行代码的人通常会在页面中要求其他人调试他们的代码。

相信我。与设计糟糕的代码相比,开销可以忽略不计。 Doug Crockford, who has been a senior JavaScript developer for several years, has a very interesting post here

其目的是允许经验较少的程序员访问JavaScript,然后给他们时间来适应新的更安全的编码实践。

包括…在内 use strict 从这一点开始,在所有敏感的JavaScript文件的开头,是一个成为更好的JavaScript程序员的小方法,可以避免随机变量变为全局变量,事情会无声地改变。

Quoting from w3schools :

“使用严格”指令

“use strict”指令是JavaScript 1.8.5(ECMAScript)中的新指令 第5版)。

它不是一个语句,而是一个文字表达式,被前面的语句忽略 JavaScript版本。

“严格使用”的目的是表示代码应 在“严格模式”下执行。

例如,在严格模式下,不能使用未声明的变量。

为什么是严格模式?

严格模式使编写“安全”JavaScript变得更容易。

严格模式将以前接受的“错误语法”更改为实际错误。

一个新的全局变量。在严格模式下,这将抛出一个错误, 使得不可能意外地创建全局变量。

在普通JavaScript中,开发人员不会收到任何错误反馈 为不可写属性赋值。

在严格模式下,对不可写属性的任何赋值 仅getter属性、不存在的属性、不存在的 变量或不存在的对象将抛出错误。

请参阅 http://www.w3schools.com/js/js_strict.asp 了解更多

"use strict" 使JavaScript代码在中运行 ,这基本上意味着在使用之前需要定义所有内容。使用strict模式的主要原因是避免意外全局使用未定义的方法。

同样在严格模式下,运行速度更快,一些警告或无声警告会抛出致命错误,最好总是使用它来生成更整洁的代码。

“严格使用” 广泛需要在ECMA5中使用, 在ECMA6中,默认情况下它是JavaScript的一部分 ,因此,如果您使用ES6,则不需要添加它。

文字表达式,被早期版本的JavaScript忽略。这个 “严格使用”的目的是表示代码应

使用“严格使用”的示例:
函数的严格模式:同样,调用函数的严格模式 函数中,放入确切的语句“使用严格”;(或“严格使用”;)在 函数体在任何其他语句之前。

1) 函数中的严格模式

 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) 全脚本严格模式

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

3) 分配给不可写全局

'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

你可以 read more on MDN .

ECMAScript委员会的一些成员进行了一次很好的讨论: Changes to JavaScript, Part 1: ECMAScript 5" "use strict" switch允许JavaScript实现者清除JavaScript的许多危险特性,而不会突然破坏世界上的每个网站。

要比较的小示例:

非严格模式:

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

严格模式:

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

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

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

注意 use strict 于年引进 EcmaScript 5 从那以后就一直留着。

以下是在中触发严格模式的条件 ES6 和 ES7 :

• 模块代码始终是严格的模式代码。
• 类声明 或者 是严格的模式代码。
• FunctionDeclaration、FunctionExpression、GeneratorDeclaration、GeneratorExpression、MethodDefinition或ArrowFunction 包含在严格模式代码中,或者生成函数[[ECMAScriptCode]]内部插槽值的代码以包含Use strict指令的指令序言开头。
• 如果最后一个参数是字符串,则作为内置函数和生成器构造函数的参数提供的函数代码是严格模式代码,而处理后的字符串是 功能体 这从包含Use Strict指令的指令序言开始。

"use strict" 是:

1. 防止意外声明全局变量。使用 "use strict()" 将确保使用 var 使用前。 如:

   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. “严格使用” 指令只能在脚本或函数的开头识别。

3. 弦 "arguments"

   "use strict";
   var arguments = 3.14;    // This will cause an error
   

4. 将限制关键字作为变量的使用。尝试使用它们将抛出错误。

简言之,这将使您的代码不那么容易出错,从而使您编写出优秀的代码。

here

ECMAScript 5中引入了JavaScript严格模式。

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

写 "use strict"; 在JS文件的最顶端,将启用“严格” 语法检查。它为我们完成以下任务:

1. 如果尝试分配给未声明的变量,则显示错误

use strict 也可以在单个函数内部工作。最好的做法是包括 在你的代码中。

浏览器兼容性问题: “use”指令意味着向后兼容。不支持它们的浏览器只会看到一个未被进一步引用的字符串文本。因此,他们将越过它继续前进。

use strict

“严格使用”;ECMA努力使JavaScript更加健壮。它引入了JS,试图使它至少有一点“严格”(自90年代以来,其他语言都实现了严格的规则)。它实际上“强迫”JavaScript开发人员遵循某种编码最佳实践。 尽管如此,JavaScript仍然非常脆弱。没有类型化变量、类型化方法等。 我强烈建议JavaScript开发人员学习更健壮的语言,如Java或ActionScript3,并在JavaScript代码中实现相同的最佳实践,这样会更好地工作,更易于调试。

通常,JavaScript不遵循严格的规则,因此增加了出错的机会。使用后 "use strict" ,JavaScript代码应该像在其他编程语言中一样遵循严格的规则集,如使用终止符、初始化前声明等。

如果 “严格使用” 在使用时,代码应该遵循一组严格的规则编写,从而减少错误和歧义的可能性。

• 防止意外的全局错误

• 无多重记录

• 消除

• 消除这种胁迫

• 不可变的错误

你也可以读这个 article 详情

“严格使用”;定义应在中执行的JavaScript代码 “严格模式”。

• “use strict”指令在ECMAScript版本5中是新的。
• JavaScript版本。
• 在“严格模式”下执行。
• 例如,在严格模式下,不能使用未声明的变量。

Internet Explorer 9及更低版本 .

缺点

如果开发人员使用的库处于严格模式,但开发人员习惯于在正常模式下工作,那么他们可能会对库调用一些无法按预期工作的操作。

更糟糕的是,由于开发人员处于正常模式,他们没有抛出额外错误的优势,因此错误可能会无声地失败。

人们通常认为首先不应该使用这些东西,但是一些开发人员不喜欢这种限制,希望使用该语言的所有特性。

• 有关基本示例和参考,请浏览:

  https://www.tutorialsteacher.com/javascript/javascript-strict

严格模式可以防止内存泄漏。

请检查以下以非严格模式编写的函数:

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

在这个函数中,我们使用一个名为 name 函数内部。在内部,编译器将首先检查在特定函数作用域中是否有使用该特定名称声明的变量。因为编译器知道没有这样的变量,所以它将检查外部范围。就我们而言,这是全球范围。同样,编译器理解在全局空间中也没有使用该名称声明的变量,因此它在全局空间中为我们创建了这样一个变量。从概念上讲,该变量将在全局范围内创建,并在整个应用程序中可用。

另一种情况是,比方说,变量在子函数中声明。在这种情况下,编译器将检查外部范围(即父函数)中该变量的有效性。只有这样,它才会在全局空间中进行检查,并在那里为我们创建一个变量。 这意味着需要进行额外的检查。这将影响应用程序的性能。

现在让我们在严格模式下编写相同的函数。

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

我们将得到以下错误。

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

这里,编译器抛出引用错误。在严格模式下,编译器不允许我们在不声明变量的情况下使用它。因此,可以防止内存泄漏。此外,我们还可以编写更优化的代码。

它被认为是最佳实践之一吗?

对 严格模式 . 这是通过在JS文件中添加下面的代码行来完成的。

'use strict';

在你的代码中。

指示代码应该在严格模式下解释,这会向浏览器等用户代理指定他们应该将代码视为书面代码,如果代码没有意义,则抛出错误。

例如: 考虑一下 .js 文件中包含以下代码:

var city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

那么,为什么在这两种情况下都会打印变量名呢?

如果未启用严格模式,用户代理通常会对有问题的代码进行一系列修改,以使其有意义。从表面上看,这似乎是一件好事,事实上,在严格模式之外工作使人们可以在不完全确定所有细节的情况下,用JavaScript代码湿脚。然而,作为一名开发人员,我不想在我的代码中留下一个bug,因为我知道它以后可能会回来咬我,我也只想写好代码。这就是严格模式的作用所在。

场景3:[严格模式]

'use strict';

city = "Chicago"
console.log(city) // Reference Error: asignment is undeclared variable city.

附加提示: .js eslint 规则如下:

文件名: .eslintrc.js

module.exports = {
    env: {
        es6: true
    },
    rules : {
        strict: ['error', 'global'],
        },
    };
    

• 将在严格模式下抛出错误。这是为了防止在整个应用程序中无意中创建全局变量。《芝加哥印刷》的例子特别说明了这一点。

• 在严格模式下为“否”。

  "use strict";
   function x(p1, p2) {}; 
   delete x; // This will cause an error
  

• 是 不 在严格模式下允许。

   "use strict";
   function x(p1, p1) {};   // This will cause an error
  

• 不允许使用Javascript语言中的保留字

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode

由于浏览器战争和糟糕的管理,JavaScript的设计和实现都很匆忙。结果,许多糟糕的设计决策、不直观的语法和令人困惑的语义进入了语言。严格模式旨在修正其中一些错误。

但在不创建替代解释的情况下修复这些错误会破坏向后兼容性。所以 "use strict" 指令在与程序员通信时创建代码的替代解释。

例如 this 关键字是指方法定义中的对象,如 或 self 用其他语言。

let o = {
  name: 'John Doe',
  sayName: function(){
    console.log(this.name);
  }
};

o.sayName(); // 'John Doe'

这 在方法上下文之外没有任何用途,但所有JavaScript函数都有 这 关键字是否为方法:

function run() {
  console.log(this);
}

run(); // Window

在这里 这

以严格的方式 这 在一个全局函数中,解析为未定义,这就是我们所期望的。

"use strict"

function run() {
  console.log(this);
}

run(); // undefined

有些错误即使在严格模式下也无法修复,因为语法应该对较旧的浏览器有效,因为它们忽略了 "strict mode"