From 176fe9dcd650905b904029a21ae8963c3fae4719 Mon Sep 17 00:00:00 2001
From: Liu <lc-soft@live.cn>
Date: Fri, 6 Sep 2019 18:11:51 +0800
Subject: [PATCH 001/280] docs(proxy): add spaces around the operator

---
 docs/proxy.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index a9b1d4ddd..0ec65c95f 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -1131,7 +1131,7 @@ service.employees().then(json => {
 function createWebService(baseUrl) {
   return new Proxy({}, {
     get(target, propKey, receiver) {
-      return () => httpGet(baseUrl+'/' + propKey);
+      return () => httpGet(baseUrl + '/' + propKey);
     }
   });
 }

From e87aba7bd95154b31ddbb45001fc209d9f0a7211 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 7 Sep 2019 11:39:10 +0800
Subject: [PATCH 002/280] feat: add banner

---
 js/ditto.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/js/ditto.js b/js/ditto.js
index 7247ee301..3985123b0 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -207,6 +207,23 @@ function li_create_linkage(li_tag, header_level) {
   });
 }
 
+function create_banner(element) {
+  var styleStr = [
+    'margin: 1em 0',
+    'padding: 1em',
+    'background-color: #c4e0e1',
+    'border-radius: 5px',
+    'font-size: 90%'
+  ].join(';');
+
+  var text = '<a href="">Vue 实战教程</a> ' +
+    '深入学习一线大厂必备 Vue 技能。VIP 教程限时免费领取。' +
+    '<a href="">⇐ 立即查看</a>';
+
+  var banner = $('<div style="' + styleStr + '">' + text + '</div>')
+    .insertAfter(element);
+}
+
 function create_page_anchors() {
   // create page anchors by matching li's to headers
   // if there is a match, create click listeners
@@ -243,6 +260,9 @@ function create_page_anchors() {
         .insertAfter('#content h1')
         .addClass('content-toc')
         .attr('id', 'content-toc');
+
+      create_banner(ul_tag);
+
       for (var j = 0; j < headers.length; j++) {
         var li_tag = $('<li></li>').html('<a href="#' + location.hash.split('#')[1] + '#' + headers[j] + '">' + headers[j] + '</a>');
         ul_tag.append(li_tag);

From 6128c2eec31ad140b11b108b8e0ad9f75d438b73 Mon Sep 17 00:00:00 2001
From: Vincent Hy <Veminem@outlook.com>
Date: Wed, 11 Sep 2019 14:02:19 +0800
Subject: [PATCH 003/280] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20'WeaKSet'=20?=
 =?UTF-8?q?=E5=90=8D=E8=AF=8D=E6=8B=BC=E5=86=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/set-map.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index 4680c8bad..f22a87541 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -354,7 +354,7 @@ const ws = new WeakSet(b);
 // Uncaught TypeError: Invalid value used in weak set(…)
 ```
 
-上面代码中，数组`b`的成员不是对象，加入 WeaKSet 就会报错。
+上面代码中，数组`b`的成员不是对象，加入 WeakSet 就会报错。
 
 WeakSet 结构有以下三个方法。
 

From 10338972d5ee6815dd5a9419ee2a936913d2fc0f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 14 Sep 2019 17:37:20 +0800
Subject: [PATCH 004/280] docs(class): fix #906

---
 docs/class.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index ba4d6378d..a235dd689 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -681,7 +681,7 @@ Foo.prop // 1
 
 上面的写法为`Foo`类定义了一个静态属性`prop`。
 
-目前，只有这种写法可行，因为 ES6 明确规定，Class 内部只有静态方法，没有静态属性。现在有一个[提案](https://github.com/tc39/proposal-class-fields)提供了类的静态属性，写法是在实例属性法的前面，加上`static`关键字。
+目前，只有这种写法可行，因为 ES6 明确规定，Class 内部只有静态方法，没有静态属性。现在有一个[提案](https://github.com/tc39/proposal-class-fields)提供了类的静态属性，写法是在实例属性的前面，加上`static`关键字。
 
 ```javascript
 class MyClass {

From fa183748b39d004a29099f2007e07642f247d0de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=BE=99=E8=85=BE=E9=81=93?= <LongTengDao@LongTengDao.com>
Date: Sat, 14 Sep 2019 22:34:42 +0800
Subject: [PATCH 005/280] Update regex.md

---
 docs/regex.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/regex.md b/docs/regex.md
index 9fa854fa2..c95e4fe39 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -132,6 +132,15 @@ codePointLength(s) // 2
 
 上面代码中，不加`u`修饰符，就无法识别非规范的`K`字符。
 
+**（6）转义**
+
+在没有`u`修饰符的情况下，正则中没有定义的转义（如`/\,/`）相当于没有转义（`/,/`）；而在`u`模式下，这会报错。
+
+```javascript
+/\,/ // /\,/
+/\,/u // Uncaught SyntaxError: Invalid regular expression: /\,/: Invalid escape
+```
+
 ## RegExp.prototype.unicode 属性
 
 正则实例对象新增`unicode`属性，表示是否设置了`u`修饰符。

From 8372288661c62c2a58bb1e65dc8c086314d8dd48 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 18 Sep 2019 01:47:26 +0800
Subject: [PATCH 006/280] docs(regex): edit u flag

---
 docs/regex.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/regex.md b/docs/regex.md
index c95e4fe39..370b01fa4 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -134,13 +134,15 @@ codePointLength(s) // 2
 
 **（6）转义**
 
-在没有`u`修饰符的情况下，正则中没有定义的转义（如`/\,/`）相当于没有转义（`/,/`）；而在`u`模式下，这会报错。
+没有`u`修饰符的情况下，正则中没有定义的转义（如逗号的转义`\,`）无效，而在`u`模式会报错。
 
 ```javascript
 /\,/ // /\,/
-/\,/u // Uncaught SyntaxError: Invalid regular expression: /\,/: Invalid escape
+/\,/u // 报错
 ```
 
+上面代码中，没有`u`修饰符时，逗号前面的反斜杠是无效的，加了`u`修饰符就报错。
+
 ## RegExp.prototype.unicode 属性
 
 正则实例对象新增`unicode`属性，表示是否设置了`u`修饰符。

From 95352fdf1196b0ccb23991d37c1ac462e1baa980 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 18 Sep 2019 17:55:23 +0800
Subject: [PATCH 007/280] docs(proposals): edit Nullish coalescing

---
 docs/proposals.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 49 insertions(+), 1 deletion(-)

diff --git a/docs/proposals.md b/docs/proposals.md
index 8cf5c0b1c..7746b8f3a 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -273,12 +273,60 @@ const showSplashScreen = response.settings.showSplashScreen ?? true;
 
 上面代码中，默认值只有在属性值为`null`或`undefined`时，才会生效。
 
-这个运算符可以跟链判断运算符`?.`配合使用。
+这个运算符的一个目的，就是跟链判断运算符`?.`配合使用，为`null`或`undefined`的值设置默认值。
 
 ```javascript
 const animationDuration = response.settings?.animationDuration ?? 300;
 ```
 
+上面代码中，`response.settings`如果是`null`或`undefined`，就会返回默认值300。
+
+这个运算符很适合判断函数参数是否赋值。
+
+```javascript
+function Component(props) {
+  const enable = props.enabled ?? true;
+  // …
+}
+```
+
+上面代码判断`props`参数的`enabled`属性是否赋值，等同于下面的写法。
+
+```javascript
+function Component(props) {
+  const {
+    enabled: enable = true,
+  } = props;
+  // …
+}
+```
+
+`??`有一个运算优先级问题，它与`&&`和`||`的优先级孰高孰低。现在的规则是，如果多个逻辑运算符一起使用，必须用括号表明优先级，否则会报错。
+
+```javascript
+// 报错
+lhs && middle ?? rhs
+lhs ?? middle && rhs
+lhs || middle ?? rhs
+lhs ?? middle || rhs
+```
+
+上面四个表达式都会报错，必须加入表明优先级的括号。
+
+```javascript
+(lhs && middle) ?? rhs;
+lhs && (middle ?? rhs);
+
+(lhs ?? middle) && rhs;
+lhs ?? (middle && rhs);
+
+(lhs || middle) ?? rhs;
+lhs || (middle ?? rhs);
+
+(lhs ?? middle) || rhs;
+lhs ?? (middle || rhs);
+```
+
 ## 函数的部分执行
 
 ### 语法

From 22665e7efc6f5345e0e2d2d3e8d609fc44fe0baa Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 20 Sep 2019 22:12:44 +0800
Subject: [PATCH 008/280] docs(generator): fix #910

---
 docs/generator.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/generator.md b/docs/generator.md
index e08a149af..c0683c6b4 100644
--- a/docs/generator.md
+++ b/docs/generator.md
@@ -700,7 +700,7 @@ g.next()        // { value: 1, done: false }
 g.return() // { value: undefined, done: true }
 ```
 
-如果 Generator 函数内部有`try...finally`代码块，且正在执行`try`代码块，那么`return`方法会推迟到`finally`代码块执行完再执行。
+如果 Generator 函数内部有`try...finally`代码块，且正在执行`try`代码块，那么`return`方法会导致立刻进入`finally`代码块，执行完以后，整个函数才会结束。
 
 ```javascript
 function* numbers () {
@@ -722,7 +722,7 @@ g.next() // { value: 5, done: false }
 g.next() // { value: 7, done: true }
 ```
 
-上面代码中，调用`return`方法后，就开始执行`finally`代码块，然后等到`finally`代码块执行完，再执行`return`方法。
+上面代码中，调用`return()`方法后，就开始执行`finally`代码块，不执行`try`里面剩下的代码了，然后等到`finally`代码块执行完，再返回`return()`方法指定的返回值。
 
 ## next()、throw()、return() 的共同点
 

From 561b30426ef7e49775e6849a142a4e58d71dc5e8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 20 Sep 2019 22:35:01 +0800
Subject: [PATCH 009/280] docs(string-methods): fix #913

---
 docs/string-methods.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 318d0f724..0d91bb305 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -49,16 +49,16 @@ String.raw`Hi\\n` === "Hi\\\\n" // true
 
 `String.raw()`方法可以作为处理模板字符串的基本方法，它会将所有变量替换，而且对斜杠进行转义，方便下一步作为字符串来使用。
 
-`String.raw()`方法也可以作为正常的函数使用。这时，它的第一个参数，应该是一个具有`raw`属性的对象，且`raw`属性的值应该是一个数组。
+`String.raw()`本质上是一个正常的函数，只是专用于模板字符串的标签函数。如果写成正常函数的形式，它的第一个参数，应该是一个具有`raw`属性的对象，且`raw`属性的值应该是一个数组，对应模板字符串解析后的值。
 
 ```javascript
-String.raw({ raw: 'test' }, 0, 1, 2);
-// 't0e1s2t'
-
+// `foo${1 + 2}bar`
 // 等同于
-String.raw({ raw: ['t','e','s','t'] }, 0, 1, 2);
+String.raw({ raw: ['foo', 'bar'] }, 1 + 2) // "foo3bar"
 ```
 
+上面代码中，`String.raw()`方法的第一个参数是一个对象，它的`raw`属性等同于原始的模板字符串解析后得到的数组。
+
 作为函数，`String.raw()`的代码实现基本如下。
 
 ```javascript

From 0e7b53f00f6235929753c0fa526bf9e8e41a039f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 20 Sep 2019 22:37:47 +0800
Subject: [PATCH 010/280] docs(string-methods): fix #913

---
 docs/string-methods.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 0d91bb305..99233f310 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -31,11 +31,11 @@ String.fromCodePoint(0x78, 0x1f680, 0x79) === 'x\uD83D\uDE80y'
 ES6 还为原生的 String 对象，提供了一个`raw()`方法。该方法返回一个斜杠都被转义（即斜杠前面再加一个斜杠）的字符串，往往用于模板字符串的处理方法。
 
 ```javascript
-String.raw`Hi\n${2+3}!`;
-// 返回 "Hi\\n5!"
+String.raw`Hi\n${2+3}!`
+// 实际返回 "Hi\\n5!"，显示的是转义后的结果 "Hi\n5!"
 
 String.raw`Hi\u000A!`;
-// 返回 "Hi\\u000A!"
+// 实际返回 "Hi\\u000A!"，显示的是转义后的结果 "Hi\u000A!"
 ```
 
 如果原字符串的斜杠已经转义，那么`String.raw()`会进行再次转义。

From 647f1221a774c352dfe5d6937261fd031d9d5bbb Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 6 Oct 2019 09:48:19 +0800
Subject: [PATCH 011/280] =?UTF-8?q?docs(array):=20Array.prototype.sore=20?=
 =?UTF-8?q?=E7=9A=84=E6=8E=92=E5=BA=8F=E7=A8=B3=E5=AE=9A=E6=80=A7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/array.md | 42 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

diff --git a/docs/array.md b/docs/array.md
index 08dd118b7..d1f123f46 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -32,7 +32,7 @@ const numbers = [4, 38];
 add(...numbers) // 42
 ```
 
-上面代码中，`array.push(...items)`和`add(...numbers)`这两行，都是函数的调用，它们的都使用了扩展运算符。该运算符将一个数组，变为参数序列。
+上面代码中，`array.push(...items)`和`add(...numbers)`这两行，都是函数的调用，它们都使用了扩展运算符。该运算符将一个数组，变为参数序列。
 
 扩展运算符与正常的函数参数可以结合使用，非常灵活。
 
@@ -947,3 +947,43 @@ for (let i of arr) {
 ```
 
 由于空位的处理规则非常不统一，所以建议避免出现空位。
+
+## Array.prototype.sort() 的排序稳定性
+
+排序稳定性（stable sorting）是排序算法的重要属性，指的是排序关键字相同的项目，排序前后的顺序不变。
+
+```javascript
+const arr = [
+  'peach',
+  'straw',
+  'apple',
+  'spork'
+];
+
+const stableSorting = (s1, s2) => {
+  if (s1[0] < s2[0]) return -1;
+  return 1;
+};
+
+arr.sort(stableSorting)
+// ["apple", "peach", "straw", "spork"]
+```
+
+上面代码对数组`arr`按照首字母进行排序。排序结果中，`straw`在`spork`的前面，跟原始顺序一致，所以排序算法`stableSorting`是稳定排序。
+
+```javascript
+const unstableSorting = (s1, s2) => {
+  if (s1[0] <= s2[0]) return -1;
+  return 1;
+};
+
+arr.sort(unstableSorting)
+// ["apple", "peach", "spork", "straw"]
+```
+
+上面代码中，排序结果是`spork`在`straw`前面，跟原始顺序相反，所以排序算法`unstableSorting`是不稳定的。
+
+常见的排序算法之中，插入排序、合并排序、冒泡排序等都是稳定的，堆排序、快速排序等是不稳定的。不稳定排序的主要缺点是，多重排序时可能会产生问题。假设有一个姓和名的列表，按照“先姓，后名”进行排序。开发者可能会先按名字排序，再按姓氏进行排序。如果排序算法是稳定的，这样也可以达到“先姓，后名”的排序效果。如果是不稳定的，就不行。
+
+早先的 ECMAScript 没有规定，`Array.prototype.sort()`的默认排序算法是否稳定，留给浏览器自己决定，这导致某些实现是不稳定的。[ES2019](https://github.com/tc39/ecma262/pull/1340) 明确规定，`Array.prototype.sort()`的默认排序算法必须稳定。这个规定已经做到了，现在 JavaScript 各个主要实现的默认排序算法都是稳定的。
+

From 99b39cc2300015a8e194ac9466a9cf460878e526 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 6 Oct 2019 20:11:13 +0800
Subject: [PATCH 012/280] docs(Promise): edit Promise

---
 docs/promise.md | 141 +++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 135 insertions(+), 6 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 27ea878a3..4b62999e2 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -567,13 +567,13 @@ Promise.reject(3).finally(() => {})
 
 ## Promise.all()
 
-`Promise.all`方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。
+`Promise.all()`方法用于将多个 Promise 实例，包装成一个新的 Promise 实例。
 
 ```javascript
 const p = Promise.all([p1, p2, p3]);
 ```
 
-上面代码中，`Promise.all`方法接受一个数组作为参数，`p1`、`p2`、`p3`都是 Promise 实例，如果不是，就会先调用下面讲到的`Promise.resolve`方法，将参数转为 Promise 实例，再进一步处理。（`Promise.all`方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。）
+上面代码中，`Promise.all()`方法接受一个数组作为参数，`p1`、`p2`、`p3`都是 Promise 实例，如果不是，就会先调用下面讲到的`Promise.resolve`方法，将参数转为 Promise 实例，再进一步处理。另外，`Promise.all()`方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。
 
 `p`的状态由`p1`、`p2`、`p3`决定，分成两种情况。
 
@@ -662,7 +662,7 @@ Promise.all([p1, p2])
 
 ## Promise.race()
 
-`Promise.race`方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。
+`Promise.race()`方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。
 
 ```javascript
 const p = Promise.race([p1, p2, p3]);
@@ -670,7 +670,7 @@ const p = Promise.race([p1, p2, p3]);
 
 上面代码中，只要`p1`、`p2`、`p3`之中有一个实例率先改变状态，`p`的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给`p`的回调函数。
 
-`Promise.race`方法的参数与`Promise.all`方法一样，如果不是 Promise 实例，就会先调用下面讲到的`Promise.resolve`方法，将参数转为 Promise 实例，再进一步处理。
+`Promise.race()`方法的参数与`Promise.all()`方法一样，如果不是 Promise 实例，就会先调用下面讲到的`Promise.resolve()`方法，将参数转为 Promise 实例，再进一步处理。
 
 下面是一个例子，如果指定时间内没有获得结果，就将 Promise 的状态变为`reject`，否则变为`resolve`。
 
@@ -689,9 +689,138 @@ p
 
 上面代码中，如果 5 秒之内`fetch`方法无法返回结果，变量`p`的状态就会变为`rejected`，从而触发`catch`方法指定的回调函数。
 
+## Promise.allSettled()
+
+`Promise.allSettled()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果，不管是`fulfilled`还是`rejected`，包装实例才会结束。该方法由[ES2020](https://github.com/tc39/proposal-promise-allSettled) 引入。
+
+```javascript
+const promises = [
+  fetch('/api-1'),
+  fetch('/api-2'),
+  fetch('/api-3'),
+];
+
+await Promise.allSettled(promises);
+removeLoadingIndicator();
+```
+
+上面代码对服务器发出三个请求，等到三个请求都结束，不管请求成功还是失败，加载的滚动图标就会消失。
+
+该方法返回的新的 Promise 实例，一旦结束，状态总是`fulfilled`，不会变成`rejected`。状态变成`fulfilled`后，Promise 的监听函数接收到的参数是一个数组，每个成员对应一个传入`Promise.allSettled()`的 Promise 实例。
+
+```javascript
+const resolved = Promise.resolve(42);
+const rejected = Promise.reject(-1);
+
+const allSettledPromise = Promise.allSettled([resolved, rejected]);
+
+allSettledPromise.then(function (results) {
+  console.log(results);
+});
+// [
+//    { status: 'fulfilled', value: 42 },
+//    { status: 'rejected', reason: -1 }
+// ]
+```
+
+上面代码中，`Promise.allSettled()`的返回值`allSettledPromise`，状态只可能变成`fulfilled`。它的监听函数接收到的参数是数组`results`。该数组的每个成员都是一个对象，对应传入`Promise.allSettled()`的两个 Promise 实例。每个对象都有`status`属性，该属性的值只可能是字符串`fulfilled`或字符串`rejected`。`fulfilled`时，对象有`value`属性，`rejected`时有`reason`属性，对应两种状态的返回值。
+
+下面是返回值用法的例子。
+
+```javascript
+const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
+const results = await Promise.allSettled(promises);
+
+// 过滤出成功的请求
+const successfulPromises = results.filter(p => p.status === 'fulfilled');
+
+// 过滤出失败的请求，并输出原因
+const errors = results
+  .filter(p => p.status === 'rejected')
+  .map(p => p.reason);
+```
+
+有时候，我们不关心异步操作的结果，只关心这些操作有没有结束。这时，`Promise.allSettled()`方法就很有用。如果没有这个方法，想要确保所有操作都结束，就很麻烦。`Promise.all()`方法无法做到这一点。
+
+```javascript
+const urls = [ /* ... */ ];
+const requests = urls.map(x => fetch(x));
+
+try {
+  await Promise.all(requests);
+  console.log('所有请求都成功。');
+} catch {
+  console.log('至少一个请求失败，其他请求可能还没结束。');
+}
+```
+
+上面代码中，`Promise.all()`无法确定所有请求都结束。想要达到这个目的，写起来很麻烦，有了`Promise.allSettled()`，这就很容易了。
+
+## Promise.any()
+
+`Promise.any()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只要参数实例有一个变成`fulfilled`状态，包装实例就会变成`fulfilled`状态；如果所有参数实例都变成`rejected`状态，包装实例就会变成`rejected`状态。该方法目前是一个第三阶段的[提案](https://github.com/tc39/proposal-promise-any) 。
+
+`Promise.all()`跟`Promise.race()`方法很像，只有一点不同，就是不会因为某个 Promise 变成`rejected`状态而结束。
+
+```javascript
+const promises = [
+  fetch('/endpoint-a').then(() => 'a'),
+  fetch('/endpoint-b').then(() => 'b'),
+  fetch('/endpoint-c').then(() => 'c'),
+];
+try {
+  const first = await Promise.any(promises);
+  console.log(first);
+} catch (error) {
+  console.log(error);
+}
+```
+
+上面代码中，`Promise.any()`方法的参数数组包含三个 Promise 操作。其中只要有一个变成`fulfilled`，`Promise.any()`返回的 Promise 对象就变成`fulfilled`。如果所有三个操作都变成`rejected`，那么就会`await`命令就会抛出错误。
+
+`Promise.any()`抛出的错误，不是一个一般的错误，而是一个 AggregateError 实例。它相当于一个数组，每个成员对应一个被`rejected`的操作所抛出的错误。下面是 AggregateError 的实现示例。
+
+```javascript
+new AggregateError() extends Array -> AggregateError
+
+const err = new AggregateError();
+err.push(new Error("first error"));
+err.push(new Error("second error"));
+throw err;
+```
+
+捕捉错误时，如果不用`try...catch`结构和 await 命令，可以像下面这样写。
+
+```javascript
+Promise.any(promises).then(
+  (first) => {
+    // Any of the promises was fulfilled.
+  },
+  (error) => {
+    // All of the promises were rejected.
+  }
+);
+```
+
+下面是一个例子。
+
+```javascript
+var resolved = Promise.resolve(42);
+var rejected = Promise.reject(-1);
+var alsoRejected = Promise.reject(Infinity);
+
+Promise.any([resolved, rejected, alsoRejected]).then(function (result) {
+  console.log(result); // 42
+});
+
+Promise.any([rejected, alsoRejected]).catch(function (results) {
+  console.log(results); // [-1, Infinity]
+});
+```
+
 ## Promise.resolve()
 
-有时需要将现有对象转为 Promise 对象，`Promise.resolve`方法就起到这个作用。
+有时需要将现有对象转为 Promise 对象，`Promise.resolve()`方法就起到这个作用。
 
 ```javascript
 const jsPromise = Promise.resolve($.ajax('/whatever.json'));
@@ -699,7 +828,7 @@ const jsPromise = Promise.resolve($.ajax('/whatever.json'));
 
 上面代码将 jQuery 生成的`deferred`对象，转为一个新的 Promise 对象。
 
-`Promise.resolve`等价于下面的写法。
+`Promise.resolve()`等价于下面的写法。
 
 ```javascript
 Promise.resolve('foo')

From eebbf77f99d2553c8a144cf766f34cc8e3ab2d5e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 6 Oct 2019 22:58:18 +0800
Subject: [PATCH 013/280] docs(proposals): edit BigInt

---
 docs/promise.md   | 2 +-
 docs/proposals.md | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 4b62999e2..5dd098504 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -691,7 +691,7 @@ p
 
 ## Promise.allSettled()
 
-`Promise.allSettled()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果，不管是`fulfilled`还是`rejected`，包装实例才会结束。该方法由[ES2020](https://github.com/tc39/proposal-promise-allSettled) 引入。
+`Promise.allSettled()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果，不管是`fulfilled`还是`rejected`，包装实例才会结束。该方法由 [ES2020](https://github.com/tc39/proposal-promise-allSettled) 引入。
 
 ```javascript
 const promises = [
diff --git a/docs/proposals.md b/docs/proposals.md
index 7746b8f3a..f10c1caaa 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -694,12 +694,15 @@ BigInt(1.5) // RangeError
 BigInt('1.5') // SyntaxError
 ```
 
-BigInt 对象继承了 Object 提供的实例方法。
+BigInt 对象继承了 Object 对象的两个实例方法。
 
-- `BigInt.prototype.toLocaleString()`
 - `BigInt.prototype.toString()`
 - `BigInt.prototype.valueOf()`
 
+它还继承了 Number 对象的一个实例方法。
+
+- `BigInt.prototype.toLocaleString()`
+
 此外，还提供了三个静态方法。
 
 - `BigInt.asUintN(width, BigInt)`： 给定的 BigInt 转为 0 到 2<sup>width</sup> - 1 之间对应的值。

From 7a028069c94ef37a715b83be81c26eef08b4f82a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=A4=A7=E9=B1=BC=E4=BD=A0=E4=B8=AA=E9=94=85=E9=94=85?=
 <31118840+igwhaler@users.noreply.github.com>
Date: Thu, 10 Oct 2019 11:45:05 +0800
Subject: [PATCH 014/280] Update promise.md

---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index 5dd098504..bd2b631e4 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -760,7 +760,7 @@ try {
 
 `Promise.any()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只要参数实例有一个变成`fulfilled`状态，包装实例就会变成`fulfilled`状态；如果所有参数实例都变成`rejected`状态，包装实例就会变成`rejected`状态。该方法目前是一个第三阶段的[提案](https://github.com/tc39/proposal-promise-any) 。
 
-`Promise.all()`跟`Promise.race()`方法很像，只有一点不同，就是不会因为某个 Promise 变成`rejected`状态而结束。
+`Promise.any()`跟`Promise.race()`方法很像，只有一点不同，就是不会因为某个 Promise 变成`rejected`状态而结束。
 
 ```javascript
 const promises = [

From 00f624e13707a02556d7a23a6948cead9c051c20 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 13 Oct 2019 22:23:44 +0800
Subject: [PATCH 015/280] feat: add banner

---
 js/ditto.js | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 3985123b0..edccf29bd 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -95,6 +95,8 @@ function init_sidebar_section() {
             }
             location.hash = menu[i + 1];
         });
+        create_banner($(ditto.sidebar_id).find('p:nth-child(3)').first());
+
     }, "text").fail(function() {
         alert("Opps! can't find the sidebar file to display!");
     });
@@ -208,19 +210,24 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
+  // 2019年11月20日
+  var deadline = new Date(2019, 10, 20);
+  if (deadline - (new Date()) < 0) return;
+
   var styleStr = [
     'margin: 1em 0',
     'padding: 1em',
     'background-color: #c4e0e1',
     'border-radius: 5px',
-    'font-size: 90%'
+    'font-size: 75%',
+    'color: #333333'
   ].join(';');
 
-  var text = '<a href="">Vue 实战教程</a> ' +
-    '深入学习一线大厂必备 Vue 技能。VIP 教程限时免费领取。' +
-    '<a href="">⇐ 立即查看</a>';
+  var text = '<span style="color: #4682BE;">ES6 实战教程</span> ' +
+    '深入学习一线大厂必备 ES6 技能。VIP 教程限时免费领取。' +
+    '<span style="color: #4682BE;">⇐ 立即查看</span>';
 
-  var banner = $('<div style="' + styleStr + '">' + text + '</div>')
+  var banner = $('<a href="http://www.mawen.co/question/405" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 
@@ -261,7 +268,7 @@ function create_page_anchors() {
         .addClass('content-toc')
         .attr('id', 'content-toc');
 
-      create_banner(ul_tag);
+      // create_banner(ul_tag);
 
       for (var j = 0; j < headers.length; j++) {
         var li_tag = $('<li></li>').html('<a href="#' + location.hash.split('#')[1] + '#' + headers[j] + '">' + headers[j] + '</a>');

From 4ebdc52dfbf8c8f44d6b72b0183e87e2c76124e1 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 13 Oct 2019 22:30:14 +0800
Subject: [PATCH 016/280] refact: add banner

---
 js/ditto.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/js/ditto.js b/js/ditto.js
index edccf29bd..e11931f16 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -220,6 +220,7 @@ function create_banner(element) {
     'background-color: #c4e0e1',
     'border-radius: 5px',
     'font-size: 75%',
+    'width: 210px',
     'color: #333333'
   ].join(';');
 

From 247a499d6ed5e4131e0094694f7d31daf86bc730 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 15 Oct 2019 18:45:13 +0800
Subject: [PATCH 017/280] refact: edit banner

---
 js/ditto.js | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index e11931f16..c7ede6cfd 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -95,7 +95,7 @@ function init_sidebar_section() {
             }
             location.hash = menu[i + 1];
         });
-        create_banner($(ditto.sidebar_id).find('p:nth-child(3)').first());
+        // create_banner($(ditto.sidebar_id).find('p:nth-child(3)').first());
 
     }, "text").fail(function() {
         alert("Opps! can't find the sidebar file to display!");
@@ -219,14 +219,15 @@ function create_banner(element) {
     'padding: 1em',
     'background-color: #c4e0e1',
     'border-radius: 5px',
-    'font-size: 75%',
-    'width: 210px',
+    'font-size: 90%',
+    // 'font-size: 75%',
+    // 'width: 210px',
     'color: #333333'
   ].join(';');
 
-  var text = '<span style="color: #4682BE;">ES6 实战教程</span> ' +
+  var text = '<span style="color: #4682BE;">《ES6 实战教程》</span> ' +
     '深入学习一线大厂必备 ES6 技能。VIP 教程限时免费领取。' +
-    '<span style="color: #4682BE;">⇐ 立即查看</span>';
+    '<span style="color: #4682BE;"> ⇐ 立即查看</span>';
 
   var banner = $('<a href="http://www.mawen.co/question/405" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
@@ -269,7 +270,7 @@ function create_page_anchors() {
         .addClass('content-toc')
         .attr('id', 'content-toc');
 
-      // create_banner(ul_tag);
+      create_banner(ul_tag);
 
       for (var j = 0; j < headers.length; j++) {
         var li_tag = $('<li></li>').html('<a href="#' + location.hash.split('#')[1] + '#' + headers[j] + '">' + headers[j] + '</a>');

From dff5c20de71b7811466a80920f650bbe0e72741b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=B0=8F=E6=87=92=E8=B1=86?= <webxujw@163.com>
Date: Tue, 29 Oct 2019 14:35:24 +0800
Subject: [PATCH 018/280] fix:Add description

fix:Add description
---
 docs/symbol.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index 3233e8000..f2ecc1711 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -370,7 +370,7 @@ Object.getOwnPropertySymbols(x) // [Symbol(size)]
 
 ## Symbol.for()，Symbol.keyFor()
 
-有时，我们希望重新使用同一个 Symbol 值，`Symbol.for`方法可以做到这一点。它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建并返回一个以该字符串为名称的 Symbol 值。
+有时，我们希望重新使用同一个 Symbol 值，`Symbol.for`方法可以做到这一点。它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建一个以该字符串为名称注册到全局的 Symbol 值然后返回。
 
 ```javascript
 let s1 = Symbol.for('foo');

From 3484625f67fee6874c12c9212eecb6940cb916ce Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 31 Oct 2019 01:28:52 +0800
Subject: [PATCH 019/280] docs(symbol): edit Symbol.for()

---
 docs/symbol.md | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index f2ecc1711..39b304b99 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -370,7 +370,7 @@ Object.getOwnPropertySymbols(x) // [Symbol(size)]
 
 ## Symbol.for()，Symbol.keyFor()
 
-有时，我们希望重新使用同一个 Symbol 值，`Symbol.for`方法可以做到这一点。它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建一个以该字符串为名称注册到全局的 Symbol 值然后返回。
+有时，我们希望重新使用同一个 Symbol 值，`Symbol.for()`方法可以做到这一点。它接受一个字符串作为参数，然后搜索有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建一个以该字符串为名称的 Symbol 值，并将其注册到全局。
 
 ```javascript
 let s1 = Symbol.for('foo');
@@ -393,7 +393,7 @@ Symbol("bar") === Symbol("bar")
 
 上面代码中，由于`Symbol()`写法没有登记机制，所以每次调用都会返回一个不同的值。
 
-`Symbol.keyFor`方法返回一个已登记的 Symbol 类型值的`key`。
+`Symbol.keyFor()`方法返回一个已登记的 Symbol 类型值的`key`。
 
 ```javascript
 let s1 = Symbol.for("foo");
@@ -405,7 +405,21 @@ Symbol.keyFor(s2) // undefined
 
 上面代码中，变量`s2`属于未登记的 Symbol 值，所以返回`undefined`。
 
-需要注意的是，`Symbol.for`为 Symbol 值登记的名字，是全局环境的，可以在不同的 iframe 或 service worker 中取到同一个值。
+注意，`Symbol.for()`为 Symbol 值登记的名字，是全局环境的，不管有没有在全局环境运行。
+
+```javascript
+function foo() {
+  return Symbol.for('bar');
+}
+
+const x = foo();
+const y = Symbol.for('bar');
+console.log(x === y); // true
+```
+
+上面代码中，`Symbol.for('bar')`是函数内部运行的，但是生成的 Symbol 值是登记在全局环境的。所以，第二次运行`Symbol.for('bar')`可以取到这个 Symbol 值。
+
+`Symbol.for()`的这个全局登记特性，可以用在不同的 iframe 或 service worker 中取到同一个值。
 
 ```javascript
 iframe = document.createElement('iframe');

From 6deab4b66c79893c65c321cdecc36bc97f065d16 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 8 Nov 2019 10:40:11 +0800
Subject: [PATCH 020/280] refactor: modify banner date

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index c7ede6cfd..6d48b4421 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -210,8 +210,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2019年11月20日
-  var deadline = new Date(2019, 10, 20);
+  // 2020年3月22日
+  var deadline = new Date(2020, 2, 22);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From 7145158b2a1322603d93e99a2dd2d1dc9ab02e79 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 8 Nov 2019 10:53:57 +0800
Subject: [PATCH 021/280] =?UTF-8?q?docs(Symbol):=20edit=20=E5=B1=9E?=
 =?UTF-8?q?=E6=80=A7=E5=90=8D=E7=9A=84=E9=81=8D=E5=8E=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/symbol.md | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index 39b304b99..e8d97cb66 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -280,9 +280,9 @@ const shapeType = {
 
 ## 属性名的遍历
 
-Symbol 作为属性名，该属性不会出现在`for...in`、`for...of`循环中，也不会被`Object.keys()`、`Object.getOwnPropertyNames()`、`JSON.stringify()`返回。但是，它也不是私有属性，有一个`Object.getOwnPropertySymbols`方法，可以获取指定对象的所有 Symbol 属性名。
+Symbol 作为属性名，遍历对象的时候，该属性不会出现在`for...in`、`for...of`循环中，也不会被`Object.keys()`、`Object.getOwnPropertyNames()`、`JSON.stringify()`返回。
 
-`Object.getOwnPropertySymbols`方法返回一个数组，成员是当前对象的所有用作属性名的 Symbol 值。
+但是，它也不是私有属性，有一个`Object.getOwnPropertySymbols()`方法，可以获取指定对象的所有 Symbol 属性名。该方法返回一个数组，成员是当前对象的所有用作属性名的 Symbol 值。
 
 ```javascript
 const obj = {};
@@ -298,31 +298,27 @@ objectSymbols
 // [Symbol(a), Symbol(b)]
 ```
 
-下面是另一个例子，`Object.getOwnPropertySymbols`方法与`for...in`循环、`Object.getOwnPropertyNames`方法进行对比的例子。
+上面代码是`Object.getOwnPropertySymbols()`方法的示例，可以获取所有 Symbol 属性名。
+
+下面是另一个例子，`Object.getOwnPropertySymbols()`方法与`for...in`循环、`Object.getOwnPropertyNames`方法进行对比的例子。
 
 ```javascript
 const obj = {};
+const foo = Symbol('foo');
 
-let foo = Symbol("foo");
-
-Object.defineProperty(obj, foo, {
-  value: "foobar",
-});
+obj[foo] = 'bar';
 
 for (let i in obj) {
   console.log(i); // 无输出
 }
 
-Object.getOwnPropertyNames(obj)
-// []
-
-Object.getOwnPropertySymbols(obj)
-// [Symbol(foo)]
+Object.getOwnPropertyNames(obj) // []
+Object.getOwnPropertySymbols(obj) // [Symbol(foo)]
 ```
 
-上面代码中，使用`Object.getOwnPropertyNames`方法得不到`Symbol`属性名，需要使用`Object.getOwnPropertySymbols`方法。
+上面代码中，使用`for...in`循环和`Object.getOwnPropertyNames()`方法都得不到 Symbol 键名，需要使用`Object.getOwnPropertySymbols()`方法。
 
-另一个新的 API，`Reflect.ownKeys`方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。
+另一个新的 API，`Reflect.ownKeys()`方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。
 
 ```javascript
 let obj = {
@@ -335,7 +331,7 @@ Reflect.ownKeys(obj)
 //  ["enum", "nonEnum", Symbol(my_key)]
 ```
 
-由于以 Symbol 值作为名称的属性，不会被常规方法遍历得到。我们可以利用这个特性，为对象定义一些非私有的、但又希望只用于内部的方法。
+由于以 Symbol 值作为键名，不会被常规方法遍历得到。我们可以利用这个特性，为对象定义一些非私有的、但又希望只用于内部的方法。
 
 ```javascript
 let size = Symbol('size');

From 37c199d560bcb93878843b79053efc6e3e35a927 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 14 Nov 2019 14:30:22 +0800
Subject: [PATCH 022/280] docs(proposal): edit BigInt

---
 docs/proposals.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/docs/proposals.md b/docs/proposals.md
index f10c1caaa..e119a63e9 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -664,6 +664,26 @@ BigInt 可以使用负号（`-`），但是不能使用正号（`+`），因为
 +42n // 报错
 ```
 
+JavaScript 以前不能计算70的阶乘（即`70!`），因为超出了可以表示的精度。
+
+```javascript
+let p = 1;
+for (let i = 1; i <= 70; i++) {
+  p *= i;
+}
+console.log(p); // 1.197857166996989e+100
+```
+
+现在支持大整数了，就可以算了，浏览器的开发者工具运行下面代码，就OK。
+
+```javascript
+let p = 1n;
+for (let i = 1n; i <= 70n; i++) {
+  p *= i;
+}
+console.log(p); // 11978571...00000000n
+```
+
 ### BigInt 对象
 
 JavaScript 原生提供`BigInt`对象，可以用作构造函数生成 BigInt 类型的数值。转换规则基本与`Number()`一致，将其他类型的值转为 BigInt。

From f0aa112f97e16e3c39f27699ff178cec81481ce9 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 20 Nov 2019 17:37:59 +0800
Subject: [PATCH 023/280] docs(module-loader): add jQuery example

---
 docs/module-loader.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 4a3fa0e50..88899b060 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -72,6 +72,15 @@ ES6 模块也允许内嵌在网页中，语法行为与加载外部脚本完全
 </script>
 ```
 
+举例来说，jQuery 就支持模块加载。
+
+```html
+<script type="module">
+  import $ from "./jquery/src/jquery.js";
+  $('#message').text('Hi from jQuery!');
+</script>
+```
+
 对于外部的模块脚本（上例是`foo.js`），有几点需要注意。
 
 - 代码是在模块作用域之中运行，而不是在全局作用域运行。模块内部的顶层变量，外部不可见。

From 6918f7abaa84431e8ad46e17db93804b2e961f2c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 7 Dec 2019 01:01:06 +0800
Subject: [PATCH 024/280] =?UTF-8?q?docs(object):=20Null=20=E5=88=A4?=
 =?UTF-8?q?=E6=96=AD=E8=BF=90=E7=AE=97=E7=AC=A6=E7=A7=BB=E5=85=A5=20Object?=
 =?UTF-8?q?=20=E7=AB=A0=E8=8A=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/object.md    | 76 +++++++++++++++++++++++++++++++++++++++++++++++
 docs/proposals.md | 76 -----------------------------------------------
 2 files changed, 76 insertions(+), 76 deletions(-)

diff --git a/docs/object.md b/docs/object.md
index 4ff75b69d..74748c003 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -698,3 +698,79 @@ let runtimeError = {
 };
 ```
 
+## Null 判断运算符
+
+读取对象属性的时候，如果某个属性的值是`null`或`undefined`，有时候需要为它们指定默认值。常见做法是通过`||`运算符指定默认值。
+
+```javascript
+const headerText = response.settings.headerText || 'Hello, world!';
+const animationDuration = response.settings.animationDuration || 300;
+const showSplashScreen = response.settings.showSplashScreen || true;
+```
+
+上面的三行代码都通过`||`运算符指定默认值，但是这样写是错的。开发者的原意是，只要属性的值为`null`或`undefined`，默认值就会生效，但是属性的值如果为空字符串或`false`或`0`，默认值也会生效。
+
+为了避免这种情况，[ECMAScript2020](https://github.com/tc39/proposal-nullish-coalescing) 引入了一个新的 Null 判断运算符`??`。它的行为类似`||`，但是只有运算符左侧的值为`null`或`undefined`时，才会返回右侧的值。
+
+```javascript
+const headerText = response.settings.headerText ?? 'Hello, world!';
+const animationDuration = response.settings.animationDuration ?? 300;
+const showSplashScreen = response.settings.showSplashScreen ?? true;
+```
+
+上面代码中，默认值只有在属性值为`null`或`undefined`时，才会生效。
+
+这个运算符的一个目的，就是跟链判断运算符`?.`配合使用，为`null`或`undefined`的值设置默认值。
+
+```javascript
+const animationDuration = response.settings?.animationDuration ?? 300;
+```
+
+上面代码中，`response.settings`如果是`null`或`undefined`，就会返回默认值300。
+
+这个运算符很适合判断函数参数是否赋值。
+
+```javascript
+function Component(props) {
+  const enable = props.enabled ?? true;
+  // …
+}
+```
+
+上面代码判断`props`参数的`enabled`属性是否赋值，等同于下面的写法。
+
+```javascript
+function Component(props) {
+  const {
+    enabled: enable = true,
+  } = props;
+  // …
+}
+```
+
+`??`有一个运算优先级问题，它与`&&`和`||`的优先级孰高孰低。现在的规则是，如果多个逻辑运算符一起使用，必须用括号表明优先级，否则会报错。
+
+```javascript
+// 报错
+lhs && middle ?? rhs
+lhs ?? middle && rhs
+lhs || middle ?? rhs
+lhs ?? middle || rhs
+```
+
+上面四个表达式都会报错，必须加入表明优先级的括号。
+
+```javascript
+(lhs && middle) ?? rhs;
+lhs && (middle ?? rhs);
+
+(lhs ?? middle) && rhs;
+lhs ?? (middle && rhs);
+
+(lhs || middle) ?? rhs;
+lhs || (middle ?? rhs);
+
+(lhs ?? middle) || rhs;
+lhs ?? (middle || rhs);
+```
+
diff --git a/docs/proposals.md b/docs/proposals.md
index e119a63e9..a8d40af3b 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -251,82 +251,6 @@ a?.b = c
 
 为了保证兼容以前的代码，允许`foo?.3:0`被解析成`foo ? .3 : 0`，因此规定如果`?.`后面紧跟一个十进制数字，那么`?.`不再被看成是一个完整的运算符，而会按照三元运算符进行处理，也就是说，那个小数点会归属于后面的十进制数字，形成一个小数。
 
-## Null 判断运算符
-
-读取对象属性的时候，如果某个属性的值是`null`或`undefined`，有时候需要为它们指定默认值。常见做法是通过`||`运算符指定默认值。
-
-```javascript
-const headerText = response.settings.headerText || 'Hello, world!';
-const animationDuration = response.settings.animationDuration || 300;
-const showSplashScreen = response.settings.showSplashScreen || true;
-```
-
-上面的三行代码都通过`||`运算符指定默认值，但是这样写是错的。开发者的原意是，只要属性的值为`null`或`undefined`，默认值就会生效，但是属性的值如果为空字符串或`false`或`0`，默认值也会生效。
-
-为了避免这种情况，现在有一个[提案](https://github.com/tc39/proposal-nullish-coalescing)，引入了一个新的 Null 判断运算符`??`。它的行为类似`||`，但是只有运算符左侧的值为`null`或`undefined`时，才会返回右侧的值。
-
-```javascript
-const headerText = response.settings.headerText ?? 'Hello, world!';
-const animationDuration = response.settings.animationDuration ?? 300;
-const showSplashScreen = response.settings.showSplashScreen ?? true;
-```
-
-上面代码中，默认值只有在属性值为`null`或`undefined`时，才会生效。
-
-这个运算符的一个目的，就是跟链判断运算符`?.`配合使用，为`null`或`undefined`的值设置默认值。
-
-```javascript
-const animationDuration = response.settings?.animationDuration ?? 300;
-```
-
-上面代码中，`response.settings`如果是`null`或`undefined`，就会返回默认值300。
-
-这个运算符很适合判断函数参数是否赋值。
-
-```javascript
-function Component(props) {
-  const enable = props.enabled ?? true;
-  // …
-}
-```
-
-上面代码判断`props`参数的`enabled`属性是否赋值，等同于下面的写法。
-
-```javascript
-function Component(props) {
-  const {
-    enabled: enable = true,
-  } = props;
-  // …
-}
-```
-
-`??`有一个运算优先级问题，它与`&&`和`||`的优先级孰高孰低。现在的规则是，如果多个逻辑运算符一起使用，必须用括号表明优先级，否则会报错。
-
-```javascript
-// 报错
-lhs && middle ?? rhs
-lhs ?? middle && rhs
-lhs || middle ?? rhs
-lhs ?? middle || rhs
-```
-
-上面四个表达式都会报错，必须加入表明优先级的括号。
-
-```javascript
-(lhs && middle) ?? rhs;
-lhs && (middle ?? rhs);
-
-(lhs ?? middle) && rhs;
-lhs ?? (middle && rhs);
-
-(lhs || middle) ?? rhs;
-lhs || (middle ?? rhs);
-
-(lhs ?? middle) || rhs;
-lhs ?? (middle || rhs);
-```
-
 ## 函数的部分执行
 
 ### 语法

From f4ce061d564bc34f5b9fc013fbe5e26ef5f62ea9 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 7 Dec 2019 17:42:05 +0800
Subject: [PATCH 025/280] =?UTF-8?q?docs(object):=20=E9=93=BE=E5=88=A4?=
 =?UTF-8?q?=E6=96=AD=E8=BF=90=E7=AE=97=E7=AC=A6=E7=A7=BB=E5=85=A5=20Object?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/object.md    | 133 ++++++++++++++++++++++++++++++++++++++++++++++
 docs/proposals.md | 133 ----------------------------------------------
 2 files changed, 133 insertions(+), 133 deletions(-)

diff --git a/docs/object.md b/docs/object.md
index 74748c003..f3f4c6c96 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -698,6 +698,139 @@ let runtimeError = {
 };
 ```
 
+## 链判断运算符
+
+编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。比如，要读取`message.body.user.firstName`，安全的写法是写成下面这样。
+
+```javascript
+const firstName = (message
+  && message.body
+  && message.body.user
+  && message.body.user.firstName) || 'default';
+```
+
+或者使用三元运算符`?:`，判断一个对象是否存在。
+
+```javascript
+const fooInput = myForm.querySelector('input[name=foo]')
+const fooValue = fooInput ? fooInput.value : undefined
+```
+
+这样的层层判断非常麻烦，因此 [ECMAScript2020](https://github.com/tc39/proposal-optional-chaining) 引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
+
+```javascript
+const firstName = message?.body?.user?.firstName || 'default';
+const fooValue = myForm.querySelector('input[name=foo]')?.value
+```
+
+上面代码使用了`?.`运算符，直接在链式调用的时候判断，左侧的对象是否为`null`或`undefined`。如果是的，就不再往下运算，而是返回`undefined`。
+
+链判断运算符有三种用法。
+
+- `obj?.prop` // 对象属性
+- `obj?.[expr]` // 同上
+- `func?.(...args)` // 函数或对象方法的调用
+
+下面是判断对象方法是否存在，如果存在就立即执行的例子。
+
+```javascript
+iterator.return?.()
+```
+
+上面代码中，`iterator.return`如果有定义，就会调用该方法，否则直接返回`undefined`。
+
+对于那些可能没有实现的方法，这个运算符尤其有用。
+
+```javascript
+if (myForm.checkValidity?.() === false) {
+  // 表单校验失败
+  return;
+}
+```
+
+上面代码中，老式浏览器的表单可能没有`checkValidity`这个方法，这时`?.`运算符就会返回`undefined`，判断语句就变成了`undefined === false`，所以就会跳过下面的代码。
+
+下面是这个运算符常见的使用形式，以及不使用该运算符时的等价形式。
+
+```javascript
+a?.b
+// 等同于
+a == null ? undefined : a.b
+
+a?.[x]
+// 等同于
+a == null ? undefined : a[x]
+
+a?.b()
+// 等同于
+a == null ? undefined : a.b()
+
+a?.()
+// 等同于
+a == null ? undefined : a()
+```
+
+上面代码中，特别注意后两种形式，如果`a?.b()`里面的`a.b`不是函数，不可调用，那么`a?.b()`是会报错的。`a?.()`也是如此，如果`a`不是`null`或`undefined`，但也不是函数，那么`a?.()`会报错。
+
+使用这个运算符，有几个注意点。
+
+（1）短路机制
+
+```javascript
+a?.[++x]
+// 等同于
+a == null ? undefined : a[++x]
+```
+
+上面代码中，如果`a`是`undefined`或`null`，那么`x`不会进行递增运算。也就是说，链判断运算符一旦为真，右侧的表达式就不再求值。
+
+（2）delete 运算符
+
+```javascript
+delete a?.b
+// 等同于
+a == null ? undefined : delete a.b
+```
+
+上面代码中，如果`a`是`undefined`或`null`，会直接返回`undefined`，而不会进行`delete`运算。
+
+（3）括号不改变运算顺序
+
+```javascript
+(a?.b).c
+// 等价于
+(a == null ? undefined : a.b).c
+```
+
+上面代码中，`?.`对圆括号没有影响，不管`a`对象是否存在，圆括号后面的`.c`总是会执行。
+
+一般来说，使用`?.`运算符的场合，不应该使用圆括号。
+
+（4）报错场合
+
+以下写法是禁止的，会报错。
+
+```javascript
+// 构造函数
+new a?.()
+new a?.b()
+
+// 链判断运算符的右侧有模板字符串
+a?.`{b}`
+a?.b`{c}`
+
+// 链判断运算符的左侧是 super
+super?.()
+super?.foo
+
+// 链运算符用于赋值运算符左侧
+a?.b = c
+```
+
+（5）右侧不得为十进制数值
+
+为了保证兼容以前的代码，允许`foo?.3:0`被解析成`foo ? .3 : 0`，因此规定如果`?.`后面紧跟一个十进制数字，那么`?.`不再被看成是一个完整的运算符，而会按照三元运算符进行处理，也就是说，那个小数点会归属于后面的十进制数字，形成一个小数。
+
 ## Null 判断运算符
 
 读取对象属性的时候，如果某个属性的值是`null`或`undefined`，有时候需要为它们指定默认值。常见做法是通过`||`运算符指定默认值。
diff --git a/docs/proposals.md b/docs/proposals.md
index a8d40af3b..50097f39e 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -118,139 +118,6 @@ class Product {
 
 语法上，`throw`表达式里面的`throw`不再是一个命令，而是一个运算符。为了避免与`throw`命令混淆，规定`throw`出现在行首，一律解释为`throw`语句，而不是`throw`表达式。
 
-## 链判断运算符
-
-编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。比如，要读取`message.body.user.firstName`，安全的写法是写成下面这样。
-
-```javascript
-const firstName = (message
-  && message.body
-  && message.body.user
-  && message.body.user.firstName) || 'default';
-```
-
-或者使用三元运算符`?:`，判断一个对象是否存在。
-
-```javascript
-const fooInput = myForm.querySelector('input[name=foo]')
-const fooValue = fooInput ? fooInput.value : undefined
-```
-
-这样的层层判断非常麻烦，因此现在有一个[提案](https://github.com/tc39/proposal-optional-chaining)，引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
-
-```javascript
-const firstName = message?.body?.user?.firstName || 'default';
-const fooValue = myForm.querySelector('input[name=foo]')?.value
-```
-
-上面代码使用了`?.`运算符，直接在链式调用的时候判断，左侧的对象是否为`null`或`undefined`。如果是的，就不再往下运算，而是返回`undefined`。
-
-链判断运算符有三种用法。
-
-- `obj?.prop` // 对象属性
-- `obj?.[expr]` // 同上
-- `func?.(...args)` // 函数或对象方法的调用
-
-下面是判断对象方法是否存在，如果存在就立即执行的例子。
-
-```javascript
-iterator.return?.()
-```
-
-上面代码中，`iterator.return`如果有定义，就会调用该方法，否则直接返回`undefined`。
-
-对于那些可能没有实现的方法，这个运算符尤其有用。
-
-```javascript
-if (myForm.checkValidity?.() === false) {
-  // 表单校验失败
-  return;
-}
-```
-
-上面代码中，老式浏览器的表单可能没有`checkValidity`这个方法，这时`?.`运算符就会返回`undefined`，判断语句就变成了`undefined === false`，所以就会跳过下面的代码。
-
-下面是这个运算符常见的使用形式，以及不使用该运算符时的等价形式。
-
-```javascript
-a?.b
-// 等同于
-a == null ? undefined : a.b
-
-a?.[x]
-// 等同于
-a == null ? undefined : a[x]
-
-a?.b()
-// 等同于
-a == null ? undefined : a.b()
-
-a?.()
-// 等同于
-a == null ? undefined : a()
-```
-
-上面代码中，特别注意后两种形式，如果`a?.b()`里面的`a.b`不是函数，不可调用，那么`a?.b()`是会报错的。`a?.()`也是如此，如果`a`不是`null`或`undefined`，但也不是函数，那么`a?.()`会报错。
-
-使用这个运算符，有几个注意点。
-
-（1）短路机制
-
-```javascript
-a?.[++x]
-// 等同于
-a == null ? undefined : a[++x]
-```
-
-上面代码中，如果`a`是`undefined`或`null`，那么`x`不会进行递增运算。也就是说，链判断运算符一旦为真，右侧的表达式就不再求值。
-
-（2）delete 运算符
-
-```javascript
-delete a?.b
-// 等同于
-a == null ? undefined : delete a.b
-```
-
-上面代码中，如果`a`是`undefined`或`null`，会直接返回`undefined`，而不会进行`delete`运算。
-
-（3）括号不改变运算顺序
-
-```javascript
-(a?.b).c
-// 等价于
-(a == null ? undefined : a.b).c
-```
-
-上面代码中，`?.`对圆括号没有影响，不管`a`对象是否存在，圆括号后面的`.c`总是会执行。
-
-一般来说，使用`?.`运算符的场合，不应该使用圆括号。
-
-（4）报错场合
-
-以下写法是禁止的，会报错。
-
-```javascript
-// 构造函数
-new a?.()
-new a?.b()
-
-// 链判断运算符的右侧有模板字符串
-a?.`{b}`
-a?.b`{c}`
-
-// 链判断运算符的左侧是 super
-super?.()
-super?.foo
-
-// 链运算符用于赋值运算符左侧
-a?.b = c
-```
-
-（5）右侧不得为十进制数值
-
-为了保证兼容以前的代码，允许`foo?.3:0`被解析成`foo ? .3 : 0`，因此规定如果`?.`后面紧跟一个十进制数字，那么`?.`不再被看成是一个完整的运算符，而会按照三元运算符进行处理，也就是说，那个小数点会归属于后面的十进制数字，形成一个小数。
-
 ## 函数的部分执行
 
 ### 语法

From 726e37ecde8e892ffe87bb665fc7c6a00085a9b1 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 7 Dec 2019 18:16:49 +0800
Subject: [PATCH 026/280] docs(object): edit object

---
 docs/object.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/object.md b/docs/object.md
index f3f4c6c96..38323ad28 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -716,7 +716,7 @@ const fooInput = myForm.querySelector('input[name=foo]')
 const fooValue = fooInput ? fooInput.value : undefined
 ```
 
-这样的层层判断非常麻烦，因此 [ECMAScript2020](https://github.com/tc39/proposal-optional-chaining) 引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
+这样的层层判断非常麻烦，因此 [ES2020](https://github.com/tc39/proposal-optional-chaining) 引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
 
 ```javascript
 const firstName = message?.body?.user?.firstName || 'default';
@@ -843,7 +843,7 @@ const showSplashScreen = response.settings.showSplashScreen || true;
 
 上面的三行代码都通过`||`运算符指定默认值，但是这样写是错的。开发者的原意是，只要属性的值为`null`或`undefined`，默认值就会生效，但是属性的值如果为空字符串或`false`或`0`，默认值也会生效。
 
-为了避免这种情况，[ECMAScript2020](https://github.com/tc39/proposal-nullish-coalescing) 引入了一个新的 Null 判断运算符`??`。它的行为类似`||`，但是只有运算符左侧的值为`null`或`undefined`时，才会返回右侧的值。
+为了避免这种情况，[ES2020](https://github.com/tc39/proposal-nullish-coalescing) 引入了一个新的 Null 判断运算符`??`。它的行为类似`||`，但是只有运算符左侧的值为`null`或`undefined`时，才会返回右侧的值。
 
 ```javascript
 const headerText = response.settings.headerText ?? 'Hello, world!';

From add1bb8f822bed70912f64aeda2f3c0345e421ad Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 7 Dec 2019 18:50:42 +0800
Subject: [PATCH 027/280] docs(array): edit sort()

---
 docs/array.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/array.md b/docs/array.md
index d1f123f46..59450e175 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -983,7 +983,7 @@ arr.sort(unstableSorting)
 
 上面代码中，排序结果是`spork`在`straw`前面，跟原始顺序相反，所以排序算法`unstableSorting`是不稳定的。
 
-常见的排序算法之中，插入排序、合并排序、冒泡排序等都是稳定的，堆排序、快速排序等是不稳定的。不稳定排序的主要缺点是，多重排序时可能会产生问题。假设有一个姓和名的列表，按照“先姓，后名”进行排序。开发者可能会先按名字排序，再按姓氏进行排序。如果排序算法是稳定的，这样也可以达到“先姓，后名”的排序效果。如果是不稳定的，就不行。
+常见的排序算法之中，插入排序、合并排序、冒泡排序等都是稳定的，堆排序、快速排序等是不稳定的。不稳定排序的主要缺点是，多重排序时可能会产生问题。假设有一个姓和名的列表，要求按照“姓氏为主要关键字，名字为次要关键字”进行排序。开发者可能会先按名字排序，再按姓氏进行排序。如果排序算法是稳定的，这样就可以达到“先姓氏，后名字”的排序效果。如果是不稳定的，就不行。
 
 早先的 ECMAScript 没有规定，`Array.prototype.sort()`的默认排序算法是否稳定，留给浏览器自己决定，这导致某些实现是不稳定的。[ES2019](https://github.com/tc39/ecma262/pull/1340) 明确规定，`Array.prototype.sort()`的默认排序算法必须稳定。这个规定已经做到了，现在 JavaScript 各个主要实现的默认排序算法都是稳定的。
 

From c4f4570f676a24a56255df237805b11516abd69e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 7 Dec 2019 22:08:20 +0800
Subject: [PATCH 028/280] docs(object): fix #931

---
 docs/object.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/object.md b/docs/object.md
index 38323ad28..4f57408ba 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -794,7 +794,9 @@ a == null ? undefined : delete a.b
 
 上面代码中，如果`a`是`undefined`或`null`，会直接返回`undefined`，而不会进行`delete`运算。
 
-（3）括号不改变运算顺序
+（3）括号的影响
+
+如果属性链有圆括号，链判断运算符对圆括号外部没有影响，只对圆括号内部有影响。
 
 ```javascript
 (a?.b).c
@@ -802,7 +804,7 @@ a == null ? undefined : delete a.b
 (a == null ? undefined : a.b).c
 ```
 
-上面代码中，`?.`对圆括号没有影响，不管`a`对象是否存在，圆括号后面的`.c`总是会执行。
+上面代码中，`?.`对圆括号外部没有影响，不管`a`对象是否存在，圆括号后面的`.c`总是会执行。
 
 一般来说，使用`?.`运算符的场合，不应该使用圆括号。
 

From ad12c153b33e133fd4a21f03dacd2ac9424cb398 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=BE=B7=E5=B8=A5?=
 <doKill@users.noreply.github.com>
Date: Mon, 16 Dec 2019 15:48:15 +0800
Subject: [PATCH 029/280] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E5=8F=82=E6=95=B0?=
 =?UTF-8?q?=E5=90=8D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

property 改为 property key 防止产生歧义
---
 docs/proxy.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 0ec65c95f..09dad1d0b 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -8,13 +8,13 @@ Proxy 可以理解成，在目标对象之前架设一层“拦截”，外界
 
 ```javascript
 var obj = new Proxy({}, {
-  get: function (target, key, receiver) {
-    console.log(`getting ${key}!`);
-    return Reflect.get(target, key, receiver);
+  get: function (target, propKey, receiver) {
+    console.log(`getting ${propKey}!`);
+    return Reflect.get(target, propKey, receiver);
   },
-  set: function (target, key, value, receiver) {
-    console.log(`setting ${key}!`);
-    return Reflect.set(target, key, value, receiver);
+  set: function (target, propKey, value, receiver) {
+    console.log(`setting ${propKey}!`);
+    return Reflect.set(target, propKey, value, receiver);
   }
 });
 ```
@@ -44,7 +44,7 @@ Proxy 对象的所有用法，都是上面这种形式，不同的只是`handler
 
 ```javascript
 var proxy = new Proxy({}, {
-  get: function(target, property) {
+  get: function(target, propKey) {
     return 35;
   }
 });
@@ -80,7 +80,7 @@ Proxy 实例也可以作为其他对象的原型对象。
 
 ```javascript
 var proxy = new Proxy({}, {
-  get: function(target, property) {
+  get: function(target, propKey) {
     return 35;
   }
 });
@@ -155,11 +155,11 @@ var person = {
 };
 
 var proxy = new Proxy(person, {
-  get: function(target, property) {
-    if (property in target) {
-      return target[property];
+  get: function(target, propKey) {
+    if (propKey in target) {
+      return target[propKey];
     } else {
-      throw new ReferenceError("Property \"" + property + "\" does not exist.");
+      throw new ReferenceError("Prop name \"" + propKey + "\" does not exist.");
     }
   }
 });
@@ -281,7 +281,7 @@ document.body.appendChild(el);
 
 ```javascript
 const proxy = new Proxy({}, {
-  get: function(target, property, receiver) {
+  get: function(target, key, receiver) {
     return receiver;
   }
 });
@@ -292,7 +292,7 @@ proxy.getReceiver === proxy // true
 
 ```javascript
 const proxy = new Proxy({}, {
-  get: function(target, property, receiver) {
+  get: function(target, key, receiver) {
     return receiver;
   }
 });

From a49a10ca485ed2065b9f297df31ca135ac0fb1b9 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 16 Dec 2019 16:11:16 +0800
Subject: [PATCH 030/280] docs(module-loader): update Node.js' esm support

---
 docs/module-loader.md | 354 ++++++++++++++++++++++++++----------------
 1 file changed, 219 insertions(+), 135 deletions(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 88899b060..c4fa9dd5c 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -1,6 +1,6 @@
 # Module 的加载实现
 
-上一章介绍了模块的语法，本章介绍如何在浏览器和 Node 之中加载 ES6 模块，以及实际开发中经常遇到的一些问题（比如循环加载）。
+上一章介绍了模块的语法，本章介绍如何在浏览器和 Node.js 之中加载 ES6 模块，以及实际开发中经常遇到的一些问题（比如循环加载）。
 
 ## 浏览器加载
 
@@ -108,7 +108,7 @@ const isNotModuleScript = this !== undefined;
 
 ## ES6 模块与 CommonJS 模块的差异
 
-讨论 Node 加载 ES6 模块之前，必须了解 ES6 模块与 CommonJS 模块完全不同。
+讨论 Node.js 加载 ES6 模块之前，必须了解 ES6 模块与 CommonJS 模块完全不同。
 
 它们有两个重大差异。
 
@@ -271,226 +271,310 @@ $ babel-node main.js
 
 这就证明了`x.js`和`y.js`加载的都是`C`的同一个实例。
 
-## Node 加载
+## Node.js 加载
 
 ### 概述
 
-Node 对 ES6 模块的处理比较麻烦，因为它有自己的 CommonJS 模块格式，与 ES6 模块格式是不兼容的。目前的解决方案是，将两者分开，ES6 模块和 CommonJS 采用各自的加载方案。
+Node.js 对 ES6 模块的处理比较麻烦，因为它有自己的 CommonJS 模块格式，与 ES6 模块格式是不兼容的。目前的解决方案是，将两者分开，ES6 模块和 CommonJS 采用各自的加载方案。从 v13.2 版本开始，Node.js 已经默认打开了 ES6 模块支持。
 
-Node 要求 ES6 模块采用`.mjs`后缀文件名。也就是说，只要脚本文件里面使用`import`或者`export`命令，那么就必须采用`.mjs`后缀名。`require`命令不能加载`.mjs`文件，会报错，只有`import`命令才可以加载`.mjs`文件。反过来，`.mjs`文件里面也不能使用`require`命令，必须使用`import`。
+Node.js 要求 ES6 模块采用`.mjs`后缀文件名。也就是说，只要脚本文件里面使用`import`或者`export`命令，那么就必须采用`.mjs`后缀名。Node.js 遇到`.mjs`文件，就认为它是 ES6 模块，默认启用严格模式，不必在每个模块文件顶部指定`"use strict"`。
 
-目前，这项功能还在试验阶段。安装 Node v8.5.0 或以上版本，要用`--experimental-modules`参数才能打开该功能。
+如果不希望将后缀名改成`.mjs`，可以在项目的`package.json`文件中，指定`type`字段为`module`。
 
-```bash
-$ node --experimental-modules my-app.mjs
+```javascript
+{
+   "type": "module"
+}
 ```
 
-为了与浏览器的`import`加载规则相同，Node 的`.mjs`文件支持 URL 路径。
+一旦设置了以后，该目录里面的 JS 脚本，就被解释用 ES6 模块。
 
-```javascript
-import './foo?query=1'; // 加载 ./foo 传入参数 ?query=1
+```bash
+# 解释成 ES6 模块
+$ node my-app.js
 ```
 
-上面代码中，脚本路径带有参数`?query=1`，Node 会按 URL 规则解读。同一个脚本只要参数不同，就会被加载多次，并且保存成不同的缓存。由于这个原因，只要文件名中含有`:`、`%`、`#`、`?`等特殊字符，最好对这些字符进行转义。
+如果这时还要使用 CommonJS 模块，那么需要将 CommonJS 脚本的后缀名都改成`.cjs`。如果没有`type`字段，或者`type`字段为`commonjs`，则`.js`脚本会被解释成 CommonJS 模块。
+
+总结为一句话：`.mjs`文件总是以 ES6 模块加载，`.cjs`文件总是以 CommonJS 模块加载，`.js`文件的加载取决于`package.json`里面`type`字段的设置。
 
-目前，Node 的`import`命令只支持加载本地模块（`file:`协议），不支持加载远程模块。
+注意，ES6 模块与 CommonJS 模块尽量不要混用。`require`命令不能加载`.mjs`文件，会报错，只有`import`命令才可以加载`.mjs`文件。反过来，`.mjs`文件里面也不能使用`require`命令，必须使用`import`。
 
-如果模块名不含路径，那么`import`命令会去`node_modules`目录寻找这个模块。
+### main 字段
+
+`package.json`文件有两个字段可以指定模块的入口文件：`main`和`exports`。比较简单的模块，可以只使用`main`字段，指定模块加载的入口文件。
 
 ```javascript
-import 'baz';
-import 'abc/123';
+// ./node_modules/es-module-package/package.json
+{
+  "type": "module",
+  "main": "./src/index.js"
+}
 ```
 
-如果模块名包含路径，那么`import`命令会按照路径去寻找这个名字的脚本文件。
+上面代码指定项目的入口脚本为`./src/index.js`，它的格式为 ES6 模块。如果没有`type`字段，`index.js`就会被解释为 CommonJS 模块。
+
+然后，`import`命令就可以加载这个模块。
 
 ```javascript
-import 'file:///etc/config/app.json';
-import './foo';
-import './foo?search';
-import '../bar';
-import '/baz';
+// ./my-app.mjs
+
+import { something } from 'es-module-package';
+// 实际加载的是 ./node_modules/es-module-package/src/index.js
 ```
 
-如果脚本文件省略了后缀名，比如`import './foo'`，Node 会依次尝试四个后缀名：`./foo.mjs`、`./foo.js`、`./foo.json`、`./foo.node`。如果这些脚本文件都不存在，Node 就会去加载`./foo/package.json`的`main`字段指定的脚本。如果`./foo/package.json`不存在或者没有`main`字段，那么就会依次加载`./foo/index.mjs`、`./foo/index.js`、`./foo/index.json`、`./foo/index.node`。如果以上四个文件还是都不存在，就会抛出错误。
+上面代码中，运行该脚本以后，Node.js 就会到`./node_modules`目录下面，寻找`es-module-package`模块，然后根据该模块`package.json`的`main`字段去执行入口文件。
 
-最后，Node 的`import`命令是异步加载，这一点与浏览器的处理方法相同。
+这时，如果用 CommonJS 模块的`require()`命令去加载`es-module-package`模块会报错，因为 CommonJS 模块不能处理`export`命令。
 
-### 内部变量
+### exports 字段
 
-ES6 模块应该是通用的，同一个模块不用修改，就可以用在浏览器环境和服务器环境。为了达到这个目标，Node 规定 ES6 模块之中不能使用 CommonJS 模块的特有的一些内部变量。
+`exports`字段的优先级高于`main`字段。它有多种用法。
 
-首先，就是`this`关键字。ES6 模块之中，顶层的`this`指向`undefined`；CommonJS 模块的顶层`this`指向当前模块，这是两者的一个重大差异。
+（1）子目录别名
 
-其次，以下这些顶层变量在 ES6 模块之中都是不存在的。
+`package.json`文件的`exports`字段可以指定脚本或子目录的别名。
 
-- `arguments`
-- `require`
-- `module`
-- `exports`
-- `__filename`
-- `__dirname`
+```javascript
+// ./node_modules/es-module-package/package.json
+{
+  "exports": {
+    "./submodule": "./src/submodule.js"
+  }
+}
+```
 
-如果你一定要使用这些变量，有一个变通方法，就是写一个 CommonJS 模块输出这些变量，然后再用 ES6 模块加载这个 CommonJS 模块。但是这样一来，该 ES6 模块就不能直接用于浏览器环境了，所以不推荐这样做。
+上面的代码指定`src/submodule.js`别名为`submodule`，然后就可以从别名加载这个文件。
 
 ```javascript
-// expose.js
-module.exports = {__dirname};
-
-// use.mjs
-import expose from './expose.js';
-const {__dirname} = expose;
+import submodule from 'es-module-package/submodule';
+// 加载 ./node_modules/es-module-package/src/submodule.js
 ```
 
-上面代码中，`expose.js`是一个 CommonJS 模块，输出变量`__dirname`，该变量在 ES6 模块之中不存在。ES6 模块加载`expose.js`，就可以得到`__dirname`。
+下面是子目录别名的例子。
 
-### ES6 模块加载 CommonJS 模块
+```javascript
+// ./node_modules/es-module-package/package.json
+{
+  "exports": {
+    "./features/": "./src/features/"
+  }
+}
 
-CommonJS 模块的输出都定义在`module.exports`这个属性上面。Node 的`import`命令加载 CommonJS 模块，Node 会自动将`module.exports`属性，当作模块的默认输出，即等同于`export default xxx`。
+import feature from 'es-module-package/features/x.js';
+// 加载 ./node_modules/es-module-package/src/features/x.js
+```
 
-下面是一个 CommonJS 模块。
+如果没有指定别名，就不能用“模块+脚本名”这种形式加载脚本。
 
 ```javascript
-// a.js
-module.exports = {
-  foo: 'hello',
-  bar: 'world'
-};
+// 报错
+import submodule from 'es-module-package/private-module.js';
 
-// 等同于
-export default {
-  foo: 'hello',
-  bar: 'world'
-};
+// 不报错
+import submodule from './node_modules/es-module-package/private-module.js';
 ```
 
-`import`命令加载上面的模块，`module.exports`会被视为默认输出，即`import`命令实际上输入的是这样一个对象`{ default: module.exports }`。
+（2）main 的别名
 
-所以，一共有三种写法，可以拿到 CommonJS 模块的`module.exports`。
+`exports`字段的别名如果是`.`，就代表模块的主入口，优先级高于`main`字段，并且可以直接简写成`exports`字段的值。
 
 ```javascript
-// 写法一
-import baz from './a';
-// baz = {foo: 'hello', bar: 'world'};
+{
+  "exports": {
+    ".": "./main.js"
+  }
+}
 
-// 写法二
-import {default as baz} from './a';
-// baz = {foo: 'hello', bar: 'world'};
+// 等同于
+{
+  "exports": "./main.js"
+}
+```
+
+由于`exports`字段只有支持 ES6 的 Node.js 才认识，所以可以用来兼容旧版本的 Node.js。
 
-// 写法三
-import * as baz from './a';
-// baz = {
-//   get default() {return module.exports;},
-//   get foo() {return this.default.foo}.bind(baz),
-//   get bar() {return this.default.bar}.bind(baz)
-// }
+```javascript
+{
+  "main": "./main-legacy.cjs",
+  "exports": {
+    ".": "./main-modern.cjs"
+  }
+}
 ```
 
-上面代码的第三种写法，可以通过`baz.default`拿到`module.exports`。`foo`属性和`bar`属性就是可以通过这种方法拿到了`module.exports`。
+上面代码中，老版本的 Node.js （不支持 ES6 模块）的入口文件是`main-legacy.cjs`，新版本的 Node.js 的入口文件是`main-modern.cjs`。
+
+**（3）条件加载**
 
-下面是一些例子。
+利用`.`这个别名，可以为 ES6 模块和 CommonJS 指定不同的入口。目前，这个功能需要在 Node.js 运行的时候，打开`--experimental-conditional-exports`标志。
 
 ```javascript
-// b.js
-module.exports = null;
+{
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": "./main.cjs",
+      "default": "./main.js"
+    }
+  }
+}
+```
 
-// es.js
-import foo from './b';
-// foo = null;
+上面代码中，别名`.`的`require`条件指定`require()`命令的入口文件（即 CommonJS 的入口），`default`条件指定其他情况的入口（即 ES6 的入口）。
 
-import * as bar from './b';
-// bar = { default:null };
+上面的写法可以简写如下。
+
+```javascript
+{
+  "exports": {
+    "require": "./main.cjs",
+    "default": "./main.js"
+  }
+}
 ```
 
-上面代码中，`es.js`采用第二种写法时，要通过`bar.default`这样的写法，才能拿到`module.exports`。
+注意，如果同时还有其他别名，就不能采用简写，否则或报错。
 
 ```javascript
-// c.js
-module.exports = function two() {
-  return 2;
-};
+{
+  // 报错
+  "exports": {
+    "./feature": "./lib/feature.js",
+    "require": "./main.cjs",
+    "default": "./main.js"
+  }
+}
+```
 
-// es.js
-import foo from './c';
-foo(); // 2
+### ES6 模块加载 CommonJS 模块
 
-import * as bar from './c';
-bar.default(); // 2
-bar(); // throws, bar is not a function
-```
+目前，一个模块同时支持 ES6 和 CommonJS 两种格式的常见方法是，`package.json`文件的`main`字段指定 CommonJS 入口，给 Node.js 使用；`module`字段指定 ES6 模块入口，给打包工具使用，因为 Node.js 不认识`module`字段。
 
-上面代码中，`bar`本身是一个对象，不能当作函数调用，只能通过`bar.default`调用。
+有了上一节的条件加载以后，Node.js 本身就可以同时处理两种模块。
 
-CommonJS 模块的输出缓存机制，在 ES6 加载方式下依然有效。
+```javascript
+// ./node_modules/pkg/package.json
+{
+  "type": "module",
+  "main": "./index.cjs",
+  "exports": {
+    "require": "./index.cjs",
+    "default": "./wrapper.mjs"
+  }
+}
+```
+
+上面代码指定了 CommonJS 入口文件`index.cjs`，下面是这个文件的代码。
 
 ```javascript
-// foo.js
-module.exports = 123;
-setTimeout(_ => module.exports = null);
+// ./node_modules/pkg/index.cjs
+exports.name = 'value';
 ```
 
-上面代码中，对于加载`foo.js`的脚本，`module.exports`将一直是`123`，而不会变成`null`。
+然后，ES6 模块可以加载这个文件。
 
-由于 ES6 模块是编译时确定输出接口，CommonJS 模块是运行时确定输出接口，所以采用`import`命令加载 CommonJS 模块时，不允许采用下面的写法。
+```javascript
+// ./node_modules/pkg/wrapper.mjs
+import cjsModule from './index.cjs';
+export const name = cjsModule.name;
+```
+
+注意，`import`命令加载 CommonJS 模块，只能整体加载，不能只加载单一的输出项。
 
 ```javascript
-// 不正确
-import { readFile } from 'fs';
+// 正确
+import packageMain from 'commonjs-package';
+
+// 报错
+import { method } from 'commonjs-package';
 ```
 
-上面的写法不正确，因为`fs`是 CommonJS 格式，只有在运行时才能确定`readFile`接口，而`import`命令要求编译时就确定这个接口。解决方法就是改为整体输入。
+还有一种变通的加载方法，就是使用 Node.js 内置的`module.createRequire()`方法。
 
 ```javascript
-// 正确的写法一
-import * as express from 'express';
-const app = express.default();
+// cjs.cjs
+module.exports = 'cjs';
+
+// esm.mjs
+import { createRequire } from 'module';
 
-// 正确的写法二
-import express from 'express';
-const app = express();
+const require = createRequire(import.meta.url);
+
+const cjs = require('./cjs.cjs');
+cjs === 'cjs'; // true
 ```
 
+上面代码中，ES6 模块通过`module.createRequire()`方法可以加载 CommonJS 模块
+
 ### CommonJS 模块加载 ES6 模块
 
-CommonJS 模块加载 ES6 模块，不能使用`require`命令，而要使用`import()`函数。ES6 模块的所有输出接口，会成为输入对象的属性。
+CommonJS 的`require`命令不能加载 ES6 模块，会报错，只能使用`import()`这个方法加载。
+
+```javascript
+(async () => {
+  await import('./my-app.mjs');
+})();
+```
+
+上面代码可以在 CommonJS 模块中运行。
+
+### Node.js 的内置模块
+
+Node.js 的内置模块可以整体加载，也可以加载指定的输出项。
 
 ```javascript
-// es.mjs
-let foo = { bar: 'my-default' };
-export default foo;
+// 整体加载
+import EventEmitter from 'events';
+const e = new EventEmitter();
 
-// cjs.js
-const es_namespace = await import('./es.mjs');
-// es_namespace = {
-//   get default() {
-//     ...
-//   }
-// }
-console.log(es_namespace.default);
-// { bar:'my-default' }
+// 加载指定的输出项
+import { readFile } from 'fs';
+readFile('./foo.txt', (err, source) => {
+  if (err) {
+    console.error(err);
+  } else {
+    console.log(source);
+  }
+});
 ```
 
-上面代码中，`default`接口变成了`es_namespace.default`属性。
+### 加载路径
 
-下面是另一个例子。
+ES6 模块的加载路径必须给出脚本的完整路径，不能省略脚本的后缀名。`import`命令和`package.json`文件的`main`字段如果省略脚本的后缀名，会报错。
 
 ```javascript
-// es.js
-export let foo = { bar:'my-default' };
-export { foo as bar };
-export function f() {};
-export class c {};
+// ES6 模块中将报错
+import { something } from './index';
+```
+
+为了与浏览器的`import`加载规则相同，Node.js 的`.mjs`文件支持 URL 路径。
 
-// cjs.js
-const es_namespace = await import('./es');
-// es_namespace = {
-//   get foo() {return foo;}
-//   get bar() {return foo;}
-//   get f() {return f;}
-//   get c() {return c;}
-// }
+```javascript
+import './foo.mjs?query=1'; // 加载 ./foo 传入参数 ?query=1
 ```
 
+上面代码中，脚本路径带有参数`?query=1`，Node 会按 URL 规则解读。同一个脚本只要参数不同，就会被加载多次，并且保存成不同的缓存。由于这个原因，只要文件名中含有`:`、`%`、`#`、`?`等特殊字符，最好对这些字符进行转义。
+
+目前，Node.js 的`import`命令只支持加载本地模块（`file:`协议）和`data:`协议，不支持加载远程模块。另外，脚本路径只支持相对路径，不支持绝对路径（即以`/`或`//`开头的路径）。
+
+最后，Node 的`import`命令是异步加载，这一点与浏览器的处理方法相同。
+
+### 内部变量
+
+ES6 模块应该是通用的，同一个模块不用修改，就可以用在浏览器环境和服务器环境。为了达到这个目标，Node 规定 ES6 模块之中不能使用 CommonJS 模块的特有的一些内部变量。
+
+首先，就是`this`关键字。ES6 模块之中，顶层的`this`指向`undefined`；CommonJS 模块的顶层`this`指向当前模块，这是两者的一个重大差异。
+
+其次，以下这些顶层变量在 ES6 模块之中都是不存在的。
+
+- `arguments`
+- `require`
+- `module`
+- `exports`
+- `__filename`
+- `__dirname`
+
 ## 循环加载
 
 “循环加载”（circular dependency）指的是，`a`脚本的执行依赖`b`脚本，而`b`脚本的执行又依赖`a`脚本。

From ce7bfc95af9fdebcf335a1b150581b9835627afd Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 16 Dec 2019 16:21:17 +0800
Subject: [PATCH 031/280] docs(module-loader): edit

---
 docs/module-loader.md | 71 -------------------------------------------
 1 file changed, 71 deletions(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index c4fa9dd5c..0bbfe3e74 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -831,74 +831,3 @@ $ node
 TypeError: even is not a function
 ```
 
-## ES6 模块的转码
-
-浏览器目前还不支持 ES6 模块，为了现在就能使用，可以将其转为 ES5 的写法。除了 Babel 可以用来转码之外，还有以下两个方法，也可以用来转码。
-
-### ES6 module transpiler
-
-[ES6 module transpiler](https://github.com/esnext/es6-module-transpiler)是 square 公司开源的一个转码器，可以将 ES6 模块转为 CommonJS 模块或 AMD 模块的写法，从而在浏览器中使用。
-
-首先，安装这个转码器。
-
-```bash
-$ npm install -g es6-module-transpiler
-```
-
-然后，使用`compile-modules convert`命令，将 ES6 模块文件转码。
-
-```bash
-$ compile-modules convert file1.js file2.js
-```
-
-`-o`参数可以指定转码后的文件名。
-
-```bash
-$ compile-modules convert -o out.js file1.js
-```
-
-### SystemJS
-
-另一种解决方法是使用 [SystemJS](https://github.com/systemjs/systemjs)。它是一个垫片库（polyfill），可以在浏览器内加载 ES6 模块、AMD 模块和 CommonJS 模块，将其转为 ES5 格式。它在后台调用的是 Google 的 Traceur 转码器。
-
-使用时，先在网页内载入`system.js`文件。
-
-```html
-<script src="system.js"></script>
-```
-
-然后，使用`System.import`方法加载模块文件。
-
-```html
-<script>
-  System.import('./app.js');
-</script>
-```
-
-上面代码中的`./app`，指的是当前目录下的 app.js 文件。它可以是 ES6 模块文件，`System.import`会自动将其转码。
-
-需要注意的是，`System.import`使用异步加载，返回一个 Promise 对象，可以针对这个对象编程。下面是一个模块文件。
-
-```javascript
-// app/es6-file.js:
-
-export class q {
-  constructor() {
-    this.es6 = 'hello';
-  }
-}
-```
-
-然后，在网页内加载这个模块文件。
-
-```html
-<script>
-
-System.import('app/es6-file').then(function(m) {
-  console.log(new m.q().es6); // hello
-});
-
-</script>
-```
-
-上面代码中，`System.import`方法返回的是一个 Promise 对象，所以可以用`then`方法指定回调函数。

From 5a465dda710bb1d16d97fe0783b6fcf0e7439d46 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 18 Dec 2019 17:08:06 +0800
Subject: [PATCH 032/280] docs(array): fix #934

---
 docs/array.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/array.md b/docs/array.md
index 59450e175..3dc145483 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -204,7 +204,7 @@ a3[0] === a1[0] // true
 a4[0] === a1[0] // true
 ```
 
-上面代码中，`a3`和`a4`是用两种不同方法合并而成的新数组，但是它们的成员都是对原数组成员的引用，这就是浅拷贝。如果修改了原数组的成员，会同步反映到新数组。
+上面代码中，`a3`和`a4`是用两种不同方法合并而成的新数组，但是它们的成员都是对原数组成员的引用，这就是浅拷贝。如果修改了引用指向的值，会同步反映到新数组。
 
 **（3）与解构赋值结合**
 

From 69cae47007874d7fd80371a5bdecf202e55fe4a4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Dec 2019 15:24:51 +0800
Subject: [PATCH 033/280] docs: update ES2020

---
 docs/let.md       |   2 +-
 docs/module.md    |  32 +++++-
 docs/number.md    | 261 ++++++++++++++++++++++++++++++++++++++++++++++
 docs/proposals.md | 260 ---------------------------------------------
 docs/regex.md     |   8 +-
 5 files changed, 297 insertions(+), 266 deletions(-)

diff --git a/docs/let.md b/docs/let.md
index 4ec238f9d..b92887beb 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -626,7 +626,7 @@ var getGlobal = function () {
 };
 ```
 
-现在有一个[提案](https://github.com/tc39/proposal-global)，在语言标准的层面，引入`globalThis`作为顶层对象。也就是说，任何环境下，`globalThis`都是存在的，都可以从它拿到顶层对象，指向全局环境下的`this`。
+[ES2020](https://github.com/tc39/proposal-global) 在语言标准的层面，引入`globalThis`作为顶层对象。也就是说，任何环境下，`globalThis`都是存在的，都可以从它拿到顶层对象，指向全局环境下的`this`。
 
 垫片库[`global-this`](https://github.com/ungap/global-this)模拟了这个提案，可以在所有环境拿到`globalThis`。
 
diff --git a/docs/module.md b/docs/module.md
index 4c3141d24..2760b8074 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -670,7 +670,7 @@ const myModual = require(path);
 
 上面的语句就是动态加载，`require`到底加载哪一个模块，只有运行时才知道。`import`命令做不到这一点。
 
-因此，有一个[提案](https://github.com/tc39/proposal-dynamic-import)，建议引入`import()`函数，完成动态加载。
+[ES2020提案](https://github.com/tc39/proposal-dynamic-import) 引入`import()`函数，支持动态加载模块。
 
 ```javascript
 import(specifier)
@@ -800,3 +800,33 @@ async function main() {
 }
 main();
 ```
+
+## import.meta
+
+开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。现在有一个[提案](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.beta`，返回当前模块的元信息。
+
+`import.meta`只能在模块内部使用，如果在模块外部使用会报错。
+
+**（1）import.meta.url**
+
+`import.meta.url`返回当前模块的 URL 路径。举例来说，当前模块主文件的路径是`https://foo.com/main.js`，`import.meta.url`就返回这个路径。如果模块里面还有一个数据文件`data.txt`，那么就可以用下面的代码，获取这个数据文件的路径。
+
+```javascript
+new URL('data.txt', import.meta.url)
+```
+
+注意，Node.js 环境中，`import.meta.url`返回的总是本地路径，即是`file:URL`协议的字符串，比如`file:///home/user/foo.js`。
+
+**（2）import.meta.scriptElement**
+
+`import.meta.scriptElement`是浏览器特有的元属性，返回加载模块的那个`<script>`元素，相当于`document.currentScript`属性。
+
+```javascript
+// HTML 代码为
+// <script type="module" src="my-module.js" data-foo="abc"></script>
+
+// my-module.js 内部执行下面的代码
+import.meta.scriptElement.dataset.foo
+// "abc"
+```
+
diff --git a/docs/number.md b/docs/number.md
index 677114de0..25611e439 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -697,3 +697,264 @@ Math.pow(99, 99)
 ```
 
 上面代码中，两个运算结果的最后一位有效数字是有差异的。
+
+## BigInt 数据类型
+
+### 简介
+
+JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算。二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回`Infinity`。
+
+```javascript
+// 超过 53 个二进制位的数值，无法保持精度
+Math.pow(2, 53) === Math.pow(2, 53) + 1 // true
+
+// 超过 2 的 1024 次方的数值，无法表示
+Math.pow(2, 1024) // Infinity
+```
+
+[ES2020](https://github.com/tc39/proposal-bigint) 引入了一种新的数据类型 BigInt（大整数），来解决这个问题。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。
+
+```javascript
+const a = 2172141653n;
+const b = 15346349309n;
+
+// BigInt 可以保持精度
+a * b // 33334444555566667777n
+
+// 普通整数无法保持精度
+Number(a) * Number(b) // 33334444555566670000
+```
+
+为了与 Number 类型区别，BigInt 类型的数据必须添加后缀`n`。
+
+```javascript
+1234 // 普通整数
+1234n // BigInt
+
+// BigInt 的运算
+1n + 2n // 3n
+```
+
+BigInt 同样可以使用各种进制表示，都要加上后缀`n`。
+
+```javascript
+0b1101n // 二进制
+0o777n // 八进制
+0xFFn // 十六进制
+```
+
+BigInt 与普通整数是两种值，它们之间并不相等。
+
+```javascript
+42n === 42 // false
+```
+
+`typeof`运算符对于 BigInt 类型的数据返回`bigint`。
+
+```javascript
+typeof 123n // 'bigint'
+```
+
+BigInt 可以使用负号（`-`），但是不能使用正号（`+`），因为会与 asm.js 冲突。
+
+```javascript
+-42n // 正确
++42n // 报错
+```
+
+JavaScript 以前不能计算70的阶乘（即`70!`），因为超出了可以表示的精度。
+
+```javascript
+let p = 1;
+for (let i = 1; i <= 70; i++) {
+  p *= i;
+}
+console.log(p); // 1.197857166996989e+100
+```
+
+现在支持大整数了，就可以算了，浏览器的开发者工具运行下面代码，就OK。
+
+```javascript
+let p = 1n;
+for (let i = 1n; i <= 70n; i++) {
+  p *= i;
+}
+console.log(p); // 11978571...00000000n
+```
+
+### BigInt 对象
+
+JavaScript 原生提供`BigInt`对象，可以用作构造函数生成 BigInt 类型的数值。转换规则基本与`Number()`一致，将其他类型的值转为 BigInt。
+
+```javascript
+BigInt(123) // 123n
+BigInt('123') // 123n
+BigInt(false) // 0n
+BigInt(true) // 1n
+```
+
+`BigInt()`构造函数必须有参数，而且参数必须可以正常转为数值，下面的用法都会报错。
+
+```javascript
+new BigInt() // TypeError
+BigInt(undefined) //TypeError
+BigInt(null) // TypeError
+BigInt('123n') // SyntaxError
+BigInt('abc') // SyntaxError
+```
+
+上面代码中，尤其值得注意字符串`123n`无法解析成 Number 类型，所以会报错。
+
+参数如果是小数，也会报错。
+
+```javascript
+BigInt(1.5) // RangeError
+BigInt('1.5') // SyntaxError
+```
+
+BigInt 对象继承了 Object 对象的两个实例方法。
+
+- `BigInt.prototype.toString()`
+- `BigInt.prototype.valueOf()`
+
+它还继承了 Number 对象的一个实例方法。
+
+- `BigInt.prototype.toLocaleString()`
+
+此外，还提供了三个静态方法。
+
+- `BigInt.asUintN(width, BigInt)`： 给定的 BigInt 转为 0 到 2<sup>width</sup> - 1 之间对应的值。
+- `BigInt.asIntN(width, BigInt)`：给定的 BigInt 转为 -2<sup>width - 1</sup> 到 2<sup>width - 1</sup> - 1 之间对应的值。
+- `BigInt.parseInt(string[, radix])`：近似于`Number.parseInt()`，将一个字符串转换成指定进制的 BigInt。
+
+```javascript
+const max = 2n ** (64n - 1n) - 1n;
+
+BigInt.asIntN(64, max)
+// 9223372036854775807n
+BigInt.asIntN(64, max + 1n)
+// -9223372036854775808n
+BigInt.asUintN(64, max + 1n)
+// 9223372036854775808n
+```
+
+上面代码中，`max`是64位带符号的 BigInt 所能表示的最大值。如果对这个值加`1n`，`BigInt.asIntN()`将会返回一个负值，因为这时新增的一位将被解释为符号位。而`BigInt.asUintN()`方法由于不存在符号位，所以可以正确返回结果。
+
+如果`BigInt.asIntN()`和`BigInt.asUintN()`指定的位数，小于数值本身的位数，那么头部的位将被舍弃。
+
+```javascript
+const max = 2n ** (64n - 1n) - 1n;
+
+BigInt.asIntN(32, max) // -1n
+BigInt.asUintN(32, max) // 4294967295n
+```
+
+上面代码中，`max`是一个64位的 BigInt，如果转为32位，前面的32位都会被舍弃。
+
+下面是`BigInt.parseInt()`的例子。
+
+```javascript
+// Number.parseInt() 与 BigInt.parseInt() 的对比
+Number.parseInt('9007199254740993', 10)
+// 9007199254740992
+BigInt.parseInt('9007199254740993', 10)
+// 9007199254740993n
+```
+
+上面代码中，由于有效数字超出了最大限度，`Number.parseInt`方法返回的结果是不精确的，而`BigInt.parseInt`方法正确返回了对应的 BigInt。
+
+对于二进制数组，BigInt 新增了两个类型`BigUint64Array`和`BigInt64Array`，这两种数据类型返回的都是64位 BigInt。`DataView`对象的实例方法`DataView.prototype.getBigInt64()`和`DataView.prototype.getBigUint64()`，返回的也是 BigInt。
+
+### 转换规则
+
+可以使用`Boolean()`、`Number()`和`String()`这三个方法，将 BigInt 可以转为布尔值、数值和字符串类型。
+
+```javascript
+Boolean(0n) // false
+Boolean(1n) // true
+Number(1n)  // 1
+String(1n)  // "1"
+```
+
+上面代码中，注意最后一个例子，转为字符串时后缀`n`会消失。
+
+另外，取反运算符（`!`）也可以将 BigInt 转为布尔值。
+
+```javascript
+!0n // true
+!1n // false
+```
+
+### 数学运算
+
+数学运算方面，BigInt 类型的`+`、`-`、`*`和`**`这四个二元运算符，与 Number 类型的行为一致。除法运算`/`会舍去小数部分，返回一个整数。
+
+```javascript
+9n / 5n
+// 1n
+```
+
+几乎所有的数值运算符都可以用在 BigInt，但是有两个例外。
+
+- 不带符号的右移位运算符`>>>`
+- 一元的求正运算符`+`
+
+上面两个运算符用在 BigInt 会报错。前者是因为`>>>`运算符是不带符号的，但是 BigInt 总是带有符号的，导致该运算无意义，完全等同于右移运算符`>>`。后者是因为一元运算符`+`在 asm.js 里面总是返回 Number 类型，为了不破坏 asm.js 就规定`+1n`会报错。
+
+BigInt 不能与普通数值进行混合运算。
+
+```javascript
+1n + 1.3 // 报错
+```
+
+上面代码报错是因为无论返回的是 BigInt 或 Number，都会导致丢失精度信息。比如`(2n**53n + 1n) + 0.5`这个表达式，如果返回 BigInt 类型，`0.5`这个小数部分会丢失；如果返回 Number 类型，有效精度只能保持 53 位，导致精度下降。
+
+同样的原因，如果一个标准库函数的参数预期是 Number 类型，但是得到的是一个 BigInt，就会报错。
+
+```javascript
+// 错误的写法
+Math.sqrt(4n) // 报错
+
+// 正确的写法
+Math.sqrt(Number(4n)) // 2
+```
+
+上面代码中，`Math.sqrt`的参数预期是 Number 类型，如果是 BigInt 就会报错，必须先用`Number`方法转一下类型，才能进行计算。
+
+asm.js 里面，`|0`跟在一个数值的后面会返回一个32位整数。根据不能与 Number 类型混合运算的规则，BigInt 如果与`|0`进行运算会报错。
+
+```javascript
+1n | 0 // 报错
+```
+
+### 其他运算
+
+BigInt 对应的布尔值，与 Number 类型一致，即`0n`会转为`false`，其他值转为`true`。
+
+```javascript
+if (0n) {
+  console.log('if');
+} else {
+  console.log('else');
+}
+// else
+```
+
+上面代码中，`0n`对应`false`，所以会进入`else`子句。
+
+比较运算符（比如`>`）和相等运算符（`==`）允许 BigInt 与其他类型的值混合计算，因为这样做不会损失精度。
+
+```javascript
+0n < 1 // true
+0n < true // true
+0n == 0 // true
+0n == false // true
+0n === 0 // false
+```
+
+BigInt 与字符串混合运算时，会先转为字符串，再进行运算。
+
+```javascript
+'' + 123n // "123"
+```
+
diff --git a/docs/proposals.md b/docs/proposals.md
index 50097f39e..6d9c35e21 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -391,266 +391,6 @@ Number('123_456') // NaN
 parseInt('123_456') // 123
 ```
 
-## BigInt 数据类型
-
-### 简介
-
-JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算。二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回`Infinity`。
-
-```javascript
-// 超过 53 个二进制位的数值，无法保持精度
-Math.pow(2, 53) === Math.pow(2, 53) + 1 // true
-
-// 超过 2 的 1024 次方的数值，无法表示
-Math.pow(2, 1024) // Infinity
-```
-
-现在有一个[提案](https://github.com/tc39/proposal-bigint)，引入了一种新的数据类型 BigInt（大整数），来解决这个问题。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。
-
-```javascript
-const a = 2172141653n;
-const b = 15346349309n;
-
-// BigInt 可以保持精度
-a * b // 33334444555566667777n
-
-// 普通整数无法保持精度
-Number(a) * Number(b) // 33334444555566670000
-```
-
-为了与 Number 类型区别，BigInt 类型的数据必须添加后缀`n`。
-
-```javascript
-1234 // 普通整数
-1234n // BigInt
-
-// BigInt 的运算
-1n + 2n // 3n
-```
-
-BigInt 同样可以使用各种进制表示，都要加上后缀`n`。
-
-```javascript
-0b1101n // 二进制
-0o777n // 八进制
-0xFFn // 十六进制
-```
-
-BigInt 与普通整数是两种值，它们之间并不相等。
-
-```javascript
-42n === 42 // false
-```
-
-`typeof`运算符对于 BigInt 类型的数据返回`bigint`。
-
-```javascript
-typeof 123n // 'bigint'
-```
-
-BigInt 可以使用负号（`-`），但是不能使用正号（`+`），因为会与 asm.js 冲突。
-
-```javascript
--42n // 正确
-+42n // 报错
-```
-
-JavaScript 以前不能计算70的阶乘（即`70!`），因为超出了可以表示的精度。
-
-```javascript
-let p = 1;
-for (let i = 1; i <= 70; i++) {
-  p *= i;
-}
-console.log(p); // 1.197857166996989e+100
-```
-
-现在支持大整数了，就可以算了，浏览器的开发者工具运行下面代码，就OK。
-
-```javascript
-let p = 1n;
-for (let i = 1n; i <= 70n; i++) {
-  p *= i;
-}
-console.log(p); // 11978571...00000000n
-```
-
-### BigInt 对象
-
-JavaScript 原生提供`BigInt`对象，可以用作构造函数生成 BigInt 类型的数值。转换规则基本与`Number()`一致，将其他类型的值转为 BigInt。
-
-```javascript
-BigInt(123) // 123n
-BigInt('123') // 123n
-BigInt(false) // 0n
-BigInt(true) // 1n
-```
-
-`BigInt()`构造函数必须有参数，而且参数必须可以正常转为数值，下面的用法都会报错。
-
-```javascript
-new BigInt() // TypeError
-BigInt(undefined) //TypeError
-BigInt(null) // TypeError
-BigInt('123n') // SyntaxError
-BigInt('abc') // SyntaxError
-```
-
-上面代码中，尤其值得注意字符串`123n`无法解析成 Number 类型，所以会报错。
-
-参数如果是小数，也会报错。
-
-```javascript
-BigInt(1.5) // RangeError
-BigInt('1.5') // SyntaxError
-```
-
-BigInt 对象继承了 Object 对象的两个实例方法。
-
-- `BigInt.prototype.toString()`
-- `BigInt.prototype.valueOf()`
-
-它还继承了 Number 对象的一个实例方法。
-
-- `BigInt.prototype.toLocaleString()`
-
-此外，还提供了三个静态方法。
-
-- `BigInt.asUintN(width, BigInt)`： 给定的 BigInt 转为 0 到 2<sup>width</sup> - 1 之间对应的值。
-- `BigInt.asIntN(width, BigInt)`：给定的 BigInt 转为 -2<sup>width - 1</sup> 到 2<sup>width - 1</sup> - 1 之间对应的值。
-- `BigInt.parseInt(string[, radix])`：近似于`Number.parseInt()`，将一个字符串转换成指定进制的 BigInt。
-
-```javascript
-const max = 2n ** (64n - 1n) - 1n;
-
-BigInt.asIntN(64, max)
-// 9223372036854775807n
-BigInt.asIntN(64, max + 1n)
-// -9223372036854775808n
-BigInt.asUintN(64, max + 1n)
-// 9223372036854775808n
-```
-
-上面代码中，`max`是64位带符号的 BigInt 所能表示的最大值。如果对这个值加`1n`，`BigInt.asIntN()`将会返回一个负值，因为这时新增的一位将被解释为符号位。而`BigInt.asUintN()`方法由于不存在符号位，所以可以正确返回结果。
-
-如果`BigInt.asIntN()`和`BigInt.asUintN()`指定的位数，小于数值本身的位数，那么头部的位将被舍弃。
-
-```javascript
-const max = 2n ** (64n - 1n) - 1n;
-
-BigInt.asIntN(32, max) // -1n
-BigInt.asUintN(32, max) // 4294967295n
-```
-
-上面代码中，`max`是一个64位的 BigInt，如果转为32位，前面的32位都会被舍弃。
-
-下面是`BigInt.parseInt()`的例子。
-
-```javascript
-// Number.parseInt() 与 BigInt.parseInt() 的对比
-Number.parseInt('9007199254740993', 10)
-// 9007199254740992
-BigInt.parseInt('9007199254740993', 10)
-// 9007199254740993n
-```
-
-上面代码中，由于有效数字超出了最大限度，`Number.parseInt`方法返回的结果是不精确的，而`BigInt.parseInt`方法正确返回了对应的 BigInt。
-
-对于二进制数组，BigInt 新增了两个类型`BigUint64Array`和`BigInt64Array`，这两种数据类型返回的都是64位 BigInt。`DataView`对象的实例方法`DataView.prototype.getBigInt64()`和`DataView.prototype.getBigUint64()`，返回的也是 BigInt。
-
-### 转换规则
-
-可以使用`Boolean()`、`Number()`和`String()`这三个方法，将 BigInt 可以转为布尔值、数值和字符串类型。
-
-```javascript
-Boolean(0n) // false
-Boolean(1n) // true
-Number(1n)  // 1
-String(1n)  // "1"
-```
-
-上面代码中，注意最后一个例子，转为字符串时后缀`n`会消失。
-
-另外，取反运算符（`!`）也可以将 BigInt 转为布尔值。
-
-```javascript
-!0n // true
-!1n // false
-```
-
-### 数学运算
-
-数学运算方面，BigInt 类型的`+`、`-`、`*`和`**`这四个二元运算符，与 Number 类型的行为一致。除法运算`/`会舍去小数部分，返回一个整数。
-
-```javascript
-9n / 5n
-// 1n
-```
-
-几乎所有的数值运算符都可以用在 BigInt，但是有两个例外。
-
-- 不带符号的右移位运算符`>>>`
-- 一元的求正运算符`+`
-
-上面两个运算符用在 BigInt 会报错。前者是因为`>>>`运算符是不带符号的，但是 BigInt 总是带有符号的，导致该运算无意义，完全等同于右移运算符`>>`。后者是因为一元运算符`+`在 asm.js 里面总是返回 Number 类型，为了不破坏 asm.js 就规定`+1n`会报错。
-
-BigInt 不能与普通数值进行混合运算。
-
-```javascript
-1n + 1.3 // 报错
-```
-
-上面代码报错是因为无论返回的是 BigInt 或 Number，都会导致丢失精度信息。比如`(2n**53n + 1n) + 0.5`这个表达式，如果返回 BigInt 类型，`0.5`这个小数部分会丢失；如果返回 Number 类型，有效精度只能保持 53 位，导致精度下降。
-
-同样的原因，如果一个标准库函数的参数预期是 Number 类型，但是得到的是一个 BigInt，就会报错。
-
-```javascript
-// 错误的写法
-Math.sqrt(4n) // 报错
-
-// 正确的写法
-Math.sqrt(Number(4n)) // 2
-```
-
-上面代码中，`Math.sqrt`的参数预期是 Number 类型，如果是 BigInt 就会报错，必须先用`Number`方法转一下类型，才能进行计算。
-
-asm.js 里面，`|0`跟在一个数值的后面会返回一个32位整数。根据不能与 Number 类型混合运算的规则，BigInt 如果与`|0`进行运算会报错。
-
-```javascript
-1n | 0 // 报错
-```
-
-### 其他运算
-
-BigInt 对应的布尔值，与 Number 类型一致，即`0n`会转为`false`，其他值转为`true`。
-
-```javascript
-if (0n) {
-  console.log('if');
-} else {
-  console.log('else');
-}
-// else
-```
-
-上面代码中，`0n`对应`false`，所以会进入`else`子句。
-
-比较运算符（比如`>`）和相等运算符（`==`）允许 BigInt 与其他类型的值混合计算，因为这样做不会损失精度。
-
-```javascript
-0n < 1 // true
-0n < true // true
-0n == 0 // true
-0n == false // true
-0n === 0 // false
-```
-
-BigInt 与字符串混合运算时，会先转为字符串，再进行运算。
-
-```javascript
-'' + 123n // "123"
-```
-
 ## Math.signbit()
 
 `Math.sign()`用来判断一个值的正负，但是如果参数是`-0`，它会返回`-0`。
diff --git a/docs/regex.md b/docs/regex.md
index 370b01fa4..a64ad1e65 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -594,7 +594,7 @@ RE_TWICE.test('abc!abc!abc') // true
 RE_TWICE.test('abc!abc!ab') // false
 ```
 
-## String.prototype.matchAll
+## String.prototype.matchAll()
 
 如果一个正则表达式在字符串里面有多个匹配，现在一般使用`g`修饰符或`y`修饰符，在循环里面逐一取出。
 
@@ -618,7 +618,7 @@ matches
 
 上面代码中，`while`循环取出每一轮的正则匹配，一共三轮。
 
-目前有一个[提案](https://github.com/tc39/proposal-string-matchall)，增加了`String.prototype.matchAll`方法，可以一次性取出所有匹配。不过，它返回的是一个遍历器（Iterator），而不是数组。
+[ES2020](https://github.com/tc39/proposal-string-matchall) 增加了`String.prototype.matchAll()`方法，可以一次性取出所有匹配。不过，它返回的是一个遍历器（Iterator），而不是数组。
 
 ```javascript
 const string = 'test1test2test3';
@@ -636,12 +636,12 @@ for (const match of string.matchAll(regex)) {
 
 上面代码中，由于`string.matchAll(regex)`返回的是遍历器，所以可以用`for...of`循环取出。相对于返回数组，返回遍历器的好处在于，如果匹配结果是一个很大的数组，那么遍历器比较节省资源。
 
-遍历器转为数组是非常简单的，使用`...`运算符和`Array.from`方法就可以了。
+遍历器转为数组是非常简单的，使用`...`运算符和`Array.from()`方法就可以了。
 
 ```javascript
 // 转为数组方法一
 [...string.matchAll(regex)]
 
 // 转为数组方法二
-Array.from(string.matchAll(regex));
+Array.from(string.matchAll(regex))
 ```

From e28d4087c511300928f5e8d5aad41713e3608a4c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Dec 2019 15:31:47 +0800
Subject: [PATCH 034/280] docs: update es2020

---
 docs/module.md    | 29 --------------------------
 docs/proposals.md | 53 +++++++++++++----------------------------------
 2 files changed, 14 insertions(+), 68 deletions(-)

diff --git a/docs/module.md b/docs/module.md
index 2760b8074..62cffbe84 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -801,32 +801,3 @@ async function main() {
 main();
 ```
 
-## import.meta
-
-开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。现在有一个[提案](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.beta`，返回当前模块的元信息。
-
-`import.meta`只能在模块内部使用，如果在模块外部使用会报错。
-
-**（1）import.meta.url**
-
-`import.meta.url`返回当前模块的 URL 路径。举例来说，当前模块主文件的路径是`https://foo.com/main.js`，`import.meta.url`就返回这个路径。如果模块里面还有一个数据文件`data.txt`，那么就可以用下面的代码，获取这个数据文件的路径。
-
-```javascript
-new URL('data.txt', import.meta.url)
-```
-
-注意，Node.js 环境中，`import.meta.url`返回的总是本地路径，即是`file:URL`协议的字符串，比如`file:///home/user/foo.js`。
-
-**（2）import.meta.scriptElement**
-
-`import.meta.scriptElement`是浏览器特有的元属性，返回加载模块的那个`<script>`元素，相当于`document.currentScript`属性。
-
-```javascript
-// HTML 代码为
-// <script type="module" src="my-module.js" data-foo="abc"></script>
-
-// my-module.js 内部执行下面的代码
-import.meta.scriptElement.dataset.foo
-// "abc"
-```
-
diff --git a/docs/proposals.md b/docs/proposals.md
index 6d9c35e21..c4c5733d4 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -603,57 +603,32 @@ $ hello.js
 
 ## import.meta
 
-加载 JavaScript 脚本的时候，有时候需要知道脚本的元信息。Node.js 提供了两个特殊变量`__filename`和`__dirname`，用来获取脚本的文件名和所在路径。
+开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。现在有一个[提案](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.beta`，返回当前模块的元信息。
 
-```javascript
-const fs = require('fs');
-const path = require('path');
-const bytes = fs.readFileSync(path.resolve(__dirname, 'data.bin'));
-```
-
-上面代码中，`__dirname`用于加载与脚本同一个目录的数据文件`data.bin`。
+`import.meta`只能在模块内部使用，如果在模块外部使用会报错。
 
-但是，浏览器没有这两个特殊变量。如果需要知道脚本的元信息，就只有手动提供。
+这个属性返回一个对象，该对象的各种属性就是当前运行的脚本的元信息。具体包含哪些属性，标准没有规定，由各个运行环境自行决定。一般来说，`import.meta`至少会有下面两个属性。
 
-```html
-<script data-option="value" src="library.js"></script>
-```
+**（1）import.meta.url**
 
-上面这一行 HTML 代码加载 JavaScript 脚本，使用`data-`属性放入元信息。如果脚本内部要获知元信息，可以像下面这样写。
+`import.meta.url`返回当前模块的 URL 路径。举例来说，当前模块主文件的路径是`https://foo.com/main.js`，`import.meta.url`就返回这个路径。如果模块里面还有一个数据文件`data.txt`，那么就可以用下面的代码，获取这个数据文件的路径。
 
 ```javascript
-const theOption = document.currentScript.dataset.option;
+new URL('data.txt', import.meta.url)
 ```
 
-上面代码中，`document.currentScript`属性可以拿到当前脚本的 DOM 节点。
-
-由于 Node.js 和浏览器做法的不统一，现在有一个[提案](https://github.com/tc39/proposal-import-meta)，提出统一使用`import.meta`属性在脚本内部获取元信息。这个属性返回一个对象，该对象的各种属性就是当前运行的脚本的元信息。具体包含哪些属性，标准没有规定，由各个运行环境自行决定。
+注意，Node.js 环境中，`import.meta.url`返回的总是本地路径，即是`file:URL`协议的字符串，比如`file:///home/user/foo.js`。
 
-一般来说，浏览器的`import.meta`至少会有两个属性。
+**（2）import.meta.scriptElement**
 
-- `import.meta.url`：脚本的 URL。
-- `import.meta.scriptElement`：加载脚本的那个`<script>`的 DOM 节点，用来替代`document.currentScript`。
-
-```html
-<script type="module" src="path/to/hamster-displayer.js" data-size="500"></script>
-```
-
-上面这行代码加载的脚本内部，就可以使用`import.meta`获取元信息。
+`import.meta.scriptElement`是浏览器特有的元属性，返回加载模块的那个`<script>`元素，相当于`document.currentScript`属性。
 
 ```javascript
-(async () => {
-  const response = await fetch(new URL("../hamsters.jpg", import.meta.url));
-  const blob = await response.blob();
-
-  const size = import.meta.scriptElement.dataset.size || 300;
+// HTML 代码为
+// <script type="module" src="my-module.js" data-foo="abc"></script>
 
-  const image = new Image();
-  image.src = URL.createObjectURL(blob);
-  image.width = image.height = size;
-
-  document.body.appendChild(image);
-})();
+// my-module.js 内部执行下面的代码
+import.meta.scriptElement.dataset.foo
+// "abc"
 ```
 
-上面代码中，`import.meta`用来获取所加载的图片的尺寸。
-

From 653f87a5e76f64e1050e95003ca0e61865270d2d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 27 Dec 2019 18:18:38 +0800
Subject: [PATCH 035/280] docs: fix #937

---
 docs/object.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/docs/object.md b/docs/object.md
index 4f57408ba..f353fef9c 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -144,6 +144,20 @@ console.log({user, foo})
 
 上面代码中，`console.log`直接输出`user`和`foo`两个对象时，就是两组键值对，可能会混淆。把它们放在大括号里面输出，就变成了对象的简洁表示法，每组键值对前面会打印对象名，这样就比较清晰了。
 
+注意，简写的对象方法不能用作构造函数，会报错。
+
+```javascript
+const obj = {
+  f() {
+    this.foo = 'bar';
+  }
+};
+
+new obj.f() // 报错
+```
+
+上面代码中，`f`是一个简写的对象方法，所以`obj.f`不能当作构造函数使用。
+
 ## 属性名表达式
 
 JavaScript 定义对象的属性，有两种方法。

From 4db83bb093acbd913dbb90ed1a514d7745fa1546 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Jan 2020 14:32:52 +0800
Subject: [PATCH 036/280] docs: edit index.html

---
 README.md  | 4 ++--
 index.html | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index a4cc5baec..686b01bdd 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# ECMAScript 6 入门
+# ECMAScript 6 (ES6) 入门教程
 
-《ECMAScript 6 入门》是一本开源的 JavaScript 语言教程，全面介绍 ECMAScript 6 新引入的语法特性。
+《ECMAScript 6 入门教程》是一本开源的 JavaScript 语言教程，全面介绍 ECMAScript 6 新引入的语法特性。
 
 [![cover](images/cover_thumbnail_3rd.jpg)](images/cover-3rd.jpg)
 
diff --git a/index.html b/index.html
index 98936328a..b9a5c087e 100644
--- a/index.html
+++ b/index.html
@@ -5,7 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <link rel="stylesheet" href="app/bower_components/normalize-css/normalize.css">
   <link rel="stylesheet" href="css/app.css">
-  <title>ECMAScript 6入门</title>
+  <title>ECMAScript 6（ES6）入门教程</title>
   <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon">
   <link rel="icon" href="/favicon.ico" type="image/x-icon">
   <script src="js/jquery-1.11.0.min.js"></script>
@@ -29,7 +29,7 @@
 
   <script src="config.js"></script>
   <noscript>
-    <p>《ECMAScript 6入门》是一本开源的JavaScript语言教程，全面介绍ECMAScript 6新增的语法特性。</p>
+    <p>《ECMAScript 6 入门教程》是一本开源的JavaScript语言教程，全面介绍ECMAScript 6新增的语法特性。</p>
     <p>本书力争覆盖ES6与ES5的所有不同之处，对涉及的语法知识给予详细介绍，并给出大量简洁易懂的示例代码。</p>
     <p>本书为中级难度，适合已有一定JavaScript语言基础的读者，了解这门语言的最新进展；也可当作参考手册，查寻新增的语法点。</p>
   </noscript>

From bf59c210cae89aec13e87fad751771d3a003bebd Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Jan 2020 14:36:01 +0800
Subject: [PATCH 037/280] docs: edit index.html

---
 README.md  | 2 +-
 index.html | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 686b01bdd..0e80abe03 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# ECMAScript 6 (ES6) 入门教程
+# ES6 入门教程
 
 《ECMAScript 6 入门教程》是一本开源的 JavaScript 语言教程，全面介绍 ECMAScript 6 新引入的语法特性。
 
diff --git a/index.html b/index.html
index b9a5c087e..76253f553 100644
--- a/index.html
+++ b/index.html
@@ -5,7 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <link rel="stylesheet" href="app/bower_components/normalize-css/normalize.css">
   <link rel="stylesheet" href="css/app.css">
-  <title>ECMAScript 6（ES6）入门教程</title>
+  <title>ES6 入门教程</title>
   <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon">
   <link rel="icon" href="/favicon.ico" type="image/x-icon">
   <script src="js/jquery-1.11.0.min.js"></script>

From 33408fd3a366a51a4676c4fe83c8f813281befb8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Jan 2020 15:06:05 +0800
Subject: [PATCH 038/280] feat: add statistics code

---
 js/ditto.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/js/ditto.js b/js/ditto.js
index 6d48b4421..eb7f13ca2 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -316,6 +316,14 @@ function show_loading() {
   return loading;
 }
 
+function statistics() {
+  var _hmt = _hmt || [];
+  var hm = document.createElement("script");
+  hm.src = "https://hm.baidu.com/hm.js?519d72adb78a0bf66de7bae18e994322";
+  var s = document.getElementsByTagName("script")[0];
+  s.parentNode.insertBefore(hm, s);
+}
+
 function router() { 
   var path = location.hash.replace(/#([^#]*)(#.*)?/, './$1');
 
@@ -415,6 +423,8 @@ function router() {
       $('#pagedown').css('display', 'inline-block');
     }
 
+    statistics();
+
     (function() {
       var $w = $(window);
       var $prog2 = $('.progress-indicator-2');

From a6abc6775ee9f880a69b5755e93390b7dc3e30b8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Jan 2020 15:10:15 +0800
Subject: [PATCH 039/280] feat: edit statistics code

---
 js/ditto.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index eb7f13ca2..03135258e 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -355,6 +355,9 @@ function router() {
 
   // otherwise get the markdown and render it
   var loading = show_loading();
+
+  statistics();
+
   $.get(path, function(data) {
     $(ditto.error_id).hide();
     $(ditto.content_id).html(marked(data) + disqusCode);
@@ -423,8 +426,6 @@ function router() {
       $('#pagedown').css('display', 'inline-block');
     }
 
-    statistics();
-
     (function() {
       var $w = $(window);
       var $prog2 = $('.progress-indicator-2');

From 942bcc3ee26ff86ab9d9c7f8a5b6ebf9bf328fa0 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 17 Jan 2020 00:45:29 +0800
Subject: [PATCH 040/280] docs(proxy): fix #943

---
 docs/proxy.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 09dad1d0b..6c57552c0 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -613,7 +613,7 @@ var handler = {
 };
 ```
 
-`construct`方法可以接受两个参数。
+`construct`方法可以接受三个参数。
 
 - `target`：目标对象
 - `args`：构造函数的参数对象

From 0d958f5c62969537b5c141403afb076f511168b9 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 17 Jan 2020 00:50:08 +0800
Subject: [PATCH 041/280] docs(string): fix #942

---
 docs/string.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/string.md b/docs/string.md
index 0806a433a..3c451ea53 100644
--- a/docs/string.md
+++ b/docs/string.md
@@ -421,7 +421,7 @@ div.innerHTML = parse({ supplies: [ "broom", "mop", "cleaner" ] });
 ```javascript
 alert`123`
 // 等同于
-alert(123)
+alert([123])
 ```
 
 标签模板其实不是模板，而是函数调用的一种特殊形式。“标签”指的就是函数，紧跟在后面的模板字符串就是它的参数。

From f9e16e462df103b8df30f7c7ce742a3b0898c9b4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 17 Jan 2020 00:52:58 +0800
Subject: [PATCH 042/280] docs(string): fix #942

---
 docs/string.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/string.md b/docs/string.md
index 3c451ea53..3a3d78560 100644
--- a/docs/string.md
+++ b/docs/string.md
@@ -419,9 +419,9 @@ div.innerHTML = parse({ supplies: [ "broom", "mop", "cleaner" ] });
 模板字符串的功能，不仅仅是上面这些。它可以紧跟在一个函数名后面，该函数将被调用来处理这个模板字符串。这被称为“标签模板”功能（tagged template）。
 
 ```javascript
-alert`123`
+alert`hello`
 // 等同于
-alert([123])
+alert(['hello'])
 ```
 
 标签模板其实不是模板，而是函数调用的一种特殊形式。“标签”指的就是函数，紧跟在后面的模板字符串就是它的参数。

From 0cc6602aca37b0764ee5c3d753f28c5fd27ca107 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 29 Jan 2020 19:50:24 +0800
Subject: [PATCH 043/280] docs: fix #947

---
 docs/set-map.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index f22a87541..25eac94ee 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -1083,18 +1083,20 @@ undefined
 前文说过，WeakMap 应用的典型场合就是 DOM 节点作为键名。下面是一个例子。
 
 ```javascript
-let myElement = document.getElementById('logo');
 let myWeakmap = new WeakMap();
 
-myWeakmap.set(myElement, {timesClicked: 0});
+myWeakmap.set(
+  document.getElementById('logo'),
+  {timesClicked: 0})
+;
 
-myElement.addEventListener('click', function() {
-  let logoData = myWeakmap.get(myElement);
+document.getElementById('logo').addEventListener('click', function() {
+  let logoData = myWeakmap.get(document.getElementById('logo'));
   logoData.timesClicked++;
 }, false);
 ```
 
-上面代码中，`myElement`是一个 DOM 节点，每当发生`click`事件，就更新一下状态。我们将这个状态作为键值放在 WeakMap 里，对应的键名就是`myElement`。一旦这个 DOM 节点删除，该状态就会自动消失，不存在内存泄漏风险。
+上面代码中，`document.getElementById('logo')`是一个 DOM 节点，每当发生`click`事件，就更新一下状态。我们将这个状态作为键值放在 WeakMap 里，对应的键名就是这个节点对象。一旦这个 DOM 节点删除，该状态就会自动消失，不存在内存泄漏风险。
 
 WeakMap 的另一个用处是部署私有属性。
 

From e1fcd8b61d042fed0945c8e45bca4ee4f29bdd5c Mon Sep 17 00:00:00 2001
From: wzx <308929264@qq.com>
Date: Sun, 2 Feb 2020 15:20:25 +0800
Subject: [PATCH 044/280] =?UTF-8?q?=E5=AD=97=E6=AF=8D=E6=9C=89=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/proposals.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proposals.md b/docs/proposals.md
index c4c5733d4..aa077ac3a 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -603,7 +603,7 @@ $ hello.js
 
 ## import.meta
 
-开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。现在有一个[提案](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.beta`，返回当前模块的元信息。
+开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。现在有一个[提案](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.meta`，返回当前模块的元信息。
 
 `import.meta`只能在模块内部使用，如果在模块外部使用会报错。
 

From 0402e4705b3b66442b46eb5d6af57f03b4f95e95 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 12 Feb 2020 18:50:35 +0800
Subject: [PATCH 045/280] refactor: edit ditto.js

---
 js/ditto.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 03135258e..d928fb085 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -225,11 +225,11 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '<span style="color: #4682BE;">《ES6 实战教程》</span> ' +
-    '深入学习一线大厂必备 ES6 技能。VIP 教程限时免费领取。' +
-    '<span style="color: #4682BE;"> ⇐ 立即查看</span>';
+  var text = '【开课吧】' +
+    '拿不到 Offer 退全款，廖雪峰的' +
+    '<span style="color: #4682BE;">《Web 全栈架构师》</span>开班了！';
 
-  var banner = $('<a href="http://www.mawen.co/question/405" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://datayi.cn/w/noqwyzdR" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 86ad600682f1bc3afe2107541c009331b16f6f8a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 12 Feb 2020 21:47:21 +0800
Subject: [PATCH 046/280] refactor: edit ditto.js

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index d928fb085..0828dc996 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -225,7 +225,7 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【开课吧】' +
+  var text = '【课程学习】' +
     '拿不到 Offer 退全款，廖雪峰的' +
     '<span style="color: #4682BE;">《Web 全栈架构师》</span>开班了！';
 

From 0daab0192dac5ccee5d379088cc66a398aad4b85 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 13 Feb 2020 15:22:09 +0800
Subject: [PATCH 047/280] =?UTF-8?q?docs(regexp):=20add=20=E6=AD=A3?=
 =?UTF-8?q?=E5=88=99=E5=8C=B9=E9=85=8D=E7=B4=A2=E5=BC=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/regex.md | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/docs/regex.md b/docs/regex.md
index a64ad1e65..1f8c1792a 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -594,6 +594,74 @@ RE_TWICE.test('abc!abc!abc') // true
 RE_TWICE.test('abc!abc!ab') // false
 ```
 
+## 正则匹配索引
+
+正则匹配结果的开始位置和结束位置，目前获取并不是很方便。正则实例的`exex()`方法，返回结果有一个`index`属性，可以获取整个匹配结果的开始位置，但是如果包含组匹配，每个组匹配的开始位置，很难拿到。
+
+现在有一个[第三阶段提案](https://github.com/tc39/proposal-regexp-match-Indices)，为`exec()`方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
+
+```javascript
+const text = 'zabbcdef';
+const re = /ab/;
+const result = re.exec(text);
+
+result.index // 1
+result.indices // [ [1, 3] ]
+```
+
+上面例子中，`exec()`方法的返回结果`result`，它的`index`属性是整个匹配结果（`ab`）的开始位置，而它的`indices`属性是一个数组，成员是每个匹配的开始位置和结束位置的数组。由于该例子的正则表达式没有组匹配，所以`indices`数组只有一个成员，表示整个匹配的开始位置是`1`，结束位置是`3`。
+
+注意，开始位置包含在匹配结果之中，但是结束位置不包含在匹配结果之中。比如，匹配结果为`ab`，分别是原始字符串的第1位和第2位，那么结束位置就是第3位。
+
+如果正则表达式包含组匹配，那么`indices`属性对应的数组就会包含多个成员，提供每个组匹配的开始位置和结束位置。
+
+```javascript
+const text = 'zabbcdef';
+const re = /ab+(cd)/;
+const result = re.exec(text);
+
+result.indices // [ [ 1, 6 ], [ 4, 6 ] ]
+```
+
+上面例子中，正则表达式包含一个组匹配，那么`indices`属性数组就有两个成员，第一个成员是整个匹配结果（`abbcd`）的开始位置和结束位置，第二个成员是组匹配（`cd`）的开始位置和结束位置。
+
+下面是多个组匹配的例子。
+
+```javascript
+const text = 'zabbcdef';
+const re = /ab+(cd(ef))/;
+const result = re.exec(text);
+
+result.indices // [ [1, 8], [4, 8], [6, 8] ]
+```
+
+上面例子中，正则表达式包含两个组匹配，所以`indices`属性数组就有三个成员。
+
+如果正则表达式包含具名组匹配，`indices`属性数组还会有一个`groups`属性。该属性是一个对象，可以从该对象获取具名组匹配的开始位置和结束位置。
+
+```javascript
+const text = 'zabbcdef';
+const re = /ab+(?<Z>cd)/;
+const result = re.exec(text);
+
+result.indices.groups // { Z: [ 4, 6 ] }
+```
+
+上面例子中，`exec()`方法返回结果的`indices.groups`属性是一个对象，提供具名组匹配`Z`的开始位置和结束位置。
+
+如果如何获取成功组匹配，`indices`属性数组的对应成员则为`undefined`，`indices.groups`属性对象的对应成员也是`undefined`。
+
+```javascript
+const text = 'zabbcdef';
+const re = /ab+(?<Z>ce)?/;
+const result = re.exec(text);
+
+result.indices[1] // undefined
+result.indices.groups['Z'] // undefined
+```
+
+上面例子中，由于组匹配不成功，所以`indices`属性数组和`indices.groups`属性对象对应的组匹配成员都是`undefined`。
+
 ## String.prototype.matchAll()
 
 如果一个正则表达式在字符串里面有多个匹配，现在一般使用`g`修饰符或`y`修饰符，在循环里面逐一取出。

From 412b29860516ab843f2123229ceedbf1efa4ff94 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 13 Feb 2020 18:23:59 +0800
Subject: [PATCH 048/280] docs(map): fix #949

---
 docs/set-map.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/set-map.md b/docs/set-map.md
index 25eac94ee..9733ee4e6 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -833,6 +833,15 @@ strMapToObj(myMap)
 
 **（4）对象转为 Map**
 
+对象转为 Map 可以通过`Object.entries()`。
+
+```javascript
+let obj = {"a":1, "b":2};
+let map = new Map(Object.entries(obj));
+```
+
+此外，也可以自己实现一个转换函数。
+
 ```javascript
 function objToStrMap(obj) {
   let strMap = new Map();

From a6e8a400bc1e539c8ec46e76cbf87da559ad6155 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 23 Feb 2020 12:41:58 +0800
Subject: [PATCH 049/280] refactor: add tencent.txt

---
 tencent9908947001655912037.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 tencent9908947001655912037.txt

diff --git a/tencent9908947001655912037.txt b/tencent9908947001655912037.txt
new file mode 100644
index 000000000..ca2c43365
--- /dev/null
+++ b/tencent9908947001655912037.txt
@@ -0,0 +1 @@
+4096418148424150100

From b0b10a308e73d4b13712ffc71ac14dfaa18b8af6 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 23 Feb 2020 12:45:18 +0800
Subject: [PATCH 050/280] refactor: add tencent.txt

---
 tencent9908947001655912037.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tencent9908947001655912037.txt b/tencent9908947001655912037.txt
index ca2c43365..c216cc792 100644
--- a/tencent9908947001655912037.txt
+++ b/tencent9908947001655912037.txt
@@ -1 +1,2 @@
 4096418148424150100
+

From 717f4e4218520e076a7dc7d0ce9a8958fb67e1ef Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 23 Feb 2020 14:13:54 +0800
Subject: [PATCH 051/280] docs: fix #952

---
 docs/intro.md | 180 ++------------------------------------------------
 1 file changed, 4 insertions(+), 176 deletions(-)

diff --git a/docs/intro.md b/docs/intro.md
index 59f418747..db626c680 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -68,11 +68,9 @@ ES6 从开始制定到最后发布，整整用了 15 年。
 
 2015 年 6 月，ECMAScript 6 正式通过，成为国际标准。从 2000 年算起，这时已经过去了 15 年。
 
-## 部署进度
+目前，各大浏览器对 ES6 的支持可以查看[kangax.github.io/compat-table/es6/](https://kangax.github.io/compat-table/es6/)。
 
-各大浏览器的最新版本，对 ES6 的支持可以查看[kangax.github.io/compat-table/es6/](https://kangax.github.io/compat-table/es6/)。随着时间的推移，支持度已经越来越高了，超过 90%的 ES6 语法特性都实现了。
-
-Node 是 JavaScript 的服务器运行环境（runtime）。它对 ES6 的支持度更高。除了那些默认打开的功能，还有一些语法功能已经实现了，但是默认没有打开。使用下面的命令，可以查看 Node 已经实现的 ES6 特性。
+Node.js 是 JavaScript 的服务器运行环境（runtime）。它对 ES6 的支持度更高。除了那些默认打开的功能，还有一些语法功能已经实现了，但是默认没有打开。使用下面的命令，可以查看 Node.js 默认没有打开的 ES6 实验性语法。
 
 ```bash
 // Linux & Mac
@@ -82,21 +80,9 @@ $ node --v8-options | grep harmony
 $ node --v8-options | findstr harmony
 ```
 
-我写了一个工具 [ES-Checker](https://github.com/ruanyf/es-checker)，用来检查各种运行环境对 ES6 的支持情况。访问[ruanyf.github.io/es-checker](http://ruanyf.github.io/es-checker)，可以看到您的浏览器支持 ES6 的程度。运行下面的命令，可以查看你正在使用的 Node 环境对 ES6 的支持程度。
-
-```bash
-$ npm install -g es-checker
-$ es-checker
-
-=========================================
-Passes 24 feature Detections
-Your runtime supports 57% of ECMAScript 6
-=========================================
-```
-
 ## Babel 转码器
 
-[Babel](https://babeljs.io/) 是一个广泛使用的 ES6 转码器，可以将 ES6 代码转为 ES5 代码，从而在现有环境执行。这意味着，你可以用 ES6 的方式编写程序，又不用担心现有环境是否支持。下面是一个例子。
+[Babel](https://babeljs.io/) 是一个广泛使用的 ES6 转码器，可以将 ES6 代码转为 ES5 代码，从而在老版本的浏览器执行。这意味着，你可以用 ES6 的方式编写程序，又不用担心现有环境是否支持。下面是一个例子。
 
 ```javascript
 // 转码前
@@ -300,7 +286,7 @@ import '@babel/polyfill';
 require('@babel/polyfill');
 ```
 
-Babel 默认不转码的 API 非常多，详细清单可以查看`babel-plugin-transform-runtime`模块的[definitions.js](https://github.com/babel/babel/blob/master/packages/babel-plugin-transform-runtime/src/definitions.js)文件。
+Babel 默认不转码的 API 非常多，详细清单可以查看`babel-plugin-transform-runtime`模块的[definitions.js](https://github.com/babel/babel/blob/master/packages/babel-plugin-transform-runtime/src/runtime-corejs3-definitions.js)文件。
 
 ### 浏览器环境
 
@@ -317,161 +303,3 @@ Babel 也可以用于浏览器环境，使用[@babel/standalone](https://babeljs
 
 Babel 提供一个[REPL 在线编译器](https://babeljs.io/repl/)，可以在线将 ES6 代码转为 ES5 代码。转换后的代码，可以直接作为 ES5 代码插入网页运行。
 
-## Traceur 转码器
-
-Google 公司的[Traceur](https://github.com/google/traceur-compiler)转码器，也可以将 ES6 代码转为 ES5 代码。
-
-### 直接插入网页
-
-Traceur 允许将 ES6 代码直接插入网页。首先，必须在网页头部加载 Traceur 库文件。
-
-```html
-<script src="https://google.github.io/traceur-compiler/bin/traceur.js"></script>
-<script src="https://google.github.io/traceur-compiler/bin/BrowserSystem.js"></script>
-<script src="https://google.github.io/traceur-compiler/src/bootstrap.js"></script>
-<script type="module">
-  import './Greeter.js';
-</script>
-```
-
-上面代码中，一共有 4 个`script`标签。第一个是加载 Traceur 的库文件，第二个和第三个是将这个库文件用于浏览器环境，第四个则是加载用户脚本，这个脚本里面可以使用 ES6 代码。
-
-注意，第四个`script`标签的`type`属性的值是`module`，而不是`text/javascript`。这是 Traceur 编译器识别 ES6 代码的标志，编译器会自动将所有`type=module`的代码编译为 ES5，然后再交给浏览器执行。
-
-除了引用外部 ES6 脚本，也可以直接在网页中放置 ES6 代码。
-
-```javascript
-<script type="module">
-  class Calc {
-    constructor() {
-      console.log('Calc constructor');
-    }
-    add(a, b) {
-      return a + b;
-    }
-  }
-
-  var c = new Calc();
-  console.log(c.add(4,5));
-</script>
-```
-
-正常情况下，上面代码会在控制台打印出`9`。
-
-如果想对 Traceur 的行为有精确控制，可以采用下面参数配置的写法。
-
-```javascript
-<script>
-  // Create the System object
-  window.System = new traceur.runtime.BrowserTraceurLoader();
-  // Set some experimental options
-  var metadata = {
-    traceurOptions: {
-      experimental: true,
-      properTailCalls: true,
-      symbols: true,
-      arrayComprehension: true,
-      asyncFunctions: true,
-      asyncGenerators: exponentiation,
-      forOn: true,
-      generatorComprehension: true
-    }
-  };
-  // Load your module
-  System.import('./myModule.js', {metadata: metadata}).catch(function(ex) {
-    console.error('Import failed', ex.stack || ex);
-  });
-</script>
-```
-
-上面代码中，首先生成 Traceur 的全局对象`window.System`，然后`System.import`方法可以用来加载 ES6。加载的时候，需要传入一个配置对象`metadata`，该对象的`traceurOptions`属性可以配置支持 ES6 功能。如果设为`experimental: true`，就表示除了 ES6 以外，还支持一些实验性的新功能。
-
-### 在线转换
-
-Traceur 也提供一个[在线编译器](http://google.github.io/traceur-compiler/demo/repl.html)，可以在线将 ES6 代码转为 ES5 代码。转换后的代码，可以直接作为 ES5 代码插入网页运行。
-
-上面的例子转为 ES5 代码运行，就是下面这个样子。
-
-```javascript
-<script src="https://google.github.io/traceur-compiler/bin/traceur.js"></script>
-<script src="https://google.github.io/traceur-compiler/bin/BrowserSystem.js"></script>
-<script src="https://google.github.io/traceur-compiler/src/bootstrap.js"></script>
-<script>
-$traceurRuntime.ModuleStore.getAnonymousModule(function() {
-  "use strict";
-
-  var Calc = function Calc() {
-    console.log('Calc constructor');
-  };
-
-  ($traceurRuntime.createClass)(Calc, {add: function(a, b) {
-    return a + b;
-  }}, {});
-
-  var c = new Calc();
-  console.log(c.add(4, 5));
-  return {};
-});
-</script>
-```
-
-### 命令行转换
-
-作为命令行工具使用时，Traceur 是一个 Node 的模块，首先需要用 npm 安装。
-
-```bash
-$ npm install -g traceur
-```
-
-安装成功后，就可以在命令行下使用 Traceur 了。
-
-Traceur 直接运行 ES6 脚本文件，会在标准输出显示运行结果，以前面的`calc.js`为例。
-
-```bash
-$ traceur calc.js
-Calc constructor
-9
-```
-
-如果要将 ES6 脚本转为 ES5 保存，要采用下面的写法。
-
-```bash
-$ traceur --script calc.es6.js --out calc.es5.js
-```
-
-上面代码的`--script`选项表示指定输入文件，`--out`选项表示指定输出文件。
-
-为了防止有些特性编译不成功，最好加上`--experimental`选项。
-
-```bash
-$ traceur --script calc.es6.js --out calc.es5.js --experimental
-```
-
-命令行下转换生成的文件，就可以直接放到浏览器中运行。
-
-### Node 环境的用法
-
-Traceur 的 Node 用法如下（假定已安装`traceur`模块）。
-
-```javascript
-var traceur = require('traceur');
-var fs = require('fs');
-
-// 将 ES6 脚本转为字符串
-var contents = fs.readFileSync('es6-file.js').toString();
-
-var result = traceur.compile(contents, {
-  filename: 'es6-file.js',
-  sourceMap: true,
-  // 其他设置
-  modules: 'commonjs'
-});
-
-if (result.error)
-  throw result.error;
-
-// result 对象的 js 属性就是转换后的 ES5 代码
-fs.writeFileSync('out.js', result.js);
-// sourceMap 属性对应 map 文件
-fs.writeFileSync('out.js.map', result.sourceMap);
-```

From 296159a4bc93a34fa5108bceab188f4799d4af7e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BF=A9=E4=BA=8C=E8=9B=8B?= <ken442266@gmail.com>
Date: Tue, 25 Feb 2020 20:27:01 +0800
Subject: [PATCH 052/280] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E4=B8=80=E5=A4=84?=
 =?UTF-8?q?=E5=B0=8F=E5=9C=B0=E6=96=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

强迫症患者看着有点变扭。
---
 docs/function.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/function.md b/docs/function.md
index 03dcece48..7dbf10798 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -197,7 +197,7 @@ function f(x = 1, y) {
 }
 
 f() // [1, undefined]
-f(2) // [2, undefined])
+f(2) // [2, undefined]
 f(, 1) // 报错
 f(undefined, 1) // [1, 1]
 

From 57701fcc2e4c972b5fa6be236362f0b57b97bab4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 27 Feb 2020 11:37:31 +0800
Subject: [PATCH 053/280] docs(class): fix typo

---
 docs/class.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index a235dd689..5d8b2e9e7 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -975,7 +975,7 @@ class Rectangle {
 }
 
 class Square extends Rectangle {
-  constructor(length) {
+  constructor(length, width) {
     super(length, width);
   }
 }

From b4ec05645d258102c75a267826209c0c3cd6d4b3 Mon Sep 17 00:00:00 2001
From: AnHongpeng <roc.anhongpeng@gmail.com>
Date: Sat, 29 Feb 2020 14:52:30 +0800
Subject: [PATCH 054/280] =?UTF-8?q?fix:=20=E4=BD=BF=E8=AF=AD=E5=8F=A5?=
 =?UTF-8?q?=E6=9B=B4=E9=80=9A=E9=A1=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/symbol.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index e8d97cb66..75eb1517e 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -375,7 +375,7 @@ let s2 = Symbol.for('foo');
 s1 === s2 // true
 ```
 
-上面代码中，`s1`和`s2`都是 Symbol 值，但是它们都是同样参数的`Symbol.for`方法生成的，所以实际上是同一个值。
+上面代码中，`s1`和`s2`都是 Symbol 值，但是它们都是由同样参数的`Symbol.for`方法生成的，所以实际上是同一个值。
 
 `Symbol.for()`与`Symbol()`这两种写法，都会生成新的 Symbol。它们的区别是，前者会被登记在全局环境中供搜索，后者不会。`Symbol.for()`不会每次调用就返回一个新的 Symbol 类型的值，而是会先检查给定的`key`是否已经存在，如果不存在才会新建一个值。比如，如果你调用`Symbol.for("cat")`30 次，每次都会返回同一个 Symbol 值，但是调用`Symbol("cat")`30 次，会返回 30 个不同的 Symbol 值。
 

From 518f311c5a329c98540b6e83362d39a0e4174c51 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 3 Mar 2020 21:27:41 +0800
Subject: [PATCH 055/280] refactor: update disqus url to HTTPS

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 0828dc996..9442f9061 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -380,14 +380,14 @@ function router() {
       window.disqus_shortname = 'es6';
       window.disqus_identifier = (location.hash ? location.hash.replace("#", "") : 'READEME');
       window.disqus_title = $(ditto.content_id + " h1").text();
-      window.disqus_url = 'http://es6.ruanyifeng.com/' + (location.hash ? location.hash.replace("#", "") : 'README');
+      window.disqus_url = 'https://es6.ruanyifeng.com/' + (location.hash ? location.hash.replace("#", "") : 'README');
 
       // http://docs.disqus.com/developers/universal/
       (function() {
         var dsq = document.createElement('script');
         dsq.type = 'text/javascript';
         dsq.async = true;
-        dsq.src = 'http://' + window.disqus_shortname + '.disqus.com/embed.js';
+        dsq.src = 'https://' + window.disqus_shortname + '.disqus.com/embed.js';
         (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
       })();
     })();

From 6800796e357b574aaf2c0915b0b434bece866a78 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 3 Mar 2020 23:35:12 +0800
Subject: [PATCH 056/280] =?UTF-8?q?docs(async):=20=E5=A6=82=E4=BD=95?=
 =?UTF-8?q?=E5=A4=84=E7=90=86=E6=95=B0=E7=BB=84=E7=9A=84=E5=BC=82=E6=AD=A5?=
 =?UTF-8?q?=E6=93=8D=E4=BD=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/async.md | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index 3c845b8a2..b3dfce791 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -482,6 +482,21 @@ async function dbFuc(db) {
 }
 ```
 
+另一种方法是使用数组的`reduce`方法。
+
+```javascript
+async function dbFuc(db) {
+  let docs = [{}, {}, {}];
+
+  await docs.reduce(async (_, doc) => {
+    await _;
+    await db.post(doc);
+  }, undefined);
+}
+```
+
+上面例子中，`reduce`方法的第一个参数是`async`函数，导致该函数的第一个参数是前一步操作返回的 Promise 对象，所以必须使用`await`等待它操作结束。另外，`reduce`方法返回的是`docs`数组最后一个成员的`async`函数的执行结果，也是一个 Promise 对象，导致在它前面也必须加上`await`。
+
 如果确实希望多个请求并发执行，可以使用`Promise.all`方法。当三个请求都会`resolved`时，下面两种写法效果相同。
 
 ```javascript
@@ -716,7 +731,7 @@ const data = await fetch('https://api.example.com');
 
 上面代码中，`await`命令独立使用，没有放在 async 函数里面，就会报错。
 
-目前，有一个[语法提案](https://github.com/tc39/proposal-top-level-await)，允许在模块的顶层独立使用`await`命令。这个提案的目的，是借用`await`解决模块异步加载的问题。
+目前，有一个[语法提案](https://github.com/tc39/proposal-top-level-await)，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。这个提案的目的，是借用`await`解决模块异步加载的问题。
 
 ```javascript
 // awaiting.js
@@ -737,7 +752,7 @@ export { output };
 ```javascript
 // awaiting.js
 let output;
-(async function main() {
+(async function1 main() {
   const dynamic = await import(someMission);
   const data = await fetch(url);
   output = someProcess(dynamic.default, data);

From 6069e3f7e14d9d1028b88d525ebf54574f336f76 Mon Sep 17 00:00:00 2001
From: Mookiepiece <48076971+Mookiepiece@users.noreply.github.com>
Date: Sat, 7 Mar 2020 20:03:45 +0800
Subject: [PATCH 057/280] =?UTF-8?q?=E4=BD=BF=E7=94=A8core-js=E6=9B=BF?=
 =?UTF-8?q?=E4=BB=A3=E8=BF=87=E6=97=B6=E7=9A=84@babel/polyfill?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/intro.md | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/docs/intro.md b/docs/intro.md
index db626c680..77fde956b 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -266,26 +266,30 @@ console.log(es5Code);
 
 上面代码中，`transform`方法的第一个参数是一个字符串，表示需要被转换的 ES6 代码，第二个参数是转换的配置对象。
 
-### @babel/polyfill
+### polyfill
 
 Babel 默认只转换新的 JavaScript 句法（syntax），而不转换新的 API，比如`Iterator`、`Generator`、`Set`、`Map`、`Proxy`、`Reflect`、`Symbol`、`Promise`等全局对象，以及一些定义在全局对象上的方法（比如`Object.assign`）都不会转码。
 
-举例来说，ES6 在`Array`对象上新增了`Array.from`方法。Babel 就不会转码这个方法。如果想让这个方法运行，必须使用`babel-polyfill`，为当前环境提供一个垫片。
+举例来说，ES6 在`Array`对象上新增了`Array.from`方法。Babel 就不会转码这个方法。如果想让这个方法运行，可以使用`core-js`和`regenerator-runtime`(后者提供generator函数的转码)，为当前环境提供一个垫片。
 
 安装命令如下。
 
 ```bash
-$ npm install --save-dev @babel/polyfill
+$ npm install --save-dev core-js regenerator-runtime
 ```
 
-然后，在脚本头部，加入如下一行代码。
+然后，在脚本头部，加入如下两行代码。
 
 ```javascript
-import '@babel/polyfill';
+import 'core-js';
+import 'regenerator-runtime/runtime';
 // 或者
-require('@babel/polyfill');
+require('core-js');
+require('regenerator-runtime/runtime);
 ```
 
+`@babel/polyfill` 在7.4.0后被废弃，如果选择`core-js`和`regenerator-runtime`则不必再引入`@babel/polyfill`，二者会冲突。
+
 Babel 默认不转码的 API 非常多，详细清单可以查看`babel-plugin-transform-runtime`模块的[definitions.js](https://github.com/babel/babel/blob/master/packages/babel-plugin-transform-runtime/src/runtime-corejs3-definitions.js)文件。
 
 ### 浏览器环境

From 428a74820894e3ab83d3e0111109775a237a55f6 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Mar 2020 15:09:17 +0800
Subject: [PATCH 058/280] docs(intro): delete Babel API #958

---
 docs/intro.md | 45 ---------------------------------------------
 1 file changed, 45 deletions(-)

diff --git a/docs/intro.md b/docs/intro.md
index 77fde956b..488a87bb8 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -223,49 +223,6 @@ $ node index.js
 
 需要注意的是，`@babel/register`只会对`require`命令加载的文件转码，而不会对当前文件转码。另外，由于它是实时转码，所以只适合在开发环境使用。
 
-### babel API
-
-如果某些代码需要调用 Babel 的 API 进行转码，就要使用`@babel/core`模块。
-
-```javascript
-var babel = require('@babel/core');
-
-// 字符串转码
-babel.transform('code();', options);
-// => { code, map, ast }
-
-// 文件转码（异步）
-babel.transformFile('filename.js', options, function(err, result) {
-  result; // => { code, map, ast }
-});
-
-// 文件转码（同步）
-babel.transformFileSync('filename.js', options);
-// => { code, map, ast }
-
-// Babel AST转码
-babel.transformFromAst(ast, code, options);
-// => { code, map, ast }
-```
-
-配置对象`options`，可以参看官方文档[http://babeljs.io/docs/usage/options/](http://babeljs.io/docs/usage/options/)。
-
-下面是一个例子。
-
-```javascript
-var es6Code = 'let x = n => n + 1';
-var es5Code = require('@babel/core')
-  .transform(es6Code, {
-    presets: ['@babel/env']
-  })
-  .code;
-
-console.log(es5Code);
-// '"use strict";\n\nvar x = function x(n) {\n  return n + 1;\n};'
-```
-
-上面代码中，`transform`方法的第一个参数是一个字符串，表示需要被转换的 ES6 代码，第二个参数是转换的配置对象。
-
 ### polyfill
 
 Babel 默认只转换新的 JavaScript 句法（syntax），而不转换新的 API，比如`Iterator`、`Generator`、`Set`、`Map`、`Proxy`、`Reflect`、`Symbol`、`Promise`等全局对象，以及一些定义在全局对象上的方法（比如`Object.assign`）都不会转码。
@@ -288,8 +245,6 @@ require('core-js');
 require('regenerator-runtime/runtime);
 ```
 
-`@babel/polyfill` 在7.4.0后被废弃，如果选择`core-js`和`regenerator-runtime`则不必再引入`@babel/polyfill`，二者会冲突。
-
 Babel 默认不转码的 API 非常多，详细清单可以查看`babel-plugin-transform-runtime`模块的[definitions.js](https://github.com/babel/babel/blob/master/packages/babel-plugin-transform-runtime/src/runtime-corejs3-definitions.js)文件。
 
 ### 浏览器环境

From 0f6569795de19e42b17d50791ff82bea8b194517 Mon Sep 17 00:00:00 2001
From: jianjian <yaoguolijianjian@gmail.com>
Date: Fri, 13 Mar 2020 18:30:23 +0800
Subject: [PATCH 059/280] perf: remove unnecessary closure

---
 docs/proxy.md | 30 ++++++++++++++----------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 6c57552c0..03df972f3 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -214,24 +214,22 @@ arr[-1] // c
 利用 Proxy，可以将读取属性的操作（`get`），转变为执行某个函数，从而实现属性的链式操作。
 
 ```javascript
-var pipe = (function () {
-  return function (value) {
-    var funcStack = [];
-    var oproxy = new Proxy({} , {
-      get : function (pipeObject, fnName) {
-        if (fnName === 'get') {
-          return funcStack.reduce(function (val, fn) {
-            return fn(val);
-          },value);
-        }
-        funcStack.push(window[fnName]);
-        return oproxy;
+var pipe = function (value) {
+  var funcStack = [];
+  var oproxy = new Proxy({} , {
+    get : function (pipeObject, fnName) {
+      if (fnName === 'get') {
+        return funcStack.reduce(function (val, fn) {
+          return fn(val);
+        },value);
       }
-    });
+      funcStack.push(window[fnName]);
+      return oproxy;
+    }
+  });
 
-    return oproxy;
-  }
-}());
+  return oproxy;
+}
 
 var double = n => n * 2;
 var pow    = n => n * n;

From e69230681e872422a23ff86308aa30250bd23721 Mon Sep 17 00:00:00 2001
From: wzx <308929264@qq.com>
Date: Wed, 18 Mar 2020 17:21:22 +0800
Subject: [PATCH 060/280] fix: arraybuffer.md add `new`

---
 docs/arraybuffer.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/arraybuffer.md b/docs/arraybuffer.md
index 9eb73ee83..a2e455104 100644
--- a/docs/arraybuffer.md
+++ b/docs/arraybuffer.md
@@ -730,7 +730,7 @@ struct someStruct {
 `DataView`视图本身也是构造函数，接受一个`ArrayBuffer`对象作为参数，生成视图。
 
 ```javascript
-DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);
+new DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);
 ```
 
 下面是一个例子。

From f18bd46755bfe80c19cfa54782a61b4cdab268f2 Mon Sep 17 00:00:00 2001
From: linmii <jg_wen@163.com>
Date: Sun, 22 Mar 2020 00:01:09 +0800
Subject: [PATCH 061/280] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E8=A1=A8=E8=BF=B0?=
 =?UTF-8?q?=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修复表述错误
---
 docs/regex.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 1f8c1792a..f33b4293c 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -649,7 +649,7 @@ result.indices.groups // { Z: [ 4, 6 ] }
 
 上面例子中，`exec()`方法返回结果的`indices.groups`属性是一个对象，提供具名组匹配`Z`的开始位置和结束位置。
 
-如果如何获取成功组匹配，`indices`属性数组的对应成员则为`undefined`，`indices.groups`属性对象的对应成员也是`undefined`。
+如果获取组匹配不成功，`indices`属性数组的对应成员则为`undefined`，`indices.groups`属性对象的对应成员也是`undefined`。
 
 ```javascript
 const text = 'zabbcdef';

From 2061ad95334c7ef2f01cff698cdf03c802fd618c Mon Sep 17 00:00:00 2001
From: Kid <44045911+kidonng@users.noreply.github.com>
Date: Sun, 22 Mar 2020 21:00:07 +0800
Subject: [PATCH 062/280] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=20`exec()`=20?=
 =?UTF-8?q?=E6=8B=BC=E5=86=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/regex.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 1f8c1792a..af89582d2 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -596,7 +596,7 @@ RE_TWICE.test('abc!abc!ab') // false
 
 ## 正则匹配索引
 
-正则匹配结果的开始位置和结束位置，目前获取并不是很方便。正则实例的`exex()`方法，返回结果有一个`index`属性，可以获取整个匹配结果的开始位置，但是如果包含组匹配，每个组匹配的开始位置，很难拿到。
+正则匹配结果的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法，返回结果有一个`index`属性，可以获取整个匹配结果的开始位置，但是如果包含组匹配，每个组匹配的开始位置，很难拿到。
 
 现在有一个[第三阶段提案](https://github.com/tc39/proposal-regexp-match-Indices)，为`exec()`方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
 

From f71a2cefeaeab30ef05335b3f1ceb11f9e93a243 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 23 Mar 2020 19:57:55 +0800
Subject: [PATCH 063/280] docs(number): fix #965

---
 docs/number.md | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/docs/number.md b/docs/number.md
index 25611e439..9205dc3d9 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -686,18 +686,6 @@ b **= 3;
 // 等同于 b = b * b * b;
 ```
 
-注意，V8 引擎的指数运算符与`Math.pow`的实现不相同，对于特别大的运算结果，两者会有细微的差异。
-
-```javascript
-Math.pow(99, 99)
-// 3.697296376497263e+197
-
-99 ** 99
-// 3.697296376497268e+197
-```
-
-上面代码中，两个运算结果的最后一位有效数字是有差异的。
-
 ## BigInt 数据类型
 
 ### 简介

From cd0310c978a3155177322eb5a33eab9109ee039f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 23 Mar 2020 20:19:08 +0800
Subject: [PATCH 064/280] =?UTF-8?q?docs(object):=20=E4=BF=AE=E6=94=B9?=
 =?UTF-8?q?=E6=89=A9=E5=B1=95=E8=BF=90=E7=AE=97=E7=AC=A6=E8=87=AA=E5=8A=A8?=
 =?UTF-8?q?=E6=89=A7=E8=A1=8C=E5=8F=96=E5=80=BC=E5=87=BD=E6=95=B0=20get=20?=
 =?UTF-8?q?=E7=9A=84=E4=BE=8B=E5=AD=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/object.md | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/docs/object.md b/docs/object.md
index f353fef9c..b8f7511bf 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -693,25 +693,17 @@ const obj = {
 扩展运算符的参数对象之中，如果有取值函数`get`，这个函数是会执行的。
 
 ```javascript
-// 并不会抛出错误，因为 x 属性只是被定义，但没执行
-let aWithXGetter = {
-  ...a,
+let a = {
   get x() {
     throw new Error('not throw yet');
   }
-};
+}
 
-// 会抛出错误，因为 x 属性被执行了
-let runtimeError = {
-  ...a,
-  ...{
-    get x() {
-      throw new Error('throw now');
-    }
-  }
-};
+let aWithXGetter = { ...a }; // 报错
 ```
 
+上面例子中，取值函数`get`在扩展`a`对象时会自动执行，导致报错。
+
 ## 链判断运算符
 
 编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。比如，要读取`message.body.user.firstName`，安全的写法是写成下面这样。

From 31ab7b10d275e63fde94f5448df6c2a9d7592799 Mon Sep 17 00:00:00 2001
From: linmii <jg_wen@163.com>
Date: Tue, 24 Mar 2020 09:28:01 +0800
Subject: [PATCH 065/280] =?UTF-8?q?=E5=8E=BB=E9=99=A4=E5=A4=9A=E4=BD=99?=
 =?UTF-8?q?=E6=96=87=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

去除多余文字
---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index bd2b631e4..6bb8976cd 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -776,7 +776,7 @@ try {
 }
 ```
 
-上面代码中，`Promise.any()`方法的参数数组包含三个 Promise 操作。其中只要有一个变成`fulfilled`，`Promise.any()`返回的 Promise 对象就变成`fulfilled`。如果所有三个操作都变成`rejected`，那么就会`await`命令就会抛出错误。
+上面代码中，`Promise.any()`方法的参数数组包含三个 Promise 操作。其中只要有一个变成`fulfilled`，`Promise.any()`返回的 Promise 对象就变成`fulfilled`。如果所有三个操作都变成`rejected`，那么`await`命令就会抛出错误。
 
 `Promise.any()`抛出的错误，不是一个一般的错误，而是一个 AggregateError 实例。它相当于一个数组，每个成员对应一个被`rejected`的操作所抛出的错误。下面是 AggregateError 的实现示例。
 

From fe723778a0e32363c0e881c1d2f8ab2fd3611e15 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Mar 2020 00:52:06 +0800
Subject: [PATCH 066/280] refactor: edit sponsor banner

---
 js/ditto.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 9442f9061..b78cf4ce9 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -210,8 +210,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2020年3月22日
-  var deadline = new Date(2020, 2, 22);
+  // 2020年4月25日
+  var deadline = new Date(2020, 3, 25);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -225,11 +225,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【课程学习】' +
-    '拿不到 Offer 退全款，廖雪峰的' +
-    '<span style="color: #4682BE;">《Web 全栈架构师》</span>开班了！';
+  var text = '【课程】' +
+    '开始学习<span style="color: #4682BE;">《ES6 实战教程》</span>，一线大厂前端必备技能。';
 
-  var banner = $('<a href="https://datayi.cn/w/noqwyzdR" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://datayi.cn/w/1P6jEmmP" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 0068aa51a6c07980337d82f9f2e79f60ab054c3c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Mar 2020 10:04:53 +0800
Subject: [PATCH 067/280] refactor: edit sponsor banner

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index b78cf4ce9..4960312e2 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -225,7 +225,7 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【课程】' +
+  var text = '【免费课程】' +
     '开始学习<span style="color: #4682BE;">《ES6 实战教程》</span>，一线大厂前端必备技能。';
 
   var banner = $('<a href="https://datayi.cn/w/1P6jEmmP" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')

From 8b4db430afb432515e43b7b54fec592ded386b16 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 30 Mar 2020 15:02:12 +0800
Subject: [PATCH 068/280] docs: edit object-methods

---
 docs/object-methods.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/object-methods.md b/docs/object-methods.md
index 1b901cbfd..20c7fd7c1 100644
--- a/docs/object-methods.md
+++ b/docs/object-methods.md
@@ -478,7 +478,7 @@ JavaScript 语言的对象继承是通过原型链实现的。ES6 提供了更
 
 ### `__proto__`属性
 
-`__proto__`属性（前后各两个下划线），用来读取或设置当前对象的`prototype`对象。目前，所有浏览器（包括 IE11）都部署了这个属性。
+`__proto__`属性（前后各两个下划线），用来读取或设置当前对象的原型对象（prototype）。目前，所有浏览器（包括 IE11）都部署了这个属性。
 
 ```javascript
 // es5 的写法
@@ -533,7 +533,7 @@ Object.getPrototypeOf({ __proto__: null })
 
 ### Object.setPrototypeOf()
 
-`Object.setPrototypeOf`方法的作用与`__proto__`相同，用来设置一个对象的`prototype`对象，返回参数对象本身。它是 ES6 正式推荐的设置原型对象的方法。
+`Object.setPrototypeOf`方法的作用与`__proto__`相同，用来设置一个对象的原型对象（prototype），返回参数对象本身。它是 ES6 正式推荐的设置原型对象的方法。
 
 ```javascript
 // 格式

From 73320217c2c0703c962d1314f2c0103319d29d0e Mon Sep 17 00:00:00 2001
From: zhangbao <zhangbao90s@qq.com>
Date: Tue, 31 Mar 2020 10:43:21 +0800
Subject: [PATCH 069/280] =?UTF-8?q?=E7=BB=9F=E4=B8=80=E2=80=9C=E6=8A=BD?=
 =?UTF-8?q?=E8=B1=A1=E6=93=8D=E4=BD=9C=E7=9A=84=E8=BF=90=E8=A1=8C=E6=B5=81?=
 =?UTF-8?q?=E7=A8=8B=E2=80=9D=E7=9A=84=E6=8F=8F=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改了两处：

1）步骤描述

`ReturnIfAbrupt(result)`  应该描述为：

> 1. If result is an abrupt completion, return result.
> 2. Set result to result.[[Value]]

而非

> 1. If resultCompletionRecord is an abrupt completion, return resultCompletionRecord.
> 2. Let result be resultCompletionRecord.[[Value]].

改写之后，方便简写前后的对照，而不至于对不上号。

另外，第一步也修改为：Let result be AbstractOp()

“Set result to result.[[Value]]”的写法参考了这里的：https://v8.dev/blog/understanding-ecmascript-part-1#completion-records

2) 简化了步骤之后的文字描述
---
 docs/spec.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/spec.md b/docs/spec.md
index f1c1e0eee..30aa2c44f 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -70,12 +70,12 @@ F.[[Call]](V, argumentsList)
 
 抽象操作的运行流程，一般是下面这样。
 
-> 1. Let `resultCompletionRecord` be `AbstractOp()`.
-> 1. If `resultCompletionRecord` is an abrupt completion, return `resultCompletionRecord`.
-> 1. Let `result` be `resultCompletionRecord.[[Value]]`.
+> 1. Let `result` be `AbstractOp()`.
+> 1. If `result` is an abrupt completion, return `result`.
+> 1. Set `result` to `result.[[Value]]`.
 > 1. return `result`.
 
-上面的第一步是调用抽象操作`AbstractOp()`，得到`resultCompletionRecord`，这是一个 Completion Record。第二步，如果这个 Record 属于 abrupt completion，就将`resultCompletionRecord`返回给用户。如果此处没有返回，就表示运行结果正常，所得的值存放在`resultCompletionRecord.[[Value]]`属性。第三步，将这个值记为`result`。第四步，将`result`返回给用户。
+上面的第一步调用了抽象操作`AbstractOp()`，得到`result`，这是一个 Completion Record。第二步，如果`result`属于 abrupt completion，就直接返回。如果此处没有返回，表示`result`属于 normal completion。第三步，将`result`的值设置为`resultCompletionRecord.[[Value]]`。第四步，返回`result`。
 
 ES6 规格将这个标准流程，使用简写的方式表达。
 

From 03c9e345a7d254043a748089868b27ba62772252 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Apr 2020 20:45:39 +0800
Subject: [PATCH 070/280] docs(module): update es2020

---
 docs/module.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/module.md b/docs/module.md
index 62cffbe84..ce6c266f0 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -540,20 +540,20 @@ export default es6;
 export { default as es6 } from './someModule';
 ```
 
-下面三种`import`语句，没有对应的复合写法。
+ES2020 之前，有一种`import`语句，没有对应的复合写法。
 
 ```javascript
 import * as someIdentifier from "someModule";
-import someIdentifier from "someModule";
-import someIdentifier, { namedIdentifier } from "someModule";
 ```
 
-为了做到形式的对称，现在有[提案](https://github.com/leebyron/ecmascript-export-default-from)，提出补上这三种复合写法。
+[ES2020](https://github.com/tc39/proposal-export-ns-from)补上了这个写法。
 
 ```javascript
-export * as someIdentifier from "someModule";
-export someIdentifier from "someModule";
-export someIdentifier, { namedIdentifier } from "someModule";
+export * as ns from "mod";
+
+// 等同于
+import * as ns from "mod";
+export {ns};
 ```
 
 ## 模块的继承

From ac50325b6ef029a47b624fb02321dccd2dbdd8a6 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 7 Apr 2020 01:22:55 +0800
Subject: [PATCH 071/280] docs: edit Promise

---
 docs/promise.md | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 6bb8976cd..8723e68c3 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -251,7 +251,7 @@ getJSON("/post/1.json").then(
 
 ## Promise.prototype.catch()
 
-`Promise.prototype.catch`方法是`.then(null, rejection)`或`.then(undefined, rejection)`的别名，用于指定发生错误时的回调函数。
+`Promise.prototype.catch()`方法是`.then(null, rejection)`或`.then(undefined, rejection)`的别名，用于指定发生错误时的回调函数。
 
 ```javascript
 getJSON('/posts.json').then(function(posts) {
@@ -262,7 +262,7 @@ getJSON('/posts.json').then(function(posts) {
 });
 ```
 
-上面代码中，`getJSON`方法返回一个 Promise 对象，如果该对象状态变为`resolved`，则会调用`then`方法指定的回调函数；如果异步操作抛出错误，状态就会变为`rejected`，就会调用`catch`方法指定的回调函数，处理这个错误。另外，`then`方法指定的回调函数，如果运行中抛出错误，也会被`catch`方法捕获。
+上面代码中，`getJSON()`方法返回一个 Promise 对象，如果该对象状态变为`resolved`，则会调用`then()`方法指定的回调函数；如果异步操作抛出错误，状态就会变为`rejected`，就会调用`catch()`方法指定的回调函数，处理这个错误。另外，`then()`方法指定的回调函数，如果运行中抛出错误，也会被`catch()`方法捕获。
 
 ```javascript
 p.then((val) => console.log('fulfilled:', val))
@@ -285,7 +285,7 @@ promise.catch(function(error) {
 // Error: test
 ```
 
-上面代码中，`promise`抛出一个错误，就被`catch`方法指定的回调函数捕获。注意，上面的写法与下面两种写法是等价的。
+上面代码中，`promise`抛出一个错误，就被`catch()`方法指定的回调函数捕获。注意，上面的写法与下面两种写法是等价的。
 
 ```javascript
 // 写法一
@@ -309,7 +309,7 @@ promise.catch(function(error) {
 });
 ```
 
-比较上面两种写法，可以发现`reject`方法的作用，等同于抛出错误。
+比较上面两种写法，可以发现`reject()`方法的作用，等同于抛出错误。
 
 如果 Promise 状态已经变成`resolved`，再抛出错误是无效的。
 
@@ -338,9 +338,9 @@ getJSON('/post/1.json').then(function(post) {
 });
 ```
 
-上面代码中，一共有三个 Promise 对象：一个由`getJSON`产生，两个由`then`产生。它们之中任何一个抛出的错误，都会被最后一个`catch`捕获。
+上面代码中，一共有三个 Promise 对象：一个由`getJSON()`产生，两个由`then()`产生。它们之中任何一个抛出的错误，都会被最后一个`catch()`捕获。
 
-一般来说，不要在`then`方法里面定义 Reject 状态的回调函数（即`then`的第二个参数），总是使用`catch`方法。
+一般来说，不要在`then()`方法里面定义 Reject 状态的回调函数（即`then`的第二个参数），总是使用`catch`方法。
 
 ```javascript
 // bad
@@ -361,9 +361,9 @@ promise
   });
 ```
 
-上面代码中，第二种写法要好于第一种写法，理由是第二种写法可以捕获前面`then`方法执行中的错误，也更接近同步的写法（`try/catch`）。因此，建议总是使用`catch`方法，而不使用`then`方法的第二个参数。
+上面代码中，第二种写法要好于第一种写法，理由是第二种写法可以捕获前面`then`方法执行中的错误，也更接近同步的写法（`try/catch`）。因此，建议总是使用`catch()`方法，而不使用`then()`方法的第二个参数。
 
-跟传统的`try/catch`代码块不同的是，如果没有使用`catch`方法指定错误处理的回调函数，Promise 对象抛出的错误不会传递到外层代码，即不会有任何反应。
+跟传统的`try/catch`代码块不同的是，如果没有使用`catch()`方法指定错误处理的回调函数，Promise 对象抛出的错误不会传递到外层代码，即不会有任何反应。
 
 ```javascript
 const someAsyncThing = function() {
@@ -382,9 +382,9 @@ setTimeout(() => { console.log(123) }, 2000);
 // 123
 ```
 
-上面代码中，`someAsyncThing`函数产生的 Promise 对象，内部有语法错误。浏览器运行到这一行，会打印出错误提示`ReferenceError: x is not defined`，但是不会退出进程、终止脚本执行，2 秒之后还是会输出`123`。这就是说，Promise 内部的错误不会影响到 Promise 外部的代码，通俗的说法就是“Promise 会吃掉错误”。
+上面代码中，`someAsyncThing()`函数产生的 Promise 对象，内部有语法错误。浏览器运行到这一行，会打印出错误提示`ReferenceError: x is not defined`，但是不会退出进程、终止脚本执行，2 秒之后还是会输出`123`。这就是说，Promise 内部的错误不会影响到 Promise 外部的代码，通俗的说法就是“Promise 会吃掉错误”。
 
-这个脚本放在服务器执行，退出码就是`0`（即表示执行成功）。不过，Node 有一个`unhandledRejection`事件，专门监听未捕获的`reject`错误，上面的脚本会触发这个事件的监听函数，可以在监听函数里面抛出错误。
+这个脚本放在服务器执行，退出码就是`0`（即表示执行成功）。不过，Node.js 有一个`unhandledRejection`事件，专门监听未捕获的`reject`错误，上面的脚本会触发这个事件的监听函数，可以在监听函数里面抛出错误。
 
 ```javascript
 process.on('unhandledRejection', function (err, p) {
@@ -410,7 +410,7 @@ promise.then(function (value) { console.log(value) });
 
 上面代码中，Promise 指定在下一轮“事件循环”再抛出错误。到了那个时候，Promise 的运行已经结束了，所以这个错误是在 Promise 函数体外抛出的，会冒泡到最外层，成了未捕获的错误。
 
-一般总是建议，Promise 对象后面要跟`catch`方法，这样可以处理 Promise 内部发生的错误。`catch`方法返回的还是一个 Promise 对象，因此后面还可以接着调用`then`方法。
+一般总是建议，Promise 对象后面要跟`catch()`方法，这样可以处理 Promise 内部发生的错误。`catch()`方法返回的还是一个 Promise 对象，因此后面还可以接着调用`then()`方法。
 
 ```javascript
 const someAsyncThing = function() {
@@ -431,7 +431,7 @@ someAsyncThing()
 // carry on
 ```
 
-上面代码运行完`catch`方法指定的回调函数，会接着运行后面那个`then`方法指定的回调函数。如果没有报错，则会跳过`catch`方法。
+上面代码运行完`catch()`方法指定的回调函数，会接着运行后面那个`then()`方法指定的回调函数。如果没有报错，则会跳过`catch()`方法。
 
 ```javascript
 Promise.resolve()
@@ -444,9 +444,9 @@ Promise.resolve()
 // carry on
 ```
 
-上面的代码因为没有报错，跳过了`catch`方法，直接执行后面的`then`方法。此时，要是`then`方法里面报错，就与前面的`catch`无关了。
+上面的代码因为没有报错，跳过了`catch()`方法，直接执行后面的`then()`方法。此时，要是`then()`方法里面报错，就与前面的`catch()`无关了。
 
-`catch`方法之中，还能再抛出错误。
+`catch()`方法之中，还能再抛出错误。
 
 ```javascript
 const someAsyncThing = function() {
@@ -468,7 +468,7 @@ someAsyncThing().then(function() {
 // oh no [ReferenceError: x is not defined]
 ```
 
-上面代码中，`catch`方法抛出一个错误，因为后面没有别的`catch`方法了，导致这个错误不会被捕获，也不会传递到外层。如果改写一下，结果就不一样了。
+上面代码中，`catch()`方法抛出一个错误，因为后面没有别的`catch()`方法了，导致这个错误不会被捕获，也不会传递到外层。如果改写一下，结果就不一样了。
 
 ```javascript
 someAsyncThing().then(function() {
@@ -484,11 +484,11 @@ someAsyncThing().then(function() {
 // carry on [ReferenceError: y is not defined]
 ```
 
-上面代码中，第二个`catch`方法用来捕获前一个`catch`方法抛出的错误。
+上面代码中，第二个`catch()`方法用来捕获前一个`catch()`方法抛出的错误。
 
 ## Promise.prototype.finally()
 
-`finally`方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。
+`finally()`方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。该方法是 ES2018 引入标准的。
 
 ```javascript
 promise

From 1474f82f17f9c77d1acef3b0d012b7c9b5a2f170 Mon Sep 17 00:00:00 2001
From: waiting <1661926154@qq.com>
Date: Tue, 7 Apr 2020 10:27:28 +0800
Subject: [PATCH 072/280] fix(proposals): shell exec style

Executing file directly must start with (absolute/relative) path under Linux
---
 docs/proposals.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proposals.md b/docs/proposals.md
index aa077ac3a..543905570 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -596,7 +596,7 @@ console.log(1);
 $ node hello.js
 
 # hashbang 的方式
-$ hello.js
+$ ./hello.js
 ```
 
 对于 JavaScript 引擎来说，会把`#!`理解成注释，忽略掉这一行。

From 7076dd5e4cbb9d180ce4d64f0b10e2889a4acd14 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 9 Apr 2020 14:15:26 +0800
Subject: [PATCH 073/280] docs(math): fix #973

---
 docs/number.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/number.md b/docs/number.md
index 9205dc3d9..0aca19309 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -397,16 +397,16 @@ Math.sign = Math.sign || function(x) {
 
 ### Math.cbrt()
 
-`Math.cbrt`方法用于计算一个数的立方根。
+`Math.cbrt()`方法用于计算一个数的立方根。
 
 ```javascript
 Math.cbrt(-1) // -1
 Math.cbrt(0)  // 0
 Math.cbrt(1)  // 1
-Math.cbrt(2)  // 1.2599210498948734
+Math.cbrt(2)  // 1.2599210498948732
 ```
 
-对于非数值，`Math.cbrt`方法内部也是先使用`Number`方法将其转为数值。
+对于非数值，`Math.cbrt()`方法内部也是先使用`Number()`方法将其转为数值。
 
 ```javascript
 Math.cbrt('8') // 2

From c3dd90d54343d38693d8625a6503c4c16af466d9 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 13 Apr 2020 18:45:20 +0800
Subject: [PATCH 074/280] refactor: edit ditto/support

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index 4960312e2..8631cee60 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -228,7 +228,7 @@ function create_banner(element) {
   var text = '【免费课程】' +
     '开始学习<span style="color: #4682BE;">《ES6 实战教程》</span>，一线大厂前端必备技能。';
 
-  var banner = $('<a href="https://datayi.cn/w/1P6jEmmP" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://datayi.cn/w/a9BLv2LP" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From e11dc14db1eb8621f511f72727725c9b95ed8488 Mon Sep 17 00:00:00 2001
From: suzhongping <55773520+suzhongping@users.noreply.github.com>
Date: Fri, 24 Apr 2020 14:04:25 +0800
Subject: [PATCH 075/280] Update module.md

lowercase "readfile"
---
 docs/module.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module.md b/docs/module.md
index ce6c266f0..dac58ff69 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -10,7 +10,7 @@ ES6 模块的设计思想是尽量的静态化，使得编译时就能确定模
 
 ```javascript
 // CommonJS模块
-let { stat, exists, readFile } = require('fs');
+let { stat, exists, readfile } = require('fs');
 
 // 等同于
 let _fs = require('fs');

From 2f908a58ba3b09bc233c9880cb14e8f57bdb5274 Mon Sep 17 00:00:00 2001
From: Ricardo Chan <chenweitech@outlook.com>
Date: Fri, 8 May 2020 15:20:46 +0800
Subject: [PATCH 076/280] =?UTF-8?q?=E5=AE=8C=E5=96=84Reflect.ownkeys()?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95=E7=9A=84=E6=8F=8F=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

```
Reflect.ownKeys(target)
Returns an array of the target object's own (not inherited) property keys.
```
Refrence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect
---
 docs/object.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/object.md b/docs/object.md
index b8f7511bf..ab7a5e99d 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -376,7 +376,7 @@ ES6 一共有 5 种方法可以遍历对象的属性。
 
 **（5）Reflect.ownKeys(obj)**
 
-`Reflect.ownKeys`返回一个数组，包含对象自身的所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举。
+`Reflect.ownKeys`返回一个数组，包含对象自身的（不含继承的）所有键名，不管键名是 Symbol 或字符串，也不管是否可枚举。
 
 以上的 5 种方法遍历对象的键名，都遵守同样的属性遍历的次序规则。
 

From 6f59bc38e18f29552d14e5a661f3aaaf8d95c041 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 13 May 2020 13:35:10 +0800
Subject: [PATCH 077/280] docs(proxy): edit defineProperty

---
 docs/proxy.md | 62 +++++++++++++++++++++++++--------------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 03df972f3..e0dfb38da 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -673,7 +673,7 @@ delete proxy._prop
 
 ### defineProperty()
 
-`defineProperty`方法拦截了`Object.defineProperty`操作。
+`defineProperty()`方法拦截了`Object.defineProperty()`操作。
 
 ```javascript
 var handler = {
@@ -686,13 +686,13 @@ var proxy = new Proxy(target, handler);
 proxy.foo = 'bar' // 不会生效
 ```
 
-上面代码中，`defineProperty`方法返回`false`，导致添加新属性总是无效。
+上面代码中，`defineProperty()`方法内部没有任何操作，只返回`false`，导致添加新属性总是无效。注意，这里的`false`只是用来提示操作失败，本身并不能阻止添加新属性。
 
-注意，如果目标对象不可扩展（non-extensible），则`defineProperty`不能增加目标对象上不存在的属性，否则会报错。另外，如果目标对象的某个属性不可写（writable）或不可配置（configurable），则`defineProperty`方法不得改变这两个设置。
+注意，如果目标对象不可扩展（non-extensible），则`defineProperty()`不能增加目标对象上不存在的属性，否则会报错。另外，如果目标对象的某个属性不可写（writable）或不可配置（configurable），则`defineProperty()`方法不得改变这两个设置。
 
 ### getOwnPropertyDescriptor()
 
-`getOwnPropertyDescriptor`方法拦截`Object.getOwnPropertyDescriptor()`，返回一个属性描述对象或者`undefined`。
+`getOwnPropertyDescriptor()`方法拦截`Object.getOwnPropertyDescriptor()`，返回一个属性描述对象或者`undefined`。
 
 ```javascript
 var handler = {
@@ -713,11 +713,11 @@ Object.getOwnPropertyDescriptor(proxy, 'baz')
 // { value: 'tar', writable: true, enumerable: true, configurable: true }
 ```
 
-上面代码中，`handler.getOwnPropertyDescriptor`方法对于第一个字符为下划线的属性名会返回`undefined`。
+上面代码中，`handler.getOwnPropertyDescriptor()`方法对于第一个字符为下划线的属性名会返回`undefined`。
 
 ### getPrototypeOf()
 
-`getPrototypeOf`方法主要用来拦截获取对象原型。具体来说，拦截下面这些操作。
+`getPrototypeOf()`方法主要用来拦截获取对象原型。具体来说，拦截下面这些操作。
 
 - `Object.prototype.__proto__`
 - `Object.prototype.isPrototypeOf()`
@@ -737,13 +737,13 @@ var p = new Proxy({}, {
 Object.getPrototypeOf(p) === proto // true
 ```
 
-上面代码中，`getPrototypeOf`方法拦截`Object.getPrototypeOf()`，返回`proto`对象。
+上面代码中，`getPrototypeOf()`方法拦截`Object.getPrototypeOf()`，返回`proto`对象。
 
-注意，`getPrototypeOf`方法的返回值必须是对象或者`null`，否则报错。另外，如果目标对象不可扩展（non-extensible）， `getPrototypeOf`方法必须返回目标对象的原型对象。
+注意，`getPrototypeOf()`方法的返回值必须是对象或者`null`，否则报错。另外，如果目标对象不可扩展（non-extensible）， `getPrototypeOf()`方法必须返回目标对象的原型对象。
 
 ### isExtensible()
 
-`isExtensible`方法拦截`Object.isExtensible`操作。
+`isExtensible()`方法拦截`Object.isExtensible()`操作。
 
 ```javascript
 var p = new Proxy({}, {
@@ -758,7 +758,7 @@ Object.isExtensible(p)
 // true
 ```
 
-上面代码设置了`isExtensible`方法，在调用`Object.isExtensible`时会输出`called`。
+上面代码设置了`isExtensible()`方法，在调用`Object.isExtensible`时会输出`called`。
 
 注意，该方法只能返回布尔值，否则返回值会被自动转为布尔值。
 
@@ -783,7 +783,7 @@ Object.isExtensible(p)
 
 ### ownKeys()
 
-`ownKeys`方法用来拦截对象自身属性的读取操作。具体来说，拦截以下操作。
+`ownKeys()`方法用来拦截对象自身属性的读取操作。具体来说，拦截以下操作。
 
 - `Object.getOwnPropertyNames()`
 - `Object.getOwnPropertySymbols()`
@@ -835,7 +835,7 @@ for (let key of Object.keys(proxy)) {
 // "baz"
 ```
 
-注意，使用`Object.keys`方法时，有三类属性会被`ownKeys`方法自动过滤，不会返回。
+注意，使用`Object.keys()`方法时，有三类属性会被`ownKeys()`方法自动过滤，不会返回。
 
 - 目标对象上不存在的属性
 - 属性名为 Symbol 值
@@ -868,9 +868,9 @@ Object.keys(proxy)
 // ['a']
 ```
 
-上面代码中，`ownKeys`方法之中，显式返回不存在的属性（`d`）、Symbol 值（`Symbol.for('secret')`）、不可遍历的属性（`key`），结果都被自动过滤掉。
+上面代码中，`ownKeys()`方法之中，显式返回不存在的属性（`d`）、Symbol 值（`Symbol.for('secret')`）、不可遍历的属性（`key`），结果都被自动过滤掉。
 
-`ownKeys`方法还可以拦截`Object.getOwnPropertyNames()`。
+`ownKeys()`方法还可以拦截`Object.getOwnPropertyNames()`。
 
 ```javascript
 var p = new Proxy({}, {
@@ -883,7 +883,7 @@ Object.getOwnPropertyNames(p)
 // [ 'a', 'b', 'c' ]
 ```
 
-`for...in`循环也受到`ownKeys`方法的拦截。
+`for...in`循环也受到`ownKeys()`方法的拦截。
 
 ```javascript
 const obj = { hello: 'world' };
@@ -898,9 +898,9 @@ for (let key in proxy) {
 }
 ```
 
-上面代码中，`ownkeys`指定只返回`a`和`b`属性，由于`obj`没有这两个属性，因此`for...in`循环不会有任何输出。
+上面代码中，`ownkeys()`指定只返回`a`和`b`属性，由于`obj`没有这两个属性，因此`for...in`循环不会有任何输出。
 
-`ownKeys`方法返回的数组成员，只能是字符串或 Symbol 值。如果有其他类型的值，或者返回的根本不是数组，就会报错。
+`ownKeys()`方法返回的数组成员，只能是字符串或 Symbol 值。如果有其他类型的值，或者返回的根本不是数组，就会报错。
 
 ```javascript
 var obj = {};
@@ -915,9 +915,9 @@ Object.getOwnPropertyNames(p)
 // Uncaught TypeError: 123 is not a valid property name
 ```
 
-上面代码中，`ownKeys`方法虽然返回一个数组，但是每一个数组成员都不是字符串或 Symbol 值，因此就报错了。
+上面代码中，`ownKeys()`方法虽然返回一个数组，但是每一个数组成员都不是字符串或 Symbol 值，因此就报错了。
 
-如果目标对象自身包含不可配置的属性，则该属性必须被`ownKeys`方法返回，否则报错。
+如果目标对象自身包含不可配置的属性，则该属性必须被`ownKeys()`方法返回，否则报错。
 
 ```javascript
 var obj = {};
@@ -937,9 +937,9 @@ Object.getOwnPropertyNames(p)
 // Uncaught TypeError: 'ownKeys' on proxy: trap result did not include 'a'
 ```
 
-上面代码中，`obj`对象的`a`属性是不可配置的，这时`ownKeys`方法返回的数组之中，必须包含`a`，否则会报错。
+上面代码中，`obj`对象的`a`属性是不可配置的，这时`ownKeys()`方法返回的数组之中，必须包含`a`，否则会报错。
 
-另外，如果目标对象是不可扩展的（non-extensible），这时`ownKeys`方法返回的数组之中，必须包含原对象的所有属性，且不能包含多余的属性，否则报错。
+另外，如果目标对象是不可扩展的（non-extensible），这时`ownKeys()`方法返回的数组之中，必须包含原对象的所有属性，且不能包含多余的属性，否则报错。
 
 ```javascript
 var obj = {
@@ -958,11 +958,11 @@ Object.getOwnPropertyNames(p)
 // Uncaught TypeError: 'ownKeys' on proxy: trap returned extra keys but proxy target is non-extensible
 ```
 
-上面代码中，`obj`对象是不可扩展的，这时`ownKeys`方法返回的数组之中，包含了`obj`对象的多余属性`b`，所以导致了报错。
+上面代码中，`obj`对象是不可扩展的，这时`ownKeys()`方法返回的数组之中，包含了`obj`对象的多余属性`b`，所以导致了报错。
 
 ### preventExtensions()
 
-`preventExtensions`方法拦截`Object.preventExtensions()`。该方法必须返回一个布尔值，否则会被自动转为布尔值。
+`preventExtensions()`方法拦截`Object.preventExtensions()`。该方法必须返回一个布尔值，否则会被自动转为布尔值。
 
 这个方法有一个限制，只有目标对象不可扩展时（即`Object.isExtensible(proxy)`为`false`），`proxy.preventExtensions`才能返回`true`，否则会报错。
 
@@ -977,9 +977,9 @@ Object.preventExtensions(proxy)
 // Uncaught TypeError: 'preventExtensions' on proxy: trap returned truish but the proxy target is extensible
 ```
 
-上面代码中，`proxy.preventExtensions`方法返回`true`，但这时`Object.isExtensible(proxy)`会返回`true`，因此报错。
+上面代码中，`proxy.preventExtensions()`方法返回`true`，但这时`Object.isExtensible(proxy)`会返回`true`，因此报错。
 
-为了防止出现这个问题，通常要在`proxy.preventExtensions`方法里面，调用一次`Object.preventExtensions`。
+为了防止出现这个问题，通常要在`proxy.preventExtensions()`方法里面，调用一次`Object.preventExtensions()`。
 
 ```javascript
 var proxy = new Proxy({}, {
@@ -997,7 +997,7 @@ Object.preventExtensions(proxy)
 
 ### setPrototypeOf()
 
-`setPrototypeOf`方法主要用来拦截`Object.setPrototypeOf`方法。
+`setPrototypeOf()`方法主要用来拦截`Object.setPrototypeOf()`方法。
 
 下面是一个例子。
 
@@ -1016,11 +1016,11 @@ Object.setPrototypeOf(proxy, proto);
 
 上面代码中，只要修改`target`的原型对象，就会报错。
 
-注意，该方法只能返回布尔值，否则会被自动转为布尔值。另外，如果目标对象不可扩展（non-extensible），`setPrototypeOf`方法不得改变目标对象的原型。
+注意，该方法只能返回布尔值，否则会被自动转为布尔值。另外，如果目标对象不可扩展（non-extensible），`setPrototypeOf()`方法不得改变目标对象的原型。
 
 ## Proxy.revocable()
 
-`Proxy.revocable`方法返回一个可取消的 Proxy 实例。
+`Proxy.revocable()`方法返回一个可取消的 Proxy 实例。
 
 ```javascript
 let target = {};
@@ -1035,9 +1035,9 @@ revoke();
 proxy.foo // TypeError: Revoked
 ```
 
-`Proxy.revocable`方法返回一个对象，该对象的`proxy`属性是`Proxy`实例，`revoke`属性是一个函数，可以取消`Proxy`实例。上面代码中，当执行`revoke`函数之后，再访问`Proxy`实例，就会抛出一个错误。
+`Proxy.revocable()`方法返回一个对象，该对象的`proxy`属性是`Proxy`实例，`revoke`属性是一个函数，可以取消`Proxy`实例。上面代码中，当执行`revoke`函数之后，再访问`Proxy`实例，就会抛出一个错误。
 
-`Proxy.revocable`的一个使用场景是，目标对象不允许直接访问，必须通过代理访问，一旦访问结束，就收回代理权，不允许再次访问。
+`Proxy.revocable()`的一个使用场景是，目标对象不允许直接访问，必须通过代理访问，一旦访问结束，就收回代理权，不允许再次访问。
 
 ## this 问题
 
@@ -1093,7 +1093,7 @@ proxy.getDate();
 // TypeError: this is not a Date object.
 ```
 
-上面代码中，`getDate`方法只能在`Date`对象实例上面拿到，如果`this`不是`Date`对象实例就会报错。这时，`this`绑定原始对象，就可以解决这个问题。
+上面代码中，`getDate()`方法只能在`Date`对象实例上面拿到，如果`this`不是`Date`对象实例就会报错。这时，`this`绑定原始对象，就可以解决这个问题。
 
 ```javascript
 const target = new Date('2015-01-01');

From 3832b6a691daa4b52ec912616375def6f5f2bab3 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 13 May 2020 13:51:58 +0800
Subject: [PATCH 078/280] refactor: adjust support date

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 8631cee60..e870748de 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -210,8 +210,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2020年4月25日
-  var deadline = new Date(2020, 3, 25);
+  // 2020年8月15日
+  var deadline = new Date(2020, 7, 15);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From 55cbbb8da9d604001f2886bbeeb52dda65ffb2b2 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 14 May 2020 16:44:18 +0800
Subject: [PATCH 079/280] fix: li tag click bug #984

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index e870748de..6daa3b3ae 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -178,7 +178,7 @@ function replace_symbols(text) {
   // replace symbols with underscore
   return text
     .replace(/, /g, ',')
-    .replace(/[&\/\\#,.+=$~%'":*?<>{}\ \]\[]/g, "-")
+    .replace(/[&\!\/\\#,.+=$~%'":*?<>{}\ \]\[]/g, "-")
     .replace(/[()]/g, '');
 }
 

From 323e9620a78167f0feee1ca9905180a33d3ab77f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 31 May 2020 20:17:06 +0800
Subject: [PATCH 080/280] docs(set): fix #991

---
 docs/async.md   | 2 +-
 docs/set-map.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index b3dfce791..53f1ccfba 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -225,7 +225,7 @@ f().then(v => console.log(v))
 
 上面代码中，`await`命令的参数是数值`123`，这时等同于`return 123`。
 
-另一种情况是，`await`命令后面是一个`thenable`对象（即定义`then`方法的对象），那么`await`会将其等同于 Promise 对象。
+另一种情况是，`await`命令后面是一个`thenable`对象（即定义了`then`方法的对象），那么`await`会将其等同于 Promise 对象。
 
 ```javascript
 class Sleep {
diff --git a/docs/set-map.md b/docs/set-map.md
index 9733ee4e6..a934cc3a4 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -281,7 +281,7 @@ let union = new Set([...a, ...b]);
 let intersect = new Set([...a].filter(x => b.has(x)));
 // set {2, 3}
 
-// 差集
+// （a 相对于 b 的）差集
 let difference = new Set([...a].filter(x => !b.has(x)));
 // Set {1}
 ```

From f0a92d5ff0184f145b42cfcd4783dec615d1b44b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 12 Jun 2020 17:42:44 +0800
Subject: [PATCH 081/280] docs(regex): fixed matchall() #992

---
 docs/regex.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/docs/regex.md b/docs/regex.md
index 6e0631cb2..2cd8a15da 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -690,8 +690,6 @@ matches
 
 ```javascript
 const string = 'test1test2test3';
-
-// g 修饰符加不加都可以
 const regex = /t(e)(st(\d?))/g;
 
 for (const match of string.matchAll(regex)) {
@@ -707,9 +705,10 @@ for (const match of string.matchAll(regex)) {
 遍历器转为数组是非常简单的，使用`...`运算符和`Array.from()`方法就可以了。
 
 ```javascript
-// 转为数组方法一
+// 转为数组的方法一
 [...string.matchAll(regex)]
 
-// 转为数组方法二
+// 转为数组的方法二
 Array.from(string.matchAll(regex))
 ```
+

From 0219f20c072780d1702a64e8073a686c4bbba50a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 21 Jun 2020 19:58:46 +0800
Subject: [PATCH 082/280] =?UTF-8?q?docs(object):=20edit=20=E9=93=BE?=
 =?UTF-8?q?=E5=88=A4=E6=96=AD=E8=BF=90=E7=AE=97=E7=AC=A6=20=3F.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/object.md | 38 ++++++++++++++++++++++++++++----------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/docs/object.md b/docs/object.md
index ab7a5e99d..698df6676 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -709,19 +709,27 @@ let aWithXGetter = { ...a }; // 报错
 编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。比如，要读取`message.body.user.firstName`，安全的写法是写成下面这样。
 
 ```javascript
+// 错误的写法
+const  firstName = message.body.user.firstName;
+
+// 正确的写法
 const firstName = (message
   && message.body
   && message.body.user
   && message.body.user.firstName) || 'default';
 ```
 
-或者使用三元运算符`?:`，判断一个对象是否存在。
+上面例子中，`firstName`属性在对象的第四层，所以需要判断四次，每一层是否有值。
+
+三元运算符`?:`也常用于判断对象是否存在。
 
 ```javascript
 const fooInput = myForm.querySelector('input[name=foo]')
 const fooValue = fooInput ? fooInput.value : undefined
 ```
 
+上面例子中，必须先判断`fooInput`是否存在，才能读取`fooInput.value`。
+
 这样的层层判断非常麻烦，因此 [ES2020](https://github.com/tc39/proposal-optional-chaining) 引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
 
 ```javascript
@@ -731,19 +739,13 @@ const fooValue = myForm.querySelector('input[name=foo]')?.value
 
 上面代码使用了`?.`运算符，直接在链式调用的时候判断，左侧的对象是否为`null`或`undefined`。如果是的，就不再往下运算，而是返回`undefined`。
 
-链判断运算符有三种用法。
-
-- `obj?.prop` // 对象属性
-- `obj?.[expr]` // 同上
-- `func?.(...args)` // 函数或对象方法的调用
-
 下面是判断对象方法是否存在，如果存在就立即执行的例子。
 
 ```javascript
 iterator.return?.()
 ```
 
-上面代码中，`iterator.return`如果有定义，就会调用该方法，否则直接返回`undefined`。
+上面代码中，`iterator.return`如果有定义，就会调用该方法，否则`iterator.return`直接返回`undefined`，不再执行`?.`后面的部分。
 
 对于那些可能没有实现的方法，这个运算符尤其有用。
 
@@ -756,7 +758,21 @@ if (myForm.checkValidity?.() === false) {
 
 上面代码中，老式浏览器的表单可能没有`checkValidity`这个方法，这时`?.`运算符就会返回`undefined`，判断语句就变成了`undefined === false`，所以就会跳过下面的代码。
 
-下面是这个运算符常见的使用形式，以及不使用该运算符时的等价形式。
+链判断运算符有三种用法。
+
+- `obj?.prop` // 对象属性
+- `obj?.[expr]` // 同上
+- `func?.(...args)` // 函数或对象方法的调用
+
+下面是`obj?.[expr]`用法的一个例子。
+
+```bash
+let hex = "#C0FFEE".match(/#([A-Z]+)/i)?.[1];
+```
+
+上面例子中，字符串的`match()`方法，如果没有发现匹配会返回`null`，如果发现匹配会返回一个数组，`?.`运算符起到了判断作用。
+
+下面是`?.`运算符常见形式，以及不使用该运算符时的等价形式。
 
 ```javascript
 a?.b
@@ -782,6 +798,8 @@ a == null ? undefined : a()
 
 （1）短路机制
 
+`?.`运算符相当于一种短路机制，只要不满足条件，就不再往下执行。
+
 ```javascript
 a?.[++x]
 // 等同于
@@ -859,7 +877,7 @@ const animationDuration = response.settings.animationDuration ?? 300;
 const showSplashScreen = response.settings.showSplashScreen ?? true;
 ```
 
-上面代码中，默认值只有在属性值为`null`或`undefined`时，才会生效。
+上面代码中，默认值只有在左侧属性值为`null`或`undefined`时，才会生效。
 
 这个运算符的一个目的，就是跟链判断运算符`?.`配合使用，为`null`或`undefined`的值设置默认值。
 

From d59b30173d31e697b53865fbe776c824ba0aed26 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 7 Jul 2020 07:47:01 +0800
Subject: [PATCH 083/280] docs(number): edit BigInt

---
 docs/number.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/number.md b/docs/number.md
index 0aca19309..250e7e735 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -700,7 +700,7 @@ Math.pow(2, 53) === Math.pow(2, 53) + 1 // true
 Math.pow(2, 1024) // Infinity
 ```
 
-[ES2020](https://github.com/tc39/proposal-bigint) 引入了一种新的数据类型 BigInt（大整数），来解决这个问题。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。
+[ES2020](https://github.com/tc39/proposal-bigint) 引入了一种新的数据类型 BigInt（大整数），来解决这个问题，这是 ECMAScript 的第八种数据类型。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。
 
 ```javascript
 const a = 2172141653n;

From 4425866c1011e83817179b04cb831bdbc409e1d3 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 8 Jul 2020 00:19:02 +0800
Subject: [PATCH 084/280] =?UTF-8?q?docs(object):=20edit=20null=20=E5=88=A4?=
 =?UTF-8?q?=E6=96=AD=E8=BF=90=E7=AE=97=E7=AC=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/object.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/object.md b/docs/object.md
index 698df6676..295608cee 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -896,7 +896,7 @@ function Component(props) {
 }
 ```
 
-上面代码判断`props`参数的`enabled`属性是否赋值，等同于下面的写法。
+上面代码判断`props`参数的`enabled`属性是否赋值，基本等同于下面的写法。
 
 ```javascript
 function Component(props) {

From 064ee65efc665759a4074f6b533c4883a6f83e8b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 8 Jul 2020 00:37:57 +0800
Subject: [PATCH 085/280] docs(object-methods): edit Object.assign()

---
 docs/object-methods.md | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/docs/object-methods.md b/docs/object-methods.md
index 20c7fd7c1..a9d8200f3 100644
--- a/docs/object-methods.md
+++ b/docs/object-methods.md
@@ -47,7 +47,7 @@ Object.defineProperty(Object, 'is', {
 
 ### 基本用法
 
-`Object.assign`方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。
+`Object.assign()`方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。
 
 ```javascript
 const target = { a: 1 };
@@ -59,7 +59,7 @@ Object.assign(target, source1, source2);
 target // {a:1, b:2, c:3}
 ```
 
-`Object.assign`方法的第一个参数是目标对象，后面的参数都是源对象。
+`Object.assign()`方法的第一个参数是目标对象，后面的参数都是源对象。
 
 注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
 
@@ -73,7 +73,7 @@ Object.assign(target, source1, source2);
 target // {a:1, b:2, c:3}
 ```
 
-如果只有一个参数，`Object.assign`会直接返回该参数。
+如果只有一个参数，`Object.assign()`会直接返回该参数。
 
 ```javascript
 const obj = {a: 1};
@@ -120,9 +120,9 @@ Object(10)  //  {[[PrimitiveValue]]: 10}
 Object('abc') // {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"}
 ```
 
-上面代码中，布尔值、数值、字符串分别转成对应的包装对象，可以看到它们的原始值都在包装对象的内部属性`[[PrimitiveValue]]`上面，这个属性是不会被`Object.assign`拷贝的。只有字符串的包装对象，会产生可枚举的实义属性，那些属性则会被拷贝。
+上面代码中，布尔值、数值、字符串分别转成对应的包装对象，可以看到它们的原始值都在包装对象的内部属性`[[PrimitiveValue]]`上面，这个属性是不会被`Object.assign()`拷贝的。只有字符串的包装对象，会产生可枚举的实义属性，那些属性则会被拷贝。
 
-`Object.assign`拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（`enumerable: false`）。
+`Object.assign()`拷贝的属性是有限制的，只拷贝源对象的自身属性（不拷贝继承属性），也不拷贝不可枚举的属性（`enumerable: false`）。
 
 ```javascript
 Object.assign({b: 'c'},
@@ -134,9 +134,9 @@ Object.assign({b: 'c'},
 // { b: 'c' }
 ```
 
-上面代码中，`Object.assign`要拷贝的对象只有一个不可枚举属性`invisible`，这个属性并没有被拷贝进去。
+上面代码中，`Object.assign()`要拷贝的对象只有一个不可枚举属性`invisible`，这个属性并没有被拷贝进去。
 
-属性名为 Symbol 值的属性，也会被`Object.assign`拷贝。
+属性名为 Symbol 值的属性，也会被`Object.assign()`拷贝。
 
 ```javascript
 Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
@@ -147,7 +147,7 @@ Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
 
 **（1）浅拷贝**
 
-`Object.assign`方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
+`Object.assign()`方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
 
 ```javascript
 const obj1 = {a: {b: 1}};
@@ -157,11 +157,11 @@ obj1.a.b = 2;
 obj2.a.b // 2
 ```
 
-上面代码中，源对象`obj1`的`a`属性的值是一个对象，`Object.assign`拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面。
+上面代码中，源对象`obj1`的`a`属性的值是一个对象，`Object.assign()`拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面。
 
 **（2）同名属性的替换**
 
-对于这种嵌套的对象，一旦遇到同名属性，`Object.assign`的处理方法是替换，而不是添加。
+对于这种嵌套的对象，一旦遇到同名属性，`Object.assign()`的处理方法是替换，而不是添加。
 
 ```javascript
 const target = { a: { b: 'c', d: 'e' } }
@@ -172,22 +172,22 @@ Object.assign(target, source)
 
 上面代码中，`target`对象的`a`属性被`source`对象的`a`属性整个替换掉了，而不会得到`{ a: { b: 'hello', d: 'e' } }`的结果。这通常不是开发者想要的，需要特别小心。
 
-一些函数库提供`Object.assign`的定制版本（比如 Lodash 的`_.defaultsDeep`方法），可以得到深拷贝的合并。
+一些函数库提供`Object.assign()`的定制版本（比如 Lodash 的`_.defaultsDeep()`方法），可以得到深拷贝的合并。
 
 **（3）数组的处理**
 
-`Object.assign`可以用来处理数组，但是会把数组视为对象。
+`Object.assign()`可以用来处理数组，但是会把数组视为对象。
 
 ```javascript
 Object.assign([1, 2, 3], [4, 5])
 // [4, 5, 3]
 ```
 
-上面代码中，`Object.assign`把数组视为属性名为 0、1、2 的对象，因此源数组的 0 号属性`4`覆盖了目标数组的 0 号属性`1`。
+上面代码中，`Object.assign()`把数组视为属性名为 0、1、2 的对象，因此源数组的 0 号属性`4`覆盖了目标数组的 0 号属性`1`。
 
 **（4）取值函数的处理**
 
-`Object.assign`只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。
+`Object.assign()`只能进行值的复制，如果要复制的值是一个取值函数，那么将求值后再复制。
 
 ```javascript
 const source = {
@@ -199,11 +199,11 @@ Object.assign(target, source)
 // { foo: 1 }
 ```
 
-上面代码中，`source`对象的`foo`属性是一个取值函数，`Object.assign`不会复制这个取值函数，只会拿到值以后，将这个值复制过去。
+上面代码中，`source`对象的`foo`属性是一个取值函数，`Object.assign()`不会复制这个取值函数，只会拿到值以后，将这个值复制过去。
 
 ### 常见用途
 
-`Object.assign`方法有很多用处。
+`Object.assign()`方法有很多用处。
 
 **（1）为对象添加属性**
 
@@ -215,7 +215,7 @@ class Point {
 }
 ```
 
-上面方法通过`Object.assign`方法，将`x`属性和`y`属性添加到`Point`类的对象实例。
+上面方法通过`Object.assign()`方法，将`x`属性和`y`属性添加到`Point`类的对象实例。
 
 **（2）为对象添加方法**
 
@@ -238,7 +238,7 @@ SomeClass.prototype.anotherMethod = function () {
 };
 ```
 
-上面代码使用了对象属性的简洁表示法，直接将两个函数放在大括号中，再使用`assign`方法添加到`SomeClass.prototype`之中。
+上面代码使用了对象属性的简洁表示法，直接将两个函数放在大括号中，再使用`assign()`方法添加到`SomeClass.prototype`之中。
 
 **（3）克隆对象**
 
@@ -290,7 +290,7 @@ function processContent(options) {
 }
 ```
 
-上面代码中，`DEFAULTS`对象是默认值，`options`对象是用户提供的参数。`Object.assign`方法将`DEFAULTS`和`options`合并成一个新对象，如果两者有同名属性，则`options`的属性值会覆盖`DEFAULTS`的属性值。
+上面代码中，`DEFAULTS`对象是默认值，`options`对象是用户提供的参数。`Object.assign()`方法将`DEFAULTS`和`options`合并成一个新对象，如果两者有同名属性，则`options`的属性值会覆盖`DEFAULTS`的属性值。
 
 注意，由于存在浅拷贝的问题，`DEFAULTS`对象和`options`对象的所有属性的值，最好都是简单类型，不要指向另一个对象。否则，`DEFAULTS`对象的该属性很可能不起作用。
 

From e78513744c80d552fb9c2268f09b2d15f6181eff Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 6 Aug 2020 19:56:54 +0800
Subject: [PATCH 086/280] docs(let): fix #1001

---
 docs/let.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/let.md b/docs/let.md
index b92887beb..e5a7c8b3e 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -601,7 +601,7 @@ JavaScript 语言存在一个顶层对象，它提供全局环境（即全局作
 
 同一段代码为了能够在各种环境，都能取到顶层对象，现在一般是使用`this`变量，但是有局限性。
 
-- 全局环境中，`this`会返回顶层对象。但是，Node 模块和 ES6 模块中，`this`返回的是当前模块。
+- 全局环境中，`this`会返回顶层对象。但是，Node.js 模块中`this`返回的是当前模块，ES6 模块中`this`返回的是`undefined`。
 - 函数里面的`this`，如果函数不是作为对象的方法运行，而是单纯作为函数运行，`this`会指向顶层对象。但是，严格模式下，这时`this`会返回`undefined`。
 - 不管是严格模式，还是普通模式，`new Function('return this')()`，总是会返回全局对象。但是，如果浏览器用了 CSP（Content Security Policy，内容安全策略），那么`eval`、`new Function`这些方法都可能无法使用。
 

From 9461a922f6e8ab6ad10ed351007a4418d42d8c6d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 14 Aug 2020 22:35:52 +0800
Subject: [PATCH 087/280] docs: edit README

---
 README.md                      | 2 ++
 js/ditto.js                    | 4 ++--
 tencent9908947001655912037.txt | 2 --
 3 files changed, 4 insertions(+), 4 deletions(-)
 delete mode 100644 tencent9908947001655912037.txt

diff --git a/README.md b/README.md
index 0e80abe03..2fbff3ee7 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # ES6 入门教程
 
+官方镜像：[网道（WangDoc.com）](https://wangdoc.com/es6/)
+
 《ECMAScript 6 入门教程》是一本开源的 JavaScript 语言教程，全面介绍 ECMAScript 6 新引入的语法特性。
 
 [![cover](images/cover_thumbnail_3rd.jpg)](images/cover-3rd.jpg)
diff --git a/js/ditto.js b/js/ditto.js
index 6daa3b3ae..d694a063e 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -210,8 +210,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2020年8月15日
-  var deadline = new Date(2020, 7, 15);
+  // 2020年12月1日
+  var deadline = new Date(2020, 11, 1);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
diff --git a/tencent9908947001655912037.txt b/tencent9908947001655912037.txt
deleted file mode 100644
index c216cc792..000000000
--- a/tencent9908947001655912037.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-4096418148424150100
-

From 266199c2d2db82e0ae32134b71ab194485b43b9d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 19 Aug 2020 20:51:55 +0800
Subject: [PATCH 088/280] =?UTF-8?q?docs(module-loader):=20edit=20Node.js?=
 =?UTF-8?q?=20=E7=9A=84=E6=A8=A1=E5=9D=97=E5=8A=A0=E8=BD=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/async.md         |  2 +
 docs/module-loader.md | 93 ++++++++++++++++++++++++-------------------
 2 files changed, 53 insertions(+), 42 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index 53f1ccfba..d109a395b 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -833,6 +833,8 @@ setTimeout(() => console.log(outputPlusValue(100), 1000);
 
 这时，模块的加载会等待依赖模块（上例是`awaiting.js`）的异步操作完成，才执行后面的代码，有点像暂停在那里。所以，它总是会得到正确的`output`，不会因为加载时机的不同，而得到不一样的值。
 
+注意，顶层`await`只能用在 ES6 模块，不能用在 CommonJS 模块。这是因为 CommonJS 模块的`require()`是同步加载，如果有顶层`await`，就没法处理加载了。
+
 下面是顶层`await`的一些使用场景。
 
 ```javascript
diff --git a/docs/module-loader.md b/docs/module-loader.md
index 0bbfe3e74..ee37ca240 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -110,10 +110,11 @@ const isNotModuleScript = this !== undefined;
 
 讨论 Node.js 加载 ES6 模块之前，必须了解 ES6 模块与 CommonJS 模块完全不同。
 
-它们有两个重大差异。
+它们有三个重大差异。
 
 - CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
 - CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。
+- CommonJS 模块的`require()`是同步加载模块，ES6 模块的`import`命令是异步加载，有一个独立模块依赖的解析阶段。
 
 第二个差异是因为 CommonJS 加载的是一个对象（即`module.exports`属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。
 
@@ -271,11 +272,15 @@ $ babel-node main.js
 
 这就证明了`x.js`和`y.js`加载的都是`C`的同一个实例。
 
-## Node.js 加载
+## Node.js 的模块加载方法
 
 ### 概述
 
-Node.js 对 ES6 模块的处理比较麻烦，因为它有自己的 CommonJS 模块格式，与 ES6 模块格式是不兼容的。目前的解决方案是，将两者分开，ES6 模块和 CommonJS 采用各自的加载方案。从 v13.2 版本开始，Node.js 已经默认打开了 ES6 模块支持。
+JavaScript 现在有两种模块。一种是 ES6 模块，简称 ESM；另一种是 CommonJS 模块，简称 CJS。
+
+CommonJS 模块是 Node.js 专用的，与 ES6 模块不兼容。语法上面，两者最明显的差异是，CommonJS 模块使用`require()`和`module.exports`，ES6 模块使用`import`和`export`。
+
+它们采用不同的加载方案。从 Node.js v13.2 版本开始，Node.js 已经默认打开了 ES6 模块支持。
 
 Node.js 要求 ES6 模块采用`.mjs`后缀文件名。也就是说，只要脚本文件里面使用`import`或者`export`命令，那么就必须采用`.mjs`后缀名。Node.js 遇到`.mjs`文件，就认为它是 ES6 模块，默认启用严格模式，不必在每个模块文件顶部指定`"use strict"`。
 
@@ -300,7 +305,7 @@ $ node my-app.js
 
 注意，ES6 模块与 CommonJS 模块尽量不要混用。`require`命令不能加载`.mjs`文件，会报错，只有`import`命令才可以加载`.mjs`文件。反过来，`.mjs`文件里面也不能使用`require`命令，必须使用`import`。
 
-### main 字段
+### package.json 的 main 字段
 
 `package.json`文件有两个字段可以指定模块的入口文件：`main`和`exports`。比较简单的模块，可以只使用`main`字段，指定模块加载的入口文件。
 
@@ -327,7 +332,7 @@ import { something } from 'es-module-package';
 
 这时，如果用 CommonJS 模块的`require()`命令去加载`es-module-package`模块会报错，因为 CommonJS 模块不能处理`export`命令。
 
-### exports 字段
+### package.json 的 exports 字段
 
 `exports`字段的优先级高于`main`字段。它有多种用法。
 
@@ -427,7 +432,7 @@ import submodule from './node_modules/es-module-package/private-module.js';
 
 ```javascript
 {
-  "exports": {
+  "exports": {package.json 的
     "require": "./main.cjs",
     "default": "./main.js"
   }
@@ -447,40 +452,23 @@ import submodule from './node_modules/es-module-package/private-module.js';
 }
 ```
 
-### ES6 模块加载 CommonJS 模块
-
-目前，一个模块同时支持 ES6 和 CommonJS 两种格式的常见方法是，`package.json`文件的`main`字段指定 CommonJS 入口，给 Node.js 使用；`module`字段指定 ES6 模块入口，给打包工具使用，因为 Node.js 不认识`module`字段。
+### CommonJS 模块加载 ES6 模块
 
-有了上一节的条件加载以后，Node.js 本身就可以同时处理两种模块。
+CommonJS 的`require()`命令不能加载 ES6 模块，会报错，只能使用`import()`这个方法加载。
 
 ```javascript
-// ./node_modules/pkg/package.json
-{
-  "type": "module",
-  "main": "./index.cjs",
-  "exports": {
-    "require": "./index.cjs",
-    "default": "./wrapper.mjs"
-  }
-}
+(async () => {
+  await import('./my-app.mjs');
+})();
 ```
 
-上面代码指定了 CommonJS 入口文件`index.cjs`，下面是这个文件的代码。
-
-```javascript
-// ./node_modules/pkg/index.cjs
-exports.name = 'value';
-```
+上面代码可以在 CommonJS 模块中运行。
 
-然后，ES6 模块可以加载这个文件。
+`require()`不支持 ES6 模块的一个原因是，它是同步加载，而 ES6 模块内部可以使用顶层`await`命令，导致无法被同步加载。
 
-```javascript
-// ./node_modules/pkg/wrapper.mjs
-import cjsModule from './index.cjs';
-export const name = cjsModule.name;
-```
+### ES6 模块加载 CommonJS 模块
 
-注意，`import`命令加载 CommonJS 模块，只能整体加载，不能只加载单一的输出项。
+ES6 模块的`import`命令可以加载 CommonJS 模块，但是只能整体加载，不能只加载单一的输出项。
 
 ```javascript
 // 正确
@@ -490,6 +478,15 @@ import packageMain from 'commonjs-package';
 import { method } from 'commonjs-package';
 ```
 
+这是因为 ES6 模块需要支持静态代码分析，而 CommonJS 模块的输出接口是`module.exports`，无法被静态分析，所以只能整体加载。
+
+加载单一的输出项，可以写成下面这样。
+
+```bash
+import packageMain from 'commonjs-package';
+const { method } = packageMain;:w
+```
+
 还有一种变通的加载方法，就是使用 Node.js 内置的`module.createRequire()`方法。
 
 ```javascript
@@ -505,19 +502,33 @@ const cjs = require('./cjs.cjs');
 cjs === 'cjs'; // true
 ```
 
-上面代码中，ES6 模块通过`module.createRequire()`方法可以加载 CommonJS 模块
+上面代码中，ES6 模块通过`module.createRequire()`方法可以加载 CommonJS 模块。但是，这种写法等于将 ES6 和 CommonJS 混在一起了，所以不建议使用。
 
-### CommonJS 模块加载 ES6 模块
+## 同时支持两种格式的模块
+
+一个模块同时要支持 CommonJS 和 ES6 两种格式，也很容易。
 
-CommonJS 的`require`命令不能加载 ES6 模块，会报错，只能使用`import()`这个方法加载。
+如果原始模块是 ES6 格式，那么需要给出一个整体输出接口，比如`export default obj`，使得 CommonJS 可以用`import()`进行加载。
+
+如果原始模块是 CommonJS 格式，那么可以加一个包装层。
 
 ```javascript
-(async () => {
-  await import('./my-app.mjs');
-})();
+import cjsModule from '../index.js';
+export const foo = cjsModule.foo; 
 ```
 
-上面代码可以在 CommonJS 模块中运行。
+上面代码先整体输入 CommonJS 模块，然后再根据需要输出具名接口。最后，可以将它放在一个子目录，再放一个单独的`package.json`文件，指明`{ module: "type" }`。
+
+另一种做法是在`package.json`文件的`exports`字段，指明两种格式模块各自的加载入口。
+
+```bash
+"exports"：{ 
+    "require": "./index.js"，
+    "import": "./esm/wrapper.js" 
+}
+```
+
+上面代码指定`require()`和`import`，加载该模块会自动切换到不一样的入口文件。
 
 ### Node.js 的内置模块
 
@@ -558,11 +569,9 @@ import './foo.mjs?query=1'; // 加载 ./foo 传入参数 ?query=1
 
 目前，Node.js 的`import`命令只支持加载本地模块（`file:`协议）和`data:`协议，不支持加载远程模块。另外，脚本路径只支持相对路径，不支持绝对路径（即以`/`或`//`开头的路径）。
 
-最后，Node 的`import`命令是异步加载，这一点与浏览器的处理方法相同。
-
 ### 内部变量
 
-ES6 模块应该是通用的，同一个模块不用修改，就可以用在浏览器环境和服务器环境。为了达到这个目标，Node 规定 ES6 模块之中不能使用 CommonJS 模块的特有的一些内部变量。
+ES6 模块应该是通用的，同一个模块不用修改，就可以用在浏览器环境和服务器环境。为了达到这个目标，Node.js 规定 ES6 模块之中不能使用 CommonJS 模块的特有的一些内部变量。
 
 首先，就是`this`关键字。ES6 模块之中，顶层的`this`指向`undefined`；CommonJS 模块的顶层`this`指向当前模块，这是两者的一个重大差异。
 

From 09accf90d958db8f31dd930801fb509905f8b5b6 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 19 Aug 2020 21:03:52 +0800
Subject: [PATCH 089/280] docs(module-loader): fix typo

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index ee37ca240..dbf26114e 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -504,7 +504,7 @@ cjs === 'cjs'; // true
 
 上面代码中，ES6 模块通过`module.createRequire()`方法可以加载 CommonJS 模块。但是，这种写法等于将 ES6 和 CommonJS 混在一起了，所以不建议使用。
 
-## 同时支持两种格式的模块
+### 同时支持两种格式的模块
 
 一个模块同时要支持 CommonJS 和 ES6 两种格式，也很容易。
 

From 7b8c0632f62f3da9310f6fe13e8d6c96c72111e5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 20 Aug 2020 14:19:23 +0800
Subject: [PATCH 090/280] =?UTF-8?q?docs(module-loader):=20edit=20=E5=90=8C?=
 =?UTF-8?q?=E6=97=B6=E6=94=AF=E6=8C=81=E4=B8=A4=E7=A7=8D=E6=A0=BC=E5=BC=8F?=
 =?UTF-8?q?=E7=9A=84=E6=A8=A1=E5=9D=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/module-loader.md | 14 ++++++++------
 docs/reference.md     |  1 +
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index dbf26114e..d1a4fbaef 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -478,7 +478,7 @@ import packageMain from 'commonjs-package';
 import { method } from 'commonjs-package';
 ```
 
-这是因为 ES6 模块需要支持静态代码分析，而 CommonJS 模块的输出接口是`module.exports`，无法被静态分析，所以只能整体加载。
+这是因为 ES6 模块需要支持静态代码分析，而 CommonJS 模块的输出接口是`module.exports`，是一个对象，无法被静态分析，所以只能整体加载。
 
 加载单一的输出项，可以写成下面这样。
 
@@ -514,17 +514,19 @@ cjs === 'cjs'; // true
 
 ```javascript
 import cjsModule from '../index.js';
-export const foo = cjsModule.foo; 
+export const foo = cjsModule.foo;
 ```
 
-上面代码先整体输入 CommonJS 模块，然后再根据需要输出具名接口。最后，可以将它放在一个子目录，再放一个单独的`package.json`文件，指明`{ module: "type" }`。
+上面代码先整体输入 CommonJS 模块，然后再根据需要输出具名接口。
+
+你可以把这个文件的后缀名改为`.mjs`，或者将它放在一个子目录，再在这个子目录里面放一个单独的`package.json`文件，指明`{ module: "type" }`。
 
 另一种做法是在`package.json`文件的`exports`字段，指明两种格式模块各自的加载入口。
 
 ```bash
-"exports"：{ 
-    "require": "./index.js"，
-    "import": "./esm/wrapper.js" 
+"exports"：{
+  "require": "./index.js"，
+  "import": "./esm/wrapper.js"
 }
 ```
 
diff --git a/docs/reference.md b/docs/reference.md
index 1391174fd..909c21cc0 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -227,6 +227,7 @@
 - Axel Rauschmayer, [Making transpiled ES modules more spec-compliant](http://www.2ality.com/2017/01/babel-esm-spec-mode.html): ES6 模块编译成 CommonJS 模块的详细介绍
 - Axel Rauschmayer, [ES proposal: import() – dynamically importing ES modules](http://www.2ality.com/2017/01/import-operator.html): import() 的用法
 - Node EPS, [ES Module Interoperability](https://github.com/nodejs/node-eps/blob/master/002-es-modules.md): Node 对 ES6 模块的处理规格
+- Dan Fabulich, [Why CommonJS and ES Modules Can’t Get Along](https://redfin.engineering/node-modules-at-war-why-commonjs-and-es-modules-cant-get-along-9617135eeca1): Node.js 对 ES6 模块的处理
 
 ## 二进制数组
 

From a841acdca5fe465f5f6548d407bf5d7192bd276d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 20 Aug 2020 16:36:45 +0800
Subject: [PATCH 091/280] docs(module-loader): fix typo

---
 docs/module-loader.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index d1a4fbaef..8ec507962 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -482,7 +482,7 @@ import { method } from 'commonjs-package';
 
 加载单一的输出项，可以写成下面这样。
 
-```bash
+```javascript
 import packageMain from 'commonjs-package';
 const { method } = packageMain;:w
 ```
@@ -523,7 +523,7 @@ export const foo = cjsModule.foo;
 
 另一种做法是在`package.json`文件的`exports`字段，指明两种格式模块各自的加载入口。
 
-```bash
+```javascript
 "exports"：{
   "require": "./index.js"，
   "import": "./esm/wrapper.js"

From 2613635b774184b9661f3ead26e385769c078c01 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 20 Aug 2020 20:26:45 +0800
Subject: [PATCH 092/280] docs(module-loader): fix typo

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 8ec507962..2c0d046ee 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -484,7 +484,7 @@ import { method } from 'commonjs-package';
 
 ```javascript
 import packageMain from 'commonjs-package';
-const { method } = packageMain;:w
+const { method } = packageMain;
 ```
 
 还有一种变通的加载方法，就是使用 Node.js 内置的`module.createRequire()`方法。

From dfe3373143a539f9a9d7b5518868be4d19faa8a4 Mon Sep 17 00:00:00 2001
From: = <rick.liu@wehotelglobal.com>
Date: Fri, 21 Aug 2020 12:09:30 +0800
Subject: [PATCH 093/280] feat: add change theme

---
 css/app.css | 26 ++++++++++++++++++++++++++
 index.html  |  8 ++++++++
 js/ditto.js | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 67 insertions(+)

diff --git a/css/app.css b/css/app.css
index a2e2f3c51..7938b0963 100644
--- a/css/app.css
+++ b/css/app.css
@@ -340,6 +340,32 @@ input.searchButton {
     cursor: pointer;
 }
 
+#theme {
+    display: none;
+    position: fixed;
+
+    height: 17px;
+    width: 70px;
+    top: 70px;
+
+    margin-left: 930px;
+    margin-top: 0px;
+
+    color: #FFF;
+    line-height: 17px;
+    text-align: center;
+    font-size: 10px;
+
+
+    border-radius: 5px;
+    background-color: #AAA;
+}
+
+#theme:hover {
+    background-color: #444;
+    cursor: pointer;
+}
+
 #loading, #error {
     display: none;
     position: fixed;
diff --git a/index.html b/index.html
index 76253f553..7cf302be0 100644
--- a/index.html
+++ b/index.html
@@ -1,3 +1,10 @@
+<!--
+ * @Descripttion: 
+ * @Author: Rick Liu
+ * @Date: 2020-08-21 10:11:13
+ * @LastEditors: Rick Liu
+ * @LastEditTime: 2020-08-21 10:20:34
+-->
 <!DOCTYPE html>
 <html>
 <head>
@@ -22,6 +29,7 @@
   <!-- optional -->
   <div id="back_to_top">back to top</div>
   <div id="edit">edit</div>
+  <div id="theme">theme</div>
   <div id="loading">Loading ...</div>
   <div id="error">Oops! ... File not found!</div>
   <div id="flip"><div id="pageup">上一章</div><div id="pagedown">下一章</div></div>
diff --git a/js/ditto.js b/js/ditto.js
index d694a063e..c633dd449 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -4,6 +4,7 @@ var ditto = {
     sidebar_id: "#sidebar",
     edit_id: "#edit",
     back_to_top_id: "#back_to_top",
+    theme_id: "#theme",
     loading_id: "#loading",
     error_id: "#error",
 
@@ -11,6 +12,7 @@ var ditto = {
     sidebar: true,
     edit_button: true,
     back_to_top_button: true,
+    theme_button: true,
     save_progress: true, // 保存阅读进度
     search_bar: true,
 
@@ -58,6 +60,10 @@ function initialize() {
   if (ditto.edit_button) {
     init_edit_button();
   }
+    
+  if (ditto.theme_button) {
+        init_theme_button();
+  }
 
   // page router
   router();
@@ -133,12 +139,39 @@ function searchbar_listener(event) {
   */
 }
 
+function init_theme_button() {
+    $(ditto.theme_id).show();
+    // 默认主题
+    var currfontColor = localStorage.getItem('fontColor') || '#0d141e';
+    var currbgColor = localStorage.getItem('bgColor') || '#ffffff';
+    $('body').css({
+        color: currfontColor,
+        backgroundColor: currbgColor
+    })
+    $(ditto.theme_id).on('click', changeTheme);
+}
 
 function init_back_to_top_button() {
   $(ditto.back_to_top_id).show();
   $(ditto.back_to_top_id).on('click', goTop);
 }
 
+// 改变主题
+function changeTheme() {
+    var fontColor = localStorage.getItem('fontColor') || '#0d141e';
+    var bgColor = localStorage.getItem('bgColor') || '#ffffff';
+    var fontColors = ['#0d141e', '#020000', '#020702', '#d0d3d8'];
+    var bgColors = ['#ffffff', '#f6f0da', '#c0edc6', '#1f2022'];
+    var currIndex = bgColors.indexOf(bgColor);
+    var nextIndex = (currIndex + 1) >= bgColors.length ? 0 : currIndex + 1;
+    $('body').css({
+        color: fontColors[nextIndex],
+        backgroundColor: bgColors[nextIndex],
+    });
+    localStorage.setItem('fontColor', fontColors[nextIndex]);
+    localStorage.setItem('bgColor', bgColors[nextIndex]);
+}
+
 function goTop(e) {
   if(e) e.preventDefault();
   $('html, body').animate({

From e33a66895df25191222a424e6b9e3aae0649f172 Mon Sep 17 00:00:00 2001
From: = <rick.liu@wehotelglobal.com>
Date: Tue, 25 Aug 2020 09:45:02 +0800
Subject: [PATCH 094/280] upt: delete note

---
 index.html  | 7 -------
 js/ditto.js | 8 ++++----
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/index.html b/index.html
index 7cf302be0..0f88f503c 100644
--- a/index.html
+++ b/index.html
@@ -1,10 +1,3 @@
-<!--
- * @Descripttion: 
- * @Author: Rick Liu
- * @Date: 2020-08-21 10:11:13
- * @LastEditors: Rick Liu
- * @LastEditTime: 2020-08-21 10:20:34
--->
 <!DOCTYPE html>
 <html>
 <head>
diff --git a/js/ditto.js b/js/ditto.js
index c633dd449..3f8e1219e 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -142,11 +142,11 @@ function searchbar_listener(event) {
 function init_theme_button() {
     $(ditto.theme_id).show();
     // 默认主题
-    var currfontColor = localStorage.getItem('fontColor') || '#0d141e';
-    var currbgColor = localStorage.getItem('bgColor') || '#ffffff';
+    var currFontColor = localStorage.getItem('fontColor') || '#0d141e';
+    var currBgColor = localStorage.getItem('bgColor') || '#ffffff';
     $('body').css({
-        color: currfontColor,
-        backgroundColor: currbgColor
+        color: currFontColor,
+        backgroundColor: currBgColor
     })
     $(ditto.theme_id).on('click', changeTheme);
 }

From adb49644ad8016b06ee1f3b417b5d958f4dcf90d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 29 Aug 2020 11:24:38 +0800
Subject: [PATCH 095/280] docs(module-loader): fix typo

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 2c0d046ee..0d1e14c53 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -519,7 +519,7 @@ export const foo = cjsModule.foo;
 
 上面代码先整体输入 CommonJS 模块，然后再根据需要输出具名接口。
 
-你可以把这个文件的后缀名改为`.mjs`，或者将它放在一个子目录，再在这个子目录里面放一个单独的`package.json`文件，指明`{ module: "type" }`。
+你可以把这个文件的后缀名改为`.mjs`，或者将它放在一个子目录，再在这个子目录里面放一个单独的`package.json`文件，指明`{ type: "module" }`。
 
 另一种做法是在`package.json`文件的`exports`字段，指明两种格式模块各自的加载入口。
 

From 4e14b40bfcde1aae70edbed62d6c561073546a43 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 2 Sep 2020 00:53:24 +0800
Subject: [PATCH 096/280] docs(object): fix #1004

---
 docs/object.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/object.md b/docs/object.md
index 295608cee..5b8395bc7 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -885,7 +885,7 @@ const showSplashScreen = response.settings.showSplashScreen ?? true;
 const animationDuration = response.settings?.animationDuration ?? 300;
 ```
 
-上面代码中，`response.settings`如果是`null`或`undefined`，就会返回默认值300。
+上面代码中，如果`response.settings`是`null`或`undefined`，或者`response.settings.animationDuration`是`null`或`undefined`，就会返回默认值300。也就是说，这一行代码包括了两级属性的判断。
 
 这个运算符很适合判断函数参数是否赋值。
 

From 2f76a9f55f8f7d330ad1c01d43ab9ddee6b50cc9 Mon Sep 17 00:00:00 2001
From: hehe1111 <2908749709@qq.com>
Date: Wed, 9 Sep 2020 11:29:06 +0800
Subject: [PATCH 097/280] (docs): fix typo

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 0d1e14c53..8b0fe33ac 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -432,7 +432,7 @@ import submodule from './node_modules/es-module-package/private-module.js';
 
 ```javascript
 {
-  "exports": {package.json 的
+  "exports": {
     "require": "./main.cjs",
     "default": "./main.js"
   }

From 76fc255da46beb06e52c393a01544765c82c510d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 10 Sep 2020 20:53:57 +0800
Subject: [PATCH 098/280] docs(promise): edit Promise.reject()

---
 docs/promise.md | 30 ++++++++++++------------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 8723e68c3..baa4287fa 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -836,7 +836,7 @@ Promise.resolve('foo')
 new Promise(resolve => resolve('foo'))
 ```
 
-`Promise.resolve`方法的参数分成四种情况。
+`Promise.resolve()`方法的参数分成四种情况。
 
 **（1）参数是一个 Promise 实例**
 
@@ -854,7 +854,7 @@ let thenable = {
 };
 ```
 
-`Promise.resolve`方法会将这个对象转为 Promise 对象，然后就立即执行`thenable`对象的`then`方法。
+`Promise.resolve()`方法会将这个对象转为 Promise 对象，然后就立即执行`thenable`对象的`then()`方法。
 
 ```javascript
 let thenable = {
@@ -864,27 +864,27 @@ let thenable = {
 };
 
 let p1 = Promise.resolve(thenable);
-p1.then(function(value) {
+p1.then(function (value) {
   console.log(value);  // 42
 });
 ```
 
-上面代码中，`thenable`对象的`then`方法执行后，对象`p1`的状态就变为`resolved`，从而立即执行最后那个`then`方法指定的回调函数，输出 42。
+上面代码中，`thenable`对象的`then()`方法执行后，对象`p1`的状态就变为`resolved`，从而立即执行最后那个`then()`方法指定的回调函数，输出42。
 
-**（3）参数不是具有`then`方法的对象，或根本就不是对象**
+**（3）参数不是具有`then()`方法的对象，或根本就不是对象**
 
-如果参数是一个原始值，或者是一个不具有`then`方法的对象，则`Promise.resolve`方法返回一个新的 Promise 对象，状态为`resolved`。
+如果参数是一个原始值，或者是一个不具有`then()`方法的对象，则`Promise.resolve()`方法返回一个新的 Promise 对象，状态为`resolved`。
 
 ```javascript
 const p = Promise.resolve('Hello');
 
-p.then(function (s){
+p.then(function (s) {
   console.log(s)
 });
 // Hello
 ```
 
-上面代码生成一个新的 Promise 对象的实例`p`。由于字符串`Hello`不属于异步操作（判断方法是字符串对象不具有 then 方法），返回 Promise 实例的状态从一生成就是`resolved`，所以回调函数会立即执行。`Promise.resolve`方法的参数，会同时传给回调函数。
+上面代码生成一个新的 Promise 对象的实例`p`。由于字符串`Hello`不属于异步操作（判断方法是字符串对象不具有 then 方法），返回 Promise 实例的状态从一生成就是`resolved`，所以回调函数会立即执行。`Promise.resolve()`方法的参数，会同时传给回调函数。
 
 **（4）不带有任何参数**
 
@@ -939,23 +939,17 @@ p.then(null, function (s) {
 
 上面代码生成一个 Promise 对象的实例`p`，状态为`rejected`，回调函数会立即执行。
 
-注意，`Promise.reject()`方法的参数，会原封不动地作为`reject`的理由，变成后续方法的参数。这一点与`Promise.resolve`方法不一致。
+`Promise.reject()`方法的参数，会原封不动地作为`reject`的理由，变成后续方法的参数。
 
 ```javascript
-const thenable = {
-  then(resolve, reject) {
-    reject('出错了');
-  }
-};
-
-Promise.reject(thenable)
+Promise.reject('出错了')
 .catch(e => {
-  console.log(e === thenable)
+  console.log(e === '出错了')
 })
 // true
 ```
 
-上面代码中，`Promise.reject`方法的参数是一个`thenable`对象，执行以后，后面`catch`方法的参数不是`reject`抛出的“出错了”这个字符串，而是`thenable`对象。
+上面代码中，`Promise.reject()`方法的参数是一个字符串，后面`catch()`方法的参数`e`就是这个字符串。
 
 ## 应用
 

From d4952d6d796d606947cef12149bd383be401fa2d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 10 Sep 2020 21:24:39 +0800
Subject: [PATCH 099/280] docs(module-loader): fix typo

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 0d1e14c53..de3813a03 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -114,7 +114,7 @@ const isNotModuleScript = this !== undefined;
 
 - CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用。
 - CommonJS 模块是运行时加载，ES6 模块是编译时输出接口。
-- CommonJS 模块的`require()`是同步加载模块，ES6 模块的`import`命令是异步加载，有一个独立模块依赖的解析阶段。
+- CommonJS 模块的`require()`是同步加载模块，ES6 模块的`import`命令是异步加载，有一个独立的模块依赖的解析阶段。
 
 第二个差异是因为 CommonJS 加载的是一个对象（即`module.exports`属性），该对象只有在脚本运行完才会生成。而 ES6 模块不是对象，它的对外接口只是一种静态定义，在代码静态解析阶段就会生成。
 

From 6dc250f739200e5f8a4f542b1fc0e870c0c40f24 Mon Sep 17 00:00:00 2001
From: Careteen <15074806497@163.com>
Date: Sat, 12 Sep 2020 17:45:34 +0800
Subject: [PATCH 100/280] =?UTF-8?q?docs(decorator):=20=E4=BF=AE=E6=94=B9?=
 =?UTF-8?q?=E5=87=BD=E6=95=B0=E6=8F=90=E5=8D=87=E6=97=B6=E4=BB=A3=E7=A0=81?=
 =?UTF-8?q?=E5=AE=9E=E9=99=85=E6=89=A7=E8=A1=8C=E9=A1=BA=E5=BA=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/decorator.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index 262016f7d..cb8517a90 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -309,13 +309,13 @@ function foo() {
 上面的代码，意图是执行后`counter`等于 1，但是实际上结果是`counter`等于 0。因为函数提升，使得实际执行的代码是下面这样。
 
 ```javascript
+var counter;
+var add;
+
 @add
 function foo() {
 }
 
-var counter;
-var add;
-
 counter = 0;
 
 add = function () {

From c43225319371a27984822c4038404d5292507378 Mon Sep 17 00:00:00 2001
From: Jacty <jacty@users.noreply.github.com>
Date: Sun, 13 Sep 2020 01:11:40 +0800
Subject: [PATCH 101/280] =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BA=86=20async=20?=
 =?UTF-8?q?=E5=87=BD=E6=95=B0=E5=86=85=E9=83=A8=E6=8A=A5=E9=94=99=E4=BC=9A?=
 =?UTF-8?q?=E5=AF=BC=E8=87=B4=20Promise=20=E5=AF=B9=E8=B1=A1=E5=8F=98?=
 =?UTF-8?q?=E4=B8=BA`reject`=E7=8A=B6=E6=80=81=E7=9A=84=E4=BE=8B=E5=AD=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

原来的例子并不能很明显的表示打印的内容来自于 reject 的回调。
---
 docs/async.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index d109a395b..1bb0dd7e2 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -184,10 +184,10 @@ async function f() {
 }
 
 f().then(
-  v => console.log(v),
-  e => console.log(e)
+  v => console.log(‘resolve’,v),
+  e => console.log('reject',e)
 )
-// Error: 出错了
+//reject Error: 出错了
 ```
 
 ### Promise 对象的状态变化

From f81d202a097e85d31fdae5e898b30b42395dcc74 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 15 Sep 2020 11:11:57 +0800
Subject: [PATCH 102/280] docs(proxy): fix constrct()

---
 docs/proxy.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index e0dfb38da..3f5b84102 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -601,7 +601,7 @@ for (let b in oproxy2) {
 
 ### construct()
 
-`construct`方法用于拦截`new`命令，下面是拦截对象的写法。
+`construct()`方法用于拦截`new`命令，下面是拦截对象的写法。
 
 ```javascript
 var handler = {
@@ -611,11 +611,11 @@ var handler = {
 };
 ```
 
-`construct`方法可以接受三个参数。
+`construct()`方法可以接受三个参数。
 
-- `target`：目标对象
-- `args`：构造函数的参数对象
-- `newTarget`：创造实例对象时，`new`命令作用的构造函数（下面例子的`p`）
+- `target`：目标对象。
+- `args`：构造函数的参数数组。
+- `newTarget`：创造实例对象时，`new`命令作用的构造函数（下面例子的`p`）。
 
 ```javascript
 var p = new Proxy(function () {}, {
@@ -630,7 +630,7 @@ var p = new Proxy(function () {}, {
 // 10
 ```
 
-`construct`方法返回的必须是一个对象，否则会报错。
+`construct()`方法返回的必须是一个对象，否则会报错。
 
 ```javascript
 var p = new Proxy(function() {}, {

From 0f1acd319a870cb7380c5ca7a1b6bb6d24b322c4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 15 Sep 2020 11:36:32 +0800
Subject: [PATCH 103/280] docs(iterable): fix typo

---
 docs/iterator.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/iterator.md b/docs/iterator.md
index a39352c4a..68fba5009 100644
--- a/docs/iterator.md
+++ b/docs/iterator.md
@@ -441,7 +441,7 @@ str // "hi"
 
 ## Iterator 接口与 Generator 函数
 
-`Symbol.iterator`方法的最简单实现，还是使用下一章要介绍的 Generator 函数。
+`Symbol.iterator()`方法的最简单实现，还是使用下一章要介绍的 Generator 函数。
 
 ```javascript
 let myIterable = {
@@ -450,7 +450,7 @@ let myIterable = {
     yield 2;
     yield 3;
   }
-}
+};
 [...myIterable] // [1, 2, 3]
 
 // 或者采用下面的简洁写法
@@ -469,13 +469,13 @@ for (let x of obj) {
 // "world"
 ```
 
-上面代码中，`Symbol.iterator`方法几乎不用部署任何代码，只要用 yield 命令给出每一步的返回值即可。
+上面代码中，`Symbol.iterator()`方法几乎不用部署任何代码，只要用 yield 命令给出每一步的返回值即可。
 
 ## 遍历器对象的 return()，throw()
 
-遍历器对象除了具有`next`方法，还可以具有`return`方法和`throw`方法。如果你自己写遍历器对象生成函数，那么`next`方法是必须部署的，`return`方法和`throw`方法是否部署是可选的。
+遍历器对象除了具有`next()`方法，还可以具有`return()`方法和`throw()`方法。如果你自己写遍历器对象生成函数，那么`next()`方法是必须部署的，`return()`方法和`throw()`方法是否部署是可选的。
 
-`return`方法的使用场合是，如果`for...of`循环提前退出（通常是因为出错，或者有`break`语句），就会调用`return`方法。如果一个对象在完成遍历前，需要清理或释放资源，就可以部署`return`方法。
+`return()`方法的使用场合是，如果`for...of`循环提前退出（通常是因为出错，或者有`break`语句），就会调用`return()`方法。如果一个对象在完成遍历前，需要清理或释放资源，就可以部署`return()`方法。
 
 ```javascript
 function readLinesSync(file) {
@@ -495,7 +495,7 @@ function readLinesSync(file) {
 }
 ```
 
-上面代码中，函数`readLinesSync`接受一个文件对象作为参数，返回一个遍历器对象，其中除了`next`方法，还部署了`return`方法。下面的两种情况，都会触发执行`return`方法。
+上面代码中，函数`readLinesSync`接受一个文件对象作为参数，返回一个遍历器对象，其中除了`next()`方法，还部署了`return()`方法。下面的两种情况，都会触发执行`return()`方法。
 
 ```javascript
 // 情况一
@@ -511,11 +511,11 @@ for (let line of readLinesSync(fileName)) {
 }
 ```
 
-上面代码中，情况一输出文件的第一行以后，就会执行`return`方法，关闭这个文件；情况二会在执行`return`方法关闭文件之后，再抛出错误。
+上面代码中，情况一输出文件的第一行以后，就会执行`return()`方法，关闭这个文件；情况二会在执行`return()`方法关闭文件之后，再抛出错误。
 
-注意，`return`方法必须返回一个对象，这是 Generator 规格决定的。
+注意，`return()`方法必须返回一个对象，这是 Generator 语法决定的。
 
-`throw`方法主要是配合 Generator 函数使用，一般的遍历器对象用不到这个方法。请参阅《Generator 函数》一章。
+`throw()`方法主要是配合 Generator 函数使用，一般的遍历器对象用不到这个方法。请参阅《Generator 函数》一章。
 
 ## for...of 循环
 

From 10defdbcacf524ec938969ad341670391d677a9d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 15 Sep 2020 20:23:25 +0800
Subject: [PATCH 104/280] docs(async): fix typo

---
 docs/async.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index 1bb0dd7e2..bdfd6e41f 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -184,8 +184,8 @@ async function f() {
 }
 
 f().then(
-  v => console.log(‘resolve’,v),
-  e => console.log('reject',e)
+  v => console.log('resolve', v),
+  e => console.log('reject', e)
 )
 //reject Error: 出错了
 ```

From 9f1f925fc1fd48a85b8bc5c9211229fbfe6a209d Mon Sep 17 00:00:00 2001
From: chua <chen_hua89@163.com>
Date: Tue, 15 Sep 2020 21:02:41 +0800
Subject: [PATCH 105/280] Update proxy.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

添加handler.construct中对于this的描述
---
 docs/proxy.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/docs/proxy.md b/docs/proxy.md
index 3f5b84102..5e76b9e2f 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -643,6 +643,18 @@ new p() // 报错
 // Uncaught TypeError: 'construct' on proxy: trap returned non-object ('1')
 ```
 
+`construct()`方法中的`this`指向的是handler  
+```
+var handler = {
+  construct: function(target, args) {
+    console.log(this ===  handler);
+    return new target(...args);
+  }
+}
+var p = new Proxy(function() {}, handler);
+new p() // true
+```
+
 ### deleteProperty()
 
 `deleteProperty`方法用于拦截`delete`操作，如果这个方法抛出错误或者返回`false`，当前属性就无法被`delete`命令删除。

From 48e318b12be1531b53de3306b5a669f0101cc3af Mon Sep 17 00:00:00 2001
From: chua <chen_hua89@163.com>
Date: Tue, 15 Sep 2020 21:11:55 +0800
Subject: [PATCH 106/280] Update proxy.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

this问题中添加对handler.construct钩子函数中this的描述
---
 docs/proxy.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/proxy.md b/docs/proxy.md
index 5e76b9e2f..3b36fe51b 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -1053,6 +1053,8 @@ proxy.foo // TypeError: Revoked
 
 ## this 问题
 
+正常情况下，Proxy代理的钩子函数中的`this`指向的是Proxy代理实例（construct钩子函数除外，该钩子函数中`this`指向的是handler)  
+  
 虽然 Proxy 可以代理针对目标对象的访问，但它不是目标对象的透明代理，即不做任何拦截的情况下，也无法保证与目标对象的行为一致。主要原因就是在 Proxy 代理的情况下，目标对象内部的`this`关键字会指向 Proxy 代理。
 
 ```javascript

From 746a9188b61dbdcb8c36286b1db800276b83f137 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 16 Sep 2020 09:13:54 +0800
Subject: [PATCH 107/280] docs(proxy): edit construct()

---
 docs/proxy.md | 47 ++++++++++++++++++++++++++++++++---------------
 1 file changed, 32 insertions(+), 15 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 3b36fe51b..e5b1823cb 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -517,11 +517,11 @@ Reflect.apply(proxy, null, [9, 10]) // 38
 
 ### has()
 
-`has`方法用来拦截`HasProperty`操作，即判断对象是否具有某个属性时，这个方法会生效。典型的操作就是`in`运算符。
+`has()`方法用来拦截`HasProperty`操作，即判断对象是否具有某个属性时，这个方法会生效。典型的操作就是`in`运算符。
 
-`has`方法可以接受两个参数，分别是目标对象、需查询的属性名。
+`has()`方法可以接受两个参数，分别是目标对象、需查询的属性名。
 
-下面的例子使用`has`方法隐藏某些属性，不被`in`运算符发现。
+下面的例子使用`has()`方法隐藏某些属性，不被`in`运算符发现。
 
 ```javascript
 var handler = {
@@ -537,9 +537,9 @@ var proxy = new Proxy(target, handler);
 '_prop' in proxy // false
 ```
 
-上面代码中，如果原对象的属性名的第一个字符是下划线，`proxy.has`就会返回`false`，从而不会被`in`运算符发现。
+上面代码中，如果原对象的属性名的第一个字符是下划线，`proxy.has()`就会返回`false`，从而不会被`in`运算符发现。
 
-如果原对象不可配置或者禁止扩展，这时`has`拦截会报错。
+如果原对象不可配置或者禁止扩展，这时`has()`拦截会报错。
 
 ```javascript
 var obj = { a: 10 };
@@ -554,11 +554,11 @@ var p = new Proxy(obj, {
 'a' in p // TypeError is thrown
 ```
 
-上面代码中，`obj`对象禁止扩展，结果使用`has`拦截就会报错。也就是说，如果某个属性不可配置（或者目标对象不可扩展），则`has`方法就不得“隐藏”（即返回`false`）目标对象的该属性。
+上面代码中，`obj`对象禁止扩展，结果使用`has`拦截就会报错。也就是说，如果某个属性不可配置（或者目标对象不可扩展），则`has()`方法就不得“隐藏”（即返回`false`）目标对象的该属性。
 
-值得注意的是，`has`方法拦截的是`HasProperty`操作，而不是`HasOwnProperty`操作，即`has`方法不判断一个属性是对象自身的属性，还是继承的属性。
+值得注意的是，`has()`方法拦截的是`HasProperty`操作，而不是`HasOwnProperty`操作，即`has()`方法不判断一个属性是对象自身的属性，还是继承的属性。
 
-另外，虽然`for...in`循环也用到了`in`运算符，但是`has`拦截对`for...in`循环不生效。
+另外，虽然`for...in`循环也用到了`in`运算符，但是`has()`拦截对`for...in`循环不生效。
 
 ```javascript
 let stu1 = {name: '张三', score: 59};
@@ -597,14 +597,14 @@ for (let b in oproxy2) {
 // 99
 ```
 
-上面代码中，`has`拦截只对`in`运算符生效，对`for...in`循环不生效，导致不符合要求的属性没有被`for...in`循环所排除。
+上面代码中，`has()`拦截只对`in`运算符生效，对`for...in`循环不生效，导致不符合要求的属性没有被`for...in`循环所排除。
 
 ### construct()
 
 `construct()`方法用于拦截`new`命令，下面是拦截对象的写法。
 
 ```javascript
-var handler = {
+const handler = {
   construct (target, args, newTarget) {
     return new target(...args);
   }
@@ -618,7 +618,7 @@ var handler = {
 - `newTarget`：创造实例对象时，`new`命令作用的构造函数（下面例子的`p`）。
 
 ```javascript
-var p = new Proxy(function () {}, {
+const p = new Proxy(function () {}, {
   construct: function(target, args) {
     console.log('called: ' + args.join(', '));
     return { value: args[0] * 10 };
@@ -633,7 +633,7 @@ var p = new Proxy(function () {}, {
 `construct()`方法返回的必须是一个对象，否则会报错。
 
 ```javascript
-var p = new Proxy(function() {}, {
+const p = new Proxy(function() {}, {
   construct: function(target, argumentsList) {
     return 1;
   }
@@ -643,15 +643,32 @@ new p() // 报错
 // Uncaught TypeError: 'construct' on proxy: trap returned non-object ('1')
 ```
 
-`construct()`方法中的`this`指向的是handler  
+另外，由于`construct()`拦截的是构造函数，所以它的目标对象必须是函数，否则就会报错。
+
+```javascript
+const p = new Proxy({}, {
+  construct: function(target, argumentsList) {
+    return {};
+  }
+});
+
+new p() // 报错
+// Uncaught TypeError: p is not a constructor
 ```
-var handler = {
+
+上面例子中，拦截的目标对象不是一个函数，而是一个对象（`new Proxy()`的第一个参数），导致报错。
+
+注意，`construct()`方法中的`this`指向的是`handler`，而不是实例对象。
+
+```javascript
+const handler = {
   construct: function(target, args) {
     console.log(this ===  handler);
     return new target(...args);
   }
 }
-var p = new Proxy(function() {}, handler);
+
+let p = new Proxy(function () {}, handler);
 new p() // true
 ```
 

From 6ff7cb8a2f61d31d86159e2d87256fab33ea59af Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 17 Sep 2020 14:18:50 +0800
Subject: [PATCH 108/280] docs(class): fix private property

---
 docs/class.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index 5d8b2e9e7..70917bcdd 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -850,7 +850,7 @@ class Foo {
     this.#b = b;
   }
   #sum() {
-    return #a + #b;
+    return this.#a + this.#b;
   }
   printSum() {
     console.log(this.#sum());

From c2d1792c62ff7e805a9705d341629511338fa24b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 23 Sep 2020 01:15:20 +0800
Subject: [PATCH 109/280] docs(set-map): edit WeakMap

---
 docs/set-map.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/set-map.md b/docs/set-map.md
index a934cc3a4..b2e14d13e 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -1087,6 +1087,8 @@ undefined
 
 上面代码中，只要外部的引用消失，WeakMap 内部的引用，就会自动被垃圾回收清除。由此可见，有了 WeakMap 的帮助，解决内存泄漏就会简单很多。
 
+Chrome 浏览器的 Dev Tools 的 Memory 面板，有一个垃圾桶的按钮，可以强制垃圾回收（garbage collect）。这个按钮也能用来观察 WeakMap 里面的引用是否消失。
+
 ### WeakMap 的用途
 
 前文说过，WeakMap 应用的典型场合就是 DOM 节点作为键名。下面是一个例子。
@@ -1137,3 +1139,4 @@ c.dec()
 ```
 
 上面代码中，`Countdown`类的两个内部属性`_counter`和`_action`，是实例的弱引用，所以如果删除实例，它们也就随之消失，不会造成内存泄漏。
+

From 4bd4d771518c81b839f4a666514d99cff23ff4b7 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 2 Oct 2020 18:38:14 +0800
Subject: [PATCH 110/280] docs(function/arrow fucntion): edit #150

---
 docs/function.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/function.md b/docs/function.md
index 7dbf10798..fe6b10750 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -731,7 +731,7 @@ foo.call({ id: 42 });
 // id: 42
 ```
 
-上面代码中，`setTimeout`的参数是一个箭头函数，这个箭头函数的定义生效是在`foo`函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时`this`应该指向全局对象`window`，这时应该输出`21`。但是，箭头函数导致`this`总是指向函数定义生效时所在的对象（本例是`{id: 42}`），所以输出的是`42`。
+上面代码中，`setTimeout()`的参数是一个箭头函数，这个箭头函数的定义生效是在`foo`函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时`this`应该指向全局对象`window`，这时应该输出`21`。但是，箭头函数导致`this`总是指向函数定义生效时所在的对象（本例是`{id: 42}`），所以打印出来的是`42`。
 
 箭头函数可以让`setTimeout`里面的`this`，绑定定义时所在的作用域，而不是指向运行时所在的作用域。下面是另一个例子。
 

From 2e082a334320716c81cb9e24cf4cd634e133d088 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 23 Oct 2020 22:20:10 +0800
Subject: [PATCH 111/280] docs(module): fix module suffix

---
 docs/module.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/module.md b/docs/module.md
index dac58ff69..040cbb2f5 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -223,10 +223,10 @@ a.foo = 'hello'; // 合法操作
 
 上面代码中，`a`的属性可以成功改写，并且其他模块也可以读到改写后的值。不过，这种写法很难查错，建议凡是输入的变量，都当作完全只读，不要轻易改变它的属性。
 
-`import`后面的`from`指定模块文件的位置，可以是相对路径，也可以是绝对路径，`.js`后缀可以省略。如果只是模块名，不带有路径，那么必须有配置文件，告诉 JavaScript 引擎该模块的位置。
+`import`后面的`from`指定模块文件的位置，可以是相对路径，也可以是绝对路径。如果不带有路径，只是一个模块名，那么必须有配置文件，告诉 JavaScript 引擎该模块的位置。
 
 ```javascript
-import {myMethod} from 'util';
+import { myMethod } from 'util';
 ```
 
 上面代码中，`util`是模块文件名，由于不带有路径，必须通过配置，告诉引擎怎么取到这个模块。

From 8f852c0425814d80d6a6108632ef3ce79cda1b36 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 24 Oct 2020 13:40:48 +0800
Subject: [PATCH 112/280] docs(Atomics): Atomics.wake() rename to
 Atomics.notify()

---
 docs/arraybuffer.md | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/docs/arraybuffer.md b/docs/arraybuffer.md
index a2e455104..449476596 100644
--- a/docs/arraybuffer.md
+++ b/docs/arraybuffer.md
@@ -1215,9 +1215,11 @@ self.addEventListener('message', (event) => {
 
 上面代码将共享内存的偶数位置的值改成`1`，奇数位置的值改成`2`。
 
-**（3）Atomics.wait()，Atomics.wake()**
+**（3）Atomics.wait()，Atomics.notify()**
 
-使用`while`循环等待主线程的通知，不是很高效，如果用在主线程，就会造成卡顿，`Atomics`对象提供了`wait()`和`wake()`两个方法用于等待通知。这两个方法相当于锁内存，即在一个线程进行操作时，让其他线程休眠（建立锁），等到操作结束，再唤醒那些休眠的线程（解除锁）。
+使用`while`循环等待主线程的通知，不是很高效，如果用在主线程，就会造成卡顿，`Atomics`对象提供了`wait()`和`notify()`两个方法用于等待通知。这两个方法相当于锁内存，即在一个线程进行操作时，让其他线程休眠（建立锁），等到操作结束，再唤醒那些休眠的线程（解除锁）。
+
+`Atomics.notify()`方法以前叫做`Atomics.wake()`，后来进行了改名。
 
 ```javascript
 // Worker 线程
@@ -1240,10 +1242,10 @@ const newArrayValue = 100;
 Atomics.store(sharedArray, 0, newArrayValue);
 const arrayIndex = 0;
 const queuePos = 1;
-Atomics.wake(sharedArray, arrayIndex, queuePos);
+Atomics.notify(sharedArray, arrayIndex, queuePos);
 ```
 
-上面代码中，`sharedArray`的`0`号位置改为`100`，然后就执行`Atomics.wake()`方法，唤醒在`sharedArray`的`0`号位置休眠队列里的一个线程。
+上面代码中，`sharedArray`的`0`号位置改为`100`，然后就执行`Atomics.notify()`方法，唤醒在`sharedArray`的`0`号位置休眠队列里的一个线程。
 
 `Atomics.wait()`方法的使用格式如下。
 
@@ -1256,14 +1258,14 @@ Atomics.wait(sharedArray, index, value, timeout)
 - sharedArray：共享内存的视图数组。
 - index：视图数据的位置（从0开始）。
 - value：该位置的预期值。一旦实际值等于预期值，就进入休眠。
-- timeout：整数，表示过了这个时间以后，就自动唤醒，单位毫秒。该参数可选，默认值是`Infinity`，即无限期的休眠，只有通过`Atomics.wake()`方法才能唤醒。
+- timeout：整数，表示过了这个时间以后，就自动唤醒，单位毫秒。该参数可选，默认值是`Infinity`，即无限期的休眠，只有通过`Atomics.notify()`方法才能唤醒。
 
-`Atomics.wait()`的返回值是一个字符串，共有三种可能的值。如果`sharedArray[index]`不等于`value`，就返回字符串`not-equal`，否则就进入休眠。如果`Atomics.wake()`方法唤醒，就返回字符串`ok`；如果因为超时唤醒，就返回字符串`timed-out`。
+`Atomics.wait()`的返回值是一个字符串，共有三种可能的值。如果`sharedArray[index]`不等于`value`，就返回字符串`not-equal`，否则就进入休眠。如果`Atomics.notify()`方法唤醒，就返回字符串`ok`；如果因为超时唤醒，就返回字符串`timed-out`。
 
-`Atomics.wake()`方法的使用格式如下。
+`Atomics.notify()`方法的使用格式如下。
 
 ```javascript
-Atomics.wake(sharedArray, index, count)
+Atomics.notify(sharedArray, index, count)
 ```
 
 它的三个参数含义如下。
@@ -1272,7 +1274,7 @@ Atomics.wake(sharedArray, index, count)
 - index：视图数据的位置（从0开始）。
 - count：需要唤醒的 Worker 线程的数量，默认为`Infinity`。
 
-`Atomics.wake()`方法一旦唤醒休眠的 Worker 线程，就会让它继续往下运行。
+`Atomics.notify()`方法一旦唤醒休眠的 Worker 线程，就会让它继续往下运行。
 
 请看一个例子。
 
@@ -1280,16 +1282,16 @@ Atomics.wake(sharedArray, index, count)
 // 主线程
 console.log(ia[37]);  // 163
 Atomics.store(ia, 37, 123456);
-Atomics.wake(ia, 37, 1);
+Atomics.notify(ia, 37, 1);
 
 // Worker 线程
 Atomics.wait(ia, 37, 163);
 console.log(ia[37]);  // 123456
 ```
 
-上面代码中，视图数组`ia`的第 37 号位置，原来的值是`163`。Worker 线程使用`Atomics.wait()`方法，指定只要`ia[37]`等于`163`，就进入休眠状态。主线程使用`Atomics.store()`方法，将`123456`写入`ia[37]`，然后使用`Atomics.wake()`方法唤醒 Worker 线程。
+上面代码中，视图数组`ia`的第 37 号位置，原来的值是`163`。Worker 线程使用`Atomics.wait()`方法，指定只要`ia[37]`等于`163`，就进入休眠状态。主线程使用`Atomics.store()`方法，将`123456`写入`ia[37]`，然后使用`Atomics.notify()`方法唤醒 Worker 线程。
 
-另外，基于`wait`和`wake`这两个方法的锁内存实现，可以看 Lars T Hansen 的 [js-lock-and-condition](https://github.com/lars-t-hansen/js-lock-and-condition) 这个库。
+另外，基于`wait`和`notify`这两个方法的锁内存实现，可以看 Lars T Hansen 的 [js-lock-and-condition](https://github.com/lars-t-hansen/js-lock-and-condition) 这个库。
 
 注意，浏览器的主线程不宜设置休眠，这会导致用户失去响应。而且，主线程实际上会拒绝进入休眠。
 
@@ -1335,3 +1337,4 @@ Atomics.xor(sharedArray, index, value)
 - `Atomics.isLockFree(size)`：返回一个布尔值，表示`Atomics`对象是否可以处理某个`size`的内存锁定。如果返回`false`，应用程序就需要自己来实现锁定。
 
 `Atomics.compareExchange`的一个用途是，从 SharedArrayBuffer 读取一个值，然后对该值进行某个操作，操作结束以后，检查一下 SharedArrayBuffer 里面原来那个值是否发生变化（即被其他线程改写过）。如果没有改写过，就将它写回原来的位置，否则读取新的值，再重头进行一次操作。
+

From d1f96feee0279ee4c1fe83a62bd6c17b3175fed0 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 24 Oct 2020 19:30:43 +0800
Subject: [PATCH 113/280] docs(proxy): fix this #1014

---
 docs/proxy.md | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index e5b1823cb..e705fba45 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -663,7 +663,7 @@ new p() // 报错
 ```javascript
 const handler = {
   construct: function(target, args) {
-    console.log(this ===  handler);
+    console.log(this === handler);
     return new target(...args);
   }
 }
@@ -1070,8 +1070,6 @@ proxy.foo // TypeError: Revoked
 
 ## this 问题
 
-正常情况下，Proxy代理的钩子函数中的`this`指向的是Proxy代理实例（construct钩子函数除外，该钩子函数中`this`指向的是handler)  
-  
 虽然 Proxy 可以代理针对目标对象的访问，但它不是目标对象的透明代理，即不做任何拦截的情况下，也无法保证与目标对象的行为一致。主要原因就是在 Proxy 代理的情况下，目标对象内部的`this`关键字会指向 Proxy 代理。
 
 ```javascript
@@ -1088,7 +1086,7 @@ target.m() // false
 proxy.m()  // true
 ```
 
-上面代码中，一旦`proxy`代理`target.m`，后者内部的`this`就是指向`proxy`，而不是`target`。
+上面代码中，一旦`proxy`代理`target`，`target.m()`内部的`this`就是指向`proxy`，而不是`target`。
 
 下面是一个例子，由于`this`指向的变化，导致 Proxy 无法代理目标对象。
 
@@ -1141,6 +1139,33 @@ const proxy = new Proxy(target, handler);
 proxy.getDate() // 1
 ```
 
+另外，Proxy 拦截函数内部的`this`，指向的是`handler`对象。
+
+```javascript
+const handler = {
+  get: function (target, key, receiver) {
+    console.log(this === handler);
+    return 'Hello, ' + key;
+  },
+  set: function (target, key, value) {
+    console.log(this === handler);
+    target[key] = value;
+    return true;
+  }
+};
+
+const proxy = new Proxy({}, handler);
+
+proxy.foo
+// true
+// Hello, foo
+
+proxy.foo = 1
+// true
+```
+
+上面例子中，`get()`和`set()`拦截函数内部的`this`，指向的都是`handler`对象。
+
 ## 实例：Web 服务的客户端
 
 Proxy 对象可以拦截目标对象的任意属性，这使得它很合适用来写 Web 服务的客户端。

From 356b0db1b0095a4e80b516a05cdf69f8bbdc0cad Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 25 Oct 2020 12:33:16 +0800
Subject: [PATCH 114/280] docs(string): add replaceAll()

---
 docs/string-methods.md | 85 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 99233f310..8b1a5d508 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -329,3 +329,88 @@ s.trimEnd() // "  abc"
 
 `matchAll()`方法返回一个正则表达式在当前字符串的所有匹配，详见《正则的扩展》的一章。
 
+## 实例方法：replaceAll()
+
+历史上，字符串的实例方法`replace()`只能替换第一个匹配。
+
+```javascript
+'aabbcc'.replace('b', '_')
+// 'aa_bcc'
+```
+
+上面例子中，`replace()`只将第一个`b`替换成了下划线。
+
+如果要替换所有的匹配，不得不使用正则表达式的`g`修饰符。
+
+```javascript
+'aabbcc'.replace(/b/g, '_')
+// 'aa__cc'
+```
+
+正则表达式毕竟不是那么方便和直观，[ES2021](https://github.com/tc39/proposal-string-replaceall) 引入了`replaceAll()`方法，可以一次性替换所有匹配。
+
+```javascript
+'aabbcc'.replaceAll('b', '_')
+// 'aa__cc'
+```
+
+它的用法与`replace()`相同，返回一个新字符串，不会改变原字符串。
+
+```javascript
+String.prototype.replaceAll(searchValue, replacement)
+```
+
+上面代码中，`searchValue`是搜索模式，可以是一个字符串，也可以是一个全局的正则表达式（带有`g`修饰符）。
+
+如果`searchValue`是一个不带有`g`修饰符的正则表达式，`replaceAll()`会报错。这一点跟`replace()`不同。
+
+```javascript
+// 不报错
+'aabbcc'.replace(/b/, '_')
+
+// 报错
+'aabbcc'.replaceAll(/b/, '_')
+```
+
+上面例子中，`/b/`不带有`g`修饰符，会导致`replaceAll()`报错。
+
+`replaceAll()`的第二个参数`replacement`是一个字符串，表示替换的文本，其中可以使用一些特殊字符串。
+
+- `$&`：匹配的子字符串。
+- `` `$` ``：匹配结果前面的文本。
+- `$'`：匹配结果后面的文本。
+- `$n`：匹配成功的第`n`组内容，`n`是从1开始的自然数。
+- `$$`：指代美元符号`$`。
+
+```javascript
+'abc'.replaceAll('b', '$$')
+// 'a$c'
+```
+
+上面例子中，`$$`表示替换的文本是单个美元符号`$`。
+
+`replaceAll()`的第二个参数`replacement`除了为字符串，也可以是一个函数，该函数的返回值将替换掉第一个参数`searchValue`匹配的文本。
+
+```javascript
+'aabbcc'.replaceAll('b', () => '_')
+// 'aa__cc'
+```
+
+上面例子中，`replaceAll()`的第二个参数是一个函数，该函数的返回值会替换掉所有`b`的匹配。
+
+这个替换函数可以接受多个参数。第一个参数是捕捉到的匹配内容，第二个参数捕捉到是组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置，最后一个参数是原字符串。
+
+```javascript
+const str = '123abc456';
+const regex = /(\d+)([a-z]+)(\d+)/g;
+
+function replacer(match, p1, p2, p3, offset, string) {
+  return [p1, p2, p3].join(' - ');
+}
+
+str.replaceAll(regex, replacer)
+// 123 - abc - 456
+```
+
+上面例子中，正则表达式有三个组匹配，所以`replacer()`函数的第一个参数`match`是捕捉到的匹配内容（即字符串`123abc456`），后面三个参数`p1`、`p2`、`p3`则依次为三个组匹配。
+

From 492fb25238677ab3e69e376f70dbe3604814fb35 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 27 Oct 2020 22:56:35 +0800
Subject: [PATCH 115/280] docs(string-methods): add replaceAll()

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 3f8e1219e..e3e69c923 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2020年12月1日
-  var deadline = new Date(2020, 11, 1);
+  // 2020年11月1日
+  var deadline = new Date(2020, 10, 1);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From 2ed3a6ba3b455045ff84d350f8a34e9790658a7d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 1 Nov 2020 00:03:02 +0800
Subject: [PATCH 116/280] docs(promise): edit Promise.any()

---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index baa4287fa..f6717616b 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -758,7 +758,7 @@ try {
 
 ## Promise.any()
 
-`Promise.any()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只要参数实例有一个变成`fulfilled`状态，包装实例就会变成`fulfilled`状态；如果所有参数实例都变成`rejected`状态，包装实例就会变成`rejected`状态。该方法目前是一个第三阶段的[提案](https://github.com/tc39/proposal-promise-any) 。
+ES2021 引入了[`Promise.any()`方法](https://github.com/tc39/proposal-promise-any)。该方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例返回。只要参数实例有一个变成`fulfilled`状态，包装实例就会变成`fulfilled`状态；如果所有参数实例都变成`rejected`状态，包装实例就会变成`rejected`状态。
 
 `Promise.any()`跟`Promise.race()`方法很像，只有一点不同，就是不会因为某个 Promise 变成`rejected`状态而结束。
 

From 04dddb2d7c34cbcd90a0bd1f027835bd744bf827 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 1 Nov 2020 01:33:11 +0800
Subject: [PATCH 117/280] docs: fix wangdoc-es6 #4

---
 docs/arraybuffer.md    | 8 ++++----
 docs/async-iterator.md | 2 +-
 docs/async.md          | 2 +-
 docs/class.md          | 6 +++---
 docs/module.md         | 2 +-
 docs/style.md          | 5 +++--
 6 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/docs/arraybuffer.md b/docs/arraybuffer.md
index 449476596..4f25ff179 100644
--- a/docs/arraybuffer.md
+++ b/docs/arraybuffer.md
@@ -1141,14 +1141,14 @@ Atomics.add(ia, 112, 1); // 正确
 
 `store()`方法用来向共享内存写入数据，`load()`方法用来从共享内存读出数据。比起直接的读写操作，它们的好处是保证了读写操作的原子性。
 
-此外，它们还用来解决一个问题：多个线程使用共享内存的某个位置作为开关（flag），一旦该位置的值变了，就执行特定操作。这时，必须保证该位置的赋值操作，一定是在它前面的所有可能会改写内存的操作结束后执行；而该位置的取值操作，一定是在它后面所有可能会读取该位置的操作开始之前执行。`store`方法和`load`方法就能做到这一点，编译器不会为了优化，而打乱机器指令的执行顺序。
+此外，它们还用来解决一个问题：多个线程使用共享内存的某个位置作为开关（flag），一旦该位置的值变了，就执行特定操作。这时，必须保证该位置的赋值操作，一定是在它前面的所有可能会改写内存的操作结束后执行；而该位置的取值操作，一定是在它后面所有可能会读取该位置的操作开始之前执行。`store()`方法和`load()`方法就能做到这一点，编译器不会为了优化，而打乱机器指令的执行顺序。
 
 ```javascript
-Atomics.load(array, index)
-Atomics.store(array, index, value)
+Atomics.load(typedArray, index)
+Atomics.store(typedArray, index, value)
 ```
 
-`store`方法接受三个参数：SharedBuffer 的视图、位置索引和值，返回`sharedArray[index]`的值。`load`方法只接受两个参数：SharedBuffer 的视图和位置索引，也是返回`sharedArray[index]`的值。
+`store`方法接受三个参数：SharedArrayBuffer 的视图、位置索引和值，返回`sharedArrayBuffer[index]`的值。`load`方法只接受两个参数：SharedArrayBuffer 的视图和位置索引，也是返回`sharedArrayBuffer[index]`的值。
 
 ```javascript
 // 主线程 main.js
diff --git a/docs/async-iterator.md b/docs/async-iterator.md
index 6e5d70a6b..e229c1b8d 100644
--- a/docs/async-iterator.md
+++ b/docs/async-iterator.md
@@ -63,9 +63,9 @@ function idMaker() {
 
 const it = idMaker();
 
+it.next().value.then(o => console.log(o)) // 0
 it.next().value.then(o => console.log(o)) // 1
 it.next().value.then(o => console.log(o)) // 2
-it.next().value.then(o => console.log(o)) // 3
 // ...
 ```
 
diff --git a/docs/async.md b/docs/async.md
index bdfd6e41f..b305d3735 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -752,7 +752,7 @@ export { output };
 ```javascript
 // awaiting.js
 let output;
-(async function1 main() {
+(async function main() {
   const dynamic = await import(someMission);
   const data = await fetch(url);
   output = someProcess(dynamic.default, data);
diff --git a/docs/class.md b/docs/class.md
index 70917bcdd..994ba1ae3 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -735,9 +735,9 @@ class Widget {
 }
 ```
 
-上面代码中，`_bar`方法前面的下划线，表示这是一个只限于内部使用的私有方法。但是，这种命名是不保险的，在类的外部，还是可以调用到这个方法。
+上面代码中，`_bar()`方法前面的下划线，表示这是一个只限于内部使用的私有方法。但是，这种命名是不保险的，在类的外部，还是可以调用到这个方法。
 
-另一种方法就是索性将私有方法移出模块，因为模块内部的所有方法都是对外可见的。
+另一种方法就是索性将私有方法移出类，因为类内部的所有方法都是对外可见的。
 
 ```javascript
 class Widget {
@@ -753,7 +753,7 @@ function bar(baz) {
 }
 ```
 
-上面代码中，`foo`是公开方法，内部调用了`bar.call(this, baz)`。这使得`bar`实际上成为了当前模块的私有方法。
+上面代码中，`foo`是公开方法，内部调用了`bar.call(this, baz)`。这使得`bar()`实际上成为了当前类的私有方法。
 
 还有一种方法是利用`Symbol`值的唯一性，将私有方法的名字命名为一个`Symbol`值。
 
diff --git a/docs/module.md b/docs/module.md
index 040cbb2f5..6c773c4cc 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -286,7 +286,7 @@ import { bar } from 'my_module';
 import { foo, bar } from 'my_module';
 ```
 
-上面代码中，虽然`foo`和`bar`在两个语句中加载，但是它们对应的是同一个`my_module`实例。也就是说，`import`语句是 Singleton 模式。
+上面代码中，虽然`foo`和`bar`在两个语句中加载，但是它们对应的是同一个`my_module`模块。也就是说，`import`语句是 Singleton 模式。
 
 目前阶段，通过 Babel 转码，CommonJS 模块的`require`命令和 ES6 模块的`import`命令，可以写在同一个模块里面，但是最好不要这样做。因为`import`在静态解析阶段执行，所以它是一个模块之中最早执行的。下面的代码可能不会得到预期结果。
 
diff --git a/docs/style.md b/docs/style.md
index 0a18f9d30..db0506740 100644
--- a/docs/style.md
+++ b/docs/style.md
@@ -497,7 +497,7 @@ $ npm i -g eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-react
 `index.js`文件的代码如下。
 
 ```javascript
-var unusued = 'I have no purpose!';
+var unused = 'I have no purpose!';
 
 function greet() {
     var message = 'Hello, World!';
@@ -513,7 +513,7 @@ greet();
 $ eslint index.js
 index.js
   1:1  error  Unexpected var, use let or const instead          no-var
-  1:5  error  unusued is defined but never used                 no-unused-vars
+  1:5  error  unused is defined but never used                 no-unused-vars
   4:5  error  Expected indentation of 2 characters but found 4  indent
   4:5  error  Unexpected var, use let or const instead          no-var
   5:5  error  Expected indentation of 2 characters but found 4  indent
@@ -522,3 +522,4 @@ index.js
 ```
 
 上面代码说明，原文件有五个错误，其中两个是不应该使用`var`命令，而要使用`let`或`const`；一个是定义了变量，却没有使用；另外两个是行首缩进为 4 个空格，而不是规定的 2 个空格。
+

From 861dd41fc542c11b991c1b472cc82a454f4abbaf Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 6 Nov 2020 22:36:42 +0800
Subject: [PATCH 118/280] docs(arraybuffer): edit Atomics.load()

---
 docs/arraybuffer.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/arraybuffer.md b/docs/arraybuffer.md
index 4f25ff179..61325fd7d 100644
--- a/docs/arraybuffer.md
+++ b/docs/arraybuffer.md
@@ -1148,7 +1148,7 @@ Atomics.load(typedArray, index)
 Atomics.store(typedArray, index, value)
 ```
 
-`store`方法接受三个参数：SharedArrayBuffer 的视图、位置索引和值，返回`sharedArrayBuffer[index]`的值。`load`方法只接受两个参数：SharedArrayBuffer 的视图和位置索引，也是返回`sharedArrayBuffer[index]`的值。
+`store()`方法接受三个参数：`typedArray`对象（SharedArrayBuffer 的视图）、位置索引和值，返回`typedArray[index]`的值。`load()`方法只接受两个参数：`typedArray`对象（SharedArrayBuffer 的视图）和位置索引，也是返回`typedArray[index]`的值。
 
 ```javascript
 // 主线程 main.js
@@ -1161,7 +1161,7 @@ console.log(ia[37]);  // 123456
 console.log(ia[42]);  // 314159
 ```
 
-上面代码中，主线程的`Atomics.store`向 42 号位置的赋值，一定是早于 37 位置的赋值。只要 37 号位置等于 163，Worker 线程就不会终止循环，而对 37 号位置和 42 号位置的取值，一定是在`Atomics.load`操作之后。
+上面代码中，主线程的`Atomics.store()`向 42 号位置的赋值，一定是早于 37 位置的赋值。只要 37 号位置等于 163，Worker 线程就不会终止循环，而对 37 号位置和 42 号位置的取值，一定是在`Atomics.load()`操作之后。
 
 下面是另一个例子。
 

From f8171643cdfaa826fe1b21e589757a4e953a30b8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 17 Nov 2020 22:32:59 +0800
Subject: [PATCH 119/280] docs(string-methods): edit replaceAll(), fixed #1018

---
 docs/string-methods.md | 31 +++++++++++++++++++++++++++----
 docs/string.md         |  3 ++-
 2 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 8b1a5d508..2fbb76174 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -377,18 +377,41 @@ String.prototype.replaceAll(searchValue, replacement)
 `replaceAll()`的第二个参数`replacement`是一个字符串，表示替换的文本，其中可以使用一些特殊字符串。
 
 - `$&`：匹配的子字符串。
-- `` `$` ``：匹配结果前面的文本。
+- `` $` ``：匹配结果前面的文本。
 - `$'`：匹配结果后面的文本。
-- `$n`：匹配成功的第`n`组内容，`n`是从1开始的自然数。
+- `$n`：匹配成功的第`n`组内容，`n`是从1开始的自然数。这个参数生效的前提是，第一个参数必须是正则表达式。
 - `$$`：指代美元符号`$`。
 
+下面是一些例子。
+
 ```javascript
+// $& 表示匹配的字符串，即`b`本身
+// 所以返回结果与原字符串一致
+'abbc'.replaceAll('b', '$&')
+// 'abbc'
+
+// $` 表示匹配结果之前的字符串
+// 对于第一个`b`，$` 指代`a`
+// 对于第二个`b`，$` 指代`ab`
+'abbc'.replaceAll('b', '$`')
+// 'aaabc'
+
+// $' 表示匹配结果之后的字符串
+// 对于第一个`b`，$' 指代`bc`
+// 对于第二个`b`，$' 指代`c`
+'abbc'.replaceAll('b', `$'`)
+// 'abccc'
+
+// $1 表示正则表达式的第一个组匹配，指代`ab`
+// $2 表示正则表达式的第二个组匹配，指代`bc`
+'abbc'.replaceAll(/(ab)(bc)/g, '$2$1')
+// 'bcab'
+
+// $$ 指代 $
 'abc'.replaceAll('b', '$$')
 // 'a$c'
 ```
 
-上面例子中，`$$`表示替换的文本是单个美元符号`$`。
-
 `replaceAll()`的第二个参数`replacement`除了为字符串，也可以是一个函数，该函数的返回值将替换掉第一个参数`searchValue`匹配的文本。
 
 ```javascript
diff --git a/docs/string.md b/docs/string.md
index 3a3d78560..97b3ddc22 100644
--- a/docs/string.md
+++ b/docs/string.md
@@ -505,10 +505,11 @@ function passthru(literals) {
   let i = 0;
 
   while (i < literals.length) {
-    result += literals[i++];
+    result += literals[i];
     if (i < arguments.length) {
       result += arguments[i];
     }
+    i++;
   }
 
   return result;

From a326217687f9cc8335d3cf9ba9147bb9a7e335a8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 17 Nov 2020 22:39:58 +0800
Subject: [PATCH 120/280] docs(string): fix typo

---
 docs/string.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/string.md b/docs/string.md
index 97b3ddc22..3a3d78560 100644
--- a/docs/string.md
+++ b/docs/string.md
@@ -505,11 +505,10 @@ function passthru(literals) {
   let i = 0;
 
   while (i < literals.length) {
-    result += literals[i];
+    result += literals[i++];
     if (i < arguments.length) {
       result += arguments[i];
     }
-    i++;
   }
 
   return result;

From ff4778487cf48986cb43df000c7e568f83abf27d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Nov 2020 06:57:53 +0800
Subject: [PATCH 121/280] docs(style): fixed #1020

---
 docs/style.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/style.md b/docs/style.md
index db0506740..42fd61da6 100644
--- a/docs/style.md
+++ b/docs/style.md
@@ -471,17 +471,17 @@ export default StyleGuide;
 
 ESLint 是一个语法规则和代码风格的检查工具，可以用来保证写出语法正确、风格统一的代码。
 
-首先，安装 ESLint。
+首先，在项目的根目录安装 ESLint。
 
 ```bash
-$ npm i -g eslint
+$ npm install --save-dev eslint
 ```
 
 然后，安装 Airbnb 语法规则，以及 import、a11y、react 插件。
 
 ```bash
-$ npm i -g eslint-config-airbnb
-$ npm i -g eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-react
+$ npm install --save-dev eslint-config-airbnb
+$ npm install --save-dev eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-react
 ```
 
 最后，在项目的根目录下新建一个`.eslintrc`文件，配置 ESLint。
@@ -501,7 +501,7 @@ var unused = 'I have no purpose!';
 
 function greet() {
     var message = 'Hello, World!';
-    alert(message);
+    console.log(message);
 }
 
 greet();
@@ -510,7 +510,7 @@ greet();
 使用 ESLint 检查这个文件，就会报出错误。
 
 ```bash
-$ eslint index.js
+$ npx eslint index.js
 index.js
   1:1  error  Unexpected var, use let or const instead          no-var
   1:5  error  unused is defined but never used                 no-unused-vars

From 584d5d93321cf780a9d51e2e0f787052f2e3a2fa Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Nov 2020 07:24:09 +0800
Subject: [PATCH 122/280] docs(generator): edit style

---
 docs/generator.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/generator.md b/docs/generator.md
index c0683c6b4..e2f7d18ee 100644
--- a/docs/generator.md
+++ b/docs/generator.md
@@ -667,7 +667,7 @@ log(g());
 
 ## Generator.prototype.return()
 
-Generator 函数返回的遍历器对象，还有一个`return`方法，可以返回给定的值，并且终结遍历 Generator 函数。
+Generator 函数返回的遍历器对象，还有一个`return()`方法，可以返回给定的值，并且终结遍历 Generator 函数。
 
 ```javascript
 function* gen() {
@@ -683,9 +683,9 @@ g.return('foo') // { value: "foo", done: true }
 g.next()        // { value: undefined, done: true }
 ```
 
-上面代码中，遍历器对象`g`调用`return`方法后，返回值的`value`属性就是`return`方法的参数`foo`。并且，Generator 函数的遍历就终止了，返回值的`done`属性为`true`，以后再调用`next`方法，`done`属性总是返回`true`。
+上面代码中，遍历器对象`g`调用`return()`方法后，返回值的`value`属性就是`return()`方法的参数`foo`。并且，Generator 函数的遍历就终止了，返回值的`done`属性为`true`，以后再调用`next()`方法，`done`属性总是返回`true`。
 
-如果`return`方法调用时，不提供参数，则返回值的`value`属性为`undefined`。
+如果`return()`方法调用时，不提供参数，则返回值的`value`属性为`undefined`。
 
 ```javascript
 function* gen() {
@@ -700,7 +700,7 @@ g.next()        // { value: 1, done: false }
 g.return() // { value: undefined, done: true }
 ```
 
-如果 Generator 函数内部有`try...finally`代码块，且正在执行`try`代码块，那么`return`方法会导致立刻进入`finally`代码块，执行完以后，整个函数才会结束。
+如果 Generator 函数内部有`try...finally`代码块，且正在执行`try`代码块，那么`return()`方法会导致立刻进入`finally`代码块，执行完以后，整个函数才会结束。
 
 ```javascript
 function* numbers () {

From 201eebe08fa11f992196a9a40a98ba3be2a48d8d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 29 Nov 2020 12:23:59 +0800
Subject: [PATCH 123/280] docs(async): fixed #1023

---
 docs/async.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index b305d3735..c28439df8 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -470,7 +470,7 @@ function dbFuc(db) { //这里不需要 async
 }
 ```
 
-上面代码可能不会正常工作，原因是这时三个`db.post`操作将是并发执行，也就是同时执行，而不是继发执行。正确的写法是采用`for`循环。
+上面代码可能不会正常工作，原因是这时三个`db.post()`操作将是并发执行，也就是同时执行，而不是继发执行。正确的写法是采用`for`循环。
 
 ```javascript
 async function dbFuc(db) {
@@ -482,7 +482,7 @@ async function dbFuc(db) {
 }
 ```
 
-另一种方法是使用数组的`reduce`方法。
+另一种方法是使用数组的`reduce()`方法。
 
 ```javascript
 async function dbFuc(db) {
@@ -495,7 +495,9 @@ async function dbFuc(db) {
 }
 ```
 
-上面例子中，`reduce`方法的第一个参数是`async`函数，导致该函数的第一个参数是前一步操作返回的 Promise 对象，所以必须使用`await`等待它操作结束。另外，`reduce`方法返回的是`docs`数组最后一个成员的`async`函数的执行结果，也是一个 Promise 对象，导致在它前面也必须加上`await`。
+上面例子中，`reduce()`方法的第一个参数是`async`函数，导致该函数的第一个参数是前一步操作返回的 Promise 对象，所以必须使用`await`等待它操作结束。另外，`reduce()`方法返回的是`docs`数组最后一个成员的`async`函数的执行结果，也是一个 Promise 对象，导致在它前面也必须加上`await`。
+
+这个例子的`reduce()`的第二个参数是`undefined`，并且第一个参数函数里面没有`return`语句，原因是这个例子没有用到累积变量，而且每一轮`async`函数不管有没有`return`语句，总是返回一个 Promise 对象。换句话说，这里的`reduce()`方法不是为了求值，而是为了遍历操作。
 
 如果确实希望多个请求并发执行，可以使用`Promise.all`方法。当三个请求都会`resolved`时，下面两种写法效果相同。
 

From bc0ba763f7c15ec2a505ab864ba3cb0c2a087f00 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 29 Nov 2020 13:04:11 +0800
Subject: [PATCH 124/280] docs(async): edit reduce()

---
 docs/async.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/async.md b/docs/async.md
index c28439df8..532c1a366 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -497,7 +497,7 @@ async function dbFuc(db) {
 
 上面例子中，`reduce()`方法的第一个参数是`async`函数，导致该函数的第一个参数是前一步操作返回的 Promise 对象，所以必须使用`await`等待它操作结束。另外，`reduce()`方法返回的是`docs`数组最后一个成员的`async`函数的执行结果，也是一个 Promise 对象，导致在它前面也必须加上`await`。
 
-这个例子的`reduce()`的第二个参数是`undefined`，并且第一个参数函数里面没有`return`语句，原因是这个例子没有用到累积变量，而且每一轮`async`函数不管有没有`return`语句，总是返回一个 Promise 对象。换句话说，这里的`reduce()`方法不是为了求值，而是为了遍历操作。
+上面的`reduce()`的参数函数里面没有`return`语句，原因是这个函数的主要目的是`db.post()`操作，不是返回值。而且`async`函数不管有没有`return`语句，总是返回一个 Promise 对象，所以这里的`return`是不必要的。
 
 如果确实希望多个请求并发执行，可以使用`Promise.all`方法。当三个请求都会`resolved`时，下面两种写法效果相同。
 

From 038a080f7b08181d3f2d17d5756f985665225dbf Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 2 Dec 2020 17:39:44 +0800
Subject: [PATCH 125/280] refactor: edit support banner

---
 js/ditto.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index e3e69c923..de35e8b72 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2020年11月1日
-  var deadline = new Date(2020, 10, 1);
+  // 2021年1月1日
+  var deadline = new Date(2021, 0, 1);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -259,7 +259,7 @@ function create_banner(element) {
   ].join(';');
 
   var text = '【免费课程】' +
-    '开始学习<span style="color: #4682BE;">《ES6 实战教程》</span>，一线大厂前端必备技能。';
+    '<span style="color: #4682BE;">《Vue进阶攻略》</span>领取，Vue 3.0 新知识点讲解。';
 
   var banner = $('<a href="https://datayi.cn/w/a9BLv2LP" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);

From 761d1075223cc931a28ff08c5b709969e5ce8606 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 2 Dec 2020 18:18:40 +0800
Subject: [PATCH 126/280] refactor: edit support banner

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index de35e8b72..7f2a404dc 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -261,7 +261,7 @@ function create_banner(element) {
   var text = '【免费课程】' +
     '<span style="color: #4682BE;">《Vue进阶攻略》</span>领取，Vue 3.0 新知识点讲解。';
 
-  var banner = $('<a href="https://datayi.cn/w/a9BLv2LP" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://datayi.cn/w/4PK5pQJ9" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 56d15b327aab1005adc52375a84c2c901761422c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 3 Dec 2020 23:17:05 +0800
Subject: [PATCH 127/280] refactor: edit support banner

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 7f2a404dc..c5eb80e0e 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年1月1日
-  var deadline = new Date(2021, 0, 1);
+  // 2021年2月3日
+  var deadline = new Date(2021, 1, 3);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From d04189323a2d6ed96b261ccf22f08e5f47f00cf8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 9 Dec 2020 13:10:24 +0800
Subject: [PATCH 128/280] docs(class): edit class intro

---
 docs/class.md | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 994ba1ae3..528fac0bd 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -38,9 +38,9 @@ class Point {
 }
 ```
 
-上面代码定义了一个“类”，可以看到里面有一个`constructor`方法，这就是构造方法，而`this`关键字则代表实例对象。也就是说，ES5 的构造函数`Point`，对应 ES6 的`Point`类的构造方法。
+上面代码定义了一个“类”，可以看到里面有一个`constructor()`方法，这就是构造方法，而`this`关键字则代表实例对象。这种新的 Class 写法，本质上与本章开头的 ES5 的构造函数`Point`是一致的。
 
-`Point`类除了构造方法，还定义了一个`toString`方法。注意，定义“类”的方法的时候，前面不需要加上`function`这个关键字，直接把函数定义放进去了就可以了。另外，方法之间不需要逗号分隔，加了会报错。
+`Point`类除了构造方法，还定义了一个`toString()`方法。注意，定义`toString()`方法的时候，前面不需要加上`function`这个关键字，直接把函数定义放进去了就可以了。另外，方法与方法之间不需要逗号分隔，加了会报错。
 
 ES6 的类，完全可以看作构造函数的另一种写法。
 
@@ -64,7 +64,7 @@ class Bar {
   }
 }
 
-var b = new Bar();
+const b = new Bar();
 b.doStuff() // "stuff"
 ```
 
@@ -94,18 +94,20 @@ Point.prototype = {
 };
 ```
 
-在类的实例上面调用方法，其实就是调用原型上的方法。
+上面代码中，`constructor()`、`toString()`、`toValue()`这三个方法，其实都是定义在`Point.prototype`上面。
+
+因此，在类的实例上面调用方法，其实就是调用原型上的方法。
 
 ```javascript
 class B {}
-let b = new B();
+const b = new B();
 
 b.constructor === B.prototype.constructor // true
 ```
 
-上面代码中，`b`是`B`类的实例，它的`constructor`方法就是`B`类原型的`constructor`方法。
+上面代码中，`b`是`B`类的实例，它的`constructor()`方法就是`B`类原型的`constructor()`方法。
 
-由于类的方法都定义在`prototype`对象上面，所以类的新方法可以添加在`prototype`对象上面。`Object.assign`方法可以很方便地一次向类添加多个方法。
+由于类的方法都定义在`prototype`对象上面，所以类的新方法可以添加在`prototype`对象上面。`Object.assign()`方法可以很方便地一次向类添加多个方法。
 
 ```javascript
 class Point {
@@ -120,7 +122,7 @@ Object.assign(Point.prototype, {
 });
 ```
 
-`prototype`对象的`constructor`属性，直接指向“类”的本身，这与 ES5 的行为是一致的。
+`prototype`对象的`constructor()`属性，直接指向“类”的本身，这与 ES5 的行为是一致的。
 
 ```javascript
 Point.prototype.constructor === Point // true
@@ -145,14 +147,14 @@ Object.getOwnPropertyNames(Point.prototype)
 // ["constructor","toString"]
 ```
 
-上面代码中，`toString`方法是`Point`类内部定义的方法，它是不可枚举的。这一点与 ES5 的行为不一致。
+上面代码中，`toString()`方法是`Point`类内部定义的方法，它是不可枚举的。这一点与 ES5 的行为不一致。
 
 ```javascript
 var Point = function (x, y) {
   // ...
 };
 
-Point.prototype.toString = function() {
+Point.prototype.toString = function () {
   // ...
 };
 
@@ -162,11 +164,11 @@ Object.getOwnPropertyNames(Point.prototype)
 // ["constructor","toString"]
 ```
 
-上面代码采用 ES5 的写法，`toString`方法就是可枚举的。
+上面代码采用 ES5 的写法，`toString()`方法就是可枚举的。
 
 ### constructor 方法
 
-`constructor`方法是类的默认方法，通过`new`命令生成对象实例时，自动调用该方法。一个类必须有`constructor`方法，如果没有显式定义，一个空的`constructor`方法会被默认添加。
+`constructor()`方法是类的默认方法，通过`new`命令生成对象实例时，自动调用该方法。一个类必须有`constructor()`方法，如果没有显式定义，一个空的`constructor()`方法会被默认添加。
 
 ```javascript
 class Point {
@@ -178,9 +180,9 @@ class Point {
 }
 ```
 
-上面代码中，定义了一个空的类`Point`，JavaScript 引擎会自动为它添加一个空的`constructor`方法。
+上面代码中，定义了一个空的类`Point`，JavaScript 引擎会自动为它添加一个空的`constructor()`方法。
 
-`constructor`方法默认返回实例对象（即`this`），完全可以指定返回另外一个对象。
+`constructor()`方法默认返回实例对象（即`this`），完全可以指定返回另外一个对象。
 
 ```javascript
 class Foo {
@@ -193,7 +195,7 @@ new Foo() instanceof Foo
 // false
 ```
 
-上面代码中，`constructor`函数返回一个全新的对象，结果导致实例对象不是`Foo`类的实例。
+上面代码中，`constructor()`函数返回一个全新的对象，结果导致实例对象不是`Foo`类的实例。
 
 类必须使用`new`调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用`new`也可以执行。
 
@@ -251,7 +253,7 @@ point.hasOwnProperty('toString') // false
 point.__proto__.hasOwnProperty('toString') // true
 ```
 
-上面代码中，`x`和`y`都是实例对象`point`自身的属性（因为定义在`this`变量上），所以`hasOwnProperty`方法返回`true`，而`toString`是原型对象的属性（因为定义在`Point`类上），所以`hasOwnProperty`方法返回`false`。这些都与 ES5 的行为保持一致。
+上面代码中，`x`和`y`都是实例对象`point`自身的属性（因为定义在`this`变量上），所以`hasOwnProperty()`方法返回`true`，而`toString()`是原型对象的属性（因为定义在`Point`类上），所以`hasOwnProperty()`方法返回`false`。这些都与 ES5 的行为保持一致。
 
 与 ES5 一样，类的所有实例共享一个原型对象。
 
@@ -282,7 +284,7 @@ var p3 = new Point(4,2);
 p3.printName() // "Oops"
 ```
 
-上面代码在`p1`的原型上添加了一个`printName`方法，由于`p1`的原型就是`p2`的原型，因此`p2`也可以调用这个方法。而且，此后新建的实例`p3`也可以调用这个方法。这意味着，使用实例的`__proto__`属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例。
+上面代码在`p1`的原型上添加了一个`printName()`方法，由于`p1`的原型就是`p2`的原型，因此`p2`也可以调用这个方法。而且，此后新建的实例`p3`也可以调用这个方法。这意味着，使用实例的`__proto__`属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例。
 
 ### 取值函数（getter）和存值函数（setter）
 

From cc2420e644113f25b4598b940dd321a0b5e3b09f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 17 Dec 2020 15:49:41 +0800
Subject: [PATCH 129/280] docs(function): edit arrow function

---
 docs/function.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/docs/function.md b/docs/function.md
index fe6b10750..792a45856 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -869,6 +869,35 @@ const cat = {
 
 上面代码中，`cat.jumps()`方法是一个箭头函数，这是错误的。调用`cat.jumps()`时，如果是普通函数，该方法内部的`this`指向`cat`；如果写成上面那样的箭头函数，使得`this`指向全局对象，因此不会得到预期结果。这是因为对象不构成单独的作用域，导致`jumps`箭头函数定义时的作用域就是全局作用域。
 
+再看一个例子。
+
+```javascript
+globalThis.s = 21;
+
+const obj = {
+  s: 42,
+  m: () => console.log(this.s)
+};
+
+obj.m() // 21
+```
+
+上面例子中，`obj.m()`使用箭头函数定义。JavaScript 引擎的处理方法是，先在全局空间生成这个箭头函数，然后赋值给`obj.m`，这导致箭头函数内部的`this`指向全局对象，所以`obj.m()`输出的是全局空间的`21`，而不是对象内部的`42`。上面的代码实际上等同于下面的代码。
+
+```javascript
+globalThis.s = 21;
+globalThis.m = () => console.log(this.s);
+
+const obj = {
+  s: 42,
+  m: globalThis.m
+};
+
+obj.m() // 21
+```
+
+由于上面这个原因，对象的属性建议使用传统的写法定义，不要用箭头函数定义。
+
 第二个场合是需要动态`this`的时候，也不应使用箭头函数。
 
 ```javascript

From 1c99572bc7be46aece9cea600f42ab0a9a55a79b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 22 Dec 2020 23:41:42 +0800
Subject: [PATCH 130/280] docs(promise): fix #1028

---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index f6717616b..c3eee3907 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -52,7 +52,7 @@ promise.then(function(value) {
 });
 ```
 
-`then`方法可以接受两个回调函数作为参数。第一个回调函数是`Promise`对象的状态变为`resolved`时调用，第二个回调函数是`Promise`对象的状态变为`rejected`时调用。其中，第二个函数是可选的，不一定要提供。这两个函数都接受`Promise`对象传出的值作为参数。
+`then`方法可以接受两个回调函数作为参数。第一个回调函数是`Promise`对象的状态变为`resolved`时调用，第二个回调函数是`Promise`对象的状态变为`rejected`时调用。这两个函数都是可选的，不一定要提供。它们都接受`Promise`对象传出的值作为参数。
 
 下面是一个`Promise`对象的简单例子。
 

From 1d556be8a7e396608639b7263f7ad4b7a5054fe9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=AB=A5=E6=AC=A7=E5=B7=B4?= <349247397@qq.com>
Date: Wed, 23 Dec 2020 00:04:15 +0800
Subject: [PATCH 131/280] Update promise.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

这里也需要同步下，阮大。
---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index c3eee3907..02c1d0611 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -210,7 +210,7 @@ new Promise((resolve, reject) => {
 
 ## Promise.prototype.then()
 
-Promise 实例具有`then`方法，也就是说，`then`方法是定义在原型对象`Promise.prototype`上的。它的作用是为 Promise 实例添加状态改变时的回调函数。前面说过，`then`方法的第一个参数是`resolved`状态的回调函数，第二个参数（可选）是`rejected`状态的回调函数。
+Promise 实例具有`then`方法，也就是说，`then`方法是定义在原型对象`Promise.prototype`上的。它的作用是为 Promise 实例添加状态改变时的回调函数。前面说过，`then`方法的第一个参数是`resolved`状态的回调函数，第二个参数是`rejected`状态的回调函数，它们都是可选的。
 
 `then`方法返回的是一个新的`Promise`实例（注意，不是原来那个`Promise`实例）。因此可以采用链式写法，即`then`方法后面再调用另一个`then`方法。
 

From 4309e6aad345a473be5bdf4ca01f140e58232ad1 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 7 Jan 2021 00:12:47 +0800
Subject: [PATCH 132/280] docs(regex): edit regex

---
 docs/regex.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/regex.md b/docs/regex.md
index 2cd8a15da..c14811110 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -38,7 +38,7 @@ new RegExp(/abc/ig, 'i').flags
 
 ## 字符串的正则方法
 
-字符串对象共有 4 个方法，可以使用正则表达式：`match()`、`replace()`、`search()`和`split()`。
+ES6 出现之前，字符串对象共有 4 个方法，可以使用正则表达式：`match()`、`replace()`、`search()`和`split()`。
 
 ES6 将这 4 个方法，在语言内部全部调用`RegExp`的实例方法，从而做到所有与正则相关的方法，全都定义在`RegExp`对象上。
 
@@ -507,9 +507,9 @@ ES2018 引入了[具名组匹配](https://github.com/tc39/proposal-regexp-named-
 const RE_DATE = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
 
 const matchObj = RE_DATE.exec('1999-12-31');
-const year = matchObj.groups.year; // 1999
-const month = matchObj.groups.month; // 12
-const day = matchObj.groups.day; // 31
+const year = matchObj.groups.year; // "1999"
+const month = matchObj.groups.month; // "12"
+const day = matchObj.groups.day; // "31"
 ```
 
 上面代码中，“具名组匹配”在圆括号内部，模式的头部添加“问号 + 尖括号 + 组名”（`?<year>`），然后就可以在`exec`方法返回结果的`groups`属性上引用该组名。同时，数字序号（`matchObj[1]`）依然有效。

From b45161a0f6a0658029432d38b6526a58c3b428b4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 22 Jan 2021 23:09:50 +0800
Subject: [PATCH 133/280] docs(proxy): fix #1032

---
 docs/proxy.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index e705fba45..7a761c0ad 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -418,13 +418,13 @@ myObj.foo === myObj // true
 
 上面代码中，设置`myObj.foo`属性的值时，`myObj`并没有`foo`属性，因此引擎会到`myObj`的原型链去找`foo`属性。`myObj`的原型对象`proxy`是一个 Proxy 实例，设置它的`foo`属性会触发`set`方法。这时，第四个参数`receiver`就指向原始赋值行为所在的对象`myObj`。
 
-注意，如果目标对象自身的某个属性，不可写且不可配置，那么`set`方法将不起作用。
+注意，如果目标对象自身的某个属性不可写，那么`set`方法将不起作用。
 
 ```javascript
 const obj = {};
 Object.defineProperty(obj, 'foo', {
   value: 'bar',
-  writable: false,
+  writable: false
 });
 
 const handler = {

From 94616305e53401ad24daec046d9c302c2eee726f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 5 Feb 2021 13:57:28 +0800
Subject: [PATCH 134/280] refactor: edit support js

---
 js/ditto.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index c5eb80e0e..d20a7eb64 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年2月3日
-  var deadline = new Date(2021, 1, 3);
+  // 2021年3月18日
+  var deadline = new Date(2021, 2, 18);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -258,10 +258,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【免费课程】' +
-    '<span style="color: #4682BE;">《Vue进阶攻略》</span>领取，Vue 3.0 新知识点讲解。';
+  var text = '【免费资料】' +
+    '开课吧<span style="color: #4682BE;">《数据分析全套讲解》</span>视频，讲解统计建模与分析工具（Excel/Python/SQL等）基础知识。';
 
-  var banner = $('<a href="https://datayi.cn/w/4PK5pQJ9" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://t.1yb.co/gUcm" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 543678f9ddcdf3b5ee670dde8aeb624d07669055 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 11 Feb 2021 15:53:32 +0800
Subject: [PATCH 135/280] docs(array): fix #1037

---
 docs/array.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index 3dc145483..e69830951 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -507,7 +507,7 @@ function countSymbols(string) {
 
 ## Array.of()
 
-`Array.of`方法用于将一组值，转换为数组。
+`Array.of()`方法用于将一组值，转换为数组。
 
 ```javascript
 Array.of(3, 11, 8) // [3,11,8]
@@ -523,9 +523,9 @@ Array(3) // [, , ,]
 Array(3, 11, 8) // [3, 11, 8]
 ```
 
-上面代码中，`Array`方法没有参数、一个参数、三个参数时，返回结果都不一样。只有当参数个数不少于 2 个时，`Array()`才会返回由参数组成的新数组。参数个数只有一个时，实际上是指定数组的长度。
+上面代码中，`Array()`方法没有参数、一个参数、三个参数时，返回的结果都不一样。只有当参数个数不少于 2 个时，`Array()`才会返回由参数组成的新数组。参数只有一个正整数时，实际上是指定数组的长度。
 
-`Array.of`基本上可以用来替代`Array()`或`new Array()`，并且不存在由于参数不同而导致的重载。它的行为非常统一。
+`Array.of()`基本上可以用来替代`Array()`或`new Array()`，并且不存在由于参数不同而导致的重载。它的行为非常统一。
 
 ```javascript
 Array.of() // []
@@ -534,9 +534,9 @@ Array.of(1) // [1]
 Array.of(1, 2) // [1, 2]
 ```
 
-`Array.of`总是返回参数值组成的数组。如果没有参数，就返回一个空数组。
+`Array.of()`总是返回参数值组成的数组。如果没有参数，就返回一个空数组。
 
-`Array.of`方法可以用下面的代码模拟实现。
+`Array.of()`方法可以用下面的代码模拟实现。
 
 ```javascript
 function ArrayOf(){

From ec9db66106511904747de9ef7bd590e6935e10e8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 20 Feb 2021 19:40:37 +0800
Subject: [PATCH 136/280] refactor: edit support banner

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index d20a7eb64..95f2c99fb 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -259,9 +259,9 @@ function create_banner(element) {
   ].join(';');
 
   var text = '【免费资料】' +
-    '开课吧<span style="color: #4682BE;">《数据分析全套讲解》</span>视频，讲解统计建模与分析工具（Excel/Python/SQL等）基础知识。';
+    'Excel + Python + SQL 数据处理入门，课程资料下载。';
 
-  var banner = $('<a href="https://t.1yb.co/gUcm" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://t.1yb.co/gXGw" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 631a66ea8f89fff4547cef0ae9fb6970d9fb628d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 20 Feb 2021 19:44:10 +0800
Subject: [PATCH 137/280] refactor: edit support banner

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index 95f2c99fb..186a85c1f 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -259,7 +259,7 @@ function create_banner(element) {
   ].join(';');
 
   var text = '【免费资料】' +
-    'Excel + Python + SQL 数据处理入门，课程资料下载。';
+    '<span style="color: #4682BE;">Excel + Python + SQL 数据处理入门</span>，课程资料下载。';
 
   var banner = $('<a href="https://t.1yb.co/gXGw" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);

From 3929f4f21148dcd2a10d2ebc722323a5dbd473f4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 23 Feb 2021 16:32:04 +0800
Subject: [PATCH 138/280] refactor: edit support banner

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 186a85c1f..417363ea1 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年3月18日
-  var deadline = new Date(2021, 2, 18);
+  // 2021年2月18日
+  var deadline = new Date(2021, 1, 18);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From e9fd28bf6460140cdc652ff50755bcfbcb68012b Mon Sep 17 00:00:00 2001
From: An Hongpeng <79783808+roc-an@users.noreply.github.com>
Date: Sun, 18 Apr 2021 21:32:40 +0800
Subject: [PATCH 139/280] fix: remove 'else'

---
 docs/iterator.md | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/docs/iterator.md b/docs/iterator.md
index 68fba5009..4d75784f8 100644
--- a/docs/iterator.md
+++ b/docs/iterator.md
@@ -209,9 +209,8 @@ Obj.prototype[Symbol.iterator] = function() {
       var value = current.value;
       current = current.next;
       return { done: false, value: value };
-    } else {
-      return { done: true };
     }
+    return { done: true };
   }
   return iterator;
 }
@@ -245,9 +244,8 @@ let obj = {
             value: self.data[index++],
             done: false
           };
-        } else {
-          return { value: undefined, done: true };
         }
+        return { value: undefined, done: true };
       }
     };
   }

From d09058f44ede41cbb44612d0817a53d4ca5a65fb Mon Sep 17 00:00:00 2001
From: An Hongpeng <79783808+roc-an@users.noreply.github.com>
Date: Tue, 20 Apr 2021 20:03:08 +0800
Subject: [PATCH 140/280] =?UTF-8?q?fix:=20=E4=B8=BA=E8=BE=93=E5=87=BA?=
 =?UTF-8?q?=E8=A1=A5=E5=85=85=E7=A4=BA=E4=BE=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/iterator.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/iterator.md b/docs/iterator.md
index 68fba5009..74056b400 100644
--- a/docs/iterator.md
+++ b/docs/iterator.md
@@ -745,6 +745,8 @@ for (var key of Object.keys(someObject)) {
 另一个方法是使用 Generator 函数将对象重新包装一下。
 
 ```javascript
+const obj = { a: 1, b: 2, c: 3 }
+
 function* entries(obj) {
   for (let key of Object.keys(obj)) {
     yield [key, obj[key]];

From fa03d29d6410caa1074382a0cfe8650222ed2220 Mon Sep 17 00:00:00 2001
From: An Hongpeng <79783808+roc-an@users.noreply.github.com>
Date: Sat, 24 Apr 2021 23:22:28 +0800
Subject: [PATCH 141/280] =?UTF-8?q?fix:=20=E5=BC=BA=E8=BF=AB=E7=97=87?=
 =?UTF-8?q?=E7=8A=AF=E4=BA=86=E6=83=B3=E5=8E=BB=E6=8E=89=E5=A4=9A=E4=BD=99?=
 =?UTF-8?q?=E7=A9=BA=E6=A0=BC=E5=A5=BD=E7=9C=8B=E4=B8=80=E4=BA=9B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/generator.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/generator.md b/docs/generator.md
index e2f7d18ee..7d18278ca 100644
--- a/docs/generator.md
+++ b/docs/generator.md
@@ -696,7 +696,7 @@ function* gen() {
 
 var g = gen();
 
-g.next()        // { value: 1, done: false }
+g.next() // { value: 1, done: false }
 g.return() // { value: undefined, done: true }
 ```
 

From 59146b4806f42ad9bb1587651493ceabaf28f0c3 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 26 Apr 2021 10:04:13 +0800
Subject: [PATCH 142/280] docs(proxy): fix set return value #1047

---
 docs/proxy.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 7a761c0ad..33492c1ba 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -344,6 +344,7 @@ let validator = {
 
     // 对于满足条件的 age 属性以及其他属性，直接保存
     obj[prop] = value;
+    return true;
   }
 };
 
@@ -393,6 +394,7 @@ proxy._prop = 'c'
 const handler = {
   set: function(obj, prop, value, receiver) {
     obj[prop] = receiver;
+    return true;
   }
 };
 const proxy = new Proxy({}, handler);
@@ -406,6 +408,7 @@ proxy.foo === proxy // true
 const handler = {
   set: function(obj, prop, value, receiver) {
     obj[prop] = receiver;
+    return true;
   }
 };
 const proxy = new Proxy({}, handler);
@@ -430,6 +433,7 @@ Object.defineProperty(obj, 'foo', {
 const handler = {
   set: function(obj, prop, value, receiver) {
     obj[prop] = 'baz';
+    return true;
   }
 };
 
@@ -440,7 +444,7 @@ proxy.foo // "bar"
 
 上面代码中，`obj.foo`属性不可写，Proxy 对这个属性的`set`代理将不会生效。
 
-注意，严格模式下，`set`代理如果没有返回`true`，就会报错。
+注意，`set`代理应当返回一个布尔值。严格模式下，`set`代理如果没有返回`true`，就会报错。
 
 ```javascript
 'use strict';

From 85b8174db3bd7b2e59a370bca4841f01941ca25f Mon Sep 17 00:00:00 2001
From: daungui <fyyz31311@gmail.com>
Date: Sat, 8 May 2021 22:36:36 +0800
Subject: [PATCH 143/280] =?UTF-8?q?docs(set-map):=20=E6=94=B9=E8=BF=9B=20W?=
 =?UTF-8?q?eakSet=20=E5=92=8C=20WeakMap=20=E6=96=87=E6=A1=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/set-map.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index b2e14d13e..cafd91141 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -322,7 +322,7 @@ ws.add(Symbol())
 
 其次，WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。
 
-这是因为垃圾回收机制依赖引用计数，如果一个值的引用次数不为`0`，垃圾回收机制就不会释放这块内存。结束使用该值之后，有时会忘记取消引用，导致内存无法释放，进而可能会引发内存泄漏。WeakSet 里面的引用，都不计入垃圾回收机制，所以就不存在这个问题。因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。
+这是因为垃圾回收机制根据对象的可达性（Reachability）来判断回收，如果对象还能被访问到即仍然可达，垃圾回收机制就不会释放这块内存。结束使用该值之后，有时会忘记取消引用，导致内存无法释放，进而可能会引发内存泄漏。WeakSet 里面的引用，都不计入垃圾回收机制，所以就不存在这个问题。因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。
 
 由于上面这个特点，WeakSet 的成员是不适合引用的，因为它会随时消失。另外，由于 WeakSet 内部有多少个成员，取决于垃圾回收机制有没有运行，运行前后很可能成员个数是不一样的，而垃圾回收机制何时运行是不可预测的，因此 ES6 规定 WeakSet 不可遍历。
 
@@ -981,9 +981,9 @@ wm.set(element, 'some information');
 wm.get(element) // "some information"
 ```
 
-上面代码中，先新建一个 Weakmap 实例。然后，将一个 DOM 节点作为键名存入该实例，并将一些附加信息作为键值，一起存放在 WeakMap 里面。这时，WeakMap 里面对`element`的引用就是弱引用，不会被计入垃圾回收机制。
+上面代码中，先新建一个 WeakMap 实例。然后，将一个 DOM 节点作为键名存入该实例，并将一些附加信息作为键值，一起存放在 WeakMap 里面。这时，WeakMap 里面对`element`的引用就是弱引用，不会被计入垃圾回收机制。
 
-也就是说，上面的 DOM 节点对象的引用计数是`1`，而不是`2`。这时，一旦消除对该节点的引用，它占用的内存就会被垃圾回收机制释放。Weakmap 保存的这个键值对，也会自动消失。
+也就是说，上面的 DOM 节点对象除了 WeakMap 的弱引用外，只有一处引用。这时，一旦消除对该节点的引用，它占用的内存就会被垃圾回收机制释放。WeakMap 保存的这个键值对，也会自动消失。
 
 总之，`WeakMap`的专用场合就是，它的键所对应的对象，可能会在将来消失。`WeakMap`结构有助于防止内存泄漏。
 

From 71af30def18573f73e6d75df7c288cabd2ce04e0 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 12 May 2021 01:07:14 +0800
Subject: [PATCH 144/280] =?UTF-8?q?docs(function):=20fixed=20=E7=AE=AD?=
 =?UTF-8?q?=E5=A4=B4=E5=87=BD=E6=95=B0=E7=9A=84this=20#1050?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/function.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/docs/function.md b/docs/function.md
index 792a45856..a826c8814 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -708,15 +708,15 @@ headAndTail(1, 2, 3, 4, 5)
 
 箭头函数有几个使用注意点。
 
-（1）函数体内的`this`对象，就是定义时所在的对象，而不是使用时所在的对象。
+（1）箭头函数没有自己的`this`对象（详见下文）。
 
-（2）不可以当作构造函数，也就是说，不可以使用`new`命令，否则会抛出一个错误。
+（2）不可以当作构造函数，也就是说，不可以对箭头函数使用`new`命令，否则会抛出一个错误。
 
 （3）不可以使用`arguments`对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
 
 （4）不可以使用`yield`命令，因此箭头函数不能用作 Generator 函数。
 
-上面四点中，第一点尤其值得注意。`this`对象的指向是可变的，但是在箭头函数中，它是固定的。
+上面四点中，最重要的是第一点。对于普通函数来说，内部的`this`代表函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的`this`对象，内部的`this`就是一个普通变量，指向定义时上层函数所在的对象。也就是说，箭头函数内部的`this`指向是固定的，相比之下，普通函数的`this`指向是可变的。
 
 ```javascript
 function foo() {
@@ -733,7 +733,7 @@ foo.call({ id: 42 });
 
 上面代码中，`setTimeout()`的参数是一个箭头函数，这个箭头函数的定义生效是在`foo`函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时`this`应该指向全局对象`window`，这时应该输出`21`。但是，箭头函数导致`this`总是指向函数定义生效时所在的对象（本例是`{id: 42}`），所以打印出来的是`42`。
 
-箭头函数可以让`setTimeout`里面的`this`，绑定定义时所在的作用域，而不是指向运行时所在的作用域。下面是另一个例子。
+下面例子是回调函数分别为箭头函数和普通函数，对比它们内部的`this`指向。
 
 ```javascript
 function Timer() {
@@ -757,7 +757,7 @@ setTimeout(() => console.log('s2: ', timer.s2), 3100);
 
 上面代码中，`Timer`函数内部设置了两个定时器，分别使用了箭头函数和普通函数。前者的`this`绑定定义时所在的作用域（即`Timer`函数），后者的`this`指向运行时所在的作用域（即全局对象）。所以，3100 毫秒之后，`timer.s1`被更新了 3 次，而`timer.s2`一次都没更新。
 
-箭头函数可以让`this`指向固定化，这种特性很有利于封装回调函数。下面是一个例子，DOM 事件的回调函数封装在一个对象里面。
+箭头函数实际上可以让`this`指向固定化，绑定`this`使得它不再可变，这种特性很有利于封装回调函数。下面是一个例子，DOM 事件的回调函数封装在一个对象里面。
 
 ```javascript
 var handler = {
@@ -774,11 +774,11 @@ var handler = {
 };
 ```
 
-上面代码的`init`方法中，使用了箭头函数，这导致这个箭头函数里面的`this`，总是指向`handler`对象。否则，回调函数运行时，`this.doSomething`这一行会报错，因为此时`this`指向`document`对象。
+上面代码的`init()`方法中，使用了箭头函数，这导致这个箭头函数里面的`this`，总是指向`handler`对象。如果回调函数是普通函数，那么运行`this.doSomething()`这一行会报错，因为此时`this`指向`document`对象。
 
-`this`指向的固定化，并不是因为箭头函数内部有绑定`this`的机制，实际原因是箭头函数根本没有自己的`this`，导致内部的`this`就是外层代码块的`this`。正是因为它没有`this`，所以也就不能用作构造函数。
+总之，箭头函数根本没有自己的`this`，导致内部的`this`就是外层代码块的`this`。正是因为它没有`this`，所以也就不能用作构造函数。
 
-所以，箭头函数转成 ES5 的代码如下。
+下面是 Babel 转箭头函数产生的 ES5 代码，就能清楚地说明`this`的指向。
 
 ```javascript
 // ES6
@@ -800,7 +800,7 @@ function foo() {
 
 上面代码中，转换后的 ES5 版本清楚地说明了，箭头函数里面根本没有自己的`this`，而是引用外层的`this`。
 
-请问下面的代码之中有几个`this`？
+请问下面的代码之中，`this`的指向有几个？
 
 ```javascript
 function foo() {
@@ -820,7 +820,7 @@ var t2 = f().call({id: 3})(); // id: 1
 var t3 = f()().call({id: 4}); // id: 1
 ```
 
-上面代码之中，只有一个`this`，就是函数`foo`的`this`，所以`t1`、`t2`、`t3`都输出同样的结果。因为所有的内层函数都是箭头函数，都没有自己的`this`，它们的`this`其实都是最外层`foo`函数的`this`。
+答案是`this`的指向只有一个，就是函数`foo`的`this`，这是因为所有的内层函数都是箭头函数，都没有自己的`this`，它们的`this`其实都是最外层`foo`函数的`this`。所以不管怎么嵌套，`t1`、`t2`、`t3`都输出同样的结果。如果这个例子的所有内层函数都写成普通函数，那么每个函数的`this`都指向运行时所在的不同对象。
 
 除了`this`，以下三个变量在箭头函数之中也是不存在的，指向外层函数的对应变量：`arguments`、`super`、`new.target`。
 

From ee1b51ecd175675595edc685f68d1f56009b171e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 12 May 2021 08:42:53 +0800
Subject: [PATCH 145/280] docs(set-map): edit text

---
 docs/set-map.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index cafd91141..0fcfde883 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -322,7 +322,7 @@ ws.add(Symbol())
 
 其次，WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。
 
-这是因为垃圾回收机制根据对象的可达性（Reachability）来判断回收，如果对象还能被访问到即仍然可达，垃圾回收机制就不会释放这块内存。结束使用该值之后，有时会忘记取消引用，导致内存无法释放，进而可能会引发内存泄漏。WeakSet 里面的引用，都不计入垃圾回收机制，所以就不存在这个问题。因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。
+这是因为垃圾回收机制根据对象的可达性（reachability）来判断回收，如果对象还能被访问到，垃圾回收机制就不会释放这块内存。结束使用该值之后，有时会忘记取消引用，导致内存无法释放，进而可能会引发内存泄漏。WeakSet 里面的引用，都不计入垃圾回收机制，所以就不存在这个问题。因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。
 
 由于上面这个特点，WeakSet 的成员是不适合引用的，因为它会随时消失。另外，由于 WeakSet 内部有多少个成员，取决于垃圾回收机制有没有运行，运行前后很可能成员个数是不一样的，而垃圾回收机制何时运行是不可预测的，因此 ES6 规定 WeakSet 不可遍历。
 
@@ -983,7 +983,7 @@ wm.get(element) // "some information"
 
 上面代码中，先新建一个 WeakMap 实例。然后，将一个 DOM 节点作为键名存入该实例，并将一些附加信息作为键值，一起存放在 WeakMap 里面。这时，WeakMap 里面对`element`的引用就是弱引用，不会被计入垃圾回收机制。
 
-也就是说，上面的 DOM 节点对象除了 WeakMap 的弱引用外，只有一处引用。这时，一旦消除对该节点的引用，它占用的内存就会被垃圾回收机制释放。WeakMap 保存的这个键值对，也会自动消失。
+也就是说，上面的 DOM 节点对象除了 WeakMap 的弱引用外，其他位置对该对象的引用一旦消除，该对象占用的内存就会被垃圾回收机制释放。WeakMap 保存的这个键值对，也会自动消失。
 
 总之，`WeakMap`的专用场合就是，它的键所对应的对象，可能会在将来消失。`WeakMap`结构有助于防止内存泄漏。
 

From d41bf835a189a2f93b5881e720c35196f6590a1b Mon Sep 17 00:00:00 2001
From: daungui <fyyz31311@gmail.com>
Date: Fri, 14 May 2021 23:27:51 +0800
Subject: [PATCH 146/280] =?UTF-8?q?docs(function):=20=E8=B0=83=E6=95=B4?=
 =?UTF-8?q?=E4=B8=8D=E5=90=88=E9=80=82=E7=9A=84=E5=87=BD=E6=95=B0=E6=8F=8F?=
 =?UTF-8?q?=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/function.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/function.md b/docs/function.md
index a826c8814..d5a8e4eda 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -669,7 +669,7 @@ const square = n => n * n;
 箭头函数的一个用处是简化回调函数。
 
 ```javascript
-// 正常函数写法
+// 普通函数写法
 [1,2,3].map(function (x) {
   return x * x;
 });
@@ -681,7 +681,7 @@ const square = n => n * n;
 另一个例子是
 
 ```javascript
-// 正常函数写法
+// 普通函数写法
 var result = values.sort(function (a, b) {
   return a - b;
 });
@@ -716,7 +716,7 @@ headAndTail(1, 2, 3, 4, 5)
 
 （4）不可以使用`yield`命令，因此箭头函数不能用作 Generator 函数。
 
-上面四点中，最重要的是第一点。对于普通函数来说，内部的`this`代表函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的`this`对象，内部的`this`就是一个普通变量，指向定义时上层函数所在的对象。也就是说，箭头函数内部的`this`指向是固定的，相比之下，普通函数的`this`指向是可变的。
+上面四点中，最重要的是第一点。对于普通函数来说，内部的`this`指向函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的`this`对象，内部的`this`就是定义时上层作用域中的`this`。也就是说，箭头函数内部的`this`指向是固定的，相比之下，普通函数的`this`指向是可变的。
 
 ```javascript
 function foo() {

From 53cb4d3ef806575686238cf74df611fe04fe9f5e Mon Sep 17 00:00:00 2001
From: daungui <fyyz31311@gmail.com>
Date: Sun, 16 May 2021 00:39:45 +0800
Subject: [PATCH 147/280] =?UTF-8?q?docs:=20=E4=BF=AE=E6=AD=A3=E5=B7=B2?=
 =?UTF-8?q?=E7=9F=A5=E7=9A=84=20this=20=E6=9C=AF=E8=AF=AD=E9=94=99?=
 =?UTF-8?q?=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/class.md | 2 +-
 docs/let.md   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 528fac0bd..f613a60e2 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -253,7 +253,7 @@ point.hasOwnProperty('toString') // false
 point.__proto__.hasOwnProperty('toString') // true
 ```
 
-上面代码中，`x`和`y`都是实例对象`point`自身的属性（因为定义在`this`变量上），所以`hasOwnProperty()`方法返回`true`，而`toString()`是原型对象的属性（因为定义在`Point`类上），所以`hasOwnProperty()`方法返回`false`。这些都与 ES5 的行为保持一致。
+上面代码中，`x`和`y`都是实例对象`point`自身的属性（因为定义在`this`对象上），所以`hasOwnProperty()`方法返回`true`，而`toString()`是原型对象的属性（因为定义在`Point`类上），所以`hasOwnProperty()`方法返回`false`。这些都与 ES5 的行为保持一致。
 
 与 ES5 一样，类的所有实例共享一个原型对象。
 
diff --git a/docs/let.md b/docs/let.md
index e5a7c8b3e..9bb8782d1 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -599,7 +599,7 @@ JavaScript 语言存在一个顶层对象，它提供全局环境（即全局作
 - 浏览器和 Web Worker 里面，`self`也指向顶层对象，但是 Node 没有`self`。
 - Node 里面，顶层对象是`global`，但其他环境都不支持。
 
-同一段代码为了能够在各种环境，都能取到顶层对象，现在一般是使用`this`变量，但是有局限性。
+同一段代码为了能够在各种环境，都能取到顶层对象，现在一般是使用`this`关键字，但是有局限性。
 
 - 全局环境中，`this`会返回顶层对象。但是，Node.js 模块中`this`返回的是当前模块，ES6 模块中`this`返回的是`undefined`。
 - 函数里面的`this`，如果函数不是作为对象的方法运行，而是单纯作为函数运行，`this`会指向顶层对象。但是，严格模式下，这时`this`会返回`undefined`。

From 89370afc1ce03750af7f3eb4469c9e6deec0d65b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 24 May 2021 19:06:00 +0800
Subject: [PATCH 148/280] =?UTF-8?q?docs(class):=20=E6=B7=BB=E5=8A=A0=20in?=
 =?UTF-8?q?=20=E8=BF=90=E7=AE=97=E7=AC=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/class.md | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 111 insertions(+)

diff --git a/docs/class.md b/docs/class.md
index f613a60e2..391194087 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -924,6 +924,117 @@ FakeMath.#computeRandomNumber() // 报错
 
 上面代码中，`#totallyRandomNumber`是私有属性，`#computeRandomNumber()`是私有方法，只能在`FakeMath`这个类的内部调用，外部调用就会报错。
 
+### in 运算符
+
+`try...catch`结构可以用来判断是否存在某个私有属性。
+
+```javascript
+class A {
+  use(obj) {
+    try {
+      obj.#foo;
+    } catch {
+      // 私有属性 #foo 不存在
+    }
+  }
+}
+
+const a = new A();
+a.use(a); // 报错
+```
+
+上面示例中，类`A`并不存在私有属性`#foo`，所以`try...catch`报错了。
+
+这样的写法很麻烦，可读性很差，V8 引擎改进了`in`运算符，使它也可以用来判断私有属性。
+
+```javascript
+class A {
+  use(obj) {
+    if (#foo in obj) {
+      // 私有属性 #foo 存在
+    } else {
+      // 私有属性 #foo 不存在
+    }
+  }
+}
+```
+
+上面示例中，`in`运算符判断当前类`A`的实例，是否有私有属性`#foo`，如果有返回`true`，否则返回`false`。
+
+`in`也可以跟`this`一起配合使用。
+
+```javascript
+class A {
+  #foo = 0;
+  m() {
+    console.log(#foo in this); // true
+    console.log(#bar in this); // false
+  }
+}
+```
+
+注意，判断私有属性时，`in`只能用在定义该私有属性的类的内部。
+
+```javascript
+class A {
+  #foo = 0;
+  static test(obj) {
+    console.log(#foo in obj);
+  }
+}
+
+A.test(new A()) // true
+A.test({}) // false
+
+class B {
+  #foo = 0;
+}
+
+A.test(new B()) // false
+```
+
+上面示例中，类`A`的私有属性`#foo`，只能在类`A`内部使用`in`运算符判断，而且只对`A`的实例返回`true`，对于其他对象都返回`false`。
+
+子类从父类继承的私有属性，也可以使用`in`运算符来判断。
+
+```javascript
+class A {
+  #foo = 0;
+  static test(obj) {
+    console.log(#foo in obj);
+  }
+}
+
+class SubA extend A {};
+
+A.test(new SubA()) // true
+```
+
+上面示例中，`SubA`从父类继承了私有属性`#foo`，`in`运算符也有效。
+
+注意，`in`运算符对于`Object.create()`、`Object.setPrototypeOf`形成的继承，是无效的，因为这种继承不会传递私有属性。
+
+```javascript
+class A {
+  #foo = 0;
+  static test(obj) {
+    console.log(#foo in obj);
+  }
+}
+const a = new A();
+
+const o1 = Object.create(a);
+A.test(o1) // false
+A.test(o1.__proto__) // true
+
+const o2 = {};
+Object.setPrototypeOf(o2, A);
+A.test(o2) // false
+A.test(o2.__proto__) // true
+```
+
+上面示例中，对于修改原型链形成的继承，子类都取不到父类的私有属性，所以`in`运算符无效。
+
 ## new.target 属性
 
 `new`是从构造函数生成实例对象的命令。ES6 为`new`命令引入了一个`new.target`属性，该属性一般用在构造函数之中，返回`new`命令作用于的那个构造函数。如果构造函数不是通过`new`命令或`Reflect.construct()`调用的，`new.target`会返回`undefined`，因此这个属性可以用来确定构造函数是怎么调用的。

From 8e236cb8b2584ea7b2e4eb2f754155f8ef28571c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 2 Jun 2021 20:26:21 +0800
Subject: [PATCH 149/280] refactor: edit support banner

---
 js/ditto.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 417363ea1..fd92bf0bc 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年2月18日
-  var deadline = new Date(2021, 1, 18);
+  // 2021年6月7日
+  var deadline = new Date(2021, 5, 7);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -258,10 +258,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【免费资料】' +
-    '<span style="color: #4682BE;">Excel + Python + SQL 数据处理入门</span>，课程资料下载。';
+  var text = '【前端课程】' +
+    '<span style="color: #4682BE;">《React Hooks 核心原理与实战》</span>通过实战案例，详细讲解 Hooks，现在优惠中。';
 
-  var banner = $('<a href="https://t.1yb.co/gXGw" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://sourl.cn/zDZrCg" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From fdac6ccb2e93dc4956e8b8ab10cdfaa912b4ca73 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 10 Jul 2021 14:58:15 +0800
Subject: [PATCH 150/280] docs: add ES2021

---
 docs/number.md    | 124 ++++++++++++++-----
 docs/object.md    | 229 ----------------------------------
 docs/operator.md  | 309 ++++++++++++++++++++++++++++++++++++++++++++++
 docs/promise.md   |  39 +++---
 docs/proposals.md |  77 ------------
 docs/set-map.md   | 148 ++++++++++++++++++++++
 6 files changed, 571 insertions(+), 355 deletions(-)
 create mode 100644 docs/operator.md

diff --git a/docs/number.md b/docs/number.md
index 250e7e735..c21067e00 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -31,6 +31,97 @@ Number('0b111')  // 7
 Number('0o10')  // 8
 ```
 
+## 数值分隔符
+
+欧美语言中，较长的数值允许每三位添加一个分隔符（通常是一个逗号），增加数值的可读性。比如，`1000`可以写作`1,000`。
+
+[ES2021](https://github.com/tc39/proposal-numeric-separator)，允许 JavaScript 的数值使用下划线（`_`）作为分隔符。
+
+```javascript
+let budget = 1_000_000_000_000;
+budget === 10 ** 12 // true
+```
+
+这个数值分隔符没有指定间隔的位数，也就是说，可以每三位添加一个分隔符，也可以每一位、每两位、每四位添加一个。
+
+```javascript
+123_00 === 12_300 // true
+
+12345_00 === 123_4500 // true
+12345_00 === 1_234_500 // true
+```
+
+小数和科学计数法也可以使用数值分隔符。
+
+```javascript
+// 小数
+0.000_001
+
+// 科学计数法
+1e10_000
+```
+
+数值分隔符有几个使用注意点。
+
+- 不能放在数值的最前面（leading）或最后面（trailing）。
+- 不能两个或两个以上的分隔符连在一起。
+- 小数点的前后不能有分隔符。
+- 科学计数法里面，表示指数的`e`或`E`前后不能有分隔符。
+
+下面的写法都会报错。
+
+```javascript
+// 全部报错
+3_.141
+3._141
+1_e12
+1e_12
+123__456
+_1464301
+1464301_
+```
+
+除了十进制，其他进制的数值也可以使用分隔符。
+
+```javascript
+// 二进制
+0b1010_0001_1000_0101
+// 十六进制
+0xA0_B0_C0
+```
+
+可以看到，数值分隔符可以按字节顺序分隔数值，这在操作二进制位时，非常有用。
+
+注意，分隔符不能紧跟着进制的前缀`0b`、`0B`、`0o`、`0O`、`0x`、`0X`。
+
+```javascript
+// 报错
+0_b111111000
+0b_111111000
+```
+
+数值分隔符只是一种书写便利，对于 JavaScript 内部数值的存储和输出，并没有影响。
+
+```javascript
+let num = 12_345;
+
+num // 12345
+num.toString() // 12345
+```
+
+上面示例中，变量`num`的值为`12_345`，但是内部存储和输出的时候，都不会有数值分隔符。
+
+下面三个将字符串转成数值的函数，不支持数值分隔符。主要原因是语言的设计者认为，数值分隔符主要是为了编码时书写数值的方便，而不是为了处理外部输入的数据。
+
+- Number()
+- parseInt()
+- parseFloat()
+
+```javascript
+Number('123_456') // NaN
+parseInt('123_456') // 123
+```
+
 ## Number.isFinite(), Number.isNaN()
 
 ES6 在`Number`对象上，新提供了`Number.isFinite()`和`Number.isNaN()`两个方法。
@@ -655,42 +746,11 @@ ES6 新增了 6 个双曲函数方法。
 - `Math.acosh(x)` 返回`x`的反双曲余弦（inverse hyperbolic cosine）
 - `Math.atanh(x)` 返回`x`的反双曲正切（inverse hyperbolic tangent）
 
-## 指数运算符
-
-ES2016 新增了一个指数运算符（`**`）。
-
-```javascript
-2 ** 2 // 4
-2 ** 3 // 8
-```
-
-这个运算符的一个特点是右结合，而不是常见的左结合。多个指数运算符连用时，是从最右边开始计算的。
-
-```javascript
-// 相当于 2 ** (3 ** 2)
-2 ** 3 ** 2
-// 512
-```
-
-上面代码中，首先计算的是第二个指数运算符，而不是第一个。
-
-指数运算符可以与等号结合，形成一个新的赋值运算符（`**=`）。
-
-```javascript
-let a = 1.5;
-a **= 2;
-// 等同于 a = a * a;
-
-let b = 4;
-b **= 3;
-// 等同于 b = b * b * b;
-```
-
 ## BigInt 数据类型
 
 ### 简介
 
-JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算。二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回`Infinity`。
+JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。一是数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数，JavaScript 是无法精确表示，这使得 JavaScript 不适合进行科学和金融方面的精确计算。二是大于或等于2的1024次方的数值，JavaScript 无法表示，会返回`Infinity`。
 
 ```javascript
 // 超过 53 个二进制位的数值，无法保持精度
diff --git a/docs/object.md b/docs/object.md
index 5b8395bc7..d2965e818 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -704,232 +704,3 @@ let aWithXGetter = { ...a }; // 报错
 
 上面例子中，取值函数`get`在扩展`a`对象时会自动执行，导致报错。
 
-## 链判断运算符
-
-编程实务中，如果读取对象内部的某个属性，往往需要判断一下该对象是否存在。比如，要读取`message.body.user.firstName`，安全的写法是写成下面这样。
-
-```javascript
-// 错误的写法
-const  firstName = message.body.user.firstName;
-
-// 正确的写法
-const firstName = (message
-  && message.body
-  && message.body.user
-  && message.body.user.firstName) || 'default';
-```
-
-上面例子中，`firstName`属性在对象的第四层，所以需要判断四次，每一层是否有值。
-
-三元运算符`?:`也常用于判断对象是否存在。
-
-```javascript
-const fooInput = myForm.querySelector('input[name=foo]')
-const fooValue = fooInput ? fooInput.value : undefined
-```
-
-上面例子中，必须先判断`fooInput`是否存在，才能读取`fooInput.value`。
-
-这样的层层判断非常麻烦，因此 [ES2020](https://github.com/tc39/proposal-optional-chaining) 引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
-
-```javascript
-const firstName = message?.body?.user?.firstName || 'default';
-const fooValue = myForm.querySelector('input[name=foo]')?.value
-```
-
-上面代码使用了`?.`运算符，直接在链式调用的时候判断，左侧的对象是否为`null`或`undefined`。如果是的，就不再往下运算，而是返回`undefined`。
-
-下面是判断对象方法是否存在，如果存在就立即执行的例子。
-
-```javascript
-iterator.return?.()
-```
-
-上面代码中，`iterator.return`如果有定义，就会调用该方法，否则`iterator.return`直接返回`undefined`，不再执行`?.`后面的部分。
-
-对于那些可能没有实现的方法，这个运算符尤其有用。
-
-```javascript
-if (myForm.checkValidity?.() === false) {
-  // 表单校验失败
-  return;
-}
-```
-
-上面代码中，老式浏览器的表单可能没有`checkValidity`这个方法，这时`?.`运算符就会返回`undefined`，判断语句就变成了`undefined === false`，所以就会跳过下面的代码。
-
-链判断运算符有三种用法。
-
-- `obj?.prop` // 对象属性
-- `obj?.[expr]` // 同上
-- `func?.(...args)` // 函数或对象方法的调用
-
-下面是`obj?.[expr]`用法的一个例子。
-
-```bash
-let hex = "#C0FFEE".match(/#([A-Z]+)/i)?.[1];
-```
-
-上面例子中，字符串的`match()`方法，如果没有发现匹配会返回`null`，如果发现匹配会返回一个数组，`?.`运算符起到了判断作用。
-
-下面是`?.`运算符常见形式，以及不使用该运算符时的等价形式。
-
-```javascript
-a?.b
-// 等同于
-a == null ? undefined : a.b
-
-a?.[x]
-// 等同于
-a == null ? undefined : a[x]
-
-a?.b()
-// 等同于
-a == null ? undefined : a.b()
-
-a?.()
-// 等同于
-a == null ? undefined : a()
-```
-
-上面代码中，特别注意后两种形式，如果`a?.b()`里面的`a.b`不是函数，不可调用，那么`a?.b()`是会报错的。`a?.()`也是如此，如果`a`不是`null`或`undefined`，但也不是函数，那么`a?.()`会报错。
-
-使用这个运算符，有几个注意点。
-
-（1）短路机制
-
-`?.`运算符相当于一种短路机制，只要不满足条件，就不再往下执行。
-
-```javascript
-a?.[++x]
-// 等同于
-a == null ? undefined : a[++x]
-```
-
-上面代码中，如果`a`是`undefined`或`null`，那么`x`不会进行递增运算。也就是说，链判断运算符一旦为真，右侧的表达式就不再求值。
-
-（2）delete 运算符
-
-```javascript
-delete a?.b
-// 等同于
-a == null ? undefined : delete a.b
-```
-
-上面代码中，如果`a`是`undefined`或`null`，会直接返回`undefined`，而不会进行`delete`运算。
-
-（3）括号的影响
-
-如果属性链有圆括号，链判断运算符对圆括号外部没有影响，只对圆括号内部有影响。
-
-```javascript
-(a?.b).c
-// 等价于
-(a == null ? undefined : a.b).c
-```
-
-上面代码中，`?.`对圆括号外部没有影响，不管`a`对象是否存在，圆括号后面的`.c`总是会执行。
-
-一般来说，使用`?.`运算符的场合，不应该使用圆括号。
-
-（4）报错场合
-
-以下写法是禁止的，会报错。
-
-```javascript
-// 构造函数
-new a?.()
-new a?.b()
-
-// 链判断运算符的右侧有模板字符串
-a?.`{b}`
-a?.b`{c}`
-
-// 链判断运算符的左侧是 super
-super?.()
-super?.foo
-
-// 链运算符用于赋值运算符左侧
-a?.b = c
-```
-
-（5）右侧不得为十进制数值
-
-为了保证兼容以前的代码，允许`foo?.3:0`被解析成`foo ? .3 : 0`，因此规定如果`?.`后面紧跟一个十进制数字，那么`?.`不再被看成是一个完整的运算符，而会按照三元运算符进行处理，也就是说，那个小数点会归属于后面的十进制数字，形成一个小数。
-
-## Null 判断运算符
-
-读取对象属性的时候，如果某个属性的值是`null`或`undefined`，有时候需要为它们指定默认值。常见做法是通过`||`运算符指定默认值。
-
-```javascript
-const headerText = response.settings.headerText || 'Hello, world!';
-const animationDuration = response.settings.animationDuration || 300;
-const showSplashScreen = response.settings.showSplashScreen || true;
-```
-
-上面的三行代码都通过`||`运算符指定默认值，但是这样写是错的。开发者的原意是，只要属性的值为`null`或`undefined`，默认值就会生效，但是属性的值如果为空字符串或`false`或`0`，默认值也会生效。
-
-为了避免这种情况，[ES2020](https://github.com/tc39/proposal-nullish-coalescing) 引入了一个新的 Null 判断运算符`??`。它的行为类似`||`，但是只有运算符左侧的值为`null`或`undefined`时，才会返回右侧的值。
-
-```javascript
-const headerText = response.settings.headerText ?? 'Hello, world!';
-const animationDuration = response.settings.animationDuration ?? 300;
-const showSplashScreen = response.settings.showSplashScreen ?? true;
-```
-
-上面代码中，默认值只有在左侧属性值为`null`或`undefined`时，才会生效。
-
-这个运算符的一个目的，就是跟链判断运算符`?.`配合使用，为`null`或`undefined`的值设置默认值。
-
-```javascript
-const animationDuration = response.settings?.animationDuration ?? 300;
-```
-
-上面代码中，如果`response.settings`是`null`或`undefined`，或者`response.settings.animationDuration`是`null`或`undefined`，就会返回默认值300。也就是说，这一行代码包括了两级属性的判断。
-
-这个运算符很适合判断函数参数是否赋值。
-
-```javascript
-function Component(props) {
-  const enable = props.enabled ?? true;
-  // …
-}
-```
-
-上面代码判断`props`参数的`enabled`属性是否赋值，基本等同于下面的写法。
-
-```javascript
-function Component(props) {
-  const {
-    enabled: enable = true,
-  } = props;
-  // …
-}
-```
-
-`??`有一个运算优先级问题，它与`&&`和`||`的优先级孰高孰低。现在的规则是，如果多个逻辑运算符一起使用，必须用括号表明优先级，否则会报错。
-
-```javascript
-// 报错
-lhs && middle ?? rhs
-lhs ?? middle && rhs
-lhs || middle ?? rhs
-lhs ?? middle || rhs
-```
-
-上面四个表达式都会报错，必须加入表明优先级的括号。
-
-```javascript
-(lhs && middle) ?? rhs;
-lhs && (middle ?? rhs);
-
-(lhs ?? middle) && rhs;
-lhs ?? (middle && rhs);
-
-(lhs || middle) ?? rhs;
-lhs || (middle ?? rhs);
-
-(lhs ?? middle) || rhs;
-lhs ?? (middle || rhs);
-```
-
diff --git a/docs/operator.md b/docs/operator.md
new file mode 100644
index 000000000..e3958b43a
--- /dev/null
+++ b/docs/operator.md
@@ -0,0 +1,309 @@
+# 运算符的扩展
+
+本章介绍 ES6 后续标准添加的一些运算符。
+
+## 指数运算符
+
+ES2016 新增了一个指数运算符（`**`）。
+
+```javascript
+2 ** 2 // 4
+2 ** 3 // 8
+```
+
+这个运算符的一个特点是右结合，而不是常见的左结合。多个指数运算符连用时，是从最右边开始计算的。
+
+```javascript
+// 相当于 2 ** (3 ** 2)
+2 ** 3 ** 2
+// 512
+```
+
+上面代码中，首先计算的是第二个指数运算符，而不是第一个。
+
+指数运算符可以与等号结合，形成一个新的赋值运算符（`**=`）。
+
+```javascript
+let a = 1.5;
+a **= 2;
+// 等同于 a = a * a;
+
+let b = 4;
+b **= 3;
+// 等同于 b = b * b * b;
+```
+
+## 链判断运算符
+
+编程实务中，如果读取对象内部的某个属性，往往需要判断一下，属性的上层对象是否存在。比如，读取`message.body.user.firstName`这个属性，安全的写法是写成下面这样。
+
+```javascript
+// 错误的写法
+const  firstName = message.body.user.firstName || 'default';
+
+// 正确的写法
+const firstName = (message
+  && message.body
+  && message.body.user
+  && message.body.user.firstName) || 'default';
+```
+
+上面例子中，`firstName`属性在对象的第四层，所以需要判断四次，每一层是否有值。
+
+三元运算符`?:`也常用于判断对象是否存在。
+
+```javascript
+const fooInput = myForm.querySelector('input[name=foo]')
+const fooValue = fooInput ? fooInput.value : undefined
+```
+
+上面例子中，必须先判断`fooInput`是否存在，才能读取`fooInput.value`。
+
+这样的层层判断非常麻烦，因此 [ES2020](https://github.com/tc39/proposal-optional-chaining) 引入了“链判断运算符”（optional chaining operator）`?.`，简化上面的写法。
+
+```javascript
+const firstName = message?.body?.user?.firstName || 'default';
+const fooValue = myForm.querySelector('input[name=foo]')?.value
+```
+
+上面代码使用了`?.`运算符，直接在链式调用的时候判断，左侧的对象是否为`null`或`undefined`。如果是的，就不再往下运算，而是返回`undefined`。
+
+下面是判断对象方法是否存在，如果存在就立即执行的例子。
+
+```javascript
+iterator.return?.()
+```
+
+上面代码中，`iterator.return`如果有定义，就会调用该方法，否则`iterator.return`直接返回`undefined`，不再执行`?.`后面的部分。
+
+对于那些可能没有实现的方法，这个运算符尤其有用。
+
+```javascript
+if (myForm.checkValidity?.() === false) {
+  // 表单校验失败
+  return;
+}
+```
+
+上面代码中，老式浏览器的表单对象可能没有`checkValidity()`这个方法，这时`?.`运算符就会返回`undefined`，判断语句就变成了`undefined === false`，所以就会跳过下面的代码。
+
+链判断运算符`?.`有三种写法。
+
+- `obj?.prop` // 对象属性是否存在
+- `obj?.[expr]` // 同上
+- `func?.(...args)` // 函数或对象方法是否存在
+
+下面是`obj?.[expr]`用法的一个例子。
+
+```bash
+let hex = "#C0FFEE".match(/#([A-Z]+)/i)?.[1];
+```
+
+上面例子中，字符串的`match()`方法，如果没有发现匹配会返回`null`，如果发现匹配会返回一个数组，`?.`运算符起到了判断作用。
+
+下面是`?.`运算符常见形式，以及不使用该运算符时的等价形式。
+
+```javascript
+a?.b
+// 等同于
+a == null ? undefined : a.b
+
+a?.[x]
+// 等同于
+a == null ? undefined : a[x]
+
+a?.b()
+// 等同于
+a == null ? undefined : a.b()
+
+a?.()
+// 等同于
+a == null ? undefined : a()
+```
+
+上面代码中，特别注意后两种形式，如果`a?.b()`和`a?.()`。如果`a?.b()`里面的`a.b`有值，但不是函数，不可调用，那么`a?.b()`是会报错的。`a?.()`也是如此，如果`a`不是`null`或`undefined`，但也不是函数，那么`a?.()`会报错。
+
+使用这个运算符，有几个注意点。
+
+（1）短路机制
+
+本质上，`?.`运算符相当于一种短路机制，只要不满足条件，就不再往下执行。
+
+```javascript
+a?.[++x]
+// 等同于
+a == null ? undefined : a[++x]
+```
+
+上面代码中，如果`a`是`undefined`或`null`，那么`x`不会进行递增运算。也就是说，链判断运算符一旦为真，右侧的表达式就不再求值。
+
+（2）括号的影响
+
+如果属性链有圆括号，链判断运算符对圆括号外部没有影响，只对圆括号内部有影响。
+
+```javascript
+(a?.b).c
+// 等价于
+(a == null ? undefined : a.b).c
+```
+
+上面代码中，`?.`对圆括号外部没有影响，不管`a`对象是否存在，圆括号后面的`.c`总是会执行。
+
+一般来说，使用`?.`运算符的场合，不应该使用圆括号。
+
+（3）报错场合
+
+以下写法是禁止的，会报错。
+
+```javascript
+// 构造函数
+new a?.()
+new a?.b()
+
+// 链判断运算符的右侧有模板字符串
+a?.`{b}`
+a?.b`{c}`
+
+// 链判断运算符的左侧是 super
+super?.()
+super?.foo
+
+// 链运算符用于赋值运算符左侧
+a?.b = c
+```
+
+（4）右侧不得为十进制数值
+
+为了保证兼容以前的代码，允许`foo?.3:0`被解析成`foo ? .3 : 0`，因此规定如果`?.`后面紧跟一个十进制数字，那么`?.`不再被看成是一个完整的运算符，而会按照三元运算符进行处理，也就是说，那个小数点会归属于后面的十进制数字，形成一个小数。
+
+## Null 判断运算符
+
+读取对象属性的时候，如果某个属性的值是`null`或`undefined`，有时候需要为它们指定默认值。常见做法是通过`||`运算符指定默认值。
+
+```javascript
+const headerText = response.settings.headerText || 'Hello, world!';
+const animationDuration = response.settings.animationDuration || 300;
+const showSplashScreen = response.settings.showSplashScreen || true;
+```
+
+上面的三行代码都通过`||`运算符指定默认值，但是这样写是错的。开发者的原意是，只要属性的值为`null`或`undefined`，默认值就会生效，但是属性的值如果为空字符串或`false`或`0`，默认值也会生效。
+
+为了避免这种情况，[ES2020](https://github.com/tc39/proposal-nullish-coalescing) 引入了一个新的 Null 判断运算符`??`。它的行为类似`||`，但是只有运算符左侧的值为`null`或`undefined`时，才会返回右侧的值。
+
+```javascript
+const headerText = response.settings.headerText ?? 'Hello, world!';
+const animationDuration = response.settings.animationDuration ?? 300;
+const showSplashScreen = response.settings.showSplashScreen ?? true;
+```
+
+上面代码中，默认值只有在左侧属性值为`null`或`undefined`时，才会生效。
+
+这个运算符的一个目的，就是跟链判断运算符`?.`配合使用，为`null`或`undefined`的值设置默认值。
+
+```javascript
+const animationDuration = response.settings?.animationDuration ?? 300;
+```
+
+上面代码中，如果`response.settings`是`null`或`undefined`，或者`response.settings.animationDuration`是`null`或`undefined`，就会返回默认值300。也就是说，这一行代码包括了两级属性的判断。
+
+这个运算符很适合判断函数参数是否赋值。
+
+```javascript
+function Component(props) {
+  const enable = props.enabled ?? true;
+  // …
+}
+```
+
+上面代码判断`props`参数的`enabled`属性是否赋值，基本等同于下面的写法。
+
+```javascript
+function Component(props) {
+  const {
+    enabled: enable = true,
+  } = props;
+  // …
+}
+```
+
+`??`本质上是逻辑运算，它与其他两个逻辑运算符`&&`和`||`有一个优先级问题，它们之间的优先级到底孰高孰低。优先级的不同，往往会导致逻辑运算的结果不同。
+
+现在的规则是，如果多个逻辑运算符一起使用，必须用括号表明优先级，否则会报错。
+
+```javascript
+// 报错
+lhs && middle ?? rhs
+lhs ?? middle && rhs
+lhs || middle ?? rhs
+lhs ?? middle || rhs
+```
+
+上面四个表达式都会报错，必须加入表明优先级的括号。
+
+```javascript
+(lhs && middle) ?? rhs;
+lhs && (middle ?? rhs);
+
+(lhs ?? middle) && rhs;
+lhs ?? (middle && rhs);
+
+(lhs || middle) ?? rhs;
+lhs || (middle ?? rhs);
+
+(lhs ?? middle) || rhs;
+lhs ?? (middle || rhs);
+```
+
+## 逻辑赋值运算符
+
+ES2021 引入了三个新的[逻辑赋值运算符](https://github.com/tc39/proposal-logical-assignment)（logical assignment operators），将逻辑运算符与赋值运算符进行结合。
+
+```javascript
+// 或赋值运算符
+x ||= y
+// 等同于
+x || (x = y)
+
+// 与赋值运算符
+x &&= y
+// 等同于
+x && (x = y)
+
+// Null 赋值运算符
+x ??= y
+// 等同于
+x ?? (x = y)
+```
+
+这三个运算符`||=`、`&&=`、`??=`相当于先进行逻辑运算，然后根据运算结果，再视情况进行赋值运算。
+
+它们的一个用途是，为变量或属性设置默认值。
+
+```javascript
+// 老的写法
+user.id = user.id || 1;
+
+// 新的写法
+user.id ||= 1;
+```
+
+上面示例中，`user.id`属性如果不存在，则设为`1`，新的写法比老的写法更紧凑一些。
+
+下面是另一个例子。
+
+```javascript
+function example(opts) {
+  opts.foo = opts.foo ?? 'bar';
+  opts.baz ?? (opts.baz = 'qux');
+}
+```
+
+上面示例中，参数对象`opts`如果不存在属性`foo`和属性`bar`，则为这两个属性设置默认值。有了“Null 赋值运算符”以后，就可以统一写成下面这样。
+
+```javascript
+function example(opts) {
+  opts.foo ??= 'bar';
+  opts.baz ??= 'qux';
+}
+```
+
diff --git a/docs/promise.md b/docs/promise.md
index 02c1d0611..ea5b04758 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -758,9 +758,25 @@ try {
 
 ## Promise.any()
 
-ES2021 引入了[`Promise.any()`方法](https://github.com/tc39/proposal-promise-any)。该方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例返回。只要参数实例有一个变成`fulfilled`状态，包装实例就会变成`fulfilled`状态；如果所有参数实例都变成`rejected`状态，包装实例就会变成`rejected`状态。
+ES2021 引入了[`Promise.any()`方法](https://github.com/tc39/proposal-promise-any)。该方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例返回。
 
-`Promise.any()`跟`Promise.race()`方法很像，只有一点不同，就是不会因为某个 Promise 变成`rejected`状态而结束。
+```javascript
+Promise.any([
+  fetch('https://v8.dev/').then(() => 'home'),
+  fetch('https://v8.dev/blog').then(() => 'blog'),
+  fetch('https://v8.dev/docs').then(() => 'docs')
+]).then((first) => {  // 只要有一个 fetch() 请求成功
+  console.log(first);
+}).catch((error) => { // 所有三个 fetch() 全部请求失败
+  console.log(error);
+});
+```
+
+只要参数实例有一个变成`fulfilled`状态，包装实例就会变成`fulfilled`状态；如果所有参数实例都变成`rejected`状态，包装实例就会变成`rejected`状态。
+
+`Promise.any()`跟`Promise.race()`方法很像，只有一点不同，就是`Promise.any()`不会因为某个 Promise 变成`rejected`状态而结束，必须等到所有参数 Promise 变成`rejected`状态才会结束。
+
+下面是`Promise()`与`await`命令结合使用的例子。
 
 ```javascript
 const promises = [
@@ -768,6 +784,7 @@ const promises = [
   fetch('/endpoint-b').then(() => 'b'),
   fetch('/endpoint-c').then(() => 'c'),
 ];
+
 try {
   const first = await Promise.any(promises);
   console.log(first);
@@ -778,30 +795,18 @@ try {
 
 上面代码中，`Promise.any()`方法的参数数组包含三个 Promise 操作。其中只要有一个变成`fulfilled`，`Promise.any()`返回的 Promise 对象就变成`fulfilled`。如果所有三个操作都变成`rejected`，那么`await`命令就会抛出错误。
 
-`Promise.any()`抛出的错误，不是一个一般的错误，而是一个 AggregateError 实例。它相当于一个数组，每个成员对应一个被`rejected`的操作所抛出的错误。下面是 AggregateError 的实现示例。
+`Promise.any()`抛出的错误，不是一个一般的 Error 错误对象，而是一个 AggregateError 实例。它相当于一个数组，每个成员对应一个被`rejected`的操作所抛出的错误。下面是 AggregateError 的实现示例。
 
 ```javascript
-new AggregateError() extends Array -> AggregateError
+// new AggregateError() extends Array
 
 const err = new AggregateError();
 err.push(new Error("first error"));
 err.push(new Error("second error"));
+// ...
 throw err;
 ```
 
-捕捉错误时，如果不用`try...catch`结构和 await 命令，可以像下面这样写。
-
-```javascript
-Promise.any(promises).then(
-  (first) => {
-    // Any of the promises was fulfilled.
-  },
-  (error) => {
-    // All of the promises were rejected.
-  }
-);
-```
-
 下面是一个例子。
 
 ```javascript
diff --git a/docs/proposals.md b/docs/proposals.md
index 543905570..4fb68488b 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -314,83 +314,6 @@ const userAge = userId |> await fetchUserById |> getAgeFromUser;
 const userAge = getAgeFromUser(await fetchUserById(userId));
 ```
 
-## 数值分隔符
-
-欧美语言中，较长的数值允许每三位添加一个分隔符（通常是一个逗号），增加数值的可读性。比如，`1000`可以写作`1,000`。
-
-现在有一个[提案](https://github.com/tc39/proposal-numeric-separator)，允许 JavaScript 的数值使用下划线（`_`）作为分隔符。
-
-```javascript
-let budget = 1_000_000_000_000;
-budget === 10 ** 12 // true
-```
-
-JavaScript 的数值分隔符没有指定间隔的位数，也就是说，可以每三位添加一个分隔符，也可以每一位、每两位、每四位添加一个。
-
-```javascript
-123_00 === 12_300 // true
-
-12345_00 === 123_4500 // true
-12345_00 === 1_234_500 // true
-```
-
-小数和科学计数法也可以使用数值分隔符。
-
-```javascript
-// 小数
-0.000_001
-// 科学计数法
-1e10_000
-```
-
-数值分隔符有几个使用注意点。
-
-- 不能在数值的最前面（leading）或最后面（trailing）。
-- 不能两个或两个以上的分隔符连在一起。
-- 小数点的前后不能有分隔符。
-- 科学计数法里面，表示指数的`e`或`E`前后不能有分隔符。
-
-下面的写法都会报错。
-
-```javascript
-// 全部报错
-3_.141
-3._141
-1_e12
-1e_12
-123__456
-_1464301
-1464301_
-```
-
-除了十进制，其他进制的数值也可以使用分隔符。
-
-```javascript
-// 二进制
-0b1010_0001_1000_0101
-// 十六进制
-0xA0_B0_C0
-```
-
-注意，分隔符不能紧跟着进制的前缀`0b`、`0B`、`0o`、`0O`、`0x`、`0X`。
-
-```javascript
-// 报错
-0_b111111000
-0b_111111000
-```
-
-下面三个将字符串转成数值的函数，不支持数值分隔符。主要原因是提案的设计者认为，数值分隔符主要是为了编码时书写数值的方便，而不是为了处理外部输入的数据。
-
-- Number()
-- parseInt()
-- parseFloat()
-
-```javascript
-Number('123_456') // NaN
-parseInt('123_456') // 123
-```
-
 ## Math.signbit()
 
 `Math.sign()`用来判断一个值的正负，但是如果参数是`-0`，它会返回`-0`。
diff --git a/docs/set-map.md b/docs/set-map.md
index 0fcfde883..ac2ca3e79 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -1140,3 +1140,151 @@ c.dec()
 
 上面代码中，`Countdown`类的两个内部属性`_counter`和`_action`，是实例的弱引用，所以如果删除实例，它们也就随之消失，不会造成内存泄漏。
 
+## WeakRef
+
+WeakSet 和 WeakMap 是基于弱引用的数据结构，[ES2021](https://github.com/tc39/proposal-weakrefs) 更进一步，提供了 WeakRef 对象，用于直接创建对象的弱引用。
+
+```javascript
+let target = {};
+let wr = new WeakRef(target);
+```
+
+上面示例中，`target`是原始对象，构造函数`WeakRef()`创建了一个基于`target`的新对象`wr`。这里，`wr`就是一个 WeakRef 的示例，属于对`target`的弱引用，垃圾回收机制不会计入这个引用，也就是说，`wr`的引入不会妨碍原始对象`target`被垃圾回收机制清除。
+
+WeakRef 实例对象有一个`deref()`方法，如果原始对象存在，该方法返回原始对象；如果原始对象已经被垃圾回收机制清除，该方法返回`undefined`。
+
+```javascript
+let target = {};
+let wr = new WeakRef(target);
+
+let obj = wr.deref();
+if (obj) { // target 未被垃圾回收机制清除
+  // ...
+}
+```
+
+上面示例中，`deref()`方法可以判断原始对象是否已被清除。
+
+弱引用对象的一大用处，就是作为缓存，未被清除时可以从缓存取值，一旦清除缓存就自动失效。
+
+```javascript
+function makeWeakCached(f) {
+  const cache = new Map();
+  return key => {
+    const ref = cache.get(key);
+    if (ref) {
+      const cached = ref.deref();
+      if (cached !== undefined) return cached;
+    }
+
+    const fresh = f(key);
+    cache.set(key, new WeakRef(fresh));
+    return fresh;
+  };
+}
+
+const getImageCached = makeWeakCached(getImage);
+```
+
+上面示例中，`makeWeakCached()`用于建立一个缓存，缓存里面保存对原始文件的弱引用。
+
+注意，标准规定，一旦使用`WeakRef()`创建了原始对象的弱引用，那么在本轮事件循环（event loop），原始对象肯定不会被清除，只会在后面的事件循环才会被清除。
+
+## FinalizationRegistry
+
+[ES2021](https://github.com/tc39/proposal-weakrefs#finalizers) 引入了清理器注册表功能 FinalizationRegistry，用来指定目标对象被垃圾回收机制清除以后，所要执行的回调函数。
+
+首先，新建一个注册表实例。
+
+```javascript
+const registry = new FinalizationRegistry(heldValue => {
+  // ....
+});
+```
+
+上面代码中，`FinalizationRegistry()`是系统提供的构造函数，返回一个清理器注册表实例，里面登记了所要执行的回调函数。回调函数作为`FinalizationRegistry()`的参数传入，它本身有一个参数`heldValue`。
+
+然后，注册表实例的`register()`方法，用来注册所要观察的目标对象。
+
+```javascript
+registry.register(theObject, "some value");
+```
+
+上面示例中，`theObject`就是所要观察的目标对象，一旦该对象被垃圾回收机制清除，注册表就会在清除完成后，调用早前注册的回调函数，并将`some value`作为参数（前面的`heldValue`）传入回调函数。
+
+注意，注册表不对目标对象`theObject`构成强引用，属于弱引用。因为强引用的话，原始对象就不会被垃圾回收机制清除，这就失去使用注册表的意义了。
+
+回调函数的参数`heldValue`可以是任意类型的值，字符串、数值、布尔值、对象，甚至可以是`undefined`。
+
+最后，如果以后还想取消已经注册的回调函数，则要向`register()`传入第三个参数，作为标记值。这个标记值必须是对象，一般都用原始对象。接着，再使用注册表实例对象的`unregister()`方法取消注册。
+
+```javascript
+registry.register(theObject, "some value", theObject);
+// ...其他操作...
+registry.unregister(theObject);
+```
+
+上面代码中，`register()`方法的第三个参数就是标记值`theObject`。取消回调函数时，要使用`unregister()`方法，并将标记值作为该方法的参数。这里`register()`方法对第三个参数的引用，也属于弱引用。如果没有这个参数，则回调函数无法取消。
+
+由于回调函数被调用以后，就不再存在于注册表之中了，所以执行`unregister()`应该是在回调函数还没被调用之前。
+
+下面使用`FinalizationRegistry`，对前一节的缓存函数进行增强。
+
+```javascript
+function makeWeakCached(f) {
+  const cache = new Map();
+  const cleanup = new FinalizationRegistry(key => {
+    const ref = cache.get(key);
+    if (ref && !ref.deref()) cache.delete(key);
+  });
+
+  return key => {
+    const ref = cache.get(key);
+    if (ref) {
+      const cached = ref.deref();
+      if (cached !== undefined) return cached;
+    }
+
+    const fresh = f(key);
+    cache.set(key, new WeakRef(fresh));
+    cleanup.register(fresh, key);
+    return fresh;
+  };
+}
+
+const getImageCached = makeWeakCached(getImage);
+```
+
+上面示例与前一节的例子相比，就是增加一个清理器注册表，一旦缓存的原始对象被垃圾回收机制清除，会自动执行一个回调函数。该回调函数会清除缓存里面已经失效的键。
+
+下面是另一个例子。
+
+```javascript
+class Thingy {
+  #file;
+  #cleanup = file => {
+    console.error(
+      `The \`release\` method was never called for the \`Thingy\` for the file "${file.name}"`
+    );
+  };
+  #registry = new FinalizationRegistry(this.#cleanup);
+
+  constructor(filename) {
+    this.#file = File.open(filename);
+    this.#registry.register(this, this.#file, this.#file);
+  }
+
+  release() {
+    if (this.#file) {
+      this.#registry.unregister(this.#file);
+      File.close(this.#file);
+      this.#file = null;
+    }
+  }
+}
+```
+
+上面示例中，如果由于某种原因，`Thingy`类的实例对象没有调用`release()`方法，就被垃圾回收机制清除了，那么清理器就会调用回调函数`#cleanup()`，输出一条错误信息。
+
+由于无法知道清理器何时会执行，所以最好避免使用它。另外，如果浏览器窗口关闭或者进程意外退出，清理器则不会运行。
+

From 9181f78036646474aa597ae91542b411bf1bc4f2 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 10 Jul 2021 14:59:18 +0800
Subject: [PATCH 151/280] refactor: update chapters

---
 sidebar.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sidebar.md b/sidebar.md
index 8d3579f54..1d167e9c4 100644
--- a/sidebar.md
+++ b/sidebar.md
@@ -17,6 +17,7 @@
 1. [数组的扩展](#docs/array)
 1. [对象的扩展](#docs/object)
 1. [对象的新增方法](#docs/object-methods)
+1. [运算符的扩展](#docs/operator)
 1. [Symbol](#docs/symbol)
 1. [Set 和 Map 数据结构](#docs/set-map)
 1. [Proxy](#docs/proxy)

From 145e84021d12ece8be356760efefaaf58bbb407b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8E=8B=E6=B0=B8=E8=BE=89?=
 <39959340+yonghui-wang@users.noreply.github.com>
Date: Wed, 14 Jul 2021 17:02:26 +0800
Subject: [PATCH 152/280] Update async.md

console.log missing a )
---
 docs/async.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/async.md b/docs/async.md
index 532c1a366..5d9376a79 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -771,7 +771,7 @@ import { output } from "./awaiting.js";
 function outputPlusValue(value) { return output + value }
 
 console.log(outputPlusValue(100));
-setTimeout(() => console.log(outputPlusValue(100), 1000);
+setTimeout(() => console.log(outputPlusValue(100)), 1000);
 ```
 
 上面代码中，`outputPlusValue()`的执行结果，完全取决于执行的时间。如果`awaiting.js`里面的异步操作没执行完，加载进来的`output`的值就是`undefined`。
@@ -801,7 +801,7 @@ function outputPlusValue(value) { return output + value }
 
 promise.then(() => {
   console.log(outputPlusValue(100));
-  setTimeout(() => console.log(outputPlusValue(100), 1000);
+  setTimeout(() => console.log(outputPlusValue(100)), 1000);
 });
 ```
 
@@ -828,7 +828,7 @@ import { output } from "./awaiting.js";
 function outputPlusValue(value) { return output + value }
 
 console.log(outputPlusValue(100));
-setTimeout(() => console.log(outputPlusValue(100), 1000);
+setTimeout(() => console.log(outputPlusValue(100)), 1000);
 ```
 
 上面代码的写法，与普通的模块加载完全一样。也就是说，模块的使用者完全不用关心，依赖模块的内部有没有异步操作，正常加载即可。

From 6a972dfdee91c752709089cdb5ecb16c72db2ad8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 15 Jul 2021 00:12:22 +0800
Subject: [PATCH 153/280] docs(operator): fix WeakRef typo

---
 docs/set-map.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index ac2ca3e79..cc6159db1 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -1149,7 +1149,7 @@ let target = {};
 let wr = new WeakRef(target);
 ```
 
-上面示例中，`target`是原始对象，构造函数`WeakRef()`创建了一个基于`target`的新对象`wr`。这里，`wr`就是一个 WeakRef 的示例，属于对`target`的弱引用，垃圾回收机制不会计入这个引用，也就是说，`wr`的引入不会妨碍原始对象`target`被垃圾回收机制清除。
+上面示例中，`target`是原始对象，构造函数`WeakRef()`创建了一个基于`target`的新对象`wr`。这里，`wr`就是一个 WeakRef 的实例，属于对`target`的弱引用，垃圾回收机制不会计入这个引用，也就是说，`wr`的引用不会妨碍原始对象`target`被垃圾回收机制清除。
 
 WeakRef 实例对象有一个`deref()`方法，如果原始对象存在，该方法返回原始对象；如果原始对象已经被垃圾回收机制清除，该方法返回`undefined`。
 

From 9d51292b694a15eb19f8864c6660f3e01fde2a4b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?bieyanghong=E3=80=82?=
 <41629560+ThroughTheNight@users.noreply.github.com>
Date: Thu, 22 Jul 2021 17:11:21 +0800
Subject: [PATCH 154/280] Update let.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

增加一个解释，方便刚入门的同学理解。
---
 docs/let.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/let.md b/docs/let.md
index 9bb8782d1..8a7c3ea17 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -71,7 +71,7 @@ for (let i = 0; i < 3; i++) {
 // abc
 ```
 
-上面代码正确运行，输出了 3 次`abc`。这表明函数内部的变量`i`与循环变量`i`不在同一个作用域，有各自单独的作用域。
+上面代码正确运行，输出了 3 次`abc`。这表明函数内部的变量`i`与循环变量`i`不在同一个作用域，有各自单独的作用域（同一个作用域不可使用 `let` 重复声明同一个变量）。
 
 ### 不存在变量提升
 

From 864c2c09aaf364fe90b4b3fe58001cf72d54fad2 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 22 Jul 2021 17:17:02 +0800
Subject: [PATCH 155/280] =?UTF-8?q?docs(proposals):=20JSON=20=E6=A8=A1?=
 =?UTF-8?q?=E5=9D=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/proposals.md | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/docs/proposals.md b/docs/proposals.md
index 4fb68488b..c565d01be 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -555,3 +555,47 @@ import.meta.scriptElement.dataset.foo
 // "abc"
 ```
 
+## JSON 模块
+
+import 命令目前只能用于加载 ES 模块，现在有一个[提案](https://github.com/tc39/proposal-json-modules)，允许加载 JSON 模块。
+
+假定有一个 JSON 模块文件`config.json`。
+
+```javascript
+{
+  "appName": "My App"
+}
+```
+
+目前，只能使用`fetch()`加载 JSON 模块。
+
+```javascript
+const response = await fetch('./config.json');
+const json = await response.json();
+```
+
+import 命令能够直接加载 JSON 模块以后，就可以像下面这样写。
+
+```javascript
+import configData from './config.json' assert { type: "json" };
+console.log(configData.appName);
+```
+
+上面示例中，整个 JSON 对象被导入为`configData`对象，然后就可以从该对象获取 JSON 数据。
+
+`import`命令导入 JSON 模块时，命令结尾的`assert {type: "json"}`不可缺少。这叫做导入断言，用来告诉 JavaScript 引擎，现在加载的是 JSON 模块。你可能会问，为什么不通过`.json`后缀名判断呢？因为浏览器的传统是不通过后缀名判断文件类型，标准委员会希望遵循这种做法，这样也可以避免一些安全问题。
+
+导入断言是 JavaScript 导入其他格式模块的标准写法，JSON 模块将是第一个使用这种语法导入的模块。以后，还会支持导入 CSS 模块、HTML 模块等等。
+
+动态加载模块的`import()`函数也支持加载 JSON 模块。
+
+```javascript
+import('./config.json', { assert: { type: 'json' } })
+```
+
+脚本加载 JSON 模块以后，还可以再用 export 命令输出。这时，可以将 export 和 import 结合成一个语句。
+
+```javascript
+export { config } from './config.json' assert { type: 'json' };
+```
+

From 4ead6a067fbf4f9e8592167fd2988aa29096a8e6 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 28 Jul 2021 01:32:44 +0800
Subject: [PATCH 156/280] docs(class): fix typo #1065

---
 docs/class.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index 391194087..868ea8359 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1005,7 +1005,7 @@ class A {
   }
 }
 
-class SubA extend A {};
+class SubA extends A {};
 
 A.test(new SubA()) // true
 ```

From 1f57596bb112291093c6a05982bdf6a7d2f2db1f Mon Sep 17 00:00:00 2001
From: "Mr.Care" <50878376+MrCare@users.noreply.github.com>
Date: Sat, 31 Jul 2021 14:38:19 +0800
Subject: [PATCH 157/280] =?UTF-8?q?=E4=B8=80=E5=A4=84=E7=AC=94=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

在字符串 replaceAll（）方法中的第二个参数的说明部分，按照笔者的意思`$&` 应当代表匹配的“字符串”，而不是匹配的“子字符串”
---
 docs/string-methods.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 2fbb76174..1d4b3fc06 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -376,7 +376,7 @@ String.prototype.replaceAll(searchValue, replacement)
 
 `replaceAll()`的第二个参数`replacement`是一个字符串，表示替换的文本，其中可以使用一些特殊字符串。
 
-- `$&`：匹配的子字符串。
+- `$&`：匹配的字符串。
 - `` $` ``：匹配结果前面的文本。
 - `$'`：匹配结果后面的文本。
 - `$n`：匹配成功的第`n`组内容，`n`是从1开始的自然数。这个参数生效的前提是，第一个参数必须是正则表达式。

From 9cf2cca1a8e15f735f5056537fc164948bcf7721 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 4 Aug 2021 16:27:37 +0800
Subject: [PATCH 158/280] refactor: edit support banner

---
 js/ditto.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index fd92bf0bc..0d1e7218e 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年6月7日
-  var deadline = new Date(2021, 5, 7);
+  // 2021年9月6日
+  var deadline = new Date(2021, 8, 6);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -258,10 +258,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【前端课程】' +
-    '<span style="color: #4682BE;">《React Hooks 核心原理与实战》</span>通过实战案例，详细讲解 Hooks，现在优惠中。';
+  var text = '【免费课程】' +
+    '开课吧<span style="color: #4682BE;">《深度理解 Vue 3.0 核心源码》</span>精品课领取，讲解 Vue 3.0 源码，动手制作实战项目，快速上手Vue 3.0。';
 
-  var banner = $('<a href="https://sourl.cn/zDZrCg" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://t.1yb.co/xNGr" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 562c688e3d654f85af523438858472e11fba8700 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?bieyanghong=E3=80=82?=
 <41629560+ThroughTheNight@users.noreply.github.com>
Date: Fri, 6 Aug 2021 15:13:37 +0800
Subject: [PATCH 159/280] Update function.md

---
 docs/function.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/function.md b/docs/function.md
index d5a8e4eda..e59b7bda1 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -418,7 +418,7 @@ add(2, 5, 3) // 10
 ```javascript
 // arguments变量的写法
 function sortNumbers() {
-  return Array.prototype.slice.call(arguments).sort();
+  return Array.from(arguments).sort();
 }
 
 // rest参数的写法
@@ -427,7 +427,7 @@ const sortNumbers = (...numbers) => numbers.sort();
 
 上面代码的两种写法，比较后可以发现，rest 参数的写法更自然也更简洁。
 
-`arguments`对象不是数组，而是一个类似数组的对象。所以为了使用数组的方法，必须使用`Array.prototype.slice.call`先将其转为数组。rest 参数就不存在这个问题，它就是一个真正的数组，数组特有的方法都可以使用。下面是一个利用 rest 参数改写数组`push`方法的例子。
+`arguments`对象不是数组，而是一个类似数组的对象。所以为了使用数组的方法，必须使用`Array.from`先将其转为数组。rest 参数就不存在这个问题，它就是一个真正的数组，数组特有的方法都可以使用。下面是一个利用 rest 参数改写数组`push`方法的例子。
 
 ```javascript
 function push(array, ...items) {

From 0549983c536f4d5cda1760b8874d163403be3dfa Mon Sep 17 00:00:00 2001
From: An Hongpeng <79783808+roc-an@users.noreply.github.com>
Date: Fri, 6 Aug 2021 17:22:59 +0800
Subject: [PATCH 160/280] =?UTF-8?q?fix:=20BigInt=20=E4=B8=8D=E6=98=AF?=
 =?UTF-8?q?=E6=9E=84=E9=80=A0=E5=87=BD=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/number.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/number.md b/docs/number.md
index c21067e00..e9904c567 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -830,9 +830,9 @@ for (let i = 1n; i <= 70n; i++) {
 console.log(p); // 11978571...00000000n
 ```
 
-### BigInt 对象
+### BigInt 函数
 
-JavaScript 原生提供`BigInt`对象，可以用作构造函数生成 BigInt 类型的数值。转换规则基本与`Number()`一致，将其他类型的值转为 BigInt。
+JavaScript 原生提供`BigInt`函数，可以用它生成 BigInt 类型的数值。转换规则基本与`Number()`一致，将其他类型的值转为 BigInt。
 
 ```javascript
 BigInt(123) // 123n
@@ -841,7 +841,7 @@ BigInt(false) // 0n
 BigInt(true) // 1n
 ```
 
-`BigInt()`构造函数必须有参数，而且参数必须可以正常转为数值，下面的用法都会报错。
+`BigInt()`函数必须有参数，而且参数必须可以正常转为数值，下面的用法都会报错。
 
 ```javascript
 new BigInt() // TypeError
@@ -860,7 +860,7 @@ BigInt(1.5) // RangeError
 BigInt('1.5') // SyntaxError
 ```
 
-BigInt 对象继承了 Object 对象的两个实例方法。
+BigInt 继承了 Object 对象的两个实例方法。
 
 - `BigInt.prototype.toString()`
 - `BigInt.prototype.valueOf()`

From a802e37d78d8c11be6b6c9fb8c5c0848a923c575 Mon Sep 17 00:00:00 2001
From: newbeman <coderen@foxmail.com>
Date: Sat, 7 Aug 2021 17:01:04 +0800
Subject: [PATCH 161/280] Update operator.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

参数对象`opts`如果不存在属性`foo`和属性`bar`
变更为
参数对象`opts`如果不存在属性`foo`和属性`baz`
---
 docs/operator.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/operator.md b/docs/operator.md
index e3958b43a..6d72c666c 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -298,7 +298,7 @@ function example(opts) {
 }
 ```
 
-上面示例中，参数对象`opts`如果不存在属性`foo`和属性`bar`，则为这两个属性设置默认值。有了“Null 赋值运算符”以后，就可以统一写成下面这样。
+上面示例中，参数对象`opts`如果不存在属性`foo`和属性`baz`，则为这两个属性设置默认值。有了“Null 赋值运算符”以后，就可以统一写成下面这样。
 
 ```javascript
 function example(opts) {

From de8fad91c77948e28dd08451c5205baa0b571101 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 9 Aug 2021 17:20:00 +0800
Subject: [PATCH 162/280] docs(promise): edit Promise.allSettled()

---
 docs/promise.md | 58 +++++++++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index ea5b04758..0474ceed5 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -691,7 +691,27 @@ p
 
 ## Promise.allSettled()
 
-`Promise.allSettled()`方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果，不管是`fulfilled`还是`rejected`，包装实例才会结束。该方法由 [ES2020](https://github.com/tc39/proposal-promise-allSettled) 引入。
+有时候，我们希望等到一组异步操作都结束了，不管每一个操作是成功还是失败，再进行下一步操作。但是，现有的 Promise 方法很难实现这个要求。
+
+`Promise.all()`方法只适合所有异步操作都成功的情况，如果有一个操作失败，就无法满足要求。
+
+```javascript
+const urls = [url_1, url_2, url_3];
+const requests = urls.map(x => fetch(x));
+
+try {
+  await Promise.all(requests);
+  console.log('所有请求都成功。');
+} catch {
+  console.log('至少一个请求失败，其他请求可能还没结束。');
+}
+```
+
+上面示例中，`Promise.all()`可以确定所有请求都成功了，但是只要有一个请求失败，它就会报错，而不管另外的请求是否结束。
+
+为了解决这个问题，[ES2020](https://github.com/tc39/proposal-promise-allSettled) 引入了`Promise.allSettled()`方法，用来确定一组异步操作是否都结束了（不管成功或失败）。所以，它的名字叫做”Settled“，包含了”fulfilled“和”rejected“两种情况。
+
+`Promise.allSettled()`方法接受一个数组作为参数，数组的每个成员都是一个 Promise 对象，并返回一个新的 Promise 对象。只有等到参数数组的所有 Promise 对象都发生状态变更（不管是`fulfilled`还是`rejected`），返回的 Promise 对象才会发生状态变更。
 
 ```javascript
 const promises = [
@@ -704,9 +724,9 @@ await Promise.allSettled(promises);
 removeLoadingIndicator();
 ```
 
-上面代码对服务器发出三个请求，等到三个请求都结束，不管请求成功还是失败，加载的滚动图标就会消失。
+上面示例中，数组`promises`包含了三个请求，只有等到这三个请求都结束了（不管请求成功还是失败），`removeLoadingIndicator()`才会执行。
 
-该方法返回的新的 Promise 实例，一旦结束，状态总是`fulfilled`，不会变成`rejected`。状态变成`fulfilled`后，Promise 的监听函数接收到的参数是一个数组，每个成员对应一个传入`Promise.allSettled()`的 Promise 实例。
+该方法返回的新的 Promise 实例，一旦发生状态变更，状态总是`fulfilled`，不会变成`rejected`。状态变成`fulfilled`后，它的回调函数会接收到一个数组作为参数，该数组的每个成员对应前面数组的每个 Promise 对象。
 
 ```javascript
 const resolved = Promise.resolve(42);
@@ -723,9 +743,21 @@ allSettledPromise.then(function (results) {
 // ]
 ```
 
-上面代码中，`Promise.allSettled()`的返回值`allSettledPromise`，状态只可能变成`fulfilled`。它的监听函数接收到的参数是数组`results`。该数组的每个成员都是一个对象，对应传入`Promise.allSettled()`的两个 Promise 实例。每个对象都有`status`属性，该属性的值只可能是字符串`fulfilled`或字符串`rejected`。`fulfilled`时，对象有`value`属性，`rejected`时有`reason`属性，对应两种状态的返回值。
+上面代码中，`Promise.allSettled()`的返回值`allSettledPromise`，状态只可能变成`fulfilled`。它的回调函数接收到的参数是数组`results`。该数组的每个成员都是一个对象，对应传入`Promise.allSettled()`的数组里面的两个 Promise 对象。
+
+`results`的每个成员是一个对象，对象的格式是固定的，对应异步操作的结果。
+
+```javascript
+// 异步操作成功时
+{status: 'fulfilled', value: value}
+
+// 异步操作失败时
+{status: 'rejected', reason: reason}
+```
+
+成员对象的`status`属性的值只可能是字符串`fulfilled`或字符串`rejected`，用来区分异步操作是成功还是失败。如果是成功（`fulfilled`），对象会有`value`属性，如果是失败（`rejected`），会有`reason`属性，对应两种状态时前面异步操作的返回值。
 
-下面是返回值用法的例子。
+下面是返回值的用法例子。
 
 ```javascript
 const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
@@ -740,22 +772,6 @@ const errors = results
   .map(p => p.reason);
 ```
 
-有时候，我们不关心异步操作的结果，只关心这些操作有没有结束。这时，`Promise.allSettled()`方法就很有用。如果没有这个方法，想要确保所有操作都结束，就很麻烦。`Promise.all()`方法无法做到这一点。
-
-```javascript
-const urls = [ /* ... */ ];
-const requests = urls.map(x => fetch(x));
-
-try {
-  await Promise.all(requests);
-  console.log('所有请求都成功。');
-} catch {
-  console.log('至少一个请求失败，其他请求可能还没结束。');
-}
-```
-
-上面代码中，`Promise.all()`无法确定所有请求都结束。想要达到这个目的，写起来很麻烦，有了`Promise.allSettled()`，这就很容易了。
-
 ## Promise.any()
 
 ES2021 引入了[`Promise.any()`方法](https://github.com/tc39/proposal-promise-any)。该方法接受一组 Promise 实例作为参数，包装成一个新的 Promise 实例返回。

From 47dec55486be2010a16a41cc0e8af6bc9e42e4f2 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 2 Sep 2021 08:29:12 +0800
Subject: [PATCH 163/280] =?UTF-8?q?docs(class):=20=E5=8A=A0=E5=85=A5=20sta?=
 =?UTF-8?q?tic=20block?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/class.md | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/docs/class.md b/docs/class.md
index 868ea8359..69cff93c1 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1035,6 +1035,87 @@ A.test(o2.__proto__) // true
 
 上面示例中，对于修改原型链形成的继承，子类都取不到父类的私有属性，所以`in`运算符无效。
 
+## 静态块
+
+静态属性的一个问题是，它的初始化要么写在类的外部，要么写在`constructor()`方法里面。
+
+```javascript
+class C {
+  static x = 234;
+  static y;
+  static z;
+}
+
+try {
+  const obj = doSomethingWith(C.x);
+  C.y = obj.y
+  C.z = obj.z;
+} catch {
+  C.y = ...;
+  C.z = ...;
+}
+```
+
+上面示例中，静态属性`y`和`z`的值依赖静态属性`x`，它们的初始化写在类的外部（上例的`try...catch`代码块）。另一种方法是写到类的`constructor()`方法里面。这两种方法都不是很理想，前者是将类的内部逻辑写到了外部，后者则是每次新建实例都会运行一次。
+
+为了解决这个问题，ES2022 引入了[静态块](https://github.com/tc39/proposal-class-static-block)（static block），允许在类的内部设置一个代码块，在类生成时运行一次，主要作用是对静态属性进行初始化。
+
+```javascript
+class C {
+  static x = ...;
+  static y;
+  static z;
+
+  static {
+    try {
+      const obj = doSomethingWith(this.x);
+      this.y = obj.y;
+      this.z = obj.z;
+    }
+    catch {
+      this.y = ...;
+      this.z = ...;
+    }
+  }
+}
+```
+
+上面代码中，类的内部有一个 static 代码块，这就是静态块。它的好处是将静态属性`y`和`z`的初始化逻辑，写入了类的内部，而且只运行一次。
+
+每个类只能有一个静态块，在静态属性声明后运行。静态块的内部不能有`return`语句。
+
+静态块内部可以使用类名或`this`，指代当前类。
+
+```c
+class C {
+  static x = 1;
+  static {
+    this.x; // 1
+    // 或者
+    C.x; // 1
+  }
+}
+```
+
+上面示例中，`this.x`和`C.x`都能获取静态属性`x`。
+
+除了静态属性的初始化，静态块还有一个作用，就是将私有属性与类的外部代码分享。
+
+```javascript
+let getX;
+
+export class C {
+  #x = 1;
+  static {
+    getX = obj => obj.#x;
+  }
+}
+
+console.log(getX(new C())); // 1
+```
+
+上面示例中，`#x`是类的私有属性，如果类外部的`getX()`方法希望获取这个属性，以前是要写在类的`constructor()`方法里面，这样的话，每次新建实例都会定义一次`getX()`方法。现在可以写在静态块里面，这样的话，只在类生成时定义一次。
+
 ## new.target 属性
 
 `new`是从构造函数生成实例对象的命令。ES6 为`new`命令引入了一个`new.target`属性，该属性一般用在构造函数之中，返回`new`命令作用于的那个构造函数。如果构造函数不是通过`new`命令或`Reflect.construct()`调用的，`new.target`会返回`undefined`，因此这个属性可以用来确定构造函数是怎么调用的。

From d50868c4bb65d760e07eb8fa9fb3b5976b98d6a1 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 2 Sep 2021 20:03:21 +0800
Subject: [PATCH 164/280] refactor: edit support banner

---
 js/ditto.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 0d1e7218e..f0565c2d0 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年9月6日
-  var deadline = new Date(2021, 8, 6);
+  // 2021年10月9日
+  var deadline = new Date(2021, 9, 9);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -261,7 +261,7 @@ function create_banner(element) {
   var text = '【免费课程】' +
     '开课吧<span style="color: #4682BE;">《深度理解 Vue 3.0 核心源码》</span>精品课领取，讲解 Vue 3.0 源码，动手制作实战项目，快速上手Vue 3.0。';
 
-  var banner = $('<a href="https://t.1yb.co/xNGr" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://t.1yb.co/AzbY" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 84dba5689b5b718a445ea6b9992ad787e9143d4e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 8 Sep 2021 18:37:50 +0800
Subject: [PATCH 165/280] docs(style): fixed #1076

---
 docs/style.md | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/docs/style.md b/docs/style.md
index 42fd61da6..45f7d88c0 100644
--- a/docs/style.md
+++ b/docs/style.md
@@ -437,16 +437,6 @@ export default Breadcrumbs;
 
 如果模块只有一个输出值，就使用`export default`，如果模块有多个输出值，就不使用`export default`，`export default`与普通的`export`不要同时使用。
 
-不要在模块输入中使用通配符。因为这样可以确保你的模块之中，有一个默认输出（export default）。
-
-```javascript
-// bad
-import * as myObject from './importModule';
-
-// good
-import myObject from './importModule';
-```
-
 如果模块默认输出一个函数，函数名的首字母应该小写。
 
 ```javascript

From 248b51a5df069e6dfdc774b199a911d8ce5768e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B0=AD=E4=B9=9D=E9=BC=8E?= <109224573@qq.com>
Date: Wed, 8 Sep 2021 21:25:53 +0800
Subject: [PATCH 166/280] =?UTF-8?q?fix=20typo:=20=E6=88=96=20->=20?=
 =?UTF-8?q?=E4=BC=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 22a2e5047..18b4f4c47 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -439,7 +439,7 @@ import submodule from './node_modules/es-module-package/private-module.js';
 }
 ```
 
-注意，如果同时还有其他别名，就不能采用简写，否则或报错。
+注意，如果同时还有其他别名，就不能采用简写，否则会报错。
 
 ```javascript
 {

From daa455fb2ac2db87f424d42ad9b7849fc7f54449 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B0=AD=E4=B9=9D=E9=BC=8E?= <109224573@qq.com>
Date: Thu, 9 Sep 2021 09:14:43 +0800
Subject: [PATCH 167/280] use https for some links

---
 404.html              |  2 +-
 README.md             |  2 +-
 book.json             |  2 +-
 docs/class-extends.md |  2 +-
 docs/let.md           |  2 +-
 docs/proposals.md     |  2 +-
 docs/reference.md     | 82 +++++++++++++++++++++----------------------
 docs/spec.md          | 10 +++---
 sidebar.md            |  6 ++--
 9 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/404.html b/404.html
index 66b119741..f70820f17 100644
--- a/404.html
+++ b/404.html
@@ -2,7 +2,7 @@
   <head>
     <title>ES6标准参考教程</title>
     <script>
-      var loc = 'http://es6.ruanyifeng.com';
+      var loc = 'https://es6.ruanyifeng.com';
       var regex = /http:\/\/es6\.ruanyifeng\.com\/docs\/([^#]+)#(.+)/;
       var result = regex.exec(window.location);
       if (result) {
diff --git a/README.md b/README.md
index 2fbff3ee7..84de1b82f 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@
 
 - [淘宝](https://s.taobao.com/search?q=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8+%E7%AC%AC3%E7%89%88)
 - [京东](https://search.jd.com/Search?keyword=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8%20%E7%AC%AC3%E7%89%88&enc=utf-8&wq=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8%20%E7%AC%AC3%E7%89%88)
-- [当当](http://product.dangdang.com/25156888.html)
+- [当当](https://product.dangdang.com/25156888.html)
 - [亚马逊](https://www.amazon.cn/ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8-%E9%98%AE%E4%B8%80%E5%B3%B0/dp/B0755547ZZ)
 - [China-pub](http://product.china-pub.com/6504650)
 
diff --git a/book.json b/book.json
index be5d775bd..6a3112367 100644
--- a/book.json
+++ b/book.json
@@ -13,7 +13,7 @@
 	  "weibo": null
 	},
 	"sidebar": {
-	  "阮一峰的个人网站": "http://www.ruanyifeng.com/blog/"
+	  "阮一峰的个人网站": "https://www.ruanyifeng.com/blog/"
 	}
   },
   "output": null,
diff --git a/docs/class-extends.md b/docs/class-extends.md
index e4a540f0d..f9944b674 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -654,7 +654,7 @@ myerror.stack
 //     ...
 ```
 
-注意，继承`Object`的子类，有一个[行为差异](http://stackoverflow.com/questions/36203614/super-does-not-pass-arguments-when-instantiating-a-class-extended-from-object)。
+注意，继承`Object`的子类，有一个[行为差异](https://stackoverflow.com/questions/36203614/super-does-not-pass-arguments-when-instantiating-a-class-extended-from-object)。
 
 ```javascript
 class NewObj extends Object{
diff --git a/docs/let.md b/docs/let.md
index 8a7c3ea17..82d30940a 100644
--- a/docs/let.md
+++ b/docs/let.md
@@ -374,7 +374,7 @@ function f() { console.log('I am outside!'); }
 
 上面的代码在 ES6 浏览器中，都会报错。
 
-原来，如果改变了块级作用域内声明的函数的处理规则，显然会对老代码产生很大影响。为了减轻因此产生的不兼容问题，ES6 在[附录 B](http://www.ecma-international.org/ecma-262/6.0/index.html#sec-block-level-function-declarations-web-legacy-compatibility-semantics)里面规定，浏览器的实现可以不遵守上面的规定，有自己的[行为方式](http://stackoverflow.com/questions/31419897/what-are-the-precise-semantics-of-block-level-functions-in-es6)。
+原来，如果改变了块级作用域内声明的函数的处理规则，显然会对老代码产生很大影响。为了减轻因此产生的不兼容问题，ES6 在[附录 B](https://www.ecma-international.org/ecma-262/6.0/index.html#sec-block-level-function-declarations-web-legacy-compatibility-semantics)里面规定，浏览器的实现可以不遵守上面的规定，有自己的[行为方式](https://stackoverflow.com/questions/31419897/what-are-the-precise-semantics-of-block-level-functions-in-es6)。
 
 - 允许在块级作用域内声明函数。
 - 函数声明类似于`var`，即会提升到全局作用域或函数作用域的头部。
diff --git a/docs/proposals.md b/docs/proposals.md
index c565d01be..2e7a2282a 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -328,7 +328,7 @@ Math.sign(-0) // -0
 +0 === -0 // true
 ```
 
-目前，有一个[提案](http://jfbastien.github.io/papers/Math.signbit.html)，引入了`Math.signbit()`方法判断一个数的符号位是否设置了。
+目前，有一个[提案](https://jfbastien.github.io/papers/Math.signbit.html)，引入了`Math.signbit()`方法判断一个数的符号位是否设置了。
 
 ```javascript
 Math.signbit(2) //false
diff --git a/docs/reference.md b/docs/reference.md
index 909c21cc0..bb3f87c71 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -2,8 +2,8 @@
 
 ## 官方文件
 
-- [ECMAScript® 2015 Language Specification](http://www.ecma-international.org/ecma-262/6.0/index.html): ECMAScript 2015 规格
-- [ECMAScript® 2016 Language Specification](http://www.ecma-international.org/ecma-262/7.0/): ECMAScript 2016 规格
+- [ECMAScript® 2015 Language Specification](https://www.ecma-international.org/ecma-262/6.0/index.html): ECMAScript 2015 规格
+- [ECMAScript® 2016 Language Specification](https://www.ecma-international.org/ecma-262/7.0/): ECMAScript 2016 规格
 - [ECMAScript® 2017 Language Specification](https://tc39.github.io/ecma262/)：ECMAScript 2017 规格（草案）
 - [ECMAScript Current Proposals](https://github.com/tc39/ecma262): ECMAScript 当前的所有提案
 - [ECMAScript Active Proposals](https://github.com/tc39/proposals): 已经进入正式流程的提案
@@ -28,7 +28,7 @@
 - Luke Hoban, [ES6 features](https://github.com/lukehoban/es6features): ES6 新语法点的罗列
 - Traceur-compiler, [Language Features](https://github.com/google/traceur-compiler/wiki/LanguageFeatures): Traceur 文档列出的一些 ES6 例子
 - Axel Rauschmayer, [ECMAScript 6: what’s next for JavaScript?](https://speakerdeck.com/rauschma/ecmascript-6-whats-next-for-javascript-august-2014): 关于 ES6 新增语法的综合介绍，有很多例子
-- Axel Rauschmayer, [Getting started with ECMAScript 6](http://www.2ality.com/2015/08/getting-started-es6.html): ES6 语法点的综合介绍
+- Axel Rauschmayer, [Getting started with ECMAScript 6](https://2ality.com/2015/08/getting-started-es6.html): ES6 语法点的综合介绍
 - Toby Ho, [ES6 in io.js](http://davidwalsh.name/es6-io)
 - Guillermo Rauch, [ECMAScript 6](http://rauchg.com/2015/ecmascript-6/)
 - Benjamin De Cock, [Frontend Guidelines](https://github.com/bendc/frontend-guidelines): ES6 最佳实践
@@ -41,10 +41,10 @@
 
 - Kyle Simpson, [For and against let](http://davidwalsh.name/for-and-against-let): 讨论 let 命令的作用域
 - kangax, [Why typeof is no longer “safe”](http://es-discourse.com/t/why-typeof-is-no-longer-safe/15): 讨论在块级作用域内，let 命令的变量声明和赋值的行为
-- Axel Rauschmayer, [Variables and scoping in ECMAScript 6](http://www.2ality.com/2015/02/es6-scoping.html): 讨论块级作用域与 let 和 const 的行为
+- Axel Rauschmayer, [Variables and scoping in ECMAScript 6](https://2ality.com/2015/02/es6-scoping.html): 讨论块级作用域与 let 和 const 的行为
 - Nicolas Bevacqua, [ES6 Let, Const and the “Temporal Dead Zone” (TDZ) in Depth](http://ponyfoo.com/articles/es6-let-const-and-temporal-dead-zone-in-depth)
 - acorn, [Function statements in strict mode](https://github.com/ternjs/acorn/issues/118): 块级作用域对严格模式的函数声明的影响
-- Axel Rauschmayer, [ES proposal: global](http://www.2ality.com/2016/09/global.html): 顶层对象`global`
+- Axel Rauschmayer, [ES proposal: global](https://2ality.com/2016/09/global.html): 顶层对象`global`
 - Mathias Bynens, [A horrifying `globalThis` polyfill in universal JavaScript](https://mathiasbynens.be/notes/globalthis)：如何写 globalThis 的垫片库
 
 ## 解构赋值
@@ -59,41 +59,41 @@
 - Addy Osmani, [Getting Literal With ES6 Template Strings](http://updates.html5rocks.com/2015/01/ES6-Template-Strings): 模板字符串的介绍
 - Blake Winton, [ES6 Templates](https://weblog.latte.ca/blake/tech/firefox/templates.html): 模板字符串的介绍
 - Peter Jaszkowiak, [How to write a template compiler in JavaScript](https://medium.com/@PitaJ/how-to-write-a-template-compiler-in-javascript-f174df6f32f): 使用模板字符串，编写一个模板编译函数
-- Axel Rauschmayer, [ES.stage3: string padding](http://www.2ality.com/2015/11/string-padding.html)
+- Axel Rauschmayer, [ES.stage3: string padding](https://2ality.com/2015/11/string-padding.html)
 
 ## 正则
 
 - Mathias Bynens, [Unicode-aware regular expressions in ES6](https://mathiasbynens.be/notes/es6-unicode-regex): 详细介绍正则表达式的 u 修饰符
-- Axel Rauschmayer, [New regular expression features in ECMAScript 6](http://www.2ality.com/2015/07/regexp-es6.html)：ES6 正则特性的详细介绍
+- Axel Rauschmayer, [New regular expression features in ECMAScript 6](https://2ality.com/2015/07/regexp-es6.html)：ES6 正则特性的详细介绍
 - Yang Guo, [RegExp lookbehind assertions](http://v8project.blogspot.jp/2016/02/regexp-lookbehind-assertions.html)：介绍后行断言
-- Axel Rauschmayer, [ES proposal: RegExp named capture groups](http://2ality.com/2017/05/regexp-named-capture-groups.html): 具名组匹配的介绍
+- Axel Rauschmayer, [ES proposal: RegExp named capture groups](https://2ality.com/2017/05/regexp-named-capture-groups.html): 具名组匹配的介绍
 - Mathias Bynens, [ECMAScript regular expressions are getting better!](https://mathiasbynens.be/notes/es-regexp-proposals): 介绍 ES2018 添加的多项正则语法
 
 ## 数值
 
 - Nicolas Bevacqua, [ES6 Number Improvements in Depth](http://ponyfoo.com/articles/es6-number-improvements-in-depth)
-- Axel Rauschmayer, [ES proposal: arbitrary precision integers](http://2ality.com/2017/03/es-integer.html)
+- Axel Rauschmayer, [ES proposal: arbitrary precision integers](https://2ality.com/2017/03/es-integer.html)
 - Mathias Bynens, [BigInt: arbitrary-precision integers in JavaScript](https://developers.google.com/web/updates/2018/05/bigint)
 
 ## 数组
 
-- Axel Rauschmayer, [ECMAScript 6’s new array methods](http://www.2ality.com/2014/05/es6-array-methods.html): 对 ES6 新增的数组方法的全面介绍
+- Axel Rauschmayer, [ECMAScript 6’s new array methods](https://2ality.com/2014/05/es6-array-methods.html): 对 ES6 新增的数组方法的全面介绍
 - TC39, [Array.prototype.includes](https://github.com/tc39/Array.prototype.includes/): 数组的 includes 方法的规格
-- Axel Rauschmayer, [ECMAScript 6: holes in Arrays](http://www.2ality.com/2015/09/holes-arrays-es6.html): 数组的空位问题
+- Axel Rauschmayer, [ECMAScript 6: holes in Arrays](https://2ality.com/2015/09/holes-arrays-es6.html): 数组的空位问题
 
 ## 函数
 
 - Nicholas C. Zakas, [Understanding ECMAScript 6 arrow functions](http://www.nczonline.net/blog/2013/09/10/understanding-ecmascript-6-arrow-functions/)
 - Jack Franklin, [Real Life ES6 - Arrow Functions](http://javascriptplayground.com/blog/2014/04/real-life-es6-arrow-fn/)
-- Axel Rauschmayer, [Handling required parameters in ECMAScript 6](http://www.2ality.com/2014/04/required-parameters-es6.html)
+- Axel Rauschmayer, [Handling required parameters in ECMAScript 6](https://2ality.com/2014/04/required-parameters-es6.html)
 - Dmitry Soshnikov, [ES6 Notes: Default values of parameters](http://dmitrysoshnikov.com/ecmascript/es6-notes-default-values-of-parameters/): 介绍参数的默认值
 - Ragan Wald, [Destructuring and Recursion in ES6](http://raganwald.com/2015/02/02/destructuring.html): rest 参数和扩展运算符的详细介绍
-- Axel Rauschmayer, [The names of functions in ES6](http://www.2ality.com/2015/09/function-names-es6.html): 函数的 name 属性的详细介绍
+- Axel Rauschmayer, [The names of functions in ES6](https://2ality.com/2015/09/function-names-es6.html): 函数的 name 属性的详细介绍
 - Kyle Simpson, [Arrow This](http://blog.getify.com/arrow-this/): 箭头函数并没有自己的 this
 - Derick Bailey, [Do ES6 Arrow Functions Really Solve “this” In JavaScript?](http://derickbailey.com/2015/09/28/do-es6-arrow-functions-really-solve-this-in-javascript/)：使用箭头函数处理 this 指向，必须非常小心
 - Mark McDonnell, [Understanding recursion in functional JavaScript programming](http://www.integralist.co.uk/posts/js-recursion.html): 如何自己实现尾递归优化
 - Nicholas C. Zakas, [The ECMAScript 2016 change you probably don't know](https://www.nczonline.net/blog/2016/10/the-ecmascript-2016-change-you-probably-dont-know/): 使用参数默认值时，不能在函数内部显式开启严格模式
-- Axel Rauschmayer, [ES proposal: optional catch binding](http://2ality.com/2017/08/optional-catch-binding.html)
+- Axel Rauschmayer, [ES proposal: optional catch binding](https://2ality.com/2017/08/optional-catch-binding.html)
 - Cynthia Lee, [When you should use ES6 arrow functions — and when you shouldn’t](https://medium.freecodecamp.org/when-and-why-you-should-use-es6-arrow-functions-and-when-you-shouldnt-3d851d7f0b26): 讨论箭头函数的适用场合
 - Eric Elliott, [What is this?](https://medium.com/javascript-scene/what-is-this-the-inner-workings-of-javascript-objects-d397bfa0708a): 箭头函数内部的 this 的解释。
 
@@ -101,19 +101,19 @@
 
 - Addy Osmani, [Data-binding Revolutions with Object.observe()](http://www.html5rocks.com/en/tutorials/es7/observe/): 介绍 Object.observe()的概念
 - Sella Rafaeli, [Native JavaScript Data-Binding](http://www.sellarafaeli.com/blog/native_javascript_data_binding): 如何使用 Object.observe 方法，实现数据对象与 DOM 对象的双向绑定
-- Axel Rauschmayer, [`__proto__` in ECMAScript 6](http://www.2ality.com/2015/09/proto-es6.html)
-- Axel Rauschmayer, [Enumerability in ECMAScript 6](http://www.2ality.com/2015/10/enumerability-es6.html)
-- Axel Rauschmayer, [ES proposal: Object.getOwnPropertyDescriptors()](http://www.2ality.com/2016/02/object-getownpropertydescriptors.html)
+- Axel Rauschmayer, [`__proto__` in ECMAScript 6](https://2ality.com/2015/09/proto-es6.html)
+- Axel Rauschmayer, [Enumerability in ECMAScript 6](https://2ality.com/2015/10/enumerability-es6.html)
+- Axel Rauschmayer, [ES proposal: Object.getOwnPropertyDescriptors()](https://2ality.com/2016/02/object-getownpropertydescriptors.html)
 - TC39, [Object.getOwnPropertyDescriptors Proposal](https://github.com/tc39/proposal-object-getownpropertydescriptors)
 - David Titarenco, [How Spread Syntax Breaks JavaScript](https://dvt.name/2018/06/02/spread-syntax-breaks-javascript/): 扩展运算符的一些不合理的地方
 
 ## Symbol
 
-- Axel Rauschmayer, [Symbols in ECMAScript 6](http://www.2ality.com/2014/12/es6-symbols.html): Symbol 简介
+- Axel Rauschmayer, [Symbols in ECMAScript 6](https://2ality.com/2014/12/es6-symbols.html): Symbol 简介
 - MDN, [Symbol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol): Symbol 类型的详细介绍
 - Jason Orendorff, [ES6 In Depth: Symbols](https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/)
 - Keith Cirkel, [Metaprogramming in ES6: Symbols and why they're awesome](http://blog.keithcirkel.co.uk/metaprogramming-in-es6-symbols/): Symbol 的深入介绍
-- Axel Rauschmayer, [Customizing ES6 via well-known symbols](http://www.2ality.com/2015/09/well-known-symbols-es6.html)
+- Axel Rauschmayer, [Customizing ES6 via well-known symbols](https://2ality.com/2015/09/well-known-symbols-es6.html)
 - Derick Bailey, [Creating A True Singleton In Node.js, With ES6 Symbols](https://derickbailey.com/2016/03/09/creating-a-true-singleton-in-node-js-with-es6-symbols/)
 - Das Surma, [How to read web specs Part IIa – Or: ECMAScript Symbols](https://dassur.ma/things/reading-specs-2/): 介绍 Symbol 的规格
 
@@ -121,14 +121,14 @@
 
 - Mozilla Developer Network, [WeakSet](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet)：介绍 WeakSet 数据结构
 - Dwayne Charrington, [What Are Weakmaps In ES6?](http://ilikekillnerds.com/2015/02/what-are-weakmaps-in-es6/): WeakMap 数据结构介绍
-- Axel Rauschmayer, [ECMAScript 6: maps and sets](http://www.2ality.com/2015/01/es6-maps-sets.html): Set 和 Map 结构的详细介绍
+- Axel Rauschmayer, [ECMAScript 6: maps and sets](https://2ality.com/2015/01/es6-maps-sets.html): Set 和 Map 结构的详细介绍
 - Jason Orendorff, [ES6 In Depth: Collections](https://hacks.mozilla.org/2015/06/es6-in-depth-collections/)：Set 和 Map 结构的设计思想
-- Axel Rauschmayer, [Converting ES6 Maps to and from JSON](http://www.2ality.com/2015/08/es6-map-json.html): 如何将 Map 与其他数据结构互相转换
+- Axel Rauschmayer, [Converting ES6 Maps to and from JSON](https://2ality.com/2015/08/es6-map-json.html): 如何将 Map 与其他数据结构互相转换
 
 ## Proxy 和 Reflect
 
 - Nicholas C. Zakas, [Creating defensive objects with ES6 proxies](http://www.nczonline.net/blog/2014/04/22/creating-defensive-objects-with-es6-proxies/)
-- Axel Rauschmayer, [Meta programming with ECMAScript 6 proxies](http://www.2ality.com/2014/12/es6-proxies.html): Proxy 详解
+- Axel Rauschmayer, [Meta programming with ECMAScript 6 proxies](https://2ality.com/2014/12/es6-proxies.html): Proxy 详解
 - Daniel Zautner, [Meta-programming JavaScript Using Proxies](http://dzautner.com/meta-programming-javascript-using-proxies/): 使用 Proxy 实现元编程
 - Tom Van Cutsem, [Harmony-reflect](https://github.com/tvcutsem/harmony-reflect/wiki): Reflect 对象的设计目的
 - Tom Van Cutsem, [Proxy Traps](https://github.com/tvcutsem/harmony-reflect/blob/master/doc/traps.md): Proxy 拦截操作一览
@@ -137,7 +137,7 @@
 - Nicolas Bevacqua, [ES6 Proxies in Depth](http://ponyfoo.com/articles/es6-proxies-in-depth)
 - Nicolas Bevacqua, [ES6 Proxy Traps in Depth](http://ponyfoo.com/articles/es6-proxy-traps-in-depth)
 - Nicolas Bevacqua, [More ES6 Proxy Traps in Depth](http://ponyfoo.com/articles/more-es6-proxy-traps-in-depth)
-- Axel Rauschmayer, [Pitfall: not all objects can be wrapped transparently by proxies](http://www.2ality.com/2016/11/proxying-builtins.html)
+- Axel Rauschmayer, [Pitfall: not all objects can be wrapped transparently by proxies](https://2ality.com/2016/11/proxying-builtins.html)
 - Bertalan Miklos, [Writing a JavaScript Framework - Data Binding with ES6 Proxies](https://blog.risingstack.com/writing-a-javascript-framework-data-binding-es6-proxy/): 使用 Proxy 实现观察者模式
 - Keith Cirkel, [Metaprogramming in ES6: Part 2 - Reflect](https://www.keithcirkel.co.uk/metaprogramming-in-es6-part-2-reflect/): Reflect API 的详细介绍
 
@@ -148,7 +148,7 @@
 - Tilde, [rsvp.js](https://github.com/tildeio/rsvp.js)
 - Sandeep Panda, [An Overview of JavaScript Promises](http://www.sitepoint.com/overview-javascript-promises/): ES6 Promise 入门介绍
 - Dave Atchley, [ES6 Promises](http://www.datchley.name/es6-promises/): Promise 的语法介绍
-- Axel Rauschmayer, [ECMAScript 6 promises (2/2): the API](http://www.2ality.com/2014/10/es6-promises-api.html): 对 ES6 Promise 规格和用法的详细介绍
+- Axel Rauschmayer, [ECMAScript 6 promises (2/2): the API](https://2ality.com/2014/10/es6-promises-api.html): 对 ES6 Promise 规格和用法的详细介绍
 - Jack Franklin, [Embracing Promises in JavaScript](http://javascriptplayground.com/blog/2015/02/promises/): catch 方法的例子
 - Ronald Chen, [How to escape Promise Hell](https://medium.com/@pyrolistical/how-to-get-out-of-promise-hell-8c20e0ab0513#.2an1he6vf): 如何使用`Promise.all`方法的一些很好的例子
 - Jordan Harband, [proposal-promise-try](https://github.com/ljharb/proposal-promise-try): Promise.try() 方法的提案
@@ -160,8 +160,8 @@
 - Mozilla Developer Network, [Iterators and generators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators)
 - Mozilla Developer Network, [The Iterator protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol)
 - Jason Orendorff, [ES6 In Depth: Iterators and the for-of loop](https://hacks.mozilla.org/2015/04/es6-in-depth-iterators-and-the-for-of-loop/): 遍历器与 for...of 循环的介绍
-- Axel Rauschmayer, [Iterators and generators in ECMAScript 6](http://www.2ality.com/2013/06/iterators-generators.html): 探讨 Iterator 和 Generator 的设计目的
-- Axel Rauschmayer, [Iterables and iterators in ECMAScript 6](http://www.2ality.com/2015/02/es6-iteration.html): Iterator 的详细介绍
+- Axel Rauschmayer, [Iterators and generators in ECMAScript 6](https://2ality.com/2013/06/iterators-generators.html): 探讨 Iterator 和 Generator 的设计目的
+- Axel Rauschmayer, [Iterables and iterators in ECMAScript 6](https://2ality.com/2015/02/es6-iteration.html): Iterator 的详细介绍
 - Kyle Simpson, [Iterating ES6 Numbers](http://blog.getify.com/iterating-es6-numbers/): 在数值对象上部署遍历器
 
 ## Generator
@@ -170,7 +170,7 @@
 - Steven Sanderson, [Experiments with Koa and JavaScript Generators](http://blog.stevensanderson.com/2013/12/21/experiments-with-koa-and-javascript-generators/)
 - jmar777, [What's the Big Deal with Generators?](http://devsmash.com/blog/whats-the-big-deal-with-generators)
 - Marc Harter, [Generators in Node.js: Common Misconceptions and Three Good Use Cases](http://strongloop.com/strongblog/how-to-generators-node-js-yield-use-cases/): 讨论 Generator 函数的作用
-- StackOverflow, [ES6 yield : what happens to the arguments of the first call next()?](http://stackoverflow.com/questions/20977379/es6-yield-what-happens-to-the-arguments-of-the-first-call-next): 第一次使用 next 方法时不能带有参数
+- StackOverflow, [ES6 yield : what happens to the arguments of the first call next()?](https://stackoverflow.com/questions/20977379/es6-yield-what-happens-to-the-arguments-of-the-first-call-next): 第一次使用 next 方法时不能带有参数
 - Kyle Simpson, [ES6 Generators: Complete Series](http://davidwalsh.name/es6-generators): 由浅入深探讨 Generator 的系列文章，共四篇
 - Gajus Kuizinas, [The Definitive Guide to the JavaScript Generators](http://gajus.com/blog/2/the-definetive-guide-to-the-javascript-generators): 对 Generator 的综合介绍
 - Jan Krems, [Generators Are Like Arrays](https://gist.github.com/jkrems/04a2b34fb9893e4c2b5c): 讨论 Generator 可以被当作数据结构看待
@@ -179,7 +179,7 @@
 - Steven Sanderson, [Experiments with Koa and JavaScript Generators](http://blog.stevensanderson.com/2013/12/21/experiments-with-koa-and-javascript-generators/): Generator 入门介绍，以 Koa 框架为例
 - Mahdi Dibaiee, [ES7 Array and Generator comprehensions](http://dibaiee.ir/es7-array-generator-comprehensions/)：ES7 的 Generator 推导
 - Nicolas Bevacqua, [ES6 Generators in Depth](http://ponyfoo.com/articles/es6-generators-in-depth)
-- Axel Rauschmayer, [ES6 generators in depth](http://www.2ality.com/2015/03/es6-generators.html): Generator 规格的详尽讲解
+- Axel Rauschmayer, [ES6 generators in depth](https://2ality.com/2015/03/es6-generators.html): Generator 规格的详尽讲解
 - Derick Bailey, [Using ES6 Generators To Short-Circuit Hierarchical Data Iteration](https://derickbailey.com/2015/10/05/using-es6-generators-to-short-circuit-hierarchical-data-iteration/)：使用 for...of 循环完成预定的操作步骤
 
 ## 异步操作和 Async 函数
@@ -190,7 +190,7 @@
 - Jafar Husain, [Async Generators](https://docs.google.com/file/d/0B4PVbLpUIdzoMDR5dWstRllXblU/view?sle=true): 对 async 与 Generator 混合使用的一些讨论
 - Daniel Brain, [Understand promises before you start using async/await](https://medium.com/@bluepnume/learn-about-promises-before-you-start-using-async-await-eb148164a9c8): 讨论 async/await 与 Promise 的关系
 - Jake Archibald, [Async functions - making promises friendly](https://developers.google.com/web/fundamentals/getting-started/primers/async-functions)
-- Axel Rauschmayer, [ES proposal: asynchronous iteration](http://www.2ality.com/2016/10/asynchronous-iteration.html): 异步遍历器的详细介绍
+- Axel Rauschmayer, [ES proposal: asynchronous iteration](https://2ality.com/2016/10/asynchronous-iteration.html): 异步遍历器的详细介绍
 - Dima Grossman, [How to write async await without try-catch blocks in JavaScript](http://blog.grossman.io/how-to-write-async-await-without-try-catch-blocks-in-javascript/): 除了 try/catch 以外的 async 函数内部捕捉错误的方法
 - Mostafa Gaafa, [6 Reasons Why JavaScript’s Async/Await Blows Promises Away](https://hackernoon.com/6-reasons-why-javascripts-async-await-blows-promises-away-tutorial-c7ec10518dd9): Async 函数的6个好处
 - Mathias Bynens, [Asynchronous stack traces: why await beats Promise#then()](https://mathiasbynens.be/notes/async-stack-traces): async 函数可以保留错误堆栈
@@ -199,8 +199,8 @@
 
 - Sebastian Porto, [ES6 classes and JavaScript prototypes](https://reinteractive.net/posts/235-es6-classes-and-javascript-prototypes): ES6 Class 的写法与 ES5 Prototype 的写法对比
 - Jack Franklin, [An introduction to ES6 classes](http://javascriptplayground.com/blog/2014/07/introduction-to-es6-classes-tutorial/): ES6 class 的入门介绍
-- Axel Rauschmayer, [ECMAScript 6: new OOP features besides classes](http://www.2ality.com/2014/12/es6-oop.html)
-- Axel Rauschmayer, [Classes in ECMAScript 6 (final semantics)](http://www.2ality.com/2015/02/es6-classes-final.html): Class 语法的详细介绍和设计思想分析
+- Axel Rauschmayer, [ECMAScript 6: new OOP features besides classes](https://2ality.com/2014/12/es6-oop.html)
+- Axel Rauschmayer, [Classes in ECMAScript 6 (final semantics)](https://2ality.com/2015/02/es6-classes-final.html): Class 语法的详细介绍和设计思想分析
 - Eric Faust, [ES6 In Depth: Subclassing](https://hacks.mozilla.org/2015/08/es6-in-depth-subclassing/): Class 语法的深入介绍
 - Nicolás Bevacqua, [Binding Methods to Class Instance Objects](https://ponyfoo.com/articles/binding-methods-to-class-instance-objects): 如何绑定类的实例中的 this
 - Jamie Kyle, [JavaScript's new #private class fields](https://jamie.build/javascripts-new-private-class-fields.html)：私有属性的介绍。
@@ -208,24 +208,24 @@
 
 ## Decorator
 
-- Maximiliano Fierro, [Declarative vs Imperative](http://elmasse.github.io/js/decorators-bindings-es7.html): Decorators 和 Mixin 介绍
+- Maximiliano Fierro, [Declarative vs Imperative](https://elmasse.github.io/js/decorators-bindings-es7.html): Decorators 和 Mixin 介绍
 - Justin Fagnani, ["Real" Mixins with JavaScript Classes](http://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/): 使用类的继承实现 Mixin
 - Addy Osmani, [Exploring ES2016 Decorators](https://medium.com/google-developers/exploring-es7-decorators-76ecb65fb841): Decorator 的深入介绍
 - Sebastian McKenzie, [Allow decorators for functions as well](https://github.com/wycats/javascript-decorators/issues/4): 为什么修饰器不能用于函数
-- Maximiliano Fierro, [Traits with ES7 Decorators](http://cocktailjs.github.io/blog/traits-with-es7-decorators.html): Trait 的用法介绍
+- Maximiliano Fierro, [Traits with ES7 Decorators](https://cocktailjs.github.io/blog/traits-with-es7-decorators.html): Trait 的用法介绍
 - Jonathan Creamer: [Using ES2016 Decorators to Publish on an Event Bus](http://jonathancreamer.com/using-es2016-decorators-to-publish-on-an-event-bus/): 使用修饰器实现自动发布事件
 
 ## Module
 
 - Jack Franklin, [JavaScript Modules the ES6 Way](http://24ways.org/2014/javascript-modules-the-es6-way/): ES6 模块入门
-- Axel Rauschmayer, [ECMAScript 6 modules: the final syntax](http://www.2ality.com/2014/09/es6-modules-final.html): ES6 模块的介绍，以及与 CommonJS 规格的详细比较
+- Axel Rauschmayer, [ECMAScript 6 modules: the final syntax](https://2ality.com/2014/09/es6-modules-final.html): ES6 模块的介绍，以及与 CommonJS 规格的详细比较
 - Dave Herman, [Static module resolution](http://calculist.org/blog/2012/06/29/static-module-resolution/): ES6 模块的静态化设计思想
 - Jason Orendorff, [ES6 In Depth: Modules](https://hacks.mozilla.org/2015/08/es6-in-depth-modules/): ES6 模块设计思想的介绍
-- Ben Newman, [The Importance of import and export](http://benjamn.github.io/empirenode-2015/#/): ES6 模块的设计思想
+- Ben Newman, [The Importance of import and export](https://benjamn.github.io/empirenode-2015/#/): ES6 模块的设计思想
 - ESDiscuss, [Why is "export default var a = 1;" invalid syntax?](https://esdiscuss.org/topic/why-is-export-default-var-a-1-invalid-syntax)
 - Bradley Meck, [ES6 Module Interoperability](https://github.com/nodejs/node-eps/blob/master/002-es6-modules.md): 介绍 Node 如何处理 ES6 语法加载 CommonJS 模块
-- Axel Rauschmayer, [Making transpiled ES modules more spec-compliant](http://www.2ality.com/2017/01/babel-esm-spec-mode.html): ES6 模块编译成 CommonJS 模块的详细介绍
-- Axel Rauschmayer, [ES proposal: import() – dynamically importing ES modules](http://www.2ality.com/2017/01/import-operator.html): import() 的用法
+- Axel Rauschmayer, [Making transpiled ES modules more spec-compliant](https://2ality.com/2017/01/babel-esm-spec-mode.html): ES6 模块编译成 CommonJS 模块的详细介绍
+- Axel Rauschmayer, [ES proposal: import() – dynamically importing ES modules](https://2ality.com/2017/01/import-operator.html): import() 的用法
 - Node EPS, [ES Module Interoperability](https://github.com/nodejs/node-eps/blob/master/002-es-modules.md): Node 对 ES6 模块的处理规格
 - Dan Fabulich, [Why CommonJS and ES Modules Can’t Get Along](https://redfin.engineering/node-modules-at-war-why-commonjs-and-es-modules-cant-get-along-9617135eeca1): Node.js 对 ES6 模块的处理
 
@@ -235,8 +235,8 @@
 - Khronos, [Typed Array Specification](http://www.khronos.org/registry/typedarray/specs/latest/)
 - Ian Elliot, [Reading A BMP File In JavaScript](http://www.i-programmer.info/projects/36-web/6234-reading-a-bmp-file-in-javascript.html)
 - Renato Mangini, [How to convert ArrayBuffer to and from String](http://updates.html5rocks.com/2012/06/How-to-convert-ArrayBuffer-to-and-from-String)
-- Axel Rauschmayer, [Typed Arrays in ECMAScript 6](http://www.2ality.com/2015/09/typed-arrays.html)
-- Axel Rauschmayer, [ES proposal: Shared memory and atomics](http://2ality.com/2017/01/shared-array-buffer.html)
+- Axel Rauschmayer, [Typed Arrays in ECMAScript 6](https://2ality.com/2015/09/typed-arrays.html)
+- Axel Rauschmayer, [ES proposal: Shared memory and atomics](https://2ality.com/2017/01/shared-array-buffer.html)
 - Lin Clark, [Avoiding race conditions in SharedArrayBuffers with Atomics](https://hacks.mozilla.org/2017/06/avoiding-race-conditions-in-sharedarraybuffers-with-atomics/): Atomics 对象使用场景的解释
 - Lars T Hansen, [Shared memory - a brief tutorial](https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md)
 - James Milner, [The Return of SharedArrayBuffers and Atomics](https://www.sitepen.com/blog/2018/09/19/the-return-of-sharedarraybuffers-and-atomics/)
@@ -246,13 +246,13 @@
 - TC39, [SIMD.js Stage 2](https://docs.google.com/presentation/d/1MY9NHrHmL7ma7C8dyNXvmYNNGgVmmxXk8ZIiQtPlfH4/edit#slide=id.p19)
 - MDN, [SIMD](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SIMD)
 - TC39, [ECMAScript SIMD](https://github.com/tc39/ecmascript_simd)
-- Axel Rauschmayer, [JavaScript gains support for SIMD](http://www.2ality.com/2013/12/simd-js.html)
+- Axel Rauschmayer, [JavaScript gains support for SIMD](https://2ality.com/2013/12/simd-js.html)
 
 ## 工具
 
 - Babel, [Babel Handbook](https://github.com/thejameskyle/babel-handbook/tree/master/translations/en): Babel 的用法介绍
 - Google, [traceur-compiler](https://github.com/google/traceur-compiler): Traceur 编译器
-- Casper Beyer, [ECMAScript 6 Features and Tools](http://caspervonb.github.io/2014/03/05/ecmascript6-features-and-tools.html)
+- Casper Beyer, [ECMAScript 6 Features and Tools](https://caspervonb.github.io/2014/03/05/ecmascript6-features-and-tools.html)
 - Stoyan Stefanov, [Writing ES6 today with jstransform](http://www.phpied.com/writing-es6-today-with-jstransform/)
 - ES6 Module Loader, [ES6 Module Loader Polyfill](https://github.com/ModuleLoader/es6-module-loader): 在浏览器和 node.js 加载 ES6 模块的一个库，文档里对 ES6 模块有详细解释
 - Paul Miller, [es6-shim](https://github.com/paulmillr/es6-shim): 一个针对老式浏览器，模拟 ES6 部分功能的垫片库（shim）
diff --git a/docs/spec.md b/docs/spec.md
index 30aa2c44f..3c33e3607 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -10,7 +10,7 @@
 
 本章介绍如何读懂 ECMAScript 6 的规格文件。
 
-ECMAScript 6 的规格，可以在 ECMA 国际标准组织的官方网站（[www.ecma-international.org/ecma-262/6.0/](http://www.ecma-international.org/ecma-262/6.0/)）免费下载和在线阅读。
+ECMAScript 6 的规格，可以在 ECMA 国际标准组织的官方网站（[www.ecma-international.org/ecma-262/6.0/](https://www.ecma-international.org/ecma-262/6.0/)）免费下载和在线阅读。
 
 这个规格文件相当庞大，一共有 26 章，A4 打印的话，足足有 545 页。它的特点就是规定得非常细致，每一个语法行为、每一个函数的实现都做了详尽的清晰的描述。基本上，编译器作者只要把每一步翻译成代码就可以了。这很大程度上，保证了所有 ES6 实现都有一致的行为。
 
@@ -111,7 +111,7 @@ ES6 规格将这个标准流程，使用简写的方式表达。
 0 == null
 ```
 
-如果你不确定答案，或者想知道语言内部怎么处理，就可以去查看规格，[7.2.12 小节](http://www.ecma-international.org/ecma-262/6.0/#sec-abstract-equality-comparison)是对相等运算符（`==`）的描述。
+如果你不确定答案，或者想知道语言内部怎么处理，就可以去查看规格，[7.2.12 小节](https://www.ecma-international.org/ecma-262/6.0/#sec-abstract-equality-comparison)是对相等运算符（`==`）的描述。
 
 规格对每一种语法行为的描述，都分成两部分：先是总体的行为描述，然后是实现的算法细节。相等运算符的总体描述，只有一句话。
 
@@ -154,7 +154,7 @@ ES6 规格将这个标准流程，使用简写的方式表达。
 > 1. 如果`Type(x)`是对象，`Type(y)`是字符串或数值或`Symbol`值，返回`ToPrimitive(x) == y`的结果。
 > 1. 返回`false`。
 
-由于`0`的类型是数值，`null`的类型是 Null（这是规格[4.3.13 小节](http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-null-type)的规定，是内部 Type 运算的结果，跟`typeof`运算符无关）。因此上面的前 11 步都得不到结果，要到第 12 步才能得到`false`。
+由于`0`的类型是数值，`null`的类型是 Null（这是规格[4.3.13 小节](https://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-null-type)的规定，是内部 Type 运算的结果，跟`typeof`运算符无关）。因此上面的前 11 步都得不到结果，要到第 12 步才能得到`false`。
 
 ```javascript
 0 == null // false
@@ -199,7 +199,7 @@ a2.map(n => 1) // [, , ,]
 
 为什么`a1`与`a2`成员的行为不一致？数组的成员是`undefined`或空位，到底有什么不同？
 
-规格的[12.2.5 小节《数组的初始化》](http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer)给出了答案。
+规格的[12.2.5 小节《数组的初始化》](https://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer)给出了答案。
 
 > “Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an AssignmentExpression (i.e., a comma at the beginning or after another comma), the missing array element contributes to the length of the Array and increases the index of subsequent elements. Elided array elements are not defined. If an element is elided at the end of an array, that element does not contribute to the length of the Array.”
 
@@ -215,7 +215,7 @@ a2.map(n => 1) // [, , ,]
 
 ## 数组的 map 方法
 
-规格的[22.1.3.15 小节](http://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.map)定义了数组的`map`方法。该小节先是总体描述`map`方法的行为，里面没有提到数组空位。
+规格的[22.1.3.15 小节](https://www.ecma-international.org/ecma-262/6.0/#sec-array.prototype.map)定义了数组的`map`方法。该小节先是总体描述`map`方法的行为，里面没有提到数组空位。
 
 后面的算法描述是这样的。
 
diff --git a/sidebar.md b/sidebar.md
index 1d167e9c4..f9ed9158a 100644
--- a/sidebar.md
+++ b/sidebar.md
@@ -1,8 +1,8 @@
 # [ECMAScript 6 入门]()
 
-作者：[阮一峰](http://www.ruanyifeng.com)
+作者：[阮一峰](https://www.ruanyifeng.com)
 
-授权：<a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/">署名-非商用许可证</a>
+授权：<a rel="license" href="https://creativecommons.org/licenses/by-nc/4.0/">署名-非商用许可证</a>
 
 ## 目录
 1. [前言](#README)
@@ -40,6 +40,6 @@
 1. [参考链接](#docs/reference)
 
 ## 其他
-- [源码](http://github.com/ruanyf/es6tutorial/)
+- [源码](https://github.com/ruanyf/es6tutorial/)
 - [修订历史](https://github.com/ruanyf/es6tutorial/commits/gh-pages)
 - [反馈意见](https://github.com/ruanyf/es6tutorial/issues)

From 9388b337a1853698141b7291f8c067406994c97c Mon Sep 17 00:00:00 2001
From: Huyue <liuhuyue@baidu.com>
Date: Fri, 17 Sep 2021 15:24:41 +0800
Subject: [PATCH 168/280] Update intro.md

---
 docs/intro.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/intro.md b/docs/intro.md
index 488a87bb8..880cf08b7 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -242,7 +242,7 @@ import 'core-js';
 import 'regenerator-runtime/runtime';
 // 或者
 require('core-js');
-require('regenerator-runtime/runtime);
+require('regenerator-runtime/runtime');
 ```
 
 Babel 默认不转码的 API 非常多，详细清单可以查看`babel-plugin-transform-runtime`模块的[definitions.js](https://github.com/babel/babel/blob/master/packages/babel-plugin-transform-runtime/src/runtime-corejs3-definitions.js)文件。

From 1fdd34ebbfb749f0fc8db113c388224ef5d37ed7 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 19 Sep 2021 15:54:44 +0800
Subject: [PATCH 169/280] docs(object): add AggregateError

---
 docs/object.md | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/docs/object.md b/docs/object.md
index d2965e818..26469cd71 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -704,3 +704,52 @@ let aWithXGetter = { ...a }; // 报错
 
 上面例子中，取值函数`get`在扩展`a`对象时会自动执行，导致报错。
 
+## AggregateError 错误对象
+
+ES2021 标准之中，伴随`Promise.any()`方法，还引入一个新的错误对象`AggregateError`，也放在这一章介绍。
+
+AggregateError 在一个错误对象里面，封装了多个错误。如果某个单一操作，同时引发了多个错误，，需要同时抛出这些错误，那么就可以抛出一个 AggregateError 错误对象，把各种错误都放在这个对象里面。
+
+AggregateError 本身是一个构造函数，用来生成 AggregateError 实例对象。
+
+```javascript
+AggregateError(errors[, message])
+```
+
+`AggregateError()`构造函数可以接受两个参数。
+
+- errors：数组，它的每个成员都是一个错误对象。该参数是必须的。
+- message：字符串，表示 AggregateError 抛出时的提示信息。该参数是可选的。
+
+```javascript
+const error = new AggregateError([
+  new Error('ERROR_11112'),
+  new TypeError('First name must be a string'),
+  new RangeError('Transaction value must be at least 1'),
+  new URIError('User profile link must be https'),
+], 'Transaction cannot be processed')
+```
+
+上面示例中，`AggregateError()`的第一个参数数组里面，一共有四个错误实例。第二个参数字符串则是这四个错误的一个整体的提示。
+
+`AggregateError`的实例对象有三个属性。
+
+- name：错误名称，默认为“AggregateError”。
+- message：错误的提示信息。
+- errors：数组，每个成员都是一个错误对象。
+
+下面是一个示例。
+
+```javascript
+try {
+  throw new AggregateError([
+    new Error("some error"),
+  ], 'Hello');
+} catch (e) {
+  console.log(e instanceof AggregateError); // true
+  console.log(e.message);                   // "Hello"
+  console.log(e.name);                      // "AggregateError"
+  console.log(e.errors);                    // [ Error: "some error" ]
+}
+```
+

From e17a5816f5c4e3f93eda577e20b318f565a0756e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 19 Sep 2021 15:59:50 +0800
Subject: [PATCH 170/280] docs(object): edit AggregateError

---
 docs/object.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/object.md b/docs/object.md
index 26469cd71..f90684462 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -706,7 +706,7 @@ let aWithXGetter = { ...a }; // 报错
 
 ## AggregateError 错误对象
 
-ES2021 标准之中，伴随`Promise.any()`方法，还引入一个新的错误对象`AggregateError`，也放在这一章介绍。
+ES2021 标准之中，为了配合新增的`Promise.any()`方法（详见《Promise 对象》一章），还引入一个新的错误对象`AggregateError`，也放在这一章介绍。
 
 AggregateError 在一个错误对象里面，封装了多个错误。如果某个单一操作，同时引发了多个错误，，需要同时抛出这些错误，那么就可以抛出一个 AggregateError 错误对象，把各种错误都放在这个对象里面。
 

From 180c700591417f183f183f9266f03758e0cdbfd0 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 4 Oct 2021 16:56:40 +0800
Subject: [PATCH 171/280] docs(style): edit module style suggestion

---
 docs/style.md | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/docs/style.md b/docs/style.md
index 45f7d88c0..fc23e2ffa 100644
--- a/docs/style.md
+++ b/docs/style.md
@@ -397,22 +397,24 @@ class PeekableQueue extends Queue {
 
 ## 模块
 
-首先，Module 语法是 JavaScript 模块的标准写法，坚持使用这种写法。使用`import`取代`require`。
+ES6 模块语法是 JavaScript 模块的标准写法，坚持使用这种写法，取代 Node.js 的 CommonJS 语法。
+
+首先，使用`import`取代`require()`。
 
 ```javascript
-// bad
+// CommonJS 的写法
 const moduleA = require('moduleA');
 const func1 = moduleA.func1;
 const func2 = moduleA.func2;
 
-// good
+// ES6 的写法
 import { func1, func2 } from 'moduleA';
 ```
 
-使用`export`取代`module.exports`。
+其次，使用`export`取代`module.exports`。
 
 ```javascript
-// commonJS的写法
+// commonJS 的写法
 var React = require('react');
 
 var Breadcrumbs = React.createClass({
@@ -423,7 +425,7 @@ var Breadcrumbs = React.createClass({
 
 module.exports = Breadcrumbs;
 
-// ES6的写法
+// ES6 的写法
 import React from 'react';
 
 class Breadcrumbs extends React.Component {
@@ -435,9 +437,9 @@ class Breadcrumbs extends React.Component {
 export default Breadcrumbs;
 ```
 
-如果模块只有一个输出值，就使用`export default`，如果模块有多个输出值，就不使用`export default`，`export default`与普通的`export`不要同时使用。
+如果模块只有一个输出值，就使用`export default`，如果模块有多个输出值，除非其中某个输出值特别重要，否则建议不要使用`export default`，即多个输出值如果是平等关系，`export default`与普通的`export`就不要同时使用。
 
-如果模块默认输出一个函数，函数名的首字母应该小写。
+如果模块默认输出一个函数，函数名的首字母应该小写，表示这是一个工具方法。
 
 ```javascript
 function makeStyleGuide() {
@@ -446,7 +448,7 @@ function makeStyleGuide() {
 export default makeStyleGuide;
 ```
 
-如果模块默认输出一个对象，对象名的首字母应该大写。
+如果模块默认输出一个对象，对象名的首字母应该大写，表示这是一个配置值对象。
 
 ```javascript
 const StyleGuide = {

From de768691a70e4192e34fa16029010218e586ba5e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 19 Oct 2021 09:07:31 +0800
Subject: [PATCH 172/280] docs(string): fixed #1086

---
 docs/string.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/string.md b/docs/string.md
index 3a3d78560..c311b860f 100644
--- a/docs/string.md
+++ b/docs/string.md
@@ -122,7 +122,7 @@ const PS = eval("'\u2029'");
 
 根据标准，JSON 数据必须是 UTF-8 编码。但是，现在的`JSON.stringify()`方法有可能返回不符合 UTF-8 标准的字符串。
 
-具体来说，UTF-8 标准规定，`0xD800`到`0xDFFF`之间的码点，不能单独使用，必须配对使用。比如，`\uD834\uDF06`是两个码点，但是必须放在一起配对使用，代表字符`𝌆`。这是为了表示码点大于`0xFFFF`的字符的一种变通方法。单独使用`\uD834`和`\uDFO6`这两个码点是不合法的，或者颠倒顺序也不行，因为`\uDF06\uD834`并没有对应的字符。
+具体来说，UTF-8 标准规定，`0xD800`到`0xDFFF`之间的码点，不能单独使用，必须配对使用。比如，`\uD834\uDF06`是两个码点，但是必须放在一起配对使用，代表字符`𝌆`。这是为了表示码点大于`0xFFFF`的字符的一种变通方法。单独使用`\uD834`和`\uDF06`这两个码点是不合法的，或者颠倒顺序也不行，因为`\uDF06\uD834`并没有对应的字符。
 
 `JSON.stringify()`的问题在于，它可能返回`0xD800`到`0xDFFF`之间的单个码点。
 

From 5b57360b2da7d51bb6a284a7e0f795d16c12de20 Mon Sep 17 00:00:00 2001
From: Huyue <liuhuyue@baidu.com>
Date: Tue, 19 Oct 2021 11:33:57 +0800
Subject: [PATCH 173/280] Update function.md

---
 docs/function.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/function.md b/docs/function.md
index e59b7bda1..6172c013c 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -303,10 +303,10 @@ function foo(x = x) {
   // ...
 }
 
-foo() // ReferenceError: x is not defined
+foo() // ReferenceError: Cannot access 'x' before initialization
 ```
 
-上面代码中，参数`x = x`形成一个单独作用域。实际执行的是`let x = x`，由于暂时性死区的原因，这行代码会报错”x 未定义“。
+上面代码中，参数`x = x`形成一个单独作用域。实际执行的是`let x = x`，由于暂时性死区的原因，这行代码会报错。
 
 如果参数的默认值是一个函数，该函数的作用域也遵守这个规则。请看下面的例子。
 

From 728b545742abc75dc0059e94bb9e14e674f3044f Mon Sep 17 00:00:00 2001
From: Chenwei Xiao <chanvinxiao@163.com>
Date: Sun, 31 Oct 2021 19:18:47 +0800
Subject: [PATCH 174/280] Add script suffix to prevent error
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

增加文件后缀，否则会报错 `Error [ERR_MODULE_NOT_FOUND]`
---
 docs/decorator.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index cb8517a90..8d343a1d8 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -109,7 +109,7 @@ export function mixins(...list) {
 }
 
 // main.js
-import { mixins } from './mixins'
+import { mixins } from './mixins.js'
 
 const Foo = {
   foo() { console.log('foo') }
@@ -591,7 +591,7 @@ export function mixins(...list) {
 然后，就可以使用上面这个装饰器，为类“混入”各种方法。
 
 ```javascript
-import { mixins } from './mixins';
+import { mixins } from './mixins.js';
 
 const Foo = {
   foo() { console.log('foo') }

From 1a0eaa5ffcfbb130cbd8270926c791555cb25c18 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 14 Nov 2021 00:51:52 +0800
Subject: [PATCH 175/280] docs(iterator): fixed #1093

---
 docs/iterator.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/iterator.md b/docs/iterator.md
index 1bfcb7f6d..31949d821 100644
--- a/docs/iterator.md
+++ b/docs/iterator.md
@@ -191,7 +191,7 @@ for (var value of range(0, 3)) {
 
 上面代码是一个类部署 Iterator 接口的写法。`Symbol.iterator`属性对应一个函数，执行后返回当前对象的遍历器对象。
 
-下面是通过遍历器实现指针结构的例子。
+下面是通过遍历器实现“链表”结构的例子。
 
 ```javascript
 function Obj(value) {

From 79e871c87201ef1ac482080ff553e65185af473a Mon Sep 17 00:00:00 2001
From: Ruan YiFeng <yifeng.ruan@gmail.com>
Date: Mon, 15 Nov 2021 03:33:33 +0800
Subject: [PATCH 176/280] docs(array): add at()

---
 docs/array.md          | 37 ++++++++++++++++++++++++++-----------
 docs/string-methods.md | 13 +++++++++++++
 2 files changed, 39 insertions(+), 11 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index e69830951..e73cfb9c7 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -544,7 +544,7 @@ function ArrayOf(){
 }
 ```
 
-## 数组实例的 copyWithin()
+## 实例方法：copyWithin()
 
 数组实例的`copyWithin()`方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。
 
@@ -593,7 +593,7 @@ i32a.copyWithin(0, 2);
 // Int32Array [4, 2, 3, 4, 5]
 ```
 
-## 数组实例的 find() 和 findIndex()
+## 实例方法：find() 和 findIndex()
 
 数组实例的`find`方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为`true`的成员，然后返回该成员。如果没有符合条件的成员，则返回`undefined`。
 
@@ -644,7 +644,7 @@ let person = {name: 'John', age: 20};
 
 上面代码中，`indexOf`方法无法识别数组的`NaN`成员，但是`findIndex`方法可以借助`Object.is`方法做到。
 
-## 数组实例的 fill()
+## 实例方法：fill()
 
 `fill`方法使用给定值，填充一个数组。
 
@@ -681,7 +681,7 @@ arr
 // [[5], [5], [5]]
 ```
 
-## 数组实例的 entries()，keys() 和 values()
+## 实例方法：entries()，keys() 和 values()
 
 ES6 提供三个新的方法——`entries()`，`keys()`和`values()`——用于遍历数组。它们都返回一个遍历器对象（详见《Iterator》一章），可以用`for...of`循环进行遍历，唯一的区别是`keys()`是对键名的遍历、`values()`是对键值的遍历，`entries()`是对键值对的遍历。
 
@@ -715,7 +715,7 @@ console.log(entries.next().value); // [1, 'b']
 console.log(entries.next().value); // [2, 'c']
 ```
 
-## 数组实例的 includes()
+## 实例方法：includes()
 
 `Array.prototype.includes`方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的`includes`方法类似。ES2016 引入了该方法。
 
@@ -770,7 +770,7 @@ contains(['foo', 'bar'], 'baz'); // => false
 - Map 结构的`has`方法，是用来查找键名的，比如`Map.prototype.has(key)`、`WeakMap.prototype.has(key)`、`Reflect.has(target, propertyKey)`。
 - Set 结构的`has`方法，是用来查找值的，比如`Set.prototype.has(value)`、`WeakSet.prototype.has(value)`。
 
-## 数组实例的 flat()，flatMap()
+## 实例方法：flat()，flatMap()
 
 数组的成员有时还是数组，`Array.prototype.flat()`用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响。
 
@@ -835,9 +835,25 @@ arr.flatMap(function callback(currentValue[, index[, array]]) {
 
 `flatMap()`方法还可以有第二个参数，用来绑定遍历函数里面的`this`。
 
+## 实例方法：at()
+
+长久以来，JavaScript 不支持数组的负索引，如果要引用数组的最后一个成员，不能写成`arr[-1]`，只能使用`arr[arr.length - 1]`。
+
+这是因为方括号运算符`[]`在 JavaScript 语言里面，不仅用于数组，还用于对象。对于对象来说，方括号里面就是键名，比如`obj[1]`引用的是键名为字符串`1`的键，同理`obj[-1]`引用的是键名为字符串`-1`的键。由于 JavaScript 的数组是特殊的对象，所以方括号里面的负数无法再有其他语义了，也就是说，不可能添加新语法来支持负索引。
+
+为了解决这个问题，现在有一个[提案](https://github.com/tc39/proposal-relative-indexing-method/)，为数组实例增加了`at()`方法，接受一个整数作为参数，返回对应位置的成员，支持负索引。这个方法不仅可用于数组，也可用于字符串和类型数组（TypedArray）。
+
+```javascript
+const arr = [5, 12, 8, 130, 44];
+arr.at[2] // 8
+arr.at[-2] // 130
+```
+
+如果参数位置超出了数组范围，`at()`返回`undefined`。
+
 ## 数组的空位
 
-数组的空位指，数组的某一个位置没有任何值。比如，`Array`构造函数返回的数组都是空位。
+数组的空位指的是，数组的某一个位置没有任何值，比如`Array()`构造函数返回的数组都是空位。
 
 ```javascript
 Array(3) // [, , ,]
@@ -845,7 +861,7 @@ Array(3) // [, , ,]
 
 上面代码中，`Array(3)`返回一个具有 3 个空位的数组。
 
-注意，空位不是`undefined`，一个位置的值等于`undefined`，依然是有值的。空位是没有任何值，`in`运算符可以说明这一点。
+注意，空位不是`undefined`，某一个位置的值等于`undefined`，依然是有值的。空位是没有任何值，`in`运算符可以说明这一点。
 
 ```javascript
 0 in [undefined, undefined, undefined] // true
@@ -888,7 +904,7 @@ ES5 对空位的处理，已经很不一致了，大多数情况下会忽略空
 
 ES6 则是明确将空位转为`undefined`。
 
-`Array.from`方法会将数组的空位，转为`undefined`，也就是说，这个方法不会忽略空位。
+`Array.from()`方法会将数组的空位，转为`undefined`，也就是说，这个方法不会忽略空位。
 
 ```javascript
 Array.from(['a',,'b'])
@@ -925,7 +941,7 @@ for (let i of arr) {
 // 1
 ```
 
-上面代码中，数组`arr`有两个空位，`for...of`并没有忽略它们。如果改成`map`方法遍历，空位是会跳过的。
+上面代码中，数组`arr`有两个空位，`for...of`并没有忽略它们。如果改成`map()`方法遍历，空位是会跳过的。
 
 `entries()`、`keys()`、`values()`、`find()`和`findIndex()`会将空位处理成`undefined`。
 
@@ -986,4 +1002,3 @@ arr.sort(unstableSorting)
 常见的排序算法之中，插入排序、合并排序、冒泡排序等都是稳定的，堆排序、快速排序等是不稳定的。不稳定排序的主要缺点是，多重排序时可能会产生问题。假设有一个姓和名的列表，要求按照“姓氏为主要关键字，名字为次要关键字”进行排序。开发者可能会先按名字排序，再按姓氏进行排序。如果排序算法是稳定的，这样就可以达到“先姓氏，后名字”的排序效果。如果是不稳定的，就不行。
 
 早先的 ECMAScript 没有规定，`Array.prototype.sort()`的默认排序算法是否稳定，留给浏览器自己决定，这导致某些实现是不稳定的。[ES2019](https://github.com/tc39/ecma262/pull/1340) 明确规定，`Array.prototype.sort()`的默认排序算法必须稳定。这个规定已经做到了，现在 JavaScript 各个主要实现的默认排序算法都是稳定的。
-
diff --git a/docs/string-methods.md b/docs/string-methods.md
index 1d4b3fc06..64333e430 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -437,3 +437,16 @@ str.replaceAll(regex, replacer)
 
 上面例子中，正则表达式有三个组匹配，所以`replacer()`函数的第一个参数`match`是捕捉到的匹配内容（即字符串`123abc456`），后面三个参数`p1`、`p2`、`p3`则依次为三个组匹配。
 
+## 实例方法：at()
+
+`at()`方法接受一个整数作为参数，返回参数指定位置的字符，支持负索引（即倒数的位置）。
+
+```javascript
+const str = 'hello';
+str.at[1] // "e"
+str.at[-1] // "o"
+```
+
+如果参数位置超出了字符串范围，`at()`返回`undefined`。
+
+该方法来自数组添加的`at()`方法，目前还是一个第三阶段的提案，可以参考《数组》一章的介绍。

From 221577312116b41a276d2f466a5b4d12c9020e27 Mon Sep 17 00:00:00 2001
From: ConradZhangcong <heisenberg0519@outlook.com>
Date: Tue, 16 Nov 2021 15:55:20 +0800
Subject: [PATCH 177/280] Update string-methods.md

---
 docs/string-methods.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 64333e430..2fc48b4c8 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -443,8 +443,8 @@ str.replaceAll(regex, replacer)
 
 ```javascript
 const str = 'hello';
-str.at[1] // "e"
-str.at[-1] // "o"
+str.at(1) // "e"
+str.at(-1) // "o"
 ```
 
 如果参数位置超出了字符串范围，`at()`返回`undefined`。

From 74de2938780d3351f7dc210cf12733ee36ed0ede Mon Sep 17 00:00:00 2001
From: ConradZhangcong <heisenberg0519@outlook.com>
Date: Tue, 23 Nov 2021 11:30:52 +0800
Subject: [PATCH 178/280] Update array.md

---
 docs/array.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index e73cfb9c7..4e235add4 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -845,8 +845,8 @@ arr.flatMap(function callback(currentValue[, index[, array]]) {
 
 ```javascript
 const arr = [5, 12, 8, 130, 44];
-arr.at[2] // 8
-arr.at[-2] // 130
+arr.at(2) // 8
+arr.at(-2) // 130
 ```
 
 如果参数位置超出了数组范围，`at()`返回`undefined`。

From a066b9a3895ff3b227e0b4f84dddd22330f01af7 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 23 Nov 2021 18:00:34 +0800
Subject: [PATCH 179/280] docs(module-loader): fix typo

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 18b4f4c47..9a99b59ef 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -292,7 +292,7 @@ Node.js 要求 ES6 模块采用`.mjs`后缀文件名。也就是说，只要脚
 }
 ```
 
-一旦设置了以后，该目录里面的 JS 脚本，就被解释用 ES6 模块。
+一旦设置了以后，该项目的 JS 脚本，就被解释成 ES6 模块。
 
 ```bash
 # 解释成 ES6 模块

From a0265eff291273a901d67203622470fc05ae1899 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 30 Nov 2021 19:08:31 +0800
Subject: [PATCH 180/280] refactor: adjust support code

---
 js/ditto.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index f0565c2d0..9ee8243fd 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年10月9日
-  var deadline = new Date(2021, 9, 9);
+  // 2022年1月1日
+  var deadline = new Date(2022, 0, 1);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -258,10 +258,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【免费课程】' +
-    '开课吧<span style="color: #4682BE;">《深度理解 Vue 3.0 核心源码》</span>精品课领取，讲解 Vue 3.0 源码，动手制作实战项目，快速上手Vue 3.0。';
+  var text = '【课程消息】' +
+    '<span style="color: #4682BE;">《Vue 3.0 核心源码与实战》</span>带大家动手，从零开发网页游戏《飞机大战》，快速上手 Vue 3.0 项目。开课吧的系列课程，现在 0 元领取。';
 
-  var banner = $('<a href="https://t.1yb.co/AzbY" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/N3MIpFtF2DZ91C502gp?kol_ad_code=kKx4Fnfd9ENkHgIfwHb" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 4781407a6833da40e64d9dc20e4319f7b8d3cba5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 30 Nov 2021 19:24:34 +0800
Subject: [PATCH 181/280] refactor: adjust support code

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index 9ee8243fd..fc54de736 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -259,7 +259,7 @@ function create_banner(element) {
   ].join(';');
 
   var text = '【课程消息】' +
-    '<span style="color: #4682BE;">《Vue 3.0 核心源码与实战》</span>带大家动手，从零开发网页游戏《飞机大战》，快速上手 Vue 3.0 项目。开课吧的系列课程，现在 0 元领取。';
+    '<span style="color: #4682BE;">《Vue 3.0 核心源码与实战》</span>带大家动手，从零开发网页游戏《飞机大战》，快速上手 Vue 3.0 项目。开课吧的课程资料，现在 0 元领取。';
 
   var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/N3MIpFtF2DZ91C502gp?kol_ad_code=kKx4Fnfd9ENkHgIfwHb" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);

From 664f6850f7958c54611b87ba8a0a14d6b4f1894e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Dec 2021 01:46:25 +0800
Subject: [PATCH 182/280] docs(class): fixed #1099

---
 docs/class.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index 69cff93c1..606848b5b 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1028,7 +1028,7 @@ A.test(o1) // false
 A.test(o1.__proto__) // true
 
 const o2 = {};
-Object.setPrototypeOf(o2, A);
+Object.setPrototypeOf(o2, a);
 A.test(o2) // false
 A.test(o2.__proto__) // true
 ```
@@ -1204,3 +1204,4 @@ var y = new Rectangle(3, 4);  // 正确
 上面代码中，`Shape`类不能被实例化，只能用于继承。
 
 注意，在函数外部，使用`new.target`会报错。
+

From fd3eb89a6cb827fae57be255a3ab23994cd86b73 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 3 Dec 2021 01:59:35 +0800
Subject: [PATCH 183/280] docs(proxy): fixed #1100

---
 docs/proxy.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index 33492c1ba..a65ec7dcc 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -1090,7 +1090,7 @@ target.m() // false
 proxy.m()  // true
 ```
 
-上面代码中，一旦`proxy`代理`target`，`target.m()`内部的`this`就是指向`proxy`，而不是`target`。
+上面代码中，一旦`proxy`代理`target`，`target.m()`内部的`this`就是指向`proxy`，而不是`target`。所以，虽然`proxy`没有做任何拦截，`target.m()`和`proxy.m()`返回不一样的结果。
 
 下面是一个例子，由于`this`指向的变化，导致 Proxy 无法代理目标对象。
 

From d9ec0db599c6d879cac38ab0ba33ffb2cb3fc0a9 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 29 Dec 2021 17:19:36 +0800
Subject: [PATCH 184/280] refact: edit support script

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index fc54de736..a2c4c74ef 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2022年1月1日
-  var deadline = new Date(2022, 0, 1);
+  // 2022年2月1日
+  var deadline = new Date(2022, 1, 1);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From cddf4b842936d3579ca11a05578e9ff45050923d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 31 Dec 2021 11:34:06 +0800
Subject: [PATCH 185/280] refactor: edit support banner

---
 js/ditto.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index a2c4c74ef..9f64620e3 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2022年2月1日
-  var deadline = new Date(2022, 1, 1);
+  // 2021年12月31日
+  var deadline = new Date(2021, 11, 31);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [

From 255eedbeee81f0d20b42fa3f2e563db32d14662e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 6 Jan 2022 15:53:33 +0800
Subject: [PATCH 186/280] =?UTF-8?q?docs(reg):=20edit=20Unicode=20=E5=B1=9E?=
 =?UTF-8?q?=E6=80=A7=E7=B1=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/regex.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/regex.md b/docs/regex.md
index c14811110..bbe069fb9 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -413,22 +413,22 @@ const RE_DOLLAR_PREFIX = /(?<=\$)foo/g;
 
 ## Unicode 属性类
 
-ES2018 [引入](https://github.com/tc39/proposal-regexp-unicode-property-escapes)了一种新的类的写法`\p{...}`和`\P{...}`，允许正则表达式匹配符合 Unicode 某种属性的所有字符。
+ES2018 [引入](https://github.com/tc39/proposal-regexp-unicode-property-escapes)了 Unicode 属性类，允许使用`\p{...}`和`\P{...}`（`\P`是`\p`的否定形式）代表一类 Unicode 字符，匹配满足条件的所有字符。
 
 ```javascript
 const regexGreekSymbol = /\p{Script=Greek}/u;
 regexGreekSymbol.test('π') // true
 ```
 
-上面代码中，`\p{Script=Greek}`指定匹配一个希腊文字母，所以匹配`π`成功。
+上面代码中，`\p{Script=Greek}`表示匹配一个希腊文字母，所以匹配`π`成功。
 
-Unicode 属性类要指定属性名和属性值。
+Unicode 属性类的标准形式，需要同时指定属性名和属性值。
 
 ```javascript
 \p{UnicodePropertyName=UnicodePropertyValue}
 ```
 
-对于某些属性，可以只写属性名，或者只写属性值。
+但是，对于某些属性，可以只写属性名，或者只写属性值。
 
 ```javascript
 \p{UnicodePropertyName}
@@ -437,7 +437,7 @@ Unicode 属性类要指定属性名和属性值。
 
 `\P{…}`是`\p{…}`的反向匹配，即匹配不满足条件的字符。
 
-注意，这两种类只对 Unicode 有效，所以使用的时候一定要加上`u`修饰符。如果不加`u`修饰符，正则表达式使用`\p`和`\P`会报错，ECMAScript 预留了这两个类。
+注意，这两种类只对 Unicode 有效，所以使用的时候一定要加上`u`修饰符。如果不加`u`修饰符，正则表达式使用`\p`和`\P`会报错。
 
 由于 Unicode 的各种属性非常多，所以这种新的类的表达能力非常强。
 

From 7fa7ee1af3da8225bc5ed43a1988fe04a917af3a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 24 Jan 2022 14:33:44 +0800
Subject: [PATCH 187/280] docs(class-extends): edit text

---
 docs/class-extends.md | 108 +++++++++++++++++++++++++++++++++++-------
 1 file changed, 90 insertions(+), 18 deletions(-)

diff --git a/docs/class-extends.md b/docs/class-extends.md
index f9944b674..71391009e 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -2,7 +2,7 @@
 
 ## 简介
 
-Class 可以通过`extends`关键字实现继承，这比 ES5 的通过修改原型链实现继承，要清晰和方便很多。
+Class 可以通过`extends`关键字实现继承，让子类继承父类的属性和方法。extends 的写法比 ES5 的原型链继承，要清晰和方便很多。
 
 ```javascript
 class Point {
@@ -12,9 +12,13 @@ class ColorPoint extends Point {
 }
 ```
 
-上面代码定义了一个`ColorPoint`类，该类通过`extends`关键字，继承了`Point`类的所有属性和方法。但是由于没有部署任何代码，所以这两个类完全一样，等于复制了一个`Point`类。下面，我们在`ColorPoint`内部加上代码。
+上面示例中，`Point`是父类，`ColorPoint`是子类，它通过`extends`关键字，继承了`Point`类的所有属性和方法。但是由于没有部署任何代码，所以这两个类完全一样，等于复制了一个`Point`类。
+
+下面，我们在`ColorPoint`内部加上代码。
 
 ```javascript
+class Point { /* ... */ }
+
 class ColorPoint extends Point {
   constructor(x, y, color) {
     super(x, y); // 调用父类的constructor(x, y)
@@ -27,9 +31,9 @@ class ColorPoint extends Point {
 }
 ```
 
-上面代码中，`constructor`方法和`toString`方法之中，都出现了`super`关键字，它在这里表示父类的构造函数，用来新建父类的`this`对象。
+上面示例中，`constructor()`方法和`toString()`方法内部，都出现了`super`关键字。`super`在这里表示父类的构造函数，用来新建一个父类的实例对象。
 
-子类必须在`constructor`方法中调用`super`方法，否则新建实例时会报错。这是因为子类自己的`this`对象，必须先通过父类的构造函数完成塑造，得到与父类同样的实例属性和方法，然后再对其进行加工，加上子类自己的实例属性和方法。如果不调用`super`方法，子类就得不到`this`对象。
+ES6 规定，子类必须在`constructor()`方法中调用`super()`，否则就会报错。这是因为子类自己的`this`对象，必须先通过父类的构造函数完成塑造，得到与父类同样的实例属性和方法，然后再对其进行加工，添加子类自己的实例属性和方法。如果不调用`super()`方法，子类就得不到自己的`this`对象。
 
 ```javascript
 class Point { /* ... */ }
@@ -42,25 +46,34 @@ class ColorPoint extends Point {
 let cp = new ColorPoint(); // ReferenceError
 ```
 
-上面代码中，`ColorPoint`继承了父类`Point`，但是它的构造函数没有调用`super`方法，导致新建实例时报错。
+上面代码中，`ColorPoint`继承了父类`Point`，但是它的构造函数没有调用`super()`，导致新建实例时报错。
 
-ES5 的继承，实质是先创造子类的实例对象`this`，然后再将父类的方法添加到`this`上面（`Parent.apply(this)`）。ES6 的继承机制完全不同，实质是先将父类实例对象的属性和方法，加到`this`上面（所以必须先调用`super`方法），然后再用子类的构造函数修改`this`。
+为什么子类的构造函数，一定要调用`super()`？原因就在于 ES6 的继承机制，与 ES5 完全不同。ES5 的继承机制，是先创造一个独立的子类的实例对象，然后再将父类的方法添加到这个对象上面，即“实例在前，继承在后”。ES6 的继承机制，则是先将父类的属性和方法，加到一个空的对象上面，然后再将该对象作为子类的实例，即“继承在前，实例在后”。这就是为什么 ES6 的继承必须先调用`super()`方法，因为这一步会生成一个继承父类的`this`对象，没有这一步就无法继承父类。
 
-如果子类没有定义`constructor`方法，这个方法会被默认添加，代码如下。也就是说，不管有没有显式定义，任何一个子类都有`constructor`方法。
+注意，这意味着新建子类实例时，父类的构造函数必定会先运行一次。
 
 ```javascript
-class ColorPoint extends Point {
+class Foo {
+  constructor() {
+    console.log(1);
+  }
 }
 
-// 等同于
-class ColorPoint extends Point {
-  constructor(...args) {
-    super(...args);
+class Bar extends Foo {
+  constructor() {
+    super();
+    console.log(2);
   }
 }
+
+const bar = new Bar();
+// 1
+// 2
 ```
 
-另一个需要注意的地方是，在子类的构造函数中，只有调用`super`之后，才可以使用`this`关键字，否则会报错。这是因为子类实例的构建，基于父类实例，只有`super`方法才能调用父类实例。
+上面示例中，子类 Bar 新建实例时，会输出1和2。原因就是子类构造函数调用`super()`时，会执行一次父类构造函数。
+
+另一个需要注意的地方是，在子类的构造函数中，只有调用`super()`之后，才可以使用`this`关键字，否则会报错。这是因为子类实例的构建，必须先完成父类的继承，只有`super()`方法才能让子类实例继承父类。
 
 ```javascript
 class Point {
@@ -79,9 +92,23 @@ class ColorPoint extends Point {
 }
 ```
 
-上面代码中，子类的`constructor`方法没有调用`super`之前，就使用`this`关键字，结果报错，而放在`super`方法之后就是正确的。
+上面代码中，子类的`constructor()`方法没有调用`super()`之前，就使用`this`关键字，结果报错，而放在`super()`之后就是正确的。
+
+如果子类没有定义`constructor()`方法，这个方法会默认添加，并且里面会调用`super()`。也就是说，不管有没有显式定义，任何一个子类都有`constructor()`方法。
+
+```javascript
+class ColorPoint extends Point {
+}
+
+// 等同于
+class ColorPoint extends Point {
+  constructor(...args) {
+    super(...args);
+  }
+}
+```
 
-下面是生成子类实例的代码。
+有了子类的定义，就可以生成子类的实例了。
 
 ```javascript
 let cp = new ColorPoint(25, 8, 'green');
@@ -90,9 +117,9 @@ cp instanceof ColorPoint // true
 cp instanceof Point // true
 ```
 
-上面代码中，实例对象`cp`同时是`ColorPoint`和`Point`两个类的实例，这与 ES5 的行为完全一致。
+上面示例中，实例对象`cp`同时是`ColorPoint`和`Point`两个类的实例，这与 ES5 的行为完全一致。
 
-最后，父类的静态方法，也会被子类继承。
+除了私有属性，父类的所有属性和方法，都会被子类继承，其中包括静态方法。
 
 ```javascript
 class A {
@@ -109,11 +136,56 @@ B.hello()  // hello world
 
 上面代码中，`hello()`是`A`类的静态方法，`B`继承`A`，也继承了`A`的静态方法。
 
+子类无法继承父类的私有属性，或者说，私有属性只能在定义它的 clss 里面使用。
+
+```javascript
+class Foo {
+  #p = 1;
+  #m() {
+    console.log('hello');
+  }
+}
+
+class Bar extends Foo {
+  constructor() {
+    super();
+    console.log(this.#p); // 报错
+    this.#m(); // 报错
+  }
+}
+```
+
+上面示例中，子类 Bar 调用父类 Foo 的私有属性或私有方法，都会报错。
+
+如果父类定义了私有属性的读写方法，子类就可以通过这些方法，读写私有属性。
+
+```javascript
+class Foo {
+  #p = 1;
+  getP() {
+    return this.#p;
+  }
+}
+
+class Bar extends Foo {
+  constructor() {
+    super();
+    console.log(this.getP()); // 1
+  }
+}
+```
+
+上面示例中，`getP()`是父类用来读取私有属性的方法，通过该方法，子类就可以读到父类的私有属性。
+
 ## Object.getPrototypeOf()
 
-`Object.getPrototypeOf`方法可以用来从子类上获取父类。
+`Object.getPrototypeOf()`方法可以用来从子类上获取父类。
 
 ```javascript
+class Point { /*...*/ }
+
+class ColorPoint extends Point { /*...*/ }
+
 Object.getPrototypeOf(ColorPoint) === Point
 // true
 ```

From e064886347e7b91c418d714d81d86d0ce3fb8a5a Mon Sep 17 00:00:00 2001
From: Liu Xuan <liuxuan4567@qq.com>
Date: Sat, 5 Feb 2022 16:31:02 +0800
Subject: [PATCH 188/280] Update class-extends.md

clss =>  class
---
 docs/class-extends.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class-extends.md b/docs/class-extends.md
index 71391009e..1e0395bc3 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -136,7 +136,7 @@ B.hello()  // hello world
 
 上面代码中，`hello()`是`A`类的静态方法，`B`继承`A`，也继承了`A`的静态方法。
 
-子类无法继承父类的私有属性，或者说，私有属性只能在定义它的 clss 里面使用。
+子类无法继承父类的私有属性，或者说，私有属性只能在定义它的 class 里面使用。
 
 ```javascript
 class Foo {

From b2a122e4d65c13e481b99cc159e805e077978531 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 6 Feb 2022 15:05:09 +0800
Subject: [PATCH 189/280] docs(symbol): fixed #1107

---
 docs/symbol.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index 75eb1517e..f420a12a7 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -4,9 +4,9 @@
 
 ES5 的对象属性名都是字符串，这容易造成属性名的冲突。比如，你使用了一个他人提供的对象，但又想为这个对象添加新的方法（mixin 模式），新方法的名字就有可能与现有方法产生冲突。如果有一种机制，保证每个属性的名字都是独一无二的就好了，这样就从根本上防止属性名的冲突。这就是 ES6 引入`Symbol`的原因。
 
-ES6 引入了一种新的原始数据类型`Symbol`，表示独一无二的值。它是 JavaScript 语言的第七种数据类型，前六种是：`undefined`、`null`、布尔值（Boolean）、字符串（String）、数值（Number）、对象（Object）。
+ES6 引入了一种新的原始数据类型`Symbol`，表示独一无二的值。它属于 JavaScript 语言的数据类型之一，其他数据类型是：`undefined`、`null`、布尔值（Boolean）、字符串（String）、数值（Number）、大整数（BigInt）、对象（Object）。
 
-Symbol 值通过`Symbol`函数生成。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。
+Symbol 值通过`Symbol()`函数生成。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。
 
 ```javascript
 let s = Symbol();

From bcfe5ee3d5f8ca01792fb4b32e96fa0762e40f0a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 7 Feb 2022 23:09:45 +0800
Subject: [PATCH 190/280] refactor: add support banner

---
 js/ditto.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 9f64620e3..e1463e471 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2021年12月31日
-  var deadline = new Date(2021, 11, 31);
+  // 2022年3月9日
+  var deadline = new Date(2022, 2, 9);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -258,10 +258,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【课程消息】' +
-    '<span style="color: #4682BE;">《Vue 3.0 核心源码与实战》</span>带大家动手，从零开发网页游戏《飞机大战》，快速上手 Vue 3.0 项目。开课吧的课程资料，现在 0 元领取。';
+  var text = '【活动消息】' +
+    '入门 AI，<span style="color: #4682BE;">人工智能四本名著</span>——《人工智能：一种现代方法》、《深度学习》、《动手学机器学习》、《流畅的 Python》——正版学习资料免费领取！';
 
-  var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/N3MIpFtF2DZ91C502gp?kol_ad_code=kKx4Fnfd9ENkHgIfwHb" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/Y9x3zlctUWhoCB3YB8U?kol_ad_code=zhchVAUzJqFhWum1D8c" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 8d81fef48ae3881a52e00f30a418a39d1a9a0ffc Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 7 Feb 2022 23:12:57 +0800
Subject: [PATCH 191/280] refactor: add support banner

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index e1463e471..1f2a1aff7 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -259,7 +259,7 @@ function create_banner(element) {
   ].join(';');
 
   var text = '【活动消息】' +
-    '入门 AI，<span style="color: #4682BE;">人工智能四本名著</span>——《人工智能：一种现代方法》、《深度学习》、《动手学机器学习》、《流畅的 Python》——正版学习资料免费领取！';
+    '入门 AI，人工智能四本名著——<span style="color: #4682BE;">《人工智能：一种现代方法》</span>、<span style="color: #4682BE;">《深度学习》</span>、<span style="color: #4682BE;">《动手学机器学习》</span>、<span style="color: #4682BE;">《流畅的 Python》</span>——正版学习资料免费领取！';
 
   var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/Y9x3zlctUWhoCB3YB8U?kol_ad_code=zhchVAUzJqFhWum1D8c" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);

From 9218ba8731ce2800c656b708f3e5f2ae323e2b55 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 8 Feb 2022 14:32:10 +0800
Subject: [PATCH 192/280] refactor: add support banner

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index 1f2a1aff7..76c417b8a 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -259,7 +259,7 @@ function create_banner(element) {
   ].join(';');
 
   var text = '【活动消息】' +
-    '入门 AI，人工智能四本名著——<span style="color: #4682BE;">《人工智能：一种现代方法》</span>、<span style="color: #4682BE;">《深度学习》</span>、<span style="color: #4682BE;">《动手学机器学习》</span>、<span style="color: #4682BE;">《流畅的 Python》</span>——正版学习资料免费领取！';
+    'AI 入门，人工智能四本名著——<span style="color: #4682BE;">《人工智能：一种现代方法》</span>、<span style="color: #4682BE;">《深度学习》</span>、<span style="color: #4682BE;">《动手学机器学习》</span>、<span style="color: #4682BE;">《流畅的 Python》</span>——正版学习资料免费领取！';
 
   var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/Y9x3zlctUWhoCB3YB8U?kol_ad_code=zhchVAUzJqFhWum1D8c" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);

From ce7fd818454c96dee3f583a158df4a936805214d Mon Sep 17 00:00:00 2001
From: 5unnyWind <72289221+5unnyWind@users.noreply.github.com>
Date: Wed, 2 Mar 2022 11:41:21 +0800
Subject: [PATCH 193/280] Update object.md

Delete an extra comma.
---
 docs/object.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/object.md b/docs/object.md
index f90684462..15380aab6 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -708,7 +708,7 @@ let aWithXGetter = { ...a }; // 报错
 
 ES2021 标准之中，为了配合新增的`Promise.any()`方法（详见《Promise 对象》一章），还引入一个新的错误对象`AggregateError`，也放在这一章介绍。
 
-AggregateError 在一个错误对象里面，封装了多个错误。如果某个单一操作，同时引发了多个错误，，需要同时抛出这些错误，那么就可以抛出一个 AggregateError 错误对象，把各种错误都放在这个对象里面。
+AggregateError 在一个错误对象里面，封装了多个错误。如果某个单一操作，同时引发了多个错误，需要同时抛出这些错误，那么就可以抛出一个 AggregateError 错误对象，把各种错误都放在这个对象里面。
 
 AggregateError 本身是一个构造函数，用来生成 AggregateError 实例对象。
 

From 8a214a6ead28cddb804d162407bdf86ae453ce25 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 31 Mar 2022 14:23:23 +0800
Subject: [PATCH 194/280] docs(array): edit Array.from()

---
 docs/array.md | 56 ++++++++++++++++++++++++++-------------------------
 1 file changed, 29 insertions(+), 27 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index 4e235add4..bd51d2481 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -73,9 +73,9 @@ console.log(...[1, 2])
 
 上面三种情况，扩展运算符都放在圆括号里面，但是前两种情况会报错，因为扩展运算符所在的括号不是函数调用。
 
-### 替代函数的 apply 方法
+### 替代函数的 apply() 方法
 
-由于扩展运算符可以展开数组，所以不再需要`apply`方法，将数组转为函数的参数了。
+由于扩展运算符可以展开数组，所以不再需要`apply()`方法将数组转为函数的参数了。
 
 ```javascript
 // ES5 的写法
@@ -85,7 +85,7 @@ function f(x, y, z) {
 var args = [0, 1, 2];
 f.apply(null, args);
 
-// ES6的写法
+// ES6 的写法
 function f(x, y, z) {
   // ...
 }
@@ -93,7 +93,7 @@ let args = [0, 1, 2];
 f(...args);
 ```
 
-下面是扩展运算符取代`apply`方法的一个实际的例子，应用`Math.max`方法，简化求出一个数组最大元素的写法。
+下面是扩展运算符取代`apply()`方法的一个实际的例子，应用`Math.max()`方法，简化求出一个数组最大元素的写法。
 
 ```javascript
 // ES5 的写法
@@ -106,12 +106,12 @@ Math.max(...[14, 3, 77])
 Math.max(14, 3, 77);
 ```
 
-上面代码中，由于 JavaScript 不提供求数组最大元素的函数，所以只能套用`Math.max`函数，将数组转为一个参数序列，然后求最大值。有了扩展运算符以后，就可以直接用`Math.max`了。
+上面代码中，由于 JavaScript 不提供求数组最大元素的函数，所以只能套用`Math.max()`函数，将数组转为一个参数序列，然后求最大值。有了扩展运算符以后，就可以直接用`Math.max()`了。
 
-另一个例子是通过`push`函数，将一个数组添加到另一个数组的尾部。
+另一个例子是通过`push()`函数，将一个数组添加到另一个数组的尾部。
 
 ```javascript
-// ES5的 写法
+// ES5 的写法
 var arr1 = [0, 1, 2];
 var arr2 = [3, 4, 5];
 Array.prototype.push.apply(arr1, arr2);
@@ -122,13 +122,14 @@ let arr2 = [3, 4, 5];
 arr1.push(...arr2);
 ```
 
-上面代码的 ES5 写法中，`push`方法的参数不能是数组，所以只好通过`apply`方法变通使用`push`方法。有了扩展运算符，就可以直接将数组传入`push`方法。
+上面代码的 ES5 写法中，`push()`方法的参数不能是数组，所以只好通过`apply()`方法变通使用`push()`方法。有了扩展运算符，就可以直接将数组传入`push()`方法。
 
 下面是另外一个例子。
 
 ```javascript
 // ES5
 new (Date.bind.apply(Date, [null, 2015, 1, 1]))
+
 // ES6
 new Date(...[2015, 1, 1]);
 ```
@@ -213,6 +214,7 @@ a4[0] === a1[0] // true
 ```javascript
 // ES5
 a = list[0], rest = list.slice(1)
+
 // ES6
 [a, ...rest] = list
 ```
@@ -281,7 +283,7 @@ str.split('').reverse().join('')
 // 'y\uD83D\uDE80x'
 ```
 
-上面代码中，如果不用扩展运算符，字符串的`reverse`操作就不正确。
+上面代码中，如果不用扩展运算符，字符串的`reverse()`操作就不正确。
 
 **（5）实现了 Iterator 接口的对象**
 
@@ -292,7 +294,7 @@ let nodeList = document.querySelectorAll('div');
 let array = [...nodeList];
 ```
 
-上面代码中，`querySelectorAll`方法返回的是一个`NodeList`对象。它不是数组，而是一个类似数组的对象。这时，扩展运算符可以将其转为真正的数组，原因就在于`NodeList`对象实现了 Iterator 。
+上面代码中，`querySelectorAll()`方法返回的是一个`NodeList`对象。它不是数组，而是一个类似数组的对象。这时，扩展运算符可以将其转为真正的数组，原因就在于`NodeList`对象实现了 Iterator。
 
 ```javascript
 Number.prototype[Symbol.iterator] = function*() {
@@ -361,9 +363,9 @@ let arr = [...obj]; // TypeError: Cannot spread non-iterable object
 
 ## Array.from()
 
-`Array.from`方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。
+`Array.from()`方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。
 
-下面是一个类似数组的对象，`Array.from`将它转为真正的数组。
+下面是一个类似数组的对象，`Array.from()`将它转为真正的数组。
 
 ```javascript
 let arrayLike = {
@@ -373,32 +375,32 @@ let arrayLike = {
     length: 3
 };
 
-// ES5的写法
+// ES5 的写法
 var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']
 
-// ES6的写法
+// ES6 的写法
 let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']
 ```
 
-实际应用中，常见的类似数组的对象是 DOM 操作返回的 NodeList 集合，以及函数内部的`arguments`对象。`Array.from`都可以将它们转为真正的数组。
+实际应用中，常见的类似数组的对象是 DOM 操作返回的 NodeList 集合，以及函数内部的`arguments`对象。`Array.from()`都可以将它们转为真正的数组。
 
 ```javascript
-// NodeList对象
+// NodeList 对象
 let ps = document.querySelectorAll('p');
 Array.from(ps).filter(p => {
   return p.textContent.length > 100;
 });
 
-// arguments对象
+// arguments 对象
 function foo() {
   var args = Array.from(arguments);
   // ...
 }
 ```
 
-上面代码中，`querySelectorAll`方法返回的是一个类似数组的对象，可以将这个对象转为真正的数组，再使用`filter`方法。
+上面代码中，`querySelectorAll()`方法返回的是一个类似数组的对象，可以将这个对象转为真正的数组，再使用`filter()`方法。
 
-只要是部署了 Iterator 接口的数据结构，`Array.from`都能将其转为数组。
+只要是部署了 Iterator 接口的数据结构，`Array.from()`都能将其转为数组。
 
 ```javascript
 Array.from('hello')
@@ -408,9 +410,9 @@ let namesSet = new Set(['a', 'b'])
 Array.from(namesSet) // ['a', 'b']
 ```
 
-上面代码中，字符串和 Set 结构都具有 Iterator 接口，因此可以被`Array.from`转为真正的数组。
+上面代码中，字符串和 Set 结构都具有 Iterator 接口，因此可以被`Array.from()`转为真正的数组。
 
-如果参数是一个真正的数组，`Array.from`会返回一个一模一样的新数组。
+如果参数是一个真正的数组，`Array.from()`会返回一个一模一样的新数组。
 
 ```javascript
 Array.from([1, 2, 3])
@@ -429,16 +431,16 @@ function foo() {
 [...document.querySelectorAll('div')]
 ```
 
-扩展运算符背后调用的是遍历器接口（`Symbol.iterator`），如果一个对象没有部署这个接口，就无法转换。`Array.from`方法还支持类似数组的对象。所谓类似数组的对象，本质特征只有一点，即必须有`length`属性。因此，任何有`length`属性的对象，都可以通过`Array.from`方法转为数组，而此时扩展运算符就无法转换。
+扩展运算符背后调用的是遍历器接口（`Symbol.iterator`），如果一个对象没有部署这个接口，就无法转换。`Array.from()`方法还支持类似数组的对象。所谓类似数组的对象，本质特征只有一点，即必须有`length`属性。因此，任何有`length`属性的对象，都可以通过`Array.from()`方法转为数组，而此时扩展运算符就无法转换。
 
 ```javascript
 Array.from({ length: 3 });
 // [ undefined, undefined, undefined ]
 ```
 
-上面代码中，`Array.from`返回了一个具有三个成员的数组，每个位置的值都是`undefined`。扩展运算符转换不了这个对象。
+上面代码中，`Array.from()`返回了一个具有三个成员的数组，每个位置的值都是`undefined`。扩展运算符转换不了这个对象。
 
-对于还没有部署该方法的浏览器，可以用`Array.prototype.slice`方法替代。
+对于还没有部署该方法的浏览器，可以用`Array.prototype.slice()`方法替代。
 
 ```javascript
 const toArray = (() =>
@@ -446,7 +448,7 @@ const toArray = (() =>
 )();
 ```
 
-`Array.from`还可以接受第二个参数，作用类似于数组的`map`方法，用来对每个元素进行处理，将处理后的值放入返回的数组。
+`Array.from()`还可以接受一个函数作为第二个参数，作用类似于数组的`map()`方法，用来对每个元素进行处理，将处理后的值放入返回的数组。
 
 ```javascript
 Array.from(arrayLike, x => x * x);
@@ -486,7 +488,7 @@ typesOf(null, [], NaN)
 // ['object', 'object', 'number']
 ```
 
-如果`map`函数里面用到了`this`关键字，还可以传入`Array.from`的第三个参数，用来绑定`this`。
+如果`map()`函数里面用到了`this`关键字，还可以传入`Array.from()`的第三个参数，用来绑定`this`。
 
 `Array.from()`可以将各种值转为真正的数组，并且还提供`map`功能。这实际上意味着，只要有一个原始的数据结构，你就可以先对它的值进行处理，然后转成规范的数组结构，进而就可以使用数量众多的数组方法。
 
@@ -495,7 +497,7 @@ Array.from({ length: 2 }, () => 'jack')
 // ['jack', 'jack']
 ```
 
-上面代码中，`Array.from`的第一个参数指定了第二个参数运行的次数。这种特性可以让该方法的用法变得非常灵活。
+上面代码中，`Array.from()`的第一个参数指定了第二个参数运行的次数。这种特性可以让该方法的用法变得非常灵活。
 
 `Array.from()`的另一个应用是，将字符串转为数组，然后返回字符串的长度。因为它能正确处理各种 Unicode 字符，可以避免 JavaScript 将大于`\uFFFF`的 Unicode 字符，算作两个字符的 bug。
 

From e856f9e4cb2ca63b75ed0590761e442cbdab0091 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 9 Apr 2022 20:01:36 +0800
Subject: [PATCH 195/280] =?UTF-8?q?docs(function):=20edit=20=E5=87=BD?=
 =?UTF-8?q?=E6=95=B0=E5=8F=82=E6=95=B0=E7=9A=84=E8=A7=A3=E6=9E=84=E8=B5=8B?=
 =?UTF-8?q?=E5=80=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/function.md | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/docs/function.md b/docs/function.md
index 6172c013c..99695e420 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -17,7 +17,7 @@ log('Hello', 'China') // Hello China
 log('Hello', '') // Hello World
 ```
 
-上面代码检查函数`log`的参数`y`有没有赋值，如果没有，则指定默认值为`World`。这种写法的缺点在于，如果参数`y`赋值了，但是对应的布尔值为`false`，则该赋值不起作用。就像上面代码的最后一行，参数`y`等于空字符，结果被改为默认值。
+上面代码检查函数`log()`的参数`y`有没有赋值，如果没有，则指定默认值为`World`。这种写法的缺点在于，如果参数`y`赋值了，但是对应的布尔值为`false`，则该赋值不起作用。就像上面代码的最后一行，参数`y`等于空字符，结果被改为默认值。
 
 为了避免这个问题，通常需要先判断一下参数`y`是否被赋值，如果没有，再等于默认值。
 
@@ -93,7 +93,7 @@ x = 100;
 foo() // 101
 ```
 
-上面代码中，参数`p`的默认值是`x + 1`。这时，每次调用函数`foo`，都会重新计算`x + 1`，而不是默认`p`等于 100。
+上面代码中，参数`p`的默认值是`x + 1`。这时，每次调用函数`foo()`，都会重新计算`x + 1`，而不是默认`p`等于 100。
 
 ### 与解构赋值默认值结合使用
 
@@ -110,7 +110,7 @@ foo({x: 1, y: 2}) // 1 2
 foo() // TypeError: Cannot read property 'x' of undefined
 ```
 
-上面代码只使用了对象的解构赋值默认值，没有使用函数参数的默认值。只有当函数`foo`的参数是一个对象时，变量`x`和`y`才会通过解构赋值生成。如果函数`foo`调用时没提供参数，变量`x`和`y`就不会生成，从而报错。通过提供函数参数的默认值，就可以避免这种情况。
+上面代码只使用了对象的解构赋值默认值，没有使用函数参数的默认值。只有当函数`foo()`的参数是一个对象时，变量`x`和`y`才会通过解构赋值生成。如果函数`foo()`调用时没提供参数，变量`x`和`y`就不会生成，从而报错。通过提供函数参数的默认值，就可以避免这种情况。
 
 ```javascript
 function foo({x, y = 5} = {}) {
@@ -136,7 +136,7 @@ fetch('http://example.com')
 // 报错
 ```
 
-上面代码中，如果函数`fetch`的第二个参数是一个对象，就可以为它的三个属性设置默认值。这种写法不能省略第二个参数，如果结合函数参数的默认值，就可以省略第二个参数。这时，就出现了双重默认值。
+上面代码中，如果函数`fetch()`的第二个参数是一个对象，就可以为它的三个属性设置默认值。这种写法不能省略第二个参数，如果结合函数参数的默认值，就可以省略第二个参数。这时，就出现了双重默认值。
 
 ```javascript
 function fetch(url, { body = '', method = 'GET', headers = {} } = {}) {
@@ -149,7 +149,19 @@ fetch('http://example.com')
 
 上面代码中，函数`fetch`没有第二个参数时，函数参数的默认值就会生效，然后才是解构赋值的默认值生效，变量`method`才会取到默认值`GET`。
 
-作为练习，请问下面两种写法有什么差别？
+注意，函数参数的默认值生效以后，参数解构赋值依然会进行。
+
+```javascript
+function f({ a, b = 'world' } = { a: 'hello' }) {
+  console.log(b);
+}
+
+f() // world
+```
+
+上面示例中，函数`f()`调用时没有参数，所以参数默认值`{ a: 'hello' }`生效，然后再对这个默认值进行解构赋值，从而触发参数变量`b`的默认值生效。
+
+作为练习，大家可以思考一下，下面两种函数写法有什么差别？
 
 ```javascript
 // 写法一
@@ -161,11 +173,7 @@ function m1({x = 0, y = 0} = {}) {
 function m2({x, y} = { x: 0, y: 0 }) {
   return [x, y];
 }
-```
 
-上面两种写法都对函数的参数设定了默认值，区别是写法一函数参数的默认值是空对象，但是设置了对象解构赋值的默认值；写法二函数参数的默认值是一个有具体属性的对象，但是没有设置对象解构赋值的默认值。
-
-```javascript
 // 函数没有参数的情况
 m1() // [0, 0]
 m2() // [0, 0]

From 95e2e7921914ed8fc1b961a74578b8e1eab413da Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 9 Apr 2022 20:38:45 +0800
Subject: [PATCH 196/280] =?UTF-8?q?docs(object):=20edit=20=E5=AF=B9?=
 =?UTF-8?q?=E8=B1=A1=E7=9A=84=E6=89=A9=E5=B1=95=E8=BF=90=E7=AE=97=E7=AC=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/object.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/object.md b/docs/object.md
index 15380aab6..bd3464725 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -606,6 +606,23 @@ foo
 // {0: "h", 1: "e", 2: "l", 3: "l", 4: "o"}
 ```
 
+对象的扩展运算符，只会返回参数对象自身的、可枚举的属性，这一点要特别小心，尤其是用于类的实例对象时。
+
+```javascript
+class C {
+  p = 12;
+  m() {}
+}
+
+let c = new C();
+let clone = { ...c };
+
+clone.p; // ok
+clone.m(); // 报错
+```
+
+上面示例中，`c`是`C`类的实例对象，对其进行扩展运算时，只会返回`c`自身的属性`c.p`，而不会返回`c`的方法`c.m()`，因为这个方法定义在`C`的原型对象上（详见 Class 的章节）。
+
 对象的扩展运算符等同于使用`Object.assign()`方法。
 
 ```javascript

From ef7033411bf0f5e43bb968d2c5b56b4249b3aa23 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 29 May 2022 15:18:40 +0800
Subject: [PATCH 197/280] docs(module): edit import()

---
 docs/module.md | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/docs/module.md b/docs/module.md
index 6c773c4cc..16deadc03 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -692,7 +692,28 @@ import(`./section-modules/${someVariable}.js`)
   });
 ```
 
-`import()`函数可以用在任何地方，不仅仅是模块，非模块的脚本也可以使用。它是运行时执行，也就是说，什么时候运行到这一句，就会加载指定的模块。另外，`import()`函数与所加载的模块没有静态连接关系，这点也是与`import`语句不相同。`import()`类似于 Node 的`require`方法，区别主要是前者是异步加载，后者是同步加载。
+`import()`函数可以用在任何地方，不仅仅是模块，非模块的脚本也可以使用。它是运行时执行，也就是说，什么时候运行到这一句，就会加载指定的模块。另外，`import()`函数与所加载的模块没有静态连接关系，这点也是与`import`语句不相同。`import()`类似于 Node.js 的`require()`方法，区别主要是前者是异步加载，后者是同步加载。
+
+由于`import()`返回 Promise
+对象，所以需要使用`then()`方法指定处理函数。考虑到代码的清晰，更推荐使用`await`命令。
+
+```javascript
+async function renderWidget() {
+  const container = document.getElementById('widget');
+  if (container !== null) {
+    // 等同于
+    // import("./widget").then(widget => {
+    //   widget.render(container);
+    // });
+    const widget = await import('./widget.js');
+    widget.render(container);
+  }
+}
+
+renderWidget();
+```
+
+上面示例中，`await`命令后面就是使用`import()`，对比`then()`的写法明显更简洁易读。
 
 ### 适用场合
 

From 8b9f1924a824898cb871dd2d69dc84c15ac1f0cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BD=BC=E8=A1=93=E5=90=91?=
 <48076971+Mookiepiece@users.noreply.github.com>
Date: Sat, 4 Jun 2022 18:49:46 +0800
Subject: [PATCH 198/280] docs(promise): edit Promise.any()

---
 docs/promise.md | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/docs/promise.md b/docs/promise.md
index 0474ceed5..2003d1880 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -811,17 +811,7 @@ try {
 
 上面代码中，`Promise.any()`方法的参数数组包含三个 Promise 操作。其中只要有一个变成`fulfilled`，`Promise.any()`返回的 Promise 对象就变成`fulfilled`。如果所有三个操作都变成`rejected`，那么`await`命令就会抛出错误。
 
-`Promise.any()`抛出的错误，不是一个一般的 Error 错误对象，而是一个 AggregateError 实例。它相当于一个数组，每个成员对应一个被`rejected`的操作所抛出的错误。下面是 AggregateError 的实现示例。
-
-```javascript
-// new AggregateError() extends Array
-
-const err = new AggregateError();
-err.push(new Error("first error"));
-err.push(new Error("second error"));
-// ...
-throw err;
-```
+`Promise.any()`抛出的错误是一个 AggregateError 实例（详见《对象的扩展》一章），里面包含了所有成员的错误。
 
 下面是一个例子。
 
@@ -835,7 +825,8 @@ Promise.any([resolved, rejected, alsoRejected]).then(function (result) {
 });
 
 Promise.any([rejected, alsoRejected]).catch(function (results) {
-  console.log(results); // [-1, Infinity]
+  console.log(results instanceof AggregateError); // true
+  console.log(results.errors); // [-1, Infinity]
 });
 ```
 

From e0772de8ec056088910e87dd77fe8ea0f02bb64f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 7 Jun 2022 15:27:41 +0800
Subject: [PATCH 199/280] docs(promise): edit AggregateError

---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index 2003d1880..ee6a7aab8 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -811,7 +811,7 @@ try {
 
 上面代码中，`Promise.any()`方法的参数数组包含三个 Promise 操作。其中只要有一个变成`fulfilled`，`Promise.any()`返回的 Promise 对象就变成`fulfilled`。如果所有三个操作都变成`rejected`，那么`await`命令就会抛出错误。
 
-`Promise.any()`抛出的错误是一个 AggregateError 实例（详见《对象的扩展》一章），里面包含了所有成员的错误。
+`Promise.any()`抛出的错误是一个 AggregateError 实例（详见《对象的扩展》一章），这个 AggregateError 实例对象的`errors`属性是一个数组，包含了所有成员的错误。
 
 下面是一个例子。
 

From a837d8f2ce01638481bb312d5e45f80886f3f473 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 25 Jun 2022 21:25:13 +0800
Subject: [PATCH 200/280] docs: update ES2022

---
 docs/array.md          |  12 +-
 docs/async.md          |  17 +-
 docs/class.md          | 490 +++++++++++++++++++++--------------------
 docs/object-methods.md |  28 +++
 docs/object.md         |  25 +++
 docs/regex.md          |  10 +-
 6 files changed, 318 insertions(+), 264 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index bd51d2481..f42c02615 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -843,7 +843,7 @@ arr.flatMap(function callback(currentValue[, index[, array]]) {
 
 这是因为方括号运算符`[]`在 JavaScript 语言里面，不仅用于数组，还用于对象。对于对象来说，方括号里面就是键名，比如`obj[1]`引用的是键名为字符串`1`的键，同理`obj[-1]`引用的是键名为字符串`-1`的键。由于 JavaScript 的数组是特殊的对象，所以方括号里面的负数无法再有其他语义了，也就是说，不可能添加新语法来支持负索引。
 
-为了解决这个问题，现在有一个[提案](https://github.com/tc39/proposal-relative-indexing-method/)，为数组实例增加了`at()`方法，接受一个整数作为参数，返回对应位置的成员，支持负索引。这个方法不仅可用于数组，也可用于字符串和类型数组（TypedArray）。
+为了解决这个问题，[ES2022](https://github.com/tc39/proposal-relative-indexing-method/) 为数组实例增加了`at()`方法，接受一个整数作为参数，返回对应位置的成员，并支持负索引。这个方法不仅可用于数组，也可用于字符串和类型数组（TypedArray）。
 
 ```javascript
 const arr = [5, 12, 8, 130, 44];
@@ -853,6 +853,16 @@ arr.at(-2) // 130
 
 如果参数位置超出了数组范围，`at()`返回`undefined`。
 
+```javascript
+const sentence = 'This is a sample sentence';
+
+sentence.at(0); // 'T'
+sentence.at(-1); // 'e'
+
+sentence.at(-100) // undefined
+sentence.at(100) // undefined
+```
+
 ## 数组的空位
 
 数组的空位指的是，数组的某一个位置没有任何值，比如`Array()`构造函数返回的数组都是空位。
diff --git a/docs/async.md b/docs/async.md
index 5d9376a79..e9fc258ce 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -724,7 +724,7 @@ async function logInOrder(urls) {
 
 ## 顶层 await
 
-根据语法规格，`await`命令只能出现在 async 函数内部，否则都会报错。
+早期的语法规定是，`await`命令只能出现在 async 函数内部，否则都会报错。
 
 ```javascript
 // 报错
@@ -733,7 +733,7 @@ const data = await fetch('https://api.example.com');
 
 上面代码中，`await`命令独立使用，没有放在 async 函数里面，就会报错。
 
-目前，有一个[语法提案](https://github.com/tc39/proposal-top-level-await)，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。这个提案的目的，是借用`await`解决模块异步加载的问题。
+从 [ES2022](https://github.com/tc39/proposal-top-level-await) 开始，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。它的只要目的，是使用`await`解决模块异步加载的问题。
 
 ```javascript
 // awaiting.js
@@ -749,19 +749,6 @@ export { output };
 
 上面代码中，模块`awaiting.js`的输出值`output`，取决于异步操作。我们把异步操作包装在一个 async 函数里面，然后调用这个函数，只有等里面的异步操作都执行，变量`output`才会有值，否则就返回`undefined`。
 
-上面的代码也可以写成立即执行函数的形式。
-
-```javascript
-// awaiting.js
-let output;
-(async function main() {
-  const dynamic = await import(someMission);
-  const data = await fetch(url);
-  output = someProcess(dynamic.default, data);
-})();
-export { output };
-```
-
 下面是加载这个模块的写法。
 
 ```javascript
diff --git a/docs/class.md b/docs/class.md
index 606848b5b..a2ec44fb2 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1,8 +1,6 @@
 # Class 的基本语法
 
-## 简介
-
-### 类的由来
+## 类的由来
 
 JavaScript 语言中，生成实例对象的传统方法是通过构造函数。下面是一个例子。
 
@@ -166,7 +164,7 @@ Object.getOwnPropertyNames(Point.prototype)
 
 上面代码采用 ES5 的写法，`toString()`方法就是可枚举的。
 
-### constructor 方法
+## constructor() 方法
 
 `constructor()`方法是类的默认方法，通过`new`命令生成对象实例时，自动调用该方法。一个类必须有`constructor()`方法，如果没有显式定义，一个空的`constructor()`方法会被默认添加。
 
@@ -210,9 +208,9 @@ Foo()
 // TypeError: Class constructor Foo cannot be invoked without 'new'
 ```
 
-### 类的实例
+## 类的实例
 
-生成类的实例的写法，与 ES5 完全一样，也是使用`new`命令。前面说过，如果忘记加上`new`，像函数那样调用`Class`，将会报错。
+生成类的实例的写法，与 ES5 完全一样，也是使用`new`命令。前面说过，如果忘记加上`new`，像函数那样调用`Class()`，将会报错。
 
 ```javascript
 class Point {
@@ -226,12 +224,10 @@ var point = Point(2, 3);
 var point = new Point(2, 3);
 ```
 
-与 ES5 一样，实例的属性除非显式定义在其本身（即定义在`this`对象上），否则都是定义在原型上（即定义在`class`上）。
+类的属性和方法，除非显式定义在其本身（即定义在`this`对象上），否则都是定义在原型上（即定义在`class`上）。
 
 ```javascript
-//定义类
 class Point {
-
   constructor(x, y) {
     this.x = x;
     this.y = y;
@@ -240,7 +236,6 @@ class Point {
   toString() {
     return '(' + this.x + ', ' + this.y + ')';
   }
-
 }
 
 var point = new Point(2, 3);
@@ -269,7 +264,7 @@ p1.__proto__ === p2.__proto__
 
 这也意味着，可以通过实例的`__proto__`属性为“类”添加方法。
 
-> `__proto__` 并不是语言本身的特性，这是各大厂商具体实现时添加的私有属性，虽然目前很多现代浏览器的 JS 引擎中都提供了这个私有属性，但依旧不建议在生产中使用该属性，避免对环境产生依赖。生产环境中，我们可以使用 `Object.getPrototypeOf` 方法来获取实例对象的原型，然后再来为原型添加方法/属性。
+> `__proto__` 并不是语言本身的特性，这是各大厂商具体实现时添加的私有属性，虽然目前很多现代浏览器的 JS 引擎中都提供了这个私有属性，但依旧不建议在生产中使用该属性，避免对环境产生依赖。生产环境中，我们可以使用 `Object.getPrototypeOf()` 方法来获取实例对象的原型，然后再来为原型添加方法/属性。
 
 ```javascript
 var p1 = new Point(2,3);
@@ -286,7 +281,63 @@ p3.printName() // "Oops"
 
 上面代码在`p1`的原型上添加了一个`printName()`方法，由于`p1`的原型就是`p2`的原型，因此`p2`也可以调用这个方法。而且，此后新建的实例`p3`也可以调用这个方法。这意味着，使用实例的`__proto__`属性改写原型，必须相当谨慎，不推荐使用，因为这会改变“类”的原始定义，影响到所有实例。
 
-### 取值函数（getter）和存值函数（setter）
+## 实例属性的新写法
+
+[ES2022](https://github.com/tc39/proposal-class-fields) 为类的实例属性，又规定了一种新写法。实例属性现在除了可以定义在`constructor()`方法里面的`this`上面，也可以定义在类内部的最顶层。
+
+```javascript
+// 原来的写法
+class IncreasingCounter {
+  constructor() {
+    this._count = 0;
+  }
+  get value() {
+    console.log('Getting the current value!');
+    return this._count;
+  }
+  increment() {
+    this._count++;
+  }
+}
+```
+
+上面示例中，实例属性`_count`定义在`constructor()`方法里面的`this`上面。
+
+现在的新写法是，这个属性也可以定义在类的最顶层，其他都不变。
+
+```javascript
+class IncreasingCounter {
+  _count = 0;
+  get value() {
+    console.log('Getting the current value!');
+    return this._count;
+  }
+  increment() {
+    this._count++;
+  }
+}
+```
+
+上面代码中，实例属性`_count`与取值函数`value()`和`increment()`方法，处于同一个层级。这时，不需要在实例属性前面加上`this`。
+
+注意，新写法定义的属性是实例对象自身的属性，而不是定义在实例对象的原型上面。
+
+这种新写法的好处是，所有实例对象自身的属性都定义在类的头部，看上去比较整齐，一眼就能看出这个类有哪些实例属性。
+
+```javascript
+class foo {
+  bar = 'hello';
+  baz = 'world';
+
+  constructor() {
+    // ...
+  }
+}
+```
+
+上面的代码，一眼就能看出，`foo`类有两个实例属性，一目了然。另外，写起来也比较简洁。
+
+## 取值函数（getter）和存值函数（setter）
 
 与 ES5 一样，在“类”的内部可以使用`get`和`set`关键字，对某个属性设置存值函数和取值函数，拦截该属性的存取行为。
 
@@ -341,7 +392,7 @@ var descriptor = Object.getOwnPropertyDescriptor(
 
 上面代码中，存值函数和取值函数是定义在`html`属性的描述对象上面，这与 ES5 完全一致。
 
-### 属性表达式
+## 属性表达式
 
 类的属性名，可以采用表达式。
 
@@ -361,7 +412,7 @@ class Square {
 
 上面代码中，`Square`类的方法名`getArea`，是从表达式得到的。
 
-### Class 表达式
+## Class 表达式
 
 与函数一样，类也可以使用表达式的形式定义。
 
@@ -407,142 +458,6 @@ person.sayName(); // "张三"
 
 上面代码中，`person`是一个立即执行的类的实例。
 
-### 注意点
-
-**（1）严格模式**
-
-类和模块的内部，默认就是严格模式，所以不需要使用`use strict`指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。考虑到未来所有的代码，其实都是运行在模块之中，所以 ES6 实际上把整个语言升级到了严格模式。
-
-**（2）不存在提升**
-
-类不存在变量提升（hoist），这一点与 ES5 完全不同。
-
-```javascript
-new Foo(); // ReferenceError
-class Foo {}
-```
-
-上面代码中，`Foo`类使用在前，定义在后，这样会报错，因为 ES6 不会把类的声明提升到代码头部。这种规定的原因与下文要提到的继承有关，必须保证子类在父类之后定义。
-
-```javascript
-{
-  let Foo = class {};
-  class Bar extends Foo {
-  }
-}
-```
-
-上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而`let`命令是不提升的，所以导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
-
-**（3）name 属性**
-
-由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被`Class`继承，包括`name`属性。
-
-```javascript
-class Point {}
-Point.name // "Point"
-```
-
-`name`属性总是返回紧跟在`class`关键字后面的类名。
-
-**（4）Generator 方法**
-
-如果某个方法之前加上星号（`*`），就表示该方法是一个 Generator 函数。
-
-```javascript
-class Foo {
-  constructor(...args) {
-    this.args = args;
-  }
-  * [Symbol.iterator]() {
-    for (let arg of this.args) {
-      yield arg;
-    }
-  }
-}
-
-for (let x of new Foo('hello', 'world')) {
-  console.log(x);
-}
-// hello
-// world
-```
-
-上面代码中，`Foo`类的`Symbol.iterator`方法前有一个星号，表示该方法是一个 Generator 函数。`Symbol.iterator`方法返回一个`Foo`类的默认遍历器，`for...of`循环会自动调用这个遍历器。
-
-**（5）this 的指向**
-
-类的方法内部如果含有`this`，它默认指向类的实例。但是，必须非常小心，一旦单独使用该方法，很可能报错。
-
-```javascript
-class Logger {
-  printName(name = 'there') {
-    this.print(`Hello ${name}`);
-  }
-
-  print(text) {
-    console.log(text);
-  }
-}
-
-const logger = new Logger();
-const { printName } = logger;
-printName(); // TypeError: Cannot read property 'print' of undefined
-```
-
-上面代码中，`printName`方法中的`this`，默认指向`Logger`类的实例。但是，如果将这个方法提取出来单独使用，`this`会指向该方法运行时所在的环境（由于 class 内部是严格模式，所以 this 实际指向的是`undefined`），从而导致找不到`print`方法而报错。
-
-一个比较简单的解决方法是，在构造方法中绑定`this`，这样就不会找不到`print`方法了。
-
-```javascript
-class Logger {
-  constructor() {
-    this.printName = this.printName.bind(this);
-  }
-
-  // ...
-}
-```
-
-另一种解决方法是使用箭头函数。
-
-```javascript
-class Obj {
-  constructor() {
-    this.getThis = () => this;
-  }
-}
-
-const myObj = new Obj();
-myObj.getThis() === myObj // true
-```
-
-箭头函数内部的`this`总是指向定义时所在的对象。上面代码中，箭头函数位于构造函数内部，它的定义生效的时候，是在构造函数执行的时候。这时，箭头函数所在的运行环境，肯定是实例对象，所以`this`会总是指向实例对象。
-
-还有一种解决方法是使用`Proxy`，获取方法的时候，自动绑定`this`。
-
-```javascript
-function selfish (target) {
-  const cache = new WeakMap();
-  const handler = {
-    get (target, key) {
-      const value = Reflect.get(target, key);
-      if (typeof value !== 'function') {
-        return value;
-      }
-      if (!cache.has(value)) {
-        cache.set(value, value.bind(target));
-      }
-      return cache.get(value);
-    }
-  };
-  const proxy = new Proxy(target, handler);
-  return proxy;
-}
-
-const logger = selfish(new Logger());
-```
-
 ## 静态方法
 
 类相当于实例的原型，所有在类中定义的方法，都会被实例继承。如果在一个方法前，加上`static`关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为“静态方法”。
@@ -618,57 +533,6 @@ class Bar extends Foo {
 Bar.classMethod() // "hello, too"
 ```
 
-## 实例属性的新写法
-
-实例属性除了定义在`constructor()`方法里面的`this`上面，也可以定义在类的最顶层。
-
-```javascript
-class IncreasingCounter {
-  constructor() {
-    this._count = 0;
-  }
-  get value() {
-    console.log('Getting the current value!');
-    return this._count;
-  }
-  increment() {
-    this._count++;
-  }
-}
-```
-
-上面代码中，实例属性`this._count`定义在`constructor()`方法里面。另一种写法是，这个属性也可以定义在类的最顶层，其他都不变。
-
-```javascript
-class IncreasingCounter {
-  _count = 0;
-  get value() {
-    console.log('Getting the current value!');
-    return this._count;
-  }
-  increment() {
-    this._count++;
-  }
-}
-```
-
-上面代码中，实例属性`_count`与取值函数`value()`和`increment()`方法，处于同一个层级。这时，不需要在实例属性前面加上`this`。
-
-这种新写法的好处是，所有实例对象自身的属性都定义在类的头部，看上去比较整齐，一眼就能看出这个类有哪些实例属性。
-
-```javascript
-class foo {
-  bar = 'hello';
-  baz = 'world';
-
-  constructor() {
-    // ...
-  }
-}
-```
-
-上面的代码，一眼就能看出，`foo`类有两个实例属性，一目了然。另外，写起来也比较简洁。
-
 ## 静态属性
 
 静态属性指的是 Class 本身的属性，即`Class.propName`，而不是定义在实例对象（`this`）上的属性。
@@ -716,7 +580,7 @@ class Foo {
 
 ### 现有的解决方案
 
-私有方法和私有属性，是只能在类的内部访问的方法和属性，外部不能访问。这是常见需求，有利于代码的封装，但 ES6 不提供，只能通过变通方法模拟实现。
+私有方法和私有属性，是只能在类的内部访问的方法和属性，外部不能访问。这是常见需求，有利于代码的封装，但早期的 ES6 不提供，只能通过变通方法模拟实现。
 
 一种做法是在命名上加以区别。
 
@@ -790,9 +654,9 @@ Reflect.ownKeys(myClass.prototype)
 
 上面代码中，Symbol 值的属性名依然可以从类的外部拿到。
 
-### 私有属性的提案
+### 私有属性的写法
 
-目前，有一个[提案](https://github.com/tc39/proposal-private-methods)，为`class`加了私有属性。方法是在属性名之前，使用`#`表示。
+[ES2022](https://github.com/tc39/proposal-class-fields)，有一个[提案](https://github.com/tc39/proposal-private-methods)，为`class`加了私有属性。方法是在属性名之前，使用`#`表示。
 
 ```javascript
 class IncreasingCounter {
@@ -815,9 +679,29 @@ counter.#count // 报错
 counter.#count = 42 // 报错
 ```
 
-上面代码在类的外部，读取私有属性，就会报错。
+上面示例中，在类的外部，读取或写入私有属性`#count`，都会报错。
 
-下面是另一个例子。
+另外，不管在类的内部或外部，读取一个不存在的私有属性，也都会报错。这跟公开属性的行为完全不同，如果读取一个不存在的公开属性，不会报错，只会返回`undefined`。
+
+```javascript
+class IncreasingCounter {
+  #count = 0;
+  get value() {
+    console.log('Getting the current value!');
+    return this.#myCount; // 报错
+  }
+  increment() {
+    this.#count++;
+  }
+}
+
+const counter = new IncreasingCounter();
+counter.#myCount // 报错
+```
+
+上面示例中，`#myCount`是一个不存在的私有属性，不管在函数内部或外部，读取该属性都会导致报错。
+
+注意，私有属性的属性名必须包括`#`，如果不带`#`，会被当作另一个属性。
 
 ```javascript
 class Point {
@@ -926,42 +810,46 @@ FakeMath.#computeRandomNumber() // 报错
 
 ### in 运算符
 
-`try...catch`结构可以用来判断是否存在某个私有属性。
+前面说过，直接访问某个类不存在的私有属性会报错，但是访问不存在的公开属性不会报错。这个特性可以用来判断，某个对象是否为类的实例。
 
 ```javascript
-class A {
-  use(obj) {
+class C {
+  #brand;
+
+  static isC(obj) {
     try {
-      obj.#foo;
+      obj.#brand;
+      return true;
     } catch {
-      // 私有属性 #foo 不存在
+      return false;
     }
   }
 }
-
-const a = new A();
-a.use(a); // 报错
 ```
 
-上面示例中，类`A`并不存在私有属性`#foo`，所以`try...catch`报错了。
+上面示例中，类`C`的静态方法`isC()`就用来判断，某个对象是否为`C`的实例。它采用的方法就是，访问该对象的私有属性`#brand`。如果不报错，就会返回`true`；如果报错，就说明该对象不是当前类的实例，从而`catch`部分返回`false`。
 
-这样的写法很麻烦，可读性很差，V8 引擎改进了`in`运算符，使它也可以用来判断私有属性。
+因此，`try...catch`结构可以用来判断某个私有属性是否存在。但是，这样的写法很麻烦，代码可读性很差，[ES2022](https://github.com/tc39/proposal-private-fields-in-in) 改进了`in`运算符，使它也可以用来判断私有属性。
 
 ```javascript
-class A {
-  use(obj) {
-    if (#foo in obj) {
-      // 私有属性 #foo 存在
+class C {
+  #brand;
+
+  static isC(obj) {
+    if (#brand in obj) {
+      // 私有属性 #brand 存在
+      return true;
     } else {
       // 私有属性 #foo 不存在
+      return false;
     }
   }
 }
 ```
 
-上面示例中，`in`运算符判断当前类`A`的实例，是否有私有属性`#foo`，如果有返回`true`，否则返回`false`。
+上面示例中，`in`运算符判断某个对象是否有私有属性`#foo`。它不会报错，而是返回一个布尔值。
 
-`in`也可以跟`this`一起配合使用。
+这种用法的`in`，也可以跟`this`一起配合使用。
 
 ```javascript
 class A {
@@ -973,27 +861,7 @@ class A {
 }
 ```
 
-注意，判断私有属性时，`in`只能用在定义该私有属性的类的内部。
-
-```javascript
-class A {
-  #foo = 0;
-  static test(obj) {
-    console.log(#foo in obj);
-  }
-}
-
-A.test(new A()) // true
-A.test({}) // false
-
-class B {
-  #foo = 0;
-}
-
-A.test(new B()) // false
-```
-
-上面示例中，类`A`的私有属性`#foo`，只能在类`A`内部使用`in`运算符判断，而且只对`A`的实例返回`true`，对于其他对象都返回`false`。
+注意，判断私有属性时，`in`只能用在类的内部。
 
 子类从父类继承的私有属性，也可以使用`in`运算符来判断。
 
@@ -1116,6 +984,142 @@ console.log(getX(new C())); // 1
 
 上面示例中，`#x`是类的私有属性，如果类外部的`getX()`方法希望获取这个属性，以前是要写在类的`constructor()`方法里面，这样的话，每次新建实例都会定义一次`getX()`方法。现在可以写在静态块里面，这样的话，只在类生成时定义一次。
 
+## 类的注意点
+
+### 严格模式**
+
+类和模块的内部，默认就是严格模式，所以不需要使用`use strict`指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。考虑到未来所有的代码，其实都是运行在模块之中，所以 ES6 实际上把整个语言升级到了严格模式。
+
+### 不存在提升**
+
+类不存在变量提升（hoist），这一点与 ES5 完全不同。
+
+```javascript
+new Foo(); // ReferenceError
+class Foo {}
+```
+
+上面代码中，`Foo`类使用在前，定义在后，这样会报错，因为 ES6 不会把类的声明提升到代码头部。这种规定的原因与下文要提到的继承有关，必须保证子类在父类之后定义。
+
+```javascript
+{
+  let Foo = class {};
+  class Bar extends Foo {
+  }
+}
+```
+
+上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而`let`命令是不提升的，所以导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
+
+### name 属性**
+
+由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被`Class`继承，包括`name`属性。
+
+```javascript
+class Point {}
+Point.name // "Point"
+```
+
+`name`属性总是返回紧跟在`class`关键字后面的类名。
+
+### Generator 方法**
+
+如果某个方法之前加上星号（`*`），就表示该方法是一个 Generator 函数。
+
+```javascript
+class Foo {
+  constructor(...args) {
+    this.args = args;
+  }
+  * [Symbol.iterator]() {
+    for (let arg of this.args) {
+      yield arg;
+    }
+  }
+}
+
+for (let x of new Foo('hello', 'world')) {
+  console.log(x);
+}
+// hello
+// world
+```
+
+上面代码中，`Foo`类的`Symbol.iterator`方法前有一个星号，表示该方法是一个 Generator 函数。`Symbol.iterator`方法返回一个`Foo`类的默认遍历器，`for...of`循环会自动调用这个遍历器。
+
+### this 的指向**
+
+类的方法内部如果含有`this`，它默认指向类的实例。但是，必须非常小心，一旦单独使用该方法，很可能报错。
+
+```javascript
+class Logger {
+  printName(name = 'there') {
+    this.print(`Hello ${name}`);
+  }
+
+  print(text) {
+    console.log(text);
+  }
+}
+
+const logger = new Logger();
+const { printName } = logger;
+printName(); // TypeError: Cannot read property 'print' of undefined
+```
+
+上面代码中，`printName`方法中的`this`，默认指向`Logger`类的实例。但是，如果将这个方法提取出来单独使用，`this`会指向该方法运行时所在的环境（由于 class 内部是严格模式，所以 this 实际指向的是`undefined`），从而导致找不到`print`方法而报错。
+
+一个比较简单的解决方法是，在构造方法中绑定`this`，这样就不会找不到`print`方法了。
+
+```javascript
+class Logger {
+  constructor() {
+    this.printName = this.printName.bind(this);
+  }
+
+  // ...
+}
+```
+
+另一种解决方法是使用箭头函数。
+
+```javascript
+class Obj {
+  constructor() {
+    this.getThis = () => this;
+  }
+}
+
+const myObj = new Obj();
+myObj.getThis() === myObj // true
+```
+
+箭头函数内部的`this`总是指向定义时所在的对象。上面代码中，箭头函数位于构造函数内部，它的定义生效的时候，是在构造函数执行的时候。这时，箭头函数所在的运行环境，肯定是实例对象，所以`this`会总是指向实例对象。
+
+还有一种解决方法是使用`Proxy`，获取方法的时候，自动绑定`this`。
+
+```javascript
+function selfish (target) {
+  const cache = new WeakMap();
+  const handler = {
+    get (target, key) {
+      const value = Reflect.get(target, key);
+      if (typeof value !== 'function') {
+        return value;
+      }
+      if (!cache.has(value)) {
+        cache.set(value, value.bind(target));
+      }
+      return cache.get(value);
+    }
+  };
+  const proxy = new Proxy(target, handler);
+  return proxy;
+}
+
+const logger = selfish(new Logger());
+```
+
 ## new.target 属性
 
 `new`是从构造函数生成实例对象的命令。ES6 为`new`命令引入了一个`new.target`属性，该属性一般用在构造函数之中，返回`new`命令作用于的那个构造函数。如果构造函数不是通过`new`命令或`Reflect.construct()`调用的，`new.target`会返回`undefined`，因此这个属性可以用来确定构造函数是怎么调用的。
diff --git a/docs/object-methods.md b/docs/object-methods.md
index a9d8200f3..999496de0 100644
--- a/docs/object-methods.md
+++ b/docs/object-methods.md
@@ -833,3 +833,31 @@ Object.fromEntries(map)
 Object.fromEntries(new URLSearchParams('foo=bar&baz=qux'))
 // { foo: "bar", baz: "qux" }
 ```
+
+## Object.hasOwn()
+
+JavaScript 对象的属性分成两种：自身的属性和继承的属性。对象实例有一个`hasOwnProperty()`方法，可以判断某个属性是否为原生属性。ES2022 在`Object`对象上面新增了一个静态方法[`Object.hasOwn()`](https://github.com/tc39/proposal-accessible-object-hasownproperty)，也可以判断是否为自身的属性。
+
+`Object.hasOwn()`可以接受两个参数，第一个是所要判断的对象，第二个是属性名。
+
+```javascript
+const foo = Object.create({ a: 123 });
+foo.b = 456;
+
+Object.hasOwn(foo, 'a') // false
+Object.hasOwn(foo, 'b') // true
+```
+
+上面示例中，对象`foo`的属性`a`是继承属性，属性`b`是原生属性。`Object.hasOwn()`对属性`a`返回`false`，对属性`b`返回`true`。
+
+`Object.hasOwn()`的一个好处是，对于不继承`Object.prototype`的对象不会报错，而`hasOwnProperty()`是会报错的。
+
+```javascript
+const obj = Object.create(null);
+
+obj.hasOwnProperty('foo') // 报错
+Object.hasOwn(obj, 'foo') // false
+```
+
+上面示例中，`Object.create(null)`返回的对象`obj`是没有原型的，不继承任何属性，这导致调用`obj.hasOwnProperty()`会报错，但是`Object.hasOwn()`就能正确处理这种情况。
+
diff --git a/docs/object.md b/docs/object.md
index bd3464725..cd817ec1e 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -770,3 +770,28 @@ try {
 }
 ```
 
+## Error 对象的 cause 属性
+
+Error 对象用来表示代码运行时的异常情况，但是从这个对象拿到的上下文信息，有时很难解读，也不够充分。[ES2022](https://github.com/tc39/proposal-error-cause) 为 Error 对象添加了一个`cause`属性，可以在生成错误时，添加报错原因的描述。
+
+它的用法是`new Error()`生成 Error 实例时，给出一个描述对象，该对象可以设置`cause`属性。
+
+```javascript
+const actual = new Error('an error!', { cause: 'Error cause' });
+actual.cause; // 'Error cause'
+```
+
+上面示例中，生成 Error 实例时，使用描述对象给出`cause`属性，写入报错的原因。然后，就可以从实例对象上读取这个属性。
+
+`casue`属性可以放置任意内容，不必一定是字符串。
+
+```javascript
+try {
+  maybeWorks();
+} catch (err) {
+  throw new Error('maybeWorks failed!', { cause: err });
+}
+```
+
+上面示例中，`cause`属性放置的就是一个对象。
+
diff --git a/docs/regex.md b/docs/regex.md
index bbe069fb9..7c1c5e7ed 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -596,9 +596,9 @@ RE_TWICE.test('abc!abc!ab') // false
 
 ## 正则匹配索引
 
-正则匹配结果的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法，返回结果有一个`index`属性，可以获取整个匹配结果的开始位置，但是如果包含组匹配，每个组匹配的开始位置，很难拿到。
+正则匹配的结果，在原始字符串里面的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法的返回结果，现有一个`index`属性，可以获取整个匹配结果的开始位置。但是，组匹配的每个组的开始位置，很难拿到。
 
-现在有一个[第三阶段提案](https://github.com/tc39/proposal-regexp-match-Indices)，为`exec()`方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
+[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 为`exec()`方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
 
 ```javascript
 const text = 'zabbcdef';
@@ -609,9 +609,9 @@ result.index // 1
 result.indices // [ [1, 3] ]
 ```
 
-上面例子中，`exec()`方法的返回结果`result`，它的`index`属性是整个匹配结果（`ab`）的开始位置，而它的`indices`属性是一个数组，成员是每个匹配的开始位置和结束位置的数组。由于该例子的正则表达式没有组匹配，所以`indices`数组只有一个成员，表示整个匹配的开始位置是`1`，结束位置是`3`。
+上面例子中，`exec()`方法的返回结果`result`，它的`index`属性是整个匹配结果（`ab`）的开始位置，现在新增了一个`indices`属性。它是一个数组，每个成员还是一个数组，包含了匹配结果在原始字符串的开始位置和结束位置。由于上例的正则表达式没有组匹配，所以`indices`数组只有一个成员，表示整个匹配的开始位置是`1`，结束位置是`3`。
 
-注意，开始位置包含在匹配结果之中，但是结束位置不包含在匹配结果之中。比如，匹配结果为`ab`，分别是原始字符串的第1位和第2位，那么结束位置就是第3位。
+注意，开始位置包含在匹配结果之中，相当于匹配结果的第一个字符的位置。但是，结束位置不包含在匹配结果之中，是匹配结果的下一个字符。比如，上例匹配结果的最后一个字符`b`的位置，是原始字符串的2号位，那么结束位置`3`就是下一个字符的位置。
 
 如果正则表达式包含组匹配，那么`indices`属性对应的数组就会包含多个成员，提供每个组匹配的开始位置和结束位置。
 
@@ -623,7 +623,7 @@ const result = re.exec(text);
 result.indices // [ [ 1, 6 ], [ 4, 6 ] ]
 ```
 
-上面例子中，正则表达式包含一个组匹配，那么`indices`属性数组就有两个成员，第一个成员是整个匹配结果（`abbcd`）的开始位置和结束位置，第二个成员是组匹配（`cd`）的开始位置和结束位置。
+上面例子中，正则表达式包含一个组匹配`(cd)`，那么`indices`属性数组就有两个成员，第一个成员是整个匹配结果（`abbcd`）的开始位置和结束位置，第二个成员是组匹配（`cd`）的开始位置和结束位置。
 
 下面是多个组匹配的例子。
 

From 6880b36897aed5b553c5b7437ad15da2469f19c5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 25 Jun 2022 21:59:29 +0800
Subject: [PATCH 201/280] docs(class): fix typo

---
 docs/class.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index a2ec44fb2..00f185514 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -986,11 +986,11 @@ console.log(getX(new C())); // 1
 
 ## 类的注意点
 
-### 严格模式**
+### 严格模式
 
 类和模块的内部，默认就是严格模式，所以不需要使用`use strict`指定运行模式。只要你的代码写在类或模块之中，就只有严格模式可用。考虑到未来所有的代码，其实都是运行在模块之中，所以 ES6 实际上把整个语言升级到了严格模式。
 
-### 不存在提升**
+### 不存在提升
 
 类不存在变量提升（hoist），这一点与 ES5 完全不同。
 
@@ -1011,7 +1011,7 @@ class Foo {}
 
 上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而`let`命令是不提升的，所以导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
 
-### name 属性**
+### name 属性
 
 由于本质上，ES6 的类只是 ES5 的构造函数的一层包装，所以函数的许多特性都被`Class`继承，包括`name`属性。
 
@@ -1022,7 +1022,7 @@ Point.name // "Point"
 
 `name`属性总是返回紧跟在`class`关键字后面的类名。
 
-### Generator 方法**
+### Generator 方法
 
 如果某个方法之前加上星号（`*`），就表示该方法是一个 Generator 函数。
 
@@ -1047,7 +1047,7 @@ for (let x of new Foo('hello', 'world')) {
 
 上面代码中，`Foo`类的`Symbol.iterator`方法前有一个星号，表示该方法是一个 Generator 函数。`Symbol.iterator`方法返回一个`Foo`类的默认遍历器，`for...of`循环会自动调用这个遍历器。
 
-### this 的指向**
+### this 的指向
 
 类的方法内部如果含有`this`，它默认指向类的实例。但是，必须非常小心，一旦单独使用该方法，很可能报错。
 

From 41970f7db088611b61b8c1638a6a7c27e267c1f5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 26 Jun 2022 22:17:23 +0800
Subject: [PATCH 202/280] docs: update latest proposals

---
 docs/array.md   | 117 +++++++++++++++++++++++++++++++++++++++++++++---
 docs/regex.md   |  35 +++++++++++++++
 docs/set-map.md |   2 +
 3 files changed, 147 insertions(+), 7 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index f42c02615..8c2b69000 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -595,9 +595,9 @@ i32a.copyWithin(0, 2);
 // Int32Array [4, 2, 3, 4, 5]
 ```
 
-## 实例方法：find() 和 findIndex()
+## 实例方法：find()，findIndex()，findLast()，findLastIndex()
 
-数组实例的`find`方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为`true`的成员，然后返回该成员。如果没有符合条件的成员，则返回`undefined`。
+数组实例的`find()`方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为`true`的成员，然后返回该成员。如果没有符合条件的成员，则返回`undefined`。
 
 ```javascript
 [1, 4, -5, 10].find((n) => n < 0)
@@ -612,9 +612,9 @@ i32a.copyWithin(0, 2);
 }) // 10
 ```
 
-上面代码中，`find`方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。
+上面代码中，`find()`方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。
 
-数组实例的`findIndex`方法的用法与`find`方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回`-1`。
+数组实例的`findIndex()`方法的用法与`find()`方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回`-1`。
 
 ```javascript
 [1, 5, 10, 15].findIndex(function(value, index, arr) {
@@ -632,9 +632,9 @@ let person = {name: 'John', age: 20};
 [10, 12, 26, 15].find(f, person);    // 26
 ```
 
-上面的代码中，`find`函数接收了第二个参数`person`对象，回调函数中的`this`对象指向`person`对象。
+上面的代码中，`find()`函数接收了第二个参数`person`对象，回调函数中的`this`对象指向`person`对象。
 
-另外，这两个方法都可以发现`NaN`，弥补了数组的`indexOf`方法的不足。
+另外，这两个方法都可以发现`NaN`，弥补了数组的`indexOf()`方法的不足。
 
 ```javascript
 [NaN].indexOf(NaN)
@@ -644,7 +644,23 @@ let person = {name: 'John', age: 20};
 // 0
 ```
 
-上面代码中，`indexOf`方法无法识别数组的`NaN`成员，但是`findIndex`方法可以借助`Object.is`方法做到。
+上面代码中，`indexOf()`方法无法识别数组的`NaN`成员，但是`findIndex()`方法可以借助`Object.is()`方法做到。
+
+`find()`和`findIndex()`都是从数组的0号位，依次向后检查。[ES2022](https://github.com/tc39/proposal-array-find-from-last) 新增了两个方法`findLast()`和`findLastIndex()`，从数组的最后一个成员开始，依次向前检查，其他都保持不变。
+
+```javascript
+const array = [
+  { value: 1 },
+  { value: 2 },
+  { value: 3 },
+  { value: 4 }
+];
+
+array.findLast(n => n.value % 2 === 1); // { value: 3 }
+array.findLastIndex(n => n.value % 2 === 1); // 2
+```
+
+上面示例中，`findLast()`和`findLastIndex()`从数组结尾开始，寻找第一个`value`属性为奇数的成员。结果，该成员是`{ value: 3 }`，位置是2号位。
 
 ## 实例方法：fill()
 
@@ -863,6 +879,93 @@ sentence.at(-100) // undefined
 sentence.at(100) // undefined
 ```
 
+## 实例方法：toReversed()，toSorted()，toSpliced()，with()
+
+很多数组的传统方法会改变原数组，比如`push()`、`pop()`、`shift()`、`unshift()`等等。数组只要调用了这些方法，它的值就变了。现在有一个[提案](https://github.com/tc39/proposal-change-array-by-copy)，允许对数组进行操作时，不改变原数组，而返回一个原数组的拷贝。
+
+这样的方法一共有四个。
+
+- `Array.prototype.toReversed() -> Array`
+- `Array.prototype.toSorted(compareFn) -> Array`
+- `Array.prototype.toSpliced(start, deleteCount, ...items) -> Array`
+- `Array.prototype.with(index, value) -> Array`
+
+它们分别对应数组的原有方法。
+
+- `toReversed()`对应`reverse()`，用来颠倒数组成员的位置。
+- `toSorted()`对应`sort()`，用来对数组成员排序。
+- `toSpliced()`对应`splice()`，用来在指定位置，删除指定数量的成员，并插入新成员。
+- `with(index, value)`对应`splice(index, 1, value)`，用来将指定位置的成员替换为新的值。
+
+上面是这四个新方法对应的原有方法，含义和用法完全一样，唯一不同的是不会改变原数组，而是返回原数组操作后的拷贝。
+
+下面是示例。
+
+```javascript
+const sequence = [1, 2, 3];
+sequence.toReversed() // [3, 2, 1]
+sequence // [1, 2, 3]
+
+const outOfOrder = [3, 1, 2];
+outOfOrder.toSorted() // [1, 2, 3]
+outOfOrder // [3, 1, 2]
+
+const array = [1, 2, 3, 4];
+array.toSpliced(1, 2, 5, 6, 7) // [1, 5, 6, 7, 4]
+array // [1, 2, 3, 4]
+
+const correctionNeeded = [1, 1, 3];
+correctionNeeded.with(1, 2) // [1, 2, 3]
+correctionNeeded // [1, 1, 3]
+```
+
+## 实例方法：group()，groupToMap()
+
+数组成员分组是一个常见需求，比如 SQL 有`GROUP BY`子句和函数式编程有 MapReduce 方法。现在有一个[提案](https://github.com/tc39/proposal-array-grouping)，为 JavaScript 新增了数组实例方法`group()`和`groupToMap()`，它们可以根据分组函数的运行结果，将数组成员分组。
+
+`group()`的参数是一个分组函数，原数组的每个成员都会依次执行这个函数，确定自己是哪一个组。
+
+```javascript
+const array = [1, 2, 3, 4, 5];
+
+array.group((num, index, array) => {
+  return num % 2 === 0 ? 'even': 'odd';
+});
+// { odd: [1, 3, 5], even: [2, 4] }
+```
+
+`group()`的分组函数可以接受三个参数，依次是数组的当前成员、该成员的位置序号、原数组（上例是`num`、`index`和`array`）。分组函数的返回值应该是字符串（或者可以自动转为字符串），以作为分组后的组名。
+
+`group()`的返回值是一个对象，该对象的键名就是每一组的组名，即分组函数返回的每一个字符串（上例是`even`和`odd`）；该对象的键值是一个数组，包括所有产生当前键名的原数组成员。
+
+下面是另一个例子。
+
+```javascript
+[6.1, 4.2, 6.3].groupBy(Math.floor)
+// { '4': [4.2], '6': [6.1, 6.3] }
+```
+
+上面示例中，`Math.floor`作为分组函数，对原数组进行分组。它的返回值原本是数值，这时会自动转为字符串，作为分组的组名。原数组的成员根据分组函数的运行结果，进入对应的组。
+
+`group()`还可以接受一个对象，作为第二个参数。该对象会绑定分组函数（第一个参数）里面的`this`，不过如果分组函数是一个箭头函数，该对象无效，因为箭头函数内部的`this`是固化的。
+
+`groupToMap()`的作用和用法与`group()`完全一致，唯一的区别是返回值是一个 Map 结构，而不是对象。Map 结构的键名可以是各种值，所以不管分组函数返回什么值，都会直接作为组名（Map 结构的键名），不会强制转为字符串。这对于分组函数返回值是对象的情况，尤其有用。
+
+```javascript
+const array = [1, 2, 3, 4, 5];
+
+const odd  = { odd: true };
+const even = { even: true };
+array.groupToMap((num, index, array) => {
+  return num % 2 === 0 ? even: odd;
+});
+//  Map { {odd: true}: [1, 3, 5], {even: true}: [2, 4] }
+```
+
+上面示例返回的是一个 Map 结构，它的键名就是分组函数返回的两个对象`odd`和`even`。
+
+总之，按照字符串分组就使用`group()`，按照对象分组就使用`groupToMap()`。
+
 ## 数组的空位
 
 数组的空位指的是，数组的某一个位置没有任何值，比如`Array()`构造函数返回的数组都是空位。
diff --git a/docs/regex.md b/docs/regex.md
index 7c1c5e7ed..1a0b215ef 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -478,6 +478,41 @@ const regexArrows = /^\p{Block=Arrows}+$/u;
 regexArrows.test('←↑→↓↔↕↖↗↘↙⇏⇐⇑⇒⇓⇔⇕⇖⇗⇘⇙⇧⇩') // true
 ```
 
+## v 修饰符，Unicode 属性类的运算
+
+有时，需要向某个 Unicode 属性类添加或减少字符，即需要对属性类进行运算。现在有一个[提案](https://github.com/tc39/proposal-regexp-v-flag)，增加了 Unicode 属性类的运算功能。
+
+它提供两种形式的运算，一种是差集运算（A 集合减去 B 集合），另一种是交集运算。
+
+```javascript
+// 差集运算（A 减去 B）
+[A--B]
+
+// 交集运算（A 与 B 的交集）
+[A&&B]
+```
+
+上面两种写法中，A 和 B 要么是字符类（例如`[a-z]`），要么是 Unicode 属性类（例如`\p{ASCII}`）。
+
+而且，这种运算支持方括号之中嵌入方括号，即方括号的嵌套。
+
+```javascript
+// 方括号嵌套的例子
+[A--[0-9]]
+```
+
+这种运算的前提是，正则表达式必须使用新引入的`v`修饰符。前面说过，Unicode 属性类必须搭配`u`修饰符使用，这个`v`修饰符等于代替`u`，使用了它就不必再写`u`了。
+
+下面是一些例子。
+
+```javascript
+// 十进制字符去除 ASCII 码的0到9
+[\p{Decimal_Number}--[0-9]]
+
+// Emoji 字符去除 ASCII 码字符
+[\p{Emoji}--\p{ASCII}]
+```
+
 ## 具名组匹配
 
 ### 简介
diff --git a/docs/set-map.md b/docs/set-map.md
index cc6159db1..d38a1d5db 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -942,6 +942,8 @@ map.set(null, 2)
 
 上面代码中，如果将数值`1`和`Symbol`值作为 WeakMap 的键名，都会报错。
 
+不过，现在有一个[提案](https://github.com/tc39/proposal-symbols-as-weakmap-keys)，允许 Symbol 值也可以作为 WeakMap 的键名。一旦纳入标准，就意味着键名存在两种可能：对象和 Symbole 值。
+
 其次，`WeakMap`的键名所指向的对象，不计入垃圾回收机制。
 
 `WeakMap`的设计目的在于，有时我们想在某个对象上面存放一些数据，但是这会形成对于这个对象的引用。请看下面的例子。

From fbd7faf0bc26377dc1495722692802e1c401e0f8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 28 Jun 2022 04:06:38 +0800
Subject: [PATCH 203/280] docs(decorator): add stage 3 proposal content

---
 docs/decorator.md | 510 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 509 insertions(+), 1 deletion(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index 8d343a1d8..5057c0305 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -2,7 +2,7 @@
 
 [说明] Decorator 提案经过了大幅修改，目前还没有定案，不知道语法会不会再变。下面的内容完全依据以前的提案，已经有点过时了。等待定案以后，需要完全重写。
 
-装饰器（Decorator）是一种与类（class）相关的语法，用来注释或修改类和类方法。许多面向对象的语言都有这项功能，目前有一个[提案](https://github.com/tc39/proposal-decorators)将其引入了 ECMAScript。
+装饰器（Decorator）用来增强 JavaScript 类（class）的功能，许多面向对象的语言都有这种语法，目前有一个[提案](https://github.com/tc39/proposal-decorators)将其引入了 ECMAScript。
 
 装饰器是一种函数，写成`@ + 函数名`。它可以放在类和类方法的定义前面。
 
@@ -19,6 +19,53 @@
 
 上面代码一共使用了四个装饰器，一个用在类本身，另外三个用在类方法。它们不仅增加了代码的可读性，清晰地表达了意图，而且提供一种方便的手段，增加或修改类的功能。
 
+装饰器可以用来装饰四种类型的值。
+
+- 类
+- 类的属性（public, private, and static）
+- 类的方法（public, private, and static）
+- 类的访问器（accessor）（public, private, and static）
+
+## 装饰器 API（新语法）
+
+装饰器是一个函数，它的 API 采用 TypeScript 描述，就是下面的形式。
+
+```typescript
+type Decorator = (value: Input, context: {
+  kind: string;
+  name: string | symbol;
+  access: {
+    get?(): unknown;
+    set?(value: unknown): void;
+  };
+  private?: boolean;
+  static?: boolean;
+  addInitializer?(initializer: () => void): void;
+}) => Output | void;
+```
+
+装饰器函数调用时，会接收到两个参数。
+
+- `value`：被装饰的值，某些情况下可能是`undefined`（装饰属性时）。
+- `context`：一个对象，包含了被装饰的值的上下文信息。
+
+另外，`input`和`output`表示输入的值和输出的值，每种装饰器都不一样，放在后面介绍。所有装饰器都可以不返回任何值。
+
+`context`对象的属性如下。
+
+- `kind`：字符串，表示装饰类型，可能取值有`class`、`method`、`getter`、`setter`、`field`、`accessor`。
+- `name`：被装饰的值的名称: The name of the value, or in the case of private elements the description of it (e.g. the readable name).
+- `access`：对象，包含访问这个值的方法，即存值器和取值器。
+- `static`: 布尔值，该值是否为静态元素。
+- `private`：布尔值，该值是否为私有元素。
+- `addInitializer`：函数，允许用户增加初始化逻辑。
+
+装饰器的执行步骤如下。
+
+1. 计算各个装饰器的值，按照从左到右，从上到下的顺序。
+1. 调用方法装饰器。
+1. 调用类装饰器。
+
 ## 类的装饰
 
 装饰器可以用来装饰整个类。
@@ -154,6 +201,118 @@ export default class MyReactComponent extends React.Component {}
 
 相对来说，后一种写法看上去更容易理解。
 
+## 类装饰器（新语法）
+
+类装饰器的类型描述如下。
+
+```typescript
+type ClassDecorator = (value: Function, context: {
+  kind: "class";
+  name: string | undefined;
+  addInitializer(initializer: () => void): void;
+}) => Function | void;
+```
+
+类装饰器的第一个参数，就是被装饰的类。第二个参数是上下文对象，如果被装饰的类是一个匿名类，`name`属性就为`undefined`。
+
+类装饰器可以返回一个新的类，取代原来的类，也可以不返回任何值。如果返回的不是构造函数，就会报错。
+
+下面是一个例子。
+
+```javascript
+function logged(value, { kind, name }) {
+  if (kind === "class") {
+    return class extends value {
+      constructor(...args) {
+        super(...args);
+        console.log(`constructing an instance of ${name} with arguments ${args.join(", ")}`);
+      }
+    }
+  }
+
+  // ...
+}
+
+@logged
+class C {}
+
+new C(1);
+// constructing an instance of C with arguments 1
+```
+
+如果不使用装饰器，类装饰器实际上执行的是下面的语法。
+
+```javascript
+class C {}
+
+C = logged(C, {
+  kind: "class",
+  name: "C",
+}) ?? C;
+
+new C(1);
+```
+
+## 方法装饰器（新语法）
+
+方式装饰器使用 TypeScript 描述类型如下。
+
+```typescript
+type ClassMethodDecorator = (value: Function, context: {
+  kind: "method";
+  name: string | symbol;
+  access: { get(): unknown };
+  static: boolean;
+  private: boolean;
+  addInitializer(initializer: () => void): void;
+}) => Function | void;
+```
+
+方法装饰器的第一个参数`value`，就是所要装饰的方法。
+
+方法装饰器可以返回一个新方法，取代原来的方法，也可以不返回值，表示依然使用原来的方法。如果返回其他类型的值，就会报错。
+
+下面是一个例子。
+
+```typescript
+function logged(value, { kind, name }) {
+  if (kind === "method") {
+    return function (...args) {
+      console.log(`starting ${name} with arguments ${args.join(", ")}`);
+      const ret = value.call(this, ...args);
+      console.log(`ending ${name}`);
+      return ret;
+    };
+  }
+}
+
+class C {
+  @logged
+  m(arg) {}
+}
+
+new C().m(1);
+// starting m with arguments 1
+// ending m
+```
+
+上面示例中，装饰器`@logged`返回一个函数，代替原来的`m()`方法。
+
+这里的装饰器实际上是一个语法糖，真正的操作是像下面这样，改掉原型链上面`m()`方法。
+
+```javascript
+class C {
+  m(arg) {}
+}
+
+C.prototype.m = logged(C.prototype.m, {
+  kind: "method",
+  name: "m",
+  static: false,
+  private: false,
+}) ?? C.prototype.m;
+```
+
 ## 方法的装饰
 
 装饰器不仅可以装饰类，还可以装饰类的属性。
@@ -366,6 +525,355 @@ function loggingDecorator(wrapped) {
 const wrapped = loggingDecorator(doSomething);
 ```
 
+## 存取器装饰器（新语法）
+
+存取器装饰器使用 TypeScript 描述的类型如下。
+
+```typescript
+type ClassGetterDecorator = (value: Function, context: {
+  kind: "getter";
+  name: string | symbol;
+  access: { get(): unknown };
+  static: boolean;
+  private: boolean;
+  addInitializer(initializer: () => void): void;
+}) => Function | void;
+
+type ClassSetterDecorator = (value: Function, context: {
+  kind: "setter";
+  name: string | symbol;
+  access: { set(value: unknown): void };
+  static: boolean;
+  private: boolean;
+  addInitializer(initializer: () => void): void;
+}) => Function | void;
+```
+
+存取器装饰器的第一个参数就是原始的存值器（setter）和取值器（getter）。
+
+存取器装饰器的返回值如果是一个函数，就会取代原来的存取器。本质上，就像方法装饰器一样，修改发生在类的原型对象上。它也可以不返回任何值，继续使用原来的存取器。如果返回其他类型的值，就会报错。
+
+存取器装饰器对存值器（setter）和取值器（getter）是分开作用的。下面的例子里面，`@foo`只装饰`get x()`，不装饰`set x()`。
+
+```javascript
+class C {
+  @foo
+  get x() {
+    // ...
+  }
+
+  set x(val) {
+    // ...
+  }
+}
+```
+
+上一节的`@logged`装饰器稍加修改，就可以用在存取装饰器。
+
+```javascript
+function logged(value, { kind, name }) {
+  if (kind === "method" || kind === "getter" || kind === "setter") {
+    return function (...args) {
+      console.log(`starting ${name} with arguments ${args.join(", ")}`);
+      const ret = value.call(this, ...args);
+      console.log(`ending ${name}`);
+      return ret;
+    };
+  }
+}
+
+class C {
+  @logged
+  set x(arg) {}
+}
+
+new C().x = 1
+// starting x with arguments 1
+// ending x
+```
+
+如果去掉语法糖，使用传统语法来写，就是改掉了类的原型链。
+
+```javascript
+class C {
+  set x(arg) {}
+}
+
+let { set } = Object.getOwnPropertyDescriptor(C.prototype, "x");
+set = logged(set, {
+  kind: "setter",
+  name: "x",
+  static: false,
+  private: false,
+}) ?? set;
+
+Object.defineProperty(C.prototype, "x", { set });
+```
+
+## 属性装饰器（新语法）
+
+属性装饰器的类型描述如下。
+
+```typescript
+type ClassFieldDecorator = (value: undefined, context: {
+  kind: "field";
+  name: string | symbol;
+  access: { get(): unknown, set(value: unknown): void };
+  static: boolean;
+  private: boolean;
+}) => (initialValue: unknown) => unknown | void;
+```
+
+属性装饰器的第一个参数是`undefined`，即没有一个直接的输入值。用户可以选择让装饰器返回一个初始化函数，当该属性被赋值时，这个初始化函数会自动运行，它会收到属性的初始值，然后返回一个新的初始值。属性装饰器也可以不返回任何值。只要返回的不是函数，而是其他类型的值，就会报错。
+
+下面是一个例子。
+
+```javascript
+function logged(value, { kind, name }) {
+  if (kind === "field") {
+    return function (initialValue) {
+      console.log(`initializing ${name} with value ${initialValue}`);
+      return initialValue;
+    };
+  }
+
+  // ...
+}
+
+class C {
+  @logged x = 1;
+}
+
+new C();
+// initializing x with value 1
+```
+
+如果不使用装饰器语法，属性装饰器的实际作用如下。
+
+```javascript
+let initializeX = logged(undefined, {
+  kind: "field",
+  name: "x",
+  static: false,
+  private: false,
+}) ?? (initialValue) => initialValue;
+
+class C {
+  x = initializeX.call(this, 1);
+}
+```
+
+## accessor 命令（新语法）
+
+类装饰器引入了一个新命令`accessor`，用来属性的前缀。
+
+```javascript
+class C {
+  accessor x = 1;
+}
+```
+
+它是一种简写形式，相当于声明属性`x`是私有属性`#x`的存取接口。上面的代码等同于下面的代码。
+
+```javascript
+class C {
+  #x = 1;
+
+  get x() {
+    return this.#x;
+  }
+
+  set x(val) {
+    this.#x = val;
+  }
+}
+```
+
+`accessor`命令前面，还可以加上`static`命令和`private`命令。
+
+```javascript
+class C {
+  static accessor x = 1;
+  accessor #y = 2;
+}
+```
+
+`accessor`命令前面还可以接受属性装饰器。
+
+```javascript
+function logged(value, { kind, name }) {
+  if (kind === "accessor") {
+    let { get, set } = value;
+
+    return {
+      get() {
+        console.log(`getting ${name}`);
+
+        return get.call(this);
+      },
+
+      set(val) {
+        console.log(`setting ${name} to ${val}`);
+
+        return set.call(this, val);
+      },
+
+      init(initialValue) {
+        console.log(`initializing ${name} with value ${initialValue}`);
+        return initialValue;
+      }
+    };
+  }
+
+  // ...
+}
+
+class C {
+  @logged accessor x = 1;
+}
+
+let c = new C();
+// initializing x with value 1
+c.x;
+// getting x
+c.x = 123;
+// setting x to 123
+```
+
+上面的示例等同于使用`@logged`装饰器，改写`accessor`属性的 getter 和 setter 方法。
+
+用于`accessor`的属性装饰器的类型描述如下。
+
+```typescript
+type ClassAutoAccessorDecorator = (
+  value: {
+    get: () => unknown;
+    set(value: unknown) => void;
+  },
+  context: {
+    kind: "accessor";
+    name: string | symbol;
+    access: { get(): unknown, set(value: unknown): void };
+    static: boolean;
+    private: boolean;
+    addInitializer(initializer: () => void): void;
+  }
+) => {
+  get?: () => unknown;
+  set?: (value: unknown) => void;
+  initialize?: (initialValue: unknown) => unknown;
+} | void;
+```
+
+`accessor`命令的第一个参数接收到的是一个对象，包含了`accessor`命令定义的属性的存取器 get 和 set。属性装饰器可以返回一个新对象，其中包含了新的存取器，用来取代原来的，即相当于拦截了原来的存取器。此外，返回的对象还可以包括一个`initialize`函数，用来改变私有属性的初始值。装饰器也可以不返回值，如果返回的是其他类型的值，或者包含其他属性的对象，就会报错。
+
+## addInitializer() 方法（新语法）
+
+除了属性装饰器，其他装饰器的上下文对象还包括一个`addInitializer()`方法，用来完成初始化操作。
+
+它的运行时间如下。
+
+- 类装饰器：在类被完全定义之后。
+- 方法装饰器：在类构造期间运行，在属性初始化之前。
+- 静态方法装饰器：在类定义期间运行，早于静态属性定义，但晚于类方法的定义。
+
+下面是一个例子。
+
+```javascript
+function customElement(name) {
+  return (value, { addInitializer }) => {
+    addInitializer(function() {
+      customElements.define(name, this);
+    });
+  }
+}
+
+@customElement('my-element')
+class MyElement extends HTMLElement {
+  static get observedAttributes() {
+    return ['some', 'attrs'];
+  }
+}
+```
+
+上面的代码等同于下面不使用装饰器的代码。
+
+```javascript
+class MyElement {
+  static get observedAttributes() {
+    return ['some', 'attrs'];
+  }
+}
+
+let initializersForMyElement = [];
+
+MyElement = customElement('my-element')(MyElement, {
+  kind: "class",
+  name: "MyElement",
+  addInitializer(fn) {
+    initializersForMyElement.push(fn);
+  },
+}) ?? MyElement;
+
+for (let initializer of initializersForMyElement) {
+  initializer.call(MyElement);
+}
+```
+
+下面是方法装饰器的例子。
+
+```javascript
+function bound(value, { name, addInitializer }) {
+  addInitializer(function () {
+    this[name] = this[name].bind(this);
+  });
+}
+
+class C {
+  message = "hello!";
+
+  @bound
+  m() {
+    console.log(this.message);
+  }
+}
+
+let { m } = new C();
+
+m(); // hello!
+```
+
+上面的代码等同于下面不使用装饰器的代码。
+
+```javascript
+class C {
+  constructor() {
+    for (let initializer of initializersForM) {
+      initializer.call(this);
+    }
+
+    this.message = "hello!";
+  }
+
+  m() {}
+}
+
+let initializersForM = []
+
+C.prototype.m = bound(
+  C.prototype.m,
+  {
+    kind: "method",
+    name: "m",
+    static: false,
+    private: false,
+    addInitializer(fn) {
+      initializersForM.push(fn);
+    },
+  }
+) ?? C.prototype.m;
+```
+
 ## core-decorators.js
 
 [core-decorators.js](https://github.com/jayphelps/core-decorators.js)是一个第三方模块，提供了几个常见的装饰器，通过它可以更好地理解装饰器。

From f6bb1b931dab654bf0d979fd29294440f353d746 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 28 Jun 2022 04:24:14 +0800
Subject: [PATCH 204/280] docs(decorator): edit editor notes

---
 docs/decorator.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index 5057c0305..b0db3e43a 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -1,6 +1,6 @@
 # 装饰器
 
-[说明] Decorator 提案经过了大幅修改，目前还没有定案，不知道语法会不会再变。下面的内容完全依据以前的提案，已经有点过时了。等待定案以后，需要完全重写。
+[说明] Decorator 提案经历了重大的语法变化，目前处于第三阶段，定案之前不知道是否还有变化。本章现在属于草稿阶段，凡是标注“新语法”的章节，都是基于当前的语法，不过没有详细整理，只是一些原始材料；未标注“新语法”的章节基于以前的语法，是过去遗留的稿子。之所以保留以前的内容，有两个原因，一是 TypeScript 装饰器会用到这些语法，二是里面包含不少有价值的内容。等到标准完全定案，本章将彻底重写：删去过时内容，补充材料，增加解释。（2022年6月）
 
 装饰器（Decorator）用来增强 JavaScript 类（class）的功能，许多面向对象的语言都有这种语法，目前有一个[提案](https://github.com/tc39/proposal-decorators)将其引入了 ECMAScript。
 
@@ -19,16 +19,18 @@
 
 上面代码一共使用了四个装饰器，一个用在类本身，另外三个用在类方法。它们不仅增加了代码的可读性，清晰地表达了意图，而且提供一种方便的手段，增加或修改类的功能。
 
+## 装饰器的种类（新语法）
+
 装饰器可以用来装饰四种类型的值。
 
 - 类
 - 类的属性（public, private, and static）
 - 类的方法（public, private, and static）
-- 类的访问器（accessor）（public, private, and static）
+- 属性存取器（accessor）（public, private, and static）
 
 ## 装饰器 API（新语法）
 
-装饰器是一个函数，它的 API 采用 TypeScript 描述，就是下面的形式。
+装饰器是一个函数，API 的类型描述如下（TypeScript 写法）。
 
 ```typescript
 type Decorator = (value: Input, context: {

From f45f032a239256cdab56b98621aa54b77cbfb20a Mon Sep 17 00:00:00 2001
From: xt1995726 <503634677@qq.com>
Date: Thu, 30 Jun 2022 20:31:26 +0800
Subject: [PATCH 205/280] docs(regex): fix es2022 indices

---
 docs/regex.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/regex.md b/docs/regex.md
index 1a0b215ef..5f96f58d3 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -633,11 +633,11 @@ RE_TWICE.test('abc!abc!ab') // false
 
 正则匹配的结果，在原始字符串里面的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法的返回结果，现有一个`index`属性，可以获取整个匹配结果的开始位置。但是，组匹配的每个组的开始位置，很难拿到。
 
-[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 为`exec()`方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
+[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 中新增`d`修饰符，使用`/d`修饰符，为`exec()`、`match`等方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
 
 ```javascript
 const text = 'zabbcdef';
-const re = /ab/;
+const re = /ab/d;
 const result = re.exec(text);
 
 result.index // 1
@@ -652,7 +652,7 @@ result.indices // [ [1, 3] ]
 
 ```javascript
 const text = 'zabbcdef';
-const re = /ab+(cd)/;
+const re = /ab+(cd)/d;
 const result = re.exec(text);
 
 result.indices // [ [ 1, 6 ], [ 4, 6 ] ]
@@ -664,7 +664,7 @@ result.indices // [ [ 1, 6 ], [ 4, 6 ] ]
 
 ```javascript
 const text = 'zabbcdef';
-const re = /ab+(cd(ef))/;
+const re = /ab+(cd(ef))/d;
 const result = re.exec(text);
 
 result.indices // [ [1, 8], [4, 8], [6, 8] ]
@@ -676,7 +676,7 @@ result.indices // [ [1, 8], [4, 8], [6, 8] ]
 
 ```javascript
 const text = 'zabbcdef';
-const re = /ab+(?<Z>cd)/;
+const re = /ab+(?<Z>cd)/d;
 const result = re.exec(text);
 
 result.indices.groups // { Z: [ 4, 6 ] }
@@ -688,7 +688,7 @@ result.indices.groups // { Z: [ 4, 6 ] }
 
 ```javascript
 const text = 'zabbcdef';
-const re = /ab+(?<Z>ce)?/;
+const re = /ab+(?<Z>ce)?/d;
 const result = re.exec(text);
 
 result.indices[1] // undefined

From d4d888e94ee9eaa8ea8cfda30dcaae4f59e6d311 Mon Sep 17 00:00:00 2001
From: xt1995726 <503634677@qq.com>
Date: Thu, 30 Jun 2022 20:46:54 +0800
Subject: [PATCH 206/280] typo: match -> match()

---
 docs/regex.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 5f96f58d3..e775383bc 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -633,7 +633,7 @@ RE_TWICE.test('abc!abc!ab') // false
 
 正则匹配的结果，在原始字符串里面的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法的返回结果，现有一个`index`属性，可以获取整个匹配结果的开始位置。但是，组匹配的每个组的开始位置，很难拿到。
 
-[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 中新增`d`修饰符，使用`/d`修饰符，为`exec()`、`match`等方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
+[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 中新增`d`修饰符，使用`/d`修饰符，为`exec()`、`match()`等方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
 
 ```javascript
 const text = 'zabbcdef';

From a090a27f2051be2734662b6bd43d8d5b726fab36 Mon Sep 17 00:00:00 2001
From: CondorHero <47056890+condorheroblog@users.noreply.github.com>
Date: Fri, 1 Jul 2022 15:38:34 +0800
Subject: [PATCH 207/280] docs(async):  fix typo

---
 docs/async.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/async.md b/docs/async.md
index e9fc258ce..b05dba0d1 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -733,7 +733,7 @@ const data = await fetch('https://api.example.com');
 
 上面代码中，`await`命令独立使用，没有放在 async 函数里面，就会报错。
 
-从 [ES2022](https://github.com/tc39/proposal-top-level-await) 开始，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。它的只要目的，是使用`await`解决模块异步加载的问题。
+从 [ES2022](https://github.com/tc39/proposal-top-level-await) 开始，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。它的主要目的，是使用`await`解决模块异步加载的问题。
 
 ```javascript
 // awaiting.js

From a0c47d5e6e256386ce0d07fc7d595dc6c31de6f5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 6 Jul 2022 11:56:11 +0800
Subject: [PATCH 208/280] =?UTF-8?q?docs(regex):=20edit=20d=20=E4=BF=AE?=
 =?UTF-8?q?=E9=A5=B0=E7=AC=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/regex.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/docs/regex.md b/docs/regex.md
index e775383bc..157778a99 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -478,7 +478,7 @@ const regexArrows = /^\p{Block=Arrows}+$/u;
 regexArrows.test('←↑→↓↔↕↖↗↘↙⇏⇐⇑⇒⇓⇔⇕⇖⇗⇘⇙⇧⇩') // true
 ```
 
-## v 修饰符，Unicode 属性类的运算
+## v 修饰符：Unicode 属性类的运算
 
 有时，需要向某个 Unicode 属性类添加或减少字符，即需要对属性类进行运算。现在有一个[提案](https://github.com/tc39/proposal-regexp-v-flag)，增加了 Unicode 属性类的运算功能。
 
@@ -629,11 +629,11 @@ RE_TWICE.test('abc!abc!abc') // true
 RE_TWICE.test('abc!abc!ab') // false
 ```
 
-## 正则匹配索引
+## d 修饰符：正则匹配索引
 
-正则匹配的结果，在原始字符串里面的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法的返回结果，现有一个`index`属性，可以获取整个匹配结果的开始位置。但是，组匹配的每个组的开始位置，很难拿到。
+组匹配的结果，在原始字符串里面的开始位置和结束位置，目前获取并不是很方便。正则实例的`exec()`方法有一个`index`属性，可以获取整个匹配结果的开始位置。但是，组匹配的每个组的开始位置，很难拿到。
 
-[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 中新增`d`修饰符，使用`/d`修饰符，为`exec()`、`match()`等方法的返回结果加上`indices`属性，在这个属性上面可以拿到匹配的开始位置和结束位置。
+[ES2022](https://github.com/tc39/proposal-regexp-match-Indices) 新增了`d`修饰符，这个修饰符可以让`exec()`、`match()`的返回结果添加`indices`属性，在该属性上面可以拿到匹配的开始位置和结束位置。
 
 ```javascript
 const text = 'zabbcdef';
@@ -644,7 +644,7 @@ result.index // 1
 result.indices // [ [1, 3] ]
 ```
 
-上面例子中，`exec()`方法的返回结果`result`，它的`index`属性是整个匹配结果（`ab`）的开始位置，现在新增了一个`indices`属性。它是一个数组，每个成员还是一个数组，包含了匹配结果在原始字符串的开始位置和结束位置。由于上例的正则表达式没有组匹配，所以`indices`数组只有一个成员，表示整个匹配的开始位置是`1`，结束位置是`3`。
+上面示例中，`exec()`方法的返回结果`result`，它的`index`属性是整个匹配结果（`ab`）的开始位置。由于正则表达式`re`有`d`修饰符，`result`现在就会多出一个`indices`属性。该属性是一个数组，它的每个成员还是一个数组，包含了匹配结果在原始字符串的开始位置和结束位置。由于上例的正则表达式`re`没有包含组匹配，所以`indices`数组只有一个成员，表示整个匹配的开始位置是`1`，结束位置是`3`。
 
 注意，开始位置包含在匹配结果之中，相当于匹配结果的第一个字符的位置。但是，结束位置不包含在匹配结果之中，是匹配结果的下一个字符。比如，上例匹配结果的最后一个字符`b`的位置，是原始字符串的2号位，那么结束位置`3`就是下一个字符的位置。
 
@@ -658,7 +658,7 @@ const result = re.exec(text);
 result.indices // [ [ 1, 6 ], [ 4, 6 ] ]
 ```
 
-上面例子中，正则表达式包含一个组匹配`(cd)`，那么`indices`属性数组就有两个成员，第一个成员是整个匹配结果（`abbcd`）的开始位置和结束位置，第二个成员是组匹配（`cd`）的开始位置和结束位置。
+上面例子中，正则表达式`re`包含一个组匹配`(cd)`，那么`indices`属性数组就有两个成员，第一个成员是整个匹配结果（`abbcd`）的开始位置和结束位置，第二个成员是组匹配（`cd`）的开始位置和结束位置。
 
 下面是多个组匹配的例子。
 
@@ -670,7 +670,7 @@ const result = re.exec(text);
 result.indices // [ [1, 8], [4, 8], [6, 8] ]
 ```
 
-上面例子中，正则表达式包含两个组匹配，所以`indices`属性数组就有三个成员。
+上面例子中，正则表达式`re`包含两个组匹配，所以`indices`属性数组就有三个成员。
 
 如果正则表达式包含具名组匹配，`indices`属性数组还会有一个`groups`属性。该属性是一个对象，可以从该对象获取具名组匹配的开始位置和结束位置。
 
@@ -695,7 +695,7 @@ result.indices[1] // undefined
 result.indices.groups['Z'] // undefined
 ```
 
-上面例子中，由于组匹配不成功，所以`indices`属性数组和`indices.groups`属性对象对应的组匹配成员都是`undefined`。
+上面例子中，由于组匹配`ce`不成功，所以`indices`属性数组和`indices.groups`属性对象对应的组匹配成员`Z`都是`undefined`。
 
 ## String.prototype.matchAll()
 

From 7d030c6ae039e7642f5dd4bb8d7817afd6be7d08 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 6 Jul 2022 12:11:29 +0800
Subject: [PATCH 209/280] docs(async): edit top-level await

---
 docs/async.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/async.md b/docs/async.md
index b05dba0d1..86ce19938 100644
--- a/docs/async.md
+++ b/docs/async.md
@@ -733,7 +733,7 @@ const data = await fetch('https://api.example.com');
 
 上面代码中，`await`命令独立使用，没有放在 async 函数里面，就会报错。
 
-从 [ES2022](https://github.com/tc39/proposal-top-level-await) 开始，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。它的主要目的，是使用`await`解决模块异步加载的问题。
+从 [ES2022](https://github.com/tc39/proposal-top-level-await) 开始，允许在模块的顶层独立使用`await`命令，使得上面那行代码不会报错了。它的主要目的是使用`await`解决模块异步加载的问题。
 
 ```javascript
 // awaiting.js

From 4c0201cf2f701e655155fc14bd4b4195d4267732 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 13 Jul 2022 15:25:57 +0800
Subject: [PATCH 210/280] docs(class): fixed #1125 private class field

---
 docs/class.md | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 00f185514..9abc6923c 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -578,7 +578,7 @@ class Foo {
 
 ## 私有方法和私有属性
 
-### 现有的解决方案
+### 早期解决方案
 
 私有方法和私有属性，是只能在类的内部访问的方法和属性，外部不能访问。这是常见需求，有利于代码的封装，但早期的 ES6 不提供，只能通过变通方法模拟实现。
 
@@ -654,9 +654,9 @@ Reflect.ownKeys(myClass.prototype)
 
 上面代码中，Symbol 值的属性名依然可以从类的外部拿到。
 
-### 私有属性的写法
+### 私有属性的正式写法
 
-[ES2022](https://github.com/tc39/proposal-class-fields)，有一个[提案](https://github.com/tc39/proposal-private-methods)，为`class`加了私有属性。方法是在属性名之前，使用`#`表示。
+[ES2022](https://github.com/tc39/proposal-class-fields)正式为`class`添加了私有属性，方法是在属性名之前使用`#`表示。
 
 ```javascript
 class IncreasingCounter {
@@ -723,8 +723,6 @@ class Point {
 
 上面代码中，`#x`就是私有属性，在`Point`类之外是读取不到这个属性的。由于井号`#`是属性名的一部分，使用时必须带有`#`一起使用，所以`#x`和`x`是两个不同的属性。
 
-之所以要引入一个新的前缀`#`表示私有属性，而没有采用`private`关键字，是因为 JavaScript 是一门动态语言，没有类型声明，使用独立的符号似乎是唯一的比较方便可靠的方法，能够准确地区分一种属性是否为私有属性。另外，Ruby 语言使用`@`表示私有属性，ES6 没有用这个符号而使用`#`，是因为`@`已经被留给了 Decorator。
-
 这种写法不仅可以写私有属性，还可以用来写私有方法。
 
 ```javascript
@@ -744,7 +742,7 @@ class Foo {
 }
 ```
 
-上面代码中，`#sum()`就是一个私有方法。
+上面示例中，`#sum()`就是一个私有方法。
 
 另外，私有属性也可以设置 getter 和 setter 方法。
 
@@ -753,18 +751,18 @@ class Counter {
   #xValue = 0;
 
   constructor() {
-    super();
-    // ...
+    console.log(this.#x);
   }
 
-  get #x() { return #xValue; }
+  get #x() { return this.#xValue; }
   set #x(value) {
     this.#xValue = value;
   }
 }
 ```
 
-上面代码中，`#x`是一个私有属性，它的读写都通过`get #x()`和`set #x()`来完成。
+上面代码中，`#x`是一个私有属性，它的读写都通过`get #x()`和`set
+#x()`操作另一个私有属性`#xValue`来完成。
 
 私有属性不限于从`this`引用，只要是在类的内部，实例也可以引用私有属性。
 

From 9348fd2839daa28c01e6482746f55705ba360494 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 23 Jul 2022 11:55:56 +0800
Subject: [PATCH 211/280] refactor: edit support banner

---
 js/ditto.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 76c417b8a..9fdbb47be 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,8 +243,8 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  // 2022年3月9日
-  var deadline = new Date(2022, 2, 9);
+  // 2022年8月25日
+  var deadline = new Date(2022, 7, 25);
   if (deadline - (new Date()) < 0) return;
 
   var styleStr = [
@@ -258,10 +258,10 @@ function create_banner(element) {
     'color: #333333'
   ].join(';');
 
-  var text = '【活动消息】' +
-    'AI 入门，人工智能四本名著——<span style="color: #4682BE;">《人工智能：一种现代方法》</span>、<span style="color: #4682BE;">《深度学习》</span>、<span style="color: #4682BE;">《动手学机器学习》</span>、<span style="color: #4682BE;">《流畅的 Python》</span>——正版学习资料免费领取！';
+  var text = '【活动】' +
+    '<span style="color: #4682BE;">IT 廉价课程超市 ApeClass</span> 新上线，不必注册，直接试听前端、Python、JAVA、云计算等众多课程，满意再开通永久会员（所有课程仅需299.5元）。';
 
-  var banner = $('<a href="https://wx.kaikeba.com/xiaoke/market/landing-page/v2/Y9x3zlctUWhoCB3YB8U?kol_ad_code=zhchVAUzJqFhWum1D8c" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
+  var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
 }
 

From 010de735fe6a178a2cf53e6a2cd22138b92f76bb Mon Sep 17 00:00:00 2001
From: nicong <liangningcong@gmail.com>
Date: Sun, 24 Jul 2022 21:56:08 +0800
Subject: [PATCH 212/280] docs(set-map): fix typo

---
 docs/set-map.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index d38a1d5db..288df2639 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -942,7 +942,7 @@ map.set(null, 2)
 
 上面代码中，如果将数值`1`和`Symbol`值作为 WeakMap 的键名，都会报错。
 
-不过，现在有一个[提案](https://github.com/tc39/proposal-symbols-as-weakmap-keys)，允许 Symbol 值也可以作为 WeakMap 的键名。一旦纳入标准，就意味着键名存在两种可能：对象和 Symbole 值。
+不过，现在有一个[提案](https://github.com/tc39/proposal-symbols-as-weakmap-keys)，允许 Symbol 值也可以作为 WeakMap 的键名。一旦纳入标准，就意味着键名存在两种可能：对象和 Symbol 值。
 
 其次，`WeakMap`的键名所指向的对象，不计入垃圾回收机制。
 

From 6bf915570cd991017907db9eafd4f70d2cdcb408 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 31 Jul 2022 10:32:40 +0800
Subject: [PATCH 213/280] refactor: edit support banner

---
 js/ditto.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/js/ditto.js b/js/ditto.js
index 9fdbb47be..f090d31c5 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -263,6 +263,7 @@ function create_banner(element) {
 
   var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
+  setTimeout(function () {if (banner.css('display') === 'none') $(ditto.content_id).html('seems adblock works...'); }, 500);
 }
 
 function create_page_anchors() {

From 686fcff1550d039021e114a9f63ba1bb36e91145 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 31 Jul 2022 10:39:03 +0800
Subject: [PATCH 214/280] refactor: edit support banner

---
 js/ditto.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/ditto.js b/js/ditto.js
index f090d31c5..40b9362fb 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -263,7 +263,7 @@ function create_banner(element) {
 
   var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
-  setTimeout(function () {if (banner.css('display') === 'none') $(ditto.content_id).html('seems adblock works...'); }, 500);
+  setTimeout(function () {if (banner.css('display') === 'none') {show_loading();show_error();} }, 500);
 }
 
 function create_page_anchors() {

From 21edbe4ea68a33e124440b06e5c9887192ccce30 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 8 Aug 2022 21:58:20 +0800
Subject: [PATCH 215/280] docs(symbol): edit text

---
 docs/symbol.md | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index f420a12a7..2297e10d5 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -4,7 +4,7 @@
 
 ES5 的对象属性名都是字符串，这容易造成属性名的冲突。比如，你使用了一个他人提供的对象，但又想为这个对象添加新的方法（mixin 模式），新方法的名字就有可能与现有方法产生冲突。如果有一种机制，保证每个属性的名字都是独一无二的就好了，这样就从根本上防止属性名的冲突。这就是 ES6 引入`Symbol`的原因。
 
-ES6 引入了一种新的原始数据类型`Symbol`，表示独一无二的值。它属于 JavaScript 语言的数据类型之一，其他数据类型是：`undefined`、`null`、布尔值（Boolean）、字符串（String）、数值（Number）、大整数（BigInt）、对象（Object）。
+ES6 引入了一种新的原始数据类型`Symbol`，表示独一无二的值。它属于 JavaScript 语言的原生数据类型之一，其他数据类型是：`undefined`、`null`、布尔值（Boolean）、字符串（String）、数值（Number）、大整数（BigInt）、对象（Object）。
 
 Symbol 值通过`Symbol()`函数生成。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。
 
@@ -17,9 +17,9 @@ typeof s
 
 上面代码中，变量`s`就是一个独一无二的值。`typeof`运算符的结果，表明变量`s`是 Symbol 数据类型，而不是字符串之类的其他类型。
 
-注意，`Symbol`函数前不能使用`new`命令，否则会报错。这是因为生成的 Symbol 是一个原始类型的值，不是对象。也就是说，由于 Symbol 值不是对象，所以不能添加属性。基本上，它是一种类似于字符串的数据类型。
+注意，`Symbol()`函数前不能使用`new`命令，否则会报错。这是因为生成的 Symbol 是一个原始类型的值，不是对象，所以不能使用`new`命令来调用。另外，由于 Symbol 值不是对象，所以也不能添加属性。基本上，它是一种类似于字符串的数据类型。
 
-`Symbol`函数可以接受一个字符串作为参数，表示对 Symbol 实例的描述，主要是为了在控制台显示，或者转为字符串时，比较容易区分。
+`Symbol()`函数可以接受一个字符串作为参数，表示对 Symbol 实例的描述。这主要是为了在控制台显示，或者转为字符串时，比较容易区分。
 
 ```javascript
 let s1 = Symbol('foo');
@@ -34,7 +34,7 @@ s2.toString() // "Symbol(bar)"
 
 上面代码中，`s1`和`s2`是两个 Symbol 值。如果不加参数，它们在控制台的输出都是`Symbol()`，不利于区分。有了参数以后，就等于为它们加上了描述，输出的时候就能够分清，到底是哪一个值。
 
-如果 Symbol 的参数是一个对象，就会调用该对象的`toString`方法，将其转为字符串，然后才生成一个 Symbol 值。
+如果 Symbol 的参数是一个对象，就会调用该对象的`toString()`方法，将其转为字符串，然后才生成一个 Symbol 值。
 
 ```javascript
 const obj = {
@@ -46,7 +46,7 @@ const sym = Symbol(obj);
 sym // Symbol(abc)
 ```
 
-注意，`Symbol`函数的参数只是表示对当前 Symbol 值的描述，因此相同参数的`Symbol`函数的返回值是不相等的。
+注意，`Symbol()`函数的参数只是表示对当前 Symbol 值的描述，因此相同参数的`Symbol`函数的返回值是不相等的。
 
 ```javascript
 // 没有参数的情况
@@ -62,7 +62,7 @@ let s2 = Symbol('foo');
 s1 === s2 // false
 ```
 
-上面代码中，`s1`和`s2`都是`Symbol`函数的返回值，而且参数相同，但是它们是不相等的。
+上面代码中，`s1`和`s2`都是`Symbol()`函数的返回值，而且参数相同，但是它们是不相等的。事实上，如果调用100次`Symbol()`，会得到100个互不相等的值。
 
 Symbol 值不能与其他类型的值进行运算，会报错。
 
@@ -101,13 +101,13 @@ sym + 2 // TypeError
 
 ## Symbol.prototype.description
 
-创建 Symbol 的时候，可以添加一个描述。
+前面说过，`Symbol()`函数创建 Symbol 值时，可以用参数添加一个描述。
 
 ```javascript
 const sym = Symbol('foo');
 ```
 
-上面代码中，`sym`的描述就是字符串`foo`。
+上面代码中，`sym`这个值的描述就是字符串`foo`。
 
 但是，读取这个描述需要将 Symbol 显式转为字符串，即下面的写法。
 
@@ -118,7 +118,7 @@ String(sym) // "Symbol(foo)"
 sym.toString() // "Symbol(foo)"
 ```
 
-上面的用法不是很方便。[ES2019](https://github.com/tc39/proposal-Symbol-description) 提供了一个实例属性`description`，直接返回 Symbol 的描述。
+上面的用法不是很方便。[ES2019](https://github.com/tc39/proposal-Symbol-description) 提供了一个 Symbol 值的实例属性`description`，直接返回 Symbol 值的描述。
 
 ```javascript
 const sym = Symbol('foo');
@@ -128,7 +128,7 @@ sym.description // "foo"
 
 ## 作为属性名的 Symbol
 
-由于每一个 Symbol 值都是不相等的，这意味着 Symbol 值可以作为标识符，用于对象的属性名，就能保证不会出现同名的属性。这对于一个对象由多个模块构成的情况非常有用，能防止某一个键被不小心改写或覆盖。
+由于每一个 Symbol 值都是不相等的，这意味着只要 Symbol 值作为标识符，用于对象的属性名，就能保证不会出现同名的属性。这对于一个对象由多个模块构成的情况非常有用，能防止某一个键被不小心改写或覆盖。
 
 ```javascript
 let mySymbol = Symbol();
@@ -150,7 +150,7 @@ Object.defineProperty(a, mySymbol, { value: 'Hello!' });
 a[mySymbol] // "Hello!"
 ```
 
-上面代码通过方括号结构和`Object.defineProperty`，将对象的属性名指定为一个 Symbol 值。
+上面代码通过方括号结构和`Object.defineProperty()`方法，将对象的属性名指定为一个 Symbol 值。
 
 注意，Symbol 值作为对象属性名时，不能用点运算符。
 
@@ -280,7 +280,7 @@ const shapeType = {
 
 ## 属性名的遍历
 
-Symbol 作为属性名，遍历对象的时候，该属性不会出现在`for...in`、`for...of`循环中，也不会被`Object.keys()`、`Object.getOwnPropertyNames()`、`JSON.stringify()`返回。
+Symbol 值作为属性名，遍历对象的时候，该属性不会出现在`for...in`、`for...of`循环中，也不会被`Object.keys()`、`Object.getOwnPropertyNames()`、`JSON.stringify()`返回。
 
 但是，它也不是私有属性，有一个`Object.getOwnPropertySymbols()`方法，可以获取指定对象的所有 Symbol 属性名。该方法返回一个数组，成员是当前对象的所有用作属性名的 Symbol 值。
 

From 2b448b6b16b874f635b11103dcf66b7d48fc8ed4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 13 Aug 2022 21:24:40 +0800
Subject: [PATCH 216/280] docs(clss-extends): add inheritance of private
 property

---
 docs/class-extends.md | 75 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 60 insertions(+), 15 deletions(-)

diff --git a/docs/class-extends.md b/docs/class-extends.md
index 1e0395bc3..6cf9a2f08 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -119,22 +119,9 @@ cp instanceof Point // true
 
 上面示例中，实例对象`cp`同时是`ColorPoint`和`Point`两个类的实例，这与 ES5 的行为完全一致。
 
-除了私有属性，父类的所有属性和方法，都会被子类继承，其中包括静态方法。
+## 私有属性和私有方法的继承
 
-```javascript
-class A {
-  static hello() {
-    console.log('hello world');
-  }
-}
-
-class B extends A {
-}
-
-B.hello()  // hello world
-```
-
-上面代码中，`hello()`是`A`类的静态方法，`B`继承`A`，也继承了`A`的静态方法。
+父类所有的属性和方法，都会被子类继承，除了私有的属性和方法。
 
 子类无法继承父类的私有属性，或者说，私有属性只能在定义它的 class 里面使用。
 
@@ -177,6 +164,64 @@ class Bar extends Foo {
 
 上面示例中，`getP()`是父类用来读取私有属性的方法，通过该方法，子类就可以读到父类的私有属性。
 
+## 静态属性和静态方法的继承
+
+父类的静态属性和静态方法，也会被子类继承。
+
+```javascript
+class A {
+  static hello() {
+    console.log('hello world');
+  }
+}
+
+class B extends A {
+}
+
+B.hello()  // hello world
+```
+
+上面代码中，`hello()`是`A`类的静态方法，`B`继承`A`，也继承了`A`的静态方法。
+
+注意，静态属性是通过软拷贝实现继承的。
+
+```javascript
+class A { static foo = 100; }
+class B extends A {
+  constructor() {
+    super();
+    B.foo--;
+  }
+}
+
+const b = new B();
+B.foo // 99
+A.foo // 100
+```
+
+上面示例中，`foo`是 A 类的静态属性，B 类继承了 A 类，因此也继承了这个属性。但是，在 B 类内部操作`B.foo`这个静态属性，影响不到`A.foo`，原因就是 B 类继承静态属性时，会采用浅拷贝，拷贝父类静态属性的值，因此`A.foo`和`B.foo`是两个彼此独立的属性。
+
+但是，由于这种拷贝是浅拷贝，如果父类的静态属性的值是一个对象，那么子类的静态属性也会指向这个对象，因为浅拷贝只会拷贝对象的内存地址。
+
+```javascript
+class A {
+  static foo = { n: 100 };
+}
+
+class B extends A {
+  constructor() {
+    super();
+    B.foo.n--;
+  }
+}
+
+const b = new B();
+B.foo.n // 99
+A.foo.n // 99
+```
+
+上面示例中，`A.foo`的值是一个对象，浅拷贝导致`B.foo`和`A.foo`指向同一个对象。所以，子类`A`修改这个对象的属性值，会影响到父类`A`。
+
 ## Object.getPrototypeOf()
 
 `Object.getPrototypeOf()`方法可以用来从子类上获取父类。

From cf4c9471dbc458cc1c3bc538a37073c809815690 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 1 Sep 2022 01:32:10 +0800
Subject: [PATCH 217/280] docs(proposals): edit links

---
 docs/proposals.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proposals.md b/docs/proposals.md
index 2e7a2282a..f98349489 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -328,7 +328,7 @@ Math.sign(-0) // -0
 +0 === -0 // true
 ```
 
-目前，有一个[提案](https://jfbastien.github.io/papers/Math.signbit.html)，引入了`Math.signbit()`方法判断一个数的符号位是否设置了。
+目前，有一个[提案](https://github.com/tc39/proposal-Math.signbit)，引入了`Math.signbit()`方法判断一个数的符号位是否设置了。
 
 ```javascript
 Math.signbit(2) //false

From eba1ada2e008ecf9c9b4948f85d265e64b2d18ca Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 1 Sep 2022 01:47:37 +0800
Subject: [PATCH 218/280] docs(proposals): edit Math.signbit()

---
 docs/proposals.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/proposals.md b/docs/proposals.md
index f98349489..d33632185 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -316,16 +316,16 @@ const userAge = getAgeFromUser(await fetchUserById(userId));
 
 ## Math.signbit()
 
-`Math.sign()`用来判断一个值的正负，但是如果参数是`-0`，它会返回`-0`。
+JavaScript 内部使用64位浮点数（国际标准 IEEE 754）表示数值。IEEE 754 规定，64位浮点数的第一位是符号位，`0`表示正数，`1`表示负数。所以会有两种零，`+0`是符号位为`0`时的零，`-0`是符号位为`1`时的零。实际编程中，判断一个值是`+0`还是`-0`非常麻烦，因为它们是相等的。
 
 ```javascript
-Math.sign(-0) // -0
++0 === -0 // true
 ```
 
-这导致对于判断符号位的正负，`Math.sign()`不是很有用。JavaScript 内部使用 64 位浮点数（国际标准 IEEE 754）表示数值，IEEE 754 规定第一位是符号位，`0`表示正数，`1`表示负数。所以会有两种零，`+0`是符号位为`0`时的零值，`-0`是符号位为`1`时的零值。实际编程中，判断一个值是`+0`还是`-0`非常麻烦，因为它们是相等的。
+ES6 新增的`Math.sign()`方法，只能用来判断数值的正负，对于判断数值的符号位用处不大。因为如果参数是`-0`，它会返回`-0`，还是不能直接知道符号位是`1`还是`0`。
 
 ```javascript
-+0 === -0 // true
+Math.sign(-0) // -0
 ```
 
 目前，有一个[提案](https://github.com/tc39/proposal-Math.signbit)，引入了`Math.signbit()`方法判断一个数的符号位是否设置了。
@@ -348,7 +348,7 @@ Math.signbit(-0) //true
 
 ## 双冒号运算符
 
-箭头函数可以绑定`this`对象，大大减少了显式绑定`this`对象的写法（`call`、`apply`、`bind`）。但是，箭头函数并不适用于所有场合，所以现在有一个[提案](https://github.com/zenparsing/es-function-bind)，提出了“函数绑定”（function bind）运算符，用来取代`call`、`apply`、`bind`调用。
+箭头函数可以绑定`this`对象，大大减少了显式绑定`this`对象的写法（`call()`、`apply()`、`bind()`）。但是，箭头函数并不适用于所有场合，所以现在有一个[提案](https://github.com/zenparsing/es-function-bind)，提出了“函数绑定”（function bind）运算符，用来取代`call()`、`apply()`、`bind()`调用。
 
 函数绑定运算符是并排的两个冒号（`::`），双冒号左边是一个对象，右边是一个函数。该运算符会自动将左边的对象，作为上下文环境（即`this`对象），绑定到右边的函数上面。
 

From 5730890e865c485873deebbadd4d53339c05cda0 Mon Sep 17 00:00:00 2001
From: CondorHero <47056890+condorheroblog@users.noreply.github.com>
Date: Thu, 1 Sep 2022 14:45:02 +0800
Subject: [PATCH 219/280] fix: line feed causes HTML rendering error view

---
 docs/class.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 9abc6923c..5bebf6230 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -761,8 +761,7 @@ class Counter {
 }
 ```
 
-上面代码中，`#x`是一个私有属性，它的读写都通过`get #x()`和`set
-#x()`操作另一个私有属性`#xValue`来完成。
+上面代码中，`#x`是一个私有属性，它的读写都通过`get #x()`和`set #x()`操作另一个私有属性`#xValue`来完成。
 
 私有属性不限于从`this`引用，只要是在类的内部，实例也可以引用私有属性。
 

From e808d04dc4d8831fd70b3a5be736145a5dbc2355 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9E=97?= <wll_rookie@aliyun.com>
Date: Sun, 18 Sep 2022 18:06:46 +0800
Subject: [PATCH 220/280] Update class-extends.md

docs(class-extends): fix typo
---
 docs/class-extends.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class-extends.md b/docs/class-extends.md
index 6cf9a2f08..02028c216 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -220,7 +220,7 @@ B.foo.n // 99
 A.foo.n // 99
 ```
 
-上面示例中，`A.foo`的值是一个对象，浅拷贝导致`B.foo`和`A.foo`指向同一个对象。所以，子类`A`修改这个对象的属性值，会影响到父类`A`。
+上面示例中，`A.foo`的值是一个对象，浅拷贝导致`B.foo`和`A.foo`指向同一个对象。所以，子类`B`修改这个对象的属性值，会影响到父类`A`。
 
 ## Object.getPrototypeOf()
 

From 1a8f46c628ed56c6e27e02f5999fdad37cafe0b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9E=97?= <wll_rookie@aliyun.com>
Date: Tue, 20 Sep 2022 21:39:05 +0800
Subject: [PATCH 221/280] docs(class): fix typo

---
 docs/class.md | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 5bebf6230..91488179b 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -947,11 +947,30 @@ class C {
 
 上面代码中，类的内部有一个 static 代码块，这就是静态块。它的好处是将静态属性`y`和`z`的初始化逻辑，写入了类的内部，而且只运行一次。
 
-每个类只能有一个静态块，在静态属性声明后运行。静态块的内部不能有`return`语句。
+每个类允许有多个静态块，每个静态块中只能访问之前声明的静态属性。
+
+```javascript
+class C {
+  static x = 1;
+  static {
+    console.log(this.x, this.y, this.z); // 1 undefined undefined
+  }
+  static y = 2;
+  static {
+    console.log(this.x, this.y, this.z); // 1 2 undefined
+  }
+  static z = 3;
+  static {
+    console.log(this.x, this.y, this.z); // 1 2 3
+  }
+}
+```
+
+静态块的内部不能有`return`语句。
 
 静态块内部可以使用类名或`this`，指代当前类。
 
-```c
+```javascript
 class C {
   static x = 1;
   static {

From 36b55b9ec93252d17040d01fcdbba46e4eb2b50a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 21 Sep 2022 15:28:20 +0800
Subject: [PATCH 222/280] =?UTF-8?q?docs(class):=20=E9=9D=99=E6=80=81?=
 =?UTF-8?q?=E5=9D=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/class.md | 27 ++++-----------------------
 1 file changed, 4 insertions(+), 23 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 91488179b..d7ac4704b 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -902,7 +902,7 @@ A.test(o2.__proto__) // true
 
 ## 静态块
 
-静态属性的一个问题是，它的初始化要么写在类的外部，要么写在`constructor()`方法里面。
+静态属性的一个问题是，如果它有初始化逻辑，这个逻辑要么写在类的外部，要么写在`constructor()`方法里面。
 
 ```javascript
 class C {
@@ -921,9 +921,9 @@ try {
 }
 ```
 
-上面示例中，静态属性`y`和`z`的值依赖静态属性`x`，它们的初始化写在类的外部（上例的`try...catch`代码块）。另一种方法是写到类的`constructor()`方法里面。这两种方法都不是很理想，前者是将类的内部逻辑写到了外部，后者则是每次新建实例都会运行一次。
+上面示例中，静态属性`y`和`z`的值依赖于静态属性`x`的运算结果，这段初始化逻辑写在类的外部（上例的`try...catch`代码块）。另一种方法是写到类的`constructor()`方法里面。这两种方法都不是很理想，前者是将类的内部逻辑写到了外部，后者则是每次新建实例都会运行一次。
 
-为了解决这个问题，ES2022 引入了[静态块](https://github.com/tc39/proposal-class-static-block)（static block），允许在类的内部设置一个代码块，在类生成时运行一次，主要作用是对静态属性进行初始化。
+为了解决这个问题，ES2022 引入了[静态块](https://github.com/tc39/proposal-class-static-block)（static block），允许在类的内部设置一个代码块，在类生成时运行且只运行一次，主要作用是对静态属性进行初始化。以后，新建类的实例时，这个块就不运行了。
 
 ```javascript
 class C {
@@ -947,26 +947,7 @@ class C {
 
 上面代码中，类的内部有一个 static 代码块，这就是静态块。它的好处是将静态属性`y`和`z`的初始化逻辑，写入了类的内部，而且只运行一次。
 
-每个类允许有多个静态块，每个静态块中只能访问之前声明的静态属性。
-
-```javascript
-class C {
-  static x = 1;
-  static {
-    console.log(this.x, this.y, this.z); // 1 undefined undefined
-  }
-  static y = 2;
-  static {
-    console.log(this.x, this.y, this.z); // 1 2 undefined
-  }
-  static z = 3;
-  static {
-    console.log(this.x, this.y, this.z); // 1 2 3
-  }
-}
-```
-
-静态块的内部不能有`return`语句。
+每个类允许有多个静态块，每个静态块中只能访问之前声明的静态属性。另外，静态块的内部不能有`return`语句。
 
 静态块内部可以使用类名或`this`，指代当前类。
 

From ef5e3a2ea341c27dedba8a533fd7d5fc07bb095b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 18 Oct 2022 21:11:54 +0800
Subject: [PATCH 223/280] docs(class): fix typo

---
 docs/class.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index d7ac4704b..cbdde3bbf 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -120,7 +120,7 @@ Object.assign(Point.prototype, {
 });
 ```
 
-`prototype`对象的`constructor()`属性，直接指向“类”的本身，这与 ES5 的行为是一致的。
+`prototype`对象的`constructor`属性，直接指向“类”的本身，这与 ES5 的行为是一致的。
 
 ```javascript
 Point.prototype.constructor === Point // true

From 7f1acfe29b49a5ce048798759de059a7f0aef165 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 23 Oct 2022 15:00:04 +0800
Subject: [PATCH 224/280] docs(module): move import.meta from proposals to
 module

---
 docs/module.md    | 31 +++++++++++++++++++++++++++++++
 docs/proposals.md | 31 -------------------------------
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/docs/module.md b/docs/module.md
index 16deadc03..7e97c43ea 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -822,3 +822,34 @@ async function main() {
 main();
 ```
 
+## import.meta
+
+开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。[ES2020](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.meta`，返回当前模块的元信息。
+
+`import.meta`只能在模块内部使用，如果在模块外部使用会报错。
+
+这个属性返回一个对象，该对象的各种属性就是当前运行的脚本的元信息。具体包含哪些属性，标准没有规定，由各个运行环境自行决定。一般来说，`import.meta`至少会有下面两个属性。
+
+**（1）import.meta.url**
+
+`import.meta.url`返回当前模块的 URL 路径。举例来说，当前模块主文件的路径是`https://foo.com/main.js`，`import.meta.url`就返回这个路径。如果模块里面还有一个数据文件`data.txt`，那么就可以用下面的代码，获取这个数据文件的路径。
+
+```javascript
+new URL('data.txt', import.meta.url)
+```
+
+注意，Node.js 环境中，`import.meta.url`返回的总是本地路径，即`file:URL`协议的字符串，比如`file:///home/user/foo.js`。
+
+**（2）import.meta.scriptElement**
+
+`import.meta.scriptElement`是浏览器特有的元属性，返回加载模块的那个`<script>`元素，相当于`document.currentScript`属性。
+
+```javascript
+// HTML 代码为
+// <script type="module" src="my-module.js" data-foo="abc"></script>
+
+// my-module.js 内部执行下面的代码
+import.meta.scriptElement.dataset.foo
+// "abc"
+```
+
diff --git a/docs/proposals.md b/docs/proposals.md
index d33632185..447151a5a 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -524,37 +524,6 @@ $ ./hello.js
 
 对于 JavaScript 引擎来说，会把`#!`理解成注释，忽略掉这一行。
 
-## import.meta
-
-开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。现在有一个[提案](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.meta`，返回当前模块的元信息。
-
-`import.meta`只能在模块内部使用，如果在模块外部使用会报错。
-
-这个属性返回一个对象，该对象的各种属性就是当前运行的脚本的元信息。具体包含哪些属性，标准没有规定，由各个运行环境自行决定。一般来说，`import.meta`至少会有下面两个属性。
-
-**（1）import.meta.url**
-
-`import.meta.url`返回当前模块的 URL 路径。举例来说，当前模块主文件的路径是`https://foo.com/main.js`，`import.meta.url`就返回这个路径。如果模块里面还有一个数据文件`data.txt`，那么就可以用下面的代码，获取这个数据文件的路径。
-
-```javascript
-new URL('data.txt', import.meta.url)
-```
-
-注意，Node.js 环境中，`import.meta.url`返回的总是本地路径，即是`file:URL`协议的字符串，比如`file:///home/user/foo.js`。
-
-**（2）import.meta.scriptElement**
-
-`import.meta.scriptElement`是浏览器特有的元属性，返回加载模块的那个`<script>`元素，相当于`document.currentScript`属性。
-
-```javascript
-// HTML 代码为
-// <script type="module" src="my-module.js" data-foo="abc"></script>
-
-// my-module.js 内部执行下面的代码
-import.meta.scriptElement.dataset.foo
-// "abc"
-```
-
 ## JSON 模块
 
 import 命令目前只能用于加载 ES 模块，现在有一个[提案](https://github.com/tc39/proposal-json-modules)，允许加载 JSON 模块。

From 406ba6da6d6996ae8d6a48bb915c1522d16c9dbf Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 23 Oct 2022 15:12:22 +0800
Subject: [PATCH 225/280] docs(module): fix import.meta typo

---
 docs/module.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module.md b/docs/module.md
index 7e97c43ea..0f2481587 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -824,7 +824,7 @@ main();
 
 ## import.meta
 
-开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。[ES2020](https://github.com/tc39/proposal-import-meta)，为 import 命令添加了一个元属性`import.meta`，返回当前模块的元信息。
+开发者使用一个模块时，有时需要知道模板本身的一些信息（比如模块的路径）。[ES2020](https://github.com/tc39/proposal-import-meta) 为 import 命令添加了一个元属性`import.meta`，返回当前模块的元信息。
 
 `import.meta`只能在模块内部使用，如果在模块外部使用会报错。
 

From ef2f8784732df5483c49c72f470d3f0177a2e7f8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 23 Oct 2022 18:00:26 +0800
Subject: [PATCH 226/280] docs(decorator): edit text

---
 docs/decorator.md | 78 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 58 insertions(+), 20 deletions(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index b0db3e43a..a5b90603d 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -2,9 +2,18 @@
 
 [说明] Decorator 提案经历了重大的语法变化，目前处于第三阶段，定案之前不知道是否还有变化。本章现在属于草稿阶段，凡是标注“新语法”的章节，都是基于当前的语法，不过没有详细整理，只是一些原始材料；未标注“新语法”的章节基于以前的语法，是过去遗留的稿子。之所以保留以前的内容，有两个原因，一是 TypeScript 装饰器会用到这些语法，二是里面包含不少有价值的内容。等到标准完全定案，本章将彻底重写：删去过时内容，补充材料，增加解释。（2022年6月）
 
+## 简介（新语法）
+
 装饰器（Decorator）用来增强 JavaScript 类（class）的功能，许多面向对象的语言都有这种语法，目前有一个[提案](https://github.com/tc39/proposal-decorators)将其引入了 ECMAScript。
 
-装饰器是一种函数，写成`@ + 函数名`。它可以放在类和类方法的定义前面。
+装饰器是一种函数，写成`@ + 函数名`，可以用来装饰四种类型的值。
+
+- 类
+- 类的属性
+- 类的方法
+- 属性存取器（accessor）
+
+下面的例子是装饰器放在类名和类方法名之前，大家可以感受一下写法。
 
 ```javascript
 @frozen class Foo {
@@ -17,16 +26,7 @@
 }
 ```
 
-上面代码一共使用了四个装饰器，一个用在类本身，另外三个用在类方法。它们不仅增加了代码的可读性，清晰地表达了意图，而且提供一种方便的手段，增加或修改类的功能。
-
-## 装饰器的种类（新语法）
-
-装饰器可以用来装饰四种类型的值。
-
-- 类
-- 类的属性（public, private, and static）
-- 类的方法（public, private, and static）
-- 属性存取器（accessor）（public, private, and static）
+上面代码一共使用了四个装饰器，一个用在类本身（@frozen），另外三个用在类方法（@configurable()、@enumerable()、@throttle()）。它们不仅增加了代码的可读性，清晰地表达了意图，而且提供一种方便的手段，增加或修改类的功能。
 
 ## 装饰器 API（新语法）
 
@@ -46,16 +46,16 @@ type Decorator = (value: Input, context: {
 }) => Output | void;
 ```
 
-装饰器函数调用时，会接收到两个参数。
+装饰器函数有两个参数。运行时，JavaScript 引擎会提供这两个参数。
 
-- `value`：被装饰的值，某些情况下可能是`undefined`（装饰属性时）。
-- `context`：一个对象，包含了被装饰的值的上下文信息。
+- `value`：所要装饰的值，某些情况下可能是`undefined`（装饰属性时）。
+- `context`：上下文信息对象。
 
-另外，`input`和`output`表示输入的值和输出的值，每种装饰器都不一样，放在后面介绍。所有装饰器都可以不返回任何值。
+装饰器函数的返回值，是一个新版本的装饰对象，但也可以不返回任何值（void）。
 
-`context`对象的属性如下。
+`context`对象有很多属性，其中`kind`属性表示属于哪一种装饰，其他属性的含义如下。
 
-- `kind`：字符串，表示装饰类型，可能取值有`class`、`method`、`getter`、`setter`、`field`、`accessor`。
+- `kind`：字符串，表示装饰类型，可能的取值有`class`、`method`、`getter`、`setter`、`field`、`accessor`。
 - `name`：被装饰的值的名称: The name of the value, or in the case of private elements the description of it (e.g. the readable name).
 - `access`：对象，包含访问这个值的方法，即存值器和取值器。
 - `static`: 布尔值，该值是否为静态元素。
@@ -257,6 +257,22 @@ new C(1);
 
 ## 方法装饰器（新语法）
 
+方法装饰器会修改类的方法。
+
+```javascript
+class C {
+  @trace
+  toString() {
+    return 'C';
+  }
+}
+
+// 相当于
+C.prototype.toString = trace(C.prototype.toString);
+```
+
+上面示例中，`@trace`装饰`toString()`方法，就相当于修改了该方法。
+
 方式装饰器使用 TypeScript 描述类型如下。
 
 ```typescript
@@ -272,9 +288,31 @@ type ClassMethodDecorator = (value: Function, context: {
 
 方法装饰器的第一个参数`value`，就是所要装饰的方法。
 
-方法装饰器可以返回一个新方法，取代原来的方法，也可以不返回值，表示依然使用原来的方法。如果返回其他类型的值，就会报错。
+方法装饰器可以返回一个新函数，取代原来的方法，也可以不返回值，表示依然使用原来的方法。如果返回其他类型的值，就会报错。下面是一个例子。
 
-下面是一个例子。
+```javascript
+function replaceMethod() {
+  return function () {
+    return `How are you, ${this.name}?`;
+  }
+}
+
+class Person {
+  constructor(name) {
+    this.name = name;
+  }
+  @replaceMethod
+  hello() {
+    return `Hi ${this.name}!`;
+  }
+}
+
+const robin = new Person('Robin');
+
+robin.hello(), 'How are you, Robin?'
+```
+
+上面示例中，`@replaceMethod`返回了一个新函数，取代了原来的`hello()`方法。
 
 ```typescript
 function logged(value, { kind, name }) {
@@ -626,7 +664,7 @@ type ClassFieldDecorator = (value: undefined, context: {
 }) => (initialValue: unknown) => unknown | void;
 ```
 
-属性装饰器的第一个参数是`undefined`，即没有一个直接的输入值。用户可以选择让装饰器返回一个初始化函数，当该属性被赋值时，这个初始化函数会自动运行，它会收到属性的初始值，然后返回一个新的初始值。属性装饰器也可以不返回任何值。只要返回的不是函数，而是其他类型的值，就会报错。
+属性装饰器的第一个参数是`undefined`，即不输入值。用户可以选择让装饰器返回一个初始化函数，当该属性被赋值时，这个初始化函数会自动运行，它会收到属性的初始值，然后返回一个新的初始值。属性装饰器也可以不返回任何值。除了这两种情况，返回其他类型的值都会报错。
 
 下面是一个例子。
 

From add0bba14eab2b26c2a9929f7a624a7d79fea215 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9E=97?= <wll_rookie@aliyun.com>
Date: Sun, 4 Dec 2022 11:04:22 +0800
Subject: [PATCH 227/280] docs(decorator): fix typo

---
 docs/decorator.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index a5b90603d..0577d18b3 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -273,7 +273,7 @@ C.prototype.toString = trace(C.prototype.toString);
 
 上面示例中，`@trace`装饰`toString()`方法，就相当于修改了该方法。
 
-方式装饰器使用 TypeScript 描述类型如下。
+方法装饰器使用 TypeScript 描述类型如下。
 
 ```typescript
 type ClassMethodDecorator = (value: Function, context: {

From 90c0ea7cc872bae5d40442dac595f92ac1d6c6b7 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 23 Dec 2022 19:30:24 +0800
Subject: [PATCH 228/280] docs(class-extends): add new materials into super()

---
 docs/class-extends.md | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/docs/class-extends.md b/docs/class-extends.md
index 02028c216..5b1ff61fd 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -241,7 +241,7 @@ Object.getPrototypeOf(ColorPoint) === Point
 
 `super`这个关键字，既可以当作函数使用，也可以当作对象使用。在这两种情况下，它的用法完全不同。
 
-第一种情况，`super`作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次`super`函数。
+第一种情况，`super`作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次`super()`函数。
 
 ```javascript
 class A {}
@@ -253,9 +253,11 @@ class B extends A {
 }
 ```
 
-上面代码中，子类`B`的构造函数之中的`super()`，代表调用父类的构造函数。这是必须的，否则 JavaScript 引擎会报错。
+上面代码中，子类`B`的构造函数之中的`super()`，代表调用父类的构造函数。这是必须的，否则报错。
 
-注意，`super`虽然代表了父类`A`的构造函数，但是返回的是子类`B`的实例，即`super`内部的`this`指的是`B`的实例，因此`super()`在这里相当于`A.prototype.constructor.call(this)`。
+调用`super()`的作用是形成子类的`this`对象，把父类的实例属性和方法放到这个`this`对象上面。子类在调用`super()`之前，是没有`this`对象的，任何对`this`的操作都要放在`super()`的后面。
+
+注意，这里的`super`虽然代表了父类的构造函数，但是因为返回的是子类的`this`（即子类的实例对象），所以`super`内部的`this`代表子类的实例，而不是父类的实例，这里的`super()`相当于`A.prototype.constructor.call(this)`（在子类的`this`上运行父类的构造函数）。
 
 ```javascript
 class A {
@@ -272,7 +274,26 @@ new A() // A
 new B() // B
 ```
 
-上面代码中，`new.target`指向当前正在执行的函数。可以看到，在`super()`执行时，它指向的是子类`B`的构造函数，而不是父类`A`的构造函数。也就是说，`super()`内部的`this`指向的是`B`。
+上面示例中，`new.target`指向当前正在执行的函数。可以看到，在`super()`执行时（`new B()`），它指向的是子类`B`的构造函数，而不是父类`A`的构造函数。也就是说，`super()`内部的`this`指向的是`B`。
+
+不过，由于`super()`在子类构造方法中执行时，子类的属性和方法还没有绑定到`this`，所以如果存在同名属性，此时拿到的是父类的属性。
+
+```javascript
+class A {
+  name = 'A';
+  constructor() {
+    console.log('My name is ' + this.name);
+  }
+}
+
+class B extends A {
+  name = 'B';
+}
+
+const b = new B(); // My name is A
+```
+
+上面示例中，最后一行输出的是`A`，而不是`B`，原因就在于`super()`执行时，`B`的`name`属性还没有绑定到`this`，所以`this.name`拿到的是`A`类的`name`属性。
 
 作为函数时，`super()`只能用在子类的构造函数之中，用在其他地方就会报错。
 

From f9ef8fdae5bbd13a2e61a97534bc0218c4587c10 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 16:09:45 +0800
Subject: [PATCH 229/280] refactor: add wwads banner

---
 js/ditto.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/js/ditto.js b/js/ditto.js
index 40b9362fb..6da384699 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,6 +243,17 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
+  (function() {
+    var wwads = document.createElement('script');
+    wwads.type = 'text/javascript';
+    wwads.async = true;
+    wwads.src = 'https://cdn.wwads.cn/js/makemoney.js';
+    (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(wwads);
+  })();
+
+  var banner = $('<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%"></div>')
+    .insertAfter(element);
+/*
   // 2022年8月25日
   var deadline = new Date(2022, 7, 25);
   if (deadline - (new Date()) < 0) return;
@@ -264,6 +275,7 @@ function create_banner(element) {
   var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
   setTimeout(function () {if (banner.css('display') === 'none') {show_loading();show_error();} }, 500);
+*/
 }
 
 function create_page_anchors() {

From c1a81dc51dcbe5ebc7ba30b16745cebc200dbaa5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 16:22:04 +0800
Subject: [PATCH 230/280] refactor: adjust wwads banner

---
 index.html  |  1 +
 js/ditto.js | 10 +---------
 2 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/index.html b/index.html
index 0f88f503c..6430cbbc0 100644
--- a/index.html
+++ b/index.html
@@ -29,6 +29,7 @@
   <div class="progress-indicator-2"></div>
 
   <script src="config.js"></script>
+  <script type="text/javascript" charset="UTF-8" src="https://cdn.wwads.cn/js/makemoney.js" async></script>
   <noscript>
     <p>《ECMAScript 6 入门教程》是一本开源的JavaScript语言教程，全面介绍ECMAScript 6新增的语法特性。</p>
     <p>本书力争覆盖ES6与ES5的所有不同之处，对涉及的语法知识给予详细介绍，并给出大量简洁易懂的示例代码。</p>
diff --git a/js/ditto.js b/js/ditto.js
index 6da384699..e971e1b1e 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -243,15 +243,7 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  (function() {
-    var wwads = document.createElement('script');
-    wwads.type = 'text/javascript';
-    wwads.async = true;
-    wwads.src = 'https://cdn.wwads.cn/js/makemoney.js';
-    (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(wwads);
-  })();
-
-  var banner = $('<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%"></div>')
+  var banner = $('<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>')
     .insertAfter(element);
 /*
   // 2022年8月25日

From 536ac2251ae443d90a2db3df118b3b15507ed427 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 16:41:50 +0800
Subject: [PATCH 231/280] refactor: adjust wwads banner

---
 js/ditto.js | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index e971e1b1e..9be4d95e3 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -45,6 +45,7 @@ var getHash = function (hash) {
 };
 
 var disqusCode = '<h3>留言</h3><div id="disqus_thread"></div>';
+var wwadsCode = '<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>';
 var menu = new Array();
 
 function initialize() {
@@ -243,9 +244,6 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  var banner = $('<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>')
-    .insertAfter(element);
-/*
   // 2022年8月25日
   var deadline = new Date(2022, 7, 25);
   if (deadline - (new Date()) < 0) return;
@@ -267,7 +265,6 @@ function create_banner(element) {
   var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
   setTimeout(function () {if (banner.css('display') === 'none') {show_loading();show_error();} }, 500);
-*/
 }
 
 function create_page_anchors() {
@@ -397,7 +394,7 @@ function router() {
 
   $.get(path, function(data) {
     $(ditto.error_id).hide();
-    $(ditto.content_id).html(marked(data) + disqusCode);
+    $(ditto.content_id).html(marked(data) + wwadsCode + disqusCode);
     if ($(ditto.content_id + " h1").text() === ditto.document_title) {
       document.title = ditto.document_title;
     } else {

From 010daf6830bc13010a10ddaee999734ac4cbe1e3 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 17:04:19 +0800
Subject: [PATCH 232/280] refactor: adjust wwads banner

---
 js/ditto.js | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index 9be4d95e3..db97c975f 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -45,7 +45,6 @@ var getHash = function (hash) {
 };
 
 var disqusCode = '<h3>留言</h3><div id="disqus_thread"></div>';
-var wwadsCode = '<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>';
 var menu = new Array();
 
 function initialize() {
@@ -126,7 +125,7 @@ function searchbar_listener(event) {
     if (q !== '') {
       var url = 'https://github.com/ruanyf/es6tutorial/search?utf8=✓&q=' + encodeURIComponent(q);
       window.open(url, '_blank');
-      win.focus();
+      window.focus();
     }
     return false;
   /*
@@ -244,6 +243,9 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
+  var banner = $('<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>')
+    .insertAfter(element);
+  /*
   // 2022年8月25日
   var deadline = new Date(2022, 7, 25);
   if (deadline - (new Date()) < 0) return;
@@ -265,6 +267,7 @@ function create_banner(element) {
   var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
   setTimeout(function () {if (banner.css('display') === 'none') {show_loading();show_error();} }, 500);
+  */
 }
 
 function create_page_anchors() {
@@ -358,7 +361,8 @@ function statistics() {
   s.parentNode.insertBefore(hm, s);
 }
 
-function router() { 
+function router() {
+  window.focus();
   var path = location.hash.replace(/#([^#]*)(#.*)?/, './$1');
 
   var hashArr = location.hash.split('#');
@@ -394,7 +398,7 @@ function router() {
 
   $.get(path, function(data) {
     $(ditto.error_id).hide();
-    $(ditto.content_id).html(marked(data) + wwadsCode + disqusCode);
+    $(ditto.content_id).html(marked(data) + disqusCode);
     if ($(ditto.content_id + " h1").text() === ditto.document_title) {
       document.title = ditto.document_title;
     } else {

From 09a4657236d8e8b2e768fed0cc7249b581b549ce Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 17:17:26 +0800
Subject: [PATCH 233/280] refactor: adjust wwads banner

---
 js/ditto.js | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/js/ditto.js b/js/ditto.js
index db97c975f..2802c525f 100644
--- a/js/ditto.js
+++ b/js/ditto.js
@@ -15,6 +15,7 @@ var ditto = {
     theme_button: true,
     save_progress: true, // 保存阅读进度
     search_bar: true,
+    wwads: true,
 
     // initialize function
     run: initialize
@@ -78,6 +79,10 @@ function init_sidebar_section() {
            init_searchbar();
         }
 
+        if (ditto.wwads) {
+          init_wwads();
+        }
+
         // 初始化内容数组
         var menuOL = $(ditto.sidebar_id + ' ol');
         menuOL.attr('start', 0);
@@ -139,6 +144,11 @@ function searchbar_listener(event) {
   */
 }
 
+function init_wwads() {
+  var wwads = '<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>';
+  $(ditto.sidebar_id).find('h2').first().before($(wwads));
+}
+
 function init_theme_button() {
     $(ditto.theme_id).show();
     // 默认主题
@@ -243,9 +253,6 @@ function li_create_linkage(li_tag, header_level) {
 }
 
 function create_banner(element) {
-  var banner = $('<div class="wwads-cn wwads-horizontal" data-id="197" style="max-width:100%;"></div>')
-    .insertAfter(element);
-  /*
   // 2022年8月25日
   var deadline = new Date(2022, 7, 25);
   if (deadline - (new Date()) < 0) return;
@@ -267,7 +274,6 @@ function create_banner(element) {
   var banner = $('<a href="http://www.apeclass.com?did=12" style="color: #333333;" target="_blank"><div style="' + styleStr + '">' + text + '</div></a>')
     .insertAfter(element);
   setTimeout(function () {if (banner.css('display') === 'none') {show_loading();show_error();} }, 500);
-  */
 }
 
 function create_page_anchors() {
@@ -362,7 +368,6 @@ function statistics() {
 }
 
 function router() {
-  window.focus();
   var path = location.hash.replace(/#([^#]*)(#.*)?/, './$1');
 
   var hashArr = location.hash.split('#');

From b9c8b3d1c438d606902baa93540c702c1b759482 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 17:23:37 +0800
Subject: [PATCH 234/280] refactor: adjust wwads banner

---
 index.html | 1 +
 1 file changed, 1 insertion(+)

diff --git a/index.html b/index.html
index 6430cbbc0..49773cc72 100644
--- a/index.html
+++ b/index.html
@@ -27,6 +27,7 @@
   <div id="error">Oops! ... File not found!</div>
   <div id="flip"><div id="pageup">上一章</div><div id="pagedown">下一章</div></div>
   <div class="progress-indicator-2"></div>
+  <div class="wwads-cn wwads-vertical wwads-sticky" data-id="197" style="max-width:180px"></div>
 
   <script src="config.js"></script>
   <script type="text/javascript" charset="UTF-8" src="https://cdn.wwads.cn/js/makemoney.js" async></script>

From b638fb01450b5b696dfd49111492c2fef3fc6f0a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 10 Jan 2023 17:26:08 +0800
Subject: [PATCH 235/280] refactor: adjust wwads banner

---
 index.html | 1 -
 1 file changed, 1 deletion(-)

diff --git a/index.html b/index.html
index 49773cc72..6430cbbc0 100644
--- a/index.html
+++ b/index.html
@@ -27,7 +27,6 @@
   <div id="error">Oops! ... File not found!</div>
   <div id="flip"><div id="pageup">上一章</div><div id="pagedown">下一章</div></div>
   <div class="progress-indicator-2"></div>
-  <div class="wwads-cn wwads-vertical wwads-sticky" data-id="197" style="max-width:180px"></div>
 
   <script src="config.js"></script>
   <script type="text/javascript" charset="UTF-8" src="https://cdn.wwads.cn/js/makemoney.js" async></script>

From 9007f1ff42d58c60594771c87ea9a7e226d1d6fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9F=AF=E6=9F=AF?= <ke.xiaolong@qq.com>
Date: Mon, 16 Jan 2023 16:49:30 +0800
Subject: [PATCH 236/280] =?UTF-8?q?refactor:=20prism=E6=B7=BB=E5=8A=A0?=
 =?UTF-8?q?=E5=AF=B9typescript=E7=9A=84=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 js/prism.js | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/js/prism.js b/js/prism.js
index b543fa4e3..acd94c294 100644
--- a/js/prism.js
+++ b/js/prism.js
@@ -1,7 +1,6 @@
-var self=typeof window!="undefined"?window:{},Prism=function(){var e=/\blang(?:uage)?-(?!\*)(\w+)\b/i,t=self.Prism={util:{type:function(e){return Object.prototype.toString.call(e).match(/\[object (\w+)\]/)[1]},clone:function(e){var n=t.util.type(e);switch(n){case"Object":var r={};for(var i in e)e.hasOwnProperty(i)&&(r[i]=t.util.clone(e[i]));return r;case"Array":return e.slice()}return e}},languages:{extend:function(e,n){var r=t.util.clone(t.languages[e]);for(var i in n)r[i]=n[i];return r},insertBefore:function(e,n,r,i){i=i||t.languages;var s=i[e],o={};for(var u in s)if(s.hasOwnProperty(u)){if(u==n)for(var a in r)r.hasOwnProperty(a)&&(o[a]=r[a]);o[u]=s[u]}return i[e]=o},DFS:function(e,n){for(var r in e){n.call(e,r,e[r]);t.util.type(e)==="Object"&&t.languages.DFS(e[r],n)}}},highlightAll:function(e,n){var r=document.querySelectorAll('code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code');for(var i=0,s;s=r[i++];)t.highlightElement(s,e===!0,n)},highlightElement:function(r,i,s){var o,u,a=r;while(a&&!e.test(a.className))a=a.parentNode;if(a){o=(a.className.match(e)||[,""])[1];u=t.languages[o]}if(!u)return;r.className=r.className.replace(e,"").replace(/\s+/g," ")+" language-"+o;a=r.parentNode;/pre/i.test(a.nodeName)&&(a.className=a.className.replace(e,"").replace(/\s+/g," ")+" language-"+o);var f=r.textContent;if(!f)return;f=f.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/\u00a0/g," ");var l={element:r,language:o,grammar:u,code:f};t.hooks.run("before-highlight",l);if(i&&self.Worker){var c=new Worker(t.filename);c.onmessage=function(e){l.highlightedCode=n.stringify(JSON.parse(e.data),o);t.hooks.run("before-insert",l);l.element.innerHTML=l.highlightedCode;s&&s.call(l.element);t.hooks.run("after-highlight",l)};c.postMessage(JSON.stringify({language:l.language,code:l.code}))}else{l.highlightedCode=t.highlight(l.code,l.grammar,l.language);t.hooks.run("before-insert",l);l.element.innerHTML=l.highlightedCode;s&&s.call(r);t.hooks.run("after-highlight",l)}},highlight:function(e,r,i){return n.stringify(t.tokenize(e,r),i)},tokenize:function(e,n,r){var i=t.Token,s=[e],o=n.rest;if(o){for(var u in o)n[u]=o[u];delete n.rest}e:for(var u in n){if(!n.hasOwnProperty(u)||!n[u])continue;var a=n[u],f=a.inside,l=!!a.lookbehind,c=0;a=a.pattern||a;for(var h=0;h<s.length;h++){var p=s[h];if(s.length>e.length)break e;if(p instanceof i)continue;a.lastIndex=0;var d=a.exec(p);if(d){l&&(c=d[1].length);var v=d.index-1+c,d=d[0].slice(c),m=d.length,g=v+m,y=p.slice(0,v+1),b=p.slice(g+1),w=[h,1];y&&w.push(y);var E=new i(u,f?t.tokenize(d,f):d);w.push(E);b&&w.push(b);Array.prototype.splice.apply(s,w)}}}return s},hooks:{all:{},add:function(e,n){var r=t.hooks.all;r[e]=r[e]||[];r[e].push(n)},run:function(e,n){var r=t.hooks.all[e];if(!r||!r.length)return;for(var i=0,s;s=r[i++];)s(n)}}},n=t.Token=function(e,t){this.type=e;this.content=t};n.stringify=function(e,r,i){if(typeof e=="string")return e;if(Object.prototype.toString.call(e)=="[object Array]")return e.map(function(t){return n.stringify(t,r,e)}).join("");var s={type:e.type,content:n.stringify(e.content,r,i),tag:"span",classes:["token",e.type],attributes:{},language:r,parent:i};s.type=="comment"&&(s.attributes.spellcheck="true");t.hooks.run("wrap",s);var o="";for(var u in s.attributes)o+=u+'="'+(s.attributes[u]||"")+'"';return"<"+s.tag+' class="'+s.classes.join(" ")+'" '+o+">"+s.content+"</"+s.tag+">"};if(!self.document){if(!self.addEventListener)return self.Prism;self.addEventListener("message",function(e){var n=JSON.parse(e.data),r=n.language,i=n.code;self.postMessage(JSON.stringify(t.tokenize(i,t.languages[r])));self.close()},!1);return self.Prism}var r=document.getElementsByTagName("script");r=r[r.length-1];if(r){t.filename=r.src;document.addEventListener&&!r.hasAttribute("data-manual")&&document.addEventListener("DOMContentLoaded",t.highlightAll)}return self.Prism}();typeof module!="undefined"&&module.exports&&(module.exports=Prism);;
-Prism.languages.markup={comment:/&lt;!--[\w\W]*?-->/g,prolog:/&lt;\?.+?\?>/,doctype:/&lt;!DOCTYPE.+?>/,cdata:/&lt;!\[CDATA\[[\w\W]*?]]>/i,tag:{pattern:/&lt;\/?[\w:-]+\s*(?:\s+[\w:-]+(?:=(?:("|')(\\?[\w\W])*?\1|[^\s'">=]+))?\s*)*\/?>/gi,inside:{tag:{pattern:/^&lt;\/?[\w:-]+/i,inside:{punctuation:/^&lt;\/?/,namespace:/^[\w-]+?:/}},"attr-value":{pattern:/=(?:('|")[\w\W]*?(\1)|[^\s>]+)/gi,inside:{punctuation:/=|>|"/g}},punctuation:/\/?>/g,"attr-name":{pattern:/[\w:-]+/g,inside:{namespace:/^[\w-]+?:/}}}},entity:/&amp;#?[\da-z]{1,8};/gi};Prism.hooks.add("wrap",function(e){e.type==="entity"&&(e.attributes.title=e.content.replace(/&amp;/,"&"))});;
-Prism.languages.css={comment:/\/\*[\w\W]*?\*\//g,atrule:{pattern:/@[\w-]+?.*?(;|(?=\s*{))/gi,inside:{punctuation:/[;:]/g}},url:/url\((["']?).*?\1\)/gi,selector:/[^\{\}\s][^\{\};]*(?=\s*\{)/g,property:/(\b|\B)[\w-]+(?=\s*:)/ig,string:/("|')(\\?.)*?\1/g,important:/\B!important\b/gi,ignore:/&(lt|gt|amp);/gi,punctuation:/[\{\};:]/g};Prism.languages.markup&&Prism.languages.insertBefore("markup","tag",{style:{pattern:/(&lt;|<)style[\w\W]*?(>|&gt;)[\w\W]*?(&lt;|<)\/style(>|&gt;)/ig,inside:{tag:{pattern:/(&lt;|<)style[\w\W]*?(>|&gt;)|(&lt;|<)\/style(>|&gt;)/ig,inside:Prism.languages.markup.tag.inside},rest:Prism.languages.css}}});;
-Prism.languages.clike={comment:{pattern:/(^|[^\\])(\/\*[\w\W]*?\*\/|(^|[^:])\/\/.*?(\r?\n|$))/g,lookbehind:!0},string:/("|')(\\?.)*?\1/g,"class-name":{pattern:/((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/ig,lookbehind:!0,inside:{punctuation:/(\.|\\)/}},keyword:/\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/g,"boolean":/\b(true|false)\b/g,"function":{pattern:/[a-z0-9_]+\(/ig,inside:{punctuation:/\(/}},number:/\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/g,operator:/[-+]{1,2}|!|&lt;=?|>=?|={1,3}|(&amp;){1,2}|\|?\||\?|\*|\/|\~|\^|\%/g,ignore:/&(lt|gt|amp);/gi,punctuation:/[{}[\];(),.:]/g};;
-Prism.languages.javascript=Prism.languages.extend("clike",{keyword:/\b(var|let|if|else|while|do|for|return|in|instanceof|function|get|set|new|with|typeof|try|throw|catch|finally|null|break|continue|this)\b/g,number:/\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?|NaN|-?Infinity)\b/g});Prism.languages.insertBefore("javascript","keyword",{regex:{pattern:/(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/g,lookbehind:!0}});Prism.languages.markup&&Prism.languages.insertBefore("markup","tag",{script:{pattern:/(&lt;|<)script[\w\W]*?(>|&gt;)[\w\W]*?(&lt;|<)\/script(>|&gt;)/ig,inside:{tag:{pattern:/(&lt;|<)script[\w\W]*?(>|&gt;)|(&lt;|<)\/script(>|&gt;)/ig,inside:Prism.languages.markup.tag.inside},rest:Prism.languages.javascript}}});;
-Prism.languages.bash=Prism.languages.extend("clike",{comment:{pattern:/(^|[^"{\\])(#.*?(\r?\n|$))/g,lookbehind:!0},string:{pattern:/("|')(\\?[\s\S])*?\1/g,inside:{property:/\$([a-zA-Z0-9_#\?\-\*!@]+|\{[^\}]+\})/g}},keyword:/\b(if|then|else|elif|fi|for|break|continue|while|in|case|function|select|do|done|until|echo|exit|return|set|declare)\b/g});Prism.languages.insertBefore("bash","keyword",{property:/\$([a-zA-Z0-9_#\?\-\*!@]+|\{[^}]+\})/g});Prism.languages.insertBefore("bash","comment",{important:/(^#!\s*\/bin\/bash)|(^#!\s*\/bin\/sh)/g});;
-Prism.languages.http={"request-line":{pattern:/^(POST|GET|PUT|DELETE|OPTIONS|PATCH|TRACE|CONNECT)\b\shttps?:\/\/\S+\sHTTP\/[0-9.]+/g,inside:{property:/^\b(POST|GET|PUT|DELETE|OPTIONS|PATCH|TRACE|CONNECT)\b/g,"attr-name":/:\w+/g}},"response-status":{pattern:/^HTTP\/1.[01] [0-9]+.*/g,inside:{property:/[0-9]+[A-Z\s-]+$/g}},keyword:/^[\w-]+:(?=.+)/gm};var httpLanguages={"application/json":Prism.languages.javascript,"application/xml":Prism.languages.markup,"text/xml":Prism.languages.markup,"text/html":Prism.languages.markup};for(var contentType in httpLanguages)if(httpLanguages[contentType]){var options={};options[contentType]={pattern:new RegExp("(content-type:\\s*"+contentType+"[\\w\\W]*?)\\n\\n[\\w\\W]*","gi"),lookbehind:!0,inside:{rest:httpLanguages[contentType]}};Prism.languages.insertBefore("http","keyword",options)};;
+/* PrismJS 1.29.0
+https://prismjs.com/download.html#themes=prism-okaidia&languages=clike+javascript+typescript */
+var _self="undefined"!=typeof window?window:"undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?self:{},Prism=function(e){var n=/(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i,t=0,r={},a={manual:e.Prism&&e.Prism.manual,disableWorkerMessageHandler:e.Prism&&e.Prism.disableWorkerMessageHandler,util:{encode:function e(n){return n instanceof i?new i(n.type,e(n.content),n.alias):Array.isArray(n)?n.map(e):n.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/\u00a0/g," ")},type:function(e){return Object.prototype.toString.call(e).slice(8,-1)},objId:function(e){return e.__id||Object.defineProperty(e,"__id",{value:++t}),e.__id},clone:function e(n,t){var r,i;switch(t=t||{},a.util.type(n)){case"Object":if(i=a.util.objId(n),t[i])return t[i];for(var l in r={},t[i]=r,n)n.hasOwnProperty(l)&&(r[l]=e(n[l],t));return r;case"Array":return i=a.util.objId(n),t[i]?t[i]:(r=[],t[i]=r,n.forEach((function(n,a){r[a]=e(n,t)})),r);default:return n}},getLanguage:function(e){for(;e;){var t=n.exec(e.className);if(t)return t[1].toLowerCase();e=e.parentElement}return"none"},setLanguage:function(e,t){e.className=e.className.replace(RegExp(n,"gi"),""),e.classList.add("language-"+t)},currentScript:function(){if("undefined"==typeof document)return null;if("currentScript"in document)return document.currentScript;try{throw new Error}catch(r){var e=(/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(r.stack)||[])[1];if(e){var n=document.getElementsByTagName("script");for(var t in n)if(n[t].src==e)return n[t]}return null}},isActive:function(e,n,t){for(var r="no-"+n;e;){var a=e.classList;if(a.contains(n))return!0;if(a.contains(r))return!1;e=e.parentElement}return!!t}},languages:{plain:r,plaintext:r,text:r,txt:r,extend:function(e,n){var t=a.util.clone(a.languages[e]);for(var r in n)t[r]=n[r];return t},insertBefore:function(e,n,t,r){var i=(r=r||a.languages)[e],l={};for(var o in i)if(i.hasOwnProperty(o)){if(o==n)for(var s in t)t.hasOwnProperty(s)&&(l[s]=t[s]);t.hasOwnProperty(o)||(l[o]=i[o])}var u=r[e];return r[e]=l,a.languages.DFS(a.languages,(function(n,t){t===u&&n!=e&&(this[n]=l)})),l},DFS:function e(n,t,r,i){i=i||{};var l=a.util.objId;for(var o in n)if(n.hasOwnProperty(o)){t.call(n,o,n[o],r||o);var s=n[o],u=a.util.type(s);"Object"!==u||i[l(s)]?"Array"!==u||i[l(s)]||(i[l(s)]=!0,e(s,t,o,i)):(i[l(s)]=!0,e(s,t,null,i))}}},plugins:{},highlightAll:function(e,n){a.highlightAllUnder(document,e,n)},highlightAllUnder:function(e,n,t){var r={callback:t,container:e,selector:'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'};a.hooks.run("before-highlightall",r),r.elements=Array.prototype.slice.apply(r.container.querySelectorAll(r.selector)),a.hooks.run("before-all-elements-highlight",r);for(var i,l=0;i=r.elements[l++];)a.highlightElement(i,!0===n,r.callback)},highlightElement:function(n,t,r){var i=a.util.getLanguage(n),l=a.languages[i];a.util.setLanguage(n,i);var o=n.parentElement;o&&"pre"===o.nodeName.toLowerCase()&&a.util.setLanguage(o,i);var s={element:n,language:i,grammar:l,code:n.textContent};function u(e){s.highlightedCode=e,a.hooks.run("before-insert",s),s.element.innerHTML=s.highlightedCode,a.hooks.run("after-highlight",s),a.hooks.run("complete",s),r&&r.call(s.element)}if(a.hooks.run("before-sanity-check",s),(o=s.element.parentElement)&&"pre"===o.nodeName.toLowerCase()&&!o.hasAttribute("tabindex")&&o.setAttribute("tabindex","0"),!s.code)return a.hooks.run("complete",s),void(r&&r.call(s.element));if(a.hooks.run("before-highlight",s),s.grammar)if(t&&e.Worker){var c=new Worker(a.filename);c.onmessage=function(e){u(e.data)},c.postMessage(JSON.stringify({language:s.language,code:s.code,immediateClose:!0}))}else u(a.highlight(s.code,s.grammar,s.language));else u(a.util.encode(s.code))},highlight:function(e,n,t){var r={code:e,grammar:n,language:t};if(a.hooks.run("before-tokenize",r),!r.grammar)throw new Error('The language "'+r.language+'" has no grammar.');return r.tokens=a.tokenize(r.code,r.grammar),a.hooks.run("after-tokenize",r),i.stringify(a.util.encode(r.tokens),r.language)},tokenize:function(e,n){var t=n.rest;if(t){for(var r in t)n[r]=t[r];delete n.rest}var a=new s;return u(a,a.head,e),o(e,a,n,a.head,0),function(e){for(var n=[],t=e.head.next;t!==e.tail;)n.push(t.value),t=t.next;return n}(a)},hooks:{all:{},add:function(e,n){var t=a.hooks.all;t[e]=t[e]||[],t[e].push(n)},run:function(e,n){var t=a.hooks.all[e];if(t&&t.length)for(var r,i=0;r=t[i++];)r(n)}},Token:i};function i(e,n,t,r){this.type=e,this.content=n,this.alias=t,this.length=0|(r||"").length}function l(e,n,t,r){e.lastIndex=n;var a=e.exec(t);if(a&&r&&a[1]){var i=a[1].length;a.index+=i,a[0]=a[0].slice(i)}return a}function o(e,n,t,r,s,g){for(var f in t)if(t.hasOwnProperty(f)&&t[f]){var h=t[f];h=Array.isArray(h)?h:[h];for(var d=0;d<h.length;++d){if(g&&g.cause==f+","+d)return;var v=h[d],p=v.inside,m=!!v.lookbehind,y=!!v.greedy,k=v.alias;if(y&&!v.pattern.global){var x=v.pattern.toString().match(/[imsuy]*$/)[0];v.pattern=RegExp(v.pattern.source,x+"g")}for(var b=v.pattern||v,w=r.next,A=s;w!==n.tail&&!(g&&A>=g.reach);A+=w.value.length,w=w.next){var E=w.value;if(n.length>e.length)return;if(!(E instanceof i)){var P,L=1;if(y){if(!(P=l(b,A,e,m))||P.index>=e.length)break;var S=P.index,O=P.index+P[0].length,j=A;for(j+=w.value.length;S>=j;)j+=(w=w.next).value.length;if(A=j-=w.value.length,w.value instanceof i)continue;for(var C=w;C!==n.tail&&(j<O||"string"==typeof C.value);C=C.next)L++,j+=C.value.length;L--,E=e.slice(A,j),P.index-=A}else if(!(P=l(b,0,E,m)))continue;S=P.index;var N=P[0],_=E.slice(0,S),M=E.slice(S+N.length),W=A+E.length;g&&W>g.reach&&(g.reach=W);var z=w.prev;if(_&&(z=u(n,z,_),A+=_.length),c(n,z,L),w=u(n,z,new i(f,p?a.tokenize(N,p):N,k,N)),M&&u(n,w,M),L>1){var I={cause:f+","+d,reach:W};o(e,n,t,w.prev,A,I),g&&I.reach>g.reach&&(g.reach=I.reach)}}}}}}function s(){var e={value:null,prev:null,next:null},n={value:null,prev:e,next:null};e.next=n,this.head=e,this.tail=n,this.length=0}function u(e,n,t){var r=n.next,a={value:t,prev:n,next:r};return n.next=a,r.prev=a,e.length++,a}function c(e,n,t){for(var r=n.next,a=0;a<t&&r!==e.tail;a++)r=r.next;n.next=r,r.prev=n,e.length-=a}if(e.Prism=a,i.stringify=function e(n,t){if("string"==typeof n)return n;if(Array.isArray(n)){var r="";return n.forEach((function(n){r+=e(n,t)})),r}var i={type:n.type,content:e(n.content,t),tag:"span",classes:["token",n.type],attributes:{},language:t},l=n.alias;l&&(Array.isArray(l)?Array.prototype.push.apply(i.classes,l):i.classes.push(l)),a.hooks.run("wrap",i);var o="";for(var s in i.attributes)o+=" "+s+'="'+(i.attributes[s]||"").replace(/"/g,"&quot;")+'"';return"<"+i.tag+' class="'+i.classes.join(" ")+'"'+o+">"+i.content+"</"+i.tag+">"},!e.document)return e.addEventListener?(a.disableWorkerMessageHandler||e.addEventListener("message",(function(n){var t=JSON.parse(n.data),r=t.language,i=t.code,l=t.immediateClose;e.postMessage(a.highlight(i,a.languages[r],r)),l&&e.close()}),!1),a):a;var g=a.util.currentScript();function f(){a.manual||a.highlightAll()}if(g&&(a.filename=g.src,g.hasAttribute("data-manual")&&(a.manual=!0)),!a.manual){var h=document.readyState;"loading"===h||"interactive"===h&&g&&g.defer?document.addEventListener("DOMContentLoaded",f):window.requestAnimationFrame?window.requestAnimationFrame(f):window.setTimeout(f,16)}return a}(_self);"undefined"!=typeof module&&module.exports&&(module.exports=Prism),"undefined"!=typeof global&&(global.Prism=Prism);
+Prism.languages.clike={comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,lookbehind:!0,greedy:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],string:{pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0},"class-name":{pattern:/(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,lookbehind:!0,inside:{punctuation:/[.\\]/}},keyword:/\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,boolean:/\b(?:false|true)\b/,function:/\b\w+(?=\()/,number:/\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,operator:/[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,punctuation:/[{}[\];(),.:]/};
+Prism.languages.javascript=Prism.languages.extend("clike",{"class-name":[Prism.languages.clike["class-name"],{pattern:/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,lookbehind:!0}],keyword:[{pattern:/((?:^|\})\s*)catch\b/,lookbehind:!0},{pattern:/(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,lookbehind:!0}],function:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,number:{pattern:RegExp("(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"),lookbehind:!0},operator:/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/}),Prism.languages.javascript["class-name"][0].pattern=/(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/,Prism.languages.insertBefore("javascript","keyword",{regex:{pattern:RegExp("((?:^|[^$\\w\\xA0-\\uFFFF.\"'\\])\\s]|\\b(?:return|yield))\\s*)/(?:(?:\\[(?:[^\\]\\\\\r\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|/\\*(?:[^*]|\\*(?!/))*\\*/)*(?:$|[\r\n,.;:})\\]]|//))"),lookbehind:!0,greedy:!0,inside:{"regex-source":{pattern:/^(\/)[\s\S]+(?=\/[a-z]*$)/,lookbehind:!0,alias:"language-regex",inside:Prism.languages.regex},"regex-delimiter":/^\/|\/$/,"regex-flags":/^[a-z]+$/}},"function-variable":{pattern:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,alias:"function"},parameter:[{pattern:/(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,lookbehind:!0,inside:Prism.languages.javascript},{pattern:/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,lookbehind:!0,inside:Prism.languages.javascript},{pattern:/(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,lookbehind:!0,inside:Prism.languages.javascript},{pattern:/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,lookbehind:!0,inside:Prism.languages.javascript}],constant:/\b[A-Z](?:[A-Z_]|\dx?)*\b/}),Prism.languages.insertBefore("javascript","string",{hashbang:{pattern:/^#!.*/,greedy:!0,alias:"comment"},"template-string":{pattern:/`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,greedy:!0,inside:{"template-punctuation":{pattern:/^`|`$/,alias:"string"},interpolation:{pattern:/((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^\$\{|\}$/,alias:"punctuation"},rest:Prism.languages.javascript}},string:/[\s\S]+/}},"string-property":{pattern:/((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,lookbehind:!0,greedy:!0,alias:"property"}}),Prism.languages.insertBefore("javascript","operator",{"literal-property":{pattern:/((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,lookbehind:!0,alias:"property"}}),Prism.languages.markup&&(Prism.languages.markup.tag.addInlined("script","javascript"),Prism.languages.markup.tag.addAttribute("on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)","javascript")),Prism.languages.js=Prism.languages.javascript;
+!function(e){e.languages.typescript=e.languages.extend("javascript",{"class-name":{pattern:/(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,lookbehind:!0,greedy:!0,inside:null},builtin:/\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/}),e.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/,/\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,/\btype\b(?=\s*(?:[\{*]|$))/),delete e.languages.typescript.parameter,delete e.languages.typescript["literal-property"];var s=e.languages.extend("typescript",{});delete s["class-name"],e.languages.typescript["class-name"].inside=s,e.languages.insertBefore("typescript","function",{decorator:{pattern:/@[$\w\xA0-\uFFFF]+/,inside:{at:{pattern:/^@/,alias:"operator"},function:/^[\s\S]+/}},"generic-function":{pattern:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,greedy:!0,inside:{function:/^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,generic:{pattern:/<[\s\S]+/,alias:"class-name",inside:s}}}}),e.languages.ts=e.languages.typescript}(Prism);

From 7fc248d6f387b50f090fcfb19eab120a29ac137e Mon Sep 17 00:00:00 2001
From: peter <1692655013wf@gmail.com>
Date: Wed, 1 Feb 2023 15:31:01 +0800
Subject: [PATCH 237/280] Update arraybuffer.md

DataView add setBigInt64 getBigInt64 setBigUint64 getBigUint64
---
 docs/arraybuffer.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/arraybuffer.md b/docs/arraybuffer.md
index 61325fd7d..19b0a3509 100644
--- a/docs/arraybuffer.md
+++ b/docs/arraybuffer.md
@@ -754,6 +754,8 @@ const dv = new DataView(buffer);
 - **`getUint16`**：读取 2 个字节，返回一个无符号的 16 位整数。
 - **`getInt32`**：读取 4 个字节，返回一个 32 位整数。
 - **`getUint32`**：读取 4 个字节，返回一个无符号的 32 位整数。
+- **`getBigInt64`**：读取 8 个字节，返回一个 64 位整数。
+- **`getBigUint64`**：读取 8 个字节，返回一个无符号的 64 位整数。
 - **`getFloat32`**：读取 4 个字节，返回一个 32 位浮点数。
 - **`getFloat64`**：读取 8 个字节，返回一个 64 位浮点数。
 
@@ -796,6 +798,8 @@ DataView 视图提供 8 个方法写入内存。
 - **`setUint16`**：写入 2 个字节的 16 位无符号整数。
 - **`setInt32`**：写入 4 个字节的 32 位整数。
 - **`setUint32`**：写入 4 个字节的 32 位无符号整数。
+- **`setBigInt64`**：写入 8 个字节的 64 位整数。
+- **`setBigUint64`**：写入 8 个字节的 64 位无符号整数。
 - **`setFloat32`**：写入 4 个字节的 32 位浮点数。
 - **`setFloat64`**：写入 8 个字节的 64 位浮点数。
 

From 7523f55ca89936a27aa8aea4f781e922561cc893 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 2 Feb 2023 08:55:08 +0800
Subject: [PATCH 238/280] docs(arraybuffer): update DataView methods

---
 .DS_Store           | Bin 0 -> 6148 bytes
 docs/arraybuffer.md |   4 ++--
 2 files changed, 2 insertions(+), 2 deletions(-)
 create mode 100644 .DS_Store

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..8907f9d4c290ebfabd3b25042a56c8678e2b71f4
GIT binary patch
literal 6148
zcmeHLF;4<96n=%n5RK#ri<>t)7}*_8g1-PZVuFAH4d<Of6617}GqVG;1A~LVKxd8r
z!NkppK}O$ei`R1K;9!h-FKNGCzrKFg5AI3<08trs$^b3^<gpMst5_`w;;Ez}qkA?G
z1<ld#mTT=Wh*BfDgB@T8{-Oi)>^iUwT{wnw>-jyHo|#+_R;#Uk*uuU%)MvBd=wZ+1
zJKyqA&v-X9Z!s0Ja0n4Zma5a(N*Gh~>bl|HjPFTP=LKP+m}V_Kcck>%Fo1!j2i~Kc
zQ8K1p>7tY9X*SVIvz8w0ke&k_2mx~~#r49g$(fp)Z|{k(I@es~GTzcHc%-|6pJjmF
zcHwA2ySO`D<W2q4NpHSpYYy`sz8YiQM=_@R$iT^her__J_nW$<yO*c>rTjk098+(R
zvvhLLq{Hzu2XN1($ge5nnjK&V*nv+6=>6bfA@nuI3gxQ<D|rM!bg)|nwq0r<dK!I=
zu|i}pgi1wJsX`wygi6PLPml98#tKzB2z~evT3P55ije9!zbA)-@D*~+4zL5Z16g(H
z(*D2y_4(gU;wyH59r#xc2&Y=BR&YsrZ%r+Z_F4~16AJ~6ixtWgtn_v)8?+VE{|YjY
Y^QeL7Ym60Q4+j4bkT!6|4*aSEAA$R}&Hw-a

literal 0
HcmV?d00001

diff --git a/docs/arraybuffer.md b/docs/arraybuffer.md
index 19b0a3509..b7abdf0b1 100644
--- a/docs/arraybuffer.md
+++ b/docs/arraybuffer.md
@@ -746,7 +746,7 @@ const dv = new DataView(buffer);
 - `DataView.prototype.byteLength`：返回占据的内存字节长度
 - `DataView.prototype.byteOffset`：返回当前视图从对应的 ArrayBuffer 对象的哪个字节开始
 
-`DataView`实例提供 8 个方法读取内存。
+`DataView`实例提供10个方法读取内存。
 
 - **`getInt8`**：读取 1 个字节，返回一个 8 位整数。
 - **`getUint8`**：读取 1 个字节，返回一个无符号的 8 位整数。
@@ -790,7 +790,7 @@ const v2 = dv.getUint16(3, false);
 const v3 = dv.getUint16(3);
 ```
 
-DataView 视图提供 8 个方法写入内存。
+DataView 视图提供10个方法写入内存。
 
 - **`setInt8`**：写入 1 个字节的 8 位整数。
 - **`setUint8`**：写入 1 个字节的 8 位无符号整数。

From 60e128cb93649fbabe727cd67e2f10f5490482cb Mon Sep 17 00:00:00 2001
From: Shude Li <islishude@gmail.com>
Date: Sun, 12 Feb 2023 10:05:16 +0800
Subject: [PATCH 239/280] module-loader: remove
 `--experimental-conditional-exports`

ref: https://nodejs.org/api/packages.html#modules-packages

> Remove the --experimental-conditional-exports option. In 12.16.0, conditional exports are still behind --experimental-modules.
---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index 9a99b59ef..ce8082cc1 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -412,7 +412,7 @@ import submodule from './node_modules/es-module-package/private-module.js';
 
 **（3）条件加载**
 
-利用`.`这个别名，可以为 ES6 模块和 CommonJS 指定不同的入口。目前，这个功能需要在 Node.js 运行的时候，打开`--experimental-conditional-exports`标志。
+利用`.`这个别名，可以为 ES6 模块和 CommonJS 指定不同的入口。
 
 ```javascript
 {

From b20e38b7b8c434dffe4cc7d5b12335a4833b5639 Mon Sep 17 00:00:00 2001
From: Hencky <928856778@qq.com>
Date: Thu, 2 Mar 2023 19:04:49 +0800
Subject: [PATCH 240/280] docs(set): fix delete fn

---
 docs/set-map.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index 288df2639..c2f586099 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -114,7 +114,7 @@ s.has(1) // true
 s.has(2) // true
 s.has(3) // false
 
-s.delete(2);
+s.delete(2) // true
 s.has(2) // false
 ```
 

From 0928b9cc1575830b53b4637cc2b065ce8ae40e45 Mon Sep 17 00:00:00 2001
From: Hencky <928856778@qq.com>
Date: Mon, 6 Mar 2023 13:56:07 +0800
Subject: [PATCH 241/280] docs(set-map): WeakSet methods

---
 docs/set-map.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index c2f586099..da23a6894 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -358,8 +358,8 @@ const ws = new WeakSet(b);
 
 WeakSet 结构有以下三个方法。
 
-- **WeakSet.prototype.add(value)**：向 WeakSet 实例添加一个新成员。
-- **WeakSet.prototype.delete(value)**：清除 WeakSet 实例的指定成员。
+- **WeakSet.prototype.add(value)**：向 WeakSet 实例添加一个新成员，返回 WeakSet 结构本身。
+- **WeakSet.prototype.delete(value)**：清除 WeakSet 实例的指定成员，清除成功返回`true`，如果在 WeakSet 中找不到该成员或该成员不是对象，返回`false`。
 - **WeakSet.prototype.has(value)**：返回一个布尔值，表示某个值是否在 WeakSet 实例之中。
 
 下面是一个例子。
@@ -373,10 +373,10 @@ ws.add(window);
 ws.add(obj);
 
 ws.has(window); // true
-ws.has(foo);    // false
+ws.has(foo); // false
 
-ws.delete(window);
-ws.has(window);    // false
+ws.delete(window); // true
+ws.has(window); // false
 ```
 
 WeakSet 没有`size`属性，没有办法遍历它的成员。

From 50e9ced0da7f4af04838202baac3d2522bb75c0e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 8 Apr 2023 00:17:12 +0800
Subject: [PATCH 242/280] =?UTF-8?q?docs(operator):=20#!=20=E5=91=BD?=
 =?UTF-8?q?=E4=BB=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/operator.md  | 42 ++++++++++++++++++++++++++++++++++++++++++
 docs/proposals.md | 42 ------------------------------------------
 2 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/docs/operator.md b/docs/operator.md
index 6d72c666c..fea9e9096 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -307,3 +307,45 @@ function example(opts) {
 }
 ```
 
+## `#!`命令
+
+Unix 的命令行脚本都支持`#!`命令，又称为 Shebang 或 Hashbang。这个命令放在脚本的第一行，用来指定脚本的执行器。
+
+比如 Bash 脚本的第一行。
+
+```bash
+#!/bin/sh
+```
+
+Python 脚本的第一行。
+
+```python
+#!/usr/bin/env python
+```
+
+[ES2023](https://github.com/tc39/proposal-hashbang) 为 JavaScript 脚本引入了`#!`命令，写在脚本文件或者模块文件的第一行。
+
+```javascript
+// 写在脚本文件第一行
+#!/usr/bin/env node
+'use strict';
+console.log(1);
+
+// 写在模块文件第一行
+#!/usr/bin/env node
+export {};
+console.log(1);
+```
+
+有了这一行以后，Unix 命令行就可以直接执行脚本。
+
+```bash
+# 以前执行脚本的方式
+$ node hello.js
+
+# hashbang 的方式
+$ ./hello.js
+```
+
+对于 JavaScript 引擎来说，会把`#!`理解成注释，忽略掉这一行。
+
diff --git a/docs/proposals.md b/docs/proposals.md
index 447151a5a..cfa19bc30 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -482,48 +482,6 @@ class FakeWindow extends Realm {
 
 上面代码中，`FakeWindow`模拟了一个假的顶层对象`window`。
 
-## `#!`命令
-
-Unix 的命令行脚本都支持`#!`命令，又称为 Shebang 或 Hashbang。这个命令放在脚本的第一行，用来指定脚本的执行器。
-
-比如 Bash 脚本的第一行。
-
-```bash
-#!/bin/sh
-```
-
-Python 脚本的第一行。
-
-```python
-#!/usr/bin/env python
-```
-
-现在有一个[提案](https://github.com/tc39/proposal-hashbang)，为 JavaScript 脚本引入了`#!`命令，写在脚本文件或者模块文件的第一行。
-
-```javascript
-// 写在脚本文件第一行
-#!/usr/bin/env node
-'use strict';
-console.log(1);
-
-// 写在模块文件第一行
-#!/usr/bin/env node
-export {};
-console.log(1);
-```
-
-有了这一行以后，Unix 命令行就可以直接执行脚本。
-
-```bash
-# 以前执行脚本的方式
-$ node hello.js
-
-# hashbang 的方式
-$ ./hello.js
-```
-
-对于 JavaScript 引擎来说，会把`#!`理解成注释，忽略掉这一行。
-
 ## JSON 模块
 
 import 命令目前只能用于加载 ES 模块，现在有一个[提案](https://github.com/tc39/proposal-json-modules)，允许加载 JSON 模块。

From 87d5dedb2d4f34682209884489ae5b7248e1b001 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 9 May 2023 14:00:30 +0800
Subject: [PATCH 243/280] docs(style): edit text

---
 docs/style.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/style.md b/docs/style.md
index fc23e2ffa..95fe4c92e 100644
--- a/docs/style.md
+++ b/docs/style.md
@@ -285,7 +285,7 @@ const boundMethod = (...params) => method.apply(this, params);
 
 简单的、单行的、不会复用的函数，建议采用箭头函数。如果函数体较为复杂，行数较多，还是应该采用传统的函数写法。
 
-所有配置项都应该集中在一个对象，放在最后一个参数，布尔值不可以直接作为参数。
+所有配置项都应该集中在一个对象，放在最后一个参数，布尔值最好不要直接作为参数，因为代码语义会很差，也不利于将来增加其他配置项。
 
 ```javascript
 // bad

From 982f4983a9a178d6eb78b92b1dd2b9496bf0f8e5 Mon Sep 17 00:00:00 2001
From: qijizh <qijizh1999@163.com>
Date: Mon, 15 May 2023 02:51:11 +0800
Subject: [PATCH 244/280] docs(generator): update example

---
 docs/generator.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/generator.md b/docs/generator.md
index 7d18278ca..283b84484 100644
--- a/docs/generator.md
+++ b/docs/generator.md
@@ -552,26 +552,26 @@ g.throw(1);
 
 上面代码中，`g.throw(1)`执行时，`next`方法一次都没有执行过。这时，抛出的错误不会被内部捕获，而是直接在外部抛出，导致程序出错。这种行为其实很好理解，因为第一次执行`next`方法，等同于启动执行 Generator 函数的内部代码，否则 Generator 函数还没有开始执行，这时`throw`方法抛错只可能抛出在函数外部。
 
-`throw`方法被捕获以后，会附带执行下一条`yield`表达式。也就是说，会附带执行一次`next`方法。
+`throw`方法被内部捕获以后，会附带执行到下一条`yield`表达式，这种情况下等同于执行一次`next`方法。
 
 ```javascript
 var gen = function* gen(){
   try {
-    yield console.log('a');
+    yield 1;
   } catch (e) {
-    // ...
+    yield 2;
   }
-  yield console.log('b');
-  yield console.log('c');
+  yield 3;
 }
 
 var g = gen();
-g.next() // a
-g.throw() // b
-g.next() // c
+g.next() // { value:1, done:false }
+g.throw() // { value:2, done:false }
+g.next() // { value:3, done:false }
+g.next() // { value:undefined, done:true }
 ```
 
-上面代码中，`g.throw`方法被捕获以后，自动执行了一次`next`方法，所以会打印`b`。另外，也可以看到，只要 Generator 函数内部部署了`try...catch`代码块，那么遍历器的`throw`方法抛出的错误，不影响下一次遍历。
+上面代码中，`g.throw`方法被内部捕获以后，等同于执行了一次`next`方法，所以返回`{ value:2, done:false }`。另外，也可以看到，只要 Generator 函数内部部署了`try...catch`代码块，那么遍历器的`throw`方法抛出的错误，不影响下一次遍历。
 
 另外，`throw`命令与`g.throw`方法是无关的，两者互不影响。
 

From 43222de51b3574f98e217364f0c271ca2cce46a2 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 6 Jun 2023 16:14:47 +0800
Subject: [PATCH 245/280] docs(set-map): fixed #1155

---
 docs/set-map.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index da23a6894..cb21460d8 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -118,7 +118,7 @@ s.delete(2) // true
 s.has(2) // false
 ```
 
-下面是一个对比，看看在判断是否包括一个键上面，`Object`结构和`Set`结构的写法不同。
+下面是一个对比，判断是否包括一个键，`Object`结构和`Set`结构写法的不同。
 
 ```javascript
 // 对象的写法
@@ -142,7 +142,7 @@ if (properties.has(someName)) {
 }
 ```
 
-`Array.from`方法可以将 Set 结构转为数组。
+`Array.from()`方法可以将 Set 结构转为数组。
 
 ```javascript
 const items = new Set([1, 2, 3, 4, 5]);

From 4e4058291619a07ff6e90b2702fcbf3c67cf316a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 15 Jun 2023 13:18:56 +0800
Subject: [PATCH 246/280] docs(module): fixed #1157

---
 docs/module.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/module.md b/docs/module.md
index 0f2481587..5d68da67a 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -162,6 +162,8 @@ function f() {}
 export {f};
 ```
 
+目前，export 命令能够对外输出的就是三种接口：函数（Functions）， 类（Classes），var、let、const 声明的变量（Variables）。
+
 另外，`export`语句输出的接口，与其对应的值是动态绑定关系，即通过该接口，可以取到模块内部实时的值。
 
 ```javascript

From 7dbca2b4bd469ec7577ea7dc101181b6d051fdaf Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 27 Jun 2023 15:03:55 +0800
Subject: [PATCH 247/280] docs(class): edit text

---
 docs/class.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class.md b/docs/class.md
index cbdde3bbf..a37947a63 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1006,7 +1006,7 @@ class Foo {}
 }
 ```
 
-上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而`let`命令是不提升的，所以导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
+上面的代码不会报错，因为`Bar`继承`Foo`的时候，`Foo`已经有定义了。但是，如果存在`class`的提升，上面代码就会报错，因为`class`会被提升到代码头部，而定义`Foo`的那一行没有提升，导致`Bar`继承`Foo`的时候，`Foo`还没有定义。
 
 ### name 属性
 

From a342ebff148fb81ed01f49f56a603ee36cfd6a3d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 13 Jul 2023 16:27:54 +0800
Subject: [PATCH 248/280] docs(class): fix private field #1159

---
 docs/class.md | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index a37947a63..c27bb2f4a 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -844,7 +844,7 @@ class C {
 }
 ```
 
-上面示例中，`in`运算符判断某个对象是否有私有属性`#foo`。它不会报错，而是返回一个布尔值。
+上面示例中，`in`运算符判断某个对象是否有私有属性`#brand`。它不会报错，而是返回一个布尔值。
 
 这种用法的`in`，也可以跟`this`一起配合使用。
 
@@ -853,12 +853,21 @@ class A {
   #foo = 0;
   m() {
     console.log(#foo in this); // true
-    console.log(#bar in this); // false
   }
 }
 ```
 
-注意，判断私有属性时，`in`只能用在类的内部。
+注意，判断私有属性时，`in`只能用在类的内部。另外，判断所针对的私有属性，一定要先声明，否则会报错。
+
+```javascript
+class A {
+  m() {
+    console.log(#foo in this); // 报错
+  }
+}
+```
+
+上面示例中，私有属性`#foo`没有声明，就直接用于`in`运算符的判断，导致报错。
 
 子类从父类继承的私有属性，也可以使用`in`运算符来判断。
 

From ece963d6ab2ab7ea8337a74de61b660a83bc1fee Mon Sep 17 00:00:00 2001
From: succyag <104663431+succyag@users.noreply.github.com>
Date: Sun, 16 Jul 2023 21:46:01 +0800
Subject: [PATCH 249/280] Update regex.md

---
 docs/regex.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 157778a99..6ea589a41 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -376,7 +376,7 @@ JavaScript 语言的正则表达式，只支持先行断言（lookahead）和先
 
 ```javascript
 /(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')  // ["100"]
-/(?<!\$)\d+/.exec('it’s is worth about €90')                // ["90"]
+/(?<!\$)\d+/.exec('it’s worth about €90')                // ["90"]
 ```
 
 上面的例子中，“后行断言”的括号之中的部分（`(?<=\$)`），也是不计入返回结果。

From 996628943ccedafc7f8cf2283526969f62edd660 Mon Sep 17 00:00:00 2001
From: succyag <104663431+succyag@users.noreply.github.com>
Date: Mon, 17 Jul 2023 08:12:51 +0800
Subject: [PATCH 250/280] Update regex.md

---
 docs/regex.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 6ea589a41..729eab3c4 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -376,7 +376,7 @@ JavaScript 语言的正则表达式，只支持先行断言（lookahead）和先
 
 ```javascript
 /(?<=\$)\d+/.exec('Benjamin Franklin is on the $100 bill')  // ["100"]
-/(?<!\$)\d+/.exec('it’s worth about €90')                // ["90"]
+/(?<!\$)\d+/.exec('it’s worth about €90')                   // ["90"]
 ```
 
 上面的例子中，“后行断言”的括号之中的部分（`(?<=\$)`），也是不计入返回结果。

From 49351992ceb523db5ce3f9b38de52c45a4711090 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 20 Jul 2023 14:38:25 +0800
Subject: [PATCH 251/280] docs(array): fix .group() #1161

---
 docs/array.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/array.md b/docs/array.md
index 8c2b69000..d12d4a38e 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -941,7 +941,7 @@ array.group((num, index, array) => {
 下面是另一个例子。
 
 ```javascript
-[6.1, 4.2, 6.3].groupBy(Math.floor)
+[6.1, 4.2, 6.3].group(Math.floor)
 // { '4': [4.2], '6': [6.1, 6.3] }
 ```
 

From d47a259b1335b609cafcb63039ed7c4969782326 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 26 Jul 2023 19:06:24 +0800
Subject: [PATCH 252/280] docs(set-map): fix Symbol() as WeakSet/WeakMap key
 #1162

---
 docs/set-map.md | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index cb21460d8..c5fa699ee 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -308,17 +308,15 @@ set = new Set(Array.from(set, val => val * 2));
 
 WeakSet 结构与 Set 类似，也是不重复的值的集合。但是，它与 Set 有两个区别。
 
-首先，WeakSet 的成员只能是对象，而不能是其他类型的值。
+首先，WeakSet 的成员只能是对象和 Symbol 值，而不能是其他类型的值。
 
 ```javascript
 const ws = new WeakSet();
-ws.add(1)
-// TypeError: Invalid value used in weak set
-ws.add(Symbol())
-// TypeError: invalid value used in weak set
+ws.add(1) // 报错
+ws.add(Symbol()) // 不报错
 ```
 
-上面代码试图向 WeakSet 添加一个数值和`Symbol`值，结果报错，因为 WeakSet 只能放置对象。
+上面代码试图向 WeakSet 添加一个数值和`Symbol`值，结果前者报错了，因为 WeakSet 只能放置对象和 Symbol 值。
 
 其次，WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中。
 
@@ -633,7 +631,7 @@ m.has(undefined)     // true
 
 **（5）Map.prototype.delete(key)**
 
-`delete`方法删除某个键，返回`true`。如果删除失败，返回`false`。
+`delete()`方法删除某个键，返回`true`。如果删除失败，返回`false`。
 
 ```javascript
 const m = new Map();
@@ -646,7 +644,7 @@ m.has(undefined)       // false
 
 **（6）Map.prototype.clear()**
 
-`clear`方法清除所有成员，没有返回值。
+`clear()`方法清除所有成员，没有返回值。
 
 ```javascript
 let map = new Map();
@@ -928,21 +926,16 @@ wm2.get(k2) // "bar"
 
 `WeakMap`与`Map`的区别有两点。
 
-首先，`WeakMap`只接受对象作为键名（`null`除外），不接受其他类型的值作为键名。
+首先，`WeakMap`只接受对象（`null`除外）和 [Symbol 值](https://github.com/tc39/proposal-symbols-as-weakmap-keys)作为键名，不接受其他类型的值作为键名。
 
 ```javascript
 const map = new WeakMap();
-map.set(1, 2)
-// TypeError: 1 is not an object!
-map.set(Symbol(), 2)
-// TypeError: Invalid value used as weak map key
-map.set(null, 2)
-// TypeError: Invalid value used as weak map key
+map.set(1, 2) // 报错
+map.set(null, 2) // 报错
+map.set(Symbol(), 2) // 不报错
 ```
 
-上面代码中，如果将数值`1`和`Symbol`值作为 WeakMap 的键名，都会报错。
-
-不过，现在有一个[提案](https://github.com/tc39/proposal-symbols-as-weakmap-keys)，允许 Symbol 值也可以作为 WeakMap 的键名。一旦纳入标准，就意味着键名存在两种可能：对象和 Symbol 值。
+上面代码中，如果将数值`1`和`null`作为 WeakMap 的键名，都会报错，将 Symbol 值作为键名不会报错。
 
 其次，`WeakMap`的键名所指向的对象，不计入垃圾回收机制。
 

From 45614204906bdc55902d7199662b8f7df7922782 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 7 Aug 2023 12:00:15 +0800
Subject: [PATCH 253/280] doc: edit README

---
 README.md | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 84de1b82f..2db96d7af 100644
--- a/README.md
+++ b/README.md
@@ -1,29 +1,30 @@
 # ES6 入门教程
 
-官方镜像：[网道（WangDoc.com）](https://wangdoc.com/es6/)
-
 《ECMAScript 6 入门教程》是一本开源的 JavaScript 语言教程，全面介绍 ECMAScript 6 新引入的语法特性。
 
 [![cover](images/cover_thumbnail_3rd.jpg)](images/cover-3rd.jpg)
 
 本书覆盖 ES6 与上一个版本 ES5 的所有不同之处，对涉及的语法知识给予详细介绍，并给出大量简洁易懂的示例代码。
 
-本书为中级难度，适合已经掌握 ES5 的读者，用来了解这门语言的最新发展；也可当作参考手册，查寻新增的语法点。如果你是 JavaScript 语言的初学者，建议先学完[《JavaScript 语言入门教程》](https://wangdoc.com/javascript/)，再来看本书。
-
-全书已由电子工业出版社出版，2017年9月推出了第三版，书名为《ES6 标准入门》。纸版是基于网站内容排版印刷的。
+本书为中级难度，适合已经掌握 ES5 的读者，用来了解这门语言的最新发展；也可当作参考手册，查寻新增的语法点。如果你是 JavaScript 语言的初学者，建议先学完[《JavaScript 语言教程》](https://wangdoc.com/javascript/)，再来看本书。
 
-感谢张春雨编辑支持我将全书开源的做法。如果您认可这本书，建议购买纸版。这样可以使出版社不因出版开源书籍而亏钱，进而鼓励更多的作者开源自己的书籍。下面是第三版的购买地址。
+全书已由电子工业出版社出版，2017年9月推出了第三版，书名为《ES6 标准入门》。纸版内容截止到出版时，网站内容一直在修订。
 
 - [淘宝](https://s.taobao.com/search?q=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8+%E7%AC%AC3%E7%89%88)
 - [京东](https://search.jd.com/Search?keyword=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8%20%E7%AC%AC3%E7%89%88&enc=utf-8&wq=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8%20%E7%AC%AC3%E7%89%88)
 - [当当](https://product.dangdang.com/25156888.html)
-- [亚马逊](https://www.amazon.cn/ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8-%E9%98%AE%E4%B8%80%E5%B3%B0/dp/B0755547ZZ)
-- [China-pub](http://product.china-pub.com/6504650)
 
-### 版权许可
+## 相关链接
+
+- [官方镜像](https://wangdoc.com/es6/)
+- [JavaScript 教程](https://wangdoc.com/javascript)
+- [TypeScript 教程](https://wangdoc.com/typescript)
+
+## 版权许可
 
 本书采用“保持署名—非商用”创意共享4.0许可证。
 
 只要保持原作者署名和非商用，您可以自由地阅读、分享、修改本书。
 
 详细的法律条文请参见[创意共享](http://creativecommons.org/licenses/by-nc/4.0/)网站。
+

From 16f567b074060d84223b324b956f61f2ec3ab9af Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 7 Aug 2023 12:03:50 +0800
Subject: [PATCH 254/280] doc: edit README

---
 README.md | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 2db96d7af..5bb40d336 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 # ES6 入门教程
 
+- [官方镜像](https://wangdoc.com/es6/)
+- [JavaScript 教程](https://wangdoc.com/javascript)
+- [TypeScript 教程](https://wangdoc.com/typescript)
+
 《ECMAScript 6 入门教程》是一本开源的 JavaScript 语言教程，全面介绍 ECMAScript 6 新引入的语法特性。
 
 [![cover](images/cover_thumbnail_3rd.jpg)](images/cover-3rd.jpg)
@@ -14,13 +18,7 @@
 - [京东](https://search.jd.com/Search?keyword=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8%20%E7%AC%AC3%E7%89%88&enc=utf-8&wq=ES6%E6%A0%87%E5%87%86%E5%85%A5%E9%97%A8%20%E7%AC%AC3%E7%89%88)
 - [当当](https://product.dangdang.com/25156888.html)
 
-## 相关链接
-
-- [官方镜像](https://wangdoc.com/es6/)
-- [JavaScript 教程](https://wangdoc.com/javascript)
-- [TypeScript 教程](https://wangdoc.com/typescript)
-
-## 版权许可
+### 版权许可
 
 本书采用“保持署名—非商用”创意共享4.0许可证。
 

From 1b9a0ccfe00b1c3b02eb5982dd6e71b803f52dd0 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 19 Aug 2023 15:31:01 +0800
Subject: [PATCH 255/280] docs(class): add Chrome 111 devtool supporting
 private field access

---
 docs/class.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/class.md b/docs/class.md
index c27bb2f4a..4a2d53af8 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -681,6 +681,8 @@ counter.#count = 42 // 报错
 
 上面示例中，在类的外部，读取或写入私有属性`#count`，都会报错。
 
+注意，[从 Chrome 111 开始](https://developer.chrome.com/blog/new-in-devtools-111/#misc)，开发者工具里面可以读写私有属性，不会报错，原因是 Chrome 团队认为这样方便调试。
+
 另外，不管在类的内部或外部，读取一个不存在的私有属性，也都会报错。这跟公开属性的行为完全不同，如果读取一个不存在的公开属性，不会报错，只会返回`undefined`。
 
 ```javascript

From e8c2d2ea7fcdc36c61c90b067af52407e46f1bf8 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 19 Aug 2023 16:07:40 +0800
Subject: [PATCH 256/280] docs(decorator): fixed #1165

---
 docs/decorator.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs/decorator.md b/docs/decorator.md
index 0577d18b3..3a46d7119 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -129,8 +129,6 @@ MyClass.isTestable // false
 
 上面代码中，装饰器`testable`可以接受参数，这就等于可以修改装饰器的行为。
 
-注意，装饰器对类的行为的改变，是代码编译时发生的，而不是在运行时。这意味着，装饰器能在编译阶段运行代码。也就是说，装饰器本质就是编译时执行的函数。
-
 前面的例子是为类添加一个静态属性，如果想添加实例属性，可以通过目标类的`prototype`对象操作。
 
 ```javascript

From 4c06dfbfca63d1c09b07d21374add98f72175848 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 22 Aug 2023 18:57:53 +0800
Subject: [PATCH 257/280] docs(symbol): fixed #1166 Symbol.toStringTag

---
 docs/symbol.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index 2297e10d5..281c81873 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -846,7 +846,7 @@ String(obj) // 'str'
 
 ### Symbol.toStringTag
 
-对象的`Symbol.toStringTag`属性，指向一个方法。在该对象上面调用`Object.prototype.toString`方法时，如果这个属性存在，它的返回值会出现在`toString`方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制`[object Object]`或`[object Array]`中`object`后面的那个字符串。
+对象的`Symbol.toStringTag`属性，返回一个字符串。在目标对象上面调用`Object.prototype.toString`方法时，如果`Symbol.toStringTag`属性存在，它的返回值会出现在`toString`方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制`[object Object]`或`[object Array]`中`object`后面的那个字符串。
 
 ```javascript
 // 例一

From b1b35cde31aa38b1a2e9b7fd330f993a1995d534 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 24 Aug 2023 14:01:03 +0800
Subject: [PATCH 258/280] docs(symbol): edit Symbol.toStringTag #1166

---
 docs/symbol.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/symbol.md b/docs/symbol.md
index 281c81873..4693410b0 100644
--- a/docs/symbol.md
+++ b/docs/symbol.md
@@ -846,7 +846,7 @@ String(obj) // 'str'
 
 ### Symbol.toStringTag
 
-对象的`Symbol.toStringTag`属性，返回一个字符串。在目标对象上面调用`Object.prototype.toString`方法时，如果`Symbol.toStringTag`属性存在，它的返回值会出现在`toString`方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制`[object Object]`或`[object Array]`中`object`后面的那个字符串。
+对象的`Symbol.toStringTag`属性，用来设定一个字符串（设为其他类型的值无效，但不报错）。在目标对象上面调用`Object.prototype.toString()`方法时，如果`Symbol.toStringTag`属性存在，该属性设定的字符串会出现在`toString()`方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制`[object Object]`或`[object Array]`中`object`后面的那个大写字符串。
 
 ```javascript
 // 例一

From 17246d85bb9e4364adc787d097ce1a158daf84ec Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 24 Aug 2023 14:20:57 +0800
Subject: [PATCH 259/280] docs(proxy): fixed #1167 Proxy get()

---
 docs/proxy.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/proxy.md b/docs/proxy.md
index a65ec7dcc..5885094b4 100644
--- a/docs/proxy.md
+++ b/docs/proxy.md
@@ -286,7 +286,7 @@ const proxy = new Proxy({}, {
 proxy.getReceiver === proxy // true
 ```
 
-上面代码中，`proxy`对象的`getReceiver`属性是由`proxy`对象提供的，所以`receiver`指向`proxy`对象。
+上面代码中，`proxy`对象的`getReceiver`属性会被`get()`拦截，得到的返回值就是`proxy`对象。
 
 ```javascript
 const proxy = new Proxy({}, {

From a623e19fb97f6dbefa25f5c5fa554160103e1bf3 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 9 Nov 2023 19:38:57 +0800
Subject: [PATCH 260/280] docs(intro): fix #1170

---
 docs/intro.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/intro.md b/docs/intro.md
index 880cf08b7..ea1695911 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -68,9 +68,9 @@ ES6 从开始制定到最后发布，整整用了 15 年。
 
 2015 年 6 月，ECMAScript 6 正式通过，成为国际标准。从 2000 年算起，这时已经过去了 15 年。
 
-目前，各大浏览器对 ES6 的支持可以查看[kangax.github.io/compat-table/es6/](https://kangax.github.io/compat-table/es6/)。
+目前，各大浏览器对 ES6 的支持可以查看[https://compat-table.github.io/compat-table/es6/](https://compat-table.github.io/compat-table/es6/)。
 
-Node.js 是 JavaScript 的服务器运行环境（runtime）。它对 ES6 的支持度更高。除了那些默认打开的功能，还有一些语法功能已经实现了，但是默认没有打开。使用下面的命令，可以查看 Node.js 默认没有打开的 ES6 实验性语法。
+Node.js 是 JavaScript 的服务器运行环境（runtime）。它对 ES6 的支持度更高。除了那些默认打开的功能，还有一些语法功能已经实现了，但是默认没有打开。使用下面的命令，可以查看 Node.js 默认没有打开的实验性语法。
 
 ```bash
 // Linux & Mac

From fc58b0c1505654bde876ace4f8f1f7f5882876fa Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 30 Dec 2023 14:42:23 +0800
Subject: [PATCH 261/280] docs(class-extends): fix typo

---
 docs/class-extends.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/class-extends.md b/docs/class-extends.md
index 5b1ff61fd..c5308bd0c 100644
--- a/docs/class-extends.md
+++ b/docs/class-extends.md
@@ -183,7 +183,7 @@ B.hello()  // hello world
 
 上面代码中，`hello()`是`A`类的静态方法，`B`继承`A`，也继承了`A`的静态方法。
 
-注意，静态属性是通过软拷贝实现继承的。
+注意，静态属性是通过浅拷贝实现继承的。
 
 ```javascript
 class A { static foo = 100; }

From 79e15346b255485dfe3e89a686dfe1de2460433e Mon Sep 17 00:00:00 2001
From: liliangrong777 <58727146+liliangrong777@users.noreply.github.com>
Date: Wed, 10 Apr 2024 17:32:06 +0800
Subject: [PATCH 262/280] Update module-loader.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

fix: 内容修正
---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index ce8082cc1..ecea1157c 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -397,7 +397,7 @@ import submodule from './node_modules/es-module-package/private-module.js';
 }
 ```
 
-由于`exports`字段只有支持 ES6 的 Node.js 才认识，所以可以用来兼容旧版本的 Node.js。
+由于`exports`字段只有支持 ES6 的 Node.js 才认识，所以可以用`main`字段来兼容旧版本的 Node.js。
 
 ```javascript
 {

From bae421dcdf73fdf71214b148358e44a0388e7fa5 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 10 Apr 2024 18:04:27 +0800
Subject: [PATCH 263/280] docs(module-loader): edit text

---
 docs/module-loader.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/module-loader.md b/docs/module-loader.md
index ecea1157c..31dd685e7 100644
--- a/docs/module-loader.md
+++ b/docs/module-loader.md
@@ -397,7 +397,7 @@ import submodule from './node_modules/es-module-package/private-module.js';
 }
 ```
 
-由于`exports`字段只有支持 ES6 的 Node.js 才认识，所以可以用`main`字段来兼容旧版本的 Node.js。
+由于`exports`字段只有支持 ES6 的 Node.js 才认识，所以可以搭配`main`字段，来兼容旧版本的 Node.js。
 
 ```javascript
 {

From 9324fdabefc5a0249a7491fe33dd896ea05c004b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 15 May 2024 13:57:19 +0800
Subject: [PATCH 264/280] =?UTF-8?q?docs(regex):=20=E6=AD=A3=E5=88=99?=
 =?UTF-8?q?=E5=8C=B9=E9=85=8D=20Emoji=20=E5=AD=97=E7=AC=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/regex.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 729eab3c4..87c3410a0 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -464,6 +464,9 @@ regex.test('ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ') // true
 // 匹配所有空格
 \p{White_Space}
 
+// 匹配十六进制字符
+\p{Hex_Digit}
+
 // 匹配各种文字的所有字母，等同于 Unicode 版的 \w
 [\p{Alphabetic}\p{Mark}\p{Decimal_Number}\p{Connector_Punctuation}\p{Join_Control}]
 
@@ -471,7 +474,7 @@ regex.test('ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ') // true
 [^\p{Alphabetic}\p{Mark}\p{Decimal_Number}\p{Connector_Punctuation}\p{Join_Control}]
 
 // 匹配 Emoji
-/\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F/gu
+/\p{Extended_Pictographic}/u
 
 // 匹配所有的箭头字符
 const regexArrows = /^\p{Block=Arrows}+$/u;

From 9c0896c68317e60c3703e69e595fc88a7fca6bfa Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 22 May 2024 12:24:13 +0800
Subject: [PATCH 265/280] =?UTF-8?q?docs(class):=20=E5=88=A0=E9=99=A4?=
 =?UTF-8?q?=E9=94=99=E8=AF=AF=E6=8F=8F=E8=BF=B0=EF=BC=88in=20=E8=BF=90?=
 =?UTF-8?q?=E7=AE=97=E7=AC=A6=E5=88=A4=E6=96=AD=E7=BB=A7=E6=89=BF=E7=9A=84?=
 =?UTF-8?q?=E7=A7=81=E6=9C=89=E5=B1=9E=E6=80=A7=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/class.md | 40 ----------------------------------------
 1 file changed, 40 deletions(-)

diff --git a/docs/class.md b/docs/class.md
index 4a2d53af8..0906a0fe9 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -871,46 +871,6 @@ class A {
 
 上面示例中，私有属性`#foo`没有声明，就直接用于`in`运算符的判断，导致报错。
 
-子类从父类继承的私有属性，也可以使用`in`运算符来判断。
-
-```javascript
-class A {
-  #foo = 0;
-  static test(obj) {
-    console.log(#foo in obj);
-  }
-}
-
-class SubA extends A {};
-
-A.test(new SubA()) // true
-```
-
-上面示例中，`SubA`从父类继承了私有属性`#foo`，`in`运算符也有效。
-
-注意，`in`运算符对于`Object.create()`、`Object.setPrototypeOf`形成的继承，是无效的，因为这种继承不会传递私有属性。
-
-```javascript
-class A {
-  #foo = 0;
-  static test(obj) {
-    console.log(#foo in obj);
-  }
-}
-const a = new A();
-
-const o1 = Object.create(a);
-A.test(o1) // false
-A.test(o1.__proto__) // true
-
-const o2 = {};
-Object.setPrototypeOf(o2, a);
-A.test(o2) // false
-A.test(o2.__proto__) // true
-```
-
-上面示例中，对于修改原型链形成的继承，子类都取不到父类的私有属性，所以`in`运算符无效。
-
 ## 静态块
 
 静态属性的一个问题是，如果它有初始化逻辑，这个逻辑要么写在类的外部，要么写在`constructor()`方法里面。

From 642a4ab3e7954ea391db4709558b91e5b2d777ed Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 8 Jun 2024 18:08:04 +0800
Subject: [PATCH 266/280] docs(array): fixed
 https://github.com/wangdoc/es6-tutorial/issues/22

---
 docs/array.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/docs/array.md b/docs/array.md
index d12d4a38e..e4ed02e8e 100644
--- a/docs/array.md
+++ b/docs/array.md
@@ -881,9 +881,7 @@ sentence.at(100) // undefined
 
 ## 实例方法：toReversed()，toSorted()，toSpliced()，with()
 
-很多数组的传统方法会改变原数组，比如`push()`、`pop()`、`shift()`、`unshift()`等等。数组只要调用了这些方法，它的值就变了。现在有一个[提案](https://github.com/tc39/proposal-change-array-by-copy)，允许对数组进行操作时，不改变原数组，而返回一个原数组的拷贝。
-
-这样的方法一共有四个。
+很多数组的传统方法会改变原数组，比如`push()`、`pop()`、`shift()`、`unshift()`等等。数组只要调用了这些方法，它的值就变了。[ES2023](https://github.com/tc39/proposal-change-array-by-copy)引入了四个新方法，对数组进行操作时，不改变原数组，而返回一个原数组的拷贝。
 
 - `Array.prototype.toReversed() -> Array`
 - `Array.prototype.toSorted(compareFn) -> Array`

From 1a445eca49782ff86ade4aeafb300dfd02015112 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 19 Jul 2024 17:47:06 +0800
Subject: [PATCH 267/280] docs(generator): fixed typo

---
 docs/generator.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/generator.md b/docs/generator.md
index 283b84484..f93604c0b 100644
--- a/docs/generator.md
+++ b/docs/generator.md
@@ -259,7 +259,7 @@ b.next(12) // { value:8, done:false }
 b.next(13) // { value:42, done:true }
 ```
 
-上面代码中，第二次运行`next`方法的时候不带参数，导致 y 的值等于`2 * undefined`（即`NaN`），除以 3 以后还是`NaN`，因此返回对象的`value`属性也等于`NaN`。第三次运行`Next`方法的时候不带参数，所以`z`等于`undefined`，返回对象的`value`属性等于`5 + NaN + undefined`，即`NaN`。
+上面代码中，第二次运行`next`方法的时候不带参数，导致 y 的值等于`2 * undefined`（即`NaN`），除以 3 以后还是`NaN`，因此返回对象的`value`属性也等于`NaN`。第三次运行`next`方法的时候不带参数，所以`z`等于`undefined`，返回对象的`value`属性等于`5 + NaN + undefined`，即`NaN`。
 
 如果向`next`方法提供参数，返回结果就完全不一样了。上面代码第一次调用`b`的`next`方法时，返回`x+1`的值`6`；第二次调用`next`方法，将上一次`yield`表达式的值设为`12`，因此`y`等于`24`，返回`y / 3`的值`8`；第三次调用`next`方法，将上一次`yield`表达式的值设为`13`，因此`z`等于`13`，这时`x`等于`5`，`y`等于`24`，所以`return`语句的值等于`42`。
 

From f6e88af4bd0f5609d1c5bd405fd9750b3e3a5668 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 24 Jul 2024 20:57:35 +0800
Subject: [PATCH 268/280] docs(string-methods): add .toWellFormed()

---
 docs/string-methods.md | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 2fc48b4c8..79520fc9a 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -450,3 +450,38 @@ str.at(-1) // "o"
 如果参数位置超出了字符串范围，`at()`返回`undefined`。
 
 该方法来自数组添加的`at()`方法，目前还是一个第三阶段的提案，可以参考《数组》一章的介绍。
+
+## 实例方法：toWellFormed()
+
+ES2024 引入了新的字符串方法`toWellFormed()`，用来处理 Unicode 的代理字符对问题（surrogates）。
+
+JavaScript 语言内部使用 UTF-16 格式，表示每个字符。UTF-16 只有16位，只能表示码点在`U+0000`到`U+FFFF`之间的 Unicode 字符。对于码点大于`U+FFFF`的 Unicode 字符（即码点大于16位的字符，`U+10000`到`U+10FFFF`），解决办法是使用代理字符对，即用两个 UTF-16 字符组合表示。
+
+具体来说，UTF-16 规定，`U+D800`至`U+DFFF`是空字符段，专门留给代理字符对使用。只要遇到这个范围内的码点，就知道它是代理字符对，本身没有意义，必须两个字符结合在一起解读。其中，前一个字符的范围规定为`0xD800`到`0xDBFF`之间，后一个字符的范围规定为`0xDC00`到`0xDFFF`之间。举例来说，码点`U+1D306`对应的字符为`𝌆`，它写成 UTF-16 就是`0xD834 0xDF06`。
+
+但是，字符串里面可能会出现单个代理字符对，即`U+D800`至`U+DFFF`里面的字符，它没有配对的另一个字符，无法进行解读，导致出现各种状况。
+
+`.toWellFormed()`就是为了解决这个问题，不改变原始字符串，返回一个新的字符串，将原始字符串里面的单个代理字符对，都替换为`U+FFFD`，从而可以在任何正常处理字符串的函数里面使用。
+
+```javascript
+"ab\uD800".toWellFormed() // 'ab�'
+```
+
+上面示例中，`\uD800`是单个的代理字符对，单独使用时没有意义。`toWellFormed()`将这个字符转为`\uFFFD`。
+
+再看下面的例子，`encodeURI()`遇到单个的代理字符对，会报错。
+
+```javascript
+const illFormed = "https://example.com/search?q=\uD800";
+
+encodeURI(illFormed) // 报错
+```
+
+`toWellFormed()`将其转换格式后，再使用`encodeURI()`就不会报错了。
+
+```javascript
+const illFormed = "https://example.com/search?q=\uD800";
+
+encodeURI(illFormed.toWellFormed()) // 正确
+```
+

From cc18cea57c3c96dc562ed5055252c1eb1a152611 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 24 Jul 2024 21:31:02 +0800
Subject: [PATCH 269/280] docs(regex): edit v flag

---
 docs/regex.md | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/docs/regex.md b/docs/regex.md
index 87c3410a0..02f2439ea 100644
--- a/docs/regex.md
+++ b/docs/regex.md
@@ -483,7 +483,7 @@ regexArrows.test('←↑→↓↔↕↖↗↘↙⇏⇐⇑⇒⇓⇔⇕⇖⇗⇘
 
 ## v 修饰符：Unicode 属性类的运算
 
-有时，需要向某个 Unicode 属性类添加或减少字符，即需要对属性类进行运算。现在有一个[提案](https://github.com/tc39/proposal-regexp-v-flag)，增加了 Unicode 属性类的运算功能。
+有时，需要向某个 Unicode 属性类添加或减少字符，即需要对属性类进行运算。[ES2024](https://github.com/tc39/proposal-regexp-v-flag) 增加了 Unicode 属性类的运算功能。
 
 它提供两种形式的运算，一种是差集运算（A 集合减去 B 集合），另一种是交集运算。
 
@@ -516,6 +516,22 @@ regexArrows.test('←↑→↓↔↕↖↗↘↙⇏⇐⇑⇒⇓⇔⇕⇖⇗⇘
 [\p{Emoji}--\p{ASCII}]
 ```
 
+看一个实际的例子，`0`属于十进制字符类。
+
+```javascript
+/[\p{Decimal_Number}]/u.test('0') // true
+```
+
+上面示例中，字符类是 Unicode 专用的，所以必须使用`u`修饰符。
+
+如果把`0-9`从十进制字符类里面去掉，那么`0`就不属于这个类了。
+
+```javascript
+/[\p{Decimal_Number}--[0-9]]/v.test('0') // false
+```
+
+上面示例中，`v`修饰符只能用于 Unicode，所以可以省略`u`修饰符。
+
 ## 具名组匹配
 
 ### 简介

From bdbcf3e520536eff4c58c2920318cc11f1a1c409 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 24 Jul 2024 21:54:13 +0800
Subject: [PATCH 270/280] docs(proposals): edit pipe operator

---
 docs/proposals.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/docs/proposals.md b/docs/proposals.md
index cfa19bc30..2626982b0 100644
--- a/docs/proposals.md
+++ b/docs/proposals.md
@@ -314,6 +314,18 @@ const userAge = userId |> await fetchUserById |> getAgeFromUser;
 const userAge = getAgeFromUser(await fetchUserById(userId));
 ```
 
+管道运算符对多步骤的数据处理，非常有用。
+
+```javascript
+const numbers = [10, 20, 30, 40, 50];
+
+const processedNumbers = numbers
+  |> (_ => _.map(n => n / 2)) // [5, 10, 15, 20, 25]
+  |> (_ => _.filter(n => n > 10)); // [15, 20, 25]
+```
+
+上面示例中，管道运算符可以清晰表达数据处理的每一步，增加代码的可读性。
+
 ## Math.signbit()
 
 JavaScript 内部使用64位浮点数（国际标准 IEEE 754）表示数值。IEEE 754 规定，64位浮点数的第一位是符号位，`0`表示正数，`1`表示负数。所以会有两种零，`+0`是符号位为`0`时的零，`-0`是符号位为`1`时的零。实际编程中，判断一个值是`+0`还是`-0`非常麻烦，因为它们是相等的。

From ff265f79826d9c5447eff0b17a682432386af077 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 25 Jul 2024 14:42:35 +0800
Subject: [PATCH 271/280] docs(set): edit set operator methods

---
 docs/set-map.md | 156 ++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 138 insertions(+), 18 deletions(-)

diff --git a/docs/set-map.md b/docs/set-map.md
index c5fa699ee..4407477bd 100644
--- a/docs/set-map.md
+++ b/docs/set-map.md
@@ -21,7 +21,7 @@ for (let i of s) {
 
 上面代码通过`add()`方法向 Set 结构加入成员，结果表明 Set 结构不会添加重复的值。
 
-`Set`函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化。
+`Set()`函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化。
 
 ```javascript
 // 例一
@@ -88,6 +88,23 @@ set.size // 2
 
 上面代码表示，由于两个空对象不相等，所以它们被视为两个值。
 
+`Array.from()`方法可以将 Set 结构转为数组。
+
+```javascript
+const items = new Set([1, 2, 3, 4, 5]);
+const array = Array.from(items);
+```
+
+这就提供了去除数组重复成员的另一种方法。
+
+```javascript
+function dedupe(array) {
+  return Array.from(new Set(array));
+}
+
+dedupe([1, 1, 2, 3]) // [1, 2, 3]
+```
+
 ### Set 实例的属性和方法
 
 Set 结构的实例有以下属性。
@@ -142,23 +159,6 @@ if (properties.has(someName)) {
 }
 ```
 
-`Array.from()`方法可以将 Set 结构转为数组。
-
-```javascript
-const items = new Set([1, 2, 3, 4, 5]);
-const array = Array.from(items);
-```
-
-这就提供了去除数组重复成员的另一种方法。
-
-```javascript
-function dedupe(array) {
-  return Array.from(new Set(array));
-}
-
-dedupe([1, 1, 2, 3]) // [1, 2, 3]
-```
-
 ### 遍历操作
 
 Set 结构的实例有四个遍历方法，可以用于遍历成员。
@@ -302,6 +302,122 @@ set = new Set(Array.from(set, val => val * 2));
 
 上面代码提供了两种方法，直接在遍历操作中改变原来的 Set 结构。
 
+### 集合运算
+
+[ES2025](https://github.com/tc39/proposal-set-methods) 为 Set 结构添加了以下集合运算方法。
+
+- Set.prototype.intersection(other)：交集
+- Set.prototype.union(other)：并集
+- Set.prototype.difference(other)：差集
+- Set.prototype.symmetricDifference(other)：对称差集
+- Set.prototype.isSubsetOf(other)：判断是否为子集
+- Set.prototype.isSupersetOf(other)：判断是否为超集
+- Set.prototype.isDisjointFrom(other)：判断是否不相交
+
+以上方法的参数都必须是 Set 结构，或者是一个类似于 Set 的结构（拥有`size`属性，以及`keys()`和`has()`方法。
+
+`.union()`是并集运算，返回包含两个集合中存在的所有成员的集合。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const backEnd = new Set(["Python", "Java", "JavaScript"]);
+
+const all = frontEnd.union(backEnd);
+// Set {"JavaScript", "HTML", "CSS", "Python", "Java"}
+```
+
+`.intersection()`是交集运算，返回同时包含在两个集合中的成员的集合。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const backEnd = new Set(["Python", "Java", "JavaScript"]);
+
+const frontAndBackEnd = frontEnd.intersection(backEnd);
+// Set {"JavaScript"}
+```
+
+`.difference()`是差集运算，返回第一个集合中存在但第二个集合中不存在的所有成员的集合。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const backEnd = new Set(["Python", "Java", "JavaScript"]);
+
+const onlyFrontEnd = frontEnd.difference(backEnd);
+// Set {"HTML", "CSS"}
+
+const onlyBackEnd = backEnd.difference(frontEnd);
+// Set {"Python", "Java"}
+```
+
+`.symmetryDifference()`是对称差集，返回两个集合的所有独一无二成员的集合，即去除了重复的成员。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const backEnd = new Set(["Python", "Java", "JavaScript"]);
+
+const onlyFrontEnd = frontEnd.symmetricDifference(backEnd);
+// Set {"HTML", "CSS", "Python", "Java"} 
+
+const onlyBackEnd = backEnd.symmetricDifference(frontEnd);
+// Set {"Python", "Java", "HTML", "CSS"}
+```
+
+注意，返回结果中的成员顺序，由添加到集合的顺序决定。
+
+`.isSubsetOf()`返回一个布尔值，判断第一个集合是否为第二个集合的子集，即第一个集合的所有成员都是第二个集合的成员。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const declarative = new Set(["HTML", "CSS"]);
+
+declarative.isSubsetOf(frontEnd);
+// true
+
+frontEndLanguages.isSubsetOf(declarativeLanguages);
+// false
+```
+
+任何集合都是自身的子集。
+
+```javascript
+frontEnd.isSubsetOf(frontEnd);
+// true
+```
+
+`isSupersetOf()`返回一个布尔值，表示第一个集合是否为第二个集合的超集，即第二个集合的所有成员都是第一个集合的成员。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const declarative = new Set(["HTML", "CSS"]);
+
+declarative.isSupersetOf(frontEnd);
+// false
+
+frontEnd.isSupersetOf(declarative);
+// true
+```
+
+任何集合都是自身的超集。
+
+```javascript
+frontEnd.isSupersetOf(frontEnd);
+// true
+```
+
+`.isDisjointFrom()`判断两个集合是否不相交，即没有共同成员。
+
+```javascript
+const frontEnd = new Set(["JavaScript", "HTML", "CSS"]);
+const interpreted = new Set(["JavaScript", "Ruby", "Python"]);
+const compiled = new Set(["Java", "C++", "TypeScript"]);
+
+interpreted.isDisjointFrom(compiled);
+// true
+
+frontEnd.isDisjointFrom(interpreted);
+// false
+```
+
 ## WeakSet
 
 ### 含义
@@ -1283,3 +1399,7 @@ class Thingy {
 
 由于无法知道清理器何时会执行，所以最好避免使用它。另外，如果浏览器窗口关闭或者进程意外退出，清理器则不会运行。
 
+## 参考链接
+
+- [Union, intersection, difference, and more are coming to JavaScript Sets](https://www.sonarsource.com/blog/union-intersection-difference-javascript-sets/)
+

From 3b89ca42e86442c412d2c95bbcce490717eacd2c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 25 Jul 2024 16:51:38 +0800
Subject: [PATCH 272/280] docs(temporal): add temporal API

---
 docs/temporal.md | 184 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 184 insertions(+)
 create mode 100644 docs/temporal.md

diff --git a/docs/temporal.md b/docs/temporal.md
new file mode 100644
index 000000000..b0a4be452
--- /dev/null
+++ b/docs/temporal.md
@@ -0,0 +1,184 @@
+# Temporal API
+
+Temporal 是一个表示日期时间的全新 API，对目前的 Date API 的诸多问题进行修正。
+
+## Temporal.Now
+
+`Temporal.Now`表示当前系统的准确时间。
+
+- Temporal.Now.instant()- 获取当前系统准确时间
+- Temporal.Now.timeZoneId()- 获取当前系统时区
+- Temporal.Now.zonedDateTimeISO()- 获取系统时区和 ISO-8601 日历中的当前日期和挂钟时间
+- Temporal.Now.plainDateISO()- 获取系统时区和 ISO-8601 日历中的当前日期
+- Temporal.Now.plainTimeISO()- 获取系统时区和 ISO-8601 日历中的当前挂钟时间
+- Temporal.Now.plainDateTimeISO()- 与上面相同，但返回 ISO-8601 日历中的日期时间
+
+```javascript
+// 返回 UTC 的当前时间
+Temporal.Now.instant().toString()
+
+// 返回某个时区的当前日期时间
+Temporal.Now.zonedDateTimeISO('Asia/Shanghai').toString()
+
+// 返回 ISO 格式当前日期时间
+Temporal.Now.plainDateTimeISO().toString()
+
+// 返回 ISO 格式的当前时间，不含日期
+Temporal.Now.plainTimeISO().toString()
+```
+
+下面的例子是获取指定时区的当前时间。
+
+```javascript
+const now = Temporal.Now.zonedDateTimeISO('America/New_York');
+console.log(now.toString());
+```
+
+## Temporal.Instant
+
+`Temporal.Instant`表示某个固定的时间。
+
+```javascript
+const instant = Temporal.Instant.from('1969-07-20T20:17Z');
+instant.toString(); // => '1969-07-20T20:17:00Z'
+instant.epochMilliseconds; // => -14182980000
+```
+
+## Temporal.ZonedDateTime
+
+`Temporal.ZonedDateTime`表示某个时区的时间。
+
+```javascript
+const zonedDateTime = Temporal.ZonedDateTime.from({
+  timeZone: 'America/Los_Angeles',
+  year: 1995,
+  month: 12,
+  day: 7,
+  hour: 3,
+  minute: 24,
+  second: 30,
+  millisecond: 0,
+  microsecond: 3,
+  nanosecond: 500
+}); // => 1995-12-07T03:24:30.0000035-08:00[America/Los_Angeles]
+```
+
+## Temporal.PlainDate
+
+`Temporal.PlainDate`表示与时区无关的日期。
+
+```javascript
+const date = Temporal.PlainDate.from({ year: 2006, month: 8, day: 24 }); // => 2006-08-24
+date.year; // => 2006
+date.inLeapYear; // => false
+date.toString(); // => '2006-08-24'
+```
+
+下面的例子是计算某个日期以后的时间。
+
+```javascript
+const date = Temporal.PlainDate.from('2024-01-01');
+const newDate = date.add({ days: 10 });
+console.log(newDate.toString()); // Outputs '2024-01-11'
+```
+
+## Temporal.PlainTime
+
+`Temporal.PlainTime`表示与时区无关的某个时点。
+
+```javascript
+const time = Temporal.PlainTime.from({
+  hour: 19,
+  minute: 39,
+  second: 9,
+  millisecond: 68,
+  microsecond: 346,
+  nanosecond: 205
+}); // => 19:39:09.068346205time.second; // => 9
+time.toString(); // => '19:39:09.068346205'
+```
+
+## Temporal.PlainDateTime
+
+`Temporal.PlainDateTime`表示时区无关的日期时间。
+
+```javascript
+const dateTime = Temporal.PlainDateTime.from({
+  year: 1995,
+  month: 12,
+  day: 7,
+  hour: 15
+}); // => 1995-12-07T15:00:00
+const dateTime1 = dateTime.with({
+  minute: 17,
+  second: 19
+}); // => 1995-12-07T15:17:19
+```
+
+## Temporal.PlainYearMonth
+
+`Temporal.PlainYearMonth`表示不含日期的年月。
+
+```javascript
+const yearMonth = Temporal.PlainYearMonth.from({ year: 2020, month: 10 }); // => 2020-10
+yearMonth.daysInMonth; // => 31
+yearMonth.daysInYear; // => 366
+```
+
+## Temporal.PlainMonthDay
+
+`Temporal.PlainMonthDay`表示没有年份的月和日。
+
+下面是计算生日的例子。
+
+```javascript
+const birthday = Temporal.PlainMonthDay.from("12-15");
+// 或者写成
+// const birthday = Temporal.PlainMonthDay.from({ month: 12, day: 15 })
+
+const birthdayIn2030 = birthday.toPlainDate({ year: 2030 });
+
+birthdayIn2030.toString() // 2030-12-15
+birthdayIn2030.dayOfWeek // 7
+```
+
+## Temporal.Duration
+
+`Temporal.Duration`表示时长。
+
+```javascript
+const duration = Temporal.Duration.from({
+  hours: 130,
+  minutes: 20
+});
+
+duration.total({ unit: 'second' }); // => 469200
+```
+
+## Temporal.TimeZone
+
+`Temporal.TimeZone`表示某个时区。
+
+```javascript
+const timeZone = Temporal.TimeZone.from('Africa/Cairo');
+timeZone.getInstantFor('2000-01-01T00:00'); // => 1999-12-31T22:00:00Z
+timeZone.getPlainDateTimeFor('2000-01-01T00:00Z'); // => 2000-01-01T02:00:00
+timeZone.getPreviousTransition(Temporal.Now.instant()); // => 2014-09-25T21:00:00Z
+timeZone.getNextTransition(Temporal.Now.instant()); // => null
+```
+
+## Temporal.Calendar
+
+`Temporal.Calendar`表示某个日历系统。
+
+```javascript
+const cal = Temporal.Calendar.from('iso8601');
+const date = cal.dateFromFields({ year: 1999, month: 12, day: 31 }, {});
+date.monthsInYear; // => 12
+date.daysInYear; // => 365
+```
+
+## 参考链接
+
+- [Temporal documentation](https://tc39.es/proposal-temporal/docs/)
+

From 43e44201a8688ab3c0c87f614e7d3c6b19f2d922 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 25 Jul 2024 17:06:22 +0800
Subject: [PATCH 273/280] docs(module): edit import.meta

---
 docs/module.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/docs/module.md b/docs/module.md
index 5d68da67a..207c38306 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -855,3 +855,14 @@ import.meta.scriptElement.dataset.foo
 // "abc"
 ```
 
+**（3）其他**
+
+Deno 现在还支持`import.meta.filename`和`import.meta.dirname`属性，对应 CommonJS 模块系统的`__filename`和`__dirname`属性。
+
+- `import.meta.filename`：当前模块文件的绝对路径。
+- `import.meta.dirname`：当前模块文件的目录的绝对路径。
+
+这两个属性都提供当前平台的正确的路径分隔符，比如 Linux 系统返回`/dev/my_module.ts`，Windows 系统返回`C:\dev\my_module.ts`。
+
+本地模块可以使用这两个属性，远程模块也可以使用。
+

From a434080ef30878f6425585c536501b9aade804ce Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 25 Aug 2024 19:11:48 +0800
Subject: [PATCH 274/280] docs(temporal): edit ZonedTimezome

---
 docs/temporal.md | 72 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 71 insertions(+), 1 deletion(-)

diff --git a/docs/temporal.md b/docs/temporal.md
index b0a4be452..4ce18ad20 100644
--- a/docs/temporal.md
+++ b/docs/temporal.md
@@ -46,7 +46,17 @@ instant.epochMilliseconds; // => -14182980000
 
 ## Temporal.ZonedDateTime
 
-`Temporal.ZonedDateTime`表示某个时区的时间。
+`Temporal.ZonedDateTime`表示某个时区的时间。它会在 ISO8601 的标准格式后面，添加时区后缀和历法后缀。
+
+```javascript
+2020-08-05T20:06:13+09:00[Asia/Tokyo][u-ca=japanese]
+```
+
+上面示例中，`2020-08-05T20:06:13+09:00`是 ISO8601 标准格式，`[Asia/Tokyo]`是时区后缀，`[u-ca=japanese]`是历法后缀，表示采用日本历法。
+
+默认的历法是 ISO8601 规定的公历，可以省略不写。
+
+下面是使用`Temporal.ZonedDateTime.from()`新建 ZonedDateTime 实例对象的例子。
 
 ```javascript
 const zonedDateTime = Temporal.ZonedDateTime.from({
@@ -63,6 +73,65 @@ const zonedDateTime = Temporal.ZonedDateTime.from({
 }); // => 1995-12-07T03:24:30.0000035-08:00[America/Los_Angeles]
 ```
 
+下面是使用`Temporal.ZonedDateTime.compare()`比较两个 ZonedDateTime 实例对象的例子。
+
+```javascript
+const one = Temporal.ZonedDateTime.from('2020-11-01T01:45-07:00[America/Los_Angeles]');
+const two = Temporal.ZonedDateTime.from('2020-11-01T01:15-08:00[America/Los_Angeles]');
+
+Temporal.ZonedDateTime.compare(one, two);
+// -1
+```
+
+上面示例中，`Temporal.ZonedDateTime.compare()`返回`-1`，表示第一个时间小于（即早于）第二个时间。如果返回`1`，表示第一个时间大于第二个时间；返回`0`，表示两个时间相等。
+
+ZonedDateTime 实例对象有以下属性。
+
+- hoursInDay：指定时区的某一天一共有多少个小时，主要用来处理夏令时。
+
+```javascript
+Temporal.ZonedDateTime.from('2020-01-01T12:00-08:00[America/Los_Angeles]').hoursInDay;
+// 24
+Temporal.ZonedDateTime.from('2020-03-08T12:00-07:00[America/Los_Angeles]').hoursInDay;
+// 23
+Temporal.ZonedDateTime.from('2020-11-01T12:00-08:00[America/Los_Angeles]').hoursInDay;
+// 25
+```
+
+- daysInYear
+- inLeapYear
+
+ZonedDateTime 实例对象有以下方法。
+
+- .withTimeZone()：切换时区。
+
+```javascript
+zdt = Temporal.ZonedDateTime.from('1995-12-07T03:24:30+09:00[Asia/Tokyo]');
+zdt.toString(); // => '1995-12-07T03:24:30+09:00[Asia/Tokyo]'
+zdt.withTimeZone('Africa/Accra').toString(); // => '1995-12-06T18:24:30+00:00[Africa/Accra]'
+```
+
+- add()：增加时间。
+
+```javascript
+zdt = Temporal.ZonedDateTime.from('2020-03-08T00:00-08:00[America/Los_Angeles]');
+
+// 增加一天
+laterDay = zdt.add({ days: 1 });
+// 2020-03-09T00:00:00-07:00[America/Los_Angeles]
+// 注意：时区改变了，表示洛杉矶这个日期处于夏令时，比正常情况早一个小时
+
+laterDay.since(zdt, { largestUnit: 'hour' }).hours;
+// 23
+// 当天只有23小时
+
+laterHours = zdt.add({ hours: 24 });
+// 2020-03-09T01:00:00-07:00[America/Los_Angeles]
+laterHours.since(zdt, { largestUnit: 'hour' }).hours; // 24
+```
+
+- .until()：计算两个时间之间的差异。
+
 ## Temporal.PlainDate
 
 `Temporal.PlainDate`表示与时区无关的日期。
@@ -181,4 +250,5 @@ date.daysInYear; // => 365
 ## 参考链接
 
 - [Temporal documentation](https://tc39.es/proposal-temporal/docs/)
+- [JS Dates Are About to Be Fixed](https://docs.timetime.in/blog/js-dates-finally-fixed/)
 

From b7b6c912957ce9809ead933cad9999c1d01ba031 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 24 Sep 2024 22:13:39 +0800
Subject: [PATCH 275/280] docs(number): fixed space style

---
 docs/number.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/number.md b/docs/number.md
index e9904c567..1b3cfbbf0 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -820,7 +820,7 @@ for (let i = 1; i <= 70; i++) {
 console.log(p); // 1.197857166996989e+100
 ```
 
-现在支持大整数了，就可以算了，浏览器的开发者工具运行下面代码，就OK。
+现在支持大整数了，就可以算了，浏览器的开发者工具运行下面代码，就 OK。
 
 ```javascript
 let p = 1n;

From a100783a99259048fbe465638ad1085ffd4631fc Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 25 Dec 2024 10:03:33 +0800
Subject: [PATCH 276/280] docs(object): fixed typo

---
 docs/object.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/object.md b/docs/object.md
index cd817ec1e..8abd76c23 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -783,7 +783,7 @@ actual.cause; // 'Error cause'
 
 上面示例中，生成 Error 实例时，使用描述对象给出`cause`属性，写入报错的原因。然后，就可以从实例对象上读取这个属性。
 
-`casue`属性可以放置任意内容，不必一定是字符串。
+`cause`属性可以放置任意内容，不必一定是字符串。
 
 ```javascript
 try {

From 4c80184abe6d7cea9d1b79a5e837d7eca9dd6b25 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 31 Dec 2024 16:24:06 +0800
Subject: [PATCH 277/280] docs(string-methonds): fixed typo

---
 docs/string-methods.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/string-methods.md b/docs/string-methods.md
index 79520fc9a..1d3e63a8e 100644
--- a/docs/string-methods.md
+++ b/docs/string-methods.md
@@ -421,7 +421,7 @@ String.prototype.replaceAll(searchValue, replacement)
 
 上面例子中，`replaceAll()`的第二个参数是一个函数，该函数的返回值会替换掉所有`b`的匹配。
 
-这个替换函数可以接受多个参数。第一个参数是捕捉到的匹配内容，第二个参数捕捉到是组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置，最后一个参数是原字符串。
+这个替换函数可以接受多个参数。第一个参数是捕捉到的匹配内容，第二个参数是捕捉到的组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置，最后一个参数是原字符串。
 
 ```javascript
 const str = '123abc456';

From 42cd9e36d145bc6ca4a4093238bb9120ca358a36 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 25 Jan 2025 18:55:49 +0800
Subject: [PATCH 278/280] docs(temporal): add text

---
 docs/temporal.md | 70 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 69 insertions(+), 1 deletion(-)

diff --git a/docs/temporal.md b/docs/temporal.md
index 4ce18ad20..e11341192 100644
--- a/docs/temporal.md
+++ b/docs/temporal.md
@@ -2,6 +2,18 @@
 
 Temporal 是一个表示日期时间的全新 API，对目前的 Date API 的诸多问题进行修正。
 
+它有几个核心概念。
+
+- 当前时间：表示此时此刻的时间，位于 Temporal.now 对象。
+- 时点（instant），表示历史上某个唯一时间，其中 Temporal.Instant 对象表示时间戳，Temporal.ZonedDateTime 表示带有时区的日期时间。
+- 时钟时间（wall-clock times），表示本地时间，包含以下几个对象，不涉及时区。
+    - Temporal.PlainDateTime：完整的日期和时间。
+    - Temporal.PlainDate：仅限于日期。
+    - Temporal.PlainYearMonth：仅限于年月。
+    - Temporal.PlainMonthDay：仅限于月和日。
+    - Temporal.PlainTime：不包含日期的时间。
+- 持续时间（durations），表示两个时间点之间的差异，位于 Temporal.Duration 对象。
+
 ## Temporal.Now
 
 `Temporal.Now`表示当前系统的准确时间。
@@ -17,6 +29,12 @@ Temporal 是一个表示日期时间的全新 API，对目前的 Date API 的诸
 // 返回 UTC 的当前时间
 Temporal.Now.instant().toString()
 
+// 系统时区的当前时间
+Temporal.Now.plainDateTimeISO() // 2025-01-22T11:46:36.144
+
+// 当前时间对应 America/New_York 时区的时间
+Temporal.Now.plainDateTimeISO("America/New_York") // 2025-01-22T05:47:02.555
+
 // 返回某个时区的当前日期时间
 Temporal.Now.zonedDateTimeISO('Asia/Shanghai').toString()
 
@@ -34,14 +52,25 @@ const now = Temporal.Now.zonedDateTimeISO('America/New_York');
 console.log(now.toString());
 ```
 
+下面的例子是获取当前时间对应的农历年。
+
+```javascript
+const currentYear = Temporal.Now.plainDateISO().withCalendar("chinese").year;
+```
+
 ## Temporal.Instant
 
-`Temporal.Instant`表示某个固定的时间。
+`Temporal.Instant`表示某个固定的时点。
 
 ```javascript
 const instant = Temporal.Instant.from('1969-07-20T20:17Z');
 instant.toString(); // => '1969-07-20T20:17:00Z'
 instant.epochMilliseconds; // => -14182980000
+
+// 某个 Unix 时间戳对应的时点
+const launch = Temporal.Instant.fromEpochMilliseconds(1851222399924);
+const now = Temporal.Now.instant();
+const duration = now.until(launch, { smallestUnit: "hour" });
 ```
 
 ## Temporal.ZonedDateTime
@@ -211,6 +240,27 @@ birthdayIn2030.toString() // 2030-12-15
 birthdayIn2030.dayOfWeek // 7
 ```
 
+下面是农历一月一日（大年初一）的例子。
+
+```javascript
+const chineseNewYear = Temporal.PlainMonthDay.from({
+  monthCode: "M01",
+  day: 1,
+  calendar: "chinese",
+});
+
+const currentYear = Temporal.Now.plainDateISO().withCalendar("chinese").year;
+
+// 获取下一个春节
+let nextCNY = chineseNewYear.toPlainDate({ year: currentYear });
+// 如果 nextCNY 早于当前时间，则向后移动一年
+if (Temporal.PlainDate.compare(nextCNY, Temporal.Now.plainDateISO()) <= 0) {
+  nextCNY = nextCNY.add({ years: 1 });
+}
+
+nextCNY.withCalendar("iso8601").toLocaleString() // 1/29/2025
+```
+
 ## Temporal.Duration
 
 `Temporal.Duration`表示时长。
@@ -247,8 +297,26 @@ date.monthsInYear; // => 12
 date.daysInYear; // => 365
 ```
 
+## Temporal.Duration
+
+Temporal.Duration 表示一个持续的时间对象。
+
+```javascript
+const durations = [
+  Temporal.Duration.from({ hours: 1 }),
+  Temporal.Duration.from({ hours: 2 }),
+  Temporal.Duration.from({ hours: 1, minutes: 30 }),
+  Temporal.Duration.from({ hours: 1, minutes: 45 }),
+];
+
+durations.sort(Temporal.Duration.compare);
+console.log(durations.map((d) => d.toString()));
+// [ 'PT1H', 'PT1H30M', 'PT1H45M', 'PT2H' ]
+````
+
 ## 参考链接
 
 - [Temporal documentation](https://tc39.es/proposal-temporal/docs/)
 - [JS Dates Are About to Be Fixed](https://docs.timetime.in/blog/js-dates-finally-fixed/)
+- [JavaScript Temporal is coming](https://developer.mozilla.org/en-US/blog/javascript-temporal-is-coming/)
 

From cbbf9ac29642351144759ea980e2cbe3c9f02fc2 Mon Sep 17 00:00:00 2001
From: zihua <63008995+zihua-1022@users.noreply.github.com>
Date: Sat, 22 Feb 2025 19:50:26 +0800
Subject: [PATCH 279/280] Update promise.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

console.log的输出和展示结果不一致
---
 docs/promise.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/promise.md b/docs/promise.md
index ee6a7aab8..758bb2edd 100644
--- a/docs/promise.md
+++ b/docs/promise.md
@@ -79,7 +79,7 @@ let promise = new Promise(function(resolve, reject) {
 });
 
 promise.then(function() {
-  console.log('resolved.');
+  console.log('resolved');
 });
 
 console.log('Hi!');

From 17d58f73020a85288f110da44f9f5ad090373e9d Mon Sep 17 00:00:00 2001
From: Chuck Lau <liuchao_huoguo@163.com>
Date: Sun, 27 Apr 2025 13:52:02 +0800
Subject: [PATCH 280/280] docs: fix typo in reference.md

---
 docs/reference.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/reference.md b/docs/reference.md
index bb3f87c71..359d045b1 100644
--- a/docs/reference.md
+++ b/docs/reference.md
@@ -184,7 +184,7 @@
 
 ## 异步操作和 Async 函数
 
-- Luke Hoban, [Async Functions for ECMAScript](https://github.com/lukehoban/ecmascript-asyncawait): Async 函数的设计思想，与 Promise、Gernerator 函数的关系
+- Luke Hoban, [Async Functions for ECMAScript](https://github.com/lukehoban/ecmascript-asyncawait): Async 函数的设计思想，与 Promise、Generator 函数的关系
 - Jafar Husain, [Asynchronous Generators for ES7](https://github.com/jhusain/asyncgenerator): Async 函数的深入讨论
 - Nolan Lawson, [Taming the asynchronous beast with ES7](http://pouchdb.com/2015/03/05/taming-the-async-beast-with-es7.html): async 函数通俗的实例讲解
 - Jafar Husain, [Async Generators](https://docs.google.com/file/d/0B4PVbLpUIdzoMDR5dWstRllXblU/view?sle=true): 对 async 与 Generator 混合使用的一些讨论