重学js —— Number 原型对象和实例上的属性(tofixed/toLocaleString/toPrecision/toString等)

[lizhongzhen11]

Number 原型对象和实例上的属性

• 接 重学js —— js数据类型：Number 对象
• 即固有对象 %NumberPrototype%
• 属于 普通对象
• 其本身是 Number 对象；有 [[NumberData]] 内置插槽值为 +0
• 有 [[Prototype]] 内置插槽其值为 %Object.prototype%

thisNumberValue(value)

1. 如果 value 是 Number 类型，返回 value
2. 如果 value 是对象类型且 value 有 [[NumberData]] 内置插槽
   1. 定义 n 为 value.[[NumberData]]
   2. 断言：n 是 Number 类型
   3. 返回 n
3. 抛 TypeError 异常

规范中短语 "this Number value" 表示将方法的 this 值作为参数传给抽象操作 thisNumberValue 调用后返回的结果

Number.prototype.constructor

初始值为 %Number%

Number.prototype.toExponential ( fractionDigits )

• MDN

// 有趣
// 和 https://github.com/lizhongzhen11/lizz-blog/issues/96 提到的思考本质是一样的
77.toExponential() // 报错
77..toExponential() // "7.7e+1"
77                 .toExponential() // "7.7e+1"

1. 定义 x 为 ? thisNumberValue(this 值)

2. 定义 f 为 ? ToInteger(fractionDigits)

3. 断言：如果 fractionDigits 为 undefined，则 f 为 0

4. 如果 x 不是有限的，返回 ! Number::toString(x)

5. 如果 f < 0 或 f > 100，抛 RangeError 异常

6. 定义 s 为空字符串

7. 如果 x < 0，

   1. 设置 s 为 "-"
   2. 设置 x 为 -x

8. 如果 x = 0，

   1. 定义 m 为字符串，由 f + 1 处出现的码位 0x0030（数字0） 组成
   2. 定义 e 为 0

9. 否则，

   1. 如果 fractionDigits 不是 undefined，
      1. 定义 e 和 n 为整数，使得 10^f ≤ n < 10^{f + 1} 并且 R(n) x 10_R^{R(e) - R(n)} - R(x) 尽可能的接近0。如果有两对 e 和 n，选满足 R(n) x 10_R^{R(e) - R(f)} 运算较大的那一对。
   2. 否则，
      1. 定义 e，n 和 f 为整数，使得 f ≥ 0，10^f ≤ n < 10^{f + 1}，R(n) x 10_R^{R(e) - R(f)} 的 Number 值为 x，并且 f 尽可能的小。注意 n 的十进制表示有 f + 1 个数字，n 不能被 10 整除，但是这些标准不一定能唯一确定 n 的最低有效位。
   3. 定义 m 为字符串，由 n 的十进制表示数字组成（按顺序，没有前导零）

10. 如果 f ≠ 0

    1. 定义 a 为 m 的第一个码位，定义 b 为 m 的剩余 f 位码位。
    2. 设置 m 为 a，"." 和 b 的字符拼接

11. 如果 e = 0，

    1. 定义 c 为 "+"
    2. 定义 d 为 "0"

12. 否则，

    1. 如果 e > 0，定义 c 为 "+"
    2. 否则，
       1. 断言：e < 0
       2. 定义 c 为 "-"
       3. 设置 e 为 -e
    3. 定义 d 为字符串，由 e 的十进制表示数字组成（按顺序，没有前导零）

13. 设置 m 为 m，"e"，c 和 d 的字符拼接

14. 返回 s 和 m 的字符拼接

Number.prototype.toFixed ( fractionDigits )

• MDN
• 规范中是介于 0 ~ 100(超过20会转字符串)，但是MDN说介于 0 ~ 20，实现环境可能支持更大范围

2.34.toFixed(3) // '2.340'
2.45.toFixed(1) // '2.5'
2.55.toFixed(1) // '2.5'
-2.34.toFixed(1) // -2.3
(-2.34).toFixed(1) // '-2.3'

2.34.toFixed(100) // 自己去试下吧

1. 定义 x 为 ? thisNumberValue(this 值)
2. 定义 f 为 ? ToInteger(fractionDigits)
3. 断言：如果 fractionDigits 为 undefined，则 f 为 0
4. 如果 f < 0 或 f > 100，抛 RangeError 异常
5. 如果 x 不是有限的，返回 ! Number::toString(x)
6. 定义 s 为空字符串
7. 如果 x < 0，
   1. 设置 s 为 "-"
   2. 设置 x 为 -x
8. 如果 x ≥ 10²¹，
   1. 定义 m 为 ! ToString(x)
9. 否则，
   1. 定义 n 为满足 R(n) ÷ 10_R^R(f) - R(x) 运算中尽可能接近0的整数。如果有两个 n，选择较大的。
   2. 如果 n = 0，定义 m 为字符 "0"。否则，定义 m 为字符串，由 n 的十进制表示数字组成。（按顺序，没有前导零）
   3. 如果 f ≠ 0，
      1. 定义 k 为 m 的长度
      2. 如果 k ≤ f，
         1. 定义 z 为字符串，由 f + 1 - k 处出现的码位 0x0030（数字0） 组成
         2. 设置 m 为 z 和 m 的字符拼接
         3. 设置 k 为 f + 1
      3. 定义 a 为 m 的前 k - f 码位，定义 b 为 m 的剩余 f 个码位
      4. 设置 m 为 a，"." 和 b 的字符拼接
10. 返回 s 和 m 的字符拼接

对于某些值，toFixed 的输出可能比 toString 更精确，因为 toString 仅打印足够的有效数字以将数字与相邻数字值区分开。

(1000000000000000128).toString() // "1000000000000000100"
(1000000000000000128).toFixed(0) // "1000000000000000128"

Number.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )

• MDN

// 好方便啊，我真第一次知道
123456789 .toLocaleString() // "123,456,789"

Number.prototype.toPrecision ( precision )

• MDN

1. 定义 x 为 ? thisNumberValue(this 值)
2. 如果 precision 为 undefined，返回 ! ToString(x)
3. 定义 p ? ToInteger(precision)
4. 如果 x 不是有限的，返回 ! Number::toString
5. 如果 p < 1 或 p > 100，抛 RangeError 异常
6. 定义 s 为空字符串
7. 如果 x < 0，
   1. 设置 s 为码位 0x002D（减号）
   2. 设置 x 为 -x
8. 如果 x = 0，
   1. 定义 m 为字符串，由 p 处d的码位 0x0030（数字0） 组成
   2. 定义 e 为 0
9. 否则
   1. 定义 e 和 n 为整数，使得 10^{p - 1} ≤ n < 10^p，同时满足 R(n) × 10_R^{R(e) - R(p) + 1_R} - R(x) 运算结果尽可能的接近0。如果有两对 e 和 n，选择执行 R(n) × 10_R^{R(e) - R(p) + 1_R} 运算结果较大的那对。
   2. 定义 m 为字符串，由 n 的十进制表示数字组成（按顺序，没有前导零）
   3. 如果 e < -6 或 e ≥ p
      1. 断言：e ≠ 0
      2. 如果 p ≠ 1，
         1. 定义 a 为 m 的第一个码位，定义 b 为 m 剩下的 p - 1 位码位
         2. 设置 m 为 a，"."，和 b 的字符拼接
      3. 如果 e > 0，
         1. 定义 c 为码位 0x002B（加号）
      4. 否则，
         1. 断言：e < 0
         2. 定义 c 为码位 0x002D（减号）
         3. 设置 e 为 -e
      5. 定义 d 为字符串，由 e 的十进制表示数字组成（按顺序，没有前导零）
      6. 返回 s，m，码位 0x0065（拉丁文小写字母E），c 和 d 的字符拼接
10. 如果 e = p - 1，返回 s 和 m 的字符串拼接
11. 如果 e ≥ 0，
    1. 设置 m 为 m 的前 e + 1 位码位，码位 0x002E（句号），以及 m 剩余的 p - (e + 1) 的字符拼接
12. 否则，
    1. 设置 m 为码位 0x0030（数字0），码位 0x002E（句号），-(e + 1) 处的码位 0x0030（数字0） 和字符 m 的字符拼接
13. 返回 s 和 m 的字符串拼接

Number.prototype.toString ( [ radix ] )

• MDN

1. 定义 x 为 ? thisNumberValue(this 值)
2. 如果 radix 为 undefined，定义 radixNumber 为 10
3. 否则，定义 radixNumber 为 ? ToInteger(radix)
4. 如果 radixNumber < 2 或 radixNumber > 36，抛 RangeError 异常
5. 如果 radixNumber = 10，返回 ! ToString(x)
6. 返回使用 radixNumber 做基数的 Number 值的字符串表示。字母a-z用于数值从10到35的数字。精度算法与实现有关，但是，该算法应该是 Number::toString(x) 中指定的算法的概括。

该方法的 "length" 属性值为 1.

Number.prototype.valueOf ( )

• MDN

1. 返回 ? thisNumberValue(this 值)

Number 实例属性

属于普通对象，属性继承自 Number 原型对象。实例也有 [[NumberData]] 内置插槽。该插槽表示该 Number 对象的 Number 类型值

为何 2.45.toFixed(1) 是 '2.5' 而 2.55.toFixed(1) 还是 '2.5'？

主要还是浮点运算问题。看算法内部，走第9步：

• 对于 2.45，n 要满足 n ÷ 10 - 2.45 尽可能接近 0，即 n 要尽可能接近 24.5且是整数
• 对于 2.55，n 要满足 n ÷ 10 - 2.55 尽可能接近 0，即 n 要尽可能接近 25.5且是整数

由于js采用 IEEE-754 64位双精度浮点类型来表示数字，所以先要得出 25.5 的二进制表示，然后再确定最接近的那个整数。这个算起来好麻烦。。。

2020-07-31 补充

Daily-Interview-Question 第143题

我第一想法就是用 toLocaleString，不过转换成 . 真没记住。。。