理解ECMAScript规范（Part 2）

March 8, 2024

原文：https://v8.dev/blog/understanding-ecmascript-part-2

准备好第 2 部分了吗？

了解规范的一个有趣方法是从我们已知的 JavaScript 特性开始，找出其规范化方式。

警告！本章节包含从 ECMAScript 规范（截至 2020 年 2 月）复制粘贴的算法。它们最终会过时。

我们知道属性是在原型链中查找的：如果一个对象没有我们要读取属性，我们会向上遍历原型链直到找到它（或找到不再有原型的对象）。

例如：

const o1 = { foo: 99 };
const o2 = {};
Object.setPrototypeOf(o2, o1);
o2.foo;
// → 99

原型遍历在何处定义？

让我们尝试找出此行为的定义位置。一个好的出发点是对象内部方法列表。

这里既有 [[GetOwnProperty]] 也有 [[Get]] — 我们对不受限于自身属性的版本感兴趣，所以我们会使用 [[Get]]。

遗憾的是，属性描述器规范类型也有一个名为 [[Get]] 的字段，因此在规范中浏览 [[Get]] 时，我们需要仔细区分两个独立的使用情况。

[[Get]] 是一种必要内部方法。普通对象实现必要内部方法的默认行为。异类对象可以定义自己的内部方法 [[Get]]，与默认行为不同。在这篇文章中，我们重点关注普通对象。

[[Get]] 的默认实现委托给 OrdinaryGet：

[[Get]] ( P, Receiver )

当 O 的 [[Get]] 内部方法使用属性键 P 和 ECMAScript 语言值 Receiver 被调用时，执行以下步骤：

返回 ? OrdinaryGet(O, P, Receiver)。

我们很快就会看到 Receiver 是在调用访问器属性的 getter 函数时用作this value的值。

OrdinaryGet 定义如下：

OrdinaryGet ( O, P, Receiver )

当抽象操作 OrdinaryGet 使用对象 O、属性键 P 和 ECMAScript 语言值 Receiver 被调用时，执行以下步骤：

断言：IsPropertyKey(P) 为 true。

令 desc 为 ? O.[[GetOwnProperty]](P)。

若 desc 为 undefined，则

令 parent 为 ? O.[[GetPrototypeOf]]()。

若 parent 为 null，则返回 undefined。

返回 ? parent.[[Get]](P, Receiver)。

若 IsDataDescriptor(desc) 为 true，则返回 desc.[[Value]]。

断言：IsAccessorDescriptor(desc) 为 true。

令 getter 为 desc.[[Get]]。

若 getter 为 undefined，则返回 undefined。

返回 ? Call(getter, Receiver)。

原型链遍历位于步骤 3 中：如果我们未找到属性作为自身属性，我们调用原型的 [[Get]] 方法，该方法再次委托给 OrdinaryGet。
如果我们仍然找不到属性，我们调用其原型的 [[Get]] 方法，该方法再次委托给 OrdinaryGet，依此类推，直至我们找到该属性或到达没有原型的对象。

让我们看看当我们访问 o2.foo 时此算法如何工作。首先，我们用 O 为 o2 且 P 为 "foo" 的值调用 OrdinaryGet。
O.[[GetOwnProperty]]("foo") 返回 undefined，因为 o2 没有名为 "foo" 的自身属性，因此我们使用步骤 3 中的分支。
在步骤 3.a 中，我们将 parent 设置为 o2 的原型，即 o1。
parent 不为 null，因此我们不会在步骤 3.b 中返回。
在步骤 3.c 中，我们使用属性键 "foo" 调用父级的 [[Get]] 方法，并返回任何它返回的内容。

父级 (o1) 是一个普通对象，因此其 [[Get]] 方法再次调用 OrdinaryGet，这次 O 为 o1 且 P 为 "foo"。
o1 有一个名为 "foo" 的自身属性，因此在步骤 2 中，O.[[GetOwnProperty]]("foo") 返回关联的属性描述符，我们将它存储在 desc 中。

属性描述符是一种规范类型。
数据属性描述符直接将属性的值存储在 [[Value]] 字段中。
访问器属性描述符将访问器函数存储在字段 [[Get]] 和/或 [[Set]] 中。
在本例中，与 "foo" 关联的属性描述符是数据属性描述符。

我们第 2 步中存储在 desc 中的数据属性描述符不是 undefined，因此我们不会在步骤 3 中使用 if 分支。接下来，我们执行步骤 4。
属性描述符是数据属性描述符，因此我们返回其 [[Value]] 字段，在步骤 4 中返回 99，我们完成了。

`Receiver` 是什么，它从何而来？

Receiver 参数仅在第 8 步访问器属性的情况下使用。它在调用访问器属性的 getter 函数时作为this value传递。

OrdinaryGet 在整个递归过程中传递原始 Receiver，保持不变（步骤 3.c）。让我们找出 Receiver 最初来自哪里！

搜索调用 [[Get]] 的地方，我们发现一个操作在 Reference 上操作的抽象操作 GetValue。Reference 是一种规范类型，由基值、引用名称和严格引用标志组成。在 o2.foo 的情况下，基值为对象 o2，引用名称为字符串 "foo"，严格引用标志为 false，因为示例代码是松散的。

附属内容：为什么 Reference 不是 Record？

附属内容：Reference 不是 Record，即使它看起来像那样。
它包含三个组件，这些组件同样可以表示为三个命名字段。Reference 不是 Record，仅仅是因为历史原因。

返回 `GetValue`

让我们看看 GetValue 的定义：

GetValue ( V )

ReturnIfAbrupt(V)。

若 Type(V) 不是 Reference，则返回 V。

令 base 为 GetBase(V)。

若 IsUnresolvableReference(V) 为 true，则抛出 ReferenceError 异常。

若 IsPropertyReference(V) 为 true，则

若 HasPrimitiveBase(V) 为 true，则

断言：在这种情况下，base 绝不会是 undefined 或 null。

将 base 设置为 ! ToObject(base)。

返回 ? base.[[Get]](GetReferencedName(V), GetThisValue(V))。

否则，

断言：base 是一个 Environment Record。

返回 ? base.GetBindingValue(GetReferencedName(V), IsStrictReference(V))

在我们示例中，引用为 o2.foo，这是一个属性引用（property reference）。因此，我们使用分支 5。我们不使用 5.a 中的分支，因为基(o2)不是原始值（Number, String, Symbol, BigInt, Boolean, Undefined, or Null）。

然后我们在步骤 5.b 中调用 [[Get]]。我们传递的 Receiver 是 GetThisValue(V)。在本例中，它只是 Reference 的基值（base value）：

GetThisValue( V )

断言：IsPropertyReference(V) 为 true。

若 IsSuperReference(V) 为 true，则

返回 Reference V 的 thisValue 组件的值。

返回 GetBase(V)。

对于 o2.foo，我们不使用步骤 2 中的分支，因为它不是 Super Reference（例如 super.foo），但我们使用步骤 3 并返回 Reference 的基值，即 o2。

将所有内容拼凑在一起，我们发现将 Receiver 设置为原始 Reference 的基，然后我们在原型链遍历期间保持不变。最后，如果我们找到的属性是访问器属性，我们使用 Receiver 作为this value来调用它。

特别是，getter 内部的this value引用的是我们尝试从中获取该属性的原始对象，而不是我们在原型链遍历期间找到该属性的对象。

让我们试一试！

const o1 = { x: 10, get foo() { return this.x; } };
const o2 = { x: 50 };
Object.setPrototypeOf(o2, o1);
o2.foo;
// → 50

在此示例中，我们有一个名为 foo 的访问器属性，并且为它定义了一个 getter。getter 返回 this.x。

然后，我们访问 o2.foo - getter 返回什么？

我们发现，当我们调用 getter 时，this value是我们最初尝试从中获取属性的对象，而不是我们在原型链遍历期间找到该属性的对象。在本例中，this value 是 o2，而不是 o1。我们可以通过检查 getter 是否返回 o2.x 或 o1.x 来验证这一点，实际上，它返回 o2.x。

有效！我们根据在规范中阅读的内容预测了此代码片段的行为。

访问属性 - 为何它调用 `[[Get]]`？

规范在哪指出访问属性（例如 o2.foo）时将调用对象内部方法 [[Get]]？这肯定在某个地方有定义。不要只相信我的话！

我们发现对象内部方法 [[Get]] 从操作在 Reference 上的抽象操作 GetValue 调用。但是 GetValue 从何处调用？

`MemberExpression` 的运行时语义

规范的语法规则定义了语言的语法。运行时语义定义语法结构“表示的意思”（即在运行时如何评估它们）。

如果你不熟悉上下文无关文法，现在了解一下是个好时机！

我们将在之后的章节中深入研究语法规则，现在先简单点！特别是，我们可以忽略本章中的下标（Yield、Await 等）。

以下生成描述了 MemberExpression 是什么样子：

MemberExpression :
  PrimaryExpression
  MemberExpression [ Expression ]
  MemberExpression . IdentifierName
  MemberExpression TemplateLiteral
  SuperProperty
  MetaProperty
  new MemberExpression Arguments

这里有 7 个 MemberExpression 的生成（productions）。MemberExpression 仅能是 PrimaryExpression。
或者，MemberExpression 可以通过拼接另一个 MemberExpression 和 Expression 来构建：
例如，MemberExpression [ Expression ]，o2['foo']。
或者，它可以是 MemberExpression . IdentifierName，例如 o2.foo - 这是我们示例中相关的生成。

生成 MemberExpression : MemberExpression . IdentifierName 的运行时语义定义了在评估它时要执行的一组步骤：

运行时语义：MemberExpression : MemberExpression . IdentifierName 的评估

令 baseReference 为评估 MemberExpression 的结果。

令 baseValue 为 ? GetValue(baseReference)。

若由 MemberExpression 匹配的代码是严格模式代码，则令 strict 为 true；否则 strict 为 false。

返回 ? EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict)。

该算法委托给抽象操作 EvaluatePropertyAccessWithIdentifierKey，所以我们也需要阅读它：

EvaluatePropertyAccessWithIdentifierKey( baseValue, identifierName, strict )

抽象操作 EvaluatePropertyAccessWithIdentifierKey 带有参数值 baseValue、解析节点 identifierName 和布尔参数 strict。它执行以下步骤：

断言：identifierName 为 IdentifierName

令 bv 为 ? RequireObjectCoercible(baseValue)。

令 propertyNameString 为 identifierName 的 StringValue。

返回类型为 Reference 的值，其基值组件（base value component）为 bv，引用名称组件（referenced name component）为 propertyNameString，严格引用标志为 strict。

即：EvaluatePropertyAccessWithIdentifierKey 构造一个 Reference，使用提供的 baseValue 作为基，identifierName 的字符串值作为属性名称，strict 作为严格模式标志。

最终，此 Reference 将传给 GetValue。这在规范的多个地方有定义，具体取决于 Reference 最终如何使用。

`MemberExpression` 作为参数

在我们的示例中，我们使用属性访问作为参数：

console.log(o2.foo);

在这种情况下，行为在 ArgumentList 生成运行时语义中定义，该运行时语义对参数调用 GetValue：

运行时语义：ArgumentListEvaluation

ArgumentList : AssignmentExpression

将 ref 设置为评估 AssignmentExpression 的结果。

将 arg 设置为 ? GetValue(ref)。

返回唯一项目为 arg 的列表。

o2.foo 不会像 AssignmentExpression 一样，但这个生成是适用的。要了解原因，你可以查看此附加内容，但在这一点上并不是绝对必要的。

步骤 1 中的 AssignmentExpression 是 o2.foo。ref，评估 o2.foo 的结果，就是上面提到的 Reference。在步骤 2 中，我们对其调用 GetValue。因此，我们知道对象内部方法 [[Get]] 将被调用，并且将发生原型链遍历。

总结

在本章节中，我们研究了规范如何跨所有不同层定义语言特性（在本例中为原型查找）：触发该特性的语法结构以及定义该特性的算法。

←Back to home

This work is licensed under CC BY-NC-SA 4.0