ECMAScript® 2024 语言规范
关于本规范
在 https://tc39.es/ecma262/ 上的文档是最准确和最新的ECMAScript规范。它包含了最新年度快照的内容以及任何已完成的提案（那些在提案流程中达到第4阶段并因此在多个实现中实现且将在下一次实际修订中包含的提案）自该快照以来的内容。
为此规范做贡献
此规范在GitHub上由ECMAScript社区的帮助下开发。有多种方式可以为此规范的发展做出贡献：
- GitHub Repository: https://github.com/tc39/ecma262
- Issues: All Issues, File a New Issue
- Pull Requests: All Pull Requests, Create a New Pull Request
- Test Suite: Test262
- 编辑:
-
社区:
- Discourse: https://es.discourse.group
- Chat: Matrix
- Mailing
List Archives: https://esdiscuss.org/
有关如何创建此文档的更多信息，请参阅
导言
此ecma标准定义了ECMAScript 2024语言。它是ECMAScript语言的第十五版 规范。自1997年第一版出版以来，ECMAScript已发展成为世界上 最广泛使用的通用编程语言。它最为人所知的是嵌入在网络中的语言 浏览器，但也被广泛用于服务器和嵌入式应用程序。
ECMAScript基于几种原始技术，最著名的是JavaScript（Netscape）和 JScript（微软）。该语言由Netscape的Brendan Eich发明，首次出现在该公司的 Navigator 2.0浏览器。它已出现在Netscape的所有后续浏览器和Netscape的所有浏览器中 Microsoft从Internet Explorer 3.0开始。
ECMAScript语言规范的开发始于1996年11月。这个的第一版 ECMA标准于1997年6月由ECMA大会通过。
该ECMA标准已提交给ISO/IEC JTC 1以供快速通道程序采用，并被批准为 国际标准ISO/IEC 16262,1998年4月。ECMA大会于1998年6月批准了第二个 ECMA-262版本，使其完全符合ISO/IEC 16262。第一个和第二个之间的变化 版本本质上是编辑性的。
标准第三版引入了强大的正则表达式、更好的字符串处理、新的控件 语句、try/catch异常处理、更严格的错误定义、数字输出的格式和次要 对未来语言增长的预期变化。ECMAScript标准的第三版被 1999年12月的ECMA大会，并于2002年6月作为ISO/IEC 16262:2002发布。
第三版发布后，ECMAScript与全球广泛采用 Web，它已成为基本上所有Web浏览器都支持的编程语言。重要的 开发ECMAScript第四版的工作已经完成。然而，这项工作没有完成，也没有出版 作为ECMAScript的第四版，但其中一些被纳入了第六版的开发。
ECMAScript第五版（作为ECMA-262 5th版发布）事实上已编纂
对浏览器实现中常见的语言规范的解释并添加了
支持自第三版出版以来出现的新功能。这些功能包括
第五版提交给ISO/IEC JTC 1采用快速通道程序，并被批准为国际标准ISO/IEC 16262:2011。ECMAScript标准的5.1版包含了一些小的修正，文本与ISO/IEC 16262:2011相同。5.1版于2011年6月被Ecma大会采纳。
第六版的集中开发始于2009年，当时第五版正在准备出版。然而，在此之前，自1999年第三版发布以来，已经进行了大量的实验和语言增强设计工作。从某种意义上说，第六版的完成是十五年努力的结晶。本版的目标包括提供对大型应用程序、库创建的更好支持，并将ECMAScript用作其他语言的编译目标。其主要增强功能包括模块、类声明、词法块作用域、迭代器和生成器、用于异步编程的Promises、解构模式和正确的尾调用。ECMAScript内置库扩展了对附加数据抽象的支持，包括地图、集合和二进制数值数组，并在字符串和正则表达式中增加了对Unicode补充字符的支持。内置库还通过子类化变得可扩展。第六版为常规的、增量的语言和库增强提供了基础。第六版于2015年6月被大会采纳。
ECMAScript 2016是Ecma TC39在新的年度发布节奏和开放开发流程下发布的第一个ECMAScript版本。从ECMAScript
2015源文档生成了一个纯文本源文档，作为在GitHub上进一步开发的基础。在这一标准的开发过程中，提交了数百个拉取请求和问题，代表了成千上万个错误修复、编辑修正和其他改进。此外，还开发了许多软件工具来帮助这一工作，包括Ecmarkup、Ecmarkdown和Grammarkdown。ES2016还包括对新幂运算符的支持，并在Array.prototype中添加了一个名为includes的新方法。
ECMAScript 2017引入了异步函数、共享内存和原子操作，以及一些较小的语言和库增强、错误修复和编辑更新。异步函数通过提供Promise返回函数的语法来改进异步编程体验。共享内存和原子操作引入了一种新的内存模型，允许多代理程序使用原子操作进行通信，即使在并行CPU上也能确保定义明确的执行顺序。它还包括Object上的新静态方法：Object.values、Object.entries和Object.getOwnPropertyDescriptors。
ECMAScript
2018通过AsyncIterator协议和异步生成器引入了对异步迭代的支持。它还包括四个新的正则表达式特性：dotAll标志、命名捕获组、Unicode属性转义和后行断言。最后，它还包括对象的剩余和扩展属性。
ECMAScript
2019引入了一些新的内置函数：Array.prototype上的flat和flatMap用于扁平化数组，Object.fromEntries用于直接将Object.entries的返回值转化为新对象，以及String.prototype上的trimStart和trimEnd作为更好命名的替代方案，取代广泛实现但非标准的String.prototype.trimLeft和trimRight内置函数。此外，它还包括一些语法和语义的较小更新。更新的语法包括可选的catch绑定参数，并允许在字符串字面量中使用U+2028（行分隔符）和U+2029（段落分隔符）以与JSON保持一致。其他更新包括要求Array.prototype.sort为稳定排序，要求JSON.stringify无论输入如何都返回格式良好的UTF-8，以及通过要求Function.prototype.toString返回相应的原始源文本或标准占位符来进行明确。
ECMAScript
2020，第11版，引入了字符串的matchAll方法，用于生成全局正则表达式匹配对象的迭代器；import()语法，用于动态异步导入模块；BigInt，一种新的数字原始类型，用于处理任意精度的整数；Promise.allSettled，一种新的Promise组合器，不会短路；globalThis，一种通用的全局this值访问方式；专用的export * as ns from 'module'语法，用于模块内；增加了for-in枚举顺序的标准化；import.meta，一个由宿主填充的对象，包含关于模块的上下文信息；以及为处理“nullish”值（
ECMAScript
2021，第12版，引入了字符串的replaceAll方法；Promise.any，一个在输入值被实现时短路的Promise组合器；AggregateError，一种新错误类型，用于同时表示多个错误；逻辑赋值操作符（??=、&&=、||=）；WeakRef，用于引用目标对象而不保留其免于垃圾回收，以及FinalizationRegistry，用于管理在目标对象被垃圾回收时执行的清理操作的注册和取消注册；数字字面量的分隔符（1_000）；并且使Array.prototype.sort更加精确，减少了导致
ECMAScript 2022，第13版，引入了顶层await，允许在模块顶层使用关键字；新的类元素：公共和私有实例字段、公共和私有静态字段、私有实例方法和访问器、以及私有静态方法和访问器；类中的静态块，用于每类评估初始化；#x in obj语法，用于测试对象上私有字段的存在；通过/d标志的正则表达式匹配索引，提供匹配子字符串的起始和结束索引；Error对象上的cause属性，用于记录错误中的因果链；用于字符串、数组和类型化数组的at方法，允许相对索引；以及Object.hasOwn，Object.prototype.hasOwnProperty的便捷替代。
ECMAScript
2023，第14版，引入了Array.prototype和TypedArray.prototype上的toSorted、toReversed、with、findLast和findLastIndex方法，以及Array.prototype上的toSpliced方法；增加了对文件开头#!注释的支持，以更好地促进可执行ECMAScript文件；并允许在弱集合中使用大多数符号作为键。
ECMAScript
2024，第15版，增加了调整和转移ArrayBuffers和SharedArrayBuffers大小的功能；添加了用于创建具有更高级功能的字符串集的RegExp/v标志；引入了用于构建Promise的便捷方法Promise.withResolvers、用于数据聚合的Object.groupBy和Map.groupBy方法、用于异步等待共享内存更改的Atomics.waitAsync方法，以及用于检查和确保字符串仅包含格式良好的Unicode的String.prototype.isWellFormed和String.prototype.toWellFormed方法。
代表许多组织的数十个人在Ecma TC39中对这一版本的开发以及之前的版本做出了非常重要的贡献。此外，还出现了一个支持TC39的ECMAScript工作的活跃社区。这个社区审查了无数草案，提交了数千个错误报告，进行了实现实验，贡献了测试套件，并向全球开发者社区介绍了ECMAScript。不幸的是，不可能识别和感谢每一个为这项工作做出贡献的人和组织。
Allen Wirfs-Brock
ECMA-262，第六版项目编辑
Brian Terlson
ECMA-262，第七版至第十版项目编辑
Jordan Harband
ECMA-262，第十版至第十二版项目编辑
Shu-yu Guo
ECMA-262，第十二版至第十五版项目编辑
Michael Ficarra
ECMA-262，第十二版至第十五版项目编辑
Kevin Gibbons
ECMA-262，第十二版至第十五版项目编辑
1 范围
本标准定义了ECMAScript 2024通用编程语言。
2 一致性
符合ECMAScript规范的实现必须提供并支持本规范中描述的所有类型、值、对象、属性、函数和程序语法及语义。
符合ECMAScript规范的实现必须按照最新版本的Unicode标准和ISO/IEC 10646解释源文本输入。
提供支持不同语言和国家的语言和文化习俗的应用编程接口（API）的符合ECMAScript规范的实现必须实现ECMA-402最新版本中与本规范兼容的接口。
符合ECMAScript规范的实现可以提供本规范中未描述的其他类型、值、对象、属性和函数。特别是，符合ECMAScript规范的实现可以为本规范中描述的对象提供本规范中未描述的属性和值。
符合ECMAScript规范的实现可以支持本规范中未描述的程序和正则表达式语法。特别是，符合ECMAScript规范的实现可以支持使用本规范第
符合ECMAScript规范的实现不得实现本规范第
符合ECMAScript规范的实现不得重新定义任何不是
符合ECMAScript规范的实现可以选择实现或不实现规范性可选的小节。如果实现了任何规范性可选行为，则必须实现包含的规范性可选条款中的所有行为。本规范中用彩色框中的“规范性可选”一词来表示规范性可选条款，如下所示。
2.1 示例规范性可选条款标题
示例条款内容。
符合ECMAScript规范的实现必须实现遗留小节，除非它们也被标记为规范性可选。遗留小节中指定的所有语言特性和行为都具有一个或多个不理想的特性。然而，它们在现有应用程序中的持续使用阻止了它们从本规范中删除。这些特性不被视为ECMAScript核心语言的一部分。程序员在编写新的ECMAScript代码时不应使用或假设这些特性和行为的存在。
2.2 示例遗留条款标题
示例条款内容。
2.3 示例遗留规范性可选条款标题
示例条款内容。
3 规范性引用
下列引用文件对于本文档的应用是必不可少的。对于有日期的引用，仅适用于所引用的版本。对于无日期的引用，适用于引用文件的最新版本（包括任何修正案）。
Unicode 标准。
https://unicode.org/versions/latest
ISO/IEC 10646，信息技术 — 通用多八位编码字符集 (UCS) 加上修正案1:2005、修正案2:2006、修正案3:2008、修正案4:2008和其他修正案和勘误，或其后续版本。
ECMA-402，ECMAScript 国际化 API 规范，特别是与本规范版本相对应的年度版。
https://www.ecma-international.org/publications-and-standards/standards/ecma-402/
ECMA-404，JSON 数据交换格式。
https://www.ecma-international.org/publications-and-standards/standards/ecma-404/
4 概述
本节包含 ECMAScript 语言的非规范性概述。
ECMAScript 是一种面向对象的编程语言，用于在 宿主环境 中执行计算和操作计算对象。本规范中定义的 ECMAScript 并不打算是计算自给自足的；实际上，本规范没有规定外部数据的输入或计算结果的输出。相反，预计 ECMAScript 程序的计算环境不仅会提供本规范中描述的对象和其他设施，还会提供某些环境特定的对象，这些对象的描述和行为超出了本规范的范围，只是表明它们可能提供某些属性可以从 ECMAScript 程序中访问和调用的函数。
ECMAScript 最初设计为一种脚本语言，但现已广泛用作通用编程语言。脚本语言 是一种用于操作、定制和自动化现有系统功能的编程语言。在这些系统中，有用的功能已经通过用户界面可用，脚本语言是将这些功能暴露给程序控制的机制。这样，现有系统就提供了一个对象和设施的 宿主环境，从而完善了脚本语言的功能。脚本语言旨在供专业和非专业程序员使用。
ECMAScript 最初设计为一种 Web 脚本语言，提供一种机制来在浏览器中使网页生动起来，并作为基于 Web 的客户端-服务器架构的一部分执行服务器计算。ECMAScript 现在用于为各种 宿主环境 提供核心脚本功能。因此，本文件中规定的核心语言与任何特定的 宿主环境 无关。
ECMAScript 的使用已经超出了简单的脚本编写，它现在用于许多不同环境和规模的全方位编程任务。随着 ECMAScript 使用范围的扩大，它提供的功能和设施也在扩展。ECMAScript 现在是一种功能齐全的通用编程语言。
4.1 Web脚本
Web浏览器为客户端计算提供了一个ECMAScript 宿主环境，包括表示窗口、菜单、弹出窗口、对话框、文本区域、锚点、框架、历史记录、Cookies以及输入/输出的对象。此外，宿主环境还提供了一种将脚本代码附加到事件（如焦点更改、页面和图像加载、卸载、错误和中止、选择、表单提交和鼠标操作）的方法。脚本代码出现在HTML中，显示的页面是用户界面元素和固定和计算文本及图像的组合。脚本代码对用户交互有反应，因此不需要主程序。
Web服务器为服务器端计算提供了不同的宿主环境，包括表示请求、客户端和文件的对象；以及锁定和共享数据的机制。通过结合使用浏览器端和服务器端脚本，可以在客户端和服务器之间分配计算，同时为基于Web的应用程序提供定制的用户界面。
每个支持ECMAScript的Web浏览器和服务器都提供自己的宿主环境，从而完成ECMAScript的执行环境。
4.2 宿主和实现
为了帮助将ECMAScript集成到宿主环境中，本规范将某些功能的定义（例如，抽象操作）全部或部分地推迟到本规范之外的来源。在编辑上，本规范区分了以下几种推迟定义的方式。
实现是进一步定义附录D中列出的功能或那些标记为实现定义或实现近似的功能的外部来源。在非正式使用中，实现是指具体的人工制品，例如特定的网络浏览器。
实现定义的功能是指将其定义推迟到外部来源而没有进一步的限定。本规范对特定行为没有做出任何建议，符合规范的实现可以在本规范提出的约束范围内选择任何行为。
实现近似的功能是指将其定义推迟到外部来源，同时建议一种理想行为。虽然符合规范的实现可以在本规范提出的约束范围内选择任何行为，但鼓励它们尽量接近理想。一些数学操作，例如Math.exp，属于实现近似。
宿主是进一步定义附录D中列出的功能，但不进一步定义其他实现定义或实现近似功能的外部来源。在非正式使用中，宿主是指以相同方式通过附录D与本规范接口的所有实现集，例如所有网络浏览器的集合。宿主通常是一个外部规范，例如WHATWG HTML (https://html.spec.whatwg.org/)。换句话说，宿主定义的功能通常在外部规范中进一步定义。
宿主挂钩 是一个由外部来源全部或部分定义的抽象操作。所有 宿主挂钩 必须列在附录 D 中。宿主挂钩 必须至少符合以下要求：
宿主定义 的功能是将其定义推迟到外部来源而没有进一步的限定，并列在附录 D 中。不是 宿主 的实现也可以提供 宿主定义 的功能定义。
宿主环境 是所有 宿主定义 功能的特定定义选择。宿主环境 通常包括允许获取输入和提供输出的对象或函数，作为 宿主定义 属性的一部分的 全局对象。
本规范遵循始终使用最具体术语的编辑约定。例如，如果一个功能是 宿主定义 的，则不应称其为 实现定义。
宿主和实现可以通过本规范中定义的语言类型、规范类型、抽象操作、语法生成、内在对象和内在符号与本规范接口。
4.3 ECMAScript 概述
以下是 ECMAScript 的非规范性概述，并未描述该语言的所有部分。该概述不属于标准的正式部分。
ECMAScript 是基于对象的：基本语言和宿主功能由对象提供，ECMAScript
程序是一个相互通信的对象集合。在 ECMAScript 中，对象 是具有零个或多个 属性 的集合，每个属性都有确定如何使用该属性的 特性 ——
例如，当属性的可写特性（Writable attribute）设置为
ECMAScript 定义了一组 内置对象，完善了 ECMAScript 实体的定义。这些内置对象包括 全局对象；对语言的 运行时语义 基本的对象，包括
Object、Function、Boolean、Symbol 及各种 Error
对象；表示和操作数值的对象，包括 Math、Number 和 Date；处理文本的对象 String 和
RegExp；值的索引集合的对象，包括 Array 和九种不同类型的元素具有特定数值表示的 Typed Arrays；键控集合，包括 Map
和 Set 对象；支持结构化数据的对象，包括 JSON
对象、ArrayBuffer、SharedArrayBuffer 和 DataView；支持控制抽象的对象，包括生成器函数和
Promise 对象；以及反射对象，包括 Proxy 和 Reflect。
ECMAScript 还定义了一组内置 运算符。ECMAScript 运算符包括各种一元运算符、乘法运算符、加法运算符、位移运算符、关系运算符、相等运算符、二进制位运算符、二进制逻辑运算符、赋值运算符和逗号运算符。
大型 ECMAScript 程序由 模块 支持，允许程序划分为多个语句和声明的序列。每个模块明确标识其使用的需要由其他模块提供的声明，以及哪些声明可供其他模块使用。
ECMAScript 语法故意类似于 Java 语法。ECMAScript 语法被放宽，以使其作为一种易于使用的脚本语言。例如，变量不需要声明其类型，属性也没有关联类型，定义的函数也不需要在调用之前出现在文本上。
4.3.1 对象
尽管 ECMAScript 包含类定义的语法，但 ECMAScript 对象并非如 C++、Smalltalk 或 Java 中的类为基础。相反，对象可以通过多种方式创建，包括字面量表示法或 构造函数，这些构造函数创建对象，然后通过为其属性分配初始值来初始化全部或部分对象。每个 构造函数 都是一个具有名为
new Date(2009, 11)
创建一个新的 Date 对象。不使用 new 调用 构造函数
会产生不同的结果，这取决于 构造函数。例如，Date()
生成当前日期和时间的字符串表示，而不是对象。
每个由 构造函数 创建的对象都有一个隐式引用（称为对象的
原型），指向其 构造函数 的
在基于类的面向对象语言中，通常状态由实例承载，方法由类承载，并且继承仅限于结构和行为。而在 ECMAScript 中，状态和方法由对象承载，而结构、行为和状态都是继承的。
所有不直接包含其原型所包含的特定属性的对象共享该属性及其值。图 1 说明了这一点：
CF 是一个 构造函数（也是一个对象）。通过使用
new
表达式创建了五个对象：cf1、cf2、cf3、cf4 和
cf5。这些对象每个都包含名为
与大多数基于类的对象语言不同，可以通过分配值动态地向对象添加属性。也就是说，构造函数 不需要命名或分配所有或任何构造对象的属性。在上图中，可以通过向 CFp 中的属性分配新值，为 cf1、cf2、cf3、cf4 和 cf5 添加一个新的共享属性。
尽管 ECMAScript 对象本质上不是基于类的，但根据 构造函数、原型对象和方法的共同模式定义类样抽象通常是方便的。ECMAScript 内置对象本身遵循这样的类样模式。从 ECMAScript 2015 开始，ECMAScript 语言包括语法类定义，允许程序员简洁地定义符合内置对象使用的相同类样抽象模式的对象。
4.3.2 ECMAScript 的严格变体
ECMAScript 语言认识到某些用户可能希望限制其使用语言中某些功能的可能性。他们可能出于安全考虑，避免他们认为容易出错的功能，获得增强的错误检查，或出于其他原因。为了支持这种可能性，ECMAScript 定义了语言的严格变体。语言的严格变体排除了一些常规 ECMAScript 语言的特定语法和语义特性，并修改了某些特性的详细语义。严格变体还指定了在非严格形式的语言未指定为错误的情况下必须通过抛出错误异常来报告的其他错误条件。
ECMAScript 的严格变体通常称为语言的严格模式。严格模式的选择和 ECMAScript 严格模式语法和语义的使用明确在单个 ECMAScript 源文本 单元级别进行，如 11.2.2 中所述。由于在语法源文本单元级别选择严格模式，因此严格模式仅对该源文本单元内具有局部效果的限制。严格模式不会限制或修改必须在多个源文本单元之间一致操作的 ECMAScript 语义。完整的 ECMAScript 程序可以由严格模式和非严格模式 ECMAScript 源文本 单元组成。在这种情况下，严格模式仅在实际执行在严格模式源文本单元中定义的代码时才适用。
为了符合本规范，ECMAScript 实现必须实现完整的无限制 ECMAScript 语言和本规范定义的 ECMAScript 语言的严格变体。此外，实现必须支持将无限制和严格模式源文本单元组合成一个单一的组合程序。
4.4 术语和定义
在本文件中，适用以下术语和定义。
4.4.1 实现近似 (implementation-approximated)
一个 实现近似 设施是由外部来源全部或部分定义的，但在本规范中有推荐的理想行为。
4.4.2 实现定义 (implementation-defined)
一个 实现定义 设施是由外部来源全部或部分定义的。
4.4.3 宿主定义 (host-defined)
与 实现定义 相同。
编辑说明，参见 4.2 条款。
4.4.4 类型 (type)
数据值集合，定义见
4.4.5 原始值 (primitive value)
是 Undefined、Null、Boolean、Number、BigInt、Symbol 或 String 类型中的一个成员，定义见
原始值是在语言实现的最低层直接表示的数据。
4.4.6 对象 (object)
Object 类型的成员。
对象是属性的集合，并且有一个单一的原型对象。原型可以是
4.4.7 构造函数 (constructor)
构造函数的
4.4.8 原型 (prototype)
为其他对象提供共享属性的对象。
4.4.9 普通对象 (ordinary object)
具有所有对象必须支持的基本内部方法默认行为的对象
4.4.10 特殊对象 (exotic object)
在一个或多个基本内部方法上不具有默认行为的对象
4.4.11 标准对象 (standard object)
其语义由本规范定义的对象
4.4.12 内置对象 (built-in object)
由 ECMAScript 实现指定和提供的对象
标准内置对象在本规范中定义。ECMAScript 实现可以指定和提供其他种类的内置对象。
4.4.13 未定义值 (undefined value)
当变量未被赋值时使用的原始值
4.4.14 Undefined 类型 (Undefined type)
唯一值为
4.4.15 空值 (null value)
表示故意缺少任何对象值的原始值
4.4.16 Null 类型 (Null type)
唯一值为
4.4.17 布尔值 (Boolean value)
属于
只有两个布尔值，
4.4.18 Boolean 类型 (Boolean type)
由原始值
4.4.19 Boolean 对象 (Boolean object)
属于
Boolean 对象是通过在 new 表达式中使用 Boolean
4.4.20 字符串值 (String value)
原始值，是一个
4.4.21 字符串类型 (String type)
所有可能的字符串值的集合
4.4.22 字符串对象 (String object)
4.4.23 Number 值 (Number value)
对应双精度 64 位二进制格式
Number 值是
4.4.24 Number 类型 (Number type)
所有可能的 Number 值的集合，包括特殊的“非数值” (NaN) 值、正无穷大和负无穷大
4.4.25 Number 对象 (Number object)
属于
4.4.26 无穷大 (Infinity)
表示正无穷大的 Number 值
4.4.27 NaN
表示
4.4.28 BigInt 值 (BigInt value)
对应任意精度
4.4.29 BigInt 类型 (BigInt type)
所有可能的 BigInt 值的集合
4.4.30 BigInt 对象 (BigInt object)
4.4.31 Symbol 值 (Symbol value)
表示唯一的、非字符串对象
4.4.32 Symbol 类型 (Symbol type)
所有可能的 Symbol 值的集合
4.4.33 Symbol 对象 (Symbol object)
4.4.34 函数 (function)
属于
除了它的属性之外，函数还包含可执行代码和状态，这些代码和状态决定了它在调用时的行为。函数的代码可以是 ECMAScript 编写的，也可以不是。
4.4.35 内置函数 (built-in function)
内置对象，是一个函数
内置函数的例子包括 parseInt 和 Math.exp。
4.4.36 内置构造函数 (built-in constructor)
内置函数，是一个
4.4.37 属性 (property)
对象的一部分，关联一个键（字符串值或 Symbol 值）和一个值
根据属性的形式，值可以直接表示为数据值（原始值、对象或
4.4.38 方法 (method)
作为属性值的函数
当函数作为对象的方法调用时，对象会作为其
4.4.39 内置方法 (built-in method)
作为内置函数的方法
标准内置方法在本规范中定义。
4.4.40 属性 (attribute)
定义属性某些特性的内部值
4.4.41 自有属性 (own property)
直接包含在对象中的属性
4.4.42 继承属性 (inherited property)
对象的属性，不是自有属性，但它是对象原型的属性（自有属性或继承属性）
4.5 本规范的组织结构 (Organization of This Specification)
本规范的其余部分组织如下：
第
第
第
第
第
5 符号约定
5.1 句法和词法语法
5.1.1 上下文无关文法
一个上下文无关文法由若干生成式组成。每个生成式的左侧都有一个抽象符号，称为非终结符，右侧则是一系列零个或多个非终结符和终结符符号。对于每个文法，终结符号来自指定的字母表。
链生成式是右侧有且只有一个非终结符号以及零个或多个终结符号的生成式。
从一个由单个特殊非终结符组成的句子开始，称为目标符号，给定的上下文无关文法指定了一种语言，即通过不断将序列中的任何非终结符替换为其左侧为该非终结符的生成式的右侧所能产生的终结符号的（可能是无限的）集合。
5.1.2 词法和正则表达式文法
ECMAScript 的词法文法在
除空白和注释外的输入元素构成 ECMAScript 语法文法的终结符，称为 ECMAScript 标记。这些标记是 ECMAScript 语言的 /*…*/ 的注释，不论是否跨越多行）不包含行终止符，则它同样会被丢弃；但如果
ECMAScript 的正则表达式文法在
词法和正则表达式文法的生成式通过两个冒号 “::” 作为分隔标点来区分。这两种文法共享一些生成式。
5.1.3 数值字符串文法
在
数值字符串文法的生成式通过三个冒号 “:::” 作为标点符号来区分，且从不用于解析源文本。
5.1.4 句法文法
ECMAScript 的 句法文法 在
当要将代码点流解析为 ECMAScript
解析成功时，会构造一个 解析树，这是一个以根为起点的树结构，其中每个节点是一个 解析节点。每个解析节点都是文法中某个符号的实例；它表示可以从该符号派生的源文本范围。表示整个源文本的解析树的根节点是解析的
解析器的每次调用都会实例化新的解析节点，并且在解析相同源文本时永不重用。解析节点被认为是相同的解析节点，当且仅当它们表示相同的源文本范围，是相同文法符号的实例，并且是由同一次解析器调用生成的。
多次解析相同的字符串会导致不同的解析节点。例如，考虑：
let str = "1 + 1;";
eval(str);
eval(str);每次调用 eval 都会将 str 的值转换为
句法文法的生成式通过使用一个冒号 “:” 作为标点符号来区分。
在
在某些情况下，为避免歧义，句法文法使用了泛化生成式，允许不形成有效 ECMAScript
- 使用 N 作为
目标符号 重新解析最初由 P 匹配的标记序列。如果 N 采用文法参数，则它们设置为与最初解析 P 时相同的值。 - 如果标记序列可以解析为 N 的单个实例，并且没有剩余标记，则：
- 我们将该 N 的实例（解析节点，在给定 P 的情况下是唯一的）称为“由 P 覆盖的 N”。
- N 及其派生生成式的所有早期错误规则也适用于由 P 覆盖的 N。
- 否则（如果解析失败），则为早期语法错误。
5.1.5 语法标记
5.1.5.1 终结符号
在ECMAScript语法中，一些终结符号显示为固定宽度字体。这些符号应当按照书写的样子准确出现在源文本中。以这种方式指定的所有终结符号码点都应被理解为来自基本拉丁块的适当Unicode码点，而不是来自其他Unicode范围的类似看起来的码点。终结符号中的一个码点不能通过\
在其终结符号是单个Unicode码点的语法中（即，词汇、RegExp和数值字符串语法），连续的多个固定宽度码点出现在一个生产中，是一种简单的速记，用于表示相同的码点序列，写作独立的终结符号。
例如，产生式：
是以下的简写形式：
相比之下，在句法语法中，连续的固定宽度码点构成一个单独的终结符号。
终结符号还有其他两种形式：
- 在词汇和RegExp语法中，没有常规打印表示的Unicode码点，会以"<ABBREV>"的形式显示，其中"ABBREV"是该码点或码点集的助记符。这些形式在
Unicode格式控制字符 、空白字符 和行终结符 中定义。 - 在句法语法中，某些终结符号（例如
IdentifierName 和RegularExpressionLiteral ）以斜体显示，因为它们指的是词汇语法中同名的非终结符号。
5.1.5.2 非终结符号与生产规则
非终结符号显示为斜体类型。非终结（也称为“产生式”）的定义是由被定义的非终结名称开始，后面跟着一个或多个冒号（冒号的数量表示生产所属的语法）。然后，非终结的一个或多个备选右侧在后续行中跟随。例如，句法定义：
说明非终结while，后跟一个左括号，然后是一个
说明一个
5.1.5.3 可选符号
下标后缀“opt”，可出现在终结符或非终结符之后，表示一个可选符号。包含可选符号的替代项实际上指定了两个右侧，一个省略可选元素，一个包含它。这意味着：
是一个方便的缩写：
和：
是一个方便的缩写：
反过来又是一个缩写：
因此，在这个例子中，非终结符
5.1.5.4 语法参数
一个产生式可能会被形式为“[parameters]”的下标注释参数化，它可能作为由产生式定义的非终结符号的后缀出现。“parameters”可以是单个名称或逗号分隔的名称列表。参数化的产生式是一组产生式的简写，这些产生式定义了所有参数名称的组合，这些名称由下划线前缀，并附加到参数化的非终结符号上。这意味着：
是以下的缩写:
并且：
是以下的缩写：
多个参数会产生组合数量的产生式，但并不是所有的产生式都必须在完整的语法中被引用。
产生式右侧的非终结符号的引用也可以被参数化。例如：
等同于说：
以及：
相当于：
一个非终结符的引用可能同时具有参数列表和“opt”后缀。例如：
是以下的缩写：
在右侧非终结符引用中，用“?”前缀参数名称，使得该参数值依赖于当前产生式左侧符号引用中参数名称的出现。例如：
是以下的缩写：
如果右侧的备选方案以“[+parameter]”为前缀，那么这个备选方案只在引用产生式的非终结符号时使用了指定的参数才可用。如果右侧的备选方案以“[~parameter]”为前缀，那么这个备选方案只在引用产生式的非终结符号时未使用指定的参数才可用。这意味着：
是以下的缩写：
并且：
是以下的缩写：
5.1.5.5 one of
当语法定义中的冒号后面跟着“one of”这几个词时，它们表示接下来的每一行上的终结符号都是一个替代定义。例如，ECMAScript的词法语法包含以下产生式：
这只是一个方便的缩写，完整形式为：
5.1.5.6 [empty]
如果产生式的右侧出现“[empty]”这一短语，它表示该产生式的右侧不包含任何终结符号或非终结符号。
5.1.5.7 前瞻限制
如果短语“[lookahead = seq]”出现在产生式的右侧，它表示只有当令牌序列seq是紧随其后的输入令牌序列的前缀时，才能使用该产生式。类似地，“[lookahead ∈ set]”，其中set是一个非空的有限令牌序列集合，表示只有当set中的某个元素是紧随其后的令牌序列的前缀时，才能使用该产生式。为了方便起见，该集合也可以写作非终结符，这种情况下它代表所有非终结符可以扩展到的令牌序列的集合。如果非终结符可以扩展到无限多个不同的令牌序列，则被认为是编辑错误。
这些条件可以被否定。“[lookahead ≠ seq]”表示只有当seq不是紧随其后的输入令牌序列的前缀时，才能使用包含的产生式，“[lookahead ∉ set]”表示只有当set中的没有元素是紧随其后的令牌序列的前缀时，才能使用该产生式。
例如，给定以下定义：
定义如下：
匹配字母n，后跟一个或多个十进制数字，第一个数字为偶数，或一个十进制数字，后面没有跟随另一个十进制数字。
注意，当这些短语在句法语法中使用时，可能无法明确识别紧随其后的令牌序列，因为确定后续的令牌需要知道在后续位置使用哪个词法目标符号。因此，当这些短语在句法语法中使用时，如果词法目标符号的选择可能会改变seq是否会成为生成的令牌序列的前缀，那么在前视限制中出现令牌序列seq（包括作为序列集合的一部分）被认为是编辑错误。
5.1.5.8 [no LineTerminator here]
如果在句法文法的生成式右侧出现短语“[no
表示如果在脚本中 throw 标记和
除非受限生成式禁止出现
5.1.5.9 but not
生成式的右侧可以使用短语“but not”并指示要排除的扩展来指定不允许某些扩展。例如，生成式：
意味着非终结符
5.1.5.10 描述性短语
最后，在一些列出所有替代方案不切实际的情况下，使用无衬线字体的描述性短语来描述少数非终结符号：
5.2 算法约定
该规范经常使用编号列表来指定算法中的步骤。这些算法用于精确指定 ECMAScript 语言结构的所需语义。这些算法并不意味着必须使用任何特定的实现技术。实际上，可能有更有效的算法可用于实现给定的功能。
算法可以明确地用一个有序的、逗号分隔的别名序列参数化，这些别名在算法步骤中可用于引用在该位置传入的参数。可选参数用方括号（[ , name
]）表示，与算法步骤中的必需参数没有区别。参数列表的末尾可以出现一个剩余参数，以省略号（, ...name）表示。剩余参数捕获所有在必需参数和可选参数之后提供的参数，这些参数被编入一个
算法步骤可以细分为顺序子步骤。子步骤是缩进的，并且本身可以进一步分为缩进的子步骤。用大纲编号约定来标识子步骤，第一层子步骤用小写字母标记，第二层子步骤用小写罗马数字标记。如果需要超过三个层级，这些规则将重复，第四层使用数字标签。例如：
- 顶层步骤
- 子步骤。
- 子步骤。
- 子子步骤。
- 子子子步骤
- 子子子子步骤
- 子子子子子步骤
- 子子子子步骤
- 子子子步骤
- 子子步骤。
步骤或子步骤可以作为一个“if”谓词编写，条件化其子步骤。在这种情况下，只有当谓词为真时，子步骤才会被应用。如果步骤或子步骤以“else”一词开头，它是一个谓词，是与同一层级前一个“if”谓词步骤的否定。
步骤可以指定其子步骤的迭代应用。
以“Assert（断言）:”开头的步骤断言其算法的不变条件。这种断言用来明确那些否则会是隐含的算法不变性。这样的断言不增加额外的语义要求，因此实现无需检查。它们仅用于澄清算法。
算法步骤可以使用“Let x be someValue”的形式声明任何值的命名别名。这些别名类似于引用，x和someValue都指向相同的底层数据，对任何一个的修改都对双方可见。如果算法步骤想要避免这种类似引用的行为，应该明确地复制右侧值：“Let x be a copy of someValue”创建了someValue的一个浅拷贝。
一旦声明，别名可以在任何后续步骤中被引用，并且不能从别名声明之前的步骤中被引用。别名可以使用“Set x to someOtherValue”的形式进行修改。
5.2.1 抽象操作
为了便于在本规范的多个部分中使用，一些算法被称为抽象操作，它们被命名并以参数化的函数形式编写，以便可以从其他算法中通过名称引用它们。抽象操作通常使用函数应用风格引用，如 OperationName(arg1, arg2)。一些抽象操作被视为类似类的规范抽象中多态分派的方法。这种类似方法的抽象操作通常使用方法应用风格引用，例如 someValue.OperationName(arg1, arg2)。
5.2.2 语法导向操作
一个语法导向操作是一个命名操作，其定义包括多个算法，每个算法都与ECMAScript语法之一的一个或多个产生式相关联。具有多个替代定义的产生式通常会为每个替代定义有一个独特的算法。当一个算法与一个语法产生式相关联时，它可以引用产生式替代的终结符和非终结符，就好像它们是算法的参数一样。在这种方式下使用时，非终结符引用在解析源文本时匹配的实际替代定义。由语法产生式匹配的源文本或由其衍生的
当一个算法与一个产生式替代相关联时，该替代通常显示时不包括任何“[ ]”语法注释。这样的注释只应影响替代的语法识别，对替代的相关语义没有影响。
语法导向操作通过使用下列算法中的步骤
- 让status为SyntaxDirectedOperation of
SomeNonTerminal 。 - 让someParseNode为一些源文本的解析。
- 执行someParseNode的SyntaxDirectedOperation。
- 带参数
"value" 执行someParseNode的SyntaxDirectedOperation。
除非另有明确规定，所有
但是
运行时语义：
5.2.3 运行时语义
需要在运行时调用以指定语义的算法称为运行时语义。运行时语义由
5.2.3.1 完成（completionRecord）
抽象操作完成接受参数completionRecord（一个
5.2.3.2 抛出异常
算法步骤中提到抛出异常的，如：
- 抛出一个
TypeError 异常。
意味着与以下内容相同：
- 返回
ThrowCompletion (新创建的TypeError 对象)。
5.2.3.3 ReturnIfAbrupt
算法步骤中提到或等同于以下内容：
ReturnIfAbrupt (argument)。
意味着：
Assert ：argument 是一个Completion Record 。- 如果 argument 是一个
abrupt completion ，返回Completion (argument)。 - 否则，将 argument 设置为 argument.[[Value]]。
算法步骤中提到或等同于：
ReturnIfAbrupt (AbstractOperation())。
意味着：
- 让 hygienicTemp 是 AbstractOperation()。
Assert ：hygienicTemp 是一个Completion Record 。- 如果 hygienicTemp 是一个
abrupt completion ，返回Completion (hygienicTemp)。 - 否则，将 hygienicTemp 设置为 hygienicTemp.[[Value]]。
hygienicTemp 是短暂的，仅在涉及 ReturnIfAbrupt 的步骤中可见。
算法步骤中提到或等同于：
- 让 result 是 AbstractOperation(
ReturnIfAbrupt (argument))。
意味着：
Assert ：argument 是一个Completion Record 。- 如果 argument 是一个
abrupt completion ，返回Completion (argument)。 - 否则，将 argument 设置为 argument.[[Value]]。
- 让 result 是 AbstractOperation(argument)。
5.2.3.4 ReturnIfAbrupt 简写
在?表示应当应用
- ? OperationName().
等同于以下步骤：
ReturnIfAbrupt (OperationName())。
同样，对于方法应用风格，步骤：
- ? someValue.OperationName().
等同于：
ReturnIfAbrupt (someValue.OperationName())。
同样地，前缀!用来表示以下对抽象或
- 让 val 是 ! OperationName().
等同于以下步骤：
!或?：
- 执行 ! SyntaxDirectedOperation of
NonTerminal 。
5.2.3.5 隐式正常完成
在声明返回
- 当直接返回应用
Completion 、NormalCompletion 或ThrowCompletion 的结果时 - 当直接返回构建一个
完成记录 的结果时
如果通过任何其他方式从这样的抽象操作中返回
- 返回
true 。
意味着与任何一种
- 返回
NormalCompletion (true )。
或
- 让completion是
NormalCompletion (true )。 - 返回
Completion (completion)。
或
- 返回
完成记录 { [[Type]]:normal , [[Value]]:true , [[Target]]:empty }。
注意，通过
- 返回 ? completion。
以下示例将是一个编辑错误，因为在该步骤中没有注明正在返回
- 让completion是
NormalCompletion (true )。 - 返回completion。
5.2.4 静态语义
无上下文语法并不足以表达所有定义流式输入元素是否形成可评估的 ECMAScript
静态语义规则具有名称，并通常使用算法定义。命名的静态语义规则与语法产生式相关联，具有多个备选定义的产生式通常对每个适用的命名静态语义规则有一个单独的算法。
静态语义规则的一种特殊类型是早期错误规则。
5.2.5 数学运算
本规范参考以下数值类型：
- 数学值：任意实数，作为默认的数值类型使用。
- 扩展数学值：
数学值 加上 +∞ 和 -∞。 - 数字：IEEE 754-2019 双精度浮点数值。
参见 IEEE 754-2019 。 - BigInts：
ECMAScript 语言值 ，表示与整数整数 一一对应的任意整数。
在本规范的术语中，数值使用下标后缀来区分不同的数值类型。下标 𝔽 表示数字（Numbers），下标 ℤ 表示大整数（BigInts）。没有下标后缀的数值指代
数值运算符（如 +、×、= 和 ≥）根据操作数的类型确定其操作。当应用于
一般来说，当本规范提到数值时，例如“y 的长度”或“由四位十六进制数字表示的
不定义混合类型操作数（例如数字和
本规范中大多数数值以十进制表示；同时也使用形如 0x 后跟数字 0-9 或 A-F 的十六进制值。
当本规范中使用术语 整数 时，指的是在
本文档中对
数学函数
数学函数
记法 “
短语 "将 x 夹在 lower 和 upper 之间"（其中 x 是
数学函数
数学函数
数学函数
从下界 a 到上界 b 的 区间 是可能是无限的、可能为空的、相同数值类型的数值集合。每个边界都将描述为包含或排除，但不会同时包含。有四种类型的区间，如下所示：
从 a（包含）到 b（包含）的区间 ，也称为从 a 到 b 的 包含区间，包括所有 x 的相同数值类型，使得 a ≤ x ≤ b，但不包括其他值。从 a（包含）到 b（排除）的区间 ，包括所有 x 的相同数值类型，使得 a ≤ x < b，但不包括其他值。从 a（排除）到 b（包含）的区间 ，包括所有 x 的相同数值类型，使得 a < x ≤ b，但不包括其他值。从 a（排除）到 b（排除）的区间 ，包括所有 x 的相同数值类型，使得 a < x < b，但不包括其他值。
例如，从 1（包含）到 2（排除）的
5.2.6 值表示法
在本规范中，Function.prototype.apply 或 let n = 42; 区分开来。
5.2.7 身份
在本规范中，规范值和
从本规范的角度来看，“is”一词用于比较两个值是否相等，例如“如果bool为
从 ECMAScript 语言的角度来看，语言值使用
对于规范值，没有规范身份的值包括但不限于：
规范身份对于所有
6 ECMAScript 数据类型和值
本规范中的算法操作值，每个值都有一个关联的类型。可能的值类型正是本条款中定义的那些类型。类型进一步分为
在本规范中，“Type(x)”表示“x的类型”，其中“类型”指的是本条款中定义的ECMAScript语言和规范类型。
6.1 ECMAScript 语言类型
ECMAScript 语言类型对应于由 ECMAScript 程序员直接使用 ECMAScript 语言操作的值。ECMAScript 语言类型包括 Undefined、Null、Boolean、String、Symbol、Number、BigInt 和 Object。一个ECMAScript 语言值是由 ECMAScript 语言类型特征化的值。
6.1.1 Undefined 类型
Undefined 类型恰好有一个值，称为
6.1.2 Null 类型
Null 类型恰好有一个值，称为
6.1.3 Boolean 类型
Boolean 类型表示具有两个值的逻辑实体，称为
6.1.4 String 类型
String 类型是所有有序序列的集合，这些序列由零个或多个 16
位无符号
不解释 String 内容的 ECMAScript 操作不应用进一步的语义。对解释 String 值的操作将每个元素视为单个 UTF-16 代码单元。然而，ECMAScript 不限制这些代码单元的值或关系，因此进一步解释 String 内容为 UTF-16 编码的 Unicode 代码点序列的操作必须考虑到格式不正确的子序列。这些操作对于每个数值位于从 0xD800 到 0xDBFF（由 Unicode 标准定义为leading surrogate，或更正式地称为high-surrogate code unit）的代码单元，以及每个数值位于从 0xDC00 到 0xDFFF（定义为trailing surrogate，或更正式地称为low-surrogate code unit）的代码单元使用以下规则：
- 一个既不是前导代理对也不是后继代理对的代码单元，将被解释为具有相同值的代码点。
- 两个代码单元的序列，其中第一个代码单元 c1 是前导代理对，第二个代码单元 c2 是后继代理对，称为代理对，解释为代码点的值为 (c1 - 0xD800) × 0x400 + (c2 - 0xDC00) + 0x10000。（参见11.1.3）
- 一个是前导代理对或后继代理对的代码单元，但不是代理对的一部分，将被解释为具有相同值的代码点。
函数 String.prototype.normalize（参见22.1.3.15）可以用来显式标准化一个字符串值。String.prototype.localeCompare（参见22.1.3.12）在内部标准化字符串值，但其他操作不会隐式地标准化它们操作的字符串。操作结果除非另有说明，否则不受语言和/或地区的影响。
这种设计背后的理念是为了保持字符串的实现尽可能简单和高效。如果ECMAScript源代码文本处于规范形式C，只要它们不包含任何Unicode转义序列，字符串字面值也保证是标准化的。
在这个规范中，“字符串连接 A、B 等...”（每个参数是一个字符串值、代码单元或代码单元的序列）表示的是一个字符串值，其代码单元的序列是每个参数（按顺序）的代码单元的连接（按顺序）。
短语“从 inclusiveStart 到 exclusiveEnd 的 子字符串”（其中 S 是一个字符串值或代码单元序列，而 inclusiveStart 和 exclusiveEnd 是整数）表示由 S 的连续代码单元组成的字符串值，开始于索引 inclusiveStart 并在索引 exclusiveEnd 之前立即结束（当 inclusiveStart = exclusiveEnd 时为空字符串）。如果省略了“to”后缀，则使用 S 的长度作为 exclusiveEnd 的值。
短语“ASCII 单词字符”表示以下字符串值，它仅由 Unicode 基本拉丁语块中的每个字母和数字以及
U+005F（下划线）组成：
出于历史原因，它对各种算法具有重要意义。
6.1.4.1 StringIndexOf ( string, searchValue, fromIndex )
抽象操作 StringIndexOf 接受参数 string（一个字符串）、searchValue（一个字符串）和 fromIndex
（一个非负
如果 searchValue 是空字符串且 fromIndex ≤ string 的长度，该算法返回 fromIndex。空字符串实际上在字符串中的每个位置都能找到，包括在最后一个码位之后。
如果 fromIndex 加上 searchValue 的长度大于 string 的长度，该算法总是返回 -1。
6.1.5 符号类型（Symbol Type）
符号类型 是可以用作对象属性键的所有非字符串值的集合（
每个可能的符号值都是唯一且不可变的。
每个符号值不可变地持有一个关联的值，称为 [[Description]]，它要么是
6.1.5.1 众所周知的符号（Well-Known Symbols）
众所周知的符号是本规范算法明确引用的内建符号值。它们通常用作属性的键，这些属性的值作为规范算法的扩展点。除非另有说明，否则众所周知的符号值在所有
在本规范中，一个众所周知的符号用 @@name 的形式表示，其中“name”是
| 规范名称 | [[Description]] | 值和用途 |
|---|---|---|
| @@asyncIterator |
|
一个方法，返回对象的默认异步迭代器。由for-await-of语句的语义调用。
|
| @@hasInstance |
|
一个方法，确定构造函数对象是否将某个对象识别为其实例之一。由instanceof运算符的语义调用。
|
| @@isConcatSpreadable |
|
一个布尔值属性，如果为true，表示对象应通过Array.prototype.concat |
| @@iterator |
|
一个方法，返回对象的默认迭代器。由for-of语句的语义调用。 |
| @@match |
|
一个正则表达式方法，将正则表达式与字符串匹配。由String.prototype.match |
| @@matchAll |
|
一个正则表达式方法，返回一个迭代器，该迭代器生成正则表达式与字符串匹配的所有结果。由String.prototype.matchAll |
| @@replace |
|
一个正则表达式方法，替换字符串中的匹配子字符串。由String.prototype.replace |
| @@search |
|
一个正则表达式方法，返回匹配正则表达式的字符串中的索引。由String.prototype.search |
| @@species |
|
一个函数值属性，是用于创建派生对象的构造函数。 |
| @@split |
|
一个正则表达式方法，在匹配正则表达式的索引处分割字符串。由String.prototype.split |
| @@toPrimitive |
|
一个方法，将对象转换为相应的原始值。由 |
| @@toStringTag |
|
一个字符串值属性，用于创建对象的默认字符串描述。由内建方法Object.prototype.toString |
| @@unscopables |
|
一个对象值属性，其自身和继承的属性名称是从相关对象的with环境绑定中排除的属性名称。
|
6.1.6 数字类型（Numeric Types）
ECMAScript 有两种内建的数字类型：Number 和 BigInt。以下
由于数值类型通常不能在不损失精度或截断的情况下相互转换，ECMAScript语言不提供这些类型之间的隐式转换。在调用需要另一种类型的函数时，程序员必须显式调用 Number 和
BigInt 函数进行类型转换。
ECMAScript 的早期和后续版本为某些运算符提供了隐式数值转换，这可能会损失精度或
6.1.6.1 数字类型（The Number Type）
数字类型（Number type）具有精确的
18,437,736,874,454,810,627
（即 NaN 产生。）在一些实现中，外部代码可能能够检测到各种不同的非数值，但这种行为是
还有另外两个特殊值，分别称为 +Infinity（或简单地
Infinity）和 -Infinity 产生。）
其余的 18,437,736,874,454,810,624（即
注意，这里有一个 +0（或简单地 0）和 -0 产生。）
18,437,736,874,454,810,622（即
18,428,729,675,200,069,632（即
其中，s 可以是 1 或 -1，m 是一个
剩余的 9,007,199,254,740,990（即
其中，s 可以是 1 或 -1，m 是一个
注意，在 Number 类型中，所有不大于 253 的正整数和负整数都可以表示。整数 0 在 Number
类型中有两种表示形式：
一个
一些 ECMAScript 运算符只处理特定范围内的
6.1.6.1.1 Number::unaryMinus ( x )
抽象操作 Number::unaryMinus 接受参数 x（一个 Number），并返回一个 Number。调用时执行以下步骤：
- 如果 x 是
NaN ，则返回NaN 。 - 返回取反后的结果 x；即具有相同大小但相反符号的 Number。
6.1.6.1.2 Number::bitwiseNOT ( x )
抽象操作 Number::bitwiseNOT 接受参数 x（一个 Number），并返回一个
6.1.6.1.3 Number::exponentiate ( base, exponent )
抽象操作 Number::exponentiate 接受参数 base（一个 Number）和 exponent（一个 Number），并返回一个
Number。它返回一个
- 如果 exponent 是
NaN ，则返回NaN 。 - 如果 exponent 是
+0 𝔽 或-0 𝔽，则返回1 𝔽。 - 如果 base 是
NaN ，则返回NaN 。 - 如果 base 是
+∞ 𝔽，则- 如果 exponent >
+0 𝔽，则返回+∞ 𝔽。否则，返回+0 𝔽。
- 如果 exponent >
- 如果 base 是
-∞ 𝔽，则- 如果 exponent >
+0 𝔽，那么- 如果 exponent 是奇数的
integral Number ，则返回-∞ 𝔽。否则，返回+∞ 𝔽。
- 如果 exponent 是奇数的
- 否则，
- 如果 exponent 是奇数的
integral Number ，则返回-0 𝔽。否则，返回+0 𝔽。
- 如果 exponent 是奇数的
- 如果 exponent >
- 如果 base 是
+0 𝔽，则- 如果 exponent >
+0 𝔽，则返回+0 𝔽。否则，返回+∞ 𝔽。
- 如果 exponent >
- 如果 base 是
-0 𝔽，则- 如果 exponent >
+0 𝔽，那么- 如果 exponent 是奇数的
integral Number ，则返回-0 𝔽。否则，返回+0 𝔽。
- 如果 exponent 是奇数的
- 否则，
- 如果 exponent 是奇数的
integral Number ，则返回-∞ 𝔽。否则，返回+∞ 𝔽。
- 如果 exponent 是奇数的
- 如果 exponent >
Assert : base 是有限数，并且不是+0 𝔽 或-0 𝔽。- 如果 exponent 是
+∞ 𝔽，则 - 如果 exponent 是
-∞ 𝔽，则 Assert : exponent 是finite ，并且不是+0 𝔽 或-0 𝔽。- 如果 base <
-0 𝔽，并且 exponent 不是一个integral Number ，则返回NaN 。 - 返回一个表示将
ℝ (base) 的ℝ (exponent) 次幂的结果的implementation-approximated 数值。
当 base 是 ** exponent 的结果与
6.1.6.1.4 Number::multiply ( x, y )
抽象操作 Number::multiply 接受参数 x（一个 Number）和 y（一个 Number），返回一个 Number。它根据
6.1.6.1.5 Number::divide ( x, y )
抽象操作 Number::divide 接受参数 x（一个 Number）和 y（一个 Number），返回一个 Number。
它根据
- 如果 x 是
NaN 或者 y 是NaN ，返回NaN 。 - 如果 x 是
+∞ 𝔽 或者-∞ 𝔽，则- 如果 y 是
+∞ 𝔽 或者-∞ 𝔽，返回NaN 。 - 如果 y 是
+0 𝔽 或者 y >+0 𝔽，返回 x。 - 返回 -x。
- 如果 y 是
- 如果 y 是
+∞ 𝔽，则- 如果 x 是
+0 𝔽 或者 x >+0 𝔽，返回+0 𝔽。 否则，返回-0 𝔽。
- 如果 x 是
- 如果 y 是
-∞ 𝔽，则- 如果 x 是
+0 𝔽 或者 x >+0 𝔽，返回-0 𝔽。 否则，返回+0 𝔽。
- 如果 x 是
- 如果 x 是
+0 𝔽 或者-0 𝔽，则- 如果 y 是
+0 𝔽 或者-0 𝔽，返回NaN 。 - 如果 y >
+0 𝔽， 返回 x。 - 返回 -x。
- 如果 y 是
- 如果 y 是
+0 𝔽，则- 如果 x >
+0 𝔽， 返回+∞ 𝔽。否则，返回-∞ 𝔽。
- 如果 x >
- 如果 y 是
-0 𝔽，则- 如果 x >
+0 𝔽， 返回-∞ 𝔽。否则，返回+∞ 𝔽。
- 如果 x >
- 返回
𝔽 (ℝ (x) /ℝ (y)).
6.1.6.1.6 Number::remainder ( n, d )
抽象操作 Number::remainder 接受参数 n（一个 Number）和 d（一个 Number），返回一个 Number。 它返回其操作数的隐含除法的余数，其中 n 是被除数，d 是除数。调用时执行以下步骤：
在 C 和 C++ 中，取余运算符只接受整数操作数；在 ECMAScript 中，它也接受浮点操作数。
% 运算符计算的“余数”操作不同，后者由 % 以类似于 Java 6.1.6.1.7 Number::add ( x, y )
抽象操作 Number::add 接受参数 x（一个 Number）和 y（一个 Number），返回一个
Number。它根据
6.1.6.1.8 Number::subtract ( x, y )
抽象操作 Number::subtract 接受参数 x（一个 Number）和 y（一个 Number），返回一个 Number。它执行减法运算，生成其操作数的差；x 是被减数，y 是减数。调用时执行以下步骤：
- 返回
Number::add (x,Number::unaryMinus (y))。
总是有 x - y 的结果与 x + (-y) 相同。
6.1.6.1.9 Number::leftShift ( x, y )
抽象操作 Number::leftShift 接受参数 x（一个 Number）和 y（一个 Number），返回一个整数 Number。调用时执行以下步骤：
6.1.6.1.10 Number::signedRightShift ( x, y )
抽象操作 Number::signedRightShift 接受参数 x（一个 Number）和 y（一个 Number），返回一个整数 Number。调用时执行以下步骤：
6.1.6.1.11 Number::unsignedRightShift ( x, y )
抽象操作 Number::unsignedRightShift 接受参数 x（一个 Number）和 y（一个 Number），返回一个整数 Number。调用时执行以下步骤：
6.1.6.1.12 Number::lessThan ( x, y )
抽象操作 Number::lessThan 接受参数 x（一个 Number）和 y（一个 Number），返回一个布尔值或
6.1.6.1.13 Number::equal ( x, y )
抽象操作 Number::equal 接受参数 x（一个 Number）和 y（一个 Number），返回一个布尔值。调用时执行以下步骤：
- 如果 x 是
NaN ，则返回false 。 - 如果 y 是
NaN ，则返回false 。 - 如果 x 等于 y，则返回
true 。 - 如果 x 是
+0 𝔽 并且 y 是-0 𝔽，则返回true 。 - 如果 x 是
-0 𝔽 并且 y 是+0 𝔽，则返回true 。 - 返回
false 。
6.1.6.1.14 Number::sameValue ( x, y )
抽象操作 Number::sameValue 接受参数 x（一个 Number）和 y（一个 Number），返回一个布尔值。调用时执行以下步骤：
- 如果 x 是
NaN 并且 y 是NaN ，则返回true 。 - 如果 x 是
+0 𝔽 并且 y 是-0 𝔽，则返回false 。 - 如果 x 是
-0 𝔽 并且 y 是+0 𝔽，则返回false 。 - 如果 x 等于 y，则返回
true 。 - 返回
false 。
6.1.6.1.15 Number::sameValueZero ( x, y )
抽象操作 Number::sameValueZero 接受参数 x（一个 Number）和 y（一个 Number），返回一个布尔值。调用时执行以下步骤：
- 如果 x 是
NaN 并且 y 是NaN ，则返回true 。 - 如果 x 是
+0 𝔽 并且 y 是-0 𝔽，则返回true 。 - 如果 x 是
-0 𝔽 并且 y 是+0 𝔽，则返回true 。 - 如果 x 等于 y，则返回
true 。 - 返回
false 。
6.1.6.1.16 Number::NumberBitwiseOp ( op, x, y )
抽象操作 Number::NumberBitwiseOp 接受参数 op（&、^ 或
|）、x（一个 Number）和 y（一个 Number），返回一个
- 令 lnum 为 !
ToInt32 (x). - 令 rnum 为 !
ToInt32 (y). - 令 lbits 为表示
ℝ (lnum) 的 32 位二进制补码位字符串。 - 令 rbits 为表示
ℝ (rnum) 的 32 位二进制补码位字符串。 - 如果 op 是
&，则- 令 result 为对 lbits 和 rbits 执行按位与操作的结果。
- 否则，如果 op 是
^，则- 令 result 为对 lbits 和 rbits 执行按位异或（XOR）操作的结果。
- 否则，
Assert ：断言 op 是|。- 令 result 为对 lbits 和 rbits 执行按位或操作的结果。
- 返回由 32 位二进制补码位字符串 result 表示的
Number value for 的integer 。
6.1.6.1.17 Number::bitwiseAND ( x, y )
抽象操作 Number::bitwiseAND 接受参数 x（一个 Number）和 y（一个 Number），返回一个
- 返回
NumberBitwiseOp (&, x, y).
6.1.6.1.18 Number::bitwiseXOR ( x, y )
抽象操作 Number::bitwiseXOR 接受参数 x（一个 Number）和 y（一个 Number），返回一个
- 返回
NumberBitwiseOp (^, x, y).
6.1.6.1.19 Number::bitwiseOR ( x, y )
抽象操作 Number::bitwiseOR 接受参数 x（一个 Number）和 y（一个 Number），返回一个
- 返回
NumberBitwiseOp (|, x, y).
6.1.6.1.20 Number::toString ( x, radix )
抽象操作 Number::toString 接受参数 x（一个数字）和 radix（一个在 2 到 36 之间的整数），并返回一个字符串。它使用以
radix 为基数的进位制系统将 x 表示为字符串。使用基数 r 表示数字时所用的数字取自
- 如果 x 是
NaN ，返回"NaN" 。 - 如果 x 是
+0 𝔽 或-0 𝔽，返回"0" 。 - 如果 x <
-0 𝔽，返回字符串连接 的"-" 和Number::toString (-x, radix)。 - 如果 x 是
+∞ 𝔽，返回"Infinity" 。 - 令
n、k 和 s 为
整数 ，使得 k ≥ 1，radixk - 1 ≤ s < radixk，𝔽 (s × radixn - k) 是 x，并且 k 尽可能小。注意，k 是使用基数 radix 表示 s 的数字个数，s 不能被 radix 整除，并且 s 的最低有效位不一定由这些条件唯一确定。 - 如果 radix ≠ 10 或 n 在
包含区间 从 -5 到 21，那么 - 注意：在这种情况下，输入将使用科学 E 表示法表示，例如
1.2e+3。 断言 ：radix 是 10。- 如果 n < 0，那么
- 令 exponentSign 为代码单元 0x002D (HYPHEN-MINUS)。
- 否则，
- 令 exponentSign 为代码单元 0x002B (PLUS SIGN)。
- 如果 k = 1，那么
- 返回
字符串连接 ：- 十进制表示的 s 的最高有效位的代码单元
- 代码单元 0x002E (FULL STOP)
- 十进制表示的 s 的剩余 k - 1 位数字的代码单元
- 代码单元 0x0065 (LATIN SMALL LETTER E)
- exponentSign
- 十进制表示的
abs (n - 1)
ECMAScript 的实现者可能会发现 David M. Gay 撰写的关于浮点数二进制到十进制转换的论文和代码很有用：
Gay, David M. 正确舍入的二进制-十进制和十进制-二进制转换。数值分析，手稿 90-10。AT&T 贝尔实验室（新泽西州默里山）。1990 年 11 月 30 日。
可在
http://ampl.com/REFS/abstracts.html#rounding
获取。
相关代码可在
http://netlib.sandia.gov/fp/dtoa.c 和
http://netlib.sandia.gov/fp/g_fmt.c 获取，并且可能在各个
netlib 镜像站点上找到。
6.1.6.2 BigInt 类型
BigInt 类型 表示一个
6.1.6.2.1 BigInt::unaryMinus ( x )
抽象操作 BigInt::unaryMinus 接受参数 x（一个 BigInt）并返回一个 BigInt。它在被调用时执行以下步骤：
- 如果 x 是
0 ℤ，返回0 ℤ。 - 返回 -x。
6.1.6.2.2 BigInt::bitwiseNOT ( x )
抽象操作 BigInt::bitwiseNOT 接受参数 x（一个 BigInt）并返回一个 BigInt。 它返回 x 的按位取反。它在被调用时执行以下步骤：
- 返回 -x -
1 ℤ。
6.1.6.2.3 BigInt::exponentiate ( base, exponent )
抽象操作 BigInt::exponentiate 接受参数 base（一个 BigInt）和 exponent（一个 BigInt），并返回一个包含 BigInt 的正常完成或抛出完成。它在被调用时执行以下步骤：
- 如果 exponent <
0 ℤ，抛出一个RangeError 异常。 - 如果 base 是
0 ℤ 且 exponent 是0 ℤ，返回1 ℤ。 - 返回 base 的 exponent 次方。
6.1.6.2.4 BigInt::multiply ( x, y )
抽象操作 BigInt::multiply 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在被调用时执行以下步骤：
- 返回 x × y。
6.1.6.2.5 BigInt::divide ( x, y )
抽象操作 BigInt::divide 接受参数 x（一个 BigInt）和 y（一个 BigInt），并返回一个包含 BigInt 的正常完成或抛出完成。它在被调用时执行以下步骤：
6.1.6.2.6 BigInt::remainder ( n, d )
抽象操作 BigInt::remainder 接受参数 n（一个 BigInt）和 d（一个 BigInt），并返回一个
6.1.6.2.7 BigInt::add ( x, y )
抽象操作 BigInt::add 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在被调用时执行以下步骤：
- 返回 x + y。
6.1.6.2.8 BigInt::subtract ( x, y )
抽象操作 BigInt::subtract 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在被调用时执行以下步骤：
- 返回 x - y。
6.1.6.2.9 BigInt::leftShift ( x, y )
抽象操作 BigInt::leftShift 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在被调用时执行以下步骤：
6.1.6.2.10 BigInt::signedRightShift ( x, y )
抽象操作 BigInt::signedRightShift 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在被调用时执行以下步骤：
- 返回
BigInt::leftShift (x, -y).
6.1.6.2.11 BigInt::unsignedRightShift ( x, y )
抽象操作 BigInt::unsignedRightShift 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个
- 抛出一个
TypeError 异常。
6.1.6.2.12 BigInt::lessThan ( x, y )
抽象操作 BigInt::lessThan 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个布尔值。它在被调用时执行以下步骤：
6.1.6.2.13 BigInt::equal ( x, y )
抽象操作 BigInt::equal 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个布尔值。它在被调用时执行以下步骤：
6.1.6.2.14 BinaryAnd ( x, y )
抽象操作 BinaryAnd 接受参数 x（0 或 1）和 y（0 或 1）并返回 0 或 1。它在被调用时执行以下步骤：
- 如果 x = 1 且 y = 1，返回 1。
- 否则，返回 0。
6.1.6.2.15 BinaryOr ( x, y )
抽象操作 BinaryOr 接受参数 x（0 或 1）和 y（0 或 1）并返回 0 或 1。它在被调用时执行以下步骤：
- 如果 x = 1 或 y = 1，返回 1。
- 否则，返回 0。
6.1.6.2.16 BinaryXor ( x, y )
抽象操作 BinaryXor 接受参数 x（0 或 1）和 y（0 或 1）并返回 0 或 1。它在被调用时执行以下步骤：
- 如果 x = 1 且 y = 0，返回 1。
- 否则如果 x = 0 且 y = 1，返回 1。
- 否则，返回 0。
6.1.6.2.17 BigInt位运算 ( op, x, y )
抽象操作 BigInt位运算 接受参数 op（&、
^ 或 |）、x（一个 BigInt）和 y（一个 BigInt）并返回一个
BigInt。它在被调用时执行以下步骤：
- 将 x 设置为
ℝ (x)。 - 将 y 设置为
ℝ (y)。 - 设 result 为 0。
- 设 shift 为 0。
- 重复，直到 (x = 0 或 x = -1) 和 (y = 0 或 y = -1)，
- 如果 op 是
&，那么 - 否则如果 op 是
|，那么 - 否则
- 如果 tmp ≠ 0，那么
- 将 result 设置为 result - 2shift。
- 注意：这扩展了符号位。
- 返回
BigInt 值 for result。
6.1.6.2.18 BigInt::bitwiseAND ( x, y )
抽象操作 BigInt::bitwiseAND 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在调用时执行以下步骤：
- 返回
BigIntBitwiseOp (&, x, y)。
6.1.6.2.19 BigInt::bitwiseXOR ( x, y )
抽象操作 BigInt::bitwiseXOR 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在调用时执行以下步骤：
- 返回
BigIntBitwiseOp (^, x, y)。
6.1.6.2.20 BigInt::bitwiseOR ( x, y )
抽象操作 BigInt::bitwiseOR 接受参数 x（一个 BigInt）和 y（一个 BigInt）并返回一个 BigInt。它在调用时执行以下步骤：
- 返回
BigIntBitwiseOp (|, x, y)。
6.1.6.2.21 BigInt::toString ( x, radix )
抽象操作 BigInt::toString 接受参数 x（一个 BigInt）和 radix（一个在 2 到 36 之间的整数）并返回一个字符串。它使用基数
radix 将 x 表示为字符串。使用基数 r 表示 BigInt 的数字取自
- 如果 x <
0 ℤ，返回字符串连接 的"-" 和BigInt::toString (-x, radix)。 - 返回使用基数 radix 表示 x 的字符串值。
6.1.7 对象类型
每个 对象类型 的实例，也简称为“一个对象”，表示一个属性的集合。每个属性要么是一个数据属性，要么是一个访问器属性：
-
一个 数据属性 将一个键值与一个
ECMAScript 语言值 和一个布尔属性集合关联起来。 -
一个 访问器属性
将一个键值与一个或两个访问器函数以及一个布尔属性集合关联起来。访问器函数用于存储或检索与该属性相关联的
ECMAScript 语言值 。
对象的属性使用属性键唯一标识。一个 属性键
要么是一个字符串，要么是一个符号。所有字符串和符号，包括空字符串，都可以作为属性键。一个 属性名 是一个
一个 整数索引 是一个
属性键用于访问属性和它们的值。属性访问有两种类型：获取 和 设置，分别对应于值的检索和赋值。通过获取和设置访问的属性包括 自有属性 和 继承属性。继承属性可能是关联对象的自有属性或继承属性。每个对象的自有属性必须具有与其他自有属性不同的键值。
所有对象在逻辑上都是属性的集合，但有多种形式的对象，它们的属性访问和操作语义不同。请参见
此外，一些对象是可调用的；这些被称为函数或
6.1.7.1 属性属性
属性用于在本规范中定义和解释对象属性的状态，如
| 属性名称 | 存在的属性类型 | 值域 | 默认值 | 描述 |
|---|---|---|---|---|
| [[Value]] |
|
|
|
通过获取属性访问检索到的值。 |
| [[Writable]] |
|
布尔值 |
|
如果为 |
| [[Get]] |
|
对象或 |
|
如果值 |
| [[Set]] |
|
对象或 |
|
如果值 |
| [[Enumerable]] |
|
一个布尔值 |
|
如果 |
| [[Configurable]] |
|
一个布尔值 |
|
如果 |
6.1.7.2 对象内部方法和内部槽
在 ECMAScript 中，对象的实际语义是通过称为 内部方法 的算法指定的。每个 ECMAScript 引擎中的对象都与一组内部方法相关联，这些方法定义了其运行时行为。这些内部方法不是 ECMAScript 语言的一部分。它们纯粹是为了说明目的而由本规范定义的。然而，ECMAScript 实现中的每个对象必须按照与其相关联的内部方法指定的行为方式行事。实现的具体方式由实现决定。
内部方法名称是多态的。这意味着不同的对象值在调用相同的内部方法名称时可能会执行不同的算法。实际调用内部方法的对象是调用的“目标”。如果在运行时，算法的实现尝试使用对象不支持的内部方法，则会抛出
内部槽对应于与对象相关联并被各种 ECMAScript 规范算法使用的内部状态。内部槽不是对象属性，也不会被继承。
根据特定的内部槽规范，这种状态可能由任何
所有对象都有一个名为 [[PrivateElements]] 的内部槽，它是一个
内部方法和内部槽在本规范中使用双括号 [[ ]] 括起来的名称进行标识。
一个 普通对象 是满足以下所有条件的对象：
-
对于
表 4 中列出的内部方法，对象使用10.1 中定义的那些。 -
如果对象具有 [[Call]] 内部方法，它使用
10.2.1 或10.3.1 中定义的其中之一。 -
如果对象具有 [[Construct]] 内部方法，它使用
10.2.2 或10.3.2 中定义的其中之一。
一个 异域对象 是一个不是
本规范通过这些对象的内部方法识别不同种类的
除了其参数外，内部方法总是可以访问作为方法调用目标的对象。
内部方法隐式返回一个
| 内部方法 | 签名 | 描述 |
|---|---|---|
| [[GetPrototypeOf]] | ( ) → Object | Null |
确定为该对象提供继承属性的对象。 |
| [[SetPrototypeOf]] | (Object | Null) → Boolean |
将该对象与提供继承属性的另一个对象关联。传递 |
| [[IsExtensible]] | ( ) → Boolean | 确定是否允许向该对象添加更多属性。 |
| [[PreventExtensions]] | ( ) → Boolean |
控制是否可以向该对象添加新属性。返回 |
| [[GetOwnProperty]] |
(propertyKey) → Undefined | |
返回该对象自身属性的 |
| [[DefineOwnProperty]] | (propertyKey, 属性描述符) → Boolean |
创建或修改自身属性，其键为 propertyKey，具有 属性描述符 描述的状态。返回 |
| [[HasProperty]] | (propertyKey) → Boolean | 返回一个布尔值，指示该对象是否已经具有键为 propertyKey 的自身或继承属性。 |
| [[Get]] | (propertyKey, Receiver) → any |
从该对象返回键为 propertyKey 的属性的值。如果需要执行 ECMAScript 代码来检索属性值，Receiver 用作评估代码时的
|
| [[Set]] | (propertyKey, value, Receiver) → Boolean |
将键为 propertyKey 的属性的值设置为 value。如果需要执行 ECMAScript
代码来设置属性值，Receiver 用作评估代码时的 |
| [[Delete]] | (propertyKey) → Boolean |
从该对象中删除键为 propertyKey 的自身属性。如果属性未删除且仍存在，返回 |
| [[OwnPropertyKeys]] |
( ) → |
返回一个 |
| 内部方法 | 签名 | 描述 |
|---|---|---|
| [[Call]] |
(any, a |
执行与此对象关联的代码。通过函数调用表达式调用。内部方法的参数是一个 |
| [[Construct]] |
(a |
创建一个对象。通过 new 运算符或 super 调用调用。内部方法的第一个参数是一个 super
调用的参数。第二个参数是最初应用 new 运算符的对象。实现此内部方法的对象称为 |
普通对象和标准异域对象的基本内部方法的语义在第
6.1.7.3 基本内部方法的不变性
ECMAScript引擎中对象的内部方法必须符合下面指定的不变性列表。普通ECMAScript对象以及本规范中的所有标准
任何实现提供的
实现不得以任何方式允许绕过这些不变性，例如通过提供实现基本内部方法功能的替代接口而不强制执行其不变性。
定义:
- 内部方法的目标是调用内部方法的对象。
-
如果目标对象的[[IsExtensible]]内部方法返回
false ，或者其[[PreventExtensions]]内部方法返回true ，则该目标是不可扩展的。 - 不存在的属性是不可扩展目标对象上不存在的自有属性。
-
所有对
SameValue 的引用均根据SameValue 算法的定义。
返回值:
任何内部方法返回的值必须是一个
- [[Type]] =
normal ，[[Target]] =empty ，和[[Value]] = 该内部方法显示的“正常返回类型”的值，或 - [[Type]] =
throw ，[[Target]] =empty ，和[[Value]] = 任何ECMAScript语言值 。
[[GetPrototypeOf]] ( )
- 正常返回类型是Object或Null。
-
如果目标对象是不可扩展的，并且[[GetPrototypeOf]]返回一个值V，那么任何未来的[[GetPrototypeOf]]调用应返回与V相同的
SameValue 。
[[SetPrototypeOf]] ( V )
- 正常返回类型是Boolean。
-
如果目标对象是不可扩展的，[[SetPrototypeOf]]必须返回
false ，除非V与目标对象观察到的[[GetPrototypeOf]]值相同SameValue 。
[[IsExtensible]] ( )
- 正常返回类型是Boolean。
-
如果[[IsExtensible]]返回
false ，所有未来对该目标对象的[[IsExtensible]]调用必须返回false 。
[[PreventExtensions]] ( )
- 正常返回类型是Boolean。
-
如果[[PreventExtensions]]返回
true ，所有未来对该目标对象的[[IsExtensible]]调用必须返回false ，并且该目标对象现在被认为是不可扩展的。
[[GetOwnProperty]] ( P )
-
正常返回类型是
Property Descriptor 或Undefined。 -
如果返回值的类型是
Property Descriptor ，则返回值必须是一个完全填充的Property Descriptor 。 -
如果P被描述为不可配置、不可写的自有
数据属性 ，所有未来对[[GetOwnProperty]] ( P )的调用必须返回Property Descriptor ，其[[Value]]与P的[[Value]]属性相同SameValue 。 -
如果P的除了[[Writable]]和[[Value]]之外的属性可能会随时间变化，或者如果该属性可能会被删除，那么P的[[Configurable]]属性必须是
true 。 -
如果[[Writable]]属性可能从
false 变为true ，那么[[Configurable]]属性必须是true 。 -
如果目标对象是不可扩展的且P不存在，那么所有未来对该目标对象的[[GetOwnProperty]] ( P
)调用必须将P描述为不存在（即[[GetOwnProperty]] ( P
)必须返回
undefined ）。
由于第三个不变性的结果，如果一个属性被描述为
[[DefineOwnProperty]] ( P, Desc )
- 正常返回类型是Boolean。
-
[[DefineOwnProperty]]必须返回
false ，如果P之前已被观察为目标对象的不可配置自有属性，除非： -
[[DefineOwnProperty]] ( P, Desc )
必须返回
false ，如果目标对象是不可扩展的且P是一个不存在的自有属性。也就是说，一个不可扩展的目标对象不能被扩展新的属性。
[[HasProperty]] ( P )
- 正常返回类型是Boolean。
-
如果P之前已被观察为目标对象的不可配置自有数据或
访问器属性 ，[[HasProperty]]必须返回true 。
[[Get]] ( P, Receiver )
-
正常返回类型是任何
ECMAScript语言类型 。 -
如果P之前已被观察为目标对象的不可配置、不可写的自有
数据属性 ，其值为V，那么[[Get]]必须返回与V相同的SameValue 。 -
如果P之前已被观察为目标对象的不可配置自有
访问器属性 ，其[[Get]]属性为undefined ，[[Get]]操作必须返回undefined 。
[[Set]] ( P, V, Receiver )
- 正常返回类型是Boolean。
-
如果P之前已被观察为目标对象的不可配置、不可写的自有
数据属性 ，那么[[Set]]必须返回false ，除非V与P的[[Value]]属性相同SameValue 。 -
如果P之前已被观察为目标对象的不可配置自有
访问器属性 ，其[[Set]]属性为undefined ，[[Set]]操作必须返回false 。
[[Delete]] ( P )
- 正常返回类型是Boolean。
-
如果P之前已被观察为目标对象的不可配置自有数据或
访问器属性 ，[[Delete]]必须返回false 。
[[OwnPropertyKeys]] ( )
-
正常返回类型是
List 。 -
返回的
List 不得包含任何重复条目。 -
返回的
List 的每个元素的类型必须是String或Symbol。 -
返回的
List 必须至少包含所有之前观察到的不可配置自有属性的键。 -
如果目标对象是不可扩展的，返回的
List 必须仅包含目标对象的所有自有属性的键，这些属性可通过[[GetOwnProperty]]观察到。
[[Call]] ( )
-
正常返回类型是任何
ECMAScript语言类型 。
[[Construct]] ( )
- 正常返回类型是Object。
- 目标对象还必须具有[[Call]]内部方法。
6.1.7.4 众所周知的内在对象
众所周知的内在对象是内置对象，它们在本规范的算法中被明确引用，并且通常具有与
在本规范中，诸如%name%的引用意味着与当前
| 内置名称 | 全局名称 | ECMAScript 语言关联 |
|---|---|---|
|
|
AggregateError
|
AggregateError |
|
|
Array
|
Array |
|
|
ArrayBuffer
|
ArrayBuffer |
|
|
数组迭代器对象的原型 ( |
|
|
|
async-from-sync 迭代器对象的原型 ( |
|
|
|
异步函数对象的 |
|
|
|
异步迭代器对象的 |
|
|
|
所有标准内置异步迭代器对象间接继承的对象 | |
|
|
Atomics
|
Atomics 对象 ( |
|
|
BigInt
|
BigInt |
|
|
BigInt64Array
|
BigInt64Array |
|
|
BigUint64Array
|
BigUint64Array |
|
|
布尔值
|
布尔值 |
|
|
数据视图
|
数据视图 |
|
|
Date
|
Date |
|
|
decodeURI
|
decodeURI 函数 ( |
|
|
decodeURIComponent
|
decodeURIComponent 函数 ( |
|
|
encodeURI
|
encodeURI 函数 ( |
|
|
encodeURIComponent
|
encodeURIComponent 函数 ( |
|
|
Error
|
Error |
|
|
eval
|
eval 函数 ( |
|
|
EvalError
|
EvalError |
|
|
FinalizationRegistry
|
|
|
|
Float32Array
|
Float32Array |
|
|
Float64Array
|
Float64Array |
|
|
For-In 迭代器对象的原型 ( |
|
|
|
Function
|
Function |
|
|
生成器的构造函数 ( |
|
|
|
Int8Array
|
Int8Array |
|
|
Int16Array
|
Int16Array |
|
|
Int32Array
|
Int32Array |
|
|
isFinite
|
isFinite 函数 ( |
|
|
isNaN
|
isNaN 函数 ( |
|
|
所有标准内置迭代器对象间接继承的对象 | |
|
|
JSON
|
JSON 对象 ( |
|
|
Map
|
Map |
|
|
Map 迭代器对象的原型 ( |
|
|
|
Math
|
Math 对象 ( |
|
|
Number
|
Number |
|
|
Object
|
Object |
|
|
parseFloat
|
parseFloat 函数 ( |
|
|
parseInt
|
parseInt 函数 ( |
|
|
Promise
|
Promise |
|
|
Proxy
|
Proxy |
|
|
RangeError
|
RangeError |
|
|
ReferenceError
|
ReferenceError |
|
|
Reflect
|
Reflect 对象 ( |
|
|
RegExp
|
RegExp |
|
|
正则表达式字符串迭代器对象的原型 ( |
|
|
|
Set
|
Set |
|
|
Set 迭代器对象的原型 ( |
|
|
|
SharedArrayBuffer
|
SharedArrayBuffer |
|
|
String
|
String |
|
|
字符串迭代器对象的原型 ( |
|
|
|
Symbol
|
Symbol |
|
|
SyntaxError
|
SyntaxError |
|
|
一个 |
|
|
|
所有类型化数组 |
|
|
|
TypeError
|
TypeError |
|
|
Uint8Array
|
Uint8Array |
|
|
Uint8ClampedArray
|
Uint8ClampedArray |
|
|
Uint16Array
|
Uint16Array |
|
|
Uint32Array
|
Uint32Array |
|
|
URIError
|
URIError |
|
|
WeakMap
|
WeakMap |
|
|
WeakRef
|
|
|
|
WeakSet
|
WeakSet |
在
6.2 ECMAScript 规范类型
规范类型对应于在算法中使用的元值，用于描述 ECMAScript 语言结构和
6.2.1 枚举规范类型
枚举是规范内部的值，不能直接从 ECMAScript 代码中观察到。枚举用
6.2.2 列表和记录规范类型
列表类型用于解释参数列表的评估（参见 new 表达式、函数调用和其他需要简单有序值列表的算法中。列表类型的值是包含各个值的列表元素的简单有序序列。这些序列可以是任意长度的。列表元素可以使用基于 0
的索引随机访问。为了表示方便，可以使用类似数组的语法来访问列表元素。例如，arguments[2] 是表示列表 arguments 的第 3 个元素的简写。
当算法迭代列表元素而不指定顺序时，使用的顺序是列表中元素的顺序。
为了在本规范中表示方便，可以使用字面量语法来表示新的列表值。例如，« 1, 2 » 定义了一个包含两个元素的列表值，每个元素初始化为特定值。一个新的空列表可以表示为 « »。
在本规范中，短语“列表连接 A、B、...”（其中每个参数是一个可能为空的列表）表示一个新列表值，其元素是每个参数（按顺序）的元素（按顺序）的连接。
记录类型用于描述本规范算法中的数据聚合。记录类型值由一个或多个命名字段组成。每个字段的值是一个
为了在本规范中表示方便，可以使用类似对象字面量的语法来表示记录值。例如，{ [[Field1]]: 42, [[Field2]]:
在规范文本和算法中，可以使用点表示法来引用记录值的特定字段。例如，如果 R 是前一段中显示的记录，则 R.[[Field2]] 是“R 中名为 [[Field2]] 的字段”的简写。
常用记录字段组合的模式可以命名，并且该名称可以用作字面量记录值的前缀，以标识所描述的特定聚合类型。例如：PropertyDescriptor { [[Value]]:
42, [[Writable]]:
6.2.3 集合和关系规范类型
集合类型用于解释
关系类型用于解释对集合的约束。关系类型的值是其值域中值的有序对集合。例如，事件上的关系是事件的有序对集合。对于关系 R 和 R 值域中的两个值 a 和 b，a R b 是表示有序对 (a, b) 是 R 成员的简写。关系在某些条件下是最小的，当它是满足这些条件的最小关系时。
严格偏序是满足以下条件的关系值 R：
-
对于 R 域中的所有 a、b 和 c：
- 不是 a R a，并且
- 如果 a R b 和 b R c，则 a R c。
上述两个属性分别称为非自反性和传递性。
严格全序是满足以下条件的关系值 R：
-
对于 R 域中的所有 a、b 和 c：
- a 是 b 或 a R b 或 b R a，并且
- 不是 a R a，并且
- 如果 a R b 和 b R c，则 a R c。
上述三个属性分别称为完全性、非自反性和传递性。
6.2.4 完成记录规范类型
完成记录规范类型用于解释值和控制流的运行时传播，例如执行非本地控制转移的语句（break、continue、return
和 throw）的行为。
完成记录具有
以下简短术语有时用于指代完成记录。
- 正常完成指任何 [[Type]] 值为
normal 的完成记录。 - 中断完成指任何 [[Type]] 值为
break 的完成记录。 - 继续完成指任何 [[Type]] 值为
continue 的完成记录。 - 返回完成指任何 [[Type]] 值为
return 的完成记录。 - 抛出完成指任何 [[Type]] 值为
throw 的完成记录。 - 异常完成指任何 [[Type]] 值不是
normal 的完成记录。 - 某种类型的 正常完成包含 指 [[Value]] 字段中包含该类型值的正常完成。
本规范中定义的可调用对象仅返回正常完成或抛出完成。返回任何其他类型的完成记录被视为编辑错误。
6.2.4.1 NormalCompletion ( value )
抽象操作 NormalCompletion 接受参数 value（任何值，除了
- 返回
完成记录 { [[Type]]:normal , [[Value]]: value, [[Target]]:empty }.
6.2.4.2 ThrowCompletion ( value )
抽象操作 ThrowCompletion 接受参数 value（一个
- 返回
完成记录 { [[Type]]:throw , [[Value]]: value, [[Target]]:empty }.
6.2.4.3 UpdateEmpty ( completionRecord, value )
抽象操作 UpdateEmpty 接受参数 completionRecord（一个
6.2.5 引用记录规范类型
引用记录类型用于解释
delete、typeof、赋值运算符、super
引用记录是已解析的名称或属性绑定；其字段由
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Base]] | 一个 |
持有绑定的值或 |
| [[ReferencedName]] | 字符串、符号或 |
绑定的名称。如果 [[Base]] 值是 |
| [[Strict]] | 布尔值 | |
| [[ThisValue]] | 一个 |
如果不是 super |
以下
6.2.5.1 IsPropertyReference ( V )
抽象操作 IsPropertyReference 接受参数 V（一个
- 如果 V.[[Base]] 是
unresolvable ，返回false 。 - 如果 V.[[Base]] 是一个
环境记录 ，返回false ；否则返回true 。
6.2.5.2 IsUnresolvableReference ( V )
抽象操作 IsUnresolvableReference 接受参数 V（一个
- 如果 V.[[Base]] 是
unresolvable ，返回true ；否则返回false 。
6.2.5.3 IsSuperReference ( V )
抽象操作 IsSuperReference 接受参数 V（一个
- 如果 V.[[ThisValue]] 不是
empty ，返回true ；否则返回false 。
6.2.5.4 IsPrivateReference ( V )
抽象操作 IsPrivateReference 接受参数 V（一个
- 如果 V.[[ReferencedName]] 是
私有名称 ，返回true ；否则返回false 。
6.2.5.5 GetValue ( V )
抽象操作 GetValue 接受参数 V（一个
- 如果 V 不是一个
引用记录 ，返回 V。 - 如果
IsUnresolvableReference (V) 是true ，抛出一个ReferenceError 异常。 - 如果
IsPropertyReference (V) 是true ，那么- 令 baseObj 为
?
ToObject (V.[[Base]])。 - 如果
IsPrivateReference (V) 是true ，那么- 返回 ?
PrivateGet (baseObj, V.[[ReferencedName]])。
- 返回 ?
- 返回 ? baseObj.[[Get]](V.[[ReferencedName]],
GetThisValue (V))。
- 令 baseObj 为
?
- 否则，
6.2.5.6 PutValue ( V, W )
抽象操作 PutValue 接受参数 V（一个
- 如果 V 不是一个
引用记录 ，抛出一个ReferenceError 异常。 - 如果
IsUnresolvableReference (V) 是true ，那么- 如果 V.[[Strict]] 是
true ，抛出一个ReferenceError 异常。 - 令 globalObj 为
GetGlobalObject ()。 - 执行 ?
Set (globalObj, V.[[ReferencedName]], W,false )。 - 返回
unused 。
- 如果 V.[[Strict]] 是
- 如果
IsPropertyReference (V) 是true ，那么- 令 baseObj 为
?
ToObject (V.[[Base]])。 - 如果
IsPrivateReference (V) 是true ，那么- 返回 ?
PrivateSet (baseObj, V.[[ReferencedName]], W)。
- 返回 ?
- 令 succeeded 为 ? baseObj.[[Set]](V.[[ReferencedName]],
W,
GetThisValue (V))。 - 如果 succeeded 是
false 且 V.[[Strict]] 是true ，抛出一个TypeError 异常。 - 返回
unused 。
- 令 baseObj 为
?
- 否则，
6.2.5.7 GetThisValue ( V )
抽象操作GetThisValue接受参数V（一个
断言 ：IsPropertyReference (V) 是true 。- 如果
IsSuperReference (V) 是true ，返回V.[[ThisValue]]；否则返回V.[[Base]]。
6.2.5.8 InitializeReferencedBinding ( V, W )
抽象操作InitializeReferencedBinding接受参数V（一个
断言 ：IsUnresolvableReference (V) 是false 。- 设base为V.[[Base]]。
断言 ：base是一个环境记录 。- 返回 ? base.InitializeBinding(V.[[ReferencedName]], W)。
6.2.5.9 MakePrivateReference ( baseValue, privateIdentifier )
抽象操作MakePrivateReference接受参数baseValue（一个
- 设privEnv为
运行执行上下文 的PrivateEnvironment。 断言 ：privEnv不是null 。- 设privateName为
ResolvePrivateIdentifier (privEnv, privateIdentifier)。 - 返回
引用记录 { [[Base]]: baseValue, [[ReferencedName]]: privateName, [[Strict]]:true , [[ThisValue]]:empty }。
6.2.6 属性描述符规范类型
属性描述符类型用于解释对象属性属性的操作和具体化。属性描述符是一个
属性描述符值可以根据某些字段的存在或使用进一步分类为数据属性描述符和访问器属性描述符。数据属性描述符是包含名为[[Value]]或[[Writable]]的字段的描述符。访问器属性描述符是包含名为[[Get]]或[[Set]]的字段的描述符。任何属性描述符都可能包含名为[[Enumerable]]和[[Configurable]]的字段。属性描述符值不能同时是数据属性描述符和访问器属性描述符；然而，它可以既不是（在这种情况下，它是一个通用属性描述符）。一个完全填充的属性描述符是访问器属性描述符或数据属性描述符，并且具有
以下
6.2.6.1 IsAccessorDescriptor ( Desc )
抽象操作IsAccessorDescriptor接受参数Desc（一个
- 如果Desc是
undefined ，返回false 。 - 如果Desc有[[Get]]字段，返回
true 。 - 如果Desc有[[Set]]字段，返回
true 。 - 返回
false 。
6.2.6.2 IsDataDescriptor ( Desc )
抽象操作IsDataDescriptor接受参数Desc（一个
- 如果Desc是
undefined ，返回false 。 - 如果Desc有[[Value]]字段，返回
true 。 - 如果Desc有[[Writable]]字段，返回
true 。 - 返回
false 。
6.2.6.3 IsGenericDescriptor ( Desc )
抽象操作IsGenericDescriptor接受参数Desc（一个
- 如果Desc是
undefined ，返回false 。 - 如果
IsAccessorDescriptor (Desc) 是true ，返回false 。 - 如果
IsDataDescriptor (Desc) 是true ，返回false 。 - 返回
true 。
6.2.6.4 FromPropertyDescriptor ( Desc )
抽象操作FromPropertyDescriptor接受参数Desc（一个
- 如果Desc是
undefined ，返回undefined 。 - 设obj为
OrdinaryObjectCreate (%Object.prototype% )。 断言 ：obj是一个可扩展的普通对象 ，没有自己的属性。- 如果Desc有[[Value]]字段，则
- 执行!
CreateDataPropertyOrThrow (obj,"value" , Desc.[[Value]])。
- 执行!
- 如果Desc有[[Writable]]字段，则
- 执行!
CreateDataPropertyOrThrow (obj,"writable" , Desc.[[Writable]])。
- 执行!
- 如果Desc有[[Get]]字段，则
- 执行!
CreateDataPropertyOrThrow (obj,"get" , Desc.[[Get]])。
- 执行!
- 如果Desc有[[Set]]字段，则
- 执行!
CreateDataPropertyOrThrow (obj,"set" , Desc.[[Set]])。
- 执行!
- 如果Desc有[[Enumerable]]字段，则
- 执行!
CreateDataPropertyOrThrow (obj,"enumerable" , Desc.[[Enumerable]])。
- 执行!
- 如果Desc有[[Configurable]]字段，则
- 执行!
CreateDataPropertyOrThrow (obj,"configurable" , Desc.[[Configurable]])。
- 执行!
- 返回obj。
6.2.6.5 ToPropertyDescriptor ( Obj )
抽象操作ToPropertyDescriptor接受参数Obj（一个
- 如果Obj
不是一个对象 ，抛出一个TypeError 异常。 - 设desc为一个新
属性描述符 ，最初没有字段。 - 设hasEnumerable为?
HasProperty (Obj,"enumerable" )。 - 如果hasEnumerable是
true ，则 - 设hasConfigurable为?
HasProperty (Obj,"configurable" )。 - 如果hasConfigurable是
true ，则 - 设hasValue为?
HasProperty (Obj,"value" )。 - 如果hasValue是
true ，则- 设value为?
Get (Obj,"value" )。 - 设desc.[[Value]]为value。
- 设value为?
- 设hasWritable为?
HasProperty (Obj,"writable" )。 - 如果hasWritable是
true ，则 - 设hasGet为?
HasProperty (Obj,"get" )。 - 如果hasGet是
true ，则- 设getter为?
Get (Obj,"get" )。 - 如果
IsCallable (getter)是false 且getter不是undefined ，抛出一个TypeError 异常。 - 设desc.[[Get]]为getter。
- 设getter为?
- 设hasSet为?
HasProperty (Obj,"set" )。 - 如果hasSet是
true ，则- 设setter为?
Get (Obj,"set" )。 - 如果
IsCallable (setter)是false 且setter不是undefined ，抛出一个TypeError 异常。 - 设desc.[[Set]]为setter。
- 设setter为?
- 如果desc有[[Get]]字段或desc有[[Set]]字段，则
- 如果desc有[[Value]]字段或desc有[[Writable]]字段，抛出一个
TypeError 异常。
- 如果desc有[[Value]]字段或desc有[[Writable]]字段，抛出一个
- 返回desc。
6.2.6.6 CompletePropertyDescriptor ( Desc )
抽象操作CompletePropertyDescriptor接受参数Desc（一个
- 设like为
记录 { [[Value]]:undefined , [[Writable]]:false , [[Get]]:undefined , [[Set]]:undefined , [[Enumerable]]:false , [[Configurable]]:false }。 - 如果
IsGenericDescriptor (Desc) 是true 或IsDataDescriptor (Desc) 是true ，则- 如果Desc没有[[Value]]字段，设Desc.[[Value]]为like.[[Value]]。
- 如果Desc没有[[Writable]]字段，设Desc.[[Writable]]为like.[[Writable]]。
- 否则
- 如果Desc没有[[Get]]字段，设Desc.[[Get]]为like.[[Get]]。
- 如果Desc没有[[Set]]字段，设Desc.[[Set]]为like.[[Set]]。
- 如果Desc没有[[Enumerable]]字段，设Desc.[[Enumerable]]为like.[[Enumerable]]。
- 如果Desc没有[[Configurable]]字段，设Desc.[[Configurable]]为like.[[Configurable]]。
- 返回
未使用 。
6.2.7 环境记录规范类型
6.2.8 抽象闭包规范类型
抽象闭包规范类型用于引用算法步骤以及一组值。抽象闭包通过函数应用风格调用，例如closure(arg1, arg2)。与
在创建抽象闭包的算法步骤中，值通过“捕获”动词后跟别名列表来捕获。当创建抽象闭包时，它会捕获创建时与每个别名关联的值。在指定抽象闭包被调用时要执行的算法步骤中，每个捕获的值通过用于捕获该值的别名来引用。
如果抽象闭包返回一个
抽象闭包作为其他算法的一部分内联创建，如下例所示。
6.2.9 数据块
数据块规范类型用于描述一个独特且可变的字节大小（8位）数值序列。字节值是一个
为了在本规范中表示方便，可以使用类似数组的语法来访问数据块值的各个字节。这种表示法将数据块值呈现为从0开始的
驻留在可以被多个
共享数据块的语义通过
以下
6.2.9.1 CreateByteDataBlock ( size )
抽象操作CreateByteDataBlock接受参数size（一个非负
6.2.9.2 CreateSharedByteDataBlock ( size )
抽象操作 CreateSharedByteDataBlock 接受参数 size（一个非负的
- 令 db 为一个由 size 字节组成的新
共享数据块 值。如果无法创建这样的共享数据块 ，则抛出一个RangeError 异常。 - 令 execution 为
周围代理 的代理记录 的 [[CandidateExecution]] 字段。 - 令 eventsRecord 为 execution.[[EventsRecords]] 的
代理事件记录 ，其 [[AgentSignifier]] 为代理标识符 ()。 - 令 zero 为 « 0 »。
- 对于 db 的每个索引 i，执行以下步骤：
- 将
写共享内存 { [[Order]]:init , [[NoTear]]:true , [[Block]]: db, [[ByteIndex]]: i, [[ElementSize]]: 1, [[Payload]]: zero } 追加到 eventsRecord.[[EventList]]。
- 将
- 返回 db。
6.2.9.3 CopyDataBlockBytes ( toBlock, toIndex, fromBlock, fromIndex, count )
抽象操作 CopyDataBlockBytes 接受参数 toBlock（一个
断言 ：fromBlock 和 toBlock 是不同的值。- 令 fromSize 为 fromBlock 中的字节数。
断言 ：fromIndex + count ≤ fromSize。- 令 toSize 为 toBlock 中的字节数。
断言 ：toIndex + count ≤ toSize。- 重复，当 count > 0 时，执行以下步骤：
- 如果 fromBlock 是一个
共享数据块 ，则- 令 execution 为
周围代理 的代理记录 的 [[CandidateExecution]] 字段。 - 令 eventsRecord 为 execution.[[EventsRecords]] 的
代理事件记录 ，其 [[AgentSignifier]] 为代理标识符 ()。 - 令 bytes 为一个
列表 ，其唯一元素是一个不确定选择的字节值 。 - 注意：在实现中，bytes 是底层硬件上非原子读指令的结果。这种不确定性是
内存模型 的语义描述，用于描述具有弱一致性硬件的可观察行为。 - 令 readEvent 为
读共享内存 { [[Order]]:unordered , [[NoTear]]:true , [[Block]]: fromBlock, [[ByteIndex]]: fromIndex, [[ElementSize]]: 1 }。 - 将 readEvent 追加到 eventsRecord.[[EventList]]。
- 将
选择值记录 { [[Event]]: readEvent, [[ChosenValue]]: bytes } 追加到 execution.[[ChosenValues]]。 - 如果 toBlock 是一个
共享数据块 ，则- 将
写共享内存 { [[Order]]:unordered , [[NoTear]]:true , [[Block]]: toBlock, [[ByteIndex]]: toIndex, [[ElementSize]]: 1, [[Payload]]: bytes } 追加到 eventsRecord.[[EventList]]。
- 将
- 否则，
- 将 toBlock[toIndex] 设置为 bytes[0]。
- 令 execution 为
- 否则，
- 将 toIndex 设置为 toIndex + 1。
- 将 fromIndex 设置为 fromIndex + 1。
- 将 count 设置为 count - 1。
- 如果 fromBlock 是一个
- 返回
unused 。
6.2.10 私有元素规范类型
私有元素类型是一个
私有元素类型的值是
| 字段名称 | [[Kind]] 字段值 | 值 | 含义 |
|---|---|---|---|
| [[Key]] | 所有 |
一个 |
字段、方法或访问器的名称。 |
| [[Kind]] | 所有 |
|
元素的种类。 |
| [[Value]] |
|
一个 |
字段的值。 |
| [[Get]] |
|
一个 |
私有访问器的 getter。 |
| [[Set]] |
|
一个 |
私有访问器的 setter。 |
6.2.11 类字段定义记录规范类型
类字段定义类型是一个
类字段定义类型的值是
6.2.12 私有名称
私有名称规范类型用于描述一个全局唯一的值（不同于任何其他私有名称，即使它们在其他方面无法区分），该值表示私有类元素（字段、方法或访问器）的键。每个私有名称都有一个关联的不可变 [[Description]]，它是一个
6.2.13 类静态块定义记录规范类型
类静态块定义记录是一个
类静态块定义记录的字段列在
7 抽象操作
这些操作不是 ECMAScript 语言的一部分；它们在这里仅用于帮助规范 ECMAScript 语言的语义。其他更专业的
7.1 类型转换
ECMAScript 语言在需要时隐式执行自动类型转换。为了阐明某些结构的语义，定义了一组转换
ECMAScript 语言中的
7.1.1 ToPrimitive ( input [ , preferredType ] )
抽象操作 ToPrimitive 接受参数 input（一个
- 如果 input
是一个对象 ， then- 令 exoticToPrim 为 ?
GetMethod (input,@@toPrimitive )。 - 如果 exoticToPrim 不是
undefined ， then - 如果 preferredType 不存在，令
preferredType 为
number 。 - 返回 ?
OrdinaryToPrimitive (input, preferredType)。
- 令 exoticToPrim 为 ?
- 返回 input。
当 ToPrimitive 被调用时不带提示时，它的行为通常类似于提示为
7.1.1.1 OrdinaryToPrimitive ( O, hint )
抽象操作 OrdinaryToPrimitive 接受参数 O（一个对象）和 hint
（
- 如果 hint 是
string ，则- 令 methodNames 为 «
"toString" ,"valueOf" »。
- 令 methodNames 为 «
- 否则，
- 令 methodNames 为 «
"valueOf" ,"toString" »。
- 令 methodNames 为 «
- 对于 methodNames 的每个元素 name，执行
- 令 method 为 ?
Get (O, name)。 - 如果
IsCallable (method) istrue ，则
- 令 method 为 ?
- 抛出一个
TypeError 异常。
7.1.2 ToBoolean ( argument )
抽象操作 ToBoolean 接受参数 argument（一个
7.1.3 ToNumeric ( value )
抽象操作 ToNumeric 接受参数 value（一个
- 令 primValue 为 ?
ToPrimitive (value,number )。 - 如果 primValue
是一个 BigInt ，返回 primValue。 - 返回 ?
ToNumber (primValue)。
7.1.4 ToNumber ( argument )
抽象操作 ToNumber 接受参数 argument（一个
- 如果 argument
是一个数字 ，返回 argument。 - 如果 argument 是符号或 BigInt，抛出一个
TypeError 异常。 - 如果 argument 是
undefined ，返回NaN 。 - 如果 argument 是
null 或false ，返回+0 𝔽。 - 如果 argument 是
true ，返回1 𝔽。 - 如果 argument
是一个字符串 ，返回StringToNumber (argument)。 断言 ：argument是一个对象 。- 令 primValue 为 ?
ToPrimitive (argument,number )。 断言 ：primValue不是一个对象 。- 返回 ?
ToNumber (primValue)。
7.1.4.1 ToNumber 应用于字符串类型
抽象操作
语法
所有未明确定义的语法符号均使用词法语法中为数字字面量定义的定义（
7.1.4.1.1 StringToNumber ( str )
抽象操作 StringToNumber 接受参数 str（一个字符串）并返回一个数字。 当调用时，它执行以下步骤：
- 令 text 为
StringToCodePoints (str). - 令 literal 为
ParseText (text,StringNumericLiteral ). - 如果 literal 是一个
List 的错误，返回NaN . - 返回
StringNumericValue 的 literal.
7.1.4.1.2 运行时语义：StringNumericValue
语法导向操作
将
它在以下产生式上分段定义：
- 返回
+0 𝔽。
- 返回
𝔽 (MV ofNonDecimalIntegerLiteral )。
- 令 a 为
StringNumericValue 的StrUnsignedDecimalLiteral 。 - 如果 a 是
+0 𝔽，返回-0 𝔽。 - 返回 -a。
- 返回
+∞ 𝔽。
- 令 a 为第一个
DecimalDigits 的 MV。 - 如果第二个
DecimalDigits 存在，则- 令 b 为第二个
DecimalDigits 的 MV。 - 令 n 为第二个
DecimalDigits 的代码点数。
- 令 b 为第二个
- 否则，
- 令 b 为 0。
- 令 n 为 0。
- 如果
ExponentPart 存在，令 e 为ExponentPart 的 MV。否则，令 e 为 0。 - 返回
RoundMVResult ((a + (b × 10-n)) × 10e)。
- 令 b 为
DecimalDigits 的 MV。 - 如果
ExponentPart 存在，令 e 为ExponentPart 的 MV。否则，令 e 为 0。 - 令 n 为
DecimalDigits 的代码点数。 - 返回
RoundMVResult (b × 10e - n)。
- 令 a 为
DecimalDigits 的 MV。 - 如果
ExponentPart 存在，令 e 为ExponentPart 的 MV。否则，令 e 为 0。 - 返回
RoundMVResult (a × 10e)。
7.1.4.1.3 RoundMVResult ( n )
抽象操作 RoundMVResult 接受参数 n（一个
- 如果 n 的十进制表示有 20 个或更少的有效数字，返回
𝔽 (n)。 - 令 option1 为结果的
mathematical value ，其中 n 的十进制表示中第 20 位之后的每个有效数字都被替换为 0。 - 令 option2 为结果的
mathematical value ，其中 n 的十进制表示中第 20 位之后的每个有效数字都被替换为 0，然后在第 20 位处递增（必要时进位）。 - 令 chosen 为
实现定义 的 option1 或 option2 的选择。 - 返回
𝔽 (chosen)。
7.1.5 ToIntegerOrInfinity ( argument )
抽象操作 ToIntegerOrInfinity 接受参数 argument（一个
7.1.6 ToInt32 ( argument )
抽象操作 ToInt32 接受参数 argument（一个
根据上述 ToInt32 的定义：
- ToInt32 抽象操作是幂等的：如果应用于其产生的结果，第二次应用不会改变该值。
-
ToInt32(
ToUint32 (x)) 与 ToInt32(x) 对于所有 x 的值是相同的。（为了保持这一特性，+∞ 𝔽 和-∞ 𝔽 被映射到+0 𝔽。） -
ToInt32 将
-0 𝔽 映射到+0 𝔽。
7.1.7 ToUint32 ( argument )
抽象操作 ToUint32 接受参数 argument（一个
7.1.8 ToInt16 ( argument )
抽象操作 ToInt16 接受参数 argument（一个
7.1.9 ToUint16 ( argument )
抽象操作 ToUint16 接受参数 argument（一个
根据上述 ToUint16 的定义：
-
在第
4 步中将 216 替换为 232 是 ToUint32 和 ToUint16 唯一的区别。 -
ToUint16 将
-0 𝔽 映射为+0 𝔽。
7.1.10 ToInt8 ( argument )
抽象操作 ToInt8 接受参数 argument（一个
7.1.11 ToUint8（argument）
抽象操作ToUint8接受参数argument（一个ECMAScript语言值），并返回一个包含整数Number的正常完成或一个抛出完成。它将argument转换为从
7.1.12 ToUint8Clamp ( argument )
抽象操作 ToUint8Clamp 接受参数 argument（一个
与大多数其他 ECMAScript Math.round
7.1.13 ToBigInt ( argument )
抽象操作 ToBigInt 接受参数 argument（一个
- 令 prim 为 ?
ToPrimitive (argument,number )。 - 返回 prim 在
表 12 中对应的值。
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出 |
| Null | 抛出 |
| Boolean | 如果 prim 是 1n；如果 prim 是
0n。
|
| BigInt | 返回 prim。 |
| Number | 抛出 |
| String |
|
| Symbol | 抛出 |
7.1.14 StringToBigInt ( str )
抽象操作 StringToBigInt 接受参数 str（一个字符串）并返回一个 BigInt 或
- 令 text 为
StringToCodePoints (str)。 - 令 literal 为
ParseText (text,StringIntegerLiteral )。 - 如果 literal 是一个
错误列表 ，返回undefined 。 - 令 mv 为 literal 的 MV。
断言 ：mv 是一个整数 。- 返回
ℤ (mv)。
7.1.14.1 StringIntegerLiteral 语法
语法
7.1.14.2 运行时语义：MV
-
StringIntegerLiteral ::: StrWhiteSpace opt -
StringIntegerLiteral ::: StrWhiteSpace opt StrIntegerLiteral StrWhiteSpace opt StrIntegerLiteral 的 MV。
7.1.15 ToBigInt64 ( argument )
抽象操作 ToBigInt64 接受参数 argument（一个
7.1.16 ToBigUint64 ( argument )
抽象操作 ToBigUint64 接受参数 argument（一个
7.1.17 ToString ( argument )
抽象操作 ToString 接受参数 argument（一个
- 如果 argument
是一个字符串 ，返回 argument。 - 如果 argument
是一个符号 ，抛出一个TypeError 异常。 - 如果 argument 是
undefined ，返回"undefined" 。 - 如果 argument 是
null ，返回"null" 。 - 如果 argument 是
true ，返回"true" 。 - 如果 argument 是
false ，返回"false" 。 - 如果 argument
是一个数字 ，返回Number::toString (argument, 10)。 - 如果 argument
是一个 BigInt ，返回BigInt::toString (argument, 10)。 断言 ：argument是一个对象 。- 令 primValue 为 ?
ToPrimitive (argument,string )。 断言 ：primValue不是一个对象 。- 返回 ?
ToString (primValue)。
7.1.18 ToObject ( argument )
抽象操作 ToObject 接受参数 argument（一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出一个 |
| Null | 抛出一个 |
| Boolean | 返回一个新的布尔对象，其 [[BooleanData]] 内部槽被设置为 argument。参见 |
| Number | 返回一个新的数字对象，其 [[NumberData]] 内部槽被设置为 argument。参见 |
| String | 返回一个新的字符串对象，其 [[StringData]] 内部槽被设置为 argument。参见 |
| Symbol | 返回一个新的符号对象，其 [[SymbolData]] 内部槽被设置为 argument。参见 |
| BigInt | 返回一个新的 BigInt 对象，其 [[BigIntData]] 内部槽被设置为 argument。参见
|
| Object | 返回 argument。 |
7.1.19 ToPropertyKey ( argument )
抽象操作 ToPropertyKey 接受参数 argument（一个
- 令 key 为 ?
ToPrimitive (argument,string )。 - 如果 key
是一个符号 ，那么- 返回 key。
- 返回 !
ToString (key)。
7.1.20 ToLength ( argument )
抽象操作 ToLength 接受参数 argument（一个
- 令 len 为 ?
ToIntegerOrInfinity (argument)。 - 如果 len ≤ 0，返回
+0 𝔽。 - 返回
𝔽 (min (len, 253 - 1))。
7.1.21 CanonicalNumericIndexString ( argument )
抽象操作 CanonicalNumericIndexString 接受参数 argument（一个字符串）并返回一个数字或
一个规范数字字符串是任何使 CanonicalNumericIndexString
抽象操作不返回
7.1.22 ToIndex ( value )
抽象操作 ToIndex 接受参数 value（一个
- 令 integer 为 ?
ToIntegerOrInfinity (value)。 - 如果 integer 不在从 0 到 253 - 1 的
闭区间 内，抛出一个RangeError 异常。 - 返回 integer。
7.2 测试和比较操作
7.2.1 RequireObjectCoercible ( argument )
抽象操作 RequireObjectCoercible 接受参数 argument（一个
| 参数类型 | 结果 |
|---|---|
| Undefined | 抛出一个 |
| Null | 抛出一个 |
| Boolean | 返回 argument。 |
| Number | 返回 argument。 |
| String | 返回 argument。 |
| Symbol | 返回 argument。 |
| BigInt | 返回 argument。 |
| Object | 返回 argument。 |
7.2.2 IsArray ( argument )
抽象操作 IsArray 接受参数 argument（一个
- 如果 argument
不是一个对象 ，返回false 。 - 如果 argument 是一个
数组异质对象 ，返回true 。 - 如果 argument 是一个
代理异质对象 ，那么- 执行 ?
ValidateNonRevokedProxy (argument)。 - 令 proxyTarget 为 argument.[[ProxyTarget]]。
- 返回 ?
IsArray (proxyTarget)。
- 执行 ?
- 返回
false 。
7.2.3 IsCallable ( argument )
抽象操作 IsCallable 接受参数 argument（一个
- 如果 argument
不是一个对象 ，返回false 。 - 如果 argument 具有 [[Call]] 内部方法，返回
true 。 - 返回
false 。
7.2.4 IsConstructor ( argument )
抽象操作 IsConstructor 接受参数 argument（一个
- 如果 argument
不是一个对象 ，返回false 。 - 如果 argument 具有 [[Construct]]
内部方法，返回
true 。 - 返回
false 。
7.2.5 IsExtensible ( O )
抽象操作 IsExtensible 接受参数 O（一个对象），并返回一个
- 返回 ? O.[[IsExtensible]]()。
7.2.6 IsIntegralNumber ( argument )
抽象操作 IsIntegralNumber 接受参数 argument（一个
7.2.7 IsPropertyKey ( argument )
抽象操作 IsPropertyKey 接受参数 argument（一个
7.2.8 IsRegExp ( argument )
抽象操作 IsRegExp 接受参数 argument（一个
7.2.9 静态语义：IsStringWellFormedUnicode ( string )
抽象操作 IsStringWellFormedUnicode 接受参数 string（一个字符串），并返回一个布尔值。它将 string 解释为一系列 UTF-16
编码的代码点，如
- 令 len 为 string 的长度。
- 令 k 为 0。
- 重复，直到 k < len，
- 令 cp 为
CodePointAt (string, k)。 - 如果 cp.[[IsUnpairedSurrogate]] 为
true ，返回false 。 - 将 k 设置为 k + cp.[[CodeUnitCount]]。
- 令 cp 为
- 返回
true 。
7.2.10 SameValue ( x, y )
抽象操作 SameValue 接受参数 x（一个
- 如果
Type (x) 不是Type (y)，返回false 。 - 如果 x
是一个数字 ，那么- 返回
Number::sameValue (x, y)。
- 返回
- 返回
SameValueNonNumber (x, y)。
这个算法不同于
7.2.11 SameValueZero ( x, y )
抽象操作 SameValueZero 接受参数 x（一个
- 如果
Type (x) 不是Type (y)，返回false 。 - 如果 x
是一个数字 ，那么- 返回
Number::sameValueZero (x, y)。
- 返回
- 返回
SameValueNonNumber (x, y)。
SameValueZero 与
7.2.12 SameValueNonNumber ( x, y )
抽象操作 SameValueNonNumber 接受参数 x（一个
断言 ：Type (x) 是Type (y)。- 如果 x 是
null 或undefined ，返回true 。 - 如果 x
是一个 BigInt ，那么- 返回
BigInt::equal (x, y)。
- 返回
- 如果 x
是一个字符串 ，那么- 如果 x 和 y 具有相同的长度并且在相同的位置具有相同的代码单元，返回
true ；否则，返回false 。
- 如果 x 和 y 具有相同的长度并且在相同的位置具有相同的代码单元，返回
- 如果 x
是一个布尔值 ，那么- 如果 x 和 y 都是
true 或都为false ，返回true ；否则，返回false 。
- 如果 x 和 y 都是
- 注意：所有其他
ECMAScript 语言值 通过身份进行比较。 - 如果 x 是 y，返回
true ；否则，返回false 。
7.2.13 IsLessThan ( x, y, LeftFirst )
抽象操作 IsLessThan 接受参数 x（一个
- 如果 LeftFirst 是
true ，则- 令 px 为 ?
ToPrimitive (x,number ). - 令 py 为 ?
ToPrimitive (y,number ).
- 令 px 为 ?
- 否则
- 注意：需要反转求值顺序以保持从左到右的求值。
- 令 py 为 ?
ToPrimitive (y,number ). - 令 px 为 ?
ToPrimitive (x,number ).
- 如果 px
是一个 字符串 且 py是一个 字符串 ，则 - 否则
- 如果 px
是一个 BigInt 且 py是一个 字符串 ，则- 令 ny 为
StringToBigInt (py). - 如果 ny 是
undefined ，返回undefined . - 返回
BigInt::lessThan (px, ny).
- 令 ny 为
- 如果 px
是一个 字符串 且 py是一个 BigInt ，则- 令 nx 为
StringToBigInt (px). - 如果 nx 是
undefined ，返回undefined . - 返回
BigInt::lessThan (nx, py).
- 令 nx 为
- 注意：因为 px 和 py 是原始值，求值顺序不重要。
- 令 nx 为 ?
ToNumeric (px). - 令 ny 为 ?
ToNumeric (py). - 如果
Type (nx) 是Type (ny)，则- 如果 nx
是一个 数字 ，则- 返回
Number::lessThan (nx, ny).
- 返回
- 否则
断言 ：nx是一个 BigInt .- 返回
BigInt::lessThan (nx, ny).
- 如果 nx
断言 ：nx是一个 BigInt 且 ny是一个 数字 ，或 nx是一个 数字 且 ny是一个 BigInt .- 如果 nx 或 ny 是
NaN ， 返回undefined . - 如果 nx 是
-∞ 𝔽 或 ny 是+∞ 𝔽，返回true . - 如果 nx 是
+∞ 𝔽 或 ny 是-∞ 𝔽，返回false . - 如果
ℝ (nx) <ℝ (ny)，返回true ；否则返回false .
- 如果 px
字符串的比较使用简单的按 UTF-16 代码单元值序列的字典顺序，没有尝试使用 Unicode 规范中定义的更复杂的、语义导向的字符或字符串相等性和排序顺序定义。因此，根据 Unicode
标准正规等价但不在相同规范化形式中的字符串值可能会被测试为不等。同样需要注意的是，对于包含
7.2.14 IsLooselyEqual ( x, y )
抽象操作 IsLooselyEqual 接受参数 x（一个 == 操作符的语义。它在被调用时执行以下步骤：
- 如果
类型 (x) 和类型 (y) 相同，则- 返回
严格相等 (x, y)。
- 返回
- 如果 x 是
null 且 y 是undefined ，返回true 。 - 如果 x 是
undefined 且 y 是null ，返回true 。 - 注意：这一步在章节
B.3.6.2 中被替换。 - 如果 x
是数字 且 y是字符串 ，返回 !宽松相等 (x, !转换为数字 (y))。 - 如果 x
是字符串 且 y是数字 ，返回 !宽松相等 (!转换为数字 (x), y)。 - 如果 x
是 BigInt 且 y是字符串 ，则- 令 n 为
字符串转换为 BigInt (y)。 - 如果 n 是
undefined ，返回false 。 - 返回 !
宽松相等 (x, n)。
- 令 n 为
- 如果 x
是字符串 且 y是 BigInt ，返回 !宽松相等 (y, x)。 - 如果 x
是布尔值 ，返回 !宽松相等 (!转换为数字 (x), y)。 - 如果 y
是布尔值 ，返回 !宽松相等 (x, !转换为数字 (y))。 - 如果 x 是字符串、数字、BigInt 或 Symbol 且 y
是对象 ，返回 !宽松相等 (x, ?转换为原始值 (y))。 - 如果 x
是对象 且 y 是字符串、数字、BigInt 或 Symbol，返回 !宽松相等 (?转换为原始值 (x), y)。 - 如果 x
是 BigInt 且 y是数字 ，或如果 x是数字 且 y是 BigInt ，则 - 返回
false 。
7.2.15 IsStrictlyEqual ( x, y )
抽象操作 IsStrictlyEqual 接受参数 x（一个 === 操作符的语义。调用时执行以下步骤：
-
如果
Type (x) 不是Type (y)，返回false 。 -
如果 x
是一个数字 ，则-
返回
Number::equal (x, y)。
-
返回
-
返回
SameValueNonNumber (x, y)。
该算法在处理有符号零和 NaN 时与
7.3 对象操作
7.3.1 MakeBasicObject ( internalSlotsList )
抽象操作 MakeBasicObject 接受参数 internalSlotsList（一个
- 让 obj 成为一个新创建的对象，其内部包含 internalSlotsList 中每个名称的内部插槽。
- 将 obj 的关键内部方法设置为默认的
普通对象 定义，详见10.1 。 Assert ：如果调用者不会覆盖 obj 的 [[GetPrototypeOf]] 和 [[SetPrototypeOf]] 关键内部方法中的任意一个，则 internalSlotsList 包含 [[Prototype]]。Assert ：如果调用者不会覆盖 obj 的 [[SetPrototypeOf]]、[[IsExtensible]] 和 [[PreventExtensions]] 关键内部方法中的所有一个或多个，则 internalSlotsList 包含 [[Extensible]]。- 如果 internalSlotsList 包含 [[Extensible]]，则将 obj.[[Extensible]] 设置为
true 。 - 返回 obj。
在本规范中，
7.3.2 Get ( O, P )
抽象操作 Get 接受参数 O（一个对象）和 P（一个
- 返回 ? O.[[Get]](P, O).
7.3.3 GetV ( V, P )
抽象操作 GetV 接受参数 V（一个
- 让 O 成为 ?
ToObject (V). - 返回 ? O.[[Get]](P, V).
7.3.4 Set ( O, P, V, Throw )
抽象操作 Set 接受参数 O（一个对象）、P（一个
- 让 success 成为 ? O.[[Set]](P, V, O).
- 如果 success 是
false 并且 Throw 是true ，则抛出一个TypeError 异常。 - 返回
unused .
7.3.5 CreateDataProperty ( O, P, V )
抽象操作 CreateDataProperty 接受参数 O（一个对象）、P（一个
- 让 newDesc 成为属性描述符 { [[Value]]:
V, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:true }. - 返回 ? O.[[DefineOwnProperty]](P, newDesc).
此抽象操作创建一个属性，其属性设置为 ECMAScript 语言赋值运算符创建的默认值。通常，该属性不会已存在。如果存在且不可配置，或者 O 不可扩展，则 [[DefineOwnProperty]] 将返回
7.3.6 CreateDataPropertyOrThrow ( O, P, V )
抽象操作 CreateDataPropertyOrThrow 接受参数 O（一个对象）、P（一个
- 让 success 成为 ?
CreateDataProperty (O, P, V). - 如果 success 是
false ，则抛出一个TypeError 异常。 - 返回
unused .
此抽象操作创建一个属性，其属性设置为 ECMAScript 语言赋值运算符创建的默认值。通常，该属性不会已存在。如果存在且不可配置，或者 O 不可扩展，则 [[DefineOwnProperty]] 将返回
7.3.7 CreateNonEnumerableDataPropertyOrThrow ( O, P, V )
抽象操作 CreateNonEnumerableDataPropertyOrThrow 接受参数 O（一个对象）、P（一个
Assert : O 是一个普通的、可扩展的对象，并且没有不可配置的属性。- 让 newDesc 成为属性描述符 { [[Value]]:
V, [[Writable]]:
true , [[Enumerable]]:false , [[Configurable]]:true }. - 执行 !
DefinePropertyOrThrow (O, P, newDesc). - 返回
unused .
此抽象操作创建一个属性，其属性设置为与 ECMAScript 语言赋值运算符创建的默认值相同，但不可枚举。通常情况下，该属性不存在。如果存在，则
7.3.8 DefinePropertyOrThrow ( O, P, desc )
抽象操作 DefinePropertyOrThrow 接受参数 O（一个对象）、P（一个
- 让 success 成为 ? O.[[DefineOwnProperty]](P, desc).
- 如果 success 是
false ，则抛出TypeError 异常。 - 返回
unused .
7.3.9 DeletePropertyOrThrow ( O, P )
抽象操作 DeletePropertyOrThrow 接受参数 O（一个对象）和 P（一个
- 让 success 成为 ? O.[[Delete]](P).
- 如果 success 是
false ，则抛出TypeError 异常。 - 返回
unused .
7.3.10 GetMethod ( V, P )
抽象操作 GetMethod 接受参数 V（一个
- 让 func 成为 ?
GetV (V, P). - 如果 func 是
undefined 或null ，则返回undefined 。 - 如果
IsCallable (func) 是false ，则抛出TypeError 异常。 - 返回 func。
7.3.11 HasProperty ( O, P )
抽象操作 HasProperty 接受参数 O（一个 Object）和 P（一个
- 返回 ? O.[[HasProperty]](P)。
7.3.12 HasOwnProperty ( O, P )
抽象操作 HasOwnProperty 接受参数 O（一个 Object）和 P（一个
- Let desc be ? O.[[GetOwnProperty]](P).
- If desc is
undefined , returnfalse . - Return
true .
7.3.13 Call ( F, V [ , argumentsList ] )
抽象操作 Call 接受参数 F（一个
- 如果argumentsList不存在，则将argumentsList设为一个新的空
List 。 - 如果
IsCallable (F)的返回值为false ，则抛出TypeError 异常。 - 返回 ? F.[[Call]](V, argumentsList)。
7.3.14 构造（F [ , argumentsList [ , newTarget ] ]）
抽象操作构造（Construct）接受参数F（一个
- 如果newTarget不存在，则将newTarget设为F。
- 如果argumentsList不存在，则将argumentsList设为一个新的空
List 。 - 返回 ? F.[[Construct]](argumentsList, newTarget)。
如果newTarget不存在，则该操作等效于：new F(...argumentsList)
7.3.15 SetIntegrityLevel ( O, level )
抽象操作 SetIntegrityLevel 接受参数 O（一个对象）和 level（
- 设 status 为 ? O.[[PreventExtensions]]()。
- 如果 status 是
false ，则返回false 。 - 设 keys 为 ? O.[[OwnPropertyKeys]]()。
- 如果 level 是
sealed ，则- 对于 keys 的每个元素 k，执行
- 执行 ?
DefinePropertyOrThrow (O, k, PropertyDescriptor { [[Configurable]]:false })。
- 执行 ?
- 对于 keys 的每个元素 k，执行
- 否则，
Assert ： level 是frozen 。- 对于 keys 的每个元素 k，执行
- 设 currentDesc 为 ? O.[[GetOwnProperty]](k)。
- 如果 currentDesc 不是
undefined ，则- 如果
IsAccessorDescriptor (currentDesc) 是true ，则- 设 desc 为 PropertyDescriptor { [[Configurable]]:
false }。
- 设 desc 为 PropertyDescriptor { [[Configurable]]:
- 否则，
- 设 desc 为 PropertyDescriptor { [[Configurable]]:
false , [[Writable]]:false }。
- 设 desc 为 PropertyDescriptor { [[Configurable]]:
- 执行 ?
DefinePropertyOrThrow (O, k, desc)。
- 如果
- 返回
true 。
7.3.16 TestIntegrityLevel ( O, level )
抽象操作 TestIntegrityLevel 接受参数 O（一个对象）和 level（
- 设 extensible 为 ?
IsExtensible (O)。 - 如果 extensible 是
true ，则返回false 。 - 注意：如果对象是可扩展的，则不检查其任何属性。
- 设 keys 为 ? O.[[OwnPropertyKeys]]()。
- 对于 keys 的每个元素 k，执行
- 设 currentDesc 为 ? O.[[GetOwnProperty]](k)。
- 如果 currentDesc 不是
undefined ，则- 如果 currentDesc.[[Configurable]] 是
true ，则返回false 。 - 如果 level 是
frozen 并且IsDataDescriptor (currentDesc) 是true ，则- 如果 currentDesc.[[Writable]] 是
true ，则返回false 。
- 如果 currentDesc.[[Writable]] 是
- 如果 currentDesc.[[Configurable]] 是
- 返回
true 。
7.3.17 CreateArrayFromList ( elements )
抽象操作 CreateArrayFromList 接受参数 elements（一个
- 设 array 为 !
ArrayCreate (0)。 - 设 n 为 0。
- 对于 elements 的每个元素 e，执行
- 执行 !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (n)), e)。 - 将 n 设为 n + 1。
- 执行 !
- 返回 array。
7.3.18 LengthOfArrayLike ( obj )
抽象操作 LengthOfArrayLike 接受参数 obj（一个对象）并返回一个
类似数组对象是指该操作返回
7.3.19 CreateListFromArrayLike ( obj [ , elementTypes ] )
抽象操作 CreateListFromArrayLike 接受参数 obj（一个
- 如果 elementTypes 不存在，则将 elementTypes 设置为« Undefined, Null, Boolean, String, Symbol, Number, BigInt, Object »。
- 如果 obj
不是对象 ，则抛出TypeError 异常。 - 让 len 是 ?
LengthOfArrayLike (obj)。 - 让 list 是一个新的空
List 。 - 让 index 是 0。
- 重复，当 index < len 时，
- 返回 list。
7.3.20 Invoke ( V, P [ , argumentsList ] )
抽象操作 Invoke 接受参数 V（一个
7.3.21 OrdinaryHasInstance ( C, O )
抽象操作 OrdinaryHasInstance 接受参数 C（一个
- 如果
IsCallable (C) 为false ，返回false 。 - 如果 C 有一个 [[BoundTargetFunction]] 内部插槽，则
- 让 BC 为 C.[[BoundTargetFunction]]。
- 返回 ?
InstanceofOperator (O, BC)。
- 如果 O
不是一个对象 ，返回false 。 - 让 P 为 ?
Get (C,"prototype" )。 - 如果 P
不是一个对象 ，抛出一个TypeError 异常。 - 重复，
- 将 O 设置为 ? O.[[GetPrototypeOf]]()。
- 如果 O 是
null ，返回false 。 - 如果
SameValue (P, O) 是true ，返回true 。
7.3.22 SpeciesConstructor ( O, defaultConstructor )
抽象操作 SpeciesConstructor 接受参数 O（一个对象）和 defaultConstructor（一个
- 让 C 为 ?
Get (O,"constructor" )。 - 如果 C 是
undefined ，返回 defaultConstructor。 - 如果 C
不是一个对象 ，抛出一个TypeError 异常。 - 让 S 为 ?
Get (C,@@species )。 - 如果 S 是
undefined 或者null ，返回 defaultConstructor。 - 如果
IsConstructor (S) 是true ，返回 S。 - 抛出一个
TypeError 异常。
7.3.23 EnumerableOwnProperties ( O, kind )
抽象操作 EnumerableOwnProperties 接受参数 O（一个对象）和 kind
（
- 让 ownKeys 为 ? O.[[OwnPropertyKeys]]()。
- 让 results 为一个新的空
列表 。 - 对于 ownKeys 的每个元素 key，做如下操作：
- 如果 key 是
字符串 ，那么：- 让 desc 为 ? O.[[GetOwnProperty]](key)。
- 如果 desc 不是
undefined 并且 desc.[[Enumerable]] 是true ，那么：- 如果 kind 是
key ，那么- 将 key 添加到 results 中。
- 否则，
- 让 value 为 ?
Get (O, key)。 - 如果 kind 是
value ，那么：- 将 value 添加到 results 中。
- 否则，
断言 ：kind 是key+value 。- 让 entry 为
CreateArrayFromList (« key, value »)。 - 将 entry 添加到 results 中。
- 让 value 为 ?
- 如果 kind 是
- 如果 key 是
- 返回 results。
7.3.24 GetFunctionRealm ( obj )
抽象操作 GetFunctionRealm 接受参数 obj（一个
- 如果 obj 拥有一个 [[Realm]] 内部插槽，则：
- 返回 obj.[[Realm]]。
- 如果 obj 是一个
绑定函数的异域对象 ，则：- 让 boundTargetFunction 为 obj.[[BoundTargetFunction]]。
- 返回 ?
GetFunctionRealm (boundTargetFunction)。
- 如果 obj 是一个
代理的异域对象 ，则：- 执行 ?
ValidateNonRevokedProxy (obj)。 - 让 proxyTarget 为 obj.[[ProxyTarget]]。
- 返回 ?
GetFunctionRealm (proxyTarget)。
- 执行 ?
- 返回
当前域记录 。
7.3.25 CopyDataProperties ( target, source, excludedItems )
抽象操作 CopyDataProperties 接受参数 target（一个对象），source
（一个
- 如果 source 是
undefined 或null ，则返回unused 。 - 让 from 为 !
ToObject (source)。 - 让 keys 为 ? from.[[OwnPropertyKeys]]()。
- 对于 keys 中的每个元素 nextKey，执行以下步骤：
- 让 excluded 为
false 。 - 对于 excludedItems 中的每个元素 e，执行以下步骤：
- 如果
SameValue (e, nextKey) 是true ，则执行以下步骤：- 将 excluded 设为
true 。
- 将 excluded 设为
- 如果
- 如果 excluded 是
false ，则执行以下步骤：- 让 desc 为 ? from.[[GetOwnProperty]](nextKey)。
- 如果 desc 不是
undefined 并且 desc.[[Enumerable]] 是true ，则执行以下步骤：- 让 propValue 为 ?
Get (from, nextKey)。 - 执行 !
CreateDataPropertyOrThrow (target, nextKey, propValue)。
- 让 propValue 为 ?
- 让 excluded 为
- 返回
unused 。
这里传入的目标对象始终是一个新创建的对象，在发生错误抛出时不会直接访问到它。
7.3.26 PrivateElementFind ( O, P )
抽象操作 PrivateElementFind 接受参数 O（一个对象）和 P（一个
- 如果 O.[[PrivateElements]]
包含一个
PrivateElement pe， 使得 pe.[[Key]] 是 P，则执行以下步骤：- 返回 pe。
- 返回
empty 。
7.3.27 PrivateFieldAdd ( O, P, value )
抽象操作 PrivateFieldAdd 接受参数 O（一个对象），P（一个
- If the
host is a web browser, then- 执行 ?
HostEnsureCanAddPrivateElement (O).
- 执行 ?
- Let entry be
PrivateElementFind (O, P). - If entry is not
empty , throw aTypeError exception. - Append
PrivateElement { [[Key]]: P, [[Kind]]:field , [[Value]]: value } to O.[[PrivateElements]]. - Return
unused .
7.3.28 PrivateMethodOrAccessorAdd ( O, method )
抽象操作 PrivateMethodOrAccessorAdd 接受参数 O（一个对象）和 method（一个
Assert : method.[[Kind]] 是method 或accessor 。- 如果
宿主环境 是 Web 浏览器，则执行：- 执行 ?
HostEnsureCanAddPrivateElement (O)。
- 执行 ?
- 让 entry 成为
PrivateElementFind (O, method.[[Key]])。 - 如果 entry 不是
empty ，则抛出一个TypeError 异常。 - 将 method 添加到 O.[[PrivateElements]]。
- 返回
unused 。
私有方法和访问器的值在实例之间是共享的。此操作不会创建方法或访问器的新副本。
7.3.29 HostEnsureCanAddPrivateElement ( O )
宿主定义的抽象操作 HostEnsureCanAddPrivateElement 接受参数 O（一个对象），并返回一个包含正常完成的
HostEnsureCanAddPrivateElement 的实现必须符合以下要求：
- 如果 O 不是宿主定义的异域对象，则此抽象操作必须返回
NormalCompletion (unused )，并且不执行其他步骤。 - 使用相同参数调用此抽象操作的任何两次必须返回相同类型的
完成记录 。
HostEnsureCanAddPrivateElement 的默认实现是返回
此抽象操作仅由 ECMAScript
7.3.30 PrivateGet ( O, P )
抽象操作 PrivateGet 接受参数 O（一个对象）和 P（一个私有名称），并返回一个包含 ECMAScript 语言值的普通完成或抛出完成。调用时执行以下步骤：
- 令 entry 为
PrivateElementFind (O, P)。 - 如果 entry 为空，则抛出 TypeError 异常。
- 如果 entry.[[Kind]] 是
field 或method ，则- 返回 entry.[[Value]]。
Assert ：确保 entry.[[Kind]] 是accessor 。- 如果 entry.[[Get]] 是
undefined ，则抛出 TypeError 异常。 - 令 getter 为 entry.[[Get]]。
- 返回 ?
Call (getter, O)。
7.3.31 PrivateSet ( O, P, value )
抽象操作 PrivateSet 接受参数 O（一个对象）、P（一个私有名称）和 value（一个 ECMAScript 语言值），并返回一个包含未使用的普通完成或抛出完成。调用时执行以下步骤：
- 令 entry 为
PrivateElementFind (O, P)。 - 如果 entry 为空，则抛出 TypeError 异常。
- 如果 entry.[[Kind]] 是
field ，则- 将 entry.[[Value]] 设置为 value。
- 否则，如果 entry.[[Kind]] 是
method ，则- 抛出 TypeError 异常。
- 否则，
- 返回
unused 。
7.3.32 DefineField ( receiver, fieldRecord )
抽象操作 DefineField 接受参数 receiver（一个对象）和 fieldRecord（一个
- 令 fieldName 为 fieldRecord.[[Name]]。
- 令 initializer 为 fieldRecord.[[Initializer]]。
- 如果 initializer 不为空，则
- 令 initValue 为 ?
Call (initializer, receiver)。
- 令 initValue 为 ?
- 否则，
- 令 initValue 为
undefined 。
- 令 initValue 为
- 如果 fieldName 是一个
Private Name ，则- 执行 ?
PrivateFieldAdd (receiver, fieldName, initValue)。
- 执行 ?
- 否则，
Assert : 确保IsPropertyKey (fieldName) 是true 。- 执行 ?
CreateDataPropertyOrThrow (receiver, fieldName, initValue)。
- 返回
unused 。
7.3.33 InitializeInstanceElements ( O, constructor )
抽象操作 InitializeInstanceElements 接受参数 O（一个对象）和 constructor（一个 ECMAScript
- 令 methods 为 constructor.[[PrivateMethods]] 的值。
- 对于每个
PrivateElement method 在 methods 中，执行- 执行 ?
PrivateMethodOrAccessorAdd (O, method)。
- 执行 ?
- 令 fields 为 constructor.[[Fields]] 的值。
- 对于每个元素 fieldRecord 在 fields 中，执行
- 执行 ?
DefineField (O, fieldRecord)。
- 执行 ?
- 返回
unused 。
7.3.34 AddValueToKeyedGroup ( groups, key, value )
抽象操作 AddValueToKeyedGroup 接受参数 groups（一个包含字段 [[Key]]（一个 ECMAScript
语言值）和 [[Elements]]（一个 ECMAScript 语言值列表）的
7.3.35 GroupBy ( items, callbackfn, keyCoercion )
抽象操作 GroupBy 接受参数 items（一个 ECMAScript 语言值）、callbackfn（一个 ECMAScript 语言值）和
keyCoercion（
- 执行 ?
RequireObjectCoercible (items). - 如果
IsCallable (callbackfn) 的结果为false ，则抛出一个TypeError 异常。 - 令 groups 为一个新的空
List 。 - 令 iteratorRecord 为 ?
GetIterator (items,sync ). - 令 k 为 0。
- 重复执行
- 如果 k ≥ 253 - 1，则
- 令 error 为
ThrowCompletion (一个新创建的TypeError 对象)。 - 返回 ?
IteratorClose (iteratorRecord, error).
- 令 error 为
- 令 next 为 ?
IteratorStepValue (iteratorRecord). - 如果 next 为
done ，则- 返回 groups。
- 令 value 为 next。
- 令 key 为
Completion (Call (callbackfn,undefined , « value,𝔽 (k) »)). IfAbruptCloseIterator (key, iteratorRecord).- 如果 keyCoercion 为
property ，则- 将 key 设置为
Completion (ToPropertyKey (key)). IfAbruptCloseIterator (key, iteratorRecord).
- 将 key 设置为
- 否则，
Assert : keyCoercion 为zero 。- 如果 key 是
-0 𝔽，则将 key 设置为+0 𝔽。
- 执行
AddValueToKeyedGroup (groups, key, value). - 将 k 设置为 k + 1。
- 如果 k ≥ 253 - 1，则
7.4 迭代器对象操作
请参阅通用迭代接口（
7.4.1 迭代器记录
迭代器记录是用于封装迭代器或异步迭代器及其 next 方法的
迭代器记录具有以下在
| 字段名 | 值 | 含义 |
|---|---|---|
| [[Iterator]] | 一个对象 | 符合 Iterator 或 AsyncIterator 接口的对象。 |
| [[NextMethod]] |
一个 |
[[Iterator]] 对象的 next 方法。
|
| [[Done]] | 一个布尔值 | 表示迭代器是否已关闭。 |
7.4.2 GetIteratorFromMethod ( obj, method )
抽象操作 GetIteratorFromMethod 接受参数 obj（一个
7.4.3 GetIterator ( obj, kind )
抽象操作 GetIterator 接受参数 obj（一个 ECMAScript 语言值）和 kind（
- 如果 kind 是
async ，则- 令 method 为 ?
GetMethod (obj,@@asyncIterator )。 - 如果 method 是
undefined ，则- 令 syncMethod 为 ?
GetMethod (obj,@@iterator )。 - 如果 syncMethod 是
undefined ，则抛出TypeError 异常。 - 令 syncIteratorRecord 为 ?
GetIteratorFromMethod (obj, syncMethod)。 - 返回
CreateAsyncFromSyncIterator (syncIteratorRecord)。
- 令 syncMethod 为 ?
- 令 method 为 ?
- 否则，
- 令 method 为 ?
GetMethod (obj,@@iterator )。
- 令 method 为 ?
- 如果 method 是
undefined ，则抛出TypeError 异常。 - 返回 ?
GetIteratorFromMethod (obj, method)。
7.4.4 IteratorNext ( iteratorRecord [ , value ] )
抽象操作 IteratorNext 接受参数 iteratorRecord（一个
7.4.5 IteratorComplete ( iterResult )
抽象操作 IteratorComplete 接受参数 iterResult（一个对象）并返回一个包含正常完成状态的布尔值或抛出异常完成状态。调用时执行以下步骤：
7.4.6 IteratorValue ( iterResult )
抽象操作 IteratorValue 接受参数 iterResult（一个对象）并返回一个包含正常完成状态的 ECMAScript 语言值或抛出异常完成状态。调用时执行以下步骤：
- 返回 ?
Get (iterResult,"value" )。
7.4.7 IteratorStep ( iteratorRecord )
抽象操作 IteratorStep 接受参数 iteratorRecord（一个
- 令 result 为 ?
IteratorNext (iteratorRecord). - 令 done 为 ?
IteratorComplete (result). - 如果 done 为
true ，则返回false 。 - 返回 result。
7.4.8 IteratorStepValue ( iteratorRecord )
抽象操作 IteratorStepValue 接受参数 iteratorRecord（一个
- 令 result 为
Completion (IteratorNext (iteratorRecord)). - If result is a
throw completion , 则- 将 iteratorRecord.[[Done]]
设置为
true 。 - 返回 ? result。
- 将 iteratorRecord.[[Done]]
设置为
- 将 result 设置为 ! result。
- 令 done 为
Completion (IteratorComplete (result)). - If done 是一个
throw completion , 则- 将 iteratorRecord.[[Done]]
设置为
true 。 - 返回 ? done。
- 将 iteratorRecord.[[Done]]
设置为
- 将 done 设置为 ! done。
- If done 是
true , 则- 将 iteratorRecord.[[Done]]
设置为
true 。 - 返回
done 。
- 将 iteratorRecord.[[Done]]
设置为
- 令 value 为
Completion (Get (result,"value" )). - If value 是一个
throw completion , 则- 将 iteratorRecord.[[Done]]
设置为
true 。
- 将 iteratorRecord.[[Done]]
设置为
- 返回 ? value。
7.4.9 IteratorClose ( iteratorRecord, completion )
抽象操作 IteratorClose 接受参数 iteratorRecord（一个
Assert ： iteratorRecord.[[Iterator]]是一个对象 。- 令 iterator 为 iteratorRecord.[[Iterator]]。
- 令 innerResult 为
Completion (GetMethod (iterator,"return" )). - 如果 innerResult 是一个
正常完成 ，则- 令 return 为 innerResult.[[Value]]。
- 如果 return 是
undefined ，则返回 ? completion。 - 将 innerResult 设置为
Completion (Call (return, iterator)).
- 如果 completion 是一个
抛出完成 ，则返回 ? completion。 - 如果 innerResult 是一个
抛出完成 ，则返回 ? innerResult。 - 如果 innerResult.[[Value]]
不是一个对象 ，则抛出TypeError 异常。 - 返回 ? completion。
7.4.10 IfAbruptCloseIterator ( value, iteratorRecord )
IfAbruptCloseIterator 是一个使用
IfAbruptCloseIterator (value, iteratorRecord).
意味着与以下内容相同：
Assert : value 是一个完成记录 。- 如果 value 是一个
突然完成 ，则返回 ?IteratorClose (iteratorRecord, value)。 - 否则，将 value 设置为 ! value。
7.4.11 AsyncIteratorClose ( iteratorRecord, completion )
异步抽象操作 AsyncIteratorClose 接受参数 iteratorRecord （一个
Assert : iteratorRecord.[[Iterator]]是一个对象 。- 让 iterator 为 iteratorRecord.[[Iterator]]。
- 让 innerResult 为
Completion (GetMethod (iterator,"return" ))。 - 如果 innerResult 是一个
正常完成 ，则：- 让 return 为 innerResult.[[Value]]。
- 如果 return 是
undefined ，返回 ? completion。 - 将 innerResult 设为
Completion (Call (return, iterator))。 - 如果 innerResult 是一个
正常完成 ， 将 innerResult 设为Completion (Await (innerResult.[[Value]]))。
- 如果 completion 是一个
抛出完成 ，返回 ? completion。 - 如果 innerResult 是一个
抛出完成 ，返回 ? innerResult。 - 如果 innerResult.[[Value]]
不是一个对象 ， 抛出TypeError 异常。 - 返回 ? completion。
7.4.12 CreateIterResultObject ( value, done )
抽象操作 CreateIterResultObject 接受参数 value （一个
- 让 obj 为
OrdinaryObjectCreate (%Object.prototype% )。 - 执行 !
CreateDataPropertyOrThrow (obj,"value" , value)。 - 执行 !
CreateDataPropertyOrThrow (obj,"done" , done)。 - 返回 obj。
7.4.13 CreateListIteratorRecord ( list )
抽象操作 CreateListIteratorRecord 接受参数 list （一个 next 方法返回
list 的连续元素。在调用时执行以下步骤：
- 让 closure 成为一个没有参数的新
Abstract Closure ，它捕获 list，并在调用时执行以下步骤：- 对于 list 的每个元素 E，执行
- 执行 ?
GeneratorYield (CreateIterResultObject (E,false ))。
- 执行 ?
- 返回
NormalCompletion (undefined )。
- 对于 list 的每个元素 E，执行
- 让 iterator 成为
CreateIteratorFromClosure (closure,empty ,%IteratorPrototype% )。 - 返回
Iterator Record { [[Iterator]]: iterator, [[NextMethod]]: %GeneratorFunction.prototype.prototype.next%, [[Done]]:false }。
列表迭代器对象对 ECMAScript 代码不可直接访问。
7.4.14 IteratorToList ( iteratorRecord )
抽象操作 IteratorToList 接受参数 iteratorRecord （一个
- 让 values 成为一个新的空
List 。 - 重复执行，
- 让 next 成为 ?
IteratorStepValue (iteratorRecord)。 - 如果 next 是
done ，那么- 返回 values。
- 将 next 追加到 values。
- 让 next 成为 ?
8 语法导向操作
除了本节中定义的操作外，专门的
8.1 运行时语义：评估
语法导向操作 Evaluation 不接受参数并返回一个
8.2 Scope 分析
8.2.1 静态语义：BoundNames
语法导向操作 BoundNames 不接受参数，并返回一个字符串列表（List）。
它在以下产生式上分段定义：
- 返回一个
List ，其唯一元素是Identifier 的字符串值，来自于Identifier 。
- 返回 «
"yield" »。
- 返回 «
"await" »。
- 返回
BoundNames 的结果， 来自于BindingList 。
- 令 names1 为
BoundNames 的结果， 来自于BindingList 。 - 令 names2 为
BoundNames 的结果， 来自于LexicalBinding 。 - 返回
list-concatenation 的结果， 包括 names1 和 names2。
- 返回
BoundNames 的结果， 来自于BindingIdentifier 。
- 返回
BoundNames 的结果， 来自于BindingPattern 。
- 令 names1 为
BoundNames 的结果， 来自于VariableDeclarationList 。 - 令 names2 为
BoundNames 的结果， 来自于VariableDeclaration 。 - 返回
list-concatenation 的结果， 包括 names1 和 names2。
- 返回
BoundNames 的结果， 来自于BindingIdentifier 。
- 返回
BoundNames 的结果， 来自于BindingPattern 。
- 返回一个新的空
List 。
- 让 names1 成为
BoundNames 的结果， 其中BindingPropertyList 是指向的非终结符。 - 让 names2 成为
BoundNames 的结果， 其中BindingRestProperty 是指向的非终结符。 - 返回
list-concatenation 的结果， 其中包含 names1 和 names2。
- 返回一个新的空
List 。
- 让 names 成为
BoundNames 的结果， 其中BindingRestElement 是指向的非终结符。
- 让 names1 成为
BoundNames 的结果， 其中BindingElementList 是指向的非终结符。 - 让 names2 成为
BoundNames 的结果， 其中BindingRestElement 是指向的非终结符。 - 返回
list-concatenation 的结果， 其中包含 names1 和 names2。
- 让 names1 成为
BoundNames 的结果， 其中BindingPropertyList 是指向的非终结符。 - 让 names2 成为
BoundNames 的结果， 其中BindingProperty 是指向的非终结符。 - 返回
list-concatenation 的结果， 其中包含 names1 和 names2。
- 让 names1 成为
BoundNames 的结果， 其中BindingElementList 是指向的非终结符。 - 让 names2 成为
BoundNames 的结果， 其中BindingElisionElement 是指向的非终结符。 - 返回
list-concatenation 的结果， 其中包含 names1 和 names2。
- 返回
BoundNames 的结果， 其中BindingElement 是指向的非终结符。
- 返回
BoundNames 的结果， 其中BindingElement 是指向的非终结符。
- 返回
BoundNames 的结果， 其中BindingIdentifier 是指向的非终结符。
- 返回
BoundNames 的结果， 其中BindingPattern 是指向的非终结符。
- 返回
BoundNames 的结果， 其中ForBinding 是指向的非终结符。
- 返回
BoundNames 的结果， 其中BindingIdentifier 是指向的非终结符。
- 返回«
"*default*" »。
- 返回一个新的空
List 。
- 将 names1 设置为获取
FormalParameterList 的BoundNames 。 - 将 names2 设置为获取
FunctionRestParameter 的BoundNames 。 - 返回
list-concatenation 的结果，即 names1 和 names2 的连接列表。
- 将 names1 设置为获取
FormalParameterList 的BoundNames 。 - 将 names2 设置为获取
FormalParameter 的BoundNames 。 - 返回
list-concatenation 的结果，即 names1 和 names2 的连接列表。
- 将 formals 设置为由
ArrowFormalParameters 覆盖的CoverParenthesizedExpressionAndArrowParameterList 。 - 返回 formals 的
BoundNames 。
- 返回
BindingIdentifier 的绑定名称。
- 返回
"*default*" 。
- 返回
BindingIdentifier 的BoundNames 。
- 返回 «
"*default*" »。
- 返回 «
"*default*" »。
- 返回 «
"*default*" »。
- 令head为被
CoverCallExpressionAndAsyncArrowHead 覆盖的AsyncArrowHead 。 - 返回head的
BoundNames 。
- 返回一个新的空
List 。
- 让names1为
BoundNames ：ImportedDefaultBinding 的BoundNames 。 - 让names2为
BoundNames ：NameSpaceImport 的BoundNames 。 - 返回
list-concatenation 的names1和names2。
- 让names1为
BoundNames ：ImportedDefaultBinding 的BoundNames 。 - 让names2为
BoundNames ：NamedImports 的BoundNames 。 - 返回
list-concatenation 的names1和names2。
- 返回一个新的空
List 。
- 让names1为
BoundNames ：ImportsList 的BoundNames 。 - 让names2为
BoundNames ：ImportSpecifier 的BoundNames 。 - 返回
list-concatenation 的names1和names2。
- 返回一个新的空
List 。
- 令declarationNames为
HoistableDeclaration 的BoundNames 。 - 如果declarationNames不包含元素
"*default*" ，则将"*default*" 添加到declarationNames中。 - 返回declarationNames。
- 令declarationNames为
ClassDeclaration 的BoundNames 。 - 如果declarationNames不包含元素
"*default*" ，则将"*default*" 添加到declarationNames中。 - 返回declarationNames。
- 返回«
"*default*" »。
8.2.2 静态语义：DeclarationPart
DeclarationPart 是一个语法导向操作，不接受参数并返回一个解析节点（Parse Node）。它根据以下产生式逐段定义：
- 返回
ClassDeclaration 。
8.2.3 静态语义：IsConstantDeclaration
- 返回
false 。
- 返回
true 。
- 返回
false 。
- 返回
false 。
- 返回
false 。
没有必要将 export default
8.2.4 静态语义：词法声明的名称
- 返回一个新的空
列表 。
- 令 names1 为
LexicallyDeclaredNames 的StatementList 。 - 令 names2 为
LexicallyDeclaredNames 的StatementListItem 。 - 返回 names1 和 names2 的
列表连接 。
- 如果
Statement 是Statement : LabelledStatement LexicallyDeclaredNames 的LabelledStatement 。 - 返回一个新的空
列表 。
- 返回
BoundNames 的Declaration 。
- 返回一个新的空
列表 。
- 如果第一个
CaseClauses 存在，令names1为第一个CaseClauses 的LexicallyDeclaredNames 。 - 否则，令names1为一个新的空
列表 。 - 令names2为
DefaultClause 的LexicallyDeclaredNames 。 - 如果第二个
CaseClauses 存在，令names3为第二个CaseClauses 的LexicallyDeclaredNames 。 - 否则，令names3为一个新的空
列表 。 - 返回names1、names2和names3的
列表连接 。
- 令 names1 为
LexicallyDeclaredNames 的CaseClauses 。 - 令 names2 为
LexicallyDeclaredNames 的CaseClause 。 - 返回 names1 和 names2 的
列表连接 。
- 如果
StatementList 存在，返回StatementList 的LexicallyDeclaredNames 。 - 返回一个新的空
列表 。
- 如果
StatementList 存在，返回StatementList 的LexicallyDeclaredNames 。 - 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
在
- 令 names1 为
LexicallyDeclaredNames 的ModuleItemList 。 - 令 names2 为
LexicallyDeclaredNames 的ModuleItem 。 - 返回 names1 和 names2 的
列表连接 。
- 如果
ExportDeclaration 是exportVariableStatement ，返回一个新的空列表 。 - 返回
BoundNames 的ExportDeclaration 。
在
8.2.5 静态语义：词法作用域声明
- 令 declarations1 为
LexicallyScopedDeclarations 的StatementList 。 - 令 declarations2 为
LexicallyScopedDeclarations 的StatementListItem 。 - 返回 declarations1 和 declarations2 的
列表连接 。
- 如果
Statement 是Statement : LabelledStatement LexicallyScopedDeclarations 的LabelledStatement 。 - 返回一个新的空
列表 。
- 返回一个
列表 ，其唯一元素是DeclarationPart 的Declaration 。
- 返回一个新的空
列表 。
- 如果第一个
CaseClauses 存在，令declarations1为第一个CaseClauses 的LexicallyScopedDeclarations 。 - 否则，令declarations1为一个新的空
列表 。 - 令declarations2为
DefaultClause 的LexicallyScopedDeclarations 。 - 如果第二个
CaseClauses 存在，令declarations3为第二个CaseClauses 的LexicallyScopedDeclarations 。 - 否则，令declarations3为一个新的空
列表 。 - 返回declarations1、declarations2和declarations3的
列表连接 。
- 令 declarations1 为
LexicallyScopedDeclarations 的CaseClauses 。 - 令 declarations2 为
LexicallyScopedDeclarations 的CaseClause 。 - 返回 declarations1 和 declarations2 的
列表连接 。
- 如果
StatementList 存在，返回StatementList 的LexicallyScopedDeclarations 。 - 返回一个新的空
列表 。
- 如果
StatementList 存在，返回StatementList 的LexicallyScopedDeclarations 。 - 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回 «
FunctionDeclaration »。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 令 declarations1 为
LexicallyScopedDeclarations 的ModuleItemList 。 - 令 declarations2 为
LexicallyScopedDeclarations 的ModuleItem 。 - 返回 declarations1 和 declarations2 的
列表连接 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个
列表 ，其唯一元素是DeclarationPart 的Declaration 。
- 返回一个
列表 ，其唯一元素是DeclarationPart 的HoistableDeclaration 。
- 返回一个
列表 ，其唯一元素是ClassDeclaration 。
- 返回一个
列表 ，其唯一元素是此ExportDeclaration 。
8.2.6 静态语义: VarDeclaredNames
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 令 names1 为
VarDeclaredNames 的StatementList 。 - 令 names2 为
VarDeclaredNames 的StatementListItem 。 - 返回 names1 和 names2 的
列表连接 。
- 返回一个新的空
列表 。
- 令 names1 为第一个
VarDeclaredNames 的Statement 。 - 令 names2 为第二个
VarDeclaredNames 的Statement 。 - 返回 names1 和 names2 的
列表连接 。
- 令 names1 为
BoundNames 的VariableDeclarationList 。 - 令 names2 为
VarDeclaredNames 的Statement 。 - 返回 names1 和 names2 的
列表连接 。
- 令 names1 为
BoundNames 的ForBinding 。 - 令 names2 为
VarDeclaredNames 的Statement 。 - 返回 names1 和 names2 的
列表连接 。
本节由附录
- 返回一个新的空
列表 。
- 如果第一个
CaseClauses 存在，令names1为第一个CaseClauses 的VarDeclaredNames 。 - 否则，令names1为一个新的空
列表 。 - 令names2为
DefaultClause 的VarDeclaredNames 。 - 如果第二个
CaseClauses 存在，令names3为第二个CaseClauses 的VarDeclaredNames 。 - 否则，令names3为一个新的空
列表 。 - 返回names1、names2和names3的
列表连接 。
- 令 names1 为
VarDeclaredNames 的CaseClauses 。 - 令 names2 为
VarDeclaredNames 的CaseClause 。 - 返回 names1 和 names2 的
列表连接 。
- 如果
StatementList 存在，返回StatementList 的VarDeclaredNames 。 - 返回一个新的空
列表 。
- 如果
StatementList 存在，返回StatementList 的VarDeclaredNames 。 - 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 令 names1 为
VarDeclaredNames 的Block 。 - 令 names2 为
VarDeclaredNames 的Catch 。 - 返回 names1 和 names2 的
列表连接 。
- 令 names1 为
VarDeclaredNames 的Block 。 - 令 names2 为
VarDeclaredNames 的Finally 。 - 返回 names1 和 names2 的
列表连接 。
- 令 names1 为
VarDeclaredNames 的Block 。 - 令 names2 为
VarDeclaredNames 的Catch 。 - 令 names3 为
VarDeclaredNames 的Finally 。 - 返回 names1、names2 和 names3 的
列表连接 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 返回一个新的空
列表 。
- 令 names1 为
VarDeclaredNames 的ModuleItemList 。 - 令 names2 为
VarDeclaredNames 的ModuleItem 。 - 返回 names1 和 names2 的
列表连接 。
- 返回一个新的空
列表 。
- 如果
ExportDeclaration 是exportVariableStatement ，返回BoundNames 的ExportDeclaration 。 - 返回一个新的空
列表 。
8.2.7 静态语义：VarScopedDeclarations
VarScopedDeclarations是一个无需参数并返回
- 返回一个新的空
List 。
- 返回一个新的空
List 。
- 令 declarations1 为
VarScopedDeclarations ，位于StatementList 。 - 令 declarations2 为
VarScopedDeclarations ，位于StatementListItem 。 - 返回
list-concatenation 的结果，包括 declarations1 和 declarations2。
- 返回一个新的空
List 。
- 返回 «
VariableDeclaration »。
- 令 declarations1 为
VarScopedDeclarations 的VariableDeclarationList 。 - 返回
list-concatenation 的 declarations1 和 «VariableDeclaration »。
- 令 declarations1 为
VarScopedDeclarations 的第一个Statement 。 - 令 declarations2 为
VarScopedDeclarations 的第二个Statement 。 - 返回
list-concatenation 的 declarations1 和 declarations2。
- 让 declarations1 成为
VariableDeclarationList 的VarScopedDeclarations 。 - 让 declarations2 成为
Statement 的VarScopedDeclarations 。 - 返回 declarations1 和 declarations2 的
list-concatenation 。
- 令 declarations1 为 «
ForBinding »。 - 令 declarations2 为
VarScopedDeclarations 在Statement 中的结果。 - 返回 declarations1 和 declarations2 的
list-concatenation 。
本节由附件
- 返回一个新的空
列表 。
- 如果第一个
CaseClauses 存在，则让declarations1成为第一个CaseClauses 的VarScopedDeclarations 。 - 否则，让declarations1成为一个新的空
列表 。 - 让declarations2成为
VarScopedDeclarations 的DefaultClause 。 - 如果第二个
CaseClauses 存在，则让declarations3成为第二个CaseClauses 的VarScopedDeclarations 。 - 否则，让declarations3成为一个新的空
列表 。 - 返回declarations1，declarations2和declarations3的
列表连接 。
- 让declarations1成为
VarScopedDeclarations 的CaseClauses 。 - 让declarations2成为
VarScopedDeclarations 的CaseClause 。 - 返回declarations1和declarations2的
列表连接 。
- 如果
StatementList 存在， 返回VarScopedDeclarations 的StatementList 。 - 返回一个新的空
List 。
- 如果
StatementList 存在， 返回VarScopedDeclarations 的StatementList 。 - 返回一个新的空
List 。
- 返回一个新的空
List 。
- 让declarations1为
VarScopedDeclarations 的Block 。 - 让declarations2为
VarScopedDeclarations 的Catch 。 - 返回declarations1和declarations2的
list-concatenation 。
- 返回一个新的空
List 。
- 返回一个新的空
List 。
- 返回一个新的空
List 。
- 返回一个新的空
List 。
- 返回一个新的空
List 。
- 返回一个新的空
List 。
- 让declarations1成为
VarScopedDeclarations 的ModuleItemList 。 - 让declarations2成为
VarScopedDeclarations 的ModuleItem 。 - 返回
list-concatenation 的declarations1和declarations2。
- 返回一个新的空
List 。
- 如果
ExportDeclaration 是exportVariableStatement ，返回VarScopedDeclarations 的VariableStatement 。 - 返回一个新的空
List 。
8.2.8 静态语义: TopLevelLexicallyDeclaredNames
- 将names1设为
StatementList 的顶层词法声明名称。 - 将names2设为
StatementListItem 的顶层词法声明名称。 - 返回names1和names2的
列表连接 。
- 返回一个新的空
List 。
- 如果
Declaration 是Declaration : HoistableDeclaration - 返回一个新的空
List 。
- 返回一个新的空
- 返回
BoundNames ，属于Declaration 。
在函数或脚本的顶层，函数声明被视为 var 声明，而不是词法声明。
8.2.9 静态语义: TopLevelLexicallyScopedDeclarations
静态语义操作 TopLevelLexicallyScopedDeclarations 不接受参数，并返回一个
- 让 declarations1 成为
TopLevelLexicallyScopedDeclarations 的StatementList 。 - 让 declarations2 成为
TopLevelLexicallyScopedDeclarations 的StatementListItem 。 - 返回
list-concatenation ， 包含 declarations1 和 declarations2。
- 返回一个新的空
List 。
- 如果
Declaration 是Declaration : HoistableDeclaration - 返回一个新的空
List 。
- 返回一个新的空
- 返回 «
Declaration »。
8.2.10 静态语义: TopLevelVarDeclaredNames
语法定向操作 TopLevelVarDeclaredNames 不接受参数，并返回一个
- 令 names1 为
TopLevelVarDeclaredNames 是StatementList 的。 - 令 names2 为
TopLevelVarDeclaredNames 是StatementListItem 的。 - 返回
list-concatenation 的 names1 和 names2。
- 如果
Declaration 是Declaration : HoistableDeclaration - 返回一个新的空
List 。
- 如果
Statement 是Statement : LabelledStatement TopLevelVarDeclaredNames 的Statement 。 - 返回
VarDeclaredNames 的Statement 。
在函数或脚本的顶层，内部函数声明被视为 var 声明。
8.2.11 Static Semantics: TopLevelVarScopedDeclarations
The
- Let declarations1 be
TopLevelVarScopedDeclarations 的StatementList 。 - Let declarations2 be
TopLevelVarScopedDeclarations 的StatementListItem 。 - Return
列表连接 declarations1 和 declarations2。
- 如果
Declaration 是Declaration : HoistableDeclaration - 让 declaration 成为
HoistableDeclaration 的DeclarationPart 。 - 返回 « declaration »。
- 让 declaration 成为
- 返回一个新的空
List 。
- 如果
Statement 是Statement : LabelledStatement TopLevelVarScopedDeclarations 中的Statement 。 - 返回
VarScopedDeclarations 中的Statement 。
- 返回 «
FunctionDeclaration »。
8.3 Labels
8.3.1 静态语义: 包含重复标签 (ContainsDuplicateLabels)
- 返回
false 。
- 令 hasDuplicates 为带有参数 labelSet 的
ContainsDuplicateLabels 在StatementList 中的结果。 - 如果 hasDuplicates 是
true ，则返回true 。 - 返回带有参数 labelSet 的
ContainsDuplicateLabels 在StatementListItem 中的结果。
- 令 hasDuplicate 为带有参数 labelSet 的
ContainsDuplicateLabels 在第一个Statement 中的结果。 - 如果 hasDuplicate 是
true ，则返回true 。 - 返回带有参数 labelSet 的
ContainsDuplicateLabels 在第二个Statement 中的结果。
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 在Statement 中的结果。
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 在Statement 中的结果。
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 在Statement 中的结果。
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 在Statement 中的结果。
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 在Statement 中的结果。
此部分由附录
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 的Statement 。
- 返回带有参数 labelSet 的
ContainsDuplicateLabels 的CaseBlock 。
- 返回
false 。
- 如果第一个
CaseClauses 存在，则- 如果使用参数 labelSet 调用第一个
CaseClauses 的ContainsDuplicateLabels 返回true ，则返回true 。
- 如果使用参数 labelSet 调用第一个
- 如果使用参数 labelSet 调用
ContainsDuplicateLabels 返回第二个DefaultClause 的结果为true ，则返回true 。 - 如果第二个
CaseClauses 不存在，则返回false 。 - 返回使用参数 labelSet 调用第二个
CaseClauses 的ContainsDuplicateLabels 。
- 令 hasDuplicates 为使用参数 labelSet 调用
ContainsDuplicateLabels 的结果，作用于CaseClauses 。 - 如果 hasDuplicates 为
true ，则返回true 。 - 返回使用参数 labelSet 调用
ContainsDuplicateLabels 的结果，作用于CaseClause 。
- 如果存在
StatementList ，则返回使用参数 labelSet 调用ContainsDuplicateLabels 的结果，作用于StatementList 。 - 返回
false 。
- 如果存在
StatementList ，则返回使用参数 labelSet 调用ContainsDuplicateLabels 的结果，作用于StatementList 。 - 返回
false 。
- 将 label 设置为
StringValue 的值，来源于LabelIdentifier 。 - 如果 labelSet 包含 label，则返回
true 。 - 令 newLabelSet 为
list-concatenation ，包含 labelSet 和 « label »。 - 返回使用参数 newLabelSet 调用
ContainsDuplicateLabels 的结果，作用于LabelledItem 。
- 返回
false 。
- 让 hasDuplicates 成为
ContainsDuplicateLabels 用参数 labelSet 计算Block 。 - 如果 hasDuplicates 是
true ，则返回true 。 - 返回
ContainsDuplicateLabels 用参数 labelSet 计算Catch 。
- 让 hasDuplicates 成为
ContainsDuplicateLabels 用参数 labelSet 计算Block 。 - 如果 hasDuplicates 是
true ，则返回true 。 - 返回
ContainsDuplicateLabels 用参数 labelSet 计算Finally 。
- 如果
ContainsDuplicateLabels 用参数 labelSet 计算Block 的结果是true ，则返回true 。 - 如果
ContainsDuplicateLabels 用参数 labelSet 计算Catch 的结果是true ，则返回true 。 - 返回
ContainsDuplicateLabels 用参数 labelSet 计算Finally 的结果。
- 返回
ContainsDuplicateLabels 用参数 labelSet 计算Block 的结果。
- 返回
false 。
- 返回
false .
- 令 hasDuplicates 为带有参数 labelSet 的
ContainsDuplicateLabels ， 其中ModuleItemList 。 - 如果 hasDuplicates 为
true ，则返回true 。 - 返回带有参数 labelSet 的
ContainsDuplicateLabels ，其对应ModuleItem 。
- 返回
false 。
8.3.2 静态语义: ContainsUndefinedBreakTarget
语法定向操作 ContainsUndefinedBreakTarget 接受参数 labelSet（一个字符串
- 返回
false 。
- 让 hasUndefinedLabels 成为
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的StatementList 。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的StatementListItem 。
- 让 hasUndefinedLabels 成为
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的第一个Statement 。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的第二个Statement 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的Statement 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的Statement 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的Statement 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的Statement 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的Statement 。
此部分由附件
- 返回
false 。
- 如果 labelSet 不包含
StringValue 的LabelIdentifier ，则返回true 。 - 返回
false 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的Statement 。
- 返回
ContainsUndefinedBreakTarget 应用于参数为 labelSet 的CaseBlock 。
- 返回
false 。
- 如果第一个
CaseClauses 存在，则- 如果使用参数labelSet调用
ContainsUndefinedBreakTarget 返回true 。
- 如果使用参数labelSet调用
- 如果使用参数labelSet调用
ContainsUndefinedBreakTarget 的返回值为true ，则返回true 。 - 如果第二个
CaseClauses 不存在，则返回false 。 - 返回使用参数labelSet调用
ContainsUndefinedBreakTarget 的第二个CaseClauses 。
- 令hasUndefinedLabels为
ContainsUndefinedBreakTarget 的返回值，使用参数labelSet调用CaseClauses 。 - 如果hasUndefinedLabels为
true ，则返回true 。 - 使用参数labelSet调用
ContainsUndefinedBreakTarget 的返回值，使用CaseClause 。
- 如果存在
StatementList ，则返回使用参数labelSet调用ContainsUndefinedBreakTarget 的返回值，使用StatementList 。 - 返回
false 。
- 如果
StatementList 存在， 使用参数labelSet调用ContainsUndefinedBreakTarget 的返回值，使用StatementList 。 - 返回
false 。
- 令label为
StringValue 的返回值， 使用LabelIdentifier 。 - 令newLabelSet为
list-concatenation 的返回值，使用labelSet和«label »。 - 使用参数newLabelSet调用
ContainsUndefinedBreakTarget 的返回值， 使用LabelledItem 。
- 返回
false 。
- 令hasUndefinedLabels为
ContainsUndefinedBreakTarget 的返回值， 使用Block 和labelSet。 - 如果hasUndefinedLabels为
true ，返回true 。 - 使用
Catch 和labelSet调用ContainsUndefinedBreakTarget 的返回值。
- 令hasUndefinedLabels为
ContainsUndefinedBreakTarget 的返回值， 使用Block 和labelSet。 - 如果hasUndefinedLabels为
true ，返回true 。 - 使用
Finally 和labelSet调用ContainsUndefinedBreakTarget 的返回值。
- 如果
ContainsUndefinedBreakTarget 的返回值为true ，使用Block 和labelSet，返回true 。 - 如果
ContainsUndefinedBreakTarget 的返回值为true ，使用Catch 和labelSet，返回true 。 - 使用
Finally 和labelSet调用ContainsUndefinedBreakTarget 的返回值。
- 使用
Block 和labelSet调用ContainsUndefinedBreakTarget 的返回值。
- 返回
false 。
- 返回
false 。
- 让hasUndefinedLabels为
ContainsUndefinedBreakTarget 的返回值，使用ModuleItemList 和labelSet作为参数。 - 如果hasUndefinedLabels为
true ，返回true 。 - 使用
ModuleItem 和labelSet作为参数，调用ContainsUndefinedBreakTarget 的返回值。
- 返回
false 。
8.3.3 静态语义: ContainsUndefinedContinueTarget
语法定向操作 ContainsUndefinedContinueTarget 接受参数 iterationSet（一个字符串
- 返回
false 。
- 返回
ContainsUndefinedContinueTarget 对于BlockStatement 的结果，参数为 iterationSet 和 « »。
- 令 newIterationSet 为
list-concatenation 的结果，参数为 iterationSet 和 labelSet。 - 返回
ContainsUndefinedContinueTarget 对于IterationStatement 的结果，参数为 newIterationSet 和 « »。
- 令 hasUndefinedLabels 为
ContainsUndefinedContinueTarget 对于StatementList 的结果，参数为 iterationSet 和 « »。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回
ContainsUndefinedContinueTarget 对于第二个Statement 的结果，参数为 iterationSet 和 « »。
- 令 hasUndefinedLabels 为
ContainsUndefinedContinueTarget 对于第一个Statement 的结果，参数为 iterationSet 和 « »。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回
ContainsUndefinedContinueTarget 对于第二个Statement 的结果，参数为 iterationSet 和 « »。
- 返回
ContainsUndefinedContinueTarget 对于Statement 的结果，参数为 iterationSet 和 « »。
- 返回
ContainsUndefinedContinueTarget 对于Statement 的结果，参数为 iterationSet 和 « »。
- 返回
ContainsUndefinedContinueTarget 对于Statement 的结果，参数为 iterationSet 和 « »。
- 返回使用参数 iterationSet 和 « » 的
ContainsUndefinedContinueTarget 对Statement 进行调用。
- 返回使用参数 iterationSet 和 « » 的
ContainsUndefinedContinueTarget 对Statement 进行调用。
本节由附录
- 返回
false 。
- 如果 iterationSet 不包含
LabelIdentifier 的StringValue ，则返回true 。 - 返回
false 。
- 返回使用参数 iterationSet 和 « » 的
ContainsUndefinedContinueTarget 对Statement 进行调用。
- 返回使用参数 iterationSet 和 « » 的
ContainsUndefinedContinueTarget 对CaseBlock 进行调用。
- 返回
false 。
- 如果第一个
CaseClauses 存在，则- 如果
ContainsUndefinedContinueTarget 对第一个带参数 iterationSet 和 « » 的CaseClauses 返回true ，则返回true 。
- 如果
- 如果
ContainsUndefinedContinueTarget 对带参数 iterationSet 和 « » 的DefaultClause 返回true ，则返回true 。 - 如果第二个
CaseClauses 不存在，则返回false 。 - 返回使用参数 iterationSet 和 « » 的第二个
CaseClauses 的ContainsUndefinedContinueTarget 。
- 令 hasUndefinedLabels 等于使用参数 iterationSet 和
« » 的
ContainsUndefinedContinueTarget 对CaseClauses 进行调用。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回使用参数 iterationSet 和 « » 的
ContainsUndefinedContinueTarget 对CaseClause 进行调用。
- 如果存在
StatementList ，则返回使用参数 iterationSet 和 « » 的ContainsUndefinedContinueTarget 对StatementList 进行调用。 - 返回
false 。
- 如果存在
StatementList ，则返回使用参数 iterationSet 和 « » 的ContainsUndefinedContinueTarget 对StatementList 进行调用。 - 返回
false 。
- 令 label 为
LabelIdentifier 的StringValue 。 - 令 newLabelSet 为 labelSet 和 «
label » 的
list-concatenation 。 - 返回使用参数 iterationSet 和 newLabelSet 的
ContainsUndefinedContinueTarget 对LabelledItem 进行调用。
- 返回
false 。
- 令 hasUndefinedLabels 为使用参数 iterationSet 和
« »
调用
ContainsUndefinedContinueTarget 对Block 的结果。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对Catch 的结果。
- 令 hasUndefinedLabels 为使用参数 iterationSet 和
« »
调用
ContainsUndefinedContinueTarget 对Block 的结果。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对Finally 的结果。
- 如果使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对Block 的结果为true ，则返回true 。 - 如果使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对Catch 的结果为true ，则返回true 。 - 返回使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对Finally 的结果。
- 返回使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对Block 的结果。
- 返回
false 。
- 返回
false 。
- 让 hasUndefinedLabels 成为使用参数 iterationSet 和
« » 调用
ContainsUndefinedContinueTarget 对ModuleItemList 的结果。 - 如果 hasUndefinedLabels 是
true ，则返回true 。 - 返回使用参数 iterationSet 和 « » 调用
ContainsUndefinedContinueTarget 对ModuleItem 的结果。
- 返回
false 。
8.4 函数名称推断
8.4.1 静态语义：HasName
- 令 expr 为
ParenthesizedExpression ，它被CoverParenthesizedExpressionAndArrowParameterList 覆盖 。 - 如果 expr 的
IsFunctionDefinition 为false ，则返回false 。 - 返回 expr 的
HasName 。
- 返回
false 。
- 返回
true .
8.4.2 静态语义：IsFunctionDefinition
- 令 expr 为
ParenthesizedExpression ，它是由CoverParenthesizedExpressionAndArrowParameterList 覆盖 的表达式。 - 返回 expr 的
IsFunctionDefinition 。
- 返回
false .
- 返回
true .
8.4.3 静态语义：IsAnonymousFunctionDefinition ( expr )
抽象操作 IsAnonymousFunctionDefinition 接受参数 expr（一个
- 如果 expr 的
IsFunctionDefinition 返回false ，则返回false 。 - 令 hasName 为 expr 的
HasName 。 - 如果 hasName 返回
true ，则返回false 。 - 返回
true 。
8.4.4 静态语义：IsIdentifierRef
- 返回
true .
- 返回
false .
8.4.5 运行时语义：NamedEvaluation
- 令 expr 为
ParenthesizedExpression ，它被覆盖 在CoverParenthesizedExpressionAndArrowParameterList 中。 - 返回 ?
NamedEvaluation 以 name 作为参数调用 expr。
断言 :IsAnonymousFunctionDefinition (Expression ) 为true 。- 返回 ?
NamedEvaluation 以 name 作为参数调用Expression 。
- 返回
InstantiateOrdinaryFunctionExpression 以 name 作为参数调用FunctionExpression 。
- 返回
InstantiateGeneratorFunctionExpression 以 name 作为参数调用GeneratorExpression 。
- 返回
InstantiateAsyncGeneratorFunctionExpression 以 name 作为参数调用AsyncGeneratorExpression 。
- 返回
InstantiateAsyncFunctionExpression 以 name 作为参数调用AsyncFunctionExpression 。
- 返回
InstantiateArrowFunctionExpression 以 name 作为参数调用ArrowFunction 。
- 返回
InstantiateAsyncArrowFunctionExpression 以 name 作为参数调用AsyncArrowFunction 。
- 令 value 为 ?
ClassDefinitionEvaluation 以ClassTail 和参数undefined 以及 name 调用。 - 将 value.[[SourceText]] 设置为
与 ClassExpression 匹配的源文本。 - 返回 value。
8.5 包含
8.5.1 静态语义：Contains
本规范中未列出的每个语法生成替代方案都隐含具有以下默认的 Contains 定义：
-
返回
false 。
依赖于子结构的静态语义规则通常不会深入查看函数定义。
- 如果 symbol 是
ClassBody ，则返回true 。 - 如果 symbol 是
ClassHeritage ，则- 如果
ClassHeritage 存在，则返回true ；否则返回false 。
- 如果
- 如果
ClassHeritage 存在，则- 如果
ClassHeritage Contains symbol 是true ，则返回true 。
- 如果
- 返回
ComputedPropertyContains 的结果，其参数为 symbol，在ClassBody 中。
Static semantic rules that depend upon substructure generally do not look into class bodies except
for
- 返回
false 。
依赖子结构的静态语义规则通常不会检查static初始化块。
- 如果 symbol 不是
NewTarget 、SuperProperty 、SuperCall 、super或this之一，则返回false 。 - 如果
ArrowParameters Contains symbol 为true ，则返回true 。 - 返回
ConciseBody Contains symbol。
- 让 formals 为
ArrowFormalParameters ，该CoverParenthesizedExpressionAndArrowParameterList 被覆盖 。 - 返回 formals
Contains symbol 的结果。
- 如果 symbol 不是以下之一：
NewTarget ，SuperProperty ，SuperCall ，super，或this，返回false 。 - 返回
AsyncConciseBody 的Contains symbol 的结果。
- 如果 symbol 不是以下之一：
NewTarget ，SuperProperty ，SuperCall ，super，或this，返回false 。 - 令 head 为
AsyncArrowHead ，它被CoverCallExpressionAndAsyncArrowHead 覆盖 。 - 如果 head
Contains symbol 的结果为true ，返回true 。 - 返回
AsyncConciseBody Contains symbol 的结果。
Contains is used to detect new.target, this, and super usage
within an
- 如果 symbol 是
MethodDefinition ，返回true 。 - 返回
MethodDefinition ComputedPropertyContains symbol 的结果。
- 返回
false 。
- 如果
MemberExpression Contains symbol 是true ，返回true 。 - 返回
false 。
- 如果 symbol 是
ReservedWord super，返回true 。 - 返回
false 。
- 如果
CallExpression Contains symbol 是true ，返回true 。 - 返回
false 。
- 返回
false 。
- 如果
OptionalChain Contains symbol 是true ，返回true 。 - 返回
false 。
8.5.2 静态语义：ComputedPropertyContains
- 返回
false 。
- 返回
ComputedPropertyName 的结果，其中 symbol 被作为Contains 的参数。
- 返回
ComputedPropertyContains 的结果，其中ClassElementName 被作为参数 symbol。
- 返回
ComputedPropertyContains 的结果，其中ClassElementName 被作为参数 symbol。
- 返回
ComputedPropertyContains 的结果，其中ClassElementName 被作为参数 symbol。
- 令 inList 为
ComputedPropertyContains 的结果，其中ClassElementList 被作为参数 symbol。 - 如果 inList 为
true ，则返回true 。 - 返回
ComputedPropertyContains 的结果，其中ClassElement 被作为参数 symbol。
- 返回
false 。
- 返回
false 。
- 返回
ComputedPropertyContains 的结果，其中ClassElementName 被作为参数 symbol。
- 返回
ComputedPropertyContains 的结果，其中ClassElementName 被作为参数 symbol。
8.6 杂项
这些操作在整个规范的多个地方使用。
8.6.1 运行时语义: InstantiateFunctionObject
- 返回
InstantiateOrdinaryFunctionObject 对FunctionDeclaration 的调用，参数为 env 和 privateEnv。
- 返回
InstantiateGeneratorFunctionObject 对GeneratorDeclaration 的调用，参数为 env 和 privateEnv。
- 返回
InstantiateAsyncGeneratorFunctionObject 对AsyncGeneratorDeclaration 的调用，参数为 env 和 privateEnv。
- 返回
InstantiateAsyncFunctionObject 对AsyncFunctionDeclaration 的调用，参数为 env 和 privateEnv。
8.6.2 运行时语义：绑定初始化
它在以下生成式中逐段定义：
- 让 name 成为
StringValue 的Identifier 。 - 返回 ?
InitializeBoundName (name, value, environment)。
- 返回 ?
InitializeBoundName ("yield" , value, environment)。
- 返回 ?
InitializeBoundName ("await" , value, environment)。
- 执行 ?
RequireObjectCoercible (value)。 - 返回 ?
BindingInitialization ofObjectBindingPattern with arguments value 和 environment。
- 让 iteratorRecord 为 ?
GetIterator (value,sync )。 - 让 result 为
Completion (IteratorBindingInitialization ofArrayBindingPattern with arguments iteratorRecord 和 environment)。 - 如果 iteratorRecord.[[Done]] 为
false ，返回 ?IteratorClose (iteratorRecord, result)。 - 返回 ? result。
- 返回
unused 。
- 执行 ?
PropertyBindingInitialization ofBindingPropertyList with arguments value 和 environment。 - 返回
unused 。
- 让 excludedNames 成为一个新的空
列表 。 - 返回 ?
RestBindingInitialization ofBindingRestProperty with arguments value, environment, 和 excludedNames。
- 让 excludedNames 成为 ?
PropertyBindingInitialization ofBindingPropertyList with arguments value 和 environment。 - 返回 ?
RestBindingInitialization ofBindingRestProperty with arguments value, environment, 和 excludedNames。
8.6.2.1 InitializeBoundName ( name, value, environment )
抽象操作 InitializeBoundName 接受参数 name（字符串），value（一个
- 如果 environment 不是
undefined ，那么- 执行 ! environment.InitializeBinding(name, value）。
- 返回
unused 。
- 否则，
- 让 lhs 等于 ?
ResolveBinding (name）。 - 返回 ?
PutValue (lhs, value）。
- 让 lhs 等于 ?
8.6.3 运行时语义：IteratorBindingInitialization
它通过以下生成式逐段定义：
- 返回
unused 。
- 返回 ?
IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord。
- 如果
Elision 存在，那么- 执行 ?
IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord。
- 执行 ?
- 返回 ?
IteratorBindingInitialization ofBindingRestElement with arguments iteratorRecord 和 environment。
- 执行 ?
IteratorBindingInitialization ofBindingElementList with arguments iteratorRecord 和 environment。 - 返回 ?
IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord。
- 执行 ?
IteratorBindingInitialization ofBindingElementList with arguments iteratorRecord 和 environment。 - 如果
Elision 存在，那么- 执行 ?
IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord。
- 执行 ?
- 返回 ?
IteratorBindingInitialization ofBindingRestElement with arguments iteratorRecord 和 environment。
- 执行 ?
IteratorBindingInitialization ofBindingElementList with arguments iteratorRecord 和 environment。 - 返回 ?
IteratorBindingInitialization ofBindingElisionElement with arguments iteratorRecord 和 environment。
- 执行 ?
IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord。 - 返回 ?
IteratorBindingInitialization ofBindingElement with arguments iteratorRecord 和 environment。
- 设 bindingId 为
字符串值（StringValue） 的绑定标识符（BindingIdentifier） 。 - 设 lhs 为
?
解析绑定（ResolveBinding） (bindingId, environment)。 - 设 v 为
未定义（undefined） 。 - 如果 iteratorRecord 的 [[完成]]（[[Done]]） 为
false ，则：- 设 next 为
?
迭代器步骤值（IteratorStepValue） (iteratorRecord)。 - 如果 next 不是
完成（done） ，则：- 将 v 设为 next。
- 设 next 为
?
- 如果存在
初始化器（Initializer） 且 v 为未定义（undefined） ，则：- 如果
是否匿名函数定义（IsAnonymousFunctionDefinition） (初始化器（Initializer） ) 为true ，则：- 将 v 设为
?
命名评估（NamedEvaluation） (初始化器（Initializer） ，参数为 bindingId)。
- 将 v 设为
?
- 否则：
- 设 defaultValue 为
?
评估（Evaluation） (初始化器（Initializer） )。 - 将 v 设为
?
获取值（GetValue） (defaultValue)。
- 设 defaultValue 为
?
- 如果
- 如果 environment 为
未定义（undefined） ， 则返回 ?放置值（PutValue） (lhs，v)。 - 返回
?
初始化引用绑定（InitializeReferencedBinding） (lhs，v)。
- 设 v 为
未定义（undefined） 。 - 如果 iteratorRecord 的 [[完成]]（[[Done]]） 为
false ，则：- 设 next 为
?
迭代器步骤值（IteratorStepValue） (iteratorRecord)。 - 如果 next 不是
完成（done） ，则：- 将 v 设为 next。
- 设 next 为
?
- 如果存在
初始化器（Initializer） 且 v 为未定义（undefined） ，则：- 设 defaultValue 为
?
评估（Evaluation） (初始化器（Initializer） )。 - 将 v 设为
?
获取值（GetValue） (defaultValue)。
- 设 defaultValue 为
?
- 返回 ?
绑定初始化（BindingInitialization） 的绑定模式（BindingPattern） ，参数为 v 和 environment。
- 设 lhs 为 ?
ResolveBinding (StringValue 的BindingIdentifier , environment)。 - 设 A 为 !
ArrayCreate (0)。 - 设 n 为 0。
- 重复，
- 设 next 为
done 。 - 如果 iteratorRecord 的 [[Done]] 为
false ，则：- 将 next 设为 ?
IteratorStepValue (iteratorRecord)。
- 将 next 设为 ?
- 如果 next 为
done ，则：- 如果 environment 为
undefined ，则返回 ?PutValue (lhs, A)。 - 返回 ?
InitializeReferencedBinding (lhs, A)。
- 如果 environment 为
- 执行 !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)), next)。 - 将 n 设为 n + 1。
- 设 next 为
- 设 A 为 !
ArrayCreate (0)。 - 设 n 为 0。
- 重复，
- 设 next 为
done 。 - 如果 iteratorRecord 的 [[Done]] 为
false ，则：- 将 next 设为 ?
IteratorStepValue (iteratorRecord)。
- 将 next 设为 ?
- 如果 next 为
done ，则：- 返回 ?
BindingInitialization ofBindingPattern ，参数为 A 和 environment。
- 返回 ?
- 执行 !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)), next)。 - 将 n 设为 n + 1。
- 设 next 为
- 返回
unused 。
- 执行 ?
IteratorBindingInitialization ofFormalParameterList ，参数为 iteratorRecord 和 environment。 - 返回 ?
IteratorBindingInitialization ofFunctionRestParameter ，参数为 iteratorRecord 和 environment。
- 执行 ?
IteratorBindingInitialization ofFormalParameterList ，参数为 iteratorRecord 和 environment。 - 返回 ?
IteratorBindingInitialization ofFormalParameter ，参数为 iteratorRecord 和 environment。
- 令 v 为
undefined 。 断言 ：iteratorRecord.[[Done]] 为false 。- 令 next 为 ?
IteratorStepValue (iteratorRecord)。 - 如果 next 不是
done ，则- 将 v 设置为 next。
- 返回 ?
BindingInitialization ofBindingIdentifier ，参数为 v 和 environment。
- 令 formals 为
ArrowFormalParameters ，它被CoverParenthesizedExpressionAndArrowParameterList 所覆盖。 - 返回 ?
IteratorBindingInitialization of formals，参数为 iteratorRecord 和 environment。
- 令 v 为
undefined 。 断言 ：iteratorRecord.[[Done]] 为false 。- 令 next 为 ?
IteratorStepValue (iteratorRecord)。 - 如果 next 不是
done ，则- 将 v 设置为 next。
- 返回 ?
BindingInitialization ofBindingIdentifier ，参数为 v 和 environment。
8.6.4 静态语义: AssignmentTargetType
语法导向操作
- 如果这个
IdentifierReference 包含在严格模式代码 中，并且Identifier 的StringValue 是"eval" 或"arguments" ，则返回invalid 。 - 返回
simple 。
- 返回
simple 。
- 设 expr 是由
ParenthesizedExpression 所包含 的部分。 - 返回
AssignmentTargetType 的 expr。
- 返回
invalid 。
8.6.5 静态语义：PropName
- 返回
empty .
- 返回
PropName 的PropertyName 。
- 返回
StringValue 的IdentifierName 。
- 返回
SV 的StringLiteral 。
- 让 nbr 为
NumericValue 的NumericLiteral 。 - 返回 !
ToString (nbr)。
- 返回
empty 。
- 返回
PropName 的ClassElementName 。
- 返回
PropName 的ClassElementName 。
- 返回
PropName 的ClassElementName 。
- 返回
empty .
- 返回
empty .
- 返回
PropName 的ClassElementName 。
- 返回
PropName 的ClassElementName 。
- 返回
empty 。
9 可执行代码和执行上下文
9.1 环境记录
环境记录是一种规范类型，用于根据 ECMAScript 代码的词法嵌套结构，定义
每个环境记录都有一个[[OuterEnv]]字段，它要么是
环境记录纯粹是规范机制，不需要对应于 ECMAScript 实现的任何具体产物。ECMAScript 程序不可能直接访问或操作这些值。
9.1.1 环境记录类型层次结构
-
环境记录 （抽象类）
| 方法 | 用途 |
|---|---|
| HasBinding(N) | 确定 |
| CreateMutableBinding(N, D) | 在 |
| CreateImmutableBinding(N, S) | 在 |
| InitializeBinding(N, V) | 设置 |
| SetMutableBinding(N, V, S) | 设置 |
| GetBindingValue(N, S) | 返回 |
| DeleteBinding(N) | 从 |
| HasThisBinding() | 确定this绑定。如果建立了，返回 |
| HasSuperBinding() | 确定super方法绑定。如果建立了，返回 |
| WithBaseObject() | 如果此with语句关联，则返回
with 对象。否则，返回 |
9.1.1.1 声明式环境记录
每个声明式环境记录都与包含变量、常量、let、class、模块、import和/或函数声明的 ECMAScript 程序范围相关联。声明式环境记录绑定其范围内包含的声明所定义的一组标识符。
声明式环境记录的具体规范方法的行为由以下算法定义。
9.1.1.1.1 HasBinding ( N )
- 如果envRec有N的绑定，则返回
true 。 - 返回
false 。
9.1.1.1.2 CreateMutableBinding ( N, D )
断言 ：envRec中不存在N的绑定。- 在envRec中为N创建一个可变绑定，并记录它未初始化。如果D是
true ，则记录新创建的绑定可以通过后续的 DeleteBinding 调用删除。 - 返回
unused 。
9.1.1.1.3 CreateImmutableBinding ( N, S )
断言 ：envRec中不存在N的绑定。- 在envRec中为N创建一个不可变绑定，并记录它未初始化。如果S是
true ，则记录新创建的绑定是严格绑定。 - 返回
unused 。
9.1.1.1.4 InitializeBinding ( N, V )
断言 ：envRec中必须有N的未初始化绑定。- 将envRec中N的绑定值设置为V。
- 记录envRec中N的绑定已被初始化。
- 返回
unused 。
9.1.1.1.5 SetMutableBinding ( N, V, S )
- 如果envRec中没有N的绑定，则
- 如果S是
true ，抛出ReferenceError 异常。 - 执行
! envRec.CreateMutableBinding(N,
true ）。 - 执行 ! envRec.InitializeBinding(N, V）。
- 返回
unused 。
- 如果S是
- 如果envRec中N的绑定是严格绑定，则将S设置为
true 。 - 如果envRec中N的绑定尚未初始化，则
- 抛出
ReferenceError 异常。
- 抛出
- 否则，如果envRec中N的绑定是可变绑定，则
- 将其绑定值更改为V。
- 否则，
断言 ：这是尝试更改不可变绑定的值。- 如果S是
true ，抛出TypeError 异常。
- 返回
unused 。
在步骤
function f() { eval("var x; x = (delete x, 0);"); }9.1.1.1.6 GetBindingValue ( N, S )
断言 ：envRec有N的绑定。- 如果envRec中N的绑定是未初始化绑定，则抛出
ReferenceError 异常。 - 返回当前绑定到envRec中N的值。
9.1.1.1.7 DeleteBinding ( N )
断言 ：envRec有N的绑定。- 如果envRec中N的绑定不能被删除，则返回
false 。 - 从envRec中移除N的绑定。
- 返回
true 。
9.1.1.1.8 HasThisBinding ( )
- 返回
false 。
9.1.1.1.9 HasSuperBinding ( )
- 返回
false 。
9.1.1.1.10 WithBaseObject ( )
- 返回
undefined 。
9.1.1.2 对象环境记录
每个对象环境记录都与一个称为绑定对象的对象相关联。对象环境记录绑定一组字符串标识符名称，这些名称直接对应于其绑定对象的属性名称。
为with语句创建的对象环境记录（
对象环境记录具有
对象环境记录的具体规范方法的行为由以下算法定义。
9.1.1.2.1 HasBinding ( N )
- 让bindingObject成为envRec的[[BindingObject]]。
- 让foundBinding为?
HasProperty (bindingObject, N）。 - 如果foundBinding为
false ，返回false 。 - 如果envRec的[[IsWithEnvironment]]为
false ，返回true 。 - 让unscopables为?
Get (bindingObject,@@unscopables ）。 - 如果unscopables是一个
对象 ，则 - 返回
true 。
9.1.1.2.2 CreateMutableBinding ( N, D )
- 让bindingObject成为envRec的[[BindingObject]]。
- 执行?
DefinePropertyOrThrow (bindingObject, N, PropertyDescriptor { [[Value]]:undefined , [[Writable]]:true , [[Enumerable]]:true , [[Configurable]]: D }）。 - 返回
unused 。
通常情况下，envRec不会有N的绑定，但如果有，
9.1.1.2.3 CreateImmutableBinding ( N, S )
9.1.1.2.4 InitializeBinding ( N, V )
- 执行? envRec.SetMutableBinding(N, V,
false ）。 - 返回
unused 。
9.1.1.2.5 SetMutableBinding ( N, V, S )
- 让bindingObject成为envRec的[[BindingObject]]。
- 让stillExists为?
HasProperty (bindingObject, N）。 - 如果stillExists为
false 且S为true ，抛出ReferenceError 异常。 - 执行?
Set (bindingObject, N, V, S）。 - 返回
unused 。
9.1.1.2.6 GetBindingValue ( N, S )
- 让bindingObject成为envRec的[[BindingObject]]。
- 让value为?
HasProperty (bindingObject, N）。 - 如果value为
false ，则- 如果S为
false ，返回undefined ；否则抛出ReferenceError 异常。
- 如果S为
- 返回?
Get (bindingObject, N）。
9.1.1.2.7 DeleteBinding ( N )
- 让bindingObject成为envRec的[[BindingObject]]。
- 返回? bindingObject.[[Delete]](N）。
9.1.1.2.8 HasThisBinding ( )
- 返回
false 。
this绑定。
9.1.1.2.9 HasSuperBinding ( )
- 返回
false 。
super绑定。
9.1.1.2.10 WithBaseObject ( )
- 如果envRec的[[IsWithEnvironment]]为
true ，返回envRec的[[BindingObject]]。 - 否则，返回
undefined 。
9.1.1.3 函数环境记录
函数环境记录 是一种
this绑定。如果函数不是一个super，则其函数环境记录还包含用于在函数内部执行super方法调用的状态。
函数环境记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[ThisValue]] |
一个 |
这是该函数调用中使用的 |
| [[ThisBindingStatus]] |
|
如果值是 |
| [[FunctionObject]] |
一个ECMAScript |
导致创建此 |
| [[NewTarget]] |
一个对象或 |
如果此 |
函数环境记录支持
函数环境记录附加具体方法的行为由以下算法定义：
9.1.1.3.1 BindThisValue ( V )
函数环境记录
断言 : envRec.[[ThisBindingStatus]]不是lexical 。- 如果envRec.[[ThisBindingStatus]]是
initialized ，抛出ReferenceError 异常。 - 将envRec.[[ThisValue]]设置为V。
- 将envRec.[[ThisBindingStatus]]设置为
initialized 。 - 返回V。
9.1.1.3.2 HasThisBinding ( )
函数环境记录
- 如果envRec.[[ThisBindingStatus]]是
lexical ，返回false ； 否则，返回true 。
9.1.1.3.3 HasSuperBinding ( )
函数环境记录
- 如果envRec.[[ThisBindingStatus]]是
lexical ，返回false 。 - 如果envRec.[[FunctionObject]].[[HomeObject]]是
undefined ，返回false ； 否则，返回true 。
9.1.1.3.4 GetThisBinding ( )
函数环境记录
断言 : envRec.[[ThisBindingStatus]]不是lexical 。- 如果envRec.[[ThisBindingStatus]]是
uninitialized ，抛出ReferenceError 异常。 - 返回envRec.[[ThisValue]]。
9.1.1.3.5 GetSuperBase ( )
函数环境记录
9.1.1.4 全局环境记录
全局环境记录用于表示所有在同一个
全局环境记录在逻辑上是一个单一的记录，但它被指定为一个复合体，封装了一个
属性可以直接在
全局环境记录具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[ObjectRecord]] |
一个 |
绑定对象是 |
| [[GlobalThisValue]] | 一个对象 |
全局作用域中this返回的值。 |
| [[DeclarativeRecord]] |
一个 |
|
| [[VarNames]] |
一个 |
在相关 |
| 方法 | 目的 |
|---|---|
| GetThisBinding() |
返回此this绑定的值。
|
| HasVarDeclaration (N) |
确定参数标识符是否在此 |
| HasLexicalDeclaration (N) |
确定参数标识符是否在此 |
| HasRestrictedGlobalProperty (N) |
确定参数是否为 |
| CanDeclareGlobalVar (N) | 确定是否可以成功调用相应的CreateGlobalVarBinding方法，并为相同的参数N声明全局变量。 |
| CanDeclareGlobalFunction (N) | 确定是否可以成功调用相应的CreateGlobalFunctionBinding方法，并为相同的参数N声明全局函数。 |
| CreateGlobalVarBinding(N, D) |
用于在[[ObjectRecord]]组件中创建并初始化一个全局var绑定，
该绑定的初始值为var的属性值。
字符串值N是绑定的名称。如果D为 |
| CreateGlobalFunctionBinding(N, V, D) |
在[[ObjectRecord]]组件中创建并初始化一个全局function绑定。
绑定将是可变绑定。相应的function的属性值。
字符串值N是绑定的名称。V是初始化值。
如果布尔参数D为 |
具体规范方法的行为定义如下算法。
9.1.1.4.1 HasBinding ( N )
全局环境记录envRec的HasBinding具体方法接受参数N（字符串），返回一个
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 如果! DclRec.HasBinding(N)为
true ，返回true 。 - 设ObjRec为envRec的[[ObjectRecord]]。
- 返回? ObjRec.HasBinding(N)。
9.1.1.4.2 CreateMutableBinding ( N, D )
全局环境记录envRec的CreateMutableBinding具体方法接受参数N（字符串）和D（布尔值），返回一个
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 如果! DclRec.HasBinding(N)为
true ，抛出类型错误 异常。 - 返回 ! DclRec.CreateMutableBinding(N, D)。
9.1.1.4.3 CreateImmutableBinding ( N, S )
全局环境记录envRec的CreateImmutableBinding具体方法接受参数N（字符串）和S（布尔值），返回一个
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 如果! DclRec.HasBinding(N)为
true ，抛出类型错误 异常。 - 返回 ! DclRec.CreateImmutableBinding(N, S)。
9.1.1.4.4 InitializeBinding ( N, V )
全局环境记录envRec的InitializeBinding具体方法接受参数N（字符串）和V（
9.1.1.4.5 SetMutableBinding ( N, V, S )
全局环境记录envRec的SetMutableBinding具体方法接受参数N（字符串）、V（
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 如果! DclRec.HasBinding(N)为
true ，则- 返回 ? DclRec.SetMutableBinding(N, V, S)。
- 设ObjRec为envRec的[[ObjectRecord]]。
- 返回? ObjRec.SetMutableBinding(N, V, S)。
9.1.1.4.6 GetBindingValue ( N, S )
全局环境记录envRec的GetBindingValue具体方法接受参数N（字符串）和S（布尔值），返回一个
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 如果! DclRec.HasBinding(N)为
true ，则- 返回 ? DclRec.GetBindingValue(N, S)。
- 设ObjRec为envRec的[[ObjectRecord]]。
- 返回? ObjRec.GetBindingValue(N, S)。
9.1.1.4.7 DeleteBinding ( N )
全局环境记录envRec的DeleteBinding具体方法接受参数N（字符串），返回一个
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 如果! DclRec.HasBinding(N)为
true ，则- 返回 ! DclRec.DeleteBinding(N)。
- 设ObjRec为envRec的[[ObjectRecord]]。
- 设globalObject为ObjRec的[[BindingObject]]。
- 设existingProp为?
HasOwnProperty (globalObject, N)。 - 如果existingProp为
true ，则- 设status为? ObjRec.DeleteBinding(N)。
- 如果status为
true ，并且envRec的[[VarNames]]包含N，则- 从envRec的[[VarNames]]中删除N。
- 返回status。
- 返回
true 。
9.1.1.4.8 HasThisBinding ( )
全局环境记录envRec的HasThisBinding具体方法不接受参数，返回
- 返回
true 。
this绑定。
9.1.1.4.9 HasSuperBinding ( )
全局环境记录envRec的HasSuperBinding具体方法不接受参数，返回
- 返回
false 。
super绑定。
9.1.1.4.10 WithBaseObject ( )
全局环境记录envRec的WithBaseObject具体方法不接受参数，返回
- 返回
undefined 。
9.1.1.4.11 GetThisBinding ( )
全局环境记录envRec的GetThisBinding具体方法不接受参数，返回一个
- 返回envRec的[[GlobalThisValue]]。
9.1.1.4.12 HasVarDeclaration ( N )
全局环境记录envRec的HasVarDeclaration具体方法接受参数N（字符串），返回一个布尔值。它确定参数标识符是否在此记录中具有通过
- 设varDeclaredNames为envRec的[[VarNames]]。
- 如果varDeclaredNames包含N，返回
true 。 - 返回
false 。
9.1.1.4.13 HasLexicalDeclaration ( N )
全局环境记录envRec的HasLexicalDeclaration具体方法接受参数N（字符串），返回一个布尔值。它确定参数标识符是否在此记录中具有通过词法声明（如
- 设DclRec为envRec的[[DeclarativeRecord]]。
- 返回! DclRec.HasBinding(N)。
9.1.1.4.14 HasRestrictedGlobalProperty ( N )
全局环境记录envRec的HasRestrictedGlobalProperty具体方法接受参数N（字符串），返回一个
- 设ObjRec为envRec的[[ObjectRecord]]。
- 设globalObject为ObjRec的[[BindingObject]]。
- 设existingProp为? globalObject.[[GetOwnProperty]](N)。
- 如果existingProp为
未定义 ， 返回false 。 - 如果existingProp的[[Configurable]]为
true ，返回false 。 - 返回
true 。
9.1.1.4.15 CanDeclareGlobalVar ( N )
全局环境记录envRec的CanDeclareGlobalVar具体方法接受参数N（字符串），返回一个
- 设ObjRec为envRec的[[ObjectRecord]]。
- 设globalObject为ObjRec的[[BindingObject]]。
- 设hasProperty为?
HasOwnProperty (globalObject, N)。 - 如果hasProperty为
true ，返回true 。 - 返回?
IsExtensible (globalObject)。
9.1.1.4.16 CanDeclareGlobalFunction ( N )
全局环境记录envRec的CanDeclareGlobalFunction具体方法接受参数N（字符串），返回一个
- 设ObjRec为envRec的[[ObjectRecord]]。
- 设globalObject为ObjRec的[[BindingObject]]。
- 设existingProp为? globalObject.[[GetOwnProperty]](N)。
- 如果existingProp为
未定义 ， 返回?IsExtensible (globalObject)。 - 如果existingProp的[[Configurable]]为
true ，返回true 。 - 如果
IsDataDescriptor (existingProp) 为true ，且existingProp具有属性值{ [[Writable]]:true , [[Enumerable]]:true }，返回true 。 - 返回
false 。
9.1.1.4.17 CreateGlobalVarBinding ( N, D )
全局环境记录envRec的CreateGlobalVarBinding具体方法接受参数N（字符串）和D（布尔值），返回一个
- 设ObjRec为envRec的[[ObjectRecord]]。
- 设globalObject为ObjRec的[[BindingObject]]。
- 设hasProperty为?
HasOwnProperty (globalObject, N)。 - 设extensible为?
IsExtensible (globalObject)。 - 如果hasProperty为
false 并且extensible为true ，则- 执行? ObjRec.CreateMutableBinding(N, D)。
- 执行? ObjRec.InitializeBinding(N,
未定义 )。
- 如果envRec的[[VarNames]]
不包含N，则
- 将N追加到envRec的[[VarNames]]中。
- 返回
未使用 。
9.1.1.4.18 CreateGlobalFunctionBinding ( N, V, D )
全局环境记录envRec的CreateGlobalFunctionBinding具体方法接受参数N（字符串）、V（
- 设ObjRec为envRec的[[ObjectRecord]]。
- 设globalObject为ObjRec的[[BindingObject]]。
- 设existingProp为? globalObject.[[GetOwnProperty]](N)。
- 如果existingProp为
未定义 或existingProp的[[Configurable]]为true ，则- 设desc为属性描述符{ [[Value]]:
V, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]: D }.
- 设desc为属性描述符{ [[Value]]:
V, [[Writable]]:
- 否则，
- 设desc为属性描述符{ [[Value]]: V }。
- 执行?
DefinePropertyOrThrow (globalObject, N, desc)。 - 执行
?
Set (globalObject, N, V,false )。 - 如果envRec的[[VarNames]]
不包含N，则
- 将N追加到envRec的[[VarNames]]中。
- 返回
未使用 。
9.1.1.5 模块环境记录
模块环境记录 是一种
模块环境记录支持所有在
模块环境记录的附加具体规范方法的行为由以下算法定义：
9.1.1.5.1 GetBindingValue ( N, S )
模块环境记录的 GetBindingValue 具体方法 envRec 接受参数 N（字符串）和 S（布尔值），返回一个包含
ECMAScript 语言值的正常完成记录或抛出完成记录。它返回其绑定标识符 N 的值。但是，如果绑定是间接绑定，则返回目标绑定的值。如果绑定存在但未初始化，则抛出
S 将始终为
9.1.1.5.2 DeleteBinding ( N )
模块环境记录的 DeleteBinding 具体方法在本规范中从未使用。
9.1.1.5.3 HasThisBinding ( )
模块环境记录的 HasThisBinding 具体方法 envRec 不接受任何参数并返回
- 返回
true 。
模块环境记录始终提供 this 绑定。
9.1.1.5.4 GetThisBinding ( )
模块环境记录的 GetThisBinding 具体方法 envRec 不接受任何参数并返回
- 返回
undefined 。
9.1.1.5.5 CreateImportBinding ( N, M, N2 )
模块环境记录的 CreateImportBinding 具体方法 envRec 接受参数 N（字符串）、M（模块记录）和 N2（字符串），并返回
9.1.2 环境记录操作
9.1.2.1 GetIdentifierReference ( env, name, strict )
抽象操作 GetIdentifierReference 接受参数 env（一个
- 如果 env 是
null ，则- 返回
引用记录 { [[Base]]:unresolvable , [[ReferencedName]]: name, [[Strict]]: strict, [[ThisValue]]:empty }。
- 返回
- 设 exists 为 ? env.HasBinding(name)。
- 如果 exists 为
true ，则- 返回
引用记录 { [[Base]]: env, [[ReferencedName]]: name, [[Strict]]: strict, [[ThisValue]]:empty }。
- 返回
- 否则，
- 设 outer 为 env.[[OuterEnv]]。
- 返回 ?
GetIdentifierReference (outer, name, strict)。
9.1.2.2 NewDeclarativeEnvironment ( E )
抽象操作 NewDeclarativeEnvironment 接受参数 E（一个
- 设 env 为一个新的
声明环境记录 ，其中不包含任何绑定。 - 将 env.[[OuterEnv]] 设置为 E。
- 返回 env。
9.1.2.3 NewObjectEnvironment ( O, W, E )
抽象操作 NewObjectEnvironment 接受参数 O（一个对象）、W（布尔值）和 E（一个
- 设 env 为一个新的
对象环境记录 。 - 将 env.[[BindingObject]] 设置为 O。
- 将 env.[[IsWithEnvironment]] 设置为 W。
- 将 env.[[OuterEnv]] 设置为 E。
- 返回 env。
9.1.2.4 NewFunctionEnvironment ( F, newTarget )
抽象操作 NewFunctionEnvironment 接受参数 F（一个 ECMAScript
- 设 env 为一个新的
函数环境记录 ，其中不包含任何绑定。 - 将 env.[[FunctionObject]] 设置为 F。
- 如果 F.[[ThisMode]] 为
lexical ，将 env.[[ThisBindingStatus]] 设置为lexical 。 - 否则，将 env.[[ThisBindingStatus]] 设置为
uninitialized 。 - 将 env.[[NewTarget]] 设置为 newTarget。
- 将 env.[[OuterEnv]] 设置为 F.[[Environment]]。
- 返回 env。
9.1.2.5 NewGlobalEnvironment ( G, thisValue )
抽象操作 NewGlobalEnvironment 接受参数 G（一个对象）和 thisValue（一个对象），返回一个
- 设 objRec 为
NewObjectEnvironment (G,false ,null )。 - 设 dclRec 为
NewDeclarativeEnvironment (null )。 - 设 env 为一个新的
全局环境记录 。 - 将 env.[[ObjectRecord]] 设置为 objRec。
- 将 env.[[GlobalThisValue]] 设置为 thisValue。
- 将 env.[[DeclarativeRecord]] 设置为 dclRec。
- 将 env.[[VarNames]] 设置为一个新的空
列表 。 - 将 env.[[OuterEnv]] 设置为
null 。 - 返回 env。
9.1.2.6 NewModuleEnvironment ( E )
抽象操作 NewModuleEnvironment 接受参数 E（一个
- 设 env 为一个新的
模块环境记录 ，其中不包含任何绑定。 - 将 env.[[OuterEnv]] 设置为 E。
- 返回 env。
9.2 私有环境记录
私有环境记录 是一种用于根据
ECMAScript 代码中的
9.2.1 私有环境记录操作
9.2.1.1 NewPrivateEnvironment ( outerPrivEnv )
抽象操作 NewPrivateEnvironment 接受参数 outerPrivEnv（一个
9.2.1.2 ResolvePrivateIdentifier ( privEnv, identifier )
抽象操作 ResolvePrivateIdentifier 接受参数 privEnv（一个
- 设 names 为 privEnv.[[Names]]。
-
对于 names 中的每个
私有名称 pn， 执行以下步骤：-
如果 pn.[[Description]] 是
identifier，则：
- 返回 pn。
-
如果 pn.[[Description]] 是
identifier，则：
- 设 outerPrivEnv 为 privEnv.[[OuterPrivateEnvironment]]。
-
断言 ： outerPrivEnv 不为null 。 -
返回
ResolvePrivateIdentifier ( outerPrivEnv, identifier)。
9.3 范围（Realms）
在评估之前，所有 ECMAScript 代码都必须与一个 范围 相关联。从概念上讲，一个
本规范中以 范围记录 表示
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[AgentSignifier]] | 一个 |
拥有此 |
| [[Intrinsics]] | 一个 |
与此 |
| [[GlobalObject]] | 一个对象或 |
此 |
| [[GlobalEnv]] | 一个 |
此 |
| [[TemplateMap]] | 一个 |
模板对象在每个 一旦
|
| [[LoadedModules]] | 一个 |
从此 正如在
import() 表达式时使用。
|
| [[HostDefined]] | 任何（默认值为 |
为 |
9.3.1 创建范围（CreateRealm） ( )
抽象操作 CreateRealm 不接受任何参数并返回一个
- 设 realmRec 为一个新的
范围记录 。 - 执行
CreateIntrinsics (realmRec)。 - 将 realmRec.[[AgentSignifier]]
设置为
AgentSignifier ()。 - 将 realmRec.[[GlobalObject]] 设置为
undefined 。 - 将 realmRec.[[GlobalEnv]] 设置为
undefined 。 - 将 realmRec.[[TemplateMap]]
设置为一个新的空
列表 。 - 返回 realmRec。
9.3.2 创建内置对象（CreateIntrinsics） ( realmRec )
抽象操作 CreateIntrinsics 接受参数 realmRec（一个
- 将 realmRec.[[Intrinsics]]
设置为一个新的
记录 。 -
使用
表 6 中列出的值设置 realmRec.[[Intrinsics]] 的字段。这些字段名称是表的第一列中列出的名称。每个字段的值是一个新的对象值，按照规范中的定义完全递归地填充属性值。这些对象的创建顺序必须避免对尚未创建的对象的依赖。 - 执行
AddRestrictedFunctionProperties (realmRec.[[Intrinsics]].[[%Function.prototype% ]], realmRec)。 - 返回
unused 。
9.3.3 设置范围全局对象（SetRealmGlobalObject） ( realmRec, globalObj, thisValue )
抽象操作 SetRealmGlobalObject 接受参数 realmRec（一个
-
如果 globalObj 是
undefined ，则：- 设 intrinsics 为 realmRec.[[Intrinsics]]。
- 将 globalObj 设置为
OrdinaryObjectCreate (intrinsics.[[%Object.prototype% ]])。
断言 ：globalObj 是一个对象 。- 如果 thisValue 是
undefined ，则将 thisValue 设置为 globalObj。 - 将 realmRec.[[GlobalObject]] 设置为 globalObj。
- 设 newGlobalEnv 为
NewGlobalEnvironment (globalObj, thisValue)。 - 将 realmRec.[[GlobalEnv]] 设置为 newGlobalEnv。
- 返回
unused 。
9.3.4 设置默认全局绑定（SetDefaultGlobalBindings） ( realmRec )
抽象操作 SetDefaultGlobalBindings 接受参数 realmRec（一个
9.4 执行上下文（Execution Contexts）
执行上下文 是一个规范设备，用于跟踪 ECMAScript 实现对代码的运行时评估。在任何时候，每个
执行上下文堆栈
用于跟踪执行上下文。
执行上下文包含所有跟踪其关联代码执行进度的必要实现特定状态。每个执行上下文至少有
ECMAScript 代码执行上下文 具有
执行上下文的词法环境和变量环境组件始终是
表示生成器评估的执行上下文具有
| 组件 | 目的 |
|---|---|
| 生成器 | 此 |
在大多数情况下，仅由此规范中的算法直接操作
执行上下文纯粹是一个规范机制，不需要对应于 ECMAScript 实现的任何特定制品。ECMAScript 代码不可能直接访问或观察到执行上下文。
9.4.1 GetActiveScriptOrModule ( )
抽象操作 GetActiveScriptOrModule 不接受参数，并返回
9.4.2 ResolveBinding ( name [ , env ] )
抽象操作 ResolveBinding 接受参数 name（一个字符串）和可选参数 env（一个
- 如果未提供 env 或 env 为
undefined ，则- 将 env 设置为
正在运行的执行上下文 的词法环境。
- 将 env 设置为
断言 ：env 是一个环境记录 。- 如果正在评估的语法生成的
源文本匹配 包含在严格模式代码 中，则将 strict 设置为true ；否则将 strict 设置为false 。 - 返回 ?
GetIdentifierReference (env, name, strict)。
ResolveBinding 的结果始终是一个
9.4.3 GetThisEnvironment ( )
抽象操作 GetThisEnvironment 不接受参数，并返回一个 this
绑定的
- 将 env 设置为
正在运行的执行上下文 的词法环境。 - 重复以下步骤，直到条件不成立为止：
- 让 exists 为 env.HasThisBinding()。
- 如果 exists 为
true ，则返回 env。 - 将 outer 设置为 env.[[OuterEnv]]。
断言 ：outer 不是null 。- 将 env 设置为 outer。
步骤 this 绑定的全局环境结束。
9.4.4 ResolveThisBinding ( )
抽象操作 ResolveThisBinding 不接受参数，并返回 this 的绑定。调用时执行以下步骤：
- 设 envRec 为
GetThisEnvironment ()。 - 返回 ? envRec.GetThisBinding()。
9.4.5 GetNewTarget ( )
抽象操作 GetNewTarget 不接受参数，并返回一个对象或
- 设 envRec 为
GetThisEnvironment ()。 断言 ：envRec 具有 [[NewTarget]] 字段。- 返回 envRec.[[NewTarget]]。
9.4.6 GetGlobalObject ( )
抽象操作 GetGlobalObject 不接受参数并返回一个对象。它返回由当前
- 设 currentRealm 为
当前范围记录 。 - 返回 currentRealm.[[GlobalObject]]。
9.5 Jobs and Host Operations to Enqueue Jobs
作业是一个无参数的
- 在将来的某个时间，当为其调度作业的
代理 中没有正在运行的上下文，并且该代理 的执行上下文堆栈 为空时，实现必须： - 在任何时间点，一个
代理 中只能有一个作业 正在积极评估。 - 一旦一个
代理 中的作业 的评估开始，必须在完成之前运行完毕，然后才能在该代理 中开始评估任何其他作业 。 抽象闭包 必须返回正常完成 ，实现其自己的错误处理。
在任何特定时间，如果以下所有条件都为真，则scriptOrModule（一个
GetActiveScriptOrModule 是scriptOrModule。- 如果scriptOrModule是一个
脚本记录 或一个模块记录 ，则设ec为执行上下文 堆栈上的最顶层的执行上下文 ，其ScriptOrModule组件是scriptOrModule。ec的范围 组件是scriptOrModule的[[Realm]]。
在任何特定时间，如果以下所有条件都为真，则执行准备好评估 ECMAScript 代码：
特定种类的
9.5.1 作业回调记录
作业回调记录是一个
WHATWG HTML 规范（https://html.spec.whatwg.org/）例如，使用宿主定义的值传播 Promise 回调的现有设置对象。
作业回调记录具有
9.5.2 HostMakeJobCallback ( callback )
HostMakeJobCallback 的实现必须符合以下要求：
- 它必须返回一个作业回调记录，其[[Callback]]字段是callback。
HostMakeJobCallback 的默认实现在调用时执行以下步骤：
- 返回作业回调记录 { [[Callback]]:
callback，[[HostDefined]]:
empty }。
不是网络浏览器的 ECMAScript 宿主必须使用 HostMakeJobCallback 的默认实现。
这在将回调传递给负责其最终调度和运行的函数时调用。例如，promise.then(thenAction)在调用Promise.prototype.then时调用
MakeJobCallback
在调用Promise.prototype.then时调用 MakeJobCallback，而不是在调度反应作业时。
9.5.3 HostCallJobCallback ( jobCallback, V, argumentsList )
HostCallJobCallback 的实现必须符合以下要求：
- 它必须执行并返回
调用 (jobCallback.[[Callback]]，V，argumentsList)的结果。
此要求意味着宿主不能更改本规范中定义的函数对象的[[Call]]行为。
HostCallJobCallback 的默认实现在调用时执行以下步骤：
断言 ：IsCallable (jobCallback.[[Callback]]) 为true 。- 返回？
调用 (jobCallback.[[Callback]]，V，argumentsList)的结果。
不是网络浏览器的 ECMAScript 宿主必须使用 HostCallJobCallback 的默认实现。
9.5.4 HostEnqueueGenericJob ( job, realm )
HostEnqueueGenericJob 的实现必须符合
9.5.5 HostEnqueuePromiseJob ( job, realm )
HostEnqueuePromiseJob 的实现必须符合
- 如果realm不是
null ，每次调用job时，实现必须执行实现定义的 步骤，以确保在调用job时执行准备评估 ECMAScript 代码 。 - 在调用 HostEnqueuePromiseJob 时，scriptOrModule为
GetActiveScriptOrModule 。如果realm不是null ，每次调用job时，实现必须执行实现定义的 步骤，以确保scriptOrModule在调用job时是活动脚本或模块 。 - 作业必须按照 HostEnqueuePromiseJob 调用的顺序运行。
通过
9.5.6 HostEnqueueTimeoutJob ( timeoutJob, realm, milliseconds )
HostEnqueueTimeoutJob 的实现必须符合
9.6 InitializeHostDefinedRealm ( )
抽象操作 InitializeHostDefinedRealm 不接受任何参数，返回一个包含
- 让 realm 为
CreateRealm () 的结果。 - 让 newContext 为一个新的
执行上下文 。 - 将 newContext 的 Function 设置为
null 。 - 将 newContext 的
Realm 设置为 realm。 - 将 newContext 的 ScriptOrModule 设置为
null 。 - 将 newContext 推入
执行上下文栈 ；newContext 现在是运行中的执行上下文 。 - 如果
宿主 需要使用一个特殊对象 作为 realm 的全局对象 ，则让 global 为以宿主定义 的方式创建的此类对象。否则，让 global 为undefined ，表示应创建一个普通对象 作为全局对象 。 - 如果
宿主 需要this绑定在 realm 的全局作用域中返回一个不同于全局对象 的对象，则让 thisValue 为以宿主定义 的方式创建的此类对象。否则，让 thisValue 为undefined ，表示 realm 的全局this绑定应为全局对象 。 - 执行
SetRealmGlobalObject (realm, global, thisValue)。 - 让 globalObj 为 ?
SetDefaultGlobalBindings (realm) 的结果。 - 在 globalObj 上创建任何
宿主定义 的全局对象 属性。 - 返回
unused 。
9.7 Agents
一个代理包括一组ECMAScript
一个
一些网络浏览器会在多个不相关的浏览器窗口标签页之间共享单个
当一个
一个代理标识符是一个全局唯一的、不透明的值，用于标识一个
| 字段名 | 值 | 含义 |
|---|---|---|
| [[LittleEndian]] | 布尔值 | 在算法 |
| [[CanBlock]] | 布尔值 | 确定 |
| [[Signifier]] | 一个 |
唯一标识其 |
| [[IsLockFree1]] | 布尔值 | 如果对一个字节大小值的原子操作是无锁的，则为 |
| [[IsLockFree2]] | 布尔值 | 如果对两字节大小值的原子操作是无锁的，则为 |
| [[IsLockFree8]] | 布尔值 | 如果对八字节大小值的原子操作是无锁的，则为 |
| [[CandidateExecution]] | 一个 |
参见 |
| [[KeptAlive]] | 一个 |
最初是一个新的空 |
一旦[[Signifier]]、[[IsLockFree1]]和[[IsLockFree2]]的值被任何
[[IsLockFree1]]和[[IsLockFree2]]的值不一定由硬件决定，还可能反映出可能随时间和不同ECMAScript实现而变化的实现选择。
没有[[IsLockFree4]]字段：四字节原子操作总是无锁的。
实际上，如果一个原子操作的实现使用了任何类型的锁，则该操作就不是无锁的。无锁不意味着无等待：没有关于完成无锁原子操作需要多少机器步骤的上限。
原子访问大小为n是无锁的，并不意味着对非原子访问大小为n的访问有任何暗示，特别是，非原子访问仍可能作为一系列单独的内存访问执行。详见
一个
9.7.1 AgentSignifier ( )
抽象操作 AgentSignifier 不接受任何参数，并返回一个
9.7.2 AgentCanSuspend ( )
抽象操作 AgentCanSuspend 不接受任何参数，并返回一个布尔值。调用时，它执行以下步骤：
在某些环境中，允许给定
9.8 代理集群
一个代理集群是可以通过操作共享内存进行通信的
每个
集群中的所有
如果一个代理集群中的不同
集群中的所有
集群中的所有
嵌入环境可以在不通知或合作代理的情况下停用（停止前进进程）或激活（恢复前进进程）一个
嵌入环境可以在不通知或合作集群中其他
每个以下的规范值及从它们递归可达的值，只属于一个代理集群。
在集群中任何
代理集群是一个规范机制，不必对应于ECMAScript实现的任何特定工件。
9.9 前进进度
对于一个
当
实现必须确保：
9.10 WeakRef 和 FinalizationRegistry 目标的处理模型
9.10.1 目标
本规范不保证任何对象或符号将被垃圾回收。对于那些不是
-
当调用
WeakRef.prototype.deref时，如果未返回undefined ，则被引用对象保持存活，以便随后的同步访问也返回相同的值。当使用ClearKeptObjects 抽象操作进行同步工作时，此列表会被重置。 -
当与
FinalizationRegistry 注册的对象或符号变得不可达时，可能会在同步 ECMAScript 执行完成后调用FinalizationRegistry 的清理回调。清理通过CleanupFinalizationRegistry 抽象操作进行。
这些操作（
一些 ECMAScript 实现包括在后台运行的垃圾回收器实现，包括 ECMAScript 空闲时。让
9.10.2 存活性
对于某些对象和/或符号的集合S，相对于S的假设的 WeakRef-oblivious执行是指抽象操作
在评估过程中，如果对象和/或符号的集合S满足以下任一条件，则被认为是存活的：
对象或符号在字段、内部槽或属性中的存在并不意味着该值是存活的。例如，如果问题中的值从未传递回程序，则无法观察到它。
这是 WeakMap 中的键、WeakSet 的成员以及[[WeakRefTarget]]和[[UnregisterToken]]字段在
上述定义意味着，如果 WeakMap 中的键不是存活的，则其对应的值也不一定是存活的。
9.10.3 执行
在任何时候，如果对象和/或符号的集合S不是
- 对于S的每个元素value，执行以下操作
- 对于每个
WeakRef ，如果ref的[[WeakRefTarget]]是value，则执行以下操作- 将ref的[[WeakRefTarget]]设置为
empty 。
- 将ref的[[WeakRefTarget]]设置为
- 对于每个
FinalizationRegistry ，如果fg的[[Cells]]包含一个记录 ，其中cell的[[WeakRefTarget]]是value，则执行以下操作- 将cell的[[WeakRefTarget]]设置为
empty 。 - 可选地，执行
HostEnqueueFinalizationRegistryCleanupJob (fg)。
- 将cell的[[WeakRefTarget]]设置为
- 对于每个 WeakMapmap，如果map的[[WeakMapData]]包含一个
记录 ，其中r的[[Key]]是value，则执行以下操作- 将r的[[Key]]设置为
empty 。 - 将r的[[Value]]设置为
empty 。
- 将r的[[Key]]设置为
- 对于每个 WeakSetset，如果set的[[WeakSetData]]包含value，则执行以下操作
- 用值为
empty 的元素替换set的[[WeakSetData]]中值为value的元素。
- 用值为
- 对于每个
结合存活性的定义，本条款规定了实现可以应用的关于
有可能在不观察对象身份的情况下访问对象。允许对非逃逸对象的属性进行死变量消除和标量替换等优化，因此这些优化可以可观察地清空指向这些对象的
另一方面，如果可以观察到对象的身份，并且该对象位于
由于调用
9.10.4 宿主钩子
9.10.4.1 HostEnqueueFinalizationRegistryCleanupJob (finalizationRegistry)
让cleanupJob成为一个新的
- 令cleanupResult为
完成 (CleanupFinalizationRegistry (finalizationRegistry))。 - 如果cleanupResult是一个
异常完成 ，执行任何宿主定义的 步骤来报告错误。 - 返回
unused 。
HostEnqueueFinalizationRegistryCleanupJob 的实现会安排在将来的某个时间执行cleanupJob，如果可能的话。它还必须符合
9.11 ClearKeptObjects ( )
抽象操作 ClearKeptObjects 不接受任何参数并返回
9.12 AddToKeptObjects ( value )
抽象操作 AddToKeptObjects 接受参数 value（一个对象或符号）并返回
9.13 CleanupFinalizationRegistry ( finalizationRegistry )
抽象操作 CleanupFinalizationRegistry 接受参数 finalizationRegistry（一个
断言 ：finalizationRegistry 具有 [[Cells]] 和 [[CleanupCallback]] 内部槽。- 让 callback 为 finalizationRegistry.[[CleanupCallback]]。
- 当 finalizationRegistry.[[Cells]]
包含一个
记录 cell，其 [[WeakRefTarget]] 为empty 时，实现可以执行以下步骤：- 选择任意这样的 cell。
- 从 finalizationRegistry.[[Cells]] 中移除 cell。
- 执行 ?
HostCallJobCallback (callback,undefined , « cell.[[HeldValue]] »)。
- 返回
unused 。
9.14 CanBeHeldWeakly ( v )
抽象操作 CanBeHeldWeakly 接受参数 v（一个
- 如果 v
是一个对象 ，返回true 。 - 如果 v
是一个符号 ，并且KeyForSymbol (v) 是undefined ，返回true 。 - 返回
false 。
没有
10 普通对象和异域对象的行为
10.1 普通对象的内部方法和内部槽
所有的
每个
在以下算法描述中，假设 O 是一个
每个
10.1.1 [[GetPrototypeOf]] ( )
[[GetPrototypeOf]] 内部方法用于一个
- 返回
OrdinaryGetPrototypeOf (O)。
10.1.1.1 OrdinaryGetPrototypeOf ( O )
抽象操作 OrdinaryGetPrototypeOf 接受一个参数 O（一个对象），并返回一个对象或
- 返回 O.[[Prototype]]。
10.1.2 [[SetPrototypeOf]] ( V )
[[SetPrototypeOf]] 内部方法用于一个
- 返回
OrdinarySetPrototypeOf (O, V)。
10.1.2.1 OrdinarySetPrototypeOf ( O, V )
抽象操作 OrdinarySetPrototypeOf 接受两个参数：O（一个对象）和 V（一个对象或
- 将 current 设为 O.[[Prototype]]。
- 如果
SameValue (V, current) 为true ，则返回true 。 - 将 extensible 设为 O.[[Extensible]]。
- 如果 extensible 为
false ，则返回false 。 - 将 p 设为 V。
- 将 done 设为
false 。 - 重复以下步骤，直到 done 为
true ： - 将 O.[[Prototype]] 设为 V。
- 返回
true 。
10.1.3 [[IsExtensible]] ( )
[[IsExtensible]] 内部方法用于一个
- 返回
OrdinaryIsExtensible (O)。
10.1.3.1 OrdinaryIsExtensible ( O )
抽象操作 OrdinaryIsExtensible 接受一个参数 O（一个对象），并返回一个布尔值。调用时执行以下步骤：
- 返回 O.[[Extensible]]。
10.1.4 [[PreventExtensions]] ( )
[[PreventExtensions]] 内部方法用于一个
- 返回
OrdinaryPreventExtensions (O)。
10.1.4.1 OrdinaryPreventExtensions ( O )
抽象操作 OrdinaryPreventExtensions 接受一个参数 O（一个对象），并返回
- 将 O.[[Extensible]] 设置为
false 。 - 返回
true 。
10.1.5 [[GetOwnProperty]] ( P )
[[GetOwnProperty]] 内部方法用于一个
- 返回
OrdinaryGetOwnProperty (O, P)。
10.1.5.1 OrdinaryGetOwnProperty ( O, P )
抽象操作 OrdinaryGetOwnProperty 接受两个参数 O（一个对象）和 P（一个
10.1.6 [[DefineOwnProperty]] ( P, Desc )
普通对象的 [[DefineOwnProperty]] 内部方法接受两个参数：P（一个
- 返回 ?
OrdinaryDefineOwnProperty (O, P, Desc).
10.1.6.1 OrdinaryDefineOwnProperty（O, P, Desc）
抽象操作 OrdinaryDefineOwnProperty 接受参数 O（一个对象）、P（一个
- 令 current 为 ? O.[[GetOwnProperty]](P)。
- 令 extensible 为 ?
IsExtensible (O)。 - 返回
ValidateAndApplyPropertyDescriptor (O, P, extensible, Desc, current)。
10.1.6.2 IsCompatiblePropertyDescriptor（Extensible, Desc, Current）
抽象操作 IsCompatiblePropertyDescriptor 接受参数 Extensible（一个布尔值）、Desc（一个
- 返回
ValidateAndApplyPropertyDescriptor (undefined ,"" , Extensible, Desc, Current)。
10.1.6.3 ValidateAndApplyPropertyDescriptor（O, P, extensible, Desc, current）
抽象操作 ValidateAndApplyPropertyDescriptor 接受参数
O（一个对象或
断言 ：IsPropertyKey (P) 是true 。- 如果 current 是
undefined ，则- 如果 extensible 是
false ，返回false 。 - 如果 O 是
undefined ，返回true 。 - 如果
IsAccessorDescriptor (Desc) 是true ，则 - 否则，
- 返回
true 。
- 如果 extensible 是
断言 ：current 是一个完全填充的属性描述符 。- 如果 Desc 没有任何字段，返回
true 。 - 如果 current.[[Configurable]] 是
false ，则- 如果 Desc 有一个 [[Configurable]] 字段且 Desc.[[Configurable]] 是
true ，返回false 。 - 如果 Desc 有一个 [[Enumerable]] 字段且 Desc.[[Enumerable]]
不等于 current.[[Enumerable]]，返回
false 。 - 如果
IsGenericDescriptor (Desc) 是false 并且IsAccessorDescriptor (Desc) 不等于IsAccessorDescriptor (current)，返回false 。 - 如果
IsAccessorDescriptor (current) 是true，则 - 否则，如果 current.[[Writable]] 是
false ，则- 如果 Desc 有一个 [[Writable]] 字段且 Desc.[[Writable]] 是
true ，返回false 。 - 如果 Desc 有一个 [[Value]] 字段且
SameValue (Desc.[[Value]], current.[[Value]]) 是false ，返回false 。
- 如果 Desc 有一个 [[Writable]] 字段且 Desc.[[Writable]] 是
- 如果 Desc 有一个 [[Configurable]] 字段且 Desc.[[Configurable]] 是
- 如果 O 不是
undefined ，则- 如果
IsDataDescriptor (current) 是true 且IsAccessorDescriptor (Desc) 是true ，则- 如果 Desc 有一个 [[Configurable]] 字段，令 configurable 为 Desc.[[Configurable]]；否则令 configurable 为 current.[[Configurable]]。
- 如果 Desc 有一个 [[Enumerable]] 字段，令 enumerable 为 Desc.[[Enumerable]]；否则令 enumerable 为 current.[[Enumerable]]。
- 替换对象 O 中名为 P 的属性为一个
存取器属性 ，其 [[Configurable]] 和 [[Enumerable]] 属性分别设置为 configurable 和 enumerable，其 [[Get]] 和 [[Set]] 属性设置为 Desc 中相应字段的值，如果 Desc 有该字段，则设置为该字段的值，否则设置为属性的默认值 。
- 否则，如果
IsAccessorDescriptor (current) 是true 且IsDataDescriptor (Desc) 是true ，则- 如果 Desc 有一个 [[Configurable]] 字段，令 configurable 为 Desc.[[Configurable]]；否则令 configurable 为 current.[[Configurable]]。
- 如果 Desc 有一个 [[Enumerable]] 字段，令 enumerable 为 Desc.[[Enumerable]]；否则令 enumerable 为 current.[[Enumerable]]。
- 替换对象 O 中名为 P 的属性为一个
数据属性 ，其 [[Configurable]] 和 [[Enumerable]] 属性分别设置为 configurable 和 enumerable，其 [[Value]] 和 [[Writable]] 属性设置为 Desc 中相应字段的值，如果 Desc 有该字段，则设置为该字段的值，否则设置为属性的默认值 。
- 否则，
- 对于 Desc 的每个字段，将对象 O 中名为 P 的属性的相应属性设置为该字段的值。
- 如果
- 返回
true 。
10.1.7 [[HasProperty]]（P）
一个
- 返回 ?
OrdinaryHasProperty （O, P）。
10.1.7.1 OrdinaryHasProperty（O, P）
抽象操作 OrdinaryHasProperty 接受参数 O（一个对象）和 P（一个
- 令 hasOwn 为 ? O.[[GetOwnProperty]](P)。
- 如果 hasOwn 不是
undefined ，返回true 。 - 令 parent 为 ? O.[[GetPrototypeOf]]()。
- 如果 parent 不是
null ，则- 返回 ? parent.[[HasProperty]](P)。
- 返回
false 。
10.1.8 [[Get]] ( P, Receiver )
[[Get]] 内部方法用于一个
- 返回 ?
OrdinaryGet (O, P, Receiver).
10.1.8.1 OrdinaryGet ( O, P, Receiver )
抽象操作 OrdinaryGet 接受参数 O（一个对象）、P（一个
- 让 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)。
10.1.9 [[Set]] ( P, V, Receiver )
普通对象（
- 返回 ?
OrdinarySet (O, P, V, Receiver)。
10.1.9.1 OrdinarySet ( O, P, V, Receiver )
抽象操作 OrdinarySet 接受四个参数：O（对象），P（属性键），V（ECMAScript 语言值），和 Receiver（ECMAScript 语言值），并返回一个完成记录，可能是包含布尔值的正常完成记录，也可能是抛出异常的完成记录。调用时执行以下步骤：
- 让 ownDesc 为 ? O.[[GetOwnProperty]](P)。
- 返回 ?
OrdinarySetWithOwnDescriptor (O, P, V, Receiver, ownDesc)。
10.1.9.2 OrdinarySetWithOwnDescriptor ( O, P, V, Receiver, ownDesc )
抽象操作 OrdinarySetWithOwnDescriptor 接受五个参数：O（对象），P（属性键），V（ECMAScript
语言值），Receiver（ECMAScript 语言值），和 ownDesc（属性描述符或
- 如果 ownDesc 为
undefined ，则：- 让 parent 为 ? O.[[GetPrototypeOf]]()。
- 如果 parent 不为
null ，则：- 返回 ? parent.[[Set]](P, V, Receiver)。
- 否则：
- 将 ownDesc 设置为属性描述符 {[[Value]]:
undefined , [[Writable]]:true , [[Enumerable]]:true , [[Configurable]]:true }。
- 将 ownDesc 设置为属性描述符 {[[Value]]:
- 如果
IsDataDescriptor (ownDesc) 为true ，则：- 如果 ownDesc.[[Writable]] 为
false ，返回false 。 - 如果 Receiver
不是一个对象 ，返回false 。 - 让 existingDescriptor 为 ? Receiver.[[GetOwnProperty]](P)。
- 如果 existingDescriptor 不为
undefined ，则：- 如果
IsAccessorDescriptor (existingDescriptor) 为true ，返回false 。 - 如果 existingDescriptor.[[Writable]] 为
false ，返回false 。 - 让 valueDesc 为属性描述符 {[[Value]]: V}。
- 返回 ? Receiver.[[DefineOwnProperty]](P, valueDesc)。
- 如果
- 否则：
Assert : Receiver 当前没有属性 P。- 返回 ?
CreateDataProperty (Receiver, P, V)。
- 如果 ownDesc.[[Writable]] 为
Assert :IsAccessorDescriptor (ownDesc) 为true 。- 让 setter 为 ownDesc.[[Set]]。
- 如果 setter 为
undefined ，返回false 。 - 执行 ?
Call (setter, Receiver, «V»)。 - 返回
true 。
10.1.10 [[Delete]] ( P )
普通对象（
- 返回 ?
OrdinaryDelete (O, P)。
10.1.10.1 OrdinaryDelete ( O, P )
抽象操作 OrdinaryDelete 接受两个参数：O（对象）和 P（
- 让 desc 为 ? O.[[GetOwnProperty]](P)。
- 如果 desc 为
undefined ，返回true 。 - 如果 desc.[[Configurable]] 为
true ，则：- 从 O 中删除名称为 P 的自身属性。
- 返回
true 。
- 返回
false 。
10.1.11 [[OwnPropertyKeys]] ( )
普通对象（
- 返回
OrdinaryOwnPropertyKeys (O)。
10.1.11.1 OrdinaryOwnPropertyKeys ( O )
抽象操作 OrdinaryOwnPropertyKeys 接受一个参数 O（对象），并返回一个包含
10.1.12 OrdinaryObjectCreate ( proto [ , additionalInternalSlotsList ] )
抽象操作 OrdinaryObjectCreate 接受参数 proto（一个对象或
- 让 internalSlotsList 为 « [[Prototype]], [[Extensible]] »。
- 如果 additionalInternalSlotsList 存在，则将
internalSlotsList 设置为
列表连接 internalSlotsList 和 additionalInternalSlotsList 的结果。 - 让 O 为
MakeBasicObject (internalSlotsList)。 - 将 O.[[Prototype]] 设置为 proto。
- 返回 O。
尽管 OrdinaryObjectCreate 仅调用
10.1.13 OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] )
抽象操作 OrdinaryCreateFromConstructor 接受参数 constructor（一个
断言 : intrinsicDefaultProto 是本规范定义的内建对象的名称。对应的对象必须是一个内建对象，旨在作为对象的 [[Prototype]] 值。- 让 proto 为 ?
GetPrototypeFromConstructor (constructor, intrinsicDefaultProto)。 - 如果 internalSlotsList 存在，令 slotsList 为 internalSlotsList。
- 否则，令 slotsList 为一个新的空
列表 。 - 返回
OrdinaryObjectCreate (proto, slotsList)。
10.1.14 GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto )
抽象操作 GetPrototypeFromConstructor 接受参数 constructor（一个
断言 : intrinsicDefaultProto 是本规范定义的内建对象的名称。对应的对象必须是一个内建对象，旨在作为对象的 [[Prototype]] 值。- 令 proto 为 ?
Get (constructor,"prototype" )。 - 如果 proto
不是一个对象 ，则- 令 realm 为 ?
GetFunctionRealm (constructor)。 - 将 proto 设置为 realm 的名为 intrinsicDefaultProto 的内建对象。
- 令 realm 为 ?
- 返回 proto。
10.1.15 RequireInternalSlot ( O, internalSlot )
抽象操作 RequireInternalSlot 接受参数 O（一个
- 如果 O
不是一个对象 ，则抛出一个TypeError 异常。 - 如果 O 不具有一个 internalSlot 内部槽，则抛出一个
TypeError 异常。 - 返回
unused 。
10.2 ECMAScript 函数对象
ECMAScript
除了 [[Extensible]] 和 [[Prototype]] 外，ECMAScript
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[Environment]] |
一个 |
函数封闭的 |
| [[PrivateEnvironment]] |
一个 |
函数封闭的 |
| [[FormalParameters]] |
一个 |
定义函数正式参数列表的源文本的根解析节点。 |
| [[ECMAScriptCode]] |
一个 |
定义函数主体的源文本的根解析节点。 |
| [[ConstructorKind]] |
|
函数是否是派生类 |
| [[Realm]] |
一个 |
函数创建的 |
| [[ScriptOrModule]] |
一个 |
函数创建的脚本或模块。 |
| [[ThisMode]] |
|
定义 this 引用在函数的正式参数和代码体内如何被解释。this
指向词法上封闭函数的 |
| [[Strict]] | 一个布尔值 |
如果这是一个 |
| [[HomeObject]] | 一个对象 |
如果函数使用了 super，这是提供 [[GetPrototypeOf]] 的对象，从而开始
super 属性的查找。
|
| [[SourceText]] | 一系列 Unicode 码点 |
定义函数的 |
| [[Fields]] |
一个 |
如果函数是一个类，则这是一个列表，表示类的非静态字段及其对应的初始化器。 |
| [[PrivateMethods]] |
一个 |
如果函数是一个类，则这是一个列表，表示类的非静态私有方法和访问器。 |
| [[ClassFieldInitializerName]] |
一个字符串、一个符号、一个 |
如果函数作为类字段的初始化器创建，则用于 |
| [[IsClassConstructor]] | 一个布尔值 |
指示函数是否是一个类 |
所有 ECMAScript
10.2.1 [[Call]] ( thisArgument, argumentsList )
ECMAScript
- 让 callerContext 为
当前执行上下文 。 - 让 calleeContext 为
PrepareForOrdinaryCall (F,undefined )。 断言 : calleeContext 现在是当前执行上下文 。- 如果 F.[[IsClassConstructor]] 为
true ，则- 让 error 为一个新创建的
TypeError 对象。 - 注意：error 是在 calleeContext 中创建的，使用
F 关联的
领域记录 。 - 从
执行上下文栈 中移除 calleeContext，并将 callerContext 恢复为当前执行上下文 。 - 返回
ThrowCompletion (error)。
- 让 error 为一个新创建的
- 执行
OrdinaryCallBindThis (F, calleeContext, thisArgument)。 - 让 result 为
Completion (OrdinaryCallEvaluateBody (F, argumentsList))。 - 从
执行上下文栈 中移除 calleeContext，并将 callerContext 恢复为当前执行上下文 。 - 如果 result 是一个
返回完成 ，返回 result.[[Value]]。 ReturnIfAbrupt (result)。- 返回
undefined 。
10.2.1.1 PrepareForOrdinaryCall ( F, newTarget )
抽象操作 PrepareForOrdinaryCall 接受参数 F（一个 ECMAScript
- 让 callerContext 为
当前执行上下文 。 - 让 calleeContext 为一个新的
ECMAScript 代码执行上下文 。 - 将 calleeContext 的函数设置为 F。
- 让 calleeRealm 为 F.[[Realm]]。
- 将 calleeContext 的
领域 设置为 calleeRealm。 - 将 calleeContext 的 ScriptOrModule 设置为 F.[[ScriptOrModule]]。
- 让 localEnv 为
NewFunctionEnvironment (F, newTarget)。 - 将 calleeContext 的词法环境设置为 localEnv。
- 将 calleeContext 的变量环境设置为 localEnv。
- 将 calleeContext 的私有环境设置为 F.[[PrivateEnvironment]]。
- 如果 callerContext 尚未被挂起，则挂起 callerContext。
- 将 calleeContext 推入
执行上下文栈 ；calleeContext 现在是当前执行上下文 。 - 注意：此后产生的任何异常对象都与 calleeRealm 关联。
- 返回 calleeContext。
10.2.1.2 OrdinaryCallBindThis ( F, calleeContext, thisArgument )
抽象操作 OrdinaryCallBindThis 接受参数 F（一个 ECMAScript
- 让 thisMode 为 F.[[ThisMode]]。
- 如果 thisMode 是
lexical ，则返回unused 。 - 让 calleeRealm 为 F.[[Realm]]。
- 让 localEnv 为 calleeContext 的词法环境。
- 如果 thisMode 是
strict ，则：- 让 thisValue 为 thisArgument。
- 否则：
Assert : localEnv 是一个函数环境记录 。Assert : 下一步不会返回突发完成 ，因为 localEnv.[[ThisBindingStatus]] 不是initialized 。- 执行 ! localEnv.BindThisValue(thisValue)。
- 返回
unused 。
10.2.1.3 运行时语义：EvaluateBody
语法驱动操作
- 返回 ?
EvaluateFunctionBody 的FunctionBody ，参数为 functionObject 和 argumentsList。
- 返回 ?
EvaluateConciseBody 的ConciseBody ，参数为 functionObject 和 argumentsList。
- 返回 ?
EvaluateGeneratorBody 的GeneratorBody ，参数为 functionObject 和 argumentsList。
- 返回 ?
EvaluateAsyncGeneratorBody 的AsyncGeneratorBody ，参数为 functionObject 和 argumentsList。
- 返回 ?
EvaluateAsyncFunctionBody 的AsyncFunctionBody ，参数为 functionObject 和 argumentsList。
- 返回 ?
EvaluateAsyncConciseBody 的AsyncConciseBody ，参数为 functionObject 和 argumentsList。
断言 ：argumentsList 为空。断言 ：functionObject.[[ClassFieldInitializerName]] 不为空。- 如果
IsAnonymousFunctionDefinition (AssignmentExpression ) 为true ，则- 令 value 为 ?
NamedEvaluation 的Initializer ，参数为 functionObject.[[ClassFieldInitializerName]]。
- 令 value 为 ?
- 否则，
- 令 rhs 为 ?
Evaluation 的AssignmentExpression 。 - 令 value 为 ?
GetValue (rhs)。
- 令 rhs 为 ?
- 返回
完成记录 { [[Type]]:return , [[Value]]: value, [[Target]]:empty }。
尽管字段初始化器构成函数边界，调用
断言 ：argumentsList 为空。- 返回 ?
EvaluateClassStaticBlockBody 的ClassStaticBlockBody ，参数为 functionObject。
10.2.1.4 OrdinaryCallEvaluateBody ( F, argumentsList )
抽象操作 OrdinaryCallEvaluateBody 接受两个参数：F（一个 ECMAScript
- 返回 ?
EvaluateBody 的 F.[[ECMAScriptCode]]，参数为 F 和 argumentsList。
10.2.2 [[Construct]] ( argumentsList, newTarget )
ECMAScript
- 令 callerContext 为当前
运行执行上下文 。 - 令 kind 为 F.[[ConstructorKind]]。
- 如果 kind 为
base ，则- 令 thisArgument 为 ?
OrdinaryCreateFromConstructor (newTarget,"%Object.prototype%" )。
- 令 thisArgument 为 ?
- 令 calleeContext 为
PrepareForOrdinaryCall (F, newTarget)。 Assert : calleeContext 现在是运行执行上下文 。- 如果 kind 为
base ，则- 执行
OrdinaryCallBindThis (F, calleeContext, thisArgument)。 - 令 initializeResult 为
Completion (InitializeInstanceElements (thisArgument, F))。 - 如果 initializeResult 是
突发完成记录 ，则
- 执行
- 令 constructorEnv 为 calleeContext 的 LexicalEnvironment。
- 令 result 为
Completion (OrdinaryCallEvaluateBody (F, argumentsList))。 - 从
执行上下文栈 中移除 calleeContext，并将 callerContext 恢复为运行执行上下文 。 - 如果 result 是
返回完成记录 ，则- 如果 result.[[Value]]
是一个对象 ，返回 result.[[Value]]。 - 如果 kind 为
base ，返回 thisArgument。 - 如果 result.[[Value]] 不是
undefined ，则抛出一个TypeError 异常。
- 如果 result.[[Value]]
- 否则,
ReturnIfAbrupt (result)。
- 令 thisBinding 为 ? constructorEnv.GetThisBinding()。
Assert : thisBinding是一个对象 。- 返回 thisBinding。
10.2.3 OrdinaryFunctionCreate ( functionPrototype, sourceText, ParameterList, Body, thisMode, env, privateEnv )
抽象操作 OrdinaryFunctionCreate 接受以下参数：functionPrototype（一个对象），
sourceText（一系列 Unicode 代码点），ParameterList（一个
- 令 internalSlotsList 为
表 30 中列出的内部槽。 - 令 F 为
OrdinaryObjectCreate (functionPrototype, internalSlotsList)。 - 将 F.[[Call]] 设置为
10.2.1 中指定的定义。 - 将 F.[[SourceText]] 设置为 sourceText。
- 将 F.[[FormalParameters]] 设置为 ParameterList。
- 将 F.[[ECMAScriptCode]] 设置为 Body。
- 如果
source text matched by Body 是严格模式代码 ，则令 Strict 为true ；否则令 Strict 为false 。 - 将 F.[[Strict]] 设置为 Strict。
- 如果 thisMode 是
lexical-this ，则将 F.[[ThisMode]] 设置为lexical 。 - 否则如果 Strict 为
true ，则将 F.[[ThisMode]] 设置为strict 。 - 否则，将 F.[[ThisMode]] 设置为
global 。 - 将 F.[[IsClassConstructor]] 设置为
false 。 - 将 F.[[Environment]] 设置为 env。
- 将 F.[[PrivateEnvironment]] 设置为 privateEnv。
- 将 F.[[ScriptOrModule]] 设置为
GetActiveScriptOrModule ()。 - 将 F.[[Realm]] 设置为
当前 Realm 记录 。 - 将 F.[[HomeObject]] 设置为
undefined 。 - 将 F.[[Fields]] 设置为一个新的空的
列表 。 - 将 F.[[PrivateMethods]]
设置为一个新的空的
列表 。 - 将 F.[[ClassFieldInitializerName]] 设置为
empty 。 - 令 len 为
ParameterList 的期望参数数量。 - 执行
SetFunctionLength (F, len)。 - 返回 F。
10.2.4 AddRestrictedFunctionProperties ( F, realm )
抽象操作 AddRestrictedFunctionProperties 接受两个参数：F（一个
断言 : realm.[[Intrinsics]].[[%ThrowTypeError% ]] 存在 并已初始化。- 令 thrower 为 realm.[[Intrinsics]].[[
%ThrowTypeError% ]]。 - 执行 !
DefinePropertyOrThrow (F,"caller" , 属性描述符 { [[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]:false , [[Configurable]]:true }). - 执行 !
DefinePropertyOrThrow (F,"arguments" , 属性描述符 { [[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]:false , [[Configurable]]:true }). - 返回
unused 。
10.2.4.1 %ThrowTypeError% ( )
这个函数是 %ThrowTypeError% 内在对象。
它是一个匿名的内置
当调用时，它执行以下步骤：
- 抛出一个
TypeError 异常。
这个函数的 [[Extensible]] 内部槽的值为
这个函数的
这个函数的
10.2.5 MakeConstructor ( F [ , writablePrototype [ , prototype ] ] )
抽象操作 MakeConstructor 接受一个参数 F（一个 ECMAScript
- 如果 F 是一个 ECMAScript
函数对象 ， 则断言 :IsConstructor (F) 为false 。断言 : F 是一个可扩展的对象，且没有一个名为"prototype" 的自身属性。- 将 F.[[Construct]] 设置为
在
10.2.2 中指定的定义。
- 否则，
- 将 F.[[Construct]] 设置为
在
10.3.2 中指定的定义。
- 将 F.[[Construct]] 设置为
在
- 将 F.[[ConstructorKind]] 设置为
base 。 - 如果 writablePrototype 不存在，将 writablePrototype
设置为
true 。 - 如果 prototype 不存在，则
- 将 prototype 设置为
OrdinaryObjectCreate (%Object.prototype% )。 - 执行 !
DefinePropertyOrThrow (prototype,"constructor" , 属性描述符 { [[Value]]: F, [[Writable]]: writablePrototype, [[Enumerable]]:false , [[Configurable]]:true }).
- 将 prototype 设置为
- 执行 !
DefinePropertyOrThrow (F,"prototype" , 属性描述符 { [[Value]]: prototype, [[Writable]]: writablePrototype, [[Enumerable]]:false , [[Configurable]]:false }). - 返回
unused 。
10.2.6 MakeClassConstructor ( F )
抽象操作 MakeClassConstructor 接受一个参数 F（一个 ECMAScript
断言 : F.[[IsClassConstructor]] 为false 。- 将 F.[[IsClassConstructor]] 设置为
true 。 - 返回
unused 。
10.2.7 MakeMethod ( F, homeObject )
抽象操作 MakeMethod 接受参数 F（一个 ECMAScript
- 将 F.[[HomeObject]] 设置为 homeObject。
- 返回
unused 。
10.2.8 DefineMethodProperty ( homeObject, key, closure, enumerable )
抽象操作 DefineMethodProperty 接受四个参数：homeObject（一个对象），key（一个
断言 : homeObject 是一个普通的、可扩展的对象。- 如果 key 是一个
私有名称 ，则- 返回
PrivateElement { [[Key]]: key, [[Kind]]:method , [[Value]]: closure }。
- 返回
- 否则,
- 让 desc 为 PropertyDescriptor { [[Value]]: closure, [[Writable]]:
true , [[Enumerable]]: enumerable, [[Configurable]]:true }。 - 执行 ?
DefinePropertyOrThrow (homeObject, key, desc)。 - 注：
DefinePropertyOrThrow 仅在尝试定义一个类静态方法时，如果 key 为"prototype" ，才会返回突然完成 。 - 返回
unused 。
- 让 desc 为 PropertyDescriptor { [[Value]]: closure, [[Writable]]:
10.2.9 SetFunctionName ( F, name [ , prefix ] )
抽象操作 SetFunctionName 接受两个必需参数和一个可选参数：F（一个
断言 : F 是一个可扩展的对象，并且没有"name" 自有属性。- 如果 name
是一个符号 ，则- 让 description 为 name 的 [[Description]] 值。
- 如果 description 为
undefined ， 将 name 设置为空字符串。 - 否则，将 name 设置为
字符串连接 ， 包含"[" 、description 和"]" 。
- 否则，如果 name 是一个
私有名称 ，则- 将 name 设置为 name 的 [[Description]]。
- 如果 F 有一个 [[InitialName]]
内部槽，则
- 将 F.[[InitialName]] 设置为 name。
- 如果 prefix 存在，则
- 将 name 设置为
字符串连接 ， 包含 prefix、代码单元 0x0020（空格）和 name。 - 如果 F 有一个 [[InitialName]]
内部槽，则
- 可选地，将 F.[[InitialName]] 设置为 name。
- 将 name 设置为
- 执行 !
DefinePropertyOrThrow (F,"name" ，属性描述符 { [[Value]]: name, [[Writable]]:false ，[[Enumerable]]:false ，[[Configurable]]:true }). - 返回
unused 。
10.2.10 SetFunctionLength ( F, length )
抽象操作 SetFunctionLength 接受两个参数：F（一个
断言 : F 是一个可扩展的对象，并且没有"length" 自有属性。- 执行 !
DefinePropertyOrThrow (F,"length" ，属性描述符 { [[Value]]:𝔽 (length), [[Writable]]:false ，[[Enumerable]]:false ，[[Configurable]]:true }). - 返回
unused 。
10.2.11 FunctionDeclarationInstantiation ( func, argumentsList )
抽象操作 FunctionDeclarationInstantiation 接受两个参数：func（一个 ECMAScript
它在调用时执行以下步骤：
- 让 calleeContext 是
正在执行的执行上下文 。 - 让 code 是 func.[[ECMAScriptCode]]。
- 让 strict 是 func.[[Strict]]。
- 让 formals 是 func.[[FormalParameters]]。
- 让 parameterNames 是
绑定名称 的 formals。 - 如果 parameterNames 有任何重复项，令
hasDuplicates 为
true 。否则，令 hasDuplicates 为false 。 - 让 simpleParameterList 是
简单参数列表 的 formals。 - 让 hasParameterExpressions 是
包含表达式 的 formals。 - 让 varNames 是
变量声明名称 的 code。 - 让 varDeclarations 是
变量作用域声明 的 code。 - 让 lexicalNames 是
词法声明名称 的 code。 - 让 functionNames 是一个新的空的
列表 。 - 让 functionsToInitialize 是一个新的空的
列表 。 - 对于 varDeclarations 的每一个元素 d，
按照反向
列表 顺序，执行以下操作- 如果 d 既不是
变量声明 也不是ForBinding 也不是BindingIdentifier ，则
- 如果 d 既不是
- 让 argumentsObjectNeeded 为
true 。 - 如果 func.[[ThisMode]] 是
lexical ，则- 注: 箭头函数永远没有 arguments 对象。
- 将 argumentsObjectNeeded 设置为
false 。
- 否则，如果 parameterNames 包含
"arguments" ，则- 将 argumentsObjectNeeded 设置为
false 。
- 将 argumentsObjectNeeded 设置为
- 否则，如果 hasParameterExpressions 为
false ，则- 如果 functionNames 包含
"arguments" 或 lexicalNames 包含"arguments" ，则- 将 argumentsObjectNeeded 设置为
false 。
- 将 argumentsObjectNeeded 设置为
- 如果 functionNames 包含
- 如果 strict 为
true 或 hasParameterExpressions 为false ，则 - 否则,
- 注: 需要一个单独的
环境记录 以确保由直接 eval 调用在形式参数列表中创建的绑定在参数声明的环境之外。 - 让 calleeEnv 为 calleeContext 的 词法环境。
- 让 env 为
NewDeclarativeEnvironment (calleeEnv)。 断言 : calleeContext 的变量环境是 calleeEnv。- 将 calleeContext 的词法环境设置为 env。
- 注: 需要一个单独的
- 对于 parameterNames 中的每个字符串 paramName，执行
- 如果 argumentsObjectNeeded 为
true ，则- 如果 strict 为
true 或 simpleParameterList 为false ，则- 让 ao 为
CreateUnmappedArgumentsObject (argumentsList)。
- 让 ao 为
- 否则，
- 注: 映射的参数对象仅在
非严格模式函数 中提供，并且这些函数没有剩余参数、参数默认值初始化器或任何解构参数。 - 让 ao 为
CreateMappedArgumentsObject (func, formals, argumentsList, env)。
- 注: 映射的参数对象仅在
- 如果 strict 为
true ，则 - 否则，
- 执行
! env.CreateMutableBinding(
"arguments" ,false )。
- 执行
! env.CreateMutableBinding(
- 执行
! env.InitializeBinding(
"arguments" , ao)。 - 让 parameterBindings 为
list-concatenation 的 parameterNames 和 «"arguments" »。
- 如果 strict 为
- 否则，
- 让 parameterBindings 为 parameterNames。
- 让 iteratorRecord 为
CreateListIteratorRecord (argumentsList)。 - 如果 hasDuplicates 为
true ，则- 执行 ?
IteratorBindingInitialization 的 formals，使用参数 iteratorRecord 和undefined 。
- 执行 ?
- 否则，
- 执行 ?
IteratorBindingInitialization 的 formals，使用参数 iteratorRecord 和 env。
- 执行 ?
- 如果 hasParameterExpressions 为
false ，则 - 否则，
- 注: 需要一个单独的
环境记录 来确保在形式参数列表中创建的闭包无法访问函数体中的声明。 - 让 varEnv 为
NewDeclarativeEnvironment (env)。 - 将 calleeContext 的 VariableEnvironment 设置为 varEnv。
- 让 instantiatedVarNames 为一个新的空
列表 。 - 对于 varNames 中的每个元素 n，执行
- 如果 instantiatedVarNames 不包含 n，则
- 将 n 添加到 instantiatedVarNames。
- 执行
! varEnv.CreateMutableBinding(n,
false )。 - 如果 parameterBindings 不包含 n，或
functionNames 包含 n，则
- 让 initialValue 为
undefined 。
- 让 initialValue 为
- 否则，
- 让 initialValue 为
! env.GetBindingValue(n,
false )。
- 让 initialValue 为
! env.GetBindingValue(n,
- 执行 ! varEnv.InitializeBinding(n, initialValue)。
- 注: 与形式参数同名的变量最初具有与相应初始化参数相同的值。
- 如果 instantiatedVarNames 不包含 n，则
- 注: 需要一个单独的
- 注: 附录
B.3.2.1 在此处添加了额外的步骤。 - 如果 strict 为
false ，则 - 否则，
- 让 lexEnv 为 varEnv。
- 将 calleeContext 的 LexicalEnvironment 设置为 lexEnv。
- 让 lexDeclarations 为
词法作用域声明 的 code。 - 对于 lexDeclarations 中的每个元素 d，执行
- 让 privateEnv 为 calleeContext 的 PrivateEnvironment。
- 对于 functionsToInitialize 中的每个
解析节点 f，执行 - 返回
unused 。
10.3 内置函数对象
内置的
除了每个
内置
内置
内置
实现可以提供本规范中未定义的额外内置
10.3.1 [[Call]] ( thisArgument, argumentsList )
内置
- 返回 ?
BuiltinCallOrConstruct (F, thisArgument, argumentsList,undefined ).
10.3.2 [[Construct]] ( argumentsList, newTarget )
内置
- 返回 ?
BuiltinCallOrConstruct (F,uninitialized , argumentsList, newTarget).
10.3.3 BuiltinCallOrConstruct ( F, thisArgument, argumentsList, newTarget )
抽象操作 BuiltinCallOrConstruct 接受以下参数：F（一个内置的
- 让 callerContext 为当前
运行中的执行上下文 。 - 如果 callerContext 尚未被挂起，则挂起 callerContext。
- 让 calleeContext 为一个新的
执行上下文 。 - 将 calleeContext 的函数设置为 F。
- 让 calleeRealm 为 F.[[Realm]]。
- 将 calleeContext 的
Realm 设置为 calleeRealm。 - 将 calleeContext 的 ScriptOrModule 设置为
null 。 - 执行对 calleeContext 的任何必要的
实现定义 初始化。 - 将 calleeContext 推入
执行上下文栈 ；calleeContext 现在是运行中的执行上下文 。 - 让 result 为
完成记录 ，即以符合 F 规范的方式评估 F 的结果。如果 thisArgument 为uninitialized ，则this 的值为未初始化；否则，thisArgument 提供this 值。argumentsList 提供命名参数。newTarget 提供 NewTarget 值。 - 注：如果 F 在本文件中定义，“F 的规范”是通过算法步骤或其他方式指定的行为。
- 从
执行上下文栈 中移除 calleeContext，并将 callerContext 恢复为运行中的执行上下文 。 - 返回 ? result。
当 calleeContext 从
10.3.4 CreateBuiltinFunction ( behaviour, length, name, additionalInternalSlotsList [ , realm [ , prototype [ , prefix ] ] ] )
抽象操作 CreateBuiltinFunction 接受以下参数：behaviour（一个
- 如果 realm 不存在，则将 realm 设置为
当前 Realm 记录 。 - 如果 prototype 不存在，则将 prototype 设置为
realm.[[Intrinsics]].[[
%Function.prototype% ]]。 - 让 internalSlotsList 为一个
列表 ，包含所有10.3 对于即将创建的内置函数对象 所需的内部槽的名称。 - 将 additionalInternalSlotsList 的元素附加到 internalSlotsList。
- 让 func 为一个新的内置
函数对象 ，当调用时，它会根据 behaviour 的描述，使用提供的参数作为 behaviour 指定的相应参数的值。新的函数对象 具有名称为 internalSlotsList 元素的内部槽，并具有一个 [[InitialName]] 内部槽。 - 将 func.[[Prototype]] 设置为 prototype。
- 将 func.[[Extensible]] 设置为
true 。 - 将 func.[[Realm]] 设置为 realm。
- 将 func.[[InitialName]] 设置为
null 。 - 执行
SetFunctionLength (func, length)。 - 如果 prefix 不存在，则
- 执行
SetFunctionName (func, name)。
- 执行
- 否则，
- 执行
SetFunctionName (func, name, prefix)。
- 执行
- 返回 func。
本规范中定义的每个内置函数都是通过调用 CreateBuiltinFunction 抽象操作创建的。
10.4 内置的异域对象内部方法和槽
本规范定义了几种内置的
10.4.1 绑定函数异域对象
一个对象是一个 绑定函数异域对象，如果它的 [[Call]] 和（如果适用的话）[[Construct]] 内部方法使用以下实现，并且它的其他基本内部方法使用在
| 内部槽 | 类型 | 描述 |
|---|---|---|
| [[BoundTargetFunction]] | 可调用的对象 |
封装的 |
| [[BoundThis]] |
一个 |
在调用封装的函数时始终传递的 |
| [[BoundArguments]] |
一个 |
一个值的列表，其元素作为对封装函数的任何调用的第一个参数。 |
10.4.1.1 [[Call]] ( thisArgument, argumentsList )
[[Call]] 内部方法用于一个
10.4.1.2 [[Construct]] ( argumentsList, newTarget )
[[Construct]] 内部方法用于一个
- 令 target 为 F.[[BoundTargetFunction]]。
断言 :IsConstructor (target) 为true 。- 令 boundArgs 为 F.[[BoundArguments]]。
- 令 args 为
列表连接 的 boundArgs 和 argumentsList。 - 如果
SameValue (F, newTarget) 为true ，则将 newTarget 设置为 target。 - 返回 ?
Construct (target, args, newTarget)。
10.4.1.3 BoundFunctionCreate ( targetFunction, boundThis, boundArgs )
抽象操作 BoundFunctionCreate 接受参数 targetFunction（一个
- 令 proto 为 ? targetFunction.[[GetPrototypeOf]]()。
- 令 internalSlotsList 为 «[[Prototype]]，[[Extensible]]» 和在
表 31 中列出的内部槽的列表连接 。 - 令 obj 为
MakeBasicObject (internalSlotsList)。 - 将 obj.[[Prototype]] 设置为 proto。
- 将 obj.[[Call]] 设置为在
10.4.1.1 中描述的内容。 - 如果
IsConstructor (targetFunction) 为true ，则：- 将 obj.[[Construct]] 设置为在
10.4.1.2 中描述的内容。
- 将 obj.[[Construct]] 设置为在
- 将 obj.[[BoundTargetFunction]] 设置为 targetFunction。
- 将 obj.[[BoundThis]] 设置为 boundThis。
- 将 obj.[[BoundArguments]] 设置为 boundArgs。
- 返回 obj。
10.4.2 数组异域对象
数组是一个
一个对象是一个 数组异域对象（或简称为数组），如果它的 [[DefineOwnProperty]]
内部方法使用以下实现，并且它的其他基本内部方法使用在
10.4.2.1 [[DefineOwnProperty]] ( P, Desc )
[[DefineOwnProperty]] 内部方法在
- 如果 P 是
"length" ，则- 返回 ?
ArraySetLength (A, Desc).
- 返回 ?
- 否则，如果 P 是一个
数组索引 ，则- 让 lengthDesc 为
OrdinaryGetOwnProperty (A,"length" ). Assert :IsDataDescriptor (lengthDesc) 是true 。Assert : lengthDesc.[[Configurable]] 是false 。- 让 length 为 lengthDesc.[[Value]]。
Assert : length 是一个非负的整数 。- 让 index 为 !
ToUint32 (P)。 - 如果 index ≥ length 且
lengthDesc.[[Writable]] 是
false ，则返回false 。 - 让 succeeded 为 !
OrdinaryDefineOwnProperty (A, P, Desc)。 - 如果 succeeded 是
false ，则返回false 。 - 如果 index ≥ length，则
- 将 lengthDesc.[[Value]] 设置为 index +
1 𝔽。 - 将 succeeded 设置为 !
OrdinaryDefineOwnProperty (A,"length" , lengthDesc)。 Assert : succeeded 是true 。
- 将 lengthDesc.[[Value]] 设置为 index +
- 返回
true 。
- 让 lengthDesc 为
- 返回 ?
OrdinaryDefineOwnProperty (A, P, Desc)。
10.4.2.2 ArrayCreate ( length [ , proto ] )
抽象操作 ArrayCreate 接受参数 length（一个非负的
- 如果 length > 232 - 1，抛出一个
RangeError 异常。 - 如果 proto 不存在，将 proto 设置为
%Array.prototype% 。 - 让 A 为
MakeBasicObject (« [[Prototype]], [[Extensible]] »)。 - 将 A.[[Prototype]] 设置为 proto。
- 将 A.[[DefineOwnProperty]]
设置为在
10.4.2.1 中规定的方式。 - 执行 !
OrdinaryDefineOwnProperty (A,"length" , 属性描述符 { [[Value]]:𝔽 (length), [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }）。 - 返回 A。
10.4.2.3 ArraySpeciesCreate ( originalArray, length )
抽象操作 ArraySpeciesCreate 接受两个参数：originalArray（一个对象）和 length（一个非负的
- 让 isArray 为 ?
IsArray (originalArray)。 - 如果 isArray 为
false ，返回 ?ArrayCreate (length)。 - 让 C 为 ?
Get (originalArray,"constructor" )。 - 如果
IsConstructor (C) 为true ，则- 让 thisRealm 为
当前 Realm 记录 。 - 让 realmC 为 ?
GetFunctionRealm (C)。 - 如果 thisRealm 和 realmC 不是同一个
Realm 记录 ，则
- 让 thisRealm 为
- 如果 C
是一个对象 ，则 - 如果 C 为
undefined ，返回 ?ArrayCreate (length)。 - 如果
IsConstructor (C) 为false ，抛出一个TypeError 异常。 - 返回 ?
Construct (C, «𝔽 (length) »)。
10.4.2.4 ArraySetLength ( A, Desc )
抽象操作 ArraySetLength 接受两个参数：A（一个数组）和 Desc（一个
- 如果 Desc 没有 [[Value]] 字段，则
- 返回 !
OrdinaryDefineOwnProperty (A,"length" , Desc).
- 返回 !
- 让 newLenDesc 为 Desc 的一个副本。
- 让 newLen 为
?
ToUint32 (Desc.[[Value]])。 - 让 numberLen 为
?
ToNumber (Desc.[[Value]])。 - 如果
SameValueZero (newLen, numberLen) 为false ，则抛出一个RangeError 异常。 - 将 newLenDesc.[[Value]] 设置为 newLen。
- 让 oldLenDesc 为 ?
OrdinaryGetOwnProperty (A,"length" )。 Assert ：IsDataDescriptor (oldLenDesc) 为true 。Assert ：oldLenDesc.[[Configurable]] 为false 。- 让 oldLen 为 oldLenDesc.[[Value]]。
- 如果 newLen ≥ oldLen，则
- 返回 !
OrdinaryDefineOwnProperty (A,"length" , newLenDesc).
- 返回 !
- 如果 oldLenDesc.[[Writable]] 为
false ，返回false 。 - 如果 newLenDesc 没有 [[Writable]] 字段，或者 newLenDesc.[[Writable]] 为
true ，则- 让 newWritable 为
true 。
- 让 newWritable 为
- 否则,
- 注意：将 [[Writable]] 属性设置为
false 是延迟的，以防某些元素无法被删除。 - 让 newWritable 为
false 。 - 将 newLenDesc.[[Writable]]
设置为
true 。
- 注意：将 [[Writable]] 属性设置为
- 让 succeeded 为 !
OrdinaryDefineOwnProperty (A,"length" , newLenDesc)。 - 如果 succeeded 为
false ，则返回false 。 - 对于 A 中每个拥有的
属性键 P，其中 P 是一个数组索引 ，并且 !ToUint32 (P) ≥ newLen，按降序数字索引顺序，执行- 让 deleteSucceeded 为 ! A.[[Delete]](P)。
- 如果 deleteSucceeded 为
false ，则- 将 newLenDesc.[[Value]] 设置为 !
ToUint32 (P) +1 𝔽。 - 如果 newWritable 为
false ，则将 newLenDesc.[[Writable]] 设置为false 。 - 执行 !
OrdinaryDefineOwnProperty (A,"length" , newLenDesc)。 - 返回
false 。
- 将 newLenDesc.[[Value]] 设置为 !
- 如果 newWritable 为
false ，则- 将 succeeded 设置为 !
OrdinaryDefineOwnProperty (A,"length" , 属性描述符 { [[Writable]]：false } )。 Assert ：succeeded 为true 。
- 将 succeeded 设置为 !
- 返回
true 。
10.4.3 字符串异域对象
字符串对象是一个封装了字符串值的
如果一个对象的 [[GetOwnProperty]]、[[DefineOwnProperty]] 和 [[OwnPropertyKeys]] 内部方法使用以下实现，并且它的其他基本内部方法使用在
10.4.3.1 [[GetOwnProperty]] ( P )
一个
- 让 desc 为
OrdinaryGetOwnProperty (S, P). - 如果 desc 不为
undefined ，则返回 desc。 - 返回
StringGetOwnProperty (S, P).
10.4.3.2 [[DefineOwnProperty]] ( P, Desc )
一个
- 让 stringDesc 为
StringGetOwnProperty (S, P). - 如果 stringDesc 不为
undefined ，则：- 让 extensible 为 S.[[Extensible]]。
- 返回
IsCompatiblePropertyDescriptor (extensible, Desc, stringDesc).
- 返回 !
OrdinaryDefineOwnProperty (S, P, Desc).
10.4.3.3 [[OwnPropertyKeys]] ( )
一个
- 让 keys 为一个新的空
列表 。 - 让 str 为 O.[[StringData]]。
断言 : str是一个字符串 。- 让 len 为 str 的长度。
- 对每一个整数 i，使得 0 ≤ i < len，按升序执行：
- 对 O 的每一个自有属性键 P，使得 P 是一个
数组索引 并且 !ToIntegerOrInfinity (P) ≥ len，按升序的数字索引顺序执行：- 将 P 追加到 keys。
- 对 O 的每一个自有属性键 P，使得 P 是一个
字符串 并且 P 不是一个数组索引 ，按属性创建的时间顺序执行：- 将 P 追加到 keys。
- 对 O 的每一个自有属性键 P，使得 P 是一个
符号 ，按属性创建的时间顺序执行：- 将 P 追加到 keys。
- 返回 keys。
10.4.3.4 StringCreate ( value, prototype )
抽象操作 StringCreate 接受两个参数：value（一个字符串）和 prototype（一个对象），并返回一个
- 让 S 为
MakeBasicObject (« [[Prototype]], [[Extensible]], [[StringData]] »)。 - 将 S.[[Prototype]] 设置为 prototype。
- 将 S.[[StringData]] 设置为 value。
- 将 S.[[GetOwnProperty]] 设置为
10.4.3.1 中指定的内容。 - 将 S.[[DefineOwnProperty]] 设置为
10.4.3.2 中指定的内容。 - 将 S.[[OwnPropertyKeys]] 设置为
10.4.3.3 中指定的内容。 - 让 length 为 value 的长度。
- 执行 !
DefinePropertyOrThrow (S,"length" , 属性描述符 { [[Value]]:𝔽 (length), [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:false })。 - 返回 S。
10.4.3.5 StringGetOwnProperty ( S, P )
抽象操作 StringGetOwnProperty 接受两个参数：S（一个具有 [[StringData]] 内部槽的对象）和
P（一个
- 如果 P
不是一个字符串 ，返回undefined 。 - 让 index 为
CanonicalNumericIndexString (P)。 - 如果 index 是
undefined ，返回undefined 。 - 如果
IsIntegralNumber (index) 是false ，返回undefined 。 - 如果 index 是
-0 𝔽，返回undefined 。 - 让 str 为 S.[[StringData]]。
Assert : str是一个字符串 。- 让 len 为 str 的长度。
- 如果
ℝ (index) < 0 或 len ≤ℝ (index)，返回undefined 。 - 让 resultStr 为
str 从ℝ (index) 到ℝ (index) + 1 的子字符串。 - 返回属性描述符 { [[Value]]:
resultStr, [[Writable]]:
false , [[Enumerable]]:true , [[Configurable]]:false }。
10.4.4 Arguments Exotic Objects
大多数 ECMAScript 函数会向其代码提供一个 arguments 对象。根据函数定义的特性，其 arguments 对象可能是一个
如果一个对象的内部方法使用以下实现（未在此处指定的使用
虽然
Object.prototype.toString (
ParameterMap 对象及其属性值用作指定 arguments 对象与参数绑定之间对应关系的设备。ParameterMap 对象及其属性值并不直接从 ECMAScript 代码中可观察。ECMAScript 实现不需要实际创建或使用此类对象来实现指定的语义。
普通 arguments 对象定义了一个不可配置的
ECMAScript 对
10.4.4.1 [[GetOwnProperty]] ( P )
[[GetOwnProperty]] 内部方法用于
- 令 desc 为
OrdinaryGetOwnProperty (args, P)。 - 如果 desc 为
undefined ，则返回undefined 。 - 令 map 为 args.[[ParameterMap]]。
- 令 isMapped 为 !
HasOwnProperty (map, P)。 - 如果 isMapped 为
true ，则- 将 desc.[[Value]] 设置为
!
Get (map, P)。
- 将 desc.[[Value]] 设置为
!
- 返回 desc。
10.4.4.2 [[DefineOwnProperty]] ( P, Desc )
[[DefineOwnProperty]] 内部方法用于
- 令 map 为 args.[[ParameterMap]]。
- 令 isMapped 为 !
HasOwnProperty (map, P)。 - 令 newArgDesc 为 Desc。
- 如果 isMapped 为
true 且IsDataDescriptor (Desc) 为true ，则- 如果 Desc 没有 [[Value]]
字段，Desc 有一个
[[Writable]] 字段，且 Desc.[[Writable]] 为
false ，则- 将 newArgDesc 设置为 Desc 的副本。
- 将 newArgDesc.[[Value]] 设置为
!
Get (map, P)。
- 如果 Desc 没有 [[Value]]
字段，Desc 有一个
[[Writable]] 字段，且 Desc.[[Writable]] 为
- 令 allowed 为 !
OrdinaryDefineOwnProperty (args, P, newArgDesc)。 - 如果 allowed 为
false ，则返回false 。 - 如果 isMapped 为
true ，则- 如果
IsAccessorDescriptor (Desc) 为true ，则- 执行 ! map.[[Delete]](P)。
- 否则，
- 如果
- 返回
true 。
10.4.4.3 [[Get]] ( P, Receiver )
[[Get]] 内部方法用于
- 令 map 为 args.[[ParameterMap]]。
- 令 isMapped 为 !
HasOwnProperty (map, P)。 - 如果 isMapped 为
false ，则- 返回 ?
OrdinaryGet (args, P, Receiver)。
- 返回 ?
- 否则，
10.4.4.4 [[Set]] ( P, V, Receiver )
[[Set]] 内部方法用于
- 如果
SameValue (args, Receiver) 为false ，则- 令 isMapped 为
false 。
- 令 isMapped 为
- 否则，
- 令 map 为 args.[[ParameterMap]]。
- 令 isMapped 为 !
HasOwnProperty (map, P)。
- 如果 isMapped 为
true ，则 - 返回 ?
OrdinarySet (args, P, V, Receiver)。
10.4.4.5 [[Delete]] ( P )
[[Delete]] 内部方法用于
- 令 map 为 args.[[ParameterMap]]。
- 令 isMapped 为 !
HasOwnProperty (map, P)。 - 令 result 为 ?
OrdinaryDelete (args, P)。 - 如果 result 为
true 且 isMapped 为true ，则- 执行 ! map.[[Delete]](P)。
- 返回 result。
10.4.4.6 CreateUnmappedArgumentsObject ( argumentsList )
抽象操作 CreateUnmappedArgumentsObject 接受一个参数 argumentsList（一个
- 令 len 为 argumentsList 中的元素数量。
- 令 obj 为
OrdinaryObjectCreate (%Object.prototype% , « [[ParameterMap]] »). - 将 obj.[[ParameterMap]] 设置为
undefined 。 - 执行 !
DefinePropertyOrThrow (obj,"length" , 属性描述符 { [[Value]]:𝔽 (len), [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - 令 index 为 0。
- 重复，直到 index < len，
- 令 val 为 argumentsList[index]。
- 执行 !
CreateDataPropertyOrThrow (obj, !ToString (𝔽 (index)), val)。 - 将 index 设置为 index + 1。
- 执行 !
DefinePropertyOrThrow (obj,@@iterator , 属性描述符 { [[Value]]: %Array.prototype.values%, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - 执行 !
DefinePropertyOrThrow (obj,"callee" , 属性描述符 { [[Get]]:%ThrowTypeError% , [[Set]]:%ThrowTypeError% , [[Enumerable]]:false , [[Configurable]]:false }). - 返回 obj。
10.4.4.7 CreateMappedArgumentsObject ( func, formals, argumentsList, env )
抽象操作 CreateMappedArgumentsObject 接受参数 func（一个对象）、formals（一个
断言 ：formals 不包含剩余参数、任何绑定模式或任何初始化器。它可以包含重复的标识符。- 令 len 为 argumentsList 中元素的数量。
- 令 obj 为
MakeBasicObject (« [[Prototype]], [[Extensible]], [[ParameterMap]] »)。 - 设置 obj.[[GetOwnProperty]] 如
10.4.4.1 所述。 - 设置 obj.[[DefineOwnProperty]]
如
10.4.4.2 所述。 - 设置 obj.[[Get]] 如
10.4.4.3 所述。 - 设置 obj.[[Set]] 如
10.4.4.4 所述。 - 设置 obj.[[Delete]] 如
10.4.4.5 所述。 - 设置 obj.[[Prototype]] 为
%Object.prototype% 。 - 令 map 为
OrdinaryObjectCreate (null )。 - 设置 obj.[[ParameterMap]] 为 map。
- 令 parameterNames 为
BoundNames 的 formals。 - 令 numberOfParameters 为 parameterNames 中元素的数量。
- 令 index 为 0。
- 重复，直到 index < len，
- 令 val 为 argumentsList[index]。
- 执行 !
CreateDataPropertyOrThrow (obj, !ToString (𝔽 (index)), val)。 - 设置 index 为 index + 1。
- 执行 !
DefinePropertyOrThrow (obj,"length" , PropertyDescriptor { [[Value]]:𝔽 (len), [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true })。 - 令 mappedNames 为一个新的空的
列表 。 - 设置 index 为 numberOfParameters - 1。
- 重复，直到 index ≥ 0，
- 令 name 为 parameterNames[index]。
- 如果 mappedNames 不包含 name，那么
- 将 name 添加到 mappedNames。
- 如果 index < len，那么
- 令 g 为
MakeArgGetter (name, env)。 - 令 p 为
MakeArgSetter (name, env)。 - 执行 ! map.[[DefineOwnProperty]](!
ToString (𝔽 (index)), PropertyDescriptor { [[Set]]: p, [[Get]]: g, [[Enumerable]]:false , [[Configurable]]:true })。
- 令 g 为
- 设置 index 为 index - 1。
- 执行 !
DefinePropertyOrThrow (obj,@@iterator , PropertyDescriptor { [[Value]]: %Array.prototype.values%, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true })。 - 执行 !
DefinePropertyOrThrow (obj,"callee" , PropertyDescriptor { [[Value]]: func, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true })。 - 返回 obj。
10.4.4.7.1 MakeArgGetter ( name, env )
抽象操作 MakeArgGetter 接受参数 name（一个字符串）和 env（一个
- 令 getterClosure 为一个新的
抽象闭包 ，无参数，捕获 name 和 env，并在调用时执行以下步骤：- 返回 env.GetBindingValue(name,
false )。
- 返回 env.GetBindingValue(name,
- 令 getter 为
CreateBuiltinFunction (getterClosure, 0,"" , « »)。 - 注意：getter 从不直接被 ECMAScript 代码访问。
- 返回 getter。
10.4.4.7.2 MakeArgSetter ( name, env )
抽象操作 MakeArgSetter 接受参数 name（一个字符串）和 env（一个
- 令 setterClosure 为一个新的
抽象闭包 ，参数为 (value)，捕获 name 和 env，并在调用时执行以下步骤：- 返回 ! env.SetMutableBinding(name,
value,
false )。
- 返回 ! env.SetMutableBinding(name,
value,
- 令 setter 为
CreateBuiltinFunction (setterClosure, 1,"" , « »)。 - 注意：setter 从不直接被 ECMAScript 代码访问。
- 返回 setter。
10.4.5 TypedArray 特殊对象
如果一个对象的 [[GetOwnProperty]]、[[HasProperty]]、[[DefineOwnProperty]]、[[Get]]、[[Set]]、[[Delete]] 和 [[OwnPropertyKeys]] 内部方法使用本节中的定义，并且其其他基本内部方法使用
10.4.5.1 [[GetOwnProperty]] ( P )
[[GetOwnProperty]] 是
-
如果 P
是一个字符串 ，则：-
令 numericIndex 为
CanonicalNumericIndexString (P)。 -
如果 numericIndex 不是
undefined ，则：-
令 value 为
TypedArrayGetElement (O, numericIndex)。 -
如果 value 是
undefined ，则返回undefined 。 -
返回属性描述符 { [[Value]]:
value, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:true }。
-
令 value 为
-
令 numericIndex 为
-
返回
OrdinaryGetOwnProperty (O, P)。
10.4.5.2 [[HasProperty]] ( P )
[[HasProperty]] 是
-
如果 P
是一个字符串 ，则：-
令 numericIndex 为
CanonicalNumericIndexString (P)。 -
如果 numericIndex 不是
undefined ，返回IsValidIntegerIndex (O, numericIndex)。
-
令 numericIndex 为
-
返回 ?
OrdinaryHasProperty (O, P)。
10.4.5.3 [[DefineOwnProperty]] ( P, Desc )
[[DefineOwnProperty]] 是
-
如果 P
是一个字符串 ，则：-
令 numericIndex 为
CanonicalNumericIndexString (P)。 -
如果 numericIndex 不是
undefined ，则：-
如果
IsValidIntegerIndex (O, numericIndex) 为false ，则返回false 。 -
如果 Desc 具有 [[Configurable]] 字段且 Desc.[[Configurable]] 为
false ，则返回false 。 -
如果 Desc 具有 [[Enumerable]] 字段且 Desc.[[Enumerable]] 为
false ，则返回false 。 -
如果
IsAccessorDescriptor (Desc) 为true ，则返回false 。 -
如果 Desc 具有 [[Writable]]
字段且 Desc.[[Writable]] 为
false ，则返回false 。 -
如果 Desc 具有 [[Value]]
字段，执行 ?
TypedArraySetElement (O, numericIndex, Desc.[[Value]])。 -
返回
true 。
-
如果
-
令 numericIndex 为
-
返回 !
OrdinaryDefineOwnProperty (O, P, Desc)。
10.4.5.4 [[Get]] ( P, Receiver )
[[Get]] 是
-
如果 P
是一个字符串 ，则：-
令 numericIndex 为
CanonicalNumericIndexString (P)。 -
如果 numericIndex 不是
undefined ，则：-
返回
TypedArrayGetElement (O, numericIndex)。
-
返回
-
令 numericIndex 为
-
返回 ?
OrdinaryGet (O, P, Receiver)。
10.4.5.5 [[Set]] ( P, V, Receiver )
[[Set]] 是
-
如果 P
是一个字符串 ，则：-
令 numericIndex 为
CanonicalNumericIndexString (P)。 -
如果 numericIndex 不是
undefined ，则：-
如果
SameValue (O, Receiver) 为true ，则：-
执行 ?
TypedArraySetElement (O, numericIndex, V)。 -
返回
true 。
-
执行 ?
-
如果
IsValidIntegerIndex (O, numericIndex) 为false ，则返回true 。
-
如果
-
令 numericIndex 为
-
返回 ?
OrdinarySet (O, P, V, Receiver)。
10.4.5.6 [[Delete]] ( P )
[[Delete]] 是
-
如果 P
是一个字符串 ，则：-
令 numericIndex 为
CanonicalNumericIndexString (P)。 -
如果 numericIndex 不是
undefined ，则：-
如果
IsValidIntegerIndex (O, numericIndex) 为false ，则返回true ；否则返回false 。
-
如果
-
令 numericIndex 为
-
返回 !
OrdinaryDelete (O, P)。
10.4.5.7 [[OwnPropertyKeys]] ( )
[[OwnPropertyKeys]] 是
-
令 taRecord 为
MakeTypedArrayWithBufferWitnessRecord (O,seq-cst )。 -
令 keys 为一个新的空的
列表 。 -
如果
IsTypedArrayOutOfBounds (taRecord) 为false ，则：-
令 length 为
TypedArrayLength (taRecord)。 -
对于每个满足 0 ≤ i < length 的
整数 i，按升序进行：
-
令 length 为
-
对于每个 O 的自身
属性键 P，如果 P是一个字符串 并且 P 不是一个整数索引 ，按属性创建的时间顺序升序进行：- 将 P 添加到 keys。
-
对于每个 O 的自身
属性键 P，如果 P是一个符号 ，按属性创建的时间顺序升序进行：- 将 P 添加到 keys。
- 返回 keys。
10.4.5.8 带缓冲见证记录的 TypedArray
一个 带缓冲见证记录的 TypedArray 是一个
带缓冲见证记录的 TypedArray 具有
| 字段名称 | 值 | 含义 |
|---|---|---|
| [[Object]] | 一个 |
其缓冲区的字节长度被加载的 |
| [[CachedBufferByteLength]] | 一个非负的 |
创建 |
10.4.5.9 MakeTypedArrayWithBufferWitnessRecord ( obj, order )
抽象操作 MakeTypedArrayWithBufferWitnessRecord 接受参数 obj（一个
- 令 buffer 为 obj.[[ViewedArrayBuffer]]。
-
如果
IsDetachedBuffer (buffer) 为true ，则：-
令 byteLength 为
detached 。
-
令 byteLength 为
-
否则，
-
令 byteLength 为
ArrayBufferByteLength (buffer, order)。
-
令 byteLength 为
-
返回
带缓冲见证记录的 TypedArray { [[Object]]: obj, [[CachedBufferByteLength]]: byteLength }。
10.4.5.10 TypedArrayCreate ( prototype )
抽象操作 TypedArrayCreate 接受参数 prototype（一个对象），并返回一个
- 令 internalSlotsList 为 « [[Prototype]], [[Extensible]], [[ViewedArrayBuffer]], [[TypedArrayName]], [[ContentType]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] »。
-
令 A 为
MakeBasicObject (internalSlotsList)。 -
设置 A.[[GetOwnProperty]] 如
10.4.5.1 中所指定的。 -
设置 A.[[HasProperty]] 如
10.4.5.2 中所指定的。 -
设置 A.[[DefineOwnProperty]] 如
10.4.5.3 中所指定的。 -
设置 A.[[Get]] 如
10.4.5.4 中所指定的。 -
设置 A.[[Set]] 如
10.4.5.5 中所指定的。 -
设置 A.[[Delete]] 如
10.4.5.6 中所指定的。 -
设置 A.[[OwnPropertyKeys]] 如
10.4.5.7 中所指定的。 - 将 A.[[Prototype]] 设置为 prototype。
- 返回 A。
10.4.5.11 TypedArrayByteLength ( taRecord )
抽象操作 TypedArrayByteLength 接受参数 taRecord（一个
-
如果
IsTypedArrayOutOfBounds (taRecord) 为true ，则返回 0。 -
令 length 为
TypedArrayLength (taRecord)。 - 如果 length = 0，则返回 0。
- 令 O 为 taRecord.[[Object]]。
-
如果 O.[[ByteLength]] 不为
auto ，则返回 O.[[ByteLength]]。 -
令 elementSize 为
TypedArrayElementSize (O)。 - 返回 length × elementSize。
10.4.5.12 TypedArrayLength ( taRecord )
抽象操作 TypedArrayLength 接受参数 taRecord（一个
-
断言 ：IsTypedArrayOutOfBounds (taRecord) 为false 。 - 令 O 为 taRecord.[[Object]]。
-
如果 O.[[ArrayLength]] 不为
auto ，则返回 O.[[ArrayLength]]。 -
断言 ：IsFixedLengthArrayBuffer (O.[[ViewedArrayBuffer]]) 为false 。 - 令 byteOffset 为 O.[[ByteOffset]]。
-
令 elementSize 为
TypedArrayElementSize (O)。 - 令 byteLength 为 taRecord.[[CachedBufferByteLength]]。
-
断言 ：byteLength 不为detached 。 -
返回
floor ((byteLength - byteOffset) / elementSize)。
10.4.5.13 IsTypedArrayOutOfBounds ( taRecord )
抽象操作 IsTypedArrayOutOfBounds 接受参数 taRecord（一个
- 令 O 为 taRecord.[[Object]]。
- 令 bufferByteLength 为 taRecord.[[CachedBufferByteLength]]。
-
断言 ：如果 O.[[ViewedArrayBuffer]] 为IsDetachedBuffer ，则 bufferByteLength 必须为detached 。 -
如果 bufferByteLength 为
detached ，返回true 。 - 令 byteOffsetStart 为 O.[[ByteOffset]]。
-
如果 O.[[ArrayLength]] 为
auto ，则：- 令 byteOffsetEnd 为 bufferByteLength。
-
否则，
-
令 elementSize 为
TypedArrayElementSize (O)。 - 令 byteOffsetEnd 为 byteOffsetStart + O.[[ArrayLength]] × elementSize。
-
令 elementSize 为
-
如果 byteOffsetStart > bufferByteLength 或
byteOffsetEnd > bufferByteLength，返回
true 。 -
注意：长度为 0 的
TypedArrays 不被视为越界。 -
返回
false 。
10.4.5.14 IsValidIntegerIndex ( O, index )
抽象操作 IsValidIntegerIndex 接受参数 O（一个
-
如果
IsDetachedBuffer (O.[[ViewedArrayBuffer]]) 为true ，返回false 。 -
如果
IsIntegralNumber (index) 为false ，返回false 。 -
如果 index 是
-0 𝔽，返回false 。 -
令 taRecord 为
MakeTypedArrayWithBufferWitnessRecord (O,unordered )。 -
注意：当 O 的后备缓冲区是一个
可增长的 SharedArrayBuffer 时，边界检查不是同步操作。 -
如果
IsTypedArrayOutOfBounds (taRecord) 为true ，返回false 。 -
令 length 为
TypedArrayLength (taRecord)。 -
如果
ℝ (index) < 0 或ℝ (index) ≥ length，返回false 。 -
返回
true 。
10.4.5.15 TypedArrayGetElement ( O, index )
抽象操作 TypedArrayGetElement 接受参数 O（一个
-
如果
IsValidIntegerIndex (O, index) 为false ，返回undefined 。 - 令 offset 为 O.[[ByteOffset]]。
-
令 elementSize 为
TypedArrayElementSize (O)。 -
令 byteIndexInBuffer 为 (
ℝ (index) × elementSize) + offset。 -
令 elementType 为
TypedArrayElementType (O)。 -
返回
GetValueFromBuffer (O.[[ViewedArrayBuffer]], byteIndexInBuffer, elementType,true ,unordered )。
10.4.5.16 TypedArraySetElement ( O, index, value )
抽象操作 TypedArraySetElement 接受参数 O（一个
-
如果 O.[[ContentType]] 为
bigint ，令 numValue 为 ?ToBigInt (value)。 -
否则，令 numValue 为 ?
ToNumber (value)。 -
如果
IsValidIntegerIndex (O, index) 为true ，则：- 令 offset 为 O.[[ByteOffset]]。
-
令 elementSize 为
TypedArrayElementSize (O)。 -
令 byteIndexInBuffer 为 (
ℝ (index) × elementSize) + offset。 -
令 elementType 为
TypedArrayElementType (O)。 -
执行
SetValueInBuffer (O.[[ViewedArrayBuffer]], byteIndexInBuffer, elementType, numValue,true ,unordered )。
-
返回
unused 。
此操作似乎总是成功，但在尝试写入
10.4.5.17 IsArrayBufferViewOutOfBounds ( O )
抽象操作 IsArrayBufferViewOutOfBounds 接受参数 O（一个
-
如果 O 具有 [[DataView]] 内部插槽，则：
-
令 viewRecord 为
MakeDataViewWithBufferWitnessRecord (O,seq-cst )。 -
返回
IsViewOutOfBounds (viewRecord)。
-
令 viewRecord 为
-
令 taRecord 为
MakeTypedArrayWithBufferWitnessRecord (O,seq-cst )。 -
返回
IsTypedArrayOutOfBounds (taRecord)。
10.4.6 模块命名空间特殊对象
一个 export * 语法间接导出的绑定。每个字符串值自身属性键是相应导出绑定名称的
一个对象是一个 模块命名空间特殊对象，如果它的 [[GetPrototypeOf]],
[[SetPrototypeOf]], [[IsExtensible]], [[PreventExtensions]], [[GetOwnProperty]], [[DefineOwnProperty]], [[HasProperty]], [[Get]], [[Set]], [[Delete]],
和
[[OwnPropertyKeys]] 内部方法使用本节中的定义，而它的其他基本内部方法使用
10.4.6.1 [[GetPrototypeOf]] ( )
一个
- 返回
null 。
10.4.6.2 [[SetPrototypeOf]] ( V )
一个
- 返回 !
SetImmutablePrototype (O, V)。
10.4.6.3 [[IsExtensible]] ( )
一个
- 返回
false 。
10.4.6.4 [[PreventExtensions]] ( )
一个
- 返回
true 。
10.4.6.5 [[GetOwnProperty]] ( P )
一个
- 如果 P
是一个符号 ，返回OrdinaryGetOwnProperty (O, P)。 - 让 exports 成为 O 的 [[Exports]]。
- 如果 exports 不包含 P，返回
undefined 。 - 让 value 成为 ? O.[[Get]](P, O)。
- 返回 PropertyDescriptor { [[Value]]:
value, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:false }。
10.4.6.6 [[DefineOwnProperty]] ( P, Desc )
一个
- 如果 P
是一个符号 ，返回 !OrdinaryDefineOwnProperty (O, P, Desc)。 - 让 current 成为 ? O.[[GetOwnProperty]](P)。
- 如果 current 是
undefined ，返回false 。 - 如果 Desc 具有 [[Configurable]]
字段，并且 Desc 的 [[Configurable]] 是
true ，返回false 。 - 如果 Desc 具有 [[Enumerable]]
字段，并且 Desc 的 [[Enumerable]] 是
false ，返回false 。 - 如果
IsAccessorDescriptor (Desc) 是true ，返回false 。 - 如果 Desc 具有 [[Writable]] 字段，并且
Desc 的 [[Writable]] 是
false ，返回false 。 - 如果 Desc 具有 [[Value]] 字段，返回
SameValue (Desc.[[Value]], current.[[Value]])。 - 返回
true 。
10.4.6.7 [[HasProperty]] ( P )
一个
- 如果 P
是一个符号 ，返回 !OrdinaryHasProperty (O, P)。 - 让 exports 成为 O 的 [[Exports]]。
- 如果 exports 包含 P，返回
true 。 - 返回
false 。
10.4.6.8 [[Get]] ( P, Receiver )
一个
- 如果 P
是一个符号 ，则- 返回 !
OrdinaryGet (O, P, Receiver)。
- 返回 !
- 让 exports 成为 O 的 [[Exports]]。
- 如果 exports 不包含 P，返回
undefined 。 - 让 m 成为 O 的 [[Module]]。
- 让 binding 成为 m.ResolveExport(P)。
断言 ：binding 是一个已解析绑定记录 。- 让 targetModule 成为 binding 的 [[Module]]。
断言 ：targetModule 不是undefined 。- 如果 binding 的 [[BindingName]]
是
namespace ，则- 返回
GetModuleNamespace (targetModule)。
- 返回
- 让 targetEnv 成为 targetModule 的 [[Environment]]。
- 如果 targetEnv 是
empty ，抛出一个ReferenceError 异常。 - 返回
? targetEnv.GetBindingValue(binding.[[BindingName]],
true )。
ResolveExport 是无副作用的。每次用特定的 exportName 和 resolveSet
参数调用此操作时，它必须返回相同的结果。实现可以选择预先计算或缓存每个
10.4.6.9 [[Set]] ( P, V, Receiver )
一个
- 返回
false 。
10.4.6.10 [[Delete]] ( P )
一个
- 如果 P
是一个符号 ，则- 返回 !
OrdinaryDelete (O, P)。
- 返回 !
- 让 exports 成为 O 的 [[Exports]]。
- 如果 exports 包含 P，返回
false 。 - 返回
true 。
10.4.6.11 [[OwnPropertyKeys]] ( )
一个
- 让 exports 成为 O 的 [[Exports]]。
- 让 symbolKeys 成为
OrdinaryOwnPropertyKeys (O)。 - 返回
列表连接 exports 和 symbolKeys。
10.4.6.12 ModuleNamespaceCreate ( module, exports )
抽象操作 ModuleNamespaceCreate 接收参数 module（一个
断言 ：module 的 [[Namespace]] 是empty 。- 让 internalSlotsList 成为
表 33 中列出的内部插槽。 - 让 M 成为
MakeBasicObject (internalSlotsList)。 - 将 M 的基本内部方法设置为
10.4.6 中的定义。 - 将 M 的 [[Module]] 设置为 module。
- 让 sortedExports 成为
列表 ，其元素是 exports 的元素，顺序就像用 %Array.prototype.sort% 使用undefined 作为 comparefn 对这些值进行排序一样。 - 将 M 的 [[Exports]] 设置为 sortedExports。
- 创建与
28.3 中定义相对应的 M 自身属性。 - 将 module 的 [[Namespace]] 设置为 M。
- 返回 M。
10.4.7 不可变原型特殊对象
一个
如果对象的 [[SetPrototypeOf]] 内部方法使用以下实现，则该对象是一个 不可变原型特殊对象。（其其他基本内部方法可以根据具体的
与其他
10.4.7.1 [[SetPrototypeOf]] ( V )
一个
- 返回 ?
SetImmutablePrototype (O, V)。
10.4.7.2 SetImmutablePrototype ( O, V )
抽象操作 SetImmutablePrototype 接收参数 O（一个对象）和 V（一个对象或
- 让 current 成为 ? O.[[GetPrototypeOf]]()。
- 如果
SameValue (V, current) 是true ，返回true 。 - 返回
false 。
10.5 代理对象的内部方法和内部插槽
代理对象是一个
如果对象的基本内部方法（包括 [[Call]] 和 [[Construct]]，如果适用）使用本节中的定义，则该对象是一个 代理特殊对象。这些内部方法在
| 内部方法 | 处理程序方法 |
|---|---|
| [[GetPrototypeOf]] |
getPrototypeOf
|
| [[SetPrototypeOf]] |
setPrototypeOf
|
| [[IsExtensible]] |
isExtensible
|
| [[PreventExtensions]] |
preventExtensions
|
| [[GetOwnProperty]] |
getOwnPropertyDescriptor
|
| [[DefineOwnProperty]] |
defineProperty
|
| [[HasProperty]] |
has
|
| [[Get]] |
get
|
| [[Set]] |
set
|
| [[Delete]] |
deleteProperty
|
| [[OwnPropertyKeys]] |
ownKeys
|
| [[Call]] |
apply
|
| [[Construct]] |
construct
|
当调用处理程序方法来提供代理对象内部方法的实现时，处理程序方法会将代理的目标对象作为参数传递。代理的处理程序对象不一定具有与每个基本内部方法对应的方法。如果处理程序对象没有对应于内部陷阱的方法，则在代理上调用内部方法将导致调用代理目标对象上的相应内部方法。
代理对象的 [[ProxyHandler]] 和 [[ProxyTarget]]
内部插槽在对象创建时总是被初始化，并且通常不可修改。有些代理对象是以允许其随后被撤销的方式创建的。当代理被撤销时，其 [[ProxyHandler]]
和 [[ProxyTarget]] 内部插槽被设置为
由于代理对象允许内部方法的实现由任意 ECMAScript 代码提供，因此可能会定义一个其处理程序方法违反
在以下算法描述中，假设 O 是一个 ECMAScript 代理对象，P 是一个
10.5.1 [[GetPrototypeOf]] ( )
[[GetPrototypeOf]] 内部方法的
- 执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
断言 ： handler 是一个对象 。- 设 trap 为 ?
GetMethod (handler,"getPrototypeOf" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[GetPrototypeOf]]()。
- 设 handlerProto 为 ?
Call (trap, handler, « target »)。 - 如果 handlerProto 不是一个
对象 并且 handlerProto 不是null ，则抛出TypeError 异常。 - 设 extensibleTarget 为 ?
IsExtensible (target)。 - 如果 extensibleTarget 是
true ，则返回 handlerProto。 - 设 targetProto 为 ? target.[[GetPrototypeOf]]()。
- 如果
SameValue (handlerProto, targetProto) 是false ，则抛出TypeError 异常。 - 返回 handlerProto。
Proxy 对象的 [[GetPrototypeOf]] 强制执行以下不变量：
- [[GetPrototypeOf]] 的结果必须是一个对象或
null 。 - 如果目标对象不可扩展，则应用于代理对象的 [[GetPrototypeOf]] 必须返回与应用于代理对象的目标对象的 [[GetPrototypeOf]] 相同的值。
10.5.2 [[SetPrototypeOf]] ( V )
[[SetPrototypeOf]] 内部方法的
- 执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
断言 ： handler 是一个对象 。- 设 trap 为 ?
GetMethod (handler,"setPrototypeOf" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[SetPrototypeOf]](V)。
- 设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, « target, V »))。 - 如果 booleanTrapResult 是
false ，则返回false 。 - 设 extensibleTarget 为 ?
IsExtensible (target)。 - 如果 extensibleTarget 是
true ，则返回true 。 - 设 targetProto 为 ? target.[[GetPrototypeOf]]()。
- 如果
SameValue (V, targetProto) 是false ，则抛出TypeError 异常。 - 返回
true 。
Proxy 对象的 [[SetPrototypeOf]] 强制执行以下不变量：
- [[SetPrototypeOf]] 的结果是一个布尔值。
- 如果目标对象不可扩展，则参数值必须与应用于目标对象的 [[GetPrototypeOf]] 的结果相同。
10.5.3 [[IsExtensible]] ( )
[[IsExtensible]] 内部方法的
- 执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
断言 ：handler 是一个对象 。- 设 trap 为 ?
GetMethod (handler,"isExtensible" )。 - 如果 trap 是
undefined ，则：- 返回 ?
IsExtensible (target)。
- 返回 ?
- 设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, « target »))。 - 设 targetResult 为 ?
IsExtensible (target)。 - 如果 booleanTrapResult 不等于 targetResult，则抛出
TypeError 异常。 - 返回 booleanTrapResult。
Proxy 对象的 [[IsExtensible]] 强制执行以下不变量：
- [[IsExtensible]] 的结果是一个布尔值。
- 应用于 Proxy 对象的 [[IsExtensible]] 必须返回与应用于 Proxy 对象的目标对象相同的参数值相同的结果。
10.5.4 [[PreventExtensions]] ( )
[[PreventExtensions]] 内部方法的
- 执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
断言 ：handler 是一个对象 。- 设 trap 为 ?
GetMethod (handler,"preventExtensions" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[PreventExtensions]]()。
- 设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, « target »))。 - 如果 booleanTrapResult 是
true ，则：- 设 extensibleTarget 为 ?
IsExtensible (target)。 - 如果 extensibleTarget 是
true ，抛出TypeError 异常。
- 设 extensibleTarget 为 ?
- 返回 booleanTrapResult。
Proxy 对象的 [[PreventExtensions]] 强制执行以下不变量：
- [[PreventExtensions]] 的结果是一个布尔值。
- 应用于 Proxy 对象的 [[PreventExtensions]] 仅当应用于 Proxy 对象的目标对象的 [[IsExtensible]] 结果为
false 时，才会返回true 。
10.5.5 [[GetOwnProperty]] ( P )
[[GetOwnProperty]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"getOwnPropertyDescriptor" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[GetOwnProperty]](P)。
-
设 trapResultObj 为 ?
Call (trap, handler, «target, P »)。 -
如果 trapResultObj 不是一个
对象 且 trapResultObj 不是undefined ，抛出一个TypeError 异常。 - 设 targetDesc 为 ? target.[[GetOwnProperty]](P)。
- 如果 trapResultObj 是
undefined ，则：-
如果 targetDesc 是
undefined ，返回undefined 。 -
如果 targetDesc.[[Configurable]] 是
false ，抛出一个TypeError 异常。 -
设 extensibleTarget 为 ?
IsExtensible (target)。 -
如果 extensibleTarget 是
false ，抛出一个TypeError 异常。 - 返回
undefined 。
-
如果 targetDesc 是
- 设 extensibleTarget 为 ?
IsExtensible (target)。 - 设 resultDesc 为 ?
ToPropertyDescriptor (trapResultObj)。 - 执行
CompletePropertyDescriptor (resultDesc)。 - 设 valid 为
IsCompatiblePropertyDescriptor (extensibleTarget, resultDesc, targetDesc)。 - 如果 valid 是
false ，抛出一个TypeError 异常。 - 如果 resultDesc.[[Configurable]] 是
false ，则：-
如果 targetDesc 是
undefined 或 targetDesc.[[Configurable]] 是true ，则：- 抛出一个
TypeError 异常。
- 抛出一个
- 如果 resultDesc 有一个 [[Writable]] 字段并且 resultDesc.[[Writable]] 是
false ，则：-
断言 ：targetDesc 有一个 [[Writable]] 字段。 -
如果 targetDesc.[[Writable]] 是
true ，抛出一个TypeError 异常。
-
-
如果 targetDesc 是
- 返回 resultDesc。
Proxy 对象的 [[GetOwnProperty]] 强制执行以下不变量：
-
[[GetOwnProperty]] 的结果必须是一个对象或
undefined 。 - 如果目标对象作为自身不可配置的属性存在，则该属性不能被报告为不存在。
- 如果目标对象作为自身不可扩展的属性存在，则该属性不能被报告为不存在。
- 如果目标对象是不可扩展的，且该属性不存在于目标对象的自身属性中，则该属性不能被报告为存在。
- 除非目标对象的自身不可配置属性存在，否则该属性不能被报告为不可配置。
- 除非目标对象的自身不可配置且不可写的属性存在，否则该属性不能被报告为既不可配置又不可写。
10.5.6 [[DefineOwnProperty]] ( P, Desc )
[[DefineOwnProperty]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"defineProperty" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[DefineOwnProperty]](P, Desc)。
-
设 descObj 为 ?
FromPropertyDescriptor (Desc)。 -
设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, «target, P, descObj »))。 - 如果 booleanTrapResult 是
false ，返回false 。 - 设 targetDesc 为 ? target.[[GetOwnProperty]](P)。
-
设 extensibleTarget 为 ?
IsExtensible (target)。 - 如果 Desc 有一个 [[Configurable]] 字段且 Desc.[[Configurable]] 是
false ，则：-
设 settingConfigFalse 为
true 。
-
设 settingConfigFalse 为
- 否则，
-
设 settingConfigFalse 为
false 。
-
设 settingConfigFalse 为
- 如果 targetDesc 是
undefined ，则：- 如果 extensibleTarget 是
false ，抛出一个TypeError 异常。 - 如果 settingConfigFalse 是
true ，抛出一个TypeError 异常。
- 如果 extensibleTarget 是
- 否则，
-
如果
IsCompatiblePropertyDescriptor (extensibleTarget, Desc, targetDesc) 是false ，抛出一个TypeError 异常。 - 如果 settingConfigFalse 是
true 且 targetDesc.[[Configurable]] 是true ，抛出一个TypeError 异常。 - 如果
IsDataDescriptor (targetDesc) 是true ，targetDesc.[[Configurable]] 是false ，且 targetDesc.[[Writable]] 是true ，则：- 如果 Desc 有一个 [[Writable]] 字段且 Desc.[[Writable]] 是
false ，抛出一个TypeError 异常。
- 如果 Desc 有一个 [[Writable]] 字段且 Desc.[[Writable]] 是
-
如果
- 返回
true 。
Proxy 对象的 [[DefineOwnProperty]] 强制执行以下不变量：
- [[DefineOwnProperty]] 的结果是一个布尔值。
- 如果目标对象是不可扩展的，则不能添加属性。
- 除非目标对象存在相应的不可配置自身属性，否则属性不能是不可配置的。
- 除非目标对象存在相应的不可配置且不可写的自身属性，否则不可配置的属性不能是不可写的。
- 如果属性有相应的目标对象属性，则使用属性的属性描述符应用于目标对象的 [[DefineOwnProperty]] 不会抛出异常。
10.5.7 [[HasProperty]] ( P )
[[HasProperty]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"has" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[HasProperty]](P)。
-
设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, «target, P »))。 - 如果 booleanTrapResult 是
false ，则：- 设 targetDesc 为 ? target.[[GetOwnProperty]](P)。
- 如果 targetDesc 不是
undefined ，则：-
如果 targetDesc.[[Configurable]] 是
false ，抛出一个TypeError 异常。 -
设 extensibleTarget 为 ?
IsExtensible (target)。 -
如果 extensibleTarget 是
false ，抛出一个TypeError 异常。
-
如果 targetDesc.[[Configurable]] 是
- 返回 booleanTrapResult。
Proxy 对象的 [[HasProperty]] 强制执行以下不变量：
- [[HasProperty]] 的结果是一个布尔值。
- 如果属性作为目标对象的不可配置自身属性存在，则不能报告该属性不存在。
- 如果属性作为目标对象的自身属性存在且目标对象不可扩展，则不能报告该属性不存在。
10.5.8 [[Get]] ( P, Receiver )
[[Get]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"get" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[Get]](P, Receiver)。
-
设 trapResult 为 ?
Call (trap, handler, «target, P, Receiver ») 。 - 设 targetDesc 为 ? target.[[GetOwnProperty]](P)。
- 如果 targetDesc 不是
undefined 且 targetDesc.[[Configurable]] 是false ，则：-
如果
IsDataDescriptor (targetDesc) 是true 且 targetDesc.[[Writable]] 是false ，则：-
如果
SameValue (trapResult, targetDesc.[[Value]]) 是false ，抛出一个TypeError 异常。
-
如果
-
如果
IsAccessorDescriptor (targetDesc) 是true 且 targetDesc.[[Get]] 是 undefined ，则：- 如果 trapResult 不是
undefined ，抛出一个TypeError 异常。
- 如果 trapResult 不是
-
如果
- 返回 trapResult。
10.5.9 [[Set]] ( P, V, Receiver )
[[Set]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"set" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[Set]](P, V, Receiver)。
-
设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, «target, P, V, Receiver »))。 - 如果 booleanTrapResult 是
false ，返回false 。 - 设 targetDesc 为 ? target.[[GetOwnProperty]](P)。
- 如果 targetDesc 不是
undefined 且 targetDesc.[[Configurable]] 是false ，则：-
如果
IsDataDescriptor (targetDesc) 是true 且 targetDesc.[[Writable]] 是 false ，则：-
如果
SameValue (V, targetDesc.[[Value]]) 是false ，抛出一个TypeError 异常。
-
如果
-
如果
IsAccessorDescriptor (targetDesc) 是true，则： -
如果 targetDesc.[[Set]] 是
undefined ，抛出一个TypeError 异常。
-
如果 targetDesc.[[Set]] 是
-
如果
- 返回
true 。
10.5.10 [[Delete]] ( P )
[[Delete]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"deleteProperty" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[Delete]](P)。
-
设 booleanTrapResult 为
ToBoolean (?Call (trap, handler, «target, P »))。 - 如果 booleanTrapResult 是
false ，返回false 。 - 设 targetDesc 为 ? target.[[GetOwnProperty]](P)。
- 如果 targetDesc 是
undefined ，返回true 。 - 如果 targetDesc.[[Configurable]] 是
false ，抛出一个TypeError 异常。 -
设 extensibleTarget 为 ?
IsExtensible (target)。 - 如果 extensibleTarget 是
false ，抛出一个TypeError 异常。 - 返回
true 。
Proxy 对象的 [[Delete]] 强制执行以下不变量：
- [[Delete]] 的结果是一个布尔值。
- 如果目标对象存在一个不可配置的自身属性，则不能将其报告为已删除。
- 如果目标对象存在一个自身属性且目标对象是不可扩展的，则不能将其报告为已删除。
10.5.11 [[OwnPropertyKeys]] ( )
[[OwnPropertyKeys]] 内部方法的
-
执行 ?
ValidateNonRevokedProxy (O)。 - 设 target 为 O.[[ProxyTarget]]。
- 设 handler 为 O.[[ProxyHandler]]。
-
断言 ：handler 是一个对象 。 -
设 trap 为 ?
GetMethod (handler,"ownKeys" )。 - 如果 trap 是
undefined ，则：- 返回 ? target.[[OwnPropertyKeys]]()。
-
设 trapResultArray 为 ?
Call (trap, handler, «target »)。 -
设 trapResult 为 ?
CreateListFromArrayLike (trapResultArray, «String, Symbol »)。 - 如果 trapResult 包含任何重复项，抛出一个
TypeError 异常。 -
设 extensibleTarget 为 ?
IsExtensible (target)。 - 设 targetKeys 为 ? target.[[OwnPropertyKeys]]()。
-
断言 ：targetKeys 是一个包含列表 的属性键 。 -
断言 ：targetKeys 不包含重复项。 -
设 targetConfigurableKeys 为一个新的空
列表 。 -
设 targetNonconfigurableKeys 为一个新的空
列表 。 - 对于 targetKeys 的每个元素 key，执行以下步骤：
- 设 desc 为 ? target.[[GetOwnProperty]](key)。
- 如果 desc 不是
undefined 且 desc.[[Configurable]] 是false ，则：- 将 key 追加到 targetNonconfigurableKeys。
- 否则：
- 将 key 追加到 targetConfigurableKeys。
- 如果 extensibleTarget 是
true 且 targetNonconfigurableKeys 为空，则：- 返回 trapResult。
-
设 uncheckedResultKeys 为一个包含 trapResult 元素的
列表 。 - 对于 targetNonconfigurableKeys 的每个元素 key，执行以下步骤：
- 如果 uncheckedResultKeys 不包含 key，抛出一个
TypeError 异常。 - 从 uncheckedResultKeys 中移除 key。
- 如果 uncheckedResultKeys 不包含 key，抛出一个
- 如果 extensibleTarget 是
true ，返回 trapResult。 - 对于 targetConfigurableKeys 的每个元素 key，执行以下步骤：
- 如果 uncheckedResultKeys 不包含 key，抛出一个
TypeError 异常。 - 从 uncheckedResultKeys 中移除 key。
- 如果 uncheckedResultKeys 不包含 key，抛出一个
- 如果 uncheckedResultKeys 不为空，抛出一个
TypeError 异常。 - 返回 trapResult。
10.5.12 [[Call]] ( thisArgument, argumentsList )
[[Call]] 内部方法用于
- 执行 ?
ValidateNonRevokedProxy (O). - 让 target 等于 O.[[ProxyTarget]].
- 让 handler 等于 O.[[ProxyHandler]].
断言 : handler 是一个对象。- 让 trap 等于 ?
GetMethod (handler, "apply"). - 如果 trap 是 undefined，则
- 返回 ?
Call (target, thisArgument, argumentsList).
- 返回 ?
- 让 argArray 等于
CreateArrayFromList (argumentsList). - 返回 ?
Call (trap, handler, « target, thisArgument, argArray »).
10.5.13 [[Construct]] ( argumentsList, newTarget )
[[Construct]] 内部方法用于
- 执行 ?
ValidateNonRevokedProxy (O). - 让 target 等于 O.[[ProxyTarget]].
断言 :IsConstructor (target) 为 true。- 让 handler 等于 O.[[ProxyHandler]].
断言 : handler 是一个对象。- 让 trap 等于 ?
GetMethod (handler, "construct"). - 如果 trap 是 undefined，则
- 返回 ?
Construct (target, argumentsList, newTarget).
- 返回 ?
- 让 argArray 等于
CreateArrayFromList (argumentsList). - 让 newObj 等于 ?
Call (trap, handler, « target, argArray, newTarget »). - 如果 newObj 不是一个对象，抛出一个 TypeError 异常。
- 返回 newObj.
[[Construct]] 对于 Proxy 对象强制执行以下不变量：
- [[Construct]] 的结果必须是一个对象。
10.5.14 ValidateNonRevokedProxy ( proxy )
抽象操作 ValidateNonRevokedProxy 接受参数 proxy（一个
- 如果 proxy.[[ProxyTarget]] 是
null ，抛出TypeError 异常。 断言 : proxy.[[ProxyHandler]] 不是null 。- 返回
unused 。
10.5.15 ProxyCreate ( target, handler )
抽象操作 ProxyCreate 接受参数 target（一个
- 如果 target
不是一个对象 ，抛出TypeError 异常。 - 如果 handler
不是一个对象 ，抛出TypeError 异常。 - 让 P 等于
MakeBasicObject (« [[ProxyHandler]], [[ProxyTarget]] »)。 - 设置 P 的基本内部方法，除了 [[Call]] 和 [[Construct]]，按照
10.5 中的定义。 - 如果
IsCallable (target) 为true ，则- 设置 P.[[Call]]，如
10.5.12 中所述。 - 如果
IsConstructor (target) 为true ，则- 设置 P.[[Construct]]，如
10.5.13 中所述。
- 设置 P.[[Construct]]，如
- 设置 P.[[Call]]，如
- 设置 P.[[ProxyTarget]] 为 target。
- 设置 P.[[ProxyHandler]] 为 handler。
- 返回 P。
11 ECMAScript 语言：源代码
11.1 源代码
语法
ECMAScript 源代码 是一系列 Unicode 代码点。在 ECMAScript 语法允许的地方，所有从 U+0000 到 U+10FFFF 的 Unicode
代码点值，包括代理代码点，都可以出现在 ECMAScript 源代码中。用于存储和交换 ECMAScript 源代码的实际编码与本规范无关。不论外部源代码编码如何，符合规范的 ECMAScript
实现都将源代码处理为等效的
组合字符序列的组成部分被视为单独的 Unicode 代码点，即使用户可能将整个序列视为一个字符。
在字符串字面量、正则表达式字面量、模板字面量和标识符中，任何 Unicode 代码点也可以使用 Unicode 转义序列来表示，显式表达代码点的数值。在注释中，这样的转义序列实际上被忽略，作为注释的一部分。
ECMAScript 与 Java 编程语言在 Unicode 转义序列的行为上有所不同。例如，在 Java 程序中，如果 Unicode 转义序列 \u000A
出现在单行注释中，它会被解释为行终止符（Unicode 代码点 U+000A 是换行符（LF）），因此下一个代码点不再是注释的一部分。同样，如果 Unicode 转义序列 \u000A
出现在 Java 程序的字符串字面量中，它也会被解释为行终止符，字符串字面量中不允许有行终止符——必须写成 \n 而不是
\u000A，以使换行符（LF）成为字符串字面量的字符串值的一部分。在 ECMAScript 程序中，出现在注释中的 Unicode 转义序列从不被解释，因此不能终止注释。同样，出现在
ECMAScript 程序的字符串字面量中的 Unicode 转义序列始终是字面量的一部分，永远不会被解释为行终止符或可能终止字符串字面量的代码点。
11.1.1 静态语义: UTF16EncodeCodePoint ( cp )
抽象操作 UTF16EncodeCodePoint 接受参数 cp（一个 Unicode 代码点）并返回一个字符串。调用时，它执行以下步骤：
11.1.2 静态语义: CodePointsToString ( text )
抽象操作 CodePointsToString 接受参数 text（一个 Unicode 代码点序列）并返回一个字符串。它将 text 转换为字符串值，如
- 令 result 为空字符串。
- 对于 text 中的每个代码点 cp，执行以下步骤
- 将 result 设为
字符串连接 result 和UTF16EncodeCodePoint (cp) 的结果。
- 将 result 设为
- 返回 result。
11.1.3 静态语义: UTF16SurrogatePairToCodePoint ( lead, trail )
抽象操作 UTF16SurrogatePairToCodePoint 接受参数 lead（一个代码单元）和 trail（一个代码单元），并返回一个代码点。形成
UTF-16
11.1.4 静态语义: CodePointAt ( string, position )
抽象操作 CodePointAt 接受参数 string（一个字符串）和 position（一个非负
- 令 size 为 string 的长度。
断言 : position ≥ 0 并且 position < size。- 令 first 为 string 内索引 position 处的代码单元。
- 令 cp 为数值为 first 的代码点。
- 如果 first 既不是
前导代理项 也不是尾随代理项 ，则- 返回
记录 { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]:false }。
- 返回
- 如果 first 是
尾随代理项 或者 position + 1 = size，则- 返回
记录 { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]:true }。
- 返回
- 令 second 为 string 内索引 position + 1 处的代码单元。
- 如果 second 不是
尾随代理项 ，则- 返回
记录 { [[CodePoint]]: cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]:true }。
- 返回
- 将 cp 设置为
UTF16SurrogatePairToCodePoint (first, second)。 - 返回
记录 { [[CodePoint]]: cp, [[CodeUnitCount]]: 2, [[IsUnpairedSurrogate]]:false }。
11.1.5 静态语义: StringToCodePoints ( string )
抽象操作 StringToCodePoints 接受参数 string（一个字符串）并返回一个代码点的
- 令 codePoints 为一个新的空的
列表 。 - 令 size 为 string 的长度。
- 令 position 为 0。
- 重复，当 position 小于 size 时，
- 令 cp 为
CodePointAt (string, position)。 - 将 cp.[[CodePoint]] 添加到 codePoints。
- 将 position 设置为 position + cp.[[CodeUnitCount]]。
- 令 cp 为
- 返回 codePoints。
11.1.6 静态语义: ParseText ( sourceText, goalSymbol )
抽象操作 ParseText 接受参数 sourceText（一个 Unicode 代码点序列）和 goalSymbol（ECMAScript
语法中的一个非终结符）并返回一个
另见第
11.2 Types of Source Code
有四种类型的 ECMAScript 代码：
-
Global code 是被当作 ECMAScript
Script 处理的源文本。特定Script 的 global code 不包括任何被解析为FunctionDeclaration 、FunctionExpression 、GeneratorDeclaration 、GeneratorExpression 、AsyncFunctionDeclaration 、AsyncFunctionExpression 、AsyncGeneratorDeclaration 、AsyncGeneratorExpression 、MethodDefinition 、ArrowFunction 、AsyncArrowFunction 、ClassDeclaration 或ClassExpression 的任何源文本。 -
Eval code 是传递给内建
eval函数的源文本。更准确地说，如果传递给内建eval函数的参数是一个字符串 ，它被当作 ECMAScriptScript 处理。特定调用eval的 eval code 是该Script 的 global code 部分。 -
Function code 是解析为 ECMAScript
function object 的 [[ECMAScriptCode]] 和 [[FormalParameters]] 内部槽的源文本（见10.2 ）。特定 ECMAScript 函数的 function code 不包括作为嵌套函数的 function code 解析的任何源文本，如FunctionDeclaration 、FunctionExpression 、GeneratorDeclaration 、GeneratorExpression 、AsyncFunctionDeclaration 、AsyncFunctionExpression 、AsyncGeneratorDeclaration 、AsyncGeneratorExpression 、MethodDefinition 、ArrowFunction 、AsyncArrowFunction 、ClassDeclaration 或ClassExpression 。 -
Module code 是提供为
ModuleBody 的源文本。它是在模块初始化时直接执行的代码。特定模块的 module code 不包括作为嵌套FunctionDeclaration 、FunctionExpression 、GeneratorDeclaration 、GeneratorExpression 、AsyncFunctionDeclaration 、AsyncFunctionExpression 、AsyncGeneratorDeclaration 、AsyncGeneratorExpression 、MethodDefinition 、ArrowFunction 、AsyncArrowFunction 、ClassDeclaration 或ClassExpression 的任何源文本。
Function code 通常以函数定义的主体形式提供（
将
11.2.1 指令序言和 "use strict" 指令
指令序言 是出现在
"use strict" 指令 是出现在
"use strict" 或 'use strict'。
11.2.2 严格模式代码
ECMAScript 语法单元可以使用无限制或严格模式语法和语义进行处理
(
-
全局代码 是严格模式代码，如果它以包含"use strict" 指令 的指令序言 开始。 -
模块代码 总是严格模式代码。 -
ClassDeclaration 或ClassExpression 的所有部分都是严格模式代码。 -
Eval 代码 是严格模式代码，如果它以包含"use strict" 指令 的指令序言 开始，或者调用eval是包含在严格模式代码中的直接 eval 。 -
函数代码 是严格模式代码， 如果相关的FunctionDeclaration ，FunctionExpression ，GeneratorDeclaration ，GeneratorExpression ，AsyncFunctionDeclaration ，AsyncFunctionExpression ，AsyncGeneratorDeclaration ，AsyncGeneratorExpression ，MethodDefinition ，ArrowFunction ， 或AsyncArrowFunction 包含在严格模式代码中， 或者如果生成函数的 [[ECMAScriptCode]] 内部槽的代码以包含"use strict" 指令 的指令序言 开始。 -
提供给内置 Function，Generator，AsyncFunction 和 AsyncGenerator
构造函数 的函数代码 是严格模式代码， 如果最后一个参数是一个字符串 ，当处理时它是一个以 包含"use strict" 指令 的指令序言 开始的函数体 。
不是严格模式代码的 ECMAScript 代码称为 非严格代码。
11.2.3 非 ECMAScript 函数
ECMAScript 实现可能支持对函数
12 ECMAScript 语言：词法语法
ECMAScript
在多个情况下，词法输入元素的识别对消耗输入元素的语法语境是敏感的。这需要词法语法的多个
语法
12.1 Unicode 格式控制字符
Unicode 格式控制字符（即 Unicode 字符数据库中类别为 “Cf” 的字符，如左到右标记或右到左标记）是用于在缺乏高级协议（如标记语言）的情况下控制一段文本格式的控制代码。
允许在源文本中使用格式控制字符以便于编辑和显示是很有用的。所有格式控制字符都可以在注释、字符串字面量、模板字面量和正则表达式字面量中使用。
U+200C（零宽非连接符）和 U+200D（零宽连接符）是用于在某些语言中形成单词或短语时进行必要区分的格式控制字符。在
U+FEFF（零宽不换行空格）是主要用于文本开头的格式控制字符，用来标记它为 Unicode 并允许检测文本的编码和字节顺序。出于这种目的而使用的 <ZWNBSP>
字符有时也会出现在文本的开头之后，例如由于文件连接的结果。在
某些格式控制字符在注释、字符串字面量和正则表达式字面量之外的特殊处理在
| 代码点 | 名称 | 缩写 | 用法 |
|---|---|---|---|
U+200C
|
零宽非连接符 | <ZWNJ> |
|
U+200D
|
零宽连接符 | <ZWJ> |
|
U+FEFF
|
零宽不换行空格 | <ZWNBSP> |
|
12.2 空白符
空白符代码点用于提高源文本的可读性，并将词法单元（不可分割的词法单位）彼此分开，但除此之外没有其他意义。空白符代码点可以出现在任意两个词法单元之间，以及输入的开头或结尾。空白符代码点可以出现在
ECMAScript 的空白符代码点列在
| 代码点 | 名称 | 缩写 |
|---|---|---|
U+0009 |
CHARACTER TABULATION | <TAB> |
U+000B |
LINE TABULATION | <VT> |
U+000C |
FORM FEED (FF) | <FF> |
U+FEFF |
ZERO WIDTH NO-BREAK SPACE | <ZWNBSP> |
| general category 中的任意代码点 “Space_Separator” | <USP> |
U+0020 (SPACE) 和 U+00A0 (NO-BREAK SPACE) 代码点是 <USP> 的一部分。
除了表
语法
12.3 行终止符
像空白符代码点一样，行终止符代码点用于提高源文本的可读性，并将词法单元（不可分割的词法单位）彼此分开。然而，与空白符代码点不同，行终止符对语法规则的行为有一定影响。通常，行终止符可以出现在任意两个词法单元之间，但在某些地方，语法规则禁止它们的出现。行终止符还会影响自动分号插入的过程（
行终止符可以出现在
行终止符包含在正则表达式中的 \s 类匹配的空白符代码点集合中。
ECMAScript 行终止符代码点列在
| 代码点 | Unicode 名称 | 缩写 |
|---|---|---|
U+000A |
LINE FEED (LF) | <LF> |
U+000D |
CARRIAGE RETURN (CR) | <CR> |
U+2028 |
LINE SEPARATOR | <LS> |
U+2029 |
PARAGRAPH SEPARATOR | <PS> |
只有表
语法
12.4 注释
注释可以是单行或多行。多行注释不能嵌套。
由于单行注释可以包含任何 Unicode 代码点，除了 // 标记到行尾的所有代码点组成。然而，行尾的
注释表现得像空白符，并被丢弃，除了如果一个
语法
本节中的一些规则在
12.5 Hashbang 注释
Hashbang 注释是位置敏感的，并且像其他类型的注释一样，从语法解析的输入元素流中被丢弃。
语法
12.6 词法单元(Tokens)
语法
12.7 名称和关键字
本标准指定了特定的代码点添加：U+0024 (美元符号) 和 U+005F (下划线) 在
语法
非终结符
_。
具有 Unicode 属性 “ID_Start” 和 “ID_Continue” 的代码点集合分别包括具有 Unicode 属性 “Other_ID_Start” 和 “Other_ID_Continue” 的代码点。
12.7.1 标识符名称
在 \ 不贡献任何代码点。Unicode 转义序列不能用于对
根据 Unicode 标准，两个规范等效的
12.7.1.1 静态语义：早期错误
-
如果
IdentifierCodePoint 不属于由IdentifierStartChar 派生的某个 Unicode 代码点，则这是一个语法错误。
-
如果
IdentifierCodePoint 不属于由IdentifierPartChar 派生的某个 Unicode 代码点，则这是一个语法错误。
12.7.1.2 静态语义：IdentifierCodePoints
语法导向操作
- 让 cp 为
IdentifierCodePoint 的IdentifierStart 。 - 返回 « cp »。
- 让 cps 为
IdentifierCodePoints 派生出的IdentifierName 。 - 让 cp 为
IdentifierCodePoint 的IdentifierPart 。 - 返回
列表串联 的 cps 和 « cp »。
12.7.1.3 静态语义：IdentifierCodePoint
语法导向操作
- 返回
IdentifierStartChar 匹配的代码点。
- 返回
IdentifierPartChar 匹配的代码点。
- 返回数值为
Hex4Digits 的代码点。
- 返回数值为
CodePoint 的代码点。
12.7.2 关键字和保留字
关键字 是一个与
if、while、async、await 等。
保留字 是一个不能用作标识符的
if 和 while 是保留字，await
仅在异步函数和模块中是保留的，而 async 不是保留的，它可以在变量名或语句标签中使用。
本规范使用语法生成式和
await 和 yield，都是无条件保留的。await 和 yield 的例外情况在
-
那些始终允许作为标识符使用的，不是关键字的名称，例如
Math、window、toString和_; -
那些永远不允许作为标识符使用的名称，即下面列出的
ReservedWord （除了await和yield）; -
那些在特定上下文中允许作为标识符使用的名称，即
await和yield; -
那些在
严格模式代码 中上下文不允许作为标识符使用的名称：let、static、implements、interface、package、private、protected和public; -
那些始终允许作为标识符使用，但在某些语法生成式中的某些地方也出现为关键字的名称，即
Identifier 不允许：as、async、from、get、meta、of、set和target。
术语 条件关键字 或 上下文关键字 有时用来指在上述最后三类中的关键字，这些关键字可以在某些上下文中作为标识符使用，而在其他上下文中作为关键字使用。
语法
根据
\ Unicode 转义序列表示。
\
els\u{65} 来声明一个名为 "else" 的变量。
enum 目前在本规范中不作为关键字使用。它是一个 未来保留字，为将来的语言扩展预留。
同样，implements、interface、package、private、protected
和 public 在
12.8 标点符号
语法
12.9 字面量
12.9.1 Null 字面量
语法
12.9.2 布尔字面量
语法
12.9.3 数值字面量
语法
紧跟在
例如：3in 是错误的，而不是两个输入元素 3 和 in。
12.9.3.1 静态语义：早期错误
- 如果
此产生式匹配的源文本 是严格模式代码 ，则会产生语法错误。
12.9.3.2 静态语义：MV
数值字面量表示
-
DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits DecimalIntegerLiteral 的 MV 加上 (DecimalDigits 的 MV × 10 -n )，其中 n 是DecimalDigits 中的代码点数，排除所有NumericLiteralSeparator 的出现。 -
DecimalLiteral :: DecimalIntegerLiteral . ExponentPart DecimalIntegerLiteral 的 MV × 10 e，其中 e 是ExponentPart 的 MV。 -
DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits ExponentPart DecimalIntegerLiteral 的 MV 加上 (DecimalDigits 的 MV × 10 -n ) ) × 10 e，其中 n 是DecimalDigits 中的代码点数，排除所有NumericLiteralSeparator 的出现，e 是ExponentPart 的 MV。 -
DecimalLiteral :: . DecimalDigits DecimalDigits 的 MV × 10 -n，其中 n 是DecimalDigits 中的代码点数，排除所有NumericLiteralSeparator 的出现。 -
DecimalLiteral :: . DecimalDigits ExponentPart DecimalDigits 的 MV × 10 e - n ，其中 n 是DecimalDigits 中的代码点数，排除所有NumericLiteralSeparator 的出现，e 是ExponentPart 的 MV。 -
DecimalLiteral :: DecimalIntegerLiteral ExponentPart DecimalIntegerLiteral 的 MV × 10 e，其中 e 是ExponentPart 的 MV。 -
DecimalIntegerLiteral :: 0 -
DecimalIntegerLiteral :: NonZeroDigit NumericLiteralSeparator opt DecimalDigits NonZeroDigit 的 MV × 10 n ) 加上DecimalDigits 的 MV，其中 n 是DecimalDigits 中的代码点数，排除所有NumericLiteralSeparator 的出现。 -
DecimalDigits :: DecimalDigits DecimalDigit DecimalDigits 的 MV × 10 ) 加上DecimalDigit 的 MV。 -
DecimalDigits :: DecimalDigits NumericLiteralSeparator DecimalDigit DecimalDigits 的 MV × 10 ) 加上DecimalDigit 的 MV。 -
ExponentPart :: ExponentIndicator SignedInteger SignedInteger 的 MV。 -
SignedInteger :: - DecimalDigits DecimalDigits 的负值。 -
DecimalDigit :: 0 HexDigit :: 0 OctalDigit :: 0 LegacyOctalEscapeSequence :: 0 BinaryDigit :: 0 -
DecimalDigit :: 1 NonZeroDigit :: 1 HexDigit :: 1 OctalDigit :: 1 BinaryDigit :: 1 -
DecimalDigit :: 2 NonZeroDigit :: 2 HexDigit :: 2 OctalDigit :: 2 -
DecimalDigit :: 3 NonZeroDigit :: 3 HexDigit :: 3 OctalDigit :: 3 -
DecimalDigit :: 4 NonZeroDigit :: 4 HexDigit :: 4 OctalDigit :: 4 -
DecimalDigit :: 5 NonZeroDigit :: 5 HexDigit :: 5 OctalDigit :: 5 -
DecimalDigit :: 6 NonZeroDigit :: 6 HexDigit :: 6 OctalDigit :: 6 -
DecimalDigit :: 7 NonZeroDigit :: 7 HexDigit :: 7 OctalDigit :: 7 -
DecimalDigit :: 8 NonZeroDigit :: 8 NonOctalDigit :: 8 HexDigit :: 8 -
DecimalDigit :: 9 NonZeroDigit :: 9 NonOctalDigit :: 9 HexDigit :: 9 -
HexDigit :: a HexDigit :: A -
HexDigit :: b HexDigit :: B -
HexDigit :: c HexDigit :: C -
HexDigit :: d HexDigit :: D -
HexDigit :: e HexDigit :: E -
HexDigit :: f HexDigit :: F -
BinaryDigits :: BinaryDigits BinaryDigit BinaryDigits 的 MV × 2 ) 加上BinaryDigit 的 MV。 -
BinaryDigits :: BinaryDigits NumericLiteralSeparator BinaryDigit BinaryDigits 的 MV × 2 ) 加上BinaryDigit 的 MV。 -
OctalDigits :: OctalDigits OctalDigit OctalDigits 的 MV × 8 ) 加上OctalDigit 的 MV。 -
OctalDigits :: OctalDigits NumericLiteralSeparator OctalDigit OctalDigits 的 MV × 8 ) 加上OctalDigit 的 MV。 -
LegacyOctalIntegerLiteral :: LegacyOctalIntegerLiteral OctalDigit LegacyOctalIntegerLiteral 的 MV × 8 ) 加上OctalDigit 的 MV。 -
NonOctalDecimalIntegerLiteral :: LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit LegacyOctalLikeDecimalIntegerLiteral 的 MV × 10 ) 加上NonOctalDigit 的 MV。 -
NonOctalDecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral DecimalDigit NonOctalDecimalIntegerLiteral 的 MV × 10 ) 加上DecimalDigit 的 MV。 -
LegacyOctalLikeDecimalIntegerLiteral :: LegacyOctalLikeDecimalIntegerLiteral OctalDigit LegacyOctalLikeDecimalIntegerLiteral 的 MV × 10 ) 加上OctalDigit 的 MV。 -
HexDigits :: HexDigits HexDigit HexDigits 的 MV × 16 ) 加上HexDigit 的 MV。 -
HexDigits :: HexDigits NumericLiteralSeparator HexDigit HexDigits 的 MV × 16 ) 加上HexDigit 的 MV。
12.9.3.3 静态语义：NumericValue
- 返回
RoundMVResult (DecimalLiteral 的 MV)。
- 返回
𝔽 (NonDecimalIntegerLiteral 的 MV)。
- 返回
𝔽 (LegacyOctalIntegerLiteral 的 MV)。
- 返回
BigInt 值 的 MVNonDecimalIntegerLiteral 。
- 返回
0 ℤ。
- 返回
BigInt 值 的 MVNonZeroDigit 。
- 让 n 为
DecimalDigits 中代码点的数量，排除所有NumericLiteralSeparator 的出现。 - 让 mv 为 (
NonZeroDigit 的 MV × 10n) 加上DecimalDigits 的 MV。 - 返回
ℤ (mv)。
12.9.4 字符串字面量
字符串字面量是用单引号或双引号括起来的 0 个或更多 Unicode 代码点。Unicode 代码点也可以通过转义序列表示。除了闭合引号的代码点、U+005C（反斜杠）、U+000D（回车符）和
U+000A（换行符）外，所有代码点都可以直接出现在字符串字面量中。任何代码点都可以以转义序列的形式出现。字符串字面量求值为 ECMAScript 字符串值。在生成这些字符串值时，Unicode 代码点按照
语法
非终结符
<LF> 和 <CR> 不能出现在字符串字面量中，除非作为 \n 或 \u000A。
12.9.4.1 静态语义：早期错误
- 如果
此产生式匹配的源文本 是严格模式代码 ，则这是一个语法错误。
12.9.4.2 静态语义：SV
字符串字面量表示
-
StringLiteral :: " " -
StringLiteral :: ' ' -
DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharacters 字符串连接 的 SVDoubleStringCharacter 和DoubleStringCharacters 。 -
SingleStringCharacters :: SingleStringCharacter SingleStringCharacters 字符串连接 的 SVSingleStringCharacter 和SingleStringCharacters 。 -
DoubleStringCharacter :: SourceCharacter 但不能是 " 或\ 或LineTerminator 之一UTF16EncodeCodePoint 的结果。 -
DoubleStringCharacter :: <LS> -
DoubleStringCharacter :: <PS> -
DoubleStringCharacter :: LineContinuation -
SingleStringCharacter :: SourceCharacter 但不能是 ' 或\ 或LineTerminator 之一UTF16EncodeCodePoint 的结果。 -
SingleStringCharacter :: <LS> -
SingleStringCharacter :: <PS> -
SingleStringCharacter :: LineContinuation -
EscapeSequence :: 0 -
CharacterEscapeSequence :: SingleEscapeCharacter SingleEscapeCharacter 根据表 38 确定。
| 转义序列 | 代码单元值 | Unicode 字符名称 | 符号 |
|---|---|---|---|
\b |
0x0008 |
退格符 | <BS> |
\t |
0x0009 |
字符制表符 | <HT> |
\n |
0x000A |
换行符 (LF) | <LF> |
\v |
0x000B |
行制表符 | <VT> |
\f |
0x000C |
换页符 (FF) | <FF> |
\r |
0x000D |
回车符 (CR) | <CR> |
\" |
0x0022 |
引号 | " |
\' |
0x0027 |
撇号 | ' |
\\ |
0x005C |
反斜杠 | \ |
-
NonEscapeCharacter :: SourceCharacter 但不能是 EscapeCharacter 或LineTerminator 之一UTF16EncodeCodePoint 的结果。 -
EscapeSequence :: LegacyOctalEscapeSequence LegacyOctalEscapeSequence 的 MV。 -
NonOctalDecimalEscapeSequence :: 8 -
NonOctalDecimalEscapeSequence :: 9 -
HexEscapeSequence :: x HexDigit HexDigit HexEscapeSequence 的 MV。 -
Hex4Digits :: HexDigit HexDigit HexDigit HexDigit Hex4Digits 的 MV。 -
UnicodeEscapeSequence :: u{ CodePoint } CodePoint 的 MV 执行UTF16EncodeCodePoint 的结果。 -
TemplateEscapeSequence :: 0
12.9.4.3 静态语义：MV
-
LegacyOctalEscapeSequence :: ZeroToThree OctalDigit ZeroToThree 的 MV) 加上OctalDigit 的 MV。 -
LegacyOctalEscapeSequence :: FourToSeven OctalDigit FourToSeven 的 MV) 加上OctalDigit 的 MV。 -
LegacyOctalEscapeSequence :: ZeroToThree OctalDigit OctalDigit ZeroToThree 的 MV) 加上 (8 倍的第一个OctalDigit 的 MV) 加上第二个OctalDigit 的 MV。 -
ZeroToThree :: 0 -
ZeroToThree :: 1 -
ZeroToThree :: 2 -
ZeroToThree :: 3 -
FourToSeven :: 4 -
FourToSeven :: 5 -
FourToSeven :: 6 -
FourToSeven :: 7 -
HexEscapeSequence :: x HexDigit HexDigit HexDigit 的 MV) 加上第二个HexDigit 的 MV。 -
Hex4Digits :: HexDigit HexDigit HexDigit HexDigit HexDigit 的 MV) 加上 (0x100 倍的第二个HexDigit 的 MV) 加上 (0x10 倍的第三个HexDigit 的 MV) 加上第四个HexDigit 的 MV。
12.9.5 正则表达式字面量
下面的生成式描述了正则表达式字面量的语法，并由输入元素扫描器用于查找正则表达式字面量的结束位置。包含
实现可以扩展
语法
正则表达式字面量不能为空；而不是表示一个空的正则表达式字面量，代码单元序列 // 启动一个单行注释。要指定一个空的正则表达式，请使用：/(?:)/。
12.9.5.1 静态语义：BodyText
- 返回被识别为
RegularExpressionBody 的源文本。
12.9.5.2 静态语义：FlagText
- 返回被识别为
RegularExpressionFlags 的源文本。
12.9.6 模板字面量词法组件
语法
12.9.6.1 静态语义：TV
-
NoSubstitutionTemplate :: ` ` -
TemplateHead :: ` ${ -
TemplateMiddle :: } ${ -
TemplateTail :: } ` -
TemplateCharacters :: TemplateCharacter TemplateCharacters undefined ，如果TemplateCharacter 的 TV 是undefined 或TemplateCharacters 的 TV 是undefined 。否则，它是字符串连接 的 TVTemplateCharacter 和 TVTemplateCharacters 。 -
TemplateCharacter :: SourceCharacter 但不包括 ` 或\ 或$ 或LineTerminator SourceCharacter 匹配的代码点执行UTF16EncodeCodePoint 的结果。 -
TemplateCharacter :: $ -
TemplateCharacter :: \ TemplateEscapeSequence SV TemplateEscapeSequence 。 -
TemplateCharacter :: \ NotEscapeSequence undefined 。 -
TemplateCharacter :: LineTerminatorSequence TRV LineTerminatorSequence 。 -
LineContinuation :: \ LineTerminatorSequence
12.9.6.2 静态语义：TRV
-
NoSubstitutionTemplate :: ` ` -
TemplateHead :: ` ${ -
TemplateMiddle :: } ${ -
TemplateTail :: } ` -
TemplateCharacters :: TemplateCharacter TemplateCharacters 字符串连接 的 TRVTemplateCharacter 和 TRVTemplateCharacters 。 -
TemplateCharacter :: SourceCharacter 但不包括 ` 或\ 或$ 或LineTerminator SourceCharacter 匹配的代码点执行UTF16EncodeCodePoint 的结果。 -
TemplateCharacter :: $ -
TemplateCharacter :: \ TemplateEscapeSequence 字符串连接 的代码单元 0x005C（反斜杠）和TemplateEscapeSequence 的 TRV。 -
TemplateCharacter :: \ NotEscapeSequence 字符串连接 的代码单元 0x005C（反斜杠）和NotEscapeSequence 的 TRV。 -
TemplateEscapeSequence :: 0 -
NotEscapeSequence :: 0 DecimalDigit 字符串连接 的代码单元 0x0030（数字零）和DecimalDigit 的 TRV。 -
NotEscapeSequence :: x [lookahead ∉ HexDigit ] -
NotEscapeSequence :: x HexDigit [lookahead ∉ HexDigit ]字符串连接 的代码单元 0x0078（拉丁字母小写 x）和HexDigit 的 TRV。 -
NotEscapeSequence :: u [lookahead ∉ HexDigit ][lookahead ≠ { ] -
NotEscapeSequence :: u HexDigit [lookahead ∉ HexDigit ]字符串连接 的代码单元 0x0075（拉丁字母小写 u）和HexDigit 的 TRV。 -
NotEscapeSequence :: u HexDigit HexDigit [lookahead ∉ HexDigit ]字符串连接 的代码单元 0x0075（拉丁字母小写 u）、第一个HexDigit 的 TRV 和第二个HexDigit 的 TRV。 -
NotEscapeSequence :: u HexDigit HexDigit HexDigit [lookahead ∉ HexDigit ]字符串连接 的代码单元 0x0075（拉丁字母小写 u）、第一个HexDigit 的 TRV、第二个HexDigit 的 TRV 和第三个HexDigit 的 TRV。 -
NotEscapeSequence :: u { [lookahead ∉ HexDigit ]字符串连接 的代码单元 0x0075（拉丁字母小写 u）和代码单元 0x007B（左花括号）。 -
NotEscapeSequence :: u { NotCodePoint [lookahead ∉ HexDigit ]字符串连接 的代码单元 0x0075（拉丁字母小写 u）、代码单元 0x007B（左花括号）和NotCodePoint 的 TRV。 -
NotEscapeSequence :: u { CodePoint [lookahead ∉ HexDigit ][lookahead ≠ } ]字符串连接 的代码单元 0x0075（拉丁字母小写 u）、代码单元 0x007B（左花括号）和CodePoint 的 TRV。 -
DecimalDigit :: 之一 0 1 2 3 4 5 6 7 8 9 UTF16EncodeCodePoint 的结果。 -
CharacterEscapeSequence :: NonEscapeCharacter SV NonEscapeCharacter 。 -
SingleEscapeCharacter :: 之一 ' " \ b f n r t v UTF16EncodeCodePoint 的结果。 -
HexEscapeSequence :: x HexDigit HexDigit 字符串连接 的代码单元 0x0078（拉丁字母小写 x）、第一个HexDigit 的 TRV 和第二个HexDigit 的 TRV。 -
UnicodeEscapeSequence :: u Hex4Digits 字符串连接 的代码单元 0x0075（拉丁字母小写 u）和Hex4Digits 的 TRV。 -
UnicodeEscapeSequence :: u{ CodePoint } 字符串连接 的代码单元 0x0075（拉丁字母小写 u）、代码单元 0x007B（左花括号）、CodePoint 的 TRV 和代码单元 0x007D（右花括号）。 -
Hex4Digits :: HexDigit HexDigit HexDigit HexDigit 字符串连接 的第一个HexDigit 的 TRV、第二个HexDigit 的 TRV、第三个HexDigit 的 TRV 和第四个HexDigit 的 TRV。 -
HexDigits :: HexDigits HexDigit 字符串连接 的HexDigits 的 TRV 和HexDigit 的 TRV。 -
HexDigit :: 之一 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F UTF16EncodeCodePoint 的结果。 -
LineContinuation :: \ LineTerminatorSequence 字符串连接 的代码单元 0x005C（反斜杠）和LineTerminatorSequence 的 TRV。 -
LineTerminatorSequence :: <LF> -
LineTerminatorSequence :: <CR> -
LineTerminatorSequence :: <LS> -
LineTerminatorSequence :: <PS> -
LineTerminatorSequence :: <CR> <LF>
12.10 自动分号插入
大多数 ECMAScript 语句和声明必须以分号结尾。这些分号总是可以显式出现在源代码中。然而，为了方便，在某些情况下，这些分号可以从源代码中省略。在这些情况下，可以通过描述分号自动插入到源代码令牌流中的那些情况来解释。
12.10.1 自动分号插入规则
在以下规则中，“令牌”是指使用当前词法
分号插入有三条基本规则：
-
当从左到右解析源文本时，遇到不允许的令牌（称为冒犯令牌）时，如果以下条件之一为真， 则会在冒犯令牌之前自动插入分号：
- 当从左到右解析源文本时，遇到输入令牌流的结尾并且解析器无法将输入令牌流解析为目标非终结符的单个实例时， 则在输入流的结尾自动插入分号。
- 当从左到右解析源文本时，遇到某些语法规则允许的令牌，但该语法规则是受限规则，并且该令牌是紧跟在标注
“[no
行终止符 here]”之后的受限规则中的第一个令牌 （因此称为受限令牌），并且受限令牌与前一个令牌之间至少有一个行终止符 分隔时， 则在受限令牌之前自动插入分号。
但是，前述规则有一个额外的优先条件：如果分号将被解析为空语句或成为for语句头中的两个分号之一，
则不会自动插入分号（见
以下是语法中唯一的受限规则：
这些受限规则的实际效果如下：
- 当遇到
++或--令牌且解析器将其视为后缀操作符，并且前一个令牌与++或--令牌之间至少有一个行终止符 时， 则在++或--令牌之前自动插入分号。 - 当遇到
continue、break、return、throw或yield令牌并且在下一个令牌之前遇到一个行终止符 时， 则在continue、break、return、throw或yield令牌之后自动插入分号。 - 当箭头函数的参数之后有一个
行终止符 且在=>令牌之前时，自动插入分号并且标点符号会导致语法错误。 - 当
async令牌之后有一个行终止符 且在function或标识符名称 或(令牌之前时，自动插入分号并且async令牌不会被视为与后续令牌相同的表达式或类元素。 - 当
async令牌之后有一个行终止符 且在*令牌之前时，自动插入分号并且标点符号会导致语法错误。
因此，对ECMAScript程序员的实际建议是：
12.10.2 自动分号插入的示例
本节为非规范性内容。以下源代码
{ 1 2 } 3即使使用自动分号插入规则，也不是 ECMAScript 语法中的有效句子。相反，以下源代码
{ 1
2 } 3也不是有效的 ECMAScript 句子，但通过自动分号插入会被转换为以下内容：
{ 1
;2 ;} 3;这是一个有效的 ECMAScript 句子。
以下源代码
for (a; b
)不是有效的 ECMAScript 句子，且不会因自动分号插入而改变，因为 for 语句头部需要的分号。自动分号插入永远不会插入 for 语句头部的两个分号之一。
以下源代码
return
a + b通过自动分号插入会被转换为以下内容：
return;
a + b;表达式 a + b 不会被视为 return 语句要返回的值，因为 return 与 a + b
之间有一个
以下源代码
a = b
++c通过自动分号插入会被转换为以下内容：
a = b;
++c;符号 ++ 不会被视为应用于变量 b 的后缀运算符，因为 b 与 ++ 之间有一个
以下源代码
if (a > b)
else c = d不是有效的 ECMAScript 句子，且即使在 else 符号之前没有任何语法规则适用，自动分号插入也不会改变，因为自动插入的分号会被解析为一个空语句。
以下源代码
a = b + c
(d + e).print()不会被自动分号插入规则改变，因为第二行开始的括号表达式可以被解释为函数调用的参数列表：
a = b + c(d + e).print()在赋值语句必须以左括号开始的情况下，程序员最好在前一条语句的末尾提供一个显式分号，而不是依赖自动分号插入。
12.10.3 自动分号插入的有趣案例
本节为非规范性内容。ECMAScript 程序可以通过依赖自动分号插入来以很少分号的风格编写。如上所述，分号并不会在每个换行处插入，自动分号插入可能依赖跨行终止符的多个标记。
随着新的语法特性被添加到 ECMAScript 中，可能会增加一些语法产生式，这会导致依赖自动分号插入的行在解析时改变语法产生式。
在本节的目的中，如果某个地方的分号是否插入取决于之前的源文本，则该自动分号插入的案例被认为是有趣的。本节的其余部分描述了 ECMAScript 这一版本中一些有趣的自动分号插入案例。
12.10.3.1 语句列表中自动分号插入的有趣案例
在一个
- 开括号 (
()。没有分号，这两行会被视为一个CallExpression 。 - 开方括号 (
[)。没有分号，这两行会被视为属性访问，而不是一个ArrayLiteral 或ArrayAssignmentPattern 。 - 模板字符串 (
`)。没有分号，这两行会被解释为一个标记模板 (13.3.11 )，前一个表达式作为MemberExpression 。 - 一元
+或-。没有分号，这两行会被解释为使用对应的二元运算符。 - 正则表达式文字。没有分号，这两行可能会被解析为
/MultiplicativeOperator ，例如如果正则表达式有标志。
12.10.3.2 自动分号插入和“[无 行终止符 这里]”的案例
本节为非规范性内容。
ECMAScript 包含一些语法产生式，它们包括“[无
本节的其余部分描述了 ECMAScript 这一版本中使用“[无
12.10.3.2.1 带有可选操作数和“[无 行终止符 这里]”的语法产生式列表
UpdateExpression 。ContinueStatement 。BreakStatement 。ReturnStatement 。YieldExpression 。- 异步函数定义 (
15.8 ) 与函数定义 (15.2 ) 相关。
13 ECMAScript 语言：表达式
13.1 标识符
语法
yield 和 await 在语法中允许作为
let
await 0;13.1.1 静态语义：早期错误
-
如果
由该生成式匹配的源文本 包含在严格模式代码 中，并且StringValue 的Identifier 是"arguments" 或"eval" ，那么这是一个语法错误。
-
如果
由该生成式匹配的源文本 包含在严格模式代码 中，那么这是一个语法错误。
- 如果该生成式有一个 [Yield] 参数，那么这是一个语法错误。
- 如果该生成式有一个 [Await] 参数，那么这是一个语法错误。
-
如果该生成式有一个 [Yield] 参数，并且
StringValue 的Identifier 是"yield" ，那么这是一个语法错误。 -
如果该生成式有一个 [Await] 参数，并且
StringValue 的Identifier 是"await" ，那么这是一个语法错误。
-
如果这个短语包含在
严格模式代码 中，并且StringValue 的IdentifierName 是"implements" 、"interface" 、"let" 、"package" 、"private" 、"protected" 、"public" 、"static" 或"yield" ，那么这是一个语法错误。 -
如果语法的
目标符号 是Module ，并且StringValue 的IdentifierName 是"await" ，那么这是一个语法错误。 -
如果
StringValue 的IdentifierName 是任何ReservedWord 的StringValue ，除了yield或await，那么这是一个语法错误。
13.1.2 静态语义：StringValue
- 让 idTextUnescaped 为
IdentifierCodePoints 的IdentifierName 。 - 返回
CodePointsToString (idTextUnescaped)。
- 返回
"yield" 。
- 返回
"await" 。
- 返回
StringValue 的IdentifierName 。
- 返回 0x0023（数字符号）和
StringValue 的IdentifierName 的字符串连接 。
- 返回
SV 的StringLiteral 。
13.1.3 运行时语义：评估
-
返回 ?
ResolveBinding (StringValue 的Identifier )。
-
返回 ?
ResolveBinding ("yield" )。
-
返回 ?
ResolveBinding ("await" )。
评估
在 yield
可以用作标识符。评估 yield 解析为
13.2 主要表达式
语法
补充语法
当处理如下产生式实例时
对
13.2.1 this 关键字
13.2.1.1 运行时语义：求值
- 返回 ?
ResolveThisBinding ().
13.2.2 标识符引用
关于
13.2.3 字面量
语法
13.2.3.1 运行时语义：求值
- 返回
null 。
- 如果
BooleanLiteral 是标记false，返回false 。 - 如果
BooleanLiteral 是标记true，返回true 。
- 返回
NumericValue 的NumericLiteral ，如12.9.3 中定义。
- 返回
SV 的StringLiteral ，如12.9.4.2 中定义。
13.2.4 数组初始化器
数组元素可以在元素列表的开头、中间或结尾省略。每当元素列表中的逗号前没有
语法
13.2.4.1 运行时语义：数组积累
- 返回 ?
ArrayAccumulation ofElision with arguments array and (nextIndex + 1)。
- 如果
Elision 存在，则- 设置 nextIndex 为 ?
ArrayAccumulation ofElision with arguments array and nextIndex。
- 设置 nextIndex 为 ?
- 令 initResult 为 ?
Evaluation ofAssignmentExpression 。 - 令 initValue 为 ?
GetValue (initResult)。 - 执行 !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (nextIndex)), initValue)。 - 返回 nextIndex + 1。
- 如果
Elision 存在，则- 设置 nextIndex 为 ?
ArrayAccumulation ofElision with arguments array and nextIndex。
- 设置 nextIndex 为 ?
- 返回 ?
ArrayAccumulation ofSpreadElement with arguments array and nextIndex。
- 令 spreadRef 为 ?
Evaluation ofAssignmentExpression 。 - 令 spreadObj 为 ?
GetValue (spreadRef)。 - 令 iteratorRecord 为 ?
GetIterator (spreadObj,sync )。 - 重复，
- 令 next 为 ?
IteratorStepValue (iteratorRecord)。 - 如果 next 为
done ，返回 nextIndex。 - 执行 !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (nextIndex)), next)。 - 设置 nextIndex 为 nextIndex + 1。
- 令 next 为 ?
13.2.4.2 运行时语义：求值
- 令 array 为 !
ArrayCreate (0)。 - 如果
Elision 存在，则- 执行 ?
ArrayAccumulation ofElision with arguments array and 0。
- 执行 ?
- 返回 array。
- 令 array 为 !
ArrayCreate (0)。 - 执行 ?
ArrayAccumulation ofElementList with arguments array and 0。 - 返回 array。
- 令 array 为 !
ArrayCreate (0)。 - 令 nextIndex 为 ?
ArrayAccumulation ofElementList with arguments array and 0。 - 如果
Elision 存在，则- 执行 ?
ArrayAccumulation ofElision with arguments array and nextIndex。
- 执行 ?
- 返回 array。
13.2.5 对象初始化器
对象初始化器是一个描述对象初始化的表达式，写成类似字面量的形式。它是一个由零个或多个
语法
在某些上下文中，
13.2.5.1 静态语义：早期错误
-
如果
HasDirectSuper ofMethodDefinition 是true ，则这是语法错误。 -
如果
PrivateBoundIdentifiers ofMethodDefinition 不为空，则这是语法错误。
除了描述实际的对象初始化器外，
- 如果任何源文本与此生产匹配，则这是语法错误。
此生产的存在是为了使
-
如果
PropertyNameList ofPropertyDefinitionList 包含任何__proto__的重复条目，并且这些条目中至少有两个是从PropertyDefinition : PropertyName : AssignmentExpression ObjectLiteral 包含在Script 中，并且正在为JSON.parse解析（请参阅JSON.parse 的步骤4 ），则不适用此规则。
由
13.2.5.2 静态语义：IsComputedPropertyKey
- 返回
false 。
- 返回
true 。
13.2.5.3 静态语义：PropertyNameList
- 让propName成为
PropName ofPropertyDefinition 。 - 如果propName是
empty ，则返回一个新的空列表 。 - 返回« propName »。
- 让list成为
PropertyNameList ofPropertyDefinitionList 。 - 让propName成为
PropName ofPropertyDefinition 。 - 如果propName是
empty ，则返回list。 - 返回
列表连接 of list和« propName »。
13.2.5.4 运行时语义：求值
- 让obj成为
OrdinaryObjectCreate (%Object.prototype% )。 - 对
PropertyDefinitionList 执行PropertyDefinitionEvaluation ，参数为obj。 - 返回obj。
- 返回
StringValue ofIdentifierName 。
- 返回
SV ofStringLiteral 。
- 让nbr成为
NumericValue ofNumericLiteral 。 - 返回!
ToString (nbr)。
- 让exprValue成为
Evaluation ofAssignmentExpression 。 - 让propName成为
GetValue (exprValue)。 - 返回
ToPropertyKey (propName)。
13.2.5.5 运行时语义：PropertyDefinitionEvaluation
- 对
PropertyDefinitionList 执行PropertyDefinitionEvaluation ，参数为object。 - 对
PropertyDefinition 执行PropertyDefinitionEvaluation ，参数为object。 - 返回
unused 。
- 让exprValue成为
Evaluation ofAssignmentExpression 。 - 让fromValue成为
GetValue (exprValue)。 - 让excludedNames成为一个新的空
列表 。 - 对object、fromValue和excludedNames执行
CopyDataProperties 。 - 返回
unused 。
- 让propName成为
StringValue ofIdentifierReference 。 - 让exprValue成为
Evaluation ofIdentifierReference 。 - 让propValue成为
GetValue (exprValue)。 断言 ：object是一个普通的、可扩展的对象，没有不可配置的属性。- 对object、propName和propValue执行
CreateDataPropertyOrThrow 。 - 返回
unused 。
- 让propKey成为
Evaluation ofPropertyName 。 - 如果此
PropertyDefinition 包含在一个Script 中，并且正在为JSON.parse求值（请参阅7 ofJSON.parse ），则- 让isProtoSetter成为
false 。
- 让isProtoSetter成为
- 否则，如果propKey是__proto__并且
IsComputedPropertyKey ofPropertyName 是false ，则- 让isProtoSetter成为
true 。
- 让isProtoSetter成为
- 否则，
- 让isProtoSetter成为
false 。
- 让isProtoSetter成为
- 如果
IsAnonymousFunctionDefinition ofAssignmentExpression 是true 并且isProtoSetter是false ，则- 让propValue成为
NamedEvaluation ofAssignmentExpression with argument propKey。
- 让propValue成为
- 否则，
- 让exprValueRef成为
Evaluation ofAssignmentExpression 。 - 让propValue成为
GetValue (exprValueRef)。
- 让exprValueRef成为
- 如果isProtoSetter是
true ，则- 如果propValue是
一个对象 或propValue是null，则- 执行!object.[[SetPrototypeOf]](propValue)。
- 返回
unused 。
- 如果propValue是
断言 ：object是一个普通的、可扩展的对象，没有不可配置的属性。- 对object、propKey和propValue执行
CreateDataPropertyOrThrow 。 - 返回
unused 。
- 对
MethodDefinition 执行MethodDefinitionEvaluation ，参数为object和true 。 - 返回
unused 。
13.2.6 函数定义表达式
参见
参见
参见
13.2.7 正则表达式字面量
语法
参见
13.2.7.1 静态语义：早期错误
- 如果
IsValidRegularExpressionLiteral (RegularExpressionLiteral )为false ，则这是一个语法错误。
13.2.7.2 静态语义：IsValidRegularExpressionLiteral(literal)
抽象操作IsValidRegularExpressionLiteral接受参数literal（一个
- 令flags为
FlagText 的literal。 - 如果flags包含
d、g、i、m、s、u、v或y之外的任何代码点，或flags包含的任何代码点不止一次，则返回false 。 - 如果flags包含
u，则令u为true ；否则令u为false 。 - 如果flags包含
v，则令v为true ；否则令v为false 。 - 令patternText为
BodyText 的literal。 - 如果u为
false 且v为false ，则- 令stringValue为
CodePointsToString (patternText)。 - 将patternText设置为解释stringValue的每个16位元素为Unicode BMP代码点而得到的代码点序列。不对元素应用UTF-16解码。
- 令stringValue为
- 令parseResult为
ParsePattern (patternText, u, v)。 - 如果parseResult是一个
Parse Node ，则返回true ；否则返回false 。
13.2.7.3 运行时语义：求值
- 令pattern为
CodePointsToString (BodyText 的RegularExpressionLiteral )。 - 令flags为
CodePointsToString (FlagText 的RegularExpressionLiteral )。 - 返回!
RegExpCreate (pattern, flags)。
13.2.8 模板字面量
语法
13.2.8.1 静态语义: 早期错误
-
如果 [Tagged] 参数未设置，并且
NoSubstitutionTemplate Contains NotEscapeSequence ，则这是一个语法错误。
-
如果
TemplateStrings 的结果中元素的数量大于或等于 232，则这是一个语法错误。
-
如果 [Tagged] 参数未设置，并且
TemplateHead Contains NotEscapeSequence ，则这是一个语法错误。
-
如果 [Tagged] 参数未设置，并且
TemplateTail Contains NotEscapeSequence ，则这是一个语法错误。
-
如果 [Tagged] 参数未设置，并且
TemplateMiddle Contains NotEscapeSequence .
13.2.8.2 静态语义：模板字符串
模板字符串是一个
- 返回 «
TemplateString (NoSubstitutionTemplate , raw) ».
- 设 head 为 «
TemplateString (TemplateHead , raw) ». - 设 tail 为
TemplateStrings ofTemplateSpans with argument raw. - 返回 head 和 tail 的
列表连接 .
- 返回 «
TemplateString (TemplateTail , raw) ».
- 设 middle 为
TemplateStrings ofTemplateMiddleList with argument raw. - 设 tail 为 «
TemplateString (TemplateTail , raw) ». - 返回 middle 和 tail 的
列表连接 .
- 返回 «
TemplateString (TemplateMiddle , raw) ».
- 设 front 为
TemplateStrings ofTemplateMiddleList with argument raw. - 设 last 为 «
TemplateString (TemplateMiddle , raw) ». - 返回 front 和 last 的
列表连接 .
13.2.8.3 静态语义：TemplateString ( templateToken, raw )
抽象操作 TemplateString 接受参数 templateToken（一个
如果 raw 是
13.2.8.4 GetTemplateObject ( templateLiteral )
抽象操作 GetTemplateObject 接受参数 templateLiteral（一个
- 设 realm 为
当前领域记录 。 - 设 templateRegistry 为 realm.[[TemplateMap]]。
- 对于 templateRegistry 中的每个元素 e，执行
- 如果 e.[[Site]] 是
与 templateLiteral 相同的解析节点 ，则- 返回 e.[[Array]]。
- 如果 e.[[Site]] 是
- 设 rawStrings 为
TemplateStrings of templateLiteral with argumenttrue 。 断言 ：rawStrings 是一个字符串列表 。- 设 cookedStrings 为
TemplateStrings of templateLiteral with argumentfalse 。 - 设 count 为 cookedStrings 的元素数量。
断言 ：count ≤ 232 - 1。- 设 template 为 !
ArrayCreate (count)。 - 设 rawObj 为 !
ArrayCreate (count)。 - 设 index 为 0。
- 重复，当 index < count 时，
- 设 prop 为 !
ToString (𝔽 (index))。 - 设 cookedValue 为 cookedStrings[index]。
- 执行 !
DefinePropertyOrThrow (template, prop, PropertyDescriptor { [[Value]]: cookedValue, [[Writable]]:false , [[Enumerable]]:true , [[Configurable]]:false })。 - 设 rawValue 为字符串值 rawStrings[index]。
- 执行 !
DefinePropertyOrThrow (rawObj, prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]:false , [[Enumerable]]:true , [[Configurable]]:false })。 - 设 index 为 index + 1。
- 设 prop 为 !
- 执行 !
SetIntegrityLevel (rawObj,frozen )。 - 执行 !
DefinePropertyOrThrow (template,"raw" , PropertyDescriptor { [[Value]]: rawObj, [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:false })。 - 执行 !
SetIntegrityLevel (template,frozen )。 - 将记录 { [[Site]]: templateLiteral, [[Array]]: template } 追加到 realm.[[TemplateMap]]。
- 返回 template。
模板对象的创建不会导致
程序代码中的每个
本规范的未来版本可能会定义模板对象的附加不可枚举属性。
13.2.8.5 运行时语义：SubstitutionEvaluation
SubstitutionEvaluation 是一个
- 返回一个新的空
列表 。
- 返回 ?
SubstitutionEvaluation ofTemplateMiddleList 。
- 设 subRef 为 ?
Evaluation ofExpression 。 - 设 sub 为 ?
GetValue (subRef)。 - 返回 « sub »。
- 设 preceding 为 ?
SubstitutionEvaluation ofTemplateMiddleList 。 - 设 nextRef 为 ?
Evaluation ofExpression 。 - 设 next 为 ?
GetValue (nextRef)。 - 返回 preceding 和 « next » 的
列表连接 。
13.2.8.6 运行时语义：求值
- 返回
NoSubstitutionTemplate 的TV ，定义在12.9.6 。
- 设 head 为
TemplateHead 的TV ，定义在12.9.6 。 - 设 subRef 为 ?
Evaluation ofExpression 。 - 设 sub 为 ?
GetValue (subRef)。 - 设 middle 为 ?
ToString (sub)。 - 设 tail 为 ?
Evaluation ofTemplateSpans 。 - 返回 head、middle 和 tail 的
字符串连接 。
String.prototype.concat 而不是 + 运算符。
- 返回
TemplateTail 的TV ，定义在12.9.6 。
- 设 head 为 ?
Evaluation ofTemplateMiddleList 。 - 设 tail 为
TemplateTail 的TV ，定义在12.9.6 。 - 返回 head 和 tail 的
字符串连接 。
- 设 head 为
TemplateMiddle 的TV ，定义在12.9.6 。 - 设 subRef 为 ?
Evaluation ofExpression 。 - 设 sub 为 ?
GetValue (subRef)。 - 设 middle 为 ?
ToString (sub)。 - 返回 head 和 middle 的
字符串连接 。
String.prototype.concat 而不是 + 运算符。
- 设 rest 为 ?
Evaluation ofTemplateMiddleList 。 - 设 middle 为
TemplateMiddle 的TV ，定义在12.9.6 。 - 设 subRef 为 ?
Evaluation ofExpression 。 - 设 sub 为 ?
GetValue (subRef)。 - 设 last 为 ?
ToString (sub)。 - 返回 rest、middle 和 last 的
字符串连接 。
String.prototype.concat 而不是 + 运算符。
13.2.9 分组运算符
13.2.9.1 静态语义：早期错误
13.2.9.2 运行时语义：求值
- 设 expr 为
ParenthesizedExpression 被覆盖 的CoverParenthesizedExpressionAndArrowParameterList 。 - 返回 ?
Evaluation of expr。
- 返回 ?
Evaluation ofExpression 。这可能是 Reference 类型。
此算法不会对 delete 和 typeof 等运算符应用于带括号的表达式。
13.3 左值表达式
语法
补充语法
当处理以下产生式的一个实例时
13.3.1 静态语义
13.3.1.1 静态语义：早期错误
- 如果任何源代码与此产生式匹配，则这是一个语法错误。
此产生式存在是为了防止自动分号插入规则（
a?.b
`c`以便将其解释为两个有效的语句。目的是保持与没有可选链的类似代码的一致性：
a.b
`c`这是一个有效的语句，并且自动分号插入不适用。
13.3.2 属性访问器
属性通过名称访问，使用点表示法：
或方括号表示法：
点表示法通过以下句法转换解释：
其行为与以下相同：
同样地：
其行为与以下相同：
其中 <identifier-name-string> 是评估
13.3.2.1 运行时语义：评估
- 设 baseReference 为 ?
Evaluation 的MemberExpression 。 - 设 baseValue 为 ?
GetValue (baseReference)。 - 如果
源代码匹配 此MemberExpression 是严格模式代码 ，设 strict 为true ；否则设 strict 为false 。 - 返回 ?
EvaluatePropertyAccessWithExpressionKey (baseValue,Expression , strict)。
- 设 baseReference 为 ?
Evaluation 的MemberExpression 。 - 设 baseValue 为 ?
GetValue (baseReference)。 - 如果
源代码匹配 此MemberExpression 是严格模式代码 ，设 strict 为true ；否则设 strict 为false 。 - 返回
EvaluatePropertyAccessWithIdentifierKey (baseValue,IdentifierName , strict)。
- 设 baseReference 为 ?
Evaluation 的MemberExpression 。 - 设 baseValue 为 ?
GetValue (baseReference)。 - 设 fieldNameString 为
StringValue 的PrivateIdentifier 。 - 返回
MakePrivateReference (baseValue, fieldNameString)。
- 设 baseReference 为 ?
Evaluation 的CallExpression 。 - 设 baseValue 为 ?
GetValue (baseReference)。 - 如果
源代码匹配 此CallExpression 是严格模式代码 ，设 strict 为true ；否则设 strict 为false 。 - 返回 ?
EvaluatePropertyAccessWithExpressionKey (baseValue,Expression , strict)。
- 设 baseReference 为 ?
Evaluation 的CallExpression 。 - 设 baseValue 为 ?
GetValue (baseReference)。 - 如果
源代码匹配 此CallExpression 是严格模式代码 ，设 strict 为true ；否则设 strict 为false 。 - 返回
EvaluatePropertyAccessWithIdentifierKey (baseValue,IdentifierName , strict)。
- 设 baseReference 为 ?
Evaluation 的CallExpression 。 - 设 baseValue 为 ?
GetValue (baseReference)。 - 设 fieldNameString 为
StringValue 的PrivateIdentifier 。 - 返回
MakePrivateReference (baseValue, fieldNameString)。
13.3.3 EvaluatePropertyAccessWithExpressionKey ( baseValue, expression, strict )
抽象操作 EvaluatePropertyAccessWithExpressionKey 接受参数 baseValue（一个
- 设 propertyNameReference 为 ?
Evaluation 的 expression。 - 设 propertyNameValue 为 ?
GetValue (propertyNameReference)。 - 设 propertyKey 为 ?
ToPropertyKey (propertyNameValue)。 - 返回
引用记录 { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]:empty }。
13.3.4 EvaluatePropertyAccessWithIdentifierKey ( baseValue, identifierName, strict )
抽象操作 EvaluatePropertyAccessWithIdentifierKey 接受参数 baseValue（一个
- 设 propertyNameString 为
StringValue 的 identifierName。 - 返回
引用记录 { [[Base]]: baseValue, [[ReferencedName]]: propertyNameString, [[Strict]]: strict, [[ThisValue]]:empty }。
13.3.5 The new Operator
13.3.5.1 运行时语义：评估
- 返回 ?
EvaluateNew (NewExpression ,empty )。
- 返回 ?
EvaluateNew (MemberExpression ,Arguments )。
13.3.5.1.1 EvaluateNew ( constructExpr, arguments )
抽象操作 EvaluateNew 接受参数 constructExpr（一个
- 设 ref 为 ?
Evaluation 的 constructExpr。 - 设 constructor 为 ?
GetValue (ref)。 - 如果 arguments 是
empty ，- 设 argList 为一个新空的
列表 。
- 设 argList 为一个新空的
- 否则，
- 设 argList 为 ?
ArgumentListEvaluation 的 arguments。
- 设 argList 为 ?
- 如果
IsConstructor (constructor) isfalse ，抛出一个TypeError 异常。 - 返回 ?
Construct (constructor, argList)。
13.3.6 Function Calls
13.3.6.1 运行时语义：评估
- 设 expr 为
CallMemberExpression 被CoverCallExpressionAndAsyncArrowHead 覆盖的部分。 - 设 memberExpr 为 expr 的
MemberExpression 。 - 设 arguments 为 expr 的
Arguments 。 - 设 ref 为 ?
Evaluation 的 memberExpr。 - 设 func 为 ?
GetValue (ref)。 - 如果 ref 是一个
引用记录 ，IsPropertyReference (ref) 是false ，且 ref.[[ReferencedName]] 是"eval" ，则- 如果
SameValue (func,%eval% ) 是true ，则- 设 argList 为 ?
ArgumentListEvaluation 的 arguments。 - 如果 argList 没有元素，返回
undefined 。 - 设 evalArg 为 argList 的第一个元素。
- 如果
源代码匹配 此CallExpression 是严格模式代码 ，设 strictCaller 为true 。否则设 strictCaller 为false 。 - 返回
?
PerformEval (evalArg, strictCaller,true )。
- 设 argList 为 ?
- 如果
- 设 thisCall 为这个
CallExpression 。 - 设 tailCall 为
IsInTailPosition (thisCall)。 - 返回 ?
EvaluateCall (func, ref, arguments, tailCall)。
一个
- 设 ref 为 ?
Evaluation 的CallExpression 。 - 设 func 为 ?
GetValue (ref)。 - 设 thisCall 为这个
CallExpression 。 - 设 tailCall 为
IsInTailPosition (thisCall)。 - 返回 ?
EvaluateCall (func, ref,Arguments , tailCall)。
13.3.6.2 EvaluateCall ( func, ref, arguments, tailPosition )
抽象操作 EvaluateCall 接受参数 func（一个
- 如果 ref 是一个
引用记录 ，则- 如果
IsPropertyReference (ref) 是true ，则- 设 thisValue 为
GetThisValue (ref)。
- 设 thisValue 为
- 否则，
- 如果
- 否则，
- 设 thisValue 为
undefined 。
- 设 thisValue 为
- 设 argList 为 ?
ArgumentListEvaluation 的 arguments。 - 如果 func
不是一个对象 ，抛出一个TypeError 异常。 - 如果
IsCallable (func) 是false ，抛出一个TypeError 异常。 - 如果 tailPosition 是
true ， 执行PrepareForTailCall ()。 - 返回 ?
Call (func, thisValue, argList)。
13.3.7 The super 关键字
13.3.7.1 运行时语义：评估
- 设 env 为运行时执行上下文的
环境记录 。 - 设 home 为 env.GetSuperBase()。
- 设 propertyNameReference 为 ?
Evaluation 的表达式 。 - 设 propertyNameValue 为 ?
GetValue (propertyNameReference)。 - 设 propertyKey 为 ?
ToPropertyKey (propertyNameValue)。 - 设 strict 为
IsStrictReference (propertyNameReference)。 - 返回
MakeSuperPropertyReference (home, propertyKey, strict)。
- 设 env 为运行时执行上下文的
环境记录 。 - 设 home 为 env.GetSuperBase()。
- 设 strict 为
IsStrictReference (propertyNameReference)。 - 设 propertyKey 为
StringValue 的IdentifierName 。 - 返回
MakeSuperPropertyReference (home, propertyKey, strict)。
- 设 newTarget 为
GetNewTarget ()。 断言 ：newTarget是一个对象 。- 设 func 为
GetSuperConstructor ()。 - 设 argList 为 ?
ArgumentListEvaluation 的Arguments 。 - 如果
IsConstructor (func) 是false ，抛出一个TypeError 异常。 - 设 result 为 ?
Construct (func, argList, newTarget)。 - 设 thisER 为
GetThisEnvironment ()。 - 执行 ? thisER.BindThisValue(result)。
- 设 F 为 thisER.[[FunctionObject]]。
断言 ：F 是一个 ECMAScript函数对象 。- 执行 ?
InitializeInstanceElements (result, F)。 - 返回 result。
13.3.7.2 GetSuperConstructor ( )
抽象操作 GetSuperConstructor 不接受任何参数，并返回一个
- 设 envRec 为
GetThisEnvironment ()。 断言 ：envRec 是一个函数环境记录 。- 设 activeFunction 为 envRec.[[FunctionObject]]。
断言 ：activeFunction 是一个 ECMAScript函数对象 。- 设 superConstructor 为 ! activeFunction.[[GetPrototypeOf]]()。
- 返回 superConstructor。
13.3.7.3 MakeSuperPropertyReference ( actualThis, propertyKey, strict )
抽象操作 MakeSuperPropertyReference 接受参数 actualThis（一个
- 设 env 为
GetThisEnvironment ()。 断言 ： env.HasSuperBinding() 是true 。- 设 baseValue 为 ? env.GetSuperBase()。
- 返回
引用记录 { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }。
13.3.8 参数列表
参数列表的评估产生一个
13.3.8.1 运行时语义：参数列表评估
语法导向操作
- 返回一个新的空
列表 。
- 设ref为?
AssignmentExpression的评估。 - 设arg为?
GetValue (ref)。 - 返回 « arg »。
- 设list为一个新空
列表 。 - 设spreadRef为?
AssignmentExpression的评估。 - 设spreadObj为?
GetValue (spreadRef)。 - 设iteratorRecord为?
GetIterator (spreadObj,sync )。 - 重复,
- 设next为?
IteratorStepValue (iteratorRecord)。 - 如果next是
done ，返回 list。 - 将next添加到list。
- 设next为?
- 设precedingArgs为?
ArgumentListEvaluation ofArgumentList 。 - 设ref为?
Evaluation ofAssignmentExpression 。 - 设arg为?
GetValue (ref)。 - 返回
列表连接 of precedingArgs 和 « arg »。
- 设precedingArgs为?
ArgumentListEvaluation ofArgumentList 。 - 设spreadRef为?
Evaluation ofAssignmentExpression 。 - 设iteratorRecord为?
GetIterator (?GetValue (spreadRef),sync )。 - 重复,
- 设next为?
IteratorStepValue (iteratorRecord)。 - 如果next是
done ，返回 precedingArgs。 - 将next添加到precedingArgs。
- 设next为?
- 设templateLiteral为这个
TemplateLiteral 。 - 设siteObj为
GetTemplateObject (templateLiteral)。 - 返回 « siteObj »。
- 设templateLiteral为这个
TemplateLiteral 。 - 设siteObj为
GetTemplateObject (templateLiteral)。 - 设remaining为?
ArgumentListEvaluation ofSubstitutionTemplate 。 - 返回
列表连接 of « siteObj » 和 remaining。
- 设firstSubRef为?
Evaluation ofExpression 。 - 设firstSub为?
GetValue (firstSubRef)。 - 设restSub为?
SubstitutionEvaluation ofTemplateSpans 。 断言 : restSub 是一个 可能为空的列表 。- 返回
列表连接 of « firstSub » 和 restSub。
13.3.9 可选链
?.标记开始。13.3.9.1 运行时语义：评估
- 设baseReference为?
Evaluation ofMemberExpression 。 - 设baseValue为?
GetValue (baseReference)。 - 如果baseValue是
undefined 或null ，则- 返回
undefined 。
- 返回
- 返回?
ChainEvaluation ofOptionalChain with arguments baseValue 和 baseReference。
- 设baseReference为?
Evaluation ofCallExpression 。 - 设baseValue为?
GetValue (baseReference)。 - 如果baseValue是
undefined 或null ，则- 返回
undefined 。
- 返回
- 返回?
ChainEvaluation ofOptionalChain with arguments baseValue 和 baseReference。
- 设baseReference为?
Evaluation ofOptionalExpression 。 - 设baseValue为?
GetValue (baseReference)。 - 如果baseValue是
undefined 或null ，则- 返回
undefined 。
- 返回
- 返回?
ChainEvaluation ofOptionalChain with arguments baseValue 和 baseReference。
13.3.9.2 运行时语义：链评估
语法导向操作
- 设thisChain为这个
OptionalChain 。 - 设tailCall为
IsInTailPosition (thisChain)。 - 返回?
EvaluateCall (baseValue, baseReference,Arguments , tailCall)。
- 如果这个
OptionalChain 的源文本匹配 是严格模式代码 ，设strict为true ；否则设strict为false 。 - 返回?
EvaluatePropertyAccessWithExpressionKey (baseValue,Expression , strict)。
- 如果这个
OptionalChain 的源文本匹配 是严格模式代码 ，设strict为true ；否则设strict为false 。 - 返回
EvaluatePropertyAccessWithIdentifierKey (baseValue,IdentifierName , strict)。
- 设fieldNameString为
PrivateIdentifier 的StringValue 。 - 返回
MakePrivateReference (baseValue, fieldNameString)。
- 设optionalChain为
OptionalChain 。 - 设newReference为?
ChainEvaluation of optionalChain with arguments baseValue 和 baseReference。 - 设newValue为?
GetValue (newReference)。 - 设thisChain为这个
OptionalChain 。 - 设tailCall为
IsInTailPosition (thisChain)。 - 返回?
EvaluateCall (newValue, newReference,Arguments , tailCall)。
- 设optionalChain为
OptionalChain 。 - 设newReference为?
ChainEvaluation of optionalChain with arguments baseValue 和 baseReference。 - 设newValue为?
GetValue (newReference)。 - 如果这个
OptionalChain 的源文本匹配 是严格模式代码 ，设strict为true ；否则设strict为false 。 - 返回?
EvaluatePropertyAccessWithExpressionKey (newValue,Expression , strict)。
- 设optionalChain为
OptionalChain 。 - 设newReference为?
ChainEvaluation of optionalChain with arguments baseValue 和 baseReference。 - 设newValue为?
GetValue (newReference)。 - 如果这个
OptionalChain 的源文本匹配 是严格模式代码 ，设strict为true ；否则设strict为false 。 - 返回
EvaluatePropertyAccessWithIdentifierKey (newValue,IdentifierName , strict)。
- 设optionalChain为
OptionalChain 。 - 设newReference为?
ChainEvaluation of optionalChain with arguments baseValue 和 baseReference。 - 设newValue为?
GetValue (newReference)。 - 设fieldNameString为
PrivateIdentifier 的StringValue 。 - 返回
MakePrivateReference (newValue, fieldNameString)。
13.3.10 Import 调用
13.3.10.1 运行时语义: Evaluation
- 设referrer为
GetActiveScriptOrModule ()。 - 如果referrer是
null ，设 referrer为当前领域记录 。 - 设argRef为?
Evaluation ofAssignmentExpression 。 - 设specifier为?
GetValue (argRef)。 - 设promiseCapability为!
NewPromiseCapability (%Promise% )。 - 设specifierString为
Completion (ToString (specifier))。 IfAbruptRejectPromise (specifierString, promiseCapability)。- 执行
HostLoadImportedModule (referrer, specifierString,empty , promiseCapability)。 - 返回promiseCapability.[[Promise]]。
13.3.10.1.1 ContinueDynamicImport ( promiseCapability, moduleCompletion )
抽象操作ContinueDynamicImport接受参数promiseCapability（一个import()
- 如果moduleCompletion是一个
突然完成 ，则- 执行!
Call (promiseCapability.[[Reject]],undefined , « moduleCompletion.[[Value]] »)。 - 返回
unused 。
- 执行!
- 设module为moduleCompletion.[[Value]]。
- 设loadPromise为 module.LoadRequestedModules()。
- 设rejectedClosure为一个新
抽象闭包 ，参数为(reason)，捕获promiseCapability，并执行以下步骤：- 执行!
Call (promiseCapability.[[Reject]],undefined , « reason »)。 - 返回
unused 。
- 执行!
- 设onRejected为
CreateBuiltinFunction (rejectedClosure, 1,"" , « »)。 - 设linkAndEvaluateClosure为一个新
抽象闭包 ，无参数，捕获module、promiseCapability和 onRejected，并执行以下步骤：- 设link为
Completion (module.Link())。 - 如果link是一个
突然完成 ，则- 执行!
Call (promiseCapability.[[Reject]],undefined , « link.[[Value]] »)。 - 返回
unused 。
- 执行!
- 设evaluatePromise为 module.Evaluate()。
- 设fulfilledClosure为一个新
抽象闭包 ，无参数，捕获module和promiseCapability，并执行以下步骤：- 设namespace为
GetModuleNamespace (module)。 - 执行!
Call (promiseCapability.[[Resolve]],undefined , « namespace »)。 - 返回
unused 。
- 设namespace为
- 设onFulfilled为
CreateBuiltinFunction (fulfilledClosure, 0,"" , « »)。 - 执行
PerformPromiseThen (evaluatePromise, onFulfilled, onRejected)。 - 返回
unused 。
- 设link为
- 设linkAndEvaluate为
CreateBuiltinFunction (linkAndEvaluateClosure, 0,"" , « »)。 - 执行
PerformPromiseThen (loadPromise, linkAndEvaluate, onRejected)。 - 返回
unused 。
13.3.11 标签模板
标签模板是一个函数调用，其中调用的参数是从一个
13.3.11.1 运行时语义：评估
- 设tagRef为?
Evaluation ofMemberExpression 。 - 设tagFunc为?
GetValue (tagRef)。 - 设thisCall为这个
MemberExpression 。 - 设tailCall为
IsInTailPosition (thisCall)。 - 返回?
EvaluateCall (tagFunc, tagRef,TemplateLiteral , tailCall)。
- 设tagRef为?
Evaluation ofCallExpression 。 - 设tagFunc为?
GetValue (tagRef)。 - 设thisCall为这个
CallExpression 。 - 设tailCall为
IsInTailPosition (thisCall)。 - 返回?
EvaluateCall (tagFunc, tagRef,TemplateLiteral , tailCall)。
13.3.12 元属性
13.3.12.1 运行时语义: Evaluation
- 返回
GetNewTarget ()。
- 设 module 为
GetActiveScriptOrModule ()。 断言 ：module 是一个源文本模块记录 。- 设 importMeta 为 module.[[ImportMeta]]。
- 如果 importMeta 是
empty ， 则- 设 importMeta 为
OrdinaryObjectCreate (null )。 - 设 importMetaValues 为
HostGetImportMetaProperties (module)。 - 对于每个
记录 { [[Key]], [[Value]] } p 的 importMetaValues，执行- 执行 !
CreateDataPropertyOrThrow (importMeta, p.[[Key]], p.[[Value]])。
- 执行 !
- 执行
HostFinalizeImportMeta (importMeta, module)。 - 设 module.[[ImportMeta]] 为 importMeta。
- 返回 importMeta。
- 设 importMeta 为
- 否则，
13.3.12.1.1 HostGetImportMetaProperties ( moduleRecord )
The import.meta 返回的对象。
HostGetImportMetaProperties 的默认实现是返回一个新的空
13.3.12.1.2 HostFinalizeImportMeta ( importMeta, moduleRecord )
The import.meta
返回的对象。
大多数
HostFinalizeImportMeta 的默认实现是返回
13.4 更新表达式
语法
13.4.1 静态语义：早期错误
-
如果
AssignmentTargetType 的LeftHandSideExpression 不是simple ，则是早期语法错误。
-
如果
AssignmentTargetType 的UnaryExpression 不是simple ，则是早期语法错误。
13.4.2 后置递增运算符
13.4.2.1 运行时语义：评估
- 设 lhs 为 ?
评估 的LeftHandSideExpression 。 - 设 oldValue 为 ?
ToNumeric (?GetValue (lhs))。 - 如果 oldValue
是一个 数字 ，则- 设 newValue 为
Number::add (oldValue,1 𝔽)。
- 设 newValue 为
- 否则，
断言 ：oldValue是一个 大整数 。- 设 newValue 为
BigInt::add (oldValue,1 ℤ)。
- 执行 ?
PutValue (lhs, newValue)。 - 返回 oldValue。
13.4.3 后置递减运算符
13.4.3.1 运行时语义：评估
- 设 lhs 为 ?
评估 的LeftHandSideExpression 。 - 设 oldValue 为 ?
ToNumeric (?GetValue (lhs))。 - 如果 oldValue
是一个 数字 ，则- 设 newValue 为
Number::subtract (oldValue,1 𝔽)。
- 设 newValue 为
- 否则，
断言 ：oldValue是一个 大整数 。- 设 newValue 为
BigInt::subtract (oldValue,1 ℤ)。
- 执行 ?
PutValue (lhs, newValue)。 - 返回 oldValue。
13.4.4 前置递增运算符
13.4.4.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 设 oldValue 为 ?
ToNumeric (?GetValue (expr))。 - 如果 oldValue
是一个 数字 ，则- 设 newValue 为
Number::add (oldValue,1 𝔽)。
- 设 newValue 为
- 否则，
断言 ：oldValue是一个 大整数 。- 设 newValue 为
BigInt::add (oldValue,1 ℤ)。
- 执行 ?
PutValue (expr, newValue)。 - 返回 newValue。
13.4.5 前置递减运算符
13.4.5.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 设 oldValue 为 ?
ToNumeric (?GetValue (expr))。 - 如果 oldValue
是一个 数字 ，则- 设 newValue 为
Number::subtract (oldValue,1 𝔽)。
- 设 newValue 为
- 否则，
断言 ：oldValue是一个 大整数 。- 设 newValue 为
BigInt::subtract (oldValue,1 ℤ)。
- 执行 ?
PutValue (expr, newValue)。 - 返回 newValue。
13.5 一元运算符
语法
13.5.1 The delete 运算符
13.5.1.1 静态语义：早期错误
-
如果
UnaryExpression 包含在严格模式代码 中，并且派生的UnaryExpression 是PrimaryExpression : IdentifierReference MemberExpression : MemberExpression . PrivateIdentifier CallExpression : CallExpression . PrivateIdentifier OptionalChain : ?. PrivateIdentifier OptionalChain : OptionalChain . PrivateIdentifier -
如果派生的
UnaryExpression 是
PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
并且CoverParenthesizedExpressionAndArrowParameterList 最终派生出的短语，如果用于替代UnaryExpression ，将根据这些规则产生语法错误。此规则递归应用。
最后一项规则意味着表达式如 delete (((foo))) 会产生
13.5.1.2 运行时语义：评估
- 设 ref 为 ?
评估 的UnaryExpression 。 - 如果 ref 不是
引用记录 ，返回true 。 - 如果
IsUnresolvableReference (ref) 是true ，则断言 ：ref.[[Strict]] 是false 。- 返回
true 。
- 如果
IsPropertyReference (ref) 是true ，则断言 ：IsPrivateReference (ref) 是false 。- 如果
IsSuperReference (ref) 是true ，抛出ReferenceError 异常。 - 设 baseObj 为
?
ToObject (ref.[[Base]])。 - 设 deleteStatus 为 ? baseObj.[[Delete]](ref.[[ReferencedName]])。
- 如果 deleteStatus 是
false 并且 ref.[[Strict]] 是true ，抛出TypeError 异常。 - 返回 deleteStatus。
- 否则，
当 delete 运算符出现在 delete 运算符出现在
13.5.2 The void 运算符
13.5.2.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 执行 ?
GetValue (expr)。 - 返回
undefined 。
13.5.3 The typeof 运算符
13.5.3.1 运行时语义：评估
- 设 val 为 ?
评估 的UnaryExpression 。 - 如果 val 是
引用记录 ，则- 如果
IsUnresolvableReference (val) 是true ，返回"undefined" 。
- 如果
- 设 val 为 ?
GetValue (val)。 - 如果 val 是
undefined ，返回"undefined" 。 - 如果 val 是
null ，返回"object" 。 - 如果 val
是字符串 ，返回"string" 。 - 如果 val
是符号 ，返回"symbol" 。 - 如果 val
是布尔值 ，返回"boolean" 。 - 如果 val
是数字 ，返回"number" 。 - 如果 val
是大整数 ，返回"bigint" 。 断言 ：val是对象 。- 注意：这一步在章节
B.3.6.3 中被替换。 - 如果 val 有 [[Call]]
内部槽，返回
"function" 。 - 返回
"object" 。
13.5.4 一元 + 运算符
一元 + 运算符将其操作数转换为
13.5.4.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 返回 ?
ToNumber (?GetValue (expr))。
13.5.5 一元 - 运算符
一元 - 运算符将其操作数转换为数值，然后对其取反。取反
13.5.5.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 设 oldValue 为 ?
ToNumeric (?GetValue (expr))。 - 如果 oldValue
是数字 ，则- 返回
Number::unaryMinus (oldValue)。
- 返回
- 否则，
断言 ：oldValue是大整数 。- 返回
BigInt::unaryMinus (oldValue)。
13.5.6 按位 NOT 运算符 ( ~ )
13.5.6.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 设 oldValue 为 ?
ToNumeric (?GetValue (expr))。 - 如果 oldValue
是数字 ，则- 返回
Number::bitwiseNOT (oldValue)。
- 返回
- 否则，
断言 ：oldValue是大整数 。- 返回
BigInt::bitwiseNOT (oldValue)。
13.5.7 逻辑 NOT 运算符 ( ! )
13.5.7.1 运行时语义：评估
- 设 expr 为 ?
评估 的UnaryExpression 。 - 设 oldValue 为
ToBoolean (?GetValue (expr))。 - 如果 oldValue 是
true ，返回false 。 - 返回
true 。
13.6 幂运算符
语法
13.6.1 运行时语义：评估
13.7 乘法运算符
语法
- 运算符
*执行乘法，生成其操作数的乘积。 - 运算符
/执行除法，生成其操作数的商。 - 运算符
%生成其操作数在隐式除法中的余数。
13.7.1 运行时语义：评估
- 设 opText 为
源文本匹配的 MultiplicativeOperator 。 - 返回 ?
EvaluateStringOrNumericBinaryExpression (MultiplicativeExpression , opText,ExponentiationExpression )。
13.8 加法运算符
语法
13.8.1 加法运算符 ( + )
加法运算符既可以执行字符串连接，也可以执行数值加法。
13.8.1.1 运行时语义：评估
13.8.2 减法运算符 ( - )
减法运算符执行减法，生成其操作数的差值。
13.8.2.1 运行时语义：评估
13.9 位移运算符
语法
13.9.1 左移运算符 ( << )
对左操作数执行按位左移操作，移动的位数由右操作数指定。
13.9.1.1 运行时语义：评估
13.9.2 带符号右移运算符 ( >> )
对左操作数执行按位右移操作，移动的位数由右操作数指定，并使用符号位填充空出的位。
13.9.2.1 运行时语义：评估
13.9.3 无符号右移运算符 ( >>> )
对左操作数执行按位右移操作，移动的位数由右操作数指定，并使用零填充空出的位。
13.9.3.1 运行时语义：评估
13.10 关系运算符
关系运算符的求值结果总是布尔类型，反映运算符命名的关系是否在其两个操作数之间成立。
语法
[In] 语法参数是为了避免在关系表达式中混淆 in 运算符和 for 语句中的 in 运算符。
13.10.1 运行时语义: 求值
-
让 lref 为 ?
Evaluation ofRelationalExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
让 r 为 ?
IsLessThan (lval, rval,true )。 -
如果 r 是
undefined ，返回false 。否则，返回 r。
-
让 lref 为 ?
Evaluation ofRelationalExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
让 r 为 ?
IsLessThan (rval, lval,false )。 -
如果 r 是
undefined ，返回false 。否则，返回 r。
-
让 lref 为 ?
Evaluation ofRelationalExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
让 r 为 ?
IsLessThan (rval, lval,false )。 -
如果 r 是
true 或undefined ，返回false 。否则，返回true 。
-
让 lref 为 ?
Evaluation ofRelationalExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
让 r 为 ?
IsLessThan (lval, rval,true )。 -
如果 r 是
true 或undefined ，返回false 。否则，返回true 。
-
让 lref 为 ?
Evaluation ofRelationalExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
返回 ?
InstanceofOperator (lval, rval)。
-
让 lref 为 ?
Evaluation ofRelationalExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
如果 rval
不是对象 ，抛出TypeError 异常。 -
返回 ?
HasProperty (rval，?ToPropertyKey (lval))。
-
让 privateIdentifier 为
StringValue ofPrivateIdentifier 。 -
让 rref 为 ?
Evaluation ofShiftExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
如果 rval
不是对象 ，抛出TypeError 异常。 -
让 privateEnv 为
运行执行上下文 的 PrivateEnvironment。 -
让 privateName 为
ResolvePrivateIdentifier (privateEnv，privateIdentifier)。 -
如果
PrivateElementFind (rval，privateName) 不是empty ，返回true 。 -
返回
false 。
13.10.2 InstanceofOperator ( V, target )
抽象操作 InstanceofOperator 接受参数 V（一个
-
如果 target
不是对象 ，抛出TypeError 异常。 -
让 instOfHandler 为 ?
GetMethod (target，@@hasInstance )。 -
如果 instOfHandler 不是
undefined ，则 -
如果
IsCallable (target) 是false ，抛出TypeError 异常。 -
返回 ?
OrdinaryHasInstance (target，V)。
步骤
instanceof 运算符语义。如果对象没有定义或继承
instanceof 语义。
13.11 等值运算符
等值运算符的求值结果总是布尔类型，反映运算符命名的关系是否在其两个操作数之间成立。
语法
13.11.1 运行时语义：求值
-
让 lref 为 ?
Evaluation ofEqualityExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofRelationalExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
返回 ?
IsLooselyEqual (rval, lval)。
-
让 lref 为 ?
Evaluation ofEqualityExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofRelationalExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
让 r 为 ?
IsLooselyEqual (rval, lval)。 -
如果 r 是
true ，返回false 。否则，返回true 。
-
让 lref 为 ?
Evaluation ofEqualityExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofRelationalExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
返回
IsStrictlyEqual (rval, lval)。
-
让 lref 为 ?
Evaluation ofEqualityExpression 。 -
让 lval 为 ?
GetValue (lref)。 -
让 rref 为 ?
Evaluation ofRelationalExpression 。 -
让 rval 为 ?
GetValue (rref)。 -
让 r 为
IsStrictlyEqual (rval, lval)。 -
如果 r 是
true ，返回false 。否则，返回true 。
根据上述等值定义：
-
字符串比较可以通过：
`${a}` == `${b}`强制进行。 -
数字比较可以通过：
+a == +b强制进行。 -
布尔值比较可以通过：
!a == !b强制进行。
等值运算符保持以下不变量：
-
A != B等价于!(A == B)。 -
A == B等价于B == A，除了A和B的求值顺序。
等值运算符并不总是传递的。例如，可能存在两个不同的字符串对象，每个对象表示相同的字符串值；每个字符串对象会被 == 运算符视为与字符串值相等，但这两个字符串对象彼此并不相等。例如：
-
new String("a") == "a"和"a" == new String("a")均为true 。 -
new String("a") == new String("a")为false 。
字符串比较使用简单的代码单元值相等测试。不会尝试使用 Unicode 规范中定义的更复杂的、语义导向的字符或字符串相等性定义和排序顺序。因此，根据 Unicode 标准规范等价的字符串值可能会被测试为不相等。实际上，这个算法假设两个字符串都已处于规范化形式。
13.12 二进制按位运算符
语法
13.12.1 运行时语义：求值
13.13 二进制逻辑运算符
语法
由 && 或 || 运算符生成的值不一定是布尔类型。生成的值始终是两个操作数表达式之一的值。
13.13.1 运行时语义：求值
-
令 lref 为 ?
Evaluation ofLogicalANDExpression 。 -
令 lval 为 ?
GetValue (lref)。 -
令 lbool 为
ToBoolean (lval)。 -
如果 lbool 为
false ，则返回 lval。 -
令 rref 为 ?
Evaluation ofBitwiseORExpression 。 -
返回 ?
GetValue (rref)。
-
令 lref 为 ?
Evaluation ofLogicalORExpression 。 -
令 lval 为 ?
GetValue (lref)。 -
令 lbool 为
ToBoolean (lval)。 -
如果 lbool 为
true ，则返回 lval。 -
令 rref 为 ?
Evaluation ofLogicalANDExpression 。 -
返回 ?
GetValue (rref)。
-
令 lref 为 ?
Evaluation ofCoalesceExpressionHead 。 -
令 lval 为 ?
GetValue (lref)。 -
如果 lval 是
undefined 或null ，则-
令 rref 为 ?
Evaluation ofBitwiseORExpression 。 -
返回 ?
GetValue (rref)。
-
令 rref 为 ?
-
否则，
- 返回 lval。
13.14 条件操作符（? :）
语法
ECMAScript 中
13.14.1 运行时语义：求值
-
令 lref 为 ?
Evaluation ofShortCircuitExpression 。 -
令 lval 为
ToBoolean (?GetValue (lref))。 -
如果 lval 为
true ，则-
令 trueRef 为 ?
Evaluation of 第一个AssignmentExpression 。 -
返回 ?
GetValue (trueRef)。
-
令 trueRef 为 ?
-
否则，
-
令 falseRef 为 ?
Evaluation of 第二个AssignmentExpression 。 -
返回 ?
GetValue (falseRef)。
-
令 falseRef 为 ?
13.15 赋值操作符
语法
13.15.1 静态语义：早期错误
如果
如果
-
如果
AssignmentTargetType 的LeftHandSideExpression 不是simple ，则为语法错误。
-
如果
AssignmentTargetType 的LeftHandSideExpression 不是simple ，则为语法错误。
13.15.2 运行时语义：求值
-
如果
LeftHandSideExpression 既不是ObjectLiteral 也不是ArrayLiteral ，则：-
让
lref是对
Evaluation 的LeftHandSideExpression 的求值。 -
如果
IsAnonymousFunctionDefinition (AssignmentExpression )和IsIdentifierRef 的LeftHandSideExpression 都为true ，则：-
让
rval是对
NamedEvaluation (AssignmentExpression )，带有参数lref.[[ReferencedName]]。
-
让
rval是对
-
否则，
-
让
rref是对
Evaluation (AssignmentExpression )的求值。 -
让
rval是对
GetValue (rref)的求值。
-
让
rref是对
-
执行
PutValue ( lref，rval)。 - 返回rval。
-
让
lref是对
-
让
assignmentPattern成为
AssignmentPattern ，由涵盖 的LeftHandSideExpression 。 -
让
rref是对
Evaluation (AssignmentExpression )的求值。 -
让
rval是对
GetValue (rref)的求值。 -
执行
DestructuringAssignmentEvaluation 的assignmentPattern，带有参数rval。 - 返回rval。
-
让
lref是对
Evaluation 的LeftHandSideExpression 的求值。 -
让
lval是对
GetValue (lref)的求值。 -
让
rref是对
Evaluation 的AssignmentExpression 的求值。 -
让
rval是对
GetValue (rref)的求值。 -
让
assignmentOpText是
源文本匹配 的AssignmentOperator 。 -
让
opText成为以下表格中与assignmentOpText关联的Unicode代码点序列：
assignmentOpText opText **=***=*/=/%=%+=+-=-<<=<<>>=>>>>>=>>>&=&^=^|=| -
让
r是对
ApplyStringOrNumericBinaryOperator ( lval， opText， rval)的求值。 -
执行
PutValue ( lref， r)。 - 返回r。
-
让
lref是对
Evaluation 的LeftHandSideExpression 的求值。 -
让
lval是对
GetValue (lref)的求值。 -
让
lbool是
ToBoolean (lval)的求值。 -
如果lbool为
false ，返回lval。 -
如果
IsAnonymousFunctionDefinition (AssignmentExpression )为true ，且IsIdentifierRef 的LeftHandSideExpression 为true ，则：-
让
rval是对
NamedEvaluation (AssignmentExpression )，带有参数 lref.[[ReferencedName]]。
-
让
rval是对
-
否则，
-
让
rref是对
Evaluation 的AssignmentExpression 的求值。 -
让
rval是对
GetValue (rref)的求值。
-
让
rref是对
-
执行
PutValue ( lref，rval)。 - 返回rval。
-
让
lref是对
Evaluation 的LeftHandSideExpression 的求值。 -
让
lval是对
GetValue (lref)的求值。 -
让
lbool是
ToBoolean (lval)的求值。 -
如果lbool为
true ，返回lval。 -
如果
IsAnonymousFunctionDefinition (AssignmentExpression )为true ，且IsIdentifierRef 的LeftHandSideExpression 为true ，则：-
让
rval是对
NamedEvaluation (AssignmentExpression )，带有参数 lref.[[ReferencedName]]。
-
让
rval是对
-
否则，
-
让
rref是对
Evaluation 的AssignmentExpression 的求值。 -
让
rval是对
GetValue (rref)的求值。
-
让
rref是对
-
执行
PutValue ( lref，rval)。 - 返回rval。
-
让
lref是对
Evaluation 的LeftHandSideExpression 的求值。 -
让
lval是对
GetValue (lref)的求值。 -
如果
lval既不是
undefined 也不是null ，返回 lval。 -
如果
IsAnonymousFunctionDefinition (AssignmentExpression )为true ，且IsIdentifierRef 的LeftHandSideExpression 为true ，则：-
让
rval是对
NamedEvaluation (AssignmentExpression )，带有参数 lref.[[ReferencedName]]。
-
让
rval是对
-
否则，
-
让
rref是对
Evaluation 的AssignmentExpression 的求值。 -
让
rval是对
GetValue (rref)的求值。
-
让
rref是对
-
执行
PutValue ( lref，rval)。 - 返回rval。
13.15.3 ApplyStringOrNumericBinaryOperator ( lval, opText, rval )
抽象操作 ApplyStringOrNumericBinaryOperator 接受参数 lval（一个 **、*、/、%、+、-、<<、>>、>>>、&、^
或 |）和 rval（一个
-
如果 opText 是
+，则-
令 lprim 为 ?
ToPrimitive (lval)。 -
令 rprim 为 ?
ToPrimitive (rval)。 -
如果 lprim 是
字符串 或 rprim 是字符串 ，则 - 将 lval 设置为 lprim。
- 将 rval 设置为 rprim。
-
令 lprim 为 ?
- 注意：此时，它必须是一个数值运算。
-
令 lnum 为 ?
ToNumeric (lval)。 -
令 rnum 为 ?
ToNumeric (rval)。 -
如果 lnum 的
类型 与 rnum 的类型 不同，抛出一个TypeError 异常。 -
如果 lnum 是
BigInt ，则-
如果 opText 是
**，返回 ?BigInt::exponentiate (lnum, rnum)。 -
如果 opText 是
/，返回 ?BigInt::divide (lnum, rnum)。 -
如果 opText 是
%，返回 ?BigInt::remainder (lnum, rnum)。 -
如果 opText 是
>>>，返回 ?BigInt::unsignedRightShift (lnum, rnum)。
-
如果 opText 是
-
令 operation 为与以下表格中的 opText 和 lnum 的
类型 相关的抽象操作：opText 类型 (lnum)operation **Number Number::exponentiate *Number Number::multiply *BigInt BigInt::multiply /Number Number::divide %Number Number::remainder +Number Number::add +BigInt BigInt::add -Number Number::subtract -BigInt BigInt::subtract <<Number Number::leftShift <<BigInt BigInt::leftShift >>Number Number::signedRightShift >>BigInt BigInt::signedRightShift >>>Number Number::unsignedRightShift &Number Number::bitwiseAND &BigInt BigInt::bitwiseAND ^Number Number::bitwiseXOR ^BigInt BigInt::bitwiseXOR |Number Number::bitwiseOR |BigInt BigInt::bitwiseOR - 返回 operation(lnum, rnum)。
在步骤
步骤
13.15.4 EvaluateStringOrNumericBinaryExpression ( leftOperand, opText, rightOperand )
抽象操作 EvaluateStringOrNumericBinaryExpression 接受参数 leftOperand（一个
- 让 lref 为 ?
Evaluation 的 leftOperand。 - 让 lval 为 ?
GetValue (lref)。 - 让 rref 为 ?
Evaluation 的 rightOperand。 - 让 rval 为 ?
GetValue (rref)。 - 返回 ?
ApplyStringOrNumericBinaryOperator (lval, opText, rval)。
13.15.5 解构赋值
补充语法
在处理以下产生式的实例时
对于
13.15.5.1 静态语义：早期错误
-
如果
AssignmentTargetType 的IdentifierReference 不是simple ，则这是一个语法错误。
-
如果
DestructuringAssignmentTarget 是ArrayLiteral 或ObjectLiteral ，则这是一个语法错误。
如果
如果
-
如果
AssignmentTargetType 的LeftHandSideExpression 不是simple ，则这是一个语法错误。
13.15.5.2 运行时语义：DestructuringAssignmentEvaluation
- 执行 ?
RequireObjectCoercible (value)。 - 返回
unused 。
- 执行 ?
RequireObjectCoercible (value)。 - 执行 ?
PropertyDestructuringAssignmentEvaluation ofAssignmentPropertyList with argument value。 - 返回
unused 。
- 执行 ?
RequireObjectCoercible (value)。 - 让 excludedNames 成为一个新的空的
列表 。 - 返回 ?
RestDestructuringAssignmentEvaluation ofAssignmentRestProperty with arguments value 和 excludedNames。
- 执行 ?
RequireObjectCoercible (value)。 - 让 excludedNames 成为 ?
PropertyDestructuringAssignmentEvaluation ofAssignmentPropertyList with argument value。 - 返回 ?
RestDestructuringAssignmentEvaluation ofAssignmentRestProperty with arguments value 和 excludedNames。
- 让 iteratorRecord 成为 ?
GetIterator (value,sync )。 - 返回 ?
IteratorClose (iteratorRecord,NormalCompletion (unused ))。
- 让 iteratorRecord 成为 ?
GetIterator (value,sync )。 - 让 result 成为
Completion (IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord)。 - 如果 iteratorRecord.[[Done]] 为
false ，返回 ?IteratorClose (iteratorRecord, result)。 - 返回 result。
- 让 iteratorRecord 成为 ?
GetIterator (value,sync )。 - 如果
Elision 存在，则- 让 status 成为
Completion (IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord)。 - 如果 status 是一个
突然完成 ，则断言 : iteratorRecord.[[Done]] 为true 。- 返回 ? status。
- 让 status 成为
- 让 result 成为
Completion (IteratorDestructuringAssignmentEvaluation ofAssignmentRestElement with argument iteratorRecord)。 - 如果 iteratorRecord.[[Done]] 为
false ，返回 ?IteratorClose (iteratorRecord, result)。 - 返回 result。
- 让 iteratorRecord 成为 ?
GetIterator (value,sync )。 - 让 status 成为
Completion (IteratorDestructuringAssignmentEvaluation ofAssignmentElementList with argument iteratorRecord)。 - 如果 status 是一个
突然完成 ，则- 如果 iteratorRecord.[[Done]] 为
false ，返回 ?IteratorClose (iteratorRecord, status)。 - 返回 ? status。
- 如果 iteratorRecord.[[Done]] 为
- 如果
Elision 存在，则- 设置 status 为
Completion (IteratorDestructuringAssignmentEvaluation ofElision with argument iteratorRecord)。 - 如果 status 是一个
突然完成 ，则断言 : iteratorRecord.[[Done]] 为true 。- 返回 ? status。
- 设置 status 为
- 如果
AssignmentRestElement 存在，则- 设置 status 为
Completion (IteratorDestructuringAssignmentEvaluation ofAssignmentRestElement with argument iteratorRecord)。
- 设置 status 为
- 如果 iteratorRecord.[[Done]] 为
false ，返回 ?IteratorClose (iteratorRecord, status)。 - 返回 ? status。
13.15.5.3 运行时语义：属性解构赋值求值
语法导向操作
- 让 propertyNames 是 ?
PropertyDestructuringAssignmentEvaluation 对AssignmentPropertyList 调用时的参数 value。 - 让 nextNames 是 ?
PropertyDestructuringAssignmentEvaluation 对AssignmentProperty 调用时的参数 value。 - 返回 propertyNames 和 nextNames 的
列表连接 。
- 让 P 是
StringValue 的IdentifierReference 。 - 让 lref 是 ?
ResolveBinding (P)。 - 让 v 是 ?
GetV (value, P)。 - 如果
Initializer 存在并且 v 是undefined ，则- 如果
IsAnonymousFunctionDefinition (Initializer ) 为true ，则- 将 v 设置为 ?
NamedEvaluation 的Initializer 参数为 P。
- 将 v 设置为 ?
- 否则,
- 让 defaultValue 是 ?
Evaluation 的Initializer 。 - 将 v 设置为 ?
GetValue (defaultValue)。
- 让 defaultValue 是 ?
- 如果
- 执行 ?
PutValue (lref, v)。 - 返回 « P »。
- 让 name 是 ?
Evaluation 的PropertyName 。 - 执行 ?
KeyedDestructuringAssignmentEvaluation 的AssignmentElement 参数为 value 和 name。 - 返回 « name »。
13.15.5.4 运行时语义：RestDestructuringAssignmentEvaluation
语法导向操作
- 让 lref 是 ?
Evaluation 的DestructuringAssignmentTarget 。 - 让 restObj 是
OrdinaryObjectCreate (%Object.prototype% )。 - 执行 ?
CopyDataProperties (restObj, value, excludedNames)。 - 返回 ?
PutValue (lref, restObj)。
13.15.5.5 运行时语义：IteratorDestructuringAssignmentEvaluation
语法导向操作
- 返回 ?
IteratorDestructuringAssignmentEvaluation 的AssignmentElisionElement 传入参数 iteratorRecord。
- 执行 ?
IteratorDestructuringAssignmentEvaluation 的AssignmentElementList 传入参数 iteratorRecord。 - 返回 ?
IteratorDestructuringAssignmentEvaluation 的AssignmentElisionElement 传入参数 iteratorRecord。
- 返回 ?
IteratorDestructuringAssignmentEvaluation 的AssignmentElement 传入参数 iteratorRecord。
- 执行 ?
IteratorDestructuringAssignmentEvaluation 的Elision 传入参数 iteratorRecord。 - 返回 ?
IteratorDestructuringAssignmentEvaluation 的AssignmentElement 传入参数 iteratorRecord。
- 如果 iteratorRecord.[[Done]]
是
false ，那么- 令 next 为
Completion (IteratorStep (iteratorRecord))。 - 如果 next 是一个
异常完成 ，设置 iteratorRecord.[[Done]] 为true 。 ReturnIfAbrupt (next)。- 如果 next 是
false ，设置 iteratorRecord.[[Done]] 为true 。
- 令 next 为
- 返回
unused 。
- 执行 ?
IteratorDestructuringAssignmentEvaluation 的Elision 传入参数 iteratorRecord。 - 如果 iteratorRecord.[[Done]]
是
false ，那么- 令 next 为
Completion (IteratorStep (iteratorRecord))。 - 如果 next 是一个
异常完成 ，设置 iteratorRecord.[[Done]] 为true 。 ReturnIfAbrupt (next)。- 如果 next 是
false ，设置 iteratorRecord.[[Done]] 为true 。
- 令 next 为
- 返回
unused 。
- 如果
DestructuringAssignmentTarget 既不是一个ObjectLiteral 也不是一个ArrayLiteral ，那么- 令 lref 为 ?
Evaluation 的DestructuringAssignmentTarget 。
- 令 lref 为 ?
- 令 value 为
undefined 。 - 如果 iteratorRecord.[[Done]]
是
false ，那么- 令 next 为 ?
IteratorStepValue 的 iteratorRecord。 - 如果 next 不是
done ，那么- 设置 value 为 next。
- 令 next 为 ?
- 如果
Initializer 存在并且 value 是undefined ，那么- 如果
IsAnonymousFunctionDefinition (Initializer ) 是true 并且IsIdentifierRef 的DestructuringAssignmentTarget 是true ，那么- 令 v 为 ?
NamedEvaluation 的Initializer 传入参数 lref.[[ReferencedName]]。
- 令 v 为 ?
- 否则，
- 令 defaultValue 为 ?
Evaluation 的Initializer 。 - 令 v 为 ?
GetValue (defaultValue)。
- 令 defaultValue 为 ?
- 如果
- 否则，
- 令 v 为 value。
- 如果
DestructuringAssignmentTarget 是一个ObjectLiteral 或一个ArrayLiteral ，那么- 令 nestedAssignmentPattern 为一个
AssignmentPattern ， 它被覆盖 在DestructuringAssignmentTarget 。 - 返回 ?
DestructuringAssignmentEvaluation 的 nestedAssignmentPattern 传入参数 v。
- 令 nestedAssignmentPattern 为一个
- 返回 ?
PutValue (lref, v)。
从左到右的求值顺序通过在访问迭代器或求值
- 如果
DestructuringAssignmentTarget 既不是一个ObjectLiteral 也不是一个ArrayLiteral ，那么- 令 lref 为 ?
Evaluation 的DestructuringAssignmentTarget 。
- 令 lref 为 ?
- 令 A 为 !
ArrayCreate (0)。 - 令 n 为 0。
- 重复，直到 iteratorRecord.[[Done]]
是
false ，- 令 next 为 ?
IteratorStepValue 的 iteratorRecord。 - 如果 next 不是
done ，那么- 执行 !
CreateDataPropertyOrThrow 的 A， !ToString 的𝔽 的 n， next。 - 设置 n 为 n + 1。
- 执行 !
- 令 next 为 ?
- 如果
DestructuringAssignmentTarget 既不是一个ObjectLiteral 也不是一个ArrayLiteral ，那么- 返回 ?
PutValue 的 lref，A。
- 返回 ?
- 令 nestedAssignmentPattern 为一个
AssignmentPattern ， 它被覆盖 在DestructuringAssignmentTarget 。 - 返回 ?
DestructuringAssignmentEvaluation 的 nestedAssignmentPattern 传入参数 A。
13.15.5.6 运行时语义：KeyedDestructuringAssignmentEvaluation
-
如果
DestructuringAssignmentTarget 既不是ObjectLiteral 也不是ArrayLiteral ，那么-
令 lref 为 ?
Evaluation 的DestructuringAssignmentTarget 。
-
令 lref 为 ?
-
令 v 为 ?
GetV 的 value 和 propertyName。 -
如果
Initializer 存在并且 v 是undefined ，那么-
如果
IsAnonymousFunctionDefinition 的Initializer 并且IsIdentifierRef 的DestructuringAssignmentTarget 都为true ，那么-
令 rhsValue 为 ?
NamedEvaluation 的Initializer 传入参数 lref.[[ReferencedName]]。
-
令 rhsValue 为 ?
-
否则，
-
令 defaultValue 为 ?
Evaluation 的Initializer 。 -
令 rhsValue 为 ?
GetValue 的 defaultValue。
-
令 defaultValue 为 ?
-
如果
-
否则，
- 令 rhsValue 为 v。
-
如果
DestructuringAssignmentTarget 是一个ObjectLiteral 或ArrayLiteral ，那么-
令 assignmentPattern 为
AssignmentPattern ，它被覆盖 在DestructuringAssignmentTarget 。 -
返回 ?
DestructuringAssignmentEvaluation 的 assignmentPattern 传入参数 rhsValue。
-
令 assignmentPattern 为
-
返回 ?
PutValue 的 lref，rhsValue。
13.16 逗号操作符 (,)
语法
13.16.1 运行时语义：Evaluation
-
令 lref 为 ?
Evaluation 的Expression 。 -
执行 ?
GetValue (lref)。 -
令 rref 为 ?
Evaluation 的AssignmentExpression 。 -
返回 ?
GetValue (rref)。
14 ECMAScript 语言：语句和声明
语法
14.1 语句语义
14.1.1 运行时语义：求值
- 返回
empty 。
- 返回 ?
求值 ofFunctionDeclaration 。
- 令 newLabelSet 为一个空的
List 。 - 返回 ?
LabelledEvaluation of thisBreakableStatement with argument newLabelSet。
14.2 块
语法
14.2.1 静态语义：早期错误
-
如果
LexicallyDeclaredNames ofStatementList 包含任何重复条目，则为语法错误。 -
如果
LexicallyDeclaredNames ofStatementList 中的任何元素也出现在VarDeclaredNames ofStatementList 中，则为语法错误。
14.2.2 运行时语义：求值
- 返回
empty 。
- 令 oldEnv 为
运行中的执行上下文 的 LexicalEnvironment。 - 令 blockEnv 为
NewDeclarativeEnvironment (oldEnv)。 - 执行
BlockDeclarationInstantiation (StatementList , blockEnv)。 - 将
运行中的执行上下文 的 LexicalEnvironment 设置为 blockEnv。 - 令 blockValue 为
Completion (求值 ofStatementList )。 - 将
运行中的执行上下文 的 LexicalEnvironment 设置为 oldEnv。 - 返回 ? blockValue。
无论控制如何离开
- 令 sl 为 ?
求值 ofStatementList 。 - 令 s 为
Completion (求值 ofStatementListItem )。 - 返回 ?
UpdateEmpty (s, sl)。
eval 函数的调用都返回值 1：
eval("1;;;;;")
eval("1;{}")
eval("1;var a;")14.2.3 BlockDeclarationInstantiation ( code, env )
抽象操作 BlockDeclarationInstantiation 接受参数 code（一个
当调用时，它执行以下步骤：
- 令 declarations 为 code 的
LexicallyScopedDeclarations 。 - 令 privateEnv 为
运行中的执行上下文 的 PrivateEnvironment。 - 对于 declarations 的每个元素 d，执行
- 对于 d 的
BoundNames 的每个元素 dn，执行- 如果 d 的
IsConstantDeclaration 为true ，则- 执行
! env.CreateImmutableBinding(dn,
true )。
- 执行
! env.CreateImmutableBinding(dn,
- 否则，
- 执行 ! env.CreateMutableBinding(dn,
false )。注意：此步骤在B.3.2.6 中被替换。
- 执行 ! env.CreateMutableBinding(dn,
- 如果 d 的
- 如果 d 是
FunctionDeclaration 、GeneratorDeclaration 、AsyncFunctionDeclaration 或AsyncGeneratorDeclaration ，则- 令 fn 为 d 的
BoundNames 的唯一元素。 - 令 fo 为 d 的
InstantiateFunctionObject ，参数为 env 和 privateEnv。 - 执行 ! env.InitializeBinding(fn, fo)。注意：此步骤在
B.3.2.6 中被替换。
- 令 fn 为 d 的
- 对于 d 的
- 返回
unused 。
14.3 声明和变量语句
14.3.1 Let 和 Const 声明
let 和 const 声明定义的变量作用域为 let 声明中的
语法
14.3.1.1 静态语义：早期错误
-
如果
BoundNames ofBindingList 包含"let" ，则为语法错误。 -
如果
BoundNames ofBindingList 包含任何 重复条目，则为语法错误。
-
如果
Initializer 不存在且IsConstantDeclaration of theLexicalDeclaration 包含此LexicalBinding 为true ，则为语法错误。
14.3.1.2 运行时语义：求值
- 执行 ?
求值 ofBindingList 。 - 返回
empty 。
- 执行 ?
求值 ofBindingList 。 - 返回 ?
求值 ofLexicalBinding 。
- 令 lhs 为 !
ResolveBinding (StringValue ofBindingIdentifier )。 - 执行 !
InitializeReferencedBinding (lhs,undefined )。 - 返回
empty 。
一个 const 声明中。
- 令 bindingId 为
StringValue ofBindingIdentifier 。 - 令 lhs 为 !
ResolveBinding (bindingId)。 - 如果
IsAnonymousFunctionDefinition (Initializer ) istrue ，则- 令 value 为 ?
NamedEvaluation ofInitializer with argument bindingId。
- 令 value 为 ?
- 否则，
- 令 rhs 为 ?
求值 ofInitializer 。 - 令 value 为 ?
GetValue (rhs)。
- 令 rhs 为 ?
- 执行 !
InitializeReferencedBinding (lhs, value)。 - 返回
empty 。
- 令 rhs 为 ?
求值 ofInitializer 。 - 令 value 为 ?
GetValue (rhs)。 - 令 env 为
运行中的执行上下文 的 LexicalEnvironment。 - 返回 ?
BindingInitialization ofBindingPattern with arguments value and env。
14.3.2 变量语句
一个 var 语句声明的变量作用域为
语法
14.3.2.1 运行时语义：求值
- 执行 ?
求值 ofVariableDeclarationList 。 - 返回
empty 。
- 执行 ?
求值 ofVariableDeclarationList 。 - 返回 ?
求值 ofVariableDeclaration 。
- 返回
empty 。
- 令 bindingId 为
StringValue ofBindingIdentifier 。 - 令 lhs 为 ?
ResolveBinding (bindingId)。 - 如果
IsAnonymousFunctionDefinition (Initializer ) istrue ，则- 令 value 为 ?
NamedEvaluation ofInitializer with argument bindingId。
- 令 value 为 ?
- 否则，
- 令 rhs 为 ?
求值 ofInitializer 。 - 令 value 为 ?
GetValue (rhs)。
- 令 rhs 为 ?
- 执行 ?
PutValue (lhs, value)。 - 返回
empty 。
如果一个
- 令 rhs 为 ?
求值 ofInitializer 。 - 令 rval 为 ?
GetValue (rhs)。 - 返回 ?
BindingInitialization ofBindingPattern with arguments rval andundefined 。
14.3.3 解构绑定模式
语法
14.3.3.1 运行时语义：属性绑定初始化
属性绑定初始化是一个
- 令 boundNames 为 ?
属性绑定初始化 ofBindingPropertyList 使用参数 value 和 environment。 - 令 nextNames 为 ?
属性绑定初始化 ofBindingProperty 使用参数 value 和 environment。 - 返回 boundNames 和 nextNames 的
列表连接 。
- 令 name 为
SingleNameBinding 的BoundNames 的唯一元素。 - 执行 ?
键绑定初始化 ofSingleNameBinding 使用参数 value、environment 和 name。 - 返回 « name »。
- 令 P 为 ?
求值 ofPropertyName 。 - 执行 ?
键绑定初始化 ofBindingElement 使用参数 value、environment 和 P。 - 返回 « P »。
14.3.3.2 运行时语义：剩余绑定初始化
剩余绑定初始化是一个
- 令 lhs 为 ?
ResolveBinding (StringValue ofBindingIdentifier , environment)。 - 令 restObj 为
OrdinaryObjectCreate (%Object.prototype% )。 - 执行 ?
CopyDataProperties (restObj, value, excludedNames)。 - 如果 environment 是
undefined ， 返回 ?PutValue (lhs, restObj)。 - 返回 ?
InitializeReferencedBinding (lhs, restObj)。
14.3.3.3 运行时语义：键绑定初始化
键绑定初始化是一个
它在以下产生式上分段定义：
- 令 v 为 ?
GetV (value, propertyName)。 - 如果
Initializer 存在且 v 是undefined ，则- 令 defaultValue 为 ?
求值 ofInitializer 。 - 设置 v 为 ?
GetValue (defaultValue)。
- 令 defaultValue 为 ?
- 返回 ?
绑定初始化 ofBindingPattern 使用参数 v 和 environment。
- 令 bindingId 为
StringValue ofBindingIdentifier 。 - 令 lhs 为 ?
ResolveBinding (bindingId, environment)。 - 令 v 为 ?
GetV (value, propertyName)。 - 如果
Initializer 存在且 v 是undefined ，则- 如果
IsAnonymousFunctionDefinition (Initializer ) istrue ，则- 设置 v 为 ?
NamedEvaluation ofInitializer with argument bindingId。
- 设置 v 为 ?
- 否则，
- 令 defaultValue 为 ?
求值 ofInitializer 。 - 设置 v 为 ?
GetValue (defaultValue)。
- 令 defaultValue 为 ?
- 如果
- 如果 environment 是
undefined ， 返回 ?PutValue (lhs, v)。 - 返回 ?
InitializeReferencedBinding (lhs, v)。
14.4 空语句
语法
14.4.1 运行时语义：求值
- 返回
empty 。
14.5 表达式语句
语法
一个 function 或 class async function 开始，因为这可能会使其与一个 let [ 开始，因为这可能会使其与一个 let
14.5.1 运行时语义：求值
- 令 exprRef 为 ?
求值 ofExpression 。 - 返回 ?
GetValue (exprRef)。
14.6 if 语句
语法
else] 以通常的方式解决了经典的“悬空 else”问题。也就是说，当关联的
if 选择不明确时，else 与最近的（最内层的）候选 if 相关联。
14.6.1 静态语义：早期错误
-
如果
IsLabelledFunction (第一个Statement ) 是true ，则为语法错误。 -
如果
IsLabelledFunction (第二个Statement ) 是true ，则为语法错误。
-
如果
IsLabelledFunction (Statement ) 是true ，则为语法错误。
只有在实现
14.6.2 运行时语义：求值
- 设 exprRef 为 ?
求值 ofExpression . - 设 exprValue 为
ToBoolean (?GetValue (exprRef)). - 如果 exprValue 是
true ，则- 设 stmtCompletion 为
Completion (求值 of the firstStatement ).
- 设 stmtCompletion 为
- 否则
- 设 stmtCompletion 为
Completion (求值 of the secondStatement ).
- 设 stmtCompletion 为
- 返回 ?
UpdateEmpty (stmtCompletion,undefined ).
- 设 exprRef 为 ?
求值 ofExpression . - 设 exprValue 为
ToBoolean (?GetValue (exprRef)). - 如果 exprValue 是
false ，则- 返回
undefined .
- 返回
- 否则
- 设 stmtCompletion 为
Completion (求值 ofStatement ). - 返回 ?
UpdateEmpty (stmtCompletion,undefined ).
- 设 stmtCompletion 为
14.7 迭代语句
语法
14.7.1 语义
14.7.1.1 LoopContinues ( completion, labelSet )
抽象操作 LoopContinues 接受参数 completion（一个
- 如果 completion 是一个
normal completion ，返回true 。 - 如果 completion 不是一个
continue completion ，返回false 。 - 如果 completion.[[Target]]
是
empty ，返回true 。 - 如果 labelSet 包含 completion.[[Target]]，返回
true 。 - 返回
false 。
在
14.7.1.2 运行时语义：LoopEvaluation
语法导向操作 LoopEvaluation 接受参数 labelSet（一个
- 返回 ?
DoWhileLoopEvaluation ofDoWhileStatement with argument labelSet.
- 返回 ?
WhileLoopEvaluation ofWhileStatement with argument labelSet.
- 返回 ?
ForLoopEvaluation ofForStatement with argument labelSet.
- 返回 ?
ForInOfLoopEvaluation ofForInOfStatement with argument labelSet.
14.7.2 do-while 语句
语法
14.7.2.1 静态语义：早期错误
-
如果
IsLabelledFunction (Statement ) 是true ，则为语法错误。
只有在实现
14.7.2.2 运行时语义：DoWhileLoopEvaluation
语法导向操作 DoWhileLoopEvaluation 接受参数 labelSet（一个
- 设 V 为
undefined 。 - 重复，
- 设 stmtResult 为
Completion (求值 ofStatement )。 - 如果
LoopContinues (stmtResult, labelSet) 是false ，返回 ?UpdateEmpty (stmtResult, V)。 - 如果 stmtResult.[[Value]]
不是
empty ，设 V 为 stmtResult.[[Value]]。 - 设 exprRef 为 ?
求值 ofExpression 。 - 设 exprValue 为 ?
GetValue (exprRef)。 - 如果
ToBoolean (exprValue) 是false ，返回 V。
- 设 stmtResult 为
14.7.3 while 语句
语法
14.7.3.1 静态语义：早期错误
-
如果
IsLabelledFunction (Statement ) 是true ，则为语法错误。
只有在实现
14.7.3.2 运行时语义：WhileLoopEvaluation
语法导向操作 WhileLoopEvaluation 接受参数 labelSet（一个
- 设 V 为
undefined 。 - 重复，
- 设 exprRef 为 ?
求值 ofExpression 。 - 设 exprValue 为 ?
GetValue (exprRef)。 - 如果
ToBoolean (exprValue) 是false ，返回 V。 - 设 stmtResult 为
Completion (求值 ofStatement )。 - 如果
LoopContinues (stmtResult, labelSet) 是false ，返回 ?UpdateEmpty (stmtResult, V)。 - 如果 stmtResult.[[Value]]
不是
empty ，设 V 为 stmtResult.[[Value]]。
- 设 exprRef 为 ?
14.7.4 for 语句
语法
14.7.4.1 静态语义：早期错误
-
如果
IsLabelledFunction (Statement ) 是true ，则为语法错误。
只有在实现
-
如果
BoundNames ofLexicalDeclaration 中的任何元素也出现在VarDeclaredNames ofStatement 中，则为语法错误。
14.7.4.2 运行时语义：ForLoopEvaluation
语法导向操作 ForLoopEvaluation 接受参数 labelSet（一个
- 如果第一个
Expression 存在，则- 设 exprRef 为 ?
求值 of the firstExpression 。 - 执行 ?
GetValue (exprRef)。
- 设 exprRef 为 ?
- 如果第二个
Expression 存在，设 test 为第二个Expression ；否则，设 test 为empty 。 - 如果第三个
Expression 存在，设 increment 为第三个Expression ；否则，设 increment 为empty 。 - 返回 ?
ForBodyEvaluation (test, increment,Statement , « », labelSet)。
- 执行 ?
求值 ofVariableDeclarationList 。 - 如果第一个
Expression 存在，设 test 为第一个Expression ；否则，设 test 为empty 。 - 如果第二个
Expression 存在，设 increment 为第二个Expression ；否则，设 increment 为empty 。 - 返回 ?
ForBodyEvaluation (test, increment,Statement , « », labelSet)。
- 设 oldEnv 为
运行执行上下文 的词法环境。 - 设 loopEnv 为
NewDeclarativeEnvironment (oldEnv)。 - 设 isConst 为
IsConstantDeclaration ofLexicalDeclaration 。 - 设 boundNames 为
BoundNames ofLexicalDeclaration 。 - 对于 boundNames 的每个元素 dn，执行
- 如果 isConst 是
true ，则- 执行
! loopEnv.CreateImmutableBinding(dn,
true )。
- 执行
! loopEnv.CreateImmutableBinding(dn,
- 否则，
- 执行
! loopEnv.CreateMutableBinding(dn,
false )。
- 执行
! loopEnv.CreateMutableBinding(dn,
- 如果 isConst 是
- 将
运行执行上下文 的词法环境设置为 loopEnv。 - 设 forDcl 为
Completion (求值 ofLexicalDeclaration )。 - 如果 forDcl 是一个
abrupt completion ，则- 将
运行执行上下文 的词法环境设置为 oldEnv。 - 返回 ? forDcl。
- 将
- 如果 isConst 是
false ，设 perIterationLets 为 boundNames；否则设 perIterationLets 为 一个新的空List 。 - 如果第一个
Expression 存在，设 test 为第一个Expression ；否则，设 test 为empty 。 - 如果第二个
Expression 存在，设 increment 为第二个Expression ；否则，设 increment 为empty 。 - 设 bodyResult 为
Completion (ForBodyEvaluation (test, increment,Statement , perIterationLets, labelSet))。 - 将
运行执行上下文 的词法环境设置为 oldEnv。 - 返回 ? bodyResult。
14.7.4.3 ForBodyEvaluation ( test, increment, stmt, perIterationBindings, labelSet )
抽象操作 ForBodyEvaluation 接受参数 test（一个
- 设 V 为
undefined 。 - 执行 ?
CreatePerIterationEnvironment (perIterationBindings)。 - 重复，
- 如果 test 不是
empty ，则 - 设 result 为
Completion (求值 of stmt)。 - 如果
LoopContinues (result, labelSet) 是false ，返回 ?UpdateEmpty (result, V)。 - 如果 result.[[Value]]
不是
empty ，设 V 为 result.[[Value]]。 - 执行 ?
CreatePerIterationEnvironment (perIterationBindings)。 - 如果 increment 不是
empty ，则
- 如果 test 不是
14.7.4.4 CreatePerIterationEnvironment ( perIterationBindings )
抽象操作 CreatePerIterationEnvironment 接受参数 perIterationBindings
（一个
- 如果 perIterationBindings 有任何元素，则
- 设 lastIterationEnv 为
运行执行上下文 的词法环境。 - 设 outer 为 lastIterationEnv.[[OuterEnv]]。
断言 ：outer 不是null 。- 设 thisIterationEnv 为
NewDeclarativeEnvironment (outer)。 - 对于 perIterationBindings 的每个元素 bn，执行
- 执行
! thisIterationEnv.CreateMutableBinding(bn,
false )。 - 设 lastValue 为
? lastIterationEnv.GetBindingValue(bn,
true )。 - 执行 ! thisIterationEnv.InitializeBinding(bn, lastValue)。
- 执行
! thisIterationEnv.CreateMutableBinding(bn,
- 将
运行执行上下文 的词法环境设置为 thisIterationEnv。
- 设 lastIterationEnv 为
- 返回
unused 。
14.7.5 for-in、for-of 和
for-await-of 语句
语法
本节由附录
14.7.5.1 静态语义：早期错误
-
如果
IsLabelledFunction (Statement ) 是true ，则为语法错误。
只有在实现
如果
如果
-
如果
AssignmentTargetType 的LeftHandSideExpression 不是simple ，则为语法错误。
-
如果
BoundNames ofForDeclaration 包含"let" ，则为语法错误。 -
如果
BoundNames ofForDeclaration 中的任何元素也出现在VarDeclaredNames ofStatement 中，则为语法错误。 -
如果
BoundNames ofForDeclaration 包含任何重复条目，则为语法错误。
14.7.5.2 静态语义：IsDestructuring
语法导向操作 IsDestructuring 不接受参数并返回一个布尔值。它在以下产生式上定义：
- 如果
PrimaryExpression 是ObjectLiteral 或ArrayLiteral ， 返回true 。 - 返回
false 。
- 返回
false 。
- 返回
IsDestructuring ofForBinding 。
- 返回
false 。
- 返回
true 。
本节由附录
14.7.5.3 运行时语义：ForDeclarationBindingInitialization
语法导向操作 ForDeclarationBindingInitialization 接受参数 value（一个
它在以下产生式上定义：
- 返回 ?
BindingInitialization ofForBinding with arguments value and environment。
14.7.5.4 运行时语义：ForDeclarationBindingInstantiation
语法导向操作 ForDeclarationBindingInstantiation 接受参数 environment（一个
- 对于
BoundNames ofForBinding 的每个元素 name，执行- 如果
IsConstantDeclaration ofLetOrConst 是true ，则- 执行
! environment.CreateImmutableBinding(name,
true )。
- 执行
! environment.CreateImmutableBinding(name,
- 否则，
- 执行
! environment.CreateMutableBinding(name,
false )。
- 执行
! environment.CreateMutableBinding(name,
- 如果
- 返回
unused 。
14.7.5.5 运行时语义：ForInOfLoopEvaluation
语法导向操作 ForInOfLoopEvaluation 接受参数 labelSet（一个
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (« »,Expression ,enumerate )。 - 返回 ?
ForIn/OfBodyEvaluation (LeftHandSideExpression ,Statement , keyResult,enumerate ,assignment , labelSet)。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (« »,Expression ,enumerate )。 - 返回 ?
ForIn/OfBodyEvaluation (ForBinding ,Statement , keyResult,enumerate ,var-binding , labelSet)。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (BoundNames ofForDeclaration ,Expression ,enumerate )。 - 返回 ?
ForIn/OfBodyEvaluation (ForDeclaration ,Statement , keyResult,enumerate ,lexical-binding , labelSet)。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,iterate )。 - 返回 ?
ForIn/OfBodyEvaluation (LeftHandSideExpression ,Statement , keyResult,iterate ,assignment , labelSet)。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,iterate )。 - 返回 ?
ForIn/OfBodyEvaluation (ForBinding ,Statement , keyResult,iterate ,var-binding , labelSet)。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (BoundNames ofForDeclaration ,AssignmentExpression ,iterate )。 - 返回 ?
ForIn/OfBodyEvaluation (ForDeclaration ,Statement , keyResult,iterate ,lexical-binding , labelSet)。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,async-iterate )。 - 返回 ?
ForIn/OfBodyEvaluation (LeftHandSideExpression ,Statement , keyResult,iterate ,assignment , labelSet,async )。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,async-iterate )。 - 返回 ?
ForIn/OfBodyEvaluation (ForBinding ,Statement , keyResult,iterate ,var-binding , labelSet,async )。
- 设 keyResult 为 ?
ForIn/OfHeadEvaluation (BoundNames ofForDeclaration ,AssignmentExpression ,async-iterate )。 - 返回 ?
ForIn/OfBodyEvaluation (ForDeclaration ,Statement , keyResult,iterate ,lexical-binding , labelSet,async )。
本节由附录
14.7.5.6 ForIn/OfHeadEvaluation ( uninitializedBoundNames, expr, iterationKind )
抽象操作 ForIn/OfHeadEvaluation 接受参数 uninitializedBoundNames（一个
- 令 oldEnv 为
运行执行上下文 的词法环境。 - 如果 uninitializedBoundNames 不为空，则
断言 ： uninitializedBoundNames 没有重复条目。- 令 newEnv 为
NewDeclarativeEnvironment (oldEnv)。 - 对于 uninitializedBoundNames 中的每个字符串
name，执行
- 执行
! newEnv.CreateMutableBinding(name,
false )。
- 执行
! newEnv.CreateMutableBinding(name,
- 将
运行执行上下文 的词法环境设置为 newEnv。
- 令 exprRef 为
Completion (Evaluation of expr)。 - 将
运行执行上下文 的词法环境设置为 oldEnv。 - 令 exprValue 为 ?
GetValue (? exprRef)。 - 如果 iterationKind 是
enumerate ，则- 如果 exprValue 是
undefined 或null ，则- 返回
完成记录 { [[Type]]:break , [[Value]]:empty , [[Target]]:empty }。
- 返回
- 令 obj 为 !
ToObject (exprValue)。 - 令 iterator 为
EnumerateObjectProperties (obj)。 - 令 nextMethod 为 !
GetV (iterator,"next" )。 - 返回
迭代器记录 { [[Iterator]]: iterator, [[NextMethod]]: nextMethod, [[Done]]:false }。
- 如果 exprValue 是
- 否则
断言 ：iterationKind 是iterate 或async-iterate 。- 如果 iterationKind 是
async-iterate ，令 iteratorKind 为async 。 - 否则，令 iteratorKind 为
sync 。 - 返回 ?
GetIterator (exprValue, iteratorKind)。
14.7.5.7 ForIn/OfBodyEvaluation ( lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet [ , iteratorKind ] )
抽象操作 ForIn/OfBodyEvaluation 接受参数 lhs（一个
- 如果 iteratorKind 不存在，设置
iteratorKind 为
sync 。 - 令 oldEnv 为
运行执行上下文 的词法环境。 - 令 V 为
undefined 。 - 令 destructuring 为
IsDestructuring 的 lhs。 - 如果 destructuring 为
true 且 lhsKind 为assignment ，则断言 ：lhs 是一个LeftHandSideExpression 。- 令 assignmentPattern 为
AssignmentPattern 的覆盖 的 lhs。
- 重复，
- 令 nextResult 为 ?
Call (iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]])。 - 如果 iteratorKind 是
async ， 设置 nextResult 为 ?Await (nextResult)。 - 如果 nextResult
不是一个 Object ，抛出一个TypeError 异常。 - 令 done 为 ?
IteratorComplete (nextResult)。 - 如果 done 是
true ，返回 V。 - 令 nextValue 为 ?
IteratorValue (nextResult)。 - 如果 lhsKind 是
assignment 或var-binding ，则- 如果 destructuring 是
true ， 则- 如果 lhsKind 是
assignment ，则- 令 status 为
Completion (DestructuringAssignmentEvaluation of assignmentPattern with argument nextValue)。
- 令 status 为
- 否则，
断言 ： lhsKind 是var-binding 。断言 ：lhs 是一个ForBinding 。- 令 status 为
Completion (BindingInitialization of lhs 使用 参数 nextValue 和undefined )。
- 如果 lhsKind 是
- 否则，
- 令 lhsRef 为
Completion (Evaluation of lhs)。（可能会被 多次评估。） - 如果 lhsRef 是一个
异常 完成 ，则- 令 status 为 lhsRef。
- 否则，
- 令 status 为
Completion (PutValue (lhsRef.[[Value]], nextValue))。
- 令 status 为
- 令 lhsRef 为
- 如果 destructuring 是
- 否则，
断言 ：lhsKind 是lexical-binding 。断言 ：lhs 是一个ForDeclaration 。- 令 iterationEnv 为
NewDeclarativeEnvironment (oldEnv)。 - 执行
ForDeclarationBindingInstantiation 的 lhs 使用参数 iterationEnv。 - 设置
运行 执行上下文 的词法环境为 iterationEnv。 - 如果 destructuring 是
true ， 则- 令 status 为
Completion (ForDeclarationBindingInitialization of lhs 使用参数 nextValue 和 iterationEnv)。
- 令 status 为
- 否则，
断言 ：lhs 绑定一个单一的名称。- 令 lhsName 为
BoundNames 的 lhs 的唯一元素。 - 令 lhsRef 为 !
ResolveBinding (lhsName)。 - 令 status 为
Completion (InitializeReferencedBinding (lhsRef, nextValue))。
- 如果 status 是一个
异常 完成 ，则- 设置
运行 执行上下文 的词法环境为 oldEnv。 - 如果 iteratorKind 是
async ，返回 ?AsyncIteratorClose (iteratorRecord, status)。 - 如果 iterationKind 是
enumerate ，则- 返回 ? status。
- 否则，
断言 ： iterationKind 是iterate 。- 返回 ?
IteratorClose (iteratorRecord, status)。
- 设置
- 令 result 为
Completion (Evaluation of stmt)。 - 设置
运行 执行上下文 的词法环境为 oldEnv。 - 如果
LoopContinues (result, labelSet) 是false ，则- 如果 iterationKind 是
enumerate ，则- 返回 ?
UpdateEmpty (result, V)。
- 返回 ?
- 否则，
断言 ： iterationKind 是iterate 。- 设置 status 为
Completion (UpdateEmpty (result, V))。 - 如果 iteratorKind 是
async ，返回 ?AsyncIteratorClose (iteratorRecord, status)。 - 返回 ?
IteratorClose (iteratorRecord, status)。
- 如果 iterationKind 是
- 如果 result.[[Value]]
不是
empty ，设置 V 为 result.[[Value]]。
- 令 nextResult 为 ?
14.7.5.8 运行时语义：评估
- 令 bindingId 为
StringValue 的BindingIdentifier 。 - 返回 ?
ResolveBinding (bindingId)。
14.7.5.9 EnumerateObjectProperties ( O )
抽象操作 EnumerateObjectProperties 接受参数 O（一个对象）并返回一个迭代器。它在调用时执行以下步骤：
- 返回一个迭代器对象（
27.1.1.2 ），其next方法遍历 O 的所有可枚举的字符串键属性。迭代器对象对 ECMAScript 代码永远不可直接访问。遍历属性的机制和顺序未指定，但必须符合以下规则。
迭代器的 throw 和 return 方法是 next 方法处理对象属性以确定属性键是否应作为迭代器值返回。返回的属性键不包括 Symbols。目标对象的属性可能在枚举期间被删除。在迭代器的 next
方法处理之前删除的属性将被忽略。如果在枚举期间向目标对象添加新属性，则不能保证新添加的属性会在活动枚举中被处理。一个属性名在任何枚举中最多由迭代器的 next 方法返回一次。
枚举目标对象的属性包括枚举其原型及其原型的原型等的属性，递归地；但如果原型的属性与迭代器的 next 方法已经处理的属性同名，则不处理原型的属性。原型对象的可枚举属性名必须通过调用
EnumerateObjectProperties 并将原型对象作为参数来获取。EnumerateObjectProperties 必须通过调用目标对象的 [[OwnPropertyKeys]] 内部方法来获取目标对象的自有属性键。目标对象的属性属性必须通过调用其 [[GetOwnProperty]] 内部方法来获取。
此外，如果 O 或其原型链中的任何对象不是
- O 或其原型链中的对象的 [[Prototype]] 内部槽的值发生变化，
- O 或其原型链中的对象的属性被删除，
- O 的原型链中的对象的属性被添加，或
- O 或其原型链中的对象的属性的 [[Enumerable]] 属性发生变化。
ECMAScript 实现不需要直接实现
以下是一个符合这些规则的 ECMAScript 生成器函数的非正式定义：
function* EnumerateObjectProperties(obj) {
const visited = new Set();
for (const key of Reflect.ownKeys(obj)) {
if (typeof key === "symbol") continue;
const desc = Reflect.getOwnPropertyDescriptor(obj, key);
if (desc) {
visited.add(key);
if (desc.enumerable) yield key;
}
}
const proto = Reflect.getPrototypeOf(obj);
if (proto === null) return;
for (const protoKey of EnumerateObjectProperties(proto)) {
if (!visited.has(protoKey)) yield protoKey;
}
}14.7.5.10 For-In 迭代器对象
For-In 迭代器是表示特定对象上的特定迭代的对象。For-In 迭代器对象永远不会直接对 ECMAScript 代码可访问；它们仅存在于阐明
14.7.5.10.1 CreateForInIterator ( object )
抽象操作 CreateForInIterator 接受参数 object（一个对象）并返回一个 For-In 迭代器。它用于创建一个 For-In 迭代器对象，该对象按特定顺序迭代 object 的自身和继承的可枚举字符串属性。调用时执行以下步骤：
- 令 iterator 为
OrdinaryObjectCreate (%ForInIteratorPrototype% , « [[Object]], [[ObjectWasVisited]], [[VisitedKeys]], [[RemainingKeys]] »)。 - 将 iterator.[[Object]] 设置为 object。
- 将 iterator.[[ObjectWasVisited]] 设置为
false 。 - 将 iterator.[[VisitedKeys]]
设置为一个新的空
列表 。 - 将 iterator.[[RemainingKeys]] 设置为一个新的空
列表 。 - 返回 iterator。
14.7.5.10.2 %ForInIteratorPrototype% 对象
%ForInIteratorPrototype% 对象：
- 具有所有 For-In 迭代器对象继承的属性。
- 是一个
普通对象 。 - 有一个内部槽 [[Prototype]]，其值是
%IteratorPrototype% 。 - 永远不能被 ECMAScript 代码直接访问。
- 具有以下属性：
14.7.5.10.2.1 %ForInIteratorPrototype%.next ( )
- 令 O 为
this 值。 断言 ：O 是一个对象 。断言 ：O 具有 For-In 迭代器实例的所有内部槽 (14.7.5.10.3 )。- 令 object 为 O.[[Object]]。
- 重复，
- 如果 O.[[ObjectWasVisited]] 为
false ，则- 令 keys 为 ? object.[[OwnPropertyKeys]]()。
- 对 keys 的每个元素 key，执行
- 如果 key 是一个
字符串 ，则- 将 key 追加到 O.[[RemainingKeys]]。
- 如果 key 是一个
- 将 O.[[ObjectWasVisited]] 设置为
true 。
- 重复，直到 O.[[RemainingKeys]] 为空，
- 令 r 为 O.[[RemainingKeys]] 的第一个元素。
- 从 O.[[RemainingKeys]] 中移除第一个元素。
- 如果 O.[[VisitedKeys]] 中不存在一个元素 v 使得
SameValue (r, v) 为true ，则- 令 desc 为 ? object.[[GetOwnProperty]](r)。
- 如果 desc 不为
undefined ，则- 将 r 追加到 O.[[VisitedKeys]]。
- 如果 desc.[[Enumerable]] 为
true ，返回CreateIterResultObject (r,false )。
- 将 object 设置为 ? object.[[GetPrototypeOf]]()。
- 将 O.[[Object]] 设置为 object。
- 将 O.[[ObjectWasVisited]] 设置为
false 。 - 如果 object 为
null ，返回CreateIterResultObject (undefined ,true )。
- 如果 O.[[ObjectWasVisited]] 为
14.7.5.10.3 For-In 迭代器实例的属性
For-In 迭代器实例是
14.8 continue 语句
语法
14.8.1 静态语义：早期错误
-
如果这个
ContinueStatement 不是嵌套在一个IterationStatement 内（直接或间接，但不跨函数或static初始化块边界），则是语法错误。
14.8.2 运行时语义：求值
- 返回
完成记录 { [[Type]]:continue , [[Value]]:empty , [[Target]]:empty }.
- 令 label 为
StringValue 的LabelIdentifier 。 - 返回
完成记录 { [[Type]]:continue , [[Value]]:empty , [[Target]]: label }.
14.9 break 语句
语法
14.9.1 静态语义：早期错误
-
如果这个
BreakStatement 不是嵌套在一个IterationStatement 或一个SwitchStatement 内（直接或间接，但不跨函数或static初始化块边界），则是语法错误。
14.9.2 运行时语义：求值
- 返回
完成记录 { [[Type]]:break , [[Value]]:empty , [[Target]]:empty }.
- 令 label 为
StringValue 的LabelIdentifier 。 - 返回
完成记录 { [[Type]]:break , [[Value]]:empty , [[Target]]: label }.
14.10 return 语句
语法
return 语句会导致函数停止执行，并在大多数情况下返回一个值给调用者。如果省略了
return 语句可能实际上不会返回值给调用者。例如，在
try 块中，return 语句的
finally 块时被另一个
14.10.1 运行时语义：求值
-
返回
Completion Record { [[Type]]:return , [[Value]]:undefined , [[Target]]:empty }.
-
令 exprRef 为 ?
Evaluation 的Expression 。 -
令 exprValue 为 ?
GetValue (exprRef)。 -
如果
GetGeneratorKind () 是async ，设置 exprValue 为 ?Await (exprValue)。 -
返回
Completion Record { [[Type]]:return , [[Value]]: exprValue, [[Target]]:empty }.
14.11 with 语句
语法
with 语句为计算对象添加了一个
14.11.1 静态语义：早期错误
-
如果此产生式匹配的
源文本 包含在严格模式代码 中，则这是一个语法错误。 -
如果
IsLabelledFunction (Statement ) 是true ，则这是一个语法错误。
仅在实现
14.11.2 运行时语义：求值
-
令 val 为 ?
Evaluation 的Expression 。 -
令 obj 为 ?
ToObject (?GetValue (val))。 -
令 oldEnv 为当前执行上下文的
词法环境 。 -
令 newEnv 为
NewObjectEnvironment (obj,true , oldEnv)。 -
将当前执行上下文的
词法环境 设置为 newEnv。 -
令 C 为
Completion (Evaluation 的Statement )。 -
将当前执行上下文的
词法环境 设置回 oldEnv。 -
返回 ?
UpdateEmpty (C,undefined )。
14.12 switch 语句
语法
14.12.1 静态语义：早期错误
-
如果
CaseBlock 的LexicallyDeclaredNames 包含任何重复条目，则这是一个语法错误。 -
如果
CaseBlock 的任何元素在VarDeclaredNames 中也出现，则这是一个语法错误。
14.12.2 运行时语义：CaseBlockEvaluation
- 返回
undefined 。
- 令 V 为
undefined 。 - 令 A 为
List 中的CaseClause 项，按源文本顺序排列。 - 令 found 为
false 。 - 对 A 中的每个
CaseClause C，执行以下操作：-
如果 found 为
false ，则：-
令 found 为 ?
CaseClauseIsSelected (C, input)。
-
令 found 为 ?
-
如果 found 为
true ，则：-
令 R 为
Completion (Evaluation (C))。 -
如果 R.[[Value]] 不是
empty ，则将 V 设为 R.[[Value]]。 -
如果 R 是
中止完成 ，则返回 ?UpdateEmpty (R, V)。
-
令 R 为
-
如果 found 为
- 返回 V。
- 令 V 为
undefined 。 - 如果存在第一个
CaseClauses ，则：-
令 A 为
List 中的CaseClause 项，按源文本顺序排列。
-
令 A 为
-
否则：
-
令 A 为一个新的空
List 。
-
令 A 为一个新的空
- 令 found 为
false 。 - 对 A 中的每个
CaseClause C，执行以下操作：-
如果 found 为
false ，则：-
令 found 为 ?
CaseClauseIsSelected (C, input)。
-
令 found 为 ?
-
如果 found 为
true ，则：-
令 R 为
Completion (Evaluation (C))。 -
如果 R.[[Value]] 不是
empty ，则将 V 设为 R.[[Value]]。 -
如果 R 是
中止完成 ，则返回 ?UpdateEmpty (R, V)。
-
令 R 为
-
如果 found 为
- 令 foundInB 为
false 。 - 如果存在第二个
CaseClauses ，则：-
令 B 为
List 中的CaseClause 项，按源文本顺序排列。
-
令 B 为
-
否则：
-
令 B 为一个新的空
List 。
-
令 B 为一个新的空
-
如果 found 为
false ，则：-
对 B 中的每个
CaseClause C，执行以下操作：-
如果 foundInB 为
false ，则：-
令 foundInB 为 ?
CaseClauseIsSelected (C, input)。
-
令 foundInB 为 ?
-
如果 foundInB 为
true ，则：-
令 R 为
Completion (Evaluation (CaseClause C))。 -
如果 R.[[Value]] 不是
empty ，则将 V 设为 R.[[Value]]。 -
如果 R 是
中止完成 ，则返回 ?UpdateEmpty (R, V)。
-
令 R 为
-
如果 foundInB 为
-
对 B 中的每个
- 如果 foundInB 为
true ，则返回 V。 -
令 defaultR 为
Completion (Evaluation (DefaultClause ))。 -
如果 defaultR.[[Value]] 不是
empty ，则将 V 设为 defaultR.[[Value]]。 -
如果 defaultR 是
中止完成 ，则返回 ?UpdateEmpty (defaultR, V)。 -
注：以下是第二个
CaseClauses 的另一个完整迭代。 -
对 B 中的每个
CaseClause C，执行以下操作：-
令 R 为
Completion (Evaluation (CaseClause C))。 -
如果 R.[[Value]] 不是
empty ，则将 V 设为 R.[[Value]]。 -
如果 R 是
中止完成 ，则返回 ?UpdateEmpty (R, V)。
-
令 R 为
- 返回 V。
14.12.3 CaseClauseIsSelected ( C, input )
抽象操作 CaseClauseIsSelected 接受参数 C（一个
-
断言 ：C 是CaseClause : case Expression : StatementList opt -
令 exprRef 为 ?
Evaluation C 的Expression 。 -
令 clauseSelector 为 ?
GetValue (exprRef)。 -
返回
IsStrictlyEqual (input, clauseSelector)。
此操作不执行 C 的
14.12.4 运行时语义：Evaluation
-
令 exprRef 为 ?
Evaluation (Expression )。 -
令 switchValue 为 ?
GetValue (exprRef)。 -
令 oldEnv 为
当前执行上下文 的 LexicalEnvironment。 -
令 blockEnv 为
NewDeclarativeEnvironment (oldEnv)。 -
执行
BlockDeclarationInstantiation (CaseBlock , blockEnv)。 -
将
当前执行上下文 的 LexicalEnvironment 设置为 blockEnv。 -
令 R 为
Completion (CaseBlockEvaluation (CaseBlock , switchValue))。 -
将
当前执行上下文 的 LexicalEnvironment 设置回 oldEnv。 - 返回 R。
无论控制如何离开
- 返回
empty 。
-
返回 ?
Evaluation (StatementList )。
- 返回
empty 。
-
返回 ?
Evaluation (StatementList )。
14.13 带标签的语句
语法
一个 break和continue语句结合使用。ECMAScript
没有goto语句。
一个
14.13.1 静态语义：早期错误
- 如果此生成的源文本匹配任何源文本，则为语法错误。
如果实现了
14.13.2 静态语义：IsLabelledFunction (stmt)
抽象操作 IsLabelledFunction 接受参数 stmt (一个
- 如果 stmt 不是一个
LabelledStatement ，返回false 。 - 让 item 成为 stmt 的
LabelledItem 。 - 如果 item 是
LabelledItem : FunctionDeclaration true 。 - 让 subStmt 成为 item 的
Statement 。 - 返回
IsLabelledFunction (subStmt)。
14.13.3 运行时语义：评估
- 返回 ?
LabelledEvaluation 的这个LabelledStatement ，参数为 « »。
14.13.4 运行时语义：LabelledEvaluation
- 让 stmtResult 成为
Completion (LoopEvaluation 的IterationStatement ，参数为 labelSet)。 - 如果 stmtResult 是一个
break completion ，则- 如果 stmtResult.[[Target]] 是
empty ，则- 如果 stmtResult.[[Value]]
是
empty ，则将 stmtResult 设置为NormalCompletion (undefined )。 - 否则，将 stmtResult 设置为
NormalCompletion (stmtResult.[[Value]])。
- 如果 stmtResult.[[Value]]
是
- 如果 stmtResult.[[Target]] 是
- 返回 ? stmtResult。
- 让 stmtResult 成为
Completion (Evaluation 的SwitchStatement )。 - 如果 stmtResult 是一个
break completion ，则- 如果 stmtResult.[[Target]] 是
empty ，则- 如果 stmtResult.[[Value]]
是
empty ，则将 stmtResult 设置为NormalCompletion (undefined )。 - 否则，将 stmtResult 设置为
NormalCompletion (stmtResult.[[Value]])。
- 如果 stmtResult.[[Value]]
是
- 如果 stmtResult.[[Target]] 是
- 返回 ? stmtResult。
一个
- 让 label 成为
StringValue 的LabelIdentifier 。 - 让 newLabelSet 成为
列表连接 的 labelSet 和 « label »。 - 让 stmtResult 成为
Completion (LabelledEvaluation 的LabelledItem ，参数为 newLabelSet)。 - 如果 stmtResult 是一个
break completion 并且 stmtResult.[[Target]] 是 label，则- 将 stmtResult 设置为
NormalCompletion (stmtResult.[[Value]])。
- 将 stmtResult 设置为
- 返回 ? stmtResult。
- 返回 ?
Evaluation 的FunctionDeclaration 。
- 返回 ?
Evaluation 的Statement 。
14.14 throw 语句
语法
14.14.1 运行时语义：求值
- 令 exprRef 为 ?
Evaluation 的表达式。 - 令 exprValue 为 ?
GetValue (exprRef)。 - 返回
ThrowCompletion (exprValue)。
14.15 try 语句
语法
try 语句包含可能发生异常的代码块，如运行时错误或 throw 语句。catch 子句提供异常处理代码。当 catch 子句捕获异常时，其
14.15.1 静态语义：早期错误
-
如果
BoundNames 中的CatchParameter 包含任何重复元素，则为语法错误。 -
如果
BoundNames 中的任何元素也出现在LexicallyDeclaredNames 的Block 中，则为语法错误。 -
如果
BoundNames 中的任何元素也出现在VarDeclaredNames 的Block 中，则为语法错误。
对于此生成规则的替代静态语义定义，见
14.15.2 运行时语义：CatchClauseEvaluation
CatchClauseEvaluation 是一个带有参数 thrownValue（一个 ECMAScript 语言值）的语法直接操作，返回一个包含 ECMAScript 语言值的正常完成记录或一个中断完成记录。它在以下生成规则中定义：
- 令 oldEnv 为当前执行上下文的 LexicalEnvironment。
- 令 catchEnv 为
NewDeclarativeEnvironment (oldEnv)。 - 对于
BoundNames 的CatchParameter 中的每个元素 argName，执行- 执行
! catchEnv.CreateMutableBinding(argName,
false )。
- 执行
! catchEnv.CreateMutableBinding(argName,
- 将当前执行上下文的 LexicalEnvironment 设置为 catchEnv。
- 令 status 为
Completion (BindingInitialization 的CatchParameter ，参数为 thrownValue 和 catchEnv)。 - 如果 status 是一个中断完成，则
- 将当前执行上下文的 LexicalEnvironment 设置为 oldEnv。
- 返回 ? status。
- 令 B 为
Completion (Evaluation 的Block )。 - 将当前执行上下文的 LexicalEnvironment 设置为 oldEnv。
- 返回 ? B。
- 返回 ?
Evaluation 的Block 。
无论控制如何离开
14.15.3 运行时语义：Evaluation
- 令 B 为
Completion (Evaluation 的Block )。 - 如果 B 是一个
throw completion ，令 C 为Completion (CatchClauseEvaluation 的Catch ，参数为 B.[[Value]])。 - 否则，令 C 为 B。
- 返回 ?
UpdateEmpty (C,undefined )。
- 令 B 为
Completion (Evaluation 的Block )。 - 令 F 为
Completion (Evaluation 的Finally )。 - 如果 F 是一个
normal completion ，则将 F 设置为 B。 - 返回 ?
UpdateEmpty (F,undefined )。
- 令 B 为
Completion (Evaluation 的Block )。 - 如果 B 是一个
throw completion ，令 C 为Completion (CatchClauseEvaluation 的Catch ，参数为 B.[[Value]])。 - 否则，令 C 为 B。
- 令 F 为
Completion (Evaluation 的Finally )。 - 如果 F 是一个
normal completion ，则将 F 设置为 C。 - 返回 ?
UpdateEmpty (F,undefined )。
14.16 debugger 语句
句法
14.16.1 运行时语义：Evaluation
执行
- 如果一个
实现定义 的调试设施可用且已启用，则- 执行一个
实现定义 的调试动作。 - 返回一个新的
实现定义 的Completion Record 。
- 执行一个
- 否则，
- 返回
empty 。
- 返回
15 ECMAScript 语言：函数和类
各种 ECMAScript 语言元素会导致创建 ECMAScript
15.1 参数列表
语法
15.1.1 静态语义：早期错误
-
如果
BoundNames 中包含FormalParameters 的任何重复元素，则这是一个语法错误。
-
如果
IsSimpleParameterList 是false ，并且BoundNames 中包含FormalParameterList 的任何重复元素，则这是一个语法错误。
在
15.1.2 静态语义：ContainsExpression
- 返回
false 。
- 返回
false 。
- 令 has 为
ContainsExpression 的BindingElementList 。 - 如果 has 为
true ，则返回true 。 - 返回
ContainsExpression 的BindingRestElement 。
- 令 has 为
ContainsExpression 的BindingPropertyList 。 - 如果 has 为
true ，则返回true 。 - 返回
ContainsExpression 的BindingProperty 。
- 令 has 为
ContainsExpression 的BindingElementList 。 - 如果 has 为
true ，则返回true 。 - 返回
ContainsExpression 的BindingElisionElement 。
- 令 has 为
IsComputedPropertyKey 的PropertyName 。 - 如果 has 为
true ，则返回true 。 - 返回
ContainsExpression 的BindingElement 。
- 返回
true 。
- 返回
false 。
- 返回
true 。
- 返回
false 。
- 返回
false 。
- 如果
ContainsExpression 的FormalParameterList 为true ，则返回true 。 - 返回
ContainsExpression 的FunctionRestParameter 。
- 如果
ContainsExpression 的FormalParameterList 为true ，则返回true 。 - 返回
ContainsExpression 的FormalParameter 。
- 返回
false 。
- 令 formals 为
ArrowFormalParameters ，它被涵盖 的CoverParenthesizedExpressionAndArrowParameterList 。 - 返回
ContainsExpression 的 formals。
- 返回
false 。
15.1.3 静态语义：IsSimpleParameterList
- 返回
false 。
- 返回
false 。
- 返回
true 。
- 返回
false 。
- 返回
true 。
- 返回
false 。
- 返回
false 。
- 如果
IsSimpleParameterList 的FormalParameterList 为false ，则返回false 。 - 返回
IsSimpleParameterList 的FormalParameter 。
- 返回
true 。
- 令 formals 为
ArrowFormalParameters ，它被涵盖 的CoverParenthesizedExpressionAndArrowParameterList 。 - 返回
IsSimpleParameterList 的 formals。
- 返回
true 。
- 令 head 为
AsyncArrowHead ，它被涵盖 的CoverCallExpressionAndAsyncArrowHead 。 - 返回
IsSimpleParameterList 的 head。
15.1.4 静态语义：HasInitializer
- 返回
false 。
- 返回
true 。
- 返回
false 。
- 返回
true 。
- 如果
HasInitializer 的FormalParameterList 为true ，则返回true 。 - 返回
HasInitializer 的FormalParameter 。
15.1.5 静态语义：ExpectedArgumentCount
- 返回 0。
- 如果
HasInitializer 的FormalParameter 为true ，返回 0。 - 返回 1。
- 令 count 为
ExpectedArgumentCount 的FormalParameterList 。 - 如果
HasInitializer 的FormalParameterList 为true 或者HasInitializer 的FormalParameter 为true ，则返回 count。 - 返回 count + 1。
- 返回 1。
- 令 formals 为
ArrowFormalParameters ，它被涵盖 的CoverParenthesizedExpressionAndArrowParameterList 。 - 返回
ExpectedArgumentCount 的 formals。
- 如果
HasInitializer 的FormalParameter 为true ，返回 0。 - 返回 1。
- 返回 1。
15.2 函数定义
语法
15.2.1 静态语义：早期错误
-
如果
source text matched by FormalParameters 是strict mode code ， 则应用UniqueFormalParameters : FormalParameters -
如果存在
BindingIdentifier 并且source text matched by BindingIdentifier 是strict mode code ， 则如果StringValue 是"eval" 或"arguments" ，则为语法错误。 -
如果
FunctionBodyContainsUseStrict 为true 并且IsSimpleParameterList 为false ，则为语法错误。 -
如果
FormalParameters 的BoundNames 的任何元素也出现在LexicallyDeclaredNames 的FunctionBody 中，则为语法错误。 -
如果
FormalParameters 包含SuperProperty 为true ，则为语法错误。 -
如果
FunctionBody 包含SuperProperty 为true ，则为语法错误。 -
如果
FormalParameters 包含SuperCall 为true ，则为语法错误。 -
如果
FunctionBody 包含SuperCall 为true ，则为语法错误。
-
如果
LexicallyDeclaredNames 包含任何重复项，则为语法错误。 -
如果
LexicallyDeclaredNames 的任何元素也出现在VarDeclaredNames 的FunctionStatementList 中，则为语法错误。 -
如果
ContainsDuplicateLabels 为true ，则为语法错误。 -
如果
ContainsUndefinedBreakTarget 为true ，则为语法错误。 -
如果
ContainsUndefinedContinueTarget 为true ，则为语法错误。
15.2.2 静态语义：FunctionBodyContainsUseStrict
-
如果
Directive Prologue 的FunctionBody 包含Use Strict Directive ，则返回true ；否则，返回false 。
15.2.3 运行时语义：EvaluateFunctionBody
-
执行 ?
FunctionDeclarationInstantiation (functionObject, argumentsList)。 -
返回 ?
Evaluation 的FunctionStatementList 。
15.2.4 运行时语义：InstantiateOrdinaryFunctionObject
-
令 name 为
StringValue 的BindingIdentifier 。 -
令 sourceText 为
source text matched by 的FunctionDeclaration 。 -
令 F 为
OrdinaryFunctionCreate (%Function.prototype% ，sourceText，FormalParameters ，FunctionBody ，non-lexical-this ，env，privateEnv)。 -
执行
SetFunctionName (F，name)。 -
执行
MakeConstructor (F)。 - 返回 F。
-
令 sourceText 为
source text matched by 的FunctionDeclaration 。 -
令 F 为
OrdinaryFunctionCreate (%Function.prototype% ，sourceText，FormalParameters ，FunctionBody ，non-lexical-this ，env，privateEnv)。 -
执行
SetFunctionName (F，"default" )。 -
执行
MakeConstructor (F)。 - 返回 F。
匿名的 export default 声明的一部分出现，因此其函数代码始终是
15.2.5 运行时语义：InstantiateOrdinaryFunctionExpression
- 如果 name 不存在，则将 name 设置为空字符串。
- 令 env 为当前执行上下文的词法环境。
- 令 privateEnv 为当前执行上下文的私有环境。
-
令 sourceText 为
source text matched by 的FunctionExpression 。 -
令 closure 为
OrdinaryFunctionCreate (%Function.prototype% ，sourceText，FormalParameters ，FunctionBody ，non-lexical-this ，env，privateEnv)。 -
执行
SetFunctionName (closure，name)。 -
执行
MakeConstructor (closure)。 - 返回 closure。
-
断言 ：name 不存在。 -
设置 name 为
StringValue 的BindingIdentifier 。 - 令 outerEnv 为当前执行上下文的词法环境。
-
令 funcEnv 为
NewDeclarativeEnvironment (outerEnv)。 -
执行 ! funcEnv.CreateImmutableBinding(name,
false )。 - 令 privateEnv 为当前执行上下文的私有环境。
-
令 sourceText 为
source text matched by 的FunctionExpression 。 -
令 closure 为
OrdinaryFunctionCreate (%Function.prototype% ，sourceText，FormalParameters ，FunctionBody ，non-lexical-this ，funcEnv，privateEnv)。 -
执行
SetFunctionName (closure，name)。 -
执行
MakeConstructor (closure)。 - 执行 ! funcEnv.InitializeBinding(name, closure)。
- 返回 closure。
15.2.6 运行时语义：Evaluation
-
返回
empty 。
替代语义见
-
返回
empty 。
使用
-
返回
undefined 。
15.3 箭头函数定义
语法
补充语法
处理生产式的实例时
15.3.1 静态语义：早期错误
-
如果
ArrowParameters Contains YieldExpression 是true ，则为语法错误。 -
如果
ArrowParameters Contains AwaitExpression 是true ，则为语法错误。 -
如果
ConciseBodyContainsUseStrict 的ConciseBody 是true 并且IsSimpleParameterList 的ArrowParameters 是false ，则为语法错误。 -
如果
BoundNames 的ArrowParameters 的任何元素也出现在LexicallyDeclaredNames 的ConciseBody 中，则为语法错误。
15.3.2 静态语义：ConciseBodyContainsUseStrict
-
返回
false 。
15.3.3 运行时语义：EvaluateConciseBody
-
执行 ?
FunctionDeclarationInstantiation (functionObject，argumentsList)。 -
返回 ?
Evaluation 的ExpressionBody 。
15.3.4 运行时语义：InstantiateArrowFunctionExpression
-
如果 name 不存在，将 name 设置为
"" 。 - 令 env 为当前执行上下文的词法环境。
- 令 privateEnv 为当前执行上下文的私有环境。
-
令 sourceText 为
source text matched by 的ArrowFunction 。 -
令 closure 为
OrdinaryFunctionCreate (%Function.prototype% ，sourceText，ArrowParameters ，ConciseBody ，lexical-this ，env，privateEnv)。 -
执行
SetFunctionName (closure，name)。 - 返回 closure。
arguments，super，this 或 new.target
的本地绑定。在
arguments，super，this 或 new.target
的任何引用必须解析为词法上封闭的环境中的绑定。通常，这将是紧密封闭函数的函数环境。即使
super 的引用，在步骤
super 的
super 所需的状态可以通过
15.3.5 运行时语义：Evaluation
-
令 exprRef 为 ?
Evaluation 的AssignmentExpression 。 -
令 exprValue 为 ?
GetValue (exprRef)。 -
返回
Completion Record { [[Type]]:return ，[[Value]]：exprValue，[[Target]]：empty }。
15.4 方法定义
语法
15.4.1 静态语义：早期错误
-
如果
FunctionBodyContainsUseStrict 的FunctionBody 是true ，并且IsSimpleParameterList 的UniqueFormalParameters 是false ，则这是语法错误。 -
如果
BoundNames 的任何元素在LexicallyDeclaredNames 的FunctionBody 中也出现，则这是语法错误。
-
如果
BoundNames 的PropertySetParameterList 包含任何重复元素，则这是语法错误。 -
如果
FunctionBodyContainsUseStrict 的FunctionBody 是true ，并且IsSimpleParameterList 的PropertySetParameterList 是false ，则这是语法错误。 -
如果
BoundNames 的任何元素在LexicallyDeclaredNames 的FunctionBody 中也出现，则这是语法错误。
15.4.2 静态语义：HasDirectSuper
语法指向操作 HasDirectSuper 不接受任何参数并返回一个布尔值。它在以下生成式上逐段定义：
-
如果
UniqueFormalParameters 包含 SuperCall 是true ，则返回true 。 -
返回
FunctionBody 包含 SuperCall 。
-
返回
FunctionBody 包含 SuperCall 。
-
如果
PropertySetParameterList 包含 SuperCall 是true ，则返回true 。 -
返回
FunctionBody 包含 SuperCall 。
-
如果
UniqueFormalParameters 包含 SuperCall 是true ，则返回true 。 -
返回
GeneratorBody 包含 SuperCall 。
-
如果
UniqueFormalParameters 包含 SuperCall 是true ，则返回true 。 -
返回
AsyncGeneratorBody 包含 SuperCall 。
-
如果
UniqueFormalParameters 包含 SuperCall 是true ，则返回true 。 -
返回
AsyncFunctionBody 包含 SuperCall 。
15.4.3 静态语义：SpecialMethod
语法指向操作 SpecialMethod 不接受任何参数并返回一个布尔值。它在以下生成式上逐段定义：
- 返回
false 。
- 返回
true 。
15.4.4 运行时语义：DefineMethod
语法指向操作 DefineMethod 接受参数 object（一个对象）和可选参数 functionPrototype（一个对象），并返回一个包含字段 [[Key]]（一个属性键）和 [[Closure]]（一个 ECMAScript 函数对象）的 Record 的正常完成，或一个中断完成。它在以下生成式上逐段定义：
-
令 propKey 为 ?
Evaluation 的ClassElementName 的结果。 -
令 env 为
当前执行上下文 的 LexicalEnvironment。 -
令 privateEnv 为
当前执行上下文 的 PrivateEnvironment。 -
如果 functionPrototype 存在，则：
- 令 prototype 为 functionPrototype。
-
否则：
-
令 prototype 为
%Function.prototype% 。
-
令 prototype 为
-
令 sourceText 为
由 MethodDefinition 匹配的源文本。 -
令 closure 为
OrdinaryFunctionCreate (prototype, sourceText,UniqueFormalParameters ,FunctionBody , non-lexical-this, env, privateEnv)。 -
执行
MakeMethod (closure, object)。 - 返回 { [[Key]]: propKey, [[Closure]]: closure } 的 Record。
15.4.5 运行时语义：MethodDefinitionEvaluation
语法指向操作 MethodDefinitionEvaluation 接受参数 object（一个对象）和 enumerable（一个布尔值），并返回包含一个 PrivateElement 或 unused 的正常完成，或一个中断完成。它在以下生成式上逐段定义：
-
令 methodDef 为 ?
DefineMethod 的结果。 -
执行
SetFunctionName (methodDef.[[Closure]], methodDef.[[Key]])。 -
返回 ?
DefineMethodProperty (object, methodDef.[[Key]], methodDef.[[Closure]], enumerable)。
-
令 propKey 为 ?
Evaluation 的ClassElementName 的结果。 -
令 env 为
当前执行上下文 的 LexicalEnvironment。 -
令 privateEnv 为
当前执行上下文 的 PrivateEnvironment。 -
令 sourceText 为
由 MethodDefinition 匹配的源文本。 -
令 formalParameterList 为生产式
FormalParameters : [empty] -
令 closure 为
OrdinaryFunctionCreate (%Function.prototype% , sourceText, formalParameterList,FunctionBody , non-lexical-this, env, privateEnv)。 -
执行
MakeMethod (closure, object)。 -
执行
SetFunctionName (closure, propKey, "get")。 -
如果 propKey 是一个
私有名称 ，则：- 返回 { [[Key]]: propKey, [[Kind]]: accessor, [[Get]]: closure, [[Set]]: undefined } 的 PrivateElement。
-
否则：
- 令 desc 为 PropertyDescriptor { [[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }。
-
执行 ?
DefinePropertyOrThrow (object, propKey, desc)。 - 返回 unused。
-
令 propKey 为 ?
Evaluation 的ClassElementName 的结果。 -
令 env 为
当前执行上下文 的 LexicalEnvironment。 -
令 privateEnv 为
当前执行上下文 的 PrivateEnvironment。 -
令 sourceText 为
由 MethodDefinition 匹配的源文本。 -
令 closure 为
OrdinaryFunctionCreate (%Function.prototype% , sourceText,PropertySetParameterList ,FunctionBody , non-lexical-this, env, privateEnv)。 -
执行
MakeMethod (closure, object)。 -
执行
SetFunctionName (closure, propKey, "set")。 -
如果 propKey 是一个
私有名称 ，则：- 返回 { [[Key]]: propKey, [[Kind]]: accessor, [[Get]]: undefined, [[Set]]: closure } 的 PrivateElement。
-
否则：
- 令 desc 为 PropertyDescriptor { [[Set]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true }。
-
执行 ?
DefinePropertyOrThrow (object, propKey, desc)。 - 返回 unused。
-
令 propKey 为 ?
Evaluation 的ClassElementName 的结果。 -
令 env 为
当前执行上下文 的 LexicalEnvironment。 -
令 privateEnv 为
当前执行上下文 的 PrivateEnvironment。 -
令 sourceText 为
由 GeneratorMethod 匹配的源文本。 -
令 closure 为
OrdinaryFunctionCreate (%GeneratorFunction.prototype% , sourceText,UniqueFormalParameters ,GeneratorBody , non-lexical-this, env, privateEnv)。 -
执行
MakeMethod (closure, object)。 -
执行
SetFunctionName (closure, propKey)。 -
令 prototype 为
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% )。 -
执行 !
DefinePropertyOrThrow (closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false })。 -
返回 ?
DefineMethodProperty (object, propKey, closure, enumerable)。
-
令 propKey 为 ?
Evaluation 的ClassElementName 的结果。 -
令 env 为
当前执行上下文 的 LexicalEnvironment。 -
令 privateEnv 为
当前执行上下文 的 PrivateEnvironment。 -
令 sourceText 为
由 AsyncGeneratorMethod 匹配的源文本。 -
令 closure 为
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% , sourceText,UniqueFormalParameters ,AsyncGeneratorBody , non-lexical-this, env, privateEnv)。 -
执行
MakeMethod (closure, object)。 -
执行
SetFunctionName (closure, propKey)。 -
令 prototype 为
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% )。 -
执行 !
DefinePropertyOrThrow (closure, "prototype", PropertyDescriptor { [[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false })。 -
返回 ?
DefineMethodProperty (object, propKey, closure, enumerable)。
-
令 propKey 为 ?
Evaluation 的ClassElementName 的结果。 -
令 env 为
当前执行上下文 的 LexicalEnvironment。 -
令 privateEnv 为
当前执行上下文 的 PrivateEnvironment。 -
令 sourceText 为
由 AsyncMethod 匹配的源文本。 -
令 closure 为
OrdinaryFunctionCreate (%AsyncFunction.prototype% , sourceText,UniqueFormalParameters ,AsyncFunctionBody , non-lexical-this, env, privateEnv)。 -
执行
MakeMethod (closure, object)。 -
执行
SetFunctionName (closure, propKey)。 -
返回 ?
DefineMethodProperty (object, propKey, closure, enumerable)。
15.5 生成器函数定义
语法
紧接在 yield 之后的语法上下文要求使用
15.5.1 静态语义：早期错误
- 如果
HasDirectSuper 的GeneratorMethod 为true ，则这是一个语法错误。 - 如果
UniqueFormalParameters Contains YieldExpression 为true ，则这是一个语法错误。 - 如果
FunctionBodyContainsUseStrict 的GeneratorBody 为true ，且IsSimpleParameterList 的UniqueFormalParameters 为false ，则这是一个语法错误。 - 如果
BoundNames 的UniqueFormalParameters 的任何元素也出现在LexicallyDeclaredNames 中，则这是一个语法错误。
- 如果
源文本匹配 的FormalParameters 是严格模式代码 ，则适用UniqueFormalParameters : FormalParameters - 如果存在
BindingIdentifier 且源文本匹配 的BindingIdentifier 是严格模式代码 ，则如果StringValue 为"eval" 或"arguments" ，则这是一个语法错误。 - 如果
FunctionBodyContainsUseStrict 的GeneratorBody 为true ，且IsSimpleParameterList 的FormalParameters 为false ，则这是一个语法错误。 - 如果
BoundNames 的FormalParameters 的任何元素也出现在LexicallyDeclaredNames 中，则这是一个语法错误。 - 如果
FormalParameters Contains YieldExpression 为true ，则这是一个语法错误。 - 如果
FormalParameters Contains SuperProperty 为true ，则这是一个语法错误。 - 如果
GeneratorBody Contains SuperProperty 为true ，则这是一个语法错误。 - 如果
FormalParameters Contains SuperCall 为true ，则这是一个语法错误。 - 如果
GeneratorBody Contains SuperCall 为true ，则这是一个语法错误。
15.5.2 运行时语义：EvaluateGeneratorBody
语法导向操作
- 执行 ?
FunctionDeclarationInstantiation (functionObject, argumentsList)。 - 令 G 为 ?
OrdinaryCreateFromConstructor (functionObject,"%GeneratorFunction.prototype.prototype%" ，« [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] »)。 - 将 G.[[GeneratorBrand]] 设置为
empty 。 - 执行
GeneratorStart (G,FunctionBody )。 - 返回
完成记录 { [[Type]]:return , [[Value]]: G, [[Target]]:empty }。
15.5.3 运行时语义：InstantiateGeneratorFunctionObject
语法导向操作
- 令 name 为
StringValue 的BindingIdentifier 。 - 令 sourceText 为与
GeneratorDeclaration 匹配的GeneratorDeclaration 的源文本。 - 令 F 为
OrdinaryFunctionCreate (%GeneratorFunction.prototype% , sourceText，FormalParameters ，GeneratorBody ，non-lexical-this ，env，privateEnv）。 - 执行
SetFunctionName (F， name)。 - 令 prototype 为
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - 执行 !
DefinePropertyOrThrow (F，"prototype" ，属性描述符 { [[Value]]: prototype，[[Writable]]:true ，[[Enumerable]]:false ，[[Configurable]]:false }）。 - 返回 F。
- 令 sourceText 为与
GeneratorDeclaration 匹配的GeneratorDeclaration 的源文本。 - 令 F 为
OrdinaryFunctionCreate (%GeneratorFunction.prototype% , sourceText，FormalParameters ，GeneratorBody ，non-lexical-this ，env，privateEnv）。 - 执行
SetFunctionName (F，"default" )。 - 令 prototype 为
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - 执行 !
DefinePropertyOrThrow (F，"prototype" ，属性描述符 { [[Value]]: prototype，[[Writable]]:true ，[[Enumerable]]:false ，[[Configurable]]:false }）。 - 返回 F。
匿名的 export default 声明的一部分出现，因此其函数代码始终是
15.5.4 运行时语义：实例化生成器函数表达式
- 如果 name 不存在，将 name 设为空字符串
"" 。 - 令 env 为当前运行执行上下文的
词法环境 。 - 令 privateEnv 为当前运行执行上下文的
私有环境 。 - 令 sourceText 为与
语法导向操作 GeneratorExpression 匹配的源文本。 - 令 closure 为
OrdinaryFunctionCreate (%GeneratorFunction.prototype% , sourceText,FormalParameters ,GeneratorBody ,non-lexical-this , env, privateEnv)。 - 执行
SetFunctionName (closure, name)。 - 令 prototype 为
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% )。 - 执行
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]: prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false })。 - 返回 closure。
15.5.5 运行时语义：求值
- 返回 ?
Yield (undefined )。
- 令 exprRef 为 ?
Evaluation 的AssignmentExpression 。 - 令 value 为 ?
GetValue (exprRef)。 - 返回 ?
Yield (value)。
- 令 generatorKind 为
GetGeneratorKind ()。 - 令 exprRef 为 ?
Evaluation 的AssignmentExpression 。 - 令 value 为 ?
GetValue (exprRef)。 - 令 iteratorRecord 为 ?
GetIterator (value, generatorKind)。 - 令 iterator 为 iteratorRecord.[[Iterator]]。
- 令 received 为
NormalCompletion (undefined )。 - 重复，直到:
- 如果 received 是
正常完成 ，则- 令 innerResult 为 ?
Call (iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]], « received.[[Value]] »)。 - 如果 generatorKind 是
async ，将 innerResult 设为 ?Await (innerResult)。 - 如果 innerResult
不是对象 ，抛出TypeError 异常。 - 令 done 为 ?
IteratorComplete (innerResult)。 - 如果 done 为
true ，则- 返回 ?
IteratorValue (innerResult)。
- 返回 ?
- 如果 generatorKind 是
async ，将 received 设为Completion (?AsyncGeneratorYield (?IteratorValue (innerResult)))。 - 否则，将 received 设为
Completion (GeneratorYield (innerResult))。
- 令 innerResult 为 ?
- 否则，如果 received 是
throw completion ，则- 令 throw 为 ?
GetMethod (iterator,"throw" )。 - 如果 throw 不是
undefined ，则- 令 innerResult 为 ?
Call (throw, iterator, « received.[[Value]] »)。 - 如果 generatorKind 是
async ，将 innerResult 设为 ?Await (innerResult)。 - 注意：内部迭代器的
throw方法抛出的异常会被传播。throw方法的正常完成与next类似。 - 如果 innerResult
不是对象 ，抛出TypeError 异常。 - 令 done 为 ?
IteratorComplete (innerResult)。 - 如果 done 为
true ，则- 返回 ?
IteratorValue (innerResult)。
- 返回 ?
- 如果 generatorKind 是
async ，将 received 设为Completion (AsyncGeneratorYield (?IteratorValue (innerResult)))。 - 否则，将 received 设为
Completion (GeneratorYield (innerResult))。
- 令 innerResult 为 ?
- 否则，
-
断言 ：received 是return completion 。 - 令 return 为 ?
GetMethod (iterator,"return" )。 - 如果 return 是
undefined ，则- 将 value 设为 received.[[Value]]。
- 如果 generatorKind 是
async ，则- 将 value 设为 ?
Await (value)。
- 将 value 设为 ?
- 返回
Completion Record { [[Type]]:return , [[Value]]: value, [[Target]]:empty }。
- 令 innerReturnResult 为 ?
Call (return, iterator, « received.[[Value]] »)。 - 如果 generatorKind 是
async ，将 innerReturnResult 设为 ?Await (innerReturnResult)。 - 如果 innerReturnResult
不是对象 ，抛出TypeError 异常。 - 令 done 为 ?
IteratorComplete (innerReturnResult)。 - 如果 done 为
true ，则- 将 value 设为 ?
IteratorValue (innerReturnResult)。 - 返回
Completion Record { [[Type]]:return , [[Value]]: value, [[Target]]:empty }。
- 将 value 设为 ?
- 如果 generatorKind 是
async ，将 received 设为Completion (AsyncGeneratorYield (?IteratorValue (innerReturnResult)))。 - 否则，将 received 设为
Completion (GeneratorYield (innerReturnResult))。
-
- 令 throw 为 ?
- 如果 received 是
15.6 异步生成器函数定义
语法
15.6.1 静态语义：早期错误
-
如果
HasDirectSuper ofAsyncGeneratorMethod istrue ，则这是一个语法错误。 -
如果
UniqueFormalParameters Contains YieldExpression istrue ，则这是一个语法错误。 -
如果
UniqueFormalParameters Contains AwaitExpression istrue ，则这是一个语法错误。 -
如果
FunctionBodyContainsUseStrict ofAsyncGeneratorBody istrue 并且IsSimpleParameterList ofUniqueFormalParameters isfalse ，则这是一个语法错误。 -
如果
BoundNames ofUniqueFormalParameters 中的任何元素也出现在LexicallyDeclaredNames ofAsyncGeneratorBody 中，则这是一个语法错误。
-
如果
源文本匹配 FormalParameters 是严格模式代码 ，则适用UniqueFormalParameters : FormalParameters -
如果
BindingIdentifier 存在，并且源文本匹配 BindingIdentifier 是严格模式代码 ，如果StringValue ofBindingIdentifier 是"eval" 或"arguments" ，则这是一个语法错误。 -
如果
FunctionBodyContainsUseStrict ofAsyncGeneratorBody 是true 并且IsSimpleParameterList ofFormalParameters 是false ，则这是一个语法错误。 -
如果
BoundNames ofFormalParameters 中的任何元素也出现在LexicallyDeclaredNames ofAsyncGeneratorBody 中，则这是一个语法错误。 -
如果
FormalParameters Contains YieldExpression 是true ，则这是一个语法错误。 -
如果
FormalParameters Contains AwaitExpression 是true ，则这是一个语法错误。 -
如果
FormalParameters Contains SuperProperty 是true ，则这是一个语法错误。 -
如果
AsyncGeneratorBody Contains SuperProperty 是true ，则这是一个语法错误。 -
如果
FormalParameters Contains SuperCall 是true ，则这是一个语法错误。 -
如果
AsyncGeneratorBody Contains SuperCall 是true ，则这是一个语法错误。
15.6.2 运行时语义：EvaluateAsyncGeneratorBody
- 执行 ?
FunctionDeclarationInstantiation (functionObject, argumentsList)。 - 令 generator 为 ?
OrdinaryCreateFromConstructor (functionObject,"%AsyncGeneratorFunction.prototype.prototype%" , « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] »)。 - 将 generator.[[GeneratorBrand]]
设为
empty 。 - 执行
AsyncGeneratorStart (generator,FunctionBody )。 - 返回
Completion Record { [[Type]]:return , [[Value]]: generator, [[Target]]:empty }。
15.6.3 运行时语义：InstantiateAsyncGeneratorFunctionObject
- 令 name 为
StringValue ofBindingIdentifier 。 - 令 sourceText 为
源文本匹配 AsyncGeneratorDeclaration 。 - 令 F 为
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% , sourceText,FormalParameters ,AsyncGeneratorBody ,non-lexical-this , env, privateEnv)。 - 执行
SetFunctionName (F, name)。 - 令 prototype 为
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% )。 - 执行 !
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]: prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false })。 - 返回 F。
- 令 sourceText 为
源文本匹配 AsyncGeneratorDeclaration 。 - 令 F 为
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% , sourceText,FormalParameters ,AsyncGeneratorBody ,non-lexical-this , env, privateEnv)。 - 执行
SetFunctionName (F,"default" )。 - 令 prototype 为
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% )。 - 执行 !
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]: prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false })。 - 返回 F。
匿名的
export default 声明的一部分出现。
15.6.4 运行时语义：InstantiateAsyncGeneratorFunctionExpression
在
15.6.5 运行时语义：评估
15.7 类定义
语法
类定义总是
15.7.1 静态语义：早期错误
-
如果
ClassHeritage 不存在，并且以下算法返回true ，则这是一个语法错误：
-
如果
PrototypePropertyNameList 的ClassElementList 包含多个"constructor" ，则这是一个语法错误。 -
如果
PrivateBoundIdentifiers 的ClassElementList 包含任何重复项，除非该名称一次用于 getter，一次用于 setter，并且在其他条目中未使用，并且 getter 和 setter 要么都是静态的，要么都是非静态的，则这是一个语法错误。
-
如果
PropName 的MethodDefinition 不是"constructor" ，并且HasDirectSuper 的MethodDefinition 为true ，则这是一个语法错误。 -
如果
PropName 的MethodDefinition 是"constructor" ，并且SpecialMethod 的MethodDefinition 为true ，则这是一个语法错误。
-
如果
HasDirectSuper 的MethodDefinition 为true ，则这是一个语法错误。 -
如果
PropName 的MethodDefinition 是"prototype" ，则这是一个语法错误。
- 如果
PropName 的FieldDefinition 是"constructor" ，则这是一个语法错误。
- 如果
PropName 的FieldDefinition 是"prototype" 或"constructor" ，则这是一个语法错误。
- 如果
Initializer 存在，并且ContainsArguments 的Initializer 为true ，则这是一个语法错误。 - 如果
Initializer 存在，并且Initializer Contains 的SuperCall 为true ，则这是一个语法错误。
- 如果
StringValue 的PrivateIdentifier 是"#constructor" ，则这是一个语法错误。
- 如果
LexicallyDeclaredNames 的ClassStaticBlockStatementList 包含任何重复项，则这是一个语法错误。 - 如果
LexicallyDeclaredNames 的ClassStaticBlockStatementList 中的任何元素也出现在VarDeclaredNames 的ClassStaticBlockStatementList 中，则这是一个语法错误。 - 如果
ContainsDuplicateLabels 的ClassStaticBlockStatementList 参数 « » 为true ，则这是一个语法错误。 - 如果
ContainsUndefinedBreakTarget 的ClassStaticBlockStatementList 参数 « » 为true ，则这是一个语法错误。 - 如果
ContainsUndefinedContinueTarget 的ClassStaticBlockStatementList 参数 « » 和 « » 为true ，则这是一个语法错误。 - 如果
ContainsArguments 的ClassStaticBlockStatementList 为true ，则这是一个语法错误。 - 如果
ClassStaticBlockStatementList Contains 的SuperCall 为true ，则这是一个语法错误。 - 如果
ClassStaticBlockStatementList Contains 的await为true ，则这是一个语法错误。
15.7.2 静态语义：ClassElementKind
- 如果
PropName 的MethodDefinition 是"constructor" ，返回constructor-method 。 - 返回
non-constructor-method 。
- 返回
non-constructor-method 。
- 返回
non-constructor-method 。
- 返回
empty 。
15.7.3 静态语义：ConstructorMethod
- 如果
ClassElementKind 的ClassElement 是constructor-method ，返回ClassElement 。 - 返回
empty 。
- 让 head 为
ConstructorMethod 的ClassElementList 。 - 如果 head 不是
empty ，返回 head。 - 如果
ClassElementKind 的ClassElement 是constructor-method ，返回ClassElement 。 - 返回
empty 。
早期错误规则确保只有一个名为
15.7.4 静态语义：IsStatic
- 返回
false 。
- 返回
true 。
- 返回
false 。
- 返回
true 。
- 返回
true 。
- 返回
false 。
15.7.5 静态语义：NonConstructorElements
- 如果
ClassElementKind 属于ClassElement 且为non-constructor-method ，则- 返回«
ClassElement »。
- 返回«
- 返回一个新的空
列表 。
- 让list等于
NonConstructorElements 属于ClassElementList 。 - 如果
ClassElementKind 属于ClassElement 且为non-constructor-method ，则- 将
ClassElement 追加到list的末尾。
- 将
- 返回list。
15.7.6 静态语义：PrototypePropertyNameList
- 令 propName 等于
PropName 属于ClassElement 。 - 如果 propName
是
empty ，则返回一个新的空列表 。 - 如果
IsStatic 属于ClassElement 是true ，则返回一个新的空列表 。 - 返回 « propName »。
- 令 list 等于
PrototypePropertyNameList 属于ClassElementList 。 - 令 propName 等于
PropName 属于ClassElement 。 - 如果 propName 是
empty ，则返回 list。 - 如果
IsStatic 属于ClassElement 是true ，则返回 list。 - 返回
列表连接 list 和 « propName »。
15.7.7 静态语义：AllPrivateIdentifiersValid
本规范中未列出的每个语法生成式替代项隐含有以下默认的 AllPrivateIdentifiersValid 定义：
- 对于此
解析节点 的每个子节点child，执行以下操作：- 如果 child 是一个非终结符的实例，那么
- 如果
AllPrivateIdentifiersValid 属于 child 并带有参数 names 为false ，则返回false 。
- 如果
- 如果 child 是一个非终结符的实例，那么
- 返回
true 。
- 如果 names 包含
StringValue 属于PrivateIdentifier ，那么- 返回
AllPrivateIdentifiersValid 属于MemberExpression 并带有参数 names。
- 返回
- 返回
false 。
- 如果 names 包含
StringValue 属于PrivateIdentifier ，那么- 返回
AllPrivateIdentifiersValid 属于CallExpression 并带有参数 names。
- 返回
- 返回
false 。
- 如果 names 包含
StringValue 属于PrivateIdentifier ，返回true 。 - 返回
false 。
- 如果 names 包含
StringValue 属于PrivateIdentifier ，那么- 返回
AllPrivateIdentifiersValid 属于OptionalChain 并带有参数 names。
- 返回
- 返回
false 。
- 令 newNames 等于
列表连接 names 和PrivateBoundIdentifiers 属于ClassBody 。 - 返回
AllPrivateIdentifiersValid 属于ClassElementList 并带有参数 newNames。
- 如果 names 包含
StringValue 属于PrivateIdentifier ，那么- 返回
AllPrivateIdentifiersValid 属于ShiftExpression 并带有参数 names。
- 返回
- 返回
false 。
15.7.8 静态语义：PrivateBoundIdentifiers
- 返回一个
列表 ，其唯一元素是StringValue 属于PrivateIdentifier 。
- 返回一个新的空
列表 。
- 令 names1 为
PrivateBoundIdentifiers 属于ClassElementList 。 - 令 names2 为
PrivateBoundIdentifiers 属于ClassElement 。 - 返回 names1 和 names2 的
列表连接 。
15.7.9 静态语义：ContainsArguments
本规范中未列出的每个语法生成式替代方案隐式具有以下 ContainsArguments 的默认定义：
- 对于此
解析节点 的每个子节点child，执行以下操作- 如果child是一个非终结符实例，则
- 如果
ContainsArguments 属于child为true ，则返回true 。
- 如果
- 如果child是一个非终结符实例，则
- 返回
false 。
- 如果
StringValue 属于Identifier 为"arguments" ，则返回true 。 - 返回
false 。
- 返回
false 。
- 返回
false 。
15.7.10 运行时语义: ClassFieldDefinitionEvaluation
-
令 name 为 ?
Evaluation ClassElementName 。 -
如果
Initializer 存在，那么：-
令 formalParameterList 为
FormalParameters : [empty] -
令 env 为
运行执行上下文 的词法环境。 -
令 privateEnv 为
运行执行上下文 的私有环境。 - 令 sourceText 为 Unicode 代码点的空序列。
-
令 initializer 为
OrdinaryFunctionCreate (%Function.prototype% , sourceText, formalParameterList,Initializer ,non-lexical-this , env, privateEnv)。 -
执行
MakeMethod (initializer, homeObject)。 - 设置 initializer.[[ClassFieldInitializerName]] 为 name。
-
令 formalParameterList 为
-
否则：
-
令 initializer 为
empty 。
-
令 initializer 为
-
返回
ClassFieldDefinition Record { [[Name]]: name, [[Initializer]]: initializer }。
15.7.11 运行时语义：ClassStaticBlockDefinitionEvaluation
-
令 lex 为
运行执行上下文 的词法环境。 -
令 privateEnv 为
运行执行上下文 的私有环境。 - 令 sourceText 为 Unicode 代码点的空序列。
-
令 formalParameters 为
FormalParameters : [empty] -
令 bodyFunction 为
OrdinaryFunctionCreate (%Function.prototype% , sourceText, formalParameters,ClassStaticBlockBody ,non-lexical-this , lex, privateEnv)。 -
执行
MakeMethod (bodyFunction, homeObject)。 -
返回
ClassStaticBlockDefinition Record { [[BodyFunction]]: bodyFunction }。
15.7.12 运行时语义：EvaluateClassStaticBlockBody
-
断言 ：functionObject 是由ClassStaticBlockDefinitionEvaluation 第5 步创建的合成函数。 -
执行 !
FunctionDeclarationInstantiation (functionObject, « »)。 -
返回 ?
Evaluation ofClassStaticBlockStatementList 。
15.7.13 运行时语义：ClassElementEvaluation
- 返回 ?
ClassFieldDefinitionEvaluation 的FieldDefinition 参数为 object。
- 返回 ?
MethodDefinitionEvaluation 的MethodDefinition 参数为 object 和false 。
- 返回
ClassStaticBlockDefinitionEvaluation 的ClassStaticBlock 参数为 object。