“use strict”是什么意思？ JavaScript 中做了什么，其背后的原因是什么？

Question

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

第 1 行字符 1 处出现问题：缺少“use strict”语句。

经过一些搜索，我发现有些人在 JavaScript 代码中添加了 "use strict"; 。添加该语句后，错误就不再出现。不幸的是，谷歌并没有透露这个字符串声明背后的太多历史。当然，这肯定与浏览器如何解释JavaScript有关，但我不知道会产生什么影响。

那么 "use strict"; 到底是什么，它意味着什么，它仍然相关吗？

当前的浏览器是否响应 "use strict"; 字符串或者供将来使用？

Answer 1

原生 ECMAScript 模块 内的ES6 模块更新

（使用 导入 和 export 语句）和 ES6 类，严格模式始终启用且无法禁用。

原始答案

这篇关于 Javascript 严格模式的文章可能会让您感兴趣： John Resig - ECMAScript 5 严格模式、JSON 等

引用一些有趣的部分：

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

和：

严格模式在几个方面提供帮助：

• 它捕获一些常见的编码错误，引发异常。
• 当采取相对“不安全”的操作（例如获取对全局对象的访问权限）时，它可以防止或引发错误。
• 它会禁用令人困惑或考虑不周的功能。

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

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code...

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

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

现在所有主流浏览器都支持严格模式。

Answer 2

这是 ECMAScript 5 的一项新功能。John Resig 写了 一篇不错的文章总结。

它只是您放入 JavaScript 文件中（位于文件顶部或函数内部）的字符串，如下所示：

"use strict";

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

Answer 3

语句“use strict”； 指示浏览器使用严格模式，这是 JavaScript 的简化且更安全的功能集。

功能列表（非详尽）

1. 不允许全局变量。 （捕获变量名称中缺少的 var 声明和拼写错误）

2. 静默失败的赋值将在严格模式下引发错误（赋值 NaN = 5;）

3. 尝试删除不可删除的属性将抛出错误（删除 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 argument[0] + b;} 中，这是有效的，因为 arguments[0] 绑定到 a 等）（请参阅下面的示例部分以了解差异）

    


12. 不支持arguments.callee

    >

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

---

示例：

11. 严格模式代码不会为在其中创建的参数对象的属性添加别名

function show( msg ){
    msg = 42;
    console.log( msg );          // msg === 42
    console.log( arguments[0] ); // arguments === 42
}
show( "Hey" );

// In strict mode arguments[i] does not track the value of 
// the corresponding named argument, nor does a named argument track the value in the corresponding arguments[i]
function showStrict( msg ){
    "use strict";
    msg = 42;
    console.log( msg );          // msg === 42
    console.log( arguments[0] ); // arguments === "Hey"
}
showStrict( "Hey" );

Answer 4

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

浏览器中的 ECMAScript 5“严格模式”支持。这是什么意思？
NovoGeek.com - Krishna 的博客

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

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 构建任务一起应用，这将使您有信心不存在任何黑暗角落仅仅因为您打开了严格模式，您的模块就会严重爆炸。或者，嘿，这里有另一个选择：只是不要将 "use strict" 添加到任何遗留代码中，老实说，这样可能更安全。 绝对不要将“use strict”添加到您不拥有或维护的任何模块中，例如第三方模块。

我认为即使它是致命的笼中动物，“use strict”也可以是好东西，但你必须做得对。严格执行的最佳时机是当您的项目刚刚起步并且您从头开始时。配置 JSHint/JSLint ，将所有警告和选项调到您的团队能够承受的范围内，获得一个良好的构建/测试/断言系统，例如 Grunt+Karma+Chai code>，然后才开始将所有新模块标记为“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'; 语句：

    // 文件：myscript.js
   
    '使用严格'；
    var a = 2;
    ....
   

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

2. 或者，在函数体顶部插入 'use strict'; 语句：

    函数 doSomething() {
        '使用严格'；
        ...
    }
   

   函数 doSomething 的词法范围中的所有内容都将以严格模式进行解释。词汇范围这个词在这里很重要。例如，如果您的严格代码调用非严格库的函数，则只有您的代码会在严格模式下执行，而不是被调用的函数。请参阅此答案以获得更好的解释。

---

严格模式下禁止哪些事情？

我发现了 好文章 描述了严格模式下禁止的几项内容（请注意，这不是详尽的列表）：

范围

从历史上看，JavaScript 一直对如何运行感到困惑
范围内。有时它们似乎是静态范围的，但有些
特性使它们的行为就像它们是动态范围的一样。这是
令人困惑，使程序难以阅读和理解。
误解会导致错误。这也是性能问题。
静态作用域允许在编译时进行变量绑定
时间，但动态作用域的要求意味着绑定必须是
推迟到运行时，这带来了显着的性能
处罚。

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

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

隐含的全局变量

JavaScript 具有隐含的全局变量。如果
您没有显式声明变量，全局变量是
隐式地为你声明。这使得编程更容易
初学者，因为他们可能会忽略一些基本的内务管理
家务活。但它使得大型程序的管理变得更加容易
困难并且它显着降低了可靠性。所以严格来说
模式下，不再创建隐含的全局变量。你应该
显式声明所有变量。

全球泄露

有多种情况可能会导致此情况
绑定到全局对象。例如，如果您忘记
调用构造函数时提供 new 前缀，
构造函数的 this 将意外绑定到全局对象，因此
它不会初始化一个新对象，而是默默地初始化
篡改全局变量。在这些情况下，严格模式将
相反，将 this 绑定到 undefined，这将导致构造函数
相反，抛出异常，从而可以更容易地检测到错误
早点。

噪音故障

JavaScript 一直都有只读属性，但是你
在 ES5 的 Object.createProperty 之前无法自己创建它们
函数暴露了这种能力。如果您尝试分配一个值
对于只读属性，它会默默地失败。该作业将
不改变属性的值，但你的程序将继续
尽管确实如此。这是一种完整性危险，可能会导致程序
进入不一致的状态。在严格模式下，尝试更改
只读属性将抛出异常。

八进制

数字的八进制（或以 8 为基数）表示非常
在机器上进行机器级编程时很有用
大小是 3 的倍数。与 CDC 合作时需要八进制
6600 大型机，其字长为 60 位。如果你能读懂
八进制，您可以将一个单词视为 20 位数字。两位数字代表
操作码，一位数字标识 8 个寄存器之一。期间
从机器代码到高级语言的过渡缓慢，
被认为对于在编程语言中提供八进制形式很有用。

在 C 语言中，八进制的一种极其不幸的表示是
选择：前导零。所以在 C 中，0100 表示 64，而不是 100，而 08 是一个
错误，不是 8。更不幸的是，这种不合时宜的现象已经被
复制到几乎所有现代语言，包括 JavaScript，其中
它仅用于创建错误。它没有其他目的。所以在
严格模式，不再允许八进制形式。

等等

参数伪数组变得多了一点
类似于 ES5 中的数组。在严格模式下，它会丢失被调用者和调用者
特性。这使得将您的参数传递给不受信任的人成为可能
代码而无需放弃大量机密上下文。另外，
函数的arguments属性被消除。

在严格模式下，函数文字中的重复键将产生
语法错误。函数不能有两个同名的参数。
函数不能有与其函数同名的变量
参数。函数无法删除自己的变量。尝试
删除不可配置的属性现在会引发异常。原始
值没有隐式包装。

---

未来 JavaScript 版本的保留字

ECMAScript 5 添加了保留字列表。如果将它们用作变量或参数，严格模式将引发错误。保留字是：

实现、接口、let、包、私有、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() 或包含 use strict 时，传递给 eval() 方法的代码被视为严格代码指令本身。

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

• 在严格模式下不能使用 with 语句。
• 在严格模式下，所有变量都必须声明：如果您将值分配给尚未声明为全局 Object 的变量、函数、函数参数、catch 子句参数或属性的标识符，则你会得到一个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() 执行完成后被销毁。

• 在严格模式下，函数的参数对象包含传递给该函数的值的静态副本。在正常模式下，参数对象有一个有点“神奇”的行为：数组的元素和命名函数参数引用相同的值。

• 在严格模式下，当delete 运算符后跟非限定标识符（变量、函数或函数参数）时，您将收到SyntaxError。在正常模式下，delete 表达式不会执行任何操作，并且计算结果为 false。

• 在严格模式下，当您尝试删除不可配置的属性时，您将收到TypeError。 （在正常模式下，尝试会失败，delete 表达式的计算结果为 false）。

• 在严格模式下，当您尝试为对象字面量定义多个同名属性时，会被视为语法错误。 （正常模式下没有错误。）

• 在严格模式下，当函数声明具有多个同名参数时，将被视为语法错误。 （正常模式下没有错误。）

• 在严格模式下，不允许使用八进制文字（这些是以 0 开头的文字。（在正常模式下，某些实现确实允许八进制文字。）< /p>

• 在严格模式下，标识符eval 和 arguments 被视为关键字，您不能更改它们的值，不能为它们赋值，也不能将它们用作变量、函数、函数参数或 catch 块的标识符。

  


• 在严格模式下，对检查调用堆栈的可能性有更多限制。 arguments.caller 和 arguments.callee 在严格模式下的函数中导致 TypeError。此外，当您尝试读取严格模式下函数的某些调用者属性和参数属性时，它们会导致TypeError。

Answer 9

我的两分钱：

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

使用 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时，代码会抛出错误。

未捕获的引用错误：nameoftree未定义

消除 with 语句：

with 语句无法使用 with 等工具进行缩小a href="http://marijnhaverbeke.nl/uglifyjs" rel="noreferrer">uglify-js。它们也被弃用并从未来的 JavaScript 版本中删除。

样本：

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

    for (var i = 0; i < 2; ++i) {
       // let(leafCount = i) { /*do something*/ }
    }
    for (var i = 0; i < 2; ++i) {
        with(leafCount = i) { /*do something*/ }
    }
};

var tree1 = new Tree(tree1Data);
console.log(window);

防止重复：

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

未捕获的语法错误：对象文字中的重复数据属性不存在
严格模式下允许

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

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

Answer 10

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

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

Answer 11

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

• 为未来的 ECMAScript 版本铺平道路，使用新保留的关键字之一（在 ECMAScript 6 的预置中）：implements、interface、let、包、私有、受保护、公共、静态和yield。

• 在块中声明函数

  if(a

• 八进制语法

  <前><代码>var n = 023;

• this 指向全局对象。

   函数 f() {
        “严格使用”；
        这个.a = 1;
   };
   f(); 
  

• 在对象文字中为属性名称声明两次相同的名称

  <前><代码> {a：1，b：3，a：7}

  ECMAScript 6 中不再出现这种情况（bug 1041128）。

• 声明两个具有相同名称函数的函数参数

  f(a, b, b){}
  

• 为未声明的变量设置值

  函数 f(x){
     “严格使用”；
     var a = 12;
     b = a + x*35; // 错误！
  }
  f();
  

• 对变量名称使用delete delete myVariable;

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

  “使用严格”；
  参数++；
  var obj = { set p(参数) { } };
  尝试 { } catch (参数) { }
  函数参数() { } 
  

来源：

• 在 MDN 上过渡到严格模式

• MDN 上的严格模式

• JavaScript 的严格模式以及为什么应该在 Colin 上使用它 J. Ihrig 的博客（存档版本）

Answer 12

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

• 通过更改消除一些 JavaScript 无提示错误
  抛出错误。

• 修复了使 JavaScript 变得困难的错误
  引擎执行优化。

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

有关更多信息，请访问严格模式 - Javascript

Answer 13

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

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

相信我。与设计不良的代码相比，开销可以忽略不计。 Doug Crockford，曾是一名高级多年的 JavaScript 开发人员，这里有一篇非常有趣的文章。就我个人而言，我喜欢一直返回他的网站，以确保我不会忘记我的良好实践。

现代 JavaScript 实践应该始终唤起“严格使用”； pragma。ECMA 集团将“严格”模式设为可选的唯一原因是允许经验不足的编码人员访问 JavaScript，并给他们时间来适应新的、更安全的编码实践。 >

Answer 14

从现在开始，在所有敏感 JavaScript 文件的开头包含 use strict 是成为更好的 JavaScript 程序员并避免随机变量成为全局变量和悄然发生变化的一个小方法。

Answer 15

引用自 w3schools：

“use strict”指令

“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" 在 ECMA5 中被广泛使用，在 ECMA6 中它默认是 JavaScript 的一部分，所以如果你使用的话不需要添加它ES6。

请看 MDN 中的这些陈述和示例：

“use strict”指令
“use strict”指令是新的
JavaScript 1.8.5（ECMAScript 版本 5）。这不是一个声明，而是一个
文字表达式，被早期版本的 JavaScript 忽略。这
“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 代码以包含“使用严格指令”的指令序言开头，或者对 eval 的调用是严格模式代码中包含的直接 eval（请参阅 12.3.4.1），则该代码是严格模式代码。
• 如果关联的 FunctionDeclaration、FunctionExpression、GeneratorDeclaration、GeneratorExpression、MethodDefinition 或 ArrowFunction 包含在严格模式代码中，或者如果生成函数 [[ 值的代码，则函数代码是严格模式代码。 ECMAScriptCode]] 内部槽以包含使用严格指令的指令序言开始。
• 如果最后一个参数是一个字符串，并且在处理时是一个以指令序言开头的FunctionBody，则作为内置 Function 和 Generator 构造函数的参数提供的函数代码是严格模式代码其中包含“使用严格指令”。

Answer 20

开发人员应使用“use strict”的主要原因是：

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

   函数 useStrictDemo(){
    '使用严格'；
    //工作正常
    var a = '没问题';
   
    // 无法正常工作并抛出错误
    k =“问题”
   
    //即使这样也会抛出错误
    someObject = {'问题': '很多问题'};
   }
   

2. 注意："use strict" 指令仅在脚本或函数的开头被识别。

3. 字符串“arguments”不能用作变量：

   “使用严格”；
   var 参数 = 3.14; // 这会导致错误
   

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

简而言之，将使您的代码不易出错，进而使您编写出好的代码。

要了解更多相关信息，您可以参考此处。

Answer 21

use strict 是一种让代码更安全的方法，因为您不能使用无法按预期工作的危险功能。而且，正如之前所写，它使代码更加严格。

Answer 22

“严格使用”； ECMA 致力于让 JavaScript 变得更加健壮。它引入了 JS，试图使其至少有点“严格”（其他语言自 90 年代以来就实施了严格的规则）。它实际上“迫使”JavaScript 开发人员遵循某种编码最佳实践。
尽管如此，JavaScript 仍然非常脆弱。不存在类型变量、类型方法等。
我强烈建议 JavaScript 开发人员学习更强大的语言，例如 Java 或 ActionScript3，并在 JavaScript 代码中实现相同的最佳实践，它将工作得更好并且更容易调试。

Answer 23

JavaScript“严格”模式是在 ECMAScript 5 中引入的。在

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

JS 文件的最顶部编写 "use strict"; 会开启严格模式
语法检查。它为我们执行以下任务：

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

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

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

use strict 也可以在个人职能。在代码中包含 use strict 始终是更好的做法。

浏览器兼容性问题：
“use”指令旨在向后兼容。不支持它们的浏览器只会看到未进一步引用的字符串文字。因此，他们会跳过它并继续前进。

Answer 24

Use Strict 用于显示常见和重复的错误，以便以不同的方式对其进行处理，并更改 java 脚本的运行方式，这些更改是：

• 防止意外全局变量

• 无重复

• 消除

• 消除此强制

• 更安全的 eval()

• 不可变错误

  p>

您还可以阅读此 文章了解详细信息

Answer 25

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

如果“use strict” 时，应遵循一组严格的规则来编写代码，从而减少出现错误和歧义的机会。

Answer 26

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

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

所有现代浏览器都支持“use strict”，Internet Explorer 9 及更低版本除外。

缺点

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

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

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

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

• 有关基本示例和参考，请访问：

  https://www.tutorialsteacher.com/javascript/javascript-strict< /p>

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 关键字，无论它们是否是方法：

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

run(); // Window

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

在严格模式下，全局函数中的 this 会解析为 undefined，这正是我们所期望的。

"use strict"

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

run(); // undefined

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

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 “更安全”。

它是否被视为最佳实践？

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

'使用严格';

在你的代码中。

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

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

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

场景 1：[无严格模式]

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

场景 2： [无严格模式]

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

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

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

场景 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'],
        },
    };
    

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

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

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

  “使用严格”；
   函数 x(p1, p2) {}; 
   删除x； // 这会导致错误
  

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

  “使用严格”；
   函数 x(p1, p1) {}; // 这会导致错误
  

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

请查看此处的 MDN 文档： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode

Answer 30

严格模式在 v8 引擎中启用严格功能。一些功能的简短示例：

您可以通过编写全局启用它：

'use strict'; // strict mode enabled!

每个函数，您只需在函数中包含：

let myfunc = () => {
  'use strict'; // strict mode enabled
  
   b = 0; // broke
}

• 您必须在使用它之前声明一个变量（sane imo）：

  var x;
  x = '0'; // ok
  y = '';  // not ok

• es6功能已启用（这是与浏览器相关的），对于节点 v4+ 这很重要。

• 在某些情况下，性能会更好。

还有更多功能，请查看此处了解更多的！