From 4fe7bb195315912ea57415d2c700d45172f4ae8e Mon Sep 17 00:00:00 2001 From: LeviDing Date: Fri, 7 Feb 2020 22:27:49 +0800 Subject: [PATCH 01/17] Update article.md --- 1-js/05-data-types/02-number/article.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md index 0bc8381e1c..b9e96f3ba3 100644 --- a/1-js/05-data-types/02-number/article.md +++ b/1-js/05-data-types/02-number/article.md @@ -1,8 +1,12 @@ # 数字类型 -JavaScript 中的所有数字都以 64 位格式 [IEEE-754](http://en.wikipedia.org/wiki/IEEE_754-1985) 存储，也称为“双精度”。 +在现代 JavaScript 中，有两种类型的数字： -让我们回顾一下并展开我们目前了解的内容。 +1. JavaScript 中常规的数字以 64 位的形式 [IEEE-754](http://en.wikipedia.org/wiki/IEEE_754-1985) 存储，也称为“双精度浮点数”。这些是我们大多数时候使用的数字，我们将在本章中讨论它们。 + +2. BigInt 数字，用于表示任意长度的整数。有时会用到它们，因为常规的数字类型无法表示大于 253 或小于 -253 的数字。由于 BigInt 只会在少数特殊领域中才会用到，因此我们在特殊的章节 中对齐进行了介绍。 + +因此，这里我们将讨论常规的数字类型。让我们开始学习它们吧。 ## 编写数字的更多方法 From f62d54f30945ae9c5a7c0bec0da58056655ef231 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sat, 8 Feb 2020 12:28:39 +0800 Subject: [PATCH 02/17] Update article.md --- 1-js/05-data-types/02-number/article.md | 37 ++++++++++++------------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md index b9e96f3ba3..cb1efd9745 100644 --- a/1-js/05-data-types/02-number/article.md +++ b/1-js/05-data-types/02-number/article.md @@ -4,37 +4,37 @@ 1. JavaScript 中常规的数字以 64 位的形式 [IEEE-754](http://en.wikipedia.org/wiki/IEEE_754-1985) 存储，也称为“双精度浮点数”。这些是我们大多数时候使用的数字，我们将在本章中讨论它们。 -2. BigInt 数字，用于表示任意长度的整数。有时会用到它们，因为常规的数字类型无法表示大于 253 或小于 -253 的数字。由于 BigInt 只会在少数特殊领域中才会用到，因此我们在特殊的章节 中对齐进行了介绍。 +2. BigInt 数字，用于表示任意长度的整数。有时会用到它们，因为常规的数字类型无法表示大于 253 或小于 -253 的数字。由于 BigInt 只会在少数特殊领域中才会用到，因此我们在特殊的章节 中对其进行了介绍。 因此，这里我们将讨论常规的数字类型。让我们开始学习它们吧。 ## 编写数字的更多方法 -想象一下，我们需要写 10 亿。显而易见的方法是： +想象一下，我们需要写 10 亿。显而易见的方式是： ```js let billion = 1000000000; ``` -但在现实生活中，我们通常避免写一长串零，因为它很容易输入错误。另外，我们很懒。我们通常会为十亿或七十三亿写一些类似于 `1bn` 的数字，为 `7.3bn`。对于大多数人来说也是如此。 +但在现实生活中，我们通常避免写一长串零，因为它很容易输入错误。另外，我们很懒。我们通常会将 10 亿或 73 亿写成类似于 `1bn` 和 `7.3bn` 的形式。对于大多数人来说也是如此。 在 JavaScript 中，我们通过在数字后附加字母 "e" 来缩短数字，并指定零的数量来计数： ```js run -let billion = 1e9; // 1 billion, literally: 1 and 9 zeroes +let billion = 1e9; // 10 亿，字面意义：1 和 9 个零 -alert( 7.3e9 ); // 7.3 billions (7,300,000,000) +alert( 7.3e9 ); // 73 亿（7,300,000,000） ``` -换句话说，`"e"` 把数字乘以 `1` 后面跟着指定数量的 0。 +换句话说，`"e"` 把数字乘以 `1` 后面跟着给定数量的 0 的数来计数。 ```js 1e3 = 1 * 1000 1.23e6 = 1.23 * 1000000 ``` - 现在让我们写一些非常小的东西。例如：1 微秒（百万分之一秒）： + ```js let ms = 0.000001; ``` @@ -42,41 +42,40 @@ let ms = 0.000001; 就像以前一样，使用 `"e"` 可以提供帮助。如果我们想避免明确地写零，我们可以说： ```js -let ms = 1e-6; // six zeroes to the left from 1 +let ms = 1e-6; // 1 左边有 6 个 0 ``` +如果我们数一下 `0.000001` 中的零，共有 6 个。所以自然是 `1e-6`。 -如果我们计算 `0.000001` 中的零，则有 6 个。所以自然是 `1e-6`。 - -换句话说，`e` 后面的负数表示除以 1 后面跟着给定数量的 0： +换句话说，`e` 后面的负数表示除以 1 后面跟着给定数量的 0 的数： ```js -// -3 divides by 1 with 3 zeroes +// -3 除以 1 后面有 3 个 0 的数 1e-3 = 1 / 1000 (=0.001) -// -6 divides by 1 with 6 zeroes +// -6 除以 1 后面有 6 个 0 的数 1.23e-6 = 1.23 / 1000000 (=0.00000123) ``` ### 十六进制，二进制和八进制数字 -[十六进制](https://en.wikipedia.org/wiki/Hexadecimal)数字在 JavaScript 中被广泛用于表示颜色，编码字符以及其他许多事物。所以很自然地，写一个更简短的方法：`0x` 然后是数字。 +[十六进制](https://en.wikipedia.org/wiki/Hexadecimal) 数字在 JavaScript 中被广泛用于表示颜色，编码字符以及其他许多事物。所以很自然地，这有一种更简短的编写方法：`0x` 后面加上数字。 例如： ```js run alert( 0xff ); // 255 -alert( 0xFF ); // 255 (the same, case doesn't matter) +alert( 0xFF ); // 255（一样，与大小写无关） ``` -虽然二进制和八进制数字系统很少使用，但也支持使用 `0b` 和 `0o` 前缀： +虽然二进制和八进制数字系统很少使用，但也可以使用 `0b` 和 `0o` 前缀来编写： ```js run -let a = 0b11111111; // binary form of 255 -let b = 0o377; // octal form of 255 +let a = 0b11111111; // 二进制形式的 255 +let b = 0o377; // 八进制形式的 255 -alert( a == b ); // true, the same number 255 at both sides +alert( a == b ); // true，两边都是数字 255 ``` 只有这三种进制支持这种写法。对于其他进制，我们应该使用函数 `parseInt`（我们将在本章后面看到）。 From 4880ee40a8855aae17833c346b8d11090c2cde27 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sat, 8 Feb 2020 21:32:32 +0800 Subject: [PATCH 03/17] Update article.md --- 1-js/05-data-types/02-number/article.md | 164 ++++++++++++------------ 1 file changed, 80 insertions(+), 84 deletions(-) diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md index cb1efd9745..baf16d90b7 100644 --- a/1-js/05-data-types/02-number/article.md +++ b/1-js/05-data-types/02-number/article.md @@ -82,9 +82,9 @@ alert( a == b ); // true，两边都是数字 255 ## toString(base) -方法 `num.toString(base)` 返回带有给定 `base` 的进制中 `num` 的字符串表示。 +方法 `num.toString(base)` 返回带有给定 `base` 的进制中数字 `num` 的字符串表示。 -举个例子： +例如： ```js run let num = 255; @@ -98,18 +98,18 @@ alert( num.toString(2) ); // 11111111 - **base=16** 用于十六进制颜色，字符编码等，数字可以是 `0..9` 或 `A..F`。 - **base=2** 主要用于调试按位操作，数字可以是 `0` 或 `1`。 -- **base=36** 是最大值，数字可以是 `0..9` 或 `A..Z`。整个拉丁字母用来表示一个数字。对于 `36` 来说，一个有趣而有用的例子是，当我们需要将一个较长的数字标识符变成较短的时候，例如做一个简短的URL。可以简单地用基数为 `36` 的数字系统表示： +- **base=36** 是最大值，数字可以是 `0..9` 或 `A..Z`。整个拉丁字母用来表示一个数字。对于 `36` 来说，一个有趣且有用的例子是，当我们需要将一个较长的数字标识符变成较短的时候，例如做一个简短的URL。可以简单地用基数为 `36` 的数字系统表示： ```js run alert( 123456..toString(36) ); // 2n9c ``` -```warn header="调用方法的两个点" -请注意 `123456..toString(36)` 中的两个点不是拼写错误。如果我们想直接在一个数字上调用一个方法，比如上面例子中的 `toString`，那么我们需要在它后面放置两个点 `..`。 +```warn header="两给点来调用方法" +请注意 `123456..toString(36)` 中的两个点不是拼写错误。如果我们想直接在一个数字上调用一个方法，比如上面例子中的 `toString`，那么我们需要在这个数字的后面放置两个点 `..`。 -如果我们放置一个点：`123456.toString(36)`，那么会出现错误，因为 JavaScript 语法暗示了第一个点之后的小数部分。如果我们再放一个点，那么 JavaScript 知道小数部分是空的，现在进入方法。 +如果我们放置一个点：`123456.toString(36)`，那么就会出现错误，因为 JavaScript 语法默认第一个点之后的部分是小数部分。如果我们再放一个点，那么 JavaScript 知道小数部分是空的，现在进入方法。 -也可以写 `(123456).toString(36)`。 +也可以写成 `(123456).toString(36)`。 ``` ## 数值修约（Rounding） @@ -125,10 +125,10 @@ alert( num.toString(2) ); // 11111111 : 向上舍入：`3.1` 变成 `4`，`-1.1` 变成 `-1`。 `Math.round` -: 向最近的整数舍入：`3.1` 变成 `3`, 3.6` 变成 `4`，`-1.1` 变成 `-1`。 +: 向最近的整数舍入：`3.1` 变成 `3`，`3.6` 变成 `4`，`-1.1` 变成 `-1`。 `Math.trunc`（IE 浏览器不支持这个方法） -: 删除小数点后的所有内容而不舍入：`3.1` 变成 `3`，`-1.1` 变成 `-1`。 +: 删除小数点后的所有内容而不进行舍入：`3.1` 变成 `3`，`-1.1` 变成 `-1`。 以下是总结它们之间差异的表格： @@ -140,47 +140,47 @@ alert( num.toString(2) ); // 11111111 |`-1.6`| `-2` | `-1` | `-2` | `-1` | -这些函数涵盖处理数字小数部分的所有可能方法。但是如果我们想在十进制后将数字四舍五入到 `n` 位呢？ +这些函数涵盖了处理数字小数部分的所有可能方法。但是如果我们想将数字四舍五入到小数点后的第 `n` 个数字，该怎么办呢？ -例如，我们有 `1.2345`，并且想把它舍入到 2 位数，只得到 `1.23`。 +例如，我们有 `1.2345`，并且想把它舍入到小数点后 2 位，只需要得到 `1.23`。 有两种方法可以这样做： 1. 乘法和除法 - 例如，要将数字四舍五入到小数点后的第二个数字，我们可以将数字乘以 100，调用舍入函数，然后再将其除回 100。 + 例如，要将数字四舍五入到小数点后的第二个数字，我们可以将数字乘以 100，调用舍入函数，然后再通过除法将其转换回来。 ```js run let num = 1.23456; alert( Math.floor(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23 ``` -2. 函数 [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) 将点数后的数字四舍五入到 `n` 个数字并返回结果的字符串表示。 +2. 方法 [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) 将小数点后的数字四舍五入到 `n` 个，返回结果的字符串表示。 ```js run let num = 12.34; alert( num.toFixed(1) ); // "12.3" ``` - 这会向上或向下舍入到最接近的值，类似于 `Math.round`： + 这个方法会将数字向最近的值进行舍入，类似于 `Math.round`： ```js run let num = 12.36; alert( num.toFixed(1) ); // "12.4" ``` - 请注意 `toFixed` 的结果是一个字符串。如果小数部分比所需要的短，则在结尾添加零： + 请注意 `toFixed` 的结果是一个字符串。如果小数部分比所需要的短，则会在末尾添加零： ```js run let num = 12.34; - alert( num.toFixed(5) ); // "12.34000", added zeroes to make exactly 5 digits + alert( num.toFixed(5) ); // "12.34000"，添加 0，以精确生成小数点后五位的小数 ``` - 我们可以使用一元加号或 `Number()` 调用将其转换为数字：`+ num.toFixed(5)`。 + 我们可以使用一元加号或 `Number()` 调用，将其转换为数字：`+num.toFixed(5)`。 ## 不精确计算 -在 js 内部，一个数字以 64 位格式 [IEEE-754](http://en.wikipedia.org/wiki/IEEE_754-1985) 表示，所以正好有 64 位可以存储一个数字：其中 52 个被使用存储这些数字，其中 11 个存储小数点的位置（它们对于整数为零），1 位用于符号。 +在 JavaScript 内部，一个数字是以 64 位的格式 [IEEE-754](https://en.wikipedia.org/wiki/IEEE_754-2008_revision) 表示的，所以正好有 64 位可以存储一个数字：其中 52 位被用于存储数字，11 位用于存储小数点的位置（对于整数则为零），剩下的 1 位用于存储符号。 如果一个数字太大，它会溢出 64 位存储，可能会输出无穷大： @@ -196,7 +196,7 @@ alert( 1e500 ); // Infinity alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!* ``` -没错，如果我们检查 `0.1` 和 `0.2` 的总和是否为 `0.3`，们会得到 `false`。 +这是对的，如果我们检查 `0.1` 和 `0.2` 的和是否为 `0.3`，我们会得到 `false`。 奇怪！那么如果不是 `0.3`，那么又是什么呢？ @@ -204,17 +204,17 @@ alert( 0.1 + 0.2 == 0.3 ); // *!*false*/!* alert( 0.1 + 0.2 ); // 0.30000000000000004 ``` -哎哟!这里的错误有更大的误差。想象一下，你正在制作一个电子购物网站，访问者将 `0.10 美元` 和 `0.20 美元` 商品放入他的图表中。订单总额将是 `$ 0.30000000000000004`。这会让任何人感到惊讶。 +啥！这个结果造成的后果会比一个错误的比较要大得多。想象一下，你正在建立一个电子购物网站，访问者将 `0.10 美元` 和 `0.20 美元` 的商品放入了他的购物车中。订单总额为 `$ 0.30000000000000004`。这会让任何人感到惊讶。 但为什么会发生这样的事呢？ -一个数字以二进制形式存储在内存中，一个 1 和 0 的序列。但是像十进制数字系统看起来很简单的 `0.1`，`0.2` 这样的小数实际上是二进制形式的循环小数。 +一个数字以二进制形式存储在内存中，一个 1 和 0 的序列。但是在十进制数字系统看起来很简单的 `0.1`，`0.2` 这样的小数，实际上是二进制形式的无限循环小数。 -换句话说，什么是 `0.1`？`0.1` 就是把 1 除以 10 `1/10`，即十分之一。在十进制数字系统中，这些数字很容易表示。将它比作三分之一：`1/3`。它变成了循环小数 `0.33333(3)`。 +换句话说，什么是 `0.1`？`0.1` 就是把 1 除以 10 `1/10`，即十分之一。在十进制数字系统中，这些数字很容易表示。而对于数字三分之一：`1/3`。则为无限循环小数 `0.33333(3)`。 -所以，按这种用 `10` 划分可以保证在十进制系统中运行良好，但用 `3` 划分不是。出于同样的原因，在二进制数字系统中，`2` 的幂的分割保证工作，但 `1/10` 变成一个无限的二进制小数。 +因此，按这种用 `10` 划分可以保证在十进制系统中运行良好，但用 `3` 划分则不行。出于同样的原因，在二进制数字系统中，`2` 的幂的分割可以保证工作，但 `1/10` 变成了一个无限的二进制小数。 -使用二进制系统无法*精确*存储 *0.1* 或 *0.2*，就像没有办法将三分之一存储为十进制小数一样。 +使用二进制系统无法 **精确** 存储 *0.1* 或 *0.2*，就像没有办法将三分之一精确存储为十进制小数一样。 数字格式 IEEE-754 通过四舍五入到最接近的可能数字来解决此问题。这些舍入规则通常不允许我们看到 `极小的精确度损失`，因此数字显示为 `0.3`。但要小心，损失依然存在。 @@ -223,66 +223,62 @@ alert( 0.1 + 0.2 ); // 0.30000000000000004 alert( 0.1.toFixed(20) ); // 0.10000000000000000555 ``` -当我们给两个数字求和时，他们的“精度损失”会加起来。 +当我们给两个数字求和时，它们的“精度损失”会加起来。 -这就是为什么 `0.1 + 0.2` 不等于 `0.3` 的原因。 +这就是为什么 `0.1 + 0.2` 不等于 `0.3`。 ```smart header="不仅仅是 JavaScript" 许多其他编程语言也存在同样的问题。 -PHP, Java, C, Perl, Ruby 给出完全相同的结果，因为它们基于相同的数字格式。 +PHP，Java，C，Perl，Ruby 都给出了完全相同的结果，因为它们都基于相同的数字格式。 ``` -我们能解决这个问题吗？当然，有很多方法： - -1. 我们可以在特定函数的帮助下对结果进行四舍五入 [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 sum = 0.1 + 0.2; - alert( sum.toFixed(2) ); // 0.30 - ``` +```js run +let sum = 0.1 + 0.2; +alert( sum.toFixed(2) ); // 0.30 +``` - 请注意 `toFixed` 总是返回一个字符串。它确保它在小数点后有 2 位数字。如果我们有电子购物并需要显示 `0.30 美元`，这实际上很方便。对于其他情况，我们可以使用一元加号将它强制为一个数字： +请注意 `toFixed` 总是返回一个字符串。它确保小数点后有 2 位数字。如果我们有电子购物并需要显示 `0.30 美元`，这实际上很方便。对于其他情况，我们可以使用一元加号将其强制转换为数字： - ```js run - let sum = 0.1 + 0.2; - alert( +sum.toFixed(2) ); // 0.3 - ``` +```js run +let sum = 0.1 + 0.2; +alert( +sum.toFixed(2) ); // 0.3 +``` -2. 我们可以暂时将数字转换为数学整数，然后将其恢复。它是这样工作的： +我们可以将数字暂时乘以 100（或更大的数字），将其转换为整数进行数学运算，然后通过除法将其恢复。当我们使用整数进行数学运算时，误差有所减少，但在进行除法操作时仍会造成误差： - ```js run - alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3 - alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001 - ``` +```js run +alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3 +alert( (0.28 * 100 + 0.14 * 100) / 100); // 0.4200000000000001 +``` - 这是有效的，因为当我们做 `0.1 * 10 = 1` 和 `0.2 * 10 = 2` 时，那么这两个数字就变成了整数，并且没有精度损失。 +因此，乘/除法可以减少误差，但是不能完全消除误差。 -3. 如果我们在与一家商店打交道，那么最激进的解决方案就是将所有价格存储在美分中，并且根本不使用分数。但是，如果我们应用 30％ 的折扣呢？在实践中，完全回避分数是很难实现的，所以上述解决方案有助于避免这种缺陷。 +有时我们可以尝试完全避开小数。就像我们与一家商店打交道一样，我们可以用美分而不是美元来存储价格。但是，如果我们应用 30% 的折扣呢？实际上，完全逃避小数几乎是不可能的。只需要在需要时将它们切分成圆形即可。 -````smart header="有趣的事情" +````smart header="有趣的事儿" 尝试运行这个： ```js run -// Hello! I'm a self-increasing number! -alert( 9999999999999999 ); // shows 10000000000000000 +// 你好！我是一个自增数！ +alert( 9999999999999999 ); // 显示 10000000000000000 ``` -出现了同样的问题：精度的损失。该号码有 64 位，其中 52 位可用于存储数字，但这还不够。所以最不重要的数字就消失了。 +这出现了同样的问题：精度的损失。计算机中以 64 位的格式存储数字，其中 52 位可用于存储数字，但这还不够。所以最不重要的数字就消失了。 -JavaScript 在这种事件中不会触发错误。它尽最大努力使数字符合所需的格式，但不幸的是，这种格式不够大到满足需求。 +JavaScript 在这种情况下不会触发错误。它尽最大努力使数字符合所需的格式，但不幸的是，这种格式不够大到满足需求。 ```` ```smart header="两个零" 数字内部表示的另一个有趣结果是存在两个零：`0` 和 `-0`。 -这是因为一个符号由一个位表示，所以每个数字可以是正数或负数，包括零。 +这是因为符号是由一个位表示的，所以每个数字都可以是正数或负数，包括零。 -在大多数情况下，这种区别并不明显，因为操作员可以将它们视为相同。 +在大多数情况下，这种区别并不明显，因为操作符将它们视为相同的。 ``` - - ## 测试：isFinite 和 isNaN 还记得这两个特殊的数值吗？ @@ -290,7 +286,7 @@ JavaScript 在这种事件中不会触发错误。它尽最大努力使数字符 - `Infinity`（和 `-Infinity`）是一个特殊的数值，比任何数值都大（小）。 - `NaN` 代表一个错误。 -它们属于 `数字` 类型，但不是 `普通` 数字，因此有特殊函数可以检查它们： +它们属于 `数字` 类型，但不是 `普通` 数字，因此有用于检查它们的特殊函数： - `isNaN(value)` 将其参数转换为数字，然后测试它是否为 `NaN`： @@ -300,38 +296,38 @@ JavaScript 在这种事件中不会触发错误。它尽最大努力使数字符 alert( isNaN("str") ); // true ``` - 但是我们需要这个功能吗？我们不能只使用比较 `=== NaN` 吗？对不起，但答案是否定的。值 "NaN" 是独一无二的，它不等于任何东西，包括它本身： + 但是我们需要这个函数吗？我们不能只使用比较 `=== NaN` 吗？对不起，答案是否定的。值 "NaN" 是独一无二的，它不等于任何东西，包括它本身： ```js run alert( NaN === NaN ); // false ``` -- `isFinite(value)` 将其参数转换为数字，如果是常规数字，则返回 `true`，而不是 `NaN / Infinity / -Infinity`： +- `isFinite(value)` 将其参数转换为数字，如果是常规数字，则返回 `true`，而不是 `NaN/Infinity/-Infinity`： ```js run alert( isFinite("15") ); // true - alert( isFinite("str") ); // false, because a special value: NaN - alert( isFinite(Infinity) ); // false, because a special value: Infinity + alert( isFinite("str") ); // false，因为是一个特殊的值：NaN + alert( isFinite(Infinity) ); // false，因为是一个特殊的值：Infinity ``` -有时 `isFinite` 用于验证字符串值是否为常规数字： +有时 `isFinite` 用于验证字符串值是否为一个常规数字： ```js run let num = +prompt("Enter a number", ''); -// 结果会是 true，除非你输入无穷大，无穷大或不是数字 +// 结果会是 true，除非你输入 Infinity，-Infinity 或非数字 alert( isFinite(num) ); ``` -请注意，所有数字函数（包括 `isFinite`）中的空字符串或空格字符串均被视为 `0`。 +请注意，所有数字函数（包括 `isFinite`）均将空字符串或空格字符串视为 `0`。 ```smart header="与 Object.is 进行比较" -有一种特殊的内置方法 [Object.is](mdn:js/Object/is)，它可以比较 `===` 等值，但对于两种边缘情况更可靠： +有一种特殊的内置方法 [Object.is](mdn:js/Object/is)，它可以像 `===` 一样对值进行比较，但对于两种边缘情况更可靠： -1. 它适用于 `NaN`： `Object.is（NaN，NaN）=== true`，这是件好事。 -2. 值 `0` 和 `-0` 是不同的：`Object.is（0，-0）=== false`，它不是很重要，但这些值在技术上是不同的。 +1. 它适用于 `NaN`：`Object.is（NaN，NaN）=== true`，这是件好事。 +2. 值 `0` 和 `-0` 是不同的：`Object.is（0，-0）=== false`，从技术上讲，这个比较结果是对的，因为在计算机内部，数字的符号位可能是不同的，即使其他所有位均为零也是如此。 在所有其他情况下，`Object.is(a，b)` 与 `a === b` 相同。 @@ -341,7 +337,7 @@ alert( isFinite(num) ); ## parseInt 和 parseFloat -使用加号 `+` 或 `Number()` 的数字转换是严格的。如果一个值不完全是一个数字，就会失败： +使用加号 `+` 或 `Number()` 的数字转换是严格的。如果一个值不完全是数字，就会失败： ```js run alert( +"100px" ); // NaN @@ -349,24 +345,24 @@ alert( +"100px" ); // NaN 唯一的例外是字符串开头或结尾的空格，因为它们会被忽略。 -但在现实生活中，我们经常以单位表示值，比如 CSS 中的 `"100px"` 或 `"12pt"`。在许多国家，货币符号也超过了金额，所以我们有 `"19€"`，并希望从中提取一个数值。 +但在现实生活中，我们经常看到有单位的值，比如 CSS 中的 `"100px"` 或 `"12pt"`。并且在许多国家，货币符号被放在了金额的后面，所以我们有 `"19€"`，并希望从中提取出一个数值。 这就是 `parseInt` 和 `parseFloat` 的作用。 -它们从字符串中“读出”一个数字，直到无法读取为止。如果发生错误，则返回收集的数字。函数 `parseInt` 返回一个整数，而 `parseFloat` 将返回一个浮点数： +它们从字符串中“读出”一个数字，直到无法读取为止。如果发生错误，则返回收集到的数字。函数 `parseInt` 返回一个整数，而 `parseFloat` 返回一个浮点数： ```js run alert( parseInt('100px') ); // 100 alert( parseFloat('12.5em') ); // 12.5 -alert( parseInt('12.3') ); // 12, only the integer part is returned -alert( parseFloat('12.3.4') ); // 12.3, the second point stops the reading +alert( parseInt('12.3') ); // 12，只有整数部分被返回 only the integer part is returned +alert( parseFloat('12.3.4') ); // 12.3，第二个点终止了数字“读取” ``` 有时候 `parseInt / parseFloat` 会返回 `NaN`。一般发生在没有数字可读的情况下： ```js run -alert( parseInt('a123') ); // NaN, the first symbol stops the process +alert( parseInt('a123') ); // NaN，第一个符号终止了“读取” ``` ````smart header="parseInt(str, radix)` 的第二个参数" @@ -374,7 +370,7 @@ alert( parseInt('a123') ); // NaN, the first symbol stops the process ```js run alert( parseInt('0xff', 16) ); // 255 -alert( parseInt('ff', 16) ); // 255, without 0x also works +alert( parseInt('ff', 16) ); // 255，没有 0x 也有效 alert( parseInt('2n9c', 36) ); // 123456 ``` @@ -410,30 +406,30 @@ JavaScript 有一个内置的 [Math](https://developer.mozilla.org/en/docs/Web/J alert( Math.pow(2, 10) ); // 2 的 10 次幂 = 1024 ``` -这里有 `Math` 对象中的更多函数和常量，包括三角函数，你可以在这里找到它 [docs for the Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math)。 +这里有 `Math` 对象中的更多函数和常量，包括三角函数，你可以在 [Math 的文档](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 中找到它们。 ## 总结 -写非常大的数字： +要写有很多零的数字： - 附加 `"e"` 来省略 0，e 后面的数字就是零的个数。就像：`123e6` 是 `123` 后面接 6 个零。 -- `"e"` 后面的负数将导致数字除以 1 后面接着给定数量的零。e-6 那是一百万分之一。 +- `"e"` 后面的负数会使数字除以 1 后面接着给定数量的零。例如 `123e-6` 表示 `0.000123`（`123` 百万分之一）。 对于不同的进制： - 可以在十六进制（`0x`），八进制（`0o`）和二进制（`0b`）系统中直接写入数字。 -- `parseInt(str，base)` 解析来自任何数字系统的整数，其基数为：`2≤base≤36`。 -- `num.toString(base)` 将数字转换为数字系统中具有给定 `base` 的字符串。 +- `parseInt(str，base)` 在给定的基数（base）下，将字符串 `str` 解析为整数，其中基数范围为：`2 ≤ base ≤ 36`。 +- `num.toString(base)` 在给定的基数（base）下，将数字转换为字符串。 -将 `12pt` 和 `100px` 等值转换为数字： +将像 `12pt` 和 `100px` 这样的值转换为数字： -- 使用 `parseInt / parseFloat` 进行 `软` 转换，它从字符串中读取一个数字，然后返回错误发生前可以读取的值。 +- 使用 `parseInt / parseFloat` 进行“软”转换，它从字符串中读取一个数字，然后返回在错误发生前可以读取到的数字。 -分数： +对于小数： -- 使用 `Math.floor`、`Math.ceil`、`Math.trunc`、`Math.round` 或 `num.toFixed(precision)` 截取。 -- 请记住，使用分数时会损失精度。 +- 使用 `Math.floor`、`Math.ceil`、`Math.trunc`、`Math.round` 或 `num.toFixed(precision)` 进行舍入。 +- 请记住，使用小数时也会损失精度。 更多的数学函数： -- 需要时请参阅 [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 对象,虽然这个文档非常小,但是它可以满足基础的要求。 +- 需要时请参阅 [Math](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math) 对象文档。虽然这个文档非常小，但是可以满足基本的需求。 From 18668cad28ae8f13b0d6cd4f19baa18121edd186 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sat, 8 Feb 2020 21:42:30 +0800 Subject: [PATCH 04/17] Update task.md --- 1-js/05-data-types/02-number/1-sum-interface/task.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index 123a44d6e1..5c0c0aba38 100644 --- 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] -提示：类型会有一个问题。 +提示：这有一个类型陷阱。 From a0dfa5ef24ccf2de36d22b39b87121d19cc4e90b Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sat, 8 Feb 2020 21:52:14 +0800 Subject: [PATCH 05/17] Update solution.md --- 1-js/05-data-types/02-number/1-sum-interface/solution.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index 96b2eef2cc..e49e7e5dcf 100644 --- 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"`。 From 96cd08ac7794e7d0bb0e8b34e3c8eeec2b825afb Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sat, 8 Feb 2020 22:57:53 +0800 Subject: [PATCH 06/17] Update task.md --- 1-js/05-data-types/02-number/2-why-rounded-down/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 711704ff51..fb8effbbe3 100644 --- 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,7 +4,7 @@ importance: 4 # 为什么 6.35.toFixed(1) == 6.3？ -根据文档 `Math.round` 和 `toFixed`，最近的数字四舍五入：`0..4` 会被舍去，而 `5..9` 会前进一位。 +根据文档 `Math.round` 和 `toFixed` 均将数字进行四舍五入：`0..4` 会被舍去，而 `5..9` 会前进一位。 例如： From 1c692fab0413fb6bf514fc0793c742bac677ca3e Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 09:32:40 +0800 Subject: [PATCH 07/17] Update solution.md --- .../02-number/2-why-rounded-down/solution.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) 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 index 6aa1ef7eb0..68e67cb793 100644 --- 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,4 +1,4 @@ -在 `6.35` 内部，小数部分是一个无限的二进制。在这种情况下，它存储的时候有一个精度的缺失。 +在 `6.35` 内部，小数部分是一个无限的二进制。在这种情况下，它的存储会存在一个精度的损失。 让我们来看看： @@ -6,25 +6,25 @@ alert( 6.35.toFixed(20) ); // 6.34999999999999964473 ``` -精度缺失可能会导致数字的增加和减小。在这种特殊情况下，数字可能会变小了一点，这就是为什么它减小了。 +精度损失可能会导致数字的增加和减小。在这种特殊情况下，数字可能会变小了一点，这就是为什么它减小了。 -那么 `1.35` 是怎样样的呢？ +那么 `1.35` 是怎样的呢？ ```js run alert( 1.35.toFixed(20) ); // 1.35000000000000008882 ``` -在这里，精度缺失使得这个数字更大一些，所以这个数字变大了一些。 +在这里，精度损失使得这个数字更大了一些，所以这个数字变大了一些。 **如果我们希望以正确的方式四舍五入，我们如何使用 `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 From 579ee5b927f5575213e53524d03d7833974f4dc4 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 09:33:58 +0800 Subject: [PATCH 08/17] Fix typo --- .../02-number/3-repeat-until-number/_js.view/test.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js b/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js index 219fa8068e..6bd0123dba 100644 --- a/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js +++ b/1-js/05-data-types/02-number/3-repeat-until-number/_js.view/test.js @@ -18,7 +18,7 @@ describe("readNumber", function() { assert.strictEqual(readNumber(), 0); }); - it("continues the loop unti meets a number", function() { + it("continues the loop until meets a number", function() { prompt.onCall(0).returns("not a number"); prompt.onCall(1).returns("not a number again"); prompt.onCall(2).returns("1"); @@ -35,4 +35,4 @@ describe("readNumber", function() { assert.isNull(readNumber()); }); -}); \ No newline at end of file +}); From c3c95449daf9670aa26d60c1ce8cbae36b73f7c2 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 09:56:21 +0800 Subject: [PATCH 09/17] Update task.md --- 1-js/05-data-types/02-number/3-repeat-until-number/task.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 index 1ea3e3d33e..c689e91d1a 100644 --- 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,12 @@ importance: 5 --- -# 重复检测，直到输入是一个数字 +# 重复检测，直到输入的是一个数字 -创建一个函数 `readNumber`，它提示输入一个数字，直到访问者输入一个有效的数字。 +创建一个函数 `readNumber`，它提示输入一个数字，直到访问者输入一个有效的数字为止。 结果值必须作为数字返回。 -访问者也可以通过输入空行或按“取消”来停止该过程。在这种情况下，函数应该返回 `null`。 +访问者也可以通过输入空行或点击“取消”来停止该过程。在这种情况下，函数应该返回 `null`。 [demo] From d04a434d808b48ec128cdf0a47ba5b2717c89261 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 10:29:03 +0800 Subject: [PATCH 10/17] Update solution.md --- .../02-number/3-repeat-until-number/solution.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 index 30c000b3b0..3da8eee13d 100644 --- 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,8 @@ function readNumber() { alert(`Read: ${readNumber()}`); ``` -该解决方案有点复杂，可能是因为我们需要处理 null/空行。 +该解决方案有点复杂，可能是因为我们需要处理 `null`/空行。 -所以我们实际上接受输入，直到它成为“常规数字”。null（取消）和空行都适合该条件，因为在数字形式中它们是 `0`。 +所以我们实际上一直接受输入，直到输入的内容为“常规数字”。`null`（取消）和空行也都适合该条件，因为在数字形式中它们是 `0`。 -在我们停止之后，我们需要专门处理 null 和空行（返回 null），因为将它们转换为数字将返回 `0`。 +在我们停止之后，我们需要专门处理 `null` 和空行（返回 `null`），因为将它们转换为数字将返回 `0`。 From 6c60c6cb48f3a5ea09c549713cddcdbd49695f70 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 10:34:44 +0800 Subject: [PATCH 11/17] Update solution.md --- .../02-number/4-endless-loop-error/solution.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) 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 index 16201a3458..08a47fc1fd 100644 --- 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` 这样的小数时出现了精度损失。 -结论：在处理小数部分时避免相等检查。 +结论：在处理小数部分时，应避免相等检查。 From 169df64b3e1940905594e4bb0cabc385422a2848 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 10:39:00 +0800 Subject: [PATCH 12/17] Update task.md --- 1-js/05-data-types/02-number/8-random-min-max/task.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index ecfa3447b6..f263c9d2f4 100644 --- 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 @@ -4,9 +4,9 @@ importance: 2 # 从最小到最大的随机数 -用内置函数Math.random() 创建一个从 0 到 1 的随机值（不包括 1 ）。 +内置函数 `Math.random()` 会创建一个 `0` 到 `1` 的随机值（不包括 `1`）。 -编写随机函数（min，max）以生成从最小到最大（不包括最大值）的随机浮点数。 +编写随机函数 `random(min, max)` 以生成从最小到最大（不包括最大值）的随机浮点数。 实例： From 04de03abf01d8dd495a953c059c542eb1ff273d4 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 10:52:44 +0800 Subject: [PATCH 13/17] Update solution.md --- 1-js/05-data-types/02-number/8-random-min-max/solution.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 index 562be1f62f..a1eed8e6e5 100644 --- 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`。 函数实现： From a385bf05aee76ed33126fe52f8c275258c8705c4 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 10:56:45 +0800 Subject: [PATCH 14/17] Update task.md --- 1-js/05-data-types/02-number/8-random-min-max/task.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index f263c9d2f4..5563b261fd 100644 --- 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,11 +2,11 @@ importance: 2 --- -# 从最小到最大的随机数 +# 从 min 到 max 的随机数 内置函数 `Math.random()` 会创建一个 `0` 到 `1` 的随机值（不包括 `1`）。 -编写随机函数 `random(min, max)` 以生成从最小到最大（不包括最大值）的随机浮点数。 +编写函数 `random(min, max)` 以生成从 `min` 到 `max`（不包括 `max`）的随机浮点数。 实例： From 4b11f07bd5ae98595d0de2d5ebace7666561377f Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 11:00:05 +0800 Subject: [PATCH 15/17] Update task.md --- 1-js/05-data-types/02-number/9-random-int-min-max/task.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) 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 index 8ae2b30676..001d5a1146 100644 --- 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,11 +2,11 @@ importance: 2 --- -# 从最小到最大的随机整数 +# 从 min 到 max 的随机整数 -创建一个函数 `randomInteger(min，max)`，该函数从 `min` 到 `max` 生成随机整数，包括 `min` 和 `max` 作为可能值。 +创建一个函数 `randomInteger(min，max)`，该函数会生成从 `min` 到 `max` 的随机整数，生成的值包括 `min` 和 `max`。 -来自间隔 `min..max` 的任何数字必须以相同的概率出现。 +取值范围在 `min..max` 中的任何数字出现的概率必须相同。 功能示例： @@ -17,4 +17,4 @@ alert( random(1, 5) ); // 3 alert( random(1, 5) ); // 5 ``` -您可以使用[上一个任务](info:task/random-min-max)的解决方案作为基础。 +你可以使用 [上一个任务](info:task/random-min-max) 的解决方案作为基础。 From 59d47b39e6c2c947ff4dd2f5cef4582f85f1d933 Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 11:26:21 +0800 Subject: [PATCH 16/17] Update task.md --- 1-js/05-data-types/02-number/9-random-int-min-max/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 001d5a1146..1f67bcddfa 100644 --- 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 @@ -4,7 +4,7 @@ importance: 2 # 从 min 到 max 的随机整数 -创建一个函数 `randomInteger(min，max)`，该函数会生成从 `min` 到 `max` 的随机整数，生成的值包括 `min` 和 `max`。 +创建一个函数 `randomInteger(min, max)`，该函数会生成从 `min` 到 `max` 的随机整数，生成的值包括 `min` 和 `max`。 取值范围在 `min..max` 中的任何数字出现的概率必须相同。 From 83a992869b60712de5f2748caf0430efb93c960d Mon Sep 17 00:00:00 2001 From: LeviDing Date: Sun, 9 Feb 2020 11:33:02 +0800 Subject: [PATCH 17/17] Update solution.md --- .../02-number/9-random-int-min-max/solution.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) 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 index b9c7a095e0..309378857b 100644 --- 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 ``` -所有间隔的长度相同，所以最终能够均匀分配。所有整数出现的概率都相同了。 +所有间隔的长度相同，从而使最终能够均匀分配。