chore: update translations (#41737)

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md

@@ -13,13 +13,17 @@ dashedName: add-new-properties-to-a-javascript-object
 
 这里展示了如何给 `ourDog` 添加一个属性 `bark`：
 
-`ourDog.bark = "bow-wow";`
+```js
+ourDog.bark = "bow-wow";
+```
 
 或者
 
-`ourDog["bark"] = "bow-wow";`
+```js
+ourDog["bark"] = "bow-wow";
+```
 
-现在，当我们执行 `ourDog.bark` 时，我们就能得到他的叫声，`bow-wow`。
+现在，当我们执行 `ourDog.bark` 时，就能得到他的叫声，`bow-wow`。
 
 例如：
 
@@ -36,17 +40,17 @@ ourDog.bark = "bow-wow";
 
 # --instructions--
 
-给 `myDog` 添加一个属性 `bark` ，并将其设置为狗的声音，比如“woof“. 你可以使用点号表示法或方括号表示法来完成此挑战。
+给 `myDog` 添加一个属性 `bark` ，并将其设置为狗的声音，比如 “woof“。 可以使用点操作符或者中括号操作符。
 
 # --hints--
 
-你应该将属性 `bark` 添加到 `myDog`。
+应该给 `myDog` 添加属性 `bark`。
 
 ```js
 assert(myDog.bark !== undefined);
 ```
 
-你不应该在 Setup 部分添加 `bark`。
+不应该在初始化部分添加 `bark`。
 
 ```js
 assert(!/bark[^\n]:/.test(code));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md

@@ -13,13 +13,15 @@ dashedName: assignment-with-a-returned-value
 
 假设我们有一个预先定义的函数 `sum` ，它将两个数相加，然后：
 
-`ourSum = sum(5, 12);`
+```js
+ourSum = sum(5, 12);
+```
 
 将会调用函数 `sum`，函数返回值 `17`，然后将该值赋给变量 `ourSum`。
 
 # --instructions--
 
-调用函数 `processArg`，传入参数 `7`，并将它的返回值赋给变量 `processed`。
+调用 `processArg` 函数，参数为 `7`，然后把返回的值赋值给变量 `processed`。
 
 # --hints--
 
@@ -29,7 +31,7 @@ dashedName: assignment-with-a-returned-value
 assert(processed === 2);
 ```
 
-你应该将 `processArg` 赋值给 `processed`。
+应该将 `processArg` 赋值给 `processed`。
 
 ```js
 assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md

@@ -11,9 +11,11 @@ dashedName: compound-assignment-with-augmented-addition
 
 在编程中，通常通过赋值来修改变量的内容。 记住，赋值时 JavaScript 会先计算等号右边的内容，所以我们可以写这样的语句：
 
-`myVar = myVar + 5;`
+```js
+myVar = myVar + 5;
+```
 
-给 `myVar` 加上 `5`。 以上是最常见的运算赋值语句，即先运算、再赋值。还有一类操作符是一步到位既做运算也赋值的。
+给 `myVar` 加上 `5`。 这是最常见的运算赋值语句，即先运算、再赋值。还有一类操作符是一步到位，既做运算也赋值的。
 
 其中一种就是 `+=` 运算符。
 
@@ -23,11 +25,11 @@ myVar += 5;
 console.log(myVar);
 ```
 
-字符串 `6` 将会出现在控制台中。
+控制台将会显示 `6`。
 
 # --instructions--
 
-使用 `+=` 操作符对 `a`、`b` 和 `c` 实现同样的效果。
+使用 `+=` 操作符对 `a`、`b` 和 `c` 赋值。
 
 # --hints--
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md

@@ -11,11 +11,15 @@ dashedName: compound-assignment-with-augmented-division
 
 `/=` 操作符是让变量与另一个数相除并赋值。
 
-`myVar = myVar / 5;`
+```js
+myVar = myVar / 5;
+```
 
-变量 `myVar` 等于自身除以 `5` 的值。 等价于:
+将 `myVar` 除以 `5`。 等价于：
 
-`myVar /= 5;`
+```js
+myVar /= 5;
+```
 
 # --instructions--
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md

@@ -11,15 +11,19 @@ dashedName: compound-assignment-with-augmented-multiplication
 
 `*=` 操作符是让变量与一个数相乘并赋值。
 
-`myVar = myVar * 5;`
+```js
+myVar = myVar * 5;
+```
 
-变量 `myVar` 等于自身与数值 `5` 相乘的值。 也可以写作这样的形式:
+将 `myVar` 乘以 `5`。 等价于：
 
-`myVar *= 5;`
+```js
+myVar *= 5;
+```
 
 # --instructions--
 
-使用 `*=` 操作符给 `a`，`b` 和 `c` 实现赋值相乘操作。
+使用 `*=` 操作符对 `a`、`b` 和 `c` 实现赋值相乘操作。
 
 # --hints--
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md

@@ -11,15 +11,19 @@ dashedName: compound-assignment-with-augmented-subtraction
 
 与 `+=` 操作符类似，`-=` 操作符用来对一个变量进行减法赋值操作。
 
-`myVar = myVar - 5;`
+```js
+myVar = myVar - 5;
+```
 
-变量 `myVar` 等于自身减去 `5` 的值。 也可以写成这种形式：
+将从 `myVar` 中减去 `5`。 等价于：
 
-`myVar -= 5;`
+```js
+myVar -= 5;
+```
 
 # --instructions--
 
-使用 `-=` 操作符对 `a`，`b` 和 `c` 实现相减赋值。
+使用 `-=` 操作符对 `a`、`b` 和 `c` 实现相减赋值操作。
 
 # --hints--
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md

@@ -22,7 +22,7 @@ for (var i = 10; i > 0; i -= 2) {
 }
 ```
 
-循环结束后，`ourArray` 的值为 `[10,8,6,4,2]`。 让我们改变 initialization 和 final-expression，这样我们就可以按照奇数从后往前两两倒着数。
+循环结束后，`ourArray` 的值为 `[10,8,6,4,2]`。 让我们改变初始值和最后的表达式，这样我们就可以按照奇数从后往前两两倒着数。
 
 # --instructions--
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md

@@ -17,9 +17,7 @@ dashedName: counting-cards
 
 请写一个函数实现 21 点算法。 它根据参数 `card` 的值（见表格，可能是数字或者字符串）来递增或递减全局变量 `count`。 然后函数返回一个由当前 count（计数）和 `Bet`（当 count > 0 时）或 `Hold`（当 count <= 0 时) 拼接的字符串。 注意 count（计数）和玩家的决定（`Bet` 或 `Hold`）之间应该有空格。
 
-**示例输出：**  
-`-3 Hold`  
-`5 Bet`
+**示例输出：**`-3 Hold` 或者 `5 Bet`
 
 **提示：**  
 当卡牌为 7、8、9 时，不要把 `count` 值重置为 0。 不要返回一个数组。  

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md

@@ -11,17 +11,19 @@ dashedName: declare-string-variables
 
 之前我们写过这样的代码：
 
-`var myName = "your name";`
+```js
+var myName = "your name";
+```
 
-`"your name"` 被称作<dfn>字符串</dfn><dfn>变量</dfn>。 字符串是用单引号或双引号包裹起来的一连串的零个或多个字符。
+`"your name"` 被称作<dfn>字符串</dfn><dfn>字面量</dfn>。 这是一个字符串，因为它是一系列包含在单引号或双引号中的零或多个字符。
 
 # --instructions--
 
-创建两个新的 string 变量：`myFirstName` 和 `myLastName`，并用你的姓和名分别为它们赋值。
+创建两个新的字符串变量：`myFirstName` 和 `myLastName`，并用你的姓和名分别为它们赋值。
 
 # --hints--
 
-`myFirstName` 应该是一个字符串，并且至少包含一个字符。
+`myFirstName` 应该是一个字符串，至少包含一个字符。
 
 ```js
 assert(
@@ -39,7 +41,7 @@ assert(
 );
 ```
 
-`myLastName` 应该是一个字符串，并且至少包含一个字符。
+`myLastName` 应该是一个字符串，至少包含一个字符。
 
 ```js
 assert(

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md

@@ -9,19 +9,23 @@ dashedName: decrement-a-number-with-javascript
 
 # --description--
 
-使用自减符号`--`，你可以很方便地对一个变量执行<dfn>自减</dfn>或者 -1 运算。
+使用自减符号 `--`，你可以很方便地对一个变量执行<dfn>自减</dfn>或者 -1 运算。
 
-`i--;`
+```js
+i--;
+```
 
-等效于
+等效于：
 
-`i = i - 1;`
+```js
+i = i - 1;
+```
 
-**提示** `i--;` 这种写法，省去了书写等号的必要。
+**注意：**`i--;` 这种写法省去了书写等号的必要。
 
 # --instructions--
 
-重写代码，使用 `--` 符号对 `myVar` 执行自减操作。
+修改代码，使用 `--` 符号对 `myVar` 执行自减操作。
 
 # --hints--
 
@@ -31,7 +35,7 @@ dashedName: decrement-a-number-with-javascript
 assert(myVar === 10);
 ```
 
-`myVar = myVar - 1;` 语句应该被修改。
+应该修改 `myVar = myVar - 1;`。
 
 ```js
 assert(
@@ -39,13 +43,13 @@ assert(
 );
 ```
 
-对 `myVar` 使用 `--` 运算符。
+应该对 `myVar` 使用 `--` 运算符。
 
 ```js
 assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
 ```
 
-不要修改注释上面的代码。
+不应修改注释上方的代码。
 
 ```js
 assert(/var myVar = 11;/.test(code));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md

@@ -11,7 +11,9 @@ dashedName: delete-properties-from-a-javascript-object
 
 我们同样可以删除对象的属性，例如：
 
-`delete ourDog.bark;`
+```js
+delete ourDog.bark;
+```
 
 例如：
 

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md

@@ -13,17 +13,23 @@ dashedName: escaping-literal-quotes-in-strings
 
 在 JavaScript 中，可以通过在引号前面使用<dfn>反斜杠</dfn>（`\`）来<dfn>转义</dfn>引号。
 
-`var sampleStr = "Alan said, \"Peter is learning JavaScript\".";`
+```js
+var sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+```
 
 有了转义符号，JavaScript 就知道这个单引号或双引号并不是字符串的结尾，而是字符串内的字符。 所以，上面的字符串打印到控制台的结果为：
 
-`Alan said, "Peter is learning JavaScript".`
+```js
+Alan said, "Peter is learning JavaScript".
+```
 
 # --instructions--
 
-使用<dfn>反斜杠</dfn>将一个字符串赋值给变量 `myStr`，打印到控制台，输出为：
+使用<dfn>反斜杠</dfn>给 `myStr` 变量赋值一个字符串，这样如果你要打印它到控制台，将会看到：
 
-`I am a "double quoted" string inside "double quotes".`
+```js
+I am a "double quoted" string inside "double quotes".
+```
 
 # --hints--
 
@@ -33,7 +39,7 @@ dashedName: escaping-literal-quotes-in-strings
 assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
 ```
 
-变量 myStr 应该包含字符串 `I am a "double quoted" string inside "double quotes".`。
+变量 myStr 应该包含字符串 `I am a "double quoted" string inside "double quotes".`
 
 ```js
 assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md

@@ -17,13 +17,15 @@ dashedName: generate-random-whole-numbers-with-javascript
 
 把操作连缀起来，代码类似于下面：
 
-`Math.floor(Math.random() * 20);`
+```js
+Math.floor(Math.random() * 20);
+```
 
 我们先调用 `Math.random()`，把它的结果乘以 20，然后把上一步的结果传给 `Math.floor()`，最终通过向下取整获得最近的整数。
 
 # --instructions--
 
-生成一个 `0` 到 `9` 之间的随机整数。
+使用这个方法生成并返回 `0` 和 `9` 之间的随机整数。
 
 # --hints--
 
@@ -39,7 +41,7 @@ assert(
 );
 ```
 
-需要使用 `Math.random` 生成一个随机数字。
+应该使用 `Math.random` 生成一个随机数字。
 
 ```js
 assert(code.match(/Math.random/g).length >= 1);
@@ -54,7 +56,7 @@ assert(
 );
 ```
 
-需要使用 `Math.floor` 移除数字中的小数部分。
+应该使用 `Math.floor` 来删除数字的十进制部分。
 
 ```js
 assert(code.match(/Math.floor/g).length >= 1);

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.md

@@ -15,11 +15,13 @@ dashedName: generate-random-whole-numbers-within-a-range
 
 下面是我们将要使用的方法， 仔细看看并尝试理解这行代码到底在干嘛：
 
-`Math.floor(Math.random() * (max - min + 1)) + min`
+```js
+Math.floor(Math.random() * (max - min + 1)) + min
+```
 
 # --instructions--
 
-创建一个函数 `randomRange`，接收参数的范围在 `myMin` 和 `myMax`之间，返回一个在 `myMin`（包括 myMin）和 `myMax`（包括 myMax）之间的随机整数。
+创建一个函数 `randomRange`，参数为 `myMin` 和 `myMax`，返回一个在 `myMin`（包括 myMin）和 `myMax`（包括 myMax）之间的随机整数。
 
 # --hints--
 
@@ -29,7 +31,7 @@ dashedName: generate-random-whole-numbers-within-a-range
 assert(calcMin === 5);
 ```
 
-`randomRange` 返回的随机数最大值应该等于 `myMax`。
+`randomRange` 返回的随机数应该小于或等于 `myMax`。
 
 ```js
 assert(calcMax === 15);

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md

@@ -11,21 +11,25 @@ dashedName: increment-a-number-with-javascript
 
 使用 `++`，我们可以很容易地对变量进行<dfn>自增</dfn>或者 +1 运算。
 
-`i++;`
+```js
+i++;
+```
 
-等效于
+等效于：
 
-`i = i + 1;`
+```js
+i = i + 1;
+```
 
-**提示** `i++;` 这种写法，省去了书写等号的必要。
+**注意：**`i++;` 这种写法省去了书写等号的必要。
 
 # --instructions--
 
-重写代码，使用 `++` 来对变量 `myVar` 进行自增操作。
+修改代码，使用 `++` 来对变量 `myVar` 进行自增操作。
 
 # --hints--
 
-`myVar` should equal `88`.
+`myVar` 应该等于 `88`。
 
 ```js
 assert(myVar === 88);
@@ -39,13 +43,13 @@ assert(
 );
 ```
 
-使用 `++` 运算符。
+应该使用 `++` 运算符。
 
 ```js
 assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
 ```
 
-不要修改注释上面的代码。
+不应该修改注释上面的代码。
 
 ```js
 assert(/var myVar = 87;/.test(code));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md

@@ -11,17 +11,19 @@ dashedName: initializing-variables-with-the-assignment-operator
 
 通常在声明变量的时候会给变量<dfn>初始化</dfn>一个初始值。
 
-`var myVar = 0;`
+```js
+var myVar = 0;
+```
 
-创建一个名为 `myVar` 的变量，并指定其初始值 `0`。
+创建一个名为 `myVar` 的变量，并指定其初始值为 `0`。
 
 # --instructions--
 
-通过关键字 `var` 定义一个变量 `a`，并给它一个初始值 `9`。
+通过关键字 `var` 定义一个变量 `a`，并且给它一个初始值 `9`。
 
 # --hints--
 
-你需要初始化 `a` 的值为 `9`。
+应该初始化 `a` 的值为 `9`。
 
 ```js
 assert(/var\s+a\s*=\s*9(\s*;?\s*)$/.test(code));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md

@@ -13,31 +13,33 @@ dashedName: shopping-list
 
 每个子数组中的第一个元素应该是购买的物品名称。 第二个元素应该是物品的数量，类似于：
 
-`["Chocolate Bar", 15]`
+```js
+["Chocolate Bar", 15]
+```
 
-任务：你的购物清单至少应该有 5 个子数组。
+列表中应至少有 5 个子数组。
 
 # --hints--
 
-`myList` 应该是一个数组
+`myList` 应该是一个数组。
 
 ```js
 assert(isArray);
 ```
 
-你的每个子数组的第一个元素的类型都应该是字符串
+每个子数组的第一个元素都应该是字符串。
 
 ```js
 assert(hasString);
 ```
 
-你的每个子数组的第二个元素的类型都应该是数字
+每个子数组的第二个元素都应该是数字。
 
 ```js
 assert(hasNumber);
 ```
 
-你的列表中至少要包含 5 个元素
+列表中至少要包含 5 个元素。
 
 ```js
 assert(count > 4);

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md

@@ -13,7 +13,9 @@ dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
 
 以左方括号开始定义一个数组，以右方括号结束，里面每个元素之间用逗号隔开，例如：
 
-`var sandwich = ["peanut butter", "jelly", "bread"]`
+```js
+var sandwich = ["peanut butter", "jelly", "bread"]
+```
 
 # --instructions--
 
@@ -21,7 +23,7 @@ dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
 
 # --hints--
 
-`myArray`应该是一个数组（`array`）。
+`myArray` 应该是一个数组（`array`）。
 
 ```js
 assert(typeof myArray == 'object');

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md

@@ -11,18 +11,20 @@ dashedName: storing-values-with-the-assignment-operator
 
 在 JavaScript 中，你可以使用赋值（<dfn>assignment</dfn>）运算符 （`=`）将值存储在变量中。
 
-`myVariable = 5;`
+```js
+myVariable = 5;
+```
 
 这条语句把 `Number` 类型的值 `5` 赋给变量 `myVariable`。
 
-在将值分配给运算符左侧的变量之前，将解析 `=` 运算符右侧的所有内容。
+在将值赋给运算符左侧的变量之前，将先执行 `=` 运算符右侧的所有运算。
 
 ```js
 var myVar;
 myVar = 5;
 ```
 
-首先，此代码创建一个名为 `myVar` 的变量。 数值 `5` 被赋给变量 `myVar`。 现在，如果 `myVar` 再次出现在代码中，程序将会将它视为 `5`。
+首先，此代码创建一个名为 `myVar` 的变量。 然后，数值 `5` 被赋给变量 `myVar`。 现在，如果 `myVar` 再次出现在代码中，程序将会将它视为 `5`。
 
 # --instructions--
 
@@ -30,7 +32,7 @@ myVar = 5;
 
 # --hints--
 
-你不应该修改注释上面的代码。
+不应该修改注释上面的代码。
 
 ```js
 assert(/var a;/.test(code));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function-with-a-radix.md

@@ -13,45 +13,49 @@ dashedName: use-the-parseint-function-with-a-radix
 
 函数调用如下所示：
 
-`parseInt(string, radix);`
+```js
+parseInt(string, radix);
+```
 
-示例：
+这是一个示例：
 
-`var a = parseInt("11", 2);`
+```js
+var a = parseInt("11", 2);
+```
 
-参数 2 表示 `11` 使用二进制数。 此示例将字符串 `11` 转换为整数 `3`。
+变量 radix 表示 `11` 是在二进制系统中。 这个示例将字符串 `11` 转换为整数 `3`。
 
 # --instructions--
 
-在 `convertToInteger` 函数中使用 `parseInt()` 将二进制数转换为正数并返回。
+在 `convertToInteger` 函数中使用 `parseInt()` ，将二进制数转换为整数并返回。
 
 # --hints--
 
-`convertToInteger` 中应该使用 `parseInt()` 函数
+`convertToInteger` 应该使用 `parseInt()` 函数。
 
 ```js
 assert(/parseInt/g.test(code));
 ```
 
-`convertToInteger("10011")` 应该返回一个数字
+`convertToInteger("10011")` 应该返回一个数字。
 
 ```js
 assert(typeof convertToInteger('10011') === 'number');
 ```
 
-`convertToInteger("10011")` 应该返回 19
+`convertToInteger("10011")` 应该返回 19。
 
 ```js
 assert(convertToInteger('10011') === 19);
 ```
 
-`convertToInteger("111001")` 应该返回 57
+`convertToInteger("111001")` 应该返回 57。
 
 ```js
 assert(convertToInteger('111001') === 57);
 ```
 
-`convertToInteger("JamesBond")` 应该返回 `NaN`
+`convertToInteger("JamesBond")`应该返回 `NaN`。
 
 ```js
 assert.isNaN(convertToInteger('JamesBond'));

curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-the-parseint-function.md

@@ -11,41 +11,43 @@ dashedName: use-the-parseint-function
 
 `parseInt()` 函数解析一个字符串返回一个整数。 下面是一个示例：
 
-`var a = parseInt("007");`
+```js
+var a = parseInt("007");
+```
 
-上述函数将字符串 `007` 转换为整数 `7`。 如果字符串参数的第一个字符是字符串类型的，结果将不会转换成数字，而是返回 `NaN`。
+上述函数将字符串 `007` 转换为整数 `7`。 如果字符串中的第一个字符不能转换为数字，则返回 `NaN`。
 
 # --instructions--
 
-在 `convertToInteger` 函数中使用 `parseInt()` 将字符串 `str` 转换为正数并返回。
+在 `convertToInteger` 函数中使用 `parseInt()` 将字符串 `str` 转换为一个整数，并返回这个值。
 
 # --hints--
 
-`convertToInteger` 应该使用 `parseInt()` 函数
+`convertToInteger` 中应该使用 `parseInt()` 函数。
 
 ```js
 assert(/parseInt/g.test(code));
 ```
 
-`convertToInteger("56")` 应该返回一个数字
+`convertToInteger("56")` 应该返回一个数字。
 
 ```js
 assert(typeof convertToInteger('56') === 'number');
 ```
 
-`convertToInteger("56")` 应该返回 56
+`convertToInteger("56")` 应该返回 56。
 
 ```js
 assert(convertToInteger('56') === 56);
 ```
 
-`convertToInteger("77")`应该返回 77
+`convertToInteger("77")` 应该返回 77。
 
 ```js
 assert(convertToInteger('77') === 77);
 ```
 
-`convertToInteger("JamesBond")`应该返回 `NaN`
+`convertToInteger("JamesBond")` 应该返回 `NaN`。
 
 ```js
 assert.isNaN(convertToInteger('JamesBond'));