diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index fe2a9905b4..c149b7899f 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -272,9 +272,9 @@ typeof alert // "function"  (3)
 
 ## 总结
 
-JavaScript 中有八种基本的数据类型（译注：前七种为基本数据类型，也称为原始数据类型，而 `object` 为复杂数据类型）。
+JavaScript 中有八种基本的数据类型。
 
-- 七种原始数据类型：
+- 七种原始数据类型（基本数据类型）：
     - `number` 用于任何类型的数字：整数或浮点数，在 <code>±(2<sup>53</sup>-1)</code> 范围内的整数。
     - `bigint` 用于任意长度的整数。
     - `string` 用于字符串：一个字符串可以包含 0 个或多个字符，所以没有单独的单字符类型。
@@ -282,7 +282,7 @@ JavaScript 中有八种基本的数据类型（译注：前七种为基本数据
     - `null` 用于未知的值 —— 只有一个 `null` 值的独立类型。
     - `undefined` 用于未定义的值 —— 只有一个 `undefined` 值的独立类型。
     - `symbol` 用于唯一的标识符。
-- 以及一种非原始数据类型：
+- 以及一种非原始数据类型（复杂数据类型）：
     - `object` 用于更复杂的数据结构。
 
 我们可以通过 `typeof` 运算符查看存储在变量中的数据类型。
diff --git a/1-js/09-classes/03-static-properties-methods/article.md b/1-js/09-classes/03-static-properties-methods/article.md
index 400e76093d..0d56ea6ce5 100644
--- a/1-js/09-classes/03-static-properties-methods/article.md
+++ b/1-js/09-classes/03-static-properties-methods/article.md
@@ -1,7 +1,7 @@
 
 # 静态属性和静态方法
 
-我们可以把一个方法作为一个整体赋值给类。这样的方法被称为 **静态的（static）**。
+我们也可以把一个方法赋值给一整个类。这样的方法被称为 **静态的（static）**。
 
 在一个类的声明中，它们以 `static` 关键字开头，如下所示：
 
diff --git a/1-js/09-classes/05-extend-natives/article.md b/1-js/09-classes/05-extend-natives/article.md
index c81b0b31cb..121970d71e 100644
--- a/1-js/09-classes/05-extend-natives/article.md
+++ b/1-js/09-classes/05-extend-natives/article.md
@@ -32,7 +32,7 @@ arr.constructor === PowerArray
 
 甚至，我们可以定制这种行为。
 
-我们可以给这个类添加一个特殊的静态 getter `Symbol.species`。如果存在，则应返回 JavaScript 在内部用来在 `map` 和 `filter` 等方法中创建新实体的 `constructor`。
+我们可以给这个类添加一个特殊的静态 getter `Symbol.species`，它会返回 JavaScript 在内部用来在 `map` 和 `filter` 等方法中创建新实体的 `constructor`。
 
 如果我们希望像 `map` 或 `filter` 这样的内建方法返回常规数组，我们可以在 `Symbol.species` 中返回 `Array`，就像这样：
 
diff --git a/1-js/09-classes/07-mixins/article.md b/1-js/09-classes/07-mixins/article.md
index 6ce70767cc..38a8abd747 100644
--- a/1-js/09-classes/07-mixins/article.md
+++ b/1-js/09-classes/07-mixins/article.md
@@ -2,13 +2,13 @@
 
 在 JavaScript 中，我们只能继承单个对象。每个对象只能有一个 `[[Prototype]]`。并且每个类只可以扩展另外一个类。
 
-但是有些时候这种设定（译注：单继承）会让人感到受限制。例如，我有一个 `StreetSweeper` 类和一个 `Bicycle` 类，现在想要一个它们的 mixin：`StreetSweepingBicycle` 类。
+但是有些时候这种设定（译注：单继承）会让人感到受限制。例如，我有一个 `StreetSweeper` 类和一个 `Bicycle` 类，现在想要一个它们的混合体：`StreetSweepingBicycle` 类。
 
 或者，我们有一个 `User` 类和一个 `EventEmitter` 类来实现事件生成（event generation），并且我们想将 `EventEmitter` 的功能添加到 `User` 中，以便我们的用户可以触发事件（emit event）。
 
-有一个概念可以帮助我们，叫做 "mixins"。
+有一个概念可以帮助我们，叫做 "mixin"。
 
-根据维基百科的定义，[mixin](https://en.wikipedia.org/wiki/Mixin) 是一个包含可被其他类使用而无需继承的方法的类。
+根据维基百科的定义，[mixin](https://en.wikipedia.org/wiki/Mixin) 是一个类，其方法可被其他类使用，而无需继承。
 
 换句话说，*mixin* 提供了实现特定行为的方法，但是我们不单独使用它，而是使用它来将这些行为添加到其他类中。
 
@@ -47,7 +47,7 @@ Object.assign(User.prototype, sayHiMixin);
 new User("Dude").sayHi(); // Hello Dude!
 ```
 
-这里没有继承，只有一个简单的方法拷贝。所以 `User` 可以从另一个类继承，还可以包括 mixin 来 "mix-in“ 其它方法，就像这样：
+这里没有继承，只有一个简单的方法拷贝。因此，我们可以让 `User` 在继承另一个类的同时，使用 mixin 来 "mix-in"（混合）其它方法，就像这样：
 
 ```js
 class User extends Person {
diff --git a/1-js/10-error-handling/1-try-catch/article.md b/1-js/10-error-handling/1-try-catch/article.md
index 5bdc6d49a5..744c079a7b 100644
--- a/1-js/10-error-handling/1-try-catch/article.md
+++ b/1-js/10-error-handling/1-try-catch/article.md
@@ -489,7 +489,7 @@ try {
 1. 如果你对于 "Make an error?" 的回答是 "Yes"，那么执行 `try -> catch -> finally`。
 2. 如果你的回答是 "No"，那么执行 `try -> finally`。
 
-`finally` 子句（clause）通常用在：当我们开始做某事的时候，希望无论出现什么情况都要完成完成某个任务。
+`finally` 子句（clause）通常用在：当我们开始做某事的时候，希望无论出现什么情况都要完成某个任务。
 
 例如，我们想要测量一个斐波那契数字函数 `fib(n)` 执行所需要花费的时间。通常，我们可以在运行它之前开始测量，并在运行完成时结束测量。但是，如果在该函数调用期间出现 error 该怎么办？特别是，下面这段 `fib(n)` 的实现代码在遇到负数或非整数数字时会返回一个 error。
 
@@ -565,7 +565,7 @@ alert( func() ); // 先执行 finally 中的 alert，然后执行这个 alert
 
 ````smart header="`try...finally`"
 
-没有 `catch` 子句的 `try...finally` 结构也很有用。当我们不想在这儿处理 error（让它们 fall through），但是需要确保我们启动的处理需要被完成。
+没有 `catch` 子句的 `try...finally` 结构也很有用。当我们不想在原地处理 error（让它们掉出去吧），但是需要确保我们启动的处理需要被完成时，我们应当使用它。
 
 ```js
 function func() {
@@ -662,7 +662,7 @@ try {
 
 Error 对象包含下列属性：
 
-- `message` _ 人类可读的 error 信息。
+- `message` —— 人类可读的 error 信息。
 - `name` —— 具有 error 名称的字符串（Error 构造器的名称）。
 - `stack`（没有标准，但得到了很好的支持）—— Error 发生时的调用栈。
 
diff --git a/1-js/10-error-handling/2-custom-errors/article.md b/1-js/10-error-handling/2-custom-errors/article.md
index ac80c7d102..e25dfe3b74 100644
--- a/1-js/10-error-handling/2-custom-errors/article.md
+++ b/1-js/10-error-handling/2-custom-errors/article.md
@@ -23,7 +23,7 @@ let json = `{ "name": "John", "age": 30 }`;
 
 我们的 `ValidationError` 类应该继承自 `Error` 类。
 
-`Error` 类是内建的，但这是其近似代码，所以我们可以了解我们要扩展的内容：
+`Error` 类是内建的，但我们可以通过下面这段近似代码理解我们要扩展的内容：
 
 ```js
 // JavaScript 自身定义的内建的 Error 类的“伪代码”
@@ -36,7 +36,7 @@ class Error {
 }
 ```
 
-现在让我们从其中继承 `ValidationError`，并尝试进行运行：
+现在让我们从其中继承 `ValidationError` 试一试：
 
 ```js run untrusted
 *!*
diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index abc233e45a..6899f32be8 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -10,7 +10,7 @@
 但是，我们会尽全力使讲解变得更加清晰。在这儿不会有浏览器方面的真正复杂的东西。
 ```
 
-JavaScript 主机（host）环境提供了许多函数，这些函数允许我们计划 **异步** 行为（action）。换句话说，我们现在开始执行的行为，但它们会在稍后完成。
+JavaScript 主机（host）环境提供了许多函数，这些函数允许我们计划 **异步** 行为（action）—— 也就是在我们执行一段时间后才自行完成的行为。
 
 例如，`setTimeout` 函数就是一个这样的函数。
 
diff --git a/1-js/11-async/02-promise-basics/article.md b/1-js/11-async/02-promise-basics/article.md
index 675ec81431..ac1acc70cf 100644
--- a/1-js/11-async/02-promise-basics/article.md
+++ b/1-js/11-async/02-promise-basics/article.md
@@ -83,7 +83,7 @@ let promise = new Promise(function(resolve, reject) {
 
 与最初的 "pending" promise 相反，一个 resolved 或 rejected 的 promise 都会被称为 "settled"。
 
-````smart header="这只能有一个结果或一个 error"
+````smart header="只有一个结果或一个 error"
 executor 只能调用一个 `resolve` 或一个 `reject`。任何状态的更改都是最终的。
 
 所有其他的再对 `resolve` 和 `reject` 的调用都会被忽略：
@@ -99,7 +99,7 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-这的宗旨是，一个被 executor 完成的工作只能有一个结果或一个 error。
+关键就在于，一个由 executor 完成的工作只能有一个结果或一个 error。
 
 并且，`resolve/reject` 只需要一个参数（或不包含任何参数），并且将忽略额外的参数。
 ````
@@ -118,7 +118,7 @@ let promise = new Promise(function(resolve, reject) {
 });
 ```
 
-例如，当我们开始做一个任务时，但随后看到一切都已经完成并已被缓存时，可能就会发生这种情况。
+例如，当我们开始做一个任务，随后发现一切都已经完成并已被缓存时，可能就会发生这种情况。
 
 这挺好。我们立即就有了一个 resolved 的 promise。
 ````
@@ -294,7 +294,7 @@ new Promise((resolve, reject) => {
 // 下面这 promise 在被创建后立即变为 resolved 状态
 let promise = new Promise(resolve => resolve("done!"));
 
-promise.then(alert); // done!（现在显示）
+promise.then(alert); // done!（立刻显示）
 ```
 
 请注意这使得 promise 比现实生活中的“订阅列表”方案强大得多。如果歌手已经发布了他们的单曲，然后某个人在订阅列表上进行了注册，则他们很可能不会收到该单曲。实际生活中的订阅必须在活动开始之前进行。
@@ -357,7 +357,7 @@ promise.then(script => alert('Another handler...'));
 
 | promise | callback |
 |----------|-----------|
-| promise 允许我们按照自然顺序进行编码。首先，我们运行 `loadScript` 和 `.then` 来处理结果。| 在调用 `loadScript(script, callback)` 时，我们必须有一个 `callback` 函数可供使用。换句话说，在调用 `loadScript` **之前**，我们必须知道如何处理结果。|
+| promise 允许我们按照自然顺序进行编码。首先，我们运行 `loadScript`，之后，用 `.then` 来处理结果。| 在调用 `loadScript(script, callback)` 时，我们必须有一个 `callback` 函数可供使用。换句话说，在调用 `loadScript` **之前**，我们必须知道如何处理结果。|
 | 我们可以根据需要，在 promise 上多次调用 `.then`。每次调用，我们都会在“订阅列表”中添加一个新的“粉丝”，一个新的订阅函数。在下一章将对此内容进行详细介绍：[](info:promise-chaining)。 | 只能有一个回调。|
 
 
diff --git a/1-js/11-async/05-promise-api/article.md b/1-js/11-async/05-promise-api/article.md
index 9fdaa2d57e..1b5599601f 100644
--- a/1-js/11-async/05-promise-api/article.md
+++ b/1-js/11-async/05-promise-api/article.md
@@ -131,10 +131,10 @@ Promise.all([
 ]).then(render); // render 方法需要所有 fetch 的数据
 ```
 
-`Promise.allSettled` 等待所有的 promise 都被 settle，无论结果如何。结果数组具有：
+`Promise.allSettled` 等待所有的 promise 都被 settle，无论结果如何。结果数组会是这样的：
 
-- `{status:"fulfilled", value:result}` 对于成功的响应，
-- `{status:"rejected", reason:error}` 对于 error。
+- 对成功的响应，结果数组对应元素的内容为 `{status:"fulfilled", value:result}`，
+- 对出现 error 的响应，结果数组对应元素的内容为 `{status:"rejected", reason:error}`。
 
 例如，我们想要获取（fetch）多个用户的信息。即使其中一个请求失败，我们仍然对其他的感兴趣。