JavaScript中使用“严格使用”是什么，背后的原因是什么？

最近，我通过Crockford的JSLint运行了一些JavaScript代码，并给出了以下错误：

第1行的问题1：缺less“严格使用”声明。

做一些search，我意识到有些人加上"use strict"; 到他们的JavaScript代码。一旦我添加了语句，错误就不再出现。不幸的是，谷歌并没有透露这个string声明背后的大部分历史。当然，它必须与浏览器如何解释JavaScript有关，但我不知道会产生什么效果。

那么什么是"use strict"; 所有关于它的含义是什么，它还是相关的？

目前的浏览器是否对"use strict";做出回应"use strict"; string还是为了将来使用？

这篇关于Javascript Strict Mode的文章可能会让你感兴趣： John Resig – ECMAScript 5严格模式，JSON等等

引用一些有趣的部分：

严格模式是ECMAScript 5中的一项新function，允许您在“严格”操作环境中放置程序或函数。这种严格的上下文阻止了某些动作被采取并抛出了更多的exception。

和：

严格的模式可以帮助你：

它捕获了一些常见的编码bloopers，抛出exception。

当相对“不安全”的行为被采取时（例如获得对全局对象的访问），它防止或抛出错误。

它禁用混淆或糟糕的function。

另外请注意，您可以将“严格模式”应用于整个文件…或者您可以将其仅用于特定function（仍引用John Resig的文章）：

 // Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code...

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

所以，我想这有点像在Perl中可以使用的"use strict" （因此名字？） ：它通过检测更多可能导致破坏的事情来帮助您减less错误。

目前，它受到所有主stream浏览器 （IE 9及以下版本）的支持 。

这是ECMAScript 5的一个新function。John Resig写了一个很好的总结。

这只是一个string，你放在你的JavaScript文件（无论是在你的文件的顶部或函数内），看起来像这样：

 "use strict";

现在把它放在你的代码中不应该对当前的浏览器造成任何问题，因为它只是一个string。如果您的代码违反杂注，可能会在将来导致您的代码出现问题。例如，如果你现在有foo = "bar"而没有先定义foo ，你的代码就会开始失败……这在我看来是一件好事。

声明"use strict"; 指示浏览器使用严格模式，这是JavaScript的一个简化和更安全的function集。

function列表（非详尽）

不允许全局variables。（捕获variables名称中缺lessvar声明和拼写错误）
静默失败的分配将在严格模式下抛出错误（分配NaN = 5; ）
尝试删除不可删除的属性将抛出（ delete Object.prototype ）
要求对象文字中的所有属性名称都是唯一的（ var x = {x1: "1", x1: "2"} ）
函数参数名称必须是唯一的（ function sum (x, x) {...} ）
禁止八进制语法（ var x = 023;一些开发人员错误地认为前一个零不会改变数字）。
禁止with关键字
严格模式下的eval不会引入新的variables
禁止删除普通名称（ delete x; ）
禁止以任何forms绑定或分配名称eval和arguments
严格模式不会将arguments对象的属性与forms参数进行别名混淆。（即在function sum (a,b) { return arguments[0] + b;}这是因为arguments[0]被绑定到a等等。
arguments.callee不受支持

[参考：严格模式， Mozilla开发者networking ]

如果人们担心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. */

谨慎的一句话，你所有的程序员都很难收费：在现有代码中"use strict"可能是危险的！这个东西不是一些感觉良好的，快乐的贴纸，你可以在代码上拍一下，让它“更好”。随着"use strict"杂注，浏览器会突然间THROWexception的地方，它从来没有扔过，因为在那个地方你正在做的事情，默认/松散的JavaScript高兴地允许，但严格的JavaScript憎恶！您的代码中可能存在严重违规行为，这些行为隐藏在您的代码中很less使用的调用中，只有在您的付费客户使用的生产环境中运行时才会抛出exception！

如果你打算冒险尝试一下，把"use strict"和全面的unit testing以及一个严格configuration的JSHint构build任务结合起来是一个不错的主意，这个任务可以让你确信你的模块没有黑暗的angular落会炸掉可怕只是因为你已经打开严格模式。或者，嘿，这里有另外一个select：只要不在你的遗留代码中加上"use strict" ，老实说，这样做可能更安全。 绝对不要将"use strict"添加到您不拥有或维护的任何模块，如第三方模块。

我认为即使它是一种致命的笼养动物， "use strict"也可能是好东西，但是你必须正确使用。最好的时间去严格的是，当你的项目是绿地，你从头开始。 configurationJSHint/JSLint ，所有的警告和选项JSHint/JSLint ，像Grunt+Karma+Chai一样，得到一个良好的构build/testing/断言系统，然后才开始把所有的新模块标记为"use strict" 。准备好解决大量的错误和警告。如果JSHint/JSLint产生任何违规，请确保每个人都了解引力，方法是将构buildconfiguration为FAIL。

当我采用"use strict"时候，我的项目不是绿地工程。因此，我的IDE充满了红色标记，因为我的模块没有"use strict" ，JSHint抱怨这一点。这让我想起了未来应该做什么重构。我的目标是由于我所有的"use strict"陈述缺失而成为红色标记，但是现在已经有几年了。

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

显然，在最初阶段会出现我们以前从未遇到过的错误。为了获得充分的利益，我们需要在切换到严格模式之后做适当的testing，以确保我们抓住了一切。当然，我们不只是在代码中use strict的代码，并假设没有错误。因此，现在是时候开始使用这个令人难以置信的有用的语言function来编写更好的代码。

例如，

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

JSLint是由Douglas Crockford编写的一个debugging器。只需粘贴您的脚本，它就会快速扫描代码中的任何明显的问题和错误。

使用`'use strict';` 不会突然让你的代码更好。

JavaScript严格模式是ECMAScript 5中的一项function。您可以通过在脚本/函数的顶部声明它来启用严格模式。

 'use strict';

当JavaScript引擎看到这个指令时 ，它将开始以特殊模式解释代码。在这种模式下，当某些编码实践可能最终成为潜在的错误时（这是严格模式背后的原因），就会出现错误。

考虑这个例子：

 var a = 365; var b = 030;

为了排列数字文字，开发人员无意中用八进制文字初始化variablesb 。非严格模式会将其解释为值为24的数字文字（以10为底）。但是，严格模式会抛出一个错误。

有关严格模式下的非专业列表，请参阅此答案。

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

在我的新的 JavaScript应用程序中： 绝对！ 严格的模式可以用来作为举报人，当你正在做你的代码愚蠢的东西。
在我现有的 JavaScript代码中： 可能不是！ 如果您现有的JavaScript代码有严格模式禁止的语句，则应用程序将会中断。如果你想要严格的模式，你应该准备好debugging和纠正你现有的代码。这就是为什么使用'use strict'; 不会突然让你的代码更好 。

我如何使用严格模式？

插入'use strict'; 在你的脚本之上的声明：
```
 // File: myscript.js 'use strict'; var a = 2; .... 
```
请注意，文件myscript.js中的所有内容都将以严格模式进行解释。
或者，插入一个'use strict'; 声明在你的函数体之上：
```
 function doSomething() { 'use strict'; ... } 
```
函数doSomething的词汇范围中的所有内容都将以严格的模式进行解释。 词汇范围这个词在这里很重要。看到这个答案更好的解释。

严格模式禁止什么东西？

我发现了一篇很好的文章，描述了在严格模式下禁止的几件事情（请注意，这不是一个独占列表）：

范围

从历史上看，JavaScript一直困惑于函数的作用范围。有时它们似乎是静态范围的，但有些function使它们像dynamic范围一样工作。这是令人困惑的，使程序难以阅读和理解。误会导致错误。这也是一个性能问题。静态范围允许variables绑定在编译时发生，但dynamic范围的要求意味着绑定必须被延迟到运行时，这会带来显着的性能损失。

严格模式要求所有的variables绑定都是静态的。这意味着之前需要dynamic绑定的function必须被删除或修改。具体来说就是消除了with语句，并且eval函数篡改调用者环境的能力受到严格的限制。

严格代码的好处之一就是像YUI压缩器这样的工具在处理时可以做得更好。

隐含的全局variables

JavaScript暗含了全局variables。如果你没有显式地声明一个variables，则为你隐式声明一个全局variables。这使初学者的编程更容易，因为他们可以忽略一些基本的家务劳动。但是，这使得大型项目的pipe理变得更加困难，并大大降低了可靠性。所以在严格模式下，隐含的全局variables不再被创build。你应该明确地声明所有的variables。

全球泄漏

有很多情况可能会导致this情况被绑定到全局对象上。例如，如果在调用构造函数时忘记提供new前缀，构造函数的this将被意外地绑定到全局对象，所以不是初始化一个新的对象，而是默默地篡改全局variables。在这种情况下，严格模式会把它绑定到undefined ，这会导致构造函数抛出一个exception，让错误更早被检测出来。

嘈杂的失败

JavaScript一直具有只读属性，但是直到ES5的Object.createProperty函数公开了该能力之后，才能创build它们。如果您试图将值分配给只读属性，则会失败。这个任务不会改变这个属性的值，但是你的程序会像进程一样继续。这是一种完整性危害，可能导致程序进入不一致的状态。在严格模式下，尝试更改只读属性将引发exception。

八进制

在字大小为3的倍数的机器上进行机器级编程时，八进制（或基数为8）的数字表示非常有用。使用字长为60位的CDC 6600主机时，需要八进制数。如果你可以读八进制，你可以看一个单词20位数字。两个数字表示操作码，一个数字表示8个寄存器之一。在从机器代码到高级语言的慢速转换过程中，认为在编程语言中提供八进制forms是有用的。

在C中，select了一个非常不幸的八进制表示法：前导零。所以在C语言中， 0100 64而不是0100错误，而不是8.更糟糕的是，这种时代错误已经被复制到几乎所有的现代语言中，包括JavaScript，它只被用来创build错误。它没有其他目的。所以在严格模式下，不再允许使用八进制格式。

等等

在ES5中，参数伪数组变得更像数组。在严格的模式下，它失去了callee和caller属性。这使得将您的arguments传递给不受信任的代码成为可能，而不会放弃很多保密上下文。而且，函数的arguments属性被消除了。

在严格模式下，函数文字中的重复键会产生语法错误。一个函数不能有两个同名的参数。一个函数不能有一个与其参数名称相同的variables。一个函数不能delete自己的variables。试图delete一个不可configuration的属性现在抛出一个exception。原始值不是隐式包装的。

未来JavaScript版本的保留字

ECMAScript 5添加了一个保留字列表。如果你使用它们作为variables或参数，严格模式会抛出一个错误。保留字是：

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

进一步阅读

严格模式 – JavaScript | MDN
浏览器支持严格模式
转换到严格模式

我想提供一个更有根据的答案补充其他答案。我希望编辑最stream行的答案，但失败了。我试图尽可能全面和完整地做到这一点。

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

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

指令与陈述类似，但不同。

use strict不包含关键字：该指令是一个简单的expression式语句，它由一个特殊的string文字（单引号或双引号）组成。没有实现ECMAScript 5的JavaScript引擎只能看到没有副作用的expression式语句。预计未来版本的ECMAScript标准将把use作为一个真正的关键词; 报价将因此变得过时。
use strict只能在脚本或函数的开始处使用，即它必须在每隔一个（真实）语句之前。它不一定是函数脚本中的第一条指令：它可以由包含string文本的其他语句expression式（以及JavaScript实现可以将它们视为特定于实现的指令）来引导。遵循第一个真实语句（在脚本或函数中）的string文字语句是简单的expression式语句。口译员不能将其解释为指令，并且不起作用。

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

ECMAScript 5的严格模式是JavaScript语言的一个有限子集，消除了语言的相关缺陷，并具有更严格的错误检查和更高的安全性。下面列出了严格模式和正常模式（其中前三个特别重要）之间的区别：

严格模式下不能使用with -statement。
在严格模式下，所有的variables必须被声明：如果你给一个没有声明为variables，函数，函数参数，catch-clause参数或全局Object属性的标识符赋值，那么你将得到一个ReferenceError 。在正常模式下，标识符被隐式地声明为全局variables（作为全局Object的属性）
在严格模式下，关键字的值在被调用为函数的函数（而不是方法）中是undefined 。（在正常模式下， this总是指向全局Object ）。这个差别可以用来testing一个实现是否支持严格模式：

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

另外当一个函数被调用call()或在严格模式下apply时， this正是call()或apply()调用的第一个参数的值。（在正常模式下， null和undefined被全局Object取代，而不是对象的值被转换成对象。）
在严格模式下，当您尝试分配给只读属性或为不可扩展对象定义新属性时，将会得到一个TypeError 。（在正常模式下，两者都会失败，没有错误信息。）
在严格模式下，将代码传递给eval() ，不能在调用者的范围内声明或定义variables或函数（正常模式下可以这样做）。而是为eval()创build一个新的作用域，并且variables和函数在该作用域内。 eval()完成执行后，该范围被销毁。
在严格模式下，函数的arguments-object包含一个值的静态副本，并传递给该函数。在正常模式下，arguments-object有一些“神奇”的行为：数组的元素和指定的函数参数引用两个相同的值。
在严格模式下，当delete操作符跟随一个非限定标识符（一个variables，函数或函数参数）时，将会得到一个SyntaxError 。在正常模式下， deleteexpression式将不会执行任何操作，并被评估为false 。
在严格模式下，当你尝试删除一个不可configuration的属性时，你会得到一个TypeError 。（在正常模式下，尝试简单失败， deleteexpression式计算为false ）。
在严格模式下，当您尝试为对象文本定义具有相同名称的多个属性时，将其视为语法错误。（在正常模式下没有错误。）
在严格模式下，当函数声明具有多个具有相同名称的参数时，将其视为语法错误。（在正常模式下没有错误。）
在严格模式下，不允许使用八进制文字（这些是以0x文字）（在正常模式下，一些实现允许使用八进制文字）。
在严格模式下，标识符eval和arguments被视为关键字。你不能改变它们的值，不能给它们赋值，也不能用它们作为variables，函数，函数参数或者catch块标识符的名字。
在严格模式下，对检查调用堆栈的可能性有更多的限制。 arguments.caller和arguments.callee在严格模式下在函数中导致TypeError 。此外，在严格模式下函数的某些调用方和参数属性在您尝试读取时会导致TypeError 。

我的两分钱：

严格模式的目标之一是允许更快的debugging问题。当发生某些错误的事情时，它会通过抛出exception来帮助开发人员，从而导致您的网页出现沉默和奇怪的行为。当我们使用use strict的代码，代码会抛出错误，帮助开发人员提前修复它。

我use strict一些重要的东西，

防止全局variables声明：

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

现在，这段代码在全局范围内创buildnameoftree ，可以使用window.nameoftree访问。当我们use strict执行use strict代码会抛出错误。

未捕获的ReferenceError：nameoftree未定义

样品

消除声明：

使用uglify-js等工具不能缩小语句。他们也被弃用，并从未来的JavaScript版本中删除。

样品

防止重复：

当我们有重复的属性，它会抛出一个exception

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

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

还有一些，但我需要获得更多的知识。

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

命令周围的引号确保代码在老版本的浏览器中仍能正常工作（尽pipe严格模式下产生语法错误的东西通常只会导致脚本在某些较老的浏览器中难以察觉的方式发生故障）。

严格模式对正常的JavaScript语义进行了一些更改：

通过更改错误来消除一些JavaScript静默错误。
修复了JavaScript引擎难以执行优化的错误。
禁止在未来版本的ECMAScript中定义一些可能的语法。

更多信息vistit 严格模式 – Javascript

“严格使用”; 是程序员不会使用JavaScript的宽松或不良属性的保险。这是一个指导，就像统治者会帮助你做直线。 “严格使用”将帮助您做“直接编码”。

那些不愿意使用统治者直线行的人通常会在那些要求他人debugging他们的代码的页面中结束。

相信我。与devise不佳的代码相比，开销可以忽略不计。多年来一直担任高级JavaScript开发人员的Doug Crockford在这里有一个非常有趣的post 。就我个人而言，我总是喜欢回到他的网站，以确保我不会忘记我的良好做法。

现代JavaScript实践应该始终唤起“严格使用”; 附注。 ECMA集团select“严格”模式的唯一原因是允许经验较less的编码人员访问JavaScript，然后有时间适应新的和更安全的编码实践。

从所有敏感的JavaScript文件开始，包括use strict都是一个更好的JavaScript程序员的一个小方法，避免随机variables变成全局变化，事物悄然改变。

“严格使用”指令

在JavaScript 1.8.5（ECMAScript版本5）中，“use strict”指令是新的。

这不是一个声明，而是一个字面expression式，被早期版本的JavaScript所忽略。

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

With strict mode, you can not, for example, use undeclared variables.

Why Strict Mode?

Strict mode makes it easier to write "secure" JavaScript.

Strict mode changes previously accepted "bad syntax" into real errors.

As an example, in normal JavaScript, mistyping a variable name creates a new global variable. In strict mode, this will throw an error, making it impossible to accidentally create a global variable.

In normal JavaScript, a developer will not receive any error feedback assigning values to non-writable properties.

In strict mode, any assignment to a non-writable property, a getter-only property, a non-existing property, a non-existing variable, or a non-existing object, will throw an error.

Please refer to…

http://www.w3schools.com/js/js_strict.asp

…to know more

There's a good talk by some people who were on the ECMAScript committee: Changes to JavaScript, Part 1: ECMAScript 5" about how incremental use of the "use strict" switch allows JavaScript implementers to clean up a lot of the dangerous features of JavaScript without suddenly breaking every website in the world.

Of course it also talks about just what a lot of those misfeatures are (were) and how ECMAScript 5 fixes them.

When adding "use strict"; , the following cases will throw a SyntaxError before the script is executing:

Paving the way for future ECMAScript versions , using one of the newly reserved keywords (in prevision for ECMAScript 6 ): implements , interface , let , package , private , protected , public , static , and yield .
Declaring function in blocks
```
 if(a<b){ function f(){} } 
```
Octal syntax
```
 var n = 023; 
```

this point to the global object.

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

Declaring twice the same name for a property name in an object literal
```
  {a: 1, b: 3, a: 7} 
```
This is no longer the case in ECMAScript 6 ( bug 1041128 ).
Declaring two function arguments with the same name function
```
 f(a, b, b){} 
```

Setting a value to an undeclared variable

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

Using delete on a variable name delete myVariable;

Using eval or arguments as variable or function argument name

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

资料来源：

Transitioning to strict mode on MDN
Strict mode on MDN
JavaScript's Strict Mode and Why You Should Use It on Colin J. Ihrig's blog (archived version)

"use strict" makes JavaScript code to run in a strict mode , which basically means everything need to be defined before using them, the main reason for strict mode is avoiding accidental global usages of any undefined methods.

Also in strict mode, things run faster, some warning or silents warnings, throw fatal errors, it's better always use it to make a neater code.

"use strict" is widely need to be used in ECMA5, in ECMA6 it's part of javascript by default , so don't need to be added if you using ES6.

Look at these statements and examples from MDN:

The "use strict" Directive
The "use strict" directive is new in JavaScript 1.8.5 (ECMAScript version 5). It is not a statement, but a literal expression, ignored by earlier versions of JavaScript. The purpose of "use strict" is to indicate that the code should be executed in "strict mode". With strict mode, you can not, for example, use undeclared variables.

Examples of using "use strict":
Strict mode for functions: Likewise, to invoke strict mode for a function, put the exact statement "use strict"; (or 'use strict';) in the function's body before any other statements.

1) strict mode in functions

  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) whole-script strict mode

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

3) Assignment to a non-writable global

 '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

For more info, visit this page here

Note that use strict was introduced in EcmaScript 5 and was kept since then.

Below are the conditions to trigger strict mode in ES6 and ES7 :

Global code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive (see 14.1.1).

Module code is always strict mode code.

All parts of a ClassDeclaration or a ClassExpression are strict mode code.

Eval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to eval is a direct eval (see 12.3.4.1) that is contained in strict mode code.

Function code is strict mode code if the associated FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, or ArrowFunction is contained in strict mode code or if the code that produces the value of the function's [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.

Function code that is supplied as the arguments to the built-in Function and Generator constructors is strict mode code if the last argument is a String that when processed is a FunctionBody that begins with a Directive Prologue that contains a Use Strict Directive.

use strict is a way to make your code safer, cause you can't use dangerous features which can work not as you expect.And as was writed before it makes code more strict.

“严格使用”; is the ECMA effort to make JavaScript a little bit more robust. It brings in JS an attempt to make it at least a little "strict" (other languages implement strict rules since the 90s). It actually "forces" JavaScript developers to follow some sort of coding best practices. Still, JavaScript is very fragile. There is no such thing as typed variables, typed methods, etc. I strongly recommend JavaScript developers to learn a more robust language such as Java or ActionScript3, and implement the same best practices in your JavaScript code, it will work better and be easier to debug.

Small example to compare:

Non-strict mode:

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

Strict mode:

 'use strict'; for (i of [1,2,3]) console.log(i) // output: // Uncaught ReferenceError: i is not defined

Use Strict is used to show common and repeated errors so that it is handled differently , and changes the way java script runs , such changes are :

Prevents accidental globals
No duplicates
Eliminates with
Eliminates this coercion
Safer eval()
Errors for immutables

you can also read this article for the details

Normally java script does not follow strict rules hence increasing chances of errors. After using "use strict" , the java script code should follow strict set of rules as like in other programming languages such as use of terminators, declaration before initialization etc.

If "use strict" is used then the code should be written by following a strict set of rules hence decreasing the chances of errors and ambiguities.

The main reasons why developers should use "use strict" are:

Prevents accidental declaration of global variables.Using "use strict()" will make sure that variables are declared with var before use. 例如：

 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'}; }

NB: The "use strict" directive is only recognized at the beginning of a script or a function.

The string "arguments" cannot be used as a variable:

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

Will restrict uses of keywords as variables. Trying to use them will throw errors.

In short will make your code less error prone and in turn will make you write good code.

To read more about it you can refer here .

JavaScript “strict” mode introduces in ECMAScript 5.

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

writing "use strict"; at the very top of your JS file turns on strict syntax checking. It does the following tasks for us :

(i) shows an error if you try to assign to an undeclared variable

(ii) stops you from overwriting key JS system libraries

(ii) forbids some unsafe or error-prone language features

"use strict" also works inside of individual functions. It is always a better practice to include "use strict in your code.

Browser Compatibility Issue: The "use" directives are meant to be backwards-compatible. Browsers that donot support them will just see a String literal that isn't referenced further. So, they will pass over it and move on.

Just wanted to add some more points.

The Reason to Use Strict Mode—>

Strict mode makes it easier to write "secure" JavaScript.
Strict mode changes previously accepted "bad syntax" into real
错误。
As an example, in normal JavaScript, mistyping a variable name
creates a new global variable.
In strict mode, this will throw an error, making it impossible to accidentally create a global variable.
In strict mode, any assignment to a non-writable property, a
getter-only property, a non-existing property, a non-existing
variable, or a non-existing object, will throw an error.

The things that will throw errors in Strict Mode Using a variable, without declaring it, is not allowed:

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

Objects are variables too.

Using an object, without declaring it, is not allowed:

  "use strict"; x = {p1:10, p2:20}; // This will cause an error

Deleting a variable (or object) is not allowed.

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

For security reasons, eval() is not allowed to create variables in the scope from which it was called:

 "use strict"; eval ("var x = 2"); alert (x); // This will cause an error

In function calls like f(), the this value was the global object. In strict mode, it is now undefined.

"use strict" is only recognized at the beginning of a script.

"use strict" is strict mode of javascript introduced in ECMA5. It is optional. Default mode of javascript is sloopy mode. Strict mode add some strict rules in javascript, for exp.

var declaration is compulsory after use strict.
octal declaration is not allowed, ie, we cannot declare numbers starting with 0, like 010 is not allowed, but 10 is allowed.

JavaScript中使用“严格使用”是什么，背后的原因是什么？

function列表（非详尽）

使用`'use strict';` 不会突然让你的代码更好。

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

我如何使用严格模式？

严格模式禁止什么东西？

范围

隐含的全局variables

全球泄漏

嘈杂的失败

八进制

等等

未来JavaScript版本的保留字

进一步阅读

“严格使用”指令

Why Strict Mode?

Ruby中的@@variables是什么意思？

将C ++string拆分为多行（代码语法，不parsing）

如何在elisp'if'语句中编写多个语句？

Ruby中的括号是什么意思？

我的java代码有一个明显的错误。为什么编译和运行？

我应该在花括号后面用分号吗？

为什么在variables名称后添加尾随逗号使其成为一个元组？

剃刀助手语法自动格式化丑。怎么修？

Python中的大括号和方括号有什么区别？

@前缀对C＃中的string文字做了什么？

JavaScript中使用“严格使用”是什么，背后的原因是什么？

function列表（非详尽）

使用'use strict'; 不会突然让你的代码更好。

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

我如何使用严格模式？

严格模式禁止什么东西？

范围

隐含的全局variables

全球泄漏

嘈杂的失败

八进制

等等

未来JavaScript版本的保留字

进一步阅读

“严格使用”指令

Why Strict Mode?

Ruby中的@@variables是什么意思？

将C ++string拆分为多行（代码语法，不parsing）

如何在elisp'if'语句中编写多个语句？

Ruby中的括号是什么意思？

我的java代码有一个明显的错误。 为什么编译和运行？

我应该在花括号后面用分号吗？

为什么在variables名称后添加尾随逗号使其成为一个元组？

剃刀助手语法自动格式化丑。 怎么修？

Python中的大括号和方括号有什么区别？

@前缀对C＃中的string文字做了什么？

使用`'use strict';` 不会突然让你的代码更好。

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

我的java代码有一个明显的错误。为什么编译和运行？

剃刀助手语法自动格式化丑。怎么修？