diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
index 8187494aa3..b5045febb5 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md
@@ -9,27 +9,28 @@ dashedName: access-array-data-with-indexes
 
 # --description--
 
-我们可以使用索引 `indexes` 来访问数组中的数据。
+我们可以使用索引（`indexes`）来访问数组中的数据。
+
+数组索引与字符串索引都需要通过方括号表示法使用。区别仅仅在于，字符串通过索引会得到一个字符，而数组通过索引得到的是一个元素。数组索引与字符串索引一样是从 0 开始的，所以数组中第一个元素的索引是 `0`。  
 
-数组索引与字符串索引一样使用中括号，但字符串索引得到的是一个字符，而数组索引得到的是一个元素。数组索引与字符串索引一样是从 0 开始的，所以数组中第一个元素的索引编号是 0。  
 **示例**
 
 ```js
 var array = [50,60,70];
-array[0]; // equals 50
-var data = array[1];  // equals 60
+array[0]; // 返回 50
+var data = array[1];  // 值为 60
 ```
 
-**提示**  
-数组名称和方括号之间不应有任何空格，如`array [0]`尽管 JavaScript 能够正确处理，但可能会让看你代码的其他程序员感到困惑
+**注意**  
+数组名与方括号之间不应有空格，不推荐像是 `array [0]` 的写法。尽管 JavaScript 能够正确处理，但可能会让其他人感到困惑。
 
 # --instructions--
 
-创建一个名为`myData`的变量，并把`myArray`的第一个索引上的值赋给它。
+创建一个名为 `myData` 的变量，并把 `myArray` 的第一个值赋给它。
 
 # --hints--
 
-变量`myData`的值应该等于`myArray`的第一个值。
+变量 `myData` 的值应为 `myArray` 中的第一个元素值。
 
 ```js
 assert(
@@ -47,7 +48,7 @@ assert(
 );
 ```
 
-应使用方括号访问变量`myArray`中的数据。
+应使用方括号表示法访问变量 `myArray` 中的元素。
 
 ```js
 assert(
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md
index f70ffd5347..01bb076ab8 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md
@@ -9,7 +9,7 @@ dashedName: access-multi-dimensional-arrays-with-indexes
 
 # --description--
 
-可以把 <dfn>多维</dfn> 数组看作成是一个 *数组中的数组*。当使用方括号去访问数组的时候，第一个`[index]`访问的是第 N 个子数组，第二个`[index]`访问的是第 N 个子数组的第N个元素。
+我们可以把<dfn>多维</dfn>数组看作成是*数组中的数组*。使用方括号表示法访问数组时，第一个方括号访问的是数组的第一层，第二个方括号访问的是数组的第二层，以此类推。
 
 **示例**
 
@@ -20,27 +20,27 @@ var arr = [
   [7,8,9],
   [[10,11,12], 13, 14]
 ];
-arr[3]; // equals [[10,11,12], 13, 14]
-arr[3][0]; // equals [10,11,12]
-arr[3][0][1]; // equals 11
+arr[3]; // 返回 [[10,11,12], 13, 14]
+arr[3][0]; // 返回 [10,11,12]
+arr[3][0][1]; // 返回 11
 ```
 
-**提示**  
-数组名称和方括号之间不应该有任何空格，如`array [0][0]`，甚至`array [0][0]`，都是不正确的。尽管 JavaScript 能够处理，但可能会让看你代码的其他程序员感到困惑。
+**注意**  
+数组名与方括号之间不应有空格，不推荐像是 `array [0][0]` 或 `array [0] [0]` 的写法。尽管 JavaScript 能够正确处理，但可能会让其他人感到困惑。
 
 # --instructions--
 
-使用索引从`myArray`选择一个元素，使得`myData`的值为`8`。
+使用方括号表示法从 `myArray` 中读取元素，使得 `myData` 的值为 `8`。
 
 # --hints--
 
-`myData`应该等于`8`。
+`myData` 的值应为 `8`。
 
 ```js
 assert(myData === 8);
 ```
 
-你应该使用方括号从`myArray`中取值。
+应使用方括号表示法从 `myArray` 中取值。
 
 ```js
 assert(
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
index f9995b4a66..3121dec2bb 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md
@@ -9,9 +9,9 @@ dashedName: accessing-nested-arrays
 
 # --description--
 
-正如我们在前面的例子所见，对象可以嵌套对象和数组。与访问嵌套对象一样，用中括号操作符同样可以访问嵌套数组。
+在之前的挑战中，我们学习了在对象中嵌套对象和数组。与访问嵌套的对象一样，我们可以用方括号表示法来访问嵌套数组。
 
-下面是如何访问嵌套数组的例子：
+下面是访问嵌套数组的例子：
 
 ```js
 var ourPets = [
@@ -38,17 +38,17 @@ ourPets[1].names[0]; // "Spot"
 
 # --instructions--
 
-使用点操作符和中括号操作符来检索变量`myPlants`的第二棵树。
+请使用点号表示法和方括号表示法来检索变量 `myPlants` 中的第二棵树，即返回 `type` 为 `trees` 的数组中的第二个元素。
 
 # --hints--
 
-`secondTree`应该等于 "pine"。
+`secondTree` 的值应为 "pine"。
 
 ```js
 assert(secondTree === 'pine');
 ```
 
-使用点操作符和中括号操作符来检索变量`myPlants`。
+应使用点号表示法和方括号表示法来检索变量 `myPlants`。
 
 ```js
 assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
index a1392c230a..3d1a48c39b 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md
@@ -9,9 +9,9 @@ dashedName: accessing-nested-objects
 
 # --description--
 
-通过串联起来的点操作符或中括号操作符来访问对象的嵌套属性。
+我们可以通过连续使用点号表示法和方括号表示法来访问对象的嵌套属性。
 
-下面是一个嵌套的对象：
+这是一个访问嵌套对象的示例：
 
 ```js
 var ourStorage = {
@@ -32,17 +32,17 @@ ourStorage.desk.drawer; // "stapler"
 
 # --instructions--
 
-读取`myStorage`对象，将`glove box`属性的内容赋值给变量`gloveBoxContents`。在适用的地方使用点操作符来访问属性，否则使用中括号操作符。
+请把 `myStorage` 对象中 `glove box` 的属性值赋给变量 `gloveBoxContents`。请优先使用点号表示法来访问属性；对于点号表示法不能处理的情况，再考虑使用方括号表示法。
 
 # --hints--
 
-`gloveBoxContents`应该等于"maps"。
+`gloveBoxContents` 的值应为 "maps"。
 
 ```js
 assert(gloveBoxContents === 'maps');
 ```
 
-应使用点操作符和中括号操作符来访问`myStorage`。
+应使用点号表示法和方括号表示法来访问 `myStorage`。
 
 ```js
 assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
index cf3b0688fd..61f4ed1376 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244c8
-title: 通过方括号访问对象属性
+title: 通过方括号表示法访问对象属性
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cBvmEHP'
 forumTopicId: 16163
@@ -9,11 +9,11 @@ dashedName: accessing-object-properties-with-bracket-notation
 
 # --description--
 
-第二种访问对象的方式就是中括号操作符(`[]`)，如果你想访问的属性的名称有一个空格，这时你只能使用中括号操作符(`[]`)。
+访问对象的第二种方式是方括号表示法（`[]`）。如果你想访问的属性名中包含空格，就必须使用方括号表示法来获取它的属性值。
 
-当然，如果属性名不包含空格，也可以使用中括号操作符。
+当然，如果属性名不包含空格，我们也可以使用方括号表示法。
 
-这是一个使用中括号操作符(`[]`)读取对象属性的例子：
+这是一个使用方括号表示法（`[]`）读取对象属性的例子：
 
 ```js
 var myObj = {
@@ -26,39 +26,39 @@ myObj['More Space']; // Spock
 myObj["NoSpace"];    // USS Enterprise
 ```
 
-提示：属性名称中如果有空格，必须把属性名称用单引号或双引号包裹起来。
+注意，属性名中如果包含空格，就必须把属性名称用单引号或双引号包裹起来。
 
 # --instructions--
 
-用中括号操作符读取对象`testObj`的`an entree`属性值和`the drink`属性值，并分别赋值给`entreeValue`和`drinkValue`。
+请使用方括号表示法读取对象 `testObj` 中 `an entree` 和 `the drink` 的属性值，并分别赋值给 `entreeValue` 和 `drinkValue`。
 
 # --hints--
 
-`entreeValue`应该是一个字符串。
+`entreeValue` 应为一个字符串。
 
 ```js
 assert(typeof entreeValue === 'string');
 ```
 
-`entreeValue`的值应该是`"hamburger"`。
+`entreeValue` 的值应为 `"hamburger"`。
 
 ```js
 assert(entreeValue === 'hamburger');
 ```
 
-`drinkValue`应该是一个字符串。
+`drinkValue` 应为一个字符串。
 
 ```js
 assert(typeof drinkValue === 'string');
 ```
 
-`drinkValue`的值应该是`"water"`。
+`drinkValue` 的值应为 `"water"`。
 
 ```js
 assert(drinkValue === 'water');
 ```
 
-你应该使用中括号两次。
+你应使用两次方括号表示法。
 
 ```js
 assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
index 20da020a7e..3c8eb1bfc5 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244c7
-title: 通过点符号访问对象属性
+title: 通过点号表示法访问对象属性
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cGryJs8'
 forumTopicId: 16164
@@ -9,11 +9,11 @@ dashedName: accessing-object-properties-with-dot-notation
 
 # --description--
 
-有两种方式访问对象属性，一个是点操作符(`.`)，一个是中括号操作符(`[]`)。
+访问对象属性有两种方式：点号表示法（`.`）和方括号表示法（`[]`）。
 
-当你知道所要读取的属性的名称的时候，使用点操作符。
+如果我们已经提前知道要访问的属性名，使用点号表示法是最方便的。
 
-这是一个使用点操作符读取对象属性的例子：
+以下是使用点号表示法读取对象属性的例子：
 
 ```js
 var myObj = {
@@ -26,35 +26,35 @@ var prop2val = myObj.prop2; // val2
 
 # --instructions--
 
-通过点操作符读取对象`testObj`，把`hat`的属性值赋给变量`hatValue`，把`shirt`的属性值赋给`shirtValue`。
+请使用点号表示法读取对象 `testObj`，把 `hat` 的属性值赋给变量 `hatValue`，把 `shirt` 的属性值赋给 `shirtValue`。
 
 # --hints--
 
-`hatValue`应该是一个字符串。
+`hatValue` 应为一个字符串。
 
 ```js
 assert(typeof hatValue === 'string');
 ```
 
-`hatValue`的值应该是`"ballcap"`。
+`hatValue` 的值应为 `"ballcap"`。
 
 ```js
 assert(hatValue === 'ballcap');
 ```
 
-`shirtValue`应该是一个字符串。
+`shirtValue` 应为一个字符串。
 
 ```js
 assert(typeof shirtValue === 'string');
 ```
 
-`shirtValue`的值应该是`"jersey"`。
+`shirtValue` 的值应为 `"jersey"`。
 
 ```js
 assert(shirtValue === 'jersey');
 ```
 
-你应该使用点操作符两次。
+你应使用两次点号表示法。
 
 ```js
 assert(code.match(/testObj\.\w+/g).length > 1);
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
index 87b9013ec2..e888e6820a 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md
@@ -9,9 +9,9 @@ dashedName: accessing-object-properties-with-variables
 
 # --description--
 
-中括号操作符的另一个使用方式是访问赋值给变量的属性。当你需要遍历对象的属性列表或访问查找表（lookup tables）时，这种方式极为有用。
+方括号表示法的另一个用途就是访问一个存储在变量中的值所对应的属性值。当你需要遍历对象的所有属性，或者根据一个变量的值查找对应的属性值时，这种写法尤其适用。
 
-这有一个使用变量来访问属性的例子：
+以下是一个使用变量来访问属性的例子：
 
 ```js
 var dogs = {
@@ -22,7 +22,7 @@ var myBreed = dogs[myDog];
 console.log(myBreed); // "Doberman"
 ```
 
-使用此概念的另一种方法是在程序执行期间动态收集属性名称，如下所示：
+使用此写法的另一种场景是程序执行期间所动态获取的属性名称，如下所示：
 
 ```js
 var someObj = {
@@ -32,49 +32,49 @@ function propPrefix(str) {
   var s = "prop";
   return s + str;
 }
-var someProp = propPrefix("Name"); // someProp now holds the value 'propName'
+var someProp = propPrefix("Name"); // someProp 的值现在是 'propName'
 console.log(someObj[someProp]); // "John"
 ```
 
-提示：当我们通过变量名访问属性的时候，不需要给变量名包裹引号。因为实际上我们使用的是变量的值，而不是变量的名称。
+注意，当我们通过变量名访问属性时，不需要给变量名包裹引号。因为我们实际需要获取的是变量的值，而不是变量的名称。
 
 # --instructions--
 
-使用变量`playerNumber`，通过中括号操作符找到`testObj`中`playerNumber`为`16`的值。然后把名字赋给变量`player`。
+首先，请将 `playerNumber` 的值设置为 `16`。然后通过 `playerNumber` 变量，使用方括号表示法获取 `testObj` 中 `16` 的属性值，然后把这个属性值赋给变量 `player`。
 
 # --hints--
 
-`playerNumber`应该是一个数字。
+`playerNumber` 应为一个数字。
 
 ```js
 assert(typeof playerNumber === 'number');
 ```
 
-变量`player`应该是一个字符串。
+`player` 应为一个字符串。
 
 ```js
 assert(typeof player === 'string');
 ```
 
-`player`点值应该是 "Montana"。
+`player` 的值应为 "Montana"。
 
 ```js
 assert(player === 'Montana');
 ```
 
-你应该使用中括号访问`testObj`。
+应使用方括号表示法访问 `testObj`。
 
 ```js
 assert(/testObj\s*?\[.*?\]/.test(code));
 ```
 
-你不应该直接将`Montana`赋给`player`。
+不应直接将 `Montana` 赋值给 `player`。
 
 ```js
 assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
 ```
 
-你应该在中括号中使用`playerNumber`变量。
+应在中括号里使用 `playerNumber` 变量。
 
 ```js
 assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
index 8441bb8693..eb971fae59 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md
@@ -11,7 +11,7 @@ dashedName: add-new-properties-to-a-javascript-object
 
 你也可以像更改属性一样给对象添加属性。
 
-看看我们是如何给`ourDog`添加`"bark"`属性：
+我们可以像这样给 `ourDog` 添加 `"bark"` 属性：
 
 `ourDog.bark = "bow-wow";`
 
@@ -19,21 +19,34 @@ dashedName: add-new-properties-to-a-javascript-object
 
 `ourDog["bark"] = "bow-wow";`
 
-现在当我们访问`ourDog.bark`时会得到 ourDog 的 bark 值 "bow-wow".
+现在当我们访问 `ourDog.bark` 时会得到它 bark 的属性值 "bow-wow".
+
+代码示例:
+
+```js
+var ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+
+ourDog.bark = "bow-wow";
+```
 
 # --instructions--
 
-给`myDog`添加一个`"bark"`属性，设置它的值为狗的声音，例如："woof"。你可以使用点或中括号操作符。
+请给 `myDog` 添加一个 `"bark"` 属性，将它的值设置为狗的叫声，如 "woof"。你可以使用点号表示法或方括号表示法来完成此挑战。
 
 # --hints--
 
-给`myDog`添加`"bark"`属性。
+应给 `myDog` 添加 `"bark"` 属性。
 
 ```js
 assert(myDog.bark !== undefined);
 ```
 
-不能在初始化 myDog 的时候添加`"bark"`属性。
+不应在初始化 myDog 的时候添加 `"bark"` 属性。
 
 ```js
 assert(!/bark[^\n]:/.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
index 866ebccabc..fb78ac82a8 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md
@@ -9,31 +9,31 @@ dashedName: add-two-numbers-with-javascript
 
 # --description--
 
-`Number`是 JavaScript 中的一种数据类型，表示数值。
+`Number` 是 JavaScript 中的一种数据类型，用来表示数值。
 
-现在让我们来尝试在 JavaScript 中做加法运算。
+现在我们来尝试在 JavaScript 中做加法运算。
 
-JavaScript 中使用`+`号进行加法运算。
+JavaScript 中，我们通过符号 `+` 来进行加法运算。
 
-**示例**
+**示例：**
 
 ```js
-myVar = 5 + 10; // assigned 15
+myVar = 5 + 10; // 赋值 15
 ```
 
 # --instructions--
 
-改变数字`0`让变量 sum 的值为`20`。
+请改变数字 `0` 让变量 sum 的值为 `20`。
 
 # --hints--
 
-`sum`应该等于`20`。
+`sum` 的值应为 `20`。
 
 ```js
 assert(sum === 20);
 ```
 
-要使用`+`运算符。
+应使用 `+` 运算符。
 
 ```js
 assert(/\+/.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
index e175e991c8..d766f8d5ee 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md
@@ -9,9 +9,9 @@ dashedName: adding-a-default-option-in-switch-statements
 
 # --description--
 
-在`switch`语句中你可能无法用 case 来指定所有情况，这时你可以添加 default 语句。当再也找不到 case 匹配的时候 default 语句会执行，非常类似于 if/else 组合中的 else 语句。
+在 `switch` 语句中你可能无法用 case 来指明所有情况，这时我们可以添加 default 语句来解决这个问题。在无法找到匹配的 case 时，default 语句就会执行。这非常类似于 if/else 语句中的 else 语句。
 
-`default`语句应该是最后一个 case。
+注意，`default` 语句应该在所有的 `case` 之后。
 
 ```js
 switch (num) {
@@ -30,7 +30,7 @@ switch (num) {
 
 # --instructions--
 
-写一个 switch 语句，根据下面的条件来设置`answer`的switch语句：  
+请实现根据下面的条件来设置 `answer` 的 `switch` 语句：  
 `"a"` - "apple"  
 `"b"` - "bird"  
 `"c"` - "cat"  
@@ -38,49 +38,49 @@ switch (num) {
 
 # --hints--
 
-`switchOfStuff("a")`应该有一个值为 "apple"。
+`switchOfStuff("a")` 的值应为 "apple"。
 
 ```js
 assert(switchOfStuff('a') === 'apple');
 ```
 
-`switchOfStuff("b")`应该有一个值为 "bird"。
+`switchOfStuff("b")` 的值应为 "bird"。
 
 ```js
 assert(switchOfStuff('b') === 'bird');
 ```
 
-`switchOfStuff("c")`应该有一个值为 "cat"。
+`switchOfStuff("c")` 的值应为 "cat"。
 
 ```js
 assert(switchOfStuff('c') === 'cat');
 ```
 
-`switchOfStuff("d")`应该有一个值为 "stuff"。
+`switchOfStuff("d")` 的值应为 "stuff"。
 
 ```js
 assert(switchOfStuff('d') === 'stuff');
 ```
 
-`switchOfStuff(4)`应该有一个值为 "stuff"。
+`switchOfStuff("4")` 的值应为 "stuff"。
 
 ```js
 assert(switchOfStuff(4) === 'stuff');
 ```
 
-不能使用任何`if`或`else`表达式。
+不应使用 `if` 或 `else` 语句。
 
 ```js
 assert(!/else/g.test(code) || !/if/g.test(code));
 ```
 
-你应该有一个`default`表达式。
+应有一个 `default` 语句。
 
 ```js
 assert(switchOfStuff('string-to-trigger-default-case') === 'stuff');
 ```
 
-你应该有至少 3 个`break`表达式。
+应至少有 3 个 `break` 语句。
 
 ```js
 assert(code.match(/break/g).length > 2);
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
index 65fe2f1e58..0993d538f9 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md
@@ -1,6 +1,6 @@
 ---
 id: 56533eb9ac21ba0edf2244ed
-title: 将变量附加到字符串
+title: 将变量追加到字符串
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cbQmZfa'
 forumTopicId: 16656
@@ -9,21 +9,30 @@ dashedName: appending-variables-to-strings
 
 # --description--
 
-我们不仅可以创建出多行的字符串，还可以使用加等号(`+=`)运算符来将变量追加到字符串。
+我们不仅可以通过字符串的<dfn>字面量</dfn>创建多行字符串，还可以使用加法赋值运算符（`+=`）来将变量追加到字符串。
+
+代码示例：
+
+```js
+var anAdjective = "awesome!";
+var ourStr = "freeCodeCamp is ";
+ourStr += anAdjective;
+// ourStr 的值现在为 "freeCodeCamp is awesome!"
+```
 
 # --instructions--
 
-设置变量`someAdjective`的值，并使用`+=`运算符把它追加到变量`myStr`上。
+请将变量 `someAdjective` 的设置为包含至少三个字符的字符串，并使用 `+=` 运算符把它追加到变量 `myStr` 上。
 
 # --hints--
 
-`someAdjective`应该是一个至少包含三个字符的字符串。
+`someAdjective` 应为至少包含三个字符的字符串。
 
 ```js
 assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
 ```
 
-使用`+=`操作符把`someAdjective`追加到`myStr`的后面。
+应使用 `+=` 操作符把 `someAdjective` 追加到 `myStr` 的末尾。
 
 ```js
 assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
index 2938f087ee..6f8e8278c2 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md
@@ -1,6 +1,6 @@
 ---
 id: 5ee127a03c3b35dd45426493
-title: Assigning the Value of One Variable to Another
+title: 将变量的值赋给另一个变量
 challengeType: 1
 videoUrl: ''
 forumTopicId: 418265
@@ -9,7 +9,7 @@ dashedName: assigning-the-value-of-one-variable-to-another
 
 # --description--
 
-After a value is assigned to a variable using the <dfn>assignment</dfn> operator, you can assign the value of that variable to another variable using the <dfn>assignment</dfn> operator.
+使用<dfn>赋值</dfn>运算符将值赋给变量后，我们可以继续使用<dfn>赋值</dfn>运算符将这个变量的值赋给其它变量。
 
 ```js
 var myVar;
@@ -18,27 +18,27 @@ var myNum;
 myNum = myVar;
 ```
 
-The above declares a `myVar` variable with no value, then assigns it the value `5`. Next, a variable named `myNum` is declared with no value. Then, the contents of `myVar` (which is `5`) is assigned to the variable `myNum`. Now, `myNum` also has the value of `5`.
+在上面的代码中，我们声明了没有初始值的 `myVar` 变量，然后给它赋值 `5`。接下来，我们又声明了没有初始值的变量 `myNum`。之后，`myVar` 的值 `5` 被赋给了变量 `myNum`。现在，`myNum` 的值也是 `5`。
 
 # --instructions--
 
-Assign the contents of `a` to variable `b`.
+请把 `a` 的值赋给 `b`。
 
 # --hints--
 
-You should not change code above the specified comment.
+不应修改注释上方的代码。
 
 ```js
 assert(/var a;/.test(code) && /a = 7;/.test(code) && /var b;/.test(code));
 ```
 
-`b` should have a value of 7.
+`b` 的值应为 7。
 
 ```js
 assert(typeof b === 'number' && b === 7);
 ```
 
-`a` should be assigned to `b` with `=`.
+`a` 的值应通过 `=` 运算符赋给 `b`。
 
 ```js
 assert(/b\s*=\s*a\s*/g.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
index c5ddb387d7..3ae6f575fd 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md
@@ -9,27 +9,27 @@ dashedName: assignment-with-a-returned-value
 
 # --description--
 
-如果你还记得我们在这一节[使用赋值运算符存储值](/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator)的讨论，赋值之前，先完成等号右边的操作。这意味着我们可把一个函数的返回值，赋值给一个变量。
+在[使用赋值运算符存储值](/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator)这一挑战中我们曾提到，赋值发生之前会先完成等号右边的操作。这意味着我们可把一个函数的返回值赋给一个变量。
 
-假设我们预先定义的函数`sum`其功能就是将两个数字相加，那么：
+假设我们已经定义了函数 `sum`，它的作用就是将两个数字相加，那么：
 
 `ourSum = sum(5, 12);`
 
-将调用`sum`函数，返回`return`了一个数值`17`，然后把它赋值给了`ourSum`变量。
+会调用 `sum` 函数，函数返回数值 `17`，然后把它赋值给 `ourSum` 变量。
 
 # --instructions--
 
-调用`processArg`函数并给参数一个值`7`，然后把返回的值赋值给变量`processed`。
+请调用 `processArg` 函数并传入 `7` 作为参数，然后把返回值赋值给变量 `processed`。
 
 # --hints--
 
-`processed`的值应该是`2`。
+`processed` 的值应为 `2`。
 
 ```js
 assert(processed === 2);
 ```
 
-你应该把`processArg`的返回值赋给`processed`。
+应将 `processArg` 的返回值赋给 `processed`。
 
 ```js
 assert(/processed\s*=\s*processArg\(\s*7\s*\)\s*;/.test(code));
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
index dae3ebc6f1..9c881020d6 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md
@@ -1,6 +1,6 @@
 ---
 id: 56bbb991ad1ed5201cd392d0
-title: 新建 JavaScript 对象
+title: 创建 JavaScript 对象
 challengeType: 1
 videoUrl: 'https://scrimba.com/c/cWGkbtd'
 forumTopicId: 16769
@@ -9,11 +9,11 @@ dashedName: build-javascript-objects
 
 # --description--
 
-你之前可能听说过对象`object`。
+你可能听说过对象（`object`）这个概念。
 
-对象和数组很相似，数组是通过索引来访问和修改数据，而对象是通过属性来访问和修改数据。
+对象和数组很相似。区别在于，数组是通过索引来访问和修改数据，而对象是通过`属性`来访问和修改数据。
 
-对象适合用来存储结构化数据，就和真实世界的对象一模一样，比如一只猫。
+对象可以让存储的数据结构化，它可以让我们更好地描述真实世界的物体，比如一只猫。
 
 这是一个对象的示例：
 
@@ -26,7 +26,7 @@ var cat = {
 };
 ```
 
-在这个示例中所有的属性以字符串的形式储存，例如，`"name"`、`"legs"`和`"tails"`。但是，你也可以使用数字作为属性，你甚至可以省略字符串属性的引号，如下所示：
+在这个示例中，属性都是以字符串的形式储存，例如 `"name"`、`"legs"`、`"tails"`。然而，我们也可以使用数字作为属性，甚至可以省略字符串属性的引号，如下所示：
 
 ```js
 var anotherObject = {
@@ -36,17 +36,17 @@ var anotherObject = {
 };
 ```
 
-但是，如果你的对象具有任何非字符串属性，JavaScript 将自动将它们转换为字符串类型。
+但是，如果你的对象包含任何非字符串属性，JavaScript 也会将它们自动转换为字符串。
 
 # --instructions--
 
-创建一个叫做`myDog`的对象，它里面有这些属性：`"name"`、`"legs"`、`"tails"`、`"friends"`。
+请创建一个名为 `myDog` 的对象，它应包含这些属性：`"name"`、`"legs"`、`"tails"`、`"friends"`。
 
-你可以设置对象属性为任何值，只需要确保`"name"`是字符串，`"legs"`和`"tails"`是数字，`"friends"`是数组。
+请确保 `"name"` 属性值是字符串、`"legs"` 和 `"tails"` 属性值是数字、`"friends"` 属性值是数组。只要满足这些条件，你可以随意设定这些属性值。
 
 # --hints--
 
-`myDog`应该包含`name`属性，并且是一个字符串`string`。
+`myDog` 应包含 `name` 属性，且属性值是一个字符串。
 
 ```js
 assert(
@@ -64,7 +64,7 @@ assert(
 );
 ```
 
-`myDog`应该包含`legs`属性，并且是一个数字`number`。
+`myDog` 应包含 `legs` 属性，且属性值是一个数字。
 
 ```js
 assert(
@@ -82,7 +82,7 @@ assert(
 );
 ```
 
-`myDog`应该包含`tails`属性，并且是一个数字`number`。
+`myDog` 应包含 `tails` 属性，且属性值是一个数字。
 
 ```js
 assert(
@@ -100,7 +100,7 @@ assert(
 );
 ```
 
-`myDog`应该包含`friends`属性，并且是一个数组`array`。
+`myDog` 应包含 `friends` 属性，且属性值是一个数组。
 
 ```js
 assert(
@@ -118,7 +118,7 @@ assert(
 );
 ```
 
-`myDog`应该只包含给出的属性。
+`myDog` 应只包含给定的属性。
 
 ```js
 assert(
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
index 754d248e13..8ceeb4b5e3 100644
--- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
+++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md
@@ -9,7 +9,7 @@ dashedName: chaining-if-else-statements
 
 # --description--
 
-`if/else`语句串联在一起可以实现复杂的逻辑，这是多个`if/else if`语句串联在一起的伪代码：
+将 `if/else` 语句串联在一起可以实现复杂的逻辑，这是多个 `if/else if` 语句串联在一起的<dfn>伪代码</dfn>：
 
 ```js
 if (condition1) {
@@ -26,89 +26,89 @@ if (condition1) {
 
 # --instructions--
 
-把`if`/`else if`语句串联起来实现下面的逻辑：
+请将 `if`/`else if` 语句串联起来实现下面的逻辑：
 
-`num < 5`- return "Tiny"  
-`num < 10`- return "Small"  
-`num < 15`- return "Medium"  
-`num < 20`- return "Large"  
-`num >= 20` - return "Huge"
+`num < 5` - 返回 "Tiny"  
+`num < 10` - 返回 "Small"  
+`num < 15` - 返回 "Medium"  
+`num < 20` - 返回 "Large"  
+`num >= 20` - 返回 "Huge"
 
 # --hints--
 
-你应该有至少 4 个`else`表达式。
+应至少有 4 个 `else` 语句。
 
 ```js
 assert(code.match(/else/g).length > 3);
 ```
 
-你应该有至少 4 个`if`表达式。
+应至少有 4 个 `if` 语句。
 
 ```js
 assert(code.match(/if/g).length > 3);
 ```
 
-你应该有至少 1 个`return`表达式。
+应至少有 1 个 `return` 语句。
 
 ```js
 assert(code.match(/return/g).length >= 1);
 ```
 
-`testSize(0)`应该返回 "Tiny"。
+`testSize(0)` 应返回 "Tiny"。
 
 ```js
 assert(testSize(0) === 'Tiny');
 ```
 
-`testSize(4)`应该返回 "Tiny"。
+`testSize(4)` 应返回 "Tiny"。
 
 ```js
 assert(testSize(4) === 'Tiny');
 ```
 
-`testSize(5)`应该返回 "Small"。
+`testSize(5)` 应返回 "Small"。
 
 ```js
 assert(testSize(5) === 'Small');
 ```
 
-`testSize(8)`应该返回 "Small"。
+`testSize(8)` 应返回 "Small"。
 
 ```js
 assert(testSize(8) === 'Small');
 ```
 
-`testSize(10)`应该返回 "Medium"。
+`testSize(10)` 应返回 "Medium"。
 
 ```js
 assert(testSize(10) === 'Medium');
 ```
 
-`testSize(14)`应该返回 "Medium"。
+`testSize(14)` 应返回 "Medium"。
 
 ```js
 assert(testSize(14) === 'Medium');
 ```
 
-`testSize(15)`应该返回 "Large"。
+`testSize(15)` 应返回 "Large"。
 
 ```js
 assert(testSize(15) === 'Large');
 ```
 
-`testSize(17)`应该返回 "Large"。
+`testSize(17)` 应返回 "Large"。
 
 ```js
 assert(testSize(17) === 'Large');
 ```
 
-`testSize(20)`应该返回 "Huge"。
+`testSize(20)` 应返回 "Huge"。
 
 ```js
 assert(testSize(20) === 'Huge');
 ```
 
-`testSize(25)`应该返回 "Huge"。
+`testSize(25)` 应返回 "Huge"。
 
 ```js
 assert(testSize(25) === 'Huge');