JavaScript中使用"严格"做什么,背后的原因是什么？

Question

最近,我通过Crockford的JSLint运行了一些我的JavaScript代码,它给出了以下错误:

第1行问题1:缺少"使用严格"声明.

做一些搜索,我意识到有些人会加入"use strict";他们的JavaScript代码.一旦我添加了语句,错误就会停止显示.不幸的是,谷歌没有透露这个字符串声明背后的历史.当然它必须与浏览器如何解释JavaScript有关,但我不知道效果会是什么.

那么它是"use strict";什么,它意味着什么,它是否仍然相关？

当前的任何浏览器都会响应"use strict";字符串还是将来使用？

Answer 1

这篇关于Javascript Strict Mode的文章可能会让您感兴趣:John Resig - ECMAScript 5 Strict Mode,JSON等

引用一些有趣的部分:

严格模式是ECMAScript 5中的一项新功能,允许您在"严格"操作上下文中放置程序或函数.这种严格的上下文阻止了某些操作被采取并引发更多异常.

和:

严格模式有两种方式:

• 它捕获了一些常见的编码bloopers,抛出异常.
• 当采取相对"不安全"的操作(例如获取对全局对象的访问权限)时,它会阻止或抛出错误.
• 它禁用令人困惑或思索不周的功能.

另请注意,您可以对整个文件应用"严格模式"...或者您只能将其用于特定功能(仍然引用John Resig的文章):

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

如果你必须混合旧代码和新代码,这可能会有所帮助;-)

所以,我认为它有点像"use strict"你可以在Perl中使用(因此名称？):通过检测可能导致破坏的更多事情,它可以帮助您减少错误.

目前,它受到所有主流浏览器 的支持(IE 9及以下版本).

Answer 2

这是ECMAScript 5的一个新功能.John Resig写了一个很好的摘要.

它只是一个放在JavaScript文件中的字符串(位于文件顶部或函数内部),如下所示:

"use strict";

现在将它放在你的代码中不应该导致当前浏览器出现任何问题,因为它只是一个字符串.如果您的代码违反了编译指示,将来可能会导致您的代码出现问题.例如,如果您目前foo = "bar"没有foo先定义,那么您的代码将开始失败......在我看来这是一件好事.

Answer 3

该语句"use strict";指示浏览器使用Strict模式,这是一种简化且更安全的JavaScript功能集.

功能列表(非详尽)

1. 不允许全局变量.(var以变​​量名称捕获缺少的声明和拼写错误)

2. 无提示失败的分配将在严格模式下抛出错误(分配NaN = 5;)

3. 尝试删除不可删除的属性将throw(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. 禁止绑定或名称的分配eval和arguments任何形式

11. 严格模式不会arguments使用形式参数别名对象的属性.(即在function sum (a,b) { return arguments[0] + b;}此作品因为arguments[0]受到约束a等等.)

12. arguments.callee 不受支持

[参考:严格模式,Mozilla开发者网络 ]

Answer 4

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

ECMAScript 5在浏览器中支持"严格模式".这是什么意思？
NovoGeek.com - 克里希纳的博客

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

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

Answer 5

需要注意的是,所有的硬件程序员:应用"use strict"现有代码都是危险的!这个东西不是一些感觉良好,快乐的贴纸,你可以拍打代码,让它"更好".有了"use strict"编译指示,浏览器会突然发现以前从未投过的随机位置的异常只是因为在那个位置你正在做一些默认/松散JavaScript允许但严格的JavaScript憎恶的东西!您可能会在代码中隐藏很少使用的严格违规,只会在最终运行时抛出异常 - 例如,在付费客户使用的生产环境中!

如果您想要采取行动,最好同时应用"use strict"全面的单元测试和严格配置的JSHint构建任务,这将使您确信模块中没有黑暗的角落会因为您而可怕地爆炸已经开启了Strict Mode.或者,嘿,这是另一个选择:只是不要添加"use strict"到任何遗留代码,它可能更安全,老实说. 绝对不要添加"use strict"到您不拥有或维护的任何模块,例如第三方模块.

我认为即使它是一种致命的笼养动物,"use strict"也可能是好东西,但你必须做得对.严格要求的最佳时机是您的项目是绿地并且您从头开始.配置JSHint/JSLint所有警告和选项,尽可能紧随团队的需要,获得一个良好的构建/测试/断言系统Grunt+Karma+Chai,并且只有那么开始标记所有新模块"use strict".准备好治愈许多琐碎的错误和警告.如果JSHint/JSLint产生任何违规,请确保每个人都了解重力,将构建配置为FAIL .

我收养时,我的项目不是一个绿地项目"use strict".结果,我的IDE充满了红色标记,因为我没有"use strict"一半的模块,JSHint抱怨这一点.这提醒我一下我将来应该做什么重构.我的目标是由于我所有遗失的"use strict"陈述而成为红色标记,但现在还需要几年的时间.

Answer 6

使用'use strict';不会突然使您的代码更好.

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

'use strict';

当JavaScript引擎看到此指令时,它将开始以特殊模式解释代码.在这种模式下,当检测到可能最终成为潜在错误的某些编码实践时(这是严格模式背后的原因),会引发错误.

考虑这个例子:

var a = 365;
var b = 030;

在他们对数字文字排列的痴迷中,开发人员无意中b用八进制文字初始化变量.非严格模式会将其解释为具有值的数字文字24(在基数10中).但是,严格模式会抛出错误.

有关严格模式的非专业清单,请参阅此答案.

我应该在哪里使用'use strict';？

• 在我的新 JavaScript应用程序中:绝对!当您使用代码做一些愚蠢的事情时,严格模式可以用作举报者.

• 在我现有的 JavaScript代码中:可能不是!如果您现有的JavaScript代码具有在严格模式下禁止的语句,则应用程序将会中断.如果您想要严格模式,您应该准备调试和更正现有代码.这就是为什么使用'use strict';不会突然使您的代码更好.

我如何使用严格模式？

1. 'use strict';在脚本之上插入一条语句:

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

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

2. 或者,'use strict';在函数体上插入一条语句:

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

   函数词法范围内的所有内容都doSomething将以严格模式进行解释.词汇范围这个词在这里很重要.请参阅此答案以获得更好的解释.

严格模式禁止哪些事情？

我发现了一篇很好的文章,描述了在严格模式下禁止的几件事(请注意,这不是一个独家列表):

范围

从历史上看,JavaScript一直困扰着函数的作用域.有时它们似乎是静态范围的,但有些功能使它们的行为类似于动态范围.这令人困惑,使程序难以阅读和理解.误解会导致错误.这也是性能问题.静态作用域允许在编译时发生变量绑定,但是对动态作用域的要求意味着必须将绑定延迟到运行时,这会带来显着的性能损失.

严格模式要求静态完成所有变量绑定.这意味着必须消除或修改以前需要动态绑定的功能.具体来说,删除了with语句,并且eval函数篡改其调用者环境的能力受到严格限制.

严格的代码的好处之一是像YUI Compressor 这样的工具在处理它时可以做得更好.

隐含的全局变量

JavaScript隐含了全局变量.如果未显式声明变量,则会隐式声明全局变量.这使得初学者的编程更容易,因为他们可以忽略一些基本的家务杂务.但它使较大程序的管理变得更加困难,并且显着降低了可靠性.因此,在严格模式下,不再创建隐含的全局变量.您应该明确声明所有变量.

全球泄漏

有许多情况可能导致this 绑定到全局对象.例如,如果new在调用构造函数时忘记提供前缀,则构造函数this将意外绑定到全局对象,因此它不是初始化新对象,而是静默地篡改全局变量.在这些情况下,严格模式将绑定this到undefined,这将导致构造函数抛出异常,允许更快地检测到错误.

吵闹失败

JavaScript始终具有只读属性,但在ES5的Object.createProperty 功能暴露该功能之前,您无法自己创建它们.如果您尝试将值分配给只读属性,则它将以静默方式失败.赋值不会改变属性的值,但是程序会像它一样继续进行.这是一种完整性危害,可能导致程序进入不一致状态.在严格模式下,尝试更改只读属性将引发异常.

八进制

当在字大小为3的倍数的机器上进行机器级编程时,数字的八进制(或基数8)表示非常有用.在使用CDC 6600大型机(字大小为60位)时,需要八进制.如果你可以读八进制,你可以看一个单词为20位数.两位数表示操作码,一位数字表示8个寄存器中的一个.在从机器代码到高级语言的缓慢过渡期间,认为在编程语言中提供八进制形式是有用的.

在C中,选择了非常不幸的八进制表示:前导零.所以在C中,0100意味着64,而不是100,并且08是一个错误,而不是8.更不幸的是,这种时代错误被复制到几乎所有现代语言中,包括JavaScript,它只用于创建错误.它没有其他目的.因此在严格模式下,不再允许八进制形式.

等等

参数伪数组在ES5中变得更像阵列.在严格模式下,它失去了它callee和caller 属性.这样就可以在arguments不放弃大量机密上下文的情况下将您的代码传递给不受信任的代码.此外,arguments消除了功能的 属性.

在严格模式下,函数文字中的重复键将产生语法错误.函数不能有两个具有相同名称的参数.函数不能具有与其参数之一具有相同名称的变量.一个函数delete不能自己变量.尝试 delete使用不可配置的属性现在会抛出异常.原始值不是隐式包装的.

未来JavaScript版本的保留字

ECMAScript 5添加了一个保留字列表.如果将它们用作变量或参数,则严格模式将引发错误.保留字是:

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

进一步阅读

• 严格模式 - JavaScript | MDN
• 浏览器支持严格模式
• 过渡到严格模式

Answer 7

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

显然,在初始阶段,我们以前从未遇到过错误.为了获得全部好处,我们需要在切换到严格模式后进行适当的测试,以确保我们已经捕获了所有内容.当然,我们不只是抛弃use strict我们的代码并假设没有错误.所以,流失是时候开始使用这个非常有用的语言功能来编写更好的代码.

例如,

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

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

Answer 8

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

您可以参考MDN文档以获取更多信息.

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

指令与陈述类似,但不同.

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

该use strict指令表明以下代码(在脚本或函数中)是严格的代码.当脚本包含use strict指令时,脚本最高级别的代码(不在函数中的代码)被视为严格代码.当函数本身在严格的代码中定义或函数包含use strict指令时,函数的内容被认为是严格的代码.传递给eval()方法的代码在eval()从严格代码调用或包含use strict指令本身时被视为严格代码.

ECMAScript 5的严格模式是JavaScript语言的一个受限子集,它消除了语言的相关缺陷,并具有更严格的错误检查和更高的安全性.以下列出了严格模式和普通模式之间的区别(前三个特别重要):

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

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

• 此外,当使用call()或apply以严格模式调用函数时,则this恰好是call()或apply()调用的第一个参数的值.(在正常模式下null,undefined由全局替换,Object而非对象的值将被转换为对象.)

• 在严格模式下TypeError,当您尝试分配给只读属性或为不可扩展对象定义新属性时,您将得到一个.(在正常模式下,两者都会失败而没有错误消息.)

• 在严格模式下,将代码传递给时eval(),您无法在调用者的范围内声明或定义变量或函数(正如您可以在正常模式下执行).而是创建一个新的范围eval(),变量和函数在该范围内.eval()完成执行后,该范围将被销毁.
• 在严格模式下,函数的arguments-object包含值的静态副本,这些副本将传递给该函数.在正常模式下,arguments-object有一些"神奇"的行为:数组的元素和命名的函数参数都引用相同的值.
• 在严格模式下,你会得到一个SyntaxError当delete操作者随后的非限定的标识符(变量,函数或函数参数).在正常模式下,delete表达式将不执行任何操作并进行求值false.
• 在严格模式下,TypeError当您尝试删除不可配置的属性时,您将获得一个.(在正常模式下,尝试只是失败并且delete表达式被评估为false).
• 在严格模式下,当您尝试为对象文字定义具有相同名称的多个属性时,会将其视为语法错误.(在正常模式下没有错误.)
• 在严格模式下,当函数声明具有多个具有相同名称的参数时,它被认为是语法错误.(在正常模式下没有错误.)
• 在严格模式下,不允许八进制文字(这些是以文字开头的文字0x.(在正常模式下,某些实现允许八进制文字.)
• 在严格模式标识符eval和arguments被当作关键字.您不能更改它们的值,不能为它们赋值,也不能将它们用作变量,函数,函数参数或catch块标识符的名称.
• 在严格模式下,对检查调用堆栈的可能性有更多限制.arguments.caller并在严格模式下arguments.callee导致TypeError函数.此外,严格模式下函数的某些调用者和参数属性会TypeError在您尝试读取它们时产生.

Answer 9

我的两分钱:

严格模式的目标之一是允许更快地调试问题.它可以帮助开发人员在发生某些可能导致网页无声和奇怪行为的错误事件时抛出异常.在我们使用的那一刻use 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.当我们实现use strict代码时会抛出错误.

未捕获的ReferenceError:未定义nameoftree

Sample

消除with声明:

with使用像uglify-js这样的工具不能缩小语句.它们也被弃用,并从未来的JavaScript版本中删除.

Sample

防止重复:

当我们有重复属性时,它会抛出异常

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

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

还有更多,但我需要获得更多的知识.

Answer 10

如果您使用过去一年左右发布的浏览器,那么它很可能支持JavaScript Strict模式.只有在ECMAScript 5成为当前标准之前的旧浏览器才支持它.

命令周围的引号确保代码仍然可以在旧版浏览器中工作(尽管在严格模式下生成语法错误的事情通常只会导致脚本在这些旧版浏览器中以某种难以检测的方式出现故障).

Answer 11

添加时"use strict";,以下情况将在脚本执行之前抛出SyntaxError:

• 从而为未来的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中不再是这种情况(错误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() { } 
  

资料来源:

• 在MDN上转换为严格模式

• MDN上的严格模式

• JavaScript的严格模式以及为什么要在Colin J. Ihrig的博客上使用它(存档版本)

Answer 12

严格模式对常规JavaScript语义进行了一些更改:

• 通过更改它们以抛出错误来消除一些JavaScript无声错误.

• 修复了使JavaScript引擎难以执行优化的错误.

• 禁止在ECMAScript的未来版本中定义某些语法.

了解更多信息vistit Strict Mode- Javascript

Answer 13

"使用严格"; 是程序员不会使用JavaScript的松散或不良属性的保险.这是一个指南,就像一个统治者将帮助你做直线."使用严格"将帮助您进行"直接编码".

那些不想使用统治者直接进行直线操作的人通常会在那些要求其他人调试代码的页面中结束.

相信我.与设计不良的代码相比,开销可以忽略不计.多年来一直担任高级JavaScript开发人员的Doug Crockford在这里发表了一篇非常有趣的帖子.就个人而言,我喜欢一直回到他的网站,以确保我不忘记我的良好做法.

现代JavaScript实践应该总是唤起"使用严格"; 附注.ECMA集团选择"严格"模式的唯一原因是允许经验较少的编码人员访问JavaScript,然后有时间适应新的更安全的编码实践.

Answer 14

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

Answer 15

引自w3schools:

"使用严格"指令

"use strict"指令是JavaScript 1.8.5(ECMAScript版本5)中的新指令.

它不是一个语句,而是一个文字表达式,被早期版本的JavaScript忽略.

"use strict"的目的是表明代码应该以"严格模式"执行.

例如,使用严格模式,您不能使用未声明的变量.

为何选择严格的模式？

严格模式可以更轻松地编写"安全"JavaScript.

严格模式将以前接受的"错误语法"更改为实际错误.

例如,在普通的JavaScript中,错误输入变量名称会创建一个新的全局变量.在严格模式下,这将引发错误,从而无法意外创建全局变量.

在普通的JavaScript中,开发人员不会收到任何错误反馈,将值分配给不可写属性.

在严格模式下,对非可写属性,仅getter属性,不存在的属性,不存在的变量或不存在的对象的任何赋值都将引发错误.

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

Answer 16

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

在严格模式下,事情运行得更快,一些警告或无声警告会导致致命错误,最好总是使用它来制作更整洁的代码.

"use strict"在ECMA6中广泛需要使用它,在ECMA6中它默认是JavaScript的一部分,所以如果你使用ES6则不需要添加它.

查看MDN的这些陈述和示例:

"use strict"指令
"use strict"指令是JavaScript 1.8.5(ECMAScript第5版)中的新指令.它不是一个语句,而是一个文字表达式,被早期版本的JavaScript忽略."use strict"的目的是表明代码应该以"严格模式"执行.例如,使用严格模式,您不能使用未声明的变量.

使用"use strict"的示例:
函数的严格模式:同样,要为函数调用严格模式,请将确切的语句设置为"use strict"; (或'use strict';)在任何其他语句之前在函数体中.

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

您可以在MDN上阅读更多内容.

Answer 17

一些参与ECMAScript委员会的人有一个很好的谈话:JavaScript的变化,第1部分:ECMAScript 5"关于"use strict"交换机的增量使用如何允许JavaScript实施者清理JavaScript的许多危险特性而不会突然破坏每个网站在世界上.

当然,它还讨论了很多这些错误信息是什么以及ECMAScript 5如何修复它们.

Answer 18

要比较的小例子:

非严格模式:

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

Answer 19

请注意,这use strict是在EcmaScript 5中引入的,从那时起就保存了下来.

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

• 全局代码是严格模式代码,如果它以包含使用严格指令的指令序言开头(见14.1.1).
• 模块代码始终是严格的模式代码.
• ClassDeclaration或ClassExpression的所有部分都是严格模式代码.
• 如果Eval代码以包含Use Strict Directive的Directive Prologue开头,或者对eval的调用是严格模式代码中包含的直接eval(见12.3.4.1),则Eval代码是严格模式代码.
• 如果关联的FunctionDeclaration,FunctionExpression,GeneratorDeclaration,GeneratorExpression,MethodDefinition或ArrowFunction包含在严格模式代码中,或者如果产生函数[[ECMAScriptCode]]内部槽的值的代码以指令序言开头,则函数代码是严格模式代码包含使用严格指令.
• 作为内置函数和生成器构造函数的参数提供的函数代码是严格模式代码,如果最后一个参数是一个String,处理时是一个以包含Use Strict指令的Directive Prologue开头的FunctionBody.

Answer 20

开发人员应该使用的主要原因"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. 注意:该"use strict"指令仅在脚本或函数的开头被识别.

3. 该字符串"arguments"不能用作变量:

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

4. 将限制使用关键字作为变量.试图使用它们会引发错误.

简而言之,这将使您的代码不易出错,反过来会让您编写好的代码.

要了解更多信息,请参阅此处.

Answer 21

"严格使用"; 是ECMA努力使JavaScript更加强大.它引入了JS,试图使其至少有一点"严格"(其他语言自90年代起实施严格的规则).它实际上"迫使"JavaScript开发人员遵循某种编码最佳实践.JavaScript仍然非常脆弱.没有类型化变量,类型化方法等.我强烈建议JavaScript开发人员学习更强大的语言,如Java或ActionScript3,并在JavaScript代码中实现相同的最佳实践,它将更好地工作并且更容易调试.

Answer 22

ECMAScript 5中引入了JavaScript"严格"模式.

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

"use strict";在JS文件的最顶层写入会打开严格的语法检查.它为我们完成以下任务:

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

2. 阻止你覆盖关键的JS系统库

3. 禁止一些不安全或容易出错的语言功能

use strict也适用于个别功能.包含use strict在代码中总是更好的做法.

浏览器兼容性问题:"use"指令旨在向后兼容.不支持它们的浏览器只会看到一个未被进一步引用的字符串文字.所以,他们会过去并继续前进.

Answer 23

use strict 是一种让你的代码更安全的方法,因为你不能使用危险的功能,这些功能可能不会像你期望的那样工作.并且在它使代码更加严格之前就被写了.

Answer 24

使用Strict用于显示常见错误和重复错误,以便以不同方式处理,并更改java脚本运行的方式,此类更改包括:

• 防止偶然的全局变量

• 没有重复

• 消除

• 消除这种强制

• 更安全的评估()

• 不可变的错误

您还可以阅读这篇文章了解详情

Answer 25

通常,JavaScript不遵循严格的规则,因此增加了错误的可能性.使用之后"use strict",JavaScript代码应遵循严格的规则集,如在其他编程语言中使用,例如终止符的使用,初始化之前的声明等.

如果"use strict"使用,则应遵循严格的规则集编写代码,从而减少错误和模糊的可能性.

Answer 26

“使用严格”；定义JavaScript代码应在“严格模式”下执行。

• “严格使用”指令是ECMAScript版本5中的新增功能。
• 它不是语句，而是文字表达式，被早期JavaScript版本忽略。
• “使用严格”的目的是指示应在“严格模式”下执行代码。
• 在严格模式下，例如，您不能使用未声明的变量。

除Internet Explorer 9及更低版本外，所有现代浏览器均支持“严格使用” 。

坏处

如果开发人员使用的是严格模式下的库，但开发人员习惯于在正常模式下工作，则他们可能会对该库调用某些无法按预期方式执行的操作。

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

另外，如上所述，严格模式会阻止您执行某些操作。

人们通常认为您不应该一开始就使用这些东西，但是一些开发人员不喜欢这种约束，而是想要使用该语言的所有功能。

• 有关基本示例和参考，请通过：

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

Answer 27

由于浏览器之争和管理不善，JavaScript 的设计和实现仓促。结果，许多糟糕的设计决策、不直观的语法和令人困惑的语义都出现在该语言中。严格模式旨在修正其中一些错误。

但是在不创建替代解释的情况下修复这些错误会破坏向后兼容性。因此，"use strict"指令在将代码传达给程序员时创建了代码的替代解释。

例如，this关键字指的是方法定义中的对象，就像this或self在其他语言中一样。

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

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

this在方法上下文之外没有任何用途，但所有 JavaScript 函数都有this关键字，无论它们是否是方法：

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

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

这里this解析为全局对象，这没有意义并且没有任何作用，因为全局对象已经在作用域中可用。

在严格模式下this，全局函数解析为未定义，这是我们所期望的。

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

run(); // Window

即使在严格模式下，某些错误也无法修复，因为语法对于旧版浏览器应该有效，因为它们忽略"strict mode"指令。这是设计使然。

Answer 28

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

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

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

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

Answer 29

严格模式消除了在非严格模式下会被忽略的错误，从而使 javascript \xe2\x80\x9c 更加安全\xe2\x80\x9d。

\n

\n

它被认为是最佳实践吗？

\n

\n

是的，它被认为是使用 javascript 时包含严格模式的最佳实践的一部分。这是通过在 JS 文件中添加以下代码行来完成的。

\n

\'use strict\';

\n

在你的代码中。

\n

\n

这对用户代理意味着什么？

\n

\n

指示应以严格模式解释代码向浏览器等用户代理指定，它们应按字面意思对待代码，如果代码没有意义，则抛出错误。

\n

例如：假设您的.js文件中有以下代码：

\n

场景 1：[无严格模式]

\n

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

\n

场景 2：[无严格模式]

\n

city = "Chicago"\nconsole.log(city) // Prints the city name, i.e. Chicago\n

\n

\n

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

\n

\n

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

\n

场景3：【严格模式】

\n

\'use strict\';\n\ncity = "Chicago"\nconsole.log(city) // Reference Error: asignment is undeclared variable city.\n

\n

附加提示：要使用严格模式维护代码质量，您不需要一遍又一遍地编写此内容，特别是如果您有多个.js文件。您可以在规则中全局强制执行此规则，eslint如下所示：

\n

文件名： .eslintrc.js

\n

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

\n

\n

好的，那么严格模式下会阻止什么？

\n

\n

\n

• 在严格模式下使用变量而不声明它会引发错误。这是为了防止在整个应用程序中无意中创建全局变量。芝加哥印刷的例子特别涵盖了这一点。

  \n
\n

• 在严格模式下，删除变量、函数或参数是禁忌。

  \n

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

  \n
\n

• 严格模式下不允许重复参数名称。

  \n

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

  \n
\n

• 严格模式下不允许使用 Javascript 语言中的保留字。这些词是实现接口、let、包、私有、受保护、公共。静态和产量

  \n
\n

\n

如需更全面的列表，请查看此处的 MDN 文档：https ://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode

\n