1 背景

卖家明天做广告推广，新增曝光率 1000，商品总曝光量达 11500，很快乐，上平台一看，显示 1.1 w 曝光率，很纳闷，按四舍五入计算，也应该是 1.2w 才对吧，怎么回事呢？
​

通过排查发现是 JS 的 toFixed 的 bug。

2 toFixed 是什么？

来自 MDN 的定义：

toFixed()返回 numObj 不应用指数表示法并且 digits 在小数点后准确地具备 数字的字符串示意模式。如有必要，数字会四舍五入，并在必要时用零填充小数局部，使其具备指定的长度。如果 的绝对值 numObj 大于或等于 1e+21，则此办法调用 Number.prototype.toString() 并返回指数表示法的字符串。

而在下方有正告：

正告：浮点数不能以二进制准确示意所有小数。这可能会导致意外后果，例如 0.1 + 0.2 === 0.3 返回 false.

通过 Chrome 浏览器控制台进行测试：

(1.15).toFixed(1)
// "1.1"
(1.25).toFixed(1)
// "1.3"
(1.35).toFixed(1)
// "1.4"
(1.45).toFixed(1)
// "1.4"
(1.55).toFixed(1)
// "1.6"

从上能够看到 toFixed 在局部例子中的确是有问题的。JS 并不辨别整数和浮点数，只有 Number 类型，即都是浮点数，采纳的是 IEEE 754 规范的 64 位双精度格局。

3 什么是 IEEE 754

来自百度百科的定义：

IEEE 二进制浮点数算术规范（IEEE 754）是 20 世纪 80 年代以来最宽泛应用的浮点数运算规范，为许多 CPU 与浮点运算器所采纳。这个规范定义了示意浮点数的格局（包含负零 -0）与反常值（denormal number）），一些非凡数值（无穷（Inf）与非数值（NaN）），以及这些数值的“浮点数运算符”；它也指明了四种数值舍入规定和五种例外情况（包含例外产生的机会与解决形式）。
IEEE 754 规定了四种示意浮点数值的形式：单精确度（32 位）、双精确度（64 位）、延长单精确度（43 比特以上，很少应用）与延长双精确度（79 比特以上，通常以 80 位实现）。只有 32 位模式有强制要求，其余都是选择性的。大部分编程语言都有提供 IEEE 浮点数格局与算术，但有些将其列为非必须的。例如，IEEE 754 问世之前就有的 C 语言，有包含 IEEE 算术，但不算作强制要求（C 语言的 float 通常是指 IEEE 单精确度，而 double 是指双精确度）。

​

IEEE 浮点数规范是从逻辑上用三元组 {S，E，M} 来示意一个数 V 的，即 V=（-1）S×M×2^E:
​

以 IEEE 754 规范 64 位双精度 里的 9.625 值为例：
​

[S（符号位）] [E（指数位）] [M（有效数字位）]
[0] [10000000010] [0011010000000000000000000000000000000000000000000000]
​

其中的指数位值 = 实在指数值 + 偏移量值（1023），偏移量 = 2^(k-1) – 1，其中 k 示意指数位位数 11 位；

3.1 指数偏移量

因为指数能够为负数，也能够为正数，为了解决负指数的状况，理论的指数值按要求须要加上一个偏移量（Bias）值作为保留在指数段中的值，

3.2 指数位

规格化：S + (E!=0 && E!=2047) + 1.M
非规格化：S + 000 00000000 + M
无穷大：S + 111 11111111 + 00000000 00000000 00000000 00000000 00000000 00000000 0000
无穷大变种（NAN)：S + 111 11111111 + (M!=0)
​

规格化的状况：即上述的个别状况，因为阶码不能为 0 也不能为 2047，所以指数不能为 -1023，也不会为 1024，只有这种状况才会有隐含位 1。
​

非规范化状况：此时阶码全为 0，指数为 -1023，如尾数全为 0，则浮点数示意正负 0；否则示意那些十分的靠近于 0.0 的数。

3.3 无效尾数位

浮点数的示意办法有很多种，例如 9.625 10^3，又能够示意为 0.9625 10^4、96.25 * 10^2。而 IEEE 浮点数规范依照迷信计数法，首位只可能是 1，对此 IEEE 754 省略了这个默认的 1，所以无效尾数有 53 位。
​

这时候有个问题，尾数 M 省略的 1 肯定会存在，以至于浮点数无奈示意 0.0，怎么示意？
符号位是 0，指数段全为 0，而小数段也全为 0），这就失去 M=f=0。令人奇怪的是，当符号位为 1，而其余段全为 0 时，就会失去值 -0.0。依据 IEEE 的浮点格局来看，值 +0.0 和 -0.0 在某些方面是不同的。

3.4 举个例子

以 -9.625 来看转化过程：

1. 负号 S 位为 1，取绝对值转二进制得：1001.101，（整数除 2 取余，小数乘 2 取整，沿着小数点排列）
2. 迷信计数法：1.001101 * 2 ^ 3
3. 计算指数位：00 000000011 (指数真值 3）+ 011 11111111（偏移量 1023）= 100 00000010
4. 最终存储值：1[00110100 00000000 00000000 00000000 00000000 00000000 0000]

但并不是所有的十进制小数都能够用浮点数示意，以 1.15 为例，转化为二进制位：
1.001001100110011001100110011001100110011001100110011……
​

以 0011 有限循环上来，但对于计算机而言，存储长度是无限的，因而最终存储值为：
0[0010011001100110011001100110011001100110011001100110]，
​

所以 1.15 实际上是 1.14999999999999991118215802999，很显著能够看进去，四舍五入后果是 1.1，也就是 因为 IEEE 754 浮点算术规范无奈用二进制准确示意十进制数，导致四舍五入的后果和预期不合乎。

4 JSCore toFixed 源码实现

4.1 ECMAScript 标准

ecmaScript 标准里对于 Number.prototype.toFixed(fractionDigits) 的 实现标准：

toFixed 返回一个蕴含此 Number 值的字符串，以十进制定点表示法示意，小数点后有 fractionDigits 位。如果 fractionDigits 未定义，则假设 为 0。
​

执行以下步骤：

1. 令 x 为 thisNumberValue(this value)。
2. ReturnIfAbrupt (x)。
3. 令 f 为 ToInteger (fractionDigits)。（如果 fractionDigits 是 undefined，这一步会产生值 0）。
4. ReturnIfAbrupt (f)。
5. 如果 f < 0 或 f > 20，则抛出 RangeError 异样。然而，容许实现扩大 f 小于 0 或大于 20 的 toFixed 值的行为。在这种状况下，不肯定会为此类值抛出 RangeError。toFixed
6. 如果 x 是 NaN，则返回 String “NaN”。
7. 让 s 成为空字符串。

8. 如果 x < 0，则

   1. 让小号是“-”。
   2. 让 x = – x。

9. 如果 x ≥ 10 21，则

   1. 让 m = ToString (x)。

10. 否则 x < 10 21 ,

    1. 设 n 是一个整数，n ÷ 10 f – x 的准确数学值尽可能接近于零。如果有两个这样的 n，则抉择较大的 n。
    2. 如果 n = 0，则让 m 为 String “0”。否则，让 m 是由 n 的十进制示意的数字组成的字符串（按程序，没有前导零）。

    3. 如果 f ≠0，则

       1. 令 k 为 m 中的元素数。

       2. 如果 k ≤ f，则

          1. 设 z 是由代码单元 0x0030 的 f +1– k 次呈现组成的字符串。
          2. 让 m 是字符串 z 和 m 的串联。
          3. 令 k = f + 1。
       3. 设 a 为 m 的前 k – f 个元素，设 b 为 m 的其余 f 个元素。
       4. 让米是三个字符串的串联一个，”.” 和 b。
11. 返回字符串 s 和 m 的串联。

​

按上述说法，对 (1.15).toFixed(1) 来说，咱们找到两个数：

11 / 10 - 1.15 //  -0.04999999999999982
12 / 10 - 1.15 // 0.050000000000000044

能够看到前者后果更靠近于 0，所以取 1.1。
​

如果两者都靠近于 0，则取两个中更大的整数，例如对 99.55 来说：

995/10 - 99.55 // -0.04999999999999716
996/10 - 99.55 //  0.04999999999999716

此时应该取 99.6，但当咱们在浏览器控制台运行 (99.55).toFixed(1) 时，失去的却是 99.5，难道浏览器没有依照标准实现？

4.2 webkit javascript core toFixed 实现

4.2.1 Webkit 编译和调试

JSCrore/WebKit 设置和调试

4.2.1.1 获取 webkit 源码

# Clone the WebKit repository from GitHub
git clone git://git.webkit.org/WebKit.git WebKit.git

4.2.1.2 构建 webkit

（1）xcode 装置

# Install
$ xcode-select --install
already installed...

# Make sure xcode path is properly set
$ xcode-select -p
/Applications/Xcode.app/Contents/Developer

# Confirm installation
$ xcodebuild -version
Xcode 10.1
Build version 10B61

（2）执行构建 JSC (JavaScriptCore) 的脚本作为调试构建。

# Run the script which builds the WebKit
Tools/Scripts/build-webkit --jsc-only --debug

# jsc-only : JavaScriptCore only
# debug    : With debug symbols

留神：装置 cmake 后 path not found, 将 cmake 命令增加到环境变量中，关上 home 目录下的 .bash_profile 文件退出上面两句，保留批改即可：

# Add Cmake Root to Path
export CMAKE_ROOT=/Applications/CMake.app/Contents/bin/
export PATH=$CMAKE_ROOT:$PATH

（3）设置 lldb（lldb 是一个相似于 gdb 的调试器。咱们能够应用 lldb 来调试 jsc）

# Incase of a python error, run the following
$ alias lldb='PATH="/usr/bin:$PATH"lldb'

# Load the file to the  debugger
$ lldb ./WebKitBuild/Debug/bin/jsc
(lldb) target create "./WebKitBuild/Debug/bin/jsc"
Current executable set to './WebKitBuild/Debug/bin/jsc' (x86_64).
(lldb) run
Process 4233 launched: './WebKitBuild/Debug/bin/jsc' (x86_64)
>>> 

lldb 相干命令

x/8gx address #查看内存地址 address

next(n) #单步执行
step(s) #进入函数
continue(c) #将程序运行到完结或者断点处（进入下一断点）finish #将程序运行到以后函数返回（从函数跳出）breakpoint(b) 行号 / 函数名 < 条件语句 > #设置断点
fr v #查看局部变量信息
print(p) x #输入变量 x 的值

4.2.2 源码剖析

4.2.2.1 入口，各种状况的解决

EncodedJSValue JSC_HOST_CALL numberProtoFuncToFixed(JSGlobalObject* globalObject, CallFrame* callFrame)
{VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    // x 取值 99.549999999999997
    double x;
    if (!toThisNumber(vm, callFrame->thisValue(), x))
        return throwVMToThisNumberError(globalObject, scope, callFrame->thisValue());

    // decimalPlaces 取值 1
    int decimalPlaces = static_cast<int>(callFrame->argument(0).toInteger(globalObject));
    RETURN_IF_EXCEPTION(scope, {});

    // 非凡解决，略
    if (decimalPlaces < 0 || decimalPlaces > 100)
        return throwVMRangeError(globalObject, scope, "toFixed() argument must be between 0 and 100"_s);

    // x 的非凡解决，略
    if (!(fabs(x) < 1e+21))
        return JSValue::encode(jsString(vm, String::number(x)));

    // NaN or Infinity 的非凡解决
    ASSERT(std::isfinite(x));

    // 进入执行 number=99.549999999999997, decimalPlaces=1
    return JSValue::encode(jsString(vm, String::numberToStringFixedWidth(x, decimalPlaces)));
}

从 numberToStringFixedWidth 办法一直进入，达到 FastFixedDtoa 解决办法
​

须要留神的是，原数值的整数和小数局部都别离采纳了指数表示法，不便前面位运算解决
99.549999999999997 = 7005208482886451 2 -46 = 99 + 38702809297715 2 -46

4.2.2.2 拆散整数局部和小数局部

// FastFixedDtoa(v=99.549999999999997, fractional_count=1, buffer=(start_ = "", length_ = 122), length=0x00007ffeefbfd488, decimal_point=0x00007ffeefbfd494)

bool FastFixedDtoa(double v,
                   int fractional_count,
                   BufferReference<char> buffer,
                   int* length,
                   int* decimal_point) {
  const uint32_t kMaxUInt32 = 0xFFFFFFFF;
  // 将 v 示意成 尾数(significand) × 底数(2) ^ 指数(exponent) 
  // 7005208482886451 x 2 ^ -46
  uint64_t significand = Double(v).Significand();
  int exponent = Double(v).Exponent();

  // 省略局部代码

  if (exponent + kDoubleSignificandSize > 64) {// ...} else if (exponent >= 0) {// ...} else if (exponent > -kDoubleSignificandSize) {
    // exponent > -53 的状况, 切割数字

    // 整数局部: integrals = 7005208482886451 >> 46 = 99 
    uint64_t integrals = significand >> -exponent;
    // 小数局部(指数表达法的尾数局部): fractionals = 7005208482886451 - 99 << 46  = 38702809297715
    // 指数不变 -46
    // 38702809297715 * (2 ** -46) = 0.5499999999999972
    uint64_t fractionals = significand - (integrals << -exponent);
    if (integrals > kMaxUInt32) {FillDigits64(integrals, buffer, length);
    } else {
      // buffer 中放入 "99"
      FillDigits32(static_cast<uint32_t>(integrals), buffer, length);
    }
    *decimal_point = *length;
    // 填充小数局部，buffer 为 "995"
    FillFractionals(fractionals, exponent, fractional_count,
                    buffer, length, decimal_point);
  } else if (exponent < -128) {// ...} else {// ...}
  TrimZeros(buffer, length, decimal_point);
  buffer[*length] = '\0';
  if ((*length) == 0) {
    // The string is empty and the decimal_point thus has no importance. Mimick
    // Gay's dtoa and and set it to -fractional_count.
    *decimal_point = -fractional_count;
  }
  return true;
}

4.2.2.3 对小数局部进行截取和进位

FillFractionals 用来填充小数局部，取几位，是否进位都在该办法中解决

// FillFractionals(fractionals=38702809297715, exponent=-46, fractional_count=1, buffer=(start_ = "99", length_ = 122), length=0x00007ffeefbfd488, decimal_point=0x00007ffeefbfd494)

/*
小数局部的二进制表示法：fractionals * 2 ^ exponent
38702809297715 * (2 ** -46) = 0.5499999999999972

前提：-128 <= exponent <=0。0 <= fractionals * 2 ^ exponent < 1 
  buffer 能够保留后果
此函数将舍入后果。在舍入过程中，此函数未生成的数字可能会更新，且小数点变量可能会更新。如果此函数生成数字 99，并且缓冲区曾经蕴含“199”（因而产生的缓冲区为“19999”），则向上舍入会将缓冲区的内容更改为“20000”。*/
static void FillFractionals(uint64_t fractionals, int exponent,
                            int fractional_count, BufferReference<char> buffer,
                            int* length, int* decimal_point) {ASSERT(-128 <= exponent && exponent <= 0);
  if (-exponent <= 64) {ASSERT(fractionals >> 56 == 0);
    int point = -exponent; // 46

    // 每次迭代，将小数乘以 10，去除整数局部放入 buffer

    for (int i = 0; i < fractional_count; ++i) { // 0->1
      if (fractionals == 0) break;

      // fractionals 乘以 5 而不是乘以 10，并调整 point 的地位，这样，fractionals 变量将不会溢出。而后整体相当于乘以 10
      // 不会溢出的验证过程：// 循环初始：fractionals < 2 ^ point , point <= 64 且 fractionals < 2 ^ 56
      // 每次迭代后，point--。// 留神 5 ^ 3 = 125 < 128 = 2 ^ 7。// 因而，此循环的三个迭代不会溢出 fractionals（即便在循环体开端没有减法）。// 与此同时 point 将满足 point <= 61，因而 fractionals < 2 ^ point，并且 fractionals 再乘以 5 将不会溢出(<int64)。// 该操作不会溢出，证实见上方
      fractionals *= 5; // 193514046488575
      point--; // 45
      int digit = static_cast<int>(fractionals >> point); // 193514046488575 * 2 ** -45 = 5
      ASSERT(digit <= 9);
      buffer[*length] = static_cast<char>('0' + digit); // '995'
      (*length)++;
      // 去掉整数位
      fractionals -= static_cast<uint64_t>(digit) << point; // 193514046488575 - 5 * 2 ** 45 = 17592186044415 
      // 17592186044415 * 2 ** -45 = 0.4999999999999716 
    }
    // 看小数的下一位是否值得让 buffer 中元素进位
    // 通过乘 2 看是否能 >=1 来判断
    ASSERT(fractionals == 0 || point - 1 >= 0);
    // 本例中 17592186044415 >> 44 = 17592186044415 * 2 ** -44 = 0.9999999999999432 , & 1 = 0
    if ((fractionals != 0) && ((fractionals >> (point - 1)) & 1) == 1) {RoundUp(buffer, length, decimal_point);
    }
  } else {  // We need 128 bits.
    // ...
  }
}

这样就失去了 995，即标准形容中的 n，前面插入一个小数点即为最终后果 99.5。

4.2.3 总结

js 引擎并没有按标准中说的，去寻找一个 n，使其 n / (10 ^ f) 尽可能等于 x，而是将 x 分为整数和小数局部，并采纳指数表示法别离进行计算。
​

解决小数的时候，让小数点右移。用指数表示法的时候，有个细节思考了底数间接 10 可能会导致溢出，而后采纳了底数 5，指数递加 1 的形式。在 f 位计算后，最初再计算下一位，看是否须要进位。
​

当然，最终后果不合乎咱们日常的计算，外围还是在于 IEEE 754 表示法中，99.55 在调试初期取值就是 99.549999999999997。

5 拓展

5.1 JS 能示意的最大最小值

数的范畴有两个概念，最大负数和最小正数，最小负数和最大正数。
​

从 S、E、M 三个维度看，S 示意正负，E 为指数示意大小，M 有效数字位示意精度。
​

下面咱们说到规格化下：
E 最大值为 111 11111110 – 011 11111111（偏移量）= 011 11111111 = 1023，失去指数值的范畴为 [-2^1023，2^1023]，即 [-8.98846567431158e+307, 8.98846567431158e+307]；
M 有效数字位的最大值是 11111111 11111111 11111111 11111111 11111111 11111111 1111，加上默认的整数 1，尾数值有限靠近 2；
综上可得最大负数有限靠近于 2 * (8.98846567431158e+307) = 1.797693134862316e+307，最小负数有限靠近于 -1.797693134862316e+307；
再看下 JS 定义的最大值 Number.MAX_VALUE = 1.7976931348623157e+308，和咱们计算出来的最大负数挺靠近的；
所以数字的范畴是 [-1.7976931348623157e+308, 1.7976931348623157e+308]，超过这个范畴，在 JS 中会显示为 Infinity 或 -Infinity。

接下来看最小负数和最大正数，下面提到在非规格化下，指数位值为 0 且有效数字位值不为 0 时，示意有限靠近于 0 的数；
此时 E 值为 = 000 00000001 – 011 11111111（偏移量）+ 1 = -100 00000000（减 1 取反）= -1022，失去指数值的最小值为 2^-1022 = 2.2250738585072014e-308；
而有效数字位值可取的非 0 最小值为 0.00000000 00000000 00000000 00000000 00000000 00000000 0001 = 2^-52
能够失去最小正数值为 2^-1022 * 2^-52 = 2^-1074 = 5e-324;
而 JS 的 Number.MIN_VALUE = 5e-324；正好和咱们计算出来的统一；

5.3 业界解决方案

准确四舍五入
银行家四舍五入
……