引擎剖析：JS 中的字符串转数值

JS 中，字符串转数值的方式有以下 9 种：

• parseInt()
• parseFloat()
• Number()
• Double tilde (~~) Operator
• Unary Operator (+)
• Math.floor()
• Multiply with number
• The Signed Right Shift Operator(>>)
• The Unsigned Right Shift Operator(>>>)

这几种方式对运行结果的差异，如下表所示：

> 对比表格的源码发布到了 https://airing.ursb.me/web/int.html，需要可自取。

除了运行结果上的存在差异之外，这些方法在性能上也存在着差异。在 NodeJS V8 环境下，这几个方法微基准测试的结果如下：

parseInt() x 19,140,190 ops/sec ±0.45% (92 runs sampled)
parseFloat() x 28,203,053 ops/sec ±0.25% (95 runs sampled)
Number() x 1,041,209,524 ops/sec ±0.20% (90 runs sampled)
Double tilde (~~) Operator x 1,035,220,963 ops/sec ±1.65% (97 runs sampled)
Math.floor() x 28,224,678 ops/sec ±0.23% (96 runs sampled)
Unary Operator (+) x 1,045,129,381 ops/sec ±0.17% (95 runs sampled)
Multiply with number x 1,044,176,084 ops/sec ±0.15% (93 runs sampled)
The Signed Right Shift Operator(>>) x 1,046,016,782 ops/sec ±0.11% (96 runs sampled)
The Unsigned Right Shift Operator(>>>) x 1,045,384,959 ops/sec ±0.08% (96 runs sampled)

可见，parseInt()，parseFloat()，Math.floor() 的效率最低，只有其他运算 2% 左右的效率，而其中又以parseInt()最慢，仅有 1%。

为什么这些方法存在着这些差异？这些运算在引擎层又是如何被解释执行的？接下来将从 V8、JavaScriptCore、QuickJS 等主流 JS 引擎的视角，探究这些方法的具体实现。

首先来看看 parsrInt()。

1. parseInt()

ECMAScript (ECMA-262) parseInt

1.1 V8 中的 parseInt()

在 V8 [→ src/init/bootstrapper.cc] 中定义了 JS 语言内置的标准对象，我们可以找到其中关于 parseInt 的定义：

`Handle number_fun = InstallFunction(isolate_, global, “Number”, JS_PRIMITIVE_WRAPPER_TYPE, JSPrimitiveWrapper::kHeaderSize, 0, isolate_->initial_object_prototype(), Builtin::kNumberConstructor);

// Install Number.parseInt and Global.parseInt. Handle parse_int_fun = SimpleInstallFunction(isolate_, number_fun, “parseInt”, Builtin::kNumberParseInt, 2, true);

JSObject::AddProperty(isolate_, global_object, “parseInt”, parse_int_fun, native_context()->set_global_parse_int_fun(*parse_int_fun); `

可以见，Number.parseInt 和全局对象的 parseInt 都是基于 SimpleInstallFunction 注册的，它会将 API 安装到 isolate 中，并将该方法与 Builtin 做绑定。JS 侧调用 pasreInt 即为引擎侧调用 Builtin::kNumberParseInt。

Builtin (Built-in Functions) 是 V8 中在 VM 运行时可执行的代码块，用于表达运行时对 VM 的更改。目前 V8 版本中 Builtin 有下述 5 种实现方式：

• Platform-dependent assembly language：很高效，但需要手动适配到所有平台，并且难以维护。
• C++：风格与runtime functions非常相似，可以访问 V8 强大的运行时功能，但通常不适合性能敏感区域。
• JavaScript：缓慢的运行时调用，受类型污染导致的不可预测的性能影响，以及复杂的 JS语义问题。现在 V8 不再使用 JavaScript 内置函数。
• CodeStubAssembler：提供高效的低级功能，非常接近汇编语言，同时保持平台依赖无关性和可读性。
• Torque：是 CodeStubAssembler 的改进版，其语法结合了 TypeScript 的一些特征，非常简单易读。强调在不损失性能的前提下尽量降低使用难度，让 Builtin 的开发更加容易一些。目前不少内置函数都是由 Torque 实现的。

回到前文 Builtin::kNumberParseInt 这个函数，在 [→ src/builtins/builtins.h] 中可以看到其定义：

// Convenience macro to avoid generating named accessors for all builtins. #define BUILTIN_CODE(isolate, name) \ (isolate)->builtins()->code_handle(i::Builtin::k##name)

因此这个函数注册的原名是 NumberParseInt，实现在 [→ src/builtins/number.tq] 中，是个基于 Torque 的 Builtin 实现。

`// ES6 #sec-number.parseint transitioning javascript builtin NumberParseInt( js-implicit context: NativeContext)(value: JSAny, radix: JSAny): Number { return ParseInt(value, radix); }

transitioning builtin ParseInt(implicit context: Context)( input: JSAny, radix: JSAny): Number { try { // Check if radix should be 10 (i.e. undefined, 0 or 10). if (radix != Undefined && !TaggedEqual(radix, SmiConstant(10)) && !TaggedEqual(radix, SmiConstant(0))) { goto CallRuntime; }

typeswitch (input) {
  case (s: Smi): {
    return s;
  }
  case (h: HeapNumber): {
    // Check if the input value is in Signed32 range.
    const asFloat64: float64 = Convert<float64>(h);
    const asInt32: int32 = Signed(TruncateFloat64ToWord32(asFloat64));
    // The sense of comparison is important for the NaN case.
    if (asFloat64 == ChangeInt32ToFloat64(asInt32)) goto Int32(asInt32);

    // Check if the absolute value of input is in the [1,1<<31[ range. Call
    // the runtime for the range [0,1[ because the result could be -0.
    const kMaxAbsValue: float64 = 2147483648.0;
    const absInput: float64 = math::Float64Abs(asFloat64);
    if (absInput < kMaxAbsValue && absInput >= 1.0) goto Int32(asInt32);
    goto CallRuntime;
  }
  case (s: String): {
    goto String(s);
  }
  case (HeapObject): {
    goto CallRuntime;
  }
}

} label Int32(i: int32) { return ChangeInt32ToTagged(i); } label String(s: String) { // Check if the string is a cached array index. const hash: NameHash = s.raw_hash_field; if (IsIntegerIndex(hash) && hash.array_index_length < kMaxCachedArrayIndexLength) { const arrayIndex: uint32 = hash.array_index_value; return SmiFromUint32(arrayIndex); } // Fall back to the runtime. goto CallRuntime; } label CallRuntime { tail runtime::StringParseInt(input, radix); } } `

看这段代码前，先科普下 V8 中的几个数据结构：（V8 所有数据结构的定义可以见 [→ src/objects/objects.h]）

• Smi：继承自 Object，immediate small integer，只有 31 位
• HeapObject：继承自 Object，superclass for everything allocated in the heap
• PrimitiveHeapObject：继承自 HeapObject
• HeapNumber：继承自 PrimitiveHeapObject，存储了数字的堆对象，用于保存大整形的对象。

我们知道 parseInt 接收两个形参， 即 parseInt(string, radix)，此处亦如是。 实现流程如下：

• 首先判断 radix 是否没传或者传了 0 或 10，如果不是，那么则不是十进制的转换，就走 runtime 中提供的 StringParseInt 函数 runtime::StringParseInt；
• 如果是十进制转换就继续走，判断第一个参数的数据类型。
• 如果是 Smi 或者是没有越界（超 31 位）的 HeapNumber，那么就直接 return 入参，相当于没有转化；否则同样走 runtime::StringParseInt。注意如果这里越界了就会走 ChangeInt32ToTagged，其为 CodeStubAssembler 实现的一个函数，会强转 Int32，如果当前执行环境不允许溢出 32 位，那么转换之后的数字就会不合预期。
• 如果是 String，则判断是否是 hash，如果是的就找到对应整型 value 返回；否则依然走 runtime::StringParseInt。

那么焦点来到了 runtime::StringParseInt。[→ src/runtime/runtime-numbers.cc]

`// ES6 18.2.5 parseInt(string, radix) slow path RUNTIME_FUNCTION(Runtime_StringParseInt) { HandleScope handle_scope(isolate); DCHECK_EQ(2, args.length()); Handle