javascript-tutorial · leviding · Apr 7, 2020 · Apr 6, 2020 · Apr 6, 2020 · Apr 6, 2020
diff --git a/1-js/05-data-types/01-primitives-methods/article.md b/1-js/05-data-types/01-primitives-methods/article.md
@@ -70,7 +70,7 @@ alert( str.toUpperCase() ); // HELLO
 
 JavaScript 引擎高度优化了这个过程。它甚至可能跳过创建额外的对象。但是它仍然必须遵守规范，并且表现得好像它创建了一样。
 
-数字有其自己的方法，例如，[toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) 将数字四舍五入到给定的精度：
+数字有其自己的方法，例如，[toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) 将数字舍入到给定的精度：
 
 ```js run
 let n = 1.23456;

diff --git a/1-js/05-data-types/02-number/1-sum-interface/solution.md b/1-js/05-data-types/02-number/1-sum-interface/solution.md
@@ -7,6 +7,6 @@ let b = +prompt("The second number?", "");
 alert( a + b );
 ```
 
-注意一元符号 `+` 在 `prompt` 前面。它会把获取的值转换成数字。
+注意在 `prompt` 前面的一元加号 `+`。它将立即把值转换成数字。
 
-否则，`a` 和 `b` 会是字符串，它们的总和就是它们的连接，即：`“1”+“2”=“12”`。
+否则，`a` 和 `b` 将会是字符串，它们的总和将是它们的连接，即：`"1" + "2" = "12"`。
diff --git a/1-js/05-data-types/02-number/1-sum-interface/task.md b/1-js/05-data-types/02-number/1-sum-interface/task.md
@@ -2,10 +2,10 @@ importance: 5
 
 ---
 
-# 来自访客的总数
+# 来自访问者的数字的总和
 
 创建一个脚本，提示访问者输入两个数字，然后显示它们的总和。
 
 [demo]
 
-提示：类型会有一个问题。
+P.S. 有一个类型陷阱。
diff --git a/1-js/05-data-types/02-number/2-why-rounded-down/solution.md b/1-js/05-data-types/02-number/2-why-rounded-down/solution.md
@@ -1,32 +1,33 @@
-在 `6.35` 内部，小数部分是一个无限的二进制。在这种情况下，它存储的时候有一个精度的缺失。
+在内部，`6.35` 的小数部分是一个无限的二进制。在这种情况下，它的存储会造成精度损失。
 
 让我们来看看：
 
 ```js run
 alert( 6.35.toFixed(20) ); // 6.34999999999999964473
 ```
 
-精度缺失可能会导致数字的增加和减小。在这种特殊情况下，数字可能会变小了一点，这就是为什么它减小了。
+精度损失可能会导致数字的增加和减小。在这种特殊的情况下，数字变小了一点，这就是它向下舍入的原因。
 
-那么 `1.35` 是怎样的呢？
+那么 `1.35` 会怎样呢？
 
 ```js run
 alert( 1.35.toFixed(20) ); // 1.35000000000000008882
 ```
 
-在这里，精度缺失使得这个数字更大一些，所以这个数字变大了一些。
+在这里，精度损失使得这个数字稍微大了一些，因此其向上舍入。
 
-**如果我们希望以正确的方式四舍五入，我们如何使用 `6.35` 为例来解决这个问题？**
+**如果我们希望以正确的方式进行舍入，我们应该如何解决 `6.35` 的舍入问题呢？**
 
-在四舍五入之前，我们应该把它接近整数：
+在进行舍入前，我们应该使其更接近整数：
 
 ```js run
 alert( (6.35 * 10).toFixed(20) ); // 63.50000000000000000000
 ```
 
-请注意 `63.5` 完全没有精度缺失。这是因为小数部分 `0.5` 实际上是 `1 / 2`。除以2的幂的分数在二进制系统中被精确地表示，现在我们可以围绕它来解决问题：
+请注意，`63.5` 完全没有精度损失。这是因为小数部分 `0.5` 实际上是 `1/2`。以 2 的整数次幂为分母的小数在二进制数字系统中可以被精确地表示，现在我们可以对它进行舍入：
 
 
 ```js run
 alert( Math.round(6.35 * 10) / 10); // 6.35 -> 63.5 -> 64(rounded) -> 6.4
 ```
+
diff --git a/1-js/05-data-types/02-number/2-why-rounded-down/task.md b/1-js/05-data-types/02-number/2-why-rounded-down/task.md
@@ -4,18 +4,19 @@ importance: 4
 
 # 为什么 6.35.toFixed(1) == 6.3？
 
-根据文档 `Math.round` 和 `toFixed`，最近的数字四舍五入：`0..4` 会被舍去，而 `5..9` 会前进一位。
+根据文档，`Math.round` 和 `toFixed` 都将数字舍入到最接近的数字：`0..4` 会被舍去，而 `5..9` 会进一位。
 
 例如：
 
 ```js run
 alert( 1.35.toFixed(1) ); // 1.4
 ```
 
-在下面的类似例子中，为什么 `6.35` 被四舍五入为 `6.3` 而不是 `6.4`？
+在下面这个类似的示例中，为什么 `6.35` 被舍入为 `6.3` 而不是 `6.4`？
 
 ```js run
 alert( 6.35.toFixed(1) ); // 6.3
 ```
 
-如何以正确的方式来四舍五入 `6.35`？
+如何以正确的方式来对 `6.35` 进行舍入？
+
diff --git a/1-js/05-data-types/02-number/3-repeat-until-number/solution.md b/1-js/05-data-types/02-number/3-repeat-until-number/solution.md
@@ -15,8 +15,9 @@ function readNumber() {
 alert(`Read: ${readNumber()}`);
 ```
 
-该解决方案有点复杂，可能是因为我们需要处理 null/空行。
+该解决方案有点复杂，因为我们需要处理 `null` 和空行。
 
-所以我们实际上接受输入，直到它成为“常规数字”。null（取消）和空行都适合该条件，因为在数字形式中它们是 `0`。
+所以，我们实际上接受输入，直到输入的是一个“常规数字”。`null`（取消）和空行都符合该条件，因为在数字形式中它们是 `0`。
+
+在我们停止之后，我们需要专门处理 `null` 和空行（返回 `null`），因为将它们转换为数字将返回 `0`。
 
-在我们停止之后，我们需要专门处理 null 和空行（返回 null），因为将它们转换为数字将返回 `0`。
diff --git a/1-js/05-data-types/02-number/3-repeat-until-number/task.md b/1-js/05-data-types/02-number/3-repeat-until-number/task.md
@@ -2,12 +2,13 @@ importance: 5
 
 ---
 
-# 重复检测，直到输入是一个数字
+# 重复，直到输入的是一个数字
 
-创建一个函数 `readNumber`，它提示输入一个数字，直到访问者输入一个有效的数字。
+创建一个函数 `readNumber`，它提示输入一个数字，直到访问者输入一个有效的数字为止。
 
-结果值必须作为数字返回。
+结果值必须以数字形式返回。
 
-访问者也可以通过输入空行或按“取消”来停止该过程。在这种情况下，函数应该返回 `null`。
+访问者也可以通过输入空行或点击“取消”来停止该过程。在这种情况下，函数应该返回 `null`。
 
 [demo]
+
diff --git a/1-js/05-data-types/02-number/4-endless-loop-error/solution.md b/1-js/05-data-types/02-number/4-endless-loop-error/solution.md
@@ -1,6 +1,6 @@
 那是因为 `i` 永远不会等于 `10`。
 
-运行它以查看 `i` 的实际值：
+运行下面这段代码来查看 `i` 的 **实际** 值：
 
 ```js run
 let i = 0;
@@ -10,8 +10,8 @@ while (i < 11) {
 }
 ```
 
-他们中没有一个完全是 `10`。
+它们中没有一个恰好是 `10`。
 
-发生这样的事情是因为在添加像 `0.2` 这样的分数时出现了精度损失。
+之所以发生这种情况，是因为对 `0.2` 这样的小数时进行加法运算时出现了精度损失。
 
-结论：在处理小数部分时避免相等检查。
+结论：在处理小数时避免相等性检查。
diff --git a/1-js/05-data-types/02-number/4-endless-loop-error/task.md b/1-js/05-data-types/02-number/4-endless-loop-error/task.md
@@ -4,7 +4,7 @@ importance: 4
 
 # 一个偶发的无限循环
 
-这个循环是无限的。它永远不会结束。为什么？
+这是一个无限循环。它永远不会结束。为什么？
 
 ```js
 let i = 0;

diff --git a/1-js/05-data-types/02-number/8-random-min-max/solution.md b/1-js/05-data-types/02-number/8-random-min-max/solution.md
@@ -1,9 +1,9 @@
-我们需要将区间 0..1 中的所有值“映射”为从最小值到最大值。
+我们需要将区间 0..1 中的所有值“映射”为范围在 `min` 到 `max` 中的值。
 
 这可以分两个阶段完成：
 
-1. 如果我们将 0..1 的随机数乘以 `max-min`，则可能值的间隔从 0..1 增加到 `0..max-min`。
-2. 现在，如果我们添加 `min`，则可能的间隔将从 `min` 变为 `max`。
+1. 如果我们将 0..1 的随机数乘以 `max-min`，则随机数的范围将从 0..1 增加到 `0..max-min`。
+2. 现在，如果我们将随机数与 `min` 相加，则随机数的范围将为 `min` 到 `max`。
 
 函数实现：
 
@@ -16,3 +16,4 @@ alert( random(1, 5) );
 alert( random(1, 5) ); 
 alert( random(1, 5) ); 
 ```
+
diff --git a/1-js/05-data-types/02-number/8-random-min-max/task.md b/1-js/05-data-types/02-number/8-random-min-max/task.md
@@ -2,13 +2,13 @@ importance: 2
 
 ---
 
-# 从最小到最大的随机数
+# 从 min 到 max 的随机数
 
-用内置函数Math.random() 创建一个从 0 到 1 的随机值（不包括 1 ）。
+内建函数 `Math.random()` 会创建一个在 `0` 到 `1` 之间（不包括 `1`）的随机数。
 
-编写随机函数（min，max）以生成从最小到最大（不包括最大值）的随机浮点数。
+编写一个 `random(min, max)` 函数，用以生成一个在 `min` 到 `max` 之间的随机浮点数（不包括 `max`)）。
 
-实例：
+运行示例：
 
 ```js
 alert( random(1, 5) ); // 1.2345623452

diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/solution.md b/1-js/05-data-types/02-number/9-random-int-min-max/solution.md
@@ -1,6 +1,6 @@
 # 简单但错误的解决方案
 
-最简单但错误的解决方案是从 `min` 到 `max` 生成一个值并取它四舍五入的值：
+最简单但错误的解决方案是生成一个范围在 `min` 到 `max` 的值，并取对其进行四舍五入后的值：
 
 ```js run
 function randomInteger(min, max) {
@@ -11,11 +11,11 @@ function randomInteger(min, max) {
 alert( randomInteger(1, 3) );
 ```
 
-这个函数是能起作用的，但不正确。获得边缘值 `min` 和 `max` 的概率是其他值的两倍。
+这个函数是能起作用的，但不正确。获得边缘值 `min` 和 `max` 的概率比其他值低两倍。
 
-如果你多次运行这个例子，你会很容易看到 `2` 出现的频率最高。
+如果你将上面这个例子运行多次，你会很容易看到 `2` 出现的频率最高。
 
-发生这种情况是因为 `Math.round()` 从间隔 `1..3` 获得随机数并按如下所示进行四舍五入：
+发生这种情况是因为 `Math.round()` 从范围 `1..3` 中获得随机数，并按如下所示进行四舍五入：
 
 ```js no-beautify
 values from 1    ... to 1.4999999999  become 1
@@ -27,12 +27,12 @@ values from 2.5  ... to 2.9999999999  become 3
 
 # 正确的解决方案
 
-这项任务有很多正确的解决方案。其中之一是调整间隔边界。为了确保相同的时间间隔，我们可以生成从 0.5 到 3.5 的值，从而将所需的概率添加到边缘：
+这个题目有很多正确的解决方案。其中之一是调整取值范围的边界。为了确保相同的取值范围，我们可以生成从 0.5 到 3.5 的值，从而将所需的概率添加到取值范围的边界：
 
 ```js run
 *!*
 function randomInteger(min, max) {
-  // now rand is from  (min-0.5) to (max+0.5)
+  // 现在范围是从  (min-0.5) 到 (max+0.5)
   let rand = min - 0.5 + Math.random() * (max - min + 1);
   return Math.round(rand);
 }
@@ -41,7 +41,7 @@ function randomInteger(min, max) {
 alert( randomInteger(1, 3) );
 ```
 
-另一种方法是使用 `Math.floor` 作为从 `min` 到 `max+1` 的随机数：
+另一种方法是使用 `Math.floor` 来取范围从 `min` 到 `max+1` 的随机数：
 
 ```js run
 *!*
@@ -63,4 +63,4 @@ values from 2  ... to 2.9999999999  become 2
 values from 3  ... to 3.9999999999  become 3
 ```
 
-所有间隔的长度相同，所以最终能够均匀分配。所有整数出现的概率都相同了。
+所有间隔的长度相同，从而使最终能够均匀分配。
diff --git a/1-js/05-data-types/02-number/9-random-int-min-max/task.md b/1-js/05-data-types/02-number/9-random-int-min-max/task.md
@@ -2,19 +2,19 @@ importance: 2
 
 ---
 
-# 从最小到最大的随机整数
+# 从 min 到 max 的随机整数
 
-创建一个函数 `randomInteger(min，max)`，该函数从 `min` 到 `max` 生成随机整数，包括 `min` 和 `max` 作为可能值。
+创建一个函数 `randomInteger(min，max)`，该函数会生成一个范围在 `min` 到 `max` 中的随机整数，包括 `min` 和 `max`。
 
-来自间隔 `min..max` 的任何数字必须以相同的概率出现。
+在 `min..max` 范围中的所有数字的出现概率必须相同。
 
 
-功能示例：
+运行示例：
 
 ```js
-alert( random(1, 5) ); // 1
-alert( random(1, 5) ); // 3
-alert( random(1, 5) ); // 5
+alert( randomInteger(1, 5) ); // 1
+alert( randomInteger(1, 5) ); // 3
+alert( randomInteger(1, 5) ); // 5
 ```
 
-您可以使用[上一个任务](info:task/random-min-max)的解决方案作为基础。
+你可以使用 [上一个任务](info:task/random-min-max) 的解决方案作为基础。