From 1e3535e30f60a4eae5856c977508fcef9ed57816 Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Sat, 28 May 2022 15:41:34 +0800 Subject: [PATCH] AutoCorrect files/zh-cn/web/javascript/guide --- .../index.html | 48 ++-- .../details_of_the_object_model/index.html | 24 +- .../expressions_and_operators/index.html | 226 +++++++++--------- .../web/javascript/guide/functions/index.html | 84 +++---- .../guide/grammar_and_types/index.html | 138 +++++------ .../guide/indexed_collections/index.html | 116 ++++----- .../javascript/guide/introduction/index.html | 40 ++-- .../guide/iterators_and_generators/index.html | 14 +- .../guide/keyed_collections/index.html | 10 +- .../guide/loops_and_iteration/index.html | 14 +- .../guide/meta_programming/index.html | 2 +- .../web/javascript/guide/modules/index.html | 8 +- .../guide/numbers_and_dates/index.html | 116 ++++----- .../regular_expressions/assertions/index.html | 36 +-- .../character_classes/index.html | 16 +- .../groups_and_ranges/index.html | 26 +- .../guide/regular_expressions/index.html | 100 ++++---- .../quantifiers/index.html | 16 +- .../unicode_property_escapes/index.html | 32 +-- .../guide/text_formatting/index.html | 76 +++--- .../guide/using_promises/index.html | 8 +- .../guide/working_with_objects/index.html | 58 ++--- 22 files changed, 604 insertions(+), 604 deletions(-) diff --git a/files/zh-cn/web/javascript/guide/control_flow_and_error_handling/index.html b/files/zh-cn/web/javascript/guide/control_flow_and_error_handling/index.html index 113730b057b37b..e4a4fa0f97de81 100644 --- a/files/zh-cn/web/javascript/guide/control_flow_and_error_handling/index.html +++ b/files/zh-cn/web/javascript/guide/control_flow_and_error_handling/index.html @@ -7,11 +7,11 @@ ---

{{jsSidebar("JavaScript Guide")}}{{PreviousNext("Web/JavaScript/Guide/Grammar_and_Types", "Web/JavaScript/Guide/Loops_and_iteration")}}

-

JavaScript 提供一套灵活的语句集，特别是控制流语句，你可以用它在你的应用程序中实现大量的交互性功能。本章节我们将带来关于JavaScript语句的一些概览。

+

JavaScript 提供一套灵活的语句集，特别是控制流语句，你可以用它在你的应用程序中实现大量的交互性功能。本章节我们将带来关于 JavaScript 语句的一些概览。

-

 这一章中的语句，在 JavaScript参考 中包含更为详尽的细节。在 JavaScript 代码中，分号（;）字符被用来分割语句。

+

 这一章中的语句，在 JavaScript 参考 中包含更为详尽的细节。在 JavaScript 代码中，分号（;）字符被用来分割语句。

-

在JavaScript中，任何表达式(expression)都可以看作一条语句(statement),如果你想了解表达式的详细信息，可以阅读表达式与运算符（Expressions and operators）这一章节。

+

在 JavaScript 中，任何表达式 (expression) 都可以看作一条语句 (statement),如果你想了解表达式的详细信息，可以阅读表达式与运算符（Expressions and operators）这一章节。

语句块

@@ -38,7 +38,7 @@

示例

这里{ x++; }就是语句块。

-

重要：在ECMAScript 6标准之前，Javascript没有块作用域。在一个块中引入的变量的作用域是包含函数或脚本，并且设置它们的效果会延续到块之外。换句话说，块语句不定义范围。JavaScript中的“独立”块会产生与C或Java中完全不同的结果。示例：

+

重要：在 ECMAScript 6 标准之前，Javascript 没有块作用域。在一个块中引入的变量的作用域是包含函数或脚本，并且设置它们的效果会延续到块之外。换句话说，块语句不定义范围。JavaScript 中的“独立”块会产生与 C 或 Java 中完全不同的结果。示例：

var x = 1;
@@ -48,7 +48,7 @@ 
示例

 alert(x); // 输出的结果为 2
-

这段代码的输出是2，这是因为块级作用域中的 var x变量声明与之前的声明在同一个作用域内。在C语言或是Java语言中，同样的代码输出的结果是1。

+

这段代码的输出是2，这是因为块级作用域中的 var x 变量声明与之前的声明在同一个作用域内。在 C 语言或是 Java 语言中，同样的代码输出的结果是 1。

从 ECMAScript 2015 开始，使用 let 和const变量是块作用域的。 更多信息请参考 {{jsxref("Statements/let", "let")}} 和 {{jsxref("Statements/const", "const")}}。

@@ -58,18 +58,18 @@

条件判断语句

if...else 语句

-

当一个逻辑条件为真，用if语句执行一个语句。当这个条件为假，使用可选择的 else 从句来执行这个语句。if 语句如下所示：

+

当一个逻辑条件为真，用 if 语句执行一个语句。当这个条件为假，使用可选择的 else 从句来执行这个语句。if 语句如下所示：

if (condition) {
   statement_1;
 }else {
   statement_2;
-} //推荐使用严格的语句块模式，语句else可选
+} //推荐使用严格的语句块模式，语句 else 可选
-

条件可以是任何返回结果被计算为true 或 false的表达式。如果条件表达式返回的是 true，statement_1 语句会被执行；否则，statement_2 被执行。statement_1 和 statement_2 可以是任何语句，甚至你可以将另一个if语句嵌套其中。 

+

条件可以是任何返回结果被计算为 true 或 false 的表达式。如果条件表达式返回的是 true，statement_1 语句会被执行；否则，statement_2 被执行。statement_1 和 statement_2 可以是任何语句，甚至你可以将另一个 if 语句嵌套其中。 

-

你也可以组合语句通过使用 else if 来测试连续多种条件判断，就像下面一样:

+

你也可以组合语句通过使用 else if 来测试连续多种条件判断，就像下面一样：

if (condition_1) {
   statement_1;
@@ -82,14 +82,14 @@ 
if...else 语句

 }
-

要执行多个语句，可以使用语句块({ ... }) 来分组这些语句。通常，总是使用语句块是一个好的习惯，特别是在代码涉及比较多的 if 语句时:

+

要执行多个语句，可以使用语句块 ({ ... }) 来分组这些语句。通常，总是使用语句块是一个好的习惯，特别是在代码涉及比较多的 if 语句时：

if (条件) {
-  当条件为真的时候，执行语句1;
-  当条件为真的时候，执行语句2;
+  当条件为真的时候，执行语句 1;
+  当条件为真的时候，执行语句 2;
 } else {
-  当条件为假的时候，执行语句3;
-  当条件为假的时候，执行语句4;
+  当条件为假的时候，执行语句 3;
+  当条件为假的时候，执行语句 4;
 }
@@ -137,7 +137,7 @@

错误的值

示例

-

在以下示例中，如果Text对象中的字符数为3，函数checkData将返回true；否则，显示警报并返回false。

+

在以下示例中，如果Text对象中的字符数为 3，函数checkData将返回true；否则，显示警报并返回false。

function checkData() {
   if (document.form1.threeChar.value.length == 3) {
@@ -168,12 +168,12 @@ 
switch 语句

 }
-

程序首先查找一个与 expression 匹配的 case 语句，然后将控制权转移到该子句，执行相关的语句。如果没有匹配值， 程序会去找 default 语句，如果找到了，控制权转移到该子句，执行相关的语句。如果没有找到 default，程序会继续执行 switch 语句后面的语句。default 语句通常出现在switch语句里的最后面，当然这不是必须的。

+

程序首先查找一个与 expression 匹配的 case 语句，然后将控制权转移到该子句，执行相关的语句。如果没有匹配值， 程序会去找 default 语句，如果找到了，控制权转移到该子句，执行相关的语句。如果没有找到 default，程序会继续执行 switch 语句后面的语句。default 语句通常出现在 switch 语句里的最后面，当然这不是必须的。

-

可选的 break 语句与每个 case 语句相关联， 保证在匹配的语句被执行后程序可以跳出 switch 并且继续执行 switch 后面的语句。如果break被忽略，则程序将继续执行switch语句中的下一条语句。

+

可选的 break 语句与每个 case 语句相关联， 保证在匹配的语句被执行后程序可以跳出 switch 并且继续执行 switch 后面的语句。如果 break 被忽略，则程序将继续执行 switch 语句中的下一条语句。

示例
- 在如下示例中, 如果 fruittype 等于 "Bananas", 程序匹配到对应 "Bananas" 的case 语句，并执行相关语句。 当执行到 break 时，程序结束了 switch 并执行 switch 后面的语句。 如果不写 break ，那么程序将会执行 case "Cherries" 下的语句。

+ 在如下示例中，如果 fruittype 等于 "Bananas", 程序匹配到对应 "Bananas" 的case 语句，并执行相关语句。 当执行到 break 时，程序结束了 switch 并执行 switch 后面的语句。 如果不写 break ，那么程序将会执行 case "Cherries" 下的语句。

switch (fruittype) {
    case "Oranges":
@@ -233,7 +233,7 @@ 
throw 语句
-

备注：你可以在抛出异常时声明一个对象。那你就可以在catch块中查询到对象的属性。

+

备注：你可以在抛出异常时声明一个对象。那你就可以在 catch 块中查询到对象的属性。

// Create an object type UserException
@@ -255,7 +255,7 @@ 
try...catch 语句

 
 
try...catch 语句标记一块待尝试的语句，并规定一个以上的响应应该有一个异常被抛出。如果我们抛出一个异常，try...catch语句就捕获它。

 
-
try...catch 语句有一个包含一条或者多条语句的try代码块，0个或1个的catch代码块，catch代码块中的语句会在try代码块中抛出异常时执行。 换句话说，如果你在try代码块中的代码如果没有执行成功，那么你希望将执行流程转入catch代码块。如果try代码块中的语句（或者try 代码块中调用的方法）一旦抛出了异常，那么执行流程会立即进入catch 代码块。如果try代码块没有抛出异常，catch代码块就会被跳过。finally 代码块总会紧跟在try和catch代码块之后执行，但会在try和catch代码块之后的其他代码之前执行。

+
try...catch 语句有一个包含一条或者多条语句的 try 代码块，0 个或 1 个的catch代码块，catch 代码块中的语句会在 try 代码块中抛出异常时执行。 换句话说，如果你在 try 代码块中的代码如果没有执行成功，那么你希望将执行流程转入 catch 代码块。如果 try 代码块中的语句（或者try 代码块中调用的方法）一旦抛出了异常，那么执行流程会立即进入catch 代码块。如果 try 代码块没有抛出异常，catch 代码块就会被跳过。finally 代码块总会紧跟在 try 和 catch 代码块之后执行，但会在 try 和 catch 代码块之后的其他代码之前执行。

 
 
下面的例子使用了try...catch语句。示例调用了一个函数用于从一个数组中根据传递值来获取一个月份名称。如果该值与月份数值不相符，会抛出一个带有"InvalidMonthNo"值的异常，然后在捕捉块语句中设monthName变量为unknown。

 
@@ -287,7 +287,7 @@ 
catch 块

 }
-

捕捉块指定了一个标识符（上述语句中的catchID）来存放抛出语句指定的值；你可以用这个标识符来获取抛出的异常信息。在插入throw块时JavaScript创建这个标识符；标识符只存在于catch块的存续期间里；当catch块执行完成时，标识符不再可用。

+

捕捉块指定了一个标识符（上述语句中的catchID）来存放抛出语句指定的值；你可以用这个标识符来获取抛出的异常信息。在插入throw块时 JavaScript 创建这个标识符；标识符只存在于catch块的存续期间里；当catch块执行完成时，标识符不再可用。

举个例子，下面代码抛出了一个异常。当异常出现时跳到catch块。

@@ -302,9 +302,9 @@

catch 块

finally块

-

finally块包含了在try和catch块完成后、下面接着try...catch的语句之前执行的语句。finally块无论是否抛出异常都会执行。如果抛出了一个异常，就算没有异常处理，finally块里的语句也会执行。

+

finally块包含了在 try 和 catch 块完成后、下面接着 try...catch 的语句之前执行的语句。finally块无论是否抛出异常都会执行。如果抛出了一个异常，就算没有异常处理，finally块里的语句也会执行。

-

你可以用finally块来令你的脚本在异常发生时优雅地退出；举个例子，你可能需要在绑定的脚本中释放资源。接下来的例子用文件处理语句打开了一个文件（服务端的JavaScript允许你进入文件）。如果在文件打开时一个异常抛出，finally块会在脚本错误之前关闭文件。

+

你可以用finally块来令你的脚本在异常发生时优雅地退出；举个例子，你可能需要在绑定的脚本中释放资源。接下来的例子用文件处理语句打开了一个文件（服务端的 JavaScript 允许你进入文件）。如果在文件打开时一个异常抛出，finally块会在脚本错误之前关闭文件。

openMyFile();
 try {
@@ -369,7 +369,7 @@ 
finally块

 
 
嵌套 try...catch 语句

 
-
你可以嵌套一个或多个try ... catch语句。如果一个内部try ... catch语句没有catch块，它需要有一个finally块，并且封闭的try ... catch语句的catch块被检查匹配。有关更多信息，请参阅try... catch参考页上的嵌套try-blocks。

+
你可以嵌套一个或多个try ... catch语句。如果一个内部try ... catch语句没有catch块，它需要有一个finally块，并且封闭的try ... catch语句的catch块被检查匹配。有关更多信息，请参阅try... catch参考页上的嵌套 try-blocks。

 
 
使用Error对象

 
diff --git a/files/zh-cn/web/javascript/guide/details_of_the_object_model/index.html b/files/zh-cn/web/javascript/guide/details_of_the_object_model/index.html
index 1173eedee118de..9926984acef377 100644
--- a/files/zh-cn/web/javascript/guide/details_of_the_object_model/index.html
+++ b/files/zh-cn/web/javascript/guide/details_of_the_object_model/index.html
@@ -10,7 +10,7 @@
 ---
 
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Using_promises")}}

 
-
JavaScript 是一种基于原型而不是基于类的基于对象(object-based)语言。正是由于这一根本的区别，其如何创建对象的层级结构以及对象的属性与属性值是如何继承的并不是那么清晰。本节试着阐明。

+
JavaScript 是一种基于原型而不是基于类的基于对象 (object-based) 语言。正是由于这一根本的区别，其如何创建对象的层级结构以及对象的属性与属性值是如何继承的并不是那么清晰。本节试着阐明。

 
 
本节假设您已经有一些 JavaScript 基础，并且用 JavaScript 函数创建过简单的对象。

 
@@ -19,27 +19,27 @@ 
基于类 vs 基于原型的
 
基于类的面向对象语言，比如 Java 和 C++，是构建在两个不同实体之上的：类和实例。

 
 
    
- 
  • 一个类(class)定义了某一对象集合所具有的特征性属性（可以将 Java 中的方法和域以及 C++ 中的成员都视作属性）。类是抽象的，而不是其所描述的对象集合中的任何特定的个体。例如 Employee 类可以用来表示所有雇员的集合。
    • 
- 
  • 另一方面，一个实例(instance)是一个类的实例化。例如， Victoria 可以是 Employee 类的一个实例，表示一个特定的雇员个体。实例具有和其父类完全一致的属性，不多也不少。
    • 
+ 
  • 一个类 (class)定义了某一对象集合所具有的特征性属性（可以将 Java 中的方法和域以及 C++ 中的成员都视作属性）。类是抽象的，而不是其所描述的对象集合中的任何特定的个体。例如 Employee 类可以用来表示所有雇员的集合。
    • 
+ 
  • 另一方面，一个实例 (instance)是一个类的实例化。例如， Victoria 可以是 Employee 类的一个实例，表示一个特定的雇员个体。实例具有和其父类完全一致的属性，不多也不少。
    • 
 

 
-
基于原型的语言（如 JavaScript）并不存在这种区别：它只有对象。基于原型的语言具有所谓原型对象(prototypical object)的概念。原型对象可以作为一个模板，新对象可以从中获得原始的属性。任何对象都可以指定其自身的属性，既可以是创建时也可以在运行时创建。而且，任何对象都可以作为另一个对象的原型(prototype)，从而允许后者共享前者的属性。

+
基于原型的语言（如 JavaScript）并不存在这种区别：它只有对象。基于原型的语言具有所谓原型对象 (prototypical object)的概念。原型对象可以作为一个模板，新对象可以从中获得原始的属性。任何对象都可以指定其自身的属性，既可以是创建时也可以在运行时创建。而且，任何对象都可以作为另一个对象的原型 (prototype)，从而允许后者共享前者的属性。

 
 
定义类

 
-
在基于类的语言中，需要专门的类定义(class definition)来定义类。在定义类时，允许定义被称为构造器(constructor)的特殊的方法来创建该类的实例。在构造器方法中，可以指定实例的属性的初始值并做一些其他的操作。你可以通过使用 new 操作符来创建类的实例。

+
在基于类的语言中，需要专门的类定义 (class definition)来定义类。在定义类时，允许定义被称为构造器 (constructor)的特殊的方法来创建该类的实例。在构造器方法中，可以指定实例的属性的初始值并做一些其他的操作。你可以通过使用 new 操作符来创建类的实例。

 
-
JavaScript 大体上与之类似，但并没有专门的类定义，你通过定义构造函数的方式来创建一系列有着特定初始值和方法的对象。任何JavaScript函数都可以被用作构造函数。你也可以使用 new 操作符来创建一个新对象。

+
JavaScript 大体上与之类似，但并没有专门的类定义，你通过定义构造函数的方式来创建一系列有着特定初始值和方法的对象。任何 JavaScript 函数都可以被用作构造函数。你也可以使用 new 操作符来创建一个新对象。

 
 

-
备注：在ES6中引入了 类定义 ，但它实际上是已有的原型继承方式的语法糖而已，并没有引入新的面向对象继承模型。

+
备注：在 ES6 中引入了 类定义 ，但它实际上是已有的原型继承方式的语法糖而已，并没有引入新的面向对象继承模型。

 

 
 
子类和继承

 
 
基于类的语言是通过对类的定义中构建类的层级结构的。在类定义中，可以指定新的类是一个现存的类的子类。子类将继承父类的全部属性，并可以添加新的属性或者修改继承的属性。例如，假设 Employee 类只有 name 和 dept 属性，而 Manager 是 Employee 的子类并添加了 reports 属性。这时，Manager 类的实例将具有所有三个属性：name，dept和reports。

 
-
JavaScript 通过将构造器函数与原型对象相关联的方式来实现继承。这样，您可以创建完全一样的 Employee — Manager 示例，不过需要使用略微不同的术语。首先，定义Employee构造函数，在该构造函数内定义name、dept属性；接下来，定义Manager构造函数，在该构造函数内调用Employee构造函数，并定义reports属性；最后，将一个获得了Employee.prototype(Employee构造函数原型)的新对象赋予manager构造函数，以作为Manager构造函数的原型。之后当你创建新的Manager对象实例时，该实例会从Employee对象继承name、dept属性。

+
JavaScript 通过将构造器函数与原型对象相关联的方式来实现继承。这样，您可以创建完全一样的 Employee — Manager 示例，不过需要使用略微不同的术语。首先，定义 Employee 构造函数，在该构造函数内定义 name、dept 属性；接下来，定义 Manager 构造函数，在该构造函数内调用 Employee 构造函数，并定义 reports 属性；最后，将一个获得了 Employee.prototype(Employee 构造函数原型) 的新对象赋予 manager 构造函数，以作为 Manager 构造函数的原型。之后当你创建新的 Manager 对象实例时，该实例会从 Employee 对象继承 name、dept 属性。

 
 
添加和移除属性

 
@@ -109,7 +109,7 @@ 
创建层级结构

 
 
在实际应用程序中，您很可能想定义构造器，以允许您在创建对象时指定属性值。（参见More flexible constructors）。当前，这些简单的定义只是说明了继承是如何实现的。

 
-
下面关于 Employee 的 Java 和 JavaScript 的定义是非常类似的。唯一的不同是在 Java 中需要指定每个属性的类型，而在 JavaScript 中则不需要（这是因为Java是 强类型 语言，而 JavaScript 是弱类型语言）。

+
下面关于 Employee 的 Java 和 JavaScript 的定义是非常类似的。唯一的不同是在 Java 中需要指定每个属性的类型，而在 JavaScript 中则不需要（这是因为 Java 是 强类型 语言，而 JavaScript 是弱类型语言）。

 
 
@@ -139,7 +139,7 @@ 
创建层级结构

  
  
 

 
-
Manager 和 WorkerBee 的定义表示在如何指定继承链中上一层对象时，两者存在不同点。在 JavaScript 中，您会添加一个原型实例作为构造器函数prototype 属性的值，然后将该构造函数原型的构造器重载为其自身。这一动作可以在构造器函数定义后的任意时刻执行。而在 Java 中，则需要在类定义中指定父类，且不能在类定义之外改变父类。

+
Manager 和 WorkerBee 的定义表示在如何指定继承链中上一层对象时，两者存在不同点。在 JavaScript 中，您会添加一个原型实例作为构造器函数 prototype 属性的值，然后将该构造函数原型的构造器重载为其自身。这一动作可以在构造器函数定义后的任意时刻执行。而在 Java 中，则需要在类定义中指定父类，且不能在类定义之外改变父类。

 
 
@@ -227,7 +227,7 @@ 
创建层级结构
使用这些定义，您可以创建这些对象的实例，以获取其属性的默认值。下图说明了如何使用这些 JavaScript 定义创建新对象并显示新对象的属性值。

-
备注：实例在基于类的语言中具有特定的技术含义。在这些语言中，一个实例是一个类的单独实例化，与一个类本质上是不同的。在 JavaScript 中，“实例”没有这个技术含义，因为JavaScript在类和实例之间不存在这样的区别。然而，在讨论 JavaScript 时，可以非正式地使用“实例”来表示使用特定构造函数创建的对象。 所以，在这个例子中，你可以非正式地说jane 是 Engineer的一个实例。同样，虽然术语 parent，child，ancestor 和 descendant 在 JavaScript 中没有正式含义；你可以非正式地使用它们来引用原型链中较高或更低的对象。

+
备注：实例在基于类的语言中具有特定的技术含义。在这些语言中，一个实例是一个类的单独实例化，与一个类本质上是不同的。在 JavaScript 中，“实例”没有这个技术含义，因为 JavaScript 在类和实例之间不存在这样的区别。然而，在讨论 JavaScript 时，可以非正式地使用“实例”来表示使用特定构造函数创建的对象。 所以，在这个例子中，你可以非正式地说jane 是 Engineer的一个实例。同样，虽然术语 parent，child，ancestor 和 descendant 在 JavaScript 中没有正式含义；你可以非正式地使用它们来引用原型链中较高或更低的对象。

 
用简单的定义创建对象

@@ -279,7 +279,7 @@ 
继承属性
当 JavaScript 执行 new 操作符时，它会先创建一个普通对象，并将这个普通对象中的 [[prototype]] 指向 WorkerBee.prototype ，然后再把这个普通对象设置为执行 WorkerBee 构造函数时 this  的值。该普通对象的 [[Prototype]] 决定其用于检索属性的原型链。当构造函数执行完成后，所有的属性都被设置完毕，JavaScript 返回之前创建的对象，通过赋值语句将它的引用赋值给变量 mark。

 
-
这个过程不会显式的将 mark所继承的原型链中的属性作为本地属性存放在 mark 对象中。当访问属性时，JavaScript 将首先检查对象自身中是否存在该属性，如果有，则返回该属性的值。如果不存在，JavaScript会检查原型链（使用内置的 [[Prototype]] ）。如果原型链中的某个对象包含该属性，则返回这个属性的值。如果遍历整条原型链都没有找到该属性，JavaScript 则认为对象中不存在该属性，返回一个 undefined。这样，mark 对象中将具有如下的属性和对应的值：

+
这个过程不会显式的将 mark所继承的原型链中的属性作为本地属性存放在 mark 对象中。当访问属性时，JavaScript 将首先检查对象自身中是否存在该属性，如果有，则返回该属性的值。如果不存在，JavaScript 会检查原型链（使用内置的 [[Prototype]] ）。如果原型链中的某个对象包含该属性，则返回这个属性的值。如果遍历整条原型链都没有找到该属性，JavaScript 则认为对象中不存在该属性，返回一个 undefined。这样，mark 对象中将具有如下的属性和对应的值：
mark.name = "";
 mark.dept = "general";
diff --git a/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html b/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html
index 20ac54e8b835c0..a3cd4894aba997 100644
--- a/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html
+++ b/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html
@@ -19,24 +19,24 @@ 
运算符

 
JavaScript 拥有如下类型的运算符。本节描述了运算符和运算符的优先级。

 
 
    
- 
  • {{ web.link("#赋值运算符", "赋值运算符(Assignment operators)") }}
    • 
- 
  • {{ web.link("#比较运算符", "比较运算符(Comparison operators)") }}
    • 
- 
  • {{ web.link("#算术运算符", "算数运算符(Arithmetic operators)") }}
    • 
- 
  • {{ web.link("#位运算符", "位运算符(Bitwise operators)") }}
    • 
- 
  • {{ web.link("#逻辑运算符", "逻辑运算符(Logical operators)") }}
    • 
- 
  • {{ web.link("#字符串运算符", "字符串运算符(String operators)") }}
    • 
- 
  • {{ web.link("#conditional_operator", "条件（三元）运算符(Conditional operator)")}}
    • 
- 
  • {{ web.link("#comma_operator", "逗号运算符(Comma operator)")}}
    • 
- 
  • {{ web.link("#delete", "一元运算符(Unary operators)")}}
    • 
- 
  • {{ web.link("#关系操作符", "关系运算符(Relational operator)")}}
    • 
+ 
  • {{ web.link("#赋值运算符", "赋值运算符 (Assignment operators)") }}
    • 
+ 
  • {{ web.link("#比较运算符", "比较运算符 (Comparison operators)") }}
    • 
+ 
  • {{ web.link("#算术运算符", "算数运算符 (Arithmetic operators)") }}
    • 
+ 
  • {{ web.link("#位运算符", "位运算符 (Bitwise operators)") }}
    • 
+ 
  • {{ web.link("#逻辑运算符", "逻辑运算符 (Logical operators)") }}
    • 
+ 
  • {{ web.link("#字符串运算符", "字符串运算符 (String operators)") }}
    • 
+ 
  • {{ web.link("#conditional_operator", "条件（三元）运算符 (Conditional operator)")}}
    • 
+ 
  • {{ web.link("#comma_operator", "逗号运算符 (Comma operator)")}}
    • 
+ 
  • {{ web.link("#delete", "一元运算符 (Unary operators)")}}
    • 
+ 
  • {{ web.link("#关系操作符", "关系运算符 (Relational operator)")}}
    • 
 

 
 
JavaScript 拥有二元和一元运算符， 和一个特殊的三元运算符（条件运算符）。一个二元运算符需要两个操作数，分别在运算符的前面和后面：

 
-
操作数1 运算符 操作数2
+
操作数 1 运算符 操作数 2
 

 
-
例如, 3+4 或 x*y。

+
例如，3+4 或 x*y。

 
 
一个一元运算符需要一个操作数，在运算符前面或后面：

 
@@ -46,11 +46,11 @@ 
运算符

 
 
操作数 运算符

 
-
例如, x++ 或 ++x。

+
例如，x++ 或 ++x。

 
 
赋值运算符

 
-
一个 赋值运算符(assignment operator) 将它右边操作数的值赋给它左边的操作数。最简单的赋值运算符是等于（=），它将右边的操作数值赋给左边的操作数。那么 x = y 就是将 y 的值赋给 x。

+
一个 赋值运算符 (assignment operator) 将它右边操作数的值赋给它左边的操作数。最简单的赋值运算符是等于（=），它将右边的操作数值赋给左边的操作数。那么 x = y 就是将 y 的值赋给 x。

 
 
还有一些复合赋值操作符，它们是下表列出的这些操作的缩写：

 
@@ -65,67 +65,67 @@ 
赋值运算符

  

-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
@@ -148,7 +148,7 @@ 
解构
比较运算符

 
-
比较运算符比较它的操作数并返回一个基于表达式是否为真的逻辑值。操作数可以是数字，字符串，逻辑，对象值。字符串比较是基于标准的字典顺序，使用Unicode值。在多数情况下，如果两个操作数不是相同的类型， JavaScript 会尝试转换它们为恰当的类型来比较。这种行为通常发生在数字作为操作数的比较。类型转换的例外是使用 === 和 !== 操作符，它们会执行严格的相等和不相等比较。这些运算符不会在检查相等之前转换操作数的类型。下面的表格描述了该示例代码中的各比较运算符

+
比较运算符比较它的操作数并返回一个基于表达式是否为真的逻辑值。操作数可以是数字，字符串，逻辑，对象值。字符串比较是基于标准的字典顺序，使用 Unicode 值。在多数情况下，如果两个操作数不是相同的类型， JavaScript 会尝试转换它们为恰当的类型来比较。这种行为通常发生在数字作为操作数的比较。类型转换的例外是使用 === 和 !== 操作符，它们会执行严格的相等和不相等比较。这些运算符不会在检查相等之前转换操作数的类型。下面的表格描述了该示例代码中的各比较运算符
var var1 = 3;
 var var2 = 4;

@@ -159,14 +159,14 @@ 
比较运算符

-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
-   
+   
@@ -217,18 +217,18 @@ 
比较运算符

  
 
 
 
 
 
 
 
 
 
  
   
赋值(Assignment)赋值 (Assignment)
    x = y
    x = y
   

   
加法赋值(Addition assignment)加法赋值 (Addition assignment)
    x += y
    x = x + y
   

   
减法赋值(Subtraction assignment)减法赋值 (Subtraction assignment)
    x -= y
    x = x - y
   

   
乘法赋值(Multiplication assignment)乘法赋值 (Multiplication assignment)
    x *= y
    x = x * y
   

   
除法赋值(Division assignment)除法赋值 (Division assignment)
    x /= y
    x = x / y
   

   
求余赋值(Remainder assignment)求余赋值 (Remainder assignment)
    x %= y
    x = x % y
   

   
求幂赋值(Exponentiation assignment)求幂赋值 (Exponentiation assignment)
    x **= y
    x = x ** y
   

   
左移位赋值(Left shift assignment)左移位赋值 (Left shift assignment)
    x <<= y
    x = x << y
   

   
右移位赋值(Right shift assignment)右移位赋值 (Right shift assignment)
    x >>= y
    x = x >> y
   

   
无符号右移位赋值(Unsigned right shift assignment)无符号右移位赋值 (Unsigned right shift assignment)
    x >>>= y
    x = x >>> y
   

   
按位与赋值(Bitwise AND assignment)按位与赋值 (Bitwise AND assignment)
    x &= y
    x = x & y
   

   
按位异或赋值(Bitwise XOR assignment)按位异或赋值 (Bitwise XOR assignment)
    x ^= y
    x = x ^ y
   

   
按位或赋值(Bitwise OR assignment)按位或赋值 (Bitwise OR assignment)
    x |= y
    x = x | y
   

 
 
 
 
   

    运算符
    描述返回true的示例返回 true 的示例
   

  
  
   

    等于 Equal (==)
    
-    
如果两边操作数相等时返回true。

+    
如果两边操作数相等时返回 true。

    		
    3 == var1
     
"3" == var1

@@ -174,42 +174,42 @@ 
比较运算符

   

   

    不等于 Not equal (!=)如果两边操作数不相等时返回true如果两边操作数不相等时返回 true
    var1 != 4

     var2 != "3"		
   

   

    全等 Strict equal (===)两边操作数相等且类型相同时返回true。 参见 {{jsxref("Object.is")}} and sameness in JS.两边操作数相等且类型相同时返回 true。 参见 {{jsxref("Object.is")}} and sameness in JS.
    3 === var1
   

   

    不全等 Strict not equal (!==)两边操作数不相等或类型不同时返回true。两边操作数不相等或类型不同时返回 true。
    var1 !== "3"

     3 !== '3'		
   

   

    大于 Greater than (>)左边的操作数大于右边的操作数返回true左边的操作数大于右边的操作数返回 true
    var2 > var1

     "12" > 2		
   

   

    大于等于 Greater than or equal (>=)左边的操作数大于或等于右边的操作数返回true左边的操作数大于或等于右边的操作数返回 true
    var2 >= var1

     var1 >= 3		
   

   

    小于 Less than (<)左边的操作数小于右边的操作数返回true左边的操作数小于右边的操作数返回 true
    var1 < var2

     "2" < 12		
   

   

    小于等于 Less than or equal (<=)左边的操作数小于或等于右边的操作数返回true左边的操作数小于或等于右边的操作数返回 true
    var1 <= var2

     var2 <= 5		
   

 

 
 

-
备注：（=>） 不是运算符，而是箭头函数的标记符号 。

+
备注：（=>）不是运算符，而是箭头函数的标记符号 。

 

 
 
算术运算符

 
-
算术运算符使用数值(字面量或者变量)作为操作数并返回一个数值.标准的算术运算符就是加减乘除(+ - * /)。当操作数是浮点数时，这些运算符表现得跟它们在大多数编程语言中一样（特殊要注意的是，除零会产生{{jsxref("Infinity")}}）。例如：

+
算术运算符使用数值 (字面量或者变量) 作为操作数并返回一个数值。标准的算术运算符就是加减乘除 (+ - * /)。当操作数是浮点数时，这些运算符表现得跟它们在大多数编程语言中一样（特殊要注意的是，除零会产生{{jsxref("Infinity")}}）。例如：

 
 
1 / 2;  // 0.5
 1 / 2 == 1.0 / 2.0; // true
 

 
-
除了标准的算术运算符（+， - ，* /），JavaScript还提供了下表中的算术运算符。

+
除了标准的算术运算符（+， - ，* /），JavaScript 还提供了下表中的算术运算符。

 
 
@@ -241,13 +241,13 @@ 
算术运算符

-   
-   
+   
+   
-   
-   
+   
+   
-   
-   
+   
+   
-   
-   
+   
+   
-   
+   
-   
-   
+   
+   
-   
+   
-   
+   
@@ -345,35 +345,35 @@ 
位运算符

-   
+   
-   
+   

  表 3.3 算术运算符
  
  
   
求余(%)二元运算符. 返回相除之后的余数.求余 (%)二元运算符。返回相除之后的余数。
    12 % 5 返回 2。
   

   
自增(++)一元运算符. 将操作数的值加一. 如果放在操作数前面 (++x), 则返回加一后的值; 如果放在操作数后面 (x++), 则返回操作数原值,然后再将操作数加一.自增 (++)一元运算符。将操作数的值加一. 如果放在操作数前面 (++x), 则返回加一后的值; 如果放在操作数后面 (x++), 则返回操作数原值，然后再将操作数加一。
    
     
var x=3; 

 
@@ -263,26 +263,26 @@ 
算术运算符

    		
   

   
自减(--)一元运算符. 将操作数的值减一. 前后缀两种用法的返回值类似自增运算符.自减 (--)一元运算符。将操作数的值减一. 前后缀两种用法的返回值类似自增运算符。
    
-    
var x=3; console.log(--x); //输入2,x=2

+    
var x=3; console.log(--x); //输入 2,x=2

 
-    
var y=3;console.log(y--);//输出3,x=2;

+    
var y=3;console.log(y--);//输出 3,x=2;

    		
   

   
一元负值符(-)一元运算符,返回操作数的负值.一元负值符 (-)一元运算符，返回操作数的负值。
    
     
var x=3; console.log(-x); //输入-3

    		
   

   

    
-    
一元正值符(+)

+    
一元正值符 (+)

    		一元运算符, 如果操作数在之前不是number，试图将其转换为number一元运算符，如果操作数在之前不是 number，试图将其转换为 number
    
     
console.log( +'3' ); // 3

 
@@ -292,8 +292,8 @@ 
算术运算符

    		
   

   
指数运算符(**)计算 base(底数) 的 exponent(指数)次方, 表示为base^exponent指数运算符 (**)计算 base(底数) 的 exponent(指数) 次方, 表示为base^exponent
    
     
2 ** 3 returns 8.

      10 ** -1 returns 0.1.

@@ -306,7 +306,7 @@ 
算术运算符

 
 
位运算符

 
-
位运算符将它的操作数视为32位元的二进制串（0和1组成）而非十进制八进制或十六进制数。例如：十进制数字9用二进制表示为1001，位运算符就是在这个二进制表示上执行运算，但是返回结果是标准的JavaScript数值。

+
位运算符将它的操作数视为 32 位元的二进制串（0 和 1 组成）而非十进制八进制或十六进制数。例如：十进制数字 9 用二进制表示为 1001，位运算符就是在这个二进制表示上执行运算，但是返回结果是标准的 JavaScript 数值。

 
 
下表总结了 JavaScript 的位运算符。

 
@@ -324,18 +324,18 @@ 
位运算符

    		按位与 AND
    a & b
    
-    
在a,b的位表示中，每一个对应的位都为1则返回1， 否则返回0.

+    
在 a,b 的位表示中，每一个对应的位都为 1 则返回 1， 否则返回 0.

    		
   

   

    按位或 OR
    a | b在a,b的位表示中，每一个对应的位，只要有一个为1则返回1， 否则返回0.在 a,b 的位表示中，每一个对应的位，只要有一个为 1 则返回 1， 否则返回 0.
   

   

    按位异或 XOR
    a ^ b在a,b的位表示中，每一个对应的位，两个不相同则返回1，相同则返回0.在 a,b 的位表示中，每一个对应的位，两个不相同则返回 1，相同则返回 0.
   

   

    按位非 NOT
   

    左移 shift
    a << b将a的二进制串向左移动b位,右边移入0.将 a 的二进制串向左移动 b 位，右边移入 0.
   

   

    算术右移
    a >> b
    
-    
把a的二进制表示向右移动b位，丢弃被移出的所有位.

+    
把 a 的二进制表示向右移动 b 位，丢弃被移出的所有位。

 
-    
(译注:算术右移左边空出的位是根据最高位是0和1来进行填充的)

+    
(译注：算术右移左边空出的位是根据最高位是 0 和 1 来进行填充的)

    		
   

   

    
     
无符号右移

 
-    
(左边空出位用0填充)

+    
(左边空出位用 0 填充)

    		
    a >>> b把a的二进制表示向右移动b位，丢弃被移出的所有位，并把左边空出的位都填充为0把 a 的二进制表示向右移动 b 位，丢弃被移出的所有位，并把左边空出的位都填充为 0
   

  
 

 
 
位逻辑运算符

 
-
概念上来讲, 位逻辑运算符工作流程如下:

+
概念上来讲，位逻辑运算符工作流程如下：

 
 
    
- 
  • 操作数被转换为32bit整數，以位序列（0和1组成）表示.若超過32bits，則取低位32bit，如下所示：
    • 
+ 
  • 操作数被转换为 32bit 整數，以位序列（0 和 1 组成）表示。若超過 32bits，則取低位 32bit，如下所示：
    • 
 

 
 
@@ -382,11 +382,11 @@ 
位逻辑运算符

 

 
 
    
- 
  • 第一个操作数的每一位都与第二个操作数的对应位组对: 第一位对应第一位,第二位对应第二位,以此类推.
    • 
- 
  • 运算符被应用到每一对"位"上, 最终的运算结果由每一对“位”的运算结果组合起来.
    • 
+ 
  • 第一个操作数的每一位都与第二个操作数的对应位组对：第一位对应第一位，第二位对应第二位，以此类推。
    • 
+ 
  • 运算符被应用到每一对"位"上，最终的运算结果由每一对“位”的运算结果组合起来。
    • 
 

 
-
例如,十进制数9的二进制表示是1001,十进制数15的二进制表示是1111.因此,当位运算符应用到这两个值时,结果如下:

+
例如，十进制数 9 的二进制表示是 1001，十进制数 15 的二进制表示是 1111.因此，当位运算符应用到这两个值时，结果如下：

 
 
@@ -426,13 +426,13 @@ 
位逻辑运算符

  位运算符范例
  
 

 
-
注意位运算符“非”将所有的32位取反，而值的最高位(最左边的一位)为1则表示负数(2-补码表示法)。

+
注意位运算符“非”将所有的 32 位取反，而值的最高位 (最左边的一位) 为 1 则表示负数 (2-补码表示法)。

 
 
移位运算符

 
-
移位运算符带两个操作数：第一个是待移位的数，第二个是指定第一个数要被移多少位的数。移位的方向由运算符来控制.

+
移位运算符带两个操作数：第一个是待移位的数，第二个是指定第一个数要被移多少位的数。移位的方向由运算符来控制。

 
-
移位运算符把操作数转为32bit整数，然后得出一个与待移位数相同种类的值。

+
移位运算符把操作数转为 32bit 整数，然后得出一个与待移位数相同种类的值。

 
 
移位运算符列表如下。

 
@@ -450,20 +450,20 @@ 
移位运算符

   
    <<

     (左移位)
-   将第一个操作数向左移动指定数量的位. 左边移出位被抛弃. 左边移出的几位被丢弃.右边多出的空位由0补齐
-   9<<2产生36，因为1001移位2比特向左变为100100，它是36。
+   将第一个操作数向左移动指定数量的位。左边移出位被抛弃. 左边移出的几位被丢弃。右边多出的空位由 0 补齐
+   9<<2 产生 36，因为 1001 移位 2 比特向左变为 100100，它是 36。
   
   
    >>

     (带符号右移)
-   将第一个操作数向右移动指定数量的位. 右边移出位被抛弃. 左边多出的空位由原值的最左边数字补齐.
-   9>>2产生2，因为1001移位2位向右变为10，其是2。同样，-9>>2产生-3，由于符号被保留。
+   将第一个操作数向右移动指定数量的位. 右边移出位被抛弃。左边多出的空位由原值的最左边数字补齐。
+   9>>2 产生 2，因为 1001 移位 2 位向右变为 10，其是 2。同样，-9>>2 产生-3，由于符号被保留。
   
   
    >>>

     (补零右移)
-   将第一个操作数向右移动指定数量的位. 右边移出位被抛弃. 左边多出的空位由0补齐.
-   19>>>2产生4，因为10011移位2位向右变为100，它是4。对非负数值，补零右移和带符号右移产生相同结果。
+   将第一个操作数向右移动指定数量的位. 右边移出位被抛弃。左边多出的空位由 0 补齐。
+   19>>>2产生 4，因为 10011 移位 2 位向右变为 100，它是 4。对非负数值，补零右移和带符号右移产生相同结果。
   
  
 
@@ -486,22 +486,22 @@ 
逻辑运算符

   
    逻辑与 (&&)
    expr1 && expr2
-   (逻辑与) 如果expr1能被转换为false，那么返回expr1；否则，返回expr2。因此，&&用于布尔值时，当操作数都为true时返回true；否则返回false.
+   (逻辑与) 如果 expr1 能被转换为 false，那么返回 expr1；否则，返回expr2。因此，&&用于布尔值时，当操作数都为 true 时返回 true；否则返回 false.
   
   
    逻辑或 (||)
    expr1 || expr2
-   (逻辑或) 如果expr1能被转换为true，那么返回expr1；否则，返回expr2。因此，||用于布尔值时，当任何一个操作数为true则返回true；如果操作数都是false则返回false。
+   (逻辑或) 如果 expr1 能被转换为 true，那么返回 expr1；否则，返回expr2。因此，|| 用于布尔值时，当任何一个操作数为 true 则返回 true；如果操作数都是 false 则返回 false。
   
   
    逻辑非 (!)
    !expr
-   (逻辑非) 如果操作数能够转换为true则返回false；否则返回true。
+   (逻辑非) 如果操作数能够转换为 true 则返回 false；否则返回 true。
   
  
 
 
-
能被转换为false的值有null, 0, NaN, 空字符串("")和undefined。（译者注：也可以称作”falsy“）

+
能被转换为false的值有null, 0, NaN, 空字符串 ("") 和undefined。（译者注：也可以称作”falsy“）

 
 
下面是&&（逻辑"与"）操作符的示例。

 
@@ -514,7 +514,7 @@ 
逻辑运算符

 var a7 = "Cat" && false;    // t && f returns false
-

下面是||（逻辑"或"）操作符的示例。

+

下面是 ||（逻辑"或"）操作符的示例。

var o1 =  true || true;     // t || t returns true
 var o2 = false || true;     // f || t returns true
@@ -537,8 +537,8 @@ 
短路求值

 
作为逻辑表达式进行求值是从左到右，它们是为可能的“短路”的出现而使用以下规则进行测试：

 
 
    
- 
  • false && anything    // 被短路求值为false
    • 
- 
  • true || anything       // 被短路求值为true
    • 
+ 
  • false && anything    // 被短路求值为 false
    • 
+ 
  • true || anything       // 被短路求值为 true
    • 
 

 
 
逻辑的规则，保证这些评估是总是正确的。请注意，上述表达式的anything部分不会被求值，所以这样做不会产生任何副作用。

@@ -560,25 +560,25 @@ 
字符串运算符

 
 
条件（三元）运算符

 
-
条件运算符是JavaScript中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：

+
条件运算符是 JavaScript 中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：

 
-
条件 ? 值1 : 值2
+
条件 ? 值 1 : 值 2
 

 
-
如果条件为真，则结果取值1。否则为值2。你能够在任何允许使用标准运算符的地方使用条件运算符。

+
如果条件为真，则结果取值 1。否则为值 2。你能够在任何允许使用标准运算符的地方使用条件运算符。

 
 
例如，

 
 
var status = (age >= 18) ? "adult" : "minor";
 

 
-
当 age 大于等于18的时候，将“adult”赋值给 status；否则将“minor”赋值给 status。

+
当 age 大于等于 18 的时候，将“adult”赋值给 status；否则将“minor”赋值给 status。

 
 
逗号操作符

 
 
逗号操作符（,）对两个操作数进行求值并返回最终操作数的值。它常常用在 for 循环中，在每次循环时对多个变量进行更新。

 
-
例如，假如 a 是一个二维数组，每个维度各有10个元素，以下代码利用逗号操作符来同时改变两个变量的值。这段代码的功能是打印出该二维数组的对角线元素的值：

+
例如，假如 a 是一个二维数组，每个维度各有 10 个元素，以下代码利用逗号操作符来同时改变两个变量的值。这段代码的功能是打印出该二维数组的对角线元素的值：

 
 
var x = [0,1,2,3,4,5,6,7,8,9]
 var a = [x, x, x, x, x];
@@ -592,7 +592,7 @@ 
一元操作符

 
 
delete

 
-
delete操作符，删除一个对象的属性或者一个数组中某一个键值。语法如下:

+
delete操作符，删除一个对象的属性或者一个数组中某一个键值。语法如下：

 
 
delete objectName.property;
 delete objectName[index];
@@ -620,7 +620,7 @@ 
delete

 
 
删除数组元素

 
-
删除数组中的元素时，数组的长度是不变的，例如删除a[3], a[4]，a[4]和a[3] 仍然存在变成了undefined。

+
删除数组中的元素时，数组的长度是不变的，例如删除a[3], a[4]，a[4]和 a[3] 仍然存在变成了undefined。

 
 
delete 删除数组中的一个元素，这个元素就不在数组中了。例如，trees[3]被删除，trees[3] 仍然可寻址并返回undefined。

 
@@ -631,7 +631,7 @@ 
删除数组元素

 }
 

 
-
如果想让数组中存在一个元素但是是undefined值，使用undefined关键字而不是delete操作. 如下： trees[3]分配一个undefined,但是这个数组元素仍然存在:

+
如果想让数组中存在一个元素但是是undefined值，使用undefined关键字而不是delete操作。如下： trees[3] 分配一个 undefined,但是这个数组元素仍然存在：

 
 
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 trees[3] = undefined;
@@ -642,7 +642,7 @@ 
删除数组元素

 
 
typeof

 
-
typeof操作符 可通过下面2种方式使用：

+
typeof 操作符 可通过下面 2 种方式使用：

 
 
typeof operand
 typeof (operand)
@@ -711,9 +711,9 @@ 
void

 void expression
 

 
-
void运算符,表明一个运算没有返回值。expression是javaScript表达式，括号中的表达式是一个可选项，当然使用该方式是一种好的形式。

+
void 运算符，表明一个运算没有返回值。expression 是 javaScript 表达式，括号中的表达式是一个可选项，当然使用该方式是一种好的形式。

 
-
你可以使用void运算符指明一个超文本链接。该表达式是有效的，但是并不会在当前文档中进行加载。

+
你可以使用 void 运算符指明一个超文本链接。该表达式是有效的，但是并不会在当前文档中进行加载。

 
 
如下创建了一个超链接文本，当用户单击该文本时，不会有任何效果。

 
@@ -766,11 +766,11 @@ 
instanceof

 
objectName instanceof objectType
 

 
-
objectName 是需要做判别的对象的名称,而objectType是假定的对象的类型, 例如{{jsxref("Date")}}或 {{jsxref("Array")}}.

+
objectName 是需要做判别的对象的名称，而objectType是假定的对象的类型，例如{{jsxref("Date")}}或 {{jsxref("Array")}}.

 
 
当你需要确认一个对象在运行时的类型时，可使用instanceof. 例如，需要 catch 异常时，你可以针对抛出异常的类型，来做不同的异常处理。

 
-
例如, 下面的代码使用instanceof去判断 theDay是否是一个 Date 对象. 因为theDay是一个Date对象, 所以if中的代码会执行.

+
例如，下面的代码使用instanceof去判断 theDay是否是一个 Date 对象。因为 theDay是一个Date对象，所以 if中的代码会执行。

 
 
var theDay = new Date(1995, 12, 17);
 if (theDay instanceof Date) {
@@ -869,18 +869,18 @@ 
表达式

 
 
每一个合法的表达式都能计算成某个值，但从概念上讲，有两种类型的表达式：有副作用的（比如赋值）和单纯计算求值的。

 
-
表达式x=7是第一类型的一个例子。该表达式使用=运算符将值7赋予变量x。这个表达式自己的值等于7。

+
表达式 x=7 是第一类型的一个例子。该表达式使用=运算符将值 7 赋予变量 x。这个表达式自己的值等于 7。

 
-
代码3 + 4是第二个表达式类型的一个例子。该表达式使用+运算符把3和4加到一起但并没有把结果（7）赋值给一个变量。

+
代码 3 + 4 是第二个表达式类型的一个例子。该表达式使用 + 运算符把 3 和 4 加到一起但并没有把结果（7）赋值给一个变量。

 
-
JavaScript有以下表达式类型：

+
JavaScript 有以下表达式类型：

 
 
    
- 
  • 算数: 得出一个数字, 例如 3.14159. (通常使用 {{ web.link("#Arithmetic_operators", "arithmetic operators") }}.)
    • 
- 
  • 字符串: 得出一个字符串, 例如, "Fred" 或 "234". (通常使用 {{ web.link("#String_operators", "string operators") }}.)
    • 
- 
  • 逻辑值: 得出true或者false. (经常涉及到 {{ web.link("#Logical_operators", "logical operators") }}.)
    • 
- 
  • 基本表达式: javascript中基本的关键字和一般表达式。
    • 
- 
  • 左值表达式: 分配给左值。
    • 
+ 
  • 算数：得出一个数字，例如 3.14159. (通常使用 {{ web.link("#Arithmetic_operators", "arithmetic operators") }}.)
    • 
+ 
  • 字符串：得出一个字符串，例如，"Fred" 或 "234". (通常使用 {{ web.link("#String_operators", "string operators") }}.)
    • 
+ 
  • 逻辑值：得出 true 或者 false. (经常涉及到 {{ web.link("#Logical_operators", "logical operators") }}.)
    • 
+ 
  • 基本表达式: javascript 中基本的关键字和一般表达式。
    • 
+ 
  • 左值表达式：分配给左值。
    • 
 

 
 
基本表达式

@@ -909,7 +909,7 @@ 
this

 
 
分组操作符

 
-
分组操作符（）控制了表达式中计算的优先级. 举例来说, 你可以改变先乘除后加减的顺序，转而先计算加法。

+
分组操作符（）控制了表达式中计算的优先级。举例来说，你可以改变先乘除后加减的顺序，转而先计算加法。

 
 
var a = 1;
 var b = 2;
@@ -928,16 +928,16 @@ 
分组操作符

 
 
数值推导

 
-
Comprehensions 是一个带有实验性质的JavaScript特性, 计划将在未来的ECMAScript版本中加入该特性. 有两种类型的comprehensions:

+
Comprehensions 是一个带有实验性质的 JavaScript 特性，计划将在未来的 ECMAScript 版本中加入该特性。有两种类型的 comprehensions:

 
 

  
{{experimental_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}

- 
数列数值推导 （非标准用法）

+ 
数列数值推导（非标准用法）

  
{{experimental_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}

- 
生成器数值推导 （译者注：生成器数值推导标准化可能不大，推荐使用 生成器函数）

+ 
生成器数值推导（译者注：生成器数值推导标准化可能不大，推荐使用 生成器函数）

 

 
-
Comprehensions特性被许多编程语言所采用，该特性能够使你快速地通过一个已有的数组来创建出一个新的数组，比如：

+
Comprehensions 特性被许多编程语言所采用，该特性能够使你快速地通过一个已有的数组来创建出一个新的数组，比如：

 
 
[for (i of [ 1, 2, 3 ]) i*i ];
 // [ 1, 4, 9 ]
@@ -965,14 +965,14 @@ 
new

 
 
扩展语句

 
-
扩展语句符允许一个表达式在原地展开， 当需要多个参数 (比如函数调用时) 或者多个值(比如字面量数组) 。

+
扩展语句符允许一个表达式在原地展开， 当需要多个参数 (比如函数调用时) 或者多个值 (比如字面量数组) 。

 
-
例如：现在你有一个数组，你想创建一个新数组，并将刚才那个作为它的一部分，用array的字面语法是不够的，你不得不写一些代码实现它，比如用些push, splice, concat等等。但是用spread syntax就没问题了：

+
例如：现在你有一个数组，你想创建一个新数组，并将刚才那个作为它的一部分，用 array 的字面语法是不够的，你不得不写一些代码实现它，比如用些push, splice, concat 等等。但是用spread syntax 就没问题了：

 
 
var parts = ['shoulder', 'knees'];
 var lyrics = ['head', ...parts, 'and', 'toes'];

 
-
类似的，扩展语句也可以用在函数调用的时候:

+
类似的，扩展语句也可以用在函数调用的时候：

 
 
function f(x, y, z) { }
 var args = [0, 1, 2];
diff --git a/files/zh-cn/web/javascript/guide/functions/index.html b/files/zh-cn/web/javascript/guide/functions/index.html
index e37f71e8a8921a..3536e44abec47f 100644
--- a/files/zh-cn/web/javascript/guide/functions/index.html
+++ b/files/zh-cn/web/javascript/guide/functions/index.html
@@ -12,7 +12,7 @@
 
 
函数是 JavaScript 中的基本组件之一。 一个函数是 JavaScript 过程 — 一组执行任务或计算值的语句。要使用一个函数，你必须将其定义在你希望调用它的作用域内。

 
-
一个JavaScript 函数用function关键字定义，后面跟着函数名和圆括号。

+
一个 JavaScript 函数用function关键字定义，后面跟着函数名和圆括号。

 
 
查看 JavaScript 函数详细参考文档 了解更多。

 
@@ -51,11 +51,11 @@ 
函数声明

 var mycar = {make: "Honda", model: "Accord", year: 1998};
 var x, y;
 
-x = mycar.make;     // x获取的值为 "Honda"
+x = mycar.make;     // x 获取的值为 "Honda"
 
 myFunc(mycar);
-y = mycar.make;     // y获取的值为 "Toyota"
-                    // (make属性被函数改变了)
+y = mycar.make;     // y 获取的值为 "Toyota"
+                    // (make 属性被函数改变了)
 

 
 
函数表达式

@@ -121,9 +121,9 @@ 
调用函数

 
square(5);
 

 
-
上述语句通过提供参数 5 来调用函数。函数执行完它的语句会返回值25。

+
上述语句通过提供参数 5 来调用函数。函数执行完它的语句会返回值 25。

 
-
函数一定要处于调用它们的域中，但是函数的声明可以被提升(出现在调用语句之后)，如下例：

+
函数一定要处于调用它们的域中，但是函数的声明可以被提升 (出现在调用语句之后)，如下例：

 
 
console.log(square(5));
 /* ... */
@@ -154,15 +154,15 @@ 
调用函数

 }
 

 
-
你可以计算1-5的阶乘如下：

+
你可以计算 1-5 的阶乘如下：

 
 
var a, b, c, d, e;
 
-a = factorial(1); // 1赋值给a
-b = factorial(2); // 2赋值给b
-c = factorial(3); // 6赋值给c
-d = factorial(4); // 24赋值给d
-e = factorial(5); // 120赋值给e
+a = factorial(1); // 1 赋值给 a
+b = factorial(2); // 2 赋值给 b
+c = factorial(3); // 6 赋值给 c
+d = factorial(4); // 24 赋值给 d
+e = factorial(5); // 120 赋值给 e
 

 
 
还有其它的方式来调用函数。常见的一些情形是某些地方需要动态调用函数，或者函数的实参数量是变化的，或者调用函数的上下文需要指定为在运行时确定的特定对象。显然，函数本身就是对象，因此这些对象也有方法（参考{{jsxref("Function")}} ）。作为此中情形之一，{{jsxref("Function.apply", "apply()")}}方法可以实现这些目的。

@@ -171,7 +171,7 @@ 
函数作用域

 
 
在函数内定义的变量不能在函数之外的任何地方访问，因为变量仅仅在该函数的域的内部有定义。相对应的，一个函数可以访问定义在其范围内的任何变量和函数。换言之，定义在全局域中的函数可以访问所有定义在全局域中的变量。在另一个函数中定义的函数也可以访问在其父函数中定义的所有变量和父函数有权访问的任何其他变量。

 
-
// 下面的变量定义在全局作用域(global scope)中
+
// 下面的变量定义在全局作用域 (global scope) 中
 var num1 = 20,
     num2 = 3,
     name = "Chamahk";
@@ -221,7 +221,7 @@ 
递归

 
 
    
  
  1. bar()
    2. 
- 
  2. arguments.callee() （译者注：ES5禁止在严格模式下使用此属性）
    3. 
+ 
  3. arguments.callee() （译者注：ES5 禁止在严格模式下使用此属性）
    4. 
  
  4. foo()
    5. 
 

 
@@ -272,7 +272,7 @@ 
递归

 }
 foo(3);
 
-// 输出:
+// 输出：
 
 // begin:3
 // begin:2
@@ -316,7 +316,7 @@ 
嵌套函数和闭包

   }
   return inside;
 }
-fn_inside = outside(3); // 可以这样想：给一个函数，使它的值加3
+fn_inside = outside(3); // 可以这样想：给一个函数，使它的值加 3
 result = fn_inside(5); // returns 8
 
 result1 = outside(3)(5); // returns 8

@@ -329,7 +329,7 @@ 
保存变量

 
 
多层嵌套函数

 
-
函数可以被多层嵌套。例如，函数A可以包含函数B，函数B可以再包含函数C。B和C都形成了闭包，所以B可以访问A，C可以访问B和A。因此，闭包可以包含多个作用域；他们递归式的包含了所有包含它的函数作用域。这个称之为作用域链。（稍后会详细解释）

+
函数可以被多层嵌套。例如，函数 A 可以包含函数 B，函数 B 可以再包含函数 C。B 和 C 都形成了闭包，所以 B 可以访问 A，C 可以访问 B 和 A。因此，闭包可以包含多个作用域；他们递归式的包含了所有包含它的函数作用域。这个称之为作用域链。（稍后会详细解释）

 
 
思考一下下面的例子：

 
@@ -344,15 +344,15 @@ 
多层嵌套函数

 }
 A(1); // logs 6 (1 + 2 + 3)

 
-
在这个例子里面，C可以访问B的y和A的x。这是因为：

+
在这个例子里面，C 可以访问 B 的 y 和 A 的 x。这是因为：

 
 
    
- 
  1. B形成了一个包含A的闭包，B可以访问A的参数和变量
    2. 
- 
  2. C形成了一个包含B的闭包
    3. 
- 
  3. B包含A，所以C也包含A，C可以访问B和A的参数和变量。换言之，C用这个顺序链接了B和A的作用域
    4. 
+ 
  4. B 形成了一个包含 A 的闭包，B 可以访问 A 的参数和变量
    5. 
+ 
  5. C 形成了一个包含 B 的闭包
    6. 
+ 
  6. B 包含 A，所以 C 也包含 A，C 可以访问 B 和 A 的参数和变量。换言之，C 用这个顺序链接了 B 和 A 的作用域
    7. 
 

 
-
反过来却不是这样。A不能访问C，因为A看不到B中的参数和变量，C是B中的一个变量，所以C是B私有的。

+
反过来却不是这样。A 不能访问 C，因为 A 看不到 B 中的参数和变量，C 是 B 中的一个变量，所以 C 是 B 私有的。

 
 
命名冲突

 
@@ -370,7 +370,7 @@ 
命名冲突

 
 outside()(10); // returns 20 instead of 10

 
-
命名冲突发生在return x上，inside的参数x和outside变量x发生了冲突。这里的作用链域是{inside, outside, 全局对象}。因此inside的x具有最高优先权，返回了20（inside的x）而不是10（outside的x）。

+
命名冲突发生在return x上，inside的参数x和outside变量x发生了冲突。这里的作用链域是{inside, outside, 全局对象}。因此inside的x具有最高优先权，返回了 20（inside的x）而不是 10（outside的x）。

 
 
闭包

 
@@ -457,14 +457,14 @@ 
闭包

 
 
使用 arguments 对象

 
-
函数的实际参数会被保存在一个类似数组的arguments对象中。在函数内，你可以按如下方式找出传入的参数：

+
函数的实际参数会被保存在一个类似数组的 arguments 对象中。在函数内，你可以按如下方式找出传入的参数：

 
 
arguments[i]
 

 
-
其中i是参数的序数编号（译注：数组索引），以0开始。所以第一个传来的参数会是arguments[0]。参数的数量由arguments.length表示。

+
其中i是参数的序数编号（译注：数组索引），以 0 开始。所以第一个传来的参数会是arguments[0]。参数的数量由arguments.length表示。

 
-
使用arguments对象，你可以处理比声明的更多的参数来调用函数。这在你事先不知道会需要将多少参数传递给函数时十分有用。你可以用arguments.length来获得实际传递给函数的参数的数量，然后用arguments对象来取得每个参数。

+
使用 arguments 对象，你可以处理比声明的更多的参数来调用函数。这在你事先不知道会需要将多少参数传递给函数时十分有用。你可以用arguments.length来获得实际传递给函数的参数的数量，然后用arguments对象来取得每个参数。

 
 
例如，设想有一个用来连接字符串的函数。唯一事先确定的参数是在连接后的字符串中用来分隔各个连接部分的字符（译注：比如例子里的分号“；”）。该函数定义如下：

 
@@ -491,18 +491,18 @@ 
使用 arguments 对象

 

 
 

-
备注：arguments变量只是 ”类数组对象“，并不是一个数组。称其为类数组对象是说它有一个索引编号和length属性。尽管如此，它并不拥有全部的Array对象的操作方法。

+
备注：arguments变量只是 ”类数组对象“，并不是一个数组。称其为类数组对象是说它有一个索引编号和length属性。尽管如此，它并不拥有全部的 Array 对象的操作方法。

 

 
-
更多信息请阅读JavaScript参考里的{{jsxref("Function")}}一文。

+
更多信息请阅读 JavaScript 参考里的{{jsxref("Function")}}一文。

 
 
函数参数

 
-
从ECMAScript 6开始，有两个新的类型的参数：默认参数，剩余参数。

+
从 ECMAScript 6 开始，有两个新的类型的参数：默认参数，剩余参数。

 
 
默认参数

 
-
在JavaScript中，函数参数的默认值是undefined。然而，在某些情况下设置不同的默认值是有用的。这时默认参数可以提供帮助。

+
在 JavaScript 中，函数参数的默认值是undefined。然而，在某些情况下设置不同的默认值是有用的。这时默认参数可以提供帮助。

 
 
在过去，用于设定默认参数的一般策略是在函数的主体中测试参数值是否为undefined，如果是则赋予这个参数一个默认值。如果在下面的例子中，调用函数时没有实参传递给b，那么它的值就是undefined，于是计算a*b得到、函数返回的是 NaN。但是，在下面的例子中，这个已经被第二行获取处理：

 
@@ -515,7 +515,7 @@ 
默认参数

 multiply(5); // 5
 

 
-
使用默认参数，在函数体的检查就不再需要了。现在，你可以在函数头简单地把1设定为b的默认值：

+
使用默认参数，在函数体的检查就不再需要了。现在，你可以在函数头简单地把 1 设定为b的默认值：

 
 
function multiply(a, b = 1) {
   return a*b;
@@ -538,7 +538,7 @@ 
剩余参数

 
 
箭头函数

 
-
箭头函数表达式（也称胖箭头函数）相比函数表达式具有较短的语法并以词法的方式绑定 this。箭头函数总是匿名的。另见 hacks.mozilla.org 的博文：“深度了解ES6：箭头函数”。

+
箭头函数表达式（也称胖箭头函数）相比函数表达式具有较短的语法并以词法的方式绑定 this。箭头函数总是匿名的。另见 hacks.mozilla.org 的博文：“深度了解 ES6：箭头函数”。

 
 
有两个因素会影响引入箭头函数：更简洁的函数和 this。

 
@@ -566,12 +566,12 @@ 
this 的词法

 
在箭头函数出现之前，每一个新函数都重新定义了自己的 this 值（在构造函数中是一个新的对象；在严格模式下是未定义的；在作为“对象方法”调用的函数中指向这个对象；等等）。以面向对象的编程风格，这样着实有点恼人。

 
 
function Person() {
-  // 构造函数Person()将`this`定义为自身
+  // 构造函数 Person() 将`this`定义为自身
   this.age = 0;
 
   setInterval(function growUp() {
-    // 在非严格模式下，growUp()函数将`this`定义为“全局对象”，
-    // 这与Person()定义的`this`不同，
+    // 在非严格模式下，growUp() 函数将`this`定义为“全局对象”，
+    // 这与 Person() 定义的`this`不同，
     // 所以下面的语句不会起到预期的效果。
     this.age++;
   }, 1000);
@@ -579,7 +579,7 @@ 
this 的词法

 
 var p = new Person();

 
-
在ECMAScript 3/5里，通过把this的值赋值给一个变量可以修复这个问题。

+
在 ECMAScript 3/5 里，通过把this的值赋值给一个变量可以修复这个问题。

 
 
function Person() {
   var self = this; // 有的人习惯用`that`而不是`self`，
@@ -600,7 +600,7 @@ 
this 的词法

   this.age = 0;
 
   setInterval(() => {
-    this.age++; // 这里的`this`正确地指向person对象
+    this.age++; // 这里的`this`正确地指向 person 对象
   }, 1000);
 }
 
@@ -608,12 +608,12 @@ 
this 的词法

 
 
预定义函数

 
-
JavaScript语言有好些个顶级的内建函数：

+
JavaScript 语言有好些个顶级的内建函数：

 
 

  
{{jsxref("Global_Objects/eval", "eval()")}}

  

- 
eval()方法会对一串字符串形式的JavaScript代码字符求值。

+ 
eval()方法会对一串字符串形式的 JavaScript 代码字符求值。

  

  
{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline}}

  

@@ -625,7 +625,7 @@ 
预定义函数

  

  
{{jsxref("Global_Objects/isNaN", "isNaN()")}}

  

- 
isNaN()函数判断一个值是否是{{jsxref("Global_Objects/NaN", "NaN")}}。注意：isNaN函数内部的强制转换规则十分有趣； 另一个可供选择的是ECMAScript 6 中定义{{jsxref("Number.isNaN()")}} , 或者使用 typeof来判断数值类型。

+ 
isNaN()函数判断一个值是否是{{jsxref("Global_Objects/NaN", "NaN")}}。注意：isNaN函数内部的强制转换规则十分有趣； 另一个可供选择的是 ECMAScript 6 中定义{{jsxref("Number.isNaN()")}} , 或者使用 typeof来判断数值类型。

  

  
{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}

  

@@ -645,11 +645,11 @@ 
预定义函数

  

  
{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}

  

- 
encodeURI()方法通过用以一个，两个，三个或四个转义序列表示字符的UTF-8编码替换统一资源标识符（URI）的某些字符来进行编码（每个字符对应四个转义序列，这四个序列组了两个”替代“字符）。

+ 
encodeURI()方法通过用以一个，两个，三个或四个转义序列表示字符的 UTF-8 编码替换统一资源标识符（URI）的某些字符来进行编码（每个字符对应四个转义序列，这四个序列组了两个”替代“字符）。

  

  
{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}

  

- 
encodeURIComponent() 方法通过用以一个，两个，三个或四个转义序列表示字符的UTF-8编码替换统一资源标识符（URI）的每个字符来进行编码（每个字符对应四个转义序列，这四个序列组了两个”替代“字符）。

+ 
encodeURIComponent() 方法通过用以一个，两个，三个或四个转义序列表示字符的 UTF-8 编码替换统一资源标识符（URI）的每个字符来进行编码（每个字符对应四个转义序列，这四个序列组了两个”替代“字符）。

  

  
{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline}}

  

diff --git a/files/zh-cn/web/javascript/guide/grammar_and_types/index.html b/files/zh-cn/web/javascript/guide/grammar_and_types/index.html
index b1257b59da725a..64daadfb7f525f 100644
--- a/files/zh-cn/web/javascript/guide/grammar_and_types/index.html
+++ b/files/zh-cn/web/javascript/guide/grammar_and_types/index.html
@@ -19,18 +19,18 @@ 
基础

 
 
JavaScript 借鉴了 Java 的大部分语法，但同时也受到 Awk，Perl 和 Python的影响。 

 
-
JavaScript 是区分大小写的，并使用 Unicode 字符集。举个例子，可以将单词 Früh （在德语中意思是“早”）用作变量名。

+
JavaScript 是区分大小写的，并使用 Unicode 字符集。举个例子，可以将单词 Früh（在德语中意思是“早”）用作变量名。

 
 
var Früh = "foobar";

 
 
但是，由于 JavaScript 是大小写敏感的，因此变量 früh 和 Früh 则是两个不同的变量。

 
-
在 JavaScript 中，指令被称为语句 （{{Glossary("Statement")}}），并用分号（;）进行分隔。

+
在 JavaScript 中，指令被称为语句（{{Glossary("Statement")}}），并用分号（;）进行分隔。

 
 
如果一条语句独占一行的话，那么分号是可以省略的。（译者注：并不建议这么做。）但如果一行中有多条语句，那么这些语句必须以分号分开。
 
 
 

-
备注：ECMAScript规定了在语句的末尾自动插入分号（ASI）。（如果想要了解更多信息，请参阅 JavaScript 词法语法 。）

+
备注：ECMAScript 规定了在语句的末尾自动插入分号（ASI）。（如果想要了解更多信息，请参阅 JavaScript 词法语法 。）

 

 
 
虽然不是必需的，但是在一条语句的末尾加上分号是一个很好的习惯。这个习惯可以大大减少代码中产生 bug 的可能性。

@@ -43,22 +43,22 @@ 
注释

 
 
// 单行注释
 
-/* 这是一个更长的,
+/* 这是一个更长的，
    多行注释
 */
 
-/* 然而, 你不能, /* 嵌套注释 */ 语法错误 */

+/* 然而，你不能，/* 嵌套注释 */ 语法错误 */

 
 
在代码执行过程中，注释将被自动跳过（不执行）。

 
 

-  
备注：你可能会在一些JavaScript脚本中见到像这样#!/usr/bin/env node的第三种注释

-  
这种注释我们称为hashbang 注释(hashbang comment)，这种注释被用来指定执行JaveScript脚本的引擎的路径，查看这篇文章来了解更详细的信息：Hashbang注释

+  
备注：你可能会在一些 JavaScript 脚本中见到像这样#!/usr/bin/env node的第三种注释

+  
这种注释我们称为hashbang 注释 (hashbang comment)，这种注释被用来指定执行 JaveScript 脚本的引擎的路径，查看这篇文章来了解更详细的信息：Hashbang 注释

 

 
 
声明

 
-
JavaScript有三种声明方式。

+
JavaScript 有三种声明方式。

 
 

  
{{jsxref("Statements/var", "var")}}

@@ -86,7 +86,7 @@ 
声明变量

 
    
  
  • 使用关键词 var 。例如 var x = 42。这个语法可以用来声明局部变量和全局变量。
    • 
  
  • 直接赋值。例如x = 42。在函数外使用这种形式赋值，会产生一个全局变量。在严格模式下会产生错误。因此你不应该使用这种方式来声明变量。
    • 
- 
  • 使用关键词 let 。例如 let y = 13。这个语法可以用来声明块作用域的局部变量。參考下方变量的作用域(Variable scope) 。
    • 
+ 
  • 使用关键词 let 。例如 let y = 13。这个语法可以用来声明块作用域的局部变量。參考下方变量的作用域 (Variable scope) 。
    • 
 

 
 

@@ -94,7 +94,7 @@ 
声明变量

 

 
 

-  你也可以直接给属性赋值。像这样x = 42。这种声明方式将会创建一个未声明全局变量。这样做还会产生JavaScript警告。因为未声明的全局变量常常导致预期之外的行为，所以不建议使用。
+  你也可以直接给属性赋值。像这样x = 42。这种声明方式将会创建一个未声明全局变量。这样做还会产生 JavaScript 警告。因为未声明的全局变量常常导致预期之外的行为，所以不建议使用。
 

 
 
变量求值

@@ -140,7 +140,7 @@ 
变量求值

 a + 2;    // 计算为 NaN
 

 
-
当你对一个 null 变量求值时，空值 null 在数值类型环境中会被当作0来对待，而布尔类型环境中会被当作 false。例如：

+
当你对一个 null 变量求值时，空值 null 在数值类型环境中会被当作 0 来对待，而布尔类型环境中会被当作 false。例如：

 
 
var n = null;
 console.log(n * 32); // 在控制台中会显示 0
@@ -170,14 +170,14 @@ 
变量提升

 
JavaScript 变量的另一个不同寻常的地方是，你可以先使用变量稍后再声明变量而不会引发异常。这一概念称为变量提升；JavaScript 变量感觉上是被“提升”或移到了函数或语句的最前面。但是，提升后的变量将返回 undefined 值。因此在使用或引用某个变量之后进行声明和初始化操作，这个被提升的变量仍将返回 undefined 值。

 
 
/**
- * 例子1
+ * 例子 1
  */
 console.log(x === undefined); // true
 var x = 3;
 
 
 /**
- * 例子2
+ * 例子 2
  */
 // will return a value of undefined
 var myvar = "my value";
@@ -191,14 +191,14 @@ 
变量提升

 
上面的例子，也可写作：

 
 
/**
- * 例子1
+ * 例子 1
  */
 var x;
 console.log(x === undefined); // true
 x = 3;
 
 /**
- * 例子2
+ * 例子 2
  */
 var myvar = "my value";
 
@@ -242,7 +242,7 @@ 
全局变量

 
 
因此，你可以通过指定 window 或 frame 的名字，在当前 window 或 frame 访问另一个 window 或 frame 中声明的变量。例如，在文档里声明一个叫 phoneNumber 的变量，那么你就可以在子框架里使用 parent.phoneNumber 的方式来引用它。

 
-
常量(Constants)

+
常量 (Constants)

 
 
你可以用关键字 const 创建一个只读的常量。常量标识符的命名规则和变量相同：必须以字母、下划线（_）或美元符号（$）开头并可以包含有字母、数字或下划线。

 
@@ -284,18 +284,18 @@ 
数据结构和类型

 
 
数据类型

 
-
最新的 ECMAScript 标准定义了8种数据类型：

+
最新的 ECMAScript 标准定义了 8 种数据类型：

 
 
    
- 
  • 七种基本数据类型:
+ 
  • 七种基本数据类型：
   
      
-   
    • 布尔值（Boolean），有2个值分别是：true 和 false.
      • 
+   
    • 布尔值（Boolean），有 2 个值分别是：true 和 false.
      • 
    
    • null ， 一个表明 null 值的特殊关键字。 JavaScript 是大小写敏感的，因此 null 与 Null、NULL或变体完全不同。
      • 
    
    • undefined ，和 null 一样是一个特殊的关键字，undefined 表示变量未赋值时的属性。
      • 
    
    • 数字（Number），整数或浮点数，例如： 42 或者 3.14159。
      • 
    
    • 任意精度的整数 (BigInt) ，可以安全地存储和操作大整数，甚至可以超过数字的安全整数限制。
      • 
    
    • 字符串（String），字符串是一串表示文本值的字符序列，例如："Howdy" 。
      • 
-   
    • 代表（Symbol） ( 在 ECMAScript 6 中新添加的类型).。一种实例是唯一且不可改变的数据类型。
      • 
+   
    • 代表（Symbol）( 在 ECMAScript 6 中新添加的类型).。一种实例是唯一且不可改变的数据类型。
      • 
   
    
  
    • 
  
  • 以及对象（Object）。
    • 
@@ -305,7 +305,7 @@ 
    数据类型
    
 
 
    数据类型的转换
    
 
-
    JavaScript是一种动态类型语言(dynamically typed language)。这意味着你在声明变量时可以不必指定数据类型，而数据类型会在代码执行时会根据需要自动转换。因此，你可以按照如下方式来定义变量：
    
+
    JavaScript 是一种动态类型语言 (dynamically typed language)。这意味着你在声明变量时可以不必指定数据类型，而数据类型会在代码执行时会根据需要自动转换。因此，你可以按照如下方式来定义变量：
    
 
 
    var answer = 42;
 
    
@@ -324,7 +324,7 @@ 
    数字转换为字符串
    
 y = 42 + " is the answer" // "42 is the answer"
 

 
-
在涉及其它运算符（译注：如下面的减号'-'）时，JavaScript语言不会把数字变为字符串。例如（译注：第一例是数学运算，第二例是字符串运算）：

+
在涉及其它运算符（译注：如下面的减号'-'）时，JavaScript 语言不会把数字变为字符串。例如（译注：第一例是数学运算，第二例是字符串运算）：

 
 
"37" - 7 // 30
 "37" + 7 // "377"
@@ -339,7 +339,7 @@ 
字符串转换为数字

   
  • parseFloat()
    • 
 
 
-
     parseInt 方法只能返回整数，所以使用它会丢失小数部分。另外，调用 parseInt 时最好总是带上进制(radix) 参数，这个参数用于指定使用哪一种进制。
    
+
     parseInt 方法只能返回整数，所以使用它会丢失小数部分。另外，调用 parseInt 时最好总是带上进制 (radix) 参数，这个参数用于指定使用哪一种进制。
    
 
 
    将字符串转换为数字的另一种方法是使用一元加法运算符。
    
 
@@ -352,22 +352,22 @@ 
    字面量 (Literals)
    
 
 
    （译注：字面量是由语法表达式定义的常量；或，通过由一定字词组成的语词表达式定义的常量）
    
 
-
    在JavaScript中，你可以使用各种字面量。这些字面量是脚本中按字面意思给出的固定的值，而不是变量。（译注：字面量是常量，其值是固定的，而且在程序脚本运行中不可更改，比如false，3.1415，thisIsStringOfHelloworld ，invokedFunction: myFunction("myArgument")。本节将介绍以下类型的字面量：
    
+
    在 JavaScript 中，你可以使用各种字面量。这些字面量是脚本中按字面意思给出的固定的值，而不是变量。（译注：字面量是常量，其值是固定的，而且在程序脚本运行中不可更改，比如false，3.1415，thisIsStringOfHelloworld ，invokedFunction: myFunction("myArgument")。本节将介绍以下类型的字面量：
    
 
 
 
 
    数组字面量 (Array literals)
    
 
-
    数组字面值是一个封闭在方括号对([])中的包含有零个或多个表达式的列表，其中每个表达式代表数组的一个元素。当你使用数组字面值创建一个数组时，该数组将会以指定的值作为其元素进行初始化，而其长度被设定为元素的个数。
    
+
    数组字面值是一个封闭在方括号对 ([]) 中的包含有零个或多个表达式的列表，其中每个表达式代表数组的一个元素。当你使用数组字面值创建一个数组时，该数组将会以指定的值作为其元素进行初始化，而其长度被设定为元素的个数。
    
 
-
    下面的示例用3个元素生成数组coffees，它的长度是3。
    
+
    下面的示例用 3 个元素生成数组coffees，它的长度是 3。
    
 
 
    var coffees = ["French Roast", "Colombian", "Kona"];
 
@@ -381,7 +381,7 @@ 
    数组字面量 (Array literals)
    
 
    备注： 这里的数组字面值也是一种对象初始化器。参考对象初始化器的使用。
    
 
 
-
    若在顶层（全局）脚本里用字面值创建数组，JavaScript语言将会在每次对包含该数组字面值的表达式求值时解释该数组。另一方面，在函数中使用的数组，将在每次调用函数时都会被创建一次。
    
+
    若在顶层（全局）脚本里用字面值创建数组，JavaScript 语言将会在每次对包含该数组字面值的表达式求值时解释该数组。另一方面，在函数中使用的数组，将在每次调用函数时都会被创建一次。
    
 
 
    数组字面值同时也是数组对象。有关数组对象的详情请参见数组对象一文。
    
 
@@ -392,9 +392,9 @@ 
    数组字面值中的多余逗号
    var fish = ["Lion", , "Angel"];
 
    
 
-
    在这个数组中，有两个已被赋值的元素，和一个空元素（fish[0]是"Lion"，fish[1]是undefined，而fish[2]是"Angel"；译注：此时数组的长度属性fish.length是3)。
    
+
    在这个数组中，有两个已被赋值的元素，和一个空元素（fish[0] 是"Lion"，fish[1] 是 undefined，而 fish[2] 是"Angel"；译注：此时数组的长度属性 fish.length 是 3)。
    
 
-
    如果你在元素列表的尾部添加了一个逗号，它将会被忽略。在下面的例子中，数组的长度是3，并不存在myList[3]这个元素（译注：这是指数组的第4个元素噢，作者是在帮大家复习数组元素的排序命名方法）。元素列表中其它所有的逗号都表示一个新元素（的开始）。
    
+
    如果你在元素列表的尾部添加了一个逗号，它将会被忽略。在下面的例子中，数组的长度是 3，并不存在 myList[3] 这个元素（译注：这是指数组的第 4 个元素噢，作者是在帮大家复习数组元素的排序命名方法）。元素列表中其它所有的逗号都表示一个新元素（的开始）。
    
 
 
    
 
    备注：尾部的逗号在早期版本的浏览器中会产生错误，因而编程时的最佳实践方式就是移除它们。
    
@@ -405,17 +405,17 @@ 
    数组字面值中的多余逗号
    var myList = ['home', , 'school', ];
 
    
 
-
    在下面的例子中，数组的长度是4，元素myList[0]和myList[2]缺失（译注：没被赋值，因而是undefined）。
    
+
    在下面的例子中，数组的长度是 4，元素myList[0]和myList[2]缺失（译注：没被赋值，因而是 undefined）。
    
 
 
    var myList = [ , 'home', , 'school'];
 
    
 
-
    再看一个例子。在这里，该数组的长度是4，元素myList[1]和myList[3]被漏掉了。（但是）只有最后的那个逗号被忽略。
    
+
    再看一个例子。在这里，该数组的长度是 4，元素myList[1]和myList[3]被漏掉了。（但是）只有最后的那个逗号被忽略。
    
 
 
    var myList = ['home', , 'school', , ];
 
    
 
-
    理解多余的逗号（在脚本运行时会被如何处理）的含义，对于从语言层面理解JavaScript是十分重要的。但是，在你自己写代码时：显式地将缺失的元素声明为undefined，将大大提高你的代码的清晰度和可维护性。
    
+
    理解多余的逗号（在脚本运行时会被如何处理）的含义，对于从语言层面理解 JavaScript 是十分重要的。但是，在你自己写代码时：显式地将缺失的元素声明为undefined，将大大提高你的代码的清晰度和可维护性。
    
 
 
    布尔字面量 (Boolean literals)
    
 
@@ -423,33 +423,33 @@ 
    布尔字面量 (Boolean literals)布尔类型有两种字面量：true和false。
    
 
-
    不要混淆作为布尔对象的真和假与布尔类型的原始值true和false。布尔对象是原始布尔数据类型的一个包装器。参见 布尔对象。
    
+
    不要混淆作为布尔对象的真和假与布尔类型的原始值 true 和 false。布尔对象是原始布尔数据类型的一个包装器。参见 布尔对象。
    
 
 
    数字字面量
    
 
-
    JavaScript数字字面量包括多种基数的整数字面量和以10为基数的浮点数字面量
    
+
    JavaScript 数字字面量包括多种基数的整数字面量和以 10 为基数的浮点数字面量
    
 
 
    值得一提的是，语言标准要求数字字面量必须是无符号的。但是像-123.4这样的代码片段还是没有问题的，会被解释为一元操作符-应用于数字字面量123.4
    
 
 
    整数字面量
    
 
-
    整数可以用十进制（基数为10）、十六进制（基数为16）、八进制（基数为8）以及二进制（基数为2）表示。
    
+
    整数可以用十进制（基数为 10）、十六进制（基数为 16）、八进制（基数为 8）以及二进制（基数为 2）表示。
    
 
 
      
- 
    • 十进制整数字面量由一串数字序列组成，且没有前缀0。
      • 
- 
    • 八进制的整数以 0（或0O、0o）开头，只能包括数字0-7。
      • 
- 
    • 十六进制整数以0x（或0X）开头，可以包含数字（0-9）和字母 a~f 或 A~F。
      • 
- 
    • 二进制整数以0b（或0B）开头，只能包含数字0和1。
      • 
+ 
    • 十进制整数字面量由一串数字序列组成，且没有前缀 0。
      • 
+ 
    • 八进制的整数以 0（或 0O、0o）开头，只能包括数字 0-7。
      • 
+ 
    • 十六进制整数以 0x（或 0X）开头，可以包含数字（0-9）和字母 a~f 或 A~F。
      • 
+ 
    • 二进制整数以 0b（或 0B）开头，只能包含数字 0 和 1。
      • 
 
    
 
-
    严格模式下，八进制整数字面量必须以0o或0O开头，而不能以0开头。
    
+
    严格模式下，八进制整数字面量必须以 0o 或 0O 开头，而不能以 0 开头。
    
 
 
    整数字面量举例：
    
 
-
    0, 117 and -345 (十进制, 基数为10)
-015, 0001 and -0o77 (八进制, 基数为8)
-0x1123, 0x00111 and -0xF1A7 (十六进制, 基数为16或"hex")
-0b11, 0b0011 and -0b11 (二进制, 基数为2)
    
+
    0, 117 and -345 (十进制，基数为 10)
+015, 0001 and -0o77 (八进制，基数为 8)
+0x1123, 0x00111 and -0xF1A7 (十六进制，基数为 16 或"hex")
+0b11, 0b0011 and -0b11 (二进制，基数为 2)
    
 
 
    浮点数字面量
    
 
@@ -478,13 +478,13 @@ 
    浮点数字面量
    
 
 
    对象字面量 (Object literals)
    
 
-
    对象字面值是封闭在花括号对({})中的一个对象的零个或多个"属性名-值"对的（元素）列表。
    
+
    对象字面值是封闭在花括号对 ({}) 中的一个对象的零个或多个"属性名 - 值"对的（元素）列表。
    
 
 
    
-
    警告：你不能在一条语句的开头就使用对象字面值，这将导致错误或产生超出预料的行为， 因为此时左花括号（{）会被认为是一个语句块的起始符号。（译者：这 里需要对语句statement、块block等基本名词的解释）
    
+
    警告：你不能在一条语句的开头就使用对象字面值，这将导致错误或产生超出预料的行为， 因为此时左花括号（{）会被认为是一个语句块的起始符号。（译者：这 里需要对语句 statement、块 block 等基本名词的解释）
    
 
    
 
-
    以下是一个对象字面值的例子。对象car的第一个元素（译注：即一个属性/值对）定义了属性myCar；第二个元素，属性getCar，引用了一个函数调用（即CarTypes("Honda")）；第三个元素，属性special，使用了一个已有的变量（即Sales）。
    
+
    以下是一个对象字面值的例子。对象car的第一个元素（译注：即一个属性/值对）定义了属性myCar；第二个元素，属性getCar，引用了一个函数调用（即 CarTypes("Honda")）；第三个元素，属性special，使用了一个已有的变量（即 Sales）。
    
 
 
    var Sales = "Toyota";
 
@@ -509,7 +509,7 @@ 
    对象字面量 (Object literals)
    
 console.log(car[7]); // Mazda
 
    
 
-
    对象属性名字可以是任意字符串，包括空串。如果对象属性名字不是合法的javascript标识符，它必须用""包裹。属性的名字不合法，那么便不能用.访问属性值，而是通过类数组标记("[]")访问和赋值。
    
+
    对象属性名字可以是任意字符串，包括空串。如果对象属性名字不是合法的 javascript 标识符，它必须用""包裹。属性的名字不合法，那么便不能用。访问属性值，而是通过类数组标记 ("[]") 访问和赋值。
    
 
 
    var unusualPropertyNames = {
   "": "An empty string",
@@ -522,7 +522,7 @@ 
    对象字面量 (Object literals)
    
 
 
    增强的对象字面量 (Enhanced Object literals)
    
 
-
    在ES2015，对象字面值扩展支持在创建时设置原型，简写了 foo: foo 形式的属性赋值，方法定义，支持父方法调用，以及使用表达式动态计算属性名。总之，这些也使对象字面值和类声明更加紧密地联系起来，让基于对象的设计从这些便利中更加受益。
    
+
    在 ES2015，对象字面值扩展支持在创建时设置原型，简写了 foo: foo 形式的属性赋值，方法定义，支持父方法调用，以及使用表达式动态计算属性名。总之，这些也使对象字面值和类声明更加紧密地联系起来，让基于对象的设计从这些便利中更加受益。
    
 
 
    var obj = {
     // __proto__
@@ -564,13 +564,13 @@ 
    字符串字面量 (String literals
 "one line \n another line"
 "John's cat"
    
 
-
    你可以在字符串字面值上使用字符串对象的所有方法——JavaScript会自动将字符串字面值转换为一个临时字符串对象，调用该方法，然后废弃掉那个临时的字符串对象。你也能用对字符串字面值使用类似String.length的属性：
    
+
    你可以在字符串字面值上使用字符串对象的所有方法——JavaScript 会自动将字符串字面值转换为一个临时字符串对象，调用该方法，然后废弃掉那个临时的字符串对象。你也能用对字符串字面值使用类似 String.length 的属性：
    
 
 
    console.log("John's cat".length)
 // 将打印字符串中的字符个数（包括空格）
 // 结果为：10
    
 
-
    在ES2015中，还提供了一种模板字面量，模板字符串提供了一些语法糖来帮你构造字符串。这与Perl、Python还有其他语言中的字符串插值（string interpolation）的特性非常相似。除此之外，你可以在通过模板字符串前添加一个tag来自定义模板字符串的解析过程，这可以用来防止注入攻击，或者用来建立基于字符串的高级数据抽象。
    
+
    在 ES2015 中，还提供了一种模板字面量，模板字符串提供了一些语法糖来帮你构造字符串。这与 Perl、Python 还有其他语言中的字符串插值（string interpolation）的特性非常相似。除此之外，你可以在通过模板字符串前添加一个 tag 来自定义模板字符串的解析过程，这可以用来防止注入攻击，或者用来建立基于字符串的高级数据抽象。
    
 
 
    // Basic literal string creation
 `In JavaScript '\n' is a line-feed.`
@@ -591,7 +591,7 @@ 
    字符串字面量 (String literals
        "bar": ${bar}}`(myOnReadyStateChangeHandler);
 
    
 
-
    除非有特别需要使用字符串对象，否则,你应当始终使用字符串字面值。要查看字符串对象的有关细节，请参见字符串对象。
    
+
    除非有特别需要使用字符串对象，否则，你应当始终使用字符串字面值。要查看字符串对象的有关细节，请参见字符串对象。
    
 
 
    在字符串中使用的特殊字符
    
 
@@ -600,7 +600,7 @@ 
    在字符串中使用的特殊字
 
    "one line \n another line"
 
    
 
-
    以下表格列举了你能在JavaScript的字符串中使用的特殊字符。
    
+
    以下表格列举了你能在 JavaScript 的字符串中使用的特殊字符。
    
 
 
@@ -613,7 +613,7 @@ 
    在字符串中使用的特殊字
  
    
-   
+   
@@ -653,19 +653,19 @@ 
    在字符串中使用的特殊字
   
    
-   
+   
-   
+   
-   
+   
-   
+   
    
  表 2.1 JavaScript 特殊字符
   
    
    \0Null字节Null 字节
   
    
   
    
    \b
    
   
    
    \XXX由从0到377最多三位八进制数XXX表示的 Latin-1 字符。例如，\251是版权符号的八进制序列。由从 0 到 377 最多三位八进制数XXX表示的 Latin-1 字符。例如，\251 是版权符号的八进制序列。
   
    
   
    
    \xXX由从00和FF的两位十六进制数字XX表示的Latin-1字符。例如，\ xA9是版权符号的十六进制序列。由从 00 和 FF 的两位十六进制数字 XX 表示的 Latin-1 字符。例如，\ xA9 是版权符号的十六进制序列。
   
    
   
    
    \uXXXX由四位十六进制数字XXXX表示的Unicode字符。例如，\ u00A9是版权符号的Unicode序列。见Unicode escape sequences (Unicode 转义字符).由四位十六进制数字 XXXX 表示的 Unicode 字符。例如，\ u00A9 是版权符号的 Unicode 序列。见Unicode escape sequences (Unicode 转义字符).
   
    
   
    
    \u{XXXXX}Unicode代码点 (code point) 转义字符。例如，\u{2F804} 相当于Unicode转义字符 \uD87E\uDC04的简写。Unicode 代码点 (code point) 转义字符。例如，\u{2F804} 相当于 Unicode 转义字符 \uD87E\uDC04 的简写。
   
    
      
 
    
@@ -674,20 +674,20 @@ 
    在字符串中使用的特殊字
 
 
    转义字符
    
 
-
    对于那些未出现在表2.1中的字符，其所带的前导反斜线'\'将被忽略。但是，这一用法已被废弃，应当避免使用。
    
+
    对于那些未出现在表 2.1 中的字符，其所带的前导反斜线'\'将被忽略。但是，这一用法已被废弃，应当避免使用。
    
 
-
    通过在引号前加上反斜线'\'，可以在字符串中插入引号，这就是引号转义。例如:
    
+
    通过在引号前加上反斜线'\'，可以在字符串中插入引号，这就是引号转义。例如：
    
 
 
    var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
 console.log(quote);
 
    
 
-
    代码的运行结果为:
    
+
    代码的运行结果为：
    
 
 
    He read "The Cremation of Sam McGee" by R.W. Service.
 
    
 
-
    要在字符串中插入'\'字面值，必须转义反斜线。例如，要把文件路径 c:\temp 赋值给一个字符串，可以采用如下方式:
    
+
    要在字符串中插入'\'字面值，必须转义反斜线。例如，要把文件路径 c:\temp 赋值给一个字符串，可以采用如下方式：
    
 
 
    var home = "c:\\temp";
 
    
@@ -701,7 +701,7 @@ 
    转义字符
    
 console.log(str);   // this string is broken across multiplelines.
 
    
 
-
    Javascript没有“heredoc”语法，但可以用行末的换行符转义和转义的换行来近似实现 
    
+
    Javascript 没有“heredoc”语法，但可以用行末的换行符转义和转义的换行来近似实现 
    
 
 
    var poem =
 "Roses are red,\n\
@@ -720,7 +720,7 @@ 
    转义字符
    
 
 
    更多信息
    
 
-
    本章重点包括声明和类型的基本语法。学习更多关于的JavaScript语言，可参见本站以下章节：
    
+
    本章重点包括声明和类型的基本语法。学习更多关于的 JavaScript 语言，可参见本站以下章节：
    
 
 
      
  
    • 流程控制与错误处理
      • 
diff --git a/files/zh-cn/web/javascript/guide/indexed_collections/index.html b/files/zh-cn/web/javascript/guide/indexed_collections/index.html
index 5e29a8d49ea19d..dd93f9ccba0acf 100644
--- a/files/zh-cn/web/javascript/guide/indexed_collections/index.html
+++ b/files/zh-cn/web/javascript/guide/indexed_collections/index.html
@@ -7,28 +7,28 @@
 
 
      这个章节主要介绍了以索引进行排序的数据集合。包括数组以及类似于数组的数据结构，如 {{jsxref("Array")}} 、{{jsxref("TypedArray")}} 。
      
 
-
      数组对象(Array object)
      
+
      数组对象 (Array object)
      
 
-
      数组(array)是一个有序的数据集合，我们可以通过数组名称(name)和索引(index)进行访问。例如，我们定义了一个数组emp，数组中的每个元素包含了一个雇员的名字以及其作为索引的员工号。那么emp[1]将会代表1号员工，emp[2]将会代表2号员工，以此类推。
      
+
      数组 (array) 是一个有序的数据集合，我们可以通过数组名称 (name) 和索引 (index) 进行访问。例如，我们定义了一个数组 emp，数组中的每个元素包含了一个雇员的名字以及其作为索引的员工号。那么 emp[1] 将会代表 1 号员工，emp[2] 将会代表 2 号员工，以此类推。
      
 
-
      JavaScript中没有明确的数组数据类型。但是，我们可以通过使用内置Array对象和它的方法对数组进行操作。Array对象有很多操作数组的方法，比如合并、反转、排序等。数组对象有一个决定数组长度和使用正则表达式操作其他属性的属性。
      
+
      JavaScript 中没有明确的数组数据类型。但是，我们可以通过使用内置 Array 对象和它的方法对数组进行操作。Array 对象有很多操作数组的方法，比如合并、反转、排序等。数组对象有一个决定数组长度和使用正则表达式操作其他属性的属性。
      
 
-
      创建数组(creating an array)
      
+
      创建数组 (creating an array)
      
 
-
      以下语句创建等效的数组:
      
+
      以下语句创建等效的数组：
      
 
 
      var arr = new Array(element0, element1, ..., elementN);
 var arr = Array(element0, element1, ..., elementN);
 var arr = [element0, element1, ..., elementN];
 
-// 译者注: var arr=[4] 和 var arr=new Array(4)是不等效的，
-// 后者4指数组长度，所以使用字面值(literal)的方式应该不仅仅是便捷，同时也不易踩坑
      
+// 译者注: var arr=[4] 和 var arr=new Array(4) 是不等效的，
+// 后者 4 指数组长度，所以使用字面值 (literal) 的方式应该不仅仅是便捷，同时也不易踩坑
    
 
-
    element0, element1, ..., elementN 是数组元素的值的列表。当这些值被指定后，数组将被初始化，他们将被作为数组元素。数组的length属性也会被设为参数的个数。
    
+
    element0, element1, ..., elementN 是数组元素的值的列表。当这些值被指定后，数组将被初始化，他们将被作为数组元素。数组的 length 属性也会被设为参数的个数。
    
 
 
    括号语法被称为 "数组字面值" 或 "数组初始化器", 它比其他创建数组的方式更便捷，所以通常是首选。详细内容参见 Array literals 。
    
 
-
    为了创建一个长度不为0，但是又没有任何元素的数组，可选以下任何一种方式：
    
+
    为了创建一个长度不为 0，但是又没有任何元素的数组，可选以下任何一种方式：
    
 
 
    var arr = new Array(arrayLength);
 var arr = Array(arrayLength);
@@ -42,7 +42,7 @@ 
    创建数组(creating an array)
    
 
    备注：以上代码，数组长度（arrayLength）必须为一个数字（Number）。否则，将会创建一个只有单个（所输入的）元素的数组。 调用 arr.length 会返回数组长度，但是数组实际上包含了空的（undefined）元素。 因此在数组上使用 for...in 循环，将不会返回任何的值 。
    
 
 
-
    除了如上所示创建新定义的变量，数组(array)也可以作为一个属性(property)分配给一个新的或者已存在的对象(object)：
    
+
    除了如上所示创建新定义的变量，数组 (array) 也可以作为一个属性 (property) 分配给一个新的或者已存在的对象 (object)：
    
 
 
    var obj = {};
 // ...
@@ -52,26 +52,26 @@ 
    创建数组(creating an array)
    
 var obj = {prop: [element0, element1, ...., elementN]}
 
    
 
-
    如果你希望用单个元素初始化一个数组，而这个元素恰好又是数字(Number)，那么你必须使用括号语法。当单个的数字(Number)传递给Array()构造函数时，将会被解释为数组长度，并非单个元素。
    
+
    如果你希望用单个元素初始化一个数组，而这个元素恰好又是数字 (Number)，那么你必须使用括号语法。当单个的数字 (Number) 传递给 Array() 构造函数时，将会被解释为数组长度，并非单个元素。
    
 
-
    var arr = [42];      // 创建一个只有唯一元素的数组:
+
    var arr = [42];      // 创建一个只有唯一元素的数组：
                      // the number 42.
-var arr = Array(42); // 创建一个没有元素的数组,
-                     // 但是数组的长度被设置成42.
+var arr = Array(42); // 创建一个没有元素的数组，
+                     // 但是数组的长度被设置成 42.
 
 // 上面的代码与下面的代码等价
 var arr = [];
 arr.length = 42;
 
    
 
-
    如果N不是一个整数，调用Array(N)将会报RangeError错误， 以下方法说明了这种行为：
    
+
    如果 N 不是一个整数，调用Array(N)将会报RangeError错误， 以下方法说明了这种行为：
    
 
 
    var arr = Array(9.3);  // RangeError: Invalid array length
 
    
 
 
    如果你需要创建任意类型的单元素数组，安全的方式是使用字面值。或者在向数组添加单个元素之前先创建一个空的数组。
    
 
-
    填充数组(populating an array)
    
+
    填充数组 (populating an array)
    
 
 
    你可以通过给元素赋值来填充数组，例如：
    
 
@@ -82,7 +82,7 @@ 
    填充数组(populating an array)
    
 
    
 
 
    
-
    备注：如果你在以上代码中给数组操作符的是一个非整形数值，那么将作为一个代表数组的对象的属性(property)创建，而非作为数组的元素。
    
+
    备注：如果你在以上代码中给数组操作符的是一个非整形数值，那么将作为一个代表数组的对象的属性 (property) 创建，而非作为数组的元素。
    
 
    
 
 
    var arr = [];
@@ -97,7 +97,7 @@ 
    填充数组(populating an array)
    
 var myArray = ["Mango", "Apple", "Orange"]
 
    
 
-
    引用数组元素(referring to array elements)
    
+
    引用数组元素 (referring to array elements)
    
 
 
    您通过可以使用元素的序号来引用数组的元素。例如，假设你定义了如下数组：
    
 
@@ -107,7 +107,7 @@ 
    引用数组元素(referr
 
    你可以用 myArray[0]引用第一个元素，myArray[1]引用第二个元素。元素的索引是从0开始的。
    
 
 
    
-
    备注：数组操作符（方括号 [ ]）也可以用来访问数组的属性(在 JavaScript 中，数组也是对象)。例如：
    
+
    备注：数组操作符（方括号 [ ]）也可以用来访问数组的属性 (在 JavaScript 中，数组也是对象)。例如：
    
 
    
 
 
    var arr = ["one", "two", "three"];
@@ -117,14 +117,14 @@ 
    引用数组元素(referr
 
 
    理解 length
    
 
-
    在实施层面， JavaScript实际上是将元素作为标准的对象属性来存储，把数组索引作为属性名。长度属性是特殊的，它总是返回最后一个元素的索引值加1(下例中， Dusty 的索引是30，所以cats.length 返回 30 + 1)。记住， JavaScript 数组索引是基于0的: 他们从0开始，而不是1。这意味着数组长度属性将比最大的索引值大1:
    
+
    在实施层面， JavaScript 实际上是将元素作为标准的对象属性来存储，把数组索引作为属性名。长度属性是特殊的，它总是返回最后一个元素的索引值加 1(下例中， Dusty 的索引是 30，所以 cats.length 返回 30 + 1)。记住， JavaScript 数组索引是基于 0 的：他们从 0 开始，而不是 1。这意味着数组长度属性将比最大的索引值大 1:
    
 
 
    var cats = [];
 cats[30] = ['Dusty'];
 console.log(cats.length); // 31
 
    
 
-
    你也可以分配length属性。写一个小于数组元素数量的值会缩短数组，写0会彻底清空数组：
    
+
    你也可以分配length属性。写一个小于数组元素数量的值会缩短数组，写 0 会彻底清空数组：
    
 
 
    var cats = ['Dusty', 'Misty', 'Twiggy'];
 console.log(cats.length); // 3
@@ -139,7 +139,7 @@ 
    理解 length
    
 console.log(cats); // [undefined, undefined, undefined]
 
    
 
-
    遍历数组(interating over array)
    
+
    遍历数组 (interating over array)
    
 
 
    遍历数组元素并以某种方式处理每个元素是一个常见的操作。以下是最简单的方式：
    
 
@@ -149,7 +149,7 @@ 
    遍历数组(interating over array)
 
-
    如果你确定数组中没有一个元素的求值是false —— 如果你的数组只包含DOM节点，如下,你可以选择一个更高效的土法子:
    
+
    如果你确定数组中没有一个元素的求值是 false —— 如果你的数组只包含DOM节点，如下，你可以选择一个更高效的土法子：
    
 
 
    var divs = document.getElementsByTagName('div');
 for (var i = 0, div; div = divs[i]; i++) {
@@ -157,7 +157,7 @@ 
    遍历数组(interating over array)
 
-
    这样避免了检测数组长度的开销，额外的好处是确保了div变量当前在每次循环中都被重新赋值为当前项。
    
+
    这样避免了检测数组长度的开销，额外的好处是确保了 div 变量当前在每次循环中都被重新赋值为当前项。
    
 
 
    {{jsxref("Array.forEach", "forEach()")}} 方法提供了遍历数组元素的其他方法：
    
 
@@ -167,9 +167,9 @@ 
    遍历数组(interating over array)
 
-
    被传递给forEach的函数会在数组的每个元素像上执行一次，元素作为参数传递给该函数。未赋值的值不会在forEach循环迭代。
    
+
    被传递给 forEach 的函数会在数组的每个元素像上执行一次，元素作为参数传递给该函数。未赋值的值不会在 forEach 循环迭代。
    
 
-
    注意，在数组定义时省略的元素不会在forEach遍历时被列出，但是手动赋值为undefined的元素是会被列出的：
    
+
    注意，在数组定义时省略的元素不会在 forEach 遍历时被列出，但是手动赋值为 undefined 的元素是会被列出的：
    
 
 
    var array = ['first', 'second', , 'fourth'];
 
@@ -189,7 +189,7 @@ 
    遍历数组(interating over array)一旦 JavaScript 元素被保存为标准的对象属性，通过for...in 循环来迭代数组将变得不明智，因为正常元素和所有可枚举的属性都会被列出。
    
 
-
    数组的方法(array methods)
    
+
    数组的方法 (array methods)
    
 
 
    {{jsxref("Array")}} 对象具有下列方法：
    
 
@@ -235,7 +235,7 @@ 
    数组的方法(array methods)
    
 
    {{jsxref("Array.slice", "slice(start_index, upto_index)")}} 从数组提取一个片段，并作为一个新数组返回。
    
 
 
    var myArray = new Array ("a", "b", "c", "d", "e");
-myArray = myArray.slice(1, 4); // 包含索引1，不包括索引4
+myArray = myArray.slice(1, 4); // 包含索引 1，不包括索引 4
                                // returning [ "b", "c", "d"]
 
    
 
@@ -263,7 +263,7 @@ 
    数组的方法(array methods)
    
 // sorts the array so that myArray = [ "Fire", "Rain", "Wind" ]
 
    
 
-
    sort() 也可以带一个回调函数来决定怎么比较数组元素。这个回调函数比较两个值，并返回3个值中的一个：
    
+
    sort() 也可以带一个回调函数来决定怎么比较数组元素。这个回调函数比较两个值，并返回 3 个值中的一个：
    
 
 
    例如，下面的代码通过字符串的最后一个字母进行排序：
    
 
@@ -306,21 +306,21 @@ 
    数组的方法(array methods)
    
 // logs each item in turn
 
    
 
-
    {{jsxref("Array.map", "map(callback[, thisObject])")}} 在数组的每个单元项上执行callback函数，并把返回包含回调函数返回值的新数组（译者注：也就是遍历数组，并通过callback对数组元素进行操作，并将所有操作结果放入数组中并返回该数组）。
    
+
    {{jsxref("Array.map", "map(callback[, thisObject])")}} 在数组的每个单元项上执行 callback 函数，并把返回包含回调函数返回值的新数组（译者注：也就是遍历数组，并通过 callback 对数组元素进行操作，并将所有操作结果放入数组中并返回该数组）。
    
 
 
    var a1 = ['a', 'b', 'c'];
 var a2 = a1.map(function(item) { return item.toUpperCase(); });
 console.log(a2); // logs A,B,C
 
    
 
-
    {{jsxref("Array.filter", "filter(callback[, thisObject])")}} 返回一个包含所有在回调函数上返回为true的元素的新数组（译者注：callback在这里担任的是过滤器的角色，当元素符合条件，过滤器就返回true，而filter则会返回所有符合过滤条件的元素）。
    
+
    {{jsxref("Array.filter", "filter(callback[, thisObject])")}} 返回一个包含所有在回调函数上返回为 true 的元素的新数组（译者注：callback 在这里担任的是过滤器的角色，当元素符合条件，过滤器就返回 true，而 filter 则会返回所有符合过滤条件的元素）。
    
 
 
    var a1 = ['a', 10, 'b', 20, 'c', 30];
 var a2 = a1.filter(function(item) { return typeof item == 'number'; });
 console.log(a2); // logs 10,20,30
 
    
 
-
    {{jsxref("Array.every", "every(callback[, thisObject])")}} 当数组中每一个元素在callback上被返回true时就返回true（译者注：同上，every其实类似filter，只不过它的功能是判断是不是数组中的所有元素都符合条件，并且返回的是布尔值）。
    
+
    {{jsxref("Array.every", "every(callback[, thisObject])")}} 当数组中每一个元素在 callback 上被返回 true 时就返回 true（译者注：同上，every 其实类似 filter，只不过它的功能是判断是不是数组中的所有元素都符合条件，并且返回的是布尔值）。
    
 
 
    function isNumber(value){
   return typeof value == 'number';
@@ -331,7 +331,7 @@ 
    数组的方法(array methods)
    
 console.log(a2.every(isNumber)); // logs false
 
    
 
-
    {{jsxref("Array.some", "some(callback[, thisObject])")}} 只要数组中有一项在callback上被返回true，就返回true（译者注：同上，类似every，不过前者要求都符合筛选条件才返回true，后者只要有符合条件的就返回true）。
    
+
    {{jsxref("Array.some", "some(callback[, thisObject])")}} 只要数组中有一项在 callback 上被返回 true，就返回 true（译者注：同上，类似 every，不过前者要求都符合筛选条件才返回 true，后者只要有符合条件的就返回 true）。
    
 
 
    function isNumber(value){
   return typeof value == 'number';
@@ -344,9 +344,9 @@ 
    数组的方法(array methods)
    
 console.log(a3.some(isNumber)); // logs false
 
    
 
-
    以上方法都带一个被称为迭代方法的的回调函数，因为他们以某种方式迭代整个数组。都有一个可选的第二参数 thisObject，如果提供了这个参数，thisObject 变成回调函数内部的 this 关键字的值。如果没有提供，例如函数在一个显示的对象上下文外被调用时，this 将引用全局对象({{domxref("window")}}).
    
+
    以上方法都带一个被称为迭代方法的的回调函数，因为他们以某种方式迭代整个数组。都有一个可选的第二参数 thisObject，如果提供了这个参数，thisObject 变成回调函数内部的 this 关键字的值。如果没有提供，例如函数在一个显示的对象上下文外被调用时，this 将引用全局对象 ({{domxref("window")}}).
    
 
-
    实际上在调用回调函数时传入了3个参数。第一个是当前元素项的值，第二个是它在数组中的索引，第三个是数组本身的一个引用。 JavaScript 函数忽略任何没有在参数列表中命名的参数，因此提供一个只有一个参数的回调函数是安全的，例如 alert 。
    
+
    实际上在调用回调函数时传入了 3 个参数。第一个是当前元素项的值，第二个是它在数组中的索引，第三个是数组本身的一个引用。 JavaScript 函数忽略任何没有在参数列表中命名的参数，因此提供一个只有一个参数的回调函数是安全的，例如 alert 。
    
 
 
    {{jsxref("Array.reduce", "reduce(callback[, initialValue])")}} 使用回调函数 callback(firstValue, secondValue) 把数组列表计算成一个单一值（译者注：他数组元素两两递归处理的方式把数组计算成一个值）
    
 
@@ -355,13 +355,13 @@ 
    数组的方法(array methods)
    
 console.log(total) // Prints 60
 
    
 
-
    {{jsxref("Array.reduceRight", "reduceRight(callback[, initalvalue])")}} 和 reduce()相似，但这从最后一个元素开始的。
    
+
    {{jsxref("Array.reduceRight", "reduceRight(callback[, initalvalue])")}} 和 reduce() 相似，但这从最后一个元素开始的。
    
 
 
    reduce 和 reduceRight 是迭代数组方法中最不被人熟知的两个函数.。他们应该使用在那些需要把数组的元素两两递归处理，并最终计算成一个单一结果的算法。
    
 
-
    多维数组(multi-dimensional arrays)
    
+
    多维数组 (multi-dimensional arrays)
    
 
-
    数组是可以嵌套的, 这就意味着一个数组可以作为一个元素被包含在另外一个数组里面。利用JavaScript数组的这个特性, 可以创建多维数组。
    
+
    数组是可以嵌套的，这就意味着一个数组可以作为一个元素被包含在另外一个数组里面。利用 JavaScript 数组的这个特性，可以创建多维数组。
    
 
 
    以下代码创建了一个二维数组。
    
 
@@ -374,7 +374,7 @@ 
    多维数组(multi-dimensional arr
 }
 
    
 
-
    这个例子创建的数组拥有以下行数据:
    
+
    这个例子创建的数组拥有以下行数据：
    
 
 
    Row 0: [0,0] [0,1] [0,2] [0,3]
 Row 1: [1,0] [1,1] [1,2] [1,3]
@@ -385,13 +385,13 @@ 
    多维数组(multi-dimensional arr
 
    数组和正则表达式
    
 
 
    当一个数组作为字符串和正则表达式的匹配结果时，该数组将会返回相关匹配信息的属性和元素。 RegExp.exec(), String.match() 和 String.split() 的返回值是一个数组。 使用数组和正则表达式的的更多信息, 请看 Regular Expressions.
    
+Objects/String/split">String.split() 的返回值是一个数组。     使用数组和正则表达式的的更多信息，请看 Regular Expressions.
    
 
-
    使用类数组对象(array-like objects)
    
+
    使用类数组对象 (array-like objects)
    
 
-
    一些 JavaScript 对象, 例如 {{domxref("document.getElementsByTagName()")}} 返回的 {{domxref("NodeList")}} 或者函数内部可用的 arguments 对象，他们表面上看起来，外观和行为像数组，但是不共享他们所有的方法。例如 arguments 对象就提供一个 length 属性，但是不实现 {{jsxref("Array.forEach", "forEach()")}} 方法。
    
+
    一些 JavaScript 对象，例如 {{domxref("document.getElementsByTagName()")}} 返回的 {{domxref("NodeList")}} 或者函数内部可用的 arguments 对象，他们表面上看起来，外观和行为像数组，但是不共享他们所有的方法。例如 arguments 对象就提供一个 length 属性，但是不实现 {{jsxref("Array.forEach", "forEach()")}} 方法。
    
 
-
    Array的原生(prototype)方法可以用来处理类似数组行为的对象，例如： :
    
+
    Array 的原生 (prototype) 方法可以用来处理类似数组行为的对象，例如： :
    
 
 
    function printArguments() {
   Array.prototype.forEach.call(arguments, function(item) {
@@ -399,7 +399,7 @@ 
    使用类数组对象(array-lik
   });
 }
    
 
-
    Array的常规方法也可以用于处理字符串，因为它提供了序列访问字符转为数组的简单方法：
    
+
    Array 的常规方法也可以用于处理字符串，因为它提供了序列访问字符转为数组的简单方法：
    
 
 
    Array.prototype.forEach.call("a string", function(chr) {
   console.log(chr);
@@ -407,21 +407,21 @@ 
    使用类数组对象(array-lik
 
 
    数组推导式（Array comprehensions）
    
 
-
    在JavaScript 1.7 被介绍并计划在 ECMAScript 7, array comprehensions 被规范化并提供一个有用的快捷方式，用来实现如何在另一个数组的基础上构造一个新的数组。推导式可以经常被用在那些需要调用 map() 和 filter()函数的地方，或作为一种结合这两种方式。
    
+
    在JavaScript 1.7 被介绍并计划在 ECMAScript 7, array comprehensions 被规范化并提供一个有用的快捷方式，用来实现如何在另一个数组的基础上构造一个新的数组。推导式可以经常被用在那些需要调用 map() 和 filter() 函数的地方，或作为一种结合这两种方式。
    
 
-
    下面的推导式创建一个数字数组并且创建一个新的数组，数组的每个元素都是原来数值的两倍（译者注：这种形式类似于Python的列表推导式）。
    
+
    下面的推导式创建一个数字数组并且创建一个新的数组，数组的每个元素都是原来数值的两倍（译者注：这种形式类似于 Python 的列表推导式）。
    
 
 
    var numbers = [1, 2, 3, 4];
 var doubled = [for (i of numbers) i * 2];
 console.log(doubled); // logs 2,4,6,8
 
    
 
-
    这跟下面的map()方法的操作是等价的。
    
+
    这跟下面的 map() 方法的操作是等价的。
    
 
 
    var doubled = numbers.map(function(i){return i * 2;});
 
    
 
-
    推导式也可以用来筛选满足条件表达式的元素. 下面的推导式用来筛选是2的倍数的元素:
    
+
    推导式也可以用来筛选满足条件表达式的元素。下面的推导式用来筛选是 2 的倍数的元素：
    
 
 
    var numbers = [1, 2, 3, 21, 22, 30];
 var evens = [i for (i of numbers) if (i % 2 === 0)];
@@ -433,43 +433,43 @@ 
    数组推导式（Array compr
 
    var evens = numbers.filter(function(i){return i % 2 === 0;});
 
    
 
-
    map() 和filter() 类型的操作可以被组合（等效）为单个数组推导式。这里就有一个过滤出偶数，创建一个它的倍数数组的例子：
    
+
    map() 和 filter() 类型的操作可以被组合（等效）为单个数组推导式。这里就有一个过滤出偶数，创建一个它的倍数数组的例子：
    
 
 
    var numbers = [1, 2, 3, 21, 22, 30];
 var doubledEvens = [i * 2 for (i of numbers) if (i % 2 === 0)];
 console.log(doubledEvens); // logs 4,44,60
 
    
 
-
    数组推导式隐含了块作用域。新的变量(如例子中的i)类似于是采用 let声明的。这意味着他们不能在推导式以外访问。
    
+
    数组推导式隐含了块作用域。新的变量 (如例子中的 i) 类似于是采用 let声明的。这意味着他们不能在推导式以外访问。
    
 
 
    数组推导式的输入不一定必须是数组; 迭代器和生成器 也是可以的。
    
 
-
    甚至字符串也可以用来作为输入; 实现filter或者map行为 (参考上面类似数组行为的对象)如下:
    
+
    甚至字符串也可以用来作为输入; 实现 filter 或者 map 行为 (参考上面类似数组行为的对象) 如下：
    
 
 
    var str = 'abcdef';
 var consonantsOnlyStr = [c for (c of str) if (!(/[aeiouAEIOU]/).test(c))  ].join(''); // 'bcdf'
 var interpolatedZeros = [c+'0' for (c of str) ].join(''); // 'a0b0c0d0e0f0'
 
    
 
-
    不过，输入形式是不能保存的，所以我们要使用join()回复到一个字符串。
    
+
    不过，输入形式是不能保存的，所以我们要使用 join() 回复到一个字符串。
    
 
-
    类型化数组(Typed Arrays )
    
+
    类型化数组 (Typed Arrays )
    
 
-
    JavaScript typed arrays 是类数组对象（array-like object），其提供访问原始二进制数据的机制。 就像你知道的那样, {{jsxref("Array")}} 对象动态增长和收缩，可以有任何JavaScript值。但对于类型化数组，JavaScript引擎执行优化使得这些数组访问速度快速。 随着Web应用程序变得越来越强大，添加音频和视频处理等功能、可以使用 WebSockets 、使用原始数据， 这都需要访问原始的二进制数据，所以专门的优化将有助于JavaScript代码能够快速和容易地操纵原始二进制数据类型的数组。
    
+
    JavaScript typed arrays 是类数组对象（array-like object），其提供访问原始二进制数据的机制。 就像你知道的那样，{{jsxref("Array")}} 对象动态增长和收缩，可以有任何 JavaScript 值。但对于类型化数组，JavaScript 引擎执行优化使得这些数组访问速度快速。 随着 Web 应用程序变得越来越强大，添加音频和视频处理等功能、可以使用 WebSockets 、使用原始数据， 这都需要访问原始的二进制数据，所以专门的优化将有助于 JavaScript 代码能够快速和容易地操纵原始二进制数据类型的数组。
    
 
 
    缓冲区和视图：类型化的数组结构
    
 
-
    为了实现最大的灵活性和效率，JavaScript类型数组被分解为缓冲(Buffer)和视图(views)。缓冲(由{{jsxref("ArrayBuffer")}} 实现)是代表数据块的对象，它没有格式可言，并没有提供任何机制来访问其内容。为了访问包含在缓冲区中的内存，您需要使用视图。视图提供了一个上下文，即数据类型、起始偏移量和元素数，这些元素将数据转换为实际类型数组。
    
+
    为了实现最大的灵活性和效率，JavaScript 类型数组被分解为缓冲 (Buffer) 和视图 (views)。缓冲 (由{{jsxref("ArrayBuffer")}} 实现) 是代表数据块的对象，它没有格式可言，并没有提供任何机制来访问其内容。为了访问包含在缓冲区中的内存，您需要使用视图。视图提供了一个上下文，即数据类型、起始偏移量和元素数，这些元素将数据转换为实际类型数组。
    
 
 
    Typed arrays in an ArrayBuffer
    
 
 
    ArrayBuffer
    
 
-
     {{jsxref("ArrayBuffer")}}是一种数据类型，用于表示一个通用的、固定长度的二进制数据缓冲区。你不能直接操纵一个ArrayBuffer中的内容；你需要创建一个数组类型视图或{{jsxref("DataView")}}来代表特定格式的缓冲区，并从而实现读写缓冲区的内容。
    
+
     {{jsxref("ArrayBuffer")}}是一种数据类型，用于表示一个通用的、固定长度的二进制数据缓冲区。你不能直接操纵一个 ArrayBuffer 中的内容；你需要创建一个数组类型视图或{{jsxref("DataView")}}来代表特定格式的缓冲区，并从而实现读写缓冲区的内容。
    
 
-
    类型数组视图(Typed array views)
    
+
    类型数组视图 (Typed array views)
    
 
-
    类型数组视图具有自描述性的名字，并且提供数据类型信息，例如Int8, Uint32, Float64等等。如一个特定类型数组视图Uint8ClampedArray. 它意味着数据元素只包含0到255的整数值。它通常用于Canvas数据处理,例如.
    
+
    类型数组视图具有自描述性的名字，并且提供数据类型信息，例如Int8, Uint32, Float64 等等。如一个特定类型数组视图Uint8ClampedArray. 它意味着数据元素只包含 0 到 255 的整数值。它通常用于Canvas 数据处理,例如。
    
 
 
    {{page("/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray", "TypedArray_objects")}}
    
 
diff --git a/files/zh-cn/web/javascript/guide/introduction/index.html b/files/zh-cn/web/javascript/guide/introduction/index.html
index c46f8deaccabc1..ff01612849f565 100644
--- a/files/zh-cn/web/javascript/guide/introduction/index.html
+++ b/files/zh-cn/web/javascript/guide/introduction/index.html
@@ -34,7 +34,7 @@ 
    去哪里获取有关 Jav
 
 
    什么是 JavaScript?
    
 
-
    JavaScript 是一门跨平台、面向对象的脚本语言，它能使网页可交互（例如拥有复杂的动画，可点击的按钮，通俗的菜单等）。另外还有高级的服务端Javascript版本，例如Node.js，它可以让你在网页上添加更多功能，不仅仅是下载文件（例如在多台电脑之间的协同合作）。在宿主环境（例如 web 浏览器）中， JavaScript 能够通过其所连接的环境提供的编程接口进行控制。
    
+
    JavaScript 是一门跨平台、面向对象的脚本语言，它能使网页可交互（例如拥有复杂的动画，可点击的按钮，通俗的菜单等）。另外还有高级的服务端 Javascript 版本，例如 Node.js，它可以让你在网页上添加更多功能，不仅仅是下载文件（例如在多台电脑之间的协同合作）。在宿主环境（例如 web 浏览器）中， JavaScript 能够通过其所连接的环境提供的编程接口进行控制。
    
 
 
    JavaScript 内置了一些对象的标准库，比如数组（Array），日期（Date），数学（Math）和一套核心语句，包括运算符、流程控制符以及声明方式等。JavaScript 的核心部分可以通过添加对象来扩展语言以适应不同用途；例如：
    
 
@@ -47,13 +47,13 @@ 
    什么是 JavaScript?
    
 
 
    JavaScript 和 Java
    
 
-
    JavaScript 和 Java 有一些共性但是在另一些方面有着根本性区别。JavaScript语言类似 Java 但是并没有 Java 的静态类型和强类型检查特性。JavaScript 遵循了 Java 的表达式语法，命名规范以及基础流程控制，这也是 JavaScript 从 LiveScript 更名的原因。
    
+
    JavaScript 和 Java 有一些共性但是在另一些方面有着根本性区别。JavaScript 语言类似 Java 但是并没有 Java 的静态类型和强类型检查特性。JavaScript 遵循了 Java 的表达式语法，命名规范以及基础流程控制，这也是 JavaScript 从 LiveScript 更名的原因。
    
 
 
    与 Java 通过声明的方式构建类的编译时系统不同，JavaScript 采用基于少量的数据类型如数字、布尔、字符串值的运行时系统。JavaScript 拥有基于原型的对象模型提供的动态继承；也就是说，独立对象的继承是可以改变的。 JavaScript 支持匿名函数。 函数也可以作为对象的属性被当做宽松的类型方式执行。
    
 
 
    与 Java 相比，Javascript 是一门形式自由的语言。你不必声明所有的变量，类和方法。你不必关心方法是否是公有、私有或者受保护的，也不需要实现接口。无需显式指定变量、参数、方法返回值的数据类型。
    
 
-
    Java 是基于类的编程语言，设计的初衷就是为了确保快速执行和类型安全。类型安全，举个例子，你不能将一个 Java 整数变量转化为一个对象引用，或者由Java字节码访问专有存储器。Java基于类的模型，意味着程序包含专有的类及其方法。Java的类继承和强类型要求紧耦合的对象层级结构。这些要求使得Java编程比JavaScript要复杂的多。
    
+
    Java 是基于类的编程语言，设计的初衷就是为了确保快速执行和类型安全。类型安全，举个例子，你不能将一个 Java 整数变量转化为一个对象引用，或者由 Java 字节码访问专有存储器。Java 基于类的模型，意味着程序包含专有的类及其方法。Java 的类继承和强类型要求紧耦合的对象层级结构。这些要求使得 Java 编程比 JavaScript 要复杂的多。
    
 
 
    相比之下，JavaScript 传承了 HyperTalk 和 dBASE 语句精简、动态类型等精髓，这些脚本语言为更多开发者提供了一种语法简单、内置功能强大以及用最小需求创建对象的编程工具。
    
 
@@ -71,8 +71,8 @@ 
    JavaScript 和 Java
    
    基于类系统。分为类和实例，通过类层级的定义实现继承。不能动态增加对象或类的属性或方法。
   
   
-   变量类型不需要提前声明(动态类型)。
-   变量类型必须提前声明(静态类型)。
+   变量类型不需要提前声明 (动态类型)。
+   变量类型必须提前声明 (静态类型)。
   
   
    不能直接自动写入硬盘。
@@ -81,49 +81,49 @@ 
    JavaScript 和 Java
    
  
 
 
-
    请查看章节 对象模型的详情 来了解更多JavaScript和Java的不同。
    
+
    请查看章节 对象模型的详情 来了解更多 JavaScript 和 Java 的不同。
    
 
 
    JavaScript 和 ECMAScript 规范
    
 
-
    JavaScript 的标准化组织是 ECMA ——这个欧洲信息与通信系统标准化协会提供基于 Javascript 的标准化方案（ECMA 原先是欧洲计算机制造商协会的首字母缩写）。这种标准化版本的 JavaScript 被称作 ECMAScript，在所有支持该标准的应用中以相同的方式工作。公司可以使用开放标准语言来开发他们自己的 JavaScript 实现版本。ECMAScript 标准在ECMA－262规范中进行文档化。 参照 JavaScript的新特性 以便学习更多关于不同版本的 JavaScript 和 ECMAScript 规范版本。
    
+
    JavaScript 的标准化组织是 ECMA ——这个欧洲信息与通信系统标准化协会提供基于 Javascript 的标准化方案（ECMA 原先是欧洲计算机制造商协会的首字母缩写）。这种标准化版本的 JavaScript 被称作 ECMAScript，在所有支持该标准的应用中以相同的方式工作。公司可以使用开放标准语言来开发他们自己的 JavaScript 实现版本。ECMAScript 标准在 ECMA－262 规范中进行文档化。 参照 JavaScript 的新特性 以便学习更多关于不同版本的 JavaScript 和 ECMAScript 规范版本。
    
 
-
    ECMA-262 标准也通过了 国际标准化组织（ISO）的 ISO-16262。你可以在这里找到该规范文件。 ECMAScript 规范并没有描述文档对象模型（DOM），该模型由 万维网联盟（W3C） 制定。DOM 定义了HTML文件对象被脚本操作的方法。为了更清楚地了解当使用JavaScript编程时用到的不同技术，请参阅 JavaScript 技术概述。
    
+
    ECMA-262 标准也通过了 国际标准化组织（ISO）的 ISO-16262。你可以在这里找到该规范文件。 ECMAScript 规范并没有描述文档对象模型（DOM），该模型由 万维网联盟（W3C） 制定。DOM 定义了 HTML 文件对象被脚本操作的方法。为了更清楚地了解当使用 JavaScript 编程时用到的不同技术，请参阅 JavaScript 技术概述。
    
 
 
    JavaScript 文献 和 ECMAScript 规范
    
 
-
    ECMAScript规范是实现ECMAScript的一组需求;如果您想在ECMAScript实现或引擎(如Firefox中的SpiderMonkey或Chrome中的V8)中实现符合标准的语言特性，那么它是非常有用的。
    
+
    ECMAScript 规范是实现 ECMAScript 的一组需求;如果您想在 ECMAScript 实现或引擎 (如 Firefox 中的 SpiderMonkey 或 Chrome 中的 V8) 中实现符合标准的语言特性，那么它是非常有用的。
    
 
-
    ECMAScript文档不是用来帮助脚本程序员的;使用JavaScript文档获取关于编写脚本的信息。
    
+
    ECMAScript 文档不是用来帮助脚本程序员的;使用 JavaScript 文档获取关于编写脚本的信息。
    
 
-
    ECMAScript规范使用了JavaScript程序员可能不熟悉的术语和语法。尽管ECMAScript中对语言的描述可能有所不同，但语言本身保持不变。JavaScript支持ECMAScript规范中列出的所有功能。
    
+
    ECMAScript 规范使用了 JavaScript 程序员可能不熟悉的术语和语法。尽管 ECMAScript 中对语言的描述可能有所不同，但语言本身保持不变。JavaScript 支持 ECMAScript 规范中列出的所有功能。
    
 
-
    JavaScript文档描述了适合JavaScript程序员的语言方面。
    
+
    JavaScript 文档描述了适合 JavaScript 程序员的语言方面。
    
 
 
    JavaScript 入门
    
 
 
    开始使用 JavaScript 很容易，你只需要一个现代 Web 浏览器。这篇教程包含了一些只在最新版本的火狐浏览器上才有的功能，所以建议大家使用最新版本的火狐浏览器。
    
 
-
    火狐浏览器内置的Web控制台非常适合学习JavaScript,Web控制台包含两个输入模式——单行模式、多行模式。
    
+
    火狐浏览器内置的 Web 控制台非常适合学习 JavaScript,Web 控制台包含两个输入模式——单行模式、多行模式。
    
 
 
    单行模式
    
 
-
    Web 控制台 不仅可以展示当前已加载页面的信息，还包含一个可以在当前页面执行Javascript表达式的 命令行。
    
+
    Web 控制台 不仅可以展示当前已加载页面的信息，还包含一个可以在当前页面执行 Javascript 表达式的 命令行。
    
 
-
    在火狐浏览器菜单栏的 “工具" => "浏览器工具" => "Web开发者工具"( 在Windows和Linux上Ctrl+Shift+I ，Mac上Cmd+Option+K)，选择"Web开发者工具栏"的控制台选项卡，它会如期出现在浏览器窗口的底部。如图，最下一行就是可以执行输入的命令行，面板上可以显示执行结果：
    
+
    在火狐浏览器菜单栏的 “工具" => "浏览器工具" => "Web 开发者工具"( 在 Windows 和 Linux 上Ctrl+Shift+I ，Mac 上Cmd+Option+K)，选择"Web 开发者工具栏"的控制台选项卡，它会如期出现在浏览器窗口的底部。如图，最下一行就是可以执行输入的命令行，面板上可以显示执行结果：
    
 
 
    
 
-
    控制台的工作方式与eval完全相同：返回最后输入的表达式。为了简单起见，可以想象每次输入到控制台的东西实际上都被 console.log 所包围。
    
+
    控制台的工作方式与 eval 完全相同：返回最后输入的表达式。为了简单起见，可以想象每次输入到控制台的东西实际上都被 console.log 所包围。
    
 
 
    console.log(eval('3 + 5'))
    
 
 
    多行模式
    
 
-
    Web控制台的单行模式非常适合用来测试单个的JavaScript表达式，对于复杂的JavaScript表达式或者一定规模的代码块就显得力不从心了。这正是多行模式要解决的！
    
+
    Web 控制台的单行模式非常适合用来测试单个的 JavaScript 表达式，对于复杂的 JavaScript 表达式或者一定规模的代码块就显得力不从心了。这正是多行模式要解决的！
    
 
 
    Hello world
    
 
-
    让我们用Web控制台的多行模式来写一个“Hello World"程序吧！JavaScript code:
    
+
    让我们用 Web 控制台的多行模式来写一个“Hello World"程序吧！JavaScript code:
    
 
 
     (function(){
@@ -136,14 +136,14 @@ 
    Hello world
    
 })();
   
    
 
-
    输入完成后，按下Cmd+Enter或者Ctrl+Enter(或者单击运行按钮)就可以在浏览器中看到执行结果了！
    
+
    输入完成后，按下Cmd+Enter或者Ctrl+Enter(或者单击运行按钮) 就可以在浏览器中看到执行结果了！
    
 
 
    在接下来的章节里，我们将向你介绍 JavaScript 的语法以及语言特性，届时你将可以使用它编写更加复杂的程序。
    
 
 
    但是现在请记住，始终将(function(){"use strict"; 添加到你的代码之前，始终将})();添加到你的代码之后。严格模式和IIFE这两篇文章详细解释了它们的作用。现在关于它们的作用你只要知道以下两点：
    
 
 
      
-  
    1. 防止JavaScript的语义影响初学者
      2. 
+  
    2. 防止 JavaScript 的语义影响初学者
      3. 
   
    3. 防止控制台中的代码片段之间发生意料之外的交互
      4. 
 
    
 
diff --git a/files/zh-cn/web/javascript/guide/iterators_and_generators/index.html b/files/zh-cn/web/javascript/guide/iterators_and_generators/index.html
index 9e5bbe3cbdea28..2b9ed0ef1a6d2f 100644
--- a/files/zh-cn/web/javascript/guide/iterators_and_generators/index.html
+++ b/files/zh-cn/web/javascript/guide/iterators_and_generators/index.html
@@ -29,12 +29,12 @@ 
    迭代器
    
 
 
    在 JavaScript 中，迭代器是一个对象，它定义一个序列，并在终止时可能返回一个返回值。 更具体地说，迭代器是通过使用 next() 方法实现 Iterator protocol 的任何一个对象，该方法返回具有两个属性的对象： value，这是序列中的 next 值；和 done ，如果已经迭代到序列中的最后一个值，则它为 true 。如果 value 和 done 一起存在，则它是迭代器的返回值。
    
 
-
    一旦创建，迭代器对象可以通过重复调用next（）显式地迭代。 迭代一个迭代器被称为消耗了这个迭代器，因为它通常只能执行一次。 在产生终止值之后，对next（）的额外调用应该继续返回{done：true}。
    
+
    一旦创建，迭代器对象可以通过重复调用 next（）显式地迭代。 迭代一个迭代器被称为消耗了这个迭代器，因为它通常只能执行一次。 在产生终止值之后，对 next（）的额外调用应该继续返回{done：true}。
    
  
    
- Javascript中最常见的迭代器是Array迭代器，它只是按顺序返回关联数组中的每个值。 虽然很容易想象所有迭代器都可以表示为数组，但事实并非如此。 数组必须完整分配，但迭代器仅在必要时使用，因此可以表示无限大小的序列，例如0和无穷大之间的整数范围。
    
+ Javascript 中最常见的迭代器是 Array 迭代器，它只是按顺序返回关联数组中的每个值。 虽然很容易想象所有迭代器都可以表示为数组，但事实并非如此。 数组必须完整分配，但迭代器仅在必要时使用，因此可以表示无限大小的序列，例如 0 和无穷大之间的整数范围。
    
 
 

    
- 这是一个可以做到这一点的例子。 它允许创建一个简单的范围迭代器，它定义了从开始（包括）到结束（独占）间隔步长的整数序列。 它的最终返回值是它创建的序列的大小，由变量iterationCount跟踪。
    
+ 这是一个可以做到这一点的例子。 它允许创建一个简单的范围迭代器，它定义了从开始（包括）到结束（独占）间隔步长的整数序列。 它的最终返回值是它创建的序列的大小，由变量 iterationCount 跟踪。
    
 
 
    function makeRangeIterator(start = 0, end = Infinity, step = 1) {
     let nextIndex = start;
@@ -75,9 +75,9 @@ 
    迭代器
    
 
 
    生成器函数
    
 
-
    虽然自定义的迭代器是一个有用的工具，但由于需要显式地维护其内部状态，因此需要谨慎地创建。生成器函数提供了一个强大的选择：它允许你定义一个包含自有迭代算法的函数， 同时它可以自动维护自己的状态。 生成器函数使用 {{jsxref("Statements/function*","function*")}}语法编写。 最初调用时，生成器函数不执行任何代码，而是返回一种称为Generator的迭代器。 通过调用生成器的下一个方法消耗值时，Generator函数将执行，直到遇到yield关键字。
    
+
    虽然自定义的迭代器是一个有用的工具，但由于需要显式地维护其内部状态，因此需要谨慎地创建。生成器函数提供了一个强大的选择：它允许你定义一个包含自有迭代算法的函数， 同时它可以自动维护自己的状态。 生成器函数使用 {{jsxref("Statements/function*","function*")}}语法编写。 最初调用时，生成器函数不执行任何代码，而是返回一种称为 Generator 的迭代器。 通过调用生成器的下一个方法消耗值时，Generator 函数将执行，直到遇到 yield 关键字。
    
 
-
    可以根据需要多次调用该函数，并且每次都返回一个新的Generator，但每个Generator只能迭代一次。
    
+
    可以根据需要多次调用该函数，并且每次都返回一个新的 Generator，但每个 Generator 只能迭代一次。
    
 
 
    我们现在可以调整上面的例子了。 此代码的行为是相同的，但实现更容易编写和读取。
    
 
@@ -101,7 +101,7 @@ 
    可迭代对象
    
 
 
    为了实现可迭代，一个对象必须实现 @@iterator 方法，这意味着这个对象（或其原型链中的任意一个对象）必须具有一个带 {{jsxref("Symbol.iterator")}} 键（key）的属性。
    
 
-
    可以多次迭代一个迭代器，或者只迭代一次。 程序员应该知道是哪种情况。 只能迭代一次的Iterables（例如Generators）通常从它们的@@iterator方法中返回它本身，其中那些可以多次迭代的方法必须在每次调用@@iterator时返回一个新的迭代器。
    
+
    可以多次迭代一个迭代器，或者只迭代一次。 程序员应该知道是哪种情况。 只能迭代一次的 Iterables（例如 Generators）通常从它们的@@iterator方法中返回它本身，其中那些可以多次迭代的方法必须在每次调用@@iterator时返回一个新的迭代器。
    
 
 
    自定义的可迭代对象
    
 
@@ -159,7 +159,7 @@ 
    高级生成器
    
 
 
    生成器会按需计算它们的产生值，这使得它们能够有效的表示一个计算成本很高的序列，甚至是如上所示的一个无限序列。
    
 
-
    The {{jsxref("Global_Objects/Generator/next","next()")}} 方法也接受一个参数用于修改生成器内部状态。传递给 next() 的参数值会被yield接收。要注意的是，传给第一个 next() 的值会被忽略。
    
+
    The {{jsxref("Global_Objects/Generator/next","next()")}} 方法也接受一个参数用于修改生成器内部状态。传递给 next() 的参数值会被 yield 接收。要注意的是，传给第一个 next() 的值会被忽略。
    
 
 
    下面的是斐波那契数列生成器，它使用了 next(x) 来重新启动序列：
    
 
diff --git a/files/zh-cn/web/javascript/guide/keyed_collections/index.html b/files/zh-cn/web/javascript/guide/keyed_collections/index.html
index 2b1d774e4590c5..2ab731ac046d08 100644
--- a/files/zh-cn/web/javascript/guide/keyed_collections/index.html
+++ b/files/zh-cn/web/javascript/guide/keyed_collections/index.html
@@ -11,7 +11,7 @@
 ---
 
    {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}
    
 
-
    这一章介绍由key值标记的数据容器；Map 和 Set 对象承载的数据元素可以按照插入时的顺序被迭代遍历。
    
+
    这一章介绍由 key 值标记的数据容器；Map 和 Set 对象承载的数据元素可以按照插入时的顺序被迭代遍历。
    
 
 
    映射
    
 
@@ -61,7 +61,7 @@ 
    Object和Map的比较WeakMap对象
    
 
-
    {{jsxref("WeakMap")}}对象也是键值对的集合。它的键必须是对象类型，值可以是任意类型。它的键被弱保持，也就是说，当其键所指对象没有其他地方引用的时候，它会被GC回收掉。WeakMap提供的接口与Map相同。
    
+
    {{jsxref("WeakMap")}}对象也是键值对的集合。它的键必须是对象类型，值可以是任意类型。它的键被弱保持，也就是说，当其键所指对象没有其他地方引用的时候，它会被 GC 回收掉。WeakMap提供的接口与Map相同。
    
 
 
    与Map对象不同的是，WeakMap的键是不可枚举的。不提供列出其键的方法。列表是否存在取决于垃圾回收器的状态，是不可预知的。
    
 
@@ -92,7 +92,7 @@ 
    Set对象
    
 
 
    {{jsxref("Set")}}对象是一组值的集合，这些值是不重复的，可以按照添加顺序来遍历。
    
 
-
    这里演示了Set的基本操作，更多示例和完整API可以参考{{jsxref("Set")}}。
    
+
    这里演示了Set的基本操作，更多示例和完整 API 可以参考{{jsxref("Set")}}。
    
 
 
    var mySet = new Set();
 mySet.add(1);
@@ -120,7 +120,7 @@ 
    数组和集合的转换
    
 
 
    Array和Set的对比
    
 
-
    一般情况下，在JavaScript中使用数组来存储一组元素，而新的集合对象有这些优势：
    
+
    一般情况下，在 JavaScript 中使用数组来存储一组元素，而新的集合对象有这些优势：
    
 
 
      
  
    • 数组中用于判断元素是否存在的{{jsxref("Array.indexOf", "indexOf")}} 函数效率低下。
      • 
@@ -140,7 +140,7 @@ 
      WeakSet对象
      
  
    • WeakSet的“weak”指的是，对集合中的对象，如果不存在其他引用，那么该对象将可被垃圾回收。于是不存在一个当前可用对象组成的列表，所以WeakSets不可枚举
      • 
 
    
 
-
    WeakSet的用例很有限，比如使用DOM元素作为键来追踪它们而不必担心内存泄漏。
    
+
    WeakSet的用例很有限，比如使用 DOM 元素作为键来追踪它们而不必担心内存泄漏。
    
 
 
    Map的键和Set的值的等值判断
    
 
diff --git a/files/zh-cn/web/javascript/guide/loops_and_iteration/index.html b/files/zh-cn/web/javascript/guide/loops_and_iteration/index.html
index 06d89bdb7dd7e3..42de49a30d66d8 100644
--- a/files/zh-cn/web/javascript/guide/loops_and_iteration/index.html
+++ b/files/zh-cn/web/javascript/guide/loops_and_iteration/index.html
@@ -10,9 +10,9 @@
 ---
 
    {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Control_flow_and_error_handling", "Web/JavaScript/Guide/Functions")}}
    
 
-
    循环提供了一种快速和简单的方式去做一些重复的事。JavaScript入门的这个章节会介绍在JavaScript中存在哪些不同的迭代语句。
    
+
    循环提供了一种快速和简单的方式去做一些重复的事。JavaScript 入门的这个章节会介绍在 JavaScript 中存在哪些不同的迭代语句。
    
 
-
    你可以把循环想成一种计算机化的游戏，告诉某人在一个方向上走X步，然后在另一个方向上走Y步；例如，“向东走5步”可以用一个循环来这样表达：
    
+
    你可以把循环想成一种计算机化的游戏，告诉某人在一个方向上走 X 步，然后在另一个方向上走 Y 步；例如，“向东走 5 步”可以用一个循环来这样表达：
    
 
 
    var step;
 for (step = 0; step < 5; step++) {
@@ -23,7 +23,7 @@
 
 
    循环有很多种类，但本质上它们都做的是同一件事：它们把一个动作重复了很多次（实际上重复的次数有可能为 0）。各种循环机制提供了不同的方法去确定循环的开始和结束。不同情况下，某一种类型循环会比其它的循环用起来更简单。
    
 
-
    JavaScript中提供了这些循环语句：
    
+
    JavaScript 中提供了这些循环语句：
    
 
 
      
  
    • for 语句
      • 
@@ -48,7 +48,7 @@ 
      for 语句
      
 
 
        
  
      1. 如果有初始化表达式 initialExpression，它将被执行。这个表达式通常会初始化一个或多个循环计数器，但语法上是允许一个任意复杂度的表达式的。这个表达式也可以声明变量。
        2. 
- 
      2. 计算 condition 表达式的值。如果 condition 的值是 true，循环中的语句会被执行。如果 condition 的值是 false，for 循环终止。如果 condition 表达式整个都被省略掉了，condition的值会被认为是true。
        3. 
+ 
      3. 计算 condition 表达式的值。如果 condition 的值是 true，循环中的语句会被执行。如果 condition 的值是 false，for 循环终止。如果 condition 表达式整个都被省略掉了，condition 的值会被认为是 true。
        4. 
  
      4. 循环中的 statement 被执行。如果需要执行多条语句，可以使用块（{ ... }）来包裹这些语句。
        5. 
  
      5. 如果有更新表达式 incrementExpression，执行更新表达式。
        6. 
  
      6. 回到步骤 2。
        7. 
@@ -56,7 +56,7 @@ 
        for 语句
        
 
 
        例子
        
 
-
        下面的函数包含一个含有 for 循环去计算一个滑动列表中被选中项目的个数（一个 {{HTMLElement("select")}} 元素允许选择多项）。for 循环声明了变量i并将它的初始值设为 0。它检查 i 是否比 <select> 元素中的选项数量少，执行了随后的 if 语句，然后在每次完成循环后，i 的值增加 1。
        
+
        下面的函数包含一个含有 for 循环去计算一个滑动列表中被选中项目的个数（一个 {{HTMLElement("select")}} 元素允许选择多项）。for 循环声明了变量 i 并将它的初始值设为 0。它检查 i 是否比 <select> 元素中的选项数量少，执行了随后的 if 语句，然后在每次完成循环后，i 的值增加 1。
        
 
 
        <form name="selectForm">
   <p>
@@ -70,7 +70,7 @@ 
        例子
        
       <option>歌剧</option>
     </select>
   </p>
-  <p><input id="btn" type="button" value="选择了多少个选项?" /></p>
+  <p><input id="btn" type="button" value="选择了多少个选项？" /></p>
 </form>
 
 <script>
@@ -224,7 +224,7 @@ 
        例子
        
 }
 alert(num);  // 95
        
 
-
        从alert(num)的值可以看出，continue outPoint; 语句的作用是跳出当前循环，并跳转到outPoint（标签）下的 for 循环继续执行。
        
+
        从 alert(num) 的值可以看出，continue outPoint; 语句的作用是跳出当前循环，并跳转到 outPoint（标签）下的 for 循环继续执行。
        
 
 
        break 语句
        
 
diff --git a/files/zh-cn/web/javascript/guide/meta_programming/index.html b/files/zh-cn/web/javascript/guide/meta_programming/index.html
index f5cd4d7ec2d794..bf43a9b7c98ae9 100644
--- a/files/zh-cn/web/javascript/guide/meta_programming/index.html
+++ b/files/zh-cn/web/javascript/guide/meta_programming/index.html
@@ -10,7 +10,7 @@
 ---
 
        {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Iterators_and_Generators", "Web/JavaScript/Guide/Modules")}}
        
 
-
        从ECMAScript 2015 开始，JavaScript 获得了 {{jsxref("Proxy")}} 和 {{jsxref("Reflect")}} 对象的支持，允许你拦截并定义基本语言操作的自定义行为（例如，属性查找，赋值，枚举，函数调用等）。借助这两个对象，你可以在 JavaScript 元级别进行编程。
        
+
        从 ECMAScript 2015 开始，JavaScript 获得了 {{jsxref("Proxy")}} 和 {{jsxref("Reflect")}} 对象的支持，允许你拦截并定义基本语言操作的自定义行为（例如，属性查找，赋值，枚举，函数调用等）。借助这两个对象，你可以在 JavaScript 元级别进行编程。
        
 
 
        代理
        
 
diff --git a/files/zh-cn/web/javascript/guide/modules/index.html b/files/zh-cn/web/javascript/guide/modules/index.html
index 620801bf2a05e4..265066c81383b0 100644
--- a/files/zh-cn/web/javascript/guide/modules/index.html
+++ b/files/zh-cn/web/javascript/guide/modules/index.html
@@ -78,7 +78,7 @@ 
        基本的示例文件的结构
        
 
    
 
 
    
-
    备注：在原生 JavaScript 模块中, 扩展名 .mjs 非常重要，因为使用 MIME-type 为 javascript/esm 来导入文件（其他的 JavaScript 兼容 MIME-type 像 application/javascript 也可以），它避免了严格的 MIME 类型检查错误，像 "The server responded with a non-JavaScript MIME type"。除此之外，.mjs 的扩展名很明了（比如这个就是一个模块，而不是一个传统 JavaScript 文件），还能够和其他工具互相适用。看这个 Google's note for further details。
    
+
    备注：在原生 JavaScript 模块中，扩展名 .mjs 非常重要，因为使用 MIME-type 为 javascript/esm 来导入文件（其他的 JavaScript 兼容 MIME-type 像 application/javascript 也可以），它避免了严格的 MIME 类型检查错误，像 "The server responded with a non-JavaScript MIME type"。除此之外，.mjs 的扩展名很明了（比如这个就是一个模块，而不是一个传统 JavaScript 文件），还能够和其他工具互相适用。看这个 Google's note for further details。
    
 
    
 
 
    .mjs 与 .js
    
@@ -90,7 +90,7 @@ 
    .mjs 与 .js
    
  
  • 这能保证你的模块可以被运行时环境和构建工具识别，比如 Node.js 和 Babel。
    • 
 
 
-
    但是我们决定继续使用 .js 扩展名，未来可能会更改。为了使模块可以在浏览器中正常地工作，你需要确保你的服务器能够正常地处理 Content-Type 头，其应该包含 JavaScript 的 MIME 类型 text/javascript。如果没有这么做，你可能会得到 一个严格 MIME 类型检查错误：“The server responded with a non-JavaScript MIME type （服务器返回了非 JavaScript MIME 类型）”，并且浏览器会拒绝执行相应的 JavaScript 代码。多数服务器可以正确地处理 .js 文件的类型，但是 .mjs 还不行。已经可以正常响应 .mjs 的服务器有 GitHub 页面 和 Node.js 的 http-server。
    
+
    但是我们决定继续使用 .js 扩展名，未来可能会更改。为了使模块可以在浏览器中正常地工作，你需要确保你的服务器能够正常地处理 Content-Type 头，其应该包含 JavaScript 的 MIME 类型 text/javascript。如果没有这么做，你可能会得到 一个严格 MIME 类型检查错误：“The server responded with a non-JavaScript MIME type（服务器返回了非 JavaScript MIME 类型）”，并且浏览器会拒绝执行相应的 JavaScript 代码。多数服务器可以正确地处理 .js 文件的类型，但是 .mjs 还不行。已经可以正常响应 .mjs 的服务器有 GitHub 页面 和 Node.js 的 http-server。
    
 
 
    如果你已经在使用相应的环境了，那么一切正常。或者如果你还没有，但你知道你在做什么（比如你可以配置服务器以为 .mjs 设置正确的 Content-Type）。但如果你不能控制提供服务，或者用于公开文件发布的服务器，这可能会导致混乱。
    
 
@@ -165,7 +165,7 @@ 
    导入功能到你的脚本
    
 reportPerimeter(square1.length, reportList);
 
    
 
-
    应用模块到你的HTML
    
+
    应用模块到你的 HTML
    
 
 
    现在我们只需要将 main.mjs 模块应用到我们的 HTML 页面。 这与我们将常规脚本应用于页面的方式非常相似，但有一些显着的差异。
    
 
@@ -443,7 +443,7 @@ 
    故障排除
    
 
    如果为了你的模块有问题，这里有一些提示有可能帮助到你。如果你发现更多的内容欢迎添加进来！
    
 
 
      
- 
    • 在前面已经提到了，在这里再重申一次： .mjs 后缀的文件需要以 MIME-type 为 javascript/esm 来加载(或者其他的 JavaScript 兼容的 MIME-type ，比如 application/javascript), 否则，你会一个严格的 MIME 类型检查错误，像是这样的 "The server responded with a non-JavaScript MIME type".
      • 
+ 
    • 在前面已经提到了，在这里再重申一次： .mjs 后缀的文件需要以 MIME-type 为 javascript/esm 来加载 (或者其他的 JavaScript 兼容的 MIME-type ，比如 application/javascript), 否则，你会一个严格的 MIME 类型检查错误，像是这样的 "The server responded with a non-JavaScript MIME type".
      • 
  
    • 如果你尝试用本地文件加载 HTML 文件 (i.e. with a file:// URL)，由于 JavaScript 模块的安全性要求，你会遇到 CORS 错误。你需要通过服务器来做你的测试。GitHub pages is ideal as it also serves .mjs files with the correct MIME type.
      • 
  
    • 因为 .mjs 是一个相当新的文件后缀，一些操作系统可能无法识别，或者尝试把它替换成别的。比如，我们发现 macOS 悄悄地在我们的 .mjs 后缀的文件后面添加上 .js 然后自动隐藏这个后缀。所以我们的文件实际上都是 x.mjs.js。当我们关闭自动隐藏文件后缀名，让它去接受认可 .mjs。问题解决。
      • 
 
    
diff --git a/files/zh-cn/web/javascript/guide/numbers_and_dates/index.html b/files/zh-cn/web/javascript/guide/numbers_and_dates/index.html
index 0c628571b1dc82..0abcf452158bb0 100644
--- a/files/zh-cn/web/javascript/guide/numbers_and_dates/index.html
+++ b/files/zh-cn/web/javascript/guide/numbers_and_dates/index.html
@@ -8,63 +8,63 @@
 ---
 
    {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Expressions_and_Operators", "Web/JavaScript/Guide/Text_formatting")}}
    
 
-
    本章节介绍了在JavaScript中使用数字和日期来处理和执行计算的概念，对象和函数。
    
+
    本章节介绍了在 JavaScript 中使用数字和日期来处理和执行计算的概念，对象和函数。
    
 
-
    本章节介绍如何掌握Javascript里的数字和日期类型
    
+
    本章节介绍如何掌握 Javascript 里的数字和日期类型
    
 
 
    数字
    
 
-
    在 JavaScript 里面，数字均为双精度浮点类型（double-precision 64-bit binary format IEEE 754），即一个介于±2^−1023和±2^+1024之间的数字，或约为±10^−308到±10^+308，数字精度为53位。整数数值仅在±(2^53 - 1)的范围内可以表示准确。
    
+
    在 JavaScript 里面，数字均为双精度浮点类型（double-precision 64-bit binary format IEEE 754），即一个介于±2^−1023 和±2^+1024 之间的数字，或约为±10^−308 到±10^+308，数字精度为 53 位。整数数值仅在±(2^53 - 1) 的范围内可以表示准确。
    
 
-
    除了能够表示浮点数，数字类型也还能表示三种符号值: +{{jsxref("Infinity")}}（正无穷）、-{{jsxref("Infinity")}}（负无穷）和 {{jsxref("NaN")}} (not-a-number，非数字)。
    
+
    除了能够表示浮点数，数字类型也还能表示三种符号值：+{{jsxref("Infinity")}}（正无穷）、-{{jsxref("Infinity")}}（负无穷）和 {{jsxref("NaN")}} (not-a-number，非数字)。
    
 
-
    JavaScript最近添加了 {{jsxref("BigInt")}} 的支持，能够用于表示极大的数字。使用 BigInt 的时候有一些注意事项，例如，你不能让 BigInt 和 {{jsxref("Number")}} 直接进行运算，你也不能用 {{jsxref("Math")}} 对象去操作 BigInt 数字。
    
+
    JavaScript 最近添加了 {{jsxref("BigInt")}} 的支持，能够用于表示极大的数字。使用 BigInt 的时候有一些注意事项，例如，你不能让 BigInt 和 {{jsxref("Number")}} 直接进行运算，你也不能用 {{jsxref("Math")}} 对象去操作 BigInt 数字。
    
 
-
    请参见Javascript指南中的 JavaScript 数据类型和数据结构 ，了解其他更多的基本类型。
    
+
    请参见 Javascript 指南中的 JavaScript 数据类型和数据结构 ，了解其他更多的基本类型。
    
 
 
    您可以使用四种数字进制：十进制，二进制，八进制和十六进制。
    
 
-
    十进制数字(Decimal numbers)
    
+
    十进制数字 (Decimal numbers)
    
 
 
    1234567890
 42
 // 以零开头的数字的注意事项：
 0888 // 888 将被当做十进制处理
-0777 // 在非严格格式下会被当做八进制处理 (用十进制表示就是511)
+0777 // 在非严格格式下会被当做八进制处理 (用十进制表示就是 511)
 
    
 
-
    请注意，十进制可以以0开头，后面接其他十进制数字，但是假如下一个接的十进制数字小于8，那么该数字将会被当做八进制处理。
    
+
    请注意，十进制可以以 0 开头，后面接其他十进制数字，但是假如下一个接的十进制数字小于 8，那么该数字将会被当做八进制处理。
    
 
-
    二进制数字(Binary numbers)
    
+
    二进制数字 (Binary numbers)
    
 
-
    二进制数字语法是以零为开头，后面接一个小写或大写的拉丁文字母B(0b或者是0B)。 假如0b后面的数字不是0或者1，那么就会提示这样的语法错误（ SyntaxError）： "Missing binary digits after 0b(0b之后缺失二有效的二进制数据)"。
    
+
    二进制数字语法是以零为开头，后面接一个小写或大写的拉丁文字母 B(0b 或者是 0B)。 假如 0b 后面的数字不是 0 或者 1，那么就会提示这样的语法错误（ SyntaxError）： "Missing binary digits after 0b(0b 之后缺失二有效的二进制数据)"。
    
 
 
    var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
 var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
 var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
    
 
-
    八进制数字(Octal numbers)
    
+
    八进制数字 (Octal numbers)
    
 
-
    八进制数字语法是以0为开头的。假如0后面的数字不在0到7的范围内，该数字将会被转换成十进制数字。
    
+
    八进制数字语法是以 0 为开头的。假如 0 后面的数字不在 0 到 7 的范围内，该数字将会被转换成十进制数字。
    
 
 
    var n = 0755; // 493
 var m = 0644; // 420
 
    
 
-
    在ECMAScript 5 严格模式下禁止使用八进制语法。八进制语法并不是ECMAScript 5规范的一部分，但是通过在八进制数字添加一个前缀0就可以被所有的浏览器支持：0644 === 420 而且 "\045" === "%"。在ECMAScript 6中使用八进制数字是需要给一个数字添加前缀"0o"。
    
+
    在 ECMAScript 5 严格模式下禁止使用八进制语法。八进制语法并不是 ECMAScript 5 规范的一部分，但是通过在八进制数字添加一个前缀 0 就可以被所有的浏览器支持：0644 === 420 而且 "\045" === "%"。在 ECMAScript 6 中使用八进制数字是需要给一个数字添加前缀"0o"。
    
 
 
    var a = 0o10; // ES6 :八进制
    
 
-
    十六进制(Hexadecimal numbers)
    
+
    十六进制 (Hexadecimal numbers)
    
 
-
    十六进制数字语法是以零为开头，后面接一个小写或大写的拉丁文字母X(0x或者是0X)。假如0x后面的数字超出规定范围(0123456789ABCDEF)，那么就会提示这样的语法错误(SyntaxError)："Identifier starts immediately after numeric literal".
    
+
    十六进制数字语法是以零为开头，后面接一个小写或大写的拉丁文字母 X(0x 或者是 0X)。假如0x后面的数字超出规定范围 (0123456789ABCDEF)，那么就会提示这样的语法错误 (SyntaxError)："Identifier starts immediately after numeric literal".
    
 
 
    0xFFFFFFFFFFFFFFFFF // 295147905179352830000
 0x123456789ABCDEF   // 81985529216486900
 0XA                 // 10
 
    
 
-
    指数形式(Exponentiation)
    
+
    指数形式 (Exponentiation)
    
 
 
    1E3   // 1000
 2e6   // 2000000
@@ -82,7 +82,7 @@ 
    数字对象
    
 var notANum = Number.NaN;
 
    
 
-
    你永远只用从Number对象引用上边显示的属性，而不是你自己创建的Number对象的属性。
    
+
    你永远只用从 Number 对象引用上边显示的属性，而不是你自己创建的 Number 对象的属性。
    
 
 
    下面的表格汇总了数字对象的属性：
    
 
@@ -119,16 +119,16 @@ 
    数字对象
    
   
    {{jsxref("Number.EPSILON")}}
    
-    
    表示1和比最接近1且大于1的最小{{jsxref("Number")}}之间的差别
    
+    
    表示 1 和比最接近 1 且大于 1 的最小{{jsxref("Number")}}之间的差别
    
    
   
   
    {{jsxref("Number.MIN_SAFE_INTEGER")}}
-   JavaScript最小安全整数.
+   JavaScript 最小安全整数。
   
   
    {{jsxref("Number.MAX_SAFE_INTEGER")}}
-   JavaScript最大安全整数.
+   JavaScript 最大安全整数。
   
  
 
@@ -145,12 +145,12 @@ 
    数字对象
    
   
    {{jsxref("Number.parseFloat()")}}
    把字符串参数解析成浮点数，
    
-    和全局方法 {{jsxref("parseFloat", "parseFloat()")}} 作用一致.
+    和全局方法 {{jsxref("parseFloat", "parseFloat()")}} 作用一致。
   
   
    {{jsxref("Number.parseInt()")}}
    
-    
    把字符串解析成特定基数对应的整型数字，和全局方法 {{jsxref("parseInt", "parseInt()")}} 作用一致.
    
+    
    把字符串解析成特定基数对应的整型数字，和全局方法 {{jsxref("parseInt", "parseInt()")}} 作用一致。
    
    
   
   
@@ -198,7 +198,7 @@ 
    数字对象
    
   
    {{jsxref("Number.toPrecision", "toPrecision()")}}
    
-    
    返回一个指定精度的数字。如下例子中，a=123中，3会由于精度限制消失
    
+    
    返回一个指定精度的数字。如下例子中，a=123 中，3 会由于精度限制消失
    
 
     
    var a=123,b=a.toPrecision(2)//b="1.2e+2"
    
    
@@ -208,21 +208,21 @@ 
    数字对象
    
 
 
    数学对象（Math）
    
 
-
    对于内置的{{jsxref("Math")}}数学常项和函数也有一些属性和方法。 比方说， Math对象的 PI 属性会有属性值 pi (3.141...)，你可以像这样调用它：
    
+
    对于内置的{{jsxref("Math")}}数学常项和函数也有一些属性和方法。 比方说， Math 对象的 PI 属性会有属性值 pi (3.141...)，你可以像这样调用它：
    
 
 
    Math.PI // π
 
    
 
-
    同理，标准数学函数也是Math的方法。 这些包括三角函数​​，对数，指数，和其他函数。比方说你想使用三角函数 sin， 你可以这么写：
    
+
    同理，标准数学函数也是 Math 的方法。 这些包括三角函数​​，对数，指数，和其他函数。比方说你想使用三角函数 sin， 你可以这么写：
    
 
 
    Math.sin(1.56)
 
    
 
-
    需要注意的是Math的所有三角函数参数都是弧度制。
    
+
    需要注意的是 Math 的所有三角函数参数都是弧度制。
    
 
 
    下面的表格总结了 Math 对象的方法。
    
 
-
    Math的方法
    
+
    Math 的方法
    
 
 
@@ -246,11 +246,11 @@ 
    数学对象（Math）
    
-   
+   
-   
+   
-   
+   
@@ -286,60 +286,60 @@ 
    数学对象（Math）
    
-   
+   
    
  
   
   
    
    {{jsxref("Math.sinh", "sinh()")}}, {{jsxref("Math.cosh", "cosh()")}}, {{jsxref("Math.tanh", "tanh()")}}双曲三角函数; 参数为弧度.双曲三角函数; 参数为弧度。
   
    
   
    
    {{jsxref("Math.asinh", "asinh()")}}, {{jsxref("Math.acosh", "acosh()")}}, {{jsxref("Math.atanh", "atanh()")}}反双曲三角函数;返回值为弧度.反双曲三角函数;返回值为弧度。
   
    
   
    
    
@@ -265,12 +265,12 @@ 
    数学对象（Math）
    
   
    
    {{jsxref("Math.min", "min()")}}, {{jsxref("Math.max", "max()")}}
    
-    
    返回一个以逗号间隔的数字参数列表中的较小或较大值(分别地)
    
+    
    返回一个以逗号间隔的数字参数列表中的较小或较大值 (分别地)
    
        		
   
    
   
    
    {{jsxref("Math.random", "random()")}}返回0和1之间的随机数。返回 0 和 1 之间的随机数。
   
    
   
    
    {{jsxref("Math.round", "round()")}}, {{jsxref("Math.fround", "fround()")}}, {{jsxref("Math.trunc", "trunc()")}},
   
    
   
    
    {{jsxref("Math.sign", "sign()")}}数字的符号, 说明数字是否为正、负、零。数字的符号，说明数字是否为正、负、零。
   
    
   
    
    {{jsxref("Math.clz32", "clz32()")}},
    
     {{jsxref("Math.imul", "imul()")}}    		
    
-    
    在32位2进制表示中，开头的0的数量.
    
+    
    在 32 位 2 进制表示中，开头的 0 的数量。
    
 
-    
    返回传入的两个参数相乘结果的类C的32位表现形式
    
+    
    返回传入的两个参数相乘结果的类 C 的 32 位表现形式
    
        		
   
    
  
 
    
 
-
    和其他对象不同，你不能够创建一个自己的Math对象。你只能使用内置的Math对象。
    
+
    和其他对象不同，你不能够创建一个自己的 Math 对象。你只能使用内置的 Math 对象。
    
 
 
    日期对象
    
 
-
    JavaScript没有日期数据类型。但是你可以在你的程序里使用 {{jsxref("Date")}} 对象和其方法来处理日期和时间。Date对象有大量的设置、获取和操作日期的方法。 它并不含有任何属性。
    
+
    JavaScript 没有日期数据类型。但是你可以在你的程序里使用 {{jsxref("Date")}} 对象和其方法来处理日期和时间。Date 对象有大量的设置、获取和操作日期的方法。 它并不含有任何属性。
    
 
-
    JavaScript 处理日期数据类似于Java。这两种语言有许多一样的处理日期的方法，也都是以1970年1月1日00:00:00以来的毫秒数来储存数据类型的。
    
+
    JavaScript 处理日期数据类似于 Java。这两种语言有许多一样的处理日期的方法，也都是以 1970 年 1 月 1 日 00:00:00 以来的毫秒数来储存数据类型的。
    
 
-
    Date 对象的范围是相对距离 UTC 1970年1月1日 的前后 100,000,000 天。
    
+
    Date 对象的范围是相对距离 UTC 1970 年 1 月 1 日 的前后 100,000,000 天。
    
 
 
    创建一个日期对象：
    
 
 
    var dateObjectName = new Date([parameters]);
 
    
 
-
    这里的 dateObjectName 对象是所创建的Date对象的一个名字，它可以成为一个新的对象或者已存在的其他对象的一个属性。
    
+
    这里的 dateObjectName 对象是所创建的 Date 对象的一个名字，它可以成为一个新的对象或者已存在的其他对象的一个属性。
    
 
-
    不使用 new 关键字来调用Date对象将返回当前时间和日期的字符串
    
+
    不使用 new 关键字来调用 Date 对象将返回当前时间和日期的字符串
    
 
 
    前边的语法中的参数（parameters）可以是一下任何一种：
    
 
 
      
  
    • 无参数 : 创建今天的日期和时间，例如： today = new Date();.
      • 
- 
    • 一个符合以下格式的表示日期的字符串: "月 日, 年 时:分:秒." 例如： var Xmas95 = new Date("December 25, 1995 13:30:00")。如果你省略时、分、秒，那么他们的值将被设置为0。
      • 
+ 
    • 一个符合以下格式的表示日期的字符串: "月 日，年 时：分:秒." 例如： var Xmas95 = new Date("December 25, 1995 13:30:00")。如果你省略时、分、秒，那么他们的值将被设置为 0。
      • 
  
    • 一个年，月，日的整型值的集合，例如： var Xmas95 = new Date(1995, 11, 25)。
      • 
  
    • 一个年，月，日，时，分，秒的集合，例如： var Xmas95 = new Date(1995, 11, 25, 9, 30, 0);.
      • 
 
    
 
-
    Date对象的方法
    
+
    Date 对象的方法
    
 
-
    处理日期时间的Date对象方法可分为以下几类：
    
+
    处理日期时间的 Date 对象方法可分为以下几类：
    
 
 
      
- 
    • "set" 方法, 用于设置Date对象的日期和时间的值。
      • 
- 
    • "get" 方法,用于获取Date对象的日期和时间的值。
      • 
- 
    • "to" 方法,用于返回Date对象的字符串格式的值。
      • 
- 
    • parse 和UTC 方法, 用于解析Date字符串。
      • 
+ 
    • "set" 方法，用于设置 Date 对象的日期和时间的值。
      • 
+ 
    • "get" 方法，用于获取 Date 对象的日期和时间的值。
      • 
+ 
    • "to" 方法，用于返回 Date 对象的字符串格式的值。
      • 
+ 
    • parse 和 UTC 方法，用于解析 Date 字符串。
      • 
 
    
 
-
    通过“get”和“set”方法，你可以分别设置和获取秒，分，时，日，星期，月份，年。这里有个getDay方法可以返回星期，但是没有相应的setDay方法用来设置星期，因为星期是自动设置的。这些方法用整数来代表以下这些值：
    
+
    通过“get”和“set”方法，你可以分别设置和获取秒，分，时，日，星期，月份，年。这里有个 getDay 方法可以返回星期，但是没有相应的 setDay 方法用来设置星期，因为星期是自动设置的。这些方法用整数来代表以下这些值：
    
 
 
      
  
    • 秒，分： 0 至 59
      • 
@@ -347,22 +347,22 @@ 
      Date对象的方法
      
  
    • 星期： 0 (周日) 至 6 (周六)
      • 
  
    • 日期：1 至 31 
      • 
  
    • 月份： 0 (一月) to 11 (十二月)
      • 
- 
    • 年份： 从1900开始的年数
      • 
+ 
    • 年份： 从 1900 开始的年数
      • 
 
    
 
-
    例如, 假设你定义了如下日期：
    
+
    例如，假设你定义了如下日期：
    
 
 
    var Xmas95 = new Date("December 25, 1995");
 
    
 
 
    Then Xmas95.getMonth() 返回 11, and Xmas95.getFullYear() 返回 1995.
    
 
-
    getTime 和 setTime 方法对于比较日期是非常有用的。getTime方法返回从1970年1月1日00:00:00的毫秒数。
    
+
    getTime 和 setTime 方法对于比较日期是非常有用的。getTime方法返回从 1970 年 1 月 1 日 00:00:00 的毫秒数。
    
 
 
    例如，以下代码展示了今年剩下的天数：
    
 
 
    var today = new Date();
-var endYear = new Date(1995, 11, 31, 23, 59, 59, 999); // 设置日和月，注意，月份是0-11
+var endYear = new Date(1995, 11, 31, 23, 59, 59, 999); // 设置日和月，注意，月份是 0-11
 endYear.setFullYear(today.getFullYear()); // 把年设置为今年
 var msPerDay = 24 * 60 * 60 * 1000; // 每天的毫秒数
 var daysLeft = (endYear.getTime() - today.getTime()) / msPerDay;
@@ -371,7 +371,7 @@ 
    Date对象的方法
    
 
 
    这个例子中，创建了一个包含今天的日期的Date对象，并命名为today，然后创建了一个名为endYear的Date对象，并把年份设置为当前年份，接着使用today和endYear的getTime分别获取今天和年底的毫秒数，再根据每一天的毫秒数，计算出了今天到年底的天数，最后四舍五入得到今年剩下的天数。
    
 
-
    parse方法对于从日期字符串赋值给现有的Date对象很有用，例如：以下代码使用parse和setTime分配了一个日期值给IPOdate对象：
    
+
    parse 方法对于从日期字符串赋值给现有的 Date 对象很有用，例如：以下代码使用parse和setTime分配了一个日期值给IPOdate对象：
    
 
 
    var IPOdate = new Date();
 IPOdate.setTime(Date.parse("Aug 9, 1995"));
@@ -379,7 +379,7 @@ 
    Date对象的方法
    
 
 
    例子：
    
 
-
    在下边的例子中，JSClock()函数返回了用数字时钟格式的时间：
    
+
    在下边的例子中，JSClock() 函数返回了用数字时钟格式的时间：
    
 
 
    function JSClock() {
   var time = new Date();
@@ -398,10 +398,10 @@ 
    例子：
    
 
 
    JSClock函数首先创建了一个叫做time的新的Date对象，因为没有参数，所以time代表了当前日期和时间。然后调用了getHours，getMinutes以及getSeconds方法把当前的时分秒分别赋值给了hour，minute，second。
    
 
-
    接下来的4句在time的基础上创建了一个字符串，第一句创建了一个变量temp，并通过一个条件表达式进行了赋值，如果小时大于12，就为(hour - 12)，其他情况就为hour，除非hour为0，这种情况下，它会变成12。
    
+
    接下来的 4 句在time的基础上创建了一个字符串，第一句创建了一个变量temp，并通过一个条件表达式进行了赋值，如果小时大于 12，就为 (hour - 12)，其他情况就为hour，除非hour为 0，这种情况下，它会变成 12。
    
 
-
    接下来的语句拼接了minute的值到temp后。如果minute小于10，条件表达式就会在minute前边加个0，其他情况下加一个冒号。然后按同样的方式在temp后拼接上了秒。
    
+
    接下来的语句拼接了minute的值到temp后。如果minute小于 10，条件表达式就会在minute前边加个 0，其他情况下加一个冒号。然后按同样的方式在temp后拼接上了秒。
    
 
-
    最后，如果hour是12或者更大，条件表达式会在temp后拼接"P.M."，否则拼接"A.M."。
    
+
    最后，如果hour是 12 或者更大，条件表达式会在temp后拼接"P.M."，否则拼接"A.M."。
    
 
 
    {{PreviousNext("Web/JavaScript/Guide/Expressions_and_Operators", "Web/JavaScript/Guide/Text_formatting")}}
    
diff --git a/files/zh-cn/web/javascript/guide/regular_expressions/assertions/index.html b/files/zh-cn/web/javascript/guide/regular_expressions/assertions/index.html
index 0d2c51777f0880..1c33f2e5ee030c 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/assertions/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/assertions/index.html
@@ -46,14 +46,14 @@ 
    边界类断言
    
   
    \b
    
-    
    匹配一个单词的边界，这是一个字的字符前后没有另一个字的字符位置, 例如在字母和空格之间。需要注意的是匹配的单词边界不包括在匹配中。换句话说，匹配字边界的长度为零。
    
+    
    匹配一个单词的边界，这是一个字的字符前后没有另一个字的字符位置，例如在字母和空格之间。需要注意的是匹配的单词边界不包括在匹配中。换句话说，匹配字边界的长度为零。
    
 
-    
    一些例子:
    
+    
    一些例子：
    
 
     
      
      
    • /\bm/  在 "moon" 中匹配到 "m" 
      • 
-     
    • /oo\b/  在 "moon" 中不会匹配到 "oo", 因为 "oo" 后面跟着 "n" 这个单词字符.
      • 
-     
    • /oon\b/ 在 "moon" 中匹配 "oon"， 因为 "oon" 是这个字符串的结尾, 因此后面没有单词字符
      • 
+     
    • /oo\b/  在 "moon" 中不会匹配到 "oo", 因为 "oo" 后面跟着 "n" 这个单词字符。
      • 
+     
    • /oon\b/ 在 "moon" 中匹配 "oon"， 因为 "oon" 是这个字符串的结尾，因此后面没有单词字符
      • 
      
    • /\w\b\w/ 将永远不会匹配任何东西，因为一个单词字符后面永远不会有非单词字符和单词字符。
      • 
     
    
 
@@ -91,7 +91,7 @@ 
    其他断言 
    
     
-       
+       
    
      
       
    向前断言: x 被 y 跟随时匹配 x。例如，对于/Jack(?=Sprat)/，“Jack”在跟有“Sprat”的情况下才会得到匹配．/Jack(?=Sprat|Frost)/ “Jack”后跟有“Sprat”或“Frost”的情况下才会得到匹配。不过， 匹配结果不包括“Sprat”或“Frost”。向前断言： x 被 y 跟随时匹配 x。例如，对于/Jack(?=Sprat)/，“Jack”在跟有“Sprat”的情况下才会得到匹配．/Jack(?=Sprat|Frost)/ “Jack”后跟有“Sprat”或“Frost”的情况下才会得到匹配。不过， 匹配结果不包括“Sprat”或“Frost”。
       
    
          
     
    
@@ -103,7 +103,7 @@ 
    其他断言 
    
     
-       
+       
    
      
       
    向前否定断言: x 没有被 y 紧随时匹配 x。例如，对于/\d+(?!\.)/，数字后没有跟随小数点的情况下才会得到匹配。对于/\d+(?!\.)/.exec(3.141)，匹配‘141’而不是‘3’。向前否定断言： x 没有被 y 紧随时匹配 x。例如，对于/\d+(?!\.)/，数字后没有跟随小数点的情况下才会得到匹配。对于/\d+(?!\.)/.exec(3.141)，匹配‘141’而不是‘3’。
       
    
          
     
    
@@ -115,7 +115,7 @@ 
    其他断言 
    
     
-       
+       
    
      
       
    向后断言: x 跟随 y 的情况下匹配 x。例如，对于/(?<=Jack)Sprat/，“Sprat”紧随“Jack”时才会得到匹配。对于/(?<=Jack|Tom)Sprat，“Sprat”在紧随“Jack”或“Tom”的情况下才会得到匹配。不过，匹配结果中不包括“Jack”或“Tom”。向后断言： x 跟随 y 的情况下匹配 x。例如，对于/(?<=Jack)Sprat/，“Sprat”紧随“Jack”时才会得到匹配。对于/(?<=Jack|Tom)Sprat，“Sprat”在紧随“Jack”或“Tom”的情况下才会得到匹配。不过，匹配结果中不包括“Jack”或“Tom”。
       
    
          
     
    
@@ -127,7 +127,7 @@ 
    其他断言 
    
     
-       
+       
    
      
       
    向后否定断言: x 不跟随 y 时匹配 x。例如，对于/(?<!-)\d+/，数字不紧随-符号的情况下才会得到匹配。对于/(?<!-)\d+/.exec(3) ，“3”得到匹配。 而/(?<!-)\d+/.exec(-3)的结果无匹配，这是由于数字之前有-符号。向后否定断言： x 不跟随 y 时匹配 x。例如，对于/(?<!-)\d+/，数字不紧随 - 符号的情况下才会得到匹配。对于/(?<!-)\d+/.exec(3) ，“3”得到匹配。 而/(?<!-)\d+/.exec(-3)的结果无匹配，这是由于数字之前有 - 符号。
       
    
          
     
    
@@ -144,30 +144,30 @@ 
    一般边界类型概述示例
    
 buggyMultiline = `tey, ihe light-greon apple
 tangs on ihe greon traa`;
 
-// 1) 使用 ^ 修正字符串开始处和换行后的匹配.
+// 1) 使用 ^ 修正字符串开始处和换行后的匹配。
 buggyMultiline = buggyMultiline.replace(/^t/gim,'h');
 console.log(1, buggyMultiline); // 修复 'tey'=>'hey'(字符串开始) , 'tangs'=>'hangs'(换行后)
 
-// 2) 使用 $ 修正字符串结尾处的匹配.
+// 2) 使用 $ 修正字符串结尾处的匹配。
 buggyMultiline = buggyMultiline.replace(/aa$/gim,'ee.');
 console.log(2, buggyMultiline); // 修复 'traa' => 'tree'.
 
-// 3) 使用 \b 修正单词和空格边界上的字符.
+// 3) 使用 \b 修正单词和空格边界上的字符。
 buggyMultiline = buggyMultiline.replace(/\bi/gim,'t');
 console.log(3, buggyMultiline); // 修复 'ihe' => 'the'  不影响 'light'.
 
-// 4) 使用 \B 匹配实体边界内的字符.
+// 4) 使用 \B 匹配实体边界内的字符。
 fixedMultiline = buggyMultiline.replace(/\Bo/gim,'e');
 console.log(4, fixedMultiline); // 修复  'greon'  不影响'on'.
    
 
 
    使用 ^（控制字符）匹配输入的开头
    
 
-
    使用 ^匹配输入的开头。在这个例子中，我们可以通过 /^A/ 正则表达式得到以A开头的水果。为了选择合适的水果，我们可以使用带有箭头函数的过滤方法.
    
+
    使用 ^匹配输入的开头。在这个例子中，我们可以通过 /^A/ 正则表达式得到以 A 开头的水果。为了选择合适的水果，我们可以使用带有箭头函数的过滤方法。
    
 
 
    let fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
 
-// 使用正则 /^A/ 选择以'A'开头的水果.
-// 这里的 '^' 只有一种含义: 匹配输入的开头.
+// 使用正则 /^A/ 选择以'A'开头的水果。
+// 这里的 '^' 只有一种含义：匹配输入的开头。
 
 let fruitsStartsWithA = fruits.filter(fruit => /^A/.test(fruit));
 console.log(fruitsStartsWithA); // [ 'Apple', 'Avocado' ]
    
@@ -177,7 +177,7 @@ 
    使用 ^（控制字符
 
    let fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
 
 // 使用正则 /^[^A]/ 选择 不是以 ‘A’ 开头的水果
-// 在这个例子中，“^” 控件符号表示两种含义:
+// 在这个例子中，“^” 控件符号表示两种含义：
 // 1) 匹配输入的开头
 // 2) 一个否定的字符集: [^A] ，意思是匹配不是 ‘A’ 的字符
 
@@ -189,7 +189,7 @@ 
    匹配字边界
    
 
 
    let fruitsWithDescription = ["Red apple", "Orange orange", "Green Avocado"];
 
-// 选择包含以 “en” 或 “ed” 结尾的单词的描述:
+// 选择包含以 “en” 或 “ed” 结尾的单词的描述：
 let enEdSelection = fruitsWithDescription.filter(descr => /(en|ed)\b/.test(descr));
 
 console.log(enEdSelection); // [ 'Red apple', 'Green Avocado' ]
    
@@ -207,7 +207,7 @@ 
    向前断言
    
 
 
    向前否定断言
    
 
-
    例如, /\d+(?!\.)/ 匹配没有被小数点跟随且至少有一位的数字。 /\d+(?!\.)/.exec('3.141') 匹配 "141" 而不是 "3" 
    
+
    例如， /\d+(?!\.)/ 匹配没有被小数点跟随且至少有一位的数字。 /\d+(?!\.)/.exec('3.141') 匹配 "141" 而不是 "3" 
    
 
 
    console.log(/\d+(?!\.)/g.exec('3.141')); // [ '141', index: 2, input: '3.141' ]
    
 
diff --git a/files/zh-cn/web/javascript/guide/regular_expressions/character_classes/index.html b/files/zh-cn/web/javascript/guide/regular_expressions/character_classes/index.html
index 09cf23daa01506..38553d9d09ccb6 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/character_classes/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/character_classes/index.html
@@ -26,40 +26,40 @@ 
    类型
    
   
    .
    
-    
    有下列含义之一:
    
+    
    有下列含义之一：
    
 
     
      
-     
    • 匹配除行终止符之外的任何单个字符: \n, \r, \u2028 or \u2029. 例如, /.y/ 在“yes make my day”中匹配“my”和“ay”，而不是“yes”。
      • 
+     
    • 匹配除行终止符之外的任何单个字符：\n, \r, \u2028 or \u2029. 例如，/.y/ 在“yes make my day”中匹配“my”和“ay”，而不是“yes”。
      • 
      
    • 在字符集内，点失去了它的特殊意义，并与文字点匹配。
      • 
     
    
 
-    
    需要注意的是，m multiline标志不会改变点的行为。因此，要跨多行匹配一个模式，可以使用字符集[^]—它将匹配任何字符，包括新行。
    
+    
    需要注意的是，m multiline 标志不会改变点的行为。因此，要跨多行匹配一个模式，可以使用字符集[^]—它将匹配任何字符，包括新行。
    
 
-    
    ES2018 添加了 s "dotAll" 标志,它允许点也匹配行终止符。
    
+    
    ES2018 添加了 s "dotAll" 标志，它允许点也匹配行终止符。
    
    
   
   
    \d
    
-    
    匹配任何数字(阿拉伯数字)。 相当于 [0-9]. 例如, /\d/ 或 /[0-9]/ 匹配 “B2is the suite number”中的“2”。
    
+    
    匹配任何数字 (阿拉伯数字)。 相当于 [0-9]. 例如，/\d/ 或 /[0-9]/ 匹配 “B2is the suite number”中的“2”。
    
    
   
   
    \D
    
-    
    匹配任何非数字(阿拉伯数字)的字符。相当于[^0-9]. 例如, /\D/ or /[^0-9]/ 在 "B2 is the suite number" 中 匹配 "B".
    
+    
    匹配任何非数字 (阿拉伯数字) 的字符。相当于[^0-9]. 例如，/\D/ or /[^0-9]/ 在 "B2 is the suite number" 中 匹配 "B".
    
    
   
   
    \w
    
-    
    匹配基本拉丁字母中的任何字母数字字符，包括下划线。相当于 [A-Za-z0-9_]. 例如, /\w/ 在 "apple" 匹配 "a" , "5" in "$5.28", "3" in "3D" and "m" in "Émanuel".
    
+    
    匹配基本拉丁字母中的任何字母数字字符，包括下划线。相当于 [A-Za-z0-9_]. 例如，/\w/ 在 "apple" 匹配 "a" , "5" in "$5.28", "3" in "3D" and "m" in "Émanuel".
    
    
   
   
    \W
    
-    
    匹配任何不是来自基本拉丁字母的单词字符。相当于 [^A-Za-z0-9_]. 例如, /\W/ or /[^A-Za-z0-9_]/ 匹配 "%" 在 "50%" 以及 "É" 在 "Émanuel" 中.
    
+    
    匹配任何不是来自基本拉丁字母的单词字符。相当于 [^A-Za-z0-9_]. 例如，/\W/ or /[^A-Za-z0-9_]/ 匹配 "%" 在 "50%" 以及 "É" 在 "Émanuel" 中。
    
    
   
   
diff --git a/files/zh-cn/web/javascript/guide/regular_expressions/groups_and_ranges/index.html b/files/zh-cn/web/javascript/guide/regular_expressions/groups_and_ranges/index.html
index f0045774ff5fc4..e051a59f3172b5 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/groups_and_ranges/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/groups_and_ranges/index.html
@@ -31,11 +31,11 @@ 
    类型
    
    
     
    字符集。 匹配任何一个包含的字符。您可以使用连字符来指定字符范围，但如果连字符显示为方括号中的第一个或最后一个字符，则它将被视为作为普通字符包含在字符集中的文字连字符。也可以在字符集中包含字符类。
    
 
-    
    例如, [abcd] 是与[a-d].一样的，它们会 在"brisket" 中匹配 "b",在 "chop" 中匹配 "c" .
    
+    
    例如，[abcd] 是与[a-d].一样的，它们会 在"brisket" 中匹配 "b",在 "chop" 中匹配 "c" .
    
 
-    
    例如, [abcd-] 和[-abcd] 将会在 "brisket" 匹配 "b" , 在 "chop" 匹配 "c" , 并且匹配 "non-profit" 中的 "-" (连字符)
    
+    
    例如，[abcd-] 和[-abcd] 将会在 "brisket" 匹配 "b" , 在 "chop" 匹配 "c" , 并且匹配 "non-profit" 中的 "-" (连字符)
    
 
-    
    例如, [\w-] 是字符集 \w 和 “-”（连字符）的并集，与这种写法一样： [A-Za-z0-9_-].。他们都会 在 "brisket"中匹配 “b”,  在 "chop"中匹配 “c”, 在 "non-profit" 中匹配 "n"。
    
+    
    例如，[\w-] 是字符集 \w 和 “-”（连字符）的并集，与这种写法一样： [A-Za-z0-9_-].。他们都会 在 "brisket"中匹配 “b”,  在 "chop"中匹配 “c”, 在 "non-profit" 中匹配 "n"。
    
    
   
   
@@ -44,7 +44,7 @@ 
    类型
    
      [^a-c]
    
    
    
-    
    一个否定的或被补充的字符集。也就是说，它匹配任何没有包含在括号中的字符。可以通过使用连字符来指定字符范围，但是如果连字符作为方括号中的第一个或最后一个字符出现，那么它将被视为作为普通字符包含在字符集中。例如，[^abc]和[^a-c]一样。它们最初匹配“bacon”中的“o”和“chop”中的“h”。
    
+    
    一个否定的或被补充的字符集。也就是说，它匹配任何没有包含在括号中的字符。可以通过使用连字符来指定字符范围，但是如果连字符作为方括号中的第一个或最后一个字符出现，那么它将被视为作为普通字符包含在字符集中。例如，[^abc] 和 [^a-c] 一样。它们最初匹配“bacon”中的“o”和“chop”中的“h”。
    
 
     
    
     
    备注： ^ 字符也可以表示   输入的起始
    
@@ -54,27 +54,27 @@ 
    类型
    
   
    (x)
    
-    
    捕获组: 匹配x并记住匹配项。例如，/(foo)/匹配并记住“foo bar”中的“foo” 
    
+    
    捕获组: 匹配 x 并记住匹配项。例如，/(foo)/匹配并记住“foo bar”中的“foo” 
    
 
     
    正则表达式可以有多个捕获组。结果，匹配通常在数组中捕获的组，该数组的成员与捕获组中左括号的顺序相同。这通常只是捕获组本身的顺序。当捕获组被嵌套时，这一点非常重要。使用结果元素的索引 ([1], ..., [n]) 或从预定义的 RegExp 对象的属性 ($1, ..., $9).
    
 
-    
    捕获组会带来性能损失。如果不需要收回匹配的子字符串，请选择非捕获括号(见下面)。
    
+    
    捕获组会带来性能损失。如果不需要收回匹配的子字符串，请选择非捕获括号 (见下面)。
    
 
-    
    String.match() 不会返回组，如果设置了 /.../g 标志. 但是，您仍然可以使用 String.matchAll() to get all matches.
    
+    
    String.match() 不会返回组，如果设置了 /.../g 标志。但是，您仍然可以使用 String.matchAll() to get all matches.
    
 
-    
    match()不会返回组，如果/…但是，您仍然可以使用String.matchAll()来获取所有匹配项。
    
+    
    match() 不会返回组，如果/…但是，您仍然可以使用 String.matchAll() 来获取所有匹配项。
    
    
   
   
    \n
    
-    
    其中n是一个正整数。对正则表达式中与n括号匹配的最后一个子字符串的反向引用(计算左括号)。例如，/apple(,)\sorange\1/ 匹配 “apple，orange，cherry，peach” 中的 "apple，orange，"， 其中 \1 引用了 之前使用 （） 捕获的 ，
    
+    
    其中 n 是一个正整数。对正则表达式中与 n 括号匹配的最后一个子字符串的反向引用 (计算左括号)。例如，/apple(,)\sorange\1/ 匹配 “apple，orange，cherry，peach” 中的 "apple，orange，"， 其中 \1 引用了 之前使用 （） 捕获的 ，
    
    
   
   
    (?<Name>x)
    
-    
    具名捕获组: 匹配"x"并将其存储在返回的匹配项的groups属性中，该属性位于<Name>指定的名称下。尖括号(< 和 >) 用于组名。
    
+    
    具名捕获组: 匹配"x"并将其存储在返回的匹配项的 groups 属性中，该属性位于<Name>指定的名称下。尖括号 (< 和 >) 用于组名。
    
 
     
    例如，使用正则 /-(?<customName>\w)/ 匹配 “web-doc” 中的 “d”
    
 
@@ -83,7 +83,7 @@ 
    类型
    
   
   
    (?:x)
-   非捕获组: 匹配 “x”，但不记得匹配。不能从结果数组的元素中收回匹配的子字符串([1], ..., [n]) or from the predefined RegExp object's properties ($1, ..., $9).
+   非捕获组: 匹配 “x”，但不记得匹配。不能从结果数组的元素中收回匹配的子字符串 ([1], ..., [n]) or from the predefined RegExp object's properties ($1, ..., $9).
   
  
 
@@ -112,8 +112,8 @@ 
    使用 组
    
 
 
    使用命名组
    
 
-
    let users= `姓氏: 李, 名字: 雷
-姓氏: 韩, 名字: 梅梅`;
+
    let users= `姓氏：李，名字：雷
+姓氏：韩，名字：梅梅`;
 
 let regexpNames =  /姓氏: (?<first>.+), 名字: (?<last>.+)/mg;
 let match = regexpNames.exec(users);
diff --git a/files/zh-cn/web/javascript/guide/regular_expressions/index.html b/files/zh-cn/web/javascript/guide/regular_expressions/index.html
index 2b1c6b0eb9dfa9..0dc45d5cde7b7f 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/index.html
@@ -13,7 +13,7 @@
 ---
 
    {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Text_formatting", "Web/JavaScript/Guide/Indexed_collections")}}
    
 
-
    正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript中，正则表达式也是对象。这些模式被用于 {{jsxref("RegExp")}} 的 {{jsxref("RegExp.exec", "exec")}} 和 {{jsxref("RegExp.test", "test")}} 方法, 以及 {{jsxref("String")}} 的 {{jsxref("String.match", "match")}}、{{jsxref("String.matchAll", "matchAll")}}、{{jsxref("String.replace", "replace")}}、{{jsxref("String.search", "search")}} 和 {{jsxref("String.split", "split")}} 方法。本章介绍 JavaScript 正则表达式。
    
+
    正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript 中，正则表达式也是对象。这些模式被用于 {{jsxref("RegExp")}} 的 {{jsxref("RegExp.exec", "exec")}} 和 {{jsxref("RegExp.test", "test")}} 方法，以及 {{jsxref("String")}} 的 {{jsxref("String.match", "match")}}、{{jsxref("String.matchAll", "matchAll")}}、{{jsxref("String.replace", "replace")}}、{{jsxref("String.search", "search")}} 和 {{jsxref("String.split", "split")}} 方法。本章介绍 JavaScript 正则表达式。
    
 
 
    创建一个正则表达式
    
 
@@ -148,7 +148,7 @@ 
    使用特殊字符
    
   
    (?:x)
    
-    
    匹配 'x' 但是不记住匹配项。这种括号叫作非捕获括号，使得你能够定义与正则表达式运算符一起使用的子表达式。看看这个例子 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2} 将只应用于 'foo' 的最后一个字符 'o'。如果使用非捕获括号，则 {1,2} 会应用于整个 'foo' 单词。更多信息，可以参阅下文的 Using parentheses 条目.
    
+    
    匹配 'x' 但是不记住匹配项。这种括号叫作非捕获括号，使得你能够定义与正则表达式运算符一起使用的子表达式。看看这个例子 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2} 将只应用于 'foo' 的最后一个字符 'o'。如果使用非捕获括号，则 {1,2} 会应用于整个 'foo' 单词。更多信息，可以参阅下文的 Using parentheses 条目。
    
    
   
   
@@ -172,7 +172,7 @@ 
    使用特殊字符
    
    
     
    仅仅当'x'后面不跟着'y'时匹配'x'，这被称为正向否定查找。
    
 
-    
    例如，仅仅当这个数字后面没有跟小数点的时候，/\d+(?!\.)/ 匹配一个数字。正则表达式/\d+(?!\.)/.exec("3.141")匹配‘141’而不是‘3.141’
    
+    
    例如，仅仅当这个数字后面没有跟小数点的时候，/\d+(?!\.)/ 匹配一个数字。正则表达式/\d+(?!\.)/.exec("3.141") 匹配‘141’而不是‘3.141’
    
    
   
   
@@ -180,7 +180,7 @@ 
    使用特殊字符
    
    
     
    仅仅当'x'前面不是'y'时匹配'x'，这被称为反向否定查找。
    
 
-    
    例如, 仅仅当这个数字前面没有负号的时候，/(?<!-)\d+/ 匹配一个数字。
    
+    
    例如，仅仅当这个数字前面没有负号的时候，/(?<!-)\d+/ 匹配一个数字。
    
      /(?<!-)\d+/.exec('3') 匹配到 "3".
    
      /(?<!-)\d+/.exec('-3') 因为这个数字前有负号，所以没有匹配到。
    
    
@@ -201,23 +201,23 @@ 
    使用特殊字符
    
   
    {n,}
    
-    
    n是一个正整数，匹配前一个字符至少出现了n次。
    
+    
    n 是一个正整数，匹配前一个字符至少出现了 n 次。
    
 
-    
    例如, /a{2,}/ 匹配 "aa", "aaaa" 和 "aaaaa" 但是不匹配 "a"。
    
+    
    例如，/a{2,}/ 匹配 "aa", "aaaa" 和 "aaaaa" 但是不匹配 "a"。
    
    
   
   
    {n,m}
    
-    
    n 和 m 都是整数。匹配前面的字符至少n次，最多m次。如果 n 或者 m 的值是0， 这个值被忽略。
    
+    
    n 和 m 都是整数。匹配前面的字符至少 n 次，最多 m 次。如果 n 或者 m 的值是 0， 这个值被忽略。
    
 
-    
    例如，/a{1, 3}/ 并不匹配“cndy”中的任意字符，匹配“candy”中的a，匹配“caandy”中的前两个a，也匹配“caaaaaaandy”中的前三个a。注意，当匹配”caaaaaaandy“时，匹配的值是“aaa”，即使原始的字符串中有更多的a。
    
+    
    例如，/a{1, 3}/ 并不匹配“cndy”中的任意字符，匹配“candy”中的 a，匹配“caandy”中的前两个 a，也匹配“caaaaaaandy”中的前三个 a。注意，当匹配”caaaaaaandy“时，匹配的值是“aaa”，即使原始的字符串中有更多的 a。
    
    
   
   
    [xyz]
    一个字符集合。匹配方括号中的任意字符，包括转义序列。你可以使用破折号（-）来指定一个字符范围。对于点（.）和星号（*）这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义，不过转义也是起作用的。
    
-    例如，[abcd] 和[a-d]是一样的。他们都匹配"brisket"中的‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/与字符串“test.i.ng”匹配。
+    例如，[abcd] 和 [a-d] 是一样的。他们都匹配"brisket"中的‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/与字符串“test.i.ng”匹配。
   
   
    [^xyz]
@@ -230,13 +230,13 @@ 
    使用特殊字符
    
   
    [\b]
    
-    
    匹配一个退格(U+0008)。（不要和\b混淆了。）
    
+    
    匹配一个退格 (U+0008)。（不要和\b混淆了。）
    
    
   
   
    \b
    
-    
    匹配一个词的边界。一个词的边界就是一个词不被另外一个“字”字符跟随的位置或者前面跟其他“字”字符的位置，例如在字母和空格之间。注意，匹配中不包括匹配的字边界。换句话说，一个匹配的词的边界的内容的长度是0。（不要和[\b]混淆了）
    
+    
    匹配一个词的边界。一个词的边界就是一个词不被另外一个“字”字符跟随的位置或者前面跟其他“字”字符的位置，例如在字母和空格之间。注意，匹配中不包括匹配的字边界。换句话说，一个匹配的词的边界的内容的长度是 0。（不要和 [\b] 混淆了）
    
 
     
    使用"moon"举例：
    
      /\bm/匹配“moon”中的‘m’；
    
@@ -245,7 +245,7 @@ 
    使用特殊字符
    
      /\w\b\w/将不能匹配任何字符串，因为在一个单词中间的字符永远也不可能同时满足没有“字”字符跟随和有“字”字符跟随两种情况。
    
 
     
    
-    
    备注： JavaScript的正则表达式引擎将特定的字符集定义为“字”字符。不在该集合中的任何字符都被认为是一个断词。这组字符相当有限：它只包括大写和小写的罗马字母，十进制数字和下划线字符。不幸的是，重要的字符，例如“é”或“ü”，被视为断词。
    
+    
    备注： JavaScript 的正则表达式引擎将特定的字符集定义为“字”字符。不在该集合中的任何字符都被认为是一个断词。这组字符相当有限：它只包括大写和小写的罗马字母，十进制数字和下划线字符。不幸的是，重要的字符，例如“é”或“ü”，被视为断词。
    
     
    
    
   
@@ -268,7 +268,7 @@ 
    使用特殊字符
    
   
    \cX
    
-    
    当X是处于A到Z之间的字符的时候，匹配字符串中的一个控制符。
    
+    
    当 X 是处于 A 到 Z 之间的字符的时候，匹配字符串中的一个控制符。
    
 
     
    例如，/\cM/ 匹配字符串中的 control-M (U+000D)。
    
    
@@ -276,7 +276,7 @@ 
    使用特殊字符
    
   
    \d
    
-    
    匹配一个数字。等价于[0-9]。
    
+    
    匹配一个数字。等价于 [0-9]。
    
 
     
    例如， /\d/ 或者 /[0-9]/ 匹配"B2 is the suite number."中的'2'。
    
    
@@ -284,7 +284,7 @@ 
    使用特殊字符
    
   
    \D
    
-    
    匹配一个非数字字符。等价于[^0-9]。
    
+    
    匹配一个非数字字符。等价于 [^0-9]。
    
 
     
    例如， /\D/ 或者 /[^0-9]/ 匹配"B2 is the suite number."中的'B' 。
    
    
@@ -304,11 +304,11 @@ 
    使用特殊字符
    
   
    \s
    
-    
    匹配一个空白字符，包括空格、制表符、换页符和换行符。等价于[ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。
    
+    
    匹配一个空白字符，包括空格、制表符、换页符和换行符。等价于 [ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]。
    
 
-    
    例如, /\s\w*/ 匹配"foo bar."中的' bar'。
    
+    
    例如，/\s\w*/ 匹配"foo bar."中的' bar'。
    
 
-    
    经测试，\s不匹配"\u180e"，在当前版本Chrome(v80.0.3987.122)和Firefox(76.0.1)控制台输入/\s/.test("\u180e")均返回false。
    
+    
    经测试，\s不匹配"\u180e"，在当前版本 Chrome(v80.0.3987.122) 和 Firefox(76.0.1) 控制台输入/\s/.test("\u180e") 均返回 false。
    
    
   
   
@@ -332,7 +332,7 @@ 
    使用特殊字符
    
    
     
    匹配一个单字字符（字母、数字或者下划线）。等价于 [A-Za-z0-9_]。
    
 
-    
    例如, /\w/ 匹配 "apple," 中的 'a'，"$5.28,"中的 '5' 和 "3D." 中的 '3'。
    
+    
    例如，/\w/ 匹配 "apple," 中的 'a'，"$5.28,"中的 '5' 和 "3D." 中的 '3'。
    
    
   
   
@@ -340,13 +340,13 @@ 
    使用特殊字符
    
    
     
    匹配一个非单字字符。等价于 [^A-Za-z0-9_]。
    
 
-    
    例如, /\W/ 或者 /[^A-Za-z0-9_]/ 匹配 "50%." 中的 '%'。
    
+    
    例如，/\W/ 或者 /[^A-Za-z0-9_]/ 匹配 "50%." 中的 '%'。
    
    
   
   
    \n
    
-    
    在正则表达式中，它返回最后的第n个子捕获匹配的子字符串(捕获的数目以左括号计数)。
    
+    
    在正则表达式中，它返回最后的第 n 个子捕获匹配的子字符串 (捕获的数目以左括号计数)。
    
 
     
    比如 /apple(,)\sorange\1/ 匹配"apple, orange, cherry, peach."中的'apple, orange,' 。
    
    
@@ -367,7 +367,7 @@ 
    使用特殊字符
    
    
     
    \u{hhhh}或\u{hhhhh}
    
    
-   （仅当设置了u标志时）匹配一个十六进制数表示的 Unicode 字符。
+   （仅当设置了 u 标志时）匹配一个十六进制数表示的 Unicode 字符。
   
  
 
@@ -380,9 +380,9 @@ 
    Escaping
    
 
 
    要匹配文本符号反斜杠，您需要转义反斜杠。 例如，要匹配字符串“C:\”，其中“C”可以是任何字母，您将使用/[A-Z]:\\/ —— 第一个反斜杠转义后面的那个反斜杠，因此表达式搜索单个普通字符反斜杠。
    
 
-
    如果将RegExp构造函数与字符串文字一起使用，请记住反斜杠是字符串文字中的转义，因此要在正则表达式中使用它，您需要在字符串文字级别转义它。 /a\*b/ 和new RegExp("a\\*b")创建的表达式是相同的，搜索“a”后跟文字“*”后跟“b”。
    
+
    如果将 RegExp 构造函数与字符串文字一起使用，请记住反斜杠是字符串文字中的转义，因此要在正则表达式中使用它，您需要在字符串文字级别转义它。 /a\*b/ 和new RegExp("a\\*b")创建的表达式是相同的，搜索“a”后跟文字“*”后跟“b”。
    
 
-
    将用户输入转义为正则表达式中的一个字面字符串, 可以通过简单的替换来实现：
    
+
    将用户输入转义为正则表达式中的一个字面字符串，可以通过简单的替换来实现：
    
 
 
    function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -391,17 +391,17 @@ 
    Escaping
    
 
 
    正则表达式后的"g"是一个表示全局搜索选项或标记，将在整个字符串查找并返回所有匹配结果。这将在下面的通过标志进行高级搜索详述。
    
 
-
    为什么这个没有内建在JavaScript中？之前有计划在RegExp对象中添加一个Function，但在TC39中被否决了。
    
+
    为什么这个没有内建在 JavaScript 中？之前有计划在 RegExp 对象中添加一个 Function，但在TC39中被否决了。
    
 
 
    使用插入语
    
 
 
    任何正则表达式的插入语都会使这部分匹配的副字符串被记忆。一旦被记忆，这个副字符串就可以被调用于其它用途，如同 使用括号的子字符串匹配之中所述。
    
 
-
    比如， /Chapter (\d+)\.\d*/ 解释了额外转义的和特殊的字符，并说明了这部分pattern应该被记忆。它精确地匹配后面跟着一个以上数字字符的字符 'Chapter ' (\d 意为任何数字字符，+ 意为1次以上)，跟着一个小数点（在这个字符中本身也是一个特殊字符；小数点前的 \ 意味着这个pattern必须寻找字面字符 '.')，跟着任何数字字符0次以上。 (\d 意为数字字符， * 意为0次以上)。另外，插入语也用来记忆第一个匹配的数字字符。
    
+
    比如， /Chapter (\d+)\.\d*/ 解释了额外转义的和特殊的字符，并说明了这部分 pattern 应该被记忆。它精确地匹配后面跟着一个以上数字字符的字符 'Chapter ' (\d 意为任何数字字符，+ 意为 1 次以上)，跟着一个小数点（在这个字符中本身也是一个特殊字符；小数点前的 \ 意味着这个 pattern 必须寻找字面字符 '.')，跟着任何数字字符 0 次以上。 (\d 意为数字字符， * 意为 0 次以上)。另外，插入语也用来记忆第一个匹配的数字字符。
    
 
 
    此模式可以匹配字符串"Open Chapter 4.3, paragraph 6"，并且'4'将会被记住。此模式并不能匹配"Chapter 3 and 4"，因为在这个字符串中'3'的后面没有点号'.'。
    
 
-
    括号中的"?:"，这种模式匹配的子字符串将不会被记住。比如，(?:\d+)匹配一次或多次数字字符，但是不能记住匹配的字符。
    
+
    括号中的"?:"，这种模式匹配的子字符串将不会被记住。比如，(?:\d+) 匹配一次或多次数字字符，但是不能记住匹配的字符。
    
 
 
    使用正则表达式
    
 
@@ -418,27 +418,27 @@ 
    使用正则表达式
    
  
   
    {{jsxref("RegExp.exec", "exec")}}
-   一个在字符串中执行查找匹配的RegExp方法，它返回一个数组（未匹配到则返回 null）。
+   一个在字符串中执行查找匹配的 RegExp 方法，它返回一个数组（未匹配到则返回 null）。
   
   
    {{jsxref("RegExp.test", "test")}}
-   一个在字符串中测试是否匹配的RegExp方法，它返回 true 或 false。
+   一个在字符串中测试是否匹配的 RegExp 方法，它返回 true 或 false。
   
   
    {{jsxref("String.match", "match")}}
-   一个在字符串中执行查找匹配的String方法，它返回一个数组，在未匹配到时会返回 null。
+   一个在字符串中执行查找匹配的 String 方法，它返回一个数组，在未匹配到时会返回 null。
   
   
    {{jsxref("String.matchAll", "matchAll")}}
-   一个在字符串中执行查找所有匹配的String方法，它返回一个迭代器（iterator）。
+   一个在字符串中执行查找所有匹配的 String 方法，它返回一个迭代器（iterator）。
   
   
    {{jsxref("String.search", "search")}}
-   一个在字符串中测试匹配的String方法，它返回匹配到的位置索引，或者在失败时返回-1。
+   一个在字符串中测试匹配的 String 方法，它返回匹配到的位置索引，或者在失败时返回-1。
   
   
    {{jsxref("String.replace", "replace")}}
-   一个在字符串中执行查找匹配的String方法，并且使用替换字符串替换掉匹配到的子字符串。
+   一个在字符串中执行查找匹配的 String 方法，并且使用替换字符串替换掉匹配到的子字符串。
   
   
    {{jsxref("String.split", "split")}}
@@ -447,15 +447,15 @@ 
    使用正则表达式
    
  
 
 
-
    当你想要知道在一个字符串中的一个匹配是否被找到，你可以使用 test 或 search 方法；想得到更多的信息（但是比较慢）则可以使用 exec 或 match 方法。如果你使用exec 或 match 方法并且匹配成功了，那么这些方法将返回一个数组并且更新相关的正则表达式对象的属性和预定义的正则表达式对象（详见下）。如果匹配失败，那么 exec 方法返回 null（也就是false）。
    
+
    当你想要知道在一个字符串中的一个匹配是否被找到，你可以使用 test 或 search 方法；想得到更多的信息（但是比较慢）则可以使用 exec 或 match 方法。如果你使用 exec 或 match 方法并且匹配成功了，那么这些方法将返回一个数组并且更新相关的正则表达式对象的属性和预定义的正则表达式对象（详见下）。如果匹配失败，那么 exec 方法返回 null（也就是 false）。
    
 
-
    在接下来的例子中，脚本将使用exec方法在一个字符串中查找一个匹配。
    
+
    在接下来的例子中，脚本将使用 exec 方法在一个字符串中查找一个匹配。
    
 
 
    var myRe = /d(b+)d/g;
 var myArray = myRe.exec("cdbbdbsbz");
 
    
 
-
    如果你不需要访问正则表达式的属性，这个脚本通过另一个方法来创建myArray：
    
+
    如果你不需要访问正则表达式的属性，这个脚本通过另一个方法来创建 myArray：
    
 
 
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
 // 和 "cdbbdbsbz".match(/d(b+)d/g); 相似。
@@ -491,7 +491,7 @@ 
    使用正则表达式
    
   
   
    index
-   在输入的字符串中匹配到的以0开始的索引值。
+   在输入的字符串中匹配到的以 0 开始的索引值。
    1
   
   
@@ -507,7 +507,7 @@ 
    使用正则表达式
    
   
    myRe
    lastIndex
-   开始下一个匹配的起始索引值。（这个属性只有在使用g参数时可用在 通过参数进行高级搜索 一节有详细的描述.)
+   开始下一个匹配的起始索引值。（这个属性只有在使用 g 参数时可用在 通过参数进行高级搜索 一节有详细的描述.)
    5
   
   
@@ -541,15 +541,15 @@ 
    使用正则表达式
    
 
    The value of lastIndex is 0
 
    
 
-
    当发生/d(b+)d/g使用两个不同状态的正则表达式对象，lastIndex属性会得到不同的值。如果你需要访问一个正则表达式的属性，则需要创建一个对象初始化生成器，你应该首先把它赋值给一个变量。
    
+
    当发生/d(b+)d/g 使用两个不同状态的正则表达式对象，lastIndex 属性会得到不同的值。如果你需要访问一个正则表达式的属性，则需要创建一个对象初始化生成器，你应该首先把它赋值给一个变量。
    
 
 
    使用括号的子字符串匹配
    
 
-
    一个正则表达式模式使用括号，将导致相应的子匹配被记住。例如，/a(b)c /可以匹配字符串“abc”，并且记得“b”。回调这些括号中匹配的子串，使用数组元素[1],……[n]。
    
+
    一个正则表达式模式使用括号，将导致相应的子匹配被记住。例如，/a(b)c /可以匹配字符串“abc”，并且记得“b”。回调这些括号中匹配的子串，使用数组元素 [1],……[n]。
    
 
 
    使用括号匹配的子字符串的数量是无限的。返回的数组中保存所有被发现的子匹配。下面的例子说明了如何使用括号的子字符串匹配。
    
 
-
    下面的脚本使用replace()方法来转换字符串中的单词。在匹配到的替换文本中，脚本使用替代的$ 1,$ 2表示第一个和第二个括号的子字符串匹配。
    
+
    下面的脚本使用 replace() 方法来转换字符串中的单词。在匹配到的替换文本中，脚本使用替代的$ 1,$ 2 表示第一个和第二个括号的子字符串匹配。
    
 
 
    var re = /(\w+)\s(\w+)/;
 var str = "John Smith";
@@ -561,7 +561,7 @@ 
    使用括号的子字符串匹配通过标志进行高级搜索
    
 
-
    正则表达式有六个可选参数 (flags) 允许全局和不分大小写搜索等。这些参数既可以单独使用也能以任意顺序一起使用, 并且被包含在正则表达式实例中。
    
+
    正则表达式有六个可选参数 (flags) 允许全局和不分大小写搜索等。这些参数既可以单独使用也能以任意顺序一起使用，并且被包含在正则表达式实例中。
    
 
 
@@ -590,11 +590,11 @@ 
    通过标志进行高级搜索
    
-   
+   
-   
+   
    
  正则表达式标志
   
   
    
    u使用unicode码的模式进行匹配。使用 unicode 码的模式进行匹配。
   
    
   
    
    y执行“粘性(sticky)”搜索,匹配从目标字符串的当前位置开始。执行“粘性 (sticky)”搜索，匹配从目标字符串的当前位置开始。
   
    
      
 
    
@@ -633,7 +633,7 @@ 
    通过标志进行高级搜索
    
 
 
    并且能获取到相同的结果。
    
 
-
    使用.exec()方法时，与'g'标志关联的行为是不同的。 （“class”和“argument”的作用相反：在.match()的情况下，字符串类（或数据类型）拥有该方法，而正则表达式只是一个参数，而在.exec()的情况下，它是拥有该方法的正则表达式，其中字符串是参数。对比str.match(re)与re.exec(str) ), 'g'标志与.exec()方法一起使用获得迭代进展。
    
+
    使用.exec()方法时，与'g'标志关联的行为是不同的。（“class”和“argument”的作用相反：在.match()的情况下，字符串类（或数据类型）拥有该方法，而正则表达式只是一个参数，而在.exec()的情况下，它是拥有该方法的正则表达式，其中字符串是参数。对比str.match(re)与re.exec(str) ), 'g'标志与.exec()方法一起使用获得迭代进展。
    
 
 
    var xArray; while(xArray = re.exec(str)) console.log(xArray);
 // produces:
@@ -641,7 +641,7 @@ 
    通过标志进行高级搜索
    
 // ["fi ", index: 4, input: "fee fi fo fum"]
 // ["fo ", index: 7, input: "fee fi fo fum"]
    
 
-
    m标志用于指定多行输入字符串应该被视为多个行。如果使用m标志，^和$匹配的开始或结束输入字符串中的每一行，而不是整个字符串的开始或结束。
    
+
    m 标志用于指定多行输入字符串应该被视为多个行。如果使用 m 标志，^和$匹配的开始或结束输入字符串中的每一行，而不是整个字符串的开始或结束。
    
 
 
    例子
    
 
@@ -649,7 +649,7 @@ 
    例子
    
 
 
    改变输入字符串的顺序
    
 
-
    以下例子解释了正则表达式的构成和 string.split() 以及 string.replace()的用途。它会整理一个只有粗略格式的含有全名（名字首先出现）的输入字符串，这个字符串被空格、换行符和一个分号分隔。最终，它会颠倒名字顺序（姓氏首先出现）和list的类型。
    
+
    以下例子解释了正则表达式的构成和 string.split() 以及 string.replace()的用途。它会整理一个只有粗略格式的含有全名（名字首先出现）的输入字符串，这个字符串被空格、换行符和一个分号分隔。最终，它会颠倒名字顺序（姓氏首先出现）和 list 的类型。
    
 
 
    // 下面这个姓名字符串包含了多个空格和制表符，
 // 且在姓和名之间可能有多个空格和制表符。
@@ -663,7 +663,7 @@ 
    改变输入字符串的顺序
    
 // 匹配模式：匹配一个分号及紧接其前后所有可能出现的连续的不可见符号。
 var pattern = /\s*;\s*/;
 
-// 把通过上述匹配模式分割的字符串放进一个叫做nameList的数组里面。
+// 把通过上述匹配模式分割的字符串放进一个叫做 nameList 的数组里面。
 var nameList = names.split(pattern);
 
 // 新建一个匹配模式：匹配一个或多个连续的不可见字符及其前后紧接着由
@@ -679,7 +679,7 @@ 
    改变输入字符串的顺序
    
 // 用逗号接空格的模式把姓和名分割开来然后存放进数组 bySurnameList 中。
 //
 // 下面的这个替换方法把 nameList 里的元素用 $2, $1 的模式
-// （第二个捕获的匹配结果紧接着一个逗号一个空格然后紧接着第一个捕获的匹配结果）替换了
+//（第二个捕获的匹配结果紧接着一个逗号一个空格然后紧接着第一个捕获的匹配结果）替换了
 // 变量 $1 和变量 $2 是上面所捕获的匹配结果。
 
 output.push("---------- After Split by Regular Expression");
@@ -712,7 +712,7 @@ 
    用特殊字符检验输入
    
 
 
    在以下例子中，我们期望用户输入一个电话号码。当用户点击“Check”按钮，我们的脚本开始检查这些数字是否合法。如果数字合法（匹配正则表达式所规定的字符序列），脚本显示一条感谢用户的信息并确认该数字。如果这串数字不合法，脚本提示用户电话号码不合法。.
    
 
-
    包含非捕获括号 (?: 这个正则表达式寻找三个数字字符\d{3} 或者 | 一个左半括号\(跟着三位数字\d{3}, 跟着一个封闭括号 \), (结束非捕获括号 ))， 后跟着一个短破折号或正斜杠或小数点，随后跟随三个数字字符，当记忆字符 ([-\/\.])捕获并记住，后面跟着三位小数 \d{3}，再后面跟随记住的破折号、正斜杠或小数点 \1，最后跟着四位小数 \d{4}。
    
+
    包含非捕获括号 (?: 这个正则表达式寻找三个数字字符\d{3} 或者 | 一个左半括号\(跟着三位数字\d{3}, 跟着一个封闭括号 \), (结束非捕获括号 ))， 后跟着一个短破折号或正斜杠或小数点，随后跟随三个数字字符，当记忆字符 ([-\/\.]) 捕获并记住，后面跟着三位小数 \d{3}，再后面跟随记住的破折号、正斜杠或小数点 \1，最后跟着四位小数 \d{4}。
    
 
 
    当用户按下 Enter 设置 RegExp.input，这些变化也能被激活。
    
 
diff --git a/files/zh-cn/web/javascript/guide/regular_expressions/quantifiers/index.html b/files/zh-cn/web/javascript/guide/regular_expressions/quantifiers/index.html
index 4f1bd7ba8083f2..f7382209695f55 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/quantifiers/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/quantifiers/index.html
@@ -23,39 +23,39 @@ 
    类型
    
   
    x*
    
-    
    将前面的项“x”匹配0次或更多次。例如，/bo*/匹配“A ghost booooed”中的“boooo”和“A bird warbled”中的“b”，但在“A goat grunt”中没有匹配。
    
+    
    将前面的项“x”匹配 0 次或更多次。例如，/bo*/匹配“A ghost booooed”中的“boooo”和“A bird warbled”中的“b”，但在“A goat grunt”中没有匹配。
    
    
   
   
    x+
    
-    
    将前一项“x”匹配1次或更多次。等价于{1,}。例如，/a+/匹配“candy”中的“a”和“caaaaaaandy”中的“a”。
    
+    
    将前一项“x”匹配 1 次或更多次。等价于{1,}。例如，/a+/匹配“candy”中的“a”和“caaaaaaandy”中的“a”。
    
    
   
   
    x?
    
-    
    将前面的项“x”匹配0或1次。例如,/e?le?/匹配angel中的el和angle中的le。
    
+    
    将前面的项“x”匹配 0 或 1 次。例如，/e?le?/匹配 angel 中的 el 和 angle 中的 le。
    
 
-    
    如果立即在任何量词*、+、?或{}之后使用，则使量词是非贪婪的(匹配最小次数)，而不是默认的贪婪的(匹配最大次数)。
    
+    
    如果立即在任何量词*、+、?或{}之后使用，则使量词是非贪婪的 (匹配最小次数)，而不是默认的贪婪的 (匹配最大次数)。
    
    
   
   
    x{n}
    
-    
    其中“n”是一个正整数，与前一项“x”的n次匹配。例如，/a{2}/ 不匹配“candy”中的“a”，但它匹配“caandy”中的所有“a”，以及“caaandy”中的前两个“a”。
    
+    
    其中“n”是一个正整数，与前一项“x”的 n 次匹配。例如，/a{2}/ 不匹配“candy”中的“a”，但它匹配“caandy”中的所有“a”，以及“caaandy”中的前两个“a”。
    
    
   
   
    x{n,}
    
-    
    其中，“n”是一个正整数，与前一项“x”至少匹配“n”次。例如，/a{2，}/不匹配“candy”中的“a”，但匹配“caandy”和“caaaaaaandy”中的所有a。
    
+    
    其中，“n”是一个正整数，与前一项“x”至少匹配“n”次。例如，/a{2，}/不匹配“candy”中的“a”，但匹配“caandy”和“caaaaaaandy”中的所有 a。
    
    
   
   
    x{n,m}
    
-    
    其中，“n”是0或一个正整数，“m”是一个正整数，而m > n至少与前一项“x”匹配，最多与“m”匹配。例如，/a{1,3}/不匹配“cndy”中的“a”，“candy”中的“a”，“caandy”中的两个“a”，以及“caaaaaaandy”中的前三个“a”。注意，当匹配“caaaaaaandy”时，匹配的是“aaa”，即使原始字符串中有更多的“a”。
    
+    
    其中，“n”是 0 或一个正整数，“m”是一个正整数，而 m > n 至少与前一项“x”匹配，最多与“m”匹配。例如，/a{1,3}/不匹配“cndy”中的“a”，“candy”中的“a”，“caandy”中的两个“a”，以及“caaaaaaandy”中的前三个“a”。注意，当匹配“caaaaaaandy”时，匹配的是“aaa”，即使原始字符串中有更多的“a”。
    
    
   
   
@@ -98,7 +98,7 @@ 
    计算字符集
    
 
 console.table(sentence.match(singleLetterWord)); // ["I"]
 console.table(sentence.match(notSoLongWord));    // [ "Why", "do", "I", "have", "to", "learn", "table" ]
-console.table(sentence.match(loooongWord));      // ["multiplication"]可选可选字符
+console.table(sentence.match(loooongWord));      // ["multiplication"] 可选可选字符
 
    
 
 
     可选字符
    
diff --git a/files/zh-cn/web/javascript/guide/regular_expressions/unicode_property_escapes/index.html b/files/zh-cn/web/javascript/guide/regular_expressions/unicode_property_escapes/index.html
index 64254c284c5900..bc1d112466042f 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/unicode_property_escapes/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/unicode_property_escapes/index.html
@@ -5,7 +5,7 @@
 ---
 
    {{jsSidebar("JavaScript Guide")}}
    
 
-
    Unicode property escapes 正则表达式 支持根据 Unicode 属性进行匹配，例如我们可以用它来匹配出表情、标点符号、字母(甚至适用特定语言或文字)等。同一符号可以拥有多种 Unicode 属性，属性则有 binary ("boolean-like") 和 non-binary 之分。
    
+
    Unicode property escapes 正则表达式 支持根据 Unicode 属性进行匹配，例如我们可以用它来匹配出表情、标点符号、字母 (甚至适用特定语言或文字) 等。同一符号可以拥有多种 Unicode 属性，属性则有 binary ("boolean-like") 和 non-binary 之分。
    
 
 
    {{EmbedInteractiveExample("pages/js/regexp-unicode-property-escapes.html", "taller")}}
    
 
@@ -14,21 +14,21 @@
 
    
 
 
    
-
    备注： 某些 Unicode 属性比字符类(如 \w 只匹配拉丁字母 a 到 z)包含更多的字符  ，但后者浏览器兼容性更好 (截至2020 一月).
    
+
    备注： 某些 Unicode 属性比字符类(如 \w 只匹配拉丁字母 a 到 z) 包含更多的字符  ，但后者浏览器兼容性更好 (截至 2020 一月).
    
 
    
 
 
    句法
    
 
 
    // Non-binary 属性
-\p{Unicode属性值}
-\p{Unicode属性名=Unicode属性值}
+\p{Unicode 属性值}
+\p{Unicode 属性名=Unicode 属性值}
 
 // Binary and non-binary 属性
-\p{UnicodeBinary属性名}
+\p{UnicodeBinary 属性名}
 
 // \P 为 \p 取反
-\P{Unicode属性值}
-\P{UnicodeBinary属性名}
+\P{Unicode 属性值}
+\P{UnicodeBinary 属性名}
 
    
 
 
      
@@ -40,12 +40,12 @@ 
      句法
      
 
      参考 PropertyValueAliases.txt 
      
 
 
      
- 
      UnicodeBinary属性名
      
- 
      Binary 属性名. E.g.: ASCII. Alpha, Math, Diacritic, Emoji, Hex_Digit, Math, White_space, 等. 另见 Unicode Data PropList.txt.
      
- 
      Unicode属性名
      
- 
      Non-binary 属性名:
      
- 
      Unicode属性值
      
- 
      很多值有同名或简写(e.g. 对应着 General_Category 属性名的属性值 Decimal_Number 可以写作 Nd, digit, 或 Decimal_Number). 大多数属性值的 Unicode属性名 和等号可以省去。如果想明确某 Unicode属性名，必须给出它的值。
      
+ 
      UnicodeBinary 属性名
      
+ 
      Binary 属性名. E.g.: ASCII. Alpha, Math, Diacritic, Emoji, Hex_Digit, Math, White_space, 等。另见 Unicode Data PropList.txt.
      
+ 
      Unicode 属性名
      
+ 
      Non-binary 属性名：
      
+ 
      Unicode 属性值
      
+ 
      很多值有同名或简写 (e.g. 对应着 General_Category 属性名的属性值 Decimal_Number 可以写作 Nd, digit, 或 Decimal_Number). 大多数属性值的 Unicode 属性名 和等号可以省去。如果想明确某 Unicode 属性名，必须给出它的值。
      
 
      
 
 
      
@@ -54,13 +54,13 @@ 
      句法
      
 
 
      基本原理
      
 
-
      在 ES2018 之前，JavaScript 没有强有效的方式用匹配出不同文字(如马其顿语，希腊语，Georgian 等)或不同 属性名 (如 Emoji 等)的字符。另见 tc39 Proposal on Unicode Property Escapes.
      
+
      在 ES2018 之前，JavaScript 没有强有效的方式用匹配出不同文字(如马其顿语，希腊语，Georgian 等) 或不同 属性名 (如 Emoji 等) 的字符。另见 tc39 Proposal on Unicode Property Escapes.
      
 
 
      例子
      
 
 
      （一般类别）General categories
      
 
-
      General categories 对 Unicode 字符进行分类，子类别用于精确定义类别。长名和简写的 Unicode 属性转义都可用.
      
+
      General categories 对 Unicode 字符进行分类，子类别用于精确定义类别。长名和简写的 Unicode 属性转义都可用。
      
 
 
      它们可匹配字母、数字、符号、标点符号、空格等等。一般类别详见 the Unicode specification.
      
 
@@ -84,7 +84,7 @@ 
      文字（Scrip
 
 
      某些语言使用不同的文字，如英语和西班牙语使用拉丁文，而阿拉伯语和俄语用阿拉伯文和俄文。Script 和 Script_Extensions Unicode 属性允许正则表达式根据字符所属的文字或该文字所属的文字扩充进行匹配。
      
 
-
      比如，A 属于 拉丁文，ε 属于希腊(Greek)文。
      
+
      比如，A 属于 拉丁文，ε 属于希腊 (Greek)文。
      
 
 
      let mixedCharacters = "aεЛ";
 
diff --git a/files/zh-cn/web/javascript/guide/text_formatting/index.html b/files/zh-cn/web/javascript/guide/text_formatting/index.html
index ea610bb1ca5032..8da4cb923a34e3 100644
--- a/files/zh-cn/web/javascript/guide/text_formatting/index.html
+++ b/files/zh-cn/web/javascript/guide/text_formatting/index.html
@@ -8,37 +8,37 @@
 ---
 
      {{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Numbers_and_dates", "Web/JavaScript/Guide/Regular_Expressions")}}
      
 
-
      本章介绍在Javascript中如何使用字符串与文本内容。
      
+
      本章介绍在 Javascript 中如何使用字符串与文本内容。
      
 
 
      字符串
      
 
-
      JavaScript中的 {{Glossary("String")}} 类型用于表示文本型的数据. 它是由无符号整数值（16bit）作为元素而组成的集合. 字符串中的每个元素在字符串中占据一个位置. 第一个元素的index值是0, 下一个元素的index值是1, 以此类推. 字符串的长度就是字符串中所含的元素个数.你可以通过String字面值或者String对象两种方式创建一个字符串。
      
+
      JavaScript 中的 {{Glossary("String")}} 类型用于表示文本型的数据。它是由无符号整数值（16bit）作为元素而组成的集合。字符串中的每个元素在字符串中占据一个位置. 第一个元素的 index 值是 0，下一个元素的 index 值是 1，以此类推。字符串的长度就是字符串中所含的元素个数.你可以通过 String 字面值或者 String 对象两种方式创建一个字符串。
      
 
-
      String字面量
      
+
      String 字面量
      
 
-
      可以使用单引号或双引号创建简单的字符串:
      
+
      可以使用单引号或双引号创建简单的字符串：
      
 
 
      'foo'
 "bar"
      
 
-
      可以使用转义序列来创建更复杂的字符串:
      
+
      可以使用转义序列来创建更复杂的字符串：
      
 
-
      16进制转义序列
      
+
      16 进制转义序列
      
 
-
      \x之后的数值将被认为是一个16进制数.
      
+
      \x之后的数值将被认为是一个 16 进制数。
      
 
 
      '\xA9' // "©"
 
      
 
-
      Unicode转义序列
      
+
      Unicode 转义序列
      
 
-
      Unicode转义序列在\u之后需要至少4个字符.
      
+
      Unicode 转义序列在\u之后需要至少 4 个字符。
      
 
 
      '\u00A9' // "©"
      
 
-
      Unicode字元逸出
      
+
      Unicode 字元逸出
      
 
-
      这是ECMAScript 6中的新特性。有了Unicode字元逸出，任何字符都可以用16进制数转义, 这使得通过Unicode转义表示大于0x10FFFF的字符成为可能。使用简单的Unicode转义时通常需要分别写字符相应的两个部分（译注：大于0x10FFFF的字符需要拆分为相应的两个小于0x10FFFF的部分）来达到同样的效果。
      
+
      这是 ECMAScript 6 中的新特性。有了 Unicode 字元逸出，任何字符都可以用 16 进制数转义，这使得通过 Unicode 转义表示大于0x10FFFF的字符成为可能。使用简单的 Unicode 转义时通常需要分别写字符相应的两个部分（译注：大于 0x10FFFF 的字符需要拆分为相应的两个小于 0x10FFFF 的部分）来达到同样的效果。
      
 
 
      请参阅 {{jsxref("String.fromCodePoint()")}} 或 {{jsxref("String.prototype.codePointAt()")}}。
      
 
@@ -49,15 +49,15 @@ 
      Unicode字元逸出
      
 
 
      字符串对象
      
 
-
      {{jsxref("String")}} 对象是对原始string类型的封装 .
      
+
      {{jsxref("String")}} 对象是对原始 string 类型的封装 .
      
 
 
      const foo = new String('foo'); // 创建一个 String 对象
 console.log(foo); // 输出: [String: 'foo']
 typeof foo; // 返回 'object'
      
 
-
      你可以在String字面值上使用String对象的任何方法—JavaScript自动把String字面值转换为一个临时的String对象, 然后调用其相应方法,最后丢弃此临时对象.在String字面值上也可以使用String.length属性.
      
+
      你可以在 String 字面值上使用 String 对象的任何方法—JavaScript 自动把 String 字面值转换为一个临时的 String 对象，然后调用其相应方法，最后丢弃此临时对象。在 String 字面值上也可以使用 String.length 属性。
      
 
-
      除非必要, 应该尽量使用 String 字面值，因为String对象的某些行为可能并不与直觉一致。举例：
      
+
      除非必要， 应该尽量使用 String 字面值，因为 String 对象的某些行为可能并不与直觉一致。举例：
      
 
 
      const firstString = '2 + 2'; //创建一个字符串字面量
 const secondString = new String('2 + 2'); // 创建一个字符串对象
@@ -73,13 +73,13 @@ 
      字符串对象
      
 
 
      Characters whose Unicode scalar values are greater than U+FFFF (such as some rare Chinese/Japanese/Korean/Vietnamese characters and some emoji) are stored in UTF-16 with two surrogate code units each. For example, a string containing the single character U+1F600 "Emoji grinning face" will have length 2. Accessing the individual code units in such a string using brackets may have undesirable consequences such as the formation of strings with unmatched surrogate code units, in violation of the Unicode standard. (Examples should be added to this page after MDN bug 857438 is fixed.) See also {{jsxref("String.fromCodePoint()")}} or {{jsxref("String.prototype.codePointAt()")}}.
      
 
-
      String对象有许多方法: 举例来说有些方法返回字符串本身的变体, 如 substring 和toUpperCase.
      
+
      String对象有许多方法：举例来说有些方法返回字符串本身的变体，如 substring 和toUpperCase.
      
 
-
      下表总结了 {{jsxref("String")}} 对象的方法.
      
+
      下表总结了 {{jsxref("String")}} 对象的方法。
      
 
 
@@ -106,11 +106,11 @@ 
      String对象方法
      
-   
+   
-   
+   
@@ -122,7 +122,7 @@ 
      String对象方法
      
-   
+   
@@ -147,20 +147,20 @@ 
      String对象方法
      多行模板字符串
      
 
-
      模板字符串是一种允许内嵌表达式的String字面值. 可以用它实现多行字符串或者字符串内插等特性.
      
+
      模板字符串是一种允许内嵌表达式的 String 字面值。可以用它实现多行字符串或者字符串内插等特性。
      
 
-
      模板字符串使用反勾号 (` `) (grave accent) 包裹内容而不是单引号或双引号. 模板字符串可以包含占位符. 占位符用美元符号和花括号标识 (${expression}).
      
+
      模板字符串使用反勾号 (` `) (grave accent) 包裹内容而不是单引号或双引号。模板字符串可以包含占位符. 占位符用美元符号和花括号标识 (${expression}).
      多行
      
 
-
      源代码中插入的任何新行开始字符都作为模板字符串的内容. 使用一般的字符串时, 为了创建多行的字符串不得不用如下语法:
      
+
      源代码中插入的任何新行开始字符都作为模板字符串的内容。使用一般的字符串时，为了创建多行的字符串不得不用如下语法：
      console.log("string text line 1\n\
 string text line 2");
 // "string text line 1
 // string text line 2"
      
 
-
      为了实现同样效果的多行字符串, 现在可以写成如下形式:
      
+
      为了实现同样效果的多行字符串，现在可以写成如下形式：
      console.log(`string text line 1
 string text line 2`);
@@ -169,36 +169,36 @@ 
      多行
      
 
 
      嵌入表达式
      
 
-
      为了在一般的字符串中嵌入表达式, 需要使用如下语法:
      
+
      为了在一般的字符串中嵌入表达式，需要使用如下语法：
      
 
 
      const five = 5;
 const ten = 10;
 console.log('Fifteen is ' + (five + ten) + ' and not ' + (2 * five + ten) + '.');
 // "Fifteen is 15 and not 20."
      
 
-
      现在, 使用模板字符串, 可以使用语法糖让类似功能的实现代码更具可读性:
      
+
      现在，使用模板字符串，可以使用语法糖让类似功能的实现代码更具可读性：
      
 
 
      const five = 5;
 const ten = 10;
 console.log(`Fifteen is ${five + ten} and not ${2 * five + ten}.`);
 // "Fifteen is 15 and not 20."
      
 
-
      更多信息, 请阅读 JavaScript reference 中的 Template literals。
      
+
      更多信息，请阅读 JavaScript reference 中的 Template literals。
      
 
 
      国际化
      
 
-
      {{jsxref("Intl")}} 对象是ECMAScript国际化API的命名空间, 它提供了语言敏感的字符串比较，数字格式化和日期时间格式化功能.  {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, 和 {{jsxref("DateTimeFormat")}} 对象的构造函数是Intl对象的属性.
      
+
      {{jsxref("Intl")}} 对象是 ECMAScript 国际化 API 的命名空间，它提供了语言敏感的字符串比较，数字格式化和日期时间格式化功能.  {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, 和 {{jsxref("DateTimeFormat")}} 对象的构造函数是Intl对象的属性。
      
 
 
      日期和时间格式化
      
 
-
      {{jsxref("DateTimeFormat")}} 对象在日期和时间的格式化方面很有用. 下面的代码把一个日期格式化为美式英语格式. (不同时区结果不同.)
      
+
      {{jsxref("DateTimeFormat")}} 对象在日期和时间的格式化方面很有用。下面的代码把一个日期格式化为美式英语格式. (不同时区结果不同.)
      
 
 
      const msPerDay = 24 * 60 * 60 * 1000;
 
 // July 17, 2014 00:00:00 UTC.
-const july172014 = new Date(msPerDay * (44 * 365 + 11 + 197));//2014-1970=44年
-//这样创建日期真是醉人。。。还要自己计算天数。。。11是闰年中多出的天数。。。
-//197是6×30+16(7月的16天)+3(3个大月)-2(2月少2天)
+const july172014 = new Date(msPerDay * (44 * 365 + 11 + 197));//2014-1970=44 年
+//这样创建日期真是醉人。。。还要自己计算天数。。。11 是闰年中多出的天数。。。
+//197 是 6×30+16(7 月的 16 天)+3(3 个大月)-2(2 月少 2 天)
 
 const options = { year: "2-digit", month: "2-digit", day: "2-digit",
                 hour: "2-digit", minute: "2-digit", timeZoneName: "short" };
@@ -209,7 +209,7 @@ 
      日期和时间格式化
      
 
 
      数字格式化
      
 
-
      {{jsxref("NumberFormat")}} 对象在数字的格式化方面很有用, 比如货币数量值.
      
+
      {{jsxref("NumberFormat")}} 对象在数字的格式化方面很有用，比如货币数量值。
      
 
 
      var gasPrice = new Intl.NumberFormat("en-US",
                         { style: "currency", currency: "USD",
@@ -220,14 +220,14 @@ 
      数字格式化
      
 var hanDecimalRMBInChina = new Intl.NumberFormat("zh-CN-u-nu-hanidec",
                         { style: "currency", currency: "CNY" });
 
-console.log(hanDecimalRMBInChina.format(1314.25)); // ￥ 一,三一四.二五
+console.log(hanDecimalRMBInChina.format(1314.25)); // ￥ 一，三一四。二五
 
      
 
 
      定序
      
 
-
      {{jsxref("Collator")}} 对象在字符串比较和排序方面很有用.
      
+
      {{jsxref("Collator")}} 对象在字符串比较和排序方面很有用。
      
 
-
      举例, 德语中有两种不同的排序方式 电话本（phonebook） 和 字典（dictionary）. 电话本排序强调发音, 比如在排序前 “ä”, “ö”等被扩展为 “ae”, “oe”等发音.
      
+
      举例，德语中有两种不同的排序方式 电话本（phonebook） 和 字典（dictionary）. 电话本排序强调发音，比如在排序前 “ä”, “ö”等被扩展为 “ae”, “oe”等发音。
      
 
 
      var names = ["Hochberg", "Hönigswald", "Holzman"];
 
@@ -238,7 +238,7 @@ 
      定序
      
 // logs "Hochberg, Hönigswald, Holzman"
 
      
 
-
      有些德语词包含变音, 所以在字典中忽略变音进行排序是合理的 (除非待排序的单词只有变音部分不同: schon 先于 schön).
      
+
      有些德语词包含变音，所以在字典中忽略变音进行排序是合理的 (除非待排序的单词只有变音部分不同：schon 先于 schön).
      
 
 
      var germanDictionary = new Intl.Collator("de-DE-u-co-dict");
 
@@ -247,6 +247,6 @@ 
      定序
      
 // logs "Hochberg, Holzman, Hönigswald"
 
      
 
-
      关于{{jsxref("Intl")}} API的更多信息, 请参考 Introducing the JavaScript Internationalization API。
      
+
      关于{{jsxref("Intl")}} API 的更多信息，请参考 Introducing the JavaScript Internationalization API。
      
 
 
      {{PreviousNext("Web/JavaScript/Guide/Numbers_and_dates", "Web/JavaScript/Guide/Regular_Expressions")}}
      
diff --git a/files/zh-cn/web/javascript/guide/using_promises/index.html b/files/zh-cn/web/javascript/guide/using_promises/index.html
index 5d7c65bf688cac..01f3922c631939 100644
--- a/files/zh-cn/web/javascript/guide/using_promises/index.html
+++ b/files/zh-cn/web/javascript/guide/using_promises/index.html
@@ -235,7 +235,7 @@ 
      在旧式回调 API 中创建 Pro
 wait(10000).then(() => saySomething("10 seconds")).catch(failureCallback);
 
      
 
-
      通常，Promise 的构造器接收一个执行函数(executor)，我们可以在这个执行函数里手动地 resolve 和 reject 一个 Promise。既然 setTimeout 并不会真的执行失败，那么我们可以在这种情况下忽略 reject。
      
+
      通常，Promise 的构造器接收一个执行函数 (executor)，我们可以在这个执行函数里手动地 resolve 和 reject 一个 Promise。既然 setTimeout 并不会真的执行失败，那么我们可以在这种情况下忽略 reject。
      
 
 
      组合
      
 
@@ -269,7 +269,7 @@ 
      组合
      
 const result3 = transformData(data);
 
      
 
-
      在 ECMAScript 2017 标准中, 时序组合可以通过使用 async/await 而变得更简单：
      
+
      在 ECMAScript 2017 标准中，时序组合可以通过使用 async/await 而变得更简单：
      let result;
 for (const f of [func1, func2, func3]) {
@@ -306,9 +306,9 @@ 
      嵌套
      
 .then(() => moreCriticalStuff())
 .catch(e => console.log("Critical failure: " + e.message));// 没有输出
      
 
-
      注意,有些代码步骤是嵌套的，而不是一个简单的纯链式，这些语句前与后都被括号 () 包裹着。
      
+
      注意，有些代码步骤是嵌套的，而不是一个简单的纯链式，这些语句前与后都被括号 () 包裹着。
      
 
-
      这个内部的 catch  语句仅能捕获到 doSomethingOptional() 和 doSomethingExtraNice() 的失败，之后就恢复到moreCriticalStuff() 的运行。重要提醒：如果 doSomethingCritical() 失败，这个错误仅会被最后的（外部）catch 语句捕获到。
      
+
      这个内部的 catch  语句仅能捕获到 doSomethingOptional() 和 doSomethingExtraNice() 的失败，之后就恢复到 moreCriticalStuff() 的运行。重要提醒：如果 doSomethingCritical() 失败，这个错误仅会被最后的（外部）catch 语句捕获到。
      常见错误
      
 
diff --git a/files/zh-cn/web/javascript/guide/working_with_objects/index.html b/files/zh-cn/web/javascript/guide/working_with_objects/index.html
index 0584ec44aa0a9c..c7fb09f45fa815 100644
--- a/files/zh-cn/web/javascript/guide/working_with_objects/index.html
+++ b/files/zh-cn/web/javascript/guide/working_with_objects/index.html
@@ -16,18 +16,18 @@
 
 
      对象概述
      
 
-
      javascript 中的对象(物体)，和其它编程语言中的对象一样，可以比照现实生活中的对象(物体)来理解它。 javascript 中对象(物体)的概念可以比照着现实生活中实实在在的物体来理解。
      
+
      javascript 中的对象 (物体)，和其它编程语言中的对象一样，可以比照现实生活中的对象 (物体) 来理解它。 javascript 中对象 (物体) 的概念可以比照着现实生活中实实在在的物体来理解。
      
 
-
      在javascript中，一个对象可以是一个单独的拥有属性和类型的实体。我们拿它和一个杯子做下类比。一个杯子是一个对象(物体)，拥有属性。杯子有颜色，图案，重量，由什么材质构成等等。同样，javascript对象也有属性来定义它的特征。
      
+
      在 javascript 中，一个对象可以是一个单独的拥有属性和类型的实体。我们拿它和一个杯子做下类比。一个杯子是一个对象 (物体)，拥有属性。杯子有颜色，图案，重量，由什么材质构成等等。同样，javascript 对象也有属性来定义它的特征。
      对象和属性
      
 
-
      一个 javascript 对象有很多属性。一个对象的属性可以被解释成一个附加到对象上的变量。对象的属性和普通的 javascript 变量基本没什么区别，仅仅是属性属于某个对象。属性定义了对象的特征(译注：动态语言面向对象的鸭子类型)。你可以通过点符号来访问一个对象的属性。
      
+
      一个 javascript 对象有很多属性。一个对象的属性可以被解释成一个附加到对象上的变量。对象的属性和普通的 javascript 变量基本没什么区别，仅仅是属性属于某个对象。属性定义了对象的特征 (译注：动态语言面向对象的鸭子类型)。你可以通过点符号来访问一个对象的属性。
      objectName.propertyName
 
      
 
-
      和其他 javascript 变量一样，对象的名字(可以是普通的变量)和属性的名字都是大小写敏感的。你可以在定义一个属性的时候就给它赋值。例如，我们创建一个myCar的对象然后给他三个属性，make，model，year。具体如下所示：
      
+
      和其他 javascript 变量一样，对象的名字 (可以是普通的变量) 和属性的名字都是大小写敏感的。你可以在定义一个属性的时候就给它赋值。例如，我们创建一个 myCar 的对象然后给他三个属性，make，model，year。具体如下所示：
      var myCar = new Object();
 myCar.make = "Ford";
@@ -39,7 +39,7 @@ 
      对象和属性
      
 
      myCar.noProperty; // undefined
 
      
 
-
      JavaScript 对象的属性也可以通过方括号访问或者设置（更多信息查看 property accessors）. 对象有时也被叫作关联数组, 因为每个属性都有一个用于访问它的字符串值。例如，你可以按如下方式访问 myCar 对象的属性：
      
+
      JavaScript 对象的属性也可以通过方括号访问或者设置（更多信息查看 property accessors）. 对象有时也被叫作关联数组，因为每个属性都有一个用于访问它的字符串值。例如，你可以按如下方式访问 myCar 对象的属性：
      
 
 
      myCar["make"] = "Ford";
 myCar["model"] = "Mustang";
@@ -64,7 +64,7 @@ 
      对象和属性
      
 console.log(myObj);
 
      
 
-
      请注意，方括号中的所有键都将转换为字符串类型，因为JavaScript中的对象只能使用String类型作为键类型。 例如，在上面的代码中，当将键obj添加到myObj时，JavaScript将调用obj.toString()方法，并将此结果字符串用作新键。
      
+
      请注意，方括号中的所有键都将转换为字符串类型，因为 JavaScript 中的对象只能使用 String 类型作为键类型。 例如，在上面的代码中，当将键 obj 添加到 myObj 时，JavaScript 将调用 obj.toString() 方法，并将此结果字符串用作新键。
      
 
 
      你也可以通过存储在变量中的字符串来访问属性：
      
 
@@ -105,7 +105,7 @@ 
      枚举一个对象的所有属性
      Object.keys(o)
      
   该方法返回对象 o 自身包含（不包括原型中）的所有可枚举属性的名称的数组。
  
    • Object.getOwnPropertyNames(o)
      
-  该方法返回对象 o 自身包含（不包括原型中）的所有属性(无论是否可枚举)的名称的数组。
      • 
+  该方法返回对象 o 自身包含（不包括原型中）的所有属性 (无论是否可枚举) 的名称的数组。
 
 
 
      在 ECMAScript 5 之前，没有原生的方法枚举一个对象的所有属性。然而，可以通过以下函数完成：
      
@@ -136,7 +136,7 @@ 
      使用对象初始化器
      
 
 
      var obj = { property_1:   value_1,   // property_# 可以是一个标识符...
             2:            value_2,   // 或一个数字...
-           ["property" +3]: value_3,  //  或一个可计算的key名...
+           ["property" +3]: value_3,  //  或一个可计算的 key 名...
             // ...,
             "property n": value_n }; // 或一个字符串
 
      
@@ -170,7 +170,7 @@ 
      使用构造函数
      
  
    • 通过 new 创建对象实例。
      • 
 
 
-
      为了定义对象类型，为对象类型创建一个函数以声明类型的名称、属性和方法。例如，你想为汽车创建一个类型，并且将这类对象称为 car ，并且拥有属性 make, model, 和 year，你可以创建如下的函数：
      
+
      为了定义对象类型，为对象类型创建一个函数以声明类型的名称、属性和方法。例如，你想为汽车创建一个类型，并且将这类对象称为 car ，并且拥有属性 make, model，和 year，你可以创建如下的函数：
      
 
 
      function Car(make, model, year) {
   this.make = make;
@@ -194,7 +194,7 @@ 
      使用构造函数
      
 var vpgscar = new Car("Mazda", "Miata", 1990);
 
      
 
-
      一个对象的属性值可以是另一个对象。例如，假设你按如下方式定义了 person 对象:
      
+
      一个对象的属性值可以是另一个对象。例如，假设你按如下方式定义了 person 对象：
      
 
 
      function Person(name, age, sex) {
   this.name = name;
@@ -203,7 +203,7 @@ 
      使用构造函数
      
 }
 
      
 
-
      然后按如下方式创建了两个 person 实例:
      
+
      然后按如下方式创建了两个 person 实例：
      
 
 
      var rand = new Person("Rand McKinnon", 33, "M");
 var ken = new Person("Ken Jones", 39, "M");
@@ -244,7 +244,7 @@ 
      使用 Object.create 方法
      
 
      // Animal properties and method encapsulation
 var Animal = {
   type: "Invertebrates", // 属性默认值
-  displayType : function() {  // 用于显示type属性的方法
+  displayType : function() {  // 用于显示 type 属性的方法
     console.log(this.type);
   }
 }
@@ -271,7 +271,7 @@ 
      对象属性索引
      
 
 
      这个限制发生在你通过构造函数创建一个对象和它的属性（就象我们之前通过 Car 对象类型所做的那样）并且显式地定义了单独的属性（如 myCar.color = "red"）之时。如果你最初使用索引定义了一个对象属性，例如 myCar[5] = "25"，则你只可能通过 myCar[5] 引用它。
      
 
-
      这条规则的例外是从与HTML对应的对象，例如 forms 数组。对于这些数组的元素，你总是既可以通过其序号（依据其在文档中出现的顺序），也可以按照其名称（如果有的话）访问它。举例而言，如果文档中的第二个 <form> 标签有一个 NAME 属性且值为 "myForm"，访问该 form 的方式可以是 document.forms[1]，document.forms["myForm"]或 document.myForm。
      
+
      这条规则的例外是从与 HTML 对应的对象，例如 forms 数组。对于这些数组的元素，你总是既可以通过其序号（依据其在文档中出现的顺序），也可以按照其名称（如果有的话）访问它。举例而言，如果文档中的第二个 <form> 标签有一个 NAME 属性且值为 "myForm"，访问该 form 的方式可以是 document.forms[1]，document.forms["myForm"] 或 document.myForm。
      
 
 
      为对象类型定义属性
      
 
@@ -377,7 +377,7 @@ 
      定义 getters 与 setters<
 
 
      一个 getter 是一个获取某个特定属性的值的方法。一个  setter 是一个设定某个属性的值的方法。你可以为预定义的或用户定义的对象定义 getter 和 setter 以支持新增的属性。定义 getter 和 setter 的语法采用对象字面量语法。
      
 
-
      下面例子描述了getters 和 setters 是如何为用户定义的对象 o 工作的。
      
+
      下面例子描述了 getters 和 setters 是如何为用户定义的对象 o 工作的。
      
 
 
      var o = {
   a: 7,
@@ -402,13 +402,13 @@ 
      定义 getters 与 setters<
  
    • o.c — 由  o.c 的值所设置 o.a 值的 setter
      • 
 
 
-
      请注意在一个对象字面量语法中定义getter和setter使用"[gs]et property()"的方式（相比较于__define[GS]etter__)时，并不是获取和设置某个属性自身，容易让人误以为是"[gs]et propertyName(){ }"这样错误的使用方法。定义一个getter或setter函数使用语法"[gs]et property()"，定义一个已经声明的函数作为的getter和setter方法，使用Object.defineProperty(或者 Object.prototype.__defineGetter__ 旧语法回退)
      
 
-
      下面这个例子展示使用getter和setter方法扩展 {{jsxref("Date")}}原型，为预定义好的Date类添加一个year的属性。定义属性year的getter和setter方法用到了Date类中已存在的getFullYear和setFullYear方法。
      
+
      下面这个例子展示使用 getter 和 setter 方法扩展 {{jsxref("Date")}}原型，为预定义好的 Date 类添加一个 year 的属性。定义属性 year 的 getter 和 setter 方法用到了 Date 类中已存在的 getFullYear 和 setFullYear 方法。
      
 
-
      定义属性year的getter和setter：
      
+
      定义属性 year 的 getter 和 setter：
      
 
 
      var d = Date.prototype;
 Object.defineProperty(d, "year", {
@@ -417,7 +417,7 @@ 
      定义 getters 与 setters<
 });
 
      
 
-
      通过一个Date对象使用getter和setter:
      
+
      通过一个 Date 对象使用 getter 和 setter:
      
 
 
      var now = new Date();
 console.log(now.year); // 2000
@@ -433,7 +433,7 @@ 
      定义 getters 与 setters<
  
    • 也可以之后随时使用 getter 和 setter 添加方法添加到任何对象
      • 
 
 
-
      当使用 使用对象初始化器 的方式定义getter和setter时，只需要在getter方法前加get，在setter方法前加set，当然，getter方法必须是无参数的，setter方法只接受一个参数(设置为新值），例如：
      
+
      当使用 使用对象初始化器 的方式定义 getter 和 setter 时，只需要在 getter 方法前加 get，在 setter 方法前加 set，当然，getter 方法必须是无参数的，setter 方法只接受一个参数 (设置为新值），例如：
      
 
 
      var o = {
   a: 7,
@@ -442,7 +442,7 @@ 
      定义 getters 与 setters<
 };
 
      
 
-
      使用Object.defineProperties的方法，同样也可以对一个已创建的对象在任何时候为其添加getter或setter方法。这个方法的第一个参数是你想定义getter或setter方法的对象，第二个参数是一个对象，这个对象的属性名用作getter或setter的名字，属性名对应的属性值用作定义getter或setter方法的函数，下面是一个例子定义了和前面例子一样的getter和setter方法：
      
+
      使用 Object.defineProperties 的方法，同样也可以对一个已创建的对象在任何时候为其添加 getter 或 setter 方法。这个方法的第一个参数是你想定义 getter 或 setter 方法的对象，第二个参数是一个对象，这个对象的属性名用作 getter 或 setter 的名字，属性名对应的属性值用作定义 getter 或 setter 方法的函数，下面是一个例子定义了和前面例子一样的 getter 和 setter 方法：
      
 
 
      var o = { a:0 }
 
@@ -455,7 +455,7 @@ 
      定义 getters 与 setters<
 console.log(o.b) // Runs the getter, which yields a + 1 or 6
 
      
 
-
      这两种定义方式的选择取决于你的编程风格和手头的工作量。当你定义一个原型准备进行初始化时，可以选择第一种方式，这种方式更简洁和自然。但是，当你需要添加getter和setter方法 —— 因为并没有编写原型或者特定的对象 ——使用第二种方式更好。第二种方式可能更能表现JavaScript语法的动态特性——但也会使代码变得难以阅读和理解。
      
+
      这两种定义方式的选择取决于你的编程风格和手头的工作量。当你定义一个原型准备进行初始化时，可以选择第一种方式，这种方式更简洁和自然。但是，当你需要添加 getter 和 setter 方法 —— 因为并没有编写原型或者特定的对象 ——使用第二种方式更好。第二种方式可能更能表现 JavaScript 语法的动态特性——但也会使代码变得难以阅读和理解。
      
 
 
      删除属性
      
 
@@ -480,9 +480,9 @@ 
      删除属性
      
 
 
      比较对象
      
 
-
      在 JavaScript 中 objects 是一种引用类型。两个独立声明的对象永远也不会相等，即使他们有相同的属性，只有在比较一个对象和这个对象的引用时，才会返回true.
      
+
      在 JavaScript 中 objects 是一种引用类型。两个独立声明的对象永远也不会相等，即使他们有相同的属性，只有在比较一个对象和这个对象的引用时，才会返回 true.
      
 
-
      // 两个变量, 两个具有同样的属性、但不相同的对象
+
      // 两个变量，两个具有同样的属性、但不相同的对象
 var fruit = {name: "apple"};
 var fruitbear = {name: "apple"};
 
@@ -491,14 +491,14 @@ 
      比较对象
      
 
      
 
 
      
-
      备注： "===" 运算符用来检查数值是否相等: 1 === "1"返回false，而1 == "1" 返回true
      
+
      备注： "===" 运算符用来检查数值是否相等: 1 === "1"返回 false，而 1 == "1" 返回 true
      
 
      
 
-
      // 两个变量, 同一个对象
+
      // 两个变量，同一个对象
 var fruit = {name: "apple"};
-var fruitbear = fruit;  // 将fruit的对象引用(reference)赋值给 fruitbear
-                        // 也称为将fruitbear“指向”fruit对象
-// fruit与fruitbear都指向同样的对象
+var fruitbear = fruit;  // 将 fruit 的对象引用(reference) 赋值给 fruitbear
+                        // 也称为将 fruitbear“指向”fruit 对象
+// fruit 与 fruitbear 都指向同样的对象
 fruit == fruitbear // return true
 fruit === fruitbear // return true
      
 
@@ -508,7 +508,7 @@ 
      附加参考
      
 
 
 
 

      
  
- 
      String对象方法
      
+ 
      String 对象方法
      
        
  
   
      
   
      
   
      
    {{jsxref("String.fromCharCode", "fromCharCode")}}, {{jsxref("String.fromCodePoint", "fromCodePoint")}}从指定的Unicode值序列构造一个字符串。这是一个String类方法，不是实例方法。从指定的 Unicode 值序列构造一个字符串。这是一个 String 类方法，不是实例方法。
   
      
   
      
    {{jsxref("String.split", "split")}}通过将字符串分离成一个个子串来把一个String对象分裂到一个字符串数组中。通过将字符串分离成一个个子串来把一个 String 对象分裂到一个字符串数组中。
   
      
   
      
    {{jsxref("String.slice", "slice")}}
   
      
   
      
    {{jsxref("String.match", "match")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}}通过正则表达式来工作.通过正则表达式来工作。
   
      
   
      
    {{jsxref("String.toLowerCase", "toLowerCase")}}, {{jsxref("String.toUpperCase", "toUpperCase")}}