diff --git a/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html b/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html index 2e33df819081b7..e7b7f7dd4e2061 100644 --- a/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html +++ b/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html @@ -13,7 +13,7 @@

为什么会有这一篇“重新介绍”呢？因为 {{Glossary("JavaScript")}} 堪称世界上被人误解最深的编程语言。虽然常被嘲为“玩具语言”，但在它看似简洁的外衣下，还隐藏着强大的语言特性。 JavaScript 目前广泛应用于众多知名应用中，对于网页和移动开发者来说，深入理解 JavaScript 就尤为必要。

-

我们有必要先从这门语言的历史谈起。在1995 年 Netscape 一位名为 Brendan Eich 的工程师创造了 JavaScript，随后在 1996 年初，JavaScript 首先被应用于 Netscape 2 浏览器上。最初的 JavaScript 名为 LiveScript，但是因为一个糟糕的营销策略而被重新命名，该策略企图利用Sun Microsystem的Java语言的流行性，将它的名字从最初的 LiveScript 更改为 JavaScript——尽管两者之间并没有什么共同点。这便是之后混淆产生的根源。

+

我们有必要先从这门语言的历史谈起。在 1995 年 Netscape 一位名为 Brendan Eich 的工程师创造了 JavaScript，随后在 1996 年初，JavaScript 首先被应用于 Netscape 2 浏览器上。最初的 JavaScript 名为 LiveScript，但是因为一个糟糕的营销策略而被重新命名，该策略企图利用 Sun Microsystem 的 Java 语言的流行性，将它的名字从最初的 LiveScript 更改为 JavaScript——尽管两者之间并没有什么共同点。这便是之后混淆产生的根源。

几个月后，Microsoft 随 IE 3 发布推出了一个与之基本兼容的语言 JScript。又过了几个月，Netscape 将 JavaScript 提交至 Ecma International（一个欧洲标准化组织）， {{Glossary("ECMAScript")}} 标准第一版便在 1997 年诞生了，随后在 1999 年以 ECMAScript 第三版的形式进行了更新，从那之后这个标准没有发生过大的改动。由于委员会在语言特性的讨论上发生分歧，ECMAScript 第四版尚未推出便被废除，但随后于 2009 年 12 月发布的 ECMAScript 第五版引入了第四版草案加入的许多特性。第六版标准已经于 2015 年 6 月发布。

@@ -21,11 +21,11 @@

备注： 由于这种用法更常见，从这里开始，我们将使用 JavaScript 来指代 ECMAScript 。

-

与大多数编程语言不同，JavaScript 没有输入或输出的概念。它是一个在宿主环境（host environment）下运行的脚本语言，任何与外界沟通的机制都是由宿主环境提供的。浏览器是最常见的宿主环境，但在非常多的其他程序中也包含 JavaScript 解释器，如 Adobe Acrobat、Adobe Photoshop、SVG 图像、Yahoo! 的 Widget 引擎，Node.js 之类的服务器端环境，NoSQL 数据库（如开源的 Apache CouchDB）、嵌入式计算机，以及包括 GNOME （注：GNU/Linux 上最流行的 GUI 之一）在内的桌面环境等等。

+

与大多数编程语言不同，JavaScript 没有输入或输出的概念。它是一个在宿主环境（host environment）下运行的脚本语言，任何与外界沟通的机制都是由宿主环境提供的。浏览器是最常见的宿主环境，但在非常多的其他程序中也包含 JavaScript 解释器，如 Adobe Acrobat、Adobe Photoshop、SVG 图像、Yahoo！的 Widget 引擎，Node.js 之类的服务器端环境，NoSQL 数据库（如开源的 Apache CouchDB）、嵌入式计算机，以及包括 GNOME （注：GNU/Linux 上最流行的 GUI 之一）在内的桌面环境等等。

概览

-

JavaScript 是一种多范式的动态语言，它包含类型、运算符、标准内置（ built-in）对象和方法。它的语法来源于 Java 和 C，所以这两种语言的许多语法特性同样适用于 JavaScript。JavaScript 通过原型链而不是类来支持面向对象编程（有关 ES6 类的内容参考这里{{jsxref("Classes")}}，有关对象原型参考见此继承与原型链）。JavaScript同样支持函数式编程——因为它们也是对象，函数也可以被保存在变量中，并且像其他对象一样被传递。

+

JavaScript 是一种多范式的动态语言，它包含类型、运算符、标准内置（ built-in）对象和方法。它的语法来源于 Java 和 C，所以这两种语言的许多语法特性同样适用于 JavaScript。JavaScript 通过原型链而不是类来支持面向对象编程（有关 ES6 类的内容参考这里{{jsxref("Classes")}}，有关对象原型参考见此继承与原型链）。JavaScript 同样支持函数式编程——因为它们也是对象，函数也可以被保存在变量中，并且像其他对象一样被传递。

先从任何编程语言都不可缺少的组成部分——“类型”开始。JavaScript 程序可以修改值（value），这些值都有各自的类型。JavaScript 中的类型包括：

@@ -61,7 +61,7 @@

概览

数字

-

根据语言规范，JavaScript 采用“遵循 IEEE 754 标准的双精度 64 位格式”（"double-precision 64-bit format IEEE 754 values"）表示数字。——在JavaScript（除了{{jsxref("BigInt")}}）当中，并不存在整数/整型(Integer)。因此在处理如下的场景时候，您一定要小心：

+

根据语言规范，JavaScript 采用“遵循 IEEE 754 标准的双精度 64 位格式”（"double-precision 64-bit format IEEE 754 values"）表示数字。——在 JavaScript（除了{{jsxref("BigInt")}}）当中，并不存在整数/整型 (Integer)。因此在处理如下的场景时候，您一定要小心：

console.log(3 / 2);             // 1.5,not 1
 console.log(Math.floor(3 / 2)); // 1
@@ -74,7 +74,7 @@ 
数字

 
0.1 + 0.2 = 0.30000000000000004
 

 
-
在具体实现时，整数值通常被视为32位整型变量，在个别实现（如某些浏览器）中也以32位整型变量的形式进行存储，直到它被用于执行某些32位整型不支持的操作，这是为了便于进行位操作。

+
在具体实现时，整数值通常被视为 32 位整型变量，在个别实现（如某些浏览器）中也以 32 位整型变量的形式进行存储，直到它被用于执行某些 32 位整型不支持的操作，这是为了便于进行位操作。

 
 
JavaScript 支持标准的算术运算符，包括加法、减法、取模（或取余）等等。还有一个之前没有提及的内置对象 {{jsxref("Math")}}（数学对象），用以处理更多的高级数学函数和常数：

 
@@ -93,7 +93,7 @@ 
数字

 
parseInt("010");  //  8
 parseInt("0x10"); // 16

 
-
这是因为字符串以数字 0 开头，{{jsxref("Global_Objects/parseInt", "parseInt()")}}函数会把这样的字符串视作八进制数字；同理，0x开头的字符串则视为十六进制数字。

+
这是因为字符串以数字 0 开头，{{jsxref("Global_Objects/parseInt", "parseInt()")}}函数会把这样的字符串视作八进制数字；同理，0x 开头的字符串则视为十六进制数字。

 
 
如果想把一个二进制数字字符串转换成整数值，只要把第二个参数设置为 2 就可以了：

 
@@ -113,7 +113,7 @@ 
数字

 
parseInt("hello", 10); // NaN
 

 
-
要小心NaN：如果把 NaN 作为参数进行任何数学运算，结果也会是 NaN：

+
要小心 NaN：如果把 NaN 作为参数进行任何数学运算，结果也会是 NaN：

 
 
NaN + 5; //NaN
 

@@ -129,7 +129,7 @@ 
数字

 -1 / 0; // -Infinity
-

可以使用内置函数 isFinite() 来判断一个变量是否是一个有穷数， 如果类型为Infinity, -Infinity 或 NaN则返回false：

+

可以使用内置函数 isFinite() 来判断一个变量是否是一个有穷数， 如果类型为Infinity, -Infinity 或 NaN 则返回 false：

isFinite(1/0); // false
 isFinite(Infinity); // false
@@ -149,7 +149,7 @@ 
数字

 
 
字符串

 
-
JavaScript 中的字符串是一串Unicode 字符序列。这对于那些需要和多语种网页打交道的开发者来说是个好消息。更准确地说，它们是一串UTF-16编码单元的序列，每一个编码单元由一个 16 位二进制数表示。每一个Unicode字符由一个或两个编码单元来表示。

+
JavaScript 中的字符串是一串Unicode 字符序列。这对于那些需要和多语种网页打交道的开发者来说是个好消息。更准确地说，它们是一串 UTF-16 编码单元的序列，每一个编码单元由一个 16 位二进制数表示。每一个 Unicode 字符由一个或两个编码单元来表示。

 
 
如果想表示一个单独的字符，只需使用长度为 1 的字符串。

 
@@ -218,7 +218,7 @@ 
变量

 
 
一个使用  var 声明变量的语句块的例子：

 
-
// myVarVariable在这里 *能* 被引用
+
// myVarVariable 在这里 *能* 被引用
 
 for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
   // myVarVariable 整个函数中都能被引用
@@ -232,7 +232,7 @@ 
变量

 
 
运算符

 
-
JavaScript的算术操作符包括 +、-、*、/ 和 % ——求余（与模运算相同）。赋值使用 = 运算符，此外还有一些复合运算符，如 += 和 -=，它们等价于 x = x operator y。

+
JavaScript 的算术操作符包括 +、-、*、/ 和 % ——求余（与模运算相同）。赋值使用 = 运算符，此外还有一些复合运算符，如 += 和 -=，它们等价于 x = x operator y。

 
 
x += 5; // 等价于 x = x + 5;
 

@@ -368,7 +368,7 @@ 
控制结构

 
 
对象

 
-
JavaScript 中的对象，Object，可以简单理解成“名称-值”对（而不是键值对：现在，ES 2015 的映射表（Map），比对象更接近键值对），不难联想 JavaScript 中的对象与下面这些概念类似：

+
JavaScript 中的对象，Object，可以简单理解成“名称 - 值”对（而不是键值对：现在，ES 2015 的映射表（Map），比对象更接近键值对），不难联想 JavaScript 中的对象与下面这些概念类似：

 
 
    
  
  • Python 中的字典（Dictionary）
    • 
@@ -422,19 +422,19 @@ 
    对象
    
 // 定义一个对象
 var You = new Person('You', 24);
 // 我们创建了一个新的 Person，名称是 "You"
-// ("You" 是第一个参数, 24 是第二个参数..)
+// ("You" 是第一个参数，24 是第二个参数..)
 

 
 
完成创建后，对象属性可以通过如下两种方式进行赋值和访问：

 
-
// 点表示法(dot notation)
+
// 点表示法 (dot notation)
 obj.name = 'Simon';
 var name = obj.name;
 

 
 
和：

 
-
// 括号表示法(bracket notation)
+
// 括号表示法 (bracket notation)
 obj['name'] = 'Simon';
 var name = obj['name'];
 // can use a variable to define a key
@@ -637,7 +637,7 @@ 
函数

 }
 avg(2, 3, 4, 5); // 3.5

 
-
这个就有用多了，但是却有些冗长。为了使代码变短一些，我们可以使用剩余参数来替换arguments的使用。在这方法中，我们可以传递任意数量的参数到函数中同时尽量减少我们的代码。这个剩余参数操作符在函数中以：...variable 的形式被使用，它将包含在调用函数时使用的未捕获整个参数列表到这个变量中。我们同样也可以将 for 循环替换为 for...of  循环来返回我们变量的值。

+
这个就有用多了，但是却有些冗长。为了使代码变短一些，我们可以使用剩余参数来替换 arguments 的使用。在这方法中，我们可以传递任意数量的参数到函数中同时尽量减少我们的代码。这个剩余参数操作符在函数中以：...variable 的形式被使用，它将包含在调用函数时使用的未捕获整个参数列表到这个变量中。我们同样也可以将 for 循环替换为 for...of  循环来返回我们变量的值。

 
 
function avg(...args) {
   var sum = 0;
@@ -741,7 +741,7 @@ 
自定义对象

 
备注：关于 JavaScript 中面向对象编程更详细的信息，请参考 JavaScript 面向对象简介。

 
 
-
在经典的面向对象语言中，对象是指数据和在这些数据上进行的操作的集合。与 C++ 和 Java 不同，JavaScript 是一种基于原型的编程语言，并没有 class 语句，而是把函数用作类。那么让我们来定义一个人名对象，这个对象包括人的姓和名两个域（field）。名字的表示有两种方法：“名 姓（First Last）”或“姓, 名（Last, First）”。使用我们前面讨论过的函数和对象概念，可以像这样完成定义：

+
在经典的面向对象语言中，对象是指数据和在这些数据上进行的操作的集合。与 C++ 和 Java 不同，JavaScript 是一种基于原型的编程语言，并没有 class 语句，而是把函数用作类。那么让我们来定义一个人名对象，这个对象包括人的姓和名两个域（field）。名字的表示有两种方法：“名 姓（First Last）”或“姓，名（Last, First）”。使用我们前面讨论过的函数和对象概念，可以像这样完成定义：

 
 
function makePerson(first, last) {
     return {
@@ -836,9 +836,9 @@ 
自定义对象

 }
 

 
-
Person.prototype 是一个可以被Person的所有实例共享的对象。它是一个名叫原型链（prototype chain）的查询链的一部分：当你试图访问 Person 某个实例（例如上个例子中的s）一个没有定义的属性时，解释器会首先检查这个 Person.prototype 来判断是否存在这样一个属性。所以，任何分配给 Person.prototype 的东西对通过 this 对象构造的实例都是可用的。

+
Person.prototype 是一个可以被Person的所有实例共享的对象。它是一个名叫原型链（prototype chain）的查询链的一部分：当你试图访问 Person 某个实例（例如上个例子中的 s）一个没有定义的属性时，解释器会首先检查这个 Person.prototype 来判断是否存在这样一个属性。所以，任何分配给 Person.prototype 的东西对通过 this 对象构造的实例都是可用的。

 
-
这个特性功能十分强大，JavaScript 允许你在程序中的任何时候修改原型（prototype）中的一些东西，也就是说你可以在运行时(runtime)给已存在的对象添加额外的方法：

+
这个特性功能十分强大，JavaScript 允许你在程序中的任何时候修改原型（prototype）中的一些东西，也就是说你可以在运行时 (runtime) 给已存在的对象添加额外的方法：

 
 
s = new Person("Simon", "Willison");
 s.firstNameCaps();  // TypeError on line 1: s.firstNameCaps is not a function
diff --git a/files/zh-cn/web/javascript/about_javascript/index.html b/files/zh-cn/web/javascript/about_javascript/index.html
index 0f720757749178..5c803666b9911a 100644
--- a/files/zh-cn/web/javascript/about_javascript/index.html
+++ b/files/zh-cn/web/javascript/about_javascript/index.html
@@ -10,9 +10,9 @@
 
 
什么是 JavaScript?

 
-
JavaScript® （通常简写为JS）是一种轻量的、解释性的、面向对象的头等函数语言，其最广为人知的应用是作为网页的脚本语言，但同时它也在很多非浏览器环境下使用。JS是一种动态的基于原型和多范式的脚本语言，支持面向对象、命令式和函数式的编程风格。

+
JavaScript®（通常简写为 JS）是一种轻量的、解释性的、面向对象的头等函数语言，其最广为人知的应用是作为网页的脚本语言，但同时它也在很多非浏览器环境下使用。JS 是一种动态的基于原型和多范式的脚本语言，支持面向对象、命令式和函数式的编程风格。

 
-
JavaScript运行在网页的客户端，能被用来设计和编程网页在事件发生时的行为。JavaScript不仅易学而且强大，因此广泛用于对网页的控制。

+
JavaScript 运行在网页的客户端，能被用来设计和编程网页在事件发生时的行为。JavaScript 不仅易学而且强大，因此广泛用于对网页的控制。

 
 
与流行的误解相反，JavaScript 并不是“解释性 Java”。简单来说，JavaScript 是一个动态脚本语言，支持 基于原型的 对象构造。其基本语法被设计地与 Java 和 C++ 接近，来减少学习语言所需要的新概念。语言结构，如条件语句（if）、循环（for，while）、分支（switch）、异常捕获（try...catch）等和这些语言一致或者很接近。

 
@@ -22,11 +22,11 @@ 
什么是 JavaScript?

 
 
如果您需要了解更多 JavaScript 编程信息，请参见下方的 JavaScript 资源 链接。

 
-
有哪些 JavaScript 的实现?

+
有哪些 JavaScript 的实现？

 
 
mozilla.org 上托管了两个 JavaScript 实现。首个 JavaScript 由网景公司的 Brendan Eich 创建，并不断地更新以符合 ECMA-262 Edition 5 及其之后的标准版本。这个引擎，代号 SpiderMonkey ，是由 C/C++ 语言开发的。而 Rhino 引擎，主要由 Norris Boyd（同样也是在网景公司）创建，则是一个 Java 语言开发的 JavaScript 实现。与 SpiderMonkey 类似，Rhino 符合 ECMA-262 Edition 5 标准。

 
-
有很多优化技术如 TraceMonkey (Firefox 3.5)、JägerMonkey (Firefox 4) 和 IonMonkey 被不断添加到了 SpiderMonkey JavaScript 引擎。并且提升JavaScript执行效率的工作一直在进行。

+
有很多优化技术如 TraceMonkey (Firefox 3.5)、JägerMonkey (Firefox 4) 和 IonMonkey 被不断添加到了 SpiderMonkey JavaScript 引擎。并且提升 JavaScript 执行效率的工作一直在进行。

 
 
除了以上实现，还有其他一些流行的 JavaScript 引擎，如：

 
@@ -37,7 +37,7 @@ 
有哪些 JavaScript 
  
  • The Chakra 引擎，用在 Internet Explorer 中（尽管它实现的语言被正式地称作为“JScript”来避免商标问题）。
    • 
 
 
-
    每个 mozilla.org 的 JavaScript 引擎都提供了 公用API使程序开发者能将其JavaScript嵌入自己的软件中。目前最常见的 JavaScript 宿主环境是网页浏览器。浏览器一般通过 API 创建“宿主对象”来负责将DOM 反射到 JavaScript 中。
    
+
    每个 mozilla.org 的 JavaScript 引擎都提供了 公用 API 使程序开发者能将其 JavaScript 嵌入自己的软件中。目前最常见的 JavaScript 宿主环境是网页浏览器。浏览器一般通过 API 创建“宿主对象”来负责将DOM 反射到 JavaScript 中。
    
 
 
    另一个常见的 JavaScript 应用是作为服务端脚本语言。JavaScript 服务器提供宿主对象代表 HTTP 请求和响应，随后可以通过 JavaScript 程序来动态的生成 Web 页面。Node.js便是一个流行的例子。
    
 
@@ -45,7 +45,7 @@ 
    JavaScript 资源
    
 
 
    
  
    SpiderMonkey
    
- 
    Mozilla使用C/C++引擎实现JavaScript（又称为SpiderMonkey），以及如何在应用中嵌入使用的相关信息。
    
+ 
    Mozilla 使用 C/C++ 引擎实现 JavaScript（又称为 SpiderMonkey），以及如何在应用中嵌入使用的相关信息。
    
  
    Rhino
    
  
    Rhino（Java 语言实现的 JavaScript）的相关信息。
    
  
    语言资源
    
@@ -54,4 +54,4 @@ 
    JavaScript 资源
    
  
    JavaScript 指南 和 JavaScript 参考。
    
 
    
 
-
    JavaScript®是Oracle于美国和其他国家注册和拥有的商标。
    
+
    JavaScript®是 Oracle 于美国和其他国家注册和拥有的商标。
    
diff --git a/files/zh-cn/web/javascript/closures/index.html b/files/zh-cn/web/javascript/closures/index.html
index 54021ca4ff7bdd..a5efc413017483 100644
--- a/files/zh-cn/web/javascript/closures/index.html
+++ b/files/zh-cn/web/javascript/closures/index.html
@@ -50,7 +50,7 @@ 
    闭包
    
 
 
    第一眼看上去，也许不能直观地看出这段代码能够正常运行。在一些编程语言中，一个函数中的局部变量仅存在于此函数的执行期间。一旦 makeFunc() 执行完毕，你可能会认为 name 变量将不能再被访问。然而，因为代码仍按预期运行，所以在 JavaScript 中情况显然与此不同。
    
 
-
    原因在于，JavaScript中的函数会形成了闭包。 闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。在本例子中，myFunc 是执行 makeFunc 时创建的 displayName 函数实例的引用。displayName 的实例维持了一个对它的词法环境（变量 name 存在于其中）的引用。因此，当 myFunc 被调用时，变量 name 仍然可用，其值 Mozilla 就被传递到alert中。
    
+
    原因在于，JavaScript 中的函数会形成了闭包。 闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量。在本例子中，myFunc 是执行 makeFunc 时创建的 displayName 函数实例的引用。displayName 的实例维持了一个对它的词法环境（变量 name 存在于其中）的引用。因此，当 myFunc 被调用时，变量 name 仍然可用，其值 Mozilla 就被传递到alert中。
    
 
 
    下面是一个更有意思的示例 — 一个 makeAdder 函数：
    
 
@@ -245,7 +245,7 @@ 
    在循环中创建闭包：
 
 
    运行这段代码后，您会发现它没有达到想要的效果。无论焦点在哪个input上，显示的都是关于年龄的信息。
    
 
-
    原因是赋值给 onfocus 的是闭包。这些闭包是由他们的函数定义和在 setupHelp 作用域中捕获的环境所组成的。这三个闭包在循环中被创建，但他们共享了同一个词法作用域，在这个作用域中存在一个变量item。这是因为变量item使用var进行声明，由于变量提升，所以具有函数作用域。当onfocus的回调执行时，item.help的值被决定。由于循环在事件触发之前早已执行完毕，变量对象item（被三个闭包所共享）已经指向了helpText的最后一项。
    
+
    原因是赋值给 onfocus 的是闭包。这些闭包是由他们的函数定义和在 setupHelp 作用域中捕获的环境所组成的。这三个闭包在循环中被创建，但他们共享了同一个词法作用域，在这个作用域中存在一个变量 item。这是因为变量item使用 var 进行声明，由于变量提升，所以具有函数作用域。当onfocus的回调执行时，item.help的值被决定。由于循环在事件触发之前早已执行完毕，变量对象item（被三个闭包所共享）已经指向了helpText的最后一项。
    
 
 
    解决这个问题的一种方案是使用更多的闭包：特别是使用前面所述的函数工厂：
    
 
@@ -298,13 +298,13 @@ 
    在循环中创建闭包：
        document.getElementById(item.id).onfocus = function() {
          showHelp(item.help);
        }
-    })(); // 马上把当前循环项的item与事件回调相关联起来
+    })(); // 马上把当前循环项的 item 与事件回调相关联起来
   }
 }
 
 setupHelp();
    
 
-
    如果不想使用过多的闭包，你可以用ES2015引入的let关键词：
    
+
    如果不想使用过多的闭包，你可以用 ES2015 引入的 let 关键词：
    
 
 
    function showHelp(help) {
   document.getElementById('help').innerHTML = help;
diff --git a/files/zh-cn/web/javascript/data_structures/index.md b/files/zh-cn/web/javascript/data_structures/index.md
index df233e7ac4e6f5..db5c9f2bcf753e 100644
--- a/files/zh-cn/web/javascript/data_structures/index.md
+++ b/files/zh-cn/web/javascript/data_structures/index.md
@@ -78,7 +78,7 @@ Infinity
 
 尽管一个数字通常仅代表它本身的值，但 JavaScript 提供了一些{{jsxref("Operators", "位运算符")}}。
 
-> **备注：** 虽然位运算符可通过[掩码](https://zh.wikipedia.org/wiki/掩码)同时表示多个布尔类型的值，但这通常被认为是不好的。JavaScript 提供了其他的方式来表示一组布尔值（如一个布尔值数组或一个布尔值分配给命名属性的对象）。掩码也容易使代码变得难以阅读、理解和维护。
+> **备注：** 虽然位运算符可通过 [掩码](https://zh.wikipedia.org/wiki/掩码) 同时表示多个布尔类型的值，但这通常被认为是不好的。JavaScript 提供了其他的方式来表示一组布尔值（如一个布尔值数组或一个布尔值分配给命名属性的对象）。掩码也容易使代码变得难以阅读、理解和维护。
 
 在一些非常受限的情况下，可能需要用到这些技术，比如试图应对本地存储的存储限制，或在一些极端场景下（例如，网络传输的每一比特都尤为重要时）。位操作只应该是用来优化字节数的最后选择。
 
@@ -135,13 +135,13 @@ JavaScript 的字符串类型用于表示文本数据。它是一组 16 位的
 
 ### 符号类型
 
-符号（Symbols）类型是**唯一**且**不可修改**的原始值，并且可以用来作为对象的键(key)（如下），在某些语言当中也有与之相似的类型（原子类型，atoms）。
+符号（Symbols）类型是**唯一**且**不可修改**的原始值，并且可以用来作为对象的键 (key)（如下），在某些语言当中也有与之相似的类型（原子类型，atoms）。
 
 更多详情可查看 {{Glossary("Symbol")}} 和 {{jsxref("Symbol")}}。
 
 ## 对象
 
-在计算机科学中, 对象（object）是指内存中的可以被{{Glossary("Identifier", "标识符")}}引用的一块区域。
+在计算机科学中，对象（object）是指内存中的可以被{{Glossary("Identifier", "标识符")}}引用的一块区域。
 
 ### 属性
 
@@ -217,7 +217,7 @@ JavaScript 的字符串类型用于表示文本数据。它是一组 16 位的
 
 | 特性       | 类型  | 描述                                              |
 | ---------- | ------- | --------------------------------------------- |
-| Read-only  | Boolean | ES5 [[Writable]] 属性的反状态(Reversed state)。 |
+| Read-only  | Boolean | ES5 [[Writable]] 属性的反状态 (Reversed state)。 |
 | DontEnum   | Boolean | ES5 [[Enumerable]] 属性的反状态。               |
 | DontDelete | Boolean | ES5 [[Configurable]] 属性的反状态。             |
 
@@ -252,20 +252,20 @@ JavaScript 的字符串类型用于表示文本数据。它是一组 16 位的
 
 此外，数组对象还继承了 `Array.prototype` 的一些操作数组的便捷方法。例如，[`indexOf()`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)（搜索数组中的一个值）或 [`push()`](/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/push)（向数组中添加一个元素），等等。这使得数组是表示列表或集合的最优选择。
 
-[类型数组(Typed Arrays)](/en-US/docs/Web/JavaScript/Typed_arrays) 是 ECMAScript 2015 中新定义的 JavaScript 内建对象，提供了一个基本的二进制数据缓冲区的类数组视图。下面的表格能帮助你找到对等的 C 语言数据类型：
+[类型数组 (Typed Arrays)](/en-US/docs/Web/JavaScript/Typed_arrays) 是 ECMAScript 2015 中新定义的 JavaScript 内建对象，提供了一个基本的二进制数据缓冲区的类数组视图。下面的表格能帮助你找到对等的 C 语言数据类型：
 
 | 类型                                         | 取值范围                                       | 占用字节数 | 描述                                                                                 | Web IDL 类型            | 对等的 C 语言类型                      |
 | --------------------------------- | --------------------------------- | ------------ | ----------------------------------------------------------- | ---------------------- | --------------------------------- |
-| {{jsxref("Int8Array")}}                  | `-128` 到 `127`                            | 1                 | 8 位有符号整数（补码）                                                   | `byte`                         | `int8_t`                                        |
+| {{jsxref("Int8Array")}}                  | `-128` 到 `127`                            | 1                 | 8 位有符号整数（补码）                                                  | `byte`                         | `int8_t`                                        |
 | {{jsxref("Uint8Array")}}                | `0` 到 `255`                                 | 1                 | 8 位无符号整数                                                               | `octet`                        | `uint8_t`                                      |
 | {{jsxref("Uint8ClampedArray")}} | `0` 到 `255`                                 | 1                 | 8 位无符号整数（固定数组）                                          | `octet`                        | `uint8_t`                                      |
-| {{jsxref("Int16Array")}}                | `-32768` 到 `32767`                    | 2                 | 16 位有符号整数（补码）                                                 | `short`                        | `int16_t`                                      |
+| {{jsxref("Int16Array")}}                | `-32768` 到 `32767`                    | 2                 | 16 位有符号整数（补码）                                                | `short`                        | `int16_t`                                      |
 | {{jsxref("Uint16Array")}}              | `0` 到 `65535`                             | 2                 | 16 位无符号整数                                                             | `unsigned short`        | `uint16_t`                                    |
-| {{jsxref("Int32Array")}}                | `-2147483648` 到 `2147483647` | 4                | 32 位有符号整数（补码）                                                 | `long`                         | `int32_t`                                       |
+| {{jsxref("Int32Array")}}                | `-2147483648` 到 `2147483647` | 4                | 32 位有符号整数（补码）                                                | `long`                         | `int32_t`                                       |
 | {{jsxref("Uint32Array")}}              | `0` 到 `4294967295`                    | 4                | 32 位无符号整数                                                             | `unsigned long`         | `uint32_t`                                    |
-| {{jsxref("Float32Array")}}             | `1.2E-38` 到 `3.4E38`                   | 4                 | 32 位 IEEE 浮点数（7 位有效数字，例如：`1.1234567`）  | `unrestricted float`     | `float`                                          |
-| {{jsxref("Float64Array")}}             | `5E-324` 到 `1.8E308`                  | 8                 | 64 位 IEEE 浮点数（16 位有效数字，例如：`1.123...15`） | `unrestricted double` | `double`                                      |
-| {{jsxref("BigInt64Array")}}           | `-2^63` 到 `2^63 - 1`                  | 8                 | 64 位有符号整数（补码）                                                | `bigint`                        | `int64_t (signed long long)`        |
+| {{jsxref("Float32Array")}}             | `1.2E-38` 到 `3.4E38`                   | 4                 | 32 位 IEEE 浮点数（7 位有效数字，例如：`1.1234567`） | `unrestricted float`     | `float`                                          |
+| {{jsxref("Float64Array")}}             | `5E-324` 到 `1.8E308`                  | 8                 | 64 位 IEEE 浮点数（16 位有效数字，例如：`1.123...15`）| `unrestricted double` | `double`                                      |
+| {{jsxref("BigInt64Array")}}           | `-2^63` 到 `2^63 - 1`                  | 8                 | 64 位有符号整数（补码）                                               | `bigint`                        | `int64_t (signed long long)`        |
 | {{jsxref("BigUint64Array")}}         | `0` 到 `2^64 - 1`                         | 8                  | 64 位无符号整数                                                            | `bigint`                        | `uint64_t (unsigned long long)` |
 
 ### 带键的集合：Maps, Sets, WeakMaps, WeakSets
diff --git a/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html b/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html
index a20bd79eecd7a0..d5cf6c4b98e62a 100644
--- a/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html
+++ b/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html
@@ -249,7 +249,7 @@ 
    统计表
    
    true
   
   
-   自身的Symbol 键
+   自身的 Symbol 键
    true
    false
    true
diff --git a/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html b/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html
index d36a7e3aad2c20..3686da3e7f1abd 100644
--- a/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html
+++ b/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html
@@ -13,16 +13,16 @@
 ---
 
    {{jsSidebar("Intermediate")}}
    
 
-
    ES2015中有四种相等算法：
    
+
    ES2015 中有四种相等算法：
    
 
 
      
  
    • 抽象（非严格）相等比较 (==)
      • 
  
    • 严格相等比较 (===): 用于  Array.prototype.indexOf, Array.prototype.lastIndexOf, 和 case-matching
      • 
- 
    • 同值零: 用于 %TypedArray% 和 ArrayBuffer 构造函数、以及Map和Set操作, 并将用于 ES2016/ES7 中的String.prototype.includes 
      • 
- 
    • 同值: 用于所有其他地方
      • 
+ 
    • 同值零：用于 %TypedArray% 和 ArrayBuffer 构造函数、以及Map和Set操作，并将用于 ES2016/ES7 中的String.prototype.includes 
      • 
+ 
    • 同值：用于所有其他地方
      • 
 
    
 
-
    JavaScript提供三种不同的值比较操作：
    
+
    JavaScript 提供三种不同的值比较操作：
    
 
 
      
  
    • 严格相等比较 (也被称作"strict equality", "identity", "triple equals")，使用 === ,
      • 
@@ -32,7 +32,7 @@
 
 
      选择使用哪个操作取决于你需要什么样的比较。
      
 
-
      简而言之，在比较两件事情时，双等号将执行类型转换; 三等号将进行相同的比较，而不进行类型转换 (如果类型不同, 只是总会返回 false );  而Object.is的行为方式与三等号相同，但是对于NaN和-0和+0进行特殊处理，所以最后两个不相同，而Object.is（NaN，NaN）将为 true。(通常使用双等号或三等号将NaN与NaN进行比较，结果为false，因为IEEE 754如是说.) 请注意，所有这些之间的区别都与其处理原语有关; 这三个运算符的原语中，没有一个会比较两个变量是否结构上概念类似。对于任意两个不同的非原始对象，即便他们有相同的结构， 以上三个运算符都会计算得到 false 。
      
+
      简而言之，在比较两件事情时，双等号将执行类型转换; 三等号将进行相同的比较，而不进行类型转换 (如果类型不同，只是总会返回 false );  而 Object.is 的行为方式与三等号相同，但是对于 NaN 和-0 和 +0 进行特殊处理，所以最后两个不相同，而 Object.is（NaN，NaN）将为 true。(通常使用双等号或三等号将 NaN 与 NaN 进行比较，结果为 false，因为 IEEE 754 如是说.) 请注意，所有这些之间的区别都与其处理原语有关; 这三个运算符的原语中，没有一个会比较两个变量是否结构上概念类似。对于任意两个不同的非原始对象，即便他们有相同的结构， 以上三个运算符都会计算得到 false 。
      
 
 
      严格相等 ===
      
 
@@ -141,7 +141,7 @@ 
      非严格相等 ==
      
  
 
 
-
      在上面的表格中，ToNumber(A) 尝试在比较前将参数 A 转换为数字，这与 +A（单目运算符+）的效果相同。ToPrimitive(A)通过尝试调用 A 的A.toString() 和 A.valueOf() 方法，将参数 A 转换为原始值（Primitive）。
      
+
      在上面的表格中，ToNumber(A) 尝试在比较前将参数 A 转换为数字，这与 +A（单目运算符 +）的效果相同。ToPrimitive(A)通过尝试调用 A 的A.toString() 和 A.valueOf() 方法，将参数 A 转换为原始值（Primitive）。
      
 
 
      一般而言，根据 ECMAScript 规范，所有的对象都与 undefined 和 null 不相等。但是大部分浏览器允许非常窄的一类对象（即，所有页面中的 document.all 对象），在某些情况下，充当效仿 undefined 的角色。相等操作符就是在这样的一个背景下。因此，IsFalsy(A) 方法的值为 true ，当且仅当 A 效仿 undefined。在其他所有情况下，一个对象都不会等于 undefined 或 null。
      
 
@@ -378,18 +378,18 @@ 
      理解相等比较的模型
      
 
 
      什么时候使用 Object.is 或是三等
      
 
-
      总的来说，除了对待NaN的方式，Object.is唯一让人感兴趣的，是当你需要一些元编程方案时，它对待0的特殊方式，特别是关于属性描述器，即你的工作需要去镜像Object.defineProperty的一些特性时。如果你的工作不需要这些，那你应该避免使用Object.is，使用===来代替。即使你需要比较两个NaN使其结果为true，总的来说编写使用NaN 检查的特例函数(用旧版本ECMAScript的isNaN方法)也会比想出一些计算方法让Object.is不影响不同符号的0的比较更容易些。
      
+
      总的来说，除了对待NaN的方式，Object.is唯一让人感兴趣的，是当你需要一些元编程方案时，它对待 0 的特殊方式，特别是关于属性描述器，即你的工作需要去镜像Object.defineProperty的一些特性时。如果你的工作不需要这些，那你应该避免使用Object.is，使用===来代替。即使你需要比较两个NaN使其结果为true，总的来说编写使用NaN 检查的特例函数 (用旧版本 ECMAScript 的isNaN 方法) 也会比想出一些计算方法让Object.is不影响不同符号的 0 的比较更容易些。
      
 
-
      这里是一个会区别对待-0和+0的内置方法和操作符不完全列表：
      
+
      这里是一个会区别对待-0 和 +0 的内置方法和操作符不完全列表：
      
 
 
      
  
      - (一元负)
      
  
      
- 
      显而易见，对0一元负操作得到-0。但表达式的抽象化可能在你没有意识到得情况下导致-0延续传播。例如当考虑下例时:
      
+ 
      显而易见，对0 一元负操作得到-0。但表达式的抽象化可能在你没有意识到得情况下导致-0 延续传播。例如当考虑下例时：
      
 
  
      let stoppingForce = obj.mass * -obj.velocity
      
 
- 
      如果obj.velocity是0 (或计算结果为0), 一个-0就在上处产生并被赋值为stoppingForce的值.
      
+ 
      如果obj.velocity是0 (或计算结果为0), 一个-0就在上处产生并被赋值为stoppingForce 的值.
      
  
      
  
      
   Math.atan2, 
@@ -406,19 +406,19 @@ 
      什么时候使用 Math.sqrt, 
   Math.tan
  
      
- 
      当传入参数中有-0时，这些方法也可能返回-0。例如， Math.min(-0, +0) 得出 -0。详情请参见这些方法各自的文档。
      
+ 
      当传入参数中有-0 时，这些方法也可能返回-0。例如， Math.min(-0, +0) 得出 -0。详情请参见这些方法各自的文档。
      
  
      
   ~, 
   <<, 
   >>
  
      
- 
      这些操作符内部都使用了ToInt32算法。因为内部32位整数类型只有一个0（没有符号区别），-0的符号在反操作后并不会保留下来。例如Object.is(~~(-0), -0)和Object.is(-0 << 2 >> 2, -0) 都会得到false.
      
+ 
      这些操作符内部都使用了 ToInt32 算法。因为内部 32 位整数类型只有一个 0（没有符号区别），-0 的符号在反操作后并不会保留下来。例如Object.is(~~(-0), -0)和Object.is(-0 << 2 >> 2, -0) 都会得到 false.
      
 
      
 
-
      在未考虑0的符号的情况下依赖于Object.is是危险的。当然，如果本意就是区分-0和+0的话，Object.is能按照期望完成工作。
      
+
      在未考虑 0 的符号的情况下依赖于Object.is是危险的。当然，如果本意就是区分-0 和 +0 的话，Object.is能按照期望完成工作。
      
 
 
      参考
      
 
 
diff --git a/files/zh-cn/web/javascript/eventloop/index.html b/files/zh-cn/web/javascript/eventloop/index.html
index 9720de3eb0051c..9d42cb2c0ebb51 100644
--- a/files/zh-cn/web/javascript/eventloop/index.html
+++ b/files/zh-cn/web/javascript/eventloop/index.html
@@ -13,11 +13,11 @@
 ---
 
      {{JsSidebar("Advanced")}}
      
 
-
      JavaScript有一个基于事件循环的并发模型，事件循环负责执行代码、收集和处理事件以及执行队列中的子任务。这个模型与其它语言中的模型截然不同，比如 C 和 Java。
      
+
      JavaScript 有一个基于事件循环的并发模型，事件循环负责执行代码、收集和处理事件以及执行队列中的子任务。这个模型与其它语言中的模型截然不同，比如 C 和 Java。
      
 
 
      运行时概念
      
 
-
      接下来的内容解释了这个理论模型。现代JavaScript引擎实现并着重优化了以下描述的这些语义。
      
+
      接下来的内容解释了这个理论模型。现代 JavaScript 引擎实现并着重优化了以下描述的这些语义。
      
 
 
      可视化描述
      
 
@@ -61,13 +61,13 @@ 
      事件循环
      
   queue.processNextMessage();
 }
    
 
-
    queue.waitForMessage() 会同步地等待消息到达(如果当前没有任何消息等待被处理)。
    
+
    queue.waitForMessage() 会同步地等待消息到达 (如果当前没有任何消息等待被处理)。
    
 
 
    "执行至完成"
    
 
-
    每一个消息完整地执行后，其它消息才会被执行。这为程序的分析提供了一些优秀的特性，包括：当一个函数执行时，它不会被抢占，只有在它运行完毕之后才会去运行任何其他的代码，才能修改这个函数操作的数据。这与C语言不同，例如，如果函数在线程中运行，它可能在任何位置被终止，然后在另一个线程中运行其他代码。
    
+
    每一个消息完整地执行后，其它消息才会被执行。这为程序的分析提供了一些优秀的特性，包括：当一个函数执行时，它不会被抢占，只有在它运行完毕之后才会去运行任何其他的代码，才能修改这个函数操作的数据。这与 C 语言不同，例如，如果函数在线程中运行，它可能在任何位置被终止，然后在另一个线程中运行其他代码。
    
 
-
    这个模型的一个缺点在于当一个消息需要太长时间才能处理完毕时，Web应用程序就无法处理与用户的交互，例如点击或滚动。为了缓解这个问题，浏览器一般会弹出一个“这个脚本运行时间过长”的对话框。一个良好的习惯是缩短单个消息处理时间，并在可能的情况下将一个消息裁剪成多个消息。
    
+
    这个模型的一个缺点在于当一个消息需要太长时间才能处理完毕时，Web 应用程序就无法处理与用户的交互，例如点击或滚动。为了缓解这个问题，浏览器一般会弹出一个“这个脚本运行时间过长”的对话框。一个良好的习惯是缩短单个消息处理时间，并在可能的情况下将一个消息裁剪成多个消息。
    
 
 
    添加消息
    
 
@@ -130,7 +130,7 @@ 
    多个运行时互相通信
    
 
 
    永不阻塞
    
 
-
    JavaScript的事件循环模型与许多其他语言不同的一个非常有趣的特性是，它永不阻塞。 处理 I/O 通常通过事件和回调来执行，所以当一个应用正等待一个 IndexedDB 查询返回或者一个 XHR 请求返回时，它仍然可以处理其它事情，比如用户输入。
    
+
    JavaScript 的事件循环模型与许多其他语言不同的一个非常有趣的特性是，它永不阻塞。 处理 I/O 通常通过事件和回调来执行，所以当一个应用正等待一个 IndexedDB 查询返回或者一个 XHR 请求返回时，它仍然可以处理其它事情，比如用户输入。
    
 
 
    由于历史原因有一些例外，如 alert 或者同步 XHR，但应该尽量避免使用它们。注意，例外的例外也是存在的（但通常是实现错误而非其它原因）。
    
 
diff --git a/files/zh-cn/web/javascript/index.html b/files/zh-cn/web/javascript/index.html
index 959237a0aeee5d..bfd18334992c7b 100644
--- a/files/zh-cn/web/javascript/index.html
+++ b/files/zh-cn/web/javascript/index.html
@@ -10,17 +10,17 @@
 ---
 
    {{JsSidebar()}}
    
 
-
    JavaScript ( JS ) 是一种具有{{Glossary("First-class Function", "函数优先")}}的轻量级，解释型或即时编译型的编程语言。虽然它是作为开发Web 页面的脚本语言而出名的，但是它也被用到了很多非浏览器环境中，例如 Node.js、 Apache CouchDB 和 Adobe Acrobat。JavaScript 是一种{{Glossary("Prototype-based_programming", "基于原型编程")}}、多范式的动态脚本语言，并且支持面向对象、命令式和声明式（如函数式编程）风格。了解更多 JavaScript。
    
+
    JavaScript ( JS ) 是一种具有{{Glossary("First-class Function", "函数优先")}}的轻量级，解释型或即时编译型的编程语言。虽然它是作为开发 Web 页面的脚本语言而出名的，但是它也被用到了很多非浏览器环境中，例如 Node.js、 Apache CouchDB 和 Adobe Acrobat。JavaScript 是一种{{Glossary("Prototype-based_programming", "基于原型编程")}}、多范式的动态脚本语言，并且支持面向对象、命令式和声明式（如函数式编程）风格。了解更多 JavaScript。
    
 
 
    本部分将专注于 JavaScript 语言本身，而非局限于网页或其他限制环境。想要了解网页有关的 {{Glossary("API","APIs")}} ，请参考 Web APIs 以及 DOM。
    
 
-
    JavaScript 的标准是 ECMAScript 。截至 2012 年，所有的现代浏览器都完整的支持  ECMAScript 5.1，旧版本的浏览器至少支持 ECMAScript 3 标准。2015年6月17日，ECMA国际组织发布了 ECMAScript 的第六版，该版本正式名称为 ECMAScript 2015，但通常被称为 ECMAScript 6 或者 ES6。自此，ECMAScript 每年发布一次新标准。本文档目前覆盖了最新 ECMAScript 的草案，也就是 ECMAScript2020。
    
+
    JavaScript 的标准是 ECMAScript 。截至 2012 年，所有的现代浏览器都完整的支持  ECMAScript 5.1，旧版本的浏览器至少支持 ECMAScript 3 标准。2015 年 6 月 17 日，ECMA 国际组织发布了 ECMAScript 的第六版，该版本正式名称为 ECMAScript 2015，但通常被称为 ECMAScript 6 或者 ES6。自此，ECMAScript 每年发布一次新标准。本文档目前覆盖了最新 ECMAScript 的草案，也就是 ECMAScript2020。
    
 
-
    不要将 JavaScript 与 Java编程语言 混淆。虽然“Java”和“JavaScript”都是 Oracle 公司在美国和其他国家注册（或未注册）的商标，但是这两门语言在语法、语义与用途方面有很大不同。
    
+
    不要将 JavaScript 与 Java 编程语言 混淆。虽然“Java”和“JavaScript”都是 Oracle 公司在美国和其他国家注册（或未注册）的商标，但是这两门语言在语法、语义与用途方面有很大不同。
    
 
 
    教程
    
 
-
    通过使用指南和教程来学习如何用JavaScript语言编程。
    
+
    通过使用指南和教程来学习如何用 JavaScript 语言编程。
    
 
 
    对于完全初学者
    
 
@@ -31,7 +31,7 @@ 
    对于完全初学者
    
  
    回答一些基本问题，比如“JavaScript 是什么？”、“它是怎么样的？”、“它可以用来做什么？”；同时还讨论如变量、字符串、数值和数组等 JavaScript 的核心特性。
    
  
    JavaScript 基本结构
    
  
    继介绍了 JavaScript 基本的核心特性后，我们需要关注常见的代码块类型，如条件语句，循环，函数和事件。
    
- 
    介绍JavaScript 对象
    
+ 
    介绍 JavaScript 对象
    
  
    如果你想进一步使用该语言撰写更有效率的代码，理解 JavaScript 面向对象的精髓是很重要的，因此我们提供了该模块来帮助你理解它。
    
 
 
@@ -48,7 +48,7 @@ 
    中级内容
    
  
    客户端 Web API
    
  
    当你正在给网页或者网页 APP 编写客户端 JavaScript 时， 你离不开使用这些 API — 这些用来操作浏览器各个不同方面和网页所在的操作系统，甚至是来自于其他网页和服务器的数据的接口。在这个模块，我们来探究这些 API 是什么，以及怎么在你的日常开发工作中使用一些最常用的 API。
    
  
    重新介绍 JavaScript（JS 教程）
    
- 
    给那些有 JavaScript 基础的朋友们的 JavaScript概述。
    
+ 
    给那些有 JavaScript 基础的朋友们的 JavaScript 概述。
    
  
    JavaScript 数据结构
    
  
    JavaScript 数据结构的概述。
    
  
    如何使用比较操作符
    
@@ -102,14 +102,14 @@ 
    工具和资源
    
  
  
    Stack Overflow
    
  
    你可以在 StackOverflow 查看或者发布带有 JavaScript 标签的问题。
    
- 
    JavaScript版本和发行记录
    
- 
    浏览 JavaScript 的历史版本特性和实现情况.
    
+ 
    JavaScript 版本和发行记录
    
+ 
    浏览 JavaScript 的历史版本特性和实现情况。
    
  
    JSFiddle
    
  
    编辑 JavaScript、CSS 和 HTML 并获得实时结果。使用外置资源，并和你的团队在线合作。
    
  
    Plunker
    
  
    Plunker 是一个在线社区，用于创建，协作和共享您的 Web 开发创意。编辑您的 JavaScript、CSS 和 HTML 文件并获取实时结果和文件结构。
    
  
    JSBin
    
  
    
- 
    JS Bin 是一种开源的协作式的web 开发调试工具。
    
+ 
    JS Bin 是一种开源的协作式的 web 开发调试工具。
    
  
    
 
diff --git a/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html b/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html
index b9ba6dc992c5cb..233ba9bceec410 100644
--- a/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html
+++ b/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html
@@ -32,14 +32,14 @@ 
    继承属性
    
 
    JavaScript 对象是动态的属性“包”（指其自己的属性）。JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。
    
 
 
    
-
    备注：遵循ECMAScript标准，someObject.[[Prototype]] 符号是用于指向 someObject 的原型。从 ECMAScript 6 开始，[[Prototype]] 可以通过 {{jsxref("Object.getPrototypeOf()")}} 和 {{jsxref("Object.setPrototypeOf()")}} 访问器来访问。这个等同于 JavaScript 的非标准但许多浏览器实现的属性 __proto__。
    
+
    备注：遵循 ECMAScript 标准，someObject.[[Prototype]] 符号是用于指向 someObject 的原型。从 ECMAScript 6 开始，[[Prototype]] 可以通过 {{jsxref("Object.getPrototypeOf()")}} 和 {{jsxref("Object.setPrototypeOf()")}} 访问器来访问。这个等同于 JavaScript 的非标准但许多浏览器实现的属性 __proto__。
    
 
 
    但它不应该与构造函数 func 的 prototype 属性相混淆。被构造函数创建的实例对象的 [[Prototype]] 指向 func 的 prototype 属性。Object.prototype 属性表示 {{jsxref("Object")}} 的原型对象。
    
 
    
 
 
    这里演示当尝试访问属性时会发生什么：
    
 
-
    // 让我们从一个函数里创建一个对象o，它自身拥有属性a和b的：
+
    // 让我们从一个函数里创建一个对象 o，它自身拥有属性 a 和 b 的：
 let f = function () {
    this.a = 1;
    this.b = 2;
@@ -52,7 +52,7 @@ 
    继承属性
    
 */
 let o = new f(); // {a: 1, b: 2}
 
-// 在f函数的原型上定义属性
+// 在 f 函数的原型上定义属性
 f.prototype.b = 3;
 f.prototype.c = 4;
 
@@ -60,25 +60,25 @@ 
    继承属性
    
 // o.[[Prototype]] 有属性 b 和 c
 //  (其实就是 o.__proto__ 或者 o.constructor.prototype)
 // o.[[Prototype]].[[Prototype]] 是 Object.prototype.
-// 最后o.[[Prototype]].[[Prototype]].[[Prototype]]是null
+// 最后 o.[[Prototype]].[[Prototype]].[[Prototype]] 是 null
 // 这就是原型链的末尾，即 null，
 // 根据定义，null 就是没有 [[Prototype]]。
 
-// 综上，整个原型链如下:
+// 综上，整个原型链如下：
 
 // {a:1, b:2} ---> {b:3, c:4} ---> Object.prototype---> null
 
 console.log(o.a); // 1
-// a是o的自身属性吗？是的，该属性的值为 1
+// a 是 o 的自身属性吗？是的，该属性的值为 1
 
 console.log(o.b); // 2
-// b是o的自身属性吗？是的，该属性的值为 2
+// b 是 o 的自身属性吗？是的，该属性的值为 2
 // 原型上也有一个'b'属性，但是它不会被访问到。
 // 这种情况被称为"属性遮蔽 (property shadowing)"
 
 console.log(o.c); // 4
-// c是o的自身属性吗？不是，那看看它的原型上有没有
-// c是o.[[Prototype]]的属性吗？是的，该属性的值为 4
+// c 是 o 的自身属性吗？不是，那看看它的原型上有没有
+// c 是 o.[[Prototype]] 的属性吗？是的，该属性的值为 4
 
 console.log(o.d); // undefined
 // d 是 o 的自身属性吗？不是，那看看它的原型上有没有
@@ -107,7 +107,7 @@ 
    继承方法
    
 // 当调用 o.m 时，'this' 指向了 o.
 
 var p = Object.create(o);
-// p是一个继承自 o 的对象
+// p 是一个继承自 o 的对象
 
 p.a = 4; // 创建 p 的自身属性 'a'
 console.log(p.m()); // 5
@@ -119,7 +119,7 @@ 
    在 JavaScript 中使用原型
    
 
 
    接下去，来仔细分析一下这些应用场景下， JavaScript 在背后做了哪些事情。
    
 
-
    正如之前提到的，在 JavaScript 中，函数（function）是允许拥有属性的。所有的函数会有一个特别的属性 —— prototype 。请注意，以下的代码是独立的（出于严谨，假定页面没有其他的JavaScript代码）。为了最佳的学习体验，我们强烈建议阁下打开浏览器的控制台（在Chrome和火狐浏览器中，按Ctrl+Shift+I即可），进入“console”选项卡，然后把如下的JavaScript代码复制粘贴到窗口中，最后通过按下回车键运行代码。
    
+
    正如之前提到的，在 JavaScript 中，函数（function）是允许拥有属性的。所有的函数会有一个特别的属性 —— prototype 。请注意，以下的代码是独立的（出于严谨，假定页面没有其他的 JavaScript 代码）。为了最佳的学习体验，我们强烈建议阁下打开浏览器的控制台（在 Chrome 和火狐浏览器中，按 Ctrl+Shift+I 即可），进入“console”选项卡，然后把如下的 JavaScript 代码复制粘贴到窗口中，最后通过按下回车键运行代码。
    
 
 
    function doSomething(){}
 console.log( doSomething.prototype );
@@ -128,7 +128,7 @@ 
    在 JavaScript 中使用原型
    
 var doSomething = function(){};
 console.log( doSomething.prototype );
    
 
-
    在控制台显示的JavaScript代码块中，我们可以看到doSomething函数的一个默认属性prototype。而这段代码运行之后，控制台应该显示类似如下的结果：
    
+
    在控制台显示的 JavaScript 代码块中，我们可以看到 doSomething 函数的一个默认属性 prototype。而这段代码运行之后，控制台应该显示类似如下的结果：
    
 
 
    {
     constructor: ƒ doSomething(),
@@ -143,7 +143,7 @@ 
    在 JavaScript 中使用原型
    
     }
 }
    
 
-
    我们可以给doSomething函数的原型对象添加新属性，如下：
    
+
    我们可以给 doSomething 函数的原型对象添加新属性，如下：
    
 
 
    function doSomething(){}
 doSomething.prototype.foo = "bar";
@@ -165,7 +165,7 @@ 
    在 JavaScript 中使用原型
    
     }
 }
    
 
-
    现在我们可以通过new操作符来创建基于这个原型对象的doSomething实例。使用new操作符，只需在调用doSomething函数语句之前添加new。这样，便可以获得这个函数的一个实例对象。一些属性就可以添加到该原型对象中。
    
+
    现在我们可以通过 new 操作符来创建基于这个原型对象的 doSomething 实例。使用 new 操作符，只需在调用 doSomething 函数语句之前添加 new。这样，便可以获得这个函数的一个实例对象。一些属性就可以添加到该原型对象中。
    
 
 
    请尝试运行以下代码：
    
 
@@ -194,13 +194,13 @@ 
    在 JavaScript 中使用原型
    
     }
 }
    
 
-
    如上所示, doSomeInstancing 中的__proto__是 doSomething.prototype. 但这是做什么的呢？当你访问doSomeInstancing 中的一个属性，浏览器首先会查看doSomeInstancing 中是否存在这个属性。
    
+
    如上所示， doSomeInstancing 中的__proto__是 doSomething.prototype. 但这是做什么的呢？当你访问doSomeInstancing 中的一个属性，浏览器首先会查看doSomeInstancing 中是否存在这个属性。
    
 
-
    如果 doSomeInstancing 不包含属性信息, 那么浏览器会在 doSomeInstancing 的 __proto__ 中进行查找(同 doSomething.prototype). 如属性在 doSomeInstancing 的 __proto__ 中查找到，则使用 doSomeInstancing 中 __proto__ 的属性。
    
+
    如果 doSomeInstancing 不包含属性信息，那么浏览器会在 doSomeInstancing 的 __proto__ 中进行查找 (同 doSomething.prototype). 如属性在 doSomeInstancing 的 __proto__ 中查找到，则使用 doSomeInstancing 中 __proto__ 的属性。
    
 
-
    否则，如果 doSomeInstancing 中 __proto__ 不具有该属性，则检查doSomeInstancing 的 __proto__ 的  __proto__ 是否具有该属性。默认情况下，任何函数的原型属性 __proto__ 都是 window.Object.prototype. 因此, 通过doSomeInstancing 的 __proto__ 的  __proto__  ( 同 doSomething.prototype 的 __proto__ (同  Object.prototype)) 来查找要搜索的属性。
    
+
    否则，如果 doSomeInstancing 中 __proto__ 不具有该属性，则检查doSomeInstancing 的 __proto__ 的  __proto__ 是否具有该属性。默认情况下，任何函数的原型属性 __proto__ 都是 window.Object.prototype. 因此，通过doSomeInstancing 的 __proto__ 的  __proto__  ( 同 doSomething.prototype 的 __proto__ (同  Object.prototype)) 来查找要搜索的属性。
    
 
-
    如果属性不存在 doSomeInstancing 的 __proto__ 的  __proto__ 中， 那么就会在doSomeInstancing 的 __proto__ 的  __proto__ 的  __proto__ 中查找。然而, 这里存在个问题：doSomeInstancing 的 __proto__ 的  __proto__ 的  __proto__ 其实不存在。因此，只有这样，在 __proto__ 的整个原型链被查看之后，这里没有更多的 __proto__ ， 浏览器断言该属性不存在，并给出属性值为 undefined 的结论。
    
+
    如果属性不存在 doSomeInstancing 的 __proto__ 的  __proto__ 中， 那么就会在doSomeInstancing 的 __proto__ 的  __proto__ 的  __proto__ 中查找。然而，这里存在个问题：doSomeInstancing 的 __proto__ 的  __proto__ 的  __proto__ 其实不存在。因此，只有这样，在 __proto__ 的整个原型链被查看之后，这里没有更多的 __proto__ ， 浏览器断言该属性不存在，并给出属性值为 undefined 的结论。
    
 
 
    让我们在控制台窗口中输入更多的代码，如下：
    
 
@@ -235,14 +235,14 @@ 
    使用语法结构创建的对象
    使用语法结构创建的对象
 
 
    使用构造器创建的对象
    
@@ -289,7 +289,7 @@ 
    使用 Object.create
 
 var d = Object.create(null);
 // d ---> null
-console.log(d.hasOwnProperty); // undefined, 因为d没有继承Object.prototype
    
+console.log(d.hasOwnProperty); // undefined，因为 d 没有继承 Object.prototype
    
 
 
    使用 class 关键字创建的对象
    
 
@@ -377,7 +377,7 @@ 
    总结：4 个用于拓展
  console.log(inst.foo_prop);
  console.log(inst.bar_prop);
    
     
-    支持目前以及所有可想象到的浏览器(IE5.5都可以使用)。 这种方法非常快，非常符合标准，并且充分利用JIT优化。
+    支持目前以及所有可想象到的浏览器 (IE5.5 都可以使用)。 这种方法非常快，非常符合标准，并且充分利用 JIT 优化。
     为使用此方法，必须对相关函数初始化。 在初始化过程中，构造函数可以存储每个对象必须生成的唯一信息。但是，这种唯一信息只生成一次，可能会带来潜在的问题。此外，构造函数的初始化，可能会将不需要的方法放在对象上。然而，如果你只在自己的代码中使用，你也清楚（或有通过注释等写明）各段代码在做什么，这些在大体上都不是问题（事实上，通常是有益处的）。
    
    
@@ -460,7 +460,7 @@ 
    总结：4 个用于拓展
  console.log(inst.foo_prop);
  console.log(inst.bar_prop)
    
     
-    支持所有现代浏览器和微软IE9+浏览器。允许动态操作对象的原型，甚至能强制给通过 Object.create(null) 创建出来的没有原型的对象添加一个原型。
+    支持所有现代浏览器和微软 IE9+ 浏览器。允许动态操作对象的原型，甚至能强制给通过 Object.create(null) 创建出来的没有原型的对象添加一个原型。
     这个方式表现并不好，应该被弃用。如果你在生产环境中使用这个方法，那么快速运行 Javascript 就是不可能的，因为许多浏览器优化了原型，尝试在调用实例之前猜测方法在内存中的位置，但是动态设置原型干扰了所有的优化，甚至可能使浏览器为了运行成功，使用完全未经优化的代码进行重编译。 不支持 IE8 及以下的浏览器版本。
    
    
@@ -553,7 +553,7 @@ 
    示例
    
 既然它没有任何作用，干嘛不将 varA 从原型（prototype）去掉 ?
 也许作为一种在隐藏类中优化分配空间的考虑 ?
 https://developers.google.com/speed/articles/optimizing-javascript
-如果varA并不是在每个实例中都被初始化，那这样做将是有效果的。
+如果 varA 并不是在每个实例中都被初始化，那这样做将是有效果的。
 */
   doSomething : function(){
     // ...
diff --git a/files/zh-cn/web/javascript/javascript_technologies_overview/index.html b/files/zh-cn/web/javascript/javascript_technologies_overview/index.html
index 8de2f8ec2738e3..407d244e6a81b2 100644
--- a/files/zh-cn/web/javascript/javascript_technologies_overview/index.html
+++ b/files/zh-cn/web/javascript/javascript_technologies_overview/index.html
@@ -46,7 +46,7 @@ 
    未来
    
 
 
    The major 6th Edition of ECMAScript was officially approved and published as a standard on June 17, 2015 by the ECMA General Assembly. Since then ECMAScript Editions are published on a yearly basis.
    
 
-
    ECMA-262（ECMAScript 4 或者 ES4）第4版的提议本应成为自1999年第3版发布以来的一次重要更新，但是在2008年8月份，ECMAScript第4版被回退到一个代号为ECMAScript Harmony的项目，像const关键字以及对象代理等内容都被涵盖其中。你可以在这里跟踪这个项目的进展。ECMA 委员会已经在 2015年6月17号，正式发布了第6版标准。
    
+
    ECMA-262（ECMAScript 4 或者 ES4）第 4 版的提议本应成为自 1999 年第 3 版发布以来的一次重要更新，但是在 2008 年 8 月份，ECMAScript 第 4 版被回退到一个代号为ECMAScript Harmony的项目，像const关键字以及对象代理等内容都被涵盖其中。你可以在这里跟踪这个项目的进展。ECMA 委员会已经在 2015 年 6 月 17 号，正式发布了第 6 版标准。
    
 
 
    国际化 API
    
 
@@ -60,11 +60,11 @@ 
    WebIDL
    
 
 
    DOM 的核心
    
 
-
    文档对象模型（DOM）是用来表达 HTML、XHTML 及 XML 文档中的对象或与其进行交互的约定，它是跨平台的，并且与编程语言无关。通过调用DOM树上对象的方法可以操纵这些对象。文档对象模型核心是由  {{glossary("W3C")}} 进行标准化的，它将 HTML 和 XML 文档抽象成对象，并在其上定义接口以及操纵这些对象的机制，DOM 定义的元素有：
    
+
    文档对象模型（DOM）是用来表达 HTML、XHTML 及 XML 文档中的对象或与其进行交互的约定，它是跨平台的，并且与编程语言无关。通过调用DOM 树上对象的方法可以操纵这些对象。文档对象模型核心是由  {{glossary("W3C")}} 进行标准化的，它将 HTML 和 XML 文档抽象成对象，并在其上定义接口以及操纵这些对象的机制，DOM 定义的元素有：
    
 
 
 
@@ -74,9 +74,9 @@ 
    HTML DOM
    
 
 
    HTML，Web 的标记语言，是根据 DOM 定义的。位于 DOM 核心抽象概念之上，HTML 还定义了元素的意义。比如元素的 className 属性以及例如 {{domxref("document.body")}} 这样的 API。
    
 
-
    HTML规范同时还约束了元素之间的关系，例如无序列表 {{htmlelement("ul")}} 元素中，只能以 {{htmlelement("li")}} 元素作为子元素来表达列表项。还有就是禁止使用标准中未定义的元素和属性。
    
+
    HTML 规范同时还约束了元素之间的关系，例如无序列表 {{htmlelement("ul")}} 元素中，只能以 {{htmlelement("li")}} 元素作为子元素来表达列表项。还有就是禁止使用标准中未定义的元素和属性。
    
 
-
    想了解更多关于 {{domxref("Document")}} 对象、{{domxref("Window")}} 对象以及其他DOM元素的信息？请访问 MDN 的 DOM 文档。
    
+
    想了解更多关于 {{domxref("Document")}} 对象、{{domxref("Window")}} 对象以及其他 DOM 元素的信息？请访问 MDN 的 DOM 文档。
    
 
 
    其他值得关注的 API
    
 
@@ -91,6 +91,6 @@ 
    其他值得关注的 API
    
 
 
    DOM 浏览器支持
    
 
-
    相信每个 Web 开发人员都曾经有过“DOM就是一团糟”的体验，因为浏览器对 DOM 的支持千差万别。造成这种局面的主要原因是DOM 规范并未清晰定义很多重要的 DOM 特性。另外，一些浏览器也增加了不兼容的特性（例如 Intenet Explorer 的事件模型）。自 2011 年 6 月以来，W3C，特别是 WHATWG 都在对旧特性进行细节定义，以提高互通性。浏览器也在基于这些更加详细的规范改善它们的实现方式。
    
+
    相信每个 Web 开发人员都曾经有过“DOM 就是一团糟”的体验，因为浏览器对 DOM 的支持千差万别。造成这种局面的主要原因是 DOM 规范并未清晰定义很多重要的 DOM 特性。另外，一些浏览器也增加了不兼容的特性（例如 Intenet Explorer 的事件模型）。自 2011 年 6 月以来，W3C，特别是 WHATWG 都在对旧特性进行细节定义，以提高互通性。浏览器也在基于这些更加详细的规范改善它们的实现方式。
    
 
 
    要实现跨浏览器的兼容性，一个常见的但可能不是最可靠的方式就是使用 JavaScript 库。这些库对于 DOM 特性进行抽象，以确保它们所提供的 API 在不同的浏览器上行为一致。被广泛采用的框架有 jQuery，prototype 和 YUI。
    
diff --git a/files/zh-cn/web/javascript/language_resources/index.html b/files/zh-cn/web/javascript/language_resources/index.html
index 69b01b5fcd21e9..350c2f70ed7a76 100644
--- a/files/zh-cn/web/javascript/language_resources/index.html
+++ b/files/zh-cn/web/javascript/language_resources/index.html
@@ -1,5 +1,5 @@
 ---
-title: JavaScript资源
+title: JavaScript 资源
 slug: Web/JavaScript/Language_Resources
 tags:
   - JavaScript
@@ -7,7 +7,7 @@
 ---
 
    {{JsSidebar}}
    
 
-
    ECMAScript是形成JavaScript语言基础的脚本语言。ECMAScript是由Ecma国际标准组织以ECMA-262和ECMA-402规范的形式进行标准化的。下面的ECMAScript标准已经通过批准：
    
+
    ECMAScript是形成JavaScript语言基础的脚本语言。ECMAScript 是由Ecma 国际标准组织以ECMA-262 和 ECMA-402 规范的形式进行标准化的。下面的 ECMAScript 标准已经通过批准：
    
 
 
@@ -23,14 +23,14 @@
   
-   
+   
-   
-   
+   
+   
@@ -38,74 +38,74 @@
   
-   
-   
+   
+   
-   
-   
+   
+   
-   
-   
+   
-   
+   
+    也请查看ES5 errata和Mozilla 对 ECMAScript 5 的支持 
-   
+   
-   
+   
-   
+   
-   
-   
+   
+   
    
  
    
    ECMA-262 Edition 6
    PDF, HTML2015年6月2015 年 6 月
    ECMAScript 2015 (6th Edition)，最新发布的规范文档。
   
    
   
    
    ECMA-402 2.0
    PDF2015年6月ECMAScript国际化API 2.0。2015 年 6 月ECMAScript 国际化 API 2.0。
   
    
   
    
    过时/历史版本
    
    ECMA-262
    PDF1997年6月最初的ECMAScript标准。1997 年 6 月最初的 ECMAScript 标准。
   
    
   
    
    ECMA-262 Edition 2
    PDF1998年8月ECMAScript第二版规范；同时也是ISO 16262标准。1998 年 8 月ECMAScript 第二版规范；同时也是 ISO 16262 标准。
   
    
   
    
    ECMA-262 Edition 3
    PDF1999年12月ECMAScript第三版规范；对应于JavaScript 1.5.
    
+       		1999 年 12 月ECMAScript 第三版规范；对应于 JavaScript 1.5.
    
     也请查看errata    		
   
    
   
    
    ECMA-262 Edition 5
    PDF2009年12月2009 年 12 月
    ECMAScript 5
    
-    也请查看ES5 errata和Mozilla对ECMAScript 5的支持     		
   
    
   
    
    ECMA-357
    PDF2004年6月2004 年 6 月
    ECMAScript for XML (E4X).
    
     也请查看E4X errata.    		
   
    
   
    
    ECMA-357 Edition 2
    PDF2005年12月2005 年 12 月
    ECMAScript for XML (E4X).
   
    
   
    
    ECMA-262 Edition 5.1
    PDF, HTML2011年6月2011 年 6 月
    This version is fully aligned with 3rd edition of the international standard ISO/IEC 16262:2011.
    
     It includes ES5 errata fixes, no new features.    		
   
    
   
    
    ECMA-402 1.0
    PDF, HTML2012年12月ECMAScript国际化API 1.0。2012 年 12 月ECMAScript 国际化 API 1.0。
   
    
      
 
    
 
-
    查看wikipedia ECMAScript entry 了解更多关于ECMAScript历史的信息。
    
+
    查看wikipedia ECMAScript entry 了解更多关于 ECMAScript 历史的信息。
    
 
-
    你也可以通过ecmascript.org的公共wiki和es-discuss邮件列表参与或查看最新版本的规范制定工作，版本代号为"Harmony"。
    
+
    你也可以通过ecmascript.org的公共 wiki 和es-discuss 邮件列表参与或查看最新版本的规范制定工作，版本代号为"Harmony"。
    
 
 
    实现引擎
    
 
 
 
 
    相关链接
    
 
 
diff --git a/files/zh-cn/web/javascript/memory_management/index.html b/files/zh-cn/web/javascript/memory_management/index.html
index e7a4852337cc58..2e13721a9ffe70 100644
--- a/files/zh-cn/web/javascript/memory_management/index.html
+++ b/files/zh-cn/web/javascript/memory_management/index.html
@@ -11,7 +11,7 @@
 
 
    简介
    
 
-
    像C语言这样的底层语言一般都有底层的内存管理接口，比如 malloc()和free()。相反，JavaScript是在创建变量（对象，字符串等）时自动进行了分配内存，并且在不使用它们时“自动”释放。 释放的过程称为垃圾回收。这个“自动”是混乱的根源，并让JavaScript（和其他高级语言）开发者错误的感觉他们可以不关心内存管理。 
    
+
    像 C 语言这样的底层语言一般都有底层的内存管理接口，比如 malloc()和free()。相反，JavaScript 是在创建变量（对象，字符串等）时自动进行了分配内存，并且在不使用它们时“自动”释放。 释放的过程称为垃圾回收。这个“自动”是混乱的根源，并让 JavaScript（和其他高级语言）开发者错误的感觉他们可以不关心内存管理。 
    
 
 
    内存生命周期
    
 
@@ -23,7 +23,7 @@ 
    内存生命周期
    
  
  • 不需要时将其释放\归还
    • 
 
 
-
    所有语言第二部分都是明确的。第一和第三部分在底层语言中是明确的，但在像JavaScript这些高级语言中，大部分都是隐含的。
    
+
    所有语言第二部分都是明确的。第一和第三部分在底层语言中是明确的，但在像 JavaScript 这些高级语言中，大部分都是隐含的。
    
 
 
    JavaScript 的内存分配
    
 
@@ -91,7 +91,7 @@ 
    垃圾回收
    
 
 
    引用
    
 
-
    垃圾回收算法主要依赖于引用的概念。在内存管理的环境中，一个对象如果有访问另一个对象的权限（隐式或者显式），叫做一个对象引用另一个对象。例如，一个Javascript对象具有对它原型的引用（隐式引用）和对它属性的引用（显式引用）。
    
+
    垃圾回收算法主要依赖于引用的概念。在内存管理的环境中，一个对象如果有访问另一个对象的权限（隐式或者显式），叫做一个对象引用另一个对象。例如，一个 Javascript 对象具有对它原型的引用（隐式引用）和对它属性的引用（显式引用）。
    
 
 
    在这里，“对象”的概念不仅特指 JavaScript 对象，还包括函数作用域（或者全局词法作用域）。
    
 
@@ -106,21 +106,21 @@ 
    示例
    
     b:2
   }
 };
-// 两个对象被创建，一个作为另一个的属性被引用，另一个被分配给变量o
+// 两个对象被创建，一个作为另一个的属性被引用，另一个被分配给变量 o
 // 很显然，没有一个可以被垃圾收集
 
 
-var o2 = o; // o2变量是第二个对“这个对象”的引用
+var o2 = o; // o2 变量是第二个对“这个对象”的引用
 
-o = 1;      // 现在，“这个对象”只有一个o2变量的引用了，“这个对象”的原始引用o已经没有
+o = 1;      // 现在，“这个对象”只有一个 o2 变量的引用了，“这个对象”的原始引用 o 已经没有
 
-var oa = o2.a; // 引用“这个对象”的a属性
-               // 现在，“这个对象”有两个引用了，一个是o2，一个是oa
+var oa = o2.a; // 引用“这个对象”的 a 属性
+               // 现在，“这个对象”有两个引用了，一个是 o2，一个是 oa
 
 o2 = "yo"; // 虽然最初的对象现在已经是零引用了，可以被垃圾回收了
-           // 但是它的属性a的对象还在被oa引用，所以还不能回收
+           // 但是它的属性 a 的对象还在被 oa 引用，所以还不能回收
 
-oa = null; // a属性的那个对象现在也是零引用了
+oa = null; // a 属性的那个对象现在也是零引用了
            // 它可以被垃圾回收了
 
    
 
@@ -152,23 +152,23 @@ 
    实际例子
    
 };
    -

    在上面的例子里，myDivElement 这个 DOM 元素里的 circularReference 属性引用了 myDivElement，造成了循环引用。如果该属性没有显示移除或者设为 null，引用计数式垃圾收集器将总是且至少有一个引用，并将一直保持在内存里的 DOM 元素，即使其从DOM 树中删去了。如果这个 DOM 元素拥有大量的数据 (如上的 lotsOfData 属性)，而这个数据占用的内存将永远不会被释放。

    +

    在上面的例子里，myDivElement 这个 DOM 元素里的 circularReference 属性引用了 myDivElement，造成了循环引用。如果该属性没有显示移除或者设为 null，引用计数式垃圾收集器将总是且至少有一个引用，并将一直保持在内存里的 DOM 元素，即使其从 DOM 树中删去了。如果这个 DOM 元素拥有大量的数据 (如上的 lotsOfData 属性)，而这个数据占用的内存将永远不会被释放。

    -

    标记-清除算法

    +

    标记 - 清除算法

    这个算法把“对象是否不再需要”简化定义为“对象是否可以获得”。

    -

    这个算法假定设置一个叫做根（root）的对象（在Javascript里，根是全局对象）。垃圾回收器将定期从根开始，找所有从根开始引用的对象，然后找这些对象引用的对象……从根开始，垃圾回收器将找到所有可以获得的对象和收集所有不能获得的对象。

    +

    这个算法假定设置一个叫做根（root）的对象（在 Javascript 里，根是全局对象）。垃圾回收器将定期从根开始，找所有从根开始引用的对象，然后找这些对象引用的对象……从根开始，垃圾回收器将找到所有可以获得的对象和收集所有不能获得的对象。

    这个算法比前一个要好，因为“有零引用的对象”总是不可获得的，但是相反却不一定，参考“循环引用”。

    -

    从2012年起，所有现代浏览器都使用了标记-清除垃圾回收算法。所有对JavaScript垃圾回收算法的改进都是基于标记-清除算法的改进，并没有改进标记-清除算法本身和它对“对象是否不再需要”的简化定义。

    +

    从 2012 年起，所有现代浏览器都使用了标记 - 清除垃圾回收算法。所有对 JavaScript 垃圾回收算法的改进都是基于标记 - 清除算法的改进，并没有改进标记 - 清除算法本身和它对“对象是否不再需要”的简化定义。

    循环引用不再是问题了

    在上面的示例中，函数调用返回之后，两个对象从全局对象出发无法获取。因此，他们将会被垃圾回收器回收。第二个示例同样，一旦 div 和其事件处理无法从根获取到，他们将会被垃圾回收器回收。
    -

    限制: 那些无法从根对象查询到的对象都将被清除

    +

    限制：那些无法从根对象查询到的对象都将被清除

    尽管这是一个限制，但实践中我们很少会碰到类似的情况，所以开发者不太会去关心垃圾回收机制。

    diff --git a/files/zh-cn/web/javascript/shells/index.html b/files/zh-cn/web/javascript/shells/index.html index a78e8f2f090dfe..1df8d74eff6cfc 100644 --- a/files/zh-cn/web/javascript/shells/index.html +++ b/files/zh-cn/web/javascript/shells/index.html @@ -1,5 +1,5 @@ --- -title: JavaScript shells编程环境 +title: JavaScript shells 编程环境 slug: Web/JavaScript/Shells tags: - JavaScript @@ -20,16 +20,16 @@

    独立的 JavaScript shells

    JavaScript shells 列表

    -

    下面的 JavaScript shells 可以与Mozilla 一起工作。

    +

    下面的 JavaScript shells 可以与 Mozilla 一起工作。