From 01b0e12ba27b5069248fd09235e9a7143915ee30 Mon Sep 17 00:00:00 2001 From: Irvin Date: Wed, 16 Feb 2022 02:02:49 +0800 Subject: remove `notranslate` class in zh-CN --- .../a_re-introduction_to_javascript/index.html | 164 ++++++++++----------- files/zh-cn/web/javascript/closures/index.html | 36 ++--- .../web/javascript/data_structures/index.html | 6 +- .../index.html | 2 +- .../equality_comparisons_and_sameness/index.html | 8 +- files/zh-cn/web/javascript/eventloop/index.html | 8 +- .../guide/details_of_the_object_model/index.html | 92 ++++++------ .../guide/expressions_and_operators/index.html | 86 +++++------ .../web/javascript/guide/functions/index.html | 74 +++++----- .../javascript/guide/grammar_and_types/index.html | 92 ++++++------ .../guide/indexed_collections/index.html | 90 +++++------ .../web/javascript/guide/introduction/index.html | 4 +- .../javascript/guide/meta_programming/index.html | 12 +- .../javascript/guide/numbers_and_dates/index.html | 28 ++-- .../regular_expressions/assertions/index.html | 16 +- .../character_classes/index.html | 6 +- .../groups_and_ranges/index.html | 6 +- .../guide/regular_expressions/index.html | 38 ++--- .../regular_expressions/quantifiers/index.html | 8 +- .../unicode_property_escapes/index.html | 10 +- .../javascript/guide/text_formatting/index.html | 30 ++-- .../web/javascript/guide/using_promises/index.html | 54 +++---- .../inheritance_and_the_prototype_chain/index.html | 52 +++---- .../web/javascript/reference/classes/index.html | 36 ++--- .../errors/cyclic_object_value/index.html | 8 +- .../reference/errors/not_a_function/index.html | 22 +-- .../reference/errors/not_defined/index.html | 10 +- .../reference/functions/arguments/index.html | 36 ++--- .../reference/functions/arrow_functions/index.html | 50 +++---- .../global_objects/aggregateerror/index.html | 6 +- .../global_objects/array/concat/index.html | 10 +- .../global_objects/array/every/index.html | 8 +- .../global_objects/array/filter/index.html | 12 +- .../global_objects/array/findindex/index.html | 6 +- .../reference/global_objects/array/flat/index.html | 18 +-- .../global_objects/array/flatmap/index.html | 10 +- .../reference/global_objects/array/from/index.html | 18 +-- .../reference/global_objects/array/map/index.html | 24 +-- .../global_objects/array/reduce/index.html | 40 ++--- .../global_objects/array/reduceright/index.html | 20 +-- .../global_objects/array/slice/index.html | 14 +- .../global_objects/array/values/index.html | 12 +- .../global_objects/arraybuffer/index.html | 8 +- .../reference/global_objects/atomics/index.html | 8 +- .../global_objects/atomics/notify/index.html | 8 +- .../global_objects/bigint64array/index.html | 2 +- .../reference/global_objects/boolean/index.html | 12 +- .../reference/global_objects/date/index.html | 14 +- .../global_objects/encodeuricomponent/index.html | 10 +- .../global_objects/finalizationregistry/index.html | 12 +- .../global_objects/function/apply/index.html | 18 +-- .../global_objects/function/bind/index.html | 16 +- .../reference/global_objects/globalthis/index.html | 6 +- .../reference/global_objects/infinity/index.html | 2 +- .../global_objects/intl/locale/index.html | 4 +- .../intl/relativetimeformat/index.html | 8 +- .../global_objects/json/stringify/index.html | 18 +-- .../global_objects/map/foreach/index.html | 4 +- .../reference/global_objects/map/keys/index.html | 4 +- .../reference/global_objects/math/floor/index.html | 6 +- .../global_objects/math/random/index.html | 10 +- .../reference/global_objects/math/sin/index.html | 4 +- .../reference/global_objects/math/sinh/index.html | 6 +- .../global_objects/number/isfinite/index.html | 6 +- .../global_objects/number/number/index.html | 4 +- .../global_objects/object/assign/index.html | 24 +-- .../global_objects/object/create/index.html | 10 +- .../object/defineproperties/index.html | 6 +- .../object/defineproperty/index.html | 24 +-- .../global_objects/object/fromentries/index.html | 8 +- .../object/getownpropertydescriptor/index.html | 6 +- .../object/hasownproperty/index.html | 12 +- .../reference/global_objects/object/index.html | 10 +- .../reference/global_objects/object/is/index.html | 6 +- .../global_objects/object/issealed/index.html | 6 +- .../reference/global_objects/parseint/index.html | 18 +-- .../global_objects/promise/all/index.html | 14 +- .../global_objects/promise/allsettled/index.html | 2 +- .../global_objects/promise/any/index.html | 8 +- .../reference/global_objects/promise/index.html | 24 +-- .../global_objects/promise/race/index.html | 6 +- .../reference/global_objects/proxy/index.html | 18 +-- .../global_objects/proxy/proxy/index.html | 4 +- .../proxy/proxy/preventextensions/index.html | 6 +- .../global_objects/reflect/construct/index.html | 10 +- .../reflect/defineproperty/index.html | 6 +- .../reference/global_objects/reflect/index.html | 6 +- .../reference/global_objects/regexp/index.html | 20 +-- .../global_objects/regexp/regexp/index.html | 4 +- .../global_objects/regexp/test/index.html | 8 +- .../global_objects/set/@@iterator/index.html | 6 +- .../global_objects/set/@@species/index.html | 4 +- .../reference/global_objects/set/add/index.html | 4 +- .../reference/global_objects/set/index.html | 12 +- .../reference/global_objects/set/set/index.html | 4 +- .../reference/global_objects/set/values/index.html | 4 +- .../global_objects/string/charcodeat/index.html | 8 +- .../global_objects/string/concat/index.html | 4 +- .../global_objects/string/endswith/index.html | 6 +- .../global_objects/string/fromcharcode/index.html | 6 +- .../global_objects/string/includes/index.html | 8 +- .../global_objects/string/indexof/index.html | 18 +-- .../global_objects/string/localecompare/index.html | 10 +- .../global_objects/string/match/index.html | 10 +- .../global_objects/string/matchall/index.html | 14 +- .../global_objects/string/padend/index.html | 6 +- .../global_objects/string/padstart/index.html | 6 +- .../global_objects/string/repeat/index.html | 6 +- .../global_objects/string/replace/index.html | 22 +-- .../global_objects/string/replaceall/index.html | 8 +- .../global_objects/string/search/index.html | 4 +- .../global_objects/string/startswith/index.html | 6 +- .../global_objects/string/substring/index.html | 10 +- .../global_objects/string/tolowercase/index.html | 4 +- .../global_objects/string/touppercase/index.html | 6 +- .../global_objects/string/trim/index.html | 6 +- .../global_objects/string/valueof/index.html | 4 +- .../global_objects/symbol/hasinstance/index.html | 2 +- .../reference/global_objects/symbol/index.html | 18 +-- .../global_objects/symbol/keyfor/index.html | 4 +- .../global_objects/symbol/search/index.html | 2 +- .../global_objects/symbol/split/index.html | 4 +- .../global_objects/typedarray/foreach/index.html | 4 +- .../global_objects/typedarray/set/index.html | 4 +- .../global_objects/uint16array/index.html | 2 +- .../global_objects/uint8clampedarray/index.html | 8 +- .../reference/global_objects/unescape/index.html | 4 +- .../global_objects/weakref/deref/index.html | 4 +- .../reference/global_objects/weakref/index.html | 2 +- .../global_objects/webassembly/global/index.html | 2 +- .../global_objects/webassembly/instance/index.html | 2 +- .../global_objects/webassembly/table/index.html | 8 +- .../reference/iteration_protocols/index.html | 30 ++-- .../reference/operators/addition/index.html | 6 +- .../operators/addition_assignment/index.html | 4 +- .../reference/operators/assignment/index.html | 4 +- .../reference/operators/await/index.html | 8 +- .../reference/operators/bitwise_and/index.html | 8 +- .../operators/bitwise_and_assignment/index.html | 4 +- .../reference/operators/bitwise_not/index.html | 8 +- .../reference/operators/bitwise_or/index.html | 8 +- .../operators/bitwise_or_assignment/index.html | 4 +- .../reference/operators/bitwise_xor/index.html | 8 +- .../operators/bitwise_xor_assignment/index.html | 4 +- .../reference/operators/decrement/index.html | 6 +- .../reference/operators/delete/index.html | 28 ++-- .../reference/operators/division/index.html | 6 +- .../operators/division_assignment/index.html | 4 +- .../reference/operators/equality/index.html | 12 +- .../reference/operators/exponentiation/index.html | 12 +- .../operators/exponentiation_assignment/index.html | 4 +- .../reference/operators/greater_than/index.html | 12 +- .../operators/greater_than_or_equal/index.html | 12 +- .../javascript/reference/operators/in/index.html | 14 +- .../reference/operators/increment/index.html | 6 +- .../reference/operators/inequality/index.html | 14 +- .../reference/operators/instanceof/index.html | 12 +- .../reference/operators/left_shift/index.html | 6 +- .../operators/left_shift_assignment/index.html | 4 +- .../reference/operators/less_than/index.html | 12 +- .../operators/less_than_or_equal/index.html | 12 +- .../reference/operators/logical_and/index.html | 20 +-- .../operators/logical_and_assignment/index.html | 8 +- .../reference/operators/logical_not/index.html | 10 +- .../logical_nullish_assignment/index.html | 8 +- .../reference/operators/logical_or/index.html | 20 +-- .../reference/operators/multiplication/index.html | 8 +- .../operators/multiplication_assignment/index.html | 4 +- .../javascript/reference/operators/new/index.html | 20 +-- .../nullish_coalescing_operator/index.html | 18 +-- .../operators/optional_chaining/index.html | 28 ++-- .../reference/operators/remainder/index.html | 8 +- .../operators/remainder_assignment/index.html | 4 +- .../reference/operators/right_shift/index.html | 8 +- .../operators/right_shift_assignment/index.html | 4 +- .../reference/operators/spread_syntax/index.html | 36 ++--- .../reference/operators/strict_equality/index.html | 8 +- .../operators/strict_inequality/index.html | 12 +- .../reference/operators/subtraction/index.html | 6 +- .../operators/subtraction_assignment/index.html | 4 +- .../reference/operators/super/index.html | 12 +- .../javascript/reference/operators/this/index.html | 46 +++--- .../reference/operators/typeof/index.html | 20 +-- .../reference/operators/unary_negation/index.html | 6 +- .../reference/operators/unary_plus/index.html | 6 +- .../operators/unsigned_right_shift/index.html | 8 +- .../unsigned_right_shift_assignment/index.html | 4 +- .../reference/statements/async_function/index.html | 22 +-- .../reference/statements/break/index.html | 14 +- .../reference/statements/const/index.html | 10 +- .../reference/statements/export/index.html | 38 ++--- .../reference/statements/for-await...of/index.html | 8 +- .../reference/statements/for...in/index.html | 8 +- .../reference/statements/function/index.html | 12 +- .../reference/statements/import/index.html | 34 ++--- .../javascript/reference/statements/let/index.html | 26 ++-- .../reference/statements/switch/index.html | 16 +- .../reference/statements/with/index.html | 8 +- 198 files changed, 1409 insertions(+), 1409 deletions(-) (limited to 'files/zh-cn/web') diff --git a/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html b/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html index 7c567f3902..b49d5c9024 100644 --- a/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html +++ b/files/zh-cn/web/javascript/a_re-introduction_to_javascript/index.html @@ -63,7 +63,7 @@ translation_of: Web/JavaScript/A_re-introduction_to_JavaScript

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

-
console.log(3 / 2);             // 1.5,not 1
+
console.log(3 / 2);             // 1.5,not 1
 console.log(Math.floor(3 / 2)); // 1
 

 
@@ -71,67 +71,67 @@ console.log(Math.floor(3 / 2)); // 1
 
 
当然，您也需要小心这种情况：

 
-
0.1 + 0.2 = 0.30000000000000004
+
0.1 + 0.2 = 0.30000000000000004
 

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

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

 
-
Math.sin(3.5);
+
Math.sin(3.5);
 var circumference = 2 * Math.PI * r;
 

 
 
你可以使用内置函数 {{jsxref("Global_Objects/parseInt", "parseInt()")}} 将字符串转换为整型。该函数的第二个可选参数表示字符串所表示数字的基（进制）：

 
-
parseInt("123", 10); // 123
+
parseInt("123", 10); // 123
 parseInt("010", 10); // 10
 

 
 
一些老版本的浏览器会将首字符为“0”的字符串当做八进制数字，2013 年以前的 JavaScript 实现会返回一个意外的结果：

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

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

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

 
-
parseInt("11", 2); // 3
+
parseInt("11", 2); // 3
 

 
 
JavaScript 还有一个类似的内置函数 {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}，用以解析浮点数字符串，与{{jsxref("Global_Objects/parseInt", "parseInt()")}}不同的地方是，parseFloat() 只应用于解析十进制数字。

 
 
一元运算符 + 也可以把数字字符串转换成数值：

 
-
+ "42";   // 42
+
+ "42";   // 42
 + "010";  // 10
 + "0x10"; // 16

 
 
如果给定的字符串不存在数值形式，函数会返回一个特殊的值 {{jsxref("NaN")}}（Not a Number 的缩写）：

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

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

 
-
NaN + 5; //NaN
+
NaN + 5; //NaN
 

 
 
可以使用内置函数 isNaN() 来判断一个变量是否为 NaN：

 
-
isNaN(NaN); // true
+
isNaN(NaN); // true
 

 
 
JavaScript 还有两个特殊值：Infinity（正无穷）和 -Infinity（负无穷）：

 
-
1 / 0; //  Infinity
+
1 / 0; //  Infinity
 -1 / 0; // -Infinity
 

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

 
-
isFinite(1/0); // false
+
isFinite(1/0); // false
 isFinite(Infinity); // false
 isFinite(-Infinity); // false
 isFinite(NaN); // false
@@ -153,12 +153,12 @@ Number.isFinite("0"); // false

 
 
通过访问字符串的 length（编码单元的个数）属性，可以得到它的长度。

 
-
"hello".length; // 5
+
"hello".length; // 5
 

 
 
这是我们第一次碰到 JavaScript 对象。我们有没有提过你可以像  {{jsxref("Object", "object", "", 1)}}  一样使用字符串？是的，字符串也有 {{jsxref("String", "methods", "#Methods", 1)}}（方法）能让你操作字符串和获取字符串的信息。

 
-
"hello".charAt(0); // "h"
+
"hello".charAt(0); // "h"
 "hello, world".replace("world", "mars"); // "hello, mars"
 "hello".toUpperCase(); // "HELLO"
 

@@ -176,7 +176,7 @@ Number.isFinite("0"); // false

 
 
也可以使用 Boolean() 函数进行显式转换：

 
-
Boolean(''); // false
+
Boolean(''); // false
 Boolean(234); // true
 

 
@@ -190,12 +190,12 @@ Boolean(234); // true
 
 
let 语句声明一个块级作用域的本地变量，并且可选的将其初始化为一个值。

 
-
let a;
+
let a;
 let name = 'Simon';

 
 
下面是使用  let 声明变量作用域的例子：

 
-
// myLetVariable 在这里 *不能* 被引用
+
// myLetVariable 在这里 *不能* 被引用
 
 for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
   // myLetVariable 只能在这里引用
@@ -205,18 +205,18 @@ for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
 
 
const 允许声明一个不可变的常量。这个常量在定义域内总是可见的。

 
-
const Pi = 3.14; // 设置 Pi 的值
+
const Pi = 3.14; // 设置 Pi 的值
 Pi = 1; // 将会抛出一个错误因为你改变了一个常量的值。

 
 
var 是最常见的声明变量的关键字。它没有其他两个关键字的种种限制。这是因为它是传统上在 JavaScript 声明变量的唯一方法。使用 var 声明的变量在它所声明的整个函数都是可见的。

 
-
var a;
+
var a;
 var name = "simon";
 

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

 
-
// myVarVariable在这里 *能* 被引用
+
// myVarVariable在这里 *能* 被引用
 
 for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
   // myVarVariable 整个函数中都能被引用
@@ -232,19 +232,19 @@ for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
 
 
JavaScript的算术操作符包括 +、-、*、/ 和 % ——求余（与模运算相同）。赋值使用 = 运算符，此外还有一些复合运算符，如 += 和 -=，它们等价于 x = x operator y。

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

 
 
可以使用 ++ 和 -- 分别实现变量的自增和自减。两者都可以作为前缀或后缀操作符使用。

 
 
+ 操作符还可以用来连接字符串：

 
-
"hello" + " world"; // hello world
+
"hello" + " world"; // hello world
 

 
 
如果你用一个字符串加上一个数字（或其他值），那么操作数都会被首先转换为字符串。如下所示：

 
-
"3" + 4 + 5; // 345
+
"3" + 4 + 5; // 345
 3 + 4 + "5"; // 75
 

 
@@ -252,13 +252,13 @@ for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
 
 
JavaScript 中的比较操作使用 <、>、<= 和 >=，这些运算符对于数字和字符串都通用。相等的比较稍微复杂一些。由两个“=（等号）”组成的相等运算符有类型自适应的功能，具体例子如下：

 
-
123 == "123" // true
+
123 == "123" // true
 1 == true; // true
 

 
 
如果在比较前不需要自动类型转换，应该使用由三个“=（等号）”组成的相等运算符：

 
-
1 === true; //false
+
1 === true; //false
 123 === "123"; // false
 

 
@@ -270,7 +270,7 @@ for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
 
 
JavaScript 的控制结构与其他类 C 语言类似。可以使用 if 和 else 来定义条件语句，还可以连起来使用：

 
-
var name = "kittens";
+
var name = "kittens";
 if (name == "puppies") {
   name += "!";
 } else if (name == "kittens") {
@@ -283,7 +283,7 @@ name == "kittens!!"; // true
 
 
JavaScript 支持 while 循环和 do-while 循环。前者适合常见的基本循环操作，如果需要循环体至少被执行一次则可以使用 do-while：

 
-
while (true) {
+
while (true) {
   // 一个无限循环！
 }
 
@@ -295,41 +295,41 @@ do {
 
 
JavaScript 的 for 循环与 C 和 Java 中的相同：使用时可以在一行代码中提供控制信息。

 
-
for (var i = 0; i < 5; i++) {
+
for (var i = 0; i < 5; i++) {
   // 将会执行五次
 }
 

 
 
JavaScript 也还包括其他两种重要的 for 循环： for...of

 
-
for (let value of array) {
+
for (let value of array) {
   // do something with value
 }

 
 
和 for...in ：

 
-
for (let property in object) {
+
for (let property in object) {
   // do something with object property
 }

 
 
&& 和 || 运算符使用短路逻辑（short-circuit logic），是否会执行第二个语句（操作数）取决于第一个操作数的结果。在需要访问某个对象的属性时，使用这个特性可以事先检测该对象是否为空：

 
-
var name = o && o.getName();
+
var name = o && o.getName();
 

 
 
或用于缓存值（当错误值无效时）：

 
-
var name = cachedName || (cachedName = getName());
+
var name = cachedName || (cachedName = getName());
 

 
 
类似地，JavaScript 也有一个用于条件表达式的三元操作符：

 
-
var allowed = (age > 18) ? "yes" : "no";
+
var allowed = (age > 18) ? "yes" : "no";
 

 
 
在需要多重分支时可以使用基于一个数字或字符串的 switch 语句：

 
-
switch(action) {
+
switch(action) {
     case 'draw':
         drawIt();
         break;
@@ -343,7 +343,7 @@ do {
 
 
如果你不使用 break 语句，JavaScript 解释器将会执行之后 case 中的代码。除非是为了调试，一般你并不需要这个特性，所以大多数时候不要忘了加上 break。

 
-
switch(a) {
+
switch(a) {
     case 1: // 继续向下
     case 2:
         eatIt();
@@ -355,7 +355,7 @@ do {
 
 
default 语句是可选的。switch 和 case 都可以使用需要运算才能得到结果的表达式；在 switch 的表达式和 case 的表达式是使用 === 严格相等运算符进行比较的：

 
-
switch(1 + 3){
+
switch(1 + 3){
     case 2 + 2:
         yay();
         break;
@@ -382,19 +382,19 @@ do {
 
 
有两种简单方法可以创建一个空对象：

 
-
var obj = new Object();
+
var obj = new Object();
 

 
 
和：

 
-
var obj = {};
+
var obj = {};
 

 
 
这两种方法在语义上是相同的。第二种更方便的方法叫作“对象字面量（object literal）”法。这种也是 JSON 格式的核心语法，一般我们优先选择第二种方法。

 
 
“对象字面量”也可以用来在对象实例中定义一个对象：

 
-
var obj = {
+
var obj = {
     name: "Carrot",
     _for: "Max",//'for' 是保留字之一，使用'_for'代替
     details: {
@@ -406,13 +406,13 @@ do {
 
 
对象的属性可以通过链式（chain）表示方法进行访问：

 
-
obj.details.color; // orange
+
obj.details.color; // orange
 obj["details"]["size"]; // 12
 

 
 
下面的例子创建了一个对象原型，Person，和这个原型的实例，You。

 
-
function Person(name, age) {
+
function Person(name, age) {
   this.name = name;
   this.age = age;
 }
@@ -425,14 +425,14 @@ var You = new Person('You', 24);
 
 
完成创建后，对象属性可以通过如下两种方式进行赋值和访问：

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

 
 
和：

 
-
// 括号表示法(bracket notation)
+
// 括号表示法(bracket notation)
 obj['name'] = 'Simon';
 var name = obj['name'];
 // can use a variable to define a key
@@ -441,7 +441,7 @@ obj[user] = prompt('what is its value?')

 
 
这两种方法在语义上也是相同的。第二种方法的优点在于属性的名称被看作一个字符串，这就意味着它可以在运行时被计算，缺点在于这样的代码有可能无法在后期被解释器优化。它也可以被用来访问某些以预留关键字作为名称的属性的值：

 
-
obj.for = 'Simon'; // 语法错误，因为 for 是一个预留关键字
+
obj.for = 'Simon'; // 语法错误，因为 for 是一个预留关键字
 obj["for"] = 'Simon'; // 工作正常
 

 
@@ -461,7 +461,7 @@ obj["for"] = 'Simon'; // 工作正常
 
 
创建数组的传统方法是：

 
-
var a = new Array();
+
var a = new Array();
 a[0] = "dog";
 a[1] = "cat";
 a[2] = "hen";
@@ -470,13 +470,13 @@ a.length; // 3
 
 
使用数组字面量（array literal）法更加方便：

 
-
var a = ["dog", "cat", "hen"];
+
var a = ["dog", "cat", "hen"];
 a.length; // 3
 

 
 
注意，Array.length 并不总是等于数组中元素的个数，如下所示：

 
-
var a = ["dog", "cat", "hen"];
+
var a = ["dog", "cat", "hen"];
 a[100] = "fox";
 a.length; // 101
 

@@ -485,40 +485,40 @@ a.length; // 101
 
 
如果试图访问一个不存在的数组索引，会得到 undefined：

 
-
typeof(a[90]); // undefined
+
typeof(a[90]); // undefined
 

 
 
可以通过如下方式遍历一个数组：

 
-
for (var i = 0; i < a.length; i++) {
+
for (var i = 0; i < a.length; i++) {
     // Do something with a[i]
 }
 

 
 
ES2015 引入了更加简洁的 for...of 循环，可以用它来遍历可迭代对象，例如数组：

 
-
for (const currentValue of a) {
+
for (const currentValue of a) {
   // Do something with currentValue
 }
 

 
 
遍历数组的另一种方法是使用 for...in 循环， 然而这并不是遍历数组元素而是数组的索引。注意，如果哪个家伙直接向 Array.prototype 添加了新的属性，使用这样的循环这些属性也同样会被遍历。所以并不推荐使用这种方法遍历数组：

 
-
for (var i in a) {
+
for (var i in a) {
   // 操作 a[i]
 }
 

 
 
ECMAScript 5 增加了另一个遍历数组的方法，forEach()：

 
-
["dog", "cat", "hen"].forEach(function(currentValue, index, array) {
+
["dog", "cat", "hen"].forEach(function(currentValue, index, array) {
   // 操作 currentValue 或者 array[index]
 });
 

 
 
如果想在数组后追加元素，只需要：

 
-
a.push(item);

+
a.push(item);

 
 
除了 forEach() 和 push()，Array（数组）类还自带了许多方法。建议查看 Array 方法的完整文档。

 
@@ -591,7 +591,7 @@ a.length; // 101
 
 
学习 JavaScript 最重要的就是要理解对象和函数两个部分。最简单的函数就像下面这个这么简单：

 
-
function add(x, y) {
+
function add(x, y) {
     var total = x + y;
     return total;
 }
@@ -601,19 +601,19 @@ a.length; // 101
 
 
已命名的参数更像是一个指示而没有其他作用。如果调用函数时没有提供足够的参数，缺少的参数会被 undefined 替代。

 
-
add(); // NaN
+
add(); // NaN
 // 不能在 undefined 对象上进行加法操作
 

 
 
你还可以传入多于函数本身需要参数个数的参数：

 
-
add(2, 3, 4); // 5
+
add(2, 3, 4); // 5
  // 将前两个值相加，4 被忽略了
 

 
 
这看上去有点蠢。函数实际上是访问了函数体中一个名为 arguments 的内部对象，这个对象就如同一个类似于数组的对象一样，包括了所有被传入的参数。让我们重写一下上面的函数，使它可以接收任意个数的参数：

 
-
function add() {
+
function add() {
     var sum = 0;
     for (var i = 0, j = arguments.length; i < j; i++) {
         sum += arguments[i];
@@ -626,7 +626,7 @@ add(2, 3, 4, 5); // 14
 
 
这跟直接写成 2 + 3 + 4 + 5 也没什么区别。我们还是创建一个求平均数的函数吧：

 
-
function avg() {
+
function avg() {
     var sum = 0;
     for (var i = 0, j = arguments.length; i < j; i++) {
         sum += arguments[i];
@@ -637,7 +637,7 @@ avg(2, 3, 4, 5); // 3.5

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

 
-
function avg(...args) {
+
function avg(...args) {
   var sum = 0;
   for (let value of args) {
     sum += value;
@@ -654,7 +654,7 @@ avg(2, 3, 4, 5); // 3.5
 
需要注意的是，无论“剩余参数操作符”被放置到函数声明的哪里，它都会把除了自己之前的所有参数存储起来。比如函数：function avg(firstValue, ...args) 会把传入函数的第一个值存入 firstValue，其他的参数存入 args。这是虽然一个很有用的语言特性，却也会带来新的问题。avg() 函数只接受逗号分开的参数列表 -- 但是如果你想要获取一个数组的平均值怎么办？一种方法是将函数按照如下方式重写：

 
 
-
function avgArray(arr) {
+
function avgArray(arr) {
     var sum = 0;
     for (var i = 0, j = arr.length; i < j; i++) {
         sum += arr[i];
@@ -666,7 +666,7 @@ avgArray([2, 3, 4, 5]); // 3.5
 
 
但如果能重用我们已经创建的那个函数不是更好吗？幸运的是 JavaScript 允许你通过任意函数对象的 apply() 方法来传递给它一个数组作为参数列表。

 
-
avg.apply(null, [2, 3, 4, 5]); // 3.5
+
avg.apply(null, [2, 3, 4, 5]); // 3.5
 

 
 
传给 apply() 的第二个参数是一个数组，它将被当作 avg() 的参数列表使用，至于第一个参数 null，我们将在后面讨论。这也正说明了一个事实——函数也是对象。

@@ -679,7 +679,7 @@ avgArray([2, 3, 4, 5]); // 3.5
 
 
JavaScript 允许你创建匿名函数：

 
-
var avg = function() {
+
var avg = function() {
     var sum = 0;
     for (var i = 0, j = arguments.length; i < j; i++) {
         sum += arguments[i];
@@ -690,7 +690,7 @@ avgArray([2, 3, 4, 5]); // 3.5
 
 
这个函数在语义上与 function avg() 相同。你可以在代码中的任何地方定义这个函数，就像写普通的表达式一样。基于这个特性，有人发明出一些有趣的技巧。与 C 中的块级作用域类似，下面这个例子隐藏了局部变量：

 
-
var a = 1;
+
var a = 1;
 var b = 2;
 (function() {
     var b = 3;
@@ -703,7 +703,7 @@ b; // 2
 
 
JavaScript 允许以递归方式调用函数。递归在处理树形结构（比如浏览器 DOM）时非常有用。

 
-
function countChars(elm) {
+
function countChars(elm) {
     if (elm.nodeType == 3) { // 文本节点
         return elm.nodeValue.length;
     }
@@ -717,7 +717,7 @@ b; // 2
 
 
这里需要说明一个潜在问题——既然匿名函数没有名字，那该怎么递归调用它呢？在这一点上，JavaScript 允许你命名这个函数表达式。你可以命名立即调用的函数表达式（IIFE——Immediately Invoked Function Expression），如下所示：

 
-
var charsInBody = (function counter(elm) {
+
var charsInBody = (function counter(elm) {
     if (elm.nodeType == 3) { // 文本节点
         return elm.nodeValue.length;
     }
@@ -739,7 +739,7 @@ b; // 2
 
 
在经典的面向对象语言中，对象是指数据和在这些数据上进行的操作的集合。与 C++ 和 Java 不同，JavaScript 是一种基于原型的编程语言，并没有 class 语句，而是把函数用作类。那么让我们来定义一个人名对象，这个对象包括人的姓和名两个域（field）。名字的表示有两种方法：“名 姓（First Last）”或“姓, 名（Last, First）”。使用我们前面讨论过的函数和对象概念，可以像这样完成定义：

 
-
function makePerson(first, last) {
+
function makePerson(first, last) {
     return {
         first: first,
         last: last
@@ -758,7 +758,7 @@ personFullNameReversed(s); // "Willison, Simon"

 
 
上面的写法虽然可以满足要求，但是看起来很麻烦，因为需要在全局命名空间中写很多函数。既然函数本身就是对象，如果需要使一个函数隶属于一个对象，那么不难得到：

 
-
function makePerson(first, last) {
+
function makePerson(first, last) {
     return {
         first: first,
         last: last,
@@ -776,7 +776,7 @@ s.fullNameReversed(); // Willison, Simon

 
 
上面的代码里有一些我们之前没有见过的东西：关键字 this。当使用在函数中时，this 指代当前的对象，也就是调用了函数的对象。如果在一个对象上使用点或者方括号来访问属性或方法，这个对象就成了 this。如果并没有使用“点”运算符调用某个对象，那么 this 将指向全局对象（global object）。这是一个经常出错的地方。例如：

 
-
s = makePerson("Simon", "Willison");
+
s = makePerson("Simon", "Willison");
 var fullName = s.fullName;
 fullName(); // undefined undefined
 

@@ -785,7 +785,7 @@ fullName(); // undefined undefined
 
 
下面使用关键字 this 改进已有的 makePerson函数：

 
-
function Person(first, last) {
+
function Person(first, last) {
     this.first = first;
     this.last = last;
     this.fullName = function() {
@@ -804,7 +804,7 @@ var s = new Person("Simon", "Willison");
 
 
我们的 Person 对象现在已经相当完善了，但还有一些不太好的地方。每次我们创建一个 Person 对象的时候，我们都在其中创建了两个新的函数对象——如果这个代码可以共享不是更好吗？

 
-
function personFullName() {
+
function personFullName() {
     return this.first + ' ' + this.last;
 }
 function personFullNameReversed() {
@@ -820,7 +820,7 @@ function Person(first, last) {
 
 
这种写法的好处是，我们只需要创建一次方法函数，在构造函数中引用它们。那是否还有更好的方法呢？答案是肯定的。

 
-
function Person(first, last) {
+
function Person(first, last) {
     this.first = first;
     this.last = last;
 }
@@ -836,7 +836,7 @@ Person.prototype.fullNameReversed = function() {
 
 
这个特性功能十分强大，JavaScript 允许你在程序中的任何时候修改原型（prototype）中的一些东西，也就是说你可以在运行时(runtime)给已存在的对象添加额外的方法：

 
-
s = new Person("Simon", "Willison");
+
s = new Person("Simon", "Willison");
 s.firstNameCaps();  // TypeError on line 1: s.firstNameCaps is not a function
 
 Person.prototype.firstNameCaps = function() {
@@ -847,7 +847,7 @@ s.firstNameCaps(); // SIMON
 
 
有趣的是，你还可以给 JavaScript 的内置函数原型（prototype）添加东西。让我们给 String 添加一个方法用来返回逆序的字符串：

 
-
var s = "Simon";
+
var s = "Simon";
 s.reversed(); // TypeError on line 1: s.reversed is not a function
 
 String.prototype.reversed = function() {
@@ -862,12 +862,12 @@ s.reversed(); // nomiS
 
 
定义新方法也可以在字符串字面量上用（string literal）。

 
-
"This can now be reversed".reversed(); // desrever eb won nac sihT
+
"This can now be reversed".reversed(); // desrever eb won nac sihT
 

 
 
正如我前面提到的，原型组成链的一部分。那条链的根节点是 Object.prototype，它包括 toString() 方法——将对象转换成字符串时调用的方法。这对于调试我们的 Person 对象很有用：

 
-
var s = new Person("Simon", "Willison");
+
var s = new Person("Simon", "Willison");
 s; // [object Object]
 
 Person.prototype.toString = function() {
@@ -878,7 +878,7 @@ s.toString(); // <Person: Simon Willison>
 
 
你是否还记得之前我们说的 avg.apply() 中的第一个参数 null？现在我们可以回头看看这个东西了。apply() 的第一个参数应该是一个被当作 this 来看待的对象。下面是一个 new 方法的简单实现：

 
-
function trivialNew(constructor, ...args) {
+
function trivialNew(constructor, ...args) {
     var o = {}; // 创建一个对象
     constructor.apply(o, args);
     return o;
@@ -889,15 +889,15 @@ s.toString(); // <Person: Simon Willison>
 
 
因此，调用

 
-
var bill = trivialNew(Person, "William", "Orange");

+
var bill = trivialNew(Person, "William", "Orange");

 
 
可认为和调用如下语句是等效的

 
-
var bill = new Person("William", "Orange");

+
var bill = new Person("William", "Orange");

 
 
apply() 有一个姐妹函数，名叫 call，它也可以允许你设置 this，但它带有一个扩展的参数列表而不是一个数组。

 
-
function lastNameCaps() {
+
function lastNameCaps() {
     return this.last.toUpperCase();
 }
 var s = new Person("Simon", "Willison");
@@ -911,7 +911,7 @@ s.lastNameCaps();
 
 
JavaScript 允许在一个函数内部定义函数，这一点我们在之前的 makePerson() 例子中也见过。关于 JavaScript 中的嵌套函数，一个很重要的细节是，它们可以访问父函数作用域中的变量：

 
-
function parentFunc() {
+
function parentFunc() {
   var a = 1;
 
   function nestedFunc() {
@@ -929,7 +929,7 @@ s.lastNameCaps();
 
 
闭包是 JavaScript 中最强大的抽象概念之一——但它也是最容易造成困惑的。它究竟是做什么的呢？

 
-
function makeAdder(a) {
+
function makeAdder(a) {
   return function(b) {
     return a + b;
   }
@@ -946,7 +946,7 @@ add20(7); // ?
 
 
这里发生的事情和前面介绍过的内嵌函数十分相似：一个函数被定义在了另外一个函数的内部，内部函数可以访问外部函数的变量。唯一的不同是，外部函数已经返回了，那么常识告诉我们局部变量“应该”不再存在。但是它们却仍然存在——否则 adder 函数将不能工作。也就是说，这里存在 makeAdder 的局部变量的两个不同的“副本”——一个是 a 等于 5，另一个是 a 等于 20。那些函数的运行结果就如下所示：

 
-
add5(6); // 返回 11
+
add5(6); // 返回 11
 add20(7); // 返回 27
 

 
diff --git a/files/zh-cn/web/javascript/closures/index.html b/files/zh-cn/web/javascript/closures/index.html
index 4b732a1a0d..29356fb61a 100644
--- a/files/zh-cn/web/javascript/closures/index.html
+++ b/files/zh-cn/web/javascript/closures/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Closures
 
请看下面的代码：

 
 

-
function init() {
+
function init() {
     var name = "Mozilla"; // name 是一个被 init 创建的局部变量
     function displayName() { // displayName() 是内部函数，一个闭包
         alert(name); // 使用了父函数中声明的变量
@@ -37,7 +37,7 @@ init();

 
 
现在来考虑以下例子 ：

 
-
function makeFunc() {
+
function makeFunc() {
     var name = "Mozilla";
     function displayName() {
         alert(name);
@@ -56,7 +56,7 @@ myFunc();

 
 
下面是一个更有意思的示例 — 一个 makeAdder 函数：

 
-
function makeAdder(x) {
+
function makeAdder(x) {
   return function(y) {
     return x + y;
   };
@@ -85,7 +85,7 @@ console.log(add10(2)); // 12
 
 
假如，我们想在页面上添加一些可以调整字号的按钮。一种方法是以像素为单位指定 body 元素的 font-size，然后通过相对的 em 单位设置页面中其它元素（例如header）的字号：

 
-
body {
+
body {
   font-family: Helvetica, Arial, sans-serif;
   font-size: 12px;
 }
@@ -103,7 +103,7 @@ h2 {
 
 
以下是 JavaScript：

 
-
function makeSizer(size) {
+
function makeSizer(size) {
   return function() {
     document.body.style.fontSize = size + 'px';
   };
@@ -116,12 +116,12 @@ var size16 = makeSizer(16);
 
 
size12，size14 和 size16 三个函数将分别把 body 文本调整为 12，14，16 像素。我们可以将它们分别添加到按钮的点击事件上。如下所示：

 
-
document.getElementById('size-12').onclick = size12;
+
document.getElementById('size-12').onclick = size12;
 document.getElementById('size-14').onclick = size14;
 document.getElementById('size-16').onclick = size16;
 

 
-
<a href="#" id="size-12">12</a>
+
<a href="#" id="size-12">12</a>
 <a href="#" id="size-14">14</a>
 <a href="#" id="size-16">16</a>
 

@@ -136,7 +136,7 @@ document.getElementById('size-16').onclick = size16;
 
 
下面的示例展现了如何使用闭包来定义公共函数，并令其可以访问私有函数和变量。这个方式也称为 模块模式（module pattern）：

 
-
var Counter = (function() {
+
var Counter = (function() {
   var privateCounter = 0;
   function changeBy(val) {
     privateCounter += val;
@@ -172,7 +172,7 @@ console.log(Counter.value()); /* logs 1 */
 
你应该注意到我们定义了一个匿名函数，用于创建一个计数器。我们立即执行了这个匿名函数，并将他的值赋给了变量Counter。我们可以把这个函数储存在另外一个变量makeCounter中，并用他来创建多个计数器。

 

 
-
var makeCounter = function() {
+
var makeCounter = function() {
   var privateCounter = 0;
   function changeBy(val) {
     privateCounter += val;
@@ -213,13 +213,13 @@ console.log(Counter2.value()); /* logs 0 */
 
 
在 ECMAScript 2015 引入 let 关键字 之前，在循环中有一个常见的闭包创建问题。参考下面的示例：

 
-
<p id="help">Helpful notes will appear here</p>
+
<p id="help">Helpful notes will appear here</p>
 <p>E-mail: <input type="text" id="email" name="email"></p>
 <p>Name: <input type="text" id="name" name="name"></p>
 <p>Age: <input type="text" id="age" name="age"></p>
 

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -251,7 +251,7 @@ setupHelp();
 
 
解决这个问题的一种方案是使用更多的闭包：特别是使用前面所述的函数工厂：

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -283,7 +283,7 @@ setupHelp();
 
 
另一种方法使用了匿名闭包：

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -308,7 +308,7 @@ setupHelp();

 
 
如果不想使用过多的闭包，你可以用ES2015引入的let关键词：

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -333,7 +333,7 @@ setupHelp();

 
 
另一个可选方案是使用 forEach()来遍历helpText数组并给每一个<p>添加一个监听器，如下所示：

 
-
function showHelp(help) {
+
function showHelp(help) {
   document.getElementById('help').innerHTML = help;
 }
 
@@ -361,7 +361,7 @@ setupHelp();

 
 
考虑以下示例：

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
   this.name = name.toString();
   this.message = message.toString();
   this.getName = function() {
@@ -376,7 +376,7 @@ setupHelp();

 
 
在上面的代码中，我们并没有利用到闭包的好处，因此可以避免使用闭包。修改成如下：

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
   this.name = name.toString();
   this.message = message.toString();
 }
@@ -393,7 +393,7 @@ MyObject.prototype = {
 
 
但我们不建议重新定义原型。可改成如下例子：

 
-
function MyObject(name, message) {
+
function MyObject(name, message) {
   this.name = name.toString();
   this.message = message.toString();
 }
diff --git a/files/zh-cn/web/javascript/data_structures/index.html b/files/zh-cn/web/javascript/data_structures/index.html
index 43090ed41c..51597b130c 100644
--- a/files/zh-cn/web/javascript/data_structures/index.html
+++ b/files/zh-cn/web/javascript/data_structures/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Data_structures
 
 
JavaScript 是一种弱类型或者说动态语言。这意味着你不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。这也意味着你可以使用同一个变量保存不同类型的数据：

 
-
var foo = 42;    // foo is a Number now
+
var foo = 42;    // foo is a Number now
 foo = "bar"; // foo is a String now
 foo = true;  // foo is a Boolean now
 

@@ -66,7 +66,7 @@ foo = true;  // foo is a Boolean now
 
 
数字类型中只有一个整数有两种表示方法： 0 可表示为 -0 和 +0（"0" 是 +0 的简写）。 在实践中，这也几乎没有影响。 例如 +0 === -0 为真。 但是，你可能要注意除以0的时候：

 
-
42 / +0; // Infinity
+
42 / +0; // Infinity
 42 / -0; // -Infinity
 

 
@@ -78,7 +78,7 @@ foo = true;  // foo is a Boolean now
 
 
通过使用常量{{jsxref("Number.MAX_SAFE_INTEGER")}}，您可以获得可以用数字递增的最安全的值。通过引入 BigInt，您可以操作超过{{jsxref("Number.MAX_SAFE_INTEGER")}}的数字。您可以在下面的示例中观察到这一点，其中递增{{jsxref("Number.MAX_SAFE_INTEGER")}}会返回预期的结果:

 
-
> const x = 2n ** 53n;
+
> const x = 2n ** 53n;
 9007199254740992n
 > const y = x + 1n;
 9007199254740993n
diff --git a/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html b/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html
index 47f75f244a..e7401b7cc1 100644
--- a/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html
+++ b/files/zh-cn/web/javascript/enumerability_and_ownership_of_properties/index.html
@@ -145,7 +145,7 @@ translation_of: Web/JavaScript/Enumerability_and_ownership_of_properties
  
  • 使用 SimplePropertyRetriever.theGetMethodYouWant(obj).forEach(function (value, prop) {}); 时将发生迭代操作。 (或使用 filter()、map() 等方法)
    • 
 
 
-
    var SimplePropertyRetriever = {
+
    var SimplePropertyRetriever = {
     getOwnEnumerables: function(obj) {
         return this._getPropertyNames(obj, true, false, this._enumerable);
          // Or could use for..in filtered with hasOwnProperty or just this: return Object.keys(obj);
diff --git a/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html b/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html
index 509f759b1d..5d8e0d7528 100644
--- a/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html
+++ b/files/zh-cn/web/javascript/equality_comparisons_and_sameness/index.html
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Equality_comparisons_and_sameness
 
 
    全等操作符比较两个值是否相等，两个被比较的值在比较前都不进行隐式转换。如果两个被比较的值具有不同的类型，这两个值是不全等的。否则，如果两个被比较的值类型相同，值也相同，并且都不是 number 类型时，两个值全等。最后，如果两个值都是 number 类型，当两个都不是 NaN，并且数值相同，或是两个值分别为 +0 和 -0 时，两个值被认为是全等的。
    
 
-
    var num = 0;
+
    var num = 0;
 var obj = new String("0");
 var str = "0";
 var b = false;
@@ -145,7 +145,7 @@ console.log(obj === undefined); // false
 
 
    一般而言，根据 ECMAScript 规范，所有的对象都与 undefined 和 null 不相等。但是大部分浏览器允许非常窄的一类对象（即，所有页面中的 document.all 对象），在某些情况下，充当效仿 undefined 的角色。相等操作符就是在这样的一个背景下。因此，IsFalsy(A) 方法的值为 true ，当且仅当 A 效仿 undefined。在其他所有情况下，一个对象都不会等于 undefined 或 null。
    
 
-
    var num = 0;
+
    var num = 0;
 var obj = new String("0");
 var str = "0";
 var b = false;
@@ -170,7 +170,7 @@ console.log(obj == undefined);
 
 
    同值相等解决了最后一个用例：确定两个值是否在任何情况下功能上是相同的。（这个用例演示了里氏替换原则的实例。）当试图对不可变（immutable）属性修改时发生出现的情况：
    
 
-
    // 向 Nmuber 构造函数添加一个不可变的属性 NEGATIVE_ZERO
+
    // 向 Nmuber 构造函数添加一个不可变的属性 NEGATIVE_ZERO
 Object.defineProperty(Number, "NEGATIVE_ZERO",
                       { value: -0, writable: false, configurable: false, enumerable: false });
 
@@ -388,7 +388,7 @@ function attemptMutation(v)
  
    
  
    显而易见，对0一元负操作得到-0。但表达式的抽象化可能在你没有意识到得情况下导致-0延续传播。例如当考虑下例时:
    
 
- 
    let stoppingForce = obj.mass * -obj.velocity
    
+ 
    let stoppingForce = obj.mass * -obj.velocity
    
 
  
    
 
diff --git a/files/zh-cn/web/javascript/eventloop/index.html b/files/zh-cn/web/javascript/eventloop/index.html
index 42b31a8fde..f9fdf69207 100644
--- a/files/zh-cn/web/javascript/eventloop/index.html
+++ b/files/zh-cn/web/javascript/eventloop/index.html
@@ -27,7 +27,7 @@ translation_of: Web/JavaScript/EventLoop
 
 
    函数调用形成了一个由若干帧组成的栈。
    
 
-
    function foo(b) {
+
    function foo(b) {
   let a = 10;
   return a + b + 11;
 }
@@ -57,7 +57,7 @@ console.log(bar(7)); // 返回 42
    
 
 
    之所以称之为 事件循环，是因为它经常按照类似如下的方式来被实现：
    
 
-
    while (queue.waitForMessage()) {
+
    while (queue.waitForMessage()) {
   queue.processNextMessage();
 }
    
 
@@ -77,7 +77,7 @@ console.log(bar(7)); // 返回 42
    
 
 
    下面的例子演示了这个概念（setTimeout 并不会在计时器到期之后直接执行）：
    
 
-
    const s = new Date().getSeconds();
+
    const s = new Date().getSeconds();
 
 setTimeout(function() {
   // 输出 "2"，表示回调函数并没有在 500 毫秒之后立即执行
@@ -99,7 +99,7 @@ while(true) {
 
 
    基本上，setTimeout 需要等待当前队列中所有的消息都处理完毕之后才能执行，即使已经超出了由第二参数所指定的时间。
    
 
-
    (function() {
+
    (function() {
 
   console.log('这是开始');
 
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 5beb697684..36f626ed0e 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
@@ -121,7 +121,7 @@ translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
  
   
    
-    
    +    
     function Employee () {
   this.name = "";
   this.dept = "general";
@@ -129,7 +129,7 @@ function Employee () {
 
    
    
    
-    
    +    
     public class Employee {
    public String name = "";
    public String dept = "general";
@@ -151,7 +151,7 @@ public class Employee {
  
   
    
-    
    +    
     function Manager() {
   Employee.call(this);
   this.reports = [];
@@ -165,7 +165,7 @@ function WorkerBee() {
 WorkerBee.prototype = Object.create(Employee.prototype);
    
    
    
-    
    +    
     public class Manager extends Employee {
    public Employee[] reports = new Employee[0];
 }
@@ -192,7 +192,7 @@ public class WorkerBee extends Employee {
  
   
    
-    
    +    
     function SalesPerson() {
    WorkerBee.call(this);
    this.dept = 'sales';
@@ -208,7 +208,7 @@ function Engineer() {
 Engineer.prototype = Object.create(WorkerBee.prototype);
    
    
    
-    
    +    
     public class SalesPerson extends WorkerBee {
    public String dept = "sales";
    public double quota = 100.0;
@@ -240,7 +240,7 @@ public class Engineer extends WorkerBee {
 
 
    个别对象
    
 
-
    var jim = new Employee; // 如构造函数无须接受任何参数，圆括号可以省略。
+
    var jim = new Employee; // 如构造函数无须接受任何参数，圆括号可以省略。
 // jim.name is ''
 // jim.dept is 'general'
 
@@ -274,14 +274,14 @@ var jane = new Engineer;
 
 
    假设您通过如下语句创建一个mark对象作为 WorkerBee的实例：
    
 
-
    var mark = new WorkerBee;
+
    var mark = new WorkerBee;
 
    
 
 
    当 JavaScript 执行 new 操作符时，它会先创建一个普通对象，并将这个普通对象中的 [[prototype]] 指向 WorkerBee.prototype ，然后再把这个普通对象设置为执行 WorkerBee 构造函数时 this  的值。该普通对象的 [[Prototype]] 决定其用于检索属性的原型链。当构造函数执行完成后，所有的属性都被设置完毕，JavaScript 返回之前创建的对象，通过赋值语句将它的引用赋值给变量 mark。
    
 
 
    这个过程不会显式的将 mark所继承的原型链中的属性作为本地属性存放在 mark 对象中。当访问属性时，JavaScript 将首先检查对象自身中是否存在该属性，如果有，则返回该属性的值。如果不存在，JavaScript会检查原型链（使用内置的 [[Prototype]] ）。如果原型链中的某个对象包含该属性，则返回这个属性的值。如果遍历整条原型链都没有找到该属性，JavaScript 则认为对象中不存在该属性，返回一个 undefined。这样，mark 对象中将具有如下的属性和对应的值：
    
 
-
    mark.name = "";
+
    mark.name = "";
 mark.dept = "general";
 mark.projects = [];
 
    
@@ -290,7 +290,7 @@ mark.projects = [];
 
 
    由于这些构造器不支持为实例设置特定的值，所以这些属性值仅仅是创建自 WorkerBee 的所有对象所共享的默认值。当然这些属性的值是可以修改的，所以您可以为 mark指定特定的信息，如下所示：
    
 
-
    mark.name = "Doe, Mark";
+
    mark.name = "Doe, Mark";
 mark.dept = "admin";
 mark.projects = ["navigator"];
    
 
@@ -298,14 +298,14 @@ mark.projects = ["navigator"];
    
 
 
    在 JavaScript 中，您可以在运行时为任何对象添加属性，而不必受限于构造函数提供的属性。添加特定于某个对象的属性，只需要为该对象指定一个属性值，如下所示：
    
 
-
    mark.bonus = 3000;
+
    mark.bonus = 3000;
 
    
 
 
    这样 mark 对象就有了 bonus 属性，而其它 WorkerBee 则没有该属性。
    
 
 
    如果您向某个构造函数的原型对象中添加新的属性，那么该属性将添加到从这个原型中继承属性的所有对象的中。例如，可以通过如下的语句向所有雇员中添加 specialty 属性：
    
 
-
    Employee.prototype.specialty = "none";
+
    Employee.prototype.specialty = "none";
 
    
 
 
    只要 JavaScript 执行了该语句，则 mark 对象也将具有 specialty 属性，其值为 "none"。下图则表示了在 Employee 原型中添加该属性，然后在 Engineer 的原型中重载该属性的效果。
    
@@ -332,7 +332,7 @@ mark.projects = ["navigator"];
    
  
   
    
-    
    +    
     function Employee (name, dept) {
   this.name = name || "";
   this.dept = dept || "general";
@@ -340,7 +340,7 @@ function Employee (name, dept) {
 
    
    
    
-    
    +    
     public class Employee {
    public String name;
    public String dept;
@@ -360,7 +360,7 @@ public class Employee {
   
   
    
-    
    +    
     function WorkerBee (projs) {
   this.projects = projs || [];
 }
@@ -368,7 +368,7 @@ WorkerBee.prototype = new Employee;
 
    
    
    
-    
    +    
     public class WorkerBee extends Employee {
    public String[] projects;
    public WorkerBee () {
@@ -384,7 +384,7 @@ public class WorkerBee extends Employee {
   
   
    
-    
    +    
     
 function Engineer (mach) {
    this.dept = "engineering";
@@ -394,7 +394,7 @@ Engineer.prototype = new WorkerBee;
 
    
    
    
-    
    +    
     public class Engineer extends WorkerBee {
    public String machine;
    public Engineer () {
@@ -414,7 +414,7 @@ public class Engineer extends WorkerBee {
 
 
    上面使用 JavaScript 定义过程使用了一种设置默认值的特殊惯用法：
    
 
-
    this.name = name || "";
+
    this.name = name || "";
 
    
 
 
    JavaScript 的逻辑或操作符（||）会对第一个参数进行判断。如果该参数值运算后结果为真，则操作符返回该值。否则，操作符返回第二个参数的值。因此，这行代码首先检查 name 是否是对name 属性有效的值。如果是，则设置其为 this.name 的值。否则，设置 this.name 的值为空的字符串。尽管这种用法乍看起来有些费解，为了简洁起见，本章将使用这种习惯用法。
    
@@ -425,12 +425,12 @@ public class Engineer extends WorkerBee {
 
 
    使用这些定义，当创建对象的实例时，可以为本地定义的属性指定值。你可以使用以下语句创建一个新的Engineer：
    
 
-
    var jane = new Engineer("belau");
+
    var jane = new Engineer("belau");
 
    
 
 
    此时，Jane 的属性如下所示：
    
 
-
    jane.name == "";
+
    jane.name == "";
 jane.dept == "engineering";
 jane.projects == [];
 jane.machine == "belau"
@@ -445,7 +445,7 @@ jane.machine == "belau"
 
 
    我们来详细看一下这些定义。这是Engineer构造函数的新定义：
    
 
-
    function Engineer (name, projs, mach) {
+
    function Engineer (name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, "engineering", projs);
   this.machine = mach || "";
@@ -454,7 +454,7 @@ jane.machine == "belau"
 
 
    假设您创建了一个新的 Engineer 对象，如下所示：
    
 
-
    var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+
    var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
 
    
 
 
    JavaScript 会按以下步骤执行：
    
@@ -475,7 +475,7 @@ jane.machine == "belau"
 
 
    你可以认为，在 Engineer 的构造器中调用了 WorkerBee 的构造器，也就为 Engineer 对象设置好了继承关系。事实并非如此。调用 WorkerBee 构造器确保了Engineer 对象以所有在构造器中所指定的属性被调用。但是，如果后续在 Employee 或者 WorkerBee 原型中添加了属性，那些属性不会被 Engineer 对象继承。例如，假设如下语句：
    
 
-
    function Engineer (name, projs, mach) {
+
    function Engineer (name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, "engineering", projs);
   this.machine = mach || "";
@@ -486,7 +486,7 @@ Employee.prototype.specialty = "none";
 
 
    对象 jane 不会继承 specialty 属性。您必须显式地设置原型才能确保动态的继承。如果修改成如下的语句：
    
 
-
    function Engineer (name, projs, mach) {
+
    function Engineer (name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, "engineering", projs);
   this.machine = mach || "";
@@ -504,7 +504,7 @@ Employee.prototype.specialty = "none";
  
   
    
-    
    +    
     function Engineer (name, projs, mach) {
   this.base = WorkerBee;
   this.base(name, "engineering", projs);
@@ -513,7 +513,7 @@ function Engineer (name, projs, mach) {
 
    
    
    
-    
    +    
     function Engineer (name, projs, mach) {
   WorkerBee.call(this, name, "engineering", projs);
   this.machine = mach || "";
@@ -543,7 +543,7 @@ function Engineer (name, projs, mach) {
 
 
    以上步骤的结果依赖于你是如何定义的。最早的例子中有如下定义：
    
 
-
    function Employee () {
+
    function Employee () {
   this.name = "";
   this.dept = "general";
 }
@@ -556,19 +556,19 @@ WorkerBee.prototype = new Employee;
 
 
    基于这些定义，假定通过如下的语句创建 WorkerBee 的实例 amy：
    
 
-
    var amy = new WorkerBee;
+
    var amy = new WorkerBee;
 
    
 
 
    则 amy 对象将具有一个本地属性 projects。name和 dept 则不是 amy 对象的本地属性，而是从 amy 对象的 __proto__ 属性获得的。因此，amy 将具有如下的属性值：
    
 
-
    amy.name == "";
+
    amy.name == "";
 amy.dept == "general";
 amy.projects == [];
 
    
 
 
    现在，假设修改了与 Employee 的相关联原型中的 name 属性的值：
    
 
-
    Employee.prototype.name = "Unknown"
+
    Employee.prototype.name = "Unknown"
 
    
 
 
    乍一看，你可能觉得新的值会传播给所有 Employee 的实例。然而，并非如此。
    
@@ -577,7 +577,7 @@ amy.projects == [];
 
 
    如果想在运行时修改一个对象的属性值并且希望该值被所有该对象的后代所继承，您就不能在该对象的构造器函数中定义该属性。而应该将该属性添加到该对象所关联的原型中。例如，假设将前面的代码作如下修改：
    
 
-
    function Employee () {
+
    function Employee () {
   this.dept = "general";
 }
 Employee.prototype.name = "";
@@ -604,17 +604,17 @@ Employee.prototype.name = "Unknown";
 
 
    每个对象都有一个 __proto__ 对象属性（除了 Object）；每个函数都有一个 prototype 对象属性。因此，通过“原型继承”，对象与其它对象之间形成关系。通过比较对象的 __proto__ 属性和函数的 prototype 属性可以检测对象的继承关系。JavaScript 提供了便捷方法：instanceof 操作符可以用来将一个对象和一个函数做检测，如果对象继承自函数的原型，则该操作符返回真。例如：
    
 
-
    var f = new Foo();
+
    var f = new Foo();
 var isTrue = (f instanceof Foo);
    
 
 
    作为详细一点的例子，假定我们使用和在 Inheriting properties 中相同的一组定义。创建 Engineer 对象如下：
    
 
-
    var chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");
+
    var chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");
 
    
 
 
    对于该对象，以下所有语句均为真：
    
 
-
    chris.__proto__ == Engineer.prototype;
+
    chris.__proto__ == Engineer.prototype;
 chris.__proto__.__proto__ == WorkerBee.prototype;
 chris.__proto__.__proto__.__proto__ == Employee.prototype;
 chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
@@ -623,7 +623,7 @@ chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
 
 
    基于此，可以写出一个如下所示的 instanceOf 函数：
    
 
-
    function instanceOf(object, constructor) {
+
    function instanceOf(object, constructor) {
    while (object != null) {
       if (object == constructor.prototype)
          return true;
@@ -642,7 +642,7 @@ chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
 
 
    
 
-
    instanceOf (chris, Engineer)
+
    instanceOf (chris, Engineer)
 instanceOf (chris, WorkerBee)
 instanceOf (chris, Employee)
 instanceOf (chris, Object)
@@ -650,13 +650,13 @@ instanceOf (chris, Object)
 
 
    但如下表达式为假：
    
 
-
    instanceOf (chris, SalesPerson)
    
+
    instanceOf (chris, SalesPerson)
    
 
 
    构造器中的全局信息
    
 
 
    在创建构造器时，在构造器中设置全局信息要小心。例如，假设希望为每一个雇员分配一个唯一标识。可能会为 Employee 使用如下定义：
    
 
-
    var idCounter = 1;
+
    var idCounter = 1;
 
 function Employee (name, dept) {
    this.name = name || "";
@@ -667,13 +667,13 @@ function Employee (name, dept) {
 
 
    基于该定义，在创建新的 Employee 时，构造器为其分配了序列中的下一个标识符。然后递增全局的标识符计数器。因此，如果，如果随后的语句如下，则 victoria.id 为 1 而 harry.id 为 2：
    
 
-
    var victoria = new Employee("Pigbert, Victoria", "pubs")
+
    var victoria = new Employee("Pigbert, Victoria", "pubs")
 var harry = new Employee("Tschopik, Harry", "sales")
 
    
 
 
    乍一看似乎没问题。但是，无论什么目的，在每一次创建 Employee 对象时，idCounter 都将被递增一次。如果创建本章中所描述的整个 Employee 层级结构，每次设置原型的时候，Employee 构造器都将被调用一次。假设有如下代码：
    
 
-
    var idCounter = 1;
+
    var idCounter = 1;
 
 function Employee (name, dept) {
    this.name = name || "";
@@ -700,7 +700,7 @@ var mac = new Engineer("Wood, Mac");
 
 
    依赖于应用程序，计数器额外的递增可能有问题，也可能没问题。如果确实需要准确的计数器，则以下构造器可以作为一个可行的方案：
    
 
-
    function Employee (name, dept) {
+
    function Employee (name, dept) {
    this.name = name || "";
    this.dept = dept || "general";
    if (name)
@@ -712,7 +712,7 @@ var mac = new Engineer("Wood, Mac");
 
 
    或者，您可以创建一个 Employee 的原型对象的副本以分配给 WorkerBee：
    
 
-
    WorkerBee.prototype = Object.create(Employee.prototype);
+
    WorkerBee.prototype = Object.create(Employee.prototype);
 // instead of WorkerBee.prototype = new Employee
    
 
 
    没有多重继承
    
@@ -723,7 +723,7 @@ var mac = new Engineer("Wood, Mac");
 
 
    在 JavaScript 中，可以在构造器函数中调用多个其它的构造器函数。这一点造成了多重继承的假象。例如，考虑如下语句：
    
 
-
    function Hobbyist (hobby) {
+
    function Hobbyist (hobby) {
    this.hobby = hobby || "scuba";
 }
 
@@ -741,7 +741,7 @@ var dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo")
 
 
    进一步假设使用本章前面所属的 WorkerBee 的定义。此时 dennis 对象具有如下属性：
    
 
-
    dennis.name == "Doe, Dennis"
+
    dennis.name == "Doe, Dennis"
 dennis.dept == "engineering"
 dennis.projects == ["collabra"]
 dennis.machine == "hugo"
@@ -750,7 +750,7 @@ dennis.hobby == "scuba"
 
 
    dennis 确实从 Hobbyist 构造器中获得了 hobby 属性。但是，假设添加了一个属性到 Hobbyist 构造器的原型：
    
 
-
    Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]
+
    Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]
 
    
 
 
    dennis 对象不会继承这个新属性。
    
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 1ea851d0f7..b90c70b5e0 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
@@ -33,18 +33,18 @@ translation_of: Web/JavaScript/Guide/Expressions_and_Operators
 
 
    JavaScript 拥有二元和一元运算符， 和一个特殊的三元运算符（条件运算符）。一个二元运算符需要两个操作数，分别在运算符的前面和后面：
    
 
-
    操作数1 运算符 操作数2
+
    操作数1 运算符 操作数2
 
    
 
 
    例如, 3+4 或 x*y。
    
 
 
    一个一元运算符需要一个操作数，在运算符前面或后面：
    
 
-
    运算符 操作数
    
+
    运算符 操作数
    
 
 
    或
    
 
-
    操作数 运算符
    
+
    操作数 运算符
    
 
 
    例如, x++ 或 ++x。
    
 
@@ -136,7 +136,7 @@ translation_of: Web/JavaScript/Guide/Expressions_and_Operators
 
 
    对于更复杂的赋值，解构赋值语法是一个能从数组或对象对应的数组结构或对象字面量里提取数据的 Javascript 表达式。
    
 
-
    var foo = ["one", "two", "three"];
+
    var foo = ["one", "two", "three"];
 
 // 不使用解构
 var one   = foo[0];
@@ -150,7 +150,7 @@ var [one, two, three] = foo;
    
 
 
    比较运算符比较它的操作数并返回一个基于表达式是否为真的逻辑值。操作数可以是数字，字符串，逻辑，对象值。字符串比较是基于标准的字典顺序，使用Unicode值。在多数情况下，如果两个操作数不是相同的类型， JavaScript 会尝试转换它们为恰当的类型来比较。这种行为通常发生在数字作为操作数的比较。类型转换的例外是使用 === 和 !== 操作符，它们会执行严格的相等和不相等比较。这些运算符不会在检查相等之前转换操作数的类型。下面的表格描述了该示例代码中的各比较运算符
    
 
-
    var var1 = 3;
+
    var var1 = 3;
 var var2 = 4;
    
 
 
@@ -224,7 +224,7 @@ var var2 = 4;
    算术运算符使用数值(字面量或者变量)作为操作数并返回一个数值.标准的算术运算符就是加减乘除(+ - * /)。当操作数是浮点数时，这些运算符表现得跟它们在大多数编程语言中一样（特殊要注意的是，除零会产生{{jsxref("Infinity")}}）。例如：
    
 
-
    1 / 2;  // 0.5
+
    1 / 2;  // 0.5
 1 / 2 == 1.0 / 2.0; // true
 
    
 
@@ -378,7 +378,7 @@ var var2 = 4;
    
  
    
- 
    Before: 11100110111110100000000000000110000000000001
+ 
    Before: 11100110111110100000000000000110000000000001
 After:              10100000000000000110000000000001
    
  
    
 
    
@@ -507,7 +507,7 @@ After:              10100000000000000110000000000001
    下面是&&（逻辑"与"）操作符的示例。
    
 
-
    var a1 =  true && true;     // t && t returns true
+
    var a1 =  true && true;     // t && t returns true
 var a2 =  true && false;    // t && f returns false
 var a3 = false && true;     // f && t returns false
 var a4 = false && (3 == 4); // f && f returns false
@@ -518,7 +518,7 @@ var a7 = "Cat" && false;    // t && f returns false
 
 
    下面是||（逻辑"或"）操作符的示例。
    
 
-
    var o1 =  true || true;     // t || t returns true
+
    var o1 =  true || true;     // t || t returns true
 var o2 = false || true;     // f || t returns true
 var o3 =  true || false;    // t || f returns true
 var o4 = false || (3 == 4); // f || f returns false
@@ -529,7 +529,7 @@ var o7 = "Cat" || false;    // t || f returns Cat
 
 
    下面是！（逻辑"非"）操作符的示例。
    
 
-
    var n1 = !true;  // !t returns false
+
    var n1 = !true;  // !t returns false
 var n2 = !false; // !f returns true
 var n3 = !"Cat"; // !t returns false
 
    
@@ -551,11 +551,11 @@ var n3 = !"Cat"; // !t returns false
 
 
    例如，
    
 
-
    console.log("my " + "string"); // console logs the string "my string".
    
+
    console.log("my " + "string"); // console logs the string "my string".
    
 
 
    简写操作符 += 也可以用来拼接字符串，例如：
    
 
-
    var myString = "alpha";
+
    var myString = "alpha";
 
 myString += "bet"; // 返回 "alphabet"  
 
    
@@ -564,14 +564,14 @@ var n3 = !"Cat"; // !t returns false
 
 
    条件运算符是JavaScript中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：
    
 
-
    条件 ? 值1 : 值2
+
    条件 ? 值1 : 值2
 
    
 
 
    如果条件为真，则结果取值1。否则为值2。你能够在任何允许使用标准运算符的地方使用条件运算符。
    
 
 
    例如，
    
 
-
    var status = (age >= 18) ? "adult" : "minor";
+
    var status = (age >= 18) ? "adult" : "minor";
 
    
 
 
    当 age 大于等于18的时候，将“adult”赋值给 status；否则将“minor”赋值给 status。
    
@@ -582,7 +582,7 @@ var n3 = !"Cat"; // !t returns false
 
 
    例如，假如 a 是一个二维数组，每个维度各有10个元素，以下代码利用逗号操作符来同时改变两个变量的值。这段代码的功能是打印出该二维数组的对角线元素的值：
    
 
-
    var x = [0,1,2,3,4,5,6,7,8,9]
+
    var x = [0,1,2,3,4,5,6,7,8,9]
 var a = [x, x, x, x, x];
 
 for (var i = 0, j = 9; i <= j; i++, j--)
@@ -596,7 +596,7 @@ for (var i = 0, j = 9; i <= j; i++, j--)
 
 
    delete操作符，删除一个对象的属性或者一个数组中某一个键值。语法如下:
    
 
-
    delete objectName.property;
+
    delete objectName.property;
 delete objectName[index];
 delete property; // legal only within a with statement
 
    
@@ -609,7 +609,7 @@ delete property; // legal only within a with statement
 
 
    如果 delete 操作成功，属性或者元素会变成 undefined。如果 delete可行会返回true，如果不成功返回false。
    
 
-
    x = 42;
+
    x = 42;
 var y = 43;
 myobj = new Number();
 myobj.h = 4;    // create property h
@@ -626,7 +626,7 @@ delete myobj;   // returns true (can delete if declared implicitly)
 
 
    delete 删除数组中的一个元素，这个元素就不在数组中了。例如，trees[3]被删除，trees[3] 仍然可寻址并返回undefined。
    
 
-
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 delete trees[3];
 if (3 in trees) {
   // 不会被执行
@@ -635,7 +635,7 @@ if (3 in trees) {
 
 
    如果想让数组中存在一个元素但是是undefined值，使用undefined关键字而不是delete操作. 如下： trees[3]分配一个undefined,但是这个数组元素仍然存在:
    
 
-
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 trees[3] = undefined;
 if (3 in trees) {
   // this gets executed（会被执行）
@@ -646,7 +646,7 @@ if (3 in trees) {
 
 
    typeof操作符 可通过下面2种方式使用：
    
 
-
    typeof operand
+
    typeof operand
 typeof (operand)
 
    
 
@@ -654,7 +654,7 @@ typeof (operand)
 
 
    假设你定义了如下的变量：
    
 
-
    var myFun = new Function("5 + 2");
+
    var myFun = new Function("5 + 2");
 var shape = "round";
 var size = 1;
 var today = new Date();
@@ -662,7 +662,7 @@ var today = new Date();
 
 
    typeof 操作符将会返回如下的结果：
    
 
-
    typeof myFun;     // returns "function"
+
    typeof myFun;     // returns "function"
 typeof shape;     // returns "string"
 typeof size;      // returns "number"
 typeof today;     // returns "object"
@@ -671,26 +671,26 @@ typeof dontExist; // returns "undefined"
 
 
    对于关键词 true 和 null， typeof 操作符将会返回如下结果：
    
 
-
    typeof true; // returns "boolean"
+
    typeof true; // returns "boolean"
 typeof null; // returns "object"
 
    
 
 
    对于一个数值或字符串， typeof 操作符将会返回如下结果：
    
 
-
    typeof 62;            // returns "number"
+
    typeof 62;            // returns "number"
 typeof 'Hello world'; // returns "string"
 
    
 
 
    对于属性值，typeof 操作符将会返回属性所包含值的类型：
    
 
-
    typeof document.lastModified; // returns "string"
+
    typeof document.lastModified; // returns "string"
 typeof window.length;         // returns "number"
 typeof Math.LN2;              // returns "number"
 
    
 
 
    对于方法和函数，typeof 操作符将会返回如下结果：
    
 
-
    typeof blur;        // returns "function"
+
    typeof blur;        // returns "function"
 typeof eval;        // returns "function"
 typeof parseInt;    // returns "function"
 typeof shape.split; // returns "function"
@@ -698,7 +698,7 @@ typeof shape.split; // returns "function"
 
 
    对于预定义的对象，typeof 操作符将会返回如下结果：
    
 
-
    typeof Date;     // returns "function"
+
    typeof Date;     // returns "function"
 typeof Function; // returns "function"
 typeof Math;     // returns "object"
 typeof Option;   // returns "function"
@@ -709,7 +709,7 @@ typeof String;   // returns "function"
 
 
    void 运算符运用方法如下：
    
 
-
    void (expression)
+
    void (expression)
 void expression
 
    
 
@@ -719,11 +719,11 @@ void expression
 
 
    如下创建了一个超链接文本，当用户单击该文本时，不会有任何效果。
    
 
-
    <a href="javascript:void(0)">Click here to do nothing</a>
    
+
    <a href="javascript:void(0)">Click here to do nothing</a>
    
 
 
    下面的代码创建了一个超链接，当用户单击它时，提交一个表单。
    
 
-
    <a href="javascript:void(document.form.submit())">
+
    <a href="javascript:void(document.form.submit())">
 Click here to submit</a>
    
 
 
    关系操作符
    
@@ -734,14 +734,14 @@ Click here to submit</a>
    
 
 
    in操作符，如果所指定的属性确实存在于所指定的对象中，则会返回true，语法如下：
    
 
-
    propNameOrNumber in objectName
+
    propNameOrNumber in objectName
 
    
 
 
    在这里 propNameOrNumber可以是一个代表着属性名的字符串或者是一个代表着数组索引的数值表达式，而objectName则是一个对象名。
    
 
 
    下面的例子是 in 操作的常见用法。
    
 
-
    // Arrays
+
    // Arrays
 var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 0 in trees;        // returns true
 3 in trees;        // returns true
@@ -765,7 +765,7 @@ var mycar = {make: "Honda", model: "Accord", year: 1998};
 
 
    如果所判别的对象确实是所指定的类型，则返回true。其语法如下：
    
 
-
    objectName instanceof objectType
+
    objectName instanceof objectType
 
    
 
 
    objectName 是需要做判别的对象的名称,而objectType是假定的对象的类型, 例如{{jsxref("Date")}}或 {{jsxref("Array")}}.
    
@@ -774,7 +774,7 @@ var mycar = {make: "Honda", model: "Accord", year: 1998};
 
 
    例如, 下面的代码使用instanceof去判断 theDay是否是一个 Date 对象. 因为theDay是一个Date对象, 所以if中的代码会执行.
    
 
-
    var theDay = new Date(1995, 12, 17);
+
    var theDay = new Date(1995, 12, 17);
 if (theDay instanceof Date) {
   // statements to execute
 }
@@ -891,13 +891,13 @@ if (theDay instanceof Date) {
 
 
    this关键字被用于指代当前的对象，通常，this指代的是方法中正在被调用的对象。用法如下：
    
 
-
    this["propertyName"]
+
    this["propertyName"]
 this.propertyName
 
    
 
 
    假设一个用于验证对象value属性的validate函数，传参有对象，最高值和最低值。
    
 
-
    function validate(obj, lowval, hival){
+
    function validate(obj, lowval, hival){
   if ((obj.value < lowval) || (obj.value > hival))
     console.log("Invalid Value!");
 }
@@ -905,7 +905,7 @@ this.propertyName
 
 
    你可以在任何表单元素的onchange事件处理中调用validat函数，用this来指代当前的表单元素，用例如下：
    
 
-
    <p>Enter a number between 18 and 99:</p>
+
    <p>Enter a number between 18 and 99:</p>
 <input type="text" name="age" size=3 onChange="validate(this, 18, 99);">
 
    
 
@@ -913,7 +913,7 @@ this.propertyName
 
 
    分组操作符（）控制了表达式中计算的优先级. 举例来说, 你可以改变先乘除后加减的顺序，转而先计算加法。
    
 
-
    var a = 1;
+
    var a = 1;
 var b = 2;
 var c = 3;
 
@@ -941,7 +941,7 @@ a * c + b * c // 9
    
 
 
    Comprehensions特性被许多编程语言所采用，该特性能够使你快速地通过一个已有的数组来创建出一个新的数组，比如：
    
 
-
    [for (i of [ 1, 2, 3 ]) i*i ];
+
    [for (i of [ 1, 2, 3 ]) i*i ];
 // [ 1, 4, 9 ]
 
 var abc = [ "A", "B", "C" ];
@@ -956,14 +956,14 @@ var abc = [ "A", "B", "C" ];
 
 
    你可以使用new operator 创建一个自定义类型或者是预置类型的对象实例。用法如下：
    
 
-
    var objectName = new objectType([param1, param2, ..., paramN]);
+
    var objectName = new objectType([param1, param2, ..., paramN]);
 
    
 
 
    super
    
 
 
    super 关键字可以用来调用一个对象父类的函数，它在用来调用一个类的父类的构造函数时非常有用，比如：
    
 
-
    super([arguments]); // calls the parent constructor. super.functionOnParent([arguments]);
    
+
    super([arguments]); // calls the parent constructor. super.functionOnParent([arguments]);
    
 
 
    扩展语句
    
 
@@ -971,12 +971,12 @@ var abc = [ "A", "B", "C" ];
 
 
    例如：现在你有一个数组，你想创建一个新数组，并将刚才那个作为它的一部分，用array的字面语法是不够的，你不得不写一些代码实现它，比如用些push, splice, concat等等。但是用spread syntax就没问题了：
    
 
-
    var parts = ['shoulder', 'knees'];
+
    var parts = ['shoulder', 'knees'];
 var lyrics = ['head', ...parts, 'and', 'toes'];
    
 
 
    类似的，扩展语句也可以用在函数调用的时候:
    
 
-
    function f(x, y, z) { }
+
    function f(x, y, z) { }
 var args = [0, 1, 2];
 f(...args);
    
 
diff --git a/files/zh-cn/web/javascript/guide/functions/index.html b/files/zh-cn/web/javascript/guide/functions/index.html
index 3d43d61305..54e0bffa4b 100644
--- a/files/zh-cn/web/javascript/guide/functions/index.html
+++ b/files/zh-cn/web/javascript/guide/functions/index.html
@@ -30,21 +30,21 @@ translation_of: Web/JavaScript/Guide/Functions
 
 
    例如，以下的代码定义了一个简单的square函数：
    
 
-
    function square(number) {
+
    function square(number) {
   return number * number;
 }
 
    
 
 
    函数square使用了一个参数，叫作number。这个函数只有一个语句，它说明该函数将函数的参数（即number）自乘后返回。函数的return语句确定了函数的返回值：
    
 
-
    return number * number;
+
    return number * number;
 
    
 
 
    原始参数（比如一个具体的数字）被作为值传递给函数；值被传递给函数，如果被调用函数改变了这个参数的值，这样的改变不会影响到全局或调用函数。
    
 
 
    如果你传递一个对象（即一个非原始值，例如{{jsxref("Array")}}或用户自定义的对象）作为参数，而函数改变了这个对象的属性，这样的改变对函数外部是可见的，如下面的例子所示：
    
 
-
    function myFunc(theObject) {
+
    function myFunc(theObject) {
   theObject.make = "Toyota";
 }
 
@@ -62,19 +62,19 @@ y = mycar.make;     // y获取的值为 "Toyota"
 
 
    虽然上面的函数声明在语法上是一个语句，但函数也可以由函数表达式创建。这样的函数可以是匿名的；它不必有一个名称。例如，函数square也可这样来定义：
    
 
-
    const square = function(number) { return number * number; };
+
    const square = function(number) { return number * number; };
 var x = square(4); // x gets the value 16
    
 
 
    然而，函数表达式也可以提供函数名，并且可以用于在函数内部代指其本身，或者在调试器堆栈跟踪中识别该函数：
    
 
-
    const factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};
+
    const factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};
 
 console.log(factorial(3));
 
    
 
 
    当将函数作为参数传递给另一个函数时，函数表达式很方便。下面的例子演示了一个叫map的函数如何被定义，而后使用一个表达式函数作为其第一个参数进行调用：
    
 
-
    function map(f,a) {
+
    function map(f,a) {
   let result = []; // 创建一个数组
   let i; // 声明一个值，用来循环
   for (i = 0; i != a.length; i++)
@@ -85,7 +85,7 @@ console.log(factorial(3));
 
 
    下面的代码：
    
 
-
    function map(f, a) {
+
    function map(f, a) {
   let result = []; // 创建一个数组
   let i; // 声明一个值，用来循环
   for (i = 0; i != a.length; i++)
@@ -103,7 +103,7 @@ console.log(cube);
    
 
 
    在 JavaScript 中，可以根据条件来定义一个函数。比如下面的代码，当num 等于 0 的时候才会定义 myFunc ：
    
 
-
    var myFunc;
+
    var myFunc;
 if (num == 0){
   myFunc = function(theObject) {
     theObject.make = "Toyota"
@@ -118,14 +118,14 @@ if (num == 0){
 
 
    定义一个函数并不会自动的执行它。定义了函数仅仅是赋予函数以名称并明确函数被调用时该做些什么。调用函数才会以给定的参数真正执行这些动作。例如，一旦你定义了函数square，你可以如下这样调用它：
    
 
-
    square(5);
+
    square(5);
 
    
 
 
    上述语句通过提供参数 5 来调用函数。函数执行完它的语句会返回值25。
    
 
 
    函数一定要处于调用它们的域中，但是函数的声明可以被提升(出现在调用语句之后)，如下例：
    
 
-
    console.log(square(5));
+
    console.log(square(5));
 /* ... */
 function square(n) { return n*n }
 
    
@@ -136,7 +136,7 @@ function square(n) { return n*n }
 
    提示：注意只有使用如上的语法形式（即 function funcName(){}）才可以。而下面的代码是无效的。就是说，函数提升仅适用于函数声明，而不适用于函数表达式。
    
 
 
-
    console.log(square); // square is hoisted with an initial value undefined.
+
    console.log(square); // square is hoisted with an initial value undefined.
 console.log(square(5)); // Uncaught TypeError: square is not a function
 const square = function (n) {
   return n * n;
@@ -146,7 +146,7 @@ const square = function (n) {
 
 
    函数可以被递归，就是说函数可以调用其本身。例如，下面这个函数就是用递归计算阶乘：
    
 
-
    function factorial(n){
+
    function factorial(n){
   if ((n == 0) || (n == 1))
     return 1;
   else
@@ -156,7 +156,7 @@ const square = function (n) {
 
 
    你可以计算1-5的阶乘如下：
    
 
-
    var a, b, c, d, e;
+
    var a, b, c, d, e;
 
 a = factorial(1); // 1赋值给a
 b = factorial(2); // 2赋值给b
@@ -171,7 +171,7 @@ e = factorial(5); // 120赋值给e
 
 
    在函数内定义的变量不能在函数之外的任何地方访问，因为变量仅仅在该函数的域的内部有定义。相对应的，一个函数可以访问定义在其范围内的任何变量和函数。换言之，定义在全局域中的函数可以访问所有定义在全局域中的变量。在另一个函数中定义的函数也可以访问在其父函数中定义的所有变量和父函数有权访问的任何其他变量。
    
 
-
    // 下面的变量定义在全局作用域(global scope)中
+
    // 下面的变量定义在全局作用域(global scope)中
 var num1 = 20,
     num2 = 3,
     name = "Chamahk";
@@ -212,7 +212,7 @@ getScore(); // 返回 "Chamahk scored 5"
 
 
    例如，思考一下如下的函数定义：
    
 
-
    var foo = function bar() {
+
    var foo = function bar() {
    // statements go here
 };
 
    
@@ -227,7 +227,7 @@ getScore(); // 返回 "Chamahk scored 5"
 
 
    调用自身的函数我们称之为递归函数。在某种意义上说，递归近似于循环。两者都重复执行相同的代码，并且两者都需要一个终止条件（避免无限循环或者无限递归）。例如以下的循环：
    
 
-
    var x = 0;
+
    var x = 0;
 while (x < 10) { // "x < 10" 是循环条件
    // do stuff
    x++;
@@ -236,7 +236,7 @@ while (x < 10) { // "x < 10" 是循环条件
 
 
    可以被转化成一个递归函数和对其的调用：
    
 
-
    function loop(x) {
+
    function loop(x) {
   if (x >= 10) // "x >= 10" 是退出条件（等同于 "!(x < 10)"）
     return;
   // 做些什么
@@ -247,7 +247,7 @@ loop(0);
 
 
    不过，有些算法并不能简单的用迭代来实现。例如，获取树结构中所有的节点时，使用递归实现要容易得多：
    
 
-
    function walkTree(node) {
+
    function walkTree(node) {
   if (node == null) //
     return;
   // do something with node
@@ -263,7 +263,7 @@ loop(0);
 
 
    这种类似堆栈的行为可以在下例中看到：
    
 
-
    function foo(i) {
+
    function foo(i) {
   if (i < 0)
     return;
   console.log('begin:' + i);
@@ -298,7 +298,7 @@ foo(3);
 
 
    下面的例子展示了嵌套函数：
    
 
-
    function addSquares(a, b) {
+
    function addSquares(a, b) {
   function square(x) {
     return x * x;
   }
@@ -310,7 +310,7 @@ c = addSquares(4, 5); // returns 41
    
 
 
    由于内部函数形成了闭包，因此你可以调用外部函数并为外部函数和内部函数指定参数：
    
 
-
    function outside(x) {
+
    function outside(x) {
   function inside(y) {
     return x + y;
   }
@@ -333,7 +333,7 @@ result1 = outside(3)(5); // returns 8
    
 
 
    思考一下下面的例子：
    
 
-
    function A(x) {
+
    function A(x) {
   function B(y) {
     function C(z) {
       console.log(x + y + z);
@@ -360,7 +360,7 @@ A(1); // logs 6 (1 + 2 + 3)
    
 
 
    看以下的例子：
    
 
-
    function outside() {
+
    function outside() {
   var x = 5;
   function inside(x) {
     return x * 2;
@@ -380,7 +380,7 @@ outside()(10); // returns 20 instead of 10
    
 
 
    此外，由于内部函数可以访问外部函数的作用域，因此当内部函数生存周期大于外部函数时，外部函数中定义的变量和函数的生存周期将比内部函数执行时间长。当内部函数以某一种方式被任何一个外部函数作用域访问时，一个闭包就产生了。
    
 
-
    var pet = function(name) {          //外部函数定义了一个变量"name"
+
    var pet = function(name) {          //外部函数定义了一个变量"name"
   var getName = function() {
     //内部函数可以访问 外部函数定义的"name"
     return name;
@@ -395,7 +395,7 @@ myPet();                            // 返回结果 "Vivie"
 
 
    实际上可能会比上面的代码复杂的多。在下面这种情形中，返回了一个包含可以操作外部函数的内部变量方法的对象。
    
 
-
    var createPet = function(name) {
+
    var createPet = function(name) {
   var sex;
 
   return {
@@ -431,7 +431,7 @@ pet.getName();                  // Oliver
 
 
    在上面的代码中，外部函数的name变量对内嵌函数来说是可取得的，而除了通过内嵌函数本身，没有其它任何方法可以取得内嵌的变量。内嵌函数的内嵌变量就像内嵌函数的保险柜。它们会为内嵌函数保留“稳定”——而又安全——的数据参与运行。而这些内嵌函数甚至不会被分配给一个变量，或者不必一定要有名字。
    
 
-
    var getCode = (function(){
+
    var getCode = (function(){
   var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...
 
   return function () {
@@ -445,7 +445,7 @@ getCode();    // Returns the secret code
 
    
 
    尽管有上述优点，使用闭包时仍然要小心避免一些陷阱。如果一个闭包的函数定义了一个和外部函数的某个变量名称相同的变量，那么这个闭包将无法引用外部函数的这个变量。
    
 
-
    var createPet = function(name) {  // Outer function defines a variable called "name"
+
    var createPet = function(name) {  // Outer function defines a variable called "name"
   return {
     setName: function(name) {    // Enclosed function also defines a variable called "name"
       name = name;               // ??? How do we access the "name" defined by the outer function ???
@@ -459,7 +459,7 @@ getCode();    // Returns the secret code
 
 
    函数的实际参数会被保存在一个类似数组的arguments对象中。在函数内，你可以按如下方式找出传入的参数：
    
 
-
    arguments[i]
+
    arguments[i]
 
    
 
 
    其中i是参数的序数编号（译注：数组索引），以0开始。所以第一个传来的参数会是arguments[0]。参数的数量由arguments.length表示。
    
@@ -468,7 +468,7 @@ getCode();    // Returns the secret code
 
 
    例如，设想有一个用来连接字符串的函数。唯一事先确定的参数是在连接后的字符串中用来分隔各个连接部分的字符（译注：比如例子里的分号“；”）。该函数定义如下：
    
 
-
    function myConcat(separator) {
+
    function myConcat(separator) {
    var result = ''; // 把值初始化成一个字符串，这样就可以用来保存字符串了！！
    var i;
    // iterate through arguments
@@ -480,7 +480,7 @@ getCode();    // Returns the secret code
 
 
    你可以给这个函数传递任意数量的参数，它会将各个参数连接成一个字符串“列表”：
    
 
-
    // returns "red, orange, blue, "
+
    // returns "red, orange, blue, "
 myConcat(", ", "red", "orange", "blue");
 
 // returns "elephant; giraffe; lion; cheetah; "
@@ -504,7 +504,7 @@ myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
 
 
    在过去，用于设定默认参数的一般策略是在函数的主体中测试参数值是否为undefined，如果是则赋予这个参数一个默认值。如果在下面的例子中，调用函数时没有实参传递给b，那么它的值就是undefined，于是计算a*b得到、函数返回的是 NaN。但是，在下面的例子中，这个已经被第二行获取处理：
    
 
-
    function multiply(a, b) {
+
    function multiply(a, b) {
   b = (typeof b !== 'undefined') ?  b : 1;
 
   return a*b;
@@ -515,7 +515,7 @@ multiply(5); // 5
 
 
    使用默认参数，在函数体的检查就不再需要了。现在，你可以在函数头简单地把1设定为b的默认值：
    
 
-
    function multiply(a, b = 1) {
+
    function multiply(a, b = 1) {
   return a*b;
 }
 
@@ -527,7 +527,7 @@ multiply(5); // 5
    
 
 
    剩余参数语法允许将不确定数量的参数表示为数组。在下面的例子中，使用剩余参数收集从第二个到最后参数。然后，我们将这个数组的每一个数与第一个参数相乘。这个例子是使用了一个箭头函数，这将在下一节介绍。
    
 
-
    function multiply(multiplier, ...theArgs) {
+
    function multiply(multiplier, ...theArgs) {
   return theArgs.map(x => multiplier * x);
 }
 
@@ -544,7 +544,7 @@ console.log(arr); // [2, 4, 6]
    
 
 
    在一些函数模式中，更简洁的函数很受欢迎。对比一下：
    
 
-
    var a = [
+
    var a = [
   "Hydrogen",
   "Helium",
   "Lithium",
@@ -563,7 +563,7 @@ console.log(a3); // logs [ 8, 6, 7, 9 ]
    
 
 
    在箭头函数出现之前，每一个新函数都重新定义了自己的 this 值（在构造函数中是一个新的对象；在严格模式下是未定义的；在作为“对象方法”调用的函数中指向这个对象；等等）。以面向对象的编程风格，这样着实有点恼人。
    
 
-
    function Person() {
+
    function Person() {
   // 构造函数Person()将`this`定义为自身
   this.age = 0;
 
@@ -579,7 +579,7 @@ var p = new Person();
    
 
 
    在ECMAScript 3/5里，通过把this的值赋值给一个变量可以修复这个问题。
    
 
-
    function Person() {
+
    function Person() {
   var self = this; // 有的人习惯用`that`而不是`self`，
                    // 无论你选择哪一种方式，请保持前后代码的一致性
   self.age = 0;
@@ -594,7 +594,7 @@ var p = new Person();
    
 
 
    箭头函数捕捉闭包上下文的this值，所以下面的代码工作正常。
    
 
-
    function Person(){
+
    function Person(){
   this.age = 0;
 
   setInterval(() => {
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 9a3aa594c3..a5e540e163 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
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Guide/Grammar_and_types
 
 
    JavaScript 是区分大小写的，并使用 Unicode 字符集。举个例子，可以将单词 Früh （在德语中意思是“早”）用作变量名。
    
 
-
    var Früh = "foobar";
    
+
    var Früh = "foobar";
    
 
 
    但是，由于 JavaScript 是大小写敏感的，因此变量 früh 和 Früh 则是两个不同的变量。
    
 
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Guide/Grammar_and_types
 
 
    Javascript 注释的语法和 C++ 或许多其他语言类似：
    
 
-
    // 单行注释
+
    // 单行注释
 
 /* 这是一个更长的,
    多行注释
@@ -84,7 +84,7 @@ translation_of: Web/JavaScript/Guide/Grammar_and_types
 
 
    如果访问一个未声明的变量会导致抛出一个引用错误（ReferenceError）异常：
    
 
-
    var a;
+
    var a;
 console.log("The value of a is " + a); // a 的值是 undefined
 
 console.log("The value of b is " + b);// b 的值是 undefined
@@ -101,7 +101,7 @@ let y;
    
 
 
    你可以使用 undefined 来判断一个变量是否已赋值。在以下的代码中，变量input未被赋值，因此 if 条件语句的求值结果是 true 。
    
 
-
    var input;
+
    var input;
 if(input === undefined){
   doThis();
 } else {
@@ -111,19 +111,19 @@ if(input === undefined){
 
 
    The following is related to "Variables" section as potential values in assignment.undefined 值在布尔类型环境中会被当作 false 。例如，下面的代码将会执行函数 myFunction，因为数组 myArray 中的元素未被赋值：
    
 
-
    var myArray = [];
+
    var myArray = [];
 if (!myArray[0])   myFunction();
 
    
 
 
    数值类型环境中 undefined 值会被转换为 NaN。
    
 
-
    var a;
+
    var a;
 a + 2;    // 计算为 NaN
 
    
 
 
    当你对一个 null 变量求值时，空值 null 在数值类型环境中会被当作0来对待，而布尔类型环境中会被当作 false。例如：
    
 
-
    var n = null;
+
    var n = null;
 console.log(n * 32); // 在控制台中会显示 0
 
    
 
@@ -133,7 +133,7 @@ console.log(n * 32); // 在控制台中会显示 0
 
 
    ECMAScript 6 之前的 JavaScript 没有 语句块 作用域；相反，语句块中声明的变量将成为语句块所在函数（或全局作用域）的局部变量。例如，如下的代码将在控制台输出 5，因为 x 的作用域是声明了 x 的那个函数（或全局范围），而不是 if 语句块。
    
 
-
    if (true) {
+
    if (true) {
   var x = 5;
 }
 console.log(x); // 5
@@ -141,7 +141,7 @@ console.log(x); // 5
 
 
    如果使用 ECMAScript 6 中的 let 声明，上述行为将发生变化。
    
 
-
    if (true) {
+
    if (true) {
   let y = 5;
 }
 console.log(y); // ReferenceError: y 没有被声明
    
@@ -150,7 +150,7 @@ console.log(y); // ReferenceError: y 没有被声明
    
 
 
    JavaScript 变量的另一个不同寻常的地方是，你可以先使用变量稍后再声明变量而不会引发异常。这一概念称为变量提升；JavaScript 变量感觉上是被“提升”或移到了函数或语句的最前面。但是，提升后的变量将返回 undefined 值。因此在使用或引用某个变量之后进行声明和初始化操作，这个被提升的变量仍将返回 undefined 值。
    
 
-
    /**
+
    /**
  * 例子1
  */
 console.log(x === undefined); // true
@@ -171,7 +171,7 @@ var myvar = "my value";
 
 
    上面的例子，也可写作：
    
 
-
    /**
+
    /**
  * 例子1
  */
 var x;
@@ -193,14 +193,14 @@ var myvar = "my value";
 
 
    在 ECMAScript 6 中，let（const）同样会被提升变量到代码块的顶部但是不会被赋予初始值。在变量声明之前引用这个变量，将抛出引用错误（ReferenceError）。这个变量将从代码块一开始的时候就处在一个“暂时性死区”，直到这个变量被声明为止。
    
 
-
    console.log(x); // ReferenceError
+
    console.log(x); // ReferenceError
 let x = 3;
    
 
 
    函数提升
    
 
 
    对于函数来说，只有函数声明会被提升到顶部，而函数表达式不会被提升。
    
 
-
    /* 函数声明 */
+
    /* 函数声明 */
 
 foo(); // "bar"
 
@@ -227,7 +227,7 @@ var baz = function() {
 
 
    你可以用关键字 const 创建一个只读的常量。常量标识符的命名规则和变量相同：必须以字母、下划线（_）或美元符号（$）开头并可以包含有字母、数字或下划线。
    
 
-
    const PI = 3.14;
+
    const PI = 3.14;
 
    
 
 
    常量不可以通过重新赋值改变其值，也不可以在代码运行时重新声明。它必须被初始化为某个值。
    
@@ -236,7 +236,7 @@ var baz = function() {
 
 
    在同一作用域中，不能使用与变量名或函数名相同的名字来命名常量。例如：
    
 
-
    // 这会造成错误
+
    // 这会造成错误
 function f() {};
 const f = 5;
 
@@ -251,12 +251,12 @@ function f() {
 
 
    然而，对象属性被赋值为常量是不受保护的，所以下面的语句执行时不会产生错误。
    
 
-
    const MY_OBJECT = {"key": "value"};
+
    const MY_OBJECT = {"key": "value"};
 MY_OBJECT.key = "otherValue";
    
 
 
    同样的，数组的被定义为常量也是不受保护的，所以下面的语句执行时也不会产生错误。
    
 
-
    const MY_ARRAY = ['HTML','CSS'];
+
    const MY_ARRAY = ['HTML','CSS'];
 MY_ARRAY.push('JAVASCRIPT');
 console.log(MY_ARRAY); //logs ['HTML','CSS','JAVASCRIPT'];
 
    
@@ -288,24 +288,24 @@ console.log(MY_ARRAY); //logs ['HTML','CSS','JAVASCRIPT'];
 
 
    JavaScript是一种动态类型语言(dynamically typed language)。这意味着你在声明变量时可以不必指定数据类型，而数据类型会在代码执行时会根据需要自动转换。因此，你可以按照如下方式来定义变量：
    
 
-
    var answer = 42;
+
    var answer = 42;
 
    
 
 
    然后，你还可以给同一个变量赋予一个字符串值，例如：
    
 
-
    answer = "Thanks for all the fish...";
    
+
    answer = "Thanks for all the fish...";
    
 
 
    因为 JavaScript 是动态类型的，这种赋值方式并不会提示出错。
    
 
 
    在包含的数字和字符串的表达式中使用加法运算符（+），JavaScript 会把数字转换成字符串。例如，观察以下语句：
    
 
-
    x = "The answer is " + 42 // "The answer is 42"
+
    x = "The answer is " + 42 // "The answer is 42"
 y = 42 + " is the answer" // "42 is the answer"
 
    
 
 
    在涉及其它运算符（译注：如下面的减号'-'）时，JavaScript语言不会把数字变为字符串。例如（译注：第一例是数学运算，第二例是字符串运算）：
    
 
-
    "37" - 7 // 30
+
    "37" - 7 // 30
 "37" + 7 // "377"
 
    
 
@@ -321,7 +321,7 @@ y = 42 + " is the answer" // "42 is the answer"
 
 
    将字符串转换为数字的另一种方法是使用一元加法运算符。
    
 
-
    "1.1" + "1.1" = "1.11.1"
+
    "1.1" + "1.1" = "1.11.1"
 (+"1.1") + (+"1.1") = 2.2
 // 注意：加入括号为清楚起见，不是必需的。
 
    
@@ -348,7 +348,7 @@ y = 42 + " is the answer" // "42 is the answer"
 
 
    下面的示例用3个元素生成数组coffees，它的长度是3。
    
 
-
    var coffees = ["French Roast", "Colombian", "Kona"];
+
    var coffees = ["French Roast", "Colombian", "Kona"];
 
 var a=[3];
 
@@ -368,7 +368,7 @@ console.log(a[0]); // 3
    
 
 
    （译注：声明时）你不必列举数组字面值中的所有元素。若你在同一行中连写两个逗号（,），数组中就会产生一个没有被指定的元素，其初始值是undefined。以下示例创建了一个名为fish的数组：
    
 
-
    var fish = ["Lion", , "Angel"];
+
    var fish = ["Lion", , "Angel"];
 
    
 
 
    在这个数组中，有两个已被赋值的元素，和一个空元素（fish[0]是"Lion"，fish[1]是undefined，而fish[2]是"Angel"；译注：此时数组的长度属性fish.length是3)。
    
@@ -381,17 +381,17 @@ console.log(a[0]); // 3
    
 
 
    (译注：而“现代”的浏览器似乎鼓励这种方式，这也很好解释原因。尾部逗号可以减少向数组的最后添加元素时，因为忘记为这最后一个元素加逗号 所造成的错误。)
    
 
-
    var myList = ['home', , 'school', ];
+
    var myList = ['home', , 'school', ];
 
    
 
 
    在下面的例子中，数组的长度是4，元素myList[0]和myList[2]缺失（译注：没被赋值，因而是undefined）。
    
 
-
    var myList = [ , 'home', , 'school'];
+
    var myList = [ , 'home', , 'school'];
 
    
 
 
    再看一个例子。在这里，该数组的长度是4，元素myList[1]和myList[3]被漏掉了。（但是）只有最后的那个逗号被忽略。
    
 
-
    var myList = ['home', , 'school', , ];
+
    var myList = ['home', , 'school', , ];
 
    
 
 
    理解多余的逗号（在脚本运行时会被如何处理）的含义，对于从语言层面理解JavaScript是十分重要的。但是，在你自己写代码时：显式地将缺失的元素声明为undefined，将大大提高你的代码的清晰度和可维护性。
    
@@ -421,7 +421,7 @@ console.log(a[0]); // 3
    
 
 
    整数字面量举例：
    
 
-
    0, 117 and -345 (十进制, 基数为10)
+
    0, 117 and -345 (十进制, 基数为10)
 015, 0001 and -0o77 (八进制, 基数为8)
 0x1123, 0x00111 and -0xF1A7 (十六进制, 基数为16或"hex")
 0b11, 0b0011 and -0b11 (二进制, 基数为2)
    
@@ -441,11 +441,11 @@ console.log(a[0]); // 3
    
 
 
    简言之，其语法是：
    
 
-
    [(+|-)][digits][.digits][(E|e)[(+|-)]digits]
    
+
    [(+|-)][digits][.digits][(E|e)[(+|-)]digits]
    
 
 
    例如：
    
 
-
    3.14
+
    3.14
 -.2345789 // -0.23456789
 -3.12e+12  // -3.12*10^12
 .1e-23    // 0.1*10^(-23)=10^(-24)=1e-24
@@ -457,7 +457,7 @@ console.log(a[0]); // 3
    
 
 
    以下是一个对象字面值的例子。对象car的第一个元素（译注：即一个属性/值对）定义了属性myCar；第二个元素，属性getCar，引用了一个函数（即CarTypes("Honda")）；第三个元素，属性special，使用了一个已有的变量（即Sales）。
    
 
-
    var Sales = "Toyota";
+
    var Sales = "Toyota";
 
 function CarTypes(name) {
   return (name === "Honda") ?
@@ -474,7 +474,7 @@ console.log(car.special); // Toyota
 
 
    更进一步的，你可以使用数字或字符串字面值作为属性的名字，或者在另一个字面值内嵌套上一个字面值。如下的示例中使用了这些可选项。
    
 
-
    var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
+
    var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
 
 console.log(car.manyCars.b); // Jeep
 console.log(car[7]); // Mazda
@@ -482,7 +482,7 @@ console.log(car[7]); // Mazda
 
 
    对象属性名字可以是任意字符串，包括空串。如果对象属性名字不是合法的javascript标识符，它必须用""包裹。属性的名字不合法，那么便不能用.访问属性值，而是通过类数组标记("[]")访问和赋值。
    
 
-
    var unusualPropertyNames = {
+
    var unusualPropertyNames = {
   "": "An empty string",
   "!": "Bang!"
 }
@@ -495,7 +495,7 @@ console.log(unusualPropertyNames["!"]); // Bang!
    
 
 
    在ES2015，对象字面值扩展支持在创建时设置原型，简写了 foo: foo 形式的属性赋值，方法定义，支持父方法调用，以及使用表达式动态计算属性名。总之，这些也使对象字面值和类声明更加紧密地联系起来，让基于对象的设计从这些便利中更加受益。
    
 
-
    var obj = {
+
    var obj = {
     // __proto__
     __proto__: theProtoObj,
     // Shorthand for ‘handler: handler’
@@ -511,7 +511,7 @@ console.log(unusualPropertyNames["!"]); // Bang!
    
 
 
    请注意：
    
 
-
    var foo = {a: "alpha", 2: "two"};
+
    var foo = {a: "alpha", 2: "two"};
 console.log(foo.a);    // alpha
 console.log(foo[2]);   // two
 //console.log(foo.2);  // SyntaxError: missing ) after argument list
@@ -523,13 +523,13 @@ console.log(foo["2"]); // two
    
 
 
    一个正则表达式是字符被斜线（译注：正斜杠“/”）围成的表达式。下面是一个正则表达式文字的一个例子。
    
 
-
    var re = /ab+c/;
    
+
    var re = /ab+c/;
    
 
 
    字符串字面量 (String literals)
    
 
 
    字符串字面量是由双引号（"）对或单引号（'）括起来的零个或多个字符。字符串被限定在同种引号之间；也即，必须是成对单引号或成对双引号。下面的例子都是字符串字面值：
    
 
-
    "foo"
+
    "foo"
 'bar'
 "1234"
 "one line \n another line"
@@ -537,13 +537,13 @@ console.log(foo["2"]); // two
    
 
 
    你可以在字符串字面值上使用字符串对象的所有方法——JavaScript会自动将字符串字面值转换为一个临时字符串对象，调用该方法，然后废弃掉那个临时的字符串对象。你也能用对字符串字面值使用类似String.length的属性：
    
 
-
    console.log("John's cat".length)
+
    console.log("John's cat".length)
 // 将打印字符串中的字符个数（包括空格）
 // 结果为：10
    
 
 
    在ES2015中，还提供了一种模板字面量（template literals），模板字符串提供了一些语法糖来帮你构造字符串。这与Perl、Python还有其他语言中的字符串插值（string interpolation）的特性非常相似。除此之外，你可以在通过模板字符串前添加一个tag来自定义模板字符串的解析过程，这可以用来防止注入攻击，或者用来建立基于字符串的高级数据抽象。
    
 
-
    // Basic literal string creation
+
    // Basic literal string creation
 `In JavaScript '\n' is a line-feed.`
 
 // Multiline strings
@@ -568,7 +568,7 @@ POST`http://foo.org/bar?a=${a}&b=${b}
 
 
    作为一般字符的扩展，你可以在字符串中使用特殊字符，如下例所示。
    
 
-
    "one line \n another line"
+
    "one line \n another line"
 
    
 
 
    以下表格列举了你能在JavaScript的字符串中使用的特殊字符。
    
@@ -649,23 +649,23 @@ POST`http://foo.org/bar?a=${a}&b=${b}
 
 
    通过在引号前加上反斜线'\'，可以在字符串中插入引号，这就是引号转义。例如:
    
 
-
    var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
+
    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.
+
    He read "The Cremation of Sam McGee" by R.W. Service.
 
    
 
 
    要在字符串中插入'\'字面值，必须转义反斜线。例如，要把文件路径 c:\temp 赋值给一个字符串，可以采用如下方式:
    
 
-
    var home = "c:\\temp";
+
    var home = "c:\\temp";
 
    
 
 
    也可以在换行之前加上反斜线以转义换行（译注：实际上就是一条语句拆成多行书写），这样反斜线和换行都不会出现在字符串的值中。
    
 
-
    var str = "this string \
+
    var str = "this string \
 is broken \
 across multiple\
 lines."
@@ -674,7 +674,7 @@ console.log(str);   // this string is broken across multiplelines.
 
 
    Javascript没有“heredoc”语法，但可以用行末的换行符转义和转义的换行来近似实现 
    
 
-
    var poem =
+
    var poem =
 "Roses are red,\n\
 Violets are blue.\n\
 Sugar is sweet,\n\
@@ -683,7 +683,7 @@ and so is foo."
 
 
    ECMAScript 2015 增加了一种新的字面量，叫做模板字面量 template literals。它包含一些新特征，包括了多行字符串！
    
 
-
    var poem =
+
    var poem =
 `Roses are red,
 Violets are blue.
 Sugar is sweet,
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 fae44cbb84..600ec4ed4e 100644
--- a/files/zh-cn/web/javascript/guide/indexed_collections/index.html
+++ b/files/zh-cn/web/javascript/guide/indexed_collections/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Guide/Indexed_collections
 
 
    以下语句创建等效的数组:
    
 
-
    var arr = new Array(element0, element1, ..., elementN);
+
    var arr = new Array(element0, element1, ..., elementN);
 var arr = Array(element0, element1, ..., elementN);
 var arr = [element0, element1, ..., elementN];
 
@@ -30,7 +30,7 @@ var arr = [element0, element1, ..., elementN];
 
 
    为了创建一个长度不为0，但是又没有任何元素的数组，可选以下任何一种方式：
    
 
-
    var arr = new Array(arrayLength);
+
    var arr = new Array(arrayLength);
 var arr = Array(arrayLength);
 
 // 这样有同样的效果
@@ -44,7 +44,7 @@ arr.length = arrayLength;
 
 
    除了如上所示创建新定义的变量，数组(array)也可以作为一个属性(property)分配给一个新的或者已存在的对象(object)：
    
 
-
    var obj = {};
+
    var obj = {};
 // ...
 obj.prop = [element0, element1, ..., elementN];
 
@@ -54,7 +54,7 @@ var obj = {prop: [element0, element1, ...., elementN]}
 
 
    如果你希望用单个元素初始化一个数组，而这个元素恰好又是数字(Number)，那么你必须使用括号语法。当单个的数字(Number)传递给Array()构造函数时，将会被解释为数组长度，并非单个元素。
    
 
-
    var arr = [42];      // 创建一个只有唯一元素的数组:
+
    var arr = [42];      // 创建一个只有唯一元素的数组:
                      // the number 42.
 var arr = Array(42); // 创建一个没有元素的数组,
                      // 但是数组的长度被设置成42.
@@ -66,7 +66,7 @@ arr.length = 42;
 
 
    如果N不是一个整数，调用Array(N)将会报RangeError错误， 以下方法说明了这种行为：
    
 
-
    var arr = Array(9.3);  // RangeError: Invalid array length
+
    var arr = Array(9.3);  // RangeError: Invalid array length
 
    
 
 
    如果你需要创建任意类型的单元素数组，安全的方式是使用字面值。或者在向数组添加单个元素之前先创建一个空的数组。
    
@@ -75,7 +75,7 @@ arr.length = 42;
 
 
    你可以通过给元素赋值来填充数组，例如：
    
 
-
    var emp = [];
+
    var emp = [];
 emp[0] = "Casey Jones";
 emp[1] = "Phil Lesh";
 emp[2] = "August West";
@@ -85,7 +85,7 @@ emp[2] = "August West";
 
    注意：如果你在以上代码中给数组操作符的是一个非整形数值，那么将作为一个代表数组的对象的属性(property)创建，而非作为数组的元素。
    
 
    
 
-
    var arr = [];
+
    var arr = [];
 arr[3.4] = "Oranges";
 console.log(arr.length);                // 0
 console.log(arr.hasOwnProperty(3.4));   // true
@@ -93,7 +93,7 @@ console.log(arr.hasOwnProperty(3.4));   // true
 
 
    你也可以在创建数组的时候去填充它：
    
 
-
    var myArray = new Array("Hello", myVar, 3.14159);
+
    var myArray = new Array("Hello", myVar, 3.14159);
 var myArray = ["Mango", "Apple", "Orange"]
 
    
 
@@ -101,7 +101,7 @@ var myArray = ["Mango", "Apple", "Orange"]
 
 
    您通过可以使用元素的序号来引用数组的元素。例如，假设你定义了如下数组：
    
 
-
    var myArray = ["Wind", "Rain", "Fire"];
+
    var myArray = ["Wind", "Rain", "Fire"];
 
    
 
 
    你可以用 myArray[0]引用第一个元素，myArray[1]引用第二个元素。元素的索引是从0开始的。
    
@@ -110,7 +110,7 @@ var myArray = ["Mango", "Apple", "Orange"]
 
    注意：数组操作符（方括号 [ ]）也可以用来访问数组的属性(在 JavaScript 中，数组也是对象)。例如：
    
 
 
-
    var arr = ["one", "two", "three"];
+
    var arr = ["one", "two", "three"];
 arr[2];  // three
 arr["length"];  // 3
 
    
@@ -119,14 +119,14 @@ arr["length"];  // 3
 
 
    在实施层面， JavaScript实际上是将元素作为标准的对象属性来存储，把数组索引作为属性名。长度属性是特殊的，它总是返回最后一个元素的索引值加1(下例中， Dusty 的索引是30，所以cats.length 返回 30 + 1)。记住， JavaScript 数组索引是基于0的: 他们从0开始，而不是1。这意味着数组长度属性将比最大的索引值大1:
    
 
-
    var cats = [];
+
    var cats = [];
 cats[30] = ['Dusty'];
 console.log(cats.length); // 31
 
    
 
 
    你也可以分配length属性。写一个小于数组元素数量的值会缩短数组，写0会彻底清空数组：
    
 
-
    var cats = ['Dusty', 'Misty', 'Twiggy'];
+
    var cats = ['Dusty', 'Misty', 'Twiggy'];
 console.log(cats.length); // 3
 
 cats.length = 2;
@@ -143,7 +143,7 @@ console.log(cats); // [undefined, undefined, undefined]
 
 
    遍历数组元素并以某种方式处理每个元素是一个常见的操作。以下是最简单的方式：
    
 
-
    var colors = ['red', 'green', 'blue'];
+
    var colors = ['red', 'green', 'blue'];
 for (var i = 0; i < colors.length; i++) {
   console.log(colors[i]);
 }
@@ -151,7 +151,7 @@ for (var i = 0; i < colors.length; i++) {
 
 
    如果你确定数组中没有一个元素的求值是false —— 如果你的数组只包含DOM节点，如下,你可以选择一个更高效的土法子:
    
 
-
    var divs = document.getElementsByTagName('div');
+
    var divs = document.getElementsByTagName('div');
 for (var i = 0, div; div = divs[i]; i++) {
   /* Process div in some way */
 }
@@ -161,7 +161,7 @@ for (var i = 0, div; div = divs[i]; i++) {
 
 
    {{jsxref("Array.forEach", "forEach()")}} 方法提供了遍历数组元素的其他方法：
    
 
-
    var colors = ['red', 'green', 'blue'];
+
    var colors = ['red', 'green', 'blue'];
 colors.forEach(function(color) {
   console.log(color);
 });
@@ -171,7 +171,7 @@ colors.forEach(function(color) {
 
 
    注意，在数组定义时省略的元素不会在forEach遍历时被列出，但是手动赋值为undefined的元素是会被列出的：
    
 
-
    var array = ['first', 'second', , 'fourth'];
+
    var array = ['first', 'second', , 'fourth'];
 
 // returns ['first', 'second', 'fourth'];
 array.forEach(function(element) {
@@ -195,53 +195,53 @@ array.forEach(function(element) {
 
 
    {{jsxref("Array.concat", "concat()")}} 连接两个数组并返回一个新的数组。
    
 
-
    var myArray = new Array("1", "2", "3");
+
    var myArray = new Array("1", "2", "3");
 myArray = myArray.concat("a", "b", "c");
 // myArray is now ["1", "2", "3", "a", "b", "c"]
 
    
 
 
    {{jsxref("Array.join", "join(deliminator = ',')")}} 将数组的所有元素连接成一个字符串。
    
 
-
    var myArray = new Array("Wind", "Rain", "Fire");
+
    var myArray = new Array("Wind", "Rain", "Fire");
 var list = myArray.join(" - "); // list is "Wind - Rain - Fire"
 
    
 
 
    {{jsxref("Array.push", "push()")}} 在数组末尾添加一个或多个元素，并返回数组操作后的长度。
    
 
-
    var myArray = new Array("1", "2");
+
    var myArray = new Array("1", "2");
 myArray.push("3"); // myArray is now ["1", "2", "3"]
 
    
 
 
    {{jsxref("Array.pop", "pop()")}} 从数组移出最后一个元素，并返回该元素。
    
 
-
    var myArray = new Array("1", "2", "3");
+
    var myArray = new Array("1", "2", "3");
 var last = myArray.pop();
 // myArray is now ["1", "2"], last = "3"
 
    
 
 
    {{jsxref("Array.shift", "shift()")}} 从数组移出第一个元素，并返回该元素。
    
 
-
    var myArray = new Array ("1", "2", "3");
+
    var myArray = new Array ("1", "2", "3");
 var first = myArray.shift();
 // myArray is now ["2", "3"], first is "1"
 
    
 
 
    {{jsxref("Array.shift", "unshift()")}} 在数组开头添加一个或多个元素，并返回数组的新长度。
    
 
-
    var myArray = new Array ("1", "2", "3");
+
    var myArray = new Array ("1", "2", "3");
 myArray.unshift("4", "5");
 // myArray becomes ["4", "5", "1", "2", "3"]
    
 
 
    {{jsxref("Array.slice", "slice(start_index, upto_index)")}} 从数组提取一个片段，并作为一个新数组返回。
    
 
-
    var myArray = new Array ("a", "b", "c", "d", "e");
+
    var myArray = new Array ("a", "b", "c", "d", "e");
 myArray = myArray.slice(1, 4); // 包含索引1，不包括索引4
                                // returning [ "b", "c", "d"]
 
    
 
 
    {{jsxref("Array.splice", "splice(index, count_to_remove, addElement1, addElement2, ...)")}}从数组移出一些元素，（可选）并替换它们。
    
 
-
    var myArray = new Array ("1", "2", "3", "4", "5");
+
    var myArray = new Array ("1", "2", "3", "4", "5");
 myArray.splice(1, 3, "a", "b", "c", "d");
 // myArray is now ["1", "a", "b", "c", "d", "5"]
 // This code started at index one (or where the "2" was),
@@ -251,14 +251,14 @@ myArray.splice(1, 3, "a", "b", "c", "d");
 
 
    {{jsxref("Array.reverse", "reverse()")}} 颠倒数组元素的顺序：第一个变成最后一个，最后一个变成第一个。
    
 
-
    var myArray = new Array ("1", "2", "3");
+
    var myArray = new Array ("1", "2", "3");
 myArray.reverse();
 // transposes the array so that myArray = [ "3", "2", "1" ]
 
    
 
 
    {{jsxref("Array.sort", "sort()")}} 给数组元素排序。
    
 
-
    var myArray = new Array("Wind", "Rain", "Fire");
+
    var myArray = new Array("Wind", "Rain", "Fire");
 myArray.sort();
 // sorts the array so that myArray = [ "Fire", "Rain", "Wind" ]
 
    
@@ -267,7 +267,7 @@ myArray.sort();
 
 
    例如，下面的代码通过字符串的最后一个字母进行排序：
    
 
-
    var sortFn = function(a, b){
+
    var sortFn = function(a, b){
   if (a[a.length - 1] < b[b.length - 1]) return -1;
   if (a[a.length - 1] > b[b.length - 1]) return 1;
   if (a[a.length - 1] == b[b.length - 1]) return 0;
@@ -283,7 +283,7 @@ myArray.sort(sortFn);
 
 
    {{jsxref("Array.indexOf", "indexOf(searchElement[, fromIndex])")}} 在数组中搜索searchElement 并返回第一个匹配的索引。
    
 
-
    var a = ['a', 'b', 'a', 'b', 'a'];
+
    var a = ['a', 'b', 'a', 'b', 'a'];
 console.log(a.indexOf('b')); // logs 1
 // Now try again, starting from after the last match
 console.log(a.indexOf('b', 2)); // logs 3
@@ -292,7 +292,7 @@ console.log(a.indexOf('z')); // logs -1, because 'z' was not found
 
 
    {{jsxref("Array.lastIndexOf", "lastIndexOf(searchElement[, fromIndex])")}} 和 indexOf 差不多，但这是从结尾开始，并且是反向搜索。
    
 
-
    var a = ['a', 'b', 'c', 'd', 'a', 'b'];
+
    var a = ['a', 'b', 'c', 'd', 'a', 'b'];
 console.log(a.lastIndexOf('b')); // logs 5
 // Now try again, starting from before the last match
 console.log(a.lastIndexOf('b', 4)); // logs 1
@@ -301,28 +301,28 @@ console.log(a.lastIndexOf('z')); // logs -1
 
 
    {{jsxref("Array.forEach", "forEach(callback[, thisObject])")}} 在数组每个元素项上执行callback。
    
 
-
    var a = ['a', 'b', 'c'];
+
    var a = ['a', 'b', 'c'];
 a.forEach(function(element) { console.log(element);} );
 // logs each item in turn
 
    
 
 
    {{jsxref("Array.map", "map(callback[, thisObject])")}} 在数组的每个单元项上执行callback函数，并把返回包含回调函数返回值的新数组（译者注：也就是遍历数组，并通过callback对数组元素进行操作，并将所有操作结果放入数组中并返回该数组）。
    
 
-
    var a1 = ['a', 'b', 'c'];
+
    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则会返回所有符合过滤条件的元素）。
    
 
-
    var a1 = ['a', 10, 'b', 20, 'c', 30];
+
    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，只不过它的功能是判断是不是数组中的所有元素都符合条件，并且返回的是布尔值）。
    
 
-
    function isNumber(value){
+
    function isNumber(value){
   return typeof value == 'number';
 }
 var a1 = [1, 2, 3];
@@ -333,7 +333,7 @@ console.log(a2.every(isNumber)); // logs false
 
 
    {{jsxref("Array.some", "some(callback[, thisObject])")}} 只要数组中有一项在callback上被返回true，就返回true（译者注：同上，类似every，不过前者要求都符合筛选条件才返回true，后者只要有符合条件的就返回true）。
    
 
-
    function isNumber(value){
+
    function isNumber(value){
   return typeof value == 'number';
 }
 var a1 = [1, 2, 3];
@@ -350,7 +350,7 @@ console.log(a3.some(isNumber)); // logs false
 
 
    {{jsxref("Array.reduce", "reduce(callback[, initialValue])")}} 使用回调函数 callback(firstValue, secondValue) 把数组列表计算成一个单一值（译者注：他数组元素两两递归处理的方式把数组计算成一个值）
    
 
-
    var a = [10, 20, 30];
+
    var a = [10, 20, 30];
 var total = a.reduce(function(first, second) { return first + second; }, 0);
 console.log(total) // Prints 60
 
    
@@ -365,7 +365,7 @@ console.log(total) // Prints 60
 
 
    以下代码创建了一个二维数组。
    
 
-
    var a = new Array(4);
+
    var a = new Array(4);
 for (i = 0; i < 4; i++) {
   a[i] = new Array(4);
   for (j = 0; j < 4; j++) {
@@ -376,7 +376,7 @@ for (i = 0; i < 4; i++) {
 
 
    这个例子创建的数组拥有以下行数据:
    
 
-
    Row 0: [0,0] [0,1] [0,2] [0,3]
+
    Row 0: [0,0] [0,1] [0,2] [0,3]
 Row 1: [1,0] [1,1] [1,2] [1,3]
 Row 2: [2,0] [2,1] [2,2] [2,3]
 Row 3: [3,0] [3,1] [3,2] [3,3]
@@ -393,7 +393,7 @@ Objects/String/split">String.split() 的返回值是一个数组。
 
 
    Array的原生(prototype)方法可以用来处理类似数组行为的对象，例如： :
    
 
-
    function printArguments() {
+
    function printArguments() {
   Array.prototype.forEach.call(arguments, function(item) {
     console.log(item);
   });
@@ -401,7 +401,7 @@ Objects/String/split">String.split() 的返回值是一个数组。
 
 
    Array的常规方法也可以用于处理字符串，因为它提供了序列访问字符转为数组的简单方法：
    
 
-
    Array.prototype.forEach.call("a string", function(chr) {
+
    Array.prototype.forEach.call("a string", function(chr) {
   console.log(chr);
 });
    
 
@@ -411,31 +411,31 @@ Objects/String/split">String.split() 的返回值是一个数组。
 
 
    下面的推导式创建一个数字数组并且创建一个新的数组，数组的每个元素都是原来数值的两倍（译者注：这种形式类似于Python的列表推导式）。
    
 
-
    var numbers = [1, 2, 3, 4];
+
    var numbers = [1, 2, 3, 4];
 var doubled = [for (i of numbers) i * 2];
 console.log(doubled); // logs 2,4,6,8
 
    
 
 
    这跟下面的map()方法的操作是等价的。
    
 
-
    var doubled = numbers.map(function(i){return i * 2;});
+
    var doubled = numbers.map(function(i){return i * 2;});
 
    
 
 
    推导式也可以用来筛选满足条件表达式的元素. 下面的推导式用来筛选是2的倍数的元素:
    
 
-
    var numbers = [1, 2, 3, 21, 22, 30];
+
    var numbers = [1, 2, 3, 21, 22, 30];
 var evens = [i for (i of numbers) if (i % 2 === 0)];
 console.log(evens); // logs 2,22,30
 
    
 
 
    filter() 也可以达到相同的目的：
    
 
-
    var evens = numbers.filter(function(i){return i % 2 === 0;});
+
    var evens = numbers.filter(function(i){return i % 2 === 0;});
 
    
 
 
    map() 和filter() 类型的操作可以被组合（等效）为单个数组推导式。这里就有一个过滤出偶数，创建一个它的倍数数组的例子：
    
 
-
    var numbers = [1, 2, 3, 21, 22, 30];
+
    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
 
    
@@ -446,7 +446,7 @@ console.log(doubledEvens); // logs 4,44,60
 
 
    甚至字符串也可以用来作为输入; 实现filter或者map行为 (参考上面类似数组行为的对象)如下:
    
 
-
    var str = 'abcdef';
+
    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'
 
    
diff --git a/files/zh-cn/web/javascript/guide/introduction/index.html b/files/zh-cn/web/javascript/guide/introduction/index.html
index 8a6a283d5c..3848d00603 100644
--- a/files/zh-cn/web/javascript/guide/introduction/index.html
+++ b/files/zh-cn/web/javascript/guide/introduction/index.html
@@ -117,7 +117,7 @@ translation_of: Web/JavaScript/Guide/Introduction
 
 
    控制台的工作方式与eval完全相同：返回最后输入的表达式。为了简单起见，可以想象每次输入到控制台的东西实际上都被 console.log 所包围。
    
 
-
    function greetMe(yourName) { alert('Hello ' + yourName); } console.log(eval('3 + 5'));
    
+
    function greetMe(yourName) { alert('Hello ' + yourName); } console.log(eval('3 + 5'));
    
 
 
    代码草稿纸（Scratchpad）
    
 
@@ -133,7 +133,7 @@ translation_of: Web/JavaScript/Guide/Introduction
 
 
    学习JavaScript 的第一步，打开浏览器的代码草稿纸尝试编写你的第一个 JavaScript 版本的 “Hello world” 程序。
    
 
-
    function greetMe(user) {
+
    function greetMe(user) {
   alert('Hi ' + user);
 }
 
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 723165c93f..65747f4058 100644
--- a/files/zh-cn/web/javascript/guide/meta_programming/index.html
+++ b/files/zh-cn/web/javascript/guide/meta_programming/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Guide/Meta_programming
 
 
    在 ECMAScript 6 中引入的 {{jsxref("Proxy")}} 对象可以拦截某些操作并实现自定义行为。例如获取一个对象上的属性：
    
 
-
    let handler = {
+
    let handler = {
   get: function(target, name){
     return name in target ? target[name] : 42;
 }};
@@ -204,7 +204,7 @@ console.log(p.a, p.b); // 1, 42
 
 
    {{jsxref("Proxy.revocable()")}} 方法被用来创建可撤销的 Proxy 对象。这意味着 proxy 可以通过 revoke 函数来撤销，并且关闭代理。此后，代理上的任意的操作都会导致{{jsxref("TypeError")}}。
    
 
-
    var revocable = Proxy.revocable({}, {
+
    var revocable = Proxy.revocable({}, {
   get: function(target, name) {
     return "[[" + name + "]]";
   }
@@ -227,18 +227,18 @@ typeof proxy            // "object", typeof doesn't trigger any trap
    
 
 
    以 {{jsxref("Reflect.has()")}} 为例，你可以将 in 运算符作为函数：
    
 
-
    Reflect.has(Object, "assign"); // true
+
    Reflect.has(Object, "assign"); // true
 
    
 
 
    更好的 apply 函数
    
 
 
    在 ES5 中，我们通常使用 {{jsxref("Function.prototype.apply()")}} 方法调用一个具有给定 this 值和 arguments 数组（或类数组对象）的函数。
    
 
-
    Function.prototype.apply.call(Math.floor, undefined, [1.75]);
    
+
    Function.prototype.apply.call(Math.floor, undefined, [1.75]);
    
 
 
    使用 {{jsxref("Reflect.apply")}}，这变得不那么冗长和容易理解：
    
 
-
    Reflect.apply(Math.floor, undefined, [1.75]);
+
    Reflect.apply(Math.floor, undefined, [1.75]);
 // 1;
 
 Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
@@ -254,7 +254,7 @@ Reflect.apply(''.charAt, 'ponies', [3]);
 
 
    使用 {{jsxref("Object.defineProperty")}}，如果成功返回一个对象，否则抛出一个 {{jsxref("TypeError")}}，你将使用 {{jsxref("Statements/try...catch","try...catch")}} 块来捕获定义属性时发生的任何错误。因为 {{jsxref("Reflect.defineProperty")}} 返回一个布尔值表示的成功状态，你可以在这里使用 {{jsxref("Statements/if...else","if...else")}} 块：
    
 
-
    if (Reflect.defineProperty(target, property, attributes)) {
+
    if (Reflect.defineProperty(target, property, attributes)) {
   // success
 } else {
   // failure
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 48a950b5ed..79bdc48877 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
@@ -26,7 +26,7 @@ translation_of: Web/JavaScript/Guide/Numbers_and_dates
 
 
    十进制数字(Decimal numbers)
    
 
-
    1234567890
+
    1234567890
 42
 // 以零开头的数字的注意事项：
 0888 // 888 将被当做十进制处理
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Guide/Numbers_and_dates
 
 
    二进制数字语法是以零为开头，后面接一个小写或大写的拉丁文字母B(0b或者是0B)。 假如0b后面的数字不是0或者1，那么就会提示这样的语法错误（ SyntaxError）： "Missing binary digits after 0b(0b之后缺失二有效的二进制数据)"。
    
 
-
    var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
+
    var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
 var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
 var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
    
 
@@ -47,26 +47,26 @@ var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
    
 
 
    八进制数字语法是以0为开头的。假如0后面的数字不在0到7的范围内，该数字将会被转换成十进制数字。
    
 
-
    var n = 0755; // 493
+
    var n = 0755; // 493
 var m = 0644; // 420
 
    
 
 
    在ECMAScript 5 严格模式下禁止使用八进制语法。八进制语法并不是ECMAScript 5规范的一部分，但是通过在八进制数字添加一个前缀0就可以被所有的浏览器支持：0644 === 420 而且 "\045" === "%"。在ECMAScript 6中使用八进制数字是需要给一个数字添加前缀"0o"。
    
 
-
    var a = 0o10; // ES6 :八进制
    
+
    var a = 0o10; // ES6 :八进制
    
 
 
    十六进制(Hexadecimal numbers)
    
 
 
    十六进制数字语法是以零为开头，后面接一个小写或大写的拉丁文字母X(0x或者是0X)。假如0x后面的数字超出规定范围(0123456789ABCDEF)，那么就会提示这样的语法错误(SyntaxError)："Identifier starts immediately after numeric literal".
    
 
-
    0xFFFFFFFFFFFFFFFFF // 295147905179352830000
+
    0xFFFFFFFFFFFFFFFFF // 295147905179352830000
 0x123456789ABCDEF   // 81985529216486900
 0XA                 // 10
 
    
 
 
    指数形式(Exponentiation)
    
 
-
    1E3   // 1000
+
    1E3   // 1000
 2e6   // 2000000
 0.1e2 // 10
 
    
@@ -75,7 +75,7 @@ var m = 0644; // 420
 
 
    内置的{{jsxref("Number")}}对象有一些有关数字的常量属性，如最大值、不是一个数字和无穷大的。你不能改变这些属性，但可以按下边的方式使用它们：
    
 
-
    var biggestNum = Number.MAX_VALUE;
+
    var biggestNum = Number.MAX_VALUE;
 var smallestNum = Number.MIN_VALUE;
 var infiniteNum = Number.POSITIVE_INFINITY;
 var negInfiniteNum = Number.NEGATIVE_INFINITY;
@@ -210,12 +210,12 @@ var notANum = Number.NaN;
 
 
    对于内置的{{jsxref("Math")}}数学常项和函数也有一些属性和方法。 比方说， Math对象的 PI 属性会有属性值 pi (3.141...)，你可以像这样调用它：
    
 
-
    Math.PI // π
+
    Math.PI // π
 
    
 
 
    同理，标准数学函数也是Math的方法。 这些包括三角函数​​，对数，指数，和其他函数。比方说你想使用三角函数 sin， 你可以这么写：
    
 
-
    Math.sin(1.56)
+
    Math.sin(1.56)
 
    
 
 
    需要注意的是Math的所有三角函数参数都是弧度制。
    
@@ -312,7 +312,7 @@ var notANum = Number.NaN;
 
 
    创建一个日期对象：
    
 
-
    var dateObjectName = new Date([parameters]);
+
    var dateObjectName = new Date([parameters]);
 
    
 
 
    这里的 dateObjectName 对象是所创建的Date对象的一个名字，它可以成为一个新的对象或者已存在的其他对象的一个属性。
    
@@ -352,7 +352,7 @@ var notANum = Number.NaN;
 
 
    例如, 假设你定义了如下日期：
    
 
-
    var Xmas95 = new Date("December 25, 1995");
+
    var Xmas95 = new Date("December 25, 1995");
 
    
 
 
    Then Xmas95.getMonth() 返回 11, and Xmas95.getFullYear() 返回 1995.
    
@@ -361,7 +361,7 @@ var notANum = Number.NaN;
 
 
    例如，以下代码展示了今年剩下的天数：
    
 
-
    var today = new Date();
+
    var today = new Date();
 var endYear = new Date(1995, 11, 31, 23, 59, 59, 999); // 设置日和月，注意，月份是0-11
 endYear.setFullYear(today.getFullYear()); // 把年设置为今年
 var msPerDay = 24 * 60 * 60 * 1000; // 每天的毫秒数
@@ -373,7 +373,7 @@ var daysLeft = Math.round(daysLeft); //返回今年剩下的天数
 
 
    parse方法对于从日期字符串赋值给现有的Date对象很有用，例如：以下代码使用parse和setTime分配了一个日期值给IPOdate对象：
    
 
-
    var IPOdate = new Date();
+
    var IPOdate = new Date();
 IPOdate.setTime(Date.parse("Aug 9, 1995"));
 
    
 
@@ -381,7 +381,7 @@ IPOdate.setTime(Date.parse("Aug 9, 1995"));
 
 
    在下边的例子中，JSClock()函数返回了用数字时钟格式的时间：
    
 
-
    function JSClock() {
+
    function JSClock() {
   var time = new Date();
   var hour = time.getHours();
   var minute = time.getMinutes();
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 b7468ef5be..0d3757acd6 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
@@ -140,7 +140,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions/Assertions
 
 
    一般边界类型概述示例
    
 
-
    // 使用 正则表达式边界修复错误字符串
+
    // 使用 正则表达式边界修复错误字符串
 buggyMultiline = `tey, ihe light-greon apple
 tangs on ihe greon traa`;
 
@@ -164,7 +164,7 @@ console.log(4, fixedMultiline); // 修复  'greon'  不影响'on'.
    
 
 
    使用 ^匹配输入的开头。在这个例子中，我们可以通过 /^A/ 正则表达式得到以A开头的水果。为了选择合适的水果，我们可以使用带有箭头函数的过滤方法.
    
 
-
    let fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
+
    let fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
 
 // 使用正则 /^A/ 选择以'A'开头的水果.
 // 这里的 '^' 只有一种含义: 匹配输入的开头.
@@ -174,7 +174,7 @@ console.log(fruitsStartsWithA); // [ 'Apple', 'Avocado' ]
    
 
 
    在第二个示例中，^用于在输入的开始处匹配，以及在内部使用时用于创建否定或被补充的字符集 组和范围.
    
 
-
    let fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
+
    let fruits = ["Apple", "Watermelon", "Orange", "Avocado", "Strawberry"];
 
 // 使用正则 /^[^A]/ 选择 不是以 ‘A’ 开头的水果
 // 在这个例子中，“^” 控件符号表示两种含义:
@@ -187,7 +187,7 @@ console.log(fruitsStartsWithNotA); // [ 'Watermelon', 'Orange', 'Strawberry' ]匹配字边界
 
-
    let fruitsWithDescription = ["Red apple", "Orange orange", "Green Avocado"];
+
    let fruitsWithDescription = ["Red apple", "Orange orange", "Green Avocado"];
 
 // 选择包含以 “en” 或 “ed” 结尾的单词的描述:
 let enEdSelection = fruitsWithDescription.filter(descr => /(en|ed)\b/.test(descr));
@@ -196,7 +196,7 @@ console.log(enEdSelection); // [ 'Red apple', 'Green Avocado' ]
    
 
 
    向前断言
    
 
-
    // JS 向前断言 x(?=y) 匹配被 y 跟随的 x
+
    // JS 向前断言 x(?=y) 匹配被 y 跟随的 x
 
 let regex = /First(?= test)/g;
 
@@ -209,13 +209,13 @@ console.log('This is a First peach in a month.'.match(regex)); // null
    
 
 
    例如, /\d+(?!\.)/ 匹配没有被小数点跟随且至少有一位的数字。 /\d+(?!\.)/.exec('3.141') 匹配 "141" 而不是 "3" 
    
 
-
    console.log(/\d+(?!\.)/g.exec('3.141')); // [ '141', index: 2, input: '3.141' ]
    
+
    console.log(/\d+(?!\.)/g.exec('3.141')); // [ '141', index: 2, input: '3.141' ]
    
 
 
    不同含义的'?!'：断言和范围的组合用法
    
 
 
    不同含义的?! 结合使用 断言  /x(?!y)/ 和  范围 [^?!].
    
 
-
    let orangeNotLemon = "Do you want to have an orange? Yes, I do not want to have a lemon!";
+
    let orangeNotLemon = "Do you want to have an orange? Yes, I do not want to have a lemon!";
 
 let selectNotLemonRegex = /[^?!]+have(?! a lemon)[^?!]+[?!]/gi
 console.log(orangeNotLemon.match(selectNotLemonRegex)); // [ 'Do you want to have an orange?' ]
@@ -225,7 +225,7 @@ console.log(orangeNotLemon.match(selectNotOrangeRegex)); // [ ' Yes, I do not wa
 
 
    向后断言
    
 
-
    let oranges = ['ripe orange A ', 'green orange B', 'ripe orange C',];
+
    let oranges = ['ripe orange A ', 'green orange B', 'ripe orange C',];
 
 let ripe_oranges = oranges.filter( fruit => fruit.match(/(?<=ripe )orange/));
 console.log(ripe_oranges); // [ 'ripe orange A ', 'ripe orange C' ]
    
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 26b1f4ee4a..80f9181f89 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
@@ -144,7 +144,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions/Character_Classes
 
 
    Looking for a series of digits
    
 
-
    var randomData = "015 354 8787 687351 3512 8735";
+
    var randomData = "015 354 8787 687351 3512 8735";
 var regexpFourDigits = /\b\d{4}\b/g;
 // \b indicates a boundary (i.e. do not start matching in the middle of a word)
 // \d{4} indicates a digit, four times
@@ -157,7 +157,7 @@ console.table(randomData.match(regexpFourDigits));
 
 
    Looking for a word (from the latin alphabet) starting with A
    
 
-
    var aliceExcerpt = "I’m sure I’m not Ada,’ she said, ‘for her hair goes in such long ringlets, and mine doesn’t go in ringlets at all.";
+
    var aliceExcerpt = "I’m sure I’m not Ada,’ she said, ‘for her hair goes in such long ringlets, and mine doesn’t go in ringlets at all.";
 var regexpWordStartingWithA = /\b[aA]\w+/g;
 // \b indicates a boundary (i.e. do not start matching in the middle of a word)
 // [aA] indicates the letter a or A
@@ -171,7 +171,7 @@ console.table(aliceExcerpt.match(regexpWordStartingWithA));
 
 
    Instead of the Latin alphabet, we can use a range of Unicode characters to identify a word (thus being able to deal with text in other languages like Russian or Arabic). The "Basic Multilingual Plane" of Unicode contains most of the characters used around the world and we can use character classes and ranges to match words written with those characters.
    
 
-
    var nonEnglishText = "Приключения Алисы в Стране чудес";
+
    var nonEnglishText = "Приключения Алисы в Стране чудес";
 var regexpBMPWord = /([\u0000-\u0019\u0021-\uFFFF])+/gu;
 // BMP goes through U+0000 to U+FFFF but space is U+0020
 
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 9a73c9b8ef..8aac5048dc 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
@@ -94,7 +94,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges
 
 
    计算元音数
    
 
-
    var aliceExcerpt = "There was a long silence after this, and Alice could only hear whispers now and then.";
+
    var aliceExcerpt = "There was a long silence after this, and Alice could only hear whispers now and then.";
 var regexpVowels = /[aeiouy]/g;
 
 console.log("Number of vowels:", aliceExcerpt.match(regexpVowels).length);
@@ -102,7 +102,7 @@ console.log("Number of vowels:", aliceExcerpt.match(regexpVowels).length);
 
 
    使用 组
    
 
-
    let personList = `First_Name: John, Last_Name: Doe
+
    let personList = `First_Name: John, Last_Name: Doe
 First_Name: Jane, Last_Name: Smith`;
 
 let regexpNames =  /First_Name: (\w+), Last_Name: (\w+)/mg;
@@ -114,7 +114,7 @@ do {
 
 
    使用命名组
    
 
-
    let users= `姓氏: 李, 名字: 雷
+
    let users= `姓氏: 李, 名字: 雷
 姓氏: 韩, 名字: 梅梅`;
 
 let regexpNames =  /姓氏: (?<first>.+), 名字: (?<last>.+)/mg;
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 4d88167c80..b38f643ced 100644
--- a/files/zh-cn/web/javascript/guide/regular_expressions/index.html
+++ b/files/zh-cn/web/javascript/guide/regular_expressions/index.html
@@ -21,14 +21,14 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
 
 
    使用一个正则表达式字面量，其由包含在斜杠之间的模式组成，如下所示：
    
 
-
    var re = /ab+c/;
+
    var re = /ab+c/;
 
    
 
 
    脚本加载后，正则表达式字面量就会被编译。当正则表达式保持不变时，使用此方法可获得更好的性能。
    
 
 
    或者调用RegExp对象的构造函数，如下所示：
    
 
-
    var re = new RegExp("ab+c");
+
    var re = new RegExp("ab+c");
 
    
 
 
    在脚本运行过程中，用构造函数创建的正则表达式会被编译。如果正则表达式将会改变，或者它将会从用户输入等来源中动态地产生，就需要使用构造函数来创建正则表达式。
    
@@ -384,7 +384,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
 
 
    将用户输入转义为正则表达式中的一个字面字符串, 可以通过简单的替换来实现：
    
 
-
    function escapeRegExp(string) {
+
    function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   //$&表示整个被匹配的字符串
 }
    
@@ -451,13 +451,13 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions
 
 
    在接下来的例子中，脚本将使用exec方法在一个字符串中查找一个匹配。
    
 
-
    var myRe = /d(b+)d/g;
+
    var myRe = /d(b+)d/g;
 var myArray = myRe.exec("cdbbdbsbz");
 
    
 
 
    如果你不需要访问正则表达式的属性，这个脚本通过另一个方法来创建myArray：
    
 
-
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
+
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
 // 和 "cdbbdbsbz".match(/d(b+)d/g); 相似。
 // 但是 "cdbbdbsbz".match(/d(b+)d/g) 输出数组 [ "dbbd" ]，
 // 而 /d(b+)d/g.exec('cdbbdbsbz') 输出数组 [ "dbbd", "bb", index: 1, input: "cdbbdbsbz" ].
@@ -466,7 +466,7 @@ var myArray = myRe.exec("cdbbdbsbz");
 
 
    如果你想通过一个字符串构建正则表达式，那么这个脚本还有另一种方法：
    
 
-
    var myRe = new RegExp("d(b+)d", "g");
+
    var myRe = new RegExp("d(b+)d", "g");
 var myArray = myRe.exec("cdbbdbsbz");
 
    
 
@@ -520,25 +520,25 @@ var myArray = myRe.exec("cdbbdbsbz");
 
 
    如这个例子中的第二种形式所示，你可以使用对象初始器创建一个正则表达式实例，但不分配给变量。如果你这样做，那么，每一次使用时都会创建一个新的正则表达式实例。因此，如果你不把正则表达式实例分配给一个变量，你以后将不能访问这个正则表达式实例的属性。例如，假如你有如下脚本：
    
 
-
    var myRe = /d(b+)d/g;
+
    var myRe = /d(b+)d/g;
 var myArray = myRe.exec("cdbbdbsbz");
 console.log("The value of lastIndex is " + myRe.lastIndex);
 
    
 
 
    这个脚本输出如下：
    
 
-
    The value of lastIndex is 5
+
    The value of lastIndex is 5
 
    
 
 
    然而，如果你有如下脚本：
    
 
-
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
+
    var myArray = /d(b+)d/g.exec("cdbbdbsbz");
 console.log("The value of lastIndex is " + /d(b+)d/g.lastIndex);
 
    
 
 
    它显示为：
    
 
-
    The value of lastIndex is 0
+
    The value of lastIndex is 0
 
    
 
 
    当发生/d(b+)d/g使用两个不同状态的正则表达式对象，lastIndex属性会得到不同的值。如果你需要访问一个正则表达式的属性，则需要创建一个对象初始化生成器，你应该首先把它赋值给一个变量。
    
@@ -551,7 +551,7 @@ console.log("The value of lastIndex is " + /d(b+)d/g.lastIndex);
 
 
    下面的脚本使用replace()方法来转换字符串中的单词。在匹配到的替换文本中，脚本使用替代的$ 1,$ 2表示第一个和第二个括号的子字符串匹配。
    
 
-
    var re = /(\w+)\s(\w+)/;
+
    var re = /(\w+)\s(\w+)/;
 var str = "John Smith";
 var newstr = str.replace(re, "$2, $1");
 console.log(newstr);
@@ -601,19 +601,19 @@ console.log(newstr);
 
 
    为了在正则表达式中包含标志，请使用以下语法：
    
 
-
    var re = /pattern/flags;
+
    var re = /pattern/flags;
 
    
 
 
    或者
    
 
-
    var re = new RegExp("pattern", "flags");
+
    var re = new RegExp("pattern", "flags");
 
    
 
 
    值得注意的是，标志是一个正则表达式的一部分，它们在接下来的时间将不能添加或删除。
    
 
 
    例如，re = /\w+\s/g 将创建一个查找一个或多个字符后有一个空格的正则表达式，或者组合起来像此要求的字符串。
    
 
-
    var re = /\w+\s/g;
+
    var re = /\w+\s/g;
 var str = "fee fi fo fum";
 var myArray = str.match(re);
 console.log(myArray);
@@ -623,19 +623,19 @@ console.log(myArray);
 
 
    这段代码将输出 ["fee ", "fi ", "fo "]。在这个例子中，你可以将：
    
 
-
    var re = /\w+\s/g;
+
    var re = /\w+\s/g;
 
    
 
 
    替换成：
    
 
-
    var re = new RegExp("\\w+\\s", "g");
+
    var re = new RegExp("\\w+\\s", "g");
 
    
 
 
    并且能获取到相同的结果。
    
 
 
    使用.exec()方法时，与'g'标志关联的行为是不同的。 （“class”和“argument”的作用相反：在.match()的情况下，字符串类（或数据类型）拥有该方法，而正则表达式只是一个参数，而在.exec()的情况下，它是拥有该方法的正则表达式，其中字符串是参数。对比str.match(re)与re.exec(str) ), 'g'标志与.exec()方法一起使用获得迭代进展。
    
 
-
    var xArray; while(xArray = re.exec(str)) console.log(xArray);
+
    var xArray; while(xArray = re.exec(str)) console.log(xArray);
 // produces:
 // ["fee ", index: 0, input: "fee fi fo fum"]
 // ["fi ", index: 4, input: "fee fi fo fum"]
@@ -651,7 +651,7 @@ console.log(myArray);
 
 
    以下例子解释了正则表达式的构成和 string.split() 以及 string.replace()的用途。它会整理一个只有粗略格式的含有全名（名字首先出现）的输入字符串，这个字符串被空格、换行符和一个分号分隔。最终，它会颠倒名字顺序（姓氏首先出现）和list的类型。
    
 
-
    // 下面这个姓名字符串包含了多个空格和制表符，
+
    // 下面这个姓名字符串包含了多个空格和制表符，
 // 且在姓和名之间可能有多个空格和制表符。
 var names = "Orange Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";
 
@@ -716,7 +716,7 @@ console.log(output.join("\n"));
 
 
    当用户按下 Enter 设置 RegExp.input，这些变化也能被激活。
    
 
-
    <!DOCTYPE html>
+
    <!DOCTYPE html>
 <html>
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
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 d705953a69..1173553f2d 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
@@ -85,14 +85,14 @@ original_slug: Web/JavaScript/Guide/Regular_Expressions/量词
 
 
    重复模式
    
 
-
    var wordEndingWithAs = /\w+a+/;
+
    var wordEndingWithAs = /\w+a+/;
 var delicateMessage = "This is Spartaaaaaaa";
 
 console.table(delicateMessage.match(wordEndingWithAs)); // [ "Spartaaaaaaa" ]
    
 
 
    计算字符集
    
 
-
    var singleLetterWord = /\b\w\b/g;
+
    var singleLetterWord = /\b\w\b/g;
 var notSoLongWord = /\b\w{1,6}\b/g;
 var loooongWord = /\b\w{13,}\b/g;
 
@@ -105,7 +105,7 @@ console.table(sentence.match(loooongWord));      // ["multiplication"]可选可
 
 
     可选字符
    
 
-
    var britishText = "He asked his neighbour a favour.";
+
    var britishText = "He asked his neighbour a favour.";
 var americanText = "He asked his neighbor a favor.";
 
 var regexpEnding = /\w+ou?r/g;
@@ -123,7 +123,7 @@ console.table(americanText.match(regexpEnding));
 
 
    贪婪 与 非贪婪的
    
 
-
    var text = "I must be getting somewhere near the centre of the earth.";
+
    var text = "I must be getting somewhere near the centre of the earth.";
 var greedyRegexp = /[\w ]+/;
 // [\w ]      a letter of the latin alphabet or a whitespace
 //      +     one or several times
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 db7312bea4..973820343c 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
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escape
 
 
 
-
    // Non-binary 属性
+
    // Non-binary 属性
 \p{Unicode属性值}
 \p{Unicode属性名=Unicode属性值}
 
@@ -66,7 +66,7 @@ translation_of: Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escape
 
 
    它们可匹配字母、数字、符号、标点符号、空格等等。一般类别详见 the Unicode specification.
    
 
-
    // finding all the letters of a text
+
    // finding all the letters of a text
 let story = "It’s the Cheshire Cat: now I shall have somebody to talk to.";
 
 // Most explicit form
@@ -88,7 +88,7 @@ story.match(/\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}/gu);
 
 
    比如，A 属于 拉丁文，ε 属于希腊(Greek)文。
    
 
-
    let mixedCharacters = "aεЛ";
+
    let mixedCharacters = "aεЛ";
 
 // Using the canonical "long" name of the script
 mixedCharacters.match(/\p{Script=Latin}/u); // a
@@ -104,7 +104,7 @@ mixedCharacters.match(/\p{Sc=Cyrillic}/u); // Л
 
 
    某字符用于多种文字时，Script 优先匹配最主要使用那个字符的文字。如果想要根据非主要的文字进行匹配，我们可以使用 Script_Extensions 属性 (简写为Scx).
    
 
-
    // ٢ is the digit 2 in Arabic-Indic notation
+
    // ٢ is the digit 2 in Arabic-Indic notation
 // while it is predominantly written within the Arabic script
 // it can also be written in the Thaana script
 
@@ -121,7 +121,7 @@ mixedCharacters.match(/\p{Sc=Cyrillic}/u); // Л
 
 
    Unicode 属性转义 categories 包含更多字符， \p{Letter} 或 \p{Number} 将会适用于任何文字。
    
 
-
    // Trying to use ranges to avoid \w limitations:
+
    // Trying to use ranges to avoid \w limitations:
 
 const nonEnglishText = "Приключения Алисы в Стране чудес";
 const regexpBMPWord = /([\u0000-\u0019\u0021-\uFFFF])+/gu;
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 fbe34d2cd6..b0f8b412fe 100644
--- a/files/zh-cn/web/javascript/guide/text_formatting/index.html
+++ b/files/zh-cn/web/javascript/guide/text_formatting/index.html
@@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Guide/Text_formatting
 
 
    可以使用单引号或双引号创建简单的字符串:
    
 
-
    'foo'
+
    'foo'
 "bar"
    
 
 
    可以使用转义序列来创建更复杂的字符串:
    
@@ -27,14 +27,14 @@ translation_of: Web/JavaScript/Guide/Text_formatting
 
 
    \x之后的数值将被认为是一个16进制数.
    
 
-
    '\xA9' // "©"
+
    '\xA9' // "©"
 
    
 
 
    Unicode转义序列
    
 
 
    Unicode转义序列在\u之后需要至少4个字符.
    
 
-
    '\u00A9' // "©"
    
+
    '\u00A9' // "©"
    
 
 
    Unicode字元逸出
    
 
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Guide/Text_formatting
 
 
    请参阅 {{jsxref("String.fromCodePoint()")}} 或 {{jsxref("String.prototype.codePointAt()")}}。
    
 
-
    '\u{2F804}'
+
    '\u{2F804}'
 
 // the same with simple Unicode escapes
 '\uD87E\uDC04'
    
@@ -51,7 +51,7 @@ translation_of: Web/JavaScript/Guide/Text_formatting
 
 
    {{jsxref("String")}} 对象是对原始string类型的封装 .
    
 
-
    const foo = new String('foo'); // 创建一个 String 对象
+
    const foo = new String('foo'); // 创建一个 String 对象
 console.log(foo); // 输出: [String: 'foo']
 typeof foo; // 返回 'object'
    
 
@@ -59,14 +59,14 @@ typeof foo; // 返回 'object'
    
 
 
    除非必要, 应该尽量使用 String 字面值，因为String对象的某些行为可能并不与直觉一致。举例：
    
 
-
    const firstString = '2 + 2'; //创建一个字符串字面量
+
    const firstString = '2 + 2'; //创建一个字符串字面量
 const secondString = new String('2 + 2'); // 创建一个字符串对象
 eval(firstString); // 返回数字 4
 eval(secondString); // 返回包含 "2 + 2" 的字符串对象
    
 
 
    String 对象有一个属性 length，标识了字符串中 UTF-16 的码点个数。举例，下面的代码把 13 赋值给了helloLength，因为 "Hello, World!" 包含 13 个字符，每个字符用一个 UTF-16 码点表示。你可以通过数组的方式访问每一个码点，但你不能修改每个字符，因为字符串是不变的类数组对象： 
    
 
-
    const hello = 'Hello, World!';
+
    const hello = 'Hello, World!';
 const helloLength = hello.length;
 hello[0] = 'L'; // 无效，因为字符串是不变的
 hello[0]; // 返回 "H"
    
@@ -155,14 +155,14 @@ hello[0]; // 返回 "H"
    
 
 
    源代码中插入的任何新行开始字符都作为模板字符串的内容. 使用一般的字符串时, 为了创建多行的字符串不得不用如下语法:
    
 
-
    console.log("string text line 1\n\
+
    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
+
    console.log(`string text line 1
 string text line 2`);
 // "string text line 1
 // string text line 2"
    
@@ -171,14 +171,14 @@ string text line 2`);
 
 
    为了在一般的字符串中嵌入表达式, 需要使用如下语法:
    
 
-
    const five = 5;
+
    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 five = 5;
 const ten = 10;
 console.log(`Fifteen is ${five + ten} and not ${2 * five + ten}.`);
 // "Fifteen is 15 and not 20."
    
@@ -193,7 +193,7 @@ console.log(`Fifteen is ${five + ten} and not ${2 * five + ten}.`);
 
 
    {{jsxref("DateTimeFormat")}} 对象在日期和时间的格式化方面很有用. 下面的代码把一个日期格式化为美式英语格式. (不同时区结果不同.)
    
 
-
    const msPerDay = 24 * 60 * 60 * 1000;
+
    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年
@@ -211,7 +211,7 @@ console.log(americanDateTime(july172014)); // 07/16/14, 5:00 PM PDT
 
 
    {{jsxref("NumberFormat")}} 对象在数字的格式化方面很有用, 比如货币数量值.
    
 
-
    var gasPrice = new Intl.NumberFormat("en-US",
+
    var gasPrice = new Intl.NumberFormat("en-US",
                         { style: "currency", currency: "USD",
                           minimumFractionDigits: 3 });
 
@@ -229,7 +229,7 @@ console.log(hanDecimalRMBInChina.format(1314.25)); // ￥ 一,三一四.二五
 
 
    举例, 德语中有两种不同的排序方式 电话本（phonebook） 和 字典（dictionary）. 电话本排序强调发音, 比如在排序前 “ä”, “ö”等被扩展为 “ae”, “oe”等发音.
    
 
-
    var names = ["Hochberg", "Hönigswald", "Holzman"];
+
    var names = ["Hochberg", "Hönigswald", "Holzman"];
 
 var germanPhonebook = new Intl.Collator("de-DE-u-co-phonebk");
 
@@ -240,7 +240,7 @@ console.log(names.sort(germanPhonebook.compare).join(", "));
 
 
    有些德语词包含变音, 所以在字典中忽略变音进行排序是合理的 (除非待排序的单词只有变音部分不同: schon 先于 schön).
    
 
-
    var germanDictionary = new Intl.Collator("de-DE-u-co-dict");
+
    var germanDictionary = new Intl.Collator("de-DE-u-co-dict");
 
 // as if sorting ["Hochberg", "Honigswald", "Holzman"]:
 console.log(names.sort(germanDictionary.compare).join(", "));
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 c714260d7f..22a0163216 100644
--- a/files/zh-cn/web/javascript/guide/using_promises/index.html
+++ b/files/zh-cn/web/javascript/guide/using_promises/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Guide/Using_promises
 
 
    以下为使用 createAudioFileAsync() 的示例：
    
 
-
    // 成功的回调函数
+
    // 成功的回调函数
 function successCallback(result) {
   console.log("音频文件创建成功: " + result);
 }
@@ -36,13 +36,13 @@ createAudioFileAsync(audioSettings, successCallback, failureCallback)
    
 
 
    如果函数 createAudioFileAsync() 被重写为返回 Promise 的形式，那么我们可以像下面这样简单地调用它：
    
 
-
    const promise = createAudioFileAsync(audioSettings);
+
    const promise = createAudioFileAsync(audioSettings);
 promise.then(successCallback, failureCallback);
 
    
 
 
    或者简写为：
    
 
-
    createAudioFileAsync(audioSettings).then(successCallback, failureCallback);
+
    createAudioFileAsync(audioSettings).then(successCallback, failureCallback);
 
    
 
 
    我们把这个称为 异步函数调用，这种形式有若干优点，下面我们将会逐一讨论。
    
@@ -65,13 +65,13 @@ promise.then(successCallback, failureCallback);
 
 
    见证奇迹的时刻：then() 函数会返回一个和原来不同的新的 Promise：
    
 
-
    const promise = doSomething();
+
    const promise = doSomething();
 const promise2 = promise.then(successCallback, failureCallback);
 
    
 
 
    或者
    
 
-
    const promise2 = doSomething().then(successCallback, failureCallback);
    
+
    const promise2 = doSomething().then(successCallback, failureCallback);
    
 
 
    promise2 不仅表示 doSomething() 函数的完成，也代表了你传入的 successCallback 或者 failureCallback 的完成，这两个函数也可以返回一个 Promise 对象，从而形成另一个异步操作，这样的话，在 promise2 上新增的回调函数会排在这个 Promise 对象的后面。
    
 
@@ -79,7 +79,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    在过去，要想做多重的异步操作，会导致经典的回调地狱：
    
 
-
    doSomething(function(result) {
+
    doSomething(function(result) {
   doSomethingElse(result, function(newResult) {
     doThirdThing(newResult, function(finalResult) {
       console.log('Got the final result: ' + finalResult);
@@ -90,7 +90,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    现在，我们可以把回调绑定到返回的 Promise 上，形成一个 Promise 链：
    
 
-
    doSomething().then(function(result) {
+
    doSomething().then(function(result) {
   return doSomethingElse(result);
 })
 .then(function(newResult) {
@@ -104,7 +104,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    then 里的参数是可选的，catch(failureCallback) 是 then(null, failureCallback) 的缩略形式。如下所示，我们也可以用箭头函数来表示：
    
 
-
    doSomething()
+
    doSomething()
 .then(result => doSomethingElse(result))
 .then(newResult => doThirdThing(newResult))
 .then(finalResult => {
@@ -119,7 +119,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    有可能会在一个回调失败之后继续使用链式操作，即，使用一个 catch，这对于在链式操作中抛出一个失败之后，再次进行新的操作会很有用。请阅读下面的例子：
    
 
-
    new Promise((resolve, reject) => {
+
    new Promise((resolve, reject) => {
     console.log('初始化');
 
     resolve();
@@ -139,7 +139,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    输出结果如下：
    
 
-
    初始化
+
    初始化
 执行“那个”
 执行“这个”，无论前面发生了什么
 
    
@@ -150,7 +150,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    在之前的回调地狱示例中，你可能记得有 3 次 failureCallback 的调用，而在 Promise 链中只有尾部的一次调用。
    
 
-
    doSomething()
+
    doSomething()
 .then(result => doSomethingElse(result))
 .then(newResult => doThirdThing(newResult))
 .then(finalResult => console.log(`Got the final result: ${finalResult}`))
@@ -160,7 +160,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    通常，一遇到异常抛出，浏览器就会顺着 Promise 链寻找下一个 onRejected 失败回调函数或者由 .catch() 指定的回调函数。这和以下同步代码的工作原理（执行过程）非常相似。
    
 
-
    try {
+
    try {
   let result = syncDoSomething();
   let newResult = syncDoSomethingElse(result);
   let finalResult = syncDoThirdThing(newResult);
@@ -172,7 +172,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    在 ECMAScript 2017 标准的 async/await 语法糖中，这种异步代码的对称性得到了极致的体现：
    
 
-
    async function foo() {
+
    async function foo() {
   try {
     const result = await doSomething();
     const newResult = await doSomethingElse(result);
@@ -204,7 +204,7 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    一个特别有用的例子：当你使用 {{Glossary("Node.js")}} 时，有些依赖模块可能会有未被处理的 rejected promises，这些都会在运行时打印到控制台。你可以在自己的代码中捕捉这些信息，然后添加与 {{domxref("Window.unhandledrejection_event", "unhandledrejection")}} 相应的处理函数来做分析和处理，或只是为了让你的输出更整洁。举例如下：
    
 
-
    window.addEventListener("unhandledrejection", event => {
+
    window.addEventListener("unhandledrejection", event => {
   /* 你可以在这里添加一些代码，以便检查
      event.promise 中的 promise 和
      event.reason 中的 rejection 原因 */
@@ -223,14 +223,14 @@ const promise2 = promise.then(successCallback, failureCallback);
 
 
    理想状态下，所有的异步函数都已经返回 Promise 了。但有一些 API 仍然使用旧方式来传入的成功（或者失败）的回调。典型的例子就是 {{domxref("WindowTimers.setTimeout", "setTimeout()")}} 函数：
    
 
-
    setTimeout(() => saySomething("10 seconds passed"), 10000);
+
    setTimeout(() => saySomething("10 seconds passed"), 10000);
 
    
 
 
    混用旧式回调和 Promise 可能会造成运行时序问题。如果 saySomething 函数失败了，或者包含了编程错误，那就没有办法捕获它了。这得怪 setTimeout。
    
 
 
    幸运地是，我们可以用 Promise 来封装它。最好的做法是，将这些有问题的函数封装起来，留在底层，并且永远不要再直接调用它们：
    
 
-
    const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
+
    const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
 
 wait(10000).then(() => saySomething("10 seconds")).catch(failureCallback);
 
    
@@ -245,33 +245,33 @@ wait(10000).then(() => saySomething("10 seconds")).catch(failureCallback);
 
 
    我们可以发起并行操作，然后等多个操作全部结束后进行下一步操作，如下：
    
 
-
    Promise.all([func1(), func2(), func3()])
+
    Promise.all([func1(), func2(), func3()])
 .then(([result1, result2, result3]) => { /* use result1, result2 and result3 */ });
    
 
 
    可以使用一些聪明的 JavaScript 写法实现时序组合：
    
 
-
    [func1, func2, func3].reduce((p, f) => p.then(f), Promise.resolve())
+
    [func1, func2, func3].reduce((p, f) => p.then(f), Promise.resolve())
 .then(result3 => { /* use result3 */ });
    
 
 
    通常，我们递归调用一个由异步函数组成的数组时，相当于一个 Promise 链：
    
 
-
    Promise.resolve().then(func1).then(func2).then(func3);
    
+
    Promise.resolve().then(func1).then(func2).then(func3);
    
 
 
    我们也可以写成可复用的函数形式，这在函数式编程中极为普遍：
    
 
-
    const applyAsync = (acc,val) => acc.then(val);
+
    const applyAsync = (acc,val) => acc.then(val);
 const composeAsync = (...funcs) => x => funcs.reduce(applyAsync, Promise.resolve(x));
 
    
 
 
    composeAsync() 函数将会接受任意数量的函数作为其参数，并返回一个新的函数，该函数接受一个通过 composition pipeline 传入的初始值。这对我们来说非常有益，因为任一函数可以是异步或同步的，它们能被保证按顺序执行：
    
 
-
    const transformData = composeAsync(func1, func2, func3);
+
    const transformData = composeAsync(func1, func2, func3);
 const result3 = transformData(data);
 
    
 
 
    在 ECMAScript 2017 标准中, 时序组合可以通过使用 async/await 而变得更简单：
    
 
-
    let result;
+
    let result;
 for (const f of [func1, func2, func3]) {
   result = await f(result);
 }
@@ -281,13 +281,13 @@ for (const f of [func1, func2, func3]) {
 
 
    为了避免意外，即使是一个已经变成 resolve 状态的 Promise，传递给 then() 的函数也总是会被异步调用：
    
 
-
    Promise.resolve().then(() => console.log(2));
+
    Promise.resolve().then(() => console.log(2));
 console.log(1); // 1, 2
 
    
 
 
    传递到 then() 中的函数被置入到一个微任务队列中，而不是立即执行，这意味着它是在 JavaScript 事件队列的所有运行时结束了，且事件队列被清空之后，才开始执行：
    
 
-
    const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
+
    const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
 
 wait().then(() => console.log(4));
 Promise.resolve().then(() => console.log(2)).then(() => console.log(3));
@@ -299,7 +299,7 @@ console.log(1); // 1, 2, 3, 4
    
 
 
    嵌套 Promise 是一种可以限制 catch 语句的作用域的控制结构写法。明确来说，嵌套的 catch 仅捕捉在其之前同时还必须是其作用域的 failureres，而捕捉不到在其链式以外或者其嵌套域以外的 error。如果使用正确，那么可以实现高精度的错误修复。
    
 
-
    doSomethingCritical()
+
    doSomethingCritical()
 .then(result => doSomethingOptional()
   .then(optionalResult => doSomethingExtraNice(optionalResult))
   .catch(e => {console.log(e.message)})) // 即使有异常也会忽略，继续运行;(最后会输出)
@@ -314,7 +314,7 @@ console.log(1); // 1, 2, 3, 4
    
 
 
    在编写 Promise 链时，需要注意以下示例中展示的几个错误：
    
 
-
    // 错误示例，包含 3 个问题！
+
    // 错误示例，包含 3 个问题！
 
 doSomething().then(function(result) {
   doSomethingElse(result) // 没有返回 Promise 以及没有必要的嵌套 Promise
@@ -330,7 +330,7 @@ doSomething().then(function(result) {
 
 
    一个好的经验法则是总是返回或终止 Promise 链，并且一旦你得到一个新的 Promise，返回它。下面是修改后的平面化的代码：
    
 
-
    doSomething()
+
    doSomething()
 .then(function(result) {
   return doSomethingElse(result);
 })
diff --git a/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html b/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html
index b83c68af65..57f9c2bf2a 100644
--- a/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html
+++ b/files/zh-cn/web/javascript/inheritance_and_the_prototype_chain/index.html
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Inheritance_and_the_prototype_chain
 
 
    这里演示当尝试访问属性时会发生什么：
    
 
-
    // 让我们从一个函数里创建一个对象o，它自身拥有属性a和b的：
+
    // 让我们从一个函数里创建一个对象o，它自身拥有属性a和b的：
 let f = function () {
    this.a = 1;
    this.b = 2;
@@ -96,7 +96,7 @@ console.log(o.d); // undefined
 
 
    当继承的函数被调用时，this 指向的是当前继承的对象，而不是继承的函数所在的原型对象。
    
 
-
    var o = {
+
    var o = {
   a: 2,
   m: function(){
     return this.a + 1;
@@ -121,7 +121,7 @@ console.log(p.m()); // 5
 
 
    正如之前提到的，在 JavaScript 中，函数（function）是允许拥有属性的。所有的函数会有一个特别的属性 —— prototype 。请注意，以下的代码是独立的（出于严谨，假定页面没有其他的JavaScript代码）。为了最佳的学习体验，我们强烈建议阁下打开浏览器的控制台（在Chrome和火狐浏览器中，按Ctrl+Shift+I即可），进入“console”选项卡，然后把如下的JavaScript代码复制粘贴到窗口中，最后通过按下回车键运行代码。
    
 
-
    function doSomething(){}
+
    function doSomething(){}
 console.log( doSomething.prototype );
 // 和声明函数的方式无关，
 // JavaScript 中的函数永远有一个默认原型属性。
@@ -130,7 +130,7 @@ console.log( doSomething.prototype );
    
 
 
    在控制台显示的JavaScript代码块中，我们可以看到doSomething函数的一个默认属性prototype。而这段代码运行之后，控制台应该显示类似如下的结果：
    
 
-
    {
+
    {
     constructor: ƒ doSomething(),
     __proto__: {
         constructor: ƒ Object(),
@@ -145,13 +145,13 @@ console.log( doSomething.prototype );
    
 
 
    我们可以给doSomething函数的原型对象添加新属性，如下：
    
 
-
    function doSomething(){}
+
    function doSomething(){}
 doSomething.prototype.foo = "bar";
 console.log( doSomething.prototype );
    
 
 
    可以看到运行后的结果如下：
    
 
-
    {
+
    {
     foo: "bar",
     constructor: ƒ doSomething(),
     __proto__: {
@@ -169,7 +169,7 @@ console.log( doSomething.prototype );
    
 
 
    请尝试运行以下代码：
    
 
-
    function doSomething(){}
+
    function doSomething(){}
 doSomething.prototype.foo = "bar"; // add a property onto the prototype
 var doSomeInstancing = new doSomething();
 doSomeInstancing.prop = "some value"; // add a property onto the object
@@ -177,7 +177,7 @@ console.log( doSomeInstancing );
    
 
 
    运行的结果类似于以下的语句。
    
 
-
    {
+
    {
     prop: "some value",
     __proto__: {
         foo: "bar",
@@ -204,7 +204,7 @@ console.log( doSomeInstancing );
    
 
 
    让我们在控制台窗口中输入更多的代码，如下：
    
 
-
    function doSomething(){}
+
    function doSomething(){}
 doSomething.prototype.foo = "bar";
 var doSomeInstancing = new doSomething();
 doSomeInstancing.prop = "some value";
@@ -217,7 +217,7 @@ console.log("doSomething.prototype.foo:  " + doSomething.prototype.foo);
    
 
 
    结果如下：
    
 
-
    doSomeInstancing.prop:      some value
+
    doSomeInstancing.prop:      some value
 doSomeInstancing.foo:       bar
 doSomething.prop:           undefined
 doSomething.foo:            undefined
@@ -228,7 +228,7 @@ doSomething.prototype.foo:  bar
    
 
 
    使用语法结构创建的对象
    
 
-
    var o = {a: 1};
+
    var o = {a: 1};
 
 // o 这个对象继承了 Object.prototype 上面的所有属性
 // o 自身没有名为 hasOwnProperty 的属性
@@ -258,7 +258,7 @@ function f(){
 
 
    在 JavaScript 中，构造器其实就是一个普通的函数。当使用 new 操作符 来作用这个函数时，它就可以被称为构造方法（构造函数）。
    
 
-
    function Graph() {
+
    function Graph() {
   this.vertices = [];
   this.edges = [];
 }
@@ -277,7 +277,7 @@ var g = new Graph();
 
 
    ECMAScript 5 中引入了一个新方法：{{jsxref("Object.create()")}}。可以调用这个方法来创建一个新对象。新对象的原型就是调用 create 方法时传入的第一个参数：
    
 
-
    var a = {a: 1};
+
    var a = {a: 1};
 // a ---> Object.prototype ---> null
 
 var b = Object.create(a);
@@ -295,7 +295,7 @@ console.log(d.hasOwnProperty); // undefined, 因为d没有继承Object.prototype
 
 
    ECMAScript6 引入了一套新的关键字用来实现 class。使用基于类语言的开发人员会对这些结构感到熟悉，但它们是不同的。JavaScript 仍然基于原型。这些新的关键字包括 {{jsxref("Statements/class", "class")}}, {{jsxref("Classes/constructor", "constructor")}}，{{jsxref("Classes/static", "static")}}，{{jsxref("Classes/extends", "extends")}} 和 {{jsxref("Operators/super", "super")}}。
    
 
-
    "use strict";
+
    "use strict";
 
 class Polygon {
   constructor(height, width) {
@@ -325,7 +325,7 @@ var square = new Square(2);
    
 
 
    遍历对象的属性时，原型链上的每个可枚举属性都会被枚举出来。要检查对象是否具有自己定义的属性，而不是其原型链上的某个属性，则必须使用所有对象从 Object.prototype 继承的 hasOwnProperty 方法。下面给出一个具体的例子来说明它：
    
 
-
    console.log(g.hasOwnProperty('vertices'));
+
    console.log(g.hasOwnProperty('vertices'));
 // true
 
 console.log(g.hasOwnProperty('nope'));
@@ -365,7 +365,7 @@ console.log(g.__proto__.hasOwnProperty('addVertex'));
   
    
 
 
 
 
 
 
    
    New-initialization
    
-    
    +    
     function foo(){}
 foo.prototype = {
   foo_prop: "foo val"
@@ -384,7 +384,7 @@ console.log(inst.bar_prop);
    
   
    
    Object.create
    
-    
    +    
     function foo(){}
 foo.prototype = {
   foo_prop: "foo val"
@@ -400,7 +400,7 @@ console.log(inst.foo_prop);
 console.log(inst.bar_prop);
 
    
 
-    
    +    
     function foo(){}
 foo.prototype = {
   foo_prop: "foo val"
@@ -427,7 +427,7 @@ console.log(inst.bar_prop)
    
     
    Object.setPrototypeOf
    
    
    		
    
-    
    +    
     function foo(){}
 foo.prototype = {
   foo_prop: "foo val"
@@ -445,7 +445,7 @@ console.log(inst.foo_prop);
 console.log(inst.bar_prop);
 
    
 
-    
    +    
     function foo(){}
 foo.prototype = {
   foo_prop: "foo val"
@@ -467,7 +467,7 @@ console.log(inst.bar_prop)
    
   
    
    __proto__
    
-    
    +    
     function foo(){}
 foo.prototype = {
   foo_prop: "foo val"
@@ -483,7 +483,7 @@ console.log(inst.foo_prop);
 console.log(inst.bar_prop);
 
    
 
-    
    +    
     var inst = {
   __proto__: {
     bar_prop: "bar val",
@@ -517,17 +517,17 @@ console.log(inst.bar_prop)
    
 
 
    因此，当你执行：
    
 
-
    var o = new Foo();
    
+
    var o = new Foo();
    
 
 
    JavaScript 实际上执行的是：
    
 
-
    var o = new Object();
+
    var o = new Object();
 o.__proto__ = Foo.prototype;
 Foo.call(o);
    
 
 
    （或者类似上面这样的），然后，当你执行：
    
 
-
    o.someProp;
    
+
    o.someProp;
    
 
 
    它检查 o 是否具有 someProp 属性。如果没有，它会查找 Object.getPrototypeOf(o).someProp，如果仍旧没有，它会继续查找 Object.getPrototypeOf(Object.getPrototypeOf(o)).someProp。
    
 
@@ -543,7 +543,7 @@ Foo.call(o);
    
 
 
    B 继承自 A：
    
 
-
    function A(a){
+
    function A(a){
   this.varA = a;
 }
 
diff --git a/files/zh-cn/web/javascript/reference/classes/index.html b/files/zh-cn/web/javascript/reference/classes/index.html
index 3b0c5f408f..55bc4d0937 100644
--- a/files/zh-cn/web/javascript/reference/classes/index.html
+++ b/files/zh-cn/web/javascript/reference/classes/index.html
@@ -26,7 +26,7 @@ translation_of: Web/JavaScript/Reference/Classes
 
 
    定义类的一种方法是使用类声明。要声明一个类，你可以使用带有class关键字的类名（这里是“Rectangle”）。
    
 
-
    class Rectangle {
+
    class Rectangle {
   constructor(height, width) {
     this.height = height;
     this.width = width;
@@ -37,7 +37,7 @@ translation_of: Web/JavaScript/Reference/Classes
 
 
    函数声明和类声明之间的一个重要区别在于, 函数声明会{{Glossary("Hoisting", "提升")}}，类声明不会。你首先需要声明你的类，然后再访问它，否则类似以下的代码将抛出{{jsxref("ReferenceError")}}：
    
 
-
    let p = new Rectangle(); // ReferenceError
+
    let p = new Rectangle(); // ReferenceError
 
 class Rectangle {}
 
    
@@ -46,7 +46,7 @@ class Rectangle {}
 
 
    类表达式是定义类的另一种方法。类表达式可以命名或不命名。命名类表达式的名称是该类体的局部名称。(不过，可以通过类的(而不是一个实例的) {{jsxref("Function.name", "name")}} 属性来检索它)。
    
 
-
    // 未命名/匿名类
+
    // 未命名/匿名类
 let Rectangle = class {
   constructor(height, width) {
     this.height = height;
@@ -88,7 +88,7 @@ console.log(Rectangle.name);
 
 
    参见方法定义。
    
 
-
    class Rectangle {
+
    class Rectangle {
     // constructor
     constructor(height, width) {
         this.height = height;
@@ -113,7 +113,7 @@ console.log(square.area);
 
 
    static 关键字用来定义一个类的一个静态方法。调用静态方法不需要实例化该类，但不能通过一个类实例调用静态方法。静态方法通常用于为一个应用程序创建工具函数。
    
 
-
    class Point {
+
    class Point {
     constructor(x, y) {
         this.x = x;
         this.y = y;
@@ -145,7 +145,7 @@ console.log(Point.distance(p1, p2));
 
 
    当调用静态或原型方法时没有指定 this 的值，那么方法内的 this 值将被置为 undefined。即使你未设置 "use strict" ，因为 class 体内部的代码总是在严格模式下执行。
    
 
-
    class Animal {
+
    class Animal {
   speak() {
     return this;
   }
@@ -167,7 +167,7 @@ eat(); // undefined
    
 
 
    严格模式下不会发生自动装箱，this 值将保留传入状态。
    
 
-
    function Animal() { }
+
    function Animal() { }
 
 Animal.prototype.speak = function() {
   return this;
@@ -189,7 +189,7 @@ eat(); // global object
 
 
    实例的属性必须定义在类的方法里：
    
 
-
    class Rectangle {
+
    class Rectangle {
   constructor(height, width) {
     this.height = height;
     this.width = width;
@@ -199,7 +199,7 @@ eat(); // global object
 
 
    静态的或原型的数据属性必须定义在类定义的外面。
    
 
-
    Rectangle.staticWidth = 20;
+
    Rectangle.staticWidth = 20;
 Rectangle.prototype.prototypeWidth = 25;
 
    
 
@@ -213,7 +213,7 @@ Rectangle.prototype.prototypeWidth = 25;    
 
 
    使用JavaScript字段声明语法，上面的示例可以写成：
    
 
-
    class Rectangle {
+
    class Rectangle {
   height = 0;
   width;
   constructor(height, width) {
@@ -231,7 +231,7 @@ Rectangle.prototype.prototypeWidth = 25;
 
 
    使用私有字段，可以按以下方式细化定义。
    
 
-
    class Rectangle {
+
    class Rectangle {
   #height = 0;
   #width;
   constructor(height, width) {
@@ -255,7 +255,7 @@ Rectangle.prototype.prototypeWidth = 25;
 
 
    extends 关键字在 类声明 或 类表达式 中用于创建一个类作为另一个类的一个子类。
    
 
-
    class Animal {
+
    class Animal {
   constructor(name) {
     this.name = name;
   }
@@ -283,7 +283,7 @@ d.speak();// 'Mitzie barks.'
 
 
    也可以继承传统的基于函数的“类”：
    
 
-
    function Animal (name) {
+
    function Animal (name) {
   this.name = name;
 }
 Animal.prototype.speak = function () {
@@ -302,7 +302,7 @@ d.speak();//Mitzie makes a noise.  Mitzie barks.
    
 
 
    请注意，类不能继承常规对象（不可构造的）。如果要继承常规对象，可以改用{{jsxref("Object.setPrototypeOf()")}}：
    
 
-
    var Animal = {
+
    var Animal = {
   speak() {
     console.log(this.name + ' makes a noise.');
   }
@@ -325,7 +325,7 @@ d.speak(); // Mitzie makes a noise.
    
 
 
    例如，当使用像{{jsxref("Array.map", "map()")}}返回默认构造函数的方法时，您希望这些方法返回一个父Array对象，而不是MyArray对象。{{jsxref("Symbol.species")}} 符号可以让你这样做：
    
 
-
    class MyArray extends Array {
+
    class MyArray extends Array {
   // Overwrite species to the parent Array constructor
   static get [Symbol.species]() { return Array; }
 }
@@ -342,7 +342,7 @@ console.log(mapped instanceof Array);
 
 
    super 关键字用于调用对象的父对象上的函数。
    
 
-
    class Cat {
+
    class Cat {
   constructor(name) {
     this.name = name;
   }
@@ -366,7 +366,7 @@ class Lion extends Cat {
 
 
    一个以超类作为输入的函数和一个继承该超类的子类作为输出可以用于在ECMAScript中实现混合：
    
 
-
    var calculatorMixin = Base => class extends Base {
+
    var calculatorMixin = Base => class extends Base {
   calc() { }
 };
 
@@ -376,7 +376,7 @@ var randomizerMixin = Base => class extends Base {
 
 
    使用 mix-ins 的类可以像下面这样写：
    
 
-
    class Foo { }
+
    class Foo { }
 class Bar extends calculatorMixin(randomizerMixin(Foo)) { }
    
 
 
    规范
    
diff --git a/files/zh-cn/web/javascript/reference/errors/cyclic_object_value/index.html b/files/zh-cn/web/javascript/reference/errors/cyclic_object_value/index.html
index 9ab3cb7b02..b729af45fa 100644
--- a/files/zh-cn/web/javascript/reference/errors/cyclic_object_value/index.html
+++ b/files/zh-cn/web/javascript/reference/errors/cyclic_object_value/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Errors/Cyclic_object_value
 
 
    提示信息
    
 
-
    TypeError: cyclic object value (Firefox)
+
    TypeError: cyclic object value (Firefox)
 TypeError: Converting circular structure to JSON (Chrome and Opera)
 TypeError: Circular reference in value argument not supported (Edge)
    
 
@@ -34,7 +34,7 @@ TypeError: Circular reference in value argument not supported (Edge)
    
 
 
    在如下循环结构中：
    
 
-
    var a = {};
+
    var a = {};
 var b = {};
 a.child = b;
 b.child = a;
@@ -42,7 +42,7 @@ b.child = a;
 
 
    {{jsxref("JSON.stringify()")}} 将会报错
    
 
-
    JSON.stringify(a);
+
    JSON.stringify(a);
 // TypeError: cyclic object value
 
    
 
@@ -52,7 +52,7 @@ b.child = a;
 
 
    注意：以下代码并不会保存循环引用的值。
    
 
-
    var seen = [];
+
    var seen = [];
 
 var replacer = function(key, value) {
   if (typeof value === "object" && value !== null) {
diff --git a/files/zh-cn/web/javascript/reference/errors/not_a_function/index.html b/files/zh-cn/web/javascript/reference/errors/not_a_function/index.html
index fc4f664e1d..00c3cb3073 100644
--- a/files/zh-cn/web/javascript/reference/errors/not_a_function/index.html
+++ b/files/zh-cn/web/javascript/reference/errors/not_a_function/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Errors/Not_a_function
 
 
    信息
    
 
-
    TypeError: Object doesn't support property or method {x} (Edge)
+
    TypeError: Object doesn't support property or method {x} (Edge)
 TypeError: "x" is not a function
    
 
 
    错误类型
    
@@ -47,20 +47,20 @@ TypeError: "x" is not a function
    
 
 
    函数的名称拼写错误，这种情况是经常发生的：
    
 
-
    var x = document.getElementByID("foo");
+
    var x = document.getElementByID("foo");
 // TypeError: document.getElementByID is not a function
 
    
 
 
    正确的方法名应该是 getElementById：
    
 
-
    var x = document.getElementById("foo");
+
    var x = document.getElementById("foo");
 
    
 
 
    调用Object类型中不存在的方法
    
 
 
    对于某些特殊的方法，它只属于某些特定的原生对象中，你必须提供一个回调函数才能正常运行。例如：这里调用了一个 {{jsxref("Array.prototype.map()")}} 方法，但是这方法只能被 {{jsxref("Array")}} 对象所调用。 
    
 
-
    var obj = { a: 13, b: 37, c: 42 };
+
    var obj = { a: 13, b: 37, c: 42 };
 
 obj.map(function(num) {
   return num * 2;
@@ -70,7 +70,7 @@ obj.map(function(num) {
 
 
    正确的做法，使用一个数组来代替:
    
 
-
    var numbers = [1, 4, 9];
+
    var numbers = [1, 4, 9];
 
 numbers.map(function(num) {
   return num * 2;
@@ -83,7 +83,7 @@ numbers.map(function(num) {
 
 
    当您在创建类时,可能会存在某个属性和某个方法的名称相同,当您在调用该函数时,编译器会认为该函数不存在.
    
 
-
    var Dog = function () {
+
    var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.name = "Ralph";
@@ -102,7 +102,7 @@ myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function
 
 
    正确的做法是使用不同的变量名.
    
 
-
    var Dog = function () {
+
    var Dog = function () {
  this.age = 11;
  this.color = "black";
  this.dogName = "Ralph"; //Using this.dogName instead of .name
@@ -124,13 +124,13 @@ myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' }<
 
 
    使用后者时将会抛出错误:
    
 
-
    const sixteen = 2(3 + 5);
+
    const sixteen = 2(3 + 5);
 alert('2 x (3 + 5) is ' + String(sixteen));
 //Uncaught TypeError: 2 is not a function
    
 
 
    您可以添加乘法运算符 * 来改正代码:
    
 
-
    const sixteen = 2 * (3 + 5);
+
    const sixteen = 2 * (3 + 5);
 alert('2 x (3 + 5) is ' + String(sixteen));
 //2 x (3 + 5) is 16
    
 
@@ -140,7 +140,7 @@ alert('2 x (3 + 5) is ' + String(sixteen));
 
 
    以下为一个示例模块 (helpers.js)
    
 
-
    let helpers = function () { };
+
    let helpers = function () { };
 
 helpers.groupBy = function (objectArray, property) {
   return objectArray.reduce(function (acc, obj) {
@@ -158,7 +158,7 @@ export default helpers;
    
 
 
    在 App.js中正确导入该模块:
    
 
-
    import helpers from './helpers'
    
+
    import helpers from './helpers'
    
 
 
    相关
    
 
diff --git a/files/zh-cn/web/javascript/reference/errors/not_defined/index.html b/files/zh-cn/web/javascript/reference/errors/not_defined/index.html
index a092f394ec..cc5fadb2a8 100644
--- a/files/zh-cn/web/javascript/reference/errors/not_defined/index.html
+++ b/files/zh-cn/web/javascript/reference/errors/not_defined/index.html
@@ -7,7 +7,7 @@ translation_of: Web/JavaScript/Reference/Errors/Not_defined
 
 
    错误信息
    
 
-
    ReferenceError: "x" is not defined
+
    ReferenceError: "x" is not defined
 
    
 
 
    错误类型
    
@@ -26,19 +26,19 @@ translation_of: Web/JavaScript/Reference/Errors/Not_defined
 
 
    变量没有被声明
    
 
-
    foo.substring(1); // ReferenceError: foo is not defined
+
    foo.substring(1); // ReferenceError: foo is not defined
 
    
 
 
    “foo” 变量没有在任何地方被声明。它需要是某种字符串，这样 {{jsxref("String.prototype.substring()")}} 方法才可以正常工作。
    
 
-
    var foo = 'bar';
+
    var foo = 'bar';
 foo.substring(1); // "ar"
    
 
 
    错误的作用域
    
 
 
    变量必须是在它当前的执行环境中可用的。在一个函数（function）中定义的变量不能从这个函数外部的任何地方访问，因为这个变量的作用域仅在这个函数的内部。
    
 
-
    function numbers () {
+
    function numbers () {
   var num1 = 2,
       num2 = 3;
   return num1 + num2;
@@ -48,7 +48,7 @@ console.log(num1); // ReferenceError num1 is not defined.
    
 
 
    然而，一个函数可用使用在它所被定义的作用域中的所有变量。换句话说，当一个函数被定义在全局作用域的时候，它可以访问所有在全局作用域中定义的变量。
    
 
-
    var num1 = 2,
+
    var num1 = 2,
     num2 = 3;
 
 function numbers () {
diff --git a/files/zh-cn/web/javascript/reference/functions/arguments/index.html b/files/zh-cn/web/javascript/reference/functions/arguments/index.html
index 0cc7216837..8aff3819bd 100644
--- a/files/zh-cn/web/javascript/reference/functions/arguments/index.html
+++ b/files/zh-cn/web/javascript/reference/functions/arguments/index.html
@@ -35,18 +35,18 @@ translation_of: Web/JavaScript/Reference/Functions/arguments
 
 
    arguments对象是所有（非箭头）函数中都可用的局部变量。你可以使用arguments对象在函数中引用函数的参数。此对象包含传递给函数的每个参数，第一个参数在索引0处。例如，如果一个函数传递了三个参数，你可以以如下方式引用他们：
    
 
-
    arguments[0]
+
    arguments[0]
 arguments[1]
 arguments[2]
 
    
 
 
    参数也可以被设置：
    
 
-
    arguments[1] = 'new value';
    
+
    arguments[1] = 'new value';
    
 
 
    arguments对象不是一个 {{jsxref("Array")}} 。它类似于Array，但除了length属性和索引元素之外没有任何Array属性。例如，它没有 pop 方法。但是它可以被转换为一个真正的Array：
    
 
-
    var args = Array.prototype.slice.call(arguments);
+
    var args = Array.prototype.slice.call(arguments);
 var args = [].slice.call(arguments);
 
 // ES2015
@@ -57,7 +57,7 @@ const args = [...arguments];
 
    
 
    对参数使用slice会阻止某些JavaScript引擎中的优化 (比如 V8 - 更多信息)。如果你关心性能，尝试通过遍历arguments对象来构造一个新的数组。另一种方法是使用被忽视的Array构造函数作为一个函数：
    
 
-
    var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));
+
    var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));
 
    
 
    
 
@@ -67,7 +67,7 @@ const args = [...arguments];
 
 
    typeof参数返回 'object'。
    
 
-
    console.log(typeof arguments);    // 'object'
+
    console.log(typeof arguments);    // 'object'
 // arguments 对象只能在函数内使用
 function test(a){
     console.log(a,Object.prototype.toString.call(arguments));
@@ -83,13 +83,13 @@ number
 
 
    可以使用索引确定单个参数的类型。
    
 
-
    console.log(typeof arguments[0]); //this will return the typeof individual arguments.
    
+
    console.log(typeof arguments[0]); //this will return the typeof individual arguments.
    
 
 
    对参数使用扩展语法
    
 
 
    您还可以使用{{jsxref("Array.from()")}}方法或扩展运算符将参数转换为真实数组：
    
 
-
    var args = Array.from(arguments);
+
    var args = Array.from(arguments);
 var args = [...arguments];
    
 
 
    属性
    
@@ -120,7 +120,7 @@ var args = [...arguments];
    
 
 
    遍历参数求和
    
 
-
    function add() {
+
    function add() {
     var sum =0,
         len = arguments.length;
     for(var i=0; i<len; i++){
@@ -136,14 +136,14 @@ add(1,2,3,4);                   // 10
    
 
 
    这个例子定义了一个函数来连接字符串。这个函数唯一正式声明了的参数是一个字符串，该参数指定一个字符作为衔接点来连接字符串。该函数定义如下：
    
 
-
    function myConcat(separator) {
+
    function myConcat(separator) {
   var args = Array.prototype.slice.call(arguments, 1);
   return args.join(separator);
 }
    
 
 
    你可以传递任意数量的参数到该函数，并使用每个参数作为列表中的项创建列表。
    
 
-
    // returns "red, orange, blue"
+
    // returns "red, orange, blue"
 myConcat(", ", "red", "orange", "blue");
 
 // returns "elephant; giraffe; lion; cheetah"
@@ -156,7 +156,7 @@ myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
    
 
 
    这个例子定义了一个函数通过一个字符串来创建HTML列表。这个函数唯一正式声明了的参数是一个字符。当该参数为 "u" 时，创建一个无序列表 (项目列表)；当该参数为 "o" 时，则创建一个有序列表 (编号列表)。该函数定义如下：
    
 
-
    function list(type) {
+
    function list(type) {
   var result = "<" + type + "l><li>";
   var args = Array.prototype.slice.call(arguments, 1);
   result += args.join("</li><li>");
@@ -167,7 +167,7 @@ myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
    
 
 
    你可以传递任意数量的参数到该函数，并将每个参数作为一个项添加到指定类型的列表中。例如：
    
 
-
    var listHTML = list("u", "One", "Two", "Three");
+
    var listHTML = list("u", "One", "Two", "Three");
 
 /* listHTML is:
 
@@ -180,7 +180,7 @@ myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
    
 
 
    arguments对象可以与剩余参数、默认参数和解构赋值参数结合使用。
    
 
-
    function foo(...args) {
+
    function foo(...args) {
   return args;
 }
 foo(1, 2, 3);  // [1,2,3]
@@ -190,7 +190,7 @@ foo(1, 2, 3);  // [1,2,3]
 
 
    当非严格模式中的函数没有包含剩余参数、默认参数和解构赋值，那么arguments对象中的值会跟踪参数的值（反之亦然）。看下面的代码：
    
 
-
    function func(a) {
+
    function func(a) {
   arguments[0] = 99;   // 更新了arguments[0] 同样更新了a
   console.log(a);
 }
@@ -199,7 +199,7 @@ func(10); // 99
 
 
    并且
    
 
-
    function func(a) {
+
    function func(a) {
   a = 99;              // 更新了a 同样更新了arguments[0]
   console.log(arguments[0]);
 }
@@ -208,7 +208,7 @@ func(10); // 99
 
 
    当非严格模式中的函数有包含剩余参数、默认参数和解构赋值，那么arguments对象中的值不会跟踪参数的值（反之亦然）。相反, arguments反映了调用时提供的参数：
    
 
-
    function func(a = 55) {
+
    function func(a = 55) {
   arguments[0] = 99; // updating arguments[0] does not also update a
   console.log(a);
 }
@@ -216,7 +216,7 @@ func(10); // 10
    
 
 
    并且
    
 
-
    function func(a = 55) {
+
    function func(a = 55) {
   a = 99; // updating a does not also update arguments[0]
   console.log(arguments[0]);
 }
@@ -224,7 +224,7 @@ func(10); // 10
    
 
 
    并且
    
 
-
    function func(a = 55) {
+
    function func(a = 55) {
   console.log(arguments[0]);
 }
 func(); // undefined
diff --git a/files/zh-cn/web/javascript/reference/functions/arrow_functions/index.html b/files/zh-cn/web/javascript/reference/functions/arrow_functions/index.html
index 7f3ca61168..a3166bf160 100644
--- a/files/zh-cn/web/javascript/reference/functions/arrow_functions/index.html
+++ b/files/zh-cn/web/javascript/reference/functions/arrow_functions/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
 
    
 
    基础语法
    
 
-
    (param1, param2, …, paramN) => { statements }
+
    (param1, param2, …, paramN) => { statements }
 (param1, param2, …, paramN) => expression
 //相当于：(param1, param2, …, paramN) =>{ return expression; }
 
@@ -39,7 +39,7 @@ singleParam => { statements }
 
    高级语法
    
 
 
    
-
    //加括号的函数体返回对象字面量表达式：
+
    //加括号的函数体返回对象字面量表达式：
 params => ({foo: bar})
 
 //支持剩余参数和默认参数
@@ -60,7 +60,7 @@ f();  // 6
    
 
 
    更短的函数
    
 
-
    var elements = [
+
    var elements = [
   'Hydrogen',
   'Helium',
   'Lithium',
@@ -103,7 +103,7 @@ elements.map(({ "length": lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]
 
 
    This被证明是令人厌烦的面向对象风格的编程。
    
 
-
    function Person() {
+
    function Person() {
   // Person() 构造函数定义 `this`作为它自己的实例.
   this.age = 0;
 
@@ -118,7 +118,7 @@ var p = new Person();
    
 
 
    在ECMAScript 3/5中，通过将this值分配给封闭的变量，可以解决this问题。
    
 
-
    function Person() {
+
    function Person() {
   var that = this;
   that.age = 0;
 
@@ -132,7 +132,7 @@ var p = new Person();
    
 
 
    箭头函数不会创建自己的this,它只会从自己的作用域链的上一层继承this。因此，在下面的代码中，传递给setInterval的函数内的this与封闭函数中的this值相同：
    
 
-
    function Person(){
+
    function Person(){
   this.age = 0;
 
   setInterval(() => {
@@ -146,7 +146,7 @@ var p = new Person();
    
 
 
    鉴于 this 是词法层面上的，严格模式中与 this 相关的规则都将被忽略。
    
 
-
    var f = () => { 'use strict'; return this; };
+
    var f = () => { 'use strict'; return this; };
 f() === window; // 或者 global
    
 
 
    严格模式的其他规则依然不变.
    
@@ -155,7 +155,7 @@ f() === window; // 或者 global
    
 
 
    由于 箭头函数没有自己的this指针，通过 call() 或 apply() 方法调用一个函数时，只能传递参数（不能绑定this---译者注），他们的第一个参数会被忽略。（这种现象对于bind方法同样成立---译者注）
    
 
-
    var adder = {
+
    var adder = {
   base : 1,
 
   add : function(a) {
@@ -180,7 +180,7 @@ console.log(adder.addThruCall(1)); // 仍然输出 2
    
 
 
    箭头函数不绑定Arguments 对象。因此，在本示例中，arguments只是引用了封闭作用域内的arguments：
    
 
-
    var arguments = [1, 2, 3];
+
    var arguments = [1, 2, 3];
 var arr = () => arguments[0];
 
 arr(); // 1
@@ -198,7 +198,7 @@ foo(3,2);//6
 
 
    在大多数情况下，使用剩余参数是相较使用arguments对象的更好选择。
    
 
-
    function foo(arg) {
+
    function foo(arg) {
   var f = (...args) => args[0];
   return f(arg);
 }
@@ -216,7 +216,7 @@ foo(1,2);  //2
 
 
    如上所述，箭头函数表达式对非方法函数是最合适的。让我们看看当我们试着把它们作为方法时发生了什么。
    
 
-
    'use strict';
+
    'use strict';
 var obj = {
   i: 10,
   b: () => console.log(this.i, this),
@@ -232,7 +232,7 @@ obj.c();
 
 
    箭头函数没有定义this绑定。另一个涉及{{jsxref("Object.defineProperty()")}}的示例：
    
 
-
    'use strict';
+
    'use strict';
 var obj = {
   a: 10
 };
@@ -252,14 +252,14 @@ obj.b; // undefined   "undefined"   Window {postMessage: ƒ, blur: ƒ, focus: ƒ
 
 
    箭头函数不能用作构造器，和 new一起用会抛出错误。
    
 
-
    var Foo = () => {};
+
    var Foo = () => {};
 var foo = new Foo(); // TypeError: Foo is not a constructor
    
 
 
    使用prototype属性
    
 
 
    箭头函数没有prototype属性。
    
 
-
    var Foo = () => {};
+
    var Foo = () => {};
 console.log(Foo.prototype); // undefined
    
 
 
    使用 yield 关键字
    
@@ -272,7 +272,7 @@ console.log(Foo.prototype); // undefined
    
 
 
    在一个简写体中，只需要一个表达式，并附加一个隐式的返回值。在块体中，必须使用明确的return语句。
    
 
-
    var func = x => x * x;
+
    var func = x => x * x;
 // 简写函数 省略return
 
 var func = (x, y) => { return x + y; };
@@ -282,7 +282,7 @@ var func = (x, y) => { return x + y; };
 
 
    记住用params => {object:literal}这种简单的语法返回对象字面量是行不通的。
    
 
-
    var func = () => { foo: 1 };
+
    var func = () => { foo: 1 };
 // Calling func() returns undefined!
 
 var func = () => { foo: function() {} };
@@ -292,19 +292,19 @@ var func = () => { foo: function() {} };
 
 
    所以，记得用圆括号把对象字面量包起来：
    
 
-
    var func = () => ({foo: 1});
    
+
    var func = () => ({foo: 1});
    
 
 
    换行
    
 
 
    箭头函数在参数和箭头之间不能换行。
    
 
-
    var func = ()
+
    var func = ()
            => 1;
 // SyntaxError: expected expression, got '=>'
    
 
 
    但是，可以通过在 ‘=>’ 之后换行，或者用 ‘( )’、'{ }'来实现换行，如下：
    
 
-
    var func = (a, b, c) =>
+
    var func = (a, b, c) =>
   1;
 
 var func = (a, b, c) => (
@@ -327,7 +327,7 @@ var func = (
 
 
    虽然箭头函数中的箭头不是运算符，但箭头函数具有与常规函数不同的特殊运算符优先级解析规则。
    
 
-
    let callback;
+
    let callback;
 
 callback = callback || function() {}; // ok
 
@@ -338,7 +338,7 @@ callback = callback || (() => {});    // ok
    
 
 
    更多示例
    
 
-
    // 空的箭头函数返回 undefined
+
    // 空的箭头函数返回 undefined
 let empty = () => {};
 
 (() => 'foobar')();
@@ -383,7 +383,7 @@ setTimeout( () => {
 
 
    箭头函数也可以使用条件（三元）运算符：
    
 
-
    var simple = a => a > 15 ? 15 : a;
+
    var simple = a => a > 15 ? 15 : a;
 simple(16); // 15
 simple(10); // 10
 
@@ -393,7 +393,7 @@ let max = (a, b) => a > b ? a : b;
    
 
    箭头函数内定义的变量及其作用域
    
 
    
 
-
    // 常规写法
+
    // 常规写法
 var greeting = () => {let now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
 greeting();          //"Good day."
 console.log(now);    // ReferenceError: now is not defined 标准的let作用域
@@ -418,7 +418,7 @@ console.log(now);    // ReferenceError: now is not defined
 
    箭头函数也可以使用闭包：
    
 
    
 
-
    // 标准的闭包函数
+
    // 标准的闭包函数
 function A(){
       var i=0;
       return function b(){
@@ -446,7 +446,7 @@ var Add = (i=0)=> ()=> (++i);
 
     箭头函数递归
    
 
 
-
    var fact = (x) => ( x==0 ?  1 : x*fact(x-1) );
+
    var fact = (x) => ( x==0 ?  1 : x*fact(x-1) );
 fact(5);       // 120
    
 
 
    规范
    
diff --git a/files/zh-cn/web/javascript/reference/global_objects/aggregateerror/index.html b/files/zh-cn/web/javascript/reference/global_objects/aggregateerror/index.html
index c9578649f5..1802bbe483 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/aggregateerror/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/aggregateerror/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/AggregateError
 
 
    语法
    
 
-
    new AggregateError(errors[, message])
    
+
    new AggregateError(errors[, message])
    
 
 
    参数
    
 
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/AggregateError
 
 
    捕获一个AggregateError
    
 
-
    Promise.any([
+
    Promise.any([
   Promise.reject(new Error("some error")),
 ]).catch(e => {
   console.log(e instanceof AggregateError); // true
@@ -62,7 +62,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/AggregateError
 
 
    创建一个AggregateError
    
 
-
    try {
+
    try {
   throw new AggregateError([
     new Error("some error"),
   ], 'Hello');
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/concat/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/concat/index.html
index 4541912a76..b0960c35d0 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/concat/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/concat/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat
 
 
    语法
    
 
-
    var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
    
+
    var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
    
 
 
    参数
    
 
@@ -53,7 +53,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat
 
 
    以下代码将两个数组合并为一个新数组：
    
 
-
    var alpha = ['a', 'b', 'c'];
+
    var alpha = ['a', 'b', 'c'];
 var numeric = [1, 2, 3];
 
 alpha.concat(numeric);
@@ -63,7 +63,7 @@ alpha.concat(numeric);
 
 
    以下代码将三个数组合并为一个新数组：
    
 
-
    var num1 = [1, 2, 3],
+
    var num1 = [1, 2, 3],
     num2 = [4, 5, 6],
     num3 = [7, 8, 9];
 
@@ -76,7 +76,7 @@ console.log(nums);
 
 
    以下代码将三个值连接到数组：
    
 
-
    var alpha = ['a', 'b', 'c'];
+
    var alpha = ['a', 'b', 'c'];
 
 var alphaNumeric = alpha.concat(1, [2, 3]);
 
@@ -87,7 +87,7 @@ console.log(alphaNumeric);
 
 
    以下代码合并数组并保留引用：
    
 
-
    var num1 = [[1]];
+
    var num1 = [[1]];
 var num2 = [2, [3]];
 var num3=[5,[6]];
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/every/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/every/index.html
index a64c25b43d..38d4388b52 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/every/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/every/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 
 
    语法
    
 
-
    arr.every(callback(element[, index[, array]])[, thisArg])
    
+
    arr.every(callback(element[, index[, array]])[, thisArg])
    
 
 
    参数
    
 
@@ -68,7 +68,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 
 
    下例检测数组中的所有元素是否都大于 10。
    
 
-
    function isBigEnough(element, index, array) {
+
    function isBigEnough(element, index, array) {
   return element >= 10;
 }
 [12, 5, 8, 130, 44].every(isBigEnough);   // false
@@ -79,14 +79,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
 
 
    箭头函数为上面的检测过程提供了更简短的语法。
    
 
-
    [12, 5, 8, 130, 44].every(x => x >= 10); // false
+
    [12, 5, 8, 130, 44].every(x => x >= 10); // false
 [12, 54, 18, 130, 44].every(x => x >= 10); // true
    
 
 
    兼容旧环境（Polyfill）
    
 
 
    在 ECMA-262 第 5 版时，every 被添加进 ECMA-262 标准；因此，在某些实现环境中，它尚未被支持。你可以把下面的代码放到脚本的开头来解决此问题，该代码允许在那些没有原生支持 every 的实现环境中使用它。该算法是 ECMA-262 第 5 版中指定的算法，它假定 Object 和 TypeError 拥有它们的初始值，且 fun.call 等价于 {{jsxref("Function.prototype.call")}}。
    
 
-
    if (!Array.prototype.every) {
+
    if (!Array.prototype.every) {
   Array.prototype.every = function(callbackfn, thisArg) {
     'use strict';
     var T, k;
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/filter/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/filter/index.html
index c23bf5cb98..acc86a9592 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/filter/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/filter/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
 
 
    语法
    
 
-
    var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
    
+
    var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
    
 
 
    参数
    
 
@@ -69,7 +69,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
 
 
    下例使用 filter 创建了一个新数组，该数组的元素由原数组中值大于 10 的元素组成。
    
 
-
    function isBigEnough(element) {
+
    function isBigEnough(element) {
   return element >= 10;
 }
 var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
@@ -80,7 +80,7 @@ var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
 
 
    以下示例使用 filter() 创建具有非零 id 的元素的 json。
    
 
-
    var arr = [
+
    var arr = [
   { id: 15 },
   { id: -1 },
   { id: 0 },
@@ -120,7 +120,7 @@ console.log('Number of Invalid Entries = ', invalidEntries);
 
 
    下例使用 filter() 根据搜索条件来过滤数组内容。
    
 
-
    var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
    var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
 
 /**
  * Array filters items based on search criteria (query)
@@ -136,7 +136,7 @@ console.log(filterItems('an')); // ['banana', 'mango', 'orange']
    
 
 
    ES2015 实现
    
 
-
    const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
    const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
 
 /**
  * Array filters items based on search criteria (query)
@@ -156,7 +156,7 @@ console.log(filterItems('an')); // ['banana', 'mango', 'orange']
 
 
    filter 被添加到 ECMA-262 标准第 5 版中，因此在某些实现环境中不被支持。可以把下面的代码插入到脚本的开头来解决此问题，该代码允许在那些没有原生支持 filter 的实现环境中使用它。该算法是 ECMA-262 第 5 版中指定的算法，假定 fn.call 等价于 {{jsxref("Function.prototype.call")}} 的初始值，且 {{jsxref("Array.prototype.push")}} 拥有它的初始值。
    
 
-
    if (!Array.prototype.filter){
+
    if (!Array.prototype.filter){
   Array.prototype.filter = function(func, thisArg) {
     'use strict';
     if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) )
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/findindex/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/findindex/index.html
index 7b1e3c7143..b0c8967e8e 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/findindex/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/findindex/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
 
 
    语法
    
 
-
    arr.findIndex(callback[, thisArg])
    
+
    arr.findIndex(callback[, thisArg])
    
 
 
    参数
    
 
@@ -62,7 +62,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
 
 
    以下示例查找数组中素数的元素的索引（如果不存在素数，则返回-1）。
    
 
-
    function isPrime(element, index, array) {
+
    function isPrime(element, index, array) {
   var start = 2;
   while (start <= Math.sqrt(element)) {
     if (element % start++ < 1) {
@@ -77,7 +77,7 @@ console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
    
 
 
    Polyfill
    
 
-
    // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex
+
    // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex
 if (!Array.prototype.findIndex) {
   Object.defineProperty(Array.prototype, 'findIndex', {
     value: function(predicate) {
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/flat/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/flat/index.html
index 2f37e8f49b..f6a9420e21 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/flat/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/flat/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
 
 
    语法
    
 
-
    var newArray = arr.flat([depth])
    
+
    var newArray = arr.flat([depth])
    
 
 
    参数
    
 
@@ -36,7 +36,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
 
 
    扁平化嵌套数组
    
 
-
    var arr1 = [1, 2, [3, 4]];
+
    var arr1 = [1, 2, [3, 4]];
 arr1.flat();
 // [1, 2, 3, 4]
 
@@ -57,7 +57,7 @@ arr4.flat(Infinity);
 
 
    flat() 方法会移除数组中的空项:
    
 
-
    var arr4 = [1, 2, , 4, 5];
+
    var arr4 = [1, 2, , 4, 5];
 arr4.flat();
 // [1, 2, 4, 5]
    
 
@@ -65,7 +65,7 @@ arr4.flat();
 
 
    使用 reduce 与 concat
    
 
-
    var arr = [1, 2, [3, 4]];
+
    var arr = [1, 2, [3, 4]];
 
 // 展开一层数组
 arr.flat();
@@ -78,7 +78,7 @@ const flattened = arr => [].concat(...arr);
    
 
 
    reduce + concat + isArray + recursivity
    
 
-
    // 使用 reduce、concat 和递归展开无限多层嵌套的数组
+
    // 使用 reduce、concat 和递归展开无限多层嵌套的数组
 var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
 
 function flatDeep(arr, d = 1) {
@@ -91,7 +91,7 @@ flatDeep(arr1, Infinity);
 
 
    forEach+isArray+push+recursivity
    
 
-
    // forEach 遍历数组会自动跳过空元素
+
    // forEach 遍历数组会自动跳过空元素
 const eachFlat = (arr = [], depth = 1) => {
   const result = []; // 缓存递归结果
   // 开始递归
@@ -131,7 +131,7 @@ const forFlat = (arr = [], depth = 1) => {
 
 
    使用堆栈stack
    
 
-
    // 无递归数组扁平化，使用堆栈
+
    // 无递归数组扁平化，使用堆栈
 // 注意：深度的控制比较低效，因为需要检查每一个值的深度
 // 也可能在 shift / unshift 上进行 w/o 反转，但是末端的数组 OPs 更快
 var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
@@ -153,7 +153,7 @@ function flatten(input) {
 }
 flatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
    
 
-
    // 递归版本的反嵌套
+
    // 递归版本的反嵌套
 function flatten(array) {
   var flattend = [];
   (function flat(array) {
@@ -167,7 +167,7 @@ function flatten(array) {
 
 
    Use Generator function
    
 
-
    function* flatten(array) {
+
    function* flatten(array) {
     for (const item of array) {
         if (Array.isArray(item)) {
             yield* flatten(item);
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/flatmap/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/flatmap/index.html
index 50c75a73ab..8383d4be6a 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/flatmap/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/flatmap/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap
 
 
    语法
    
 
-
    var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
+
    var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
     // return element for new_array
 }[, thisArg])
    
 
@@ -54,7 +54,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap
 
 
    map() 与 flatMap()
    
 
-
    var arr1 = [1, 2, 3, 4];
+
    var arr1 = [1, 2, 3, 4];
 
 arr1.map(x => [x * 2]);
 // [[2], [4], [6], [8]]
@@ -70,7 +70,7 @@ arr1.flatMap(x => [[x * 2]]);
 
 
    所以，为了更好的展示 flatMap 的作用，下面我们将包含几句话的数组拆分成单个词组成的新数组。
    
 
-
    let arr1 = ["it's Sunny in", "", "California"];
+
    let arr1 = ["it's Sunny in", "", "California"];
 
 arr1.map(x => x.split(" "));
 // [["it's","Sunny","in"],[""],["California"]]
@@ -84,7 +84,7 @@ arr1.flatMap(x => x.split(" "));
 
 
    flatMap 能用于在map期间增删项目（也就是修改items的数量）。换句话说，它允许你遍历很多项使之成为另一些项（靠分别把它们放进去来处理），而不是总是一对一。 从这个意义上讲，它的作用类似于 filter的对立面。只需返回一个1项元素数组以保留该项，返回一个多元素数组以添加项，或返回一个0项元素数组以删除该项。
    
 
-
    // Let's say we want to remove all the negative numbers and split the odd numbers into an even number and a 1
+
    // Let's say we want to remove all the negative numbers and split the odd numbers into an even number and a 1
 let a = [5, 4, -3, 20, 17, -33, -4, 18]
 //       |\  \  x   |  | \   x   x   |
 //      [4,1, 4,   20, 16, 1,       18]
@@ -101,7 +101,7 @@ a.flatMap( (n) =>
 
 
    reduce() 与 concat()
    
 
-
    var arr = [1, 2, 3, 4];
+
    var arr = [1, 2, 3, 4];
 
 arr.flatMap(x => [x, x * 2]);
 // is equivalent to
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/from/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/from/index.html
index 8cab100d7c..01b6062f91 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/from/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/from/index.html
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
 
 
    语法
    
 
-
    Array.from(arrayLike[, mapFn[, thisArg]])
+
    Array.from(arrayLike[, mapFn[, thisArg]])
 
    
 
 
    参数
    
@@ -59,18 +59,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
 
 
    从 String 生成数组
    
 
-
    Array.from('foo');
+
    Array.from('foo');
 // [ "f", "o", "o" ]
    
 
 
    从 Set 生成数组
    
 
-
    const set = new Set(['foo', 'bar', 'baz', 'foo']);
+
    const set = new Set(['foo', 'bar', 'baz', 'foo']);
 Array.from(set);
 // [ "foo", "bar", "baz" ]
    
 
 
    从 Map 生成数组
    
 
-
    const map = new Map([[1, 2], [2, 4], [4, 8]]);
+
    const map = new Map([[1, 2], [2, 4], [4, 8]]);
 Array.from(map);
 // [[1, 2], [2, 4], [4, 8]]
 
@@ -84,7 +84,7 @@ Array.from(mapper.keys());
 
 
    从类数组对象（arguments）生成数组
    
 
-
    function f() {
+
    function f() {
   return Array.from(arguments);
 }
 
@@ -94,7 +94,7 @@ f(1, 2, 3);
 
 
    在 Array.from 中使用箭头函数
    
 
-
    // Using an arrow function as the map function to
+
    // Using an arrow function as the map function to
 // manipulate the elements
 Array.from([1, 2, 3], x => x + x);
 // [2, 4, 6]
@@ -109,7 +109,7 @@ Array.from({length: 5}, (v, i) => i);
 
 
    序列生成器(指定范围)
    
 
-
    // Sequence generator function (commonly referred to as "range", e.g. Clojure, PHP etc)
+
    // Sequence generator function (commonly referred to as "range", e.g. Clojure, PHP etc)
 const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));
 
 // Generate numbers range 0..4
@@ -127,7 +127,7 @@ range('A'.charCodeAt(0), 'Z'.charCodeAt(0), 1).map(x => String.fromCharCode(x
 
 
    数组去重合并
    
 
-
    function combine(){
+
    function combine(){
     let arr = [].concat.apply([], arguments);  //没有去重复的新数组
     return Array.from(new Set(arr));
 }
@@ -139,7 +139,7 @@ console.log(combine(m,n));                     // [1, 2, 3]
    
 
 
    ECMA-262 第六版标准中添加了 Array.from 。有些实现中可能尚未包括在其中。你可以通过在脚本前添加如下内容作为替代方法，以使用未原生支持的 Array.from 方法。该算法按照 ECMA-262 第六版中的规范实现，并假定 Object 和 TypeError 有其本身的值， callback.call 对应 {{jsxref("Function.prototype.call")}} 。此外，鉴于无法使用 Polyfill 实现真正的的迭代器，该实现不支持规范中定义的泛型可迭代元素。
    
 
-
    // Production steps of ECMA-262, Edition 6, 22.1.2.1
+
    // Production steps of ECMA-262, Edition 6, 22.1.2.1
 if (!Array.from) {
   Array.from = (function () {
     var toStr = Object.prototype.toString;
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/map/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/map/index.html
index b00ce5df07..1517622c81 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/map/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/map/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 
 
    语法
    
 
-
    var new_array = arr.map(function callback(currentValue[, index[, array]]) {
+
    var new_array = arr.map(function callback(currentValue[, index[, array]]) {
  // Return element for new_array 
 }[, thisArg])
    
 
@@ -68,7 +68,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
 
 
    下面的代码创建了一个新数组，值为原数组中对应数字的平方根。
    
 
-
    var numbers = [1, 4, 9];
+
    var numbers = [1, 4, 9];
 var roots = numbers.map(Math.sqrt);
 // roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9]
    
 
@@ -76,7 +76,7 @@ var roots = numbers.map(Math.sqrt);
 
 
    以下代码使用一个包含对象的数组来重新创建一个格式化后的数组。
    
 
-
    var kvArray = [{key: 1, value: 10},
+
    var kvArray = [{key: 1, value: 10},
                {key: 2, value: 20},
                {key: 3, value: 30}];
 
@@ -98,7 +98,7 @@ var reformattedArray = kvArray.map(function(obj) {
 
 
    下面的代码表示了当函数需要一个参数时map的工作方式。当map循环遍历原始数组时，这个参数会自动被分配成数组中对应的每个元素。
    
 
-
    var numbers = [1, 4, 9];
+
    var numbers = [1, 4, 9];
 var doubles = numbers.map(function(num) {
   return num * 2;
 });
@@ -110,7 +110,7 @@ var doubles = numbers.map(function(num) {
 
 
    下面的例子演示如何在一个 {{jsxref("String")}}  上使用 map 方法获取字符串中每个字符所对应的 ASCII 码组成的数组：
    
 
-
    var map = Array.prototype.map
+
    var map = Array.prototype.map
 var a = map.call("Hello World", function(x) {
   return x.charCodeAt(0);
 })
@@ -121,7 +121,7 @@ var a = map.call("Hello World", function(x) {
 
 
    下面代码展示了如何去遍历用 querySelectorAll 得到的动态对象集合。在这里，我们获得了文档里所有选中的选项，并将其打印：
    
 
-
    var elems = document.querySelectorAll('select option:checked');
+
    var elems = document.querySelectorAll('select option:checked');
 var values = Array.prototype.map.call(elems, function(obj) {
   return obj.value;
 });
@@ -135,7 +135,7 @@ var values = Array.prototype.map.call(elems, function(obj) {
 
 
    考虑下例：
    
 
-
    ["1", "2", "3"].map(parseInt);
    
+
    ["1", "2", "3"].map(parseInt);
    
 
 
    我们期望输出 [1, 2, 3], 而实际结果是 [1, NaN, NaN].
    
 
@@ -149,14 +149,14 @@ var values = Array.prototype.map.call(elems, function(obj) {
 
 
    第三个参数被parseInt忽视了, but not the second one, 但不是第二个。因此可能出现混淆。下面是迭代步骤的简明示例：
    
 
-
    // parseInt(string, radix) -> map(parseInt(value, index))
+
    // parseInt(string, radix) -> map(parseInt(value, index))
 /*  first iteration (index is 0): */ parseInt("1", 0); // 1
 /* second iteration (index is 1): */ parseInt("2", 1); // NaN
 /*  third iteration (index is 2): */ parseInt("3", 2); // NaN
    
 
 
    下面让我们来讨论解决方案：
    
 
-
    function returnInt(element) {
+
    function returnInt(element) {
   return parseInt(element, 10);
 }
 
@@ -176,7 +176,7 @@ var values = Array.prototype.map.call(elems, function(obj) {
 
 
    一个map方法调用 parseInt 作为一个参数的等效输出运行如下:
    
 
-
    var xs = ['10', '10', '10'];
+
    var xs = ['10', '10', '10'];
 
 xs = xs.map(parseInt);
 
@@ -187,7 +187,7 @@ console.log(xs);  // 输出结果为(3) [10, NaN, 2]
 
 
    当返回undefined 或没有返回任何内容时:
    
 
-
    var numbers = [1, 2, 3, 4];
+
    var numbers = [1, 2, 3, 4];
 var filteredNumbers = numbers.map(function(num, index) {
   if(index < 3) {
      return num;
@@ -201,7 +201,7 @@ var filteredNumbers = numbers.map(function(num, index) {
 
 
    map was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of map in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming {{jsxref("Object")}}, {{jsxref("TypeError")}}, and {{jsxref("Array")}} have their original values and that callback.call evaluates to the original value of {{jsxref("Function.prototype.call")}}.
    
 
-
    // Production steps of ECMA-262, Edition 5, 15.4.4.19
+
    // Production steps of ECMA-262, Edition 5, 15.4.4.19
 // Reference: http://es5.github.io/#x15.4.4.19
 if (!Array.prototype.map) {
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/reduce/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/reduce/index.html
index f356bceaf6..cc217e28af 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/reduce/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/reduce/index.html
@@ -36,7 +36,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
 
 
    语法
    
 
-
    arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    
+
    arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    
 
 
    参数
    
 
@@ -89,7 +89,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
 
 
    提供初始值通常更安全，正如下面的例子，如果没有提供initialValue，则可能有四种输出：
    
 
-
    var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
+
    var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
 var maxCallback2 = ( max, cur ) => Math.max( max, cur );
 
 // reduce() 没有初始值
@@ -107,7 +107,7 @@ var maxCallback2 = ( max, cur ) => Math.max( max, cur );
 
 
    假如运行下段reduce()代码：
    
 
-
    [0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array){
+
    [0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array){
   return accumulator + currentValue;
 });
 
    
@@ -172,11 +172,11 @@ var maxCallback2 = ( max, cur ) => Math.max( max, cur );
 
 
    你还可以使用{{jsxref("Functions/Arrow_functions", "箭头函数","",1)}}来代替完整的函数。 下面的代码将产生与上面的代码相同的输出：
    
 
-
    [0, 1, 2, 3, 4].reduce((prev, curr) => prev + curr );
    
+
    [0, 1, 2, 3, 4].reduce((prev, curr) => prev + curr );
    
 
 
    如果你打算提供一个初始值作为reduce()方法的第二个参数，以下是运行过程及结果：
    
 
-
    [0, 1, 2, 3, 4].reduce((accumulator, currentValue, currentIndex, array) => {
+
    [0, 1, 2, 3, 4].reduce((accumulator, currentValue, currentIndex, array) => {
     return accumulator + currentValue
 }, 10)
 
    
@@ -332,14 +332,14 @@ var maxCallback2 = ( max, cur ) => Math.max( max, cur );
 
 
    数组里所有值的和
    
 
-
    var sum = [0, 1, 2, 3].reduce(function (accumulator, currentValue) {
+
    var sum = [0, 1, 2, 3].reduce(function (accumulator, currentValue) {
   return accumulator + currentValue;
 }, 0);
 // 和为 6
    
 
 
    你也可以写成箭头函数的形式：
    
 
-
    var total = [ 0, 1, 2, 3 ].reduce(
+
    var total = [ 0, 1, 2, 3 ].reduce(
   ( acc, cur ) => acc + cur,
   0
 );
    
@@ -348,7 +348,7 @@ var maxCallback2 = ( max, cur ) => Math.max( max, cur );
 
 
    要累加对象数组中包含的值，必须提供初始值，以便各个item正确通过你的函数。
    
 
-
    var initialValue = 0;
+
    var initialValue = 0;
 var sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {
     return accumulator + currentValue.x;
 },initialValue)
@@ -357,7 +357,7 @@ console.log(sum) // logs 6
    
 
 
    你也可以写成箭头函数的形式：
    
 
-
    var initialValue = 0;
+
    var initialValue = 0;
 var sum = [{x: 1}, {x:2}, {x:3}].reduce(
     (accumulator, currentValue) => accumulator + currentValue.x
     ,initialValue
@@ -368,7 +368,7 @@ console.log(sum) // logs 6
 
 
    将二维数组转化为一维
    
 
-
    var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
+
    var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
   function(a, b) {
     return a.concat(b);
   },
@@ -379,7 +379,7 @@ console.log(sum) // logs 6
 
 
    你也可以写成箭头函数的形式：
    
 
-
    var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
+
    var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
  ( acc, cur ) => acc.concat(cur),
  []
 );
@@ -388,7 +388,7 @@ console.log(sum) // logs 6
 
 
    计算数组中每个元素出现的次数
    
 
-
    var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
+
    var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
 
 var countedNames = names.reduce(function (allNames, name) {
   if (name in allNames) {
@@ -404,7 +404,7 @@ var countedNames = names.reduce(function (allNames, name) {
 
 
    按属性对object分类
    
 
-
    var people = [
+
    var people = [
   { name: 'Alice', age: 21 },
   { name: 'Max', age: 20 },
   { name: 'Jane', age: 20 }
@@ -434,7 +434,7 @@ var groupedPeople = groupBy(people, 'age');
 
 
    使用扩展运算符和initialValue绑定包含在对象数组中的数组
    
 
-
    // friends - 对象数组
+
    // friends - 对象数组
 // where object field "books" - list of favorite books
 var friends = [{
   name: 'Anna',
@@ -469,7 +469,7 @@ var allbooks = friends.reduce(function(prev, curr) {
 
    注意： 如果你正在使用一个可以兼容{{jsxref("Set")}} 和 {{jsxref("Array.from()")}} 的环境， 你可以使用let orderedArray = Array.from(new Set(myArray)); 来获得一个相同元素被移除的数组。
    
 
 
-
    let myArray = ['a', 'b', 'a', 'b', 'c', 'e', 'e', 'c', 'd', 'd', 'd', 'd']
+
    let myArray = ['a', 'b', 'a', 'b', 'c', 'e', 'e', 'c', 'd', 'd', 'd', 'd']
 let myOrderedArray = myArray.reduce(function (accumulator, currentValue) {
   if (accumulator.indexOf(currentValue) === -1) {
     accumulator.push(currentValue)
@@ -479,7 +479,7 @@ let myOrderedArray = myArray.reduce(function (accumulator, currentValue) {
 
 console.log(myOrderedArray)
    
 
-
    let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
+
    let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
 let result = arr.sort().reduce((init, current) => {
     if(init.length === 0 || init[init.length-1] !== current) {
         init.push(current);
@@ -490,7 +490,7 @@ console.log(result); //[1,2,3,4,5]
    
 
 
    按顺序运行Promise
    
 
-
    /**
+
    /**
  * Runs promises from array of functions that can return promises
  * in chained manner
  *
@@ -537,7 +537,7 @@ runPromiseInSequence(promiseArr, 10)
 
 
    功能型函数管道
    
 
-
    // Building-blocks to use for composition
+
    // Building-blocks to use for composition
 const double = x => x + x;
 const triple = x => 3 * x;
 const quadruple = x => 4 * x;
@@ -563,7 +563,7 @@ multiply24(10); // 240
 
 
    使用 reduce实现map
    
 
-
    if (!Array.prototype.mapUsingReduce) {
+
    if (!Array.prototype.mapUsingReduce) {
   Array.prototype.mapUsingReduce = function(callback, thisArg) {
     return this.reduce(function(mappedArray, currentValue, index, array) {
       mappedArray[index] = callback.call(thisArg, currentValue, index, array)
@@ -579,7 +579,7 @@ multiply24(10); // 240
 
 
    Polyfill
    
 
-
    // Production steps of ECMA-262, Edition 5, 15.4.4.21
+
    // Production steps of ECMA-262, Edition 5, 15.4.4.21
 // Reference: http://es5.github.io/#x15.4.4.21
 // https://tc39.github.io/ecma262/#sec-array.prototype.reduce
 if (!Array.prototype.reduce) {
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/reduceright/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/reduceright/index.html
index 94ef4c7602..1245486db3 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/reduceright/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/reduceright/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 
 
    语法
    
 
-
    arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    
+
    arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    
 
 
    参数
    
 
@@ -55,7 +55,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 
 
    可以像下面这样调用 reduceRight 的回调函数 callback：
    
 
-
    array.reduceRight(function(accumulator, currentValue, index, array) {
+
    array.reduceRight(function(accumulator, currentValue, index, array) {
   // ...
 });
    
 
@@ -111,7 +111,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 
 
    该函数的完整执行过程见下例：
    
 
-
    [0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+
    [0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
     return previousValue + currentValue;
 });
 
    
@@ -169,7 +169,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 
 
    如果提供了一个 initialValue 参数，则结果如下：
    
 
-
    [0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+
    [0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
     return previousValue + currentValue;
 }, 10);
 
    
@@ -235,14 +235,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 
 
    求一个数组中所有值的和
    
 
-
    var sum = [0, 1, 2, 3].reduceRight(function(a, b) {
+
    var sum = [0, 1, 2, 3].reduceRight(function(a, b) {
   return a + b;
 });
 // sum is 6
    
 
 
    扁平化（flatten）一个二维数组
    
 
-
    var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+
    var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
     return a.concat(b);
 }, []);
 // flattened is [4, 5, 2, 3, 0, 1]
@@ -250,7 +250,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
 
 
    运行一个带有回调每个函数将其结果传给下一个的异步函数列表
    
 
-
    const waterfall = (...functions) => (callback, ...args) =>
+
    const waterfall = (...functions) => (callback, ...args) =>
   functions.reduceRight(
     (composition, fn) => (...results) => fn(composition, ...results),
     callback
@@ -293,7 +293,7 @@ const computation2 = (input, callback) => {
 
 
    展示 reduce 与 reduceRight 之间的区别
    
 
-
    var a = ['1', '2', '3', '4', '5'];
+
    var a = ['1', '2', '3', '4', '5'];
 var left  = a.reduce(function(prev, cur)      { return prev + cur; });
 var right = a.reduceRight(function(prev, cur) { return prev + cur; });
 
@@ -304,7 +304,7 @@ console.log(right); // "54321"
    
 
 
    组合函数的概念简单，它只是简单地结合了多个函数。它是一个从右向左流动的函数，用上一个函数的输出调用每个函数。
    
 
-
    /**
+
    /**
  * Function Composition is way in which result of one function can
  * be passed to another and so on.
  *
@@ -333,7 +333,7 @@ console.log(compose(inc, double)(2)); // 5
    
 
 
    reduceRight 被添加到 ECMA-262 标准第 5 版，因此它在某些实现环境中可能不被支持。把下面的代码添加到脚本开头可以解决此问题，从而允许在那些没有原生支持 reduceRight 的实现环境中使用它。
    
 
-
    // Production steps of ECMA-262, Edition 5, 15.4.4.22
+
    // Production steps of ECMA-262, Edition 5, 15.4.4.22
 // Reference: http://es5.github.io/#x15.4.4.22
 if ('function' !== typeof Array.prototype.reduceRight) {
   Array.prototype.reduceRight = function(callback /*, initialValue*/) {
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/slice/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/slice/index.html
index eb68df4907..b69293d1db 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/slice/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/slice/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 
    语法
    
 
-
    arr.slice([begin[, end]])
    
+
    arr.slice([begin[, end]])
    
 
 
    参数
    
 
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
 
 
    返回现有数组的一部分
    
 
-
    var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
+
    var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
 var citrus = fruits.slice(1, 3);
 
 // fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
@@ -78,7 +78,7 @@ var citrus = fruits.slice(1, 3);
 
 
    在下例中, slice 从 myCar 中创建了一个新数组newCar。两个数组都包含了一个 myHonda 对象的引用。当 myHonda 的 color 属性改变为 purple，则两个数组中的对应元素都会随之改变。
    
 
-
    // 使用 slice 方法从 myCar 中创建一个 newCar。
+
    // 使用 slice 方法从 myCar 中创建一个 newCar。
 var myHonda = { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } };
 var myCar = [myHonda, 2, "cherry condition", "purchased 1997"];
 var newCar = myCar.slice(0, 2);
@@ -100,7 +100,7 @@ console.log('newCar[0].color = ' + newCar[0].color);
 
 
    上述代码输出：
    
 
-
     myCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2,
+
     myCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2,
        'cherry condition', 'purchased 1997']
 newCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2]
  myCar[0].color = red
@@ -114,7 +114,7 @@ newCar[0].color = purple
 
 
    slice 方法可以用来将一个类数组（Array-like）对象/集合转换成一个新数组。你只需将该方法绑定到这个对象上。 一个函数中的  {{jsxref("Functions/arguments", "arguments")}} 就是一个类数组对象的例子。
    
 
-
    function list() {
+
    function list() {
   return Array.prototype.slice.call(arguments);
 }
 
@@ -123,7 +123,7 @@ var list1 = list(1, 2, 3); // [1, 2, 3]
 
 
    除了使用 Array.prototype.slice.call(arguments)，你也可以简单的使用 [].slice.call(arguments) 来代替。另外，你可以使用 bind 来简化该过程。
    
 
-
    var unboundSlice = Array.prototype.slice;
+
    var unboundSlice = Array.prototype.slice;
 var slice = Function.prototype.call.bind(unboundSlice);
 
 function list() {
@@ -137,7 +137,7 @@ var list1 = list(1, 2, 3); // [1, 2, 3]
 
 
    根据规范，使用 Array.prototype.slice 转换宿主对象（如 DOM 对象）时，不必遵循 Mozilla 的默认行为，即可以转化任何符合条件的伪数组宿主对象为数组，IE < 9 没有遵循，而 IE9 + 遵循这个行为，但是稍加改造可以使其在跨浏览器使用时更可靠。只要其他现代浏览器继续支持该行为，目前 IE 9+、FireFox、Chrome、Safari 以及 Opera 都支持，开发者在使用下面代码时遍历 DOM 时就不会被该方法的字面意义误导，即 IE < 9 不能转化 DOM Collections。开发者可以安全地根据语义知道该方法的实际上的标准行为。（下面的代码还修正了 IE 中 slice() 方法第二个参数不允许为显式的 {{jsxref("Global_Objects/null", "null")}}/{{jsxref("Global_Objects/undefined", "undefined")}} 值的问题，其他现代浏览器，包括 IE9+ 都允许）。
    
 
-
    /**
+
    /**
  * Shim for "fixing" IE's lack of support (IE < 9) for applying slice
  * on host objects like NamedNodeMap, NodeList, and HTMLCollection
  * (technically, since host objects have been implementation-dependent,
diff --git a/files/zh-cn/web/javascript/reference/global_objects/array/values/index.html b/files/zh-cn/web/javascript/reference/global_objects/array/values/index.html
index 7af8b40436..d8cc03f53f 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/array/values/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/array/values/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/values
 
 
    语法
    
 
-
    arr.values()
    
+
    arr.values()
    
 
 
    返回值
    
 
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Array/values
 
 
    使用 for...of 循环进行迭代
    
 
-
    let arr = ['w', 'y', 'k', 'o', 'p'];
+
    let arr = ['w', 'y', 'k', 'o', 'p'];
 let eArr = arr.values();
 
 for (let letter of eArr) {
@@ -39,11 +39,11 @@ for (let letter of eArr) {
 
 
    Array.prototype.values 是 Array.prototype[Symbol.iterator] 的默认实现。
    
 
-
    Array.prototype.values === Array.prototype[Symbol.iterator]  // true 
    
+
    Array.prototype.values === Array.prototype[Symbol.iterator]  // true 
    
 
 
    使用 .next() 迭代
    
 
-
    var arr = ['a', 'b', 'c', 'd', 'e'];
+
    var arr = ['a', 'b', 'c', 'd', 'e'];
 var iterator = arr.values();
 iterator.next();               // Object { value: "a", done: false }
 iterator.next().value;         // "b"
@@ -59,7 +59,7 @@ iterator.next().value;         // undefined
    
 
 
    例子：
    
 
-
    var arr = ['a', 'b', 'c', 'd', 'e'];
+
    var arr = ['a', 'b', 'c', 'd', 'e'];
  var iterator = arr.values();
  for (let letter of iterator) {
  console.log(letter);
@@ -72,7 +72,7 @@ console.log(letter);
 
 
    值: 数组迭代器中存储的是原数组的地址，而不是数组元素值。
    
 
-
    var arr = ['a', 'b', 'c', 'd', 'e'];
+
    var arr = ['a', 'b', 'c', 'd', 'e'];
 var iterator = arr.values();
 console.log(iterator); // Array Iterator {  }
 iterator.next().value; // "a"
diff --git a/files/zh-cn/web/javascript/reference/global_objects/arraybuffer/index.html b/files/zh-cn/web/javascript/reference/global_objects/arraybuffer/index.html
index 0dde8cd36a..f58f460328 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/arraybuffer/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/arraybuffer/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
 
 
    语法
    
 
-
    new ArrayBuffer(length)
+
    new ArrayBuffer(length)
 
    
 
 
    参数
    
@@ -104,7 +104,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
 
 
    下面的例子创建了一个 8 字节的缓冲区，并使用一个 {{jsxref("Global_Objects/Int32Array", "Int32Array")}} 来引用它：
    
 
-
    var buffer = new ArrayBuffer(8);
+
    var buffer = new ArrayBuffer(8);
 var view   = new Int32Array(buffer);
 
    
 
@@ -143,11 +143,11 @@ var view   = new Int32Array(buffer);    
 
 
    从 ECMAScript 2015 开始，ArrayBuffer 对象需要用 {{jsxref("Operators/new", "new")}} 运算符创建。如果调用构造函数时没有使用 new，将会抛出 {{jsxref("TypeError")}}  异常。
    
 
-
    var dv = ArrayBuffer(10);
+
    var dv = ArrayBuffer(10);
 // TypeError: calling a builtin ArrayBuffer constructor
 // without new is forbidden
    
 
-
    var dv = new ArrayBuffer(10);
    
+
    var dv = new ArrayBuffer(10);
    
 
 
    相关链接
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/atomics/index.html b/files/zh-cn/web/javascript/reference/global_objects/atomics/index.html
index 838b6d8b99..2b3b3364a4 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/atomics/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/atomics/index.html
@@ -54,7 +54,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Atomics
 
 
    使用 Atomics
    
 
-
    const sab = new SharedArrayBuffer(1024);
+
    const sab = new SharedArrayBuffer(1024);
 const ta = new Uint8Array(sab);
 
 ta[0];
@@ -101,19 +101,19 @@ Atomics.load(ta, 0); // 4
 
 
    给定一个共享的 Int32Array：
    
 
-
    const sab = new SharedArrayBuffer(1024);
+
    const sab = new SharedArrayBuffer(1024);
 const int32 = new Int32Array(sab);
 
    
 
 
    读取线程正在休眠并位置0上等待。只要该位置应为0，它就不会继续。但是，一旦写入线程存储了新值，写入线程将通知它并返回新值（123）。
    
 
-
    Atomics.wait(int32, 0, 0);
+
    Atomics.wait(int32, 0, 0);
 console.log(int32[0]); // 123
 
    
 
 
    写入线程存储一个新值并再写入完成时通知等待线程：
    
 
-
    console.log(int32[0]); // 0;
+
    console.log(int32[0]); // 0;
 Atomics.store(int32, 0, 123);
 Atomics.notify(int32, 0, 1);
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/atomics/notify/index.html b/files/zh-cn/web/javascript/reference/global_objects/atomics/notify/index.html
index bf2399192c..6459625463 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/atomics/notify/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/atomics/notify/index.html
@@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/notify
 
 
    语法
    
 
-
    Atomics.notify(typedArray, index, count)
+
    Atomics.notify(typedArray, index, count)
 
    
 
 
    参数
    
@@ -47,18 +47,18 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/notify
 
 
    分配一个共享的 Int32Array：
    
 
-
    var sab = new SharedArrayBuffer(1024);
+
    var sab = new SharedArrayBuffer(1024);
 var int32 = new Int32Array(sab);
 
    
 
 
    一个读线程会进入休眠并监视索引0处的值（默认为0）。只要索引0处的值不为0，读进程就会唤醒。但是，一旦写进程存储了一个新的值，写进程就会产生一个提醒并返回写入后的新值（123）。（这里示例有问题或者说对初学者不友好，如果直接在浏览器控制台运行下面代码会报错，因为我们不能尝试睡眠主线程，可以见 重学js —— 结构化数据之Atomics对象，同时我在 codepen 写了一个示例：Atomics.wait使用示例）
    
 
-
    Atomics.wait(int32, 0, 0);
+
    Atomics.wait(int32, 0, 0);
 console.log(int32[0]); // 123
    
 
 
    写进程写入一个新值并告知等待进程已经写入成功了：
    
 
-
    console.log(int32[0]); // 0;
+
    console.log(int32[0]); // 0;
 Atomics.store(int32, 0, 123);
 Atomics.notify(int32, 0, 1);
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/bigint64array/index.html b/files/zh-cn/web/javascript/reference/global_objects/bigint64array/index.html
index 69b980e18b..23361908f2 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/bigint64array/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/bigint64array/index.html
@@ -111,7 +111,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/BigInt64Array
 
 
    不同的方法去创建一个 BigInt64Array
    
 
-
    // From a length
+
    // From a length
 var bigint64 = new BigInt64Array(2);
 bigint64[0] = 42n;
 console.log(bigint64[0]); // 42n
diff --git a/files/zh-cn/web/javascript/reference/global_objects/boolean/index.html b/files/zh-cn/web/javascript/reference/global_objects/boolean/index.html
index a236f20273..4101843056 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/boolean/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/boolean/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
 
 
    其值不是{{jsxref("undefined")}}或{{jsxref("null")}}的任何对象（包括其值为false的布尔对象）在传递给条件语句时都将计算为true。 例如，以下{{jsxref("Statements/if...else", "if")}}语句中的条件评估为true：
    
 
-
    var x = new Boolean(false);
+
    var x = new Boolean(false);
 if (x) {
   // 这里的代码会被执行
 }
@@ -27,7 +27,7 @@ if (x) {
 
 
    基本类型的布尔值不受此规则影响。例如下面的 {{jsxref("Statements/if...else", "if")}} 语句的条件为假：
    
 
-
    var x = false;
+
    var x = false;
 if (x) {
   // 这里的代码不会执行
 }
@@ -35,14 +35,14 @@ if (x) {
 
 
    不要用创建 Boolean 对象的方式将一个非布尔值转化成布尔值，直接将 Boolean 当做转换函数来使用即可，或者使用双重非（!!）运算符：
    
 
-
    var x = Boolean(expression);     // 推荐
+
    var x = Boolean(expression);     // 推荐
 var x = !!(expression);          // 推荐
 var x = new Boolean(expression); // 不太好
 
    
 
 
    对于任何对象，即使是值为 false 的 Boolean 对象，当将其传给 Boolean 函数时，生成的 Boolean 对象的值都是 true。
    
 
-
    var myFalse = new Boolean(false);   // true
+
    var myFalse = new Boolean(false);   // true
 var g = new Boolean(myFalse);       // true
 var myString = new String("Hello");
 var s = new Boolean(myString);      // true
@@ -74,7 +74,7 @@ var s = new Boolean(myString);      // true
 
 
    创建值为 false 的 Boolean 对象
    
 
-
    var bNoParam = new Boolean();
+
    var bNoParam = new Boolean();
 var bZero = new Boolean(0);
 var bNull = new Boolean(null);
 var bEmptyString = new Boolean('');
@@ -83,7 +83,7 @@ var bfalse = new Boolean(false);
 
 
    创建值为 true 的  Boolean 对象
    
 
-
    var btrue = new Boolean(true);
+
    var btrue = new Boolean(true);
 var btrueString = new Boolean('true');
 var bfalseString = new Boolean('false');
 var bSuLin = new Boolean('Su Lin');
diff --git a/files/zh-cn/web/javascript/reference/global_objects/date/index.html b/files/zh-cn/web/javascript/reference/global_objects/date/index.html
index 152caed1a0..2c8e41406b 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/date/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/date/index.html
@@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Date
 
 
    语法
    
 
-
    new Date();
+
    new Date();
 new Date(value);
 new Date(dateString);
 new Date(year, monthIndex [, day [, hours [, minutes [, seconds [, milliseconds]]]]]);
    
@@ -147,7 +147,7 @@ new Date(year, monthIndex [, day [, hours<
 
    注意: 由于浏览器差异和不一致性，强烈建议不要使用Date构造函数（和Date.parse，它们是等效的）解析日期字符串。
    
 
 
-
    var today = new Date();
+
    var today = new Date();
 var birthday = new Date('December 17, 1995 03:24:00');
 var birthday = new Date('1995-12-17T03:24:00');
 var birthday = new Date(1995, 11, 17);
@@ -158,7 +158,7 @@ var birthday = new Date(1995, 11, 17, 3, 24, 0);
 
 
    为了创建和获取 0 到 99 之间的年份，应使用 {{jsxref("Date.prototype.setFullYear()")}} 和 {{jsxref("Date.prototype.getFullYear()")}} 方法。
    
 
-
    var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
+
    var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
 
 // 已弃用的方法, 同样将 98 映射为 1998
 date.setYear(98);           // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)
@@ -172,7 +172,7 @@ date.setFullYear(98);       // Sat Feb 01 0098 00:00:00 GMT+0000 (BST)
 
 
    由于不同日期、月份、年份长度的不同（日期长度不同来自夏令时的切换），使用大于秒、分钟、小时的单位表示经过的时间会遇到很多问题，在使用前需要经过详尽的调研。
    
 
-
    // 使用 Date 对象
+
    // 使用 Date 对象
 var start = Date.now();
 
 // 调用一个消耗一定时间的方法：
@@ -180,7 +180,7 @@ doSomethingForALongTime();
 var end = Date.now();
 var elapsed = end - start; // 以毫秒计的运行时长
    
 
-
    // 使用内建的创建方法
+
    // 使用内建的创建方法
 var start = new Date();
 
 // 调用一个消耗一定时间的方法：
@@ -188,7 +188,7 @@ doSomethingForALongTime();
 var end = new Date();
 var elapsed = end.getTime() - start.getTime(); // 运行时间的毫秒值
    
 
-
    // to test a function and get back its return
+
    // to test a function and get back its return
 function printElapsedTime (fTest) {
     var nStartTime = Date.now(),
         vReturn = fTest(),
@@ -205,7 +205,7 @@ yourFunctionReturn = printElapsedTime(yourFunction);
 
 
    获取自 Unix 起始时间以来经过的秒数
    
 
-
    var seconds = Math.floor(Date.now() / 1000);
    
+
    var seconds = Math.floor(Date.now() / 1000);
    
 
 
    注意此处需要返回一个整数 （仅做除法得到的不是整数），并且需要返回实际已经经过的秒数（所以这里使用了{{jsxref("Math.floor()")}}而不是{{jsxref("Math.round()")}}).
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/encodeuricomponent/index.html b/files/zh-cn/web/javascript/reference/global_objects/encodeuricomponent/index.html
index dd30f152b1..2864496ff8 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/encodeuricomponent/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/encodeuricomponent/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
 
 
    语法
    
 
-
    encodeURIComponent(str);
    
+
    encodeURIComponent(str);
    
 
 
    参数
    
 
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
 
 
    encodeURIComponent 转义除了如下所示外的所有字符：
    
 
-
    不转义的字符：
+
    不转义的字符：
     A-Z a-z 0-9 - _ . ! ~ * ' ( )
    
 
 
    encodeURIComponent() 和 encodeURI 有以下几个不同点：
    
@@ -54,7 +54,7 @@ console.log(encodeURIComponent(set4)); // ABC%20abc%20123 (the space gets encode
 
 
    注意，如果试图编码一个非高-低位完整的代理字符，将会抛出一个 {{jsxref("URIError")}} 错误，例如：
    
 
-
    // 高低位完整
+
    // 高低位完整
 alert(encodeURIComponent('\uD800\uDFFF'));
 
 // 只有高位，将抛出"URIError: malformed URI sequence"
@@ -69,7 +69,7 @@ alert(encodeURIComponent('\uDFFF')); 
    
 
 
    为了更严格的遵循 {{rfc("3986")}}（它保留 !, ', (, ), 和 *），即使这些字符并没有正式划定 URI 的用途，下面这种方式是比较安全的：
    
 
-
    function fixedEncodeURIComponent (str) {
+
    function fixedEncodeURIComponent (str) {
   return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
     return '%' + c.charCodeAt(0).toString(16).toUpperCase();
   });
@@ -79,7 +79,7 @@ alert(encodeURIComponent('\uDFFF')); 
    
 
 
    下面这个例子提供了 UTF-8 下 {{HTTPHeader("Content-Disposition")}} 和 {{HTTPHeader("Link")}} 的服务器响应头信息的参数（例如 UTF-8 文件名)：
    
 
-
    var fileName = 'my file(2).txt';
+
    var fileName = 'my file(2).txt';
 var header = "Content-Disposition: attachment; filename*=UTF-8''"
              + encodeRFC5987ValueChars(fileName);
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/finalizationregistry/index.html b/files/zh-cn/web/javascript/reference/global_objects/finalizationregistry/index.html
index 10e720eb80..5dbd569caf 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/finalizationregistry/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/finalizationregistry/index.html
@@ -21,14 +21,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
 
 
    你在回调中创建了如下的 registry：
    
 
-
    const registry = new FinalizationRegistry(heldValue => {
+
    const registry = new FinalizationRegistry(heldValue => {
   // ....
 });
 
    
 
 
    然后，你可以通过调用`register`方法，注册任何你想要清理回调的对象，传入该对象和*所含的值*。
    
 
-
    registry.register(theObject, "some value");
+
    registry.register(theObject, "some value");
 
    
 
 
    The registry does not keep a strong reference to the object, as that would defeat the purpose (if the registry held it strongly, the object would never be reclaimed).
    
@@ -39,14 +39,14 @@ translation_of: Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
 
 
    It's common to use the object itself as the unregister token, which is just fine:
    
 
-
    registry.register(theObject, "some value", theObject);
+
    registry.register(theObject, "some value", theObject);
 // ...some time later, if you don't care about `theObject` anymore...
 registry.unregister(theObject);
 
    
 
 
    It doesn't have to be the same object, though; it can be a different one:
    
 
-
    registry.register(theObject, "some value", tokenObject);
+
    registry.register(theObject, "some value", tokenObject);
 // ...some time later, if you don't care about `theObject` anymore...
 registry.unregister(tokenObject);
 
    
@@ -108,7 +108,7 @@ registry.unregister(tokenObject);
 
 
    You create the registry passing in the callback:
    
 
-
    const registry = new FinalizationRegistry(heldValue => {
+
    const registry = new FinalizationRegistry(heldValue => {
   // ....
 });
 
    
@@ -117,7 +117,7 @@ registry.unregister(tokenObject);
 
 
    Then you register any objects you want a cleanup callback for by calling the `register` method, passing in the object and a *held value* for it:
    
 
-
    registry.register(theObject, "some value");
    
+
    registry.register(theObject, "some value");
    
 
 
    Specifications
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/function/apply/index.html b/files/zh-cn/web/javascript/reference/global_objects/function/apply/index.html
index d345215619..944791e29c 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/function/apply/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/function/apply/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
 
 
    语法
    
 
-
    func.apply(thisArg, [argsArray])
    
+
    func.apply(thisArg, [argsArray])
    
 
 
    参数
    
 
@@ -58,7 +58,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
 
 
    apply正派上用场！
    
 
-
    var array = ['a', 'b'];
+
    var array = ['a', 'b'];
 var elements = [0, 1, 2];
 array.push.apply(array, elements);
 console.info(array); // ["a", "b", 0, 1, 2]
@@ -70,7 +70,7 @@ console.info(array); // ["a", "b", 0, 1, 2]
 
 
    下面是示例，我们将用Math.max/Math.min求得数组中的最大/小值。
    
 
-
    /* 找出数组中最大/小的数字 */
+
    /* 找出数组中最大/小的数字 */
 var numbers = [5, 6, 2, 3, 7];
 
 /* 使用Math.min/Math.max以及apply 函数时的代码 */
@@ -91,7 +91,7 @@ for (var i = 0; i < numbers.length; i++) {
 
 
    如果你的参数数组可能非常大，那么推荐使用下面这种混合策略：将数组切块后循环传入目标方法：
    
 
-
    function minOfArray(arr) {
+
    function minOfArray(arr) {
   var min = Infinity;
   var QUANTUM = 32768;
 
@@ -110,7 +110,7 @@ var min = minOfArray([5, 6, 2, 3, 7]);
 
 
    你可以使用apply来链接一个对象构造器，类似于Java。在接下来的例子中我们会创建一个全局Function 对象的construct方法 ，来使你能够在构造器中使用一个类数组对象而非参数列表。
    
 
-
    Function.prototype.construct = function (aArgs) {
+
    Function.prototype.construct = function (aArgs) {
   var oNew = Object.create(this.prototype);
   this.apply(oNew, aArgs);
   return oNew;
@@ -122,7 +122,7 @@ var min = minOfArray([5, 6, 2, 3, 7]);
 
 
    Using {{jsxref("Object/__proto__", "Object.__proto__")}}:
    
 
-
    Function.prototype.construct = function (aArgs) {
+
    Function.prototype.construct = function (aArgs) {
   var oNew = {};
   oNew.__proto__ = this.prototype;
   this.apply(oNew, aArgs);
@@ -131,7 +131,7 @@ var min = minOfArray([5, 6, 2, 3, 7]);
 
 
    使用闭包：
    
 
-
    Function.prototype.construct = function(aArgs) {
+
    Function.prototype.construct = function(aArgs) {
   var fConstructor = this, fNewConstr = function() {
     fConstructor.apply(this, aArgs);
   };
@@ -141,7 +141,7 @@ var min = minOfArray([5, 6, 2, 3, 7]);
 
 
    使用 Function 构造器：
    
 
-
    Function.prototype.construct = function (aArgs) {
+
    Function.prototype.construct = function (aArgs) {
   var fNewConstr = new Function("");
   fNewConstr.prototype = this.prototype;
   var oNew = new fNewConstr();
@@ -152,7 +152,7 @@ var min = minOfArray([5, 6, 2, 3, 7]);
 
 
    使用示例：
    
 
-
    function MyConstructor (arguments) {
+
    function MyConstructor (arguments) {
     for (var nProp = 0; nProp < arguments.length; nProp++) {
         this["property" + nProp] = arguments[nProp];
     }
diff --git a/files/zh-cn/web/javascript/reference/global_objects/function/bind/index.html b/files/zh-cn/web/javascript/reference/global_objects/function/bind/index.html
index c612abb1df..8940da5ad4 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/function/bind/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/function/bind/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
 
 
    语法
    
 
-
    function.bind(thisArg[, arg1[, arg2[, ...]]])
    
+
    function.bind(thisArg[, arg1[, arg2[, ...]]])
    
 
 
    参数
    
 
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
 
 
    bind() 最简单的用法是创建一个函数，不论怎么调用，这个函数都有同样的 this 值。JavaScript新手经常犯的一个错误是将一个方法从对象中拿出来，然后再调用，期望方法中的 this 是原来的对象（比如在回调中传入这个方法）。如果不做特殊处理的话，一般会丢失原来的对象。基于这个函数，用原始的对象创建一个绑定函数，巧妙地解决了这个问题：
    
 
-
    this.x = 9;    // 在浏览器中，this 指向全局的 "window" 对象
+
    this.x = 9;    // 在浏览器中，this 指向全局的 "window" 对象
 var module = {
   x: 81,
   getX: function() { return this.x; }
@@ -85,7 +85,7 @@ boundGetX(); // 81
 
 
    bind() 的另一个最简单的用法是使一个函数拥有预设的初始参数。只要将这些参数（如果有的话）作为 bind() 的参数写在 this 后面。当绑定函数被调用时，这些参数会被插入到目标函数的参数列表的开始位置，传递给绑定函数的参数会跟在它们后面。
    
 
-
    function list() {
+
    function list() {
   return Array.prototype.slice.call(arguments);
 }
 
@@ -120,7 +120,7 @@ var result3 = addThirtySeven(5, 10);
 
 
    在默认情况下，使用 {{ domxref("window.setTimeout()") }} 时，this 关键字会指向 {{ domxref("window") }} （或 global）对象。当类的方法中需要 this 指向类的实例时，你可能需要显式地把 this 绑定到回调函数，就不会丢失该实例的引用。
    
 
-
    function LateBloomer() {
+
    function LateBloomer() {
   this.petalCount = Math.ceil(Math.random() * 12) + 1;
 }
 
@@ -145,7 +145,7 @@ flower.bloom();  // 一秒钟后, 调用 'declare' 方法
    
 
 
    绑定函数自动适应于使用 {{jsxref("Operators/new", "new")}} 操作符去构造一个由目标函数创建的新实例。当一个绑定函数是用来构建一个值的，原来提供的 this 就会被忽略。不过提供的参数列表仍然会插入到构造函数调用时的参数列表之前。
    
 
-
    function Point(x, y) {
+
    function Point(x, y) {
   this.x = x;
   this.y = y;
 }
@@ -178,7 +178,7 @@ new YAxisPoint(17, 42) instanceof Point; // true
    
 
 
    请注意，你不需要做特别的处理就可以创建一个和 {{jsxref("Operators/new", "new")}} 操作符一起使用的绑定函数。也就是说，你不需要做特别处理就可以创建一个可以被直接调用的绑定函数，即使你更希望绑定函数是用 {{jsxref("Operators/new", "new")}} 操作符来调用。
    
 
-
    // ...接着上面的代码继续的话，
+
    // ...接着上面的代码继续的话，
 // 这个例子可以直接在你的 JavaScript 控制台运行
 
 // 仍然能作为一个普通函数来调用
@@ -196,7 +196,7 @@ emptyObj.x + ',' + emptyObj.y;   //  '0,13'
 
 
    你可以用 {{jsxref("Array.prototype.slice")}} 来将一个类似于数组的对象（array-like object）转换成一个真正的数组，就拿它来举例子吧。你可以简单地这样写：
    
 
-
    var slice = Array.prototype.slice;
+
    var slice = Array.prototype.slice;
 
 // ...
 
@@ -204,7 +204,7 @@ slice.apply(arguments);
    
 
 
    用 bind()可以使这个过程变得简单。在下面这段代码里面，slice 是 {{jsxref("Function.prototype")}} 的 {{jsxref("Function.prototype.apply()", "apply()")}} 方法的绑定函数，并且将 {{jsxref("Array.prototype")}} 的 {{jsxref("Array.prototype.slice()", "slice()")}} 方法作为 this 的值。这意味着我们压根儿用不着上面那个 apply()调用了。
    
 
-
    // 与前一段代码的 "slice" 效果相同
+
    // 与前一段代码的 "slice" 效果相同
 var unboundSlice = Array.prototype.slice;
 var slice = Function.prototype.apply.bind(unboundSlice);
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/globalthis/index.html b/files/zh-cn/web/javascript/reference/global_objects/globalthis/index.html
index e3c5d1b0a2..a4dc9510c1 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/globalthis/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/globalthis/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/globalThis
 
 
    语法
    
 
-
    globalThis
    
+
    globalThis
    
 
 
    描述
    
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/globalThis
 
 
    在 globalThis 之前，获取某个全局对象的唯一方式就是 Function('return this')()，但是这在某些情况下会违反 CSP 规则，所以，es6-shim 使用了类似如下的方式：
    
 
-
    var getGlobal = function () {
+
    var getGlobal = function () {
   if (typeof self !== 'undefined') { return self; }
   if (typeof window !== 'undefined') { return window; }
   if (typeof global !== 'undefined') { return global; }
@@ -62,7 +62,7 @@ if (typeof globals.setTimeout !== 'function') {
 
 
    但是有了 globalThis 之后，只需要：
    
 
-
    if (typeof globalThis.setTimeout !== 'function') {
+
    if (typeof globalThis.setTimeout !== 'function') {
   //  此环境中没有 setTimeout 方法！
 }
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/infinity/index.html b/files/zh-cn/web/javascript/reference/global_objects/infinity/index.html
index 3181d4b7ff..f20755f907 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/infinity/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/infinity/index.html
@@ -25,7 +25,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
 
 
    示例
    
 
-
    console.log(Infinity          ); /* Infinity */
+
    console.log(Infinity          ); /* Infinity */
 console.log(Infinity + 1      ); /* Infinity */
 console.log(Math.pow(10, 1000)); /* Infinity */
 console.log(Math.log(0)       ); /* -Infinity */
diff --git a/files/zh-cn/web/javascript/reference/global_objects/intl/locale/index.html b/files/zh-cn/web/javascript/reference/global_objects/intl/locale/index.html
index 181d9dc0bf..08af53d8fa 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/intl/locale/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/intl/locale/index.html
@@ -64,13 +64,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale
 
 
    很简单，就是需要给{{jsxref("Locale/Locale", "Intl.Locale")}} 构造函数传入一个 locale 标识字符串作为参数：
    
 
-
    let us = new Intl.Locale('zh-Hans-CN');
    
+
    let us = new Intl.Locale('zh-Hans-CN');
    
 
 
    使用配置实例化
    
 
 
    构造函数支持传入 object 作为配置，object 中可包含多个配置属性。例如，设置 hourCycle 属性，用于设置您所需要的小时周期类型：
    
 
-
    let zh12hour = new Intl.Locale("zh-Hans-CN", {hourCycle: "h12"});
+
    let zh12hour = new Intl.Locale("zh-Hans-CN", {hourCycle: "h12"});
 console.log(zh12hour.hourCycle); // Prints "h12"
    
 
 
    规范
    
diff --git a/files/zh-cn/web/javascript/reference/global_objects/intl/relativetimeformat/index.html b/files/zh-cn/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
index 561af8a1fe..a05c3385dd 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
 
 
    句法
    
 
-
    new Intl.RelativeTimeFormat([locales[, options]])
+
    new Intl.RelativeTimeFormat([locales[, options]])
 
    
 
 
    参数
    
@@ -84,7 +84,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
 
 
    以下示例显示如何使用英语创建相对时间格式化程序。
    
 
-
    //在语言环境中创建相对时间格式化程序
+
    //在语言环境中创建相对时间格式化程序
 //显式传入默认值。
 const rtf = new Intl.RelativeTimeFormat("en",{
     localeMatcher: "bestfit",//其他值："lookup"
@@ -104,7 +104,7 @@ rtf.format(1,"day");
 
 
    如果numeric:auto选项被传递,它将生成字符串yesterday或tomorrow代替1 day ago或in 1 day。这允许不必总是在输出中使用数值。
    
 
-
    //在语言环境中创建相对时间格式化程序
+
    //在语言环境中创建相对时间格式化程序
 //使用数字：传入"auto"选项值。
 const rtf = new Intl.RelativeTimeFormat("en",{numeric: "auto"});
 
@@ -121,7 +121,7 @@ rtf.format(1,"day");
 
 
    以下示例显示如何创建返回格式化部件的相对时间格式器
    
 
-
    const rtf = new Intl.RelativeTimeFormat("en",{numeric: "auto"});
+
    const rtf = new Intl.RelativeTimeFormat("en",{numeric: "auto"});
 
 //使用日期单位格式化相对时间。
 rtf.formatToParts(-1,"day");
diff --git a/files/zh-cn/web/javascript/reference/global_objects/json/stringify/index.html b/files/zh-cn/web/javascript/reference/global_objects/json/stringify/index.html
index 3ccfd067d3..ac4e1cdd67 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/json/stringify/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/json/stringify/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify
 
 
    语法
    
 
-
    JSON.stringify(value[, replacer [, space]])
+
    JSON.stringify(value[, replacer [, space]])
 
    
 
 
    参数
    
@@ -64,7 +64,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify
 
 
    使用 JSON.stringify
    
 
-
    JSON.stringify({});                        // '{}'
+
    JSON.stringify({});                        // '{}'
 JSON.stringify(true);                      // 'true'
 JSON.stringify("foo");                     // '"foo"'
 JSON.stringify([1, "false", false]);       // '[1,"false",false]'
@@ -134,7 +134,7 @@ JSON.stringify(
 
 
    例子(function)
    
 
-
    function replacer(key, value) {
+
    function replacer(key, value) {
   if (typeof value === "string") {
     return undefined;
   }
@@ -150,18 +150,18 @@ var jsonString = JSON.stringify(foo, replacer);
    
 
 
    如果 replacer 是一个数组，数组的值代表将被序列化成 JSON 字符串的属性名。
    
 
-
    JSON.stringify(foo, ['week', 'month']);
+
    JSON.stringify(foo, ['week', 'month']);
 // '{"week":45,"month":7}', 只保留 “week” 和 “month” 属性值。
    
 
 
    space 参数
    
 
 
    space 参数用来控制结果字符串里面的间距。如果是一个数字, 则在字符串化时每一级别会比上一级别缩进多这个数字值的空格（最多10个空格）；如果是一个字符串，则每一级别会比上一级别多缩进该字符串（或该字符串的前10个字符）。
    
 
-
    JSON.stringify({ a: 2 }, null, " ");   // '{\n "a": 2\n}'
    
+
    JSON.stringify({ a: 2 }, null, " ");   // '{\n "a": 2\n}'
    
 
 
    使用制表符（\t）来缩进：
    
 
-
    JSON.stringify({ uno: 1, dos : 2 }, null, '\t')
+
    JSON.stringify({ uno: 1, dos : 2 }, null, '\t')
 // '{            \
 //     "uno": 1, \
 //     "dos": 2  \
@@ -172,7 +172,7 @@ var jsonString = JSON.stringify(foo, replacer);
    
 
 
    如果一个被序列化的对象拥有 toJSON 方法，那么该 toJSON 方法就会覆盖该对象默认的序列化行为：不是该对象被序列化，而是调用 toJSON 方法后的返回值会被序列化，例如：
    
 
-
    var obj = {
+
    var obj = {
   foo: 'foo',
   toJSON: function () {
     return 'bar';
@@ -186,7 +186,7 @@ JSON.stringify({x: obj}); // '{"x":"bar"}'
 
 
    注意 JSON 不是 JavaScript 严格意义上的子集，在 JSON 中不需要省略两条终线（Line separator 和 Paragraph separator），但在 JavaScript 中需要被省略。因此，如果 JSON 被用作 JSONP 时，下面方法可以使用：
    
 
-
    function jsFriendlyJSONStringify (s) {
+
    function jsFriendlyJSONStringify (s) {
     return JSON.stringify(s).
         replace(/\u2028/g, '\\u2028').
         replace(/\u2029/g, '\\u2029');
@@ -213,7 +213,7 @@ alert(jsFriendlyJSONStringify(s)); // {"a":"\u2028","b":"\u2029"}
    
 
 
    一些时候，你想存储用户创建的一个对象，并且，即使在浏览器被关闭后仍能恢复该对象。下面的例子是 JSON.stringify 适用于这种情形的一个样板：
    
 
-
    // 创建一个示例数据
+
    // 创建一个示例数据
 var session = {
     'screens' : [],
     'state' : true
diff --git a/files/zh-cn/web/javascript/reference/global_objects/map/foreach/index.html b/files/zh-cn/web/javascript/reference/global_objects/map/foreach/index.html
index 76ef36556e..50b701e541 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/map/foreach/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/map/foreach/index.html
@@ -22,7 +22,7 @@ browser-compat: javascript.builtins.Map.forEach
 
 
    语法
    
 
-
    myMap.forEach(callback([value][,key][,map])[, thisArg])
    
+
    myMap.forEach(callback([value][,key][,map])[, thisArg])
    
 
 
    参数
    
 
@@ -72,7 +72,7 @@ browser-compat: javascript.builtins.Map.forEach
 
 
    以下的代码在每行中打印一个 Map 对象中的元素
    
 
-
    function logMapElements(value, key, map) {
+
    function logMapElements(value, key, map) {
     console.log(`map.get('${key}') = ${value}`)
 }
 new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements)
diff --git a/files/zh-cn/web/javascript/reference/global_objects/map/keys/index.html b/files/zh-cn/web/javascript/reference/global_objects/map/keys/index.html
index 59c1b50654..87758cf8f3 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/map/keys/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/map/keys/index.html
@@ -22,7 +22,7 @@ browser-compat: javascript.builtins.Map.keys
 
 
    语法
    
 
-
    myMap.keys()
    
+
    myMap.keys()
    
 
 
    返回值
    
 
@@ -32,7 +32,7 @@ browser-compat: javascript.builtins.Map.keys
 
 
    使用 keys()
    
 
-
    var myMap = new Map();
+
    var myMap = new Map();
 myMap.set("0", "foo");
 myMap.set(1, "bar");
 myMap.set({}, "baz");
diff --git a/files/zh-cn/web/javascript/reference/global_objects/math/floor/index.html b/files/zh-cn/web/javascript/reference/global_objects/math/floor/index.html
index 530f15a033..6a8bb13fc2 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/math/floor/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/math/floor/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor
 
 
    语法
    
 
-
    Math.floor(x) 
    
+
    Math.floor(x) 
    
 
 
    参数
    
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor
 
 
    例子：使用 Math.floor
    
 
-
    Math.floor( 45.95);
+
    Math.floor( 45.95);
 // 45
 Math.floor( 45.05);
 // 45
@@ -54,7 +54,7 @@ Math.floor(-45.95);
 
 
    例子：十进制调整
    
 
-
    // Closure
+
    // Closure
 (function(){
 
 	/**
diff --git a/files/zh-cn/web/javascript/reference/global_objects/math/random/index.html b/files/zh-cn/web/javascript/reference/global_objects/math/random/index.html
index e25608ec05..91796ae506 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/math/random/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/math/random/index.html
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 
 
    语法
    
 
-
    Math.random()
    
+
    Math.random()
    
 
 
    返回值
    
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 
 
    得到一个大于等于0，小于1之间的随机数
    
 
-
    function getRandom() {
+
    function getRandom() {
   return Math.random();
 }
    
 
@@ -41,7 +41,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 
 
    这个例子返回了一个在指定值之间的随机数。这个值不小于 min（有可能等于），并且小于（不等于）max。
    
 
-
    function getRandomArbitrary(min, max) {
+
    function getRandomArbitrary(min, max) {
   return Math.random() * (max - min) + min;
 }
 
    
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 
 
    这个例子返回了一个在指定值之间的随机整数。这个值不小于 min （如果 min 不是整数，则不小于 min 的向上取整数），且小于（不等于）max。
    
 
-
    function getRandomInt(min, max) {
+
    function getRandomInt(min, max) {
   min = Math.ceil(min);
   max = Math.floor(max);
   return Math.floor(Math.random() * (max - min)) + min; //不含最大值，含最小值
@@ -64,7 +64,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
 
 
    上一个例子提到的函数 getRandomInt() 结果范围包含了最小值，但不含最大值。如果你的随机结果需要同时包含最小值和最大值，怎么办呢?  getRandomIntInclusive() 函数可以实现。
    
 
-
    function getRandomIntInclusive(min, max) {
+
    function getRandomIntInclusive(min, max) {
   min = Math.ceil(min);
   max = Math.floor(max);
   return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/math/sin/index.html b/files/zh-cn/web/javascript/reference/global_objects/math/sin/index.html
index 989c5af7e5..a08cda8912 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/math/sin/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/math/sin/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin
 
 
    语法
    
 
-
    Math.sin(x)
    
+
    Math.sin(x)
    
 
 
    参数
    
 
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin
 
 
    例子：使用 Math.sin
    
 
-
    Math.sin(0);           // 0
+
    Math.sin(0);           // 0
 Math.sin(1);           // 0.8414709848078965
 
 Math.sin(Math.PI / 2); // 1
    
diff --git a/files/zh-cn/web/javascript/reference/global_objects/math/sinh/index.html b/files/zh-cn/web/javascript/reference/global_objects/math/sinh/index.html
index c9f0d376f9..1682a0ba73 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/math/sinh/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/math/sinh/index.html
@@ -11,7 +11,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh
 
 
    语法
    
 
-
    Math.sinh(x)
    
+
    Math.sinh(x)
    
 
 
    参数
    
 
@@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh
 
 
    示例
    
 
-
    Math.sinh(0)      // 0
+
    Math.sinh(0)      // 0
 Math.sinh(1)      // 1.1752011936438014
 Math.sinh("-1")   // -1.1752011936438014
 Math.sinh("foo")  // NaN
@@ -55,7 +55,7 @@ Math.sinh("foo")  // NaN
 
 
    该函数可以使用 {{jsxref("Math.exp()")}} 函数来实现:
    
 
-
    function sinh(x){
+
    function sinh(x){
     return  (Math.exp(x) - Math.exp(-x)) / 2;
 }
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/number/isfinite/index.html b/files/zh-cn/web/javascript/reference/global_objects/number/isfinite/index.html
index aef163cfb6..47a2ee8f0b 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/number/isfinite/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/number/isfinite/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite
 
 
    语法
    
 
-
    Number.isFinite(value)
    
+
    Number.isFinite(value)
    
 
 
    参数
    
 
@@ -36,13 +36,13 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite
 
 
    Polyfill
    
 
-
    if (Number.isFinite === undefined) Number.isFinite = function(value) {
+
    if (Number.isFinite === undefined) Number.isFinite = function(value) {
     return typeof value === 'number' && isFinite(value);
 }
    
 
 
    示例
    
 
-
    Number.isFinite(Infinity);  // false
+
    Number.isFinite(Infinity);  // false
 Number.isFinite(NaN);       // false
 Number.isFinite(-Infinity); // false
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/number/number/index.html b/files/zh-cn/web/javascript/reference/global_objects/number/number/index.html
index e539061589..604944ab1b 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/number/number/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/number/number/index.html
@@ -9,7 +9,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/Number
 
 
    语法
    
 
-
    new Number(value)
+
    new Number(value)
 
    
 
 
    参数
    
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Number/Number
 
 
    创建 Number 对象
    
 
-
    const a = new Number('123'); // a === 123 is false
+
    const a = new Number('123'); // a === 123 is false
 const b = Number('123');     // b === 123 is true
 a instanceof Number;         // is true
 b instanceof Number;         // is false
    
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/assign/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/assign/index.html
index 1e1080be00..080c859773 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/assign/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/assign/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
 
 
    语法
    
 
-
    Object.assign(target, ...sources)
    
+
    Object.assign(target, ...sources)
    
 
 
    参数
    
 
@@ -53,7 +53,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
 
 
    这个 polyfill 不支持 symbol 属性, 由于 ES5 中本来就不存在 symbols :
    
 
-
    if (typeof Object.assign !== 'function') {
+
    if (typeof Object.assign !== 'function') {
   // Must be writable: true, enumerable: false, configurable: true
   Object.defineProperty(Object, "assign", {
     value: function assign(target, varArgs) { // .length of function is 2
@@ -87,7 +87,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
 
 
    复制一个对象
    
 
-
    const obj = { a: 1 };
+
    const obj = { a: 1 };
 const copy = Object.assign({}, obj);
 console.log(copy); // { a: 1 }
 
    
@@ -98,7 +98,7 @@ console.log(copy); // { a: 1 }
 
 
    假如源值是一个对象的引用，它仅仅会复制其引用值。
    
 
-
    const log = console.log;
+
    const log = console.log;
 
 function test() {
   'use strict';
@@ -139,7 +139,7 @@ test();
 
 
    合并对象
    
 
-
    const o1 = { a: 1 };
+
    const o1 = { a: 1 };
 const o2 = { b: 2 };
 const o3 = { c: 3 };
 
@@ -150,7 +150,7 @@ console.log(o1);  // { a: 1, b: 2, c: 3 }, 注意目标对象自身也会改变
 
 
    合并具有相同属性的对象
    
 
-
    const o1 = { a: 1, b: 1, c: 1 };
+
    const o1 = { a: 1, b: 1, c: 1 };
 const o2 = { b: 2, c: 2 };
 const o3 = { c: 3 };
 
@@ -161,7 +161,7 @@ console.log(obj); // { a: 1, b: 2, c: 3 }
    
 
 
    拷贝 symbol 类型的属性
    
 
-
    const o1 = { a: 1 };
+
    const o1 = { a: 1 };
 const o2 = { [Symbol('foo')]: 2 };
 
 const obj = Object.assign({}, o1, o2);
@@ -170,7 +170,7 @@ Object.getOwnPropertySymbols(obj); // [Symbol(foo)]
    
 
 
    继承属性和不可枚举属性是不能拷贝的
    
 
-
    const obj = Object.create({foo: 1}, { // foo 是个继承属性。
+
    const obj = Object.create({foo: 1}, { // foo 是个继承属性。
     bar: {
         value: 2  // bar 是个不可枚举属性。
     },
@@ -186,7 +186,7 @@ console.log(copy); // { baz: 3 }
 
 
    原始类型会被包装为对象
    
 
-
    const v1 = "abc";
+
    const v1 = "abc";
 const v2 = true;
 const v3 = 10;
 const v4 = Symbol("foo")
@@ -198,7 +198,7 @@ console.log(obj); // { "0": "a", "1": "b", "2": "c" }
    
 
 
    异常会打断后续拷贝任务
    
 
-
    const target = Object.defineProperty({}, "foo", {
+
    const target = Object.defineProperty({}, "foo", {
     value: 1,
     writable: false
 }); // target 的 foo 属性是个只读属性。
@@ -216,7 +216,7 @@ console.log(target.baz);  // undefined，第三个源对象更是不会被拷贝
 
 
    拷贝访问器
    
 
-
    const obj = {
+
    const obj = {
   foo: 1,
   get bar() {
     return 2;
@@ -255,7 +255,7 @@ console.log(copy);
 
 
    此{{Glossary("Polyfill","polyfill")}}不支持 symbol 属性，因为ES5 中根本没有 symbol ：
    
 
-
    if (typeof Object.assign != 'function') {
+
    if (typeof Object.assign != 'function') {
   // Must be writable: true, enumerable: false, configurable: true
   Object.defineProperty(Object, "assign", {
     value: function assign(target, varArgs) { // .length of function is 2
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/create/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/create/index.html
index 073605d77f..671c542a48 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/create/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/create/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
 
 
    语法
    
 
-
    Object.create(proto，[propertiesObject])
    
+
    Object.create(proto，[propertiesObject])
    
 
 
    参数
    
 
@@ -45,7 +45,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
 
 
    下面的例子演示了如何使用Object.create()来实现类式继承。这是一个所有版本JavaScript都支持的单继承。
    
 
-
    // Shape - 父类(superclass)
+
    // Shape - 父类(superclass)
 function Shape() {
   this.x = 0;
   this.y = 0;
@@ -77,7 +77,7 @@ rect.move(1, 1); // Outputs, 'Shape moved.'
    
 
 
    如果你希望能继承到多个对象，则可以使用混入的方式。
    
 
-
    function MyClass() {
+
    function MyClass() {
      SuperClass.call(this);
      OtherSuperClass.call(this);
 }
@@ -98,7 +98,7 @@ MyClass.prototype.myMethod = function() {
 
 
    使用 Object.create 的 propertyObject参数
    
 
-
    var o;
+
    var o;
 
 // 创建一个原型为null的空对象
 o = Object.create(null);
@@ -167,7 +167,7 @@ o2 = Object.create({}, {
 
 
    请注意，尽管在 ES5 中 Object.create支持设置为[[Prototype]]为null，但因为那些ECMAScript5以前版本限制，此 polyfill 无法支持该特性。
    
 
-
    if (typeof Object.create !== "function") {
+
    if (typeof Object.create !== "function") {
     Object.create = function (proto, propertiesObject) {
         if (typeof proto !== 'object' && typeof proto !== 'function') {
             throw new TypeError('Object prototype may only be an Object: ' + proto);
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/defineproperties/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/defineproperties/index.html
index 483bcdf234..e4d9e9ef7a 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/defineproperties/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/defineproperties/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
 
 
    语法
    
 
-
    Object.defineProperties(obj, props)
    
+
    Object.defineProperties(obj, props)
    
 
 
    参数
    
 
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
 
 
    例子
    
 
-
    var obj = {};
+
    var obj = {};
 Object.defineProperties(obj, {
   'property1': {
     value: true,
@@ -80,7 +80,7 @@ Object.defineProperties(obj, {
 
 
    假设一个原始的执行环境，所有的名称和属性都引用它们的初始值，Object.defineProperties几乎完全等同于（注意isCallable中的注释）以下JavaScript中的重新实现：
    
 
-
    function defineProperties(obj, properties) {
+
    function defineProperties(obj, properties) {
   function convertToDescriptor(desc) {
     function hasProperty(obj, prop) {
       return Object.prototype.hasOwnProperty.call(obj, prop);
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/defineproperty/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/defineproperty/index.html
index c711f8b4d5..b37662d5ab 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/defineproperty/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/defineproperty/index.html
@@ -25,7 +25,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
 
 
    语法
    
 
-
    Object.defineProperty(obj, prop, descriptor)
    
+
    Object.defineProperty(obj, prop, descriptor)
    
 
 
    参数
    
 
@@ -135,7 +135,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
 
 
    记住，这些选项不一定是自身属性，也要考虑继承来的属性。为了确认保留这些默认值，在设置之前，可能要冻结 {{jsxref("Object.prototype")}}，明确指定所有的选项，或者通过 {{jsxref("Object.create", "Object.create(null)")}} 将 {{jsxref("Object.prototype.__proto__", "__proto__")}} 属性指向 {{jsxref("null")}}。
    
 
-
    // 使用 __proto__
+
    // 使用 __proto__
 var obj = {};
 var descriptor = Object.create(null); // 没有继承的属性
 // 默认没有 enumerable，没有 configurable，没有 writable
@@ -178,7 +178,7 @@ Object.defineProperty(obj, "key", withValue("static"));
 
 
    如果对象中不存在指定的属性，Object.defineProperty() 会创建这个属性。当描述符中省略某些字段时，这些字段将使用它们的默认值。
    
 
-
    var o = {}; // 创建一个新对象
+
    var o = {}; // 创建一个新对象
 
 // 在对象中添加一个属性与数据描述符的示例
 Object.defineProperty(o, "a", {
@@ -225,7 +225,7 @@ Object.defineProperty(o, "conflict", {
 
 
    当 writable 属性设置为 false 时，该属性被称为“不可写的”。它不能被重新赋值。
    
 
-
    var o = {}; // 创建一个新对象
+
    var o = {}; // 创建一个新对象
 
 Object.defineProperty(o, 'a', {
   value: 37,
@@ -256,7 +256,7 @@ console.log(o.a); // logs 37. The assignment didn't work.
 
 
    enumerable 定义了对象的属性是否可以在 {{jsxref("Statements/for...in", "for...in")}} 循环和 {{jsxref("Object.keys()")}} 中被枚举。
    
 
-
    var o = {};
+
    var o = {};
 Object.defineProperty(o, "a", { value : 1, enumerable: true });
 Object.defineProperty(o, "b", { value : 2, enumerable: false });
 Object.defineProperty(o, "c", { value : 3 }); // enumerable 默认为 false
@@ -296,7 +296,7 @@ p[Symbol.for('f')] // undefined
    
 
 
    configurable 特性表示对象的属性是否可以被删除，以及除 value 和 writable 特性外的其他特性是否可以被修改。
    
 
-
    var o = {};
+
    var o = {};
 Object.defineProperty(o, 'a', {
   get() { return 1; },
   configurable: false
@@ -329,7 +329,7 @@ console.log(o.a); // logs 1
    
 
 
    考虑特性被赋予的默认特性值非常重要，通常，使用点运算符和 Object.defineProperty() 为对象的属性赋值时，数据描述符中的属性默认值是不同的，如下例所示。
    
 
-
    var o = {};
+
    var o = {};
 
 o.a = 1;
 // 等同于：
@@ -356,7 +356,7 @@ Object.defineProperty(o, "a", {
 
 
    下面的例子展示了如何实现一个自存档对象。当设置temperature 属性时，archive 数组会收到日志条目。
    
 
-
    function Archiver() {
+
    function Archiver() {
   var temperature = null;
   var archive = [];
 
@@ -382,7 +382,7 @@ arc.getArchive(); // [{ val: 11 }, { val: 13 }]
    
 
 
    下面这个例子中，getter 总是会返回一个相同的值。
    
 
-
    var pattern = {
+
    var pattern = {
     get: function () {
         return 'I alway return this string,whatever you have assigned';
     },
@@ -409,7 +409,7 @@ console.log(instance.myname);
    
 
 
    如果访问者的属性是被继承的，它的 get 和 set 方法会在子对象的属性被访问或者修改时被调用。如果这些方法用一个变量存值，该值会被所有对象共享。
    
 
-
    function myclass() {
+
    function myclass() {
 }
 
 var value;
@@ -430,7 +430,7 @@ console.log(b.x); // 1
 
 
    这可以通过将值存储在另一个属性中解决。在 get 和 set 方法中，this 指向某个被访问和修改属性的对象。
    
 
-
    function myclass() {
+
    function myclass() {
 }
 
 Object.defineProperty(myclass.prototype, "x", {
@@ -449,7 +449,7 @@ console.log(b.x); // undefined
    
 
 
    不像访问者属性，值属性始终在对象自身上设置，而不是一个原型。然而，如果一个不可写的属性被继承，它仍然可以防止修改对象的属性。
    
 
-
    function myclass() {
+
    function myclass() {
 }
 
 myclass.prototype.x = 1;
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/fromentries/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/fromentries/index.html
index 80cb1de95a..d7b9c46865 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/fromentries/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/fromentries/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/fromEntries
 
 
    语法
    
 
-
    Object.fromEntries(iterable);
    
+
    Object.fromEntries(iterable);
    
 
 
    参数
    
 
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/fromEntries
 
 
    通过 Object.fromEntries， 可以将 {{jsxref("Map")}} 转换为 {{jsxref("Object")}}:
    
 
-
    const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
+
    const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
 const obj = Object.fromEntries(map);
 console.log(obj); // { foo: "bar", baz: 42 }
 
    
@@ -47,7 +47,7 @@ console.log(obj); // { foo: "bar", baz: 42 }
 
 
    通过 Object.fromEntries， 可以将 {{jsxref("Array")}} 转换为 {{jsxref("Object")}}:
    
 
-
    const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
+
    const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
 const obj = Object.fromEntries(arr);
 console.log(obj); // { 0: "a", 1: "b", 2: "c" }
 
    
@@ -56,7 +56,7 @@ console.log(obj); // { 0: "a", 1: "b", 2: "c" }
 
 
    Object.fromEntries 是与 {{jsxref("Object.entries()")}} 相反的方法，用 数组处理函数 可以像下面这样转换对象：
    
 
-
    const object1 = { a: 1, b: 2, c: 3 };
+
    const object1 = { a: 1, b: 2, c: 3 };
 
 const object2 = Object.fromEntries(
   Object.entries(object1)
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
index a5b4088128..08874a06e8 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDes
 
 
    语法
    
 
-
    Object.getOwnPropertyDescriptor(obj, prop)
    
+
    Object.getOwnPropertyDescriptor(obj, prop)
    
 
 
    参数
    
 
@@ -54,7 +54,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDes
 
 
    示例
    
 
-
    var o, d;
+
    var o, d;
 
 o = { get foo() { return 17; } };
 d = Object.getOwnPropertyDescriptor(o, "foo");
@@ -92,7 +92,7 @@ d = Object.getOwnPropertyDescriptor(o, "baz");
 
 
    在 ES5 中，如果该方法的第一个参数不是对象（而是原始类型），那么就会产生出现 {{jsxref("TypeError")}}。而在 ES2015，第一个的参数不是对象的话就会被强制转换为对象。
    
 
-
    Object.getOwnPropertyDescriptor('foo', 0);
+
    Object.getOwnPropertyDescriptor('foo', 0);
 // 类型错误: "foo" 不是一个对象  // ES5 code
 
 Object.getOwnPropertyDescriptor('foo', 0);
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/hasownproperty/index.html
index 70f5f307d6..b0c254e52a 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/hasownproperty/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/hasownproperty/index.html
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
 
 
    语法
    
 
-
    obj.hasOwnProperty(prop)
    
+
    obj.hasOwnProperty(prop)
    
 
 
    参数
    
 
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
 
 
    即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true。
    
 
-
    o = new Object();
+
    o = new Object();
 o.propOne = null;
 o.hasOwnProperty('propOne'); // 返回 true
 o.propTwo = undefined;
@@ -56,7 +56,7 @@ o.hasOwnProperty('propTwo'); // 返回 true
 
 
    下面的例子检测了对象 o 是否含有自身属性 prop：
    
 
-
    o = new Object();
+
    o = new Object();
 o.hasOwnProperty('prop'); // 返回 false
 o.prop = 'exists';
 o.hasOwnProperty('prop'); // 返回 true
@@ -68,7 +68,7 @@ o.hasOwnProperty('prop'); // 返回 false
 
 
    下面的例子演示了 hasOwnProperty 方法对待自身属性和继承属性的区别：
    
 
-
    o = new Object();
+
    o = new Object();
 o.prop = 'exists';
 o.hasOwnProperty('prop');             // 返回 true
 o.hasOwnProperty('toString');         // 返回 false
@@ -79,7 +79,7 @@ o.hasOwnProperty('hasOwnProperty');   // 返回 false
 
 
    下面的例子演示了如何在遍历一个对象的所有属性时忽略掉继承属性，注意这里 {{jsxref("Statements/for...in", "for...in")}}  循环只会遍历可枚举属性，所以不应该基于这个循环中没有不可枚举的属性而得出 hasOwnProperty 是严格限制于可枚举项目的（如同 {{jsxref("Object.getOwnPropertyNames()")}}）。
    
 
-
    var buz = {
+
    var buz = {
   fog: 'stack'
 };
 
@@ -98,7 +98,7 @@ for (var name in buz) {
 
 
    JavaScript 并没有保护 hasOwnProperty 这个属性名，因此，当某个对象可能自有一个占用该属性名的属性时，就需要使用外部的 hasOwnProperty 获得正确的结果：
    
 
-
    var foo = {
+
    var foo = {
   hasOwnProperty: function() {
     return false;
   },
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/index.html
index cd90b70b07..e143a7d49d 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/index.html
@@ -139,24 +139,24 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object
 
 
    下面的例子将一个空的 Object 对象存到 o 中：
    
 
-
    var o = new Object();
+
    var o = new Object();
 
    
 
-
    var o = new Object(undefined);
+
    var o = new Object(undefined);
 
    
 
-
    var o = new Object(null);
+
    var o = new Object(null);
 
    
 
 
    使用 Object 生成布尔对象
    
 
 
    下面的例子将{{jsxref("Boolean")}} 对象存到 o 中：
    
 
-
    // 等价于 o = new Boolean(true);
+
    // 等价于 o = new Boolean(true);
 var o = new Object(true);
 
    
 
-
    // 等价于 o = new Boolean(false);
+
    // 等价于 o = new Boolean(false);
 var o = new Object(Boolean());
 
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/is/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/is/index.html
index 9c3aff1abd..04a528b7b8 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/is/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/is/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
 
    语法
    
 
 
    
- 
    Object.is(value1, value2);
    
+ 
    Object.is(value1, value2);
    
 
 
 
    参数
    
@@ -59,7 +59,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
 
 
    Polyfill
    
 
-
    if (!Object.is) {
+
    if (!Object.is) {
   Object.is = function(x, y) {
     // SameValue algorithm
     if (x === y) { // Steps 1-5, 7-10
@@ -99,7 +99,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
 
 
    使用 Object.is
    
 
-
    Object.is('foo', 'foo');     // true
+
    Object.is('foo', 'foo');     // true
 Object.is(window, window);   // true
 
 Object.is('foo', 'bar');     // false
diff --git a/files/zh-cn/web/javascript/reference/global_objects/object/issealed/index.html b/files/zh-cn/web/javascript/reference/global_objects/object/issealed/index.html
index d4bb3a438e..e6a895f345 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/object/issealed/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/object/issealed/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isSealed
 
 
    语法
    
 
-
    Object.isSealed(obj)
    
+
    Object.isSealed(obj)
    
 
 
    参数
    
 
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Object/isSealed
 
 
    例子
    
 
-
    // 新建的对象默认不是密封的.
+
    // 新建的对象默认不是密封的.
 var empty = {};
 Object.isSealed(empty); // === false
 
@@ -72,7 +72,7 @@ Object.isFrozen(s3); // === true ，访问器属性不考虑可写不可写,只
 
 
    在ES5中，如果这个方法的参数不是一个对象（一个原始类型），那么它会导致{{jsxref("TypeError")}}。在ES2015中，非对象参数将被视为是一个密封的普通对象，只返回true。
    
 
-
    Object.isSealed(1);
+
    Object.isSealed(1);
 // TypeError: 1 is not an object (ES5 code)
 
 Object.isSealed(1);
diff --git a/files/zh-cn/web/javascript/reference/global_objects/parseint/index.html b/files/zh-cn/web/javascript/reference/global_objects/parseint/index.html
index 2bbf25fe98..cf2555558b 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/parseint/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/parseint/index.html
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
 
 
    语法
    
 
-
    parseInt(string, radix);
    
+
    parseInt(string, radix);
    
 
 
    参数
    
 
@@ -48,7 +48,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
  
  • 第一个非空格字符不能转换为数字。
    • 
 
 
-
    parseInt('123', 5) // 将'123'看作5进制数，返回十进制数38 => 1*5^2 + 2*5^1 + 3*5^0 = 38
    
+
    parseInt('123', 5) // 将'123'看作5进制数，返回十进制数38 => 1*5^2 + 2*5^1 + 3*5^0 = 38
    
 
 
    描述
    
 
@@ -89,7 +89,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
 
 
    以下例子均返回15:
    
 
-
    parseInt("0xF", 16);
+
    parseInt("0xF", 16);
 parseInt("F", 16);
 parseInt("17", 8);
 parseInt(021, 8);
@@ -105,13 +105,13 @@ parseInt("12", 13);
    
 
 
    以下例子均返回 NaN:
    
 
-
    parseInt("Hello", 8); // 根本就不是数值
+
    parseInt("Hello", 8); // 根本就不是数值
 parseInt("546", 2);   // 除了“0、1”外，其它数字都不是有效二进制数字
 
    
 
 
    以下例子均返回 -15：
    
 
-
    parseInt("-F", 16);
+
    parseInt("-F", 16);
 parseInt("-0F", 16);
 parseInt("-0XF", 16);
 parseInt(-15.1, 10);
@@ -124,19 +124,19 @@ parseInt("-12", 13);
 
 
    下例中全部返回 4:
    
 
-
    parseInt(4.7, 10);
+
    parseInt(4.7, 10);
 parseInt(4.7 * 1e22, 10); // 非常大的数值变成 4
 parseInt(0.00000000000434, 10); // 非常小的数值变成 4
    
 
 
    下面的例子返回 224
    
 
-
    parseInt("0e0",16);
    
+
    parseInt("0e0",16);
    
 
 
    没有指定 radix 参数时的八进制解析
    
 
 
    尽管 ECMAScript 3 已经不赞成这种做法，且 ECMAScript 5 已经禁止了这种做法，但是仍然有很多实现环境仍然把以 0 开头的数值字符串（numeric string）解释为一个八进制数。下面的例子可能返回八进制的结果，也可能返回十进制的结果。总是指定一个基数（radix）可以避免这种不可靠的行为。
    
 
-
    parseInt("0e0");
+
    parseInt("0e0");
 // 0
 
 parseInt("08");
@@ -157,7 +157,7 @@ parseInt("08");
 
 
    有时采用一个更严格的方法来解析整型值很有用。此时可以使用正则表达式：
    
 
-
    filterInt = function (value) {
+
    filterInt = function (value) {
   if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value))
     return Number(value);
   return NaN;
diff --git a/files/zh-cn/web/javascript/reference/global_objects/promise/all/index.html b/files/zh-cn/web/javascript/reference/global_objects/promise/all/index.html
index c2d22ae1cd..113760c25d 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/promise/all/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/promise/all/index.html
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
 
 
    语法
    
 
-
    Promise.all(iterable);
    
+
    Promise.all(iterable);
    
 
 
    参数
    
 
@@ -56,7 +56,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
 
 
    Promise.all 等待所有都完成（或第一个失败）。
    
 
-
    var p1 = Promise.resolve(3);
+
    var p1 = Promise.resolve(3);
 var p2 = 1337;
 var p3 = new Promise((resolve, reject) => {
   setTimeout(resolve, 100, 'foo');
@@ -68,7 +68,7 @@ Promise.all([p1, p2, p3]).then(values => {
 
 
    如果参数中包含非 promise 值，这些值将被忽略，但仍然会被放在返回数组中（如果 promise 完成的话）：
    
 
-
    // this will be counted as if the iterable passed is empty, so it gets fulfilled
+
    // this will be counted as if the iterable passed is empty, so it gets fulfilled
 var p = Promise.all([1,2,3]);
 // this will be counted as if the iterable passed contains only the resolved promise with value "444", so it gets fulfilled
 var p2 = Promise.all([1,2,3, Promise.resolve(444)]);
@@ -91,7 +91,7 @@ setTimeout(function(){
 
 
    下面的例子中演示了 Promise.all 的异步性（如果传入的可迭代对象是空的，就是同步）：
    
 
-
    // we are passing as argument an array of promises that are already resolved,
+
    // we are passing as argument an array of promises that are already resolved,
 // to trigger Promise.all as soon as possible
 var resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];
 
@@ -113,7 +113,7 @@ setTimeout(function(){
 
 
    如果 Promise.all 失败，也是一样的：
    
 
-
    var mixedPromisesArray = [Promise.resolve(33), Promise.reject(44)];
+
    var mixedPromisesArray = [Promise.resolve(33), Promise.reject(44)];
 var p = Promise.all(mixedPromisesArray);
 console.log(p);
 setTimeout(function(){
@@ -129,7 +129,7 @@ setTimeout(function(){
 
 
    但是，Promise.all 当且仅当传入的可迭代对象为空时为同步：
    
 
-
    var p = Promise.all([]); // will be immediately resolved
+
    var p = Promise.all([]); // will be immediately resolved
 var p2 = Promise.all([1337, "hi"]); // non-promise values will be ignored, but the evaluation will be done asynchronously
 console.log(p);
 console.log(p2)
@@ -149,7 +149,7 @@ setTimeout(function(){
 
 
    Promise.all 在任意一个传入的 promise 失败时返回失败。例如，如果你传入的 promise中，有四个 promise 在一定的时间之后调用成功函数，有一个立即调用失败函数，那么 Promise.all 将立即变为失败。
    
 
-
    var p1 = new Promise((resolve, reject) => {
+
    var p1 = new Promise((resolve, reject) => {
   setTimeout(resolve, 1000, 'one');
 });
 var p2 = new Promise((resolve, reject) => {
diff --git a/files/zh-cn/web/javascript/reference/global_objects/promise/allsettled/index.html b/files/zh-cn/web/javascript/reference/global_objects/promise/allsettled/index.html
index a448dfb79b..d6ceaaa2ad 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/promise/allsettled/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/promise/allsettled/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/allSettled
 
 
    句法
    
 
-
    Promise.allSettled(iterable);
    
+
    Promise.allSettled(iterable);
    
 
 
    参数
    
 
diff --git a/files/zh-cn/web/javascript/reference/global_objects/promise/any/index.html b/files/zh-cn/web/javascript/reference/global_objects/promise/any/index.html
index 25e87a91af..b61b833f5f 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/promise/any/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/promise/any/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/any
 
 
    语法
    
 
-
    Promise.any(iterable);
    
+
    Promise.any(iterable);
    
 
 
    参数
    
 
@@ -63,7 +63,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise/any
 
 
    即使第一个返回的 promise 是失败的，Promise.any() 依然使用第一个成功状态的 promise 来返回。这与使用首个（无论 rejected 还是 fullfiled）promise 来返回的 {{jsxref("Promise.race()")}} 相反。
    
 
-
    const pErr = new Promise((resolve, reject) => {
+
    const pErr = new Promise((resolve, reject) => {
   reject("总是失败");
 });
 
@@ -86,7 +86,7 @@ Promise.any([pErr, pSlow, pFast]).then((value) => {
 
 
    如果没有 fulfilled (成功的) promise，Promise.any() 返回 {{jsxref("AggregateError")}} 错误。
    
 
-
    const pErr = new Promise((resolve, reject) => {
+
    const pErr = new Promise((resolve, reject) => {
   reject('总是失败');
 });
 
@@ -100,7 +100,7 @@ Promise.any([pErr]).catch((err) => {
 
 
    在这个例子，我们有一个获取图片并返回 blob 的函数，我们使用 Promise.any() 来获取一些图片并显示第一张有效的图片（即最先 resolved 的那个 promise）。
    
 
-
    function fetchAndDecode(url) {
+
    function fetchAndDecode(url) {
   return fetch(url).then(response => {
     if(!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`);
diff --git a/files/zh-cn/web/javascript/reference/global_objects/promise/index.html b/files/zh-cn/web/javascript/reference/global_objects/promise/index.html
index 3dd832b401..31420f60c5 100644
--- a/files/zh-cn/web/javascript/reference/global_objects/promise/index.html
+++ b/files/zh-cn/web/javascript/reference/global_objects/promise/index.html
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Global_Objects/Promise
 
 
    我们可以用 promise.then()，promise.catch() 和 promise.finally() 这些方法将进一步的操作与一个变为已敲定状态的 promise 关联起来。这些方法还会返回一个新生成的 promise 对象，这个对象可以被非强制性的用来做链式调用，就像这样：
    
 
-
    const myPromise =
+
    const myPromise =
   (new Promise(myExecutorFunc))
   .then(handleFulfilledA,handleRejectedA)
   .then(handleFulfilledB,handleRejectedB)
@@ -65,7 +65,7 @@ const myPromise =
 
 
    这两个函数的签名很简单，它们只接受一个任意类型的参数。这些函数由您（编程者）编写。这些函数的终止状态决定着链式调用中下一个promise的"已敲定 （settled）"状态是什么。任何不是 throw 的终止都会创建一个"已决议（resolved）"状态，而以 throw 终止则会创建一个"已拒绝"状态。
    
 
-
    handleFulfilled(value)       { /*...*/; return nextValue;  }
+
    handleFulfilled(value)       { /*...*/; return nextValue;  }
 handleRejection(reason)  { /*...*/; throw  nextReason; }
 handleRejection(reason)  { /*...*/; return nextValue;  }
    
 
@@ -75,21 +75,21 @@ handleRejection(reason)  { /*...*/; return nextValue;  }
    
 
 
    链式调用中的 promise 们就像俄罗斯套娃一样，是嵌套起来的，但又像是一个栈，每个都必须从顶端被弹出。链式调用中的第一个 promise 是嵌套最深的一个，也将是第一个被弹出的。
    
 
-
    (promise D, (promise C, (promise B, (promise A) ) ) )
    
+
    (promise D, (promise C, (promise B, (promise A) ) ) )
    
 
 
    当存在一个 nextValue 是 promise 时，就会出现一种动态的替换效果。return 会导致一个 promise 被弹出，但这个 nextValue promise 则会被推入被弹出 promise 原来的位置。对于上面所示的嵌套场景，假设与 "promise B" 相关的 .then() 返回了一个值为 "promise X" 的 nextValue 。那么嵌套的结果看起来就会是这样：
    
 
-
    (promise D, (promise C, (promise X) ) )
    
+
    (promise D, (promise C, (promise X) ) )
    
 
 
    一个 promise 可能会参与不止一次的嵌套。对于下面的代码，promiseA 向"已敲定"（"settled"）状态的过渡会导致两个实例的 .then 都被调用。
    
 
-
    const promiseA = new Promise(myExecutorFunc);
+
    const promiseA = new Promise(myExecutorFunc);
 const promiseB = promiseA.then(handleFulfilled1, handleRejected1);
 const promiseC = promiseA.then(handleFulfilled2, handleRejected2); 
    
 
 
    一个已经处于"已敲定"（"settled"）状态的 promise 也可以接收操作。在那种情况下，（如果没有问题的话，）这个操作会被作为第一个异步操作被执行。注意，所有的 promise 都一定是异步的。因此，一个已经处于"已敲定"（"settled"）状态的 promise 中的操作只有 promise 链式调用的栈被清空了和一个事件循环过去了之后才会被执行。这种效果跟 setTimeout(action, 10) 特别相似。
    
 
-
    const promiseA = new Promise( (resolutionFunc,rejectionFunc) => {
+
    const promiseA = new Promise( (resolutionFunc,rejectionFunc) => {
     resolutionFunc(777);
 });
 // 这时，"promiseA" 已经被敲定了。
@@ -155,7 +155,7 @@ console.log("immediate logging");
 
 
    Promise 对象是由关键字 new 及其构造函数来创建的。该构造函数会把一个叫做“处理器函数”（executor function）的函数作为它的参数。这个“处理器函数”接受两个函数——resolve 和 reject ——作为其参数。当异步任务顺利完成且返回结果值时，会调用 resolve 函数；而当异步任务失败且返回失败原因（通常是一个错误对象）时，会调用reject 函数。
    
 
-
    const myFirstPromise = new Promise((resolve, reject) => {
+
    const myFirstPromise = new Promise((resolve, reject) => {
   // ?做一些异步操作，最终会调用下面两者之一:
   //
   //   resolve(someValue); // fulfilled
@@ -165,7 +165,7 @@ console.log("immediate logging");
 
 
    想要某个函数拥有promise功能，只需让其返回一个promise即可。
    
 
-
    function myAsyncFunction(url) {
+
    function myAsyncFunction(url) {
   return new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest();
     xhr.open("GET", url);
@@ -179,7 +179,7 @@ console.log("immediate logging");
 
 
    基础示例
    
 
-
    let myFirstPromise = new Promise(function(resolve, reject){
+
    let myFirstPromise = new Promise(function(resolve, reject){
     //当异步代码执行成功时，我们才会调用resolve(...), 当异步代码失败时就会调用reject(...)
     //在本例中，我们使用setTimeout(...)来模拟异步代码，实际编码时可能是XHR请求或是HTML5的一些API方法.
     setTimeout(function(){
@@ -196,7 +196,7 @@ myFirstPromise.then(function(successMessage){
 
 
    高级示例
    
 
-
    
 
    
 
-
    .    9 (base 10) = 00000000000000000000000000001001 (base 2)
+
    .    9 (base 10) = 00000000000000000000000000001001 (base 2)
     14 (base 10) = 00000000000000000000000000001110 (base 2)
                    --------------------------------
 14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
@@ -74,7 +74,7 @@ After:              10100000000000000110000000000001
    
 
 
    使用按位与
    
 
-
    // 5: 00000000000000000000000000000101
+
    // 5: 00000000000000000000000000000101
 // 2: 00000000000000000000000000000010
 5 & 2; // 0
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/bitwise_and_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/bitwise_and_assignment/index.html
index 5c92f0196c..05df4461d6 100644
--- a/files/zh-cn/web/javascript/reference/operators/bitwise_and_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/bitwise_and_assignment/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND_assignment
 
 
    语法
    
 
-
    Operator: x &= y
+
    Operator: x &= y
 Meaning:  x  = x & y
 
    
 
@@ -27,7 +27,7 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_AND_assignment
 
 
    按位与赋值运算
    
 
-
    let a = 5;
+
    let a = 5;
 // 5:     00000000000000000000000000000101
 // 2:     00000000000000000000000000000010
 a &= 2; // 0
    
diff --git a/files/zh-cn/web/javascript/reference/operators/bitwise_not/index.html b/files/zh-cn/web/javascript/reference/operators/bitwise_not/index.html
index ff285826b0..416bb69347 100644
--- a/files/zh-cn/web/javascript/reference/operators/bitwise_not/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/bitwise_not/index.html
@@ -19,14 +19,14 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_NOT
 
 
    语法
    
 
-
    ~a
+
    ~a
 
    
 
 
    描述
    
 
 
    操作数被转换为32位二进制表示（0和1）。超过32位的数字将丢弃其最高有效位。如下例子中，超过32位的整数转换为32位整数：
    
 
-
    Before: 11100110111110100000000000000110000000000001
+
    Before: 11100110111110100000000000000110000000000001
 After:              10100000000000000110000000000001
    
 
 
    第一个操作数中的每个位都与第二个操作数中的相应位配对：第一位到第一位，第二位到第二位，依此类推。
    
@@ -54,7 +54,7 @@ After:              10100000000000000110000000000001
    
  
 
 
-
     9 (base 10) = 00000000000000000000000000001001 (base 2)
+
     9 (base 10) = 00000000000000000000000000001001 (base 2)
                --------------------------------
 ~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
 
    
@@ -69,7 +69,7 @@ After:              10100000000000000110000000000001
    
 
 
    使用按位取反
    
 
-
    ~0;  // -1
+
    ~0;  // -1
 ~-1; // 0
 ~1;  // -2
 
    
diff --git a/files/zh-cn/web/javascript/reference/operators/bitwise_or/index.html b/files/zh-cn/web/javascript/reference/operators/bitwise_or/index.html
index dcd9c54de0..245da8fdab 100644
--- a/files/zh-cn/web/javascript/reference/operators/bitwise_or/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/bitwise_or/index.html
@@ -13,14 +13,14 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_OR
 
 
    语法
    
 
-
    a | b
+
    a | b
 
    
 
 
    描述
    
 
 
    The operands are converted to 32-bit integers and expressed by a series of bits (zeroes and ones). Numbers with more than 32 bits get their most significant bits discarded. For example, the following integer with more than 32 bits will be converted to a 32 bit integer:
    
 
-
    Before: 11100110111110100000000000000110000000000001
+
    Before: 11100110111110100000000000000110000000000001
 After:              10100000000000000110000000000001
    
 
 
    Each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on.
    
@@ -61,7 +61,7 @@ After:              10100000000000000110000000000001
    
  
 
 
-
    .    9 (base 10) = 00000000000000000000000000001001 (base 2)
+
    .    9 (base 10) = 00000000000000000000000000001001 (base 2)
     14 (base 10) = 00000000000000000000000000001110 (base 2)
                    --------------------------------
 14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
@@ -73,7 +73,7 @@ After:              10100000000000000110000000000001
    
 
 
    Using bitwise OR
    
 
-
    // 9  (00000000000000000000000000001001)
+
    // 9  (00000000000000000000000000001001)
 // 14 (00000000000000000000000000001110)
 
 14 | 9;
diff --git a/files/zh-cn/web/javascript/reference/operators/bitwise_or_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/bitwise_or_assignment/index.html
index 752a80154a..fad4f94082 100644
--- a/files/zh-cn/web/javascript/reference/operators/bitwise_or_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/bitwise_or_assignment/index.html
@@ -13,14 +13,14 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_OR_assignment
 
 
    语法
    
 
-
    Operator: x |= y
+
    Operator: x |= y
 Meaning:  x  = x | y
    
 
 
    Examples
    
 
 
    Using bitwise OR assignment
    
 
-
    let a = 5;
+
    let a = 5;
 a |= 2; // 7
 // 5: 00000000000000000000000000000101
 // 2: 00000000000000000000000000000010
diff --git a/files/zh-cn/web/javascript/reference/operators/bitwise_xor/index.html b/files/zh-cn/web/javascript/reference/operators/bitwise_xor/index.html
index c2fa597627..e68e1d436b 100644
--- a/files/zh-cn/web/javascript/reference/operators/bitwise_xor/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/bitwise_xor/index.html
@@ -13,14 +13,14 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_XOR
 
 
    语法
    
 
-
    a ^ b
+
    a ^ b
 
    
 
 
    描述
    
 
 
    The operands are converted to 32-bit integers and expressed by a series of bits (zeroes and ones). Numbers with more than 32 bits get their most significant bits discarded. For example, the following integer with more than 32 bits will be converted to a 32 bit integer:
    
 
-
    Before: 11100110111110100000000000000110000000000001
+
    Before: 11100110111110100000000000000110000000000001
 After:              10100000000000000110000000000001
    
 
 
    Each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on.
    
@@ -61,7 +61,7 @@ After:              10100000000000000110000000000001
    
  
 
 
-
    .    9 (base 10) = 00000000000000000000000000001001 (base 2)
+
    .    9 (base 10) = 00000000000000000000000000001001 (base 2)
     14 (base 10) = 00000000000000000000000000001110 (base 2)
                    --------------------------------
 14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
@@ -73,7 +73,7 @@ After:              10100000000000000110000000000001
    
 
 
    Using bitwise XOR
    
 
-
    // 9  (00000000000000000000000000001001)
+
    // 9  (00000000000000000000000000001001)
 // 14 (00000000000000000000000000001110)
 
 14 ^ 9;
diff --git a/files/zh-cn/web/javascript/reference/operators/bitwise_xor_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/bitwise_xor_assignment/index.html
index 7257e9cdb5..d8601d9eba 100644
--- a/files/zh-cn/web/javascript/reference/operators/bitwise_xor_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/bitwise_xor_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment
 
 
    语法
    
 
-
    Operator: x ^= y
+
    Operator: x ^= y
 Meaning:  x  = x ^ y
    
 
 
    例子
    
 
 
    使用按位异或赋值
    
 
-
    let a = 5;      // 00000000000000000000000000000101
+
    let a = 5;      // 00000000000000000000000000000101
 a ^= 3;         // 00000000000000000000000000000011
 
 console.log(a); // 00000000000000000000000000000110
diff --git a/files/zh-cn/web/javascript/reference/operators/decrement/index.html b/files/zh-cn/web/javascript/reference/operators/decrement/index.html
index aca67c15f9..8103a647d1 100644
--- a/files/zh-cn/web/javascript/reference/operators/decrement/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/decrement/index.html
@@ -22,7 +22,7 @@ original_slug: Web/JavaScript/Reference/Operators/自减
 

    
  语法
    
 
-
    操作符: x-- or --x
+
    操作符: x-- or --x
 
    
 
 
    语法细节
    
@@ -35,7 +35,7 @@ original_slug: Web/JavaScript/Reference/Operators/自减
 
 
    后缀式
    
 
-
    let x = 3;
+
    let x = 3;
 y = x--;
 
 // y = 3
@@ -44,7 +44,7 @@ y = x--;
 
 
    前缀式
    
 
-
    let a = 2;
+
    let a = 2;
 b = --a;
 
 // a = 1
diff --git a/files/zh-cn/web/javascript/reference/operators/delete/index.html b/files/zh-cn/web/javascript/reference/operators/delete/index.html
index f460f0e268..ce9d2120a4 100644
--- a/files/zh-cn/web/javascript/reference/operators/delete/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/delete/index.html
@@ -20,12 +20,12 @@ translation_of: Web/JavaScript/Reference/Operators/delete
 
 
    语法
    
 
-
    delete expression
+
    delete expression
 
    
 
 
     expression 的计算结果应该是某个属性的引用，例如：
    
 
-
    delete object.property
+
    delete object.property
 delete object['property']
 
    
 
@@ -72,7 +72,7 @@ delete object['property']
 
 
    下面的代码块给出了一个简单的例子：
    
 
-
    var Employee = {
+
    var Employee = {
   age: 28,
   name: 'abc',
   designation: 'developer'
@@ -89,14 +89,14 @@ console.log(delete Employee.salary); // returns true
    
 
 
    当一个属性被设置为不可设置，delete操作将不会有任何效果，并且会返回false。在严格模式下会抛出语法错误（{{jsxref("SyntaxError")}}）。
    
 
-
    var Employee = {};
+
    var Employee = {};
 Object.defineProperty(Employee, 'name', {configurable: false});
 
 console.log(delete Employee.name);  // returns false
    
 
 
    {{jsxref("Statements/var","var")}}, {{jsxref("Statements/let","let")}}以及{{jsxref("Statements/const","const")}}创建的不可设置的属性不能被delete操作删除。
    
 
-
    var nameOther = 'XYZ';
+
    var nameOther = 'XYZ';
 
 // 通过以下方法获取全局属性:
 Object.getOwnPropertyDescriptor(window, 'nameOther');
@@ -116,7 +116,7 @@ delete nameOther;   // return false
    
 
 
    在严格模式下，如果对一个变量的直接引用、函数的参数或者函数名使用delete操作，将会抛出语法错误（{{jsxref("SyntaxError")}}）。因此，为避免严格模式下的语法错误，必须以delete object.property或delete object['property']的形式使用delete运算符。
    
 
-
    Object.defineProperty(globalThis, 'variable1', { value: 10, configurable: true, });
+
    Object.defineProperty(globalThis, 'variable1', { value: 10, configurable: true, });
 Object.defineProperty(globalThis, 'variable2', { value: 10, configurable: false, });
 
 console.log(delete variable1); // true
@@ -125,7 +125,7 @@ console.log(delete variable1); // true
 console.log(delete variable2); // false
 
    
 
-
    function func(param) {
+
    function func(param) {
   // SyntaxError in strict mode.
   console.log(delete param); // false
 }
@@ -140,7 +140,7 @@ console.log(delete func); // false
 
 
    任何使用var声明的变量都会被标记为不可设置的。在下面的例子中，salary是不可设置的以及不能被删除的。在非严格模式下，下面的delete操作将会返回false。
    
 
-
    function Employee() {
+
    function Employee() {
   delete salary;
   var salary;
 }
@@ -149,7 +149,7 @@ Employee();
    
 
 
    让我们来看看相同的代码在严格模式下会有怎样的表现。会抛出一个语法错误（ SyntaxError）而不是返回false。
    
 
-
    "use strict";
+
    "use strict";
 
 function Employee() {
   delete salary;  // SyntaxError
@@ -167,7 +167,7 @@ delete DemoFunction; // SyntaxError
    
 
 
    示例
    
 
-
    // 在全局作用域创建 adminName 属性
+
    // 在全局作用域创建 adminName 属性
 adminName = 'xyz';
 
 // 在全局作用域创建 empCount 属性
@@ -213,7 +213,7 @@ function f() {
 
 
    在下面的示例中，我们删除一个对象的自己的属性，而原型链上具有相同名称的属性可用：
    
 
-
    function Foo() {
+
    function Foo() {
   this.bar = 10;
 }
 
@@ -240,7 +240,7 @@ console.log(foo.bar);    //undefined
 
 
    当用 delete 操作符删除一个数组元素时，被删除的元素已经不再属于该数组。下面的例子中用 delete 删除了 trees[3]。
    
 
-
    var trees = ["redwood","bay","cedar","oak","maple"];
+
    var trees = ["redwood","bay","cedar","oak","maple"];
 delete trees[3];
 if (3 in trees) {
    // 这里不会执行
@@ -249,7 +249,7 @@ if (3 in trees) {
 
 
    如果你想让一个数组元素继续存在但是其值是 undefined，那么可以使用将 undefined 赋值给这个元素而不是使用 delete。下面的例子中，trees[3] 被赋值为 undefined，但该元素仍然存在。
    
 
-
    var trees = ["redwood","bay","cedar","oak","maple"];
+
    var trees = ["redwood","bay","cedar","oak","maple"];
 trees[3] = undefined;
 if (3 in trees) {
    // 这里会被执行
@@ -257,7 +257,7 @@ if (3 in trees) {
 
 
    如果你想通过改变数组的内容来移除一个数组元素，请使用{{jsxref("Array.splice()", "splice()")}} 方法。在下面的例子中，通过使用{{jsxref("Array.splice()", "splice()")}}，将trees[3]从数组中移除。
    
 
-
    var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+
    var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
 trees.splice(3,1);
 console.log(trees); // ["redwood", "bay", "cedar", "maple"]
 
    
diff --git a/files/zh-cn/web/javascript/reference/operators/division/index.html b/files/zh-cn/web/javascript/reference/operators/division/index.html
index 8bfc53db1f..d1af1e83a0 100644
--- a/files/zh-cn/web/javascript/reference/operators/division/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/division/index.html
@@ -20,14 +20,14 @@ translation_of: Web/JavaScript/Reference/Operators/Division
 
 
    语法
    
 
-
    Operator: x / y
+
    Operator: x / y
 
    
 
 
    例子
    
 
 
    基本除法
    
 
-
    1 / 2              // 0.5
+
    1 / 2              // 0.5
 
 Math.floor(3 / 2) // 1
 
@@ -36,7 +36,7 @@ Math.floor(3 / 2) // 1
 
 
    除以0
    
 
-
    2.0 / 0     // Infinity
+
    2.0 / 0     // Infinity
 
 2.0 / 0.0   // Infinity, because 0.0 === 0
 
diff --git a/files/zh-cn/web/javascript/reference/operators/division_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/division_assignment/index.html
index a5afd52f49..a9d3508d00 100644
--- a/files/zh-cn/web/javascript/reference/operators/division_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/division_assignment/index.html
@@ -13,14 +13,14 @@ translation_of: Web/JavaScript/Reference/Operators/Division_assignment
 
 
    语法
    
 
-
    Operator: x /= y
+
    Operator: x /= y
 Meaning:  x  = x / y
    
 
 
    Examples
    
 
 
    Using division assignment
    
 
-
    // Assuming the following variable
+
    // Assuming the following variable
 //  bar = 5
 
 bar /= 2     // 2.5
diff --git a/files/zh-cn/web/javascript/reference/operators/equality/index.html b/files/zh-cn/web/javascript/reference/operators/equality/index.html
index fadd413b17..5ea543e057 100644
--- a/files/zh-cn/web/javascript/reference/operators/equality/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/equality/index.html
@@ -15,7 +15,7 @@ original_slug: Web/JavaScript/Reference/Operators/相等
 
 
    语法
    
 
-
    x == y
+
    x == y
 
    
 
 
    描述
    
@@ -52,12 +52,12 @@ original_slug: Web/JavaScript/Reference/Operators/相等
 
 
    没有类型转换的比较
    
 
-
    1 == 1;              // true
+
    1 == 1;              // true
 "hello" == "hello";  // true
    
 
 
    与类型转换比较
    
 
-
    "1" ==  1;            // true
+
    "1" ==  1;            // true
 1 == "1";             // true
 0 == false;           // true
 0 == null;            // false
@@ -71,7 +71,7 @@ number1 == number2;   // false
    
 
 
    对象比较
    
 
-
    const object1 = {"key": "value"}
+
    const object1 = {"key": "value"}
 const object2 = {"key": "value"};
 
 object1 == object2 // false
@@ -81,7 +81,7 @@ object2 == object2 // true
    
 
 
    请注意，使用构造的字符串new String()是对象。如果将其中之一与字符串文字进行比较，则该String对象将被转换为字符串文字并对其内容进行比较。但是，如果两个操作数都是String对象，则将它们作为对象进行比较，并且必须引用相同的对象才能进行比较：
    
 
-
    const string1 = "hello";
+
    const string1 = "hello";
 const string2 = String("hello");
 const string3 = new String("hello");
 const string4 = new String("hello");
@@ -94,7 +94,7 @@ console.log(string4 == string4); // true
    
 
 
    比较日期和字符串
    
 
-
    const d = new Date('December 17, 1995 03:24:00');
+
    const d = new Date('December 17, 1995 03:24:00');
 const s = d.toString(); // for example: "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
 console.log(d == s);    //true
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/exponentiation/index.html b/files/zh-cn/web/javascript/reference/operators/exponentiation/index.html
index 26fbf9ff64..7e138abfa2 100644
--- a/files/zh-cn/web/javascript/reference/operators/exponentiation/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/exponentiation/index.html
@@ -18,7 +18,7 @@ translation_of: Web/JavaScript/Reference/Operators/Exponentiation
 
 
    语法
    
 
-
    Operator: var1 ** var2
+
    Operator: var1 ** var2
 
    
 
 
    简介
    
@@ -29,7 +29,7 @@ translation_of: Web/JavaScript/Reference/Operators/Exponentiation
 
 
    在JavaScript里，你不可能写出一个不明确的求幂表达式。这就是说，你不能立刻将一个一元运算符（+/-/~/!/delete/void/typeof）放在基数前，这样做只会导致一个语法错误。
    
 
-
    -2 ** 2;
+
    -2 ** 2;
 // 4 in Bash, -4 in other languages.
 // This is invalid in JavaScript, as the operation is ambiguous.
 
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Operators/Exponentiation
 
 
    基本求幂
    
 
-
    2 ** 3   // 8
+
    2 ** 3   // 8
 3 ** 2   // 9
 3 ** 2.5 // 15.588457268119896
 10 ** -1 // 0.1
@@ -53,7 +53,7 @@ NaN ** 2 // NaN
 
 
    结合
    
 
-
    2 ** 3 ** 2   // 512
+
    2 ** 3 ** 2   // 512
 2 ** (3 ** 2) // 512
 (2 ** 3) ** 2 // 64
    
 
@@ -61,12 +61,12 @@ NaN ** 2 // NaN
 
 
    取求幂表达式的值的相反数：
    
 
-
    -(2 ** 2) // -4
+
    -(2 ** 2) // -4
 
    
 
 
    将求幂表达式的底数转化为一个负数：
    
 
-
    (-2) ** 2 // 4
+
    (-2) ** 2 // 4
 
    
 
 
    规范
    
diff --git a/files/zh-cn/web/javascript/reference/operators/exponentiation_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/exponentiation_assignment/index.html
index f9f53ca532..bd8e58da23 100644
--- a/files/zh-cn/web/javascript/reference/operators/exponentiation_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/exponentiation_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Exponentiation_assignment
 
 
    语法
    
 
-
    Operator: x **= y
+
    Operator: x **= y
 Meaning:  x  = x ** y
    
 
 
    Examples
    
 
 
    Using exponentiation assignment
    
 
-
    // Assuming the following variable
+
    // Assuming the following variable
 //  bar = 5
 
 bar **= 2     // 25
diff --git a/files/zh-cn/web/javascript/reference/operators/greater_than/index.html b/files/zh-cn/web/javascript/reference/operators/greater_than/index.html
index afb4a2d134..0c8c8a8328 100644
--- a/files/zh-cn/web/javascript/reference/operators/greater_than/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/greater_than/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Greater_than
 
 
    语法
    
 
-
    x > y
    
+
    x > y
    
 
 
    描述
    
 
@@ -23,13 +23,13 @@ translation_of: Web/JavaScript/Reference/Operators/Greater_than
 
 
    字符串的比较
    
 
-
    console.log("a" > "b");        // false
+
    console.log("a" > "b");        // false
 console.log("a" > "a");        // false
 console.log("a" > "3");        // true
    
 
 
    字符串和数字的比较
    
 
-
    console.log("5" > 3);          // true
+
    console.log("5" > 3);          // true
 console.log("3" > 3);          // false
 console.log("3" > 5);          // false
 
@@ -41,18 +41,18 @@ console.log("3" > 5n);         // false
    
 
 
    数字间的比较
    
 
-
    console.log(5 > 3);            // true
+
    console.log(5 > 3);            // true
 console.log(3 > 3);            // false
 console.log(3 > 5);            // false
    
 
 
    数字和 BigInt 数据的比较
    
 
-
    console.log(5n > 3);           // true
+
    console.log(5n > 3);           // true
 console.log(3 > 5n);           // false
    
 
 
    Boolean, null, undefined, NaN的比较
    
 
-
    console.log(true > false);     // true
+
    console.log(true > false);     // true
 console.log(false > true);     // false
 
 console.log(true > 0);         // true
diff --git a/files/zh-cn/web/javascript/reference/operators/greater_than_or_equal/index.html b/files/zh-cn/web/javascript/reference/operators/greater_than_or_equal/index.html
index 9fa5b48436..f54a1061fa 100644
--- a/files/zh-cn/web/javascript/reference/operators/greater_than_or_equal/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/greater_than_or_equal/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Greater_than_or_equal
 
 
    Syntax
    
 
-
     x >= y
    
+
     x >= y
    
 
 
    Description
    
 
@@ -23,14 +23,14 @@ translation_of: Web/JavaScript/Reference/Operators/Greater_than_or_equal
 
 
    String to string comparison
    
 
-
    console.log("a" >= "b");     // false
+
    console.log("a" >= "b");     // false
 console.log("a" >= "a");     // true
 console.log("a" >= "3");     // true
 
    
 
 
    String to number comparison
    
 
-
    console.log("5" >= 3);       // true
+
    console.log("5" >= 3);       // true
 console.log("3" >= 3);       // true
 console.log("3" >= 5);       // false
 
@@ -39,19 +39,19 @@ console.log(5 >= "hello");   // false
    
 
 
    Number to Number comparison
    
 
-
    console.log(5 >= 3);         // true
+
    console.log(5 >= 3);         // true
 console.log(3 >= 3);         // true
 console.log(3 >= 5);         // false
    
 
 
    Number to BigInt comparison
    
 
-
    console.log(5n >= 3);        // true
+
    console.log(5n >= 3);        // true
 console.log(3 >= 3n);        // true
 console.log(3 >= 5n);        // false
    
 
 
    Comparing Boolean, null, undefined, NaN
    
 
-
    console.log(true >= false);  // true
+
    console.log(true >= false);  // true
 console.log(true >= true);   // true
 console.log(false >= true);  // false
 
diff --git a/files/zh-cn/web/javascript/reference/operators/in/index.html b/files/zh-cn/web/javascript/reference/operators/in/index.html
index 2ac7bb0ed4..f974698598 100644
--- a/files/zh-cn/web/javascript/reference/operators/in/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/in/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Operators/in
 
 
    语法
    
 
-
    prop in object
    
+
    prop in object
    
 
 
    参数
    
 
@@ -35,7 +35,7 @@ translation_of: Web/JavaScript/Reference/Operators/in
 
 
    下面的例子演示了一些 in 运算符的用法。
    
 
-
    // 数组
+
    // 数组
 var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 0 in trees        // 返回true
 3 in trees        // 返回true
@@ -58,7 +58,7 @@ var mycar = {make: "Honda", model: "Accord", year: 1998};
 
 
    in右操作数必须是一个对象值。例如，你可以指定使用String构造函数创建的字符串，但不能指定字符串文字。
    
 
-
    var color1 = new String("green");
+
    var color1 = new String("green");
 "length" in color1 // 返回true
 var color2 = "coral";
 "length" in color2 // 报错(color2不是对象)
@@ -68,7 +68,7 @@ var color2 = "coral";
 
 
    如果你使用 delete 运算符删除了一个属性，则 in 运算符对所删除属性返回 false。
    
 
-
    var mycar = {make: "Honda", model: "Accord", year: 1998};
+
    var mycar = {make: "Honda", model: "Accord", year: 1998};
 delete mycar.make;
 "make" in mycar;  // 返回false
 
@@ -79,12 +79,12 @@ delete trees[3];
 
 
    如果你只是将一个属性的值赋值为{{jsxref("Global_Objects/undefined", "undefined")}}，而没有删除它，则 in 运算仍然会返回true。
    
 
-
    var mycar = {make: "Honda", model: "Accord", year: 1998};
+
    var mycar = {make: "Honda", model: "Accord", year: 1998};
 mycar.make = undefined;
 "make" in mycar;  // 返回true
 
    
 
-
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+
    var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 trees[3] = undefined;
 3 in trees; // 返回true
 
    
@@ -93,7 +93,7 @@ trees[3] = undefined;
 
 
    如果一个属性是从原型链上继承来的，in 运算符也会返回 true。
    
 
-
    "toString" in {}; // 返回true
+
    "toString" in {}; // 返回true
 
    
 
 
    规范
    
diff --git a/files/zh-cn/web/javascript/reference/operators/increment/index.html b/files/zh-cn/web/javascript/reference/operators/increment/index.html
index afe307f389..31620cb751 100644
--- a/files/zh-cn/web/javascript/reference/operators/increment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/increment/index.html
@@ -17,7 +17,7 @@ translation_of: Web/JavaScript/Reference/Operators/Increment
 
 
    语法
    
 
-
    Operator: x++ or ++x
+
    Operator: x++ or ++x
 
    
 
 
    描述
    
@@ -30,7 +30,7 @@ translation_of: Web/JavaScript/Reference/Operators/Increment
 
 
    后置自增(Postfix increment)
    
 
-
    let x = 3;
+
    let x = 3;
 y = x++;
 
 // y = 3
@@ -39,7 +39,7 @@ y = x++;
 
 
    前置自增(Prefix increment)
    
 
-
    let a = 2;
+
    let a = 2;
 b = ++a;
 
 // a = 3
diff --git a/files/zh-cn/web/javascript/reference/operators/inequality/index.html b/files/zh-cn/web/javascript/reference/operators/inequality/index.html
index 11b16d1c2e..cbc90433e7 100644
--- a/files/zh-cn/web/javascript/reference/operators/inequality/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/inequality/index.html
@@ -18,13 +18,13 @@ translation_of: Web/JavaScript/Reference/Operators/Inequality
 
 
    语法
    
 
-
    x != y
    
+
    x != y
    
 
 
    描述
    
 
 
    不等式运算符检查其操作数是否不相等。这是等于运算符的取反，因此以下两行将始终给出相同的结果： 
    
 
-
    x != y
+
    x != y
 
 !(x == y)
    
 
@@ -32,17 +32,17 @@ translation_of: Web/JavaScript/Reference/Operators/Inequality
 
 
    与等于运算符一样，不等于运算符将尝试转换和比较不同类型的操作数：
    
 
-
    3 != "3"; // false
    
+
    3 != "3"; // false
    
 
 
    为避免这种情况，并要求将不同类型视为不同，请使用严格的不等于运算符：
    
 
-
    3 !== "3"; // true
    
+
    3 !== "3"; // true
    
 
 
    例子
    
 
 
    没有类型转换的比较
    
 
-
    1 != 2;              // true
+
    1 != 2;              // true
 "hello" != "hola";   // true
 
 1 != 1;              // false
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Operators/Inequality
 
 
    与类型转换比较
    
 
-
    "1" !=  1;            // false
+
    "1" !=  1;            // false
 1 != "1";             // false
 0 != false;           // false
 0 != null;            // true
@@ -66,7 +66,7 @@ number1 != number2;   // true
    
 
 
    对象比较
    
 
-
    const object1 = {"key": "value"}
+
    const object1 = {"key": "value"}
 const object2 = {"key": "value"};
 
 object1 != object2 // true
diff --git a/files/zh-cn/web/javascript/reference/operators/instanceof/index.html b/files/zh-cn/web/javascript/reference/operators/instanceof/index.html
index a1e3c5a538..9bc5622462 100644
--- a/files/zh-cn/web/javascript/reference/operators/instanceof/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/instanceof/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Operators/instanceof
 
 
    语法
    
 
-
    object instanceof constructor
    
+
    object instanceof constructor
    
 
 
    参数
    
 
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Operators/instanceof
 
 
    instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上。
    
 
-
    // 定义构造函数
+
    // 定义构造函数
 function C(){}
 function D(){}
 
@@ -87,7 +87,7 @@ o3 instanceof C; // true 因为 C.prototype 现在在 o3 的原型链上
 
 
    但是，使用对象文字符号创建的对象在这里是一个例外：虽然原型未定义，但 instanceof Object 返回 true。
    
 
-
    var simpleStr = "This is a simple string";
+
    var simpleStr = "This is a simple string";
 var myString  = new String();
 var newStr    = new String("String created with constructor");
 var myDate    = new Date();
@@ -113,7 +113,7 @@ myDate instanceof String;   // 返回 false
    
 
 
    下面的代码创建了一个类型 Car，以及该类型的对象实例 mycar. instanceof 运算符表明了这个 mycar 对象既属于 Car 类型，又属于 Object 类型。
    
 
-
    function Car(make, model, year) {
+
    function Car(make, model, year) {
   this.make = make;
   this.model = model;
   this.year = year;
@@ -128,13 +128,13 @@ var b = mycar instanceof Object; // 返回 true
 
 
    要检测对象不是某个构造函数的实例时，你可以这样做
    
 
-
    if (!(mycar instanceof Car)) {
+
    if (!(mycar instanceof Car)) {
   // Do something, like mycar = new Car(mycar)
 }
    
 
 
    这和以下代码完全不同
    
 
-
    if (!mycar instanceof Car)
    
+
    if (!mycar instanceof Car)
    
 
 
    这段代码永远会得到 false（!mycar 将在 instanceof 之前被处理，所以你总是在验证一个布尔值是否是 Car 的一个实例）。
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/left_shift/index.html b/files/zh-cn/web/javascript/reference/operators/left_shift/index.html
index 83fe088941..4bae0bcde0 100644
--- a/files/zh-cn/web/javascript/reference/operators/left_shift/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/left_shift/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Left_shift
 
 
    语法
    
 
-
    a << b
+
    a << b
 
    
 
 
    描述
    
@@ -22,7 +22,7 @@ translation_of: Web/JavaScript/Reference/Operators/Left_shift
 
 
    例如， 9 << 2 得出 36：
    
 
-
    .    9 (十进制): 00000000000000000000000000001001 (二进制)
+
    .    9 (十进制): 00000000000000000000000000001001 (二进制)
                   --------------------------------
 9 << 2 (十进制): 00000000000000000000000000100100 (二进制) = 36 (十进制)
 
    
@@ -34,7 +34,7 @@ translation_of: Web/JavaScript/Reference/Operators/Left_shift
 
 
    使用左移
    
 
-
    9 << 3; // 72
+
    9 << 3; // 72
 
 // 9 * 2³ = 9 * 8 = 72
 
    
diff --git a/files/zh-cn/web/javascript/reference/operators/left_shift_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/left_shift_assignment/index.html
index ccf5bbce00..e48b9616d0 100644
--- a/files/zh-cn/web/javascript/reference/operators/left_shift_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/left_shift_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Left_shift_assignment
 
 
    语法
    
 
-
    Operator: x <<= y
+
    Operator: x <<= y
 Meaning:  x   = x << y
    
 
 
    Examples
    
 
 
    Using left shift assignment
    
 
-
    let a = 5;
+
    let a = 5;
 // 00000000000000000000000000000101
 
 a <<= 2; // 20
diff --git a/files/zh-cn/web/javascript/reference/operators/less_than/index.html b/files/zh-cn/web/javascript/reference/operators/less_than/index.html
index 1a33554b98..d98a89f03c 100644
--- a/files/zh-cn/web/javascript/reference/operators/less_than/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/less_than/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Less_than
 
 
    语法
    
 
-
     x < y
    
+
     x < y
    
 
 
    Description
    
 
@@ -38,13 +38,13 @@ translation_of: Web/JavaScript/Reference/Operators/Less_than
 
 
    String to string comparison
    
 
-
    console.log("a" < "b");        // true
+
    console.log("a" < "b");        // true
 console.log("a" < "a");        // false
 console.log("a" < "3");        // false
    
 
 
    String to number comparison
    
 
-
    console.log("5" < 3);          // false
+
    console.log("5" < 3);          // false
 console.log("3" < 3);          // false
 console.log("3" < 5);          // true
 
@@ -56,18 +56,18 @@ console.log("3" < 5n);         // true
    
 
 
    Number to Number comparison
    
 
-
    console.log(5 < 3);            // false
+
    console.log(5 < 3);            // false
 console.log(3 < 3);            // false
 console.log(3 < 5);            // true
    
 
 
    Number to BigInt comparison
    
 
-
    console.log(5n < 3);           // false
+
    console.log(5n < 3);           // false
 console.log(3 < 5n);           // true
    
 
 
    Comparing Boolean, null, undefined, NaN
    
 
-
    console.log(true < false);     // false
+
    console.log(true < false);     // false
 console.log(false < true);     // true
 
 console.log(0 < true);         // true
diff --git a/files/zh-cn/web/javascript/reference/operators/less_than_or_equal/index.html b/files/zh-cn/web/javascript/reference/operators/less_than_or_equal/index.html
index 97a6f6746b..498dc2bbfd 100644
--- a/files/zh-cn/web/javascript/reference/operators/less_than_or_equal/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/less_than_or_equal/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Less_than_or_equal
 
 
    Syntax
    
 
-
     x <= y
    
+
     x <= y
    
 
 
    Description
    
 
@@ -23,14 +23,14 @@ translation_of: Web/JavaScript/Reference/Operators/Less_than_or_equal
 
 
    String to string comparison
    
 
-
    console.log("a" <= "b");     // true
+
    console.log("a" <= "b");     // true
 console.log("a" <= "a");     // true
 console.log("a" <= "3");     // false
 
    
 
 
    String to number comparison
    
 
-
    console.log("5" <= 3);       // false
+
    console.log("5" <= 3);       // false
 console.log("3" <= 3);       // true
 console.log("3" <= 5);       // true
 
@@ -39,19 +39,19 @@ console.log(5 <= "hello");   // false
    
 
 
    Number to Number comparison
    
 
-
    console.log(5 <= 3);         // false
+
    console.log(5 <= 3);         // false
 console.log(3 <= 3);         // true
 console.log(3 <= 5);         // true
    
 
 
    Number to BigInt comparison
    
 
-
    console.log(5n <= 3);        // false
+
    console.log(5n <= 3);        // false
 console.log(3 <= 3n);        // true
 console.log(3 <= 5n);        // true
    
 
 
    Comparing Boolean, null, undefined, NaN
    
 
-
    console.log(true <= false);  // false
+
    console.log(true <= false);  // false
 console.log(true <= true);   // true
 console.log(false <= true);  // true
 
diff --git a/files/zh-cn/web/javascript/reference/operators/logical_and/index.html b/files/zh-cn/web/javascript/reference/operators/logical_and/index.html
index 78c4eee070..e418a76518 100644
--- a/files/zh-cn/web/javascript/reference/operators/logical_and/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/logical_and/index.html
@@ -14,7 +14,7 @@ original_slug: Web/JavaScript/Reference/Operators/逻辑和
 
 
    Syntax
    
 
-
    expr1 && expr2
+
    expr1 && expr2
 
    
 
 
    Description
    
@@ -43,7 +43,7 @@ original_slug: Web/JavaScript/Reference/Operators/逻辑和
 
 
    Short circuit means that the expr part above is not evaluated, hence any side effects of doing so do not take effect (e.g., if expr is a function call, the calling never takes place). This happens because the value of the operator is already determined after the evaluation of the first operand. See example:
    
 
-
    function A(){ console.log('called A'); return false; }
+
    function A(){ console.log('called A'); return false; }
 function B(){ console.log('called B'); return true; }
 
 console.log( A() && B() );
@@ -55,7 +55,7 @@ console.log( A() && B() );
 
 
    The following expressions might seem equivalent, but they are not, because the && operator is executed before the || operator (see operator precedence).
    
 
-
    true || false && false      // returns true, because && is executed first
+
    true || false && false      // returns true, because && is executed first
 (true || false) && false    // returns false, because operator precedence cannot apply
    
 
 
    Examples
    
@@ -64,7 +64,7 @@ console.log( A() && B() );
 
 
    The following code shows examples of the && (logical AND) operator.
    
 
-
    a1 = true  && true       // t && t returns true
+
    a1 = true  && true       // t && t returns true
 a2 = true  && false      // t && f returns false
 a3 = false && true       // f && t returns false
 a4 = false && (3 == 4)   // f && f returns false
@@ -80,21 +80,21 @@ a9 = false && ''         // f && f returns false
    
 
 
    The following operation involving booleans:
    
 
-
    bCondition1 && bCondition2
    
+
    bCondition1 && bCondition2
    
 
 
    is always equal to:
    
 
-
    !(!bCondition1 || !bCondition2)
    
+
    !(!bCondition1 || !bCondition2)
    
 
 
    Converting OR to AND
    
 
 
    The following operation involving booleans:
    
 
-
    bCondition1 || bCondition2
    
+
    bCondition1 || bCondition2
    
 
 
    is always equal to:
    
 
-
    !(!bCondition1 && !bCondition2)
    
+
    !(!bCondition1 && !bCondition2)
    
 
 
    Removing nested parentheses
    
 
@@ -102,11 +102,11 @@ a9 = false && ''         // f && f returns false
    
 
 
    The following composite operation involving booleans:
    
 
-
    bCondition1 || (bCondition2 && bCondition3)
    
+
    bCondition1 || (bCondition2 && bCondition3)
    
 
 
    is always equal to:
    
 
-
    bCondition1 || bCondition2 && bCondition3
    
+
    bCondition1 || bCondition2 && bCondition3
    
 
 
    Specifications
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/logical_and_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/logical_and_assignment/index.html
index 3ed9a1582a..4ee00585a5 100644
--- a/files/zh-cn/web/javascript/reference/operators/logical_and_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/logical_and_assignment/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_AND_assignment
 
 
    语法
    
 
-
    expr1 &&= expr2
+
    expr1 &&= expr2
 
    
 
 
    描述
    
@@ -28,18 +28,18 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_AND_assignment
 
 
    Logical AND assignment short-circuits as well meaning that x &&= y is equivalent to:
    
 
-
    x && (x = y);
    
+
    x && (x = y);
    
 
 
    And not equivalent to the following which would always perform an assignment:
    
 
-
    x = x && y;
+
    x = x && y;
 
    
 
 
    例子
    
 
 
    Using logical AND assignment
    
 
-
    let x = 0;
+
    let x = 0;
 let y = 1;
 
 x &&= 0; // 0
diff --git a/files/zh-cn/web/javascript/reference/operators/logical_not/index.html b/files/zh-cn/web/javascript/reference/operators/logical_not/index.html
index f05bfb180a..e27ad4db4f 100644
--- a/files/zh-cn/web/javascript/reference/operators/logical_not/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/logical_not/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_NOT
 
 
    语法
    
 
-
    !expr
+
    !expr
 
    
 
 
    Description
    
@@ -40,7 +40,7 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_NOT
 
 
    The following code shows examples of the ! (logical NOT) operator.
    
 
-
    n1 = !true               // !t returns false
+
    n1 = !true               // !t returns false
 n2 = !false              // !f returns true
 n3 = !''                 // !f returns true
 n4 = !'Cat'              // !t returns false
    
@@ -51,7 +51,7 @@ n4 = !'Cat'              // !t returns false
    
 
 
    The same conversion can be done through the {{jsxref("Global_Objects/Boolean/Boolean", "Boolean")}} function.
    
 
-
    n1 = !!true                   // !!truthy returns true
+
    n1 = !!true                   // !!truthy returns true
 n2 = !!{}                     // !!truthy returns true: any object is truthy...
 n3 = !!(new Boolean(false))   // ...even Boolean objects with a false .valueOf()!
 n4 = !!false                  // !!falsy returns false
@@ -62,11 +62,11 @@ n6 = !!Boolean(false)         // !!falsy returns false
    
 
 
    The following operation involving booleans:
    
 
-
    !!bCondition
    
+
    !!bCondition
    
 
 
    is always equal to:
    
 
-
    bCondition
    
+
    bCondition
    
 
 
    Specifications
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/logical_nullish_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/logical_nullish_assignment/index.html
index a57c18e5c2..c4fea43591 100644
--- a/files/zh-cn/web/javascript/reference/operators/logical_nullish_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/logical_nullish_assignment/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_nullish_assignment
 
 
    语法
    
 
-
    expr1 ??= expr2
+
    expr1 ??= expr2
 
    
 
 
    描述
    
@@ -28,18 +28,18 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_nullish_assignment
 
 
    逻辑空赋值的语法短路也意味着 x ??= y 等价于：
    
 
-
    x ?? (x = y);
    
+
    x ?? (x = y);
    
 
 
    而不等价于如下的表达式，因为其一定会发生赋值：
    
 
-
    x = x ?? y;
+
    x = x ?? y;
 
    
 
 
    例子
    
 
 
    使用逻辑空赋值
    
 
-
    function config(options) {
+
    function config(options) {
   options.duration ??= 100;
   options.speed ??= 25;
   return options;
diff --git a/files/zh-cn/web/javascript/reference/operators/logical_or/index.html b/files/zh-cn/web/javascript/reference/operators/logical_or/index.html
index 1a8f881377..3604b99140 100644
--- a/files/zh-cn/web/javascript/reference/operators/logical_or/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/logical_or/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_OR
 
 
    语法
    
 
-
    expr1 || expr2
+
    expr1 || expr2
 
    
 
 
    Description
    
@@ -42,7 +42,7 @@ translation_of: Web/JavaScript/Reference/Operators/Logical_OR
 
 
    Short circuit means that the expr part above is not evaluated, hence any side effects of doing so do not take effect (e.g., if expr is a function call, the calling never takes place). This happens because the value of the operator is already determined after the evaluation of the first operand. See example:
    
 
-
    function A(){ console.log('called A'); return false; }
+
    function A(){ console.log('called A'); return false; }
 function B(){ console.log('called B'); return true; }
 
 console.log( B() || A() );
@@ -54,7 +54,7 @@ console.log( B() || A() );
 
 
    The following expressions might seem equivalent, but they are not, because the && operator is executed before the || operator (see operator precedence).
    
 
-
    true || false && false      // returns true, because && is executed first
+
    true || false && false      // returns true, because && is executed first
 (true || false) && false    // returns false, because operator precedence cannot apply
    
 
 
    Examples
    
@@ -63,7 +63,7 @@ console.log( B() || A() );
 
 
    The following code shows examples of the || (logical OR) operator.
    
 
-
    o1 = true  || true       // t || t returns true
+
    o1 = true  || true       // t || t returns true
 o2 = false || true       // f || t returns true
 o3 = true  || false      // t || f returns true
 o4 = false || (3 == 4)   // f || f returns false
@@ -85,21 +85,21 @@ o10 = false || varObject // f || object returns varObject
 
 
    The following operation involving booleans:
    
 
-
    bCondition1 && bCondition2
    
+
    bCondition1 && bCondition2
    
 
 
    is always equal to:
    
 
-
    !(!bCondition1 || !bCondition2)
    
+
    !(!bCondition1 || !bCondition2)
    
 
 
    Converting OR to AND
    
 
 
    The following operation involving booleans:
    
 
-
    bCondition1 || bCondition2
    
+
    bCondition1 || bCondition2
    
 
 
    is always equal to:
    
 
-
    !(!bCondition1 && !bCondition2)
    
+
    !(!bCondition1 && !bCondition2)
    
 
 
    Removing nested parentheses
    
 
@@ -107,11 +107,11 @@ o10 = false || varObject // f || object returns varObject
 
 
    The following composite operation involving booleans:
    
 
-
    bCondition1 && (bCondition2 || bCondition3)
    
+
    bCondition1 && (bCondition2 || bCondition3)
    
 
 
    is always equal to:
    
 
-
    !(!bCondition1 || !bCondition2 && !bCondition3)
    
+
    !(!bCondition1 || !bCondition2 && !bCondition3)
    
 
 
    Specifications
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/multiplication/index.html b/files/zh-cn/web/javascript/reference/operators/multiplication/index.html
index db346f4cbe..a37d1e7a54 100644
--- a/files/zh-cn/web/javascript/reference/operators/multiplication/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/multiplication/index.html
@@ -15,25 +15,25 @@ translation_of: Web/JavaScript/Reference/Operators/Multiplication
 
 
    语法
    
 
-
    Operator: x * y
+
    Operator: x * y
 
    
 
 
    例子
    
 
 
    使用数字相乘
    
 
-
     2 * 2      // 4
+
     2 * 2      // 4
 -2 * 2     // -4
 
    
 
 
    使用 Infinity 相乘
    
 
-
    Infinity * 0         // NaN
+
    Infinity * 0         // NaN
 Infinity * Infinity  // Infinity
    
 
 
    使用非数字相乘
    
 
-
    'foo' * 2 // NaN
    
+
    'foo' * 2 // NaN
    
 
 
    规范
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/multiplication_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/multiplication_assignment/index.html
index e05019acba..274729034b 100644
--- a/files/zh-cn/web/javascript/reference/operators/multiplication_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/multiplication_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Multiplication_assignment
 
 
    语法
    
 
-
    Operator: x *= y
+
    Operator: x *= y
 Meaning:  x  = x * y
    
 
 
    Examples
    
 
 
    Using multiplication assignment
    
 
-
    // Assuming the following variable
+
    // Assuming the following variable
 //  bar = 5
 
 bar *= 2     // 10
diff --git a/files/zh-cn/web/javascript/reference/operators/new/index.html b/files/zh-cn/web/javascript/reference/operators/new/index.html
index 0b2d5c24c7..e6833d4cc7 100644
--- a/files/zh-cn/web/javascript/reference/operators/new/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/new/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Operators/new
 
 
    语法
    
 
-
    new constructor[([arguments])]
    
+
    new constructor[([arguments])]
    
 
 
    参数
    
 
@@ -67,7 +67,7 @@ translation_of: Web/JavaScript/Reference/Operators/new
 
 
    你可以使用 Function.prototype 属性将共享属性添加到以前定义的对象类型。这定义了一个由该函数创建的所有对象共享的属性，而不仅仅是对象类型的其中一个实例。下面的代码将一个值为 null 的 color 属性添加到 car 类型的所有对象，然后仅在实例对象 car1 中用字符串 "black" 覆盖该值。详见 prototype。
    
 
-
    function Car() {}
+
    function Car() {}
 car1 = new Car();
 car2 = new Car();
 
@@ -95,7 +95,7 @@ console.log(car2.color) // original color
 
 
    假设你要创建一个汽车的对象类型。你希望这个类型叫做car，这个类型具备make, model, year等属性，要做到这些，你需要写这样一个函数：
    
 
-
    function Car(make, model, year) {
+
    function Car(make, model, year) {
    this.make = make;
    this.model = model;
    this.year = year;
@@ -104,19 +104,19 @@ console.log(car2.color) // original color
 
 
    现在，你可以如下所示创建一个 mycar 的对象：
    
 
-
    var mycar = new Car("Eagle", "Talon TSi", 1993);
    
+
    var mycar = new Car("Eagle", "Talon TSi", 1993);
    
 
 
    这段代码创建了 mycar 并给他的属性指定值，于是 mycar.make 的值为"Eagle"， mycar.year 的值为1993，以此类推。
    
 
 
    你可以通过调用 new 来创建任意个汽车对象。例如：
    
 
-
    var kenscar = new Car("Nissan", "300ZX", 1992);
    
+
    var kenscar = new Car("Nissan", "300ZX", 1992);
    
 
 
    对象属性为其他对象
    
 
 
    假设你定义了一个对象叫做 person：
    
 
-
    function Person(name, age, sex) {
+
    function Person(name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
@@ -125,13 +125,13 @@ console.log(car2.color) // original color
 
 
    然后实例化两个新的 person 对象如下：
    
 
-
    var rand = new Person("Rand McNally", 33, "M");
+
    var rand = new Person("Rand McNally", 33, "M");
 var ken = new Person("Ken Jones", 39, "M");
 
    
 
 
    然后你可以重写 car 的定义，添加一个值为 person 对象的 owner 属性，如下：
    
 
-
    function Car(make, model, year, owner) {
+
    function Car(make, model, year, owner) {
    this.make = make;
    this.model = model;
    this.year = year;
@@ -141,13 +141,13 @@ var ken = new Person("Ken Jones", 39, "M");
 
 
    为了实例化新的对象，你可以用如下代码：
    
 
-
    var car1 = new Car("Eagle", "Talon TSi", 1993, rand);
+
    var car1 = new Car("Eagle", "Talon TSi", 1993, rand);
 var car2 = new Car("Nissan", "300ZX", 1992, ken);
 
    
 
 
    创建对象时，并没有传字符串或数字给owner，而是传了对象 rand 和 ken 。这个时候，你可以这样来获取 car2 的owner的name：
    
 
-
    car2.owner.name
    
+
    car2.owner.name
    
 
 
    规范
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/nullish_coalescing_operator/index.html b/files/zh-cn/web/javascript/reference/operators/nullish_coalescing_operator/index.html
index 59b7443e60..1dfd0302a9 100644
--- a/files/zh-cn/web/javascript/reference/operators/nullish_coalescing_operator/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/nullish_coalescing_operator/index.html
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
 
 
    语法
    
 
-
    leftExpr ?? rightExpr
+
    leftExpr ?? rightExpr
 
    
 
 
    示例
    
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
 
 
    在这个例子中，我们使用空值合并操作符为常量提供默认值，保证常量不为 null 或者 undefined。
    
 
-
    const nullValue = null;
+
    const nullValue = null;
 const emptyText = ""; // 空字符串，是一个假值，Boolean("") === false
 const someNumber = 42;
 
@@ -48,14 +48,14 @@ console.log(valC); // 42
    
 
 
    以前，如果想为一个变量赋默认值，通常的做法是使用逻辑或操作符（||）：
    
 
-
    let foo;
+
    let foo;
 
 //  foo is never assigned any value so it is still undefined
 let someDummyText = foo || 'Hello!';
    
 
 
    然而，由于 || 是一个布尔逻辑运算符，左侧的操作数会被强制转换成布尔值用于求值。任何假值（0， ''， NaN， null， undefined）都不会被返回。这导致如果你使用0，''或NaN作为有效值，就会出现不可预料的后果。
    
 
-
    let count = 0;
+
    let count = 0;
 let text = "";
 
 let qty = count || 42;
@@ -65,7 +65,7 @@ console.log(message); // "hi!"，而不是 ""
    
 
 
    空值合并操作符可以避免这种陷阱，其只在第一个操作数为null 或 undefined 时（而不是其它假值）返回第二个操作数：
    
 
-
    let myText = ''; // An empty string (which is also a falsy value)
+
    let myText = ''; // An empty string (which is also a falsy value)
 
 let notFalsyText = myText || 'Hello world';
 console.log(notFalsyText); // Hello world
@@ -78,7 +78,7 @@ console.log(preservingFalsy); // '' (as myText is neither undefined nor null)
 
 
    与 OR 和 AND 逻辑操作符相似，当左表达式不为 null 或 undefined 时，不会对右表达式进行求值。
    
 
-
    function A() { console.log('函数 A 被调用了'); return undefined; }
+
    function A() { console.log('函数 A 被调用了'); return undefined; }
 function B() { console.log('函数 B 被调用了'); return false; }
 function C() { console.log('函数 C 被调用了'); return "foo"; }
 
@@ -96,19 +96,19 @@ console.log( B() ?? C() );
 
 
    将 ?? 直接与 AND（&&）和 OR（||）操作符组合使用是不可取的。（译者注：应当是因为空值合并操作符和其他逻辑操作符之间的运算优先级/运算顺序是未定义的）这种情况下会抛出 SyntaxError 。
    
 
-
    null || undefined ?? "foo"; // 抛出 SyntaxError
+
    null || undefined ?? "foo"; // 抛出 SyntaxError
 true || undefined ?? "foo"; // 抛出 SyntaxError
    
 
 
    但是，如果使用括号来显式表明运算优先级，是没有问题的：
    
 
-
    (null || undefined ) ?? "foo"; // 返回 "foo"
+
    (null || undefined ) ?? "foo"; // 返回 "foo"
 
    
 
 
    与可选链式操作符（?.）的关系
    
 
 
    空值合并操作符针对 undefined 与 null 这两个值，可选链式操作符（?.） 也是如此。在这访问属性可能为 undefined 与 null 的对象时，可选链式操作符非常有用。
    
 
-
    let foo = { someFooProp: "hi" };
+
    let foo = { someFooProp: "hi" };
 
 console.log(foo.someFooProp?.toUpperCase()); // "HI"
 console.log(foo.someBarProp?.toUpperCase()); // undefined
diff --git a/files/zh-cn/web/javascript/reference/operators/optional_chaining/index.html b/files/zh-cn/web/javascript/reference/operators/optional_chaining/index.html
index 6f639f537a..e765e6d66b 100644
--- a/files/zh-cn/web/javascript/reference/operators/optional_chaining/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/optional_chaining/index.html
@@ -26,7 +26,7 @@ original_slug: Web/JavaScript/Reference/Operators/可选链
 
 
    语法
    
 
-
    obj?.prop
+
    obj?.prop
 obj?.[expr]
 arr?.[index]
 func?.(args)
@@ -38,19 +38,19 @@ original_slug: Web/JavaScript/Reference/Operators/可选链
 
 
    比如，思考一个存在嵌套结构的对象 obj。不使用可选链的话，查找一个深度嵌套的子属性时，需要验证之间的引用，例如：
    
 
-
    let nestedProp = obj.first && obj.first.second;
    
+
    let nestedProp = obj.first && obj.first.second;
    
 
 
    为了避免报错，在访问obj.first.second之前，要保证 obj.first 的值既不是 null，也不是 undefined。如果只是直接访问 obj.first.second，而不对 obj.first 进行校验，则有可能抛出错误。
    
 
 
    有了可选链操作符（?.），在访问 obj.first.second 之前，不再需要明确地校验 obj.first 的状态，再并用短路计算获取最终结果：
    
 
-
    let nestedProp = obj.first?.second;
    
+
    let nestedProp = obj.first?.second;
    
 
 
    通过使用 ?. 操作符取代 . 操作符，JavaScript 会在尝试访问 obj.first.second 之前，先隐式地检查并确定 obj.first 既不是 null 也不是 undefined。如果obj.first 是 null 或者 undefined，表达式将会短路计算直接返回 undefined。
    
 
 
    这等价于以下表达式，但实际上没有创建临时变量：
    
 
-
    let temp = obj.first;
+
    let temp = obj.first;
 let nestedProp = ((temp === null || temp === undefined) ? undefined : temp.second);
    
 
 
    可选链与函数调用
    
@@ -59,7 +59,7 @@ let nestedProp = ((temp === null || temp === undefined) ? undefined : temp.secon
 
 
    函数调用时如果被调用的方法不存在，使用可选链可以使表达式自动返回undefined而不是抛出一个异常。
    
 
-
    let result = someInterface.customMethod?.();
    
+
    let result = someInterface.customMethod?.();
    
 
 
    
 
    注意: 如果存在一个属性名且不是函数, 使用 ?. 仍然会产生一个 {{JSxRef("TypeError")}} 异常 (x.y is not a function).
    
@@ -73,7 +73,7 @@ let nestedProp = ((temp === null || temp === undefined) ? undefined : temp.secon
 
 
    如果使用解构赋值来解构的一个对象的回调函数或 fetch 方法，你可能得到不能当做函数直接调用的不存在的值，除非你已经校验了他们的存在性。使用?.的你可以忽略这些额外的校验：
    
 
-
    //  ES2019的写法
+
    //  ES2019的写法
 function doSomething(onContent, onError) {
   try {
     // ... do something with the data
@@ -86,7 +86,7 @@ function doSomething(onContent, onError) {
 }
 
    
 
-
    // 使用可选链进行函数调用
+
    // 使用可选链进行函数调用
 function doSomething(onContent, onError) {
   try {
    // ... do something with the data
@@ -101,16 +101,16 @@ function doSomething(onContent, onError) {
 
 
    当使用方括号与属性名的形式来访问属性时，你也可以使用可选链操作符：
    
 
-
    let nestedProp = obj?.['prop' + 'Name'];
    
+
    let nestedProp = obj?.['prop' + 'Name'];
    
 
 
    可选链不能用于赋值
    
 
-
    let object = {};
+
    let object = {};
 object?.property = 1; // Uncaught SyntaxError: Invalid left-hand side in assignment
    
 
 
    可选链访问数组元素
    
 
-
    let arrayItem = arr?.[42];
    
+
    let arrayItem = arr?.[42];
    
 
 
    例子
    
 
@@ -118,7 +118,7 @@ object?.property = 1; // Uncaught SyntaxError: Invalid left-hand side in assignm
 
 
    如下的例子在一个不含 bar 成员的 Map 中查找 bar 成员的 name 属性，因此结果是 undefined。
    
 
-
    let myMap = new Map();
+
    let myMap = new Map();
 myMap.set("foo", {name: "baz", desc: "inga"});
 
 let nameBar = myMap.get("bar")?.name;
    
@@ -127,7 +127,7 @@ let nameBar = myMap.get("bar")?.name;
    
 
 
    当在表达式中使用可选链时，如果左操作数是 null 或 undefined，表达式将不会被计算，例如：
    
 
-
    let potentiallyNullObj = null;
+
    let potentiallyNullObj = null;
 let x = 0;
 let prop = potentiallyNullObj?.[x++];
 
@@ -138,7 +138,7 @@ console.log(x); // x 将不会被递增，依旧输出 0
 
 
    可以连续使用可选链读取多层嵌套结构：
    
 
-
    let customer = {
+
    let customer = {
   name: "Carl",
   details: {
     age: 82,
@@ -155,7 +155,7 @@ let duration = vacations.trip?.getTime?.();
 
 
    {{JSxRef("Operators/Nullish_Coalescing_Operator", "空值合并操作符")}}可以在使用可选链时设置一个默认值：
    
 
-
    let customer = {
+
    let customer = {
   name: "Carl",
   details: { age: 82 }
 };
diff --git a/files/zh-cn/web/javascript/reference/operators/remainder/index.html b/files/zh-cn/web/javascript/reference/operators/remainder/index.html
index f09292e4ff..a2d1e19fa6 100644
--- a/files/zh-cn/web/javascript/reference/operators/remainder/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/remainder/index.html
@@ -21,14 +21,14 @@ original_slug: Web/JavaScript/Reference/Operators/取余
 
 
    语法
    
 
-
    Operator: var1 % var2
+
    Operator: var1 % var2
 
    
 
 
    示例
    
 
 
    被除数为正数
    
 
-
     12 % 5  //  2
+
     12 % 5  //  2
  1 % -2 //  1
  1 % 2  //  1
  2 % 3  //  2
@@ -37,13 +37,13 @@ original_slug: Web/JavaScript/Reference/Operators/取余
 
 
    被除数为负数
    
 
-
    -12 % 5 // -2
+
    -12 % 5 // -2
 -1 % 2  // -1
 -4 % 2  // -0
    
 
 
    被除数为NaN
    
 
-
    NaN % 2 // NaN
    
+
    NaN % 2 // NaN
    
 
 
    规范
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/remainder_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/remainder_assignment/index.html
index a9d015e467..d36fa7cdc3 100644
--- a/files/zh-cn/web/javascript/reference/operators/remainder_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/remainder_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Remainder_assignment
 
 
    语法
    
 
-
    Operator: x %= y
+
    Operator: x %= y
 Meaning:  x  = x % y
    
 
 
    Examples
    
 
 
    Using remainder assignment
    
 
-
    // Assuming the following variable
+
    // Assuming the following variable
 //  bar = 5
 
 bar %= 2     // 1
diff --git a/files/zh-cn/web/javascript/reference/operators/right_shift/index.html b/files/zh-cn/web/javascript/reference/operators/right_shift/index.html
index f049a499a9..583da5cafe 100644
--- a/files/zh-cn/web/javascript/reference/operators/right_shift/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/right_shift/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Right_shift
 
 
    语法
    
 
-
    a >> b
+
    a >> b
 
    
 
 
    Description
    
@@ -22,14 +22,14 @@ translation_of: Web/JavaScript/Reference/Operators/Right_shift
 
 
    For example, 9 >> 2 yields 2:
    
 
-
    .    9 (base 10): 00000000000000000000000000001001 (base 2)
+
    .    9 (base 10): 00000000000000000000000000001001 (base 2)
                   --------------------------------
 9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
 
    
 
 
    Likewise, -9 >> 2 yields -3, because the sign is preserved:
    
 
-
    .    -9 (base 10): 11111111111111111111111111110111 (base 2)
+
    .    -9 (base 10): 11111111111111111111111111110111 (base 2)
                    --------------------------------
 -9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
 
    
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Operators/Right_shift
 
 
    Using right shift
    
 
-
     9 >> 2; //  2
+
     9 >> 2; //  2
 -9 >> 2; // -3
 
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/right_shift_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/right_shift_assignment/index.html
index f9e8b3c8c4..0ebfbbd51e 100644
--- a/files/zh-cn/web/javascript/reference/operators/right_shift_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/right_shift_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Right_shift_assignment
 
 
    语法
    
 
-
    Operator: x >>= y
+
    Operator: x >>= y
 Meaning:  x   = x >> y
    
 
 
    Examples
    
 
 
    Using right shift assignment
    
 
-
    let a = 5; //   (00000000000000000000000000000101)
+
    let a = 5; //   (00000000000000000000000000000101)
 a >>= 2;   // 1 (00000000000000000000000000000001)
 
 let b = -5; //  (-00000000000000000000000000000101)
diff --git a/files/zh-cn/web/javascript/reference/operators/spread_syntax/index.html b/files/zh-cn/web/javascript/reference/operators/spread_syntax/index.html
index 0397ee8e96..3f21c5b960 100644
--- a/files/zh-cn/web/javascript/reference/operators/spread_syntax/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/spread_syntax/index.html
@@ -20,15 +20,15 @@ translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
 
 
    函数调用：
    
 
-
    myFunction(...iterableObj);
    
+
    myFunction(...iterableObj);
    
 
 
    字面量数组构造或字符串：
    
 
-
    [...iterableObj, '4', ...'hello', 6];
    
+
    [...iterableObj, '4', ...'hello', 6];
    
 
 
    构造字面量对象时,进行克隆或者属性拷贝（ECMAScript 2018规范新增特性）：
    
 
-
    let objClone = { ...obj };
    
+
    let objClone = { ...obj };
    
 
 
    示例
    
 
@@ -38,19 +38,19 @@ translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
 
 
    如果想将数组元素迭代为函数参数，一般使用{{jsxref( "Function.prototype.apply")}} 的方式进行调用。
    
 
-
    function myFunction(x, y, z) { }
+
    function myFunction(x, y, z) { }
 var args = [0, 1, 2];
 myFunction.apply(null, args);
    
 
 
    有了展开语法，可以这样写：
    
 
-
    function myFunction(x, y, z) { }
+
    function myFunction(x, y, z) { }
 var args = [0, 1, 2];
 myFunction(...args);
    
 
 
    所有参数都可以通过展开语法来传值，也不限制多次使用展开语法。
    
 
-
    function myFunction(v, w, x, y, z) { }
+
    function myFunction(v, w, x, y, z) { }
 var args = [0, 1];
 myFunction(-1, ...args, 2, ...[3]);
    
 
@@ -58,13 +58,13 @@ myFunction(-1, ...args, 2, ...[3]);
    
 
 
    使用 new 关键字来调用构造函数时，不能直接使用数组+ apply 的方式（apply 执行的是调用 [[Call]] , 而不是构造 [[Construct]]）。当然, 有了展开语法, 将数组展开为构造函数的参数就很简单了：
    
 
-
    var dateFields = [1970, 0, 1]; // 1970年1月1日
+
    var dateFields = [1970, 0, 1]; // 1970年1月1日
 var d = new Date(...dateFields);
 
    
 
 
    如果不使用展开语法, 想将数组元素传给构造函数, 实现方式可能是这样的：
    
 
-
    function applyAndNew(constructor, args) {
+
    function applyAndNew(constructor, args) {
    function partial () {
       return constructor.apply(this, args);
    };
@@ -96,7 +96,7 @@ console.log(new myConstructorWithArguments);
 
 
    没有展开语法的时候，只能组合使用 push, splice, concat 等方法，来将已有数组元素变成新数组的一部分。有了展开语法,  通过字面量方式, 构造新数组会变得更简单、更优雅：
    
 
-
    var parts = ['shoulders', 'knees'];
+
    var parts = ['shoulders', 'knees'];
 var lyrics = ['head', ...parts, 'and', 'toes']; 
 // ["head", "shoulders", "knees", "and", "toes"]
 
    
@@ -105,7 +105,7 @@ var lyrics = ['head', ...parts, 'and', 'toes']; 
 
 
    数组拷贝(copy)
    
 
-
    var arr = [1, 2, 3];
+
    var arr = [1, 2, 3];
 var arr2 = [...arr]; // like arr.slice()
 arr2.push(4);
 
@@ -115,7 +115,7 @@ arr2.push(4);
 
 
    提示: 实际上, 展开语法和 {{jsxref("Object.assign()")}} 行为一致, 执行的都是浅拷贝(只遍历一层)。如果想对多维数组进行深拷贝, 下面的示例就有些问题了。
    
 
-
    var a = [[1], [2], [3]];
+
    var a = [[1], [2], [3]];
 var b = [...a];
 b.shift().shift(); // 1
 // Now array a is affected as well: [[2], [3]]
@@ -125,28 +125,28 @@ b.shift().shift(); // 1
 
 
    {{jsxref("Array.concat")}} 函数常用于将一个数组连接到另一个数组的后面。如果不使用展开语法, 代码可能是下面这样的:
    
 
-
    var arr1 = [0, 1, 2];
+
    var arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 // 将 arr2 中所有元素附加到 arr1 后面并返回
 var arr3 = arr1.concat(arr2);
    
 
 
    使用展开语法:
    
 
-
    var arr1 = [0, 1, 2];
+
    var arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 var arr3 = [...arr1, ...arr2];
 
    
 
 
    {{jsxref("Array.unshift")}} 方法常用于在数组的开头插入新元素/数组.  不使用展开语法, 示例如下:
    
 
-
    var arr1 = [0, 1, 2];
+
    var arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 // 将 arr2 中的元素插入到 arr1 的开头
 Array.prototype.unshift.apply(arr1, arr2) // arr1 现在是 [3, 4, 5, 0, 1, 2]
    
 
 
    如果使用展开语法, 代码如下:  [请注意, 这里使用展开语法创建了一个新的 arr1 数组,  {{jsxref("Array.unshift")}} 方法则是修改了原本存在的 arr1 数组]:
    
 
-
    var arr1 = [0, 1, 2];
+
    var arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 arr1 = [...arr2, ...arr1]; // arr1 现在为 [3, 4, 5, 0, 1, 2]
 
    
@@ -157,7 +157,7 @@ arr1 = [...arr2, ...arr1]; // arr1 现在为 [3, 4, 5, 0, 1, 2]
 
 
    浅拷贝(Shallow-cloning, 不包含 prototype) 和对象合并, 可以使用更简短的展开语法。而不必再使用 {{jsxref("Object.assign()")}} 方式.
    
 
-
    var obj1 = { foo: 'bar', x: 42 };
+
    var obj1 = { foo: 'bar', x: 42 };
 var obj2 = { foo: 'baz', y: 13 };
 
 var clonedObj = { ...obj1 };
@@ -173,7 +173,7 @@ var mergedObj = { ...obj1, ...obj2 };
 
 
    提示: 不能替换或者模拟 {{jsxref("Object.assign()")}} 函数:
    
 
-
    var obj1 = { foo: 'bar', x: 42 };
+
    var obj1 = { foo: 'bar', x: 42 };
 var obj2 = { foo: 'baz', y: 13 };
 const merge = ( ...objects ) => ( { ...objects } );
 
@@ -191,7 +191,7 @@ var mergedObj = merge ( {}, obj1, obj2);
 
 
    在数组或函数参数中使用展开语法时, 该语法只能用于 可迭代对象：
    
 
-
    var obj = {'key1': 'value1'};
+
    var obj = {'key1': 'value1'};
 var array = [...obj]; // TypeError: obj is not iterable
 
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/strict_equality/index.html b/files/zh-cn/web/javascript/reference/operators/strict_equality/index.html
index 125b67c168..1b8211841a 100644
--- a/files/zh-cn/web/javascript/reference/operators/strict_equality/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/strict_equality/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Strict_equality
 
 
    语法
    
 
-
    x === y
    
+
    x === y
    
 
 
    描述
    
 
@@ -39,7 +39,7 @@ translation_of: Web/JavaScript/Reference/Operators/Strict_equality
 
 
    比较相同类型的操作数
    
 
-
    console.log("hello" === "hello");   // true
+
    console.log("hello" === "hello");   // true
 console.log("hello" === "hola");    // false
 
 console.log(3 === 3);               // true
@@ -52,7 +52,7 @@ console.log(null === null);         // true
    
 
 
    比较不同类型的操作数
    
 
-
    console.log("3" === 3);           // false
+
    console.log("3" === 3);           // false
 
 console.log(true === 1);          // false
 
@@ -60,7 +60,7 @@ console.log(null === undefined);  // false
    
 
 
    比较对象
    
 
-
    const object1 = {
+
    const object1 = {
   name: "hello"
 }
 
diff --git a/files/zh-cn/web/javascript/reference/operators/strict_inequality/index.html b/files/zh-cn/web/javascript/reference/operators/strict_inequality/index.html
index a31aa575d1..26efd1748f 100644
--- a/files/zh-cn/web/javascript/reference/operators/strict_inequality/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/strict_inequality/index.html
@@ -13,13 +13,13 @@ translation_of: Web/JavaScript/Reference/Operators/Strict_inequality
 
 
    语法
    
 
-
    x !== y
    
+
    x !== y
    
 
 
    描述
    
 
 
    严格不等式运算符检查其对象是否不相等。它是严格相等运算符的否定，因此下面两行总是会给出相同的结果:
    
 
-
    x !== y
+
    x !== y
 
 !(x === y)
    
 
@@ -27,13 +27,13 @@ translation_of: Web/JavaScript/Reference/Operators/Strict_inequality
 
 
    与严格相等运算符一样，严格不等运算符始终认为不同类型的对象是不同的:
    
 
-
    3 !== "3"; // true
    
+
    3 !== "3"; // true
    
 
 
    示例
    
 
 
    比较相同类型的对象
    
 
-
    console.log("hello" !== "hello");   // false
+
    console.log("hello" !== "hello");   // false
 console.log("hello" !== "hola");    // true
 
 console.log(3 !== 3);               // false
@@ -46,7 +46,7 @@ console.log(null !== null);         // false
    
 
 
    比较不同类型的对象
    
 
-
    console.log("3" !== 3);           // true
+
    console.log("3" !== 3);           // true
 
 console.log(true !== 1);          // true
 
@@ -54,7 +54,7 @@ console.log(null !== undefined);  // true
    
 
 
    比较Object对象
    
 
-
    const object1 = {
+
    const object1 = {
   name: "hello"
 }
 
diff --git a/files/zh-cn/web/javascript/reference/operators/subtraction/index.html b/files/zh-cn/web/javascript/reference/operators/subtraction/index.html
index 00dcee2a1e..c4307e2ace 100644
--- a/files/zh-cn/web/javascript/reference/operators/subtraction/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/subtraction/index.html
@@ -15,19 +15,19 @@ translation_of: Web/JavaScript/Reference/Operators/Subtraction
 
 
    语法
    
 
-
    Operator: x - y
+
    Operator: x - y
 
    
 
 
    Examples
    
 
 
    Subtraction with numbers
    
 
-
    5 - 3     // 2
+
    5 - 3     // 2
 3 - 5     // -2
    
 
 
    Subtraction with non-numbers
    
 
-
    'foo' - 3 // NaN
    
+
    'foo' - 3 // NaN
    
 
 
    Specifications
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/subtraction_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/subtraction_assignment/index.html
index 93dc5a138b..9d96a67f7e 100644
--- a/files/zh-cn/web/javascript/reference/operators/subtraction_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/subtraction_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Subtraction_assignment
 
 
    语法
    
 
-
    Operator: x -= y
+
    Operator: x -= y
 Meaning:  x  = x - y
    
 
 
    Examples
    
 
 
    Using subtraction assignment
    
 
-
    // Assuming the following variable
+
    // Assuming the following variable
 //  bar = 5
 
 bar -= 2     // 3
diff --git a/files/zh-cn/web/javascript/reference/operators/super/index.html b/files/zh-cn/web/javascript/reference/operators/super/index.html
index 1f279cb42f..ba936e09ba 100644
--- a/files/zh-cn/web/javascript/reference/operators/super/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/super/index.html
@@ -16,7 +16,7 @@ translation_of: Web/JavaScript/Reference/Operators/super
 
 
    语法
    
 
-
    super([arguments]);
+
    super([arguments]);
 // 调用 父对象/父类 的构造函数
 
 super.functionOnParent([arguments]);
@@ -33,7 +33,7 @@ super.functionOnParent([arguments]);
 
 
    以下代码片段来自于 classes sample。
    
 
-
    class Polygon {
+
    class Polygon {
   constructor(height, width) {
     this.name = 'Rectangle';
     this.height = height;
@@ -69,7 +69,7 @@ class Square extends Polygon {
 
 
    你也可以用 super 调用父类的静态方法。
    
 
-
    class Rectangle {
+
    class Rectangle {
   constructor() {}
   static logNbSides() {
     return 'I have 4 sides';
@@ -88,7 +88,7 @@ Square.logDescription(); // 'I have 4 sides which are all equal'
    
 
 
    你不能使用 delete 操作符 加 super.prop 或者 super[expr] 去删除父类的属性，这样做会抛出 {{jsxref("ReferenceError")}}。
    
 
-
    class Base {
+
    class Base {
   constructor() {}
   foo() {}
 }
@@ -105,7 +105,7 @@ new Derived().delete(); // ReferenceError: invalid delete involving 'super'.当使用 {{jsxref("Object.defineProperty")}} 定义一个属性为不可写时，super将不能重写这个属性的值。
    
 
-
    class X {
+
    class X {
   constructor() {
     Object.defineProperty(this, 'prop', {
       configurable: true,
@@ -132,7 +132,7 @@ console.log(y.prop); // 1
    
 
 
    Super也可以在object initializer / literal 符号中使用。在下面的例子中，两个对象各定义了一个方法。在第二个对象中, 我们使用super调用了第一个对象中的方法。 当然，这需要我们先利用 {{jsxref("Object.setPrototypeOf()")}} 设置obj2的原型为obj1，然后才能够使用super调用 obj1上的method1。
    
 
-
    var obj1 = {
+
    var obj1 = {
   method1() {
     console.log("method 1");
   }
diff --git a/files/zh-cn/web/javascript/reference/operators/this/index.html b/files/zh-cn/web/javascript/reference/operators/this/index.html
index aea931541f..86616407d0 100644
--- a/files/zh-cn/web/javascript/reference/operators/this/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/this/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Operators/this
 
 
    语法
    
 
-
    this
    
+
    this
    
 
 
    值
    
 
@@ -32,7 +32,7 @@ translation_of: Web/JavaScript/Reference/Operators/this
 
 
    无论是否在严格模式下，在全局执行环境中（在任何函数体外部）this 都指向全局对象。
    
 
-
    // 在浏览器中, window 对象同时也是全局对象：
+
    // 在浏览器中, window 对象同时也是全局对象：
 console.log(this === window); // true
 
 a = 37;
@@ -52,7 +52,7 @@ console.log(b)         // "MDN"
    
 
 
    因为下面的代码不在严格模式下，且 this 的值不是由该调用设置的，所以 this 的值默认指向全局对象，浏览器中就是 {{domxref("Window", "window")}}。
    
 
-
    function f1(){
+
    function f1(){
   return this;
 }
 //在浏览器中：
@@ -64,7 +64,7 @@ f1() === globalThis;
 
 
    然而，在严格模式下，如果进入执行环境时没有设置 this 的值，this 会保持为 undefined，如下：
    
 
-
    function f2(){
+
    function f2(){
   "use strict"; // 这里是严格模式
   return this;
 }
@@ -82,7 +82,7 @@ f2() === undefined; // true
 
 
    在类的构造函数中，this 是一个常规对象。类中所有非静态的方法都会被添加到 this 的原型中：
    
 
-
    class Example {
+
    class Example {
   constructor() {
     const proto = Object.getPrototypeOf(this);
     console.log(Object.getOwnPropertyNames(proto));
@@ -102,7 +102,7 @@ new Example(); // ['constructor', 'first', 'second']
    
 
 
    不像基类的构造函数，派生类的构造函数没有初始的 this 绑定。在构造函数中调用 {{jsxref("Operators/super", "super()")}} 会生成一个 this 绑定，并相当于执行如下代码，Base为基类：
    
 
-
    this = new Base();
    
+
    this = new Base();
    
 
 
    
 
    警告：在调用 super() 之前引用 this 会抛出错误。
    
@@ -110,7 +110,7 @@ new Example(); // ['constructor', 'first', 'second']
    
 
 
    派生类不能在调用 super() 之前返回，除非其构造函数返回的是一个对象，或者根本没有构造函数。
    
 
-
    class Base {}
+
    class Base {}
 class Good extends Base {}
 class AlsoGood extends Base {
   constructor() {
@@ -147,7 +147,7 @@ whatsThis.apply(obj); // 'Custom' 因为函数中的 this 被设置为obj
 
 
    this 和对象转换
    
 
-
    function add(c, d) {
+
    function add(c, d) {
   return this.a + this.b + c + d;
 }
 
@@ -164,7 +164,7 @@ add.apply(o, [10, 20]); // 34
 
 
    在非严格模式下使用 call 和 apply 时，如果用作 this 的值不是对象，则会被尝试转换为对象。null 和 undefined 被转换为全局对象。原始值如 7 或 'foo' 会使用相应构造函数转换为对象。因此 7 会被转换为 new Number(7) 生成的对象，字符串 'foo' 会转换为 new String('foo') 生成的对象。
    
 
-
    function bar() {
+
    function bar() {
   console.log(Object.prototype.toString.call(this));
 }
 
@@ -176,7 +176,7 @@ bar.call(undefined); // [object global]
    
 
 
    ECMAScript 5 引入了 {{jsxref("Function.prototype.bind()")}}。调用f.bind(someObject)会创建一个与f具有相同函数体和作用域的函数，但是在这个新函数中，this将永久地被绑定到了bind的第一个参数，无论这个函数是如何被调用的。
    
 
-
    function f(){
+
    function f(){
   return this.a;
 }
 
@@ -194,7 +194,7 @@ console.log(o.a, o.f(), o.g(), o.h()); // 37, 37, azerty, azerty
 
 
    在箭头函数中，this与封闭词法环境的this保持一致。在全局代码中，它将被设置为全局对象：
    
 
-
    var globalObject = this;
+
    var globalObject = this;
 var foo = (() => this);
 console.log(foo() === globalObject); // true
    
 
@@ -202,7 +202,7 @@ console.log(foo() === globalObject); // true
    
 
    注意：如果将this传递给call、bind、或者apply来调用箭头函数，它将被忽略。不过你仍然可以为调用添加参数，不过第一个参数（thisArg）应该设置为null。
    
 
    
 
-
    // 接着上面的代码
+
    // 接着上面的代码
 // 作为对象的一个方法调用
 var obj = {foo: foo};
 console.log(obj.foo() === globalObject); // true
@@ -216,7 +216,7 @@ console.log(foo() === globalObject); // true
    
 
 
    无论如何，foo 的 this 被设置为他被创建时的环境（在上面的例子中，就是全局对象）。这同样适用于在其他函数内创建的箭头函数：这些箭头函数的this被设置为封闭的词法环境的。
    
 
-
    // 创建一个含有bar方法的obj对象，
+
    // 创建一个含有bar方法的obj对象，
 // bar返回一个函数，
 // 这个函数返回this，
 // 这个返回的函数是以箭头函数创建的，
@@ -252,7 +252,7 @@ console.log(fn2()() == window); // true
    
 
 
    下面的例子中，当 o.f() 被调用时，函数内的 this 将绑定到 o 对象。
    
 
-
    var o = {
+
    var o = {
   prop: 37,
   f: function() {
     return this.prop;
@@ -264,7 +264,7 @@ console.log(o.f()); // 37
 
 
    请注意，这样的行为完全不会受函数定义方式或位置的影响。在前面的例子中，我们在定义对象o的同时，将其中的函数定义为成员 f 。但是，我们也可以先定义函数，然后再将其附属到o.f。这样做的结果是一样的：
    
 
-
    var o = {prop: 37};
+
    var o = {prop: 37};
 
 function independent() {
   return this.prop;
@@ -279,14 +279,14 @@ console.log(o.f()); // 37
 
 
    同样，this 的绑定只受最接近的成员引用的影响。在下面的这个例子中，我们把一个方法g当作对象o.b的函数调用。在这次执行期间，函数中的this将指向o.b。事实证明，这与他是对象 o 的成员没有多大关系，最近的引用才是最重要的。
    
 
-
    o.b = {g: independent, prop: 42};
+
    o.b = {g: independent, prop: 42};
 console.log(o.b.g()); // 42
    
 
 
    原型链中的 this
    
 
 
    对于在对象原型链上某处定义的方法，同样的概念也适用。如果该方法存在于一个对象的原型链上，那么 this 指向的是调用这个方法的对象，就像该方法就在这个对象上一样。
    
 
-
    var o = {
+
    var o = {
   f: function() {
     return this.a + this.b;
   }
@@ -304,7 +304,7 @@ console.log(p.f()); // 5
 
 
    再次，相同的概念也适用于当函数在一个 getter 或者 setter 中被调用。用作 getter 或 setter 的函数都会把 this 绑定到设置或获取属性的对象。
    
 
-
    function sum() {
+
    function sum() {
   return this.a + this.b + this.c;
 }
 
@@ -331,7 +331,7 @@ console.log(o.average, o.sum); // logs 2, 6
 
    虽然构造函数返回的默认值是 this 所指的那个对象，但它仍可以手动返回其他的对象（如果返回值不是一个对象，则返回 this 对象）。
    
 
 
-
    /*
+
    /*
  * 构造函数这样工作:
  *
  * function MyConstructor(){
@@ -370,7 +370,7 @@ console.log(o.a); // logs 38
 
 
    当函数被用作事件处理函数时，它的 this 指向触发事件的元素（一些浏览器在使用非 addEventListener 的函数动态地添加监听函数时不遵守这个约定）。
    
 
-
    // 被调用时，将关联的元素变成蓝色
+
    // 被调用时，将关联的元素变成蓝色
 function bluify(e){
   console.log(this === e.currentTarget); // 总是 true
 
@@ -391,14 +391,14 @@ for(var i=0 ; i<elements.length ; i++){
 
 
    当代码被内联 on-event 处理函数 调用时，它的this指向监听器所在的DOM元素：
    
 
-
    <button onclick="alert(this.tagName.toLowerCase());">
+
    <button onclick="alert(this.tagName.toLowerCase());">
   Show this
 </button>
 
    
 
 
    上面的 alert 会显示 button。注意只有外层代码中的 this 是这样设置的：
    
 
-
    <button onclick="alert((function(){return this})());">
+
    <button onclick="alert((function(){return this})());">
   Show inner this
 </button>
 
    
@@ -409,7 +409,7 @@ for(var i=0 ; i<elements.length ; i++){
 
 
    和其他普通函数一样，方法中的 this 值取决于它们如何被调用。有时，改写这个行为，让类中的 this 值总是指向这个类实例会很有用。为了做到这一点，可在构造函数中绑定类方法：
    
 
-
    class Car {
+
    class Car {
   constructor() {
     // Bind sayBye but not sayHi to show the difference
     this.sayBye = this.sayBye.bind(this);
diff --git a/files/zh-cn/web/javascript/reference/operators/typeof/index.html b/files/zh-cn/web/javascript/reference/operators/typeof/index.html
index 41cf3c8da9..60cd51b992 100644
--- a/files/zh-cn/web/javascript/reference/operators/typeof/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/typeof/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Operators/typeof
 
 
    typeof 运算符后接操作数：
    
 
-
    typeof operand
+
    typeof operand
 typeof(operand)
 
    
 
@@ -88,7 +88,7 @@ typeof(operand)    
 
 
    示例
    
 
-
    // 数值
+
    // 数值
 typeof 37 === 'number';
 typeof 3.14 === 'number';
 typeof(42) === 'number';
@@ -152,7 +152,7 @@ typeof Math.sin === 'function';
 
 
    typeof null
    
 
-
    // JavaScript 诞生以来便如此
+
    // JavaScript 诞生以来便如此
 typeof null === 'object';
    
 
 
    在 JavaScript 最初的实现中，JavaScript 中的值是由一个表示类型的标签和实际数据值表示的。对象的类型标签是 0。由于 null 代表的是空指针（大多数平台下值为 0x00），因此，null 的类型标签是 0，typeof null 也因此返回 "object"。（参考来源）
    
@@ -161,7 +161,7 @@ typeof null === 'object';
    
 
 
    使用 new 操作符
    
 
-
    // 除 Function 外的所有构造函数的类型都是 'object'
+
    // 除 Function 外的所有构造函数的类型都是 'object'
 var str = new String('String');
 var num = new Number(100);
 
@@ -174,7 +174,7 @@ typeof func; // 返回 'function'
    
 
 
    语法中的括号
    
 
-
    // 括号有无将决定表达式的类型。
+
    // 括号有无将决定表达式的类型。
 var iData = 99;
 
 typeof iData + ' Wisen'; // 'number Wisen'
@@ -184,7 +184,7 @@ typeof (iData + ' Wisen'); // 'string'
    
 
 
    对正则表达式字面量的类型判断在某些浏览器中不符合标准：
    
 
-
    typeof /s/ === 'function'; // Chrome 1-12 , 不符合 ECMAScript 5.1
+
    typeof /s/ === 'function'; // Chrome 1-12 , 不符合 ECMAScript 5.1
 typeof /s/ === 'object'; // Firefox 5+ , 符合 ECMAScript 5.1
 
    
 
@@ -194,7 +194,7 @@ typeof /s/ === 'object'; // Firefox 5+ , 符合 ECMAScript 5.1
 
 
    但在加入了块级作用域的 let 和 const 之后，在其被声明之前对块中的 let 和 const 变量使用 typeof 会抛出一个 ReferenceError。块作用域变量在块的头部处于“暂存死区”，直至其被初始化，在这期间，访问变量将会引发错误。
    
 
-
    typeof undeclaredVariable === 'undefined';
+
    typeof undeclaredVariable === 'undefined';
 
 typeof newLetVariable; // ReferenceError
 typeof newConstVariable; // ReferenceError
@@ -208,7 +208,7 @@ class newClass{};
    
 
 
    当前所有的浏览器都暴露了一个类型为 undefined 的非标准宿主对象 {{domxref("document.all")}}。
    
 
-
    typeof document.all === 'undefined';
+
    typeof document.all === 'undefined';
 
    
 
 
    尽管规范允许为非标准的外来对象自定义类型标签，但它要求这些类型标签与已有的不同。document.all 的类型标签为 'undefined' 的例子在 Web 领域中被归类为对原 ECMA JavaScript 标准的“故意侵犯”。
    
@@ -219,7 +219,7 @@ class newClass{};
    
 
 
    For greater specificity in checking types, a typeof wrapper for usage in production-level code would be as follows (provided obj exists):
    
 
-
      function type(obj, fullClass) {
+
      function type(obj, fullClass) {
 
     // get toPrototypeString() of obj (handles all types)
     // Early JS environments return '[object Object]' for null, so it's best to directly check for it.
@@ -265,7 +265,7 @@ class newClass{};
    
 
 
    在 IE 6, 7 和 8 上，很多宿主对象是对象而不是函数。例如：
    
 
-
    typeof alert === 'object'
    
+
    typeof alert === 'object'
    
 
 
 
    
diff --git a/files/zh-cn/web/javascript/reference/operators/unary_negation/index.html b/files/zh-cn/web/javascript/reference/operators/unary_negation/index.html
index 2170b92c53..887a79a2a0 100644
--- a/files/zh-cn/web/javascript/reference/operators/unary_negation/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/unary_negation/index.html
@@ -13,14 +13,14 @@ translation_of: Web/JavaScript/Reference/Operators/Unary_negation
 
 
    语法
    
 
-
    Operator: -x
+
    Operator: -x
 
    
 
 
    Examples
    
 
 
    Negating numbers
    
 
-
    const x = 3;
+
    const x = 3;
 const y = -x;
 
 // y = -3
@@ -31,7 +31,7 @@ const y = -x;
 
 
    The unary negation operator can convert a non-number into a number.
    
 
-
    const x = "4";
+
    const x = "4";
 const y = -x;
 
 // y = -4
diff --git a/files/zh-cn/web/javascript/reference/operators/unary_plus/index.html b/files/zh-cn/web/javascript/reference/operators/unary_plus/index.html
index 9f3b818df9..da09fa1f02 100644
--- a/files/zh-cn/web/javascript/reference/operators/unary_plus/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/unary_plus/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Unary_plus
 
 
    语法
    
 
-
    Operator: +x
+
    Operator: +x
 
    
 
 
    Description
    
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Operators/Unary_plus
 
 
    Usage with numbers
    
 
-
    const x = 1;
+
    const x = 1;
 const y = -1;
 
 console.log(+x);
@@ -34,7 +34,7 @@ console.log(+y);
 
 
    Usage with non-numbers
    
 
-
    +true  // 1
+
    +true  // 1
 +false // 0
 +null  // 0
 +function(val){ return val } // NaN
diff --git a/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift/index.html b/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift/index.html
index f40a28e8b0..52f18ea92c 100644
--- a/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift/index.html
@@ -13,7 +13,7 @@ translation_of: Web/JavaScript/Reference/Operators/Unsigned_right_shift
 
 
    语法
    
 
-
    a >>> b
+
    a >>> b
 
    
 
 
    描述
    
@@ -22,14 +22,14 @@ translation_of: Web/JavaScript/Reference/Operators/Unsigned_right_shift
 
 
    For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result. For example, 9 >>> 2 yields 2, the same as 9 >> 2:
    
 
-
    .     9 (base 10): 00000000000000000000000000001001 (base 2)
+
    .     9 (base 10): 00000000000000000000000000001001 (base 2)
                    --------------------------------
 9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
 
    
 
 
    However, this is not the case for negative numbers. For example, -9 >>> 2 yields 1073741821, which is different than -9 >> 2 (which yields -3):
    
 
-
    .     -9 (base 10): 11111111111111111111111111110111 (base 2)
+
    .     -9 (base 10): 11111111111111111111111111110111 (base 2)
                     --------------------------------
 -9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
 
    
@@ -38,7 +38,7 @@ translation_of: Web/JavaScript/Reference/Operators/Unsigned_right_shift
 
 
    Using unsigned right shift
    
 
-
     9 >>> 2; // 2
+
     9 >>> 2; // 2
 -9 >>> 2; // 1073741821
 
    
 
diff --git a/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html b/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html
index 76379358c0..0c2e1fb3c5 100644
--- a/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html
+++ b/files/zh-cn/web/javascript/reference/operators/unsigned_right_shift_assignment/index.html
@@ -15,14 +15,14 @@ translation_of: Web/JavaScript/Reference/Operators/Unsigned_right_shift_assignme
 
 
    语法
    
 
-
    Operator: x >>>= y
+
    Operator: x >>>= y
 Meaning:  x    = x >>> y
    
 
 
    例子
    
 
 
    Using unsigned right shift assignment
    
 
-
    let a = 5; //   (00000000000000000000000000000101)
+
    let a = 5; //   (00000000000000000000000000000101)
 a >>>= 2;  // 1 (00000000000000000000000000000001)
 
 let b = -5; // (-00000000000000000000000000000101)
diff --git a/files/zh-cn/web/javascript/reference/statements/async_function/index.html b/files/zh-cn/web/javascript/reference/statements/async_function/index.html
index 37aad08974..b4bdd88173 100644
--- a/files/zh-cn/web/javascript/reference/statements/async_function/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/async_function/index.html
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Statements/async_function
 
 
    语法
    
 
-
    async function name([param[, param[, ... param]]]) {
+
    async function name([param[, param[, ... param]]]) {
     statements 
 }
 
    
@@ -65,14 +65,14 @@ translation_of: Web/JavaScript/Reference/Statements/async_function
 
 
    例如，如下代码:
    
 
-
    async function foo() {
+
    async function foo() {
    return 1
 }
 
    
 
 
    等价于:
    
 
-
    function foo() {
+
    function foo() {
    return Promise.resolve(1)
 }
 
    
@@ -81,14 +81,14 @@ translation_of: Web/JavaScript/Reference/Statements/async_function
 
 
    例如：
    
 
-
    async function foo() {
+
    async function foo() {
    await 1
 }
 
    
 
 
    等价于
    
 
-
    function foo() {
+
    function foo() {
    return Promise.resolve(1).then(() => undefined)
 }
 
    
@@ -103,7 +103,7 @@ translation_of: Web/JavaScript/Reference/Statements/async_function
  
  • 一段时间后，同样当第二个promise完结的时候，result2将被赋值为2，之后函数将会正常同步执行，将默认返回undefined 。
    • 
 
 
-
    async function foo() {
+
    async function foo() {
    const result1 = await new Promise((resolve) => setTimeout(() => resolve('1')))
    const result2 = await new Promise((resolve) => setTimeout(() => resolve('2')))
 }
@@ -113,7 +113,7 @@ foo()
    
 
 
    例如，在下面的代码中，在promise链上配置了.catch处理程序，将抛出未处理的promise错误。这是因为p2返回的结果不会被await处理。
    
 
-
    async function foo() {
+
    async function foo() {
    const p1 = new Promise((resolve) => setTimeout(() => resolve('1'), 1000))
    const p2 = new Promise((_,reject) => setTimeout(() => reject('2'), 500))
    const results = [await p1, await p2] // 不推荐使用这种方式，请使用 Promise.all或者Promise.allSettled 
@@ -126,7 +126,7 @@ foo().catch(() => {}) // 捕捉所有的错误...
    
 
 
    简单例子
    
 
-
    var resolveAfter2Seconds = function() {
+
    var resolveAfter2Seconds = function() {
   console.log("starting slow promise");
   return new Promise(resolve => {
     setTimeout(function() {
@@ -238,7 +238,7 @@ setTimeout(parallelPromise, 13000); // same as parallel
 
 
    返回 {{jsxref("Promise")}}的 API 将会产生一个 promise 链，它将函数肢解成许多部分。例如下面的代码：
    
 
-
    function getProcessedData(url) {
+
    function getProcessedData(url) {
   return downloadData(url) // 返回一个 promise 对象
     .catch(e => {
       return downloadFallbackData(url)  // 返回一个 promise 对象
@@ -250,7 +250,7 @@ setTimeout(parallelPromise, 13000); // same as parallel
 
 
    可以重写为单个async函数：
    
 
-
    async function getProcessedData(url) {
+
    async function getProcessedData(url) {
   let v;
   try {
     v = await downloadData(url);
@@ -270,7 +270,7 @@ setTimeout(parallelPromise, 13000); // same as parallel
 
 
    看下下面重写的上面代码，在processDataInWorker抛出异常时返回了null：
    
 
-
    async function getProcessedData(url) {
+
    async function getProcessedData(url) {
   let v;
   try {
     v = await downloadData(url);
diff --git a/files/zh-cn/web/javascript/reference/statements/break/index.html b/files/zh-cn/web/javascript/reference/statements/break/index.html
index 25d8964e32..c0297dbb86 100644
--- a/files/zh-cn/web/javascript/reference/statements/break/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/break/index.html
@@ -14,7 +14,7 @@ translation_of: Web/JavaScript/Reference/Statements/break
 
 
    语法
    
 
-
    break [label];
    
+
    break [label];
    
 
 
    
     
    label {{optional_inline}}
    
@@ -33,7 +33,7 @@ translation_of: Web/JavaScript/Reference/Statements/break
 
 
    下面的函数里有个 break 语句，当 i 为 3 时，会中止 {{jsxref("Statements/while", "while")}} 循环，然后返回 3 * x 的值。
    
 
-
    function testBreak(x) {
+
    function testBreak(x) {
   var i = 0;
 
   while (i < 6) {
@@ -50,7 +50,7 @@ translation_of: Web/JavaScript/Reference/Statements/break
 
 
    在下面的代码中， break 使用在 {{jsxref("Statements/switch", "switch")}} 语句中，当遇到匹配到case后，就会执行相应的代码并中断循环体。
    
 
-
    const food = "sushi";
+
    const food = "sushi";
 
 switch (food) {
   case "sushi":
@@ -68,7 +68,7 @@ switch (food) {
 
 
    下面的代码中一起使用 break 语句和被标记的块语句。一个 break 语句必须内嵌在它引用的标记中。注意，inner_block 内嵌在 outer_block 中。
    
 
-
    outer_block:{
+
    outer_block:{
 
   inner_block:{
     console.log ('1');
@@ -84,7 +84,7 @@ switch (food) {
 
 
    下面的代码同样使用了 break 语句和被标记的块语句，但是产生了一个语法错误，因为它的 break 语句在 block_1 中，但是引用了 block_2。break 语句必须内嵌在它引用的标签中。
    
 
-
    block_1:{
+
    block_1:{
   console.log ('1');
   break block_2;            // SyntaxError: label not found
 }
@@ -98,7 +98,7 @@ block_2:{
 
 
    在下面的代码同样会产生SyntaxError，因为它并没被正确的使用在循环、switch或label语句中。
    
 
-
    function testBreak(x) {
+
    function testBreak(x) {
   var i = 0;
 
   while (i < 6) {
@@ -116,7 +116,7 @@ return i * x;
 testBreak(1); // SyntaxError: Illegal break statement
 
    
 
-
    block_1: {
+
    block_1: {
   console.log('1');
   ( function() {
     break block_1; // SyntaxError: Undefined label 'block_1'
diff --git a/files/zh-cn/web/javascript/reference/statements/const/index.html b/files/zh-cn/web/javascript/reference/statements/const/index.html
index b096efd17f..de8e0c7f39 100644
--- a/files/zh-cn/web/javascript/reference/statements/const/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/const/index.html
@@ -19,7 +19,7 @@ translation_of: Web/JavaScript/Reference/Statements/const
 
 
    语法
    
 
-
    const name1 = value1 [, name2 = value2 [, ... [, nameN = valueN]]];
    
+
    const name1 = value1 [, name2 = value2 [, ... [, nameN = valueN]]];
    
 
 
    
  
    nameN
    
@@ -44,7 +44,7 @@ translation_of: Web/JavaScript/Reference/Statements/const
 
 
    常量在声明的时候可以使用大小写，但通常情况下全部用大写字母。
    
 
-
    // 定义常量MY_FAV并赋值7
+
    // 定义常量MY_FAV并赋值7
 const MY_FAV = 7;
 
 // 报错 - Uncaught TypeError: Assignment to constant variable.
@@ -69,7 +69,7 @@ let MY_FAV = 20;
 
 
    注意块作用域的性质很重要
    
 
-
    if (MY_FAV === 7) {
+
    if (MY_FAV === 7) {
   // 没问题，并且创建了一个块作用域变量 MY_FAV
   // (works equally well with let to declare a block scoped non const variable)
   let MY_FAV = 20;
@@ -87,7 +87,7 @@ console.log('my favorite number is ' + MY_FAV);
 
 
    常量要求一个初始值
    
 
-
    // 报错
+
    // 报错
 // Uncaught SyntaxError: Missing initializer in const declaration
 
 const FOO;
@@ -97,7 +97,7 @@ const FOO;
 
 
    常量可以定义成对象和数组
    
 
-
    const MY_OBJECT = {'key': 'value'};
+
    const MY_OBJECT = {'key': 'value'};
 
 // 重写对象和上面一样会失败
 // Uncaught TypeError: Assignment to constant variable.
diff --git a/files/zh-cn/web/javascript/reference/statements/export/index.html b/files/zh-cn/web/javascript/reference/statements/export/index.html
index 2eb0086a2f..f2a8e5a226 100644
--- a/files/zh-cn/web/javascript/reference/statements/export/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/export/index.html
@@ -24,7 +24,7 @@ translation_of: Web/JavaScript/Reference/Statements/export
  
  • 默认导出（每个模块包含一个）
    • 
 
 
-
    // 导出单个特性
+
    // 导出单个特性
 export let name1, name2, …, nameN; // also var, const
 export let name1 = …, name2 = …, …, nameN; // also var, const
 export function FunctionName(){...}
@@ -63,7 +63,7 @@ export { default } from …;
    
 
 
    命名导出：
    
 
-
    // 导出事先定义的特性
+
    // 导出事先定义的特性
 export { myFunction，myVariable };
 
 // 导出单个特性（可以导出var，let，
@@ -73,7 +73,7 @@ export function myFunction() { ... };
    
 
 
    默认导出：
    
 
-
    // 导出事先定义的特性作为默认值
+
    // 导出事先定义的特性作为默认值
 export { myFunction as default };
 
 // 导出单个特性作为默认值
@@ -86,16 +86,16 @@ export default class { .. }
 
 
    但是，可以使用任何名称导入默认导出，例如：
    
 
-
    // 文件 test.js
+
    // 文件 test.js
 let k; export default k = 12; 
    
 
-
    // 另一个文件
+
    // 另一个文件
 import m from './test'; // 由于 k 是默认导出，所以可以自由使用 import m 替代 import k
 console.log(m);        // 输出为 12 
    
 
 
     你也可以重命名命名导出以避免命名冲突：
    
 
-
    export { myFunction as function1,
+
    export { myFunction as function1,
          myVariable as variable };
    
 
 
    重导出 / 聚合
    
@@ -104,13 +104,13 @@ console.log(m);        // 输出为 12 
    
 
 
    这个可以使用“export from”语法实现：
    
 
-
    export { default as function1,
+
    export { default as function1,
          function2 } from 'bar.js';
 
    
 
 
    与之形成对比的是联合使用导入和导出：
    
 
-
    import { default as function1,
+
    import { default as function1,
          function2 } from 'bar.js';
 export { function1, function2 };
 
    
@@ -121,14 +121,14 @@ export { function1, function2 };
 
    注意：尽管与import等效，但以下语法在语法上无效：
    
 
 
-
    import DefaultExport from 'bar.js'; // 有效的
+
    import DefaultExport from 'bar.js'; // 有效的
 
    
 
-
    export DefaultExport from 'bar.js'; // 无效的
    
+
    export DefaultExport from 'bar.js'; // 无效的
    
 
 
    这里正确的做法是重命名这个导出：
    
 
-
    export { default as DefaultExport } from 'bar.js';
    
+
    export { default as DefaultExport } from 'bar.js';
    
 
 
    示例
    
 
@@ -136,7 +136,7 @@ export { function1, function2 };
 
 
    在模块 my-module.js 中，可能包含以下代码：
    
 
-
    // module "my-module.js"
+
    // module "my-module.js"
 function cube(x) {
   return x * x * x;
 }
@@ -158,7 +158,7 @@ export { cube, foo, graph };
 
 
    然后，在你的 HTML 页面的顶级模块中：
    
 
-
    import { cube, foo, graph } from 'my-module.js';
+
    import { cube, foo, graph } from 'my-module.js';
 
 graph.options = {
     color:'blue',
@@ -180,7 +180,7 @@ console.log(foo);    // 4.555806215962888
    
 
 
    如果我们要导出一个值或得到模块中的返回值，就可以使用默认导出：
    
 
-
    // module "my-module.js"
+
    // module "my-module.js"
 
 export default function cube(x) {
   return x * x * x;
@@ -189,7 +189,7 @@ export default function cube(x) {
 
 
    然后，在另一个脚本中，可以直接导入默认导出：
    
 
-
    import cube from './my-module.js';
+
    import cube from './my-module.js';
 console.log(cube(3)); // 27
 
    
 
@@ -206,24 +206,24 @@ console.log(cube(3)); // 27
 
 
    你的代码看起来应该像这样：
    
 
-
    // childModule1.js 中
+
    // childModule1.js 中
 let myFunction = ...; // assign something useful to myFunction
 let myVariable = ...; // assign something useful to myVariable
 export {myFunction, myVariable};
    
 
-
    // childModule2.js 中
+
    // childModule2.js 中
 let myClass = ...; // assign something useful to myClass
 export myClass;
 
    
 
-
    // parentModule.js 中
+
    // parentModule.js 中
 // 仅仅聚合 childModule1 和 childModule2 中的导出
 // 以重新导出他们
 export { myFunction, myVariable } from 'childModule1.js';
 export { myClass } from 'childModule2.js';
 
    
 
-
    // 顶层模块中
+
    // 顶层模块中
 // 我们可以从单个模块调用所有导出，因为 parentModule 事先
 // 已经将他们“收集”/“打包”到一起
 import { myFunction, myVariable, myClass } from 'parentModule.js'
diff --git a/files/zh-cn/web/javascript/reference/statements/for-await...of/index.html b/files/zh-cn/web/javascript/reference/statements/for-await...of/index.html
index 247677e1b9..597426a1fc 100644
--- a/files/zh-cn/web/javascript/reference/statements/for-await...of/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/for-await...of/index.html
@@ -28,7 +28,7 @@ translation_of: Web/JavaScript/Reference/Statements/for-await...of
 
 
    语法
    
 
-
    for await (variable of iterable) {
+
    for await (variable of iterable) {
   statement
 }
 
    
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Statements/for-await...of
 
 
    你还可以迭代一个明确实现异步迭代协议的对象：
    
 
-
    var asyncIterable = {
+
    var asyncIterable = {
   [Symbol.asyncIterator]() {
     return {
       i: 0,
@@ -76,7 +76,7 @@ translation_of: Web/JavaScript/Reference/Statements/for-await...of
 
 
    异步生成器已经实现了异步迭代器协议, 所以可以用 for await...of循环。
    
 
-
    async function* asyncGenerator() {
+
    async function* asyncGenerator() {
   var i = 0;
   while (i < 3) {
     yield i++;
@@ -94,7 +94,7 @@ translation_of: Web/JavaScript/Reference/Statements/for-await...of
 
 
    有关使用for await... of考虑迭代API中获取数据的异步 generator 更具体的例子。这个例子首先为一个数据流创建了一个异步 generator，然后使用它来获得这个API的响应值的大小。
    
 
-
    async function* streamAsyncIterator(stream) {
+
    async function* streamAsyncIterator(stream) {
   const reader = stream.getReader();
   try {
     while (true) {
diff --git a/files/zh-cn/web/javascript/reference/statements/for...in/index.html b/files/zh-cn/web/javascript/reference/statements/for...in/index.html
index 7254cda762..b1ec38f6ef 100644
--- a/files/zh-cn/web/javascript/reference/statements/for...in/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/for...in/index.html
@@ -12,7 +12,7 @@ translation_of: Web/JavaScript/Reference/Statements/for...in
 
 
    语法
    
 
-
    for (variable in object)
+
    for (variable in object)
   statement
    
 
 
    
@@ -47,7 +47,7 @@ translation_of: Web/JavaScript/Reference/Statements/for...in
 
 
    下面的函数接受一个对象作为参数。被调用时迭代传入对象的所有可枚举属性然后返回一个所有属性名和其对应值的字符串。
    
 
-
    var obj = {a:1, b:2, c:3};
+
    var obj = {a:1, b:2, c:3};
 
 for (var prop in obj) {
   console.log("obj." + prop + " = " + obj[prop]);
@@ -60,7 +60,7 @@ for (var prop in obj) {
 
 
    下面的函数说明了{{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}}的用法：继承的属性不显示。
    
 
-
    var triangle = {a: 1, b: 2, c: 3};
+
    var triangle = {a: 1, b: 2, c: 3};
 
 function ColoredTriangle() {
   this.color = 'red';
@@ -124,7 +124,7 @@ for (var prop in obj) {
 
 
    在 SpiderMonkey 40 {{geckoRelease(40)}} 版本之前，可以在使用一个初始化表达式（i=0）在一个for...in循环中：
    
 
-
    var obj = {a: 1, b: 2, c: 3};
+
    var obj = {a: 1, b: 2, c: 3};
 for (var i = 0 in obj) {
   console.log(obj[i]);
 }
diff --git a/files/zh-cn/web/javascript/reference/statements/function/index.html b/files/zh-cn/web/javascript/reference/statements/function/index.html
index dc052a53d0..0ab978503d 100644
--- a/files/zh-cn/web/javascript/reference/statements/function/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/function/index.html
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Statements/function
 
 
    语法
    
 
-
    function name([param,[, param,[..., param]]]) {
+
    function name([param,[, param,[..., param]]]) {
    [statements]
 }
 
    
@@ -55,7 +55,7 @@ translation_of: Web/JavaScript/Reference/Statements/function
 
 
    函数可以被有条件来声明，这意味着，函数声明可能出现在一个 if 语句里，但是，这种声明方式在不同的浏览器里可能有不同的效果。因此，不应该在生产环境代码中使用这种声明方式，应该使用函数表达式来代替。
    
 
-
    var hoisted = "foo" in this;
+
    var hoisted = "foo" in this;
 console.log(`'foo' name ${hoisted ? "is" : "is not"} hoisted. typeof foo is ${typeof foo}`);
 if (false) {
   function foo(){ return 1; }
@@ -75,7 +75,7 @@ if (false) {
 
 
    注意，即使把上面代码中的 if(false) 改为 if(true)，结果也是一样的
    
 
-
    var hoisted = "foo" in this;
+
    var hoisted = "foo" in this;
 console.log(`'foo' name ${hoisted ? "is" : "is not"} hoisted. typeof foo is ${typeof foo}`);
 if (true) {
   function foo(){ return 1; }
@@ -98,7 +98,7 @@ if (true) {
 
 
    JavaScript 中的函数声明被提升到了函数定义。你可以在函数声明之前使用该函数:
    
 
-
    hoisted(); // logs "foo"
+
    hoisted(); // logs "foo"
 
 function hoisted() {
   console.log('foo');
@@ -109,7 +109,7 @@ function hoisted() {
 
    注意 :函数表达式{{jsxref("Operators/function", "function expressions")}} 不会被提升:
    
 
 
-
    notHoisted(); // TypeError: notHoisted is not a function
+
    notHoisted(); // TypeError: notHoisted is not a function
 
 var notHoisted = function() {
   console.log('bar');
@@ -122,7 +122,7 @@ var notHoisted = function() {
 
 
    下面的代码声明了一个函数,该函数返回了销售的总金额, 参数是产品a,b,c分别的销售的数量.
    
 
-
    function calc_sales(units_a, units_b, units_c) {functionfunctionfunctionfunctionfunctionfunctionfunctionfunctionfunctionfunctionfunction
+
    function calc_sales(units_a, units_b, units_c) {functionfunctionfunctionfunctionfunctionfunctionfunctionfunctionfunctionfunctionfunction
    return units_a*79 + units_b * 129 + units_c * 699;
 }
    
 
diff --git a/files/zh-cn/web/javascript/reference/statements/import/index.html b/files/zh-cn/web/javascript/reference/statements/import/index.html
index eac05517ff..8daa4187e2 100644
--- a/files/zh-cn/web/javascript/reference/statements/import/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/import/index.html
@@ -21,7 +21,7 @@ translation_of: Web/JavaScript/Reference/Statements/import
 
 
    语法
    
 
-
    import defaultExport from "module-name";
+
    import defaultExport from "module-name";
 import * as name from "module-name";
 import { export } from "module-name";
 import { export as alias } from "module-name";
@@ -55,37 +55,37 @@ var promise = import("module-name");//这是一个处于第三阶段的提案。
 
 
    这将myModule插入当前作用域，其中包含来自位于/modules/my-module.js文件中导出的所有接口。
    
 
-
    import * as myModule from '/modules/my-module.js';
+
    import * as myModule from '/modules/my-module.js';
 
    
 
 
    在这里，访问导出接口意味着使用模块名称（在本例为“myModule”）作为命名空间。例如，如果上面导入的模块包含一个接口doAllTheAmazingThings()，你可以这样调用：
    
 
-
    myModule.doAllTheAmazingThings();
    
+
    myModule.doAllTheAmazingThings();
    
 
 
    导入单个接口
    
 
 
    给定一个名为myExport的对象或值，它已经从模块my-module导出（因为整个模块被导出）或显式地导出（使用{{jsxref("Statements/export", "export")}}语句），将myExport插入当前作用域。
    
 
-
    import {myExport} from '/modules/my-module.js';
    
+
    import {myExport} from '/modules/my-module.js';
    
 
 
    导入多个接口
    
 
 
    这将foo和bar插入当前作用域。
    
 
-
    import {foo, bar} from '/modules/my-module.js';
    
+
    import {foo, bar} from '/modules/my-module.js';
    
 
 
    导入带有别名的接口
    
 
 
    你可以在导入时重命名接口。例如，将shortName插入当前作用域。
    
 
-
    import {reallyReallyLongModuleExportName as shortName}
+
    import {reallyReallyLongModuleExportName as shortName}
   from '/modules/my-module.js';
    
 
 
    导入时重命名多个接口
    
 
 
    使用别名导入模块的多个接口。
    
 
-
    import {
+
    import {
   reallyReallyLongModuleMemberName as shortName,
   anotherLongModuleName as short
 } from '/modules/my-module.js';
@@ -95,7 +95,7 @@ var promise = import("module-name");//这是一个处于第三阶段的提案。
 
 
    整个模块仅为副作用（中性词，无贬义含义）而导入，而不导入模块中的任何内容（接口）。 这将运行模块中的全局代码, 但实际上不导入任何值。
    
 
-
    import '/modules/my-module.js';
    
+
    import '/modules/my-module.js';
    
 
 
    导入默认值
    
 
@@ -103,22 +103,22 @@ var promise = import("module-name");//这是一个处于第三阶段的提案。
 
 
    最简单的用法是直接导入默认值：
    
 
-
    import myDefault from '/modules/my-module.js';
    
+
    import myDefault from '/modules/my-module.js';
    
 
 
    也可以同时将default语法与上述用法（命名空间导入或命名导入）一起使用。在这种情况下，default导入必须首先声明。 例如：
    
 
-
    import myDefault, * as myModule from '/modules/my-module.js';
+
    import myDefault, * as myModule from '/modules/my-module.js';
 // myModule used as a namespace
    
 
 
    或者
    
 
-
    import myDefault, {foo, bar} from '/modules/my-module.js';
+
    import myDefault, {foo, bar} from '/modules/my-module.js';
 // specific, named imports
 
    
 
 
    当用{{anch("动态导入")}}的方式导入默认导出时，其工作方式有所不同。你需要从返回的对象中解构并重命名 "default" 键。
    
 
-
    (async () => {
+
    (async () => {
   if (somethingIsTrue) {
     const { default: myDefault, foo, bar } = await import('/modules/my-module.js');
   }
@@ -140,7 +140,7 @@ var promise = import("module-name");//这是一个处于第三阶段的提案。
 
 
    关键字import可以像调用函数一样来动态的导入模块。以这种方式调用，将返回一个 promise。
    
 
-
    import('/modules/my-module.js')
+
    import('/modules/my-module.js')
   .then((module) => {
     // Do something with the module.
   });
@@ -148,7 +148,7 @@ var promise = import("module-name");//这是一个处于第三阶段的提案。
 
 
    这种使用方式也支持 await 关键字。
    
 
-
    let module = await import('/modules/my-module.js');
    
+
    let module = await import('/modules/my-module.js');
    
 
 
    示例
    
 
@@ -158,7 +158,7 @@ var promise = import("module-name");//这是一个处于第三阶段的提案。
 
 
    模块：file.js
    
 
-
    function getJSON(url, callback) {
+
    function getJSON(url, callback) {
   let xhr = new XMLHttpRequest();
   xhr.onload = function () {
     callback(this.responseText)
@@ -173,7 +173,7 @@ export function getUsefulContents(url, callback) {
 
 
    主程序：main.js
    
 
-
    import { getUsefulContents } from '/modules/file.js';
+
    import { getUsefulContents } from '/modules/file.js';
 
 getUsefulContents('http://www.example.com',
     data => { doSomethingUseful(data); });
    
@@ -182,7 +182,7 @@ getUsefulContents('http://www.example.com',
 
 
    此示例展示了如何基于用户操作去加载功能模块到页面上，在例子中通过点击按钮，然后会调用模块内的函数。当然这不是能实现这个功能的唯一方式，import()函数也可以支持await。
    
 
-
    const main = document.querySelector("main");
+
    const main = document.querySelector("main");
 for (const link of document.querySelectorAll("nav > a")) {
   link.addEventListener("click", e => {
     e.preventDefault();
diff --git a/files/zh-cn/web/javascript/reference/statements/let/index.html b/files/zh-cn/web/javascript/reference/statements/let/index.html
index 84898ef237..0dc1a84365 100644
--- a/files/zh-cn/web/javascript/reference/statements/let/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/let/index.html
@@ -23,7 +23,7 @@ translation_of: Web/JavaScript/Reference/Statements/let
 
 
    语法
    
 
-
    let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];
    
+
    let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];
    
 
 
    参数
    
 
@@ -46,7 +46,7 @@ translation_of: Web/JavaScript/Reference/Statements/let
 
 
    let声明的变量只在其声明的块或子块中可用，这一点，与var相似。二者之间最主要的区别在于var声明的变量的作用域是整个封闭函数。
    
 
-
    function varTest() {
+
    function varTest() {
   var x = 1;
   {
     var x = 2;  // 同样的变量!
@@ -69,7 +69,7 @@ function letTest() {
 
 
    位于函数或代码顶部的var声明会给全局对象新增属性, 而let不会。例如:
    
 
-
    var x = 'global';
+
    var x = 'global';
 let y = 'global';
 console.log(this.x); // "global"
 console.log(this.y); // undefined
@@ -79,7 +79,7 @@ console.log(this.y); // undefined
 
 
    在处理构造函数的时候，可以通过let声明而不是闭包来创建一个或多个私有成员。
    
 
-
    var Thing;
+
    var Thing;
 
 {
   let privateScope = new WeakMap();
@@ -122,7 +122,7 @@ thing.showPrivate();
 
 
    在同一个函数或块作用域中重复声明同一个变量会引起{{jsxref("SyntaxError")}}。
    
 
-
    if (x) {
+
    if (x) {
   let foo;
   let foo; // SyntaxError thrown.
 }
@@ -130,7 +130,7 @@ thing.showPrivate();
 
 
    在 switch 语句中只有一个块，你可能因此而遇到错误。
    
 
-
    let x = 1;
+
    let x = 1;
 switch(x) {
   case 0:
     let foo;
@@ -144,7 +144,7 @@ switch(x) {
 
 
    然而，需要特别指出的是，一个嵌套在 case 子句中的块会创建一个新的块作用域的词法环境，就不会产生上诉重复声明的错误。
    
 
-
    let x = 1;
+
    let x = 1;
 
 switch(x) {
   case 0: {
@@ -162,7 +162,7 @@ switch(x) {
 
 
    与通过  var 声明的有初始化值 undefined 的变量不同，通过 let 声明的变量直到它们的定义被执行时才初始化。在变量初始化前访问该变量会导致 ReferenceError。该变量处在一个自块顶部到初始化处理的“暂存死区”中。
    
 
-
    function do_something() {
+
    function do_something() {
   console.log(bar); // undefined
   console.log(foo); // ReferenceError
   var bar = 1;
@@ -173,7 +173,7 @@ switch(x) {
 
 
    与通过var声明的变量, 有初始化值 undefined和只是未声明的变量不同的是，如果使用typeof检测在暂存死区中的变量, 会抛出ReferenceError异常:
    
 
-
    // prints out 'undefined'
+
    // prints out 'undefined'
 console.log(typeof undeclaredVariable);
 
 // results in a 'ReferenceError'
@@ -189,7 +189,7 @@ let i = 10;
 
 
    这个if块里的foo还依旧在暂存死区里。
    
 
-
    function test(){
+
    function test(){
    var foo = 33;
    if (foo) {
       let foo = (foo + 55); // ReferenceError
@@ -201,7 +201,7 @@ test();
    
 
 
    在没有执行到它的初始化语句之前，它仍旧存在于暂存死区中。
    
 
-
    function go(n) {
+
    function go(n) {
   // n here is defined!
   console.log(n); // Object {a: [1,2,3]}
 
@@ -216,7 +216,7 @@ go({a: [1, 2, 3]});
    
 
 
    用在块级作用域中时, let将变量的作用域限制在块内, 而var声明的变量的作用域是在函数内.
    
 
-
    var a = 1;
+
    var a = 1;
 var b = 2;
 
 if (a === 1) {
@@ -232,7 +232,7 @@ console.log(b); // 2
    
 
 
    而这种var 与 let合并的声明方式会报SyntaxError错误, 因为var会将变量提升至块的顶部, 这会导致隐式地重复声明变量.
    
 
-
    let x = 1;
+
    let x = 1;
 
 {
   var x = 2; // SyntaxError for re-declaration
diff --git a/files/zh-cn/web/javascript/reference/statements/switch/index.html b/files/zh-cn/web/javascript/reference/statements/switch/index.html
index 64cce4f231..763bda116b 100644
--- a/files/zh-cn/web/javascript/reference/statements/switch/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/switch/index.html
@@ -20,7 +20,7 @@ translation_of: Web/JavaScript/Reference/Statements/switch
 
 
    语法
    
 
-
    switch (expression) {
+
    switch (expression) {
   case value1:
     // 当 expression 的结果与 value1 匹配时，执行此处语句
     [break;]
@@ -59,7 +59,7 @@ translation_of: Web/JavaScript/Reference/Statements/switch
 
 
    下面的例子中，如果 expr 计算为 "Bananas"，程序就会匹配值为 "Bananas" 的 case 然后执行相关语句。当遇到 break 时，程序就跳出 switch 然后执行 switch 后的语句。若 break 被省略，值为 "Cherries" 的 case 中的语句就也将被执行。
    
 
-
    switch (expr) {
+
    switch (expr) {
   case 'Oranges':
     console.log('Oranges are $0.59 a pound.');
     break;
@@ -87,7 +87,7 @@ console.log("Is there anything else you'd like?");
 
 
    如果你忘记添加 break，那么代码将会从值所匹配的 case 语句开始运行，然后持续执行下一个 case 语句而不论值是否匹配。例子如下：
    
 
-
    var foo = 0;
+
    var foo = 0;
 switch (foo) {
   case -1:
     console.log('negative 1');
@@ -109,7 +109,7 @@ switch (foo) {
 
 
    可以啊！JavaScript 会在它找不到匹配项时跳回到那个 default ：
    
 
-
    var foo = 5;
+
    var foo = 5;
 switch (foo) {
   case 2:
     console.log(2);
@@ -136,7 +136,7 @@ switch (foo) {
 
 
    这是一个单操作顺序的 switch 语句，其中四个不同值的执行结果完全一样。
    
 
-
    var Animal = 'Giraffe';
+
    var Animal = 'Giraffe';
 switch (Animal) {
   case 'Cow':
   case 'Giraffe':
@@ -153,7 +153,7 @@ switch (Animal) {
 
 
    这是一个关联操作顺序的 switch 语句，其中，根据所输入的整数，你会得到不同的输出。这表示它将以你放置 case 语句的顺序遍历，并且不必是数字顺序的。在 JavaScript 中，你甚至可以将字符串定义到这些 case 语句里。
    
 
-
    var foo = 1;
+
    var foo = 1;
 var output = 'Output: ';
 switch (foo) {
   case 0:
@@ -222,7 +222,7 @@ switch (foo) {
 
 
    以这段代码为例：
    
 
-
    const action = 'say_hello';
+
    const action = 'say_hello';
 switch (action) {
   case 'say_hello':
     let message = 'hello';
@@ -243,7 +243,7 @@ switch (action) {
 
 
    通过把 case 语句包装到括号里面，我们就可以轻松解决这个问题。
    
 
-
    const action = 'say_hello';
+
    const action = 'say_hello';
 switch (action) {
   case 'say_hello': { // added brackets
     let message = 'hello';
diff --git a/files/zh-cn/web/javascript/reference/statements/with/index.html b/files/zh-cn/web/javascript/reference/statements/with/index.html
index 32ce03679b..4454271872 100644
--- a/files/zh-cn/web/javascript/reference/statements/with/index.html
+++ b/files/zh-cn/web/javascript/reference/statements/with/index.html
@@ -15,7 +15,7 @@ translation_of: Web/JavaScript/Reference/Statements/with
 
 
    语法
    
 
-
    with (expression) {
+
    with (expression) {
     statement
 }
 
    
@@ -43,7 +43,7 @@ translation_of: Web/JavaScript/Reference/Statements/with
 
 
    弊端：with语句使得代码不易阅读，同时使得JavaScript编译器难以在作用域链上查找某个变量，难以决定应该在哪个对象上来取值。请看下面的例子：
    
 
-
    function f(x, o) {
+
    function f(x, o) {
   with (o)
     print(x);
 }
    
@@ -53,7 +53,7 @@ translation_of: Web/JavaScript/Reference/Statements/with
 
    弊端：使用with语句的代码，无法向前兼容，特別是在使用一些原生数据类型的时候。看下面的例子：
    
 
 
    
-
    function f(foo, values) {
+
    function f(foo, values) {
     with (foo) {
         console.log(values)
     }
@@ -69,7 +69,7 @@ translation_of: Web/JavaScript/Reference/Statements/with
 
 
    下面的with语句指定Math对象作为默认对象。with语句里面的变量，分別指向Math对象的PI 、cos和sin函数，不用在前面添加命名空间。后续所有引用都指向Math对象。
    
 
-
    var a, x, y;
+
    var a, x, y;
 var r = 10;
 
 with (Math) {
-- 
cgit v1.2.3-54-g00ecf