ECMA-262, 12th edition, June 2021
ECMAScript® 2021 Language Specification
About this Specification
The document athttps://tc39.es/ecma262/ is the most accurate and up-to-date ECMAScript specification. It contains the content of the most recent yearly snapshot plus anyfinished proposals (those that have reached Stage 4 in theproposal process and thus are implemented in several implementations and will be in the next practical revision) since that snapshot was taken.
Contributing to this Specification
This specification is developed on GitHub with the help of the ECMAScript community. There are a number of ways to contribute to the development of this specification:
- 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
- Editors:
- Community:
- Discourse:https://es.discourse.group
- IRC:#tc39 onfreenode
- Mailing
List Archives:https://esdiscuss.org/
Refer to the
Introduction
This Ecma Standard defines the ECMAScript 2021 Language. It is the twelfth edition of the ECMAScript Language Specification. Since publication of the first edition in 1997, ECMAScript has grown to be one of the world's most widely used general-purpose programming languages. It is best known as the language embedded in web browsers but has also been widely adopted for server and embedded applications.
ECMAScript is based on several originating technologies, the most well-known being JavaScript (Netscape) and JScript (Microsoft). The language was invented by Brendan Eich at Netscape and first appeared in that company's Navigator 2.0 browser. It has appeared in all subsequent browsers from Netscape and in all browsers from Microsoft starting with Internet Explorer 3.0.
The development of the ECMAScript Language Specification started in November 1996. The first edition of this Ecma Standard was adopted by the Ecma General Assembly of June 1997.
That Ecma Standard was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262, in April 1998. The Ecma General Assembly of June 1998 approved the second edition of ECMA-262 to keep it fully aligned with ISO/IEC 16262. Changes between the first and the second edition are editorial in nature.
The third edition of the Standard introduced powerful regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and minor changes in anticipation of future language growth. The third edition of the ECMAScript standard was adopted by the Ecma General Assembly of December 1999 and published as ISO/IEC 16262:2002 in June 2002.
After publication of the third edition, ECMAScript achieved massive adoption in conjunction with the World Wide Web where it has become the programming language that is supported by essentially all web browsers. Significant work was done to develop a fourth edition of ECMAScript. However, that work was not completed and not published as the fourth edition of ECMAScript but some of it was incorporated into the development of the sixth edition.
The fifth edition of ECMAScript (published as ECMA-262 5th edition) codified de facto interpretations of the language specification that have become common among browser implementations and added support for new features that had emerged since the publication of the third edition. Such features include accessor properties, reflective creation and inspection of objects, program control of property attributes, additional array manipulation functions, support for the JSON object encoding format, and a strict mode that provides enhanced error checking and program security. The fifth edition was adopted by the Ecma General Assembly of December 2009.
The fifth edition was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as international standard ISO/IEC 16262:2011. Edition 5.1 of the ECMAScript Standard incorporated minor corrections and is the same text as ISO/IEC 16262:2011. The 5.1 Edition was adopted by the Ecma General Assembly of June 2011.
Focused development of the sixth edition started in 2009, as the fifth edition was being prepared for publication. However, this was preceded by significant experimentation and language enhancement design efforts dating to the publication of the third edition in 1999. In a very real sense, the completion of the sixth edition is the culmination of a fifteen year effort. The goals for this edition included providing better support for large applications, library creation, and for use of ECMAScript as a compilation target for other languages. Some of its major enhancements included modules, class declarations, lexical block scoping, iterators and generators, promises for asynchronous programming, destructuring patterns, and proper tail calls. The ECMAScript library of built-ins was expanded to support additional data abstractions including maps, sets, and arrays of binary numeric values as well as additional support for Unicode supplemental characters in strings and regular expressions. The built-ins were also made extensible via subclassing. The sixth edition provides the foundation for regular, incremental language and library enhancements. The sixth edition was adopted by the General Assembly of June 2015.
ECMAScript 2016 was the first ECMAScript edition released under Ecma TC39's new yearly release cadence and open development process. A plain-text source document was built from the ECMAScript 2015 source document to serve as the base for further development entirely on GitHub. Over the year of this standard's development, hundreds of pull requests and issues were filed representing thousands of bug fixes, editorial fixes and other improvements. Additionally, numerous software tools were developed to aid in this effort including Ecmarkup, Ecmarkdown, and Grammarkdown. ES2016 also included support for a new exponentiation operator and adds a new method toArray.prototype calledincludes.
ECMAScript 2017 introduced Async Functions, Shared Memory, and Atomics along with smaller language and library enhancements, bug fixes, and editorial updates. Async functions improve the asynchronous programming experience by providing syntax for promise-returning functions. Shared Memory and Atomics introduce a newObject.values,Object.entries, andObject.getOwnPropertyDescriptors.
ECMAScript 2018 introduced support for asynchronous iteration via the AsyncIterator protocol and async generators. It also included four new regular expression features: thedotAll flag, named capture groups, Unicode property escapes, and look-behind assertions. Lastly it included object rest and spread properties.
ECMAScript 2019 introduced a few new built-in functions:flat andflatMap onArray.prototype for flattening arrays,Object.fromEntries for directly turning the return value ofObject.entries into a new Object, andtrimStart andtrimEnd onString.prototype as better-named alternatives to the widely implemented but non-standardString.prototype.trimLeft andtrimRight built-ins. In addition, it included a few minor updates to syntax and semantics. Updated syntax included optional catch binding parameters and allowing U+2028 (LINE SEPARATOR) and U+2029 (PARAGRAPH SEPARATOR) in string literals to align with JSON. Other updates included requiring thatArray.prototype.sort be a stable sort, requiring thatJSON.stringify return well-formed UTF-8 regardless of input, and clarifyingFunction.prototype.toString by requiring that it either return the corresponding original source text or a standard placeholder.
ECMAScript 2020, the 11th edition, introduces thematchAll method for Strings, to produce an iterator for all match objects generated by a global regular expression;import(), a syntax to asynchronously import Modules with a dynamic specifier;BigInt, a new number primitive for working with arbitrary precision integers;Promise.allSettled, a new Promise combinator that does not short-circuit;globalThis, a universal way to access the globalthis value; dedicatedexport * as ns from 'module' syntax for use within modules; increased standardization offor-in enumeration order;import.meta, anull orundefined): nullish coalescing, a value selection operator; and optional chaining, a property access and function invocation operator that short-circuits if the value to access/invoke is nullish.
This specification, the 12th edition, introduces thereplaceAll method for Strings;Promise.any, a Promise combinator that short-circuits when an input value is fulfilled;AggregateError, a new Error type to represent multiple errors at once; logical assignment operators (??=,&&=,||=);WeakRef, for referring to a target object without preserving it from garbage collection, andFinalizationRegistry, to manage registration and unregistration of cleanup operations performed when target objects are garbage collected; separators for numeric literals (1_000); andArray.prototype.sort was made more precise, reducing the amount of cases that result in an
Dozens of individuals representing many organizations have made very significant contributions within Ecma TC39 to the development of this edition and to the prior editions. In addition, a vibrant community has emerged supporting TC39's ECMAScript efforts. This community has reviewed numerous drafts, filed thousands of bug reports, performed implementation experiments, contributed test suites, and educated the world-wide developer community about ECMAScript. Unfortunately, it is impossible to identify and acknowledge every person and organization who has contributed to this effort.
Allen Wirfs-Brock
ECMA-262, Project Editor, 6th Edition
Brian Terlson
ECMA-262, Project Editor, 7th through 10th Editions
Jordan Harband
ECMA-262, Project Editor, 10th through 12th Editions
1 Scope
This Standard defines the ECMAScript 2021 general-purpose programming language.
2 Conformance
A conforming implementation of ECMAScript must provide and support all the types, values, objects, properties, functions, and program syntax and semantics described in this specification.
A conforming implementation of ECMAScript must interpret source text input in conformance with the latest version of the Unicode Standard and ISO/IEC 10646.
A conforming implementation of ECMAScript that provides an application programming interface (API) that supports programs that need to adapt to the linguistic and cultural conventions used by different human languages and countries must implement the interface defined by the most recent edition of ECMA-402 that is compatible with this specification.
A conforming implementation of ECMAScript may provide additional types, values, objects, properties, and functions beyond those described in this specification. In particular, a conforming implementation of ECMAScript may provide properties not described in this specification, and values for those properties, for objects that are described in this specification.
A conforming implementation of ECMAScript may support program and regular expression syntax not described in this specification. In particular, a conforming implementation of ECMAScript may support program syntax that makes use of any “future reserved words” noted in subclause
A conforming implementation of ECMAScript must not implement any extension that is listed as a Forbidden Extension in subclause
A conforming implementation of ECMAScript must not redefine any facilities that are not
A conforming implementation of ECMAScript may choose to implement or not implementNormative Optional subclauses. If any Normative Optional behaviour is implemented, all of the behaviour in the containing Normative Optional clause must be implemented. A Normative Optional clause is denoted in this specification with the words "Normative Optional" in a coloured box, as shown below.
2.1 Example Clause Heading
Example clause contents.
3 Normative References
The following referenced documents are indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.
ISO/IEC 10646Information Technology — Universal Multiple-Octet Coded Character Set (UCS) plus Amendment 1:2005, Amendment 2:2006, Amendment 3:2008, and Amendment 4:2008, plus additional amendments and corrigenda, or successor
ECMA-402,ECMAScript 2015 Internationalization API Specification.
https://www.ecma-international.org/publications-and-standards/standards/ecma-402/
ECMA-404,The JSON Data Interchange Format.
https://www.ecma-international.org/publications-and-standards/standards/ecma-404/
4 Overview
This section contains a non-normative overview of the ECMAScript language.
ECMAScript is an object-oriented programming language for performing computations and manipulating computational objects within a
ECMAScript was originally designed to be used as a scripting language, but has become widely used as a general-purpose programming language. Ascripting language is a programming language that is used to manipulate, customize, and automate the facilities of an existing system. In such systems, useful functionality is already available through a user interface, and the scripting language is a mechanism for exposing that functionality to program control. In this way, the existing system is said to provide a
ECMAScript was originally designed to be aWeb scripting language, providing a mechanism to enliven Web pages in browsers and to perform server computation as part of a Web-based client-server architecture. ECMAScript is now used to provide core scripting capabilities for a variety of
ECMAScript usage has moved beyond simple scripting and it is now used for the full spectrum of programming tasks in many different environments and scales. As the usage of ECMAScript has expanded, so have the features and facilities it provides. ECMAScript is now a fully featured general-purpose programming language.
4.1 Web Scripting
A web browser provides an ECMAScript
A web server provides a different
Each Web browser and server that supports ECMAScript supplies its own
4.2 Hosts and Implementations
To aid integrating ECMAScript into
Animplementation is an external source that further defines facilities enumerated in Annex
Animplementation-defined facility is one that defers its definition to an external source without further qualification. This specification does not make any recommendations for particular behaviours, and conforming implementations are free to choose any behaviour within the constraints put forth by this specification.
Animplementation-approximated facility is one that defers its definition to an external source while recommending an ideal behaviour. While conforming implementations are free to choose any behaviour within the constraints put forth by this specification, they are encouraged to strive to approximate the ideal. Some mathematical operations, such asMath.exp
Ahost is an external source that further defines facilities listed in Annex
Ahost hook is an abstract operation that is defined in whole or in part by an external source. All
Ahost-defined facility is one that defers its definition to an external source without further qualification and is listed in Annex
Ahost environment is a particular choice of definition for all
This specification follows the editorial convention of always using the most specific term. For example, if a facility is
Both hosts and implementations may interface with this specification via the language types, specification types,
4.3 ECMAScript Overview
The following is an informal overview of ECMAScript—not all parts of the language are described. This overview is not part of the standard proper.
ECMAScript is object-based: basic language and
ECMAScript defines a collection ofbuilt-in objects that round out the definition of ECMAScript entities. These built-in objects include theObject,Function,Boolean,Symbol, and variousError objects; objects that represent and manipulate numeric values includingMath,Number, andDate; the text processing objectsString andRegExp; objects that are indexed collections of values includingArray and nine different kinds of Typed Arrays whose elements all have a specific numeric data representation; keyed collections includingMap andSet objects; objects supporting structured data including theJSON object,ArrayBuffer,SharedArrayBuffer, andDataView; objects supporting control abstractions including generator functions andPromise objects; and reflection objects includingProxy andReflect.
ECMAScript also defines a set of built-inoperators. ECMAScript operators include various unary operations, multiplicative operators, additive operators, bitwise shift operators, relational operators, equality operators, binary bitwise operators, binary logical operators, assignment operators, and the comma operator.
Large ECMAScript programs are supported bymodules which allow a program to be divided into multiple sequences of statements and declarations. Each module explicitly identifies declarations it uses that need to be provided by other modules and which of its declarations are available for use by other modules.
ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to serve as an easy-to-use scripting language. For example, a variable is not required to have its type declared nor are types associated with properties, and defined functions are not required to have their declarations appear textually before calls to them.
4.3.1 Objects
Even though ECMAScript includes syntax for class definitions, ECMAScript objects are not fundamentally class-based such as those in C++, Smalltalk, or Java. Instead objects may be created in various ways including via a literal notation or viaconstructors which create objects and then execute code that initializes all or part of them by assigning initial values to their properties. Eachnew Date(2009, 11) creates a new Date object. Invoking aDate() produces a string representation of the current date and time rather than an object.
Every object created by a
In a class-based object-oriented language, in general, state is carried by instances, methods are carried by classes, and inheritance is only of structure and behaviour. In ECMAScript, the state and methods are carried by objects, while structure, behaviour, and state are all inherited.
All objects that do not directly contain a particular property that their prototype contains share that property and its value. Figure 1 illustrates this:
CF is anew expressions:cf1,cf2,cf3,cf4, andcf5. Each of these objects contains properties named
Unlike most class-based object languages, properties can be added to objects dynamically by assigning values to them. That is, constructors are not required to name or assign values to all or any of the constructed object's properties. In the above diagram, one could add a new shared property forcf1,cf2,cf3,cf4, andcf5 by assigning a new value to the property inCFp.
Although ECMAScript objects are not inherently class-based, it is often convenient to define class-like abstractions based upon a common pattern of
4.3.2 The Strict Variant of ECMAScript
The ECMAScript Language recognizes the possibility that some users of the language may wish to restrict their usage of some features available in the language. They might do so in the interests of security, to avoid what they consider to be error-prone features, to get enhanced error checking, or for other reasons of their choosing. In support of this possibility, ECMAScript defines a strict variant of the language. The strict variant of the language excludes some specific syntactic and semantic features of the regular ECMAScript language and modifies the detailed semantics of some features. The strict variant also specifies additional error conditions that must be reported by throwing error exceptions in situations that are not specified as errors by the non-strict form of the language.
The strict variant of ECMAScript is commonly referred to as thestrict mode of the language. Strict mode selection and use of the strict mode syntax and semantics of ECMAScript is explicitly made at the level of individual ECMAScript source text units as described in
In order to conform to this specification, an ECMAScript implementation must implement both the full unrestricted ECMAScript language and the strict variant of the ECMAScript language as defined by this specification. In addition, an implementation must support the combination of unrestricted and strict mode source text units into a single composite program.
4.4 Terms and Definitions
For the purposes of this document, the following terms and definitions apply.
4.4.1 implementation-approximated
an
4.4.2 implementation-defined
an
4.4.3 host-defined
same as
Editorially, see clause
4.4.4 type
set of data values as defined in clause
4.4.5 primitive value
member of one of the types Undefined, Null, Boolean, Number, BigInt, Symbol, or String as defined in clause
A primitive value is a datum that is represented directly at the lowest level of the language implementation.
4.4.6 object
member of the type Object
An object is a collection of properties and has a single prototype object. The prototype may be the null value.
4.4.7 constructor
The value of a
4.4.8 prototype
object that provides shared properties for other objects
When aconstructor.prototype, and properties added to an object's prototype are shared, through inheritance, by all objects sharing the prototype. Alternatively, a new object may be created with an explicitly specified prototype by using theObject.create built-in function.
4.4.9 ordinary object
object that has the default behaviour for the essential internal methods that must be supported by all objects
4.4.10 exotic object
object that does not have the default behaviour for one or more of the essential internal methods
Any object that is not an
4.4.11 standard object
object whose semantics are defined by this specification
4.4.12 built-in object
object specified and supplied by an ECMAScript implementation
Standard built-in objects are defined in this specification. An ECMAScript implementation may specify and supply additional kinds of built-in objects. Abuilt-in
4.4.13 undefined value
primitive value used when a variable has not been assigned a value
4.4.14 Undefined type
type whose sole value is the
4.4.15 null value
primitive value that represents the intentional absence of any object value
4.4.16 Null type
type whose sole value is the
4.4.17 Boolean value
member of the Boolean type
There are only two Boolean values,
4.4.18 Boolean type
type consisting of the primitive values
4.4.19 Boolean object
member of the Object type that is an instance of the standard built-in Boolean
A Boolean object is created by using the Booleannew expression, supplying a Boolean value as an argument. The resulting object has an internal slot whose value is the Boolean value. A Boolean object can be coerced to a Boolean value.
4.4.20 String value
primitive value that is a finite ordered sequence of zero or more 16-bit unsigned
A String value is a member of the String type. Each
4.4.21 String type
set of all possible String values
4.4.22 String object
member of the Object type that is an instance of the standard built-in String
A String object is created by using the Stringnew expression, supplying a String value as an argument. The resulting object has an internal slot whose value is the String value. A String object can be coerced to a String value by calling the String
4.4.23 Number value
primitive value corresponding to a double-precision 64-bit binary format
A
4.4.24 Number type
set of all possible Number values including the special “Not-a-Number” (NaN) value, positive infinity, and negative infinity
4.4.25 Number object
member of the Object type that is an instance of the standard built-in Number
A Number object is created by using the Numbernew expression, supplying a
4.4.26 Infinity
4.4.27 NaN
4.4.28 BigInt value
primitive value corresponding to an arbitrary-precision
4.4.29 BigInt type
set of all possible BigInt values
4.4.30 BigInt object
member of the Object type that is an instance of the standard built-in BigInt
4.4.31 Symbol value
primitive value that represents a unique, non-String Object property key
4.4.32 Symbol type
set of all possible Symbol values
4.4.33 Symbol object
member of the Object type that is an instance of the standard built-in Symbol
4.4.34 function
member of the Object type that may be invoked as a subroutine
In addition to its properties, a function contains executable code and state that determine how it behaves when invoked. A function's code may or may not be written in ECMAScript.
4.4.35 built-in function
built-in object that is a function
Examples of built-in functions includeparseInt andMath.exp. A
4.4.36 property
part of an object that associates a key (either a String value or a Symbol value) and a value
Depending upon the form of the property the value may be represented either directly as a data value (a primitive value, an object, or a
4.4.37 method
function that is the value of a property
When a function is called as a method of an object, the object is passed to the function as its
4.4.38 built-in method
method that is a built-in function
Standard built-in methods are defined in this specification. A
4.4.39 attribute
internal value that defines some characteristic of a property
4.4.40 own property
property that is directly contained by its object
4.4.41 inherited property
property of an object that is not an own property but is a property (either own or inherited) of the object's prototype
4.5 Organization of This Specification
The remainder of this specification is organized as follows:
Clause
Clauses
Clauses
Clauses
Clause
5 Notational Conventions
5.1 Syntactic and Lexical Grammars
5.1.1 Context-Free Grammars
Acontext-free grammar consists of a number ofproductions. Each production has an abstract symbol called anonterminal as itsleft-hand side, and a sequence of zero or more nonterminal andterminal symbols as itsright-hand side. For each grammar, the terminal symbols are drawn from a specified alphabet.
Achain production is a production that has exactly one nonterminal symbol on its right-hand side along with zero or more terminal symbols.
Starting from a sentence consisting of a single distinguished nonterminal, called thegoal symbol, a given context-free grammar specifies alanguage, namely, the (perhaps infinite) set of possible sequences of terminal symbols that can result from repeatedly replacing any nonterminal in the sequence with a right-hand side of a production for which the nonterminal is the left-hand side.
5.1.2 The Lexical and RegExp Grammars
Alexical grammar for ECMAScript is given in clause
Input elements other than white space and comments form the terminal symbols for the syntactic grammar for ECMAScript and are called ECMAScripttokens. These tokens are the reserved words, identifiers, literals, and punctuators of the ECMAScript language. Moreover, line terminators, although not considered to be tokens, also become part of the stream of input elements and guide the process of automatic semicolon insertion (/*…*/ regardless of whether it spans more than one line) is likewise simply discarded if it contains no line terminator; but if a
ARegExp grammar for ECMAScript is given in
Productions of the lexical and RegExp grammars are distinguished by having two colons “::” as separating punctuation. The lexical and RegExp grammars share some productions.
5.1.3 The Numeric String Grammar
Another grammar is used for translating Strings into numeric values. This grammar is similar to the part of the lexical grammar having to do with numeric literals and has as its terminal symbols
Productions of the numeric string grammar are distinguished by having three colons “:::” as punctuation.
5.1.4 The Syntactic Grammar
Thesyntactic grammar for ECMAScript is given in clauses
When a stream of code points is to be parsed as an ECMAScript
When a parse is successful, it constructs aparse tree, a rooted tree structure in which each node is aParse Node. Each Parse Node is aninstance of a symbol in the grammar; it represents a span of the source text that can be derived from that symbol. The root node of the parse tree, representing the whole of the source text, is an instance of the parse's
New Parse Nodes are instantiated for each invocation of the parser and never reused between parses even of identical source text. Parse Nodes are consideredthe same Parse Node if and only if they represent the same span of source text, are instances of the same grammar symbol, and resulted from the same parser invocation.
Parsing the same String multiple times will lead to different Parse Nodes. For example, consider:
let str ="1 + 1;";eval(str);eval(str);Each call toeval converts the value ofstr into an ECMAScript source text and performs an independent parse that creates its own separate tree of Parse Nodes. The trees are distinct even though each parse operates upon a source text that was derived from the same String value.
Productions of the syntactic grammar are distinguished by having just one colon “:” as punctuation.
The syntactic grammar as presented in clauses
In certain cases, in order to avoid ambiguities, the syntactic grammar uses generalized productions that permit token sequences that do not form a valid ECMAScript
5.1.5 Grammar Notation
Terminal symbols are shown infixed width font, both in the productions of the grammars and throughout this specification whenever the text directly refers to such a terminal symbol. These are to appear in a script exactly as written. All terminal symbol code points specified in this way are to be understood as the appropriate Unicode code points from the Basic Latin range, as opposed to any similar-looking code points from other Unicode ranges. A code point in a terminal symbol cannot be expressed by a\
Nonterminal symbols are shown initalic type. The definition of a nonterminal (also called a “production”) is introduced by the name of the nonterminal being defined followed by one or more colons. (The number of colons indicates to which grammar the production belongs.) One or more alternative right-hand sides for the nonterminal then follow on succeeding lines. For example, the syntactic definition:
states that the nonterminalwhile, followed by a left parenthesis token, followed by an
states that an
The subscripted suffix “opt”, which may appear after a terminal or nonterminal, indicates an optional symbol. The alternative containing the optional symbol actually specifies two right-hand sides, one that omits the optional element and one that includes it. This means that:
is a convenient abbreviation for:
and that:
is a convenient abbreviation for:
which in turn is an abbreviation for:
so, in this example, the nonterminal
A production may be parameterized by a subscripted annotation of the form “[parameters]”, which may appear as a suffix to the nonterminal symbol defined by the production. “parameters” may be either a single name or a comma separated list of names. A parameterized production is shorthand for a set of productions defining all combinations of the parameter names, preceded by an underscore, appended to the parameterized nonterminal symbol. This means that:
is a convenient abbreviation for:
and that:
is an abbreviation for:
Multiple parameters produce a combinatory number of productions, not all of which are necessarily referenced in a complete grammar.
References to nonterminals on the right-hand side of a production can also be parameterized. For example:
is equivalent to saying:
and:
is equivalent to:
A nonterminal reference may have both a parameter list and an “opt” suffix. For example:
is an abbreviation for:
Prefixing a parameter name with “?” on a right-hand side nonterminal reference makes that parameter value dependent upon the occurrence of the parameter name on the reference to the current production's left-hand side symbol. For example:
is an abbreviation for:
If a right-hand side alternative is prefixed with “[+parameter]” that alternative is only available if the named parameter was used in referencing the production's nonterminal symbol. If a right-hand side alternative is prefixed with “[~parameter]” that alternative is only available if the named parameter wasnot used in referencing the production's nonterminal symbol. This means that:
is an abbreviation for:
and that:
is an abbreviation for:
When the words “one of” follow the colon(s) in a grammar definition, they signify that each of the terminal symbols on the following line or lines is an alternative definition. For example, the lexical grammar for ECMAScript contains the production:
which is merely a convenient abbreviation for:
If the phrase “[empty]” appears as the right-hand side of a production, it indicates that the production's right-hand side contains no terminals or nonterminals.
If the phrase “[lookahead =seq]” appears in the right-hand side of a production, it indicates that the production may only be used if the token sequenceseq is a prefix of the immediately following input token sequence. Similarly, “[lookahead ∈set]”, whereset is a finite nonempty set of token sequences, indicates that the production may only be used if some element ofset is a prefix of the immediately following token sequence. For convenience, the set can also be written as a nonterminal, in which case it represents the set of all token sequences to which that nonterminal could expand. It is considered an editorial error if the nonterminal could expand to infinitely many distinct token sequences.
These conditions may be negated. “[lookahead ≠seq]” indicates that the containing production may only be used ifseq isnot a prefix of the immediately following input token sequence, and “[lookahead ∉set]” indicates that the production may only be used ifno element ofset is a prefix of the immediately following token sequence.
As an example, given the definitions:
the definition:
matches either the lettern followed by one or more decimal digits the first of which is even, or a decimal digit not followed by another decimal digit.
Note that when these phrases are used in the syntactic grammar, it may not be possible to unambiguously identify the immediately following token sequence because determining later tokens requires knowing which lexical
If the phrase “[no
indicates that the production may not be used if athrow token and the
Unless the presence of a
When an alternative in a production of the lexical grammar or the numeric string grammar appears to be a multi-code point token, it represents the sequence of code points that would make up such a token.
The right-hand side of a production may specify that certain expansions are not permitted by using the phrase “but not” and then indicating the expansions to be excluded. For example, the production:
means that the nonterminal
Finally, a few nonterminal symbols are described by a descriptive phrase in sans-serif type in cases where it would be impractical to list all the alternatives:
5.2 Algorithm Conventions
The specification often uses a numbered list to specify steps in an algorithm. These algorithms are used to precisely specify the required semantics of ECMAScript language constructs. The algorithms are not intended to imply the use of any specific implementation technique. In practice, there may be more efficient algorithms available to implement a given feature.
Algorithms may be explicitly parameterized with an ordered, comma-separated sequence of alias names which may be used within the algorithm steps to reference the argument passed in that position. Optional parameters are denoted with surrounding brackets ([ ,name ]) and are no different from required parameters within algorithm steps. A rest parameter may appear at the end of a parameter list, denoted with leading ellipsis (, ...name). The rest parameter captures all of the arguments provided following the required and optional parameters into a
Algorithm steps may be subdivided into sequential substeps. Substeps are indented and may themselves be further divided into indented substeps. Outline numbering conventions are used to identify substeps with the first level of substeps labelled with lower case alphabetic characters and the second level of substeps labelled with lower case roman numerals. If more than three levels are required these rules repeat with the fourth level using numeric labels. For example:
- Top-level step
- Substep.
- Substep.
- Subsubstep.
- Subsubsubstep
- Subsubsubsubstep
- Subsubsubsubsubstep
- Subsubsubsubstep
- Subsubsubstep
- Subsubstep.
A step or substep may be written as an “if” predicate that conditions its substeps. In this case, the substeps are only applied if the predicate is true. If a step or substep begins with the word “else”, it is a predicate that is the negation of the preceding “if” predicate step at the same level.
A step may specify the iterative application of its substeps.
A step that begins with “Assert:” asserts an invariant condition of its algorithm. Such assertions are used to make explicit algorithmic invariants that would otherwise be implicit. Such assertions add no additional semantic requirements and hence need not be checked by an implementation. They are used simply to clarify algorithms.
Algorithm steps may declare named aliases for any value using the form “Letx besomeValue”. These aliases are reference-like in that bothx andsomeValue refer to the same underlying data and modifications to either are visible to both. Algorithm steps that want to avoid this reference-like behaviour should explicitly make a copy of the right-hand side: “Letx be a copy ofsomeValue” creates a shallow copy ofsomeValue.
Once declared, an alias may be referenced in any subsequent steps and must not be referenced from steps prior to the alias's declaration. Aliases may be modified using the form “Setx tosomeOtherValue”.
5.2.1 Abstract Operations
In order to facilitate their use in multiple parts of this specification, some algorithms, calledabstract operations, are named and written in parameterized functional form so that they may be referenced by name from within other algorithms. Abstract operations are typically referenced using a functional application style such as OperationName(arg1,arg2). Some abstract operations are treated as polymorphically dispatched methods of class-like specification abstractions. Such method-like abstract operations are typically referenced using a method application style such assomeValue.OperationName(arg1,arg2).
5.2.2 Syntax-Directed Operations
Asyntax-directed operation is a named operation whose definition consists of algorithms, each of which is associated with one or more productions from one of the ECMAScript grammars. A production that has multiple alternative definitions will typically have a distinct algorithm for each alternative. When an algorithm is associated with a grammar production, it may reference the terminal and nonterminal symbols of the production alternative as if they were parameters of the algorithm. When used in this manner, nonterminal symbols refer to the actual alternative definition that is matched when parsing the source text. Thesource text matched by a grammar production is the portion of the source text that starts at the beginning of the first terminal that participated in the match and ends at the end of the last terminal that participated in the match.
When an algorithm is associated with a production alternative, the alternative is typically shown without any “[ ]” grammar annotations. Such annotations should only affect the syntactic recognition of the alternative and have no effect on the associated semantics for the alternative.
Syntax-directed operations are invoked with a parse node and, optionally, other parameters by using the conventions on steps
- Letstatus be SyntaxDirectedOperation of
SomeNonTerminal . - LetsomeParseNode be the parse of some source text.
- Perform SyntaxDirectedOperation ofsomeParseNode.
- Perform SyntaxDirectedOperation ofsomeParseNode passing
"value" as the argument.
Unless explicitly specified otherwise, all chain productions have an implicit definition for every operation that might be applied to that production's left-hand side nonterminal. The implicit definition simply reapplies the same operation with the same parameters, if any, to the
but the Evaluation operation does not associate an algorithm with that production. In that case, the Evaluation operation implicitly includes an association of the form:
Runtime Semantics: Evaluation
- Return the result of evaluating
StatementList .
5.2.3 Runtime Semantics
Algorithms which specify semantics that must be called at runtime are calledruntime semantics. Runtime semantics are defined by
5.2.3.1 Implicit Completion Values
The algorithms of this specification often implicitly return
- Return
"Infinity" .
means the same thing as:
- Return
NormalCompletion ("Infinity" ).
However, if the value expression of a “return” statement is a
The abstract operation
Assert :completionRecord is aCompletion Record .- ReturncompletionRecord as the
Completion Record of this abstract operation.
A “return” statement without a value in an algorithm step means the same thing as:
- Return
NormalCompletion (undefined ).
Any reference to a
5.2.3.2 Throw an Exception
Algorithms steps that say to throw an exception, such as
- Throw a
TypeError exception.
mean the same things as:
- Return
ThrowCompletion (a newly createdTypeError object).
5.2.3.3 ReturnIfAbrupt
Algorithms steps that say or are otherwise equivalent to:
ReturnIfAbrupt (argument).
mean the same thing as:
- Ifargument is an
abrupt completion , returnargument. - Else ifargument is a
Completion Record , setargument toargument.[[Value]].
Algorithms steps that say or are otherwise equivalent to:
ReturnIfAbrupt (AbstractOperation()).
mean the same thing as:
- LethygienicTemp be AbstractOperation().
- IfhygienicTemp is an
abrupt completion , returnhygienicTemp. - Else ifhygienicTemp is a
Completion Record , sethygienicTemp tohygienicTemp.[[Value]].
WherehygienicTemp is ephemeral and visible only in the steps pertaining to ReturnIfAbrupt.
Algorithms steps that say or are otherwise equivalent to:
- Letresult be AbstractOperation(
ReturnIfAbrupt (argument)).
mean the same thing as:
- Ifargument is an
abrupt completion , returnargument. - Ifargument is a
Completion Record , setargument toargument.[[Value]]. - Letresult be AbstractOperation(argument).
5.2.3.4 ReturnIfAbrupt Shorthands
Invocations of? indicate that
- ? OperationName().
is equivalent to the following step:
ReturnIfAbrupt (OperationName()).
Similarly, for method application style, the step:
- ?someValue.OperationName().
is equivalent to:
ReturnIfAbrupt (someValue.OperationName()).
Similarly, prefix! is used to indicate that the following invocation of an abstract or
- Letval be ! OperationName().
is equivalent to the following steps:
- Letval be OperationName().
Assert :val is never anabrupt completion .- Ifval is a
Completion Record , setval toval.[[Value]].
Syntax-directed operations for! or? before the invocation of the operation:
- Perform ! SyntaxDirectedOperation of
NonTerminal .
5.2.4 Static Semantics
Context-free grammars are not sufficiently powerful to express all the rules that define whether a stream of input elements form a valid ECMAScript
Static Semantic Rules have names and typically are defined using an algorithm. Named Static Semantic Rules are associated with grammar productions and a production that has multiple alternative definitions will typically have for each alternative a distinct algorithm for each applicable named static semantic rule.
A special kind of static semantic rule is anEarly Error Rule.
5.2.5 Mathematical Operations
This specification makes reference to these kinds of numeric values:
- Mathematical values: Arbitrary real numbers, used as the default numeric type.
- Extended mathematical values: Mathematical values together with +∞ and -∞.
- Numbers:
IEEE 754-2019 double-precision floating point values. - BigInts: ECMAScript values representing arbitrary integers in a one-to-one correspondence.
In the language of this specification, numerical values are distinguished among different numeric kinds using subscript suffixes. The subscript𝔽 refers to Numbers, and the subscriptℤ refers to BigInts. Numeric values without a subscript suffix refer to mathematical values.
Numeric operators such as +, ×, =, and ≥ refer to those operations as determined by the type of the operands. When applied to mathematical values, the operators refer to the usual mathematical operations. When applied to Numbers, the operators refer to the relevant operations within
In general, when this specification refers to a numerical value, such as in the phrase, "the length ofy" or "the
Numeric operators applied to mixed-type operands (such as a Number and a
This specification denotes most numeric values in base 10; it also uses numeric values of the form 0x followed by digits 0-9 or A-F as base-16 values.
When the terminteger is used in this specification, it refers to a
Conversions between mathematical values and Numbers or BigInts are always explicit in this document. A conversion from a
The mathematical function
The mathematical function
The notation “
The phrase "the result ofclampingx betweenlower andupper" (wherex is an
The mathematical function
Mathematical functions min, max,
5.2.6 Value Notation
In this specification, ECMAScript language values are displayed inFunction.prototype.apply orlet n = 42;.
Values which are internal to the specification and not directly observable from ECMAScript code are indicated with a
6 ECMAScript Data Types and Values
Algorithms within this specification manipulate values each of which has an associated type. The possible value types are exactly those defined in this clause. Types are further subclassified into ECMAScript language types and specification types.
Within this specification, the notation “Type(x)” is used as shorthand for “thetype ofx” where “type” refers to the ECMAScript language and specification types defined in this clause. When the term “empty” is used as if it was naming a value, it is equivalent to saying “no value of any type”.
6.1 ECMAScript Language Types
AnECMAScript language type corresponds to values that are directly manipulated by an ECMAScript programmer using the ECMAScript language. The ECMAScript language types are Undefined, Null, Boolean, String, Symbol, Number, BigInt, and Object. AnECMAScript language value is a value that is characterized by an ECMAScript language type.
6.1.1 The Undefined Type
The Undefined type has exactly one value, called
6.1.2 The Null Type
The Null type has exactly one value, called
6.1.3 The Boolean Type
The Boolean type represents a logical entity having two values, called
6.1.4 The String Type
The String type is the set of all ordered sequences of zero or more 16-bit unsigned
ECMAScript operations that do not interpret String contents apply no further semantics. Operations that do interpret String values treat each element as a single UTF-16 code unit. However, ECMAScript does not restrict the value of or relationships between these code units, so operations that further interpret String contents as sequences of Unicode code points encoded in UTF-16 must account for ill-formed subsequences. Such operations apply special treatment to every code unit with a numeric value in the inclusive range 0xD800 to 0xDBFF (defined by the Unicode Standard as aleading surrogate, or more formally as ahigh-surrogate code unit) and every code unit with a numeric value in the inclusive range 0xDC00 to 0xDFFF (defined as atrailing surrogate, or more formally as alow-surrogate code unit) using the following rules:
- A code unit that is not a
leading surrogate and not atrailing surrogate is interpreted as a code point with the same value. - A sequence of two code units, where the first code unitc1 is a
leading surrogate and the second code unitc2 atrailing surrogate , is asurrogate pair and is interpreted as a code point with the value (c1 - 0xD800) × 0x400 + (c2 - 0xDC00) + 0x10000. (See11.1.3 ) - A code unit that is a
leading surrogate ortrailing surrogate , but is not part of asurrogate pair , is interpreted as a code point with the same value.
The functionString.prototype.normalize (seeString.prototype.localeCompare (see
The rationale behind this design was to keep the implementation of Strings as simple and high-performing as possible. If ECMAScript source text is in Normalized Form C, string literals are guaranteed to also be normalized, as long as they do not contain any Unicode escape sequences.
In this specification, the phrase "thestring-concatenation ofA,B, ..." (where each argument is a String value, a code unit, or a sequence of code units) denotes the String value whose sequence of code units is the concatenation of the code units (in order) of each of the arguments (in order).
The phrase "thesubstring ofS frominclusiveStart toexclusiveEnd" (whereS is a String value or a sequence of code units andinclusiveStart andexclusiveEnd are integers) denotes the String value consisting of the consecutive code units ofS beginning at indexinclusiveStart and ending immediately before indexexclusiveEnd (which is the empty String wheninclusiveStart =exclusiveEnd). If the "to" suffix is omitted, the length ofS is used as the value ofexclusiveEnd.
6.1.4.1 StringIndexOf (string,searchValue,fromIndex )
The abstract operation StringIndexOf takes argumentsstring (a String),searchValue (a String), andfromIndex (a non-negative
Assert :Type (string) is String.Assert :Type (searchValue) is String.Assert :fromIndex is a non-negativeinteger .- Letlen be the length ofstring.
- IfsearchValue is the empty String andfromIndex ≤len, returnfromIndex.
- LetsearchLen be the length ofsearchValue.
- For each
integer i starting withfromIndex such thati ≤len -searchLen, in ascending order, do- Letcandidate be the
substring ofstring fromi toi +searchLen. - Ifcandidate is the same sequence of code units assearchValue, returni.
- Letcandidate be the
- Return -1.
IfsearchValue is the empty String andfromIndex is less than or equal to the length ofstring, this algorithm returnsfromIndex. The empty String is effectively found at every position within a string, including after the last code unit.
This algorithm always returns -1 iffromIndex > the length ofstring.
6.1.5 The Symbol Type
The Symbol type is the set of all non-String values that may be used as the key of an Object property (
Each possible Symbol value is unique and immutable.
Each Symbol value immutably holds an associated value called [[Description]] that is either
6.1.5.1 Well-Known Symbols
Well-known symbols are built-in Symbol values that are explicitly referenced by algorithms of this specification. They are typically used as the keys of properties whose values serve as extension points of a specification algorithm. Unless otherwise specified, well-known symbols values are shared by all realms (
Within this specification a well-known symbol is referred to by using a notation of the form @@name, where “name” is one of the values listed in
| Specification Name | [[Description]] | Value and Purpose |
|---|---|---|
| @@asyncIterator | A method that returns the default AsyncIterator for an object. Called by the semantics of thefor-await-of statement. | |
| @@hasInstance | A method that determines if ainstanceof operator. | |
| @@isConcatSpreadable | A Boolean valued property that if true indicates that an object should be flattened to its array elements byArray.prototype.concat | |
| @@iterator | A method that returns the default Iterator for an object. Called by the semantics of the for-of statement. | |
| @@match | A regular expression method that matches the regular expression against a string. Called by theString.prototype.match | |
| @@matchAll | A regular expression method that returns an iterator, that yields matches of the regular expression against a string. Called by theString.prototype.matchAll | |
| @@replace | A regular expression method that replaces matched substrings of a string. Called by theString.prototype.replace | |
| @@search | A regular expression method that returns the index within a string that matches the regular expression. Called by theString.prototype.search | |
| @@species | A function valued property that is the | |
| @@split | A regular expression method that splits a string at the indices that match the regular expression. Called by theString.prototype.split | |
| @@toPrimitive | A method that converts an object to a corresponding primitive value. Called by the | |
| @@toStringTag | A String valued property that is used in the creation of the default string description of an object. Accessed by the built-in methodObject.prototype.toString | |
| @@unscopables | An object valued property whose own and inherited property names are property names that are excluded from thewith environment bindings of the associated object. |
6.1.6 Numeric Types
ECMAScript has two built-in numeric types: Number and BigInt. In this specification, every numeric typeT contains a multiplicative identity value denotedT::unit. The specification types also have the following
| Invocation Synopsis | Example source | Invoked by the Evaluation semantics of ... | Result |
|---|---|---|---|
| T::unaryMinus(x) | -x | - Operator | T |
| T::bitwiseNOT(x) | ~x | ~ ) | T |
| T::exponentiate(x, y) | x ** y | T, may throw | |
| T::multiply(x, y) | x * y | T | |
| T::divide(x, y) | x / y | T, may throw | |
| T::remainder(x, y) | x % y | T, may throw | |
| T::add(x, y) | x ++++ xx + y | + ) | T |
| T::subtract(x, y) | x ---- xx - y | - ) | T |
| T::leftShift(x, y) | x << y | << ) | T |
| T::signedRightShift(x, y) | x >> y | >> ) | T |
| T::unsignedRightShift(x, y) | x >>> y | >>> ) | T, may throw |
| T::lessThan(x, y) | x < yx > yx <= yx >= y | Boolean or | |
| T::equal(x, y) | x == yx != yx === yx !== y | Boolean | |
| T::sameValue(x, y) | Object internal methods, via | Boolean | |
| T::sameValueZero(x, y) | Array, Map, and Set methods, via | Boolean | |
| T::bitwiseAND(x, y) | x & y | T | |
| T::bitwiseXOR(x, y) | x ^ y | T | |
| T::bitwiseOR(x, y) | x | y | T | |
| T::toString(x) | String(x) | Many expressions and built-in functions, via | String |
TheT::unit value andT::op operations are not a part of the ECMAScript language; they are defined here solely to aid the specification of the semantics of the ECMAScript language. Other
Because the numeric types are in general not convertible without loss of precision or truncation, the ECMAScript language provides no implicit conversion among these types. Programmers must explicitly callNumber andBigInt functions to convert among types when calling a function which requires another type.
The first and subsequent editions of ECMAScript have provided, for certain operators, implicit numeric conversions that could lose precision or truncate. These legacy implicit conversions are maintained for backward compatibility, but not provided for BigInt in order to minimize opportunity for programmer error, and to leave open the option of generalizedvalue types in a future edition.
6.1.6.1 The Number Type
The Number type has exactly 18,437,736,874,454,810,627 (that is,NaN.) In some implementations, external code might be able to detect a difference between various Not-a-Number values, but such behaviour is
The bit pattern that might be observed in an ArrayBuffer (see
There are two other special values, called+Infinity (or simplyInfinity) and-Infinity.)
The other 18,437,736,874,454,810,624 (that is,
Note that there is both a+0 (or simply0) and-0.)
The 18,437,736,874,454,810,622 (that is,
18,428,729,675,200,069,632 (that is,
wheres is 1 or -1,m is an
The remaining 9,007,199,254,740,990 (that is,
wheres is 1 or -1,m is an
Note that all the positive and negative integers whose magnitude is no greater than 253 are representable in the Number type. The
A finite number has anodd significand if it is non-zero and the
In this specification, the phrase “theNumber value forx” wherex represents an exact real mathematical quantity (which might even be an irrational number such as π) means a
The
Some ECMAScript operators deal only with integers in specific ranges such as
The Number::unit value is
6.1.6.1.1 Number::unaryMinus (x )
The abstract operation Number::unaryMinus takes argumentx (a Number). It performs the following steps when called:
- Ifx is
NaN , returnNaN . - Return the result of negatingx; that is, compute a Number with the same magnitude but opposite sign.
6.1.6.1.2 Number::bitwiseNOT (x )
The abstract operation Number::bitwiseNOT takes argumentx (a Number). It performs the following steps when called:
- LetoldValue be !
ToInt32 (x). - Return the result of applying bitwise complement tooldValue. The
mathematical value of the result is exactly representable as a 32-bit two's complement bit string.
6.1.6.1.3 Number::exponentiate (base,exponent )
The abstract operation Number::exponentiate takes argumentsbase (a Number) andexponent (a Number). It returns an
- Ifexponent is
NaN , returnNaN . - Ifexponent is
+0 𝔽 orexponent is-0 𝔽, return1 𝔽. - Ifbase is
NaN , returnNaN . - Ifbase is
+∞ 𝔽, then- Ifexponent >
+0 𝔽, return+∞ 𝔽. Otherwise, return+0 𝔽.
- Ifexponent >
- Ifbase is
-∞ 𝔽, then- Ifexponent >
+0 𝔽, then- Ifexponent is an odd
integral Number , return-∞ 𝔽. Otherwise, return+∞ 𝔽.
- Ifexponent is an odd
- Else,
- Ifexponent is an odd
integral Number , return-0 𝔽. Otherwise, return+0 𝔽.
- Ifexponent is an odd
- Ifexponent >
- Ifbase is
+0 𝔽, then- Ifexponent >
+0 𝔽, return+0 𝔽. Otherwise, return+∞ 𝔽.
- Ifexponent >
- Ifbase is
-0 𝔽, then- Ifexponent >
+0 𝔽, then- Ifexponent is an odd
integral Number , return-0 𝔽. Otherwise, return+0 𝔽.
- Ifexponent is an odd
- Else,
- Ifexponent is an odd
integral Number , return-∞ 𝔽. Otherwise, return+∞ 𝔽.
- Ifexponent is an odd
- Ifexponent >
Assert :base is finite and is neither+0 𝔽 nor-0 𝔽.- Ifexponent is
+∞ 𝔽, then - Ifexponent is
-∞ 𝔽, then Assert :exponent is finite and is neither+0 𝔽 nor-0 𝔽.- Ifbase <
+0 𝔽 andexponent is not anintegral Number , returnNaN . - Return an
implementation-approximated value representing the result of raisingℝ (base) to theℝ (exponent) power.
The result ofbase**exponent whenbase is
6.1.6.1.4 Number::multiply (x,y )
The abstract operation Number::multiply takes argumentsx (a Number) andy (a Number). It performs multiplication according to the rules of
Finite-precision multiplication is commutative, but not always associative.
6.1.6.1.5 Number::divide (x,y )
The abstract operation Number::divide takes argumentsx (a Number) andy (a Number). It performs division according to the rules of
- Ifx is
NaN ory isNaN , returnNaN . - Ifx is
+∞ 𝔽 orx is-∞ 𝔽, then- Ify is
+∞ 𝔽 ory is-∞ 𝔽, returnNaN . - Ify is
+0 𝔽 ory >+0 𝔽, returnx. - Return -x.
- Ify is
- Ify is
+∞ 𝔽, then- Ifx is
+0 𝔽 orx >+0 𝔽, return+0 𝔽. Otherwise, return-0 𝔽.
- Ifx is
- Ify is
-∞ 𝔽, then- Ifx is
+0 𝔽 orx >+0 𝔽, return-0 𝔽. Otherwise, return+0 𝔽.
- Ifx is
- Ifx is
+0 𝔽 orx is-0 𝔽, then- Ify is
+0 𝔽 ory is-0 𝔽, returnNaN . - Ify >
+0 𝔽, returnx. - Return -x.
- Ify is
- Ify is
+0 𝔽, then- Ifx >
+0 𝔽, return+∞ 𝔽. Otherwise, return-∞ 𝔽.
- Ifx >
- Ify is
-0 𝔽, then- Ifx >
+0 𝔽, return-∞ 𝔽. Otherwise, return+∞ 𝔽.
- Ifx >
- Return
𝔽 (ℝ (x) /ℝ (y)).
6.1.6.1.6 Number::remainder (n,d )
The abstract operation Number::remainder takes argumentsn (a Number) andd (a Number). It yields the remainder from an implied division of its operands wheren is the dividend andd is the divisor. It performs the following steps when called:
- Ifn is
NaN ord isNaN , returnNaN . - Ifn is
+∞ 𝔽 orn is-∞ 𝔽, returnNaN . - Ifd is
+∞ 𝔽 ord is-∞ 𝔽, returnn. - Ifd is
+0 𝔽 ord is-0 𝔽, returnNaN . - Ifn is
+0 𝔽 orn is-0 𝔽, returnn. Assert :n andd are finite and non-zero.- Letr be
ℝ (n) - (ℝ (d) ×q) whereq is aninteger that is negative if and only ifn andd have opposite sign, and whose magnitude is as large as possible without exceeding the magnitude ofℝ (n) /ℝ (d). - Return
𝔽 (r).
In C and C++, the remainder operator accepts only integral operands; in ECMAScript, it also accepts floating-point operands.
% operator is not the same as the “remainder” operation defined by% on floating-point operations to behave in a manner analogous to that of the Java6.1.6.1.7 Number::add (x,y )
The abstract operation Number::add takes argumentsx (a Number) andy (a Number). It performs addition according to the rules of
Finite-precision addition is commutative, but not always associative.
6.1.6.1.8 Number::subtract (x,y )
The abstract operation Number::subtract takes argumentsx (a Number) andy (a Number). It performs subtraction, producing the difference of its operands;x is the minuend andy is the subtrahend. It performs the following steps when called:
- Return Number::add(x, Number::unaryMinus(y)).
It is always the case thatx - y produces the same result asx + (-y).
6.1.6.1.9 Number::leftShift (x,y )
The abstract operation Number::leftShift takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Letlnum be !
ToInt32 (x). - Letrnum be !
ToUint32 (y). - LetshiftCount be
ℝ (rnum)modulo 32. - Return the result of left shiftinglnum byshiftCount bits. The
mathematical value of the result is exactly representable as a 32-bit two's complement bit string.
6.1.6.1.10 Number::signedRightShift (x,y )
The abstract operation Number::signedRightShift takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Letlnum be !
ToInt32 (x). - Letrnum be !
ToUint32 (y). - LetshiftCount be
ℝ (rnum)modulo 32. - Return the result of performing a sign-extending right shift oflnum byshiftCount bits. The most significant bit is propagated. The
mathematical value of the result is exactly representable as a 32-bit two's complement bit string.
6.1.6.1.11 Number::unsignedRightShift (x,y )
The abstract operation Number::unsignedRightShift takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Letlnum be !
ToUint32 (x). - Letrnum be !
ToUint32 (y). - LetshiftCount be
ℝ (rnum)modulo 32. - Return the result of performing a zero-filling right shift oflnum byshiftCount bits. Vacated bits are filled with zero. The
mathematical value of the result is exactly representable as a 32-bit unsigned bit string.
6.1.6.1.12 Number::lessThan (x,y )
The abstract operation Number::lessThan takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Ifx is
NaN , returnundefined . - Ify is
NaN , returnundefined . - Ifx andy are the same
Number value , returnfalse . - Ifx is
+0 𝔽 andy is-0 𝔽, returnfalse . - Ifx is
-0 𝔽 andy is+0 𝔽, returnfalse . - Ifx is
+∞ 𝔽, returnfalse . - Ify is
+∞ 𝔽, returntrue . - Ify is
-∞ 𝔽, returnfalse . - Ifx is
-∞ 𝔽, returntrue . Assert :x andy are finite and non-zero.- If
ℝ (x) <ℝ (y), returntrue . Otherwise, returnfalse .
6.1.6.1.13 Number::equal (x,y )
The abstract operation Number::equal takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Ifx is
NaN , returnfalse . - Ify is
NaN , returnfalse . - Ifx is the same
Number value asy, returntrue . - Ifx is
+0 𝔽 andy is-0 𝔽, returntrue . - Ifx is
-0 𝔽 andy is+0 𝔽, returntrue . - Return
false .
6.1.6.1.14 Number::sameValue (x,y )
The abstract operation Number::sameValue takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Ifx is
NaN andy isNaN , returntrue . - Ifx is
+0 𝔽 andy is-0 𝔽, returnfalse . - Ifx is
-0 𝔽 andy is+0 𝔽, returnfalse . - Ifx is the same
Number value asy, returntrue . - Return
false .
6.1.6.1.15 Number::sameValueZero (x,y )
The abstract operation Number::sameValueZero takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Ifx is
NaN andy isNaN , returntrue . - Ifx is
+0 𝔽 andy is-0 𝔽, returntrue . - Ifx is
-0 𝔽 andy is+0 𝔽, returntrue . - Ifx is the same
Number value asy, returntrue . - Return
false .
6.1.6.1.16 NumberBitwiseOp (op,x,y )
The abstract operation NumberBitwiseOp takes argumentsop (a sequence of Unicode code points),x, andy. It performs the following steps when called:
Assert :op is&,^, or|.- Letlnum be !
ToInt32 (x). - Letrnum be !
ToInt32 (y). - Letlbits be the 32-bit two's complement bit string representing
ℝ (lnum). - Letrbits be the 32-bit two's complement bit string representing
ℝ (rnum). - Ifop is
&, letresult be the result of applying the bitwise AND operation tolbits andrbits. - Else ifop is
^, letresult be the result of applying the bitwise exclusive OR (XOR) operation tolbits andrbits. - Else,op is
|. Letresult be the result of applying the bitwise inclusive OR operation tolbits andrbits. - Return the
Number value for theinteger represented by the 32-bit two's complement bit stringresult.
6.1.6.1.17 Number::bitwiseAND (x,y )
The abstract operation Number::bitwiseAND takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Return
NumberBitwiseOp (&,x,y).
6.1.6.1.18 Number::bitwiseXOR (x,y )
The abstract operation Number::bitwiseXOR takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Return
NumberBitwiseOp (^,x,y).
6.1.6.1.19 Number::bitwiseOR (x,y )
The abstract operation Number::bitwiseOR takes argumentsx (a Number) andy (a Number). It performs the following steps when called:
- Return
NumberBitwiseOp (|,x,y).
6.1.6.1.20 Number::toString (x )
The abstract operation Number::toString takes argumentx (a Number). It convertsx to String format. It performs the following steps when called:
- Ifx is
NaN , return the String"NaN" . - Ifx is
+0 𝔽 or-0 𝔽, return the String"0" . - Ifx <
+0 𝔽, return thestring-concatenation of"-" and !Number::toString (-x). - Ifx is
+∞ 𝔽, return the String"Infinity" . - Otherwise, letn,k, ands be integers such thatk ≥ 1, 10k - 1 ≤s < 10k,s × 10n -k is
ℝ (x), andk is as small as possible. Note thatk is the number of digits in the decimal representation ofs, thats is not divisible by 10, and that the least significant digit ofs is not necessarily uniquely determined by these criteria. - Ifk ≤n ≤ 21, return the
string-concatenation of:- the code units of thek digits of the decimal representation ofs (in order, with no leading zeroes)
- n -k occurrences of the code unit 0x0030 (DIGIT ZERO)
- If 0 <n ≤ 21, return the
string-concatenation of:- the code units of the most significantn digits of the decimal representation ofs
- the code unit 0x002E (FULL STOP)
- the code units of the remainingk -n digits of the decimal representation ofs
- If -6 <n ≤ 0, return the
string-concatenation of:- the code unit 0x0030 (DIGIT ZERO)
- the code unit 0x002E (FULL STOP)
- -n occurrences of the code unit 0x0030 (DIGIT ZERO)
- the code units of thek digits of the decimal representation ofs
- Otherwise, ifk = 1, return the
string-concatenation of: - Return the
string-concatenation of:- the code units of the most significant digit of the decimal representation ofs
- the code unit 0x002E (FULL STOP)
- the code units of the remainingk - 1 digits of the decimal representation ofs
- the code unit 0x0065 (LATIN SMALL LETTER E)
- the code unit 0x002B (PLUS SIGN) or the code unit 0x002D (HYPHEN-MINUS) according to whethern - 1 is positive or negative
- the code units of the decimal representation of the
integer abs (n - 1) (with no leading zeroes)
The following observations may be useful as guidelines for implementations, but are not part of the normative requirements of this Standard:
- If x is any
Number value other than-0 𝔽, thenToNumber (ToString (x)) is exactly the sameNumber value as x. - The least significant digit of s is not always uniquely determined by the requirements listed in step
5 .
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step
- Otherwise, letn,k, ands be integers such thatk ≥ 1, 10k - 1 ≤s < 10k,s × 10n -k is
ℝ (x), andk is as small as possible. If there are multiple possibilities fors, choose the value ofs for whichs × 10n -k is closest in value toℝ (x). If there are two such possible values ofs, choose the one that is even. Note thatk is the number of digits in the decimal representation ofs and thats is not divisible by 10.
Implementers of ECMAScript may find useful the paper and code written by David M. Gay for binary-to-decimal conversion of floating-point numbers:
Gay, David M. Correctly Rounded Binary-Decimal and Decimal-Binary Conversions. Numerical Analysis, Manuscript 90-10. AT&T Bell Laboratories (Murray Hill, New Jersey). 30 November 1990. Available as
http://ampl.com/REFS/abstracts.html#rounding. Associated code available as
http://netlib.sandia.gov/fp/dtoa.c and as
http://netlib.sandia.gov/fp/g_fmt.c and may also be found at the variousnetlib mirror sites.
6.1.6.2 The BigInt Type
The BigInt type represents an
The BigInt::unit value is
6.1.6.2.1 BigInt::unaryMinus (x )
The abstract operation BigInt::unaryMinus takes argumentx (a BigInt). It performs the following steps when called:
- Ifx is
0 ℤ, return0 ℤ. - Return the BigInt value that represents the negation of
ℝ (x).
6.1.6.2.2 BigInt::bitwiseNOT (x )
The abstract operation BigInt::bitwiseNOT takes argumentx (a BigInt). It returns the one's complement ofx; that is, -x -
6.1.6.2.3 BigInt::exponentiate (base,exponent )
The abstract operation BigInt::exponentiate takes argumentsbase (a BigInt) andexponent (a BigInt). It performs the following steps when called:
6.1.6.2.4 BigInt::multiply (x,y )
The abstract operation BigInt::multiply takes argumentsx (a BigInt) andy (a BigInt). It returns the BigInt value that represents the result of multiplyingx andy.
6.1.6.2.5 BigInt::divide (x,y )
The abstract operation BigInt::divide takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
6.1.6.2.6 BigInt::remainder (n,d )
The abstract operation BigInt::remainder takes argumentsn (a BigInt) andd (a BigInt). It performs the following steps when called:
- Ifd is
0 ℤ, throw aRangeError exception. - Ifn is
0 ℤ, return0 ℤ. - Letr be the BigInt defined by the mathematical relationr =n - (d ×q) whereq is a BigInt that is negative only ifn/d is negative and positive only ifn/d is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient ofn andd.
- Returnr.
6.1.6.2.7 BigInt::add (x,y )
The abstract operation BigInt::add takes argumentsx (a BigInt) andy (a BigInt). It returns the BigInt value that represents the sum ofx andy.
6.1.6.2.8 BigInt::subtract (x,y )
The abstract operation BigInt::subtract takes argumentsx (a BigInt) andy (a BigInt). It returns the BigInt value that represents the differencex minusy.
6.1.6.2.9 BigInt::leftShift (x,y )
The abstract operation BigInt::leftShift takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
6.1.6.2.10 BigInt::signedRightShift (x,y )
The abstract operation BigInt::signedRightShift takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Return BigInt::leftShift(x, -y).
6.1.6.2.11 BigInt::unsignedRightShift (x,y )
The abstract operation BigInt::unsignedRightShift takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Throw a
TypeError exception.
6.1.6.2.12 BigInt::lessThan (x,y )
The abstract operation BigInt::lessThan takes argumentsx (a BigInt) andy (a BigInt). It returns
6.1.6.2.13 BigInt::equal (x,y )
The abstract operation BigInt::equal takes argumentsx (a BigInt) andy (a BigInt). It returns
6.1.6.2.14 BigInt::sameValue (x,y )
The abstract operation BigInt::sameValue takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Return BigInt::equal(x,y).
6.1.6.2.15 BigInt::sameValueZero (x,y )
The abstract operation BigInt::sameValueZero takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Return BigInt::equal(x,y).
6.1.6.2.16 BinaryAnd (x,y )
The abstract operation BinaryAnd takes argumentsx andy. It performs the following steps when called:
6.1.6.2.17 BinaryOr (x,y )
The abstract operation BinaryOr takes argumentsx andy. It performs the following steps when called:
6.1.6.2.18 BinaryXor (x,y )
The abstract operation BinaryXor takes argumentsx andy. It performs the following steps when called:
6.1.6.2.19 BigIntBitwiseOp (op,x,y )
The abstract operation BigIntBitwiseOp takes argumentsop (a sequence of Unicode code points),x (a BigInt), andy (a BigInt). It performs the following steps when called:
Assert :op is&,^, or|.- Setx to
ℝ (x). - Sety to
ℝ (y). - Letresult be 0.
- Letshift be 0.
- Repeat, until (x = 0 orx = -1) and (y = 0 ory = -1),
- Ifop is
&, lettmp beBinaryAnd (xmodulo 2,ymodulo 2). - Else ifop is
|, lettmp beBinaryOr (xmodulo 2,ymodulo 2). - Else,
- Iftmp ≠ 0, then
- Setresult toresult - 2shift.
- NOTE: This extends the sign.
- Return the BigInt value forresult.
6.1.6.2.20 BigInt::bitwiseAND (x,y )
The abstract operation BigInt::bitwiseAND takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Return
BigIntBitwiseOp (&,x,y).
6.1.6.2.21 BigInt::bitwiseXOR (x,y )
The abstract operation BigInt::bitwiseXOR takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Return
BigIntBitwiseOp (^,x,y).
6.1.6.2.22 BigInt::bitwiseOR (x,y )
The abstract operation BigInt::bitwiseOR takes argumentsx (a BigInt) andy (a BigInt). It performs the following steps when called:
- Return
BigIntBitwiseOp (|,x,y).
6.1.6.2.23 BigInt::toString (x )
The abstract operation BigInt::toString takes argumentx (a BigInt). It convertsx to String format. It performs the following steps when called:
- Ifx <
0 ℤ, return thestring-concatenation of the String"-" and !BigInt::toString (-x). - Return the String value consisting of the code units of the digits of the decimal representation ofx.
6.1.7 The Object Type
An Object is logically a collection of properties. Each property is either a data property, or an accessor property:
- Adata property associates a key value with an
ECMAScript language value and a set of Boolean attributes. - Anaccessor property associates a key value with one or two accessor functions, and a set of Boolean attributes. The accessor functions are used to store or retrieve an
ECMAScript language value that is associated with the property.
Properties are identified using key values. A property key value is either an ECMAScript String value or a Symbol value. All String and Symbol values, including the empty String, are valid as property keys. Aproperty name is a property key that is a String value.
Aninteger index is a String-valued property key that is a canonical numeric String (see
Property keys are used to access properties and their values. There are two kinds of access for properties:get andset, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes bothown properties that are a direct part of an object andinherited properties which are provided by another associated object via a property inheritance relationship. Inherited properties may be either own or inherited properties of the associated object. Each own property of an object must each have a key value that is distinct from the key values of the other own properties of that object.
All objects are logically collections of properties, but there are multiple forms of objects that differ in their semantics for accessing and manipulating their properties. Please see
6.1.7.1 Property Attributes
Attributes are used in this specification to define and explain the state of Object properties. A
| Attribute Name | Value Domain | Description |
|---|---|---|
| [[Value]] | Any | The value retrieved by a get access of the property. |
| [[Writable]] | Boolean | If |
| [[Enumerable]] | Boolean | If |
| [[Configurable]] | Boolean | If |
An
| Attribute Name | Value Domain | Description |
|---|---|---|
| [[Get]] | Object | Undefined | If the value is an Object it must be a |
| [[Set]] | Object | Undefined | If the value is an Object it must be a |
| [[Enumerable]] | Boolean | If |
| [[Configurable]] | Boolean | If |
If the initial values of a property's attributes are not explicitly specified by this specification, the default value defined in
| Attribute Name | Default Value |
|---|---|
| [[Value]] | |
| [[Get]] | |
| [[Set]] | |
| [[Writable]] | |
| [[Enumerable]] | |
| [[Configurable]] |
6.1.7.2 Object Internal Methods and Internal Slots
The actual semantics of objects, in ECMAScript, are specified via algorithms calledinternal methods. Each object in an ECMAScript engine is associated with a set of internal methods that defines its runtime behaviour. These internal methods are not part of the ECMAScript language. They are defined by this specification purely for expository purposes. However, each object within an implementation of ECMAScript must behave as specified by the internal methods associated with it. The exact manner in which this is accomplished is determined by the implementation.
Internal method names are polymorphic. This means that different object values may perform different algorithms when a common internal method name is invoked upon them. That actual object upon which an internal method is invoked is the “target” of the invocation. If, at runtime, the implementation of an algorithm attempts to use an internal method of an object that the object does not support, a
Internal slots correspond to internal state that is associated with objects and used by various ECMAScript specification algorithms. Internal slots are not object properties and they are not inherited. Depending upon the specific internal slot specification, such state may consist of values of any
Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].
Anordinary object is an object that satisfies all of the following criteria:
- For the internal methods listed in
Table 6 , the object uses those defined in10.1 . - If the object has a [[Call]] internal method, it uses the one defined in
10.2.1 . - If the object has a [[Construct]] internal method, it uses the one defined in
10.2.2 .
Anexotic object is an object that is not an
This specification recognizes different kinds of exotic objects by those objects' internal methods. An object that is behaviourally equivalent to a particular kind of
The “Signature” column of
In addition to its parameters, an internal method always has access to the object that is the target of the method invocation.
An internal method implicitly returns a
| Internal Method | Signature | Description |
|---|---|---|
| [[GetPrototypeOf]] | ( )→ Object | Null | Determine the object that provides inherited properties for this object. A |
| [[SetPrototypeOf]] | (Object | Null)→ Boolean | Associate this object with another object that provides inherited properties. Passing |
| [[IsExtensible]] | ( )→ Boolean | Determine whether it is permitted to add additional properties to this object. |
| [[PreventExtensions]] | ( )→ Boolean | Control whether new properties may be added to this object. Returns |
| [[GetOwnProperty]] | (propertyKey)→ Undefined | | Return a |
| [[DefineOwnProperty]] | (propertyKey,PropertyDescriptor)→ Boolean | Create or alter the own property, whose key ispropertyKey, to have the state described byPropertyDescriptor. Return |
| [[HasProperty]] | (propertyKey)→ Boolean | Return a Boolean value indicating whether this object already has either an own or inherited property whose key ispropertyKey. |
| [[Get]] | (propertyKey,Receiver)→any | Return the value of the property whose key ispropertyKey from this object. If any ECMAScript code must be executed to retrieve the property value,Receiver is used as the |
| [[Set]] | (propertyKey,value,Receiver)→ Boolean | Set the value of the property whose key ispropertyKey tovalue. If any ECMAScript code must be executed to set the property value,Receiver is used as the |
| [[Delete]] | (propertyKey)→ Boolean | Remove the own property whose key ispropertyKey from this object. Return |
| [[OwnPropertyKeys]] | ( )→ | Return a |
| Internal Method | Signature | Description |
|---|---|---|
| [[Call]] | (any, a | Executes code associated with this object. Invoked via a function call expression. The arguments to the internal method are a |
| [[Construct]] | (a | Creates an object. Invoked via thenew operator or asuper call. The first argument to the internal method is asuper call. The second argument is the object to which thenew operator was initially applied. Objects that implement this internal method are calledconstructors. A |
The semantics of the essential internal methods for ordinary objects and standard exotic objects are specified in clause
6.1.7.3 Invariants of the Essential Internal Methods
The Internal Methods of Objects of an ECMAScript engine must conform to the list of invariants specified below. Ordinary ECMAScript Objects as well as all standard exotic objects in this specification maintain these invariants. ECMAScript Proxy objects maintain these invariants by means of runtime checks on the result of traps invoked on the [[ProxyHandler]] object.
Any implementation provided exotic objects must also maintain these invariants for those objects. Violation of these invariants may cause ECMAScript code to have unpredictable behaviour and create security issues. However, violation of these invariants must never compromise the memory safety of an implementation.
An implementation must not allow these invariants to be circumvented in any manner such as by providing alternative interfaces that implement the functionality of the essential internal methods without enforcing their invariants.
Definitions:
- Thetarget of an internal method is the object upon which the internal method is called.
- A target isnon-extensible if it has been observed to return
false from its [[IsExtensible]] internal method, ortrue from its [[PreventExtensions]] internal method. - Anon-existent property is a property that does not exist as an own property on a non-extensible target.
- All references to
SameValue are according to the definition of theSameValue algorithm.
Return value:
The value returned by any internal method must be a
- [[Type]] =
normal , [[Target]] =empty , and [[Value]] = a value of the "normal return type" shown below for that internal method, or - [[Type]] =
throw , [[Target]] =empty , and [[Value]] = anyECMAScript language value .
An internal method must not return a completion with [[Type]] =
[[GetPrototypeOf]] ( )
- The normal return type is either Object or Null.
- If target is non-extensible, and [[GetPrototypeOf]] returns a valueV, then any future calls to [[GetPrototypeOf]] should return the
SameValue asV.
An object's prototype chain should have finite length (that is, starting from any object, recursively applying the [[GetPrototypeOf]] internal method to its result should eventually lead to the value
[[SetPrototypeOf]] (V )
- The normal return type is Boolean.
- If target is non-extensible, [[SetPrototypeOf]] must return
false , unlessV is theSameValue as the target's observed [[GetPrototypeOf]] value.
[[IsExtensible]] ( )
- The normal return type is Boolean.
- If [[IsExtensible]] returns
false , all future calls to [[IsExtensible]] on the target must returnfalse .
[[PreventExtensions]] ( )
- The normal return type is Boolean.
- If [[PreventExtensions]] returns
true , all future calls to [[IsExtensible]] on the target must returnfalse and the target is now considered non-extensible.
[[GetOwnProperty]] (P )
- The normal return type is either
Property Descriptor or Undefined. - If the Type of the return value is
Property Descriptor , the return value must be a fully populatedProperty Descriptor . - IfP is described as a non-configurable, non-writable own
data property , all future calls to [[GetOwnProperty]] (P ) must returnProperty Descriptor whose [[Value]] isSameValue asP's [[Value]] attribute. - IfP's attributes other than [[Writable]] may change over time or if the property might be deleted, thenP's [[Configurable]] attribute must be
true . - If the [[Writable]] attribute may change from
false totrue , then the [[Configurable]] attribute must betrue . - If the target is non-extensible andP is non-existent, then all future calls to [[GetOwnProperty]] (P) on the target must describeP as non-existent (i.e. [[GetOwnProperty]] (P) must return
undefined ).
As a consequence of the third invariant, if a property is described as a
[[DefineOwnProperty]] (P,Desc )
- The normal return type is Boolean.
- [[DefineOwnProperty]] must return
false ifP has previously been observed as a non-configurable own property of the target, unless either:- P is a writable
data property . A non-configurable writabledata property can be changed into a non-configurable non-writabledata property . - All attributes ofDesc are the
SameValue asP's attributes.
- P is a writable
- [[DefineOwnProperty]] (P,Desc) must return
false if target is non-extensible andP is a non-existent own property. That is, a non-extensible target object cannot be extended with new properties.
[[HasProperty]] (P )
- The normal return type is Boolean.
- IfP was previously observed as a non-configurable own data or
accessor property of the target, [[HasProperty]] must returntrue .
[[Get]] (P,Receiver )
- The normal return type is any
ECMAScript language type . - IfP was previously observed as a non-configurable, non-writable own
data property of the target with valueV, then [[Get]] must return theSameValue asV. - IfP was previously observed as a non-configurable own
accessor property of the target whose [[Get]] attribute isundefined , the [[Get]] operation must returnundefined .
[[Set]] (P,V,Receiver )
- The normal return type is Boolean.
- IfP was previously observed as a non-configurable, non-writable own
data property of the target, then [[Set]] must returnfalse unlessV is theSameValue asP's [[Value]] attribute. - IfP was previously observed as a non-configurable own
accessor property of the target whose [[Set]] attribute isundefined , the [[Set]] operation must returnfalse .
[[Delete]] (P )
- The normal return type is Boolean.
- IfP was previously observed as a non-configurable own data or
accessor property of the target, [[Delete]] must returnfalse .
[[OwnPropertyKeys]] ( )
- The normal return type is
List . - The returned
List must not contain any duplicate entries. - The Type of each element of the returned
List is either String or Symbol. - The returned
List must contain at least the keys of all non-configurable own properties that have previously been observed. - If the target is non-extensible, the returned
List must contain only the keys of all own properties of the target that are observable using [[GetOwnProperty]].
[[Call]] ( )
- The normal return type is any
ECMAScript language type .
[[Construct]] ( )
- The normal return type is Object.
- The target must also have a [[Call]] internal method.
6.1.7.4 Well-Known Intrinsic Objects
Well-known intrinsics are built-in objects that are explicitly referenced by the algorithms of this specification and which usually have
Within this specification a reference such as %name% means the intrinsic object, associated with the current
| Intrinsic Name | Global Name | ECMAScript Language Association |
|---|---|---|
AggregateError | TheAggregateError | |
Array | The Array | |
ArrayBuffer | The ArrayBuffer | |
| The prototype of Array iterator objects ( | ||
| The prototype of async-from-sync iterator objects ( | ||
| The | ||
| The | ||
| An object that all standard built-in async iterator objects indirectly inherit from | ||
Atomics | TheAtomics object ( | |
BigInt | The BigInt | |
BigInt64Array | The BigInt64Array | |
BigUint64Array | The BigUint64Array | |
Boolean | The Boolean | |
DataView | The DataView | |
Date | The Date | |
decodeURI | ThedecodeURI function ( | |
decodeURIComponent | ThedecodeURIComponent function ( | |
encodeURI | TheencodeURI function ( | |
encodeURIComponent | TheencodeURIComponent function ( | |
Error | The Error | |
eval | Theeval function ( | |
EvalError | The EvalError | |
FinalizationRegistry | The | |
Float32Array | The Float32Array | |
Float64Array | The Float64Array | |
| The prototype of For-In iterator objects ( | ||
Function | The Function | |
| The | ||
Int8Array | The Int8Array | |
Int16Array | The Int16Array | |
Int32Array | The Int32Array | |
isFinite | TheisFinite function ( | |
isNaN | TheisNaN function ( | |
| An object that all standard built-in iterator objects indirectly inherit from | ||
JSON | TheJSON object ( | |
Map | The Map | |
| The prototype of Map iterator objects ( | ||
Math | TheMath object ( | |
Number | The Number | |
Object | The Object | |
parseFloat | TheparseFloat function ( | |
parseInt | TheparseInt function ( | |
Promise | The Promise | |
Proxy | The Proxy | |
RangeError | The RangeError | |
ReferenceError | The ReferenceError | |
Reflect | TheReflect object ( | |
RegExp | The RegExp | |
| The prototype of RegExp String Iterator objects ( | ||
Set | The Set | |
| The prototype of Set iterator objects ( | ||
SharedArrayBuffer | The SharedArrayBuffer | |
String | The String | |
| The prototype of String iterator objects ( | ||
Symbol | The Symbol | |
SyntaxError | The SyntaxError | |
| A | ||
| The super class of all typed Array constructors ( | ||
TypeError | The TypeError | |
Uint8Array | The Uint8Array | |
Uint8ClampedArray | The Uint8ClampedArray | |
Uint16Array | The Uint16Array | |
Uint32Array | The Uint32Array | |
URIError | The URIError | |
WeakMap | The WeakMap | |
WeakRef | The | |
WeakSet | The WeakSet |
Additional entries in
6.2 ECMAScript Specification Types
A specification type corresponds to meta-values that are used within algorithms to describe the semantics of ECMAScript language constructs and ECMAScript language types. The specification types include
6.2.1 The List and Record Specification Types
TheList type is used to explain the evaluation of argument lists (seenew expressions, in function calls, and in other algorithms where a simple ordered list of values is needed. Values of the List type are simply ordered sequences of list elements containing the individual values. These sequences may be of any length. The elements of a list may be randomly accessed using 0-origin indices. For notational convenience an array-like syntax can be used to access List elements. For example,arguments[2] is shorthand for saying the 3rd element of the Listarguments.
When an algorithm iterates over the elements of a List without specifying an order, the order used is the order of the elements in the List.
For notational convenience within this specification, a literal syntax can be used to express a new List value. For example, « 1, 2 » defines a List value that has two elements each of which is initialized to a specific value. A new empty List can be expressed as « ».
TheRecord type is used to describe data aggregations within the algorithms of this specification. A Record type value consists of one or more named fields. The value of each field is either an ECMAScript value or an abstract value represented by a name associated with the Record type. Field names are always enclosed in double brackets, for example [[Value]].
For notational convenience within this specification, an object literal-like syntax can be used to express a Record value. For example, { [[Field1]]: 42, [[Field2]]:
In specification text and algorithms, dot notation may be used to refer to a specific field of a Record value. For example, if R is the record shown in the previous paragraph then R.[[Field2]] is shorthand for “the field of R named [[Field2]]”.
Schema for commonly used Record field combinations may be named, and that name may be used as a prefix to a literal Record value to identify the specific kind of aggregations that is being described. For example: PropertyDescriptor { [[Value]]: 42, [[Writable]]:
6.2.2 The Set and Relation Specification Types
TheSet type is used to explain a collection of unordered elements for use in the
TheRelation type is used to explain constraints on Sets. Values of the Relation type are Sets of ordered pairs of values from its value domain. For example, a Relation on events is a set of ordered pairs of events. For a RelationR and two valuesa andb in the value domain ofR,aRb is shorthand for saying the ordered pair (a,b) is a member ofR. A Relation is least with respect to some conditions when it is the smallest Relation that satisfies those conditions.
Astrict partial order is a Relation valueR that satisfies the following.
For alla,b, andc inR's domain:
- It is not the case thataRa, and
- IfaRb andbRc, thenaRc.
The two properties above are called irreflexivity and transitivity, respectively.
Astrict total order is a Relation valueR that satisfies the following.
For alla,b, andc inR's domain:
- a is identical tob oraRb orbRa, and
- It is not the case thataRa, and
- IfaRb andbRc, thenaRc.
The three properties above are called totality, irreflexivity, and transitivity, respectively.
6.2.3 The Completion Record Specification Type
The Completion type is abreak,continue,return andthrow) that perform nonlocal transfers of control.
Values of the Completion type are
| Field Name | Value | Meaning |
|---|---|---|
| [[Type]] | One of | The type of completion that occurred. |
| [[Value]] | any | The value that was produced. |
| [[Target]] | any ECMAScript string or | The target label for directed control transfers. |
The term “abrupt completion” refers to any completion with a [[Type]] value other than
6.2.3.1 Await
Algorithm steps that say
- Letcompletion be
Await (value).
mean the same thing as:
- LetasyncContext be the
running execution context . - Letpromise be ?
PromiseResolve (%Promise% ,value). - LetstepsFulfilled be the algorithm steps defined in
Await Fulfilled Functions . - LetlengthFulfilled be the number of non-optional parameters of the function definition in
Await Fulfilled Functions . - LetonFulfilled be !
CreateBuiltinFunction (stepsFulfilled,lengthFulfilled,"" , « [[AsyncContext]] »). - SetonFulfilled.[[AsyncContext]] toasyncContext.
- LetstepsRejected be the algorithm steps defined in
Await Rejected Functions . - LetlengthRejected be the number of non-optional parameters of the function definition in
Await Rejected Functions . - LetonRejected be !
CreateBuiltinFunction (stepsRejected,lengthRejected,"" , « [[AsyncContext]] »). - SetonRejected.[[AsyncContext]] toasyncContext.
- Perform !
PerformPromiseThen (promise,onFulfilled,onRejected). - RemoveasyncContext from the
execution context stack and restore theexecution context that is at the top of theexecution context stack as therunning execution context . - Set the code evaluation state ofasyncContext such that when evaluation is resumed with a
Completion completion, the following steps of the algorithm that invokedAwait will be performed, withcompletion available. - Return.
- NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation ofasyncContext.
where all aliases in the above steps, with the exception ofcompletion, are ephemeral and visible only in the steps pertaining to Await.
Await can be combined with the? and! prefixes, so that for example
- Letresult be ?
Await (value).
means the same thing as:
- Letresult be
Await (value). ReturnIfAbrupt (result).
6.2.3.1.1 Await Fulfilled Functions
An
When an
- LetF be the
active function object . - LetasyncContext beF.[[AsyncContext]].
- LetprevContext be the
running execution context . Suspend prevContext.- PushasyncContext onto the
execution context stack ;asyncContext is now therunning execution context . - Resume the suspended evaluation ofasyncContext using
NormalCompletion (value) as the result of the operation that suspended it. Assert : When we reach this step,asyncContext has already been removed from theexecution context stack andprevContext is the currentlyrunning execution context .- Return
undefined .
The
6.2.3.1.2 Await Rejected Functions
An
When an
- LetF be the
active function object . - LetasyncContext beF.[[AsyncContext]].
- LetprevContext be the
running execution context . Suspend prevContext.- PushasyncContext onto the
execution context stack ;asyncContext is now therunning execution context . - Resume the suspended evaluation ofasyncContext using
ThrowCompletion (reason) as the result of the operation that suspended it. Assert : When we reach this step,asyncContext has already been removed from theexecution context stack andprevContext is the currentlyrunning execution context .- Return
undefined .
The
6.2.3.2 NormalCompletion
The abstract operation NormalCompletion with a singleargument, such as:
- Return
NormalCompletion (argument).
Is a shorthand that is defined as follows:
- Return
Completion { [[Type]]:normal , [[Value]]:argument, [[Target]]:empty }.
6.2.3.3 ThrowCompletion
The abstract operation ThrowCompletion with a singleargument, such as:
- Return
ThrowCompletion (argument).
Is a shorthand that is defined as follows:
- Return
Completion { [[Type]]:throw , [[Value]]:argument, [[Target]]:empty }.
6.2.3.4 UpdateEmpty (completionRecord,value )
The abstract operation UpdateEmpty takes argumentscompletionRecord andvalue. It performs the following steps when called:
Assert : IfcompletionRecord.[[Type]] is eitherreturn orthrow , thencompletionRecord.[[Value]] is notempty .- IfcompletionRecord.[[Value]] is not
empty , returnCompletion (completionRecord). - Return
Completion { [[Type]]:completionRecord.[[Type]], [[Value]]:value, [[Target]]:completionRecord.[[Target]] }.
6.2.4 The Reference Record Specification Type
TheReference Record type is used to explain the behaviour of such operators asdelete,typeof, the assignment operators, thesuper
A Reference Record is a resolved name or property binding; its fields are defined by
| Field Name | Value | Meaning |
|---|---|---|
| [[Base]] | One of:
| The value or |
| [[ReferencedName]] | String or Symbol | The name of the binding. Always a String if [[Base]] value is an |
| [[Strict]] | Boolean | |
| [[ThisValue]] | any | If notsuper |
The following
6.2.4.1 IsPropertyReference (V )
The abstract operation IsPropertyReference takes argumentV. It performs the following steps when called:
Assert :V is aReference Record .- IfV.[[Base]] is
unresolvable , returnfalse . - If
Type (V.[[Base]]) is Boolean, String, Symbol, BigInt, Number, or Object, returntrue ; otherwise returnfalse .
6.2.4.2 IsUnresolvableReference (V )
The abstract operation IsUnresolvableReference takes argumentV. It performs the following steps when called:
Assert :V is aReference Record .- IfV.[[Base]] is
unresolvable , returntrue ; otherwise returnfalse .
6.2.4.3 IsSuperReference (V )
The abstract operation IsSuperReference takes argumentV. It performs the following steps when called:
Assert :V is aReference Record .- IfV.[[ThisValue]] is not
empty , returntrue ; otherwise returnfalse .
6.2.4.4 GetValue (V )
The abstract operation GetValue takes argumentV. It performs the following steps when called:
ReturnIfAbrupt (V).- IfV is not a
Reference Record , returnV. - If
IsUnresolvableReference (V) istrue , throw aReferenceError exception. - If
IsPropertyReference (V) istrue , then- LetbaseObj be !
ToObject (V.[[Base]]). - Return ?baseObj.[[Get]](V.[[ReferencedName]],
GetThisValue (V)).
- LetbaseObj be !
- Else,
- Letbase beV.[[Base]].
Assert :base is anEnvironment Record .- Return ?base.GetBindingValue(V.[[ReferencedName]],V.[[Strict]]) (see
9.1 ).
The object that may be created in step
6.2.4.5 PutValue (V,W )
The abstract operation PutValue takes argumentsV andW. It performs the following steps when called:
ReturnIfAbrupt (V).ReturnIfAbrupt (W).- IfV is not a
Reference Record , throw aReferenceError exception. - If
IsUnresolvableReference (V) istrue , then- IfV.[[Strict]] is
true , throw aReferenceError exception. - LetglobalObj be
GetGlobalObject (). - Return ?
Set (globalObj,V.[[ReferencedName]],W,false ).
- IfV.[[Strict]] is
- If
IsPropertyReference (V) istrue , then- LetbaseObj be !
ToObject (V.[[Base]]). - Letsucceeded be ?baseObj.[[Set]](V.[[ReferencedName]],W,
GetThisValue (V)). - Ifsucceeded is
false andV.[[Strict]] istrue , throw aTypeError exception. - Return.
- LetbaseObj be !
- Else,
- Letbase beV.[[Base]].
Assert :base is anEnvironment Record .- Return ?base.SetMutableBinding(V.[[ReferencedName]],W,V.[[Strict]]) (see
9.1 ).
The object that may be created in step
6.2.4.6 GetThisValue (V )
The abstract operation GetThisValue takes argumentV. It performs the following steps when called:
Assert :IsPropertyReference (V) istrue .- If
IsSuperReference (V) istrue , returnV.[[ThisValue]]; otherwise returnV.[[Base]].
6.2.4.7 InitializeReferencedBinding (V,W )
The abstract operation InitializeReferencedBinding takes argumentsV andW. It performs the following steps when called:
ReturnIfAbrupt (V).ReturnIfAbrupt (W).Assert :V is aReference Record .Assert :IsUnresolvableReference (V) isfalse .- Letbase beV.[[Base]].
Assert :base is anEnvironment Record .- Returnbase.InitializeBinding(V.[[ReferencedName]],W).
6.2.5 The Property Descriptor Specification Type
TheProperty Descriptor type is used to explain the manipulation and reification of Object property attributes. Values of the Property Descriptor type are Records. Each field's name is an attribute name and its value is a corresponding attribute value as specified in
Property Descriptor values may be further classified as data Property Descriptors and accessor Property Descriptors based upon the existence or use of certain fields. A data Property Descriptor is one that includes any fields named either [[Value]] or [[Writable]]. An accessor Property Descriptor is one that includes any fields named either [[Get]] or [[Set]]. Any Property Descriptor may have fields named [[Enumerable]] and [[Configurable]]. A Property Descriptor value may not be both a data Property Descriptor and an accessor Property Descriptor; however, it may be neither. A generic Property Descriptor is a Property Descriptor value that is neither a data Property Descriptor nor an accessor Property Descriptor. A fully populated Property Descriptor is one that is either an accessor Property Descriptor or a data Property Descriptor and that has all of the fields that correspond to the property attributes defined in either
The following
6.2.5.1 IsAccessorDescriptor (Desc )
The abstract operation IsAccessorDescriptor takes argumentDesc (a
- IfDesc is
undefined , returnfalse . - If bothDesc.[[Get]] andDesc.[[Set]] are absent, return
false . - Return
true .
6.2.5.2 IsDataDescriptor (Desc )
The abstract operation IsDataDescriptor takes argumentDesc (a
- IfDesc is
undefined , returnfalse . - If bothDesc.[[Value]] andDesc.[[Writable]] are absent, return
false . - Return
true .
6.2.5.3 IsGenericDescriptor (Desc )
The abstract operation IsGenericDescriptor takes argumentDesc (a
- IfDesc is
undefined , returnfalse . - If
IsAccessorDescriptor (Desc) andIsDataDescriptor (Desc) are bothfalse , returntrue . - Return
false .
6.2.5.4 FromPropertyDescriptor (Desc )
The abstract operation FromPropertyDescriptor takes argumentDesc (a
- IfDesc is
undefined , returnundefined . - Letobj be !
OrdinaryObjectCreate (%Object.prototype% ). Assert :obj is an extensibleordinary object with no own properties.- IfDesc has a [[Value]] field, then
- Perform !
CreateDataPropertyOrThrow (obj,"value" ,Desc.[[Value]]).
- Perform !
- IfDesc has a [[Writable]] field, then
- Perform !
CreateDataPropertyOrThrow (obj,"writable" ,Desc.[[Writable]]).
- Perform !
- IfDesc has a [[Get]] field, then
- Perform !
CreateDataPropertyOrThrow (obj,"get" ,Desc.[[Get]]).
- Perform !
- IfDesc has a [[Set]] field, then
- Perform !
CreateDataPropertyOrThrow (obj,"set" ,Desc.[[Set]]).
- Perform !
- IfDesc has an [[Enumerable]] field, then
- Perform !
CreateDataPropertyOrThrow (obj,"enumerable" ,Desc.[[Enumerable]]).
- Perform !
- IfDesc has a [[Configurable]] field, then
- Perform !
CreateDataPropertyOrThrow (obj,"configurable" ,Desc.[[Configurable]]).
- Perform !
- Returnobj.
6.2.5.5 ToPropertyDescriptor (Obj )
The abstract operation ToPropertyDescriptor takes argumentObj. It performs the following steps when called:
- If
Type (Obj) is not Object, throw aTypeError exception. - Letdesc be a new
Property Descriptor that initially has no fields. - LethasEnumerable be ?
HasProperty (Obj,"enumerable" ). - IfhasEnumerable is
true , then - LethasConfigurable be ?
HasProperty (Obj,"configurable" ). - IfhasConfigurable is
true , then - LethasValue be ?
HasProperty (Obj,"value" ). - IfhasValue is
true , then- Letvalue be ?
Get (Obj,"value" ). - Setdesc.[[Value]] tovalue.
- Letvalue be ?
- LethasWritable be ?
HasProperty (Obj,"writable" ). - IfhasWritable is
true , then - LethasGet be ?
HasProperty (Obj,"get" ). - IfhasGet is
true , then- Letgetter be ?
Get (Obj,"get" ). - If
IsCallable (getter) isfalse andgetter is notundefined , throw aTypeError exception. - Setdesc.[[Get]] togetter.
- Letgetter be ?
- LethasSet be ?
HasProperty (Obj,"set" ). - IfhasSet is
true , then- Letsetter be ?
Get (Obj,"set" ). - If
IsCallable (setter) isfalse andsetter is notundefined , throw aTypeError exception. - Setdesc.[[Set]] tosetter.
- Letsetter be ?
- Ifdesc.[[Get]] is present ordesc.[[Set]] is present, then
- Ifdesc.[[Value]] is present ordesc.[[Writable]] is present, throw a
TypeError exception.
- Ifdesc.[[Value]] is present ordesc.[[Writable]] is present, throw a
- Returndesc.
6.2.5.6 CompletePropertyDescriptor (Desc )
The abstract operation CompletePropertyDescriptor takes argumentDesc (a
Assert :Desc is aProperty Descriptor .- Letlike be the
Record { [[Value]]:undefined , [[Writable]]:false , [[Get]]:undefined , [[Set]]:undefined , [[Enumerable]]:false , [[Configurable]]:false }. - If
IsGenericDescriptor (Desc) istrue orIsDataDescriptor (Desc) istrue , then- IfDesc does not have a [[Value]] field, setDesc.[[Value]] tolike.[[Value]].
- IfDesc does not have a [[Writable]] field, setDesc.[[Writable]] tolike.[[Writable]].
- Else,
- IfDesc does not have a [[Get]] field, setDesc.[[Get]] tolike.[[Get]].
- IfDesc does not have a [[Set]] field, setDesc.[[Set]] tolike.[[Set]].
- IfDesc does not have an [[Enumerable]] field, setDesc.[[Enumerable]] tolike.[[Enumerable]].
- IfDesc does not have a [[Configurable]] field, setDesc.[[Configurable]] tolike.[[Configurable]].
- ReturnDesc.
6.2.6 The Environment Record Specification Type
The
6.2.7 The Abstract Closure Specification Type
TheAbstract Closure specification type is used to refer to algorithm steps together with a collection of values. Abstract Closures are meta-values and are invoked using function application style such asclosure(arg1,arg2). Like
In algorithm steps that create an Abstract Closure, values are captured with the verb "capture" followed by a list of aliases. When an Abstract Closure is created, it captures the value that is associated with each alias at that time. In steps that specify the algorithm to be performed when an Abstract Closure is called, each captured value is referred to by the alias that was used to capture the value.
If an Abstract Closure returns a
Abstract Closures are created inline as part of other algorithms, shown in the following example.
- Letaddend be 41.
- Letclosure be a new
Abstract Closure with parameters (x) that capturesaddend and performs the following steps when called:- Returnx +addend.
- Letval beclosure(1).
Assert :val is 42.
6.2.8 Data Blocks
TheData Block specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. Abyte value is an
For notational convenience within this specification, an array-like syntax can be used to access the individual bytes of a Data Block value. This notation presents a Data Block value as a 0-origined
A data block that resides in memory that can be referenced from multiple agents concurrently is designated aShared Data Block. A Shared Data Block has an identity (for the purposes of equality testing Shared Data Block values) that isaddress-free: it is tied not to the virtual addresses the block is mapped to in any process, but to the set of locations in memory that the block represents. Two data blocks are equal only if the sets of the locations they contain are equal; otherwise, they are not equal and the intersection of the sets of locations they contain is empty. Finally, Shared Data Blocks can be distinguished from Data Blocks.
The semantics of Shared Data Blocks is defined using Shared Data Block events by the
Shared Data Block events are modeled by Records, defined in the
The following
6.2.8.1 CreateByteDataBlock (size )
The abstract operation CreateByteDataBlock takes argumentsize (an
Assert :size ≥ 0.- Letdb be a new
Data Block value consisting ofsize bytes. If it is impossible to create such aData Block , throw aRangeError exception. - Set all of the bytes ofdb to 0.
- Returndb.
6.2.8.2 CreateSharedByteDataBlock (size )
The abstract operation CreateSharedByteDataBlock takes argumentsize (a non-negative
Assert :size ≥ 0.- Letdb be a new
Shared Data Block value consisting ofsize bytes. If it is impossible to create such aShared Data Block , throw aRangeError exception. - Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventList be the [[EventList]] field of the element inexecution.[[EventsRecords]] whose [[AgentSignifier]] is
AgentSignifier (). - Letzero be « 0 ».
- For each indexi ofdb, do
- Append
WriteSharedMemory { [[Order]]:Init , [[NoTear]]:true , [[Block]]:db, [[ByteIndex]]:i, [[ElementSize]]: 1, [[Payload]]:zero } toeventList.
- Append
- Returndb.
6.2.8.3 CopyDataBlockBytes (toBlock,toIndex,fromBlock,fromIndex,count )
The abstract operation CopyDataBlockBytes takes argumentstoBlock,toIndex (a non-negative
Assert :fromBlock andtoBlock are distinctData Block orShared Data Block values.- LetfromSize be the number of bytes infromBlock.
Assert :fromIndex +count ≤fromSize.- LettoSize be the number of bytes intoBlock.
Assert :toIndex +count ≤toSize.- Repeat, whilecount > 0,
- IffromBlock is a
Shared Data Block , then- Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventList be the [[EventList]] field of the element inexecution.[[EventsRecords]] whose [[AgentSignifier]] is
AgentSignifier (). - Letbytes be a
List whose sole element is a nondeterministically chosenbyte value . - NOTE: In implementations,bytes is the result of a non-atomic read instruction on the underlying hardware. The nondeterminism is a semantic prescription of the
memory model to describe observable behaviour of hardware with weak consistency. - LetreadEvent be
ReadSharedMemory { [[Order]]:Unordered , [[NoTear]]:true , [[Block]]:fromBlock, [[ByteIndex]]:fromIndex, [[ElementSize]]: 1 }. - AppendreadEvent toeventList.
- Append
Chosen Value Record { [[Event]]:readEvent, [[ChosenValue]]:bytes } toexecution.[[ChosenValues]]. - IftoBlock is a
Shared Data Block , then- Append
WriteSharedMemory { [[Order]]:Unordered , [[NoTear]]:true , [[Block]]:toBlock, [[ByteIndex]]:toIndex, [[ElementSize]]: 1, [[Payload]]:bytes } toeventList.
- Append
- Else,
- SettoBlock[toIndex] tobytes[0].
- Letexecution be the [[CandidateExecution]] field of the
- Else,
Assert :toBlock is not aShared Data Block .- SettoBlock[toIndex] tofromBlock[fromIndex].
- SettoIndex totoIndex + 1.
- SetfromIndex tofromIndex + 1.
- Setcount tocount - 1.
- IffromBlock is a
- Return
NormalCompletion (empty ).
7 Abstract Operations
These operations are not a part of the ECMAScript language; they are defined here solely to aid the specification of the semantics of the ECMAScript language. Other, more specialized
7.1 Type Conversion
The ECMAScript language implicitly performs automatic type conversion as needed. To clarify the semantics of certain constructs it is useful to define a set of conversion
The BigInt type has no implicit conversions in the ECMAScript language; programmers must call BigInt explicitly to convert values from other types.
7.1.1 ToPrimitive (input [ ,preferredType ] )
The abstract operation ToPrimitive takes argumentinput and optional argumentpreferredType. It converts itsinput argument to a non-Object type. If an object is capable of converting to more than one primitive type, it may use the optional hintpreferredType to favour that type. It performs the following steps when called:
Assert :input is anECMAScript language value .- If
Type (input) is Object, then- LetexoticToPrim be ?
GetMethod (input,@@toPrimitive ). - IfexoticToPrim is not
undefined , then - IfpreferredType is not present, letpreferredType be
number . - Return ?
OrdinaryToPrimitive (input,preferredType).
- LetexoticToPrim be ?
- Returninput.
When ToPrimitive is called with no hint, then it generally behaves as if the hint were
7.1.1.1 OrdinaryToPrimitive (O,hint )
The abstract operation OrdinaryToPrimitive takes argumentsO andhint. It performs the following steps when called:
Assert :Type (O) is Object.Assert :hint is eitherstring ornumber .- Ifhint is
string , then- LetmethodNames be «
"toString" ,"valueOf" ».
- LetmethodNames be «
- Else,
- LetmethodNames be «
"valueOf" ,"toString" ».
- LetmethodNames be «
- For each elementname ofmethodNames, do
- Letmethod be ?
Get (O,name). - If
IsCallable (method) istrue , then
- Letmethod be ?
- Throw a
TypeError exception.
7.1.2 ToBoolean (argument )
The abstract operation ToBoolean takes argumentargument. It convertsargument to a value of type Boolean according to
| Argument Type | Result |
|---|---|
| Undefined | Return |
| Null | Return |
| Boolean | Returnargument. |
| Number | Ifargument is |
| String | Ifargument is the empty String (its length is 0), return |
| Symbol | Return |
| BigInt | Ifargument is |
| Object | Return An alternate algorithm related to the |
7.1.3 ToNumeric (value )
The abstract operation ToNumeric takes argumentvalue. It returnsvalue converted to a Number or a BigInt. It performs the following steps when called:
- LetprimValue be ?
ToPrimitive (value,number ). - If
Type (primValue) is BigInt, returnprimValue. - Return ?
ToNumber (primValue).
7.1.4 ToNumber (argument )
The abstract operation ToNumber takes argumentargument. It convertsargument to a value of type Number according to
| Argument Type | Result |
|---|---|
| Undefined | Return |
| Null | Return |
| Boolean | Ifargument is |
| Number | Returnargument (no conversion). |
| String | See grammar and conversion algorithm below. |
| Symbol | Throw a |
| BigInt | Throw a |
| Object | Apply the following steps:
|
7.1.4.1 ToNumber Applied to the String Type
The terminal symbols of this grammar are all composed of characters in the Unicode Basic Multilingual Plane (BMP). Therefore, the result of
Syntax
All grammar symbols not explicitly defined above have the definitions used in the Lexical Grammar for numeric literals (
Some differences should be noted between the syntax of a
- A
StringNumericLiteral may include leading and/or trailing white space and/or line terminators. - A
StringNumericLiteral that is decimal may have any number of leading0digits. - A
StringNumericLiteral that is decimal may include a+or-to indicate its sign. - A
StringNumericLiteral that is empty or contains only white space is converted to+0 𝔽. Infinityand-Infinityare recognized as aStringNumericLiteral but not as aNumericLiteral .- A
StringNumericLiteral cannot include aBigIntLiteralSuffix .
7.1.4.1.1 Runtime Semantics: MV
The conversion of a String to a
- The MV of
StringNumericLiteral ::: [empty] - The MV of
StringNumericLiteral ::: StrWhiteSpace - The MV of
StringNumericLiteral ::: StrWhiteSpace opt StrNumericLiteral StrWhiteSpace opt StrNumericLiteral , no matter whether white space is present or not. - The MV of
StrDecimalLiteral ::: - StrUnsignedDecimalLiteral StrUnsignedDecimalLiteral . (Note that if the MV ofStrUnsignedDecimalLiteral is 0, the negative of this MV is also 0. The rounding rule described below handles the conversion of this signless mathematical zero to a floating-point+0 𝔽 or-0 𝔽 as appropriate.) - The MV of
StrUnsignedDecimalLiteral ::: Infinity +∞ 𝔽). - The MV of
StrUnsignedDecimalLiteral ::: DecimalDigits . DecimalDigits DecimalDigits plus (the MV of the secondDecimalDigits times 10-n), wheren is the number of code points in the secondDecimalDigits . - The MV of
StrUnsignedDecimalLiteral ::: DecimalDigits . ExponentPart DecimalDigits times 10e, wheree is the MV ofExponentPart . - The MV of
StrUnsignedDecimalLiteral ::: DecimalDigits . DecimalDigits ExponentPart DecimalDigits plus (the MV of the secondDecimalDigits times 10-n)) times 10e, wheren is the number of code points in the secondDecimalDigits ande is the MV ofExponentPart . - The MV of
StrUnsignedDecimalLiteral ::: . DecimalDigits DecimalDigits times 10-n, wheren is the number of code points inDecimalDigits . - The MV of
StrUnsignedDecimalLiteral ::: . DecimalDigits ExponentPart DecimalDigits times 10e -n, wheren is the number of code points inDecimalDigits ande is the MV ofExponentPart . - The MV of
StrUnsignedDecimalLiteral ::: DecimalDigits ExponentPart DecimalDigits times 10e, wheree is the MV ofExponentPart .
Once the exact MV for a String numeric literal has been determined, it is then rounded to a value of the Number type. If the MV is 0, then the rounded value is-, in which case the rounded value is
- it is not
0; or - there is a non-zero digit to its left and there is a non-zero digit, not in the
ExponentPart , to its right.
7.1.5 ToIntegerOrInfinity (argument )
The abstract operation ToIntegerOrInfinity takes argumentargument. It convertsargument to an
7.1.6 ToInt32 (argument )
The abstract operation ToInt32 takes argumentargument. It convertsargument to one of 232
Given the above definition of ToInt32:
- The ToInt32 abstract operation is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
- ToInt32(
ToUint32 (x)) is the same value as ToInt32(x) for all values ofx. (It is to preserve this latter property that+∞ 𝔽 and-∞ 𝔽 are mapped to+0 𝔽.) - ToInt32 maps
-0 𝔽 to+0 𝔽.
7.1.7 ToUint32 (argument )
The abstract operation ToUint32 takes argumentargument. It convertsargument to one of 232
Given the above definition of ToUint32:
- Step
5 is the only difference between ToUint32 andToInt32 . - The ToUint32 abstract operation is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
- ToUint32(
ToInt32 (x)) is the same value as ToUint32(x) for all values ofx. (It is to preserve this latter property that+∞ 𝔽 and-∞ 𝔽 are mapped to+0 𝔽.) - ToUint32 maps
-0 𝔽 to+0 𝔽.
7.1.8 ToInt16 (argument )
The abstract operation ToInt16 takes argumentargument. It convertsargument to one of 216
7.1.9 ToUint16 (argument )
The abstract operation ToUint16 takes argumentargument. It convertsargument to one of 216
7.1.10 ToInt8 (argument )
The abstract operation ToInt8 takes argumentargument. It convertsargument to one of 28
7.1.11 ToUint8 (argument )
The abstract operation ToUint8 takes argumentargument. It convertsargument to one of 28
7.1.12 ToUint8Clamp (argument )
The abstract operation ToUint8Clamp takes argumentargument. It convertsargument to one of 28
Unlike the other ECMAScriptMath.round which does “round half up” tie-breaking.
7.1.13 ToBigInt (argument )
The abstract operation ToBigInt takes argumentargument. It convertsargument to a BigInt value, or throws if an implicit conversion from Number would be required. It performs the following steps when called:
- Letprim be ?
ToPrimitive (argument,number ). - Return the value thatprim corresponds to in
Table 13 .
| Argument Type | Result |
|---|---|
| Undefined | Throw a |
| Null | Throw a |
| Boolean | Return1n ifprim is0n ifprim is |
| BigInt | Returnprim. |
| Number | Throw a |
| String |
|
| Symbol | Throw a |
7.1.14 StringToBigInt (argument )
Apply the algorithm in
- Replace the
StrUnsignedDecimalLiteral production withDecimalDigits to not allowInfinity , decimal points, or exponents. - If the MV is
NaN , returnNaN , otherwise return the BigInt which exactly corresponds to the MV, rather than rounding to a Number.
7.1.15 ToBigInt64 (argument )
The abstract operation ToBigInt64 takes argumentargument. It convertsargument to one of 264 BigInt values in the range
7.1.16 ToBigUint64 (argument )
The abstract operation ToBigUint64 takes argumentargument. It convertsargument to one of 264 BigInt values in the range
7.1.17 ToString (argument )
The abstract operation ToString takes argumentargument. It convertsargument to a value of type String according to
| Argument Type | Result |
|---|---|
| Undefined | Return |
| Null | Return |
| Boolean | Ifargument is Ifargument is |
| Number | Return ! |
| String | Returnargument. |
| Symbol | Throw a |
| BigInt | Return ! |
| Object | Apply the following steps:
|
7.1.18 ToObject (argument )
The abstract operation ToObject takes argumentargument. It convertsargument to a value of type Object according to
| Argument Type | Result |
|---|---|
| Undefined | Throw a |
| Null | Throw a |
| Boolean | Return a new Boolean object whose [[BooleanData]] internal slot is set toargument. See |
| Number | Return a new Number object whose [[NumberData]] internal slot is set toargument. See |
| String | Return a new String object whose [[StringData]] internal slot is set toargument. See |
| Symbol | Return a new Symbol object whose [[SymbolData]] internal slot is set toargument. See |
| BigInt | Return a new BigInt object whose [[BigIntData]] internal slot is set toargument. See |
| Object | Returnargument. |
7.1.19 ToPropertyKey (argument )
The abstract operation ToPropertyKey takes argumentargument. It convertsargument to a value that can be used as a property key. It performs the following steps when called:
- Letkey be ?
ToPrimitive (argument,string ). - If
Type (key) is Symbol, then- Returnkey.
- Return !
ToString (key).
7.1.20 ToLength (argument )
The abstract operation ToLength takes argumentargument. It convertsargument to an
- Letlen be ?
ToIntegerOrInfinity (argument). - Iflen ≤ 0, return
+0 𝔽. - Return
𝔽 (min (len, 253 - 1)).
7.1.21 CanonicalNumericIndexString (argument )
The abstract operation CanonicalNumericIndexString takes argumentargument. It returnsargument converted to a
Acanonical numeric string is any String value for which the CanonicalNumericIndexString abstract operation does not return
7.1.22 ToIndex (value )
The abstract operation ToIndex takes argumentvalue. It returnsvalue argument converted to a non-negative
- Ifvalue is
undefined , then- Return 0.
- Else,
- LetintegerIndex be
𝔽 (?ToIntegerOrInfinity (value)). - IfintegerIndex <
+0 𝔽, throw aRangeError exception. - Letindex be !
ToLength (integerIndex). - If !
SameValue (integerIndex,index) isfalse , throw aRangeError exception. - Return
ℝ (index).
- LetintegerIndex be
7.2 Testing and Comparison Operations
7.2.1 RequireObjectCoercible (argument )
The abstract operation RequireObjectCoercible takes argumentargument. It throws an error ifargument is a value that cannot be converted to an Object using
| Argument Type | Result |
|---|---|
| Undefined | Throw a |
| Null | Throw a |
| Boolean | Returnargument. |
| Number | Returnargument. |
| String | Returnargument. |
| Symbol | Returnargument. |
| BigInt | Returnargument. |
| Object | Returnargument. |
7.2.2 IsArray (argument )
The abstract operation IsArray takes argumentargument. It performs the following steps when called:
- If
Type (argument) is not Object, returnfalse . - Ifargument is an
Array exotic object , returntrue . - Ifargument is a
Proxy exotic object , then- Ifargument.[[ProxyHandler]] is
null , throw aTypeError exception. - Lettarget beargument.[[ProxyTarget]].
- Return ?
IsArray (target).
- Ifargument.[[ProxyHandler]] is
- Return
false .
7.2.3 IsCallable (argument )
The abstract operation IsCallable takes argumentargument (an
- If
Type (argument) is not Object, returnfalse . - Ifargument has a [[Call]] internal method, return
true . - Return
false .
7.2.4 IsConstructor (argument )
The abstract operation IsConstructor takes argumentargument (an
- If
Type (argument) is not Object, returnfalse . - Ifargument has a [[Construct]] internal method, return
true . - Return
false .
7.2.5 IsExtensible (O )
The abstract operation IsExtensible takes argumentO (an Object) and returns a completion record which, if its [[Type]] is
7.2.6 IsIntegralNumber (argument )
The abstract operation IsIntegralNumber takes argumentargument. It determines ifargument is a finite
7.2.7 IsPropertyKey (argument )
The abstract operation IsPropertyKey takes argumentargument (an
7.2.8 IsRegExp (argument )
The abstract operation IsRegExp takes argumentargument. It performs the following steps when called:
7.2.9 IsStringPrefix (p,q )
The abstract operation IsStringPrefix takes argumentsp (a String) andq (a String). It determines ifp is a prefix ofq. It performs the following steps when called:
Assert :Type (p) is String.Assert :Type (q) is String.- Ifq can be the
string-concatenation ofp and some other Stringr, returntrue . Otherwise, returnfalse .
Any String is a prefix of itself, becauser may be the empty String.
7.2.10 SameValue (x,y )
The abstract operation SameValue takes argumentsx (an
- If
Type (x) is different fromType (y), returnfalse . - If
Type (x) is Number or BigInt, then- Return !
Type (x)::sameValue(x,y).
- Return !
- Return !
SameValueNonNumeric (x,y).
This algorithm differs from the
7.2.11 SameValueZero (x,y )
The abstract operation SameValueZero takes argumentsx (an
- If
Type (x) is different fromType (y), returnfalse . - If
Type (x) is Number or BigInt, then- Return !
Type (x)::sameValueZero(x,y).
- Return !
- Return !
SameValueNonNumeric (x,y).
SameValueZero differs from
7.2.12 SameValueNonNumeric (x,y )
The abstract operation SameValueNonNumeric takes argumentsx (an
Assert :Type (x) is not Number or BigInt.Assert :Type (x) is the same asType (y).- If
Type (x) is Undefined, returntrue . - If
Type (x) is Null, returntrue . - If
Type (x) is String, then- Ifx andy are exactly the same sequence of code units (same length and same code units at corresponding indices), return
true ; otherwise, returnfalse .
- Ifx andy are exactly the same sequence of code units (same length and same code units at corresponding indices), return
- If
Type (x) is Boolean, then- Ifx andy are both
true or bothfalse , returntrue ; otherwise, returnfalse .
- Ifx andy are both
- If
Type (x) is Symbol, then- Ifx andy are both the same Symbol value, return
true ; otherwise, returnfalse .
- Ifx andy are both the same Symbol value, return
- Ifx andy are the same Object value, return
true . Otherwise, returnfalse .
7.2.13 Abstract Relational Comparison
The comparisonx <y, wherex andy are values, produces
- If theLeftFirst flag is
true , then- Letpx be ?
ToPrimitive (x,number ). - Letpy be ?
ToPrimitive (y,number ).
- Letpx be ?
- Else,
- NOTE: The order of evaluation needs to be reversed to preserve left to right evaluation.
- Letpy be ?
ToPrimitive (y,number ). - Letpx be ?
ToPrimitive (x,number ).
- If
Type (px) is String andType (py) is String, then- If
IsStringPrefix (py,px) istrue , returnfalse . - If
IsStringPrefix (px,py) istrue , returntrue . - Letk be the smallest non-negative
integer such that the code unit at indexk withinpx is different from the code unit at indexk withinpy. (There must be such ak, for neither String is a prefix of the other.) - Letm be the
integer that is the numeric value of the code unit at indexk withinpx. - Letn be the
integer that is the numeric value of the code unit at indexk withinpy. - Ifm <n, return
true . Otherwise, returnfalse .
- If
- Else,
- If
Type (px) is BigInt andType (py) is String, then- Letny be !
StringToBigInt (py). - Ifny is
NaN , returnundefined . - Return BigInt::lessThan(px,ny).
- Letny be !
- If
Type (px) is String andType (py) is BigInt, then- Letnx be !
StringToBigInt (px). - Ifnx is
NaN , returnundefined . - Return BigInt::lessThan(nx,py).
- Letnx be !
- NOTE: Becausepx andpy are primitive values, evaluation order is not important.
- Letnx be !
ToNumeric (px). - Letny be !
ToNumeric (py). - If
Type (nx) is the same asType (ny), returnType (nx)::lessThan(nx,ny). Assert :Type (nx) is BigInt andType (ny) is Number, orType (nx) is Number andType (ny) is BigInt.- Ifnx orny is
NaN , returnundefined . - Ifnx is
-∞ 𝔽 orny is+∞ 𝔽, returntrue . - Ifnx is
+∞ 𝔽 orny is-∞ 𝔽, returnfalse . - If
ℝ (nx) <ℝ (ny), returntrue ; otherwise returnfalse .
- If
The comparison of Strings uses a simple lexicographic ordering on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore String values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form. Also, note that for strings containing supplementary characters, lexicographic ordering on sequences of UTF-16 code unit values differs from that on sequences of code point values.
7.2.14 Abstract Equality Comparison
The comparisonx ==y, wherex andy are values, produces
- If
Type (x) is the same asType (y), then- Return the result of performing
Strict Equality Comparison x ===y.
- Return the result of performing
- Ifx is
null andy isundefined , returntrue . - Ifx is
undefined andy isnull , returntrue . - NOTE: This step is replaced in section
B.3.7.2 . - If
Type (x) is Number andType (y) is String, return the result of the comparisonx == !ToNumber (y). - If
Type (x) is String andType (y) is Number, return the result of the comparison !ToNumber (x) ==y. - If
Type (x) is BigInt andType (y) is String, then- Letn be !
StringToBigInt (y). - Ifn is
NaN , returnfalse . - Return the result of the comparisonx ==n.
- Letn be !
- If
Type (x) is String andType (y) is BigInt, return the result of the comparisony ==x. - If
Type (x) is Boolean, return the result of the comparison !ToNumber (x) ==y. - If
Type (y) is Boolean, return the result of the comparisonx == !ToNumber (y). - If
Type (x) is either String, Number, BigInt, or Symbol andType (y) is Object, return the result of the comparisonx == ?ToPrimitive (y). - If
Type (x) is Object andType (y) is either String, Number, BigInt, or Symbol, return the result of the comparison ?ToPrimitive (x) ==y. - If
Type (x) is BigInt andType (y) is Number, or ifType (x) is Number andType (y) is BigInt, then - Return
false .
7.2.15 Strict Equality Comparison
The comparisonx ===y, wherex andy are values, produces
- If
Type (x) is different fromType (y), returnfalse . - If
Type (x) is Number or BigInt, then- Return !
Type (x)::equal(x,y).
- Return !
- Return !
SameValueNonNumeric (x,y).
This algorithm differs from the
7.3 Operations on Objects
7.3.1 MakeBasicObject (internalSlotsList )
The abstract operation MakeBasicObject takes argumentinternalSlotsList. It is the source of all ECMAScript objects that are created algorithmically, including both ordinary objects and exotic objects. It factors out common steps used in creating all objects, and centralizes object creation. It performs the following steps when called:
Assert :internalSlotsList is aList of internal slot names.- Letobj be a newly created object with an internal slot for each name ininternalSlotsList.
- Setobj's essential internal methods to the default
ordinary object definitions specified in10.1 . Assert : If the caller will not be overriding bothobj's [[GetPrototypeOf]] and [[SetPrototypeOf]] essential internal methods, theninternalSlotsList contains [[Prototype]].Assert : If the caller will not be overriding all ofobj's [[SetPrototypeOf]], [[IsExtensible]], and [[PreventExtensions]] essential internal methods, theninternalSlotsList contains [[Extensible]].- IfinternalSlotsList contains [[Extensible]], setobj.[[Extensible]] to
true . - Returnobj.
Within this specification, exotic objects are created in
7.3.2 Get (O,P )
The abstract operation Get takes argumentsO (an Object) andP (a property key). It is used to retrieve the value of a specific property of an object. It performs the following steps when called:
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- Return ?O.[[Get]](P,O).
7.3.3 GetV (V,P )
The abstract operation GetV takes argumentsV (an
Assert :IsPropertyKey (P) istrue .- LetO be ?
ToObject (V). - Return ?O.[[Get]](P,V).
7.3.4 Set (O,P,V,Throw )
The abstract operation Set takes argumentsO (an Object),P (a property key),V (an
7.3.5 CreateDataProperty (O,P,V )
The abstract operation CreateDataProperty takes argumentsO (an Object),P (a property key), andV (an
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- LetnewDesc be the PropertyDescriptor { [[Value]]:V, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:true }. - Return ?O.[[DefineOwnProperty]](P,newDesc).
This abstract operation creates a property whose attributes are set to the same defaults used for properties created by the ECMAScript language assignment operator. Normally, the property will not already exist. If it does exist and is not configurable or ifO is not extensible, [[DefineOwnProperty]] will return
7.3.6 CreateMethodProperty (O,P,V )
The abstract operation CreateMethodProperty takes argumentsO (an Object),P (a property key), andV (an
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- LetnewDesc be the PropertyDescriptor { [[Value]]:V, [[Writable]]:
true , [[Enumerable]]:false , [[Configurable]]:true }. - Return ?O.[[DefineOwnProperty]](P,newDesc).
This abstract operation creates a property whose attributes are set to the same defaults used for built-in methods and methods defined using class declaration syntax. Normally, the property will not already exist. If it does exist and is not configurable or ifO is not extensible, [[DefineOwnProperty]] will return
7.3.7 CreateDataPropertyOrThrow (O,P,V )
The abstract operation CreateDataPropertyOrThrow takes argumentsO (an Object),P (a property key), andV (an
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- Letsuccess be ?
CreateDataProperty (O,P,V). - Ifsuccess is
false , throw aTypeError exception. - Returnsuccess.
This abstract operation creates a property whose attributes are set to the same defaults used for properties created by the ECMAScript language assignment operator. Normally, the property will not already exist. If it does exist and is not configurable or ifO is not extensible, [[DefineOwnProperty]] will return
7.3.8 DefinePropertyOrThrow (O,P,desc )
The abstract operation DefinePropertyOrThrow takes argumentsO (an Object),P (a property key), anddesc (a
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- Letsuccess be ?O.[[DefineOwnProperty]](P,desc).
- Ifsuccess is
false , throw aTypeError exception. - Returnsuccess.
7.3.9 DeletePropertyOrThrow (O,P )
The abstract operation DeletePropertyOrThrow takes argumentsO (an Object) andP (a property key). It is used to remove a specific own property of an object. It throws an exception if the property is not configurable. It performs the following steps when called:
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- Letsuccess be ?O.[[Delete]](P).
- Ifsuccess is
false , throw aTypeError exception. - Returnsuccess.
7.3.10 GetMethod (V,P )
The abstract operation GetMethod takes argumentsV (an
Assert :IsPropertyKey (P) istrue .- Letfunc be ?
GetV (V,P). - Iffunc is either
undefined ornull , returnundefined . - If
IsCallable (func) isfalse , throw aTypeError exception. - Returnfunc.
7.3.11 HasProperty (O,P )
The abstract operation HasProperty takes argumentsO (an Object) andP (a property key) and returns a completion record which, if its [[Type]] is
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- Return ?O.[[HasProperty]](P).
7.3.12 HasOwnProperty (O,P )
The abstract operation HasOwnProperty takes argumentsO (an Object) andP (a property key) and returns a completion record which, if its [[Type]] is
Assert :Type (O) is Object.Assert :IsPropertyKey (P) istrue .- Letdesc be ?O.[[GetOwnProperty]](P).
- Ifdesc is
undefined , returnfalse . - Return
true .
7.3.13 Call (F,V [ ,argumentsList ] )
The abstract operation Call takes argumentsF (an
- IfargumentsList is not present, setargumentsList to a new empty
List . - If
IsCallable (F) isfalse , throw aTypeError exception. - Return ?F.[[Call]](V,argumentsList).
7.3.14 Construct (F [ ,argumentsList [ ,newTarget ] ] )
The abstract operation Construct takes argumentF (a
- IfnewTarget is not present, setnewTarget toF.
- IfargumentsList is not present, setargumentsList to a new empty
List . Assert :IsConstructor (F) istrue .Assert :IsConstructor (newTarget) istrue .- Return ?F.[[Construct]](argumentsList,newTarget).
IfnewTarget is not present, this operation is equivalent to:new F(...argumentsList)
7.3.15 SetIntegrityLevel (O,level )
The abstract operation SetIntegrityLevel takes argumentsO andlevel. It is used to fix the set of own properties of an object. It performs the following steps when called:
Assert :Type (O) is Object.Assert :level is eithersealed orfrozen .- Letstatus be ?O.[[PreventExtensions]]().
- Ifstatus is
false , returnfalse . - Letkeys be ?O.[[OwnPropertyKeys]]().
- Iflevel is
sealed , then- For each elementk ofkeys, do
- Perform ?
DefinePropertyOrThrow (O,k, PropertyDescriptor { [[Configurable]]:false }).
- Perform ?
- For each elementk ofkeys, do
- Else,
Assert :level isfrozen .- For each elementk ofkeys, do
- LetcurrentDesc be ?O.[[GetOwnProperty]](k).
- IfcurrentDesc is not
undefined , then- If
IsAccessorDescriptor (currentDesc) istrue , then- Letdesc be the PropertyDescriptor { [[Configurable]]:
false }.
- Letdesc be the PropertyDescriptor { [[Configurable]]:
- Else,
- Letdesc be the PropertyDescriptor { [[Configurable]]:
false , [[Writable]]:false }.
- Letdesc be the PropertyDescriptor { [[Configurable]]:
- Perform ?
DefinePropertyOrThrow (O,k,desc).
- If
- Return
true .
7.3.16 TestIntegrityLevel (O,level )
The abstract operation TestIntegrityLevel takes argumentsO andlevel. It is used to determine if the set of own properties of an object are fixed. It performs the following steps when called:
Assert :Type (O) is Object.Assert :level is eithersealed orfrozen .- Letextensible be ?
IsExtensible (O). - Ifextensible is
true , returnfalse . - NOTE: If the object is extensible, none of its properties are examined.
- Letkeys be ?O.[[OwnPropertyKeys]]().
- For each elementk ofkeys, do
- LetcurrentDesc be ?O.[[GetOwnProperty]](k).
- IfcurrentDesc is not
undefined , then- IfcurrentDesc.[[Configurable]] is
true , returnfalse . - Iflevel is
frozen andIsDataDescriptor (currentDesc) istrue , then- IfcurrentDesc.[[Writable]] is
true , returnfalse .
- IfcurrentDesc.[[Writable]] is
- IfcurrentDesc.[[Configurable]] is
- Return
true .
7.3.17 CreateArrayFromList (elements )
The abstract operation CreateArrayFromList takes argumentelements (a
Assert :elements is aList whose elements are all ECMAScript language values.- Letarray be !
ArrayCreate (0). - Letn be 0.
- For each elemente ofelements, do
- Perform !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (n)),e). - Setn ton + 1.
- Perform !
- Returnarray.
7.3.18 LengthOfArrayLike (obj )
The abstract operation LengthOfArrayLike takes argumentobj. It returns the value of the
Anarray-like object is any object for which this operation returns an
7.3.19 CreateListFromArrayLike (obj [ ,elementTypes ] )
The abstract operation CreateListFromArrayLike takes argumentobj and optional argumentelementTypes (a
- IfelementTypes is not present, setelementTypes to « Undefined, Null, Boolean, String, Symbol, Number, BigInt, Object ».
- If
Type (obj) is not Object, throw aTypeError exception. - Letlen be ?
LengthOfArrayLike (obj). - Letlist be a new empty
List . - Letindex be 0.
- Repeat, whileindex <len,
- Returnlist.
7.3.20 Invoke (V,P [ ,argumentsList ] )
The abstract operation Invoke takes argumentsV (an
Assert :IsPropertyKey (P) istrue .- IfargumentsList is not present, setargumentsList to a new empty
List . - Letfunc be ?
GetV (V,P). - Return ?
Call (func,V,argumentsList).
7.3.21 OrdinaryHasInstance (C,O )
The abstract operation OrdinaryHasInstance takes argumentsC (an
- If
IsCallable (C) isfalse , returnfalse . - IfC has a [[BoundTargetFunction]] internal slot, then
- LetBC beC.[[BoundTargetFunction]].
- Return ?
InstanceofOperator (O,BC).
- If
Type (O) is not Object, returnfalse . - LetP be ?
Get (C,"prototype" ). - If
Type (P) is not Object, throw aTypeError exception. - Repeat,
- SetO to ?O.[[GetPrototypeOf]]().
- IfO is
null , returnfalse . - If
SameValue (P,O) istrue , returntrue .
7.3.22 SpeciesConstructor (O,defaultConstructor )
The abstract operation SpeciesConstructor takes argumentsO (an Object) anddefaultConstructor (a
7.3.23 EnumerableOwnPropertyNames (O,kind )
The abstract operation EnumerableOwnPropertyNames takes argumentsO (an Object) andkind (one of
Assert :Type (O) is Object.- LetownKeys be ?O.[[OwnPropertyKeys]]().
- Letproperties be a new empty
List . - For each elementkey ofownKeys, do
- If
Type (key) is String, then- Letdesc be ?O.[[GetOwnProperty]](key).
- Ifdesc is not
undefined anddesc.[[Enumerable]] istrue , then- Ifkind is
key , appendkey toproperties. - Else,
- Letvalue be ?
Get (O,key). - Ifkind is
value , appendvalue toproperties. - Else,
Assert :kind iskey+value .- Letentry be !
CreateArrayFromList («key,value »). - Appendentry toproperties.
- Letvalue be ?
- Ifkind is
- If
- Returnproperties.
7.3.24 GetFunctionRealm (obj )
The abstract operation GetFunctionRealm takes argumentobj. It performs the following steps when called:
Assert : !IsCallable (obj) istrue .- Ifobj has a [[Realm]] internal slot, then
- Returnobj.[[Realm]].
- Ifobj is a
bound function exotic object , then- Lettarget beobj.[[BoundTargetFunction]].
- Return ?
GetFunctionRealm (target).
- Ifobj is a
Proxy exotic object , then- Ifobj.[[ProxyHandler]] is
null , throw aTypeError exception. - LetproxyTarget beobj.[[ProxyTarget]].
- Return ?
GetFunctionRealm (proxyTarget).
- Ifobj.[[ProxyHandler]] is
- Return
the current Realm Record .
Step
7.3.25 CopyDataProperties (target,source,excludedItems )
The abstract operation CopyDataProperties takes argumentstarget,source, andexcludedItems. It performs the following steps when called:
Assert :Type (target) is Object.Assert :excludedItems is aList of property keys.- Ifsource is
undefined ornull , returntarget. - Letfrom be !
ToObject (source). - Letkeys be ?from.[[OwnPropertyKeys]]().
- For each elementnextKey ofkeys, do
- Letexcluded be
false . - For each elemente ofexcludedItems, do
- If
SameValue (e,nextKey) istrue , then- Setexcluded to
true .
- Setexcluded to
- If
- Ifexcluded is
false , then- Letdesc be ?from.[[GetOwnProperty]](nextKey).
- Ifdesc is not
undefined anddesc.[[Enumerable]] istrue , then- LetpropValue be ?
Get (from,nextKey). - Perform !
CreateDataPropertyOrThrow (target,nextKey,propValue).
- LetpropValue be ?
- Letexcluded be
- Returntarget.
The target passed in here is always a newly created object which is not directly accessible in case of an error being thrown.
7.4 Operations on Iterator Objects
See Common Iteration Interfaces (
7.4.1 GetIterator (obj [ ,hint [ ,method ] ] )
The abstract operation GetIterator takes argumentobj and optional argumentshint andmethod. It performs the following steps when called:
- Ifhint is not present, sethint to
sync . Assert :hint is eithersync orasync .- Ifmethod is not present, then
- Ifhint is
async , then- Setmethod to ?
GetMethod (obj,@@asyncIterator ). - Ifmethod is
undefined , then- LetsyncMethod be ?
GetMethod (obj,@@iterator ). - LetsyncIteratorRecord be ?
GetIterator (obj,sync ,syncMethod). - Return !
CreateAsyncFromSyncIterator (syncIteratorRecord).
- LetsyncMethod be ?
- Setmethod to ?
- Otherwise, setmethod to ?
GetMethod (obj,@@iterator ).
- Ifhint is
- Letiterator be ?
Call (method,obj). - If
Type (iterator) is not Object, throw aTypeError exception. - LetnextMethod be ?
GetV (iterator,"next" ). - LetiteratorRecord be the
Record { [[Iterator]]:iterator, [[NextMethod]]:nextMethod, [[Done]]:false }. - ReturniteratorRecord.
7.4.2 IteratorNext (iteratorRecord [ ,value ] )
The abstract operation IteratorNext takes argumentiteratorRecord and optional argumentvalue. It performs the following steps when called:
7.4.3 IteratorComplete (iterResult )
The abstract operation IteratorComplete takes argumentiterResult. It performs the following steps when called:
7.4.4 IteratorValue (iterResult )
The abstract operation IteratorValue takes argumentiterResult. It performs the following steps when called:
7.4.5 IteratorStep (iteratorRecord )
The abstract operation IteratorStep takes argumentiteratorRecord. It requests the next value fromiteratorRecord.[[Iterator]] by callingiteratorRecord.[[NextMethod]] and returns either
- Letresult be ?
IteratorNext (iteratorRecord). - Letdone be ?
IteratorComplete (result). - Ifdone is
true , returnfalse . - Returnresult.
7.4.6 IteratorClose (iteratorRecord,completion )
The abstract operation IteratorClose takes argumentsiteratorRecord andcompletion. It is used to notify an iterator that it should perform any actions it would normally perform when it has reached its completed state. It performs the following steps when called:
Assert :Type (iteratorRecord.[[Iterator]]) is Object.Assert :completion is aCompletion Record .- Letiterator beiteratorRecord.[[Iterator]].
- LetinnerResult be
GetMethod (iterator,"return" ). - IfinnerResult.[[Type]] is
normal , then- Letreturn beinnerResult.[[Value]].
- Ifreturn is
undefined , returnCompletion (completion). - SetinnerResult to
Call (return,iterator).
- Ifcompletion.[[Type]] is
throw , returnCompletion (completion). - IfinnerResult.[[Type]] is
throw , returnCompletion (innerResult). - If
Type (innerResult.[[Value]]) is not Object, throw aTypeError exception. - Return
Completion (completion).
7.4.7 AsyncIteratorClose (iteratorRecord,completion )
The abstract operation AsyncIteratorClose takes argumentsiteratorRecord andcompletion. It is used to notify an async iterator that it should perform any actions it would normally perform when it has reached its completed state. It performs the following steps when called:
Assert :Type (iteratorRecord.[[Iterator]]) is Object.Assert :completion is aCompletion Record .- Letiterator beiteratorRecord.[[Iterator]].
- LetinnerResult be
GetMethod (iterator,"return" ). - IfinnerResult.[[Type]] is
normal , then- Letreturn beinnerResult.[[Value]].
- Ifreturn is
undefined , returnCompletion (completion). - SetinnerResult to
Call (return,iterator). - IfinnerResult.[[Type]] is
normal , setinnerResult toAwait (innerResult.[[Value]]).
- Ifcompletion.[[Type]] is
throw , returnCompletion (completion). - IfinnerResult.[[Type]] is
throw , returnCompletion (innerResult). - If
Type (innerResult.[[Value]]) is not Object, throw aTypeError exception. - Return
Completion (completion).
7.4.8 CreateIterResultObject (value,done )
The abstract operation CreateIterResultObject takes argumentsvalue anddone. It creates an object that supports the IteratorResult interface. It performs the following steps when called:
Assert :Type (done) is Boolean.- Letobj be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform !
CreateDataPropertyOrThrow (obj,"value" ,value). - Perform !
CreateDataPropertyOrThrow (obj,"done" ,done). - Returnobj.
7.4.9 CreateListIteratorRecord (list )
The abstract operation CreateListIteratorRecord takes argumentlist. It creates an Iterator (
- Letclosure be a new
Abstract Closure with no parameters that captureslist and performs the following steps when called:- For each elementE oflist, do
- Perform ?
Yield (E).
- Perform ?
- Return
undefined .
- For each elementE oflist, do
- Letiterator be !
CreateIteratorFromClosure (closure,empty ,%IteratorPrototype% ). - Return
Record { [[Iterator]]:iterator, [[NextMethod]]: %GeneratorFunction.prototype.prototype.next%, [[Done]]:false }.
The list iterator object is never directly accessible to ECMAScript code.
7.4.10 IterableToList (items [ ,method ] )
The abstract operation IterableToList takes argumentitems and optional argumentmethod. It performs the following steps when called:
- Ifmethod is present, then
- LetiteratorRecord be ?
GetIterator (items,sync ,method).
- LetiteratorRecord be ?
- Else,
- LetiteratorRecord be ?
GetIterator (items,sync ).
- LetiteratorRecord be ?
- Letvalues be a new empty
List . - Letnext be
true . - Repeat, whilenext is not
false ,- Setnext to ?
IteratorStep (iteratorRecord). - Ifnext is not
false , then- LetnextValue be ?
IteratorValue (next). - AppendnextValue to the end of the
List values.
- LetnextValue be ?
- Setnext to ?
- Returnvalues.
8 Syntax-Directed Operations
In addition to those defined in this section, specialized syntax-directed operations are defined throughout this specification.
8.1 Scope Analysis
8.1.1 Static Semantics: BoundNames
- Return a
List whose sole element is theStringValue ofIdentifier .
- Return a
List whose sole element is"yield" .
- Return a
List whose sole element is"await" .
- Return the
BoundNames ofBindingList .
- Letnames be the
BoundNames ofBindingList . - Append tonames the elements of the
BoundNames ofLexicalBinding . - Returnnames.
- Return the
BoundNames ofBindingIdentifier .
- Return the
BoundNames ofBindingPattern .
- Letnames be
BoundNames ofVariableDeclarationList . - Append tonames the elements of
BoundNames ofVariableDeclaration . - Returnnames.
- Return the
BoundNames ofBindingIdentifier .
- Return the
BoundNames ofBindingPattern .
- Return a new empty
List .
- Letnames be
BoundNames ofBindingPropertyList . - Append tonames the elements of
BoundNames ofBindingRestProperty . - Returnnames.
- Return a new empty
List .
- Return the
BoundNames ofBindingRestElement .
- Return the
BoundNames ofBindingElementList .
- Letnames be
BoundNames ofBindingElementList . - Append tonames the elements of
BoundNames ofBindingRestElement . - Returnnames.
- Letnames be
BoundNames ofBindingPropertyList . - Append tonames the elements of
BoundNames ofBindingProperty . - Returnnames.
- Letnames be
BoundNames ofBindingElementList . - Append tonames the elements of
BoundNames ofBindingElisionElement . - Returnnames.
- Return
BoundNames ofBindingElement .
- Return the
BoundNames ofBindingElement .
- Return the
BoundNames ofBindingIdentifier .
- Return the
BoundNames ofBindingPattern .
- Return the
BoundNames ofForBinding .
- Return the
BoundNames ofBindingIdentifier .
- Return «
"*default*" ».
- Return a new empty
List .
- Letnames be
BoundNames ofFormalParameterList . - Append tonames the
BoundNames ofFunctionRestParameter . - Returnnames.
- Letnames be
BoundNames ofFormalParameterList . - Append tonames the
BoundNames ofFormalParameter . - Returnnames.
- Letformals be
CoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList . - Return the
BoundNames offormals.
- Return the
BoundNames ofBindingIdentifier .
- Return «
"*default*" ».
- Return the
BoundNames ofBindingIdentifier .
- Return «
"*default*" ».
- Return the
BoundNames ofBindingIdentifier .
- Return «
"*default*" ».
- Return the
BoundNames ofBindingIdentifier .
- Return «
"*default*" ».
- Lethead be
CoveredAsyncArrowHead ofCoverCallExpressionAndAsyncArrowHead . - Return the
BoundNames ofhead.
- Return the
BoundNames ofImportClause .
- Return a new empty
List .
- Letnames be the
BoundNames ofImportedDefaultBinding . - Append tonames the elements of the
BoundNames ofNameSpaceImport . - Returnnames.
- Letnames be the
BoundNames ofImportedDefaultBinding . - Append tonames the elements of the
BoundNames ofNamedImports . - Returnnames.
- Return a new empty
List .
- Letnames be the
BoundNames ofImportsList . - Append tonames the elements of the
BoundNames ofImportSpecifier . - Returnnames.
- Return the
BoundNames ofImportedBinding .
- Return a new empty
List .
- Return the
BoundNames ofVariableStatement .
- Return the
BoundNames ofDeclaration .
- LetdeclarationNames be the
BoundNames ofHoistableDeclaration . - IfdeclarationNames does not include the element
"*default*" , append"*default*" todeclarationNames. - ReturndeclarationNames.
- LetdeclarationNames be the
BoundNames ofClassDeclaration . - IfdeclarationNames does not include the element
"*default*" , append"*default*" todeclarationNames. - ReturndeclarationNames.
- Return «
"*default*" ».
8.1.2 Static Semantics: DeclarationPart
- Return
FunctionDeclaration .
- Return
GeneratorDeclaration .
- Return
AsyncFunctionDeclaration .
- Return
AsyncGeneratorDeclaration .
- Return
ClassDeclaration .
- Return
LexicalDeclaration .
8.1.3 Static Semantics: IsConstantDeclaration
- Return
IsConstantDeclaration ofLetOrConst .
- Return
false .
- Return
true .
- Return
false .
- Return
false .
- Return
false .
It is not necessary to treatexport default
8.1.4 Static Semantics: LexicallyDeclaredNames
- Return a new empty
List .
- Letnames be
LexicallyDeclaredNames ofStatementList . - Append tonames the elements of the
LexicallyDeclaredNames ofStatementListItem . - Returnnames.
- If
Statement isStatement : LabelledStatement LexicallyDeclaredNames ofLabelledStatement . - Return a new empty
List .
- Return the
BoundNames ofDeclaration .
- Return a new empty
List .
- If the first
CaseClauses is present, letnames be theLexicallyDeclaredNames of the firstCaseClauses . - Else, letnames be a new empty
List . - Append tonames the elements of the
LexicallyDeclaredNames ofDefaultClause . - If the second
CaseClauses is not present, returnnames. - Return the result of appending tonames the elements of the
LexicallyDeclaredNames of the secondCaseClauses .
- Letnames be
LexicallyDeclaredNames ofCaseClauses . - Append tonames the elements of the
LexicallyDeclaredNames ofCaseClause . - Returnnames.
- If the
StatementList is present, return theLexicallyDeclaredNames ofStatementList . - Return a new empty
List .
- If the
StatementList is present, return theLexicallyDeclaredNames ofStatementList . - Return a new empty
List .
- Return the
LexicallyDeclaredNames ofLabelledItem .
- Return a new empty
List .
- Return
BoundNames ofFunctionDeclaration .
- Return a new empty
List .
- Return a new empty
List .
- Return a new empty
List .
At the top level of a
The LexicallyDeclaredNames of a
- Letnames be
LexicallyDeclaredNames ofModuleItemList . - Append tonames the elements of the
LexicallyDeclaredNames ofModuleItem . - Returnnames.
- Return the
BoundNames ofImportDeclaration .
- If
ExportDeclaration isexportVariableStatement , return a new emptyList . - Return the
BoundNames ofExportDeclaration .
- Return
LexicallyDeclaredNames ofStatementListItem .
At the top level of a
8.1.5 Static Semantics: LexicallyScopedDeclarations
- Letdeclarations be
LexicallyScopedDeclarations ofStatementList . - Append todeclarations the elements of the
LexicallyScopedDeclarations ofStatementListItem . - Returndeclarations.
- If
Statement isStatement : LabelledStatement LexicallyScopedDeclarations ofLabelledStatement . - Return a new empty
List .
- Return a
List whose sole element isDeclarationPart ofDeclaration .
- Return a new empty
List .
- If the first
CaseClauses is present, letdeclarations be theLexicallyScopedDeclarations of the firstCaseClauses . - Else, letdeclarations be a new empty
List . - Append todeclarations the elements of the
LexicallyScopedDeclarations ofDefaultClause . - If the second
CaseClauses is not present, returndeclarations. - Return the result of appending todeclarations the elements of the
LexicallyScopedDeclarations of the secondCaseClauses .
- Letdeclarations be
LexicallyScopedDeclarations ofCaseClauses . - Append todeclarations the elements of the
LexicallyScopedDeclarations ofCaseClause . - Returndeclarations.
- If the
StatementList is present, return theLexicallyScopedDeclarations ofStatementList . - Return a new empty
List .
- If the
StatementList is present, return theLexicallyScopedDeclarations ofStatementList . - Return a new empty
List .
- Return the
LexicallyScopedDeclarations ofLabelledItem .
- Return a new empty
List .
- Return a
List whose sole element isFunctionDeclaration .
- Return a new empty
List .
- Return the
TopLevelLexicallyScopedDeclarations ofStatementList .
- Return a new empty
List .
- Return a new empty
List .
- Return a new empty
List .
- Letdeclarations be
LexicallyScopedDeclarations ofModuleItemList . - Append todeclarations the elements of the
LexicallyScopedDeclarations ofModuleItem . - Returndeclarations.
- Return a new empty
List .
- Return a new empty
List .
- Return a
List whose sole element isDeclarationPart ofDeclaration .
- Return a
List whose sole element isDeclarationPart ofHoistableDeclaration .
- Return a
List whose sole element isClassDeclaration .
- Return a
List whose sole element is thisExportDeclaration .
8.1.6 Static Semantics: VarDeclaredNames
- Return a new empty
List .
- Return a new empty
List .
- Letnames be
VarDeclaredNames ofStatementList . - Append tonames the elements of the
VarDeclaredNames ofStatementListItem . - Returnnames.
- Return a new empty
List .
- Return
BoundNames ofVariableDeclarationList .
- Letnames be
VarDeclaredNames of the firstStatement . - Append tonames the elements of the
VarDeclaredNames of the secondStatement . - Returnnames.
- Return the
VarDeclaredNames ofStatement .
- Return the
VarDeclaredNames ofStatement .
- Return the
VarDeclaredNames ofStatement .
- Return the
VarDeclaredNames ofStatement .
- Letnames be
BoundNames ofVariableDeclarationList . - Append tonames the elements of the
VarDeclaredNames ofStatement . - Returnnames.
- Return the
VarDeclaredNames ofStatement .
- Return the
VarDeclaredNames ofStatement .
- Letnames be the
BoundNames ofForBinding . - Append tonames the elements of the
VarDeclaredNames ofStatement . - Returnnames.
This section is extended by Annex
- Return the
VarDeclaredNames ofStatement .
- Return the
VarDeclaredNames ofCaseBlock .
- Return a new empty
List .
- If the first
CaseClauses is present, letnames be theVarDeclaredNames of the firstCaseClauses . - Else, letnames be a new empty
List . - Append tonames the elements of the
VarDeclaredNames ofDefaultClause . - If the second
CaseClauses is not present, returnnames. - Return the result of appending tonames the elements of the
VarDeclaredNames of the secondCaseClauses .
- Letnames be
VarDeclaredNames ofCaseClauses . - Append tonames the elements of the
VarDeclaredNames ofCaseClause . - Returnnames.
- If the
StatementList is present, return theVarDeclaredNames ofStatementList . - Return a new empty
List .
- If the
StatementList is present, return theVarDeclaredNames ofStatementList . - Return a new empty
List .
- Return the
VarDeclaredNames ofLabelledItem .
- Return a new empty
List .
- Letnames be
VarDeclaredNames ofBlock . - Append tonames the elements of the
VarDeclaredNames ofCatch . - Returnnames.
- Letnames be
VarDeclaredNames ofBlock . - Append tonames the elements of the
VarDeclaredNames ofFinally . - Returnnames.
- Letnames be
VarDeclaredNames ofBlock . - Append tonames the elements of the
VarDeclaredNames ofCatch . - Append tonames the elements of the
VarDeclaredNames ofFinally . - Returnnames.
- Return the
VarDeclaredNames ofBlock .
- Return a new empty
List .
- Return
TopLevelVarDeclaredNames ofStatementList .
- Return a new empty
List .
- Return a new empty
List .
- Return
TopLevelVarDeclaredNames ofStatementList .
- Return a new empty
List .
- Letnames be
VarDeclaredNames ofModuleItemList . - Append tonames the elements of the
VarDeclaredNames ofModuleItem . - Returnnames.
- Return a new empty
List .
- If
ExportDeclaration isexportVariableStatement , returnBoundNames ofExportDeclaration . - Return a new empty
List .
8.1.7 Static Semantics: VarScopedDeclarations
- Return a new empty
List .
- Return a new empty
List .
- Letdeclarations be
VarScopedDeclarations ofStatementList . - Append todeclarations the elements of the
VarScopedDeclarations ofStatementListItem . - Returndeclarations.
- Return a new empty
List .
- Return a
List whose sole element isVariableDeclaration .
- Letdeclarations be
VarScopedDeclarations ofVariableDeclarationList . - Append
VariableDeclaration todeclarations. - Returndeclarations.
- Letdeclarations be
VarScopedDeclarations of the firstStatement . - Append todeclarations the elements of the
VarScopedDeclarations of the secondStatement . - Returndeclarations.
- Return the
VarScopedDeclarations ofStatement .
- Return the
VarScopedDeclarations ofStatement .
- Return the
VarScopedDeclarations ofStatement .
- Return the
VarScopedDeclarations ofStatement .
- Letdeclarations be
VarScopedDeclarations ofVariableDeclarationList . - Append todeclarations the elements of the
VarScopedDeclarations ofStatement . - Returndeclarations.
- Return the
VarScopedDeclarations ofStatement .
- Return the
VarScopedDeclarations ofStatement .
- Letdeclarations be a
List whose sole element isForBinding . - Append todeclarations the elements of the
VarScopedDeclarations ofStatement . - Returndeclarations.
This section is extended by Annex
- Return the
VarScopedDeclarations ofStatement .
- Return the
VarScopedDeclarations ofCaseBlock .
- Return a new empty
List .
- If the first
CaseClauses is present, letdeclarations be theVarScopedDeclarations of the firstCaseClauses . - Else, letdeclarations be a new empty
List . - Append todeclarations the elements of the
VarScopedDeclarations ofDefaultClause . - If the second
CaseClauses is not present, returndeclarations. - Return the result of appending todeclarations the elements of the
VarScopedDeclarations of the secondCaseClauses .
- Letdeclarations be
VarScopedDeclarations ofCaseClauses . - Append todeclarations the elements of the
VarScopedDeclarations ofCaseClause . - Returndeclarations.
- If the
StatementList is present, return theVarScopedDeclarations ofStatementList . - Return a new empty
List .
- If the
StatementList is present, return theVarScopedDeclarations ofStatementList . - Return a new empty
List .
- Return the
VarScopedDeclarations ofLabelledItem .
- Return a new empty
List .
- Letdeclarations be
VarScopedDeclarations ofBlock . - Append todeclarations the elements of the
VarScopedDeclarations ofCatch . - Returndeclarations.
- Letdeclarations be
VarScopedDeclarations ofBlock . - Append todeclarations the elements of the
VarScopedDeclarations ofFinally . - Returndeclarations.
- Letdeclarations be
VarScopedDeclarations ofBlock . - Append todeclarations the elements of the
VarScopedDeclarations ofCatch . - Append todeclarations the elements of the
VarScopedDeclarations ofFinally . - Returndeclarations.
- Return the
VarScopedDeclarations ofBlock .
- Return a new empty
List .
- Return the
TopLevelVarScopedDeclarations ofStatementList .
- Return a new empty
List .
- Return a new empty
List .
- Return a new empty
List .
- Letdeclarations be
VarScopedDeclarations ofModuleItemList . - Append todeclarations the elements of the
VarScopedDeclarations ofModuleItem . - Returndeclarations.
- Return a new empty
List .
- If
ExportDeclaration isexportVariableStatement , returnVarScopedDeclarations ofVariableStatement . - Return a new empty
List .
8.1.8 Static Semantics: TopLevelLexicallyDeclaredNames
- Letnames be
TopLevelLexicallyDeclaredNames ofStatementList . - Append tonames the elements of the
TopLevelLexicallyDeclaredNames ofStatementListItem . - Returnnames.
- Return a new empty
List .
- If
Declaration isDeclaration : HoistableDeclaration - Return « ».
- Return the
BoundNames ofDeclaration .
At the top level of a function, or script, function declarations are treated like var declarations rather than like lexical declarations.
- Return a new empty
List .
8.1.9 Static Semantics: TopLevelLexicallyScopedDeclarations
- Return a new empty
List .
- Letdeclarations be
TopLevelLexicallyScopedDeclarations ofStatementList . - Append todeclarations the elements of the
TopLevelLexicallyScopedDeclarations ofStatementListItem . - Returndeclarations.
- Return a new empty
List .
- If
Declaration isDeclaration : HoistableDeclaration - Return « ».
- Return a
List whose sole element isDeclaration .
- Return a new empty
List .
8.1.10 Static Semantics: TopLevelVarDeclaredNames
- Return a new empty
List .
- Letnames be
TopLevelVarDeclaredNames ofStatementList . - Append tonames the elements of the
TopLevelVarDeclaredNames ofStatementListItem . - Returnnames.
- If
Declaration isDeclaration : HoistableDeclaration - Return the
BoundNames ofHoistableDeclaration .
- Return the
- Return a new empty
List .
- If
Statement isStatement : LabelledStatement TopLevelVarDeclaredNames ofStatement . - Return
VarDeclaredNames ofStatement .
At the top level of a function or script, inner function declarations are treated like var declarations.
- Return the
TopLevelVarDeclaredNames ofLabelledItem .
- If
Statement isStatement : LabelledStatement TopLevelVarDeclaredNames ofStatement . - Return
VarDeclaredNames ofStatement .
- Return
BoundNames ofFunctionDeclaration .
8.1.11 Static Semantics: TopLevelVarScopedDeclarations
- Return a new empty
List .
- Letdeclarations be
TopLevelVarScopedDeclarations ofStatementList . - Append todeclarations the elements of the
TopLevelVarScopedDeclarations ofStatementListItem . - Returndeclarations.
- If
Statement isStatement : LabelledStatement TopLevelVarScopedDeclarations ofStatement . - Return
VarScopedDeclarations ofStatement .
- If
Declaration isDeclaration : HoistableDeclaration - Letdeclaration be
DeclarationPart ofHoistableDeclaration . - Return «declaration ».
- Letdeclaration be
- Return a new empty
List .
- Return the
TopLevelVarScopedDeclarations ofLabelledItem .
- If
Statement isStatement : LabelledStatement TopLevelVarScopedDeclarations ofStatement . - Return
VarScopedDeclarations ofStatement .
- Return a
List whose sole element isFunctionDeclaration .
8.2 Labels
8.2.1 Static Semantics: ContainsDuplicateLabels
With parameterlabelSet.
- Return
false .
- LethasDuplicates be
ContainsDuplicateLabels ofStatementList with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - Return
ContainsDuplicateLabels ofStatementListItem with argumentlabelSet.
- LethasDuplicate be
ContainsDuplicateLabels of the firstStatement with argumentlabelSet. - IfhasDuplicate is
true , returntrue . - Return
ContainsDuplicateLabels of the secondStatement with argumentlabelSet.
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
This section is extended by Annex
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
- Return
ContainsDuplicateLabels ofCaseBlock with argumentlabelSet.
- Return
false .
- If the first
CaseClauses is present, then- LethasDuplicates be
ContainsDuplicateLabels of the firstCaseClauses with argumentlabelSet. - IfhasDuplicates is
true , returntrue .
- LethasDuplicates be
- LethasDuplicates be
ContainsDuplicateLabels ofDefaultClause with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - If the second
CaseClauses is not present, returnfalse . - Return
ContainsDuplicateLabels of the secondCaseClauses with argumentlabelSet.
- LethasDuplicates be
ContainsDuplicateLabels ofCaseClauses with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - Return
ContainsDuplicateLabels ofCaseClause with argumentlabelSet.
- If the
StatementList is present, returnContainsDuplicateLabels ofStatementList with argumentlabelSet. - Return
false .
- If the
StatementList is present, returnContainsDuplicateLabels ofStatementList with argumentlabelSet. - Return
false .
- Letlabel be the
StringValue ofLabelIdentifier . - Iflabel is an element oflabelSet, return
true . - LetnewLabelSet be a copy oflabelSet withlabel appended.
- Return
ContainsDuplicateLabels ofLabelledItem with argumentnewLabelSet.
- Return
false .
- LethasDuplicates be
ContainsDuplicateLabels ofBlock with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - Return
ContainsDuplicateLabels ofCatch with argumentlabelSet.
- LethasDuplicates be
ContainsDuplicateLabels ofBlock with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - Return
ContainsDuplicateLabels ofFinally with argumentlabelSet.
- LethasDuplicates be
ContainsDuplicateLabels ofBlock with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - LethasDuplicates be
ContainsDuplicateLabels ofCatch with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - Return
ContainsDuplicateLabels ofFinally with argumentlabelSet.
- Return
ContainsDuplicateLabels ofBlock with argumentlabelSet.
- Return
false .
- LethasDuplicates be
ContainsDuplicateLabels ofModuleItemList with argumentlabelSet. - IfhasDuplicates is
true , returntrue . - Return
ContainsDuplicateLabels ofModuleItem with argumentlabelSet.
- Return
false .
8.2.2 Static Semantics: ContainsUndefinedBreakTarget
With parameterlabelSet.
- Return
false .
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofStatementList with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget ofStatementListItem with argumentlabelSet.
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget of the firstStatement with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget of the secondStatement with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
This section is extended by Annex
- Return
false .
- If the
StringValue ofLabelIdentifier is not an element oflabelSet, returntrue . - Return
false .
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofCaseBlock with argumentlabelSet.
- Return
false .
- If the first
CaseClauses is present, then- LethasUndefinedLabels be
ContainsUndefinedBreakTarget of the firstCaseClauses with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue .
- LethasUndefinedLabels be
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofDefaultClause with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - If the second
CaseClauses is not present, returnfalse . - Return
ContainsUndefinedBreakTarget of the secondCaseClauses with argumentlabelSet.
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofCaseClauses with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget ofCaseClause with argumentlabelSet.
- If the
StatementList is present, returnContainsUndefinedBreakTarget ofStatementList with argumentlabelSet. - Return
false .
- If the
StatementList is present, returnContainsUndefinedBreakTarget ofStatementList with argumentlabelSet. - Return
false .
- Letlabel be the
StringValue ofLabelIdentifier . - LetnewLabelSet be a copy oflabelSet withlabel appended.
- Return
ContainsUndefinedBreakTarget ofLabelledItem with argumentnewLabelSet.
- Return
false .
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofBlock with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget ofCatch with argumentlabelSet.
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofBlock with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget ofFinally with argumentlabelSet.
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofBlock with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofCatch with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget ofFinally with argumentlabelSet.
- Return
ContainsUndefinedBreakTarget ofBlock with argumentlabelSet.
- Return
false .
- LethasUndefinedLabels be
ContainsUndefinedBreakTarget ofModuleItemList with argumentlabelSet. - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedBreakTarget ofModuleItem with argumentlabelSet.
- Return
false .
8.2.3 Static Semantics: ContainsUndefinedContinueTarget
With parametersiterationSet andlabelSet.
- Return
false .
- LetnewIterationSet be a copy ofiterationSet with all the elements oflabelSet appended.
- Return
ContainsUndefinedContinueTarget ofIterationStatement with argumentsnewIterationSet and « ».
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofStatementList with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget ofStatementListItem with argumentsiterationSet and « ».
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget of the firstStatement with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget of the secondStatement with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
This section is extended by Annex
- Return
false .
- If the
StringValue ofLabelIdentifier is not an element ofiterationSet, returntrue . - Return
false .
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofCaseBlock with argumentsiterationSet and « ».
- Return
false .
- If the first
CaseClauses is present, then- LethasUndefinedLabels be
ContainsUndefinedContinueTarget of the firstCaseClauses with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue .
- LethasUndefinedLabels be
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofDefaultClause with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - If the second
CaseClauses is not present, returnfalse . - Return
ContainsUndefinedContinueTarget of the secondCaseClauses with argumentsiterationSet and « ».
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofCaseClauses with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget ofCaseClause with argumentsiterationSet and « ».
- If the
StatementList is present, returnContainsUndefinedContinueTarget ofStatementList with argumentsiterationSet and « ». - Return
false .
- If the
StatementList is present, returnContainsUndefinedContinueTarget ofStatementList with argumentsiterationSet and « ». - Return
false .
- Letlabel be the
StringValue ofLabelIdentifier . - LetnewLabelSet be a copy oflabelSet withlabel appended.
- Return
ContainsUndefinedContinueTarget ofLabelledItem with argumentsiterationSet andnewLabelSet.
- Return
false .
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofBlock with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget ofCatch with argumentsiterationSet and « ».
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofBlock with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget ofFinally with argumentsiterationSet and « ».
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofBlock with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofCatch with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget ofFinally with argumentsiterationSet and « ».
- Return
ContainsUndefinedContinueTarget ofBlock with argumentsiterationSet and « ».
- Return
false .
- LethasUndefinedLabels be
ContainsUndefinedContinueTarget ofModuleItemList with argumentsiterationSet and « ». - IfhasUndefinedLabels is
true , returntrue . - Return
ContainsUndefinedContinueTarget ofModuleItem with argumentsiterationSet and « ».
- Return
false .
8.3 Function Name Inference
8.3.1 Static Semantics: HasName
- Letexpr be
CoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList . - If
IsFunctionDefinition ofexpr isfalse , returnfalse . - Return
HasName ofexpr.
- Return
false .
- Return
true .
8.3.2 Static Semantics: IsFunctionDefinition
- Letexpr be
CoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList . - Return
IsFunctionDefinition ofexpr.
- Return
false .
- Return
true .
8.3.3 Static Semantics: IsAnonymousFunctionDefinition (expr )
The abstract operation IsAnonymousFunctionDefinition takes argumentexpr (a
- If
IsFunctionDefinition ofexpr isfalse , returnfalse . - LethasName be
HasName ofexpr. - IfhasName is
true , returnfalse . - Return
true .
8.3.4 Static Semantics: IsIdentifierRef
- Return
true .
- Return
false .
8.3.5 Runtime Semantics: NamedEvaluation
With parametername.
- Letexpr be
CoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList . - Return the result of performing
NamedEvaluation forexpr with argumentname.
Assert :IsAnonymousFunctionDefinition (Expression ) istrue .- Return the result of performing
NamedEvaluation forExpression with argumentname.
- Return
InstantiateOrdinaryFunctionExpression ofFunctionExpression with argumentname.
- Return
InstantiateGeneratorFunctionExpression ofGeneratorExpression with argumentname.
- Return
InstantiateAsyncGeneratorFunctionExpression ofAsyncGeneratorExpression with argumentname.
- Return
InstantiateAsyncFunctionExpression ofAsyncFunctionExpression with argumentname.
- Return
InstantiateArrowFunctionExpression ofArrowFunction with argumentname.
- Return
InstantiateAsyncArrowFunctionExpression ofAsyncArrowFunction with argumentname.
- Letvalue be the result of
ClassDefinitionEvaluation ofClassTail with argumentsundefined andname. ReturnIfAbrupt (value).- Setvalue.[[SourceText]] to the
source text matched by ClassExpression . - Returnvalue.
8.4 Contains
8.4.1 Static Semantics: Contains
With parametersymbol.
Every grammar production alternative in this specification which is not listed below implicitly has the following default definition of Contains:
- For each child nodechild of this
Parse Node , do- Ifchild is an instance ofsymbol, return
true . - Ifchild is an instance of a nonterminal, then
- Letcontained be the result ofchild
Contains symbol. - Ifcontained is
true , returntrue .
- Letcontained be the result ofchild
- Ifchild is an instance ofsymbol, return
- Return
false .
- Return
false .
Static semantic rules that depend upon substructure generally do not look into function definitions.
- Ifsymbol is
ClassBody , returntrue . - Ifsymbol is
ClassHeritage , then- If
ClassHeritage is present, returntrue ; otherwise returnfalse .
- If
- LetinHeritage be
ClassHeritage Contains symbol. - IfinHeritage is
true , returntrue . - Return the result of
ComputedPropertyContains forClassBody with argumentsymbol.
Static semantic rules that depend upon substructure generally do not look into class bodies except for
- Ifsymbol is not one of
NewTarget ,SuperProperty ,SuperCall ,superorthis, returnfalse . - If
ArrowParameters Contains symbol istrue , returntrue . - Return
ConciseBody Contains symbol.
- Letformals be
CoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList . - Returnformals
Contains symbol.
- Ifsymbol is not one of
NewTarget ,SuperProperty ,SuperCall ,super, orthis, returnfalse . - Return
AsyncConciseBody Contains symbol.
- Ifsymbol is not one of
NewTarget ,SuperProperty ,SuperCall ,super, orthis, returnfalse . - Lethead be
CoveredAsyncArrowHead ofCoverCallExpressionAndAsyncArrowHead . - Ifhead
Contains symbol istrue , returntrue . - Return
AsyncConciseBody Contains symbol.
Contains is used to detectnew.target,this, andsuper usage within an
- Ifsymbol is
MethodDefinition , returntrue . - Return the result of
ComputedPropertyContains forMethodDefinition with argumentsymbol.
- Return
false .
- If
MemberExpression Contains symbol istrue , returntrue . - Return
false .
- Ifsymbol is the
ReservedWord super, returntrue . - Return
false .
- If
CallExpression Contains symbol istrue , returntrue . - Return
false .
- Return
false .
- If
OptionalChain Contains symbol istrue , returntrue . - Return
false .
8.4.2 Static Semantics: ComputedPropertyContains
With parametersymbol.
- Return
false .
- Return the result of
ComputedPropertyName Contains symbol.
- Return the result of
ComputedPropertyContains forPropertyName with argumentsymbol.
- Return the result of
ComputedPropertyContains forPropertyName with argumentsymbol.
- Return the result of
ComputedPropertyContains forPropertyName with argumentsymbol.
- LetinList be
ComputedPropertyContains ofClassElementList with argumentsymbol. - IfinList is
true , returntrue . - Return the result of
ComputedPropertyContains forClassElement with argumentsymbol.
- Return
false .
- Return the result of
ComputedPropertyContains forPropertyName with argumentsymbol.
8.5 Miscellaneous
These operations are used in multiple places throughout the specification.
8.5.1 Runtime Semantics: InstantiateFunctionObject
With parameterscope.
- Return ?
InstantiateOrdinaryFunctionObject ofFunctionDeclaration with argumentscope.
- Return ?
InstantiateGeneratorFunctionObject ofGeneratorDeclaration with argumentscope.
- Return ?
InstantiateAsyncGeneratorFunctionObject ofAsyncGeneratorDeclaration with argumentscope.
- Return ?
InstantiateAsyncFunctionObject ofAsyncFunctionDeclaration with argumentscope.
8.5.2 Runtime Semantics: BindingInitialization
With parametersvalue andenvironment.
var statements and formal parameter lists of some non-strict functions (See
- Letname be
StringValue ofIdentifier . - Return ?
InitializeBoundName (name,value,environment).
- Return ?
InitializeBoundName ("yield" ,value,environment).
- Return ?
InitializeBoundName ("await" ,value,environment).
- Perform ?
RequireObjectCoercible (value). - Return the result of performing
BindingInitialization forObjectBindingPattern usingvalue andenvironment as arguments.
- LetiteratorRecord be ?
GetIterator (value). - Letresult be
IteratorBindingInitialization ofArrayBindingPattern with argumentsiteratorRecord andenvironment. - IfiteratorRecord.[[Done]] is
false , return ?IteratorClose (iteratorRecord,result). - Returnresult.
- Return
NormalCompletion (empty ).
- Perform ?
PropertyBindingInitialization forBindingPropertyList usingvalue andenvironment as the arguments. - Return
NormalCompletion (empty ).
- LetexcludedNames be a new empty
List . - Return the result of performing
RestBindingInitialization ofBindingRestProperty withvalue,environment, andexcludedNames as the arguments.
- LetexcludedNames be ?
PropertyBindingInitialization ofBindingPropertyList with argumentsvalue andenvironment. - Return the result of performing
RestBindingInitialization ofBindingRestProperty with argumentsvalue,environment, andexcludedNames.
8.5.2.1 InitializeBoundName (name,value,environment )
The abstract operation InitializeBoundName takes argumentsname,value, andenvironment. It performs the following steps when called:
Assert :Type (name) is String.- Ifenvironment is not
undefined , then- Performenvironment.InitializeBinding(name,value).
- Return
NormalCompletion (undefined ).
- Else,
- Letlhs be
ResolveBinding (name). - Return ?
PutValue (lhs,value).
- Letlhs be
8.5.3 Runtime Semantics: IteratorBindingInitialization
With parametersiteratorRecord andenvironment.
When
- Return
NormalCompletion (empty ).
- Return the result of performing
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument.
- If
Elision is present, then- Perform ?
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument.
- Perform ?
- Return the result of performing
IteratorBindingInitialization forBindingRestElement withiteratorRecord andenvironment as arguments.
- Perform ?
IteratorBindingInitialization forBindingElementList withiteratorRecord andenvironment as arguments. - Return the result of performing
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument.
- Perform ?
IteratorBindingInitialization forBindingElementList withiteratorRecord andenvironment as arguments. - If
Elision is present, then- Perform ?
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument.
- Perform ?
- Return the result of performing
IteratorBindingInitialization forBindingRestElement withiteratorRecord andenvironment as arguments.
- Perform ?
IteratorBindingInitialization forBindingElementList withiteratorRecord andenvironment as arguments. - Return the result of performing
IteratorBindingInitialization forBindingElisionElement usingiteratorRecord andenvironment as arguments.
- Perform ?
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument. - Return the result of performing
IteratorBindingInitialization ofBindingElement withiteratorRecord andenvironment as the arguments.
- LetbindingId be
StringValue ofBindingIdentifier . - Letlhs be ?
ResolveBinding (bindingId,environment). - IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue . - Else,
- Letv be
IteratorValue (next). - Ifv is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (v).
- Letv be
- Letnext be
- IfiteratorRecord.[[Done]] is
true , letv beundefined . - If
Initializer is present andv isundefined , then- If
IsAnonymousFunctionDefinition (Initializer ) istrue , then- Setv to the result of performing
NamedEvaluation forInitializer with argumentbindingId.
- Setv to the result of performing
- Else,
- LetdefaultValue be the result of evaluating
Initializer . - Setv to ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- If
- Ifenvironment is
undefined , return ?PutValue (lhs,v). - Return
InitializeReferencedBinding (lhs,v).
- IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue . - Else,
- Letv be
IteratorValue (next). - Ifv is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (v).
- Letv be
- Letnext be
- IfiteratorRecord.[[Done]] is
true , letv beundefined . - If
Initializer is present andv isundefined , then- LetdefaultValue be the result of evaluating
Initializer . - Setv to ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- Return the result of performing
BindingInitialization ofBindingPattern withv andenvironment as the arguments.
- Letlhs be ?
ResolveBinding (StringValue ofBindingIdentifier ,environment). - LetA be !
ArrayCreate (0). - Letn be 0.
- Repeat,
- IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue .
- Letnext be
- IfiteratorRecord.[[Done]] is
true , then- Ifenvironment is
undefined , return ?PutValue (lhs,A). - Return
InitializeReferencedBinding (lhs,A).
- Ifenvironment is
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),nextValue). - Setn ton + 1.
- IfiteratorRecord.[[Done]] is
- LetA be !
ArrayCreate (0). - Letn be 0.
- Repeat,
- IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue .
- Letnext be
- IfiteratorRecord.[[Done]] is
true , then- Return the result of performing
BindingInitialization ofBindingPattern withA andenvironment as the arguments.
- Return the result of performing
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),nextValue). - Setn ton + 1.
- IfiteratorRecord.[[Done]] is
- Return
NormalCompletion (empty ).
- Perform ?
IteratorBindingInitialization forFormalParameterList usingiteratorRecord andenvironment as the arguments. - Return the result of performing
IteratorBindingInitialization forFunctionRestParameter usingiteratorRecord andenvironment as the arguments.
- Perform ?
IteratorBindingInitialization forFormalParameterList usingiteratorRecord andenvironment as the arguments. - Return the result of performing
IteratorBindingInitialization forFormalParameter usingiteratorRecord andenvironment as the arguments.
Assert :iteratorRecord.[[Done]] isfalse .- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue . - Else,
- Letv be
IteratorValue (next). - Ifv is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (v).
- Letv be
- IfiteratorRecord.[[Done]] is
true , letv beundefined . - Return the result of performing
BindingInitialization forBindingIdentifier usingv andenvironment as the arguments.
- Letformals be
CoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList . - Return
IteratorBindingInitialization offormals with argumentsiteratorRecord andenvironment.
Assert :iteratorRecord.[[Done]] isfalse .- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue . - Else,
- Letv be
IteratorValue (next). - Ifv is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (v).
- Letv be
- IfiteratorRecord.[[Done]] is
true , letv beundefined . - Return the result of performing
BindingInitialization forBindingIdentifier usingv andenvironment as the arguments.
8.5.4 Static Semantics: AssignmentTargetType
- If this
IdentifierReference is contained instrict mode code andStringValue ofIdentifier is"eval" or"arguments" , returninvalid . - Return
simple .
- Return
simple .
- Letexpr be
CoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList . - Return
AssignmentTargetType ofexpr.
- Return
invalid .
8.5.5 Static Semantics: PropName
- Return
StringValue ofIdentifierReference .
- Return
empty .
- Return
PropName ofPropertyName .
- Return
StringValue ofIdentifierName .
- Return the
SV ofStringLiteral .
- Letnbr be the
NumericValue ofNumericLiteral . - Return !
ToString (nbr).
- Return
empty .
- Return
PropName ofPropertyName .
- Return
PropName ofPropertyName .
- Return
PropName ofPropertyName .
- Return
empty .
- Return
PropName ofPropertyName .
9 Executable Code and Execution Contexts
9.1 Environment Records
Environment Record is a specification type used to define the association of
Every Environment Record has an [[OuterEnv]] field, which is either
Environment Records are purely specification mechanisms and need not correspond to any specific artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to directly access or manipulate such values.
9.1.1 The Environment Record Type Hierarchy
Environment Records can be thought of as existing in a simple object-oriented hierarchy where
Environment Record (abstract)A
declarative Environment Record is used to define the effect of ECMAScript language syntactic elements such asFunctionDeclaration s,VariableDeclaration s, andCatch clauses that directly associate identifier bindings with ECMAScript language values.A
function Environment Record corresponds to the invocation of an ECMAScriptfunction object , and contains bindings for the top-level declarations within that function. It may establish a newthisbinding. It also captures the state necessary to supportsupermethod invocations.A
module Environment Record contains the bindings for the top-level declarations of aModule . It also contains the bindings that are explicitly imported by theModule . Its [[OuterEnv]] is aglobal Environment Record .
An
object Environment Record is used to define the effect of ECMAScript elements such asWithStatement that associate identifier bindings with the properties of some object.A
global Environment Record is used forScript global declarations. It does not have an outer environment; its [[OuterEnv]] isnull . It may be prepopulated with identifier bindings and it includes an associatedglobal object whose properties provide some of theglobal environment 's identifier bindings. As ECMAScript code is executed, additional properties may be added to theglobal object and the initial properties may be modified.
The
| Method | Purpose |
|---|---|
| HasBinding(N) | Determine if an |
| CreateMutableBinding(N, D) | Create a new but uninitialized mutable binding in an |
| CreateImmutableBinding(N, S) | Create a new but uninitialized immutable binding in an |
| InitializeBinding(N, V) | Set the value of an already existing but uninitialized binding in an |
| SetMutableBinding(N, V, S) | Set the value of an already existing mutable binding in an |
| GetBindingValue(N, S) | Returns the value of an already existing binding from an |
| DeleteBinding(N) | Delete a binding from an |
| HasThisBinding() | Determine if anthis binding. Return |
| HasSuperBinding() | Determine if ansuper method binding. Return |
| WithBaseObject() | If thiswith statement, return the with object. Otherwise, return |
9.1.1.1 Declarative Environment Records
Eachdeclarative Environment Record is associated with an ECMAScript program scope containing variable, constant, let, class, module, import, and/or function declarations. A declarative Environment Record binds the set of identifiers defined by the declarations contained within its scope.
The behaviour of the concrete specification methods for declarative Environment Records is defined by the following algorithms.
9.1.1.1.1 HasBinding (N )
The HasBinding concrete method of a
- IfenvRec has a binding for the name that is the value ofN, return
true . - Return
false .
9.1.1.1.2 CreateMutableBinding (N,D )
The CreateMutableBinding concrete method of a
Assert :envRec does not already have a binding forN.- Create a mutable binding inenvRec forN and record that it is uninitialized. IfD is
true , record that the newly created binding may be deleted by a subsequent DeleteBinding call. - Return
NormalCompletion (empty ).
9.1.1.1.3 CreateImmutableBinding (N,S )
The CreateImmutableBinding concrete method of a
Assert :envRec does not already have a binding forN.- Create an immutable binding inenvRec forN and record that it is uninitialized. IfS is
true , record that the newly created binding is a strict binding. - Return
NormalCompletion (empty ).
9.1.1.1.4 InitializeBinding (N,V )
The InitializeBinding concrete method of a
Assert :envRec must have an uninitialized binding forN.- Set the bound value forN inenvRec toV.
Record that the binding forN inenvRec has been initialized.- Return
NormalCompletion (empty ).
9.1.1.1.5 SetMutableBinding (N,V,S )
The SetMutableBinding concrete method of a
- IfenvRec does not have a binding forN, then
- IfS is
true , throw aReferenceError exception. - PerformenvRec.CreateMutableBinding(N,
true ). - PerformenvRec.InitializeBinding(N,V).
- Return
NormalCompletion (empty ).
- IfS is
- If the binding forN inenvRec is a strict binding, setS to
true . - If the binding forN inenvRec has not yet been initialized, throw a
ReferenceError exception. - Else if the binding forN inenvRec is a mutable binding, change its bound value toV.
- Else,
Assert : This is an attempt to change the value of an immutable binding.- IfS is
true , throw aTypeError exception.
- Return
NormalCompletion (empty ).
An example of ECMAScript code that results in a missing binding at step
functionf(){eval("var x; x = (delete x, 0);"); }9.1.1.1.6 GetBindingValue (N,S )
The GetBindingValue concrete method of a
Assert :envRec has a binding forN.- If the binding forN inenvRec is an uninitialized binding, throw a
ReferenceError exception. - Return the value currently bound toN inenvRec.
9.1.1.1.7 DeleteBinding (N )
The DeleteBinding concrete method of a
Assert :envRec has a binding for the name that is the value ofN.- If the binding forN inenvRec cannot be deleted, return
false . - Remove the binding forN fromenvRec.
- Return
true .
9.1.1.1.8 HasThisBinding ( )
The HasThisBinding concrete method of a
- Return
false .
A regularthis binding.
9.1.1.1.9 HasSuperBinding ( )
The HasSuperBinding concrete method of a
- Return
false .
A regularsuper binding.
9.1.1.1.10 WithBaseObject ( )
The WithBaseObject concrete method of a
- Return
undefined .
9.1.1.2 Object Environment Records
Eachobject Environment Record is associated with an object called itsbinding object. An object Environment Record binds the set of string identifier names that directly correspond to the property names of its binding object. Property keys that are not strings in the form of an
Object Environment Records created forwith statements (
The behaviour of the concrete specification methods for object Environment Records is defined by the following algorithms.
9.1.1.2.1 HasBinding (N )
The HasBinding concrete method of an
- Letbindings be the binding object forenvRec.
- LetfoundBinding be ?
HasProperty (bindings,N). - IffoundBinding is
false , returnfalse . - If thewithEnvironment flag ofenvRec is
false , returntrue . - Letunscopables be ?
Get (bindings,@@unscopables ). - If
Type (unscopables) is Object, then - Return
true .
9.1.1.2.2 CreateMutableBinding (N,D )
The CreateMutableBinding concrete method of an
- Letbindings be the binding object forenvRec.
- Return ?
DefinePropertyOrThrow (bindings,N, PropertyDescriptor { [[Value]]:undefined , [[Writable]]:true , [[Enumerable]]:true , [[Configurable]]:D }).
NormallyenvRec will not have a binding forN but if it does, the semantics of
9.1.1.2.3 CreateImmutableBinding (N,S )
The CreateImmutableBinding concrete method of an
9.1.1.2.4 InitializeBinding (N,V )
The InitializeBinding concrete method of an
- Return ?envRec.SetMutableBinding(N,V,
false ).
In this specification, all uses of CreateMutableBinding for object Environment Records are immediately followed by a call to InitializeBinding for the same name. Hence, this specification does not explicitly track the initialization state of bindings in object Environment Records.
9.1.1.2.5 SetMutableBinding (N,V,S )
The SetMutableBinding concrete method of an
- Letbindings be the binding object forenvRec.
- LetstillExists be ?
HasProperty (bindings,N). - IfstillExists is
false andS istrue , throw aReferenceError exception. - Return ?
Set (bindings,N,V,S).
9.1.1.2.6 GetBindingValue (N,S )
The GetBindingValue concrete method of an
- Letbindings be the binding object forenvRec.
- Letvalue be ?
HasProperty (bindings,N). - Ifvalue is
false , then- IfS is
false , return the valueundefined ; otherwise throw aReferenceError exception.
- IfS is
- Return ?
Get (bindings,N).
9.1.1.2.7 DeleteBinding (N )
The DeleteBinding concrete method of an
- Letbindings be the binding object forenvRec.
- Return ?bindings.[[Delete]](N).
9.1.1.2.8 HasThisBinding ( )
The HasThisBinding concrete method of an
- Return
false .
Object Environment Records do not provide athis binding.
9.1.1.2.9 HasSuperBinding ( )
The HasSuperBinding concrete method of an
- Return
false .
Object Environment Records do not provide asuper binding.
9.1.1.2.10 WithBaseObject ( )
The WithBaseObject concrete method of an
- If thewithEnvironment flag ofenvRec is
true , return the binding object forenvRec. - Otherwise, return
undefined .
9.1.1.3 Function Environment Records
Afunction Environment Record is athis binding. If a function is not ansuper, its function Environment Record also contains the state that is used to performsuper method invocations from within the function.
Function Environment Records have the additional state fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[ThisValue]] | Any | This is the |
| [[ThisBindingStatus]] | If the value is | |
| [[FunctionObject]] | Object | The |
| [[NewTarget]] | Object | | If this |
Function Environment Records support all of the
| Method | Purpose |
|---|---|
| BindThisValue(V) | Set the [[ThisValue]] and record that it has been initialized. |
| GetThisBinding() | Return the value of thisthis binding. Throws athis binding has not been initialized. |
| GetSuperBase() | Return the object that is the base forsuper property accesses bound in thissuper property accesses will produce runtime errors. |
The behaviour of the additional concrete specification methods for function Environment Records is defined by the following algorithms:
9.1.1.3.1 BindThisValue (V )
The BindThisValue concrete method of a
Assert :envRec.[[ThisBindingStatus]] is notlexical .- IfenvRec.[[ThisBindingStatus]] is
initialized , throw aReferenceError exception. - SetenvRec.[[ThisValue]] toV.
- SetenvRec.[[ThisBindingStatus]] to
initialized . - ReturnV.
9.1.1.3.2 HasThisBinding ( )
The HasThisBinding concrete method of a
- IfenvRec.[[ThisBindingStatus]] is
lexical , returnfalse ; otherwise, returntrue .
9.1.1.3.3 HasSuperBinding ( )
The HasSuperBinding concrete method of a
- IfenvRec.[[ThisBindingStatus]] is
lexical , returnfalse . - IfenvRec.[[FunctionObject]].[[HomeObject]] has the value
undefined , returnfalse ; otherwise, returntrue .
9.1.1.3.4 GetThisBinding ( )
The GetThisBinding concrete method of a
Assert :envRec.[[ThisBindingStatus]] is notlexical .- IfenvRec.[[ThisBindingStatus]] is
uninitialized , throw aReferenceError exception. - ReturnenvRec.[[ThisValue]].
9.1.1.3.5 GetSuperBase ( )
The GetSuperBase concrete method of a
9.1.1.4 Global Environment Records
Aglobal Environment Record is used to represent the outer most scope that is shared by all of the ECMAScript
A global Environment Record is logically a single record but it is specified as a composite encapsulating an
Properties may be created directly on a
Global Environment Records have the additional fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[ObjectRecord]] | Binding object is the | |
| [[GlobalThisValue]] | Object | The value returned bythis in global scope. Hosts may provide any ECMAScript Object value. |
| [[DeclarativeRecord]] | ||
| [[VarNames]] | The string names bound by |
| Method | Purpose |
|---|---|
| GetThisBinding() | Return the value of thisthis binding. |
| HasVarDeclaration (N) | Determines if the argument identifier has a binding in this |
| HasLexicalDeclaration (N) | Determines if the argument identifier has a binding in this |
| HasRestrictedGlobalProperty (N) | Determines if the argument is the name of a |
| CanDeclareGlobalVar (N) | Determines if a corresponding CreateGlobalVarBinding call would succeed if called for the same argumentN. |
| CanDeclareGlobalFunction (N) | Determines if a corresponding CreateGlobalFunctionBinding call would succeed if called for the same argumentN. |
| CreateGlobalVarBinding(N, D) | Used to create and initialize tovar binding in the [[ObjectRecord]] component of avar. The String valueN is the bound name. IfD is |
| CreateGlobalFunctionBinding(N, V, D) | Create and initialize a globalfunction binding in the [[ObjectRecord]] component of afunction. The String valueN is the bound name.V is the initialization value. If the Boolean argumentD is |
The behaviour of the concrete specification methods for global Environment Records is defined by the following algorithms.
9.1.1.4.1 HasBinding (N )
The HasBinding concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , returntrue . - LetObjRec beenvRec.[[ObjectRecord]].
- Return ?ObjRec.HasBinding(N).
9.1.1.4.2 CreateMutableBinding (N,D )
The CreateMutableBinding concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , throw aTypeError exception. - ReturnDclRec.CreateMutableBinding(N,D).
9.1.1.4.3 CreateImmutableBinding (N,S )
The CreateImmutableBinding concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , throw aTypeError exception. - ReturnDclRec.CreateImmutableBinding(N,S).
9.1.1.4.4 InitializeBinding (N,V )
The InitializeBinding concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , then- ReturnDclRec.InitializeBinding(N,V).
Assert : If the binding exists, it must be in theobject Environment Record .- LetObjRec beenvRec.[[ObjectRecord]].
- Return ?ObjRec.InitializeBinding(N,V).
9.1.1.4.5 SetMutableBinding (N,V,S )
The SetMutableBinding concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , then- ReturnDclRec.SetMutableBinding(N,V,S).
- LetObjRec beenvRec.[[ObjectRecord]].
- Return ?ObjRec.SetMutableBinding(N,V,S).
9.1.1.4.6 GetBindingValue (N,S )
The GetBindingValue concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , then- ReturnDclRec.GetBindingValue(N,S).
- LetObjRec beenvRec.[[ObjectRecord]].
- Return ?ObjRec.GetBindingValue(N,S).
9.1.1.4.7 DeleteBinding (N )
The DeleteBinding concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- IfDclRec.HasBinding(N) is
true , then- ReturnDclRec.DeleteBinding(N).
- LetObjRec beenvRec.[[ObjectRecord]].
- LetglobalObject be the binding object forObjRec.
- LetexistingProp be ?
HasOwnProperty (globalObject,N). - IfexistingProp is
true , then- Letstatus be ?ObjRec.DeleteBinding(N).
- Ifstatus is
true , then- LetvarNames beenvRec.[[VarNames]].
- IfN is an element ofvarNames, remove that element from thevarNames.
- Returnstatus.
- Return
true .
9.1.1.4.8 HasThisBinding ( )
The HasThisBinding concrete method of a
- Return
true .
Global Environment Records always provide athis binding.
9.1.1.4.9 HasSuperBinding ( )
The HasSuperBinding concrete method of a
- Return
false .
Global Environment Records do not provide asuper binding.
9.1.1.4.10 WithBaseObject ( )
The WithBaseObject concrete method of a
- Return
undefined .
9.1.1.4.11 GetThisBinding ( )
The GetThisBinding concrete method of a
- ReturnenvRec.[[GlobalThisValue]].
9.1.1.4.12 HasVarDeclaration (N )
The HasVarDeclaration concrete method of a
- LetvarDeclaredNames beenvRec.[[VarNames]].
- IfvarDeclaredNames containsN, return
true . - Return
false .
9.1.1.4.13 HasLexicalDeclaration (N )
The HasLexicalDeclaration concrete method of a
- LetDclRec beenvRec.[[DeclarativeRecord]].
- ReturnDclRec.HasBinding(N).
9.1.1.4.14 HasRestrictedGlobalProperty (N )
The HasRestrictedGlobalProperty concrete method of a
- LetObjRec beenvRec.[[ObjectRecord]].
- LetglobalObject be the binding object forObjRec.
- LetexistingProp be ?globalObject.[[GetOwnProperty]](N).
- IfexistingProp is
undefined , returnfalse . - IfexistingProp.[[Configurable]] is
true , returnfalse . - Return
true .
Properties may exist upon a
9.1.1.4.15 CanDeclareGlobalVar (N )
The CanDeclareGlobalVar concrete method of a
- LetObjRec beenvRec.[[ObjectRecord]].
- LetglobalObject be the binding object forObjRec.
- LethasProperty be ?
HasOwnProperty (globalObject,N). - IfhasProperty is
true , returntrue . - Return ?
IsExtensible (globalObject).
9.1.1.4.16 CanDeclareGlobalFunction (N )
The CanDeclareGlobalFunction concrete method of a
- LetObjRec beenvRec.[[ObjectRecord]].
- LetglobalObject be the binding object forObjRec.
- LetexistingProp be ?globalObject.[[GetOwnProperty]](N).
- IfexistingProp is
undefined , return ?IsExtensible (globalObject). - IfexistingProp.[[Configurable]] is
true , returntrue . - If
IsDataDescriptor (existingProp) istrue andexistingProp has attribute values { [[Writable]]:true , [[Enumerable]]:true }, returntrue . - Return
false .
9.1.1.4.17 CreateGlobalVarBinding (N,D )
The CreateGlobalVarBinding concrete method of a
- LetObjRec beenvRec.[[ObjectRecord]].
- LetglobalObject be the binding object forObjRec.
- LethasProperty be ?
HasOwnProperty (globalObject,N). - Letextensible be ?
IsExtensible (globalObject). - IfhasProperty is
false andextensible istrue , then- Perform ?ObjRec.CreateMutableBinding(N,D).
- Perform ?ObjRec.InitializeBinding(N,
undefined ).
- LetvarDeclaredNames beenvRec.[[VarNames]].
- IfvarDeclaredNames does not containN, then
- AppendN tovarDeclaredNames.
- Return
NormalCompletion (empty ).
9.1.1.4.18 CreateGlobalFunctionBinding (N,V,D )
The CreateGlobalFunctionBinding concrete method of a
- LetObjRec beenvRec.[[ObjectRecord]].
- LetglobalObject be the binding object forObjRec.
- LetexistingProp be ?globalObject.[[GetOwnProperty]](N).
- IfexistingProp is
undefined orexistingProp.[[Configurable]] istrue , then- Letdesc be the PropertyDescriptor { [[Value]]:V, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:D }.
- Letdesc be the PropertyDescriptor { [[Value]]:V, [[Writable]]:
- Else,
- Letdesc be the PropertyDescriptor { [[Value]]:V }.
- Perform ?
DefinePropertyOrThrow (globalObject,N,desc). - Perform ?
Set (globalObject,N,V,false ). - LetvarDeclaredNames beenvRec.[[VarNames]].
- IfvarDeclaredNames does not containN, then
- AppendN tovarDeclaredNames.
- Return
NormalCompletion (empty ).
Global function declarations are always represented as own properties of the
9.1.1.5 Module Environment Records
Amodule Environment Record is a
Module Environment Records support all of the
| Method | Purpose |
|---|---|
| CreateImportBinding(N, M, N2) | Create an immutable indirect binding in a |
| GetThisBinding() | Return the value of thisthis binding. |
The behaviour of the additional concrete specification methods for module Environment Records are defined by the following algorithms:
9.1.1.5.1 GetBindingValue (N,S )
The GetBindingValue concrete method of a
Assert :S istrue .Assert :envRec has a binding forN.- If the binding forN is an indirect binding, then
- LetM andN2 be the indirection values provided when this binding forN was created.
- LettargetEnv beM.[[Environment]].
- IftargetEnv is
undefined , throw aReferenceError exception. - Return ?targetEnv.GetBindingValue(N2,
true ).
- If the binding forN inenvRec is an uninitialized binding, throw a
ReferenceError exception. - Return the value currently bound toN inenvRec.
S will always be
9.1.1.5.2 DeleteBinding (N )
The DeleteBinding concrete method of a
Module Environment Records are only used within strict code and an
9.1.1.5.3 HasThisBinding ( )
The HasThisBinding concrete method of a
- Return
true .
Module Environment Records always provide athis binding.
9.1.1.5.4 GetThisBinding ( )
The GetThisBinding concrete method of a
- Return
undefined .
9.1.1.5.5 CreateImportBinding (N,M,N2 )
The CreateImportBinding concrete method of a
Assert :envRec does not already have a binding forN.Assert :M is aModule Record .Assert : WhenM.[[Environment]] is instantiated it will have a direct binding forN2.- Create an immutable indirect binding inenvRec forN that referencesM andN2 as its target binding and record that the binding is initialized.
- Return
NormalCompletion (empty ).
9.1.2 Environment Record Operations
The following
9.1.2.1 GetIdentifierReference (env,name,strict )
The abstract operation GetIdentifierReference takes argumentsenv (an
- Ifenv is the value
null , then- Return the
Reference Record { [[Base]]:unresolvable , [[ReferencedName]]:name, [[Strict]]:strict, [[ThisValue]]:empty }.
- Return the
- Letexists be ?env.HasBinding(name).
- Ifexists is
true , then- Return the
Reference Record { [[Base]]:env, [[ReferencedName]]:name, [[Strict]]:strict, [[ThisValue]]:empty }.
- Return the
- Else,
- Letouter beenv.[[OuterEnv]].
- Return ?
GetIdentifierReference (outer,name,strict).
9.1.2.2 NewDeclarativeEnvironment (E )
The abstract operation NewDeclarativeEnvironment takes argumentE (an
- Letenv be a new
declarative Environment Record containing no bindings. - Setenv.[[OuterEnv]] toE.
- Returnenv.
9.1.2.3 NewObjectEnvironment (O,E )
The abstract operation NewObjectEnvironment takes argumentsO (an Object) andE (an
- Letenv be a new
object Environment Record containingO as the binding object. - Setenv.[[OuterEnv]] toE.
- Returnenv.
9.1.2.4 NewFunctionEnvironment (F,newTarget )
The abstract operation NewFunctionEnvironment takes argumentsF andnewTarget. It performs the following steps when called:
Assert :F is an ECMAScript function.Assert :Type (newTarget) is Undefined or Object.- Letenv be a new
function Environment Record containing no bindings. - Setenv.[[FunctionObject]] toF.
- IfF.[[ThisMode]] is
lexical , setenv.[[ThisBindingStatus]] tolexical . - Else, setenv.[[ThisBindingStatus]] to
uninitialized . - Setenv.[[NewTarget]] tonewTarget.
- Setenv.[[OuterEnv]] toF.[[Environment]].
- Returnenv.
9.1.2.5 NewGlobalEnvironment (G,thisValue )
The abstract operation NewGlobalEnvironment takes argumentsG andthisValue. It performs the following steps when called:
- LetobjRec be a new
object Environment Record containingG as the binding object. - LetdclRec be a new
declarative Environment Record containing no bindings. - Letenv be a new
global Environment Record . - Setenv.[[ObjectRecord]] toobjRec.
- Setenv.[[GlobalThisValue]] tothisValue.
- Setenv.[[DeclarativeRecord]] todclRec.
- Setenv.[[VarNames]] to a new empty
List . - Setenv.[[OuterEnv]] to
null . - Returnenv.
9.1.2.6 NewModuleEnvironment (E )
The abstract operation NewModuleEnvironment takes argumentE (an
- Letenv be a new
module Environment Record containing no bindings. - Setenv.[[OuterEnv]] toE.
- Returnenv.
9.2 Realms
Before it is evaluated, all ECMAScript code must be associated with arealm. Conceptually, a
A
| Field Name | Value | Meaning |
|---|---|---|
| [[Intrinsics]] | The intrinsic values used by code associated with this | |
| [[GlobalObject]] | Object | The |
| [[GlobalEnv]] | The | |
| [[TemplateMap]] | A | Template objects are canonicalized separately for each Once a |
| [[HostDefined]] | Any, default value is | Field reserved for use by hosts that need to associate additional information with a |
9.2.1 CreateRealm ( )
The abstract operation CreateRealm takes no arguments. It performs the following steps when called:
- LetrealmRec be a new
Realm Record . - Perform
CreateIntrinsics (realmRec). - SetrealmRec.[[GlobalObject]] to
undefined . - SetrealmRec.[[GlobalEnv]] to
undefined . - SetrealmRec.[[TemplateMap]] to a new empty
List . - ReturnrealmRec.
9.2.2 CreateIntrinsics (realmRec )
The abstract operation CreateIntrinsics takes argumentrealmRec. It performs the following steps when called:
- Letintrinsics be a new
Record . - SetrealmRec.[[Intrinsics]] tointrinsics.
- Set fields ofintrinsics with the values listed in
Table 8 . The field names are the names listed in column one of the table. The value of each field is a new object value fully and recursively populated with property values as defined by the specification of each object in clauses19 through28 . All object property values are newly created object values. All values that are built-in function objects are created by performingCreateBuiltinFunction (steps,length,name,slots,realmRec,prototype) wheresteps is the definition of that function provided by this specification,name is the initial value of the function'snameproperty,length is the initial value of the function'slengthproperty,slots is a list of the names, if any, of the function's specified internal slots, andprototype is the specified value of the function's [[Prototype]] internal slot. The creation of the intrinsics and their properties must be ordered to avoid any dependencies upon objects that have not yet been created. - Perform
AddRestrictedFunctionProperties (intrinsics.[[%Function.prototype% ]],realmRec). - Returnintrinsics.
9.2.3 SetRealmGlobalObject (realmRec,globalObj,thisValue )
The abstract operation SetRealmGlobalObject takes argumentsrealmRec,globalObj, andthisValue. It performs the following steps when called:
- IfglobalObj is
undefined , then- Letintrinsics berealmRec.[[Intrinsics]].
- SetglobalObj to !
OrdinaryObjectCreate (intrinsics.[[%Object.prototype% ]]).
Assert :Type (globalObj) is Object.- IfthisValue is
undefined , setthisValue toglobalObj. - SetrealmRec.[[GlobalObject]] toglobalObj.
- LetnewGlobalEnv be
NewGlobalEnvironment (globalObj,thisValue). - SetrealmRec.[[GlobalEnv]] tonewGlobalEnv.
- ReturnrealmRec.
9.2.4 SetDefaultGlobalBindings (realmRec )
The abstract operation SetDefaultGlobalBindings takes argumentrealmRec. It performs the following steps when called:
- Letglobal berealmRec.[[GlobalObject]].
- For each property of the Global Object specified in clause
19 , do- Letname be the String value of the
property name . - Letdesc be the fully populated data
Property Descriptor for the property, containing the specified attributes for the property. For properties listed in19.2 ,19.3 , or19.4 the value of the [[Value]] attribute is the corresponding intrinsic object fromrealmRec. - Perform ?
DefinePropertyOrThrow (global,name,desc).
- Letname be the String value of the
- Returnglobal.
9.3 Execution Contexts
Anexecution context is a specification device that is used to track the runtime evaluation of code by an ECMAScript implementation. At any point in time, there is at most one execution context per
Theexecution context stack is used to track execution contexts. The
An execution context contains whatever implementation specific state is necessary to track the execution progress of its associated code. Each execution context has at least the state components listed in
| Component | Purpose |
|---|---|
| code evaluation state | Any state needed to perform, suspend, and resume evaluation of the code associated with this |
| Function | If this |
| The | |
| ScriptOrModule | The |
Evaluation of code by the
The value of the
Execution contexts for ECMAScript code have the additional state components listed in
| Component | Purpose |
|---|---|
| LexicalEnvironment | Identifies the |
| VariableEnvironment | Identifies the |
The LexicalEnvironment and VariableEnvironment components of an execution context are always Environment Records.
Execution contexts representing the evaluation of generator objects have the additional state components listed in
| Component | Purpose |
|---|---|
| Generator | The generator object that this |
In most situations only the
An execution context is purely a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation. It is impossible for ECMAScript code to directly access or observe an execution context.
9.3.1 GetActiveScriptOrModule ( )
The abstract operation GetActiveScriptOrModule takes no arguments. It is used to determine the running script or module, based on the
- If the
execution context stack is empty, returnnull . - Letec be the topmost
execution context on theexecution context stack whose ScriptOrModule component is notnull . - If no such
execution context exists, returnnull . Otherwise, returnec's ScriptOrModule.
9.3.2 ResolveBinding (name [ ,env ] )
The abstract operation ResolveBinding takes argumentname (a String) and optional argumentenv (an
- Ifenv is not present or ifenv is
undefined , then- Setenv to the
running execution context 's LexicalEnvironment.
- Setenv to the
Assert :env is anEnvironment Record .- If the code matching the syntactic production that is being evaluated is contained in
strict mode code , letstrict betrue ; else letstrict befalse . - Return ?
GetIdentifierReference (env,name,strict).
The result of ResolveBinding is always a
9.3.3 GetThisEnvironment ( )
The abstract operation GetThisEnvironment takes no arguments. It finds thethis. It performs the following steps when called:
- Letenv be the
running execution context 's LexicalEnvironment. - Repeat,
- Letexists beenv.HasThisBinding().
- Ifexists is
true , returnenv. - Letouter beenv.[[OuterEnv]].
Assert :outer is notnull .- Setenv toouter.
The loop in stepthis binding.
9.3.4 ResolveThisBinding ( )
The abstract operation ResolveThisBinding takes no arguments. It determines the binding of thethis using the LexicalEnvironment of the
- LetenvRec be
GetThisEnvironment (). - Return ?envRec.GetThisBinding().
9.3.5 GetNewTarget ( )
The abstract operation GetNewTarget takes no arguments. It determines the NewTarget value using the LexicalEnvironment of the
- LetenvRec be
GetThisEnvironment (). Assert :envRec has a [[NewTarget]] field.- ReturnenvRec.[[NewTarget]].
9.3.6 GetGlobalObject ( )
The abstract operation GetGlobalObject takes no arguments. It returns the
- LetcurrentRealm be
the current Realm Record . - ReturncurrentRealm.[[GlobalObject]].
9.4 Jobs and Host Operations to Enqueue Jobs
AJob is an
Jobs are scheduled for execution by ECMAScript
- At some future point in time, when there is no
running execution context and theexecution context stack is empty, the implementation must:- Perform any
host-defined preparation steps. Invoke theJob Abstract Closure .- Perform any
host-defined cleanup steps, after which theexecution context stack must be empty.
- Perform any
- Only one
Job may be actively undergoing evaluation at any point in time. - Once evaluation of a
Job starts, it must run to completion before evaluation of any otherJob starts. - The
Abstract Closure must return a normal completion, implementing its own handling of errors.
At any particular time,scriptOrModule (a
GetActiveScriptOrModule () isscriptOrModule.- IfscriptOrModule is a
Script Record orModule Record , letec be the topmostexecution context on theexecution context stack whose ScriptOrModule component isscriptOrModule. TheRealm component ofec isscriptOrModule.[[Realm]].
At any particular time, an execution isprepared to evaluate ECMAScript code if all of the following conditions are true:
- The
execution context stack is not empty. - The
Realm component of the topmostexecution context on theexecution context stack is aRealm Record .
The specific choice of
Particular kinds of Jobs have additional conformance requirements.
9.4.1 JobCallback Records
AJobCallback Record is a
The WHATWG HTML specification (https://html.spec.whatwg.org/), for example, uses the
JobCallback Records have the fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[Callback]] | A | The function to invoke when the |
| [[HostDefined]] | Any, default value is | Field reserved for use by hosts. |
9.4.2 HostMakeJobCallback (callback )
The
The implementation of HostMakeJobCallback must conform to the following requirements:
- It must always complete normally (i.e., not return an
abrupt completion ). - It must always return a
JobCallback Record whose [[Callback]] field iscallback.
The default implementation of HostMakeJobCallback performs the following steps when called:
Assert :IsCallable (callback) istrue .- Return the
JobCallback Record { [[Callback]]:callback, [[HostDefined]]:empty }.
ECMAScript hosts that are not web browsers must use the default implementation of HostMakeJobCallback.
This is called at the time that the callback is passed to the function that is responsible for its being eventually scheduled and run. For example,promise.then(thenAction) calls MakeJobCallback onthenAction at the time of invokingPromise.prototype.then, not at the time of scheduling the reaction
9.4.3 HostCallJobCallback (jobCallback,V,argumentsList )
The
The implementation of HostCallJobCallback must conform to the following requirements:
- It must always perform and return the result of
Call (jobCallback.[[Callback]],V,argumentsList).
This requirement means that hosts cannot change the [[Call]] behaviour of function objects defined in this specification.
The default implementation of HostCallJobCallback performs the following steps when called:
Assert :IsCallable (jobCallback.[[Callback]]) istrue .- Return ?
Call (jobCallback.[[Callback]],V,argumentsList).
ECMAScript hosts that are not web browsers must use the default implementation of HostCallJobCallback.
9.4.4 HostEnqueuePromiseJob (job,realm )
The
The implementation of HostEnqueuePromiseJob must conform to the requirements in
- Ifrealm is not
null , each timejob is invoked the implementation must performimplementation-defined steps such that execution isprepared to evaluate ECMAScript code at the time ofjob's invocation. - LetscriptOrModule be
GetActiveScriptOrModule () at the time HostEnqueuePromiseJob is invoked. Ifrealm is notnull , each timejob is invoked the implementation must performimplementation-defined steps such thatscriptOrModule is theactive script or module at the time ofjob's invocation. - Jobs must run in the same order as the HostEnqueuePromiseJob invocations that scheduled them.
Therealm for Jobs returned by
9.5 InitializeHostDefinedRealm ( )
The abstract operation InitializeHostDefinedRealm takes no arguments. It performs the following steps when called:
- Letrealm be
CreateRealm (). - LetnewContext be a new
execution context . - Set the Function ofnewContext to
null . - Set the
Realm ofnewContext torealm. - Set the ScriptOrModule ofnewContext to
null . - PushnewContext onto the
execution context stack ;newContext is now therunning execution context . - If the
host requires use of anexotic object to serve asrealm'sglobal object , letglobal be such an object created in ahost-defined manner. Otherwise, letglobal beundefined , indicating that anordinary object should be created as theglobal object . - If the
host requires that thethisbinding inrealm's global scope return an object other than theglobal object , letthisValue be such an object created in ahost-defined manner. Otherwise, letthisValue beundefined , indicating thatrealm's globalthisbinding should be theglobal object . - Perform
SetRealmGlobalObject (realm,global,thisValue). - LetglobalObj be ?
SetDefaultGlobalBindings (realm). - Create any
host-defined global object properties onglobalObj. - Return
NormalCompletion (empty ).
9.6 Agents
Anagent comprises a set of ECMAScript execution contexts, an
An
Some web browsers share a single
While an
| Field Name | Value | Meaning |
|---|---|---|
| [[LittleEndian]] | Boolean | The default value computed for theisLittleEndian parameter when it is needed by the algorithms |
| [[CanBlock]] | Boolean | Determines whether the |
| [[Signifier]] | Any globally-unique value | Uniquely identifies the |
| [[IsLockFree1]] | Boolean | |
| [[IsLockFree2]] | Boolean | |
| [[IsLockFree8]] | Boolean | |
| [[CandidateExecution]] | A | See the |
| [[KeptAlive]] | Initially a new empty |
Once the values of [[Signifier]], [[IsLockFree1]], and [[IsLockFree2]] have been observed by any
The values of [[IsLockFree1]] and [[IsLockFree2]] are not necessarily determined by the hardware, but may also reflect implementation choices that can vary over time and between ECMAScript implementations.
There is no [[IsLockFree4]] property: 4-byte atomic operations are always lock-free.
In practice, if an atomic operation is implemented with any type of lock the operation is not lock-free. Lock-free does not imply wait-free: there is no upper bound on how many machine steps may be required to complete a lock-free atomic operation.
That an atomic access of sizen is lock-free does not imply anything about the (perceived) atomicity of non-atomic accesses of sizen, specifically, non-atomic accesses may still be performed as a sequence of several separate memory accesses. See
An
9.6.1 AgentSignifier ( )
The abstract operation AgentSignifier takes no arguments. It performs the following steps when called:
- LetAR be the
Agent Record of thesurrounding agent . - ReturnAR.[[Signifier]].
9.6.2 AgentCanSuspend ( )
The abstract operation AgentCanSuspend takes no arguments. It performs the following steps when called:
- LetAR be the
Agent Record of thesurrounding agent . - ReturnAR.[[CanBlock]].
In some environments it may not be reasonable for a given
9.7 Agent Clusters
Anagent cluster is a maximal set of agents that can communicate by operating on shared memory.
Programs within different agents may share memory by unspecified means. At a minimum, the backing memory for SharedArrayBuffer objects can be shared among the agents in the cluster.
There may be agents that can communicate by message passing that cannot share memory; they are never in the same agent cluster.
Every
All agents within a cluster must have the same value for the [[LittleEndian]] property in their respective
If different agents within an agent cluster have different values of [[LittleEndian]] it becomes hard to use shared memory for multi-byte data.
All agents within a cluster must have the same values for the [[IsLockFree1]] property in their respective
All agents within a cluster must have different values for the [[Signifier]] property in their respective
An embedding may deactivate (stop forward progress) or activate (resume forward progress) an
The purpose of the preceding restriction is to avoid a situation where an
The implication of the restriction is that it will not be possible to share memory between agents that don't belong to the same suspend/wake collective within the embedding.
An embedding may terminate an
Prior to any evaluation of any ECMAScript code by any
All agents in an agent cluster share the same
An agent cluster is a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation.
9.8 Forward Progress
For an
An
Implementations must ensure that:
- every unblocked
agent with a dedicatedexecuting thread eventually makes forward progress - in a set of agents that share an
executing thread , oneagent eventually makes forward progress - an
agent does not cause anotheragent to become blocked except via explicit APIs that provide blocking.
This, along with the liveness guarantee in the
9.9 Processing Model of WeakRef and FinalizationRegistry Objects
9.9.1 Objectives
This specification does not make any guarantees that any object will be garbage collected. Objects which are not
The semantics of
- When
WeakRef.prototype.derefis called, the referent (ifundefined is not returned) is kept alive so that subsequent, synchronous accesses also return the object. This list is reset when synchronous work is done using theClearKeptObjects abstract operation. - When an object which is registered with a
FinalizationRegistry becomes unreachable, a call of theFinalizationRegistry 's cleanup callback may eventually be made, after synchronous ECMAScript execution completes. TheFinalizationRegistry cleanup is performed with theCleanupFinalizationRegistry abstract operation.
Neither of these actions (
Some ECMAScript implementations include garbage collector implementations which run in the background, including when ECMAScript is idle. Letting the
9.9.2 Liveness
For some set of objectsS, ahypothetical WeakRef-oblivious execution with respect toS is an execution whereby the abstract operation
At any point during evaluation, a set of objectsS is consideredlive if either of the following conditions is met:
- Any element inS is included in any
agent 's [[KeptAlive]]List . - There exists a valid future hypothetical WeakRef-oblivious execution with respect toS that observes the Object value of any object inS.
Presence of an object in a field, an internal slot, or a property does not imply that the object is live. For example if the object in question is never passed back to the program, then it cannot be observed.
This is the case for keys in a WeakMap, members of a WeakSet, as well as the [[WeakRefTarget]] and [[UnregisterToken]] fields of a
The above definition implies that, if a key in a WeakMap is not live, then its corresponding value is not necessarily live either.
9.9.3 Execution
At any time, if a set of objectsS is not
- For each elementobj ofS, do
- For each
WeakRef ref such thatref.[[WeakRefTarget]] isobj, do- Setref.[[WeakRefTarget]] to
empty .
- Setref.[[WeakRefTarget]] to
- For each
FinalizationRegistry fg such thatfg.[[Cells]] contains aRecord cell such thatcell.[[WeakRefTarget]] isobj, do- Setcell.[[WeakRefTarget]] to
empty . - Optionally, perform !
HostEnqueueFinalizationRegistryCleanupJob (fg).
- Setcell.[[WeakRefTarget]] to
- For each WeakMapmap such thatmap.[[WeakMapData]] contains a
Record r such thatr.[[Key]] isobj, do- Setr.[[Key]] to
empty . - Setr.[[Value]] to
empty .
- Setr.[[Key]] to
- For each WeakSetset such thatset.[[WeakSetData]] containsobj, do
- Replace the element ofset.[[WeakSetData]] whose value isobj with an element whose value is
empty .
- Replace the element ofset.[[WeakSetData]] whose value isobj with an element whose value is
- For each
Together with the definition of liveness, this clause prescribes legal optimizations that an implementation may apply regarding WeakRefs.
It is possible to access an object without observing its identity. Optimizations such as dead variable elimination and scalar replacement on properties of non-escaping objects whose identity is not observed are allowed. These optimizations are thus allowed to observably empty WeakRefs that point to such objects.
On the other hand, if an object's identity is observable, and that object is in the [[WeakRefTarget]] internal slot of a
Because calling
Implementations are not obligated to empty WeakRefs for maximal sets of non-
If an implementation chooses a non-
9.9.4 Host Hooks
9.9.4.1 HostEnqueueFinalizationRegistryCleanupJob (finalizationRegistry )
The abstract operation HostEnqueueFinalizationRegistryCleanupJob takes argumentfinalizationRegistry (a
9.10 ClearKeptObjects ( )
The abstract operation ClearKeptObjects takes no arguments. ECMAScript implementations are expected to call ClearKeptObjects when a synchronous sequence of ECMAScript executions completes. It performs the following steps when called:
- LetagentRecord be the
surrounding agent 'sAgent Record . - SetagentRecord.[[KeptAlive]] to a new empty
List .
9.11 AddToKeptObjects (object )
The abstract operation AddToKeptObjects takes argumentobject (an Object). It performs the following steps when called:
- LetagentRecord be the
surrounding agent 'sAgent Record . - Appendobject toagentRecord.[[KeptAlive]].
9.12 CleanupFinalizationRegistry (finalizationRegistry )
The abstract operation CleanupFinalizationRegistry takes argumentfinalizationRegistry (a
Assert :finalizationRegistry has [[Cells]] and [[CleanupCallback]] internal slots.- Letcallback befinalizationRegistry.[[CleanupCallback]].
- WhilefinalizationRegistry.[[Cells]] contains a
Record cell such thatcell.[[WeakRefTarget]] isempty , an implementation may perform the following steps:- Choose any suchcell.
- Removecell fromfinalizationRegistry.[[Cells]].
- Perform ?
Call (callback,undefined , «cell.[[HeldValue]] »).
- Return
NormalCompletion (undefined ).
10 Ordinary and Exotic Objects Behaviours
10.1 Ordinary Object Internal Methods and Internal Slots
All ordinary objects have an internal slot called [[Prototype]]. The value of this internal slot is either
Every
In the following algorithm descriptions, assumeO is an
Each
10.1.1 [[GetPrototypeOf]] ( )
The [[GetPrototypeOf]] internal method of an
- Return !
OrdinaryGetPrototypeOf (O).
10.1.1.1 OrdinaryGetPrototypeOf (O )
The abstract operation OrdinaryGetPrototypeOf takes argumentO (an Object). It performs the following steps when called:
- ReturnO.[[Prototype]].
10.1.2 [[SetPrototypeOf]] (V )
The [[SetPrototypeOf]] internal method of an
- Return !
OrdinarySetPrototypeOf (O,V).
10.1.2.1 OrdinarySetPrototypeOf (O,V )
The abstract operation OrdinarySetPrototypeOf takes argumentsO (an Object) andV (an
Assert : EitherType (V) is Object orType (V) is Null.- Letcurrent beO.[[Prototype]].
- If
SameValue (V,current) istrue , returntrue . - Letextensible beO.[[Extensible]].
- Ifextensible is
false , returnfalse . - Letp beV.
- Letdone be
false . - Repeat, whiledone is
false ,- Ifp is
null , setdone totrue . - Else if
SameValue (p,O) istrue , returnfalse . - Else,
- Ifp.[[GetPrototypeOf]] is not the
ordinary object internal method defined in10.1.1 , setdone totrue . - Else, setp top.[[Prototype]].
- Ifp.[[GetPrototypeOf]] is not the
- Ifp is
- SetO.[[Prototype]] toV.
- Return
true .
The loop in step
10.1.3 [[IsExtensible]] ( )
The [[IsExtensible]] internal method of an
- Return !
OrdinaryIsExtensible (O).
10.1.3.1 OrdinaryIsExtensible (O )
The abstract operation OrdinaryIsExtensible takes argumentO (an Object). It performs the following steps when called:
- ReturnO.[[Extensible]].
10.1.4 [[PreventExtensions]] ( )
The [[PreventExtensions]] internal method of an
- Return !
OrdinaryPreventExtensions (O).
10.1.4.1 OrdinaryPreventExtensions (O )
The abstract operation OrdinaryPreventExtensions takes argumentO (an Object). It performs the following steps when called:
- SetO.[[Extensible]] to
false . - Return
true .
10.1.5 [[GetOwnProperty]] (P )
The [[GetOwnProperty]] internal method of an
- Return !
OrdinaryGetOwnProperty (O,P).
10.1.5.1 OrdinaryGetOwnProperty (O,P )
The abstract operation OrdinaryGetOwnProperty takes argumentsO (an Object) andP (a property key). It performs the following steps when called:
Assert :IsPropertyKey (P) istrue .- IfO does not have an own property with keyP, return
undefined . - LetD be a newly created
Property Descriptor with no fields. - LetX beO's own property whose key isP.
- IfX is a
data property , then- SetD.[[Value]] to the value ofX's [[Value]] attribute.
- SetD.[[Writable]] to the value ofX's [[Writable]] attribute.
- Else,
Assert :X is anaccessor property .- SetD.[[Get]] to the value ofX's [[Get]] attribute.
- SetD.[[Set]] to the value ofX's [[Set]] attribute.
- SetD.[[Enumerable]] to the value ofX's [[Enumerable]] attribute.
- SetD.[[Configurable]] to the value ofX's [[Configurable]] attribute.
- ReturnD.
10.1.6 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of an
- Return ?
OrdinaryDefineOwnProperty (O,P,Desc).
10.1.6.1 OrdinaryDefineOwnProperty (O,P,Desc )
The abstract operation OrdinaryDefineOwnProperty takes argumentsO (an Object),P (a property key), andDesc (a
- Letcurrent be ?O.[[GetOwnProperty]](P).
- Letextensible be ?
IsExtensible (O). - Return
ValidateAndApplyPropertyDescriptor (O,P,extensible,Desc,current).
10.1.6.2 IsCompatiblePropertyDescriptor (Extensible,Desc,Current )
The abstract operation IsCompatiblePropertyDescriptor takes argumentsExtensible (a Boolean),Desc (a
- Return
ValidateAndApplyPropertyDescriptor (undefined ,undefined ,Extensible,Desc,Current).
10.1.6.3 ValidateAndApplyPropertyDescriptor (O,P,extensible,Desc,current )
The abstract operation ValidateAndApplyPropertyDescriptor takes argumentsO (an Object or
If
Assert : IfO is notundefined , thenIsPropertyKey (P) istrue .- Ifcurrent is
undefined , then- Ifextensible is
false , returnfalse . Assert :extensible istrue .- If
IsGenericDescriptor (Desc) istrue orIsDataDescriptor (Desc) istrue , then- IfO is not
undefined , create an owndata property namedP of objectO whose [[Value]], [[Writable]], [[Enumerable]], and [[Configurable]] attribute values are described byDesc. If the value of an attribute field ofDesc is absent, the attribute of the newly created property is set to itsdefault value .
- IfO is not
- Else,
Assert : !IsAccessorDescriptor (Desc) istrue .- IfO is not
undefined , create an ownaccessor property namedP of objectO whose [[Get]], [[Set]], [[Enumerable]], and [[Configurable]] attribute values are described byDesc. If the value of an attribute field ofDesc is absent, the attribute of the newly created property is set to itsdefault value .
- Return
true .
- Ifextensible is
- If every field inDesc is absent, return
true . - Ifcurrent.[[Configurable]] is
false , then- IfDesc.[[Configurable]] is present and its value is
true , returnfalse . - IfDesc.[[Enumerable]] is present and !
SameValue (Desc.[[Enumerable]],current.[[Enumerable]]) isfalse , returnfalse .
- IfDesc.[[Configurable]] is present and its value is
- If !
IsGenericDescriptor (Desc) istrue , then- NOTE: No further validation is required.
- Else if !
SameValue (!IsDataDescriptor (current), !IsDataDescriptor (Desc)) isfalse , then- Ifcurrent.[[Configurable]] is
false , returnfalse . - If
IsDataDescriptor (current) istrue , then- IfO is not
undefined , convert the property namedP of objectO from adata property to anaccessor property . Preserve the existing values of the converted property's [[Configurable]] and [[Enumerable]] attributes and set the rest of the property's attributes to theirdefault values .
- IfO is not
- Else,
- IfO is not
undefined , convert the property namedP of objectO from anaccessor property to adata property . Preserve the existing values of the converted property's [[Configurable]] and [[Enumerable]] attributes and set the rest of the property's attributes to theirdefault values .
- IfO is not
- Ifcurrent.[[Configurable]] is
- Else if
IsDataDescriptor (current) andIsDataDescriptor (Desc) are bothtrue , then- Ifcurrent.[[Configurable]] is
false andcurrent.[[Writable]] isfalse , then- IfDesc.[[Writable]] is present andDesc.[[Writable]] is
true , returnfalse . - IfDesc.[[Value]] is present and
SameValue (Desc.[[Value]],current.[[Value]]) isfalse , returnfalse . - Return
true .
- IfDesc.[[Writable]] is present andDesc.[[Writable]] is
- Ifcurrent.[[Configurable]] is
- Else,
Assert : !IsAccessorDescriptor (current) and !IsAccessorDescriptor (Desc) are bothtrue .- Ifcurrent.[[Configurable]] is
false , then
- IfO is not
undefined , then- For each field ofDesc that is present, set the corresponding attribute of the property namedP of objectO to the value of the field.
- Return
true .
10.1.7 [[HasProperty]] (P )
The [[HasProperty]] internal method of an
- Return ?
OrdinaryHasProperty (O,P).
10.1.7.1 OrdinaryHasProperty (O,P )
The abstract operation OrdinaryHasProperty takes argumentsO (an Object) andP (a property key). It performs the following steps when called:
Assert :IsPropertyKey (P) istrue .- LethasOwn be ?O.[[GetOwnProperty]](P).
- IfhasOwn is not
undefined , returntrue . - Letparent be ?O.[[GetPrototypeOf]]().
- Ifparent is not
null , then- Return ?parent.[[HasProperty]](P).
- Return
false .
10.1.8 [[Get]] (P,Receiver )
The [[Get]] internal method of an
- Return ?
OrdinaryGet (O,P,Receiver).
10.1.8.1 OrdinaryGet (O,P,Receiver )
The abstract operation OrdinaryGet takes argumentsO (an Object),P (a property key), andReceiver (an
Assert :IsPropertyKey (P) istrue .- Letdesc be ?O.[[GetOwnProperty]](P).
- Ifdesc is
undefined , then- Letparent be ?O.[[GetPrototypeOf]]().
- Ifparent is
null , returnundefined . - Return ?parent.[[Get]](P,Receiver).
- If
IsDataDescriptor (desc) istrue , returndesc.[[Value]]. Assert :IsAccessorDescriptor (desc) istrue .- Letgetter bedesc.[[Get]].
- Ifgetter is
undefined , returnundefined . - Return ?
Call (getter,Receiver).
10.1.9 [[Set]] (P,V,Receiver )
The [[Set]] internal method of an
- Return ?
OrdinarySet (O,P,V,Receiver).
10.1.9.1 OrdinarySet (O,P,V,Receiver )
The abstract operation OrdinarySet takes argumentsO (an Object),P (a property key),V (an
Assert :IsPropertyKey (P) istrue .- LetownDesc be ?O.[[GetOwnProperty]](P).
- Return
OrdinarySetWithOwnDescriptor (O,P,V,Receiver,ownDesc).
10.1.9.2 OrdinarySetWithOwnDescriptor (O,P,V,Receiver,ownDesc )
The abstract operation OrdinarySetWithOwnDescriptor takes argumentsO (an Object),P (a property key),V (an
Assert :IsPropertyKey (P) istrue .- IfownDesc is
undefined , then- Letparent be ?O.[[GetPrototypeOf]]().
- Ifparent is not
null , then- Return ?parent.[[Set]](P,V,Receiver).
- Else,
- SetownDesc to the PropertyDescriptor { [[Value]]:
undefined , [[Writable]]:true , [[Enumerable]]:true , [[Configurable]]:true }.
- SetownDesc to the PropertyDescriptor { [[Value]]:
- If
IsDataDescriptor (ownDesc) istrue , then- IfownDesc.[[Writable]] is
false , returnfalse . - If
Type (Receiver) is not Object, returnfalse . - LetexistingDescriptor be ?Receiver.[[GetOwnProperty]](P).
- IfexistingDescriptor is not
undefined , then- If
IsAccessorDescriptor (existingDescriptor) istrue , returnfalse . - IfexistingDescriptor.[[Writable]] is
false , returnfalse . - LetvalueDesc be the PropertyDescriptor { [[Value]]:V }.
- Return ?Receiver.[[DefineOwnProperty]](P,valueDesc).
- If
- Else,
Assert :Receiver does not currently have a propertyP.- Return ?
CreateDataProperty (Receiver,P,V).
- IfownDesc.[[Writable]] is
Assert :IsAccessorDescriptor (ownDesc) istrue .- Letsetter beownDesc.[[Set]].
- Ifsetter is
undefined , returnfalse . - Perform ?
Call (setter,Receiver, «V »). - Return
true .
10.1.10 [[Delete]] (P )
The [[Delete]] internal method of an
- Return ?
OrdinaryDelete (O,P).
10.1.10.1 OrdinaryDelete (O,P )
The abstract operation OrdinaryDelete takes argumentsO (an Object) andP (a property key). It performs the following steps when called:
Assert :IsPropertyKey (P) istrue .- Letdesc be ?O.[[GetOwnProperty]](P).
- Ifdesc is
undefined , returntrue . - Ifdesc.[[Configurable]] is
true , then- Remove the own property with nameP fromO.
- Return
true .
- Return
false .
10.1.11 [[OwnPropertyKeys]] ( )
The [[OwnPropertyKeys]] internal method of an
- Return !
OrdinaryOwnPropertyKeys (O).
10.1.11.1 OrdinaryOwnPropertyKeys (O )
The abstract operation OrdinaryOwnPropertyKeys takes argumentO (an Object). It performs the following steps when called:
- Letkeys be a new empty
List . - For each own property keyP ofO such thatP is an
array index , in ascending numeric index order, do- AddP as the last element ofkeys.
- For each own property keyP ofO such that
Type (P) is String andP is not anarray index , in ascending chronological order of property creation, do- AddP as the last element ofkeys.
- For each own property keyP ofO such that
Type (P) is Symbol, in ascending chronological order of property creation, do- AddP as the last element ofkeys.
- Returnkeys.
10.1.12 OrdinaryObjectCreate (proto [ ,additionalInternalSlotsList ] )
The abstract operation OrdinaryObjectCreate takes argumentproto (an Object or
- LetinternalSlotsList be « [[Prototype]], [[Extensible]] ».
- IfadditionalInternalSlotsList is present, append each of its elements tointernalSlotsList.
- LetO be !
MakeBasicObject (internalSlotsList). - SetO.[[Prototype]] toproto.
- ReturnO.
Although OrdinaryObjectCreate does little more than call
10.1.13 OrdinaryCreateFromConstructor (constructor,intrinsicDefaultProto [ ,internalSlotsList ] )
The abstract operation OrdinaryCreateFromConstructor takes argumentsconstructor andintrinsicDefaultProto and optional argumentinternalSlotsList (a
Assert :intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.- Letproto be ?
GetPrototypeFromConstructor (constructor,intrinsicDefaultProto). - Return !
OrdinaryObjectCreate (proto,internalSlotsList).
10.1.14 GetPrototypeFromConstructor (constructor,intrinsicDefaultProto )
The abstract operation GetPrototypeFromConstructor takes argumentsconstructor andintrinsicDefaultProto. It determines the [[Prototype]] value that should be used to create an object corresponding to a specific
Assert :intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.Assert :IsCallable (constructor) istrue .- Letproto be ?
Get (constructor,"prototype" ). - If
Type (proto) is not Object, then- Letrealm be ?
GetFunctionRealm (constructor). - Setproto torealm's intrinsic object namedintrinsicDefaultProto.
- Letrealm be ?
- Returnproto.
Ifconstructor does not supply a [[Prototype]] value, the default value that is used is obtained from the
10.1.15 RequireInternalSlot (O,internalSlot )
The abstract operation RequireInternalSlot takes argumentsO andinternalSlot. It throws an exception unlessO is an Object and has the given internal slot. It performs the following steps when called:
- If
Type (O) is not Object, throw aTypeError exception. - IfO does not have aninternalSlot internal slot, throw a
TypeError exception.
10.2 ECMAScript Function Objects
ECMAScript function objects encapsulate parameterized ECMAScript code closed over a lexical environment and support the dynamic evaluation of that code. An ECMAScript
In addition to [[Extensible]] and [[Prototype]], ECMAScript function objects also have the internal slots listed in
| Internal Slot | Type | Description |
|---|---|---|
| [[Environment]] | The | |
| [[FormalParameters]] | The root parse node of the source text that defines the function's formal parameter list. | |
| [[ECMAScriptCode]] | The root parse node of the source text that defines the function's body. | |
| [[ConstructorKind]] | Whether or not the function is a derived class | |
| [[Realm]] | The | |
| [[ScriptOrModule]] | The script or module in which the function was created. | |
| [[ThisMode]] | Defines howthis references are interpreted within the formal parameters and code body of the function.this refers to the | |
| [[Strict]] | Boolean | |
| [[HomeObject]] | Object | If the function usessuper, this is the object whose [[GetPrototypeOf]] provides the object wheresuper property lookups begin. |
| [[SourceText]] | sequence of Unicode code points | The |
| [[IsClassConstructor]] | Boolean | Indicates whether the function is a class |
All ECMAScript function objects have the [[Call]] internal method defined here. ECMAScript functions that are also constructors in addition have the [[Construct]] internal method.
10.2.1 [[Call]] (thisArgument,argumentsList )
The [[Call]] internal method of an ECMAScript
Assert :F is an ECMAScriptfunction object .- LetcallerContext be the
running execution context . - LetcalleeContext be
PrepareForOrdinaryCall (F,undefined ). Assert :calleeContext is now therunning execution context .- IfF.[[IsClassConstructor]] is
true , then- Leterror be a newly created
TypeError object. - NOTE:error is created incalleeContext withF's associated
Realm Record . - RemovecalleeContext from the
execution context stack and restorecallerContext as therunning execution context . - Return
ThrowCompletion (error).
- Leterror be a newly created
- Perform
OrdinaryCallBindThis (F,calleeContext,thisArgument). - Letresult be
OrdinaryCallEvaluateBody (F,argumentsList). - RemovecalleeContext from the
execution context stack and restorecallerContext as therunning execution context . - Ifresult.[[Type]] is
return , returnNormalCompletion (result.[[Value]]). ReturnIfAbrupt (result).- Return
NormalCompletion (undefined ).
WhencalleeContext is removed from the
10.2.1.1 PrepareForOrdinaryCall (F,newTarget )
The abstract operation PrepareForOrdinaryCall takes argumentsF (a
Assert :Type (newTarget) is Undefined or Object.- LetcallerContext be the
running execution context . - LetcalleeContext be a new ECMAScript code
execution context . - Set the Function ofcalleeContext toF.
- LetcalleeRealm beF.[[Realm]].
- Set the
Realm ofcalleeContext tocalleeRealm. - Set the ScriptOrModule ofcalleeContext toF.[[ScriptOrModule]].
- LetlocalEnv be
NewFunctionEnvironment (F,newTarget). - Set the LexicalEnvironment ofcalleeContext tolocalEnv.
- Set the VariableEnvironment ofcalleeContext tolocalEnv.
- IfcallerContext is not already suspended, suspendcallerContext.
- PushcalleeContext onto the
execution context stack ;calleeContext is now therunning execution context . - NOTE: Any exception objects produced after this point are associated withcalleeRealm.
- ReturncalleeContext.
10.2.1.2 OrdinaryCallBindThis (F,calleeContext,thisArgument )
The abstract operation OrdinaryCallBindThis takes argumentsF (a
- LetthisMode beF.[[ThisMode]].
- IfthisMode is
lexical , returnNormalCompletion (undefined ). - LetcalleeRealm beF.[[Realm]].
- LetlocalEnv be the LexicalEnvironment ofcalleeContext.
- IfthisMode is
strict , letthisValue bethisArgument. - Else,
- IfthisArgument is
undefined ornull , then- LetglobalEnv becalleeRealm.[[GlobalEnv]].
Assert :globalEnv is aglobal Environment Record .- LetthisValue beglobalEnv.[[GlobalThisValue]].
- Else,
- IfthisArgument is
Assert :localEnv is afunction Environment Record .Assert : The next step never returns anabrupt completion becauselocalEnv.[[ThisBindingStatus]] is notinitialized .- ReturnlocalEnv.BindThisValue(thisValue).
10.2.1.3 Runtime Semantics: EvaluateBody
With parametersfunctionObject andargumentsList (a
- Return ?
EvaluateFunctionBody ofFunctionBody with argumentsfunctionObject andargumentsList.
- Return ?
EvaluateConciseBody ofConciseBody with argumentsfunctionObject andargumentsList.
- Return ?
EvaluateGeneratorBody ofGeneratorBody with argumentsfunctionObject andargumentsList.
- Return ?
EvaluateAsyncGeneratorBody ofAsyncGeneratorBody with argumentsfunctionObject andargumentsList.
- Return ?
EvaluateAsyncFunctionBody ofAsyncFunctionBody with argumentsfunctionObject andargumentsList.
- Return ?
EvaluateAsyncConciseBody ofAsyncConciseBody with argumentsfunctionObject andargumentsList.
10.2.1.4 OrdinaryCallEvaluateBody (F,argumentsList )
The abstract operation OrdinaryCallEvaluateBody takes argumentsF (a
- Return the result of
EvaluateBody of the parsed code that isF.[[ECMAScriptCode]] passingF andargumentsList as the arguments.
10.2.2 [[Construct]] (argumentsList,newTarget )
The [[Construct]] internal method of an ECMAScript
Assert :F is an ECMAScriptfunction object .Assert :Type (newTarget) is Object.- LetcallerContext be the
running execution context . - Letkind beF.[[ConstructorKind]].
- Ifkind is
base , then- LetthisArgument be ?
OrdinaryCreateFromConstructor (newTarget,"%Object.prototype%" ).
- LetthisArgument be ?
- LetcalleeContext be
PrepareForOrdinaryCall (F,newTarget). Assert :calleeContext is now therunning execution context .- Ifkind is
base , performOrdinaryCallBindThis (F,calleeContext,thisArgument). - LetconstructorEnv be the LexicalEnvironment ofcalleeContext.
- Letresult be
OrdinaryCallEvaluateBody (F,argumentsList). - RemovecalleeContext from the
execution context stack and restorecallerContext as therunning execution context . - Ifresult.[[Type]] is
return , then- If
Type (result.[[Value]]) is Object, returnNormalCompletion (result.[[Value]]). - Ifkind is
base , returnNormalCompletion (thisArgument). - Ifresult.[[Value]] is not
undefined , throw aTypeError exception.
- If
- Else,
ReturnIfAbrupt (result). - Return ?constructorEnv.GetThisBinding().
10.2.3 OrdinaryFunctionCreate (functionPrototype,sourceText,ParameterList,Body,thisMode,Scope )
The abstract operation OrdinaryFunctionCreate takes argumentsfunctionPrototype (an Object),sourceText (a sequence of Unicode code points),ParameterList (a
Assert :Type (functionPrototype) is Object.- LetinternalSlotsList be the internal slots listed in
Table 29 . - LetF be !
OrdinaryObjectCreate (functionPrototype,internalSlotsList). - SetF.[[Call]] to the definition specified in
10.2.1 . - SetF.[[SourceText]] tosourceText.
- SetF.[[FormalParameters]] toParameterList.
- SetF.[[ECMAScriptCode]] toBody.
- If the source text matchingBody is
strict mode code , letStrict betrue ; else letStrict befalse . - SetF.[[Strict]] toStrict.
- IfthisMode is
lexical-this , setF.[[ThisMode]] tolexical . - Else ifStrict is
true , setF.[[ThisMode]] tostrict . - Else, setF.[[ThisMode]] to
global . - SetF.[[IsClassConstructor]] to
false . - SetF.[[Environment]] toScope.
- SetF.[[ScriptOrModule]] to
GetActiveScriptOrModule (). - SetF.[[Realm]] to
the current Realm Record . - SetF.[[HomeObject]] to
undefined . - Letlen be the
ExpectedArgumentCount ofParameterList. - Perform !
SetFunctionLength (F,len). - ReturnF.
10.2.4 AddRestrictedFunctionProperties (F,realm )
The abstract operation AddRestrictedFunctionProperties takes argumentsF (a
Assert :realm.[[Intrinsics]].[[%ThrowTypeError% ]] exists and has been initialized.- Letthrower berealm.[[Intrinsics]].[[
%ThrowTypeError% ]]. - Perform !
DefinePropertyOrThrow (F,"caller" , PropertyDescriptor { [[Get]]:thrower, [[Set]]:thrower, [[Enumerable]]:false , [[Configurable]]:true }). - Return !
DefinePropertyOrThrow (F,"arguments" , PropertyDescriptor { [[Get]]:thrower, [[Set]]:thrower, [[Enumerable]]:false , [[Configurable]]:true }).
10.2.4.1 %ThrowTypeError% ( )
The%ThrowTypeError% intrinsic is an anonymous built-in
- Throw a
TypeError exception.
The value of the [[Extensible]] internal slot of a %ThrowTypeError% function is
The
The
10.2.5 MakeConstructor (F [ ,writablePrototype [ ,prototype ] ] )
The abstract operation MakeConstructor takes argumentF (a
Assert :F is an ECMAScriptfunction object or a built-infunction object .- IfF is an ECMAScript
function object , thenAssert :IsConstructor (F) isfalse .Assert :F is an extensible object that does not have a"prototype" own property.- SetF.[[Construct]] to the definition specified in
10.2.2 .
- SetF.[[ConstructorKind]] to
base . - IfwritablePrototype is not present, setwritablePrototype to
true . - Ifprototype is not present, then
- Setprototype to !
OrdinaryObjectCreate (%Object.prototype% ). - Perform !
DefinePropertyOrThrow (prototype,"constructor" , PropertyDescriptor { [[Value]]:F, [[Writable]]:writablePrototype, [[Enumerable]]:false , [[Configurable]]:true }).
- Setprototype to !
- Perform !
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:writablePrototype, [[Enumerable]]:false , [[Configurable]]:false }). - Return
NormalCompletion (undefined ).
10.2.6 MakeClassConstructor (F )
The abstract operation MakeClassConstructor takes argumentF. It performs the following steps when called:
Assert :F is an ECMAScriptfunction object .Assert :F.[[IsClassConstructor]] isfalse .- SetF.[[IsClassConstructor]] to
true . - Return
NormalCompletion (undefined ).
10.2.7 MakeMethod (F,homeObject )
The abstract operation MakeMethod takes argumentsF andhomeObject. It configuresF as a method. It performs the following steps when called:
Assert :F is an ECMAScriptfunction object .Assert :Type (homeObject) is Object.- SetF.[[HomeObject]] tohomeObject.
- Return
NormalCompletion (undefined ).
10.2.8 SetFunctionName (F,name [ ,prefix ] )
The abstract operation SetFunctionName takes argumentsF (a
Assert :F is an extensible object that does not have a"name" own property.Assert :Type (name) is either Symbol or String.Assert : Ifprefix is present, thenType (prefix) is String.- If
Type (name) is Symbol, then- Letdescription bename's [[Description]] value.
- Ifdescription is
undefined , setname to the empty String. - Else, setname to the
string-concatenation of"[" ,description, and"]" .
- IfF has an [[InitialName]] internal slot, then
- SetF.[[InitialName]] toname.
- Ifprefix is present, then
- Setname to the
string-concatenation ofprefix, the code unit 0x0020 (SPACE), andname. - IfF has an [[InitialName]] internal slot, then
- Optionally, setF.[[InitialName]] toname.
- Setname to the
- Return !
DefinePropertyOrThrow (F,"name" , PropertyDescriptor { [[Value]]:name, [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:true }).
10.2.9 SetFunctionLength (F,length )
The abstract operation SetFunctionLength takes argumentsF (a
Assert :F is an extensible object that does not have a"length" own property.- Return !
DefinePropertyOrThrow (F,"length" , PropertyDescriptor { [[Value]]:𝔽 (length), [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:true }).
10.2.10 FunctionDeclarationInstantiation (func,argumentsList )
When an
The abstract operation FunctionDeclarationInstantiation takes argumentsfunc (a
- LetcalleeContext be the
running execution context . - Letcode befunc.[[ECMAScriptCode]].
- Letstrict befunc.[[Strict]].
- Letformals befunc.[[FormalParameters]].
- LetparameterNames be the
BoundNames offormals. - IfparameterNames has any duplicate entries, lethasDuplicates be
true . Otherwise, lethasDuplicates befalse . - LetsimpleParameterList be
IsSimpleParameterList offormals. - LethasParameterExpressions be
ContainsExpression offormals. - LetvarNames be the
VarDeclaredNames ofcode. - LetvarDeclarations be the
VarScopedDeclarations ofcode. - LetlexicalNames be the
LexicallyDeclaredNames ofcode. - LetfunctionNames be a new empty
List . - LetfunctionsToInitialize be a new empty
List . - For each elementd ofvarDeclarations, in reverse
List order, do- Ifd is neither a
VariableDeclaration nor aForBinding nor aBindingIdentifier , thenAssert :d is either aFunctionDeclaration , aGeneratorDeclaration , anAsyncFunctionDeclaration , or anAsyncGeneratorDeclaration .- Letfn be the sole element of the
BoundNames ofd. - Iffn is not an element offunctionNames, then
- Insertfn as the first element offunctionNames.
- NOTE: If there are multiple function declarations for the same name, the last declaration is used.
- Insertd as the first element offunctionsToInitialize.
- Ifd is neither a
- LetargumentsObjectNeeded be
true . - Iffunc.[[ThisMode]] is
lexical , then- NOTE: Arrow functions never have an arguments objects.
- SetargumentsObjectNeeded to
false .
- Else if
"arguments" is an element ofparameterNames, then- SetargumentsObjectNeeded to
false .
- SetargumentsObjectNeeded to
- Else ifhasParameterExpressions is
false , then- If
"arguments" is an element offunctionNames or if"arguments" is an element oflexicalNames, then- SetargumentsObjectNeeded to
false .
- SetargumentsObjectNeeded to
- If
- Ifstrict is
true or ifhasParameterExpressions isfalse , then- NOTE: Only a single
Environment Record is needed for the parameters and top-level vars. - Letenv be the LexicalEnvironment ofcalleeContext.
- NOTE: Only a single
- Else,
- NOTE: A separate
Environment Record is needed to ensure that bindings created bydirect eval calls in the formal parameter list are outside the environment where parameters are declared. - LetcalleeEnv be the LexicalEnvironment ofcalleeContext.
- Letenv be
NewDeclarativeEnvironment (calleeEnv). Assert : The VariableEnvironment ofcalleeContext iscalleeEnv.- Set the LexicalEnvironment ofcalleeContext toenv.
- NOTE: A separate
- For each StringparamName ofparameterNames, do
- LetalreadyDeclared beenv.HasBinding(paramName).
- NOTE: Early errors ensure that duplicate parameter names can only occur in non-strict functions that do not have parameter default values or rest parameters.
- IfalreadyDeclared is
false , then- Perform !env.CreateMutableBinding(paramName,
false ). - IfhasDuplicates is
true , then- Perform !env.InitializeBinding(paramName,
undefined ).
- Perform !env.InitializeBinding(paramName,
- Perform !env.CreateMutableBinding(paramName,
- IfargumentsObjectNeeded is
true , then- Ifstrict is
true or ifsimpleParameterList isfalse , then- Letao be
CreateUnmappedArgumentsObject (argumentsList).
- Letao be
- Else,
- NOTE: A mapped argument object is only provided for non-strict functions that don't have a rest parameter, any parameter default value initializers, or any destructured parameters.
- Letao be
CreateMappedArgumentsObject (func,formals,argumentsList,env).
- Ifstrict is
true , then- Perform !env.CreateImmutableBinding(
"arguments" ,false ).
- Perform !env.CreateImmutableBinding(
- Else,
- Perform !env.CreateMutableBinding(
"arguments" ,false ).
- Perform !env.CreateMutableBinding(
- Callenv.InitializeBinding(
"arguments" ,ao). - LetparameterBindings be a
List whose elements are the elements ofparameterNames, followed by"arguments" .
- Ifstrict is
- Else,
- LetparameterBindings beparameterNames.
- LetiteratorRecord be
CreateListIteratorRecord (argumentsList). - IfhasDuplicates is
true , then- Perform ?
IteratorBindingInitialization forformals withiteratorRecord andundefined as arguments.
- Perform ?
- Else,
- Perform ?
IteratorBindingInitialization forformals withiteratorRecord andenv as arguments.
- Perform ?
- IfhasParameterExpressions is
false , then- NOTE: Only a single
Environment Record is needed for the parameters and top-level vars. - LetinstantiatedVarNames be a copy of the
List parameterBindings. - For each elementn ofvarNames, do
- Ifn is not an element ofinstantiatedVarNames, then
- Appendn toinstantiatedVarNames.
- Perform !env.CreateMutableBinding(n,
false ). - Callenv.InitializeBinding(n,
undefined ).
- Ifn is not an element ofinstantiatedVarNames, then
- LetvarEnv beenv.
- NOTE: Only a single
- Else,
- NOTE: A separate
Environment Record is needed to ensure that closures created by expressions in the formal parameter list do not have visibility of declarations in the function body. - LetvarEnv be
NewDeclarativeEnvironment (env). - Set the VariableEnvironment ofcalleeContext tovarEnv.
- LetinstantiatedVarNames be a new empty
List . - For each elementn ofvarNames, do
- Ifn is not an element ofinstantiatedVarNames, then
- Appendn toinstantiatedVarNames.
- Perform !varEnv.CreateMutableBinding(n,
false ). - Ifn is not an element ofparameterBindings or ifn is an element offunctionNames, letinitialValue be
undefined . - Else,
- LetinitialValue be !env.GetBindingValue(n,
false ).
- LetinitialValue be !env.GetBindingValue(n,
- CallvarEnv.InitializeBinding(n,initialValue).
- NOTE: A var with the same name as a formal parameter initially has the same value as the corresponding initialized parameter.
- Ifn is not an element ofinstantiatedVarNames, then
- NOTE: A separate
- NOTE: Annex
B.3.3.1 adds additional steps at this point. - Ifstrict is
false , then- LetlexEnv be
NewDeclarativeEnvironment (varEnv). - NOTE: Non-strict functions use a separate
Environment Record for top-level lexical declarations so that adirect eval can determine whether any var scoped declarations introduced by the eval code conflict with pre-existing top-level lexically scoped declarations. This is not needed for strict functions because a strictdirect eval always places all declarations into a newEnvironment Record .
- LetlexEnv be
- Else, letlexEnv bevarEnv.
- Set the LexicalEnvironment ofcalleeContext tolexEnv.
- LetlexDeclarations be the
LexicallyScopedDeclarations ofcode. - For each elementd oflexDeclarations, do
- NOTE: A lexically declared name cannot be the same as a function/generator declaration, formal parameter, or a var name. Lexically declared names are only instantiated here but not initialized.
- For each elementdn of the
BoundNames ofd, do- If
IsConstantDeclaration ofd istrue , then- Perform !lexEnv.CreateImmutableBinding(dn,
true ).
- Perform !lexEnv.CreateImmutableBinding(dn,
- Else,
- Perform !lexEnv.CreateMutableBinding(dn,
false ).
- Perform !lexEnv.CreateMutableBinding(dn,
- If
- For each
Parse Node f offunctionsToInitialize, do- Letfn be the sole element of the
BoundNames off. - Letfo be
InstantiateFunctionObject off with argumentlexEnv. - Perform !varEnv.SetMutableBinding(fn,fo,
false ).
- Letfn be the sole element of the
- Return
NormalCompletion (empty ).
Parameter
10.3 Built-in Function Objects
The built-in function objects defined in this specification may be implemented as either ECMAScript function objects (
If a built-in
Unless otherwise specified every built-in
The behaviour specified for each built-in function via algorithm steps or other means is the specification of the function body behaviour for both [[Call]] and [[Construct]] invocations of the function. However, [[Construct]] invocation is not supported by all built-in functions. For each built-in function, when invoked with [[Call]], the [[Call]]thisArgument provides the
Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function. When a built-innew expression theargumentsList parameter of the invoked [[Construct]] internal method provides the values for the built-in
Built-in functions that are not constructors do not have a
Built-in functions have an [[InitialName]] internal slot.
If a built-in
10.3.1 [[Call]] (thisArgument,argumentsList )
The [[Call]] internal method of a built-in
- LetcallerContext be the
running execution context . - IfcallerContext is not already suspended, suspendcallerContext.
- LetcalleeContext be a new
execution context . - Set the Function ofcalleeContext toF.
- LetcalleeRealm beF.[[Realm]].
- Set the
Realm ofcalleeContext tocalleeRealm. - Set the ScriptOrModule ofcalleeContext to
null . - Perform any necessary
implementation-defined initialization ofcalleeContext. - PushcalleeContext onto the
execution context stack ;calleeContext is now therunning execution context . - Letresult be the
Completion Record that is the result of evaluatingF in a manner that conforms to the specification ofF.thisArgument is thethis value,argumentsList provides the named parameters, and the NewTarget value isundefined . - RemovecalleeContext from the
execution context stack and restorecallerContext as therunning execution context . - Returnresult.
WhencalleeContext is removed from the
10.3.2 [[Construct]] (argumentsList,newTarget )
The [[Construct]] internal method of a built-in
- Letresult be the
Completion Record that is the result of evaluatingF in a manner that conforms to the specification ofF. Thethis value is uninitialized,argumentsList provides the named parameters, andnewTarget provides the NewTarget value.
10.3.3 CreateBuiltinFunction (steps,length,name,internalSlotsList [ ,realm [ ,prototype [ ,prefix ] ] ] )
The abstract operation CreateBuiltinFunction takes argumentssteps,length,name, andinternalSlotsList (a
Assert :steps is either a set of algorithm steps or other definition of a function's behaviour provided in this specification.- Ifrealm is not present orrealm is
empty , setrealm tothe current Realm Record . Assert :realm is aRealm Record .- Ifprototype is not present, setprototype torealm.[[Intrinsics]].[[
%Function.prototype% ]]. - Letfunc be a new built-in
function object that when called performs the action described bysteps. The newfunction object has internal slots whose names are the elements ofinternalSlotsList, and an [[InitialName]] internal slot. - Setfunc.[[Realm]] torealm.
- Setfunc.[[Prototype]] toprototype.
- Setfunc.[[Extensible]] to
true . - Setfunc.[[InitialName]] to
null . - Perform !
SetFunctionLength (func,length). - Ifprefix is not present, then
- Perform !
SetFunctionName (func,name).
- Perform !
- Else,
- Perform !
SetFunctionName (func,name,prefix).
- Perform !
- Returnfunc.
Each built-in function defined in this specification is created by calling the CreateBuiltinFunction abstract operation.
10.4 Built-in Exotic Object Internal Methods and Slots
This specification defines several kinds of built-in exotic objects. These objects generally behave similar to ordinary objects except for a few specific situations. The following exotic objects use the
10.4.1 Bound Function Exotic Objects
A
An object is abound function exotic object if its [[Call]] and (if applicable) [[Construct]] internal methods use the following implementations, and its other essential internal methods use the definitions found in
Bound function exotic objects do not have the internal slots of ECMAScript function objects listed in
| Internal Slot | Type | Description |
|---|---|---|
| [[BoundTargetFunction]] | Callable Object | The wrapped |
| [[BoundThis]] | Any | The value that is always passed as the |
| [[BoundArguments]] | A list of values whose elements are used as the first arguments to any call to the wrapped function. |
10.4.1.1 [[Call]] (thisArgument,argumentsList )
The [[Call]] internal method of a
10.4.1.2 [[Construct]] (argumentsList,newTarget )
The [[Construct]] internal method of a
- Lettarget beF.[[BoundTargetFunction]].
Assert :IsConstructor (target) istrue .- LetboundArgs beF.[[BoundArguments]].
- Letargs be a
List whose elements are the elements ofboundArgs, followed by the elements ofargumentsList. - If
SameValue (F,newTarget) istrue , setnewTarget totarget. - Return ?
Construct (target,args,newTarget).
10.4.1.3 BoundFunctionCreate (targetFunction,boundThis,boundArgs )
The abstract operation BoundFunctionCreate takes argumentstargetFunction,boundThis, andboundArgs. It is used to specify the creation of new
Assert :Type (targetFunction) is Object.- Letproto be ?targetFunction.[[GetPrototypeOf]]().
- LetinternalSlotsList be the internal slots listed in
Table 30 , plus [[Prototype]] and [[Extensible]]. - Letobj be !
MakeBasicObject (internalSlotsList). - Setobj.[[Prototype]] toproto.
- Setobj.[[Call]] as described in
10.4.1.1 . - If
IsConstructor (targetFunction) istrue , then- Setobj.[[Construct]] as described in
10.4.1.2 .
- Setobj.[[Construct]] as described in
- Setobj.[[BoundTargetFunction]] totargetFunction.
- Setobj.[[BoundThis]] toboundThis.
- Setobj.[[BoundArguments]] toboundArgs.
- Returnobj.
10.4.2 Array Exotic Objects
An Array object is an
A String
An object is anArray exotic object (or simply, an Array object) if its [[DefineOwnProperty]] internal method uses the following implementation, and its other essential internal methods use the definitions found in
10.4.2.1 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of an
Assert :IsPropertyKey (P) istrue .- IfP is
"length" , then- Return ?
ArraySetLength (A,Desc).
- Return ?
- Else ifP is an
array index , then- LetoldLenDesc be
OrdinaryGetOwnProperty (A,"length" ). Assert : !IsDataDescriptor (oldLenDesc) istrue .Assert :oldLenDesc.[[Configurable]] isfalse .- LetoldLen beoldLenDesc.[[Value]].
Assert :oldLen is a non-negativeintegral Number .- Letindex be !
ToUint32 (P). - Ifindex ≥oldLen andoldLenDesc.[[Writable]] is
false , returnfalse . - Letsucceeded be !
OrdinaryDefineOwnProperty (A,P,Desc). - Ifsucceeded is
false , returnfalse . - Ifindex ≥oldLen, then
- SetoldLenDesc.[[Value]] toindex +
1 𝔽. - Letsucceeded be
OrdinaryDefineOwnProperty (A,"length" ,oldLenDesc). Assert :succeeded istrue .
- SetoldLenDesc.[[Value]] toindex +
- Return
true .
- LetoldLenDesc be
- Return
OrdinaryDefineOwnProperty (A,P,Desc).
10.4.2.2 ArrayCreate (length [ ,proto ] )
The abstract operation ArrayCreate takes argumentlength (a non-negative
- Iflength > 232 - 1, throw a
RangeError exception. - Ifproto is not present, setproto to
%Array.prototype% . - LetA be !
MakeBasicObject (« [[Prototype]], [[Extensible]] »). - SetA.[[Prototype]] toproto.
- SetA.[[DefineOwnProperty]] as specified in
10.4.2.1 . - Perform !
OrdinaryDefineOwnProperty (A,"length" , PropertyDescriptor { [[Value]]:𝔽 (length), [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - ReturnA.
10.4.2.3 ArraySpeciesCreate (originalArray,length )
The abstract operation ArraySpeciesCreate takes argumentsoriginalArray andlength (a non-negative
- LetisArray be ?
IsArray (originalArray). - IfisArray is
false , return ?ArrayCreate (length). - LetC be ?
Get (originalArray,"constructor" ). - If
IsConstructor (C) istrue , then- LetthisRealm be
the current Realm Record . - LetrealmC be ?
GetFunctionRealm (C). - IfthisRealm andrealmC are not the same
Realm Record , then
- LetthisRealm be
- If
Type (C) is Object, then - IfC is
undefined , return ?ArrayCreate (length). - If
IsConstructor (C) isfalse , throw aTypeError exception. - Return ?
Construct (C, «𝔽 (length) »).
IforiginalArray was created using the standard built-in ArrayArray.prototype methods that now are defined using ArraySpeciesCreate.
10.4.2.4 ArraySetLength (A,Desc )
The abstract operation ArraySetLength takes argumentsA (an Array object) andDesc (a
- IfDesc.[[Value]] is absent, then
- Return
OrdinaryDefineOwnProperty (A,"length" ,Desc).
- Return
- LetnewLenDesc be a copy ofDesc.
- LetnewLen be ?
ToUint32 (Desc.[[Value]]). - LetnumberLen be ?
ToNumber (Desc.[[Value]]). - IfnewLen is not the same value asnumberLen, throw a
RangeError exception. - SetnewLenDesc.[[Value]] tonewLen.
- LetoldLenDesc be
OrdinaryGetOwnProperty (A,"length" ). Assert : !IsDataDescriptor (oldLenDesc) istrue .Assert :oldLenDesc.[[Configurable]] isfalse .- LetoldLen beoldLenDesc.[[Value]].
- IfnewLen ≥oldLen, then
- Return
OrdinaryDefineOwnProperty (A,"length" ,newLenDesc).
- Return
- IfoldLenDesc.[[Writable]] is
false , returnfalse . - IfnewLenDesc.[[Writable]] is absent or has the value
true , letnewWritable betrue . - Else,
- NOTE: Setting the [[Writable]] attribute to
false is deferred in case any elements cannot be deleted. - LetnewWritable be
false . - SetnewLenDesc.[[Writable]] to
true .
- NOTE: Setting the [[Writable]] attribute to
- Letsucceeded be !
OrdinaryDefineOwnProperty (A,"length" ,newLenDesc). - Ifsucceeded is
false , returnfalse . - For each own property keyP ofA that is an
array index , whose numeric value is greater than or equal tonewLen, in descending numeric index order, do- LetdeleteSucceeded be !A.[[Delete]](P).
- IfdeleteSucceeded is
false , then- SetnewLenDesc.[[Value]] to !
ToUint32 (P) +1 𝔽. - IfnewWritable is
false , setnewLenDesc.[[Writable]] tofalse . - Perform !
OrdinaryDefineOwnProperty (A,"length" ,newLenDesc). - Return
false .
- SetnewLenDesc.[[Value]] to !
- IfnewWritable is
false , then- Letsucceeded be !
OrdinaryDefineOwnProperty (A,"length" , PropertyDescriptor { [[Writable]]:false }). Assert :succeeded istrue .
- Letsucceeded be !
- Return
true .
10.4.3 String Exotic Objects
A String object is an
An object is aString exotic object (or simply, a String object) if its [[GetOwnProperty]], [[DefineOwnProperty]], and [[OwnPropertyKeys]] internal methods use the following implementations, and its other essential internal methods use the definitions found in
String exotic objects have the same internal slots as ordinary objects. They also have a [[StringData]] internal slot.
10.4.3.1 [[GetOwnProperty]] (P )
The [[GetOwnProperty]] internal method of a
Assert :IsPropertyKey (P) istrue .- Letdesc be
OrdinaryGetOwnProperty (S,P). - Ifdesc is not
undefined , returndesc. - Return !
StringGetOwnProperty (S,P).
10.4.3.2 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of a
Assert :IsPropertyKey (P) istrue .- LetstringDesc be !
StringGetOwnProperty (S,P). - IfstringDesc is not
undefined , then- Letextensible beS.[[Extensible]].
- Return !
IsCompatiblePropertyDescriptor (extensible,Desc,stringDesc).
- Return !
OrdinaryDefineOwnProperty (S,P,Desc).
10.4.3.3 [[OwnPropertyKeys]] ( )
The [[OwnPropertyKeys]] internal method of a
- Letkeys be a new empty
List . - Letstr beO.[[StringData]].
Assert :Type (str) is String.- Letlen be the length ofstr.
- For each
integer i starting with 0 such thati <len, in ascending order, do - For each own property keyP ofO such thatP is an
array index and !ToIntegerOrInfinity (P) ≥len, in ascending numeric index order, do- AddP as the last element ofkeys.
- For each own property keyP ofO such that
Type (P) is String andP is not anarray index , in ascending chronological order of property creation, do- AddP as the last element ofkeys.
- For each own property keyP ofO such that
Type (P) is Symbol, in ascending chronological order of property creation, do- AddP as the last element ofkeys.
- Returnkeys.
10.4.3.4 StringCreate (value,prototype )
The abstract operation StringCreate takes argumentsvalue (a String) andprototype. It is used to specify the creation of new String exotic objects. It performs the following steps when called:
- LetS be !
MakeBasicObject (« [[Prototype]], [[Extensible]], [[StringData]] »). - SetS.[[Prototype]] toprototype.
- SetS.[[StringData]] tovalue.
- SetS.[[GetOwnProperty]] as specified in
10.4.3.1 . - SetS.[[DefineOwnProperty]] as specified in
10.4.3.2 . - SetS.[[OwnPropertyKeys]] as specified in
10.4.3.3 . - Letlength be the number of code unit elements invalue.
- Perform !
DefinePropertyOrThrow (S,"length" , PropertyDescriptor { [[Value]]:𝔽 (length), [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:false }). - ReturnS.
10.4.3.5 StringGetOwnProperty (S,P )
The abstract operation StringGetOwnProperty takes argumentsS andP. It performs the following steps when called:
Assert :S is an Object that has a [[StringData]] internal slot.Assert :IsPropertyKey (P) istrue .- If
Type (P) is not String, returnundefined . - Letindex be !
CanonicalNumericIndexString (P). - Ifindex is
undefined , returnundefined . - If
IsIntegralNumber (index) isfalse , returnundefined . - Ifindex is
-0 𝔽, returnundefined . - Letstr beS.[[StringData]].
Assert :Type (str) is String.- Letlen be the length ofstr.
- If
ℝ (index) < 0 orlen ≤ℝ (index), returnundefined . - LetresultStr be the String value of length 1, containing one code unit fromstr, specifically the code unit at index
ℝ (index). - Return the PropertyDescriptor { [[Value]]:resultStr, [[Writable]]:
false , [[Enumerable]]:true , [[Configurable]]:false }.
10.4.4 Arguments Exotic Objects
Most ECMAScript functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an
An object is anarguments exotic object if its internal methods use the following implementations, with the ones not specified here using those found in
While
Arguments exotic objects have the same internal slots as ordinary objects. They also have a [[ParameterMap]] internal slot. Ordinary arguments objects also have a [[ParameterMap]] internal slot whose value is always undefined. For ordinary argument objects the [[ParameterMap]] internal slot is only used byObject.prototype.toString (
The
The ParameterMap object and its property values are used as a device for specifying the arguments object correspondence to argument bindings. The ParameterMap object and the objects that are the values of its properties are not directly observable from ECMAScript code. An ECMAScript implementation does not need to actually create or use such objects to implement the specified semantics.
Ordinary arguments objects define a non-configurable
ECMAScript implementations of arguments exotic objects have historically contained an
10.4.4.1 [[GetOwnProperty]] (P )
The [[GetOwnProperty]] internal method of an
- Letdesc be
OrdinaryGetOwnProperty (args,P). - Ifdesc is
undefined , returndesc. - Letmap beargs.[[ParameterMap]].
- LetisMapped be !
HasOwnProperty (map,P). - IfisMapped is
true , then- Setdesc.[[Value]] to
Get (map,P).
- Setdesc.[[Value]] to
- Returndesc.
10.4.4.2 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of an
- Letmap beargs.[[ParameterMap]].
- LetisMapped be
HasOwnProperty (map,P). - LetnewArgDesc beDesc.
- IfisMapped is
true andIsDataDescriptor (Desc) istrue , then- IfDesc.[[Value]] is not present andDesc.[[Writable]] is present and its value is
false , then- SetnewArgDesc to a copy ofDesc.
- SetnewArgDesc.[[Value]] to
Get (map,P).
- IfDesc.[[Value]] is not present andDesc.[[Writable]] is present and its value is
- Letallowed be ?
OrdinaryDefineOwnProperty (args,P,newArgDesc). - Ifallowed is
false , returnfalse . - IfisMapped is
true , then- If
IsAccessorDescriptor (Desc) istrue , then- Callmap.[[Delete]](P).
- Else,
- If
- Return
true .
10.4.4.3 [[Get]] (P,Receiver )
The [[Get]] internal method of an
- Letmap beargs.[[ParameterMap]].
- LetisMapped be !
HasOwnProperty (map,P). - IfisMapped is
false , then- Return ?
OrdinaryGet (args,P,Receiver).
- Return ?
- Else,
10.4.4.4 [[Set]] (P,V,Receiver )
The [[Set]] internal method of an
- If
SameValue (args,Receiver) isfalse , then- LetisMapped be
false .
- LetisMapped be
- Else,
- Letmap beargs.[[ParameterMap]].
- LetisMapped be !
HasOwnProperty (map,P).
- IfisMapped is
true , then - Return ?
OrdinarySet (args,P,V,Receiver).
10.4.4.5 [[Delete]] (P )
The [[Delete]] internal method of an
- Letmap beargs.[[ParameterMap]].
- LetisMapped be !
HasOwnProperty (map,P). - Letresult be ?
OrdinaryDelete (args,P). - Ifresult is
true andisMapped istrue , then- Callmap.[[Delete]](P).
- Returnresult.
10.4.4.6 CreateUnmappedArgumentsObject (argumentsList )
The abstract operation CreateUnmappedArgumentsObject takes argumentargumentsList. It performs the following steps when called:
- Letlen be the number of elements inargumentsList.
- Letobj be !
OrdinaryObjectCreate (%Object.prototype% , « [[ParameterMap]] »). - Setobj.[[ParameterMap]] to
undefined . - Perform
DefinePropertyOrThrow (obj,"length" , PropertyDescriptor { [[Value]]:𝔽 (len), [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - Letindex be 0.
- Repeat, whileindex <len,
- Letval beargumentsList[index].
- Perform !
CreateDataPropertyOrThrow (obj, !ToString (𝔽 (index)),val). - Setindex toindex + 1.
- Perform !
DefinePropertyOrThrow (obj,@@iterator , PropertyDescriptor { [[Value]]: %Array.prototype.values%, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - Perform !
DefinePropertyOrThrow (obj,"callee" , PropertyDescriptor { [[Get]]:%ThrowTypeError% , [[Set]]:%ThrowTypeError% , [[Enumerable]]:false , [[Configurable]]:false }). - Returnobj.
10.4.4.7 CreateMappedArgumentsObject (func,formals,argumentsList,env )
The abstract operation CreateMappedArgumentsObject takes argumentsfunc (an Object),formals (a
Assert :formals does not contain a rest parameter, any binding patterns, or any initializers. It may contain duplicate identifiers.- Letlen be the number of elements inargumentsList.
- Letobj be !
MakeBasicObject (« [[Prototype]], [[Extensible]], [[ParameterMap]] »). - Setobj.[[GetOwnProperty]] as specified in
10.4.4.1 . - Setobj.[[DefineOwnProperty]] as specified in
10.4.4.2 . - Setobj.[[Get]] as specified in
10.4.4.3 . - Setobj.[[Set]] as specified in
10.4.4.4 . - Setobj.[[Delete]] as specified in
10.4.4.5 . - Setobj.[[Prototype]] to
%Object.prototype% . - Letmap be !
OrdinaryObjectCreate (null ). - Setobj.[[ParameterMap]] tomap.
- LetparameterNames be the
BoundNames offormals. - LetnumberOfParameters be the number of elements inparameterNames.
- Letindex be 0.
- Repeat, whileindex <len,
- Letval beargumentsList[index].
- Perform !
CreateDataPropertyOrThrow (obj, !ToString (𝔽 (index)),val). - Setindex toindex + 1.
- Perform !
DefinePropertyOrThrow (obj,"length" , PropertyDescriptor { [[Value]]:𝔽 (len), [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - LetmappedNames be a new empty
List . - Letindex benumberOfParameters - 1.
- Repeat, whileindex ≥ 0,
- Letname beparameterNames[index].
- Ifname is not an element ofmappedNames, then
- Addname as an element of the listmappedNames.
- Ifindex <len, then
- Letg be
MakeArgGetter (name,env). - Letp be
MakeArgSetter (name,env). - Performmap.[[DefineOwnProperty]](!
ToString (𝔽 (index)), PropertyDescriptor { [[Set]]:p, [[Get]]:g, [[Enumerable]]:false , [[Configurable]]:true }).
- Letg be
- Setindex toindex - 1.
- Perform !
DefinePropertyOrThrow (obj,@@iterator , PropertyDescriptor { [[Value]]: %Array.prototype.values%, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - Perform !
DefinePropertyOrThrow (obj,"callee" , PropertyDescriptor { [[Value]]:func, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:true }). - Returnobj.
10.4.4.7.1 MakeArgGetter (name,env )
The abstract operation MakeArgGetter takes argumentsname (a String) andenv (an
- Letsteps be the steps of an ArgGetter function as specified below.
- Letlength be the number of non-optional parameters of an ArgGetter function as specified below.
- Letgetter be !
CreateBuiltinFunction (steps,length,"" , « [[Name]], [[Env]] »). - Setgetter.[[Name]] toname.
- Setgetter.[[Env]] toenv.
- Returngetter.
An ArgGetter function is an anonymous built-in function with [[Name]] and [[Env]] internal slots. When an ArgGetter function that expects no arguments is called it performs the following steps:
- Letf be the
active function object . - Letname bef.[[Name]].
- Letenv bef.[[Env]].
- Returnenv.GetBindingValue(name,
false ).
ArgGetter functions are never directly accessible to ECMAScript code.
10.4.4.7.2 MakeArgSetter (name,env )
The abstract operation MakeArgSetter takes argumentsname (a String) andenv (an
- Letsteps be the steps of an ArgSetter function as specified below.
- Letlength be the number of non-optional parameters of an ArgSetter function as specified below.
- Letsetter be !
CreateBuiltinFunction (steps,length,"" , « [[Name]], [[Env]] »). - Setsetter.[[Name]] toname.
- Setsetter.[[Env]] toenv.
- Returnsetter.
An ArgSetter function is an anonymous built-in function with [[Name]] and [[Env]] internal slots. When an ArgSetter function is called with argumentvalue it performs the following steps:
- Letf be the
active function object . - Letname bef.[[Name]].
- Letenv bef.[[Env]].
- Returnenv.SetMutableBinding(name,value,
false ).
ArgSetter functions are never directly accessible to ECMAScript code.
10.4.5 Integer-Indexed Exotic Objects
An
An object is anInteger-Indexed exotic object if its [[GetOwnProperty]], [[HasProperty]], [[DefineOwnProperty]], [[Get]], [[Set]], [[Delete]], and [[OwnPropertyKeys]] internal methods use the definitions in this section, and its other essential internal methods use the definitions found in
10.4.5.1 [[GetOwnProperty]] (P )
The [[GetOwnProperty]] internal method of an
Assert :IsPropertyKey (P) istrue .Assert :O is anInteger-Indexed exotic object .- If
Type (P) is String, then- LetnumericIndex be !
CanonicalNumericIndexString (P). - IfnumericIndex is not
undefined , then- Letvalue be !
IntegerIndexedElementGet (O,numericIndex). - Ifvalue is
undefined , returnundefined . - Return the PropertyDescriptor { [[Value]]:value, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:true }.
- Letvalue be !
- LetnumericIndex be !
- Return
OrdinaryGetOwnProperty (O,P).
10.4.5.2 [[HasProperty]] (P )
The [[HasProperty]] internal method of an
Assert :IsPropertyKey (P) istrue .Assert :O is anInteger-Indexed exotic object .- If
Type (P) is String, then- LetnumericIndex be !
CanonicalNumericIndexString (P). - IfnumericIndex is not
undefined , return !IsValidIntegerIndex (O,numericIndex).
- LetnumericIndex be !
- Return ?
OrdinaryHasProperty (O,P).
10.4.5.3 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of an
Assert :IsPropertyKey (P) istrue .Assert :O is anInteger-Indexed exotic object .- If
Type (P) is String, then- LetnumericIndex be !
CanonicalNumericIndexString (P). - IfnumericIndex is not
undefined , then- If !
IsValidIntegerIndex (O,numericIndex) isfalse , returnfalse . - IfDesc has a [[Configurable]] field and ifDesc.[[Configurable]] is
false , returnfalse . - IfDesc has an [[Enumerable]] field and ifDesc.[[Enumerable]] is
false , returnfalse . - If !
IsAccessorDescriptor (Desc) istrue , returnfalse . - IfDesc has a [[Writable]] field and ifDesc.[[Writable]] is
false , returnfalse . - IfDesc has a [[Value]] field, perform ?
IntegerIndexedElementSet (O,numericIndex,Desc.[[Value]]). - Return
true .
- If !
- LetnumericIndex be !
- Return !
OrdinaryDefineOwnProperty (O,P,Desc).
10.4.5.4 [[Get]] (P,Receiver )
The [[Get]] internal method of an
Assert :IsPropertyKey (P) istrue .- If
Type (P) is String, then- LetnumericIndex be !
CanonicalNumericIndexString (P). - IfnumericIndex is not
undefined , then- Return !
IntegerIndexedElementGet (O,numericIndex).
- Return !
- LetnumericIndex be !
- Return ?
OrdinaryGet (O,P,Receiver).
10.4.5.5 [[Set]] (P,V,Receiver )
The [[Set]] internal method of an
Assert :IsPropertyKey (P) istrue .- If
Type (P) is String, then- LetnumericIndex be !
CanonicalNumericIndexString (P). - IfnumericIndex is not
undefined , then- Perform ?
IntegerIndexedElementSet (O,numericIndex,V). - Return
true .
- Perform ?
- LetnumericIndex be !
- Return ?
OrdinarySet (O,P,V,Receiver).
10.4.5.6 [[Delete]] (P )
The [[Delete]] internal method of an
Assert :IsPropertyKey (P) istrue .Assert :O is anInteger-Indexed exotic object .- If
Type (P) is String, then- LetnumericIndex be !
CanonicalNumericIndexString (P). - IfnumericIndex is not
undefined , then- If !
IsValidIntegerIndex (O,numericIndex) isfalse , returntrue ; else returnfalse .
- If !
- LetnumericIndex be !
- Return ?
OrdinaryDelete (O,P).
10.4.5.7 [[OwnPropertyKeys]] ( )
The [[OwnPropertyKeys]] internal method of an
- Letkeys be a new empty
List . Assert :O is anInteger-Indexed exotic object .- If
IsDetachedBuffer (O.[[ViewedArrayBuffer]]) isfalse , then - For each own property keyP ofO such that
Type (P) is String andP is not aninteger index , in ascending chronological order of property creation, do- AddP as the last element ofkeys.
- For each own property keyP ofO such that
Type (P) is Symbol, in ascending chronological order of property creation, do- AddP as the last element ofkeys.
- Returnkeys.
10.4.5.8 IntegerIndexedObjectCreate (prototype )
The abstract operation IntegerIndexedObjectCreate takes argumentprototype. It is used to specify the creation of new
- LetinternalSlotsList be « [[Prototype]], [[Extensible]], [[ViewedArrayBuffer]], [[TypedArrayName]], [[ContentType]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] ».
- LetA be !
MakeBasicObject (internalSlotsList). - SetA.[[GetOwnProperty]] as specified in
10.4.5.1 . - SetA.[[HasProperty]] as specified in
10.4.5.2 . - SetA.[[DefineOwnProperty]] as specified in
10.4.5.3 . - SetA.[[Get]] as specified in
10.4.5.4 . - SetA.[[Set]] as specified in
10.4.5.5 . - SetA.[[Delete]] as specified in
10.4.5.6 . - SetA.[[OwnPropertyKeys]] as specified in
10.4.5.7 . - SetA.[[Prototype]] toprototype.
- ReturnA.
10.4.5.9 IsValidIntegerIndex (O,index )
The abstract operation IsValidIntegerIndex takes argumentsO andindex (a Number). It performs the following steps when called:
Assert :O is anInteger-Indexed exotic object .- If
IsDetachedBuffer (O.[[ViewedArrayBuffer]]) istrue , returnfalse . - If !
IsIntegralNumber (index) isfalse , returnfalse . - Ifindex is
-0 𝔽, returnfalse . - If
ℝ (index) < 0 orℝ (index) ≥O.[[ArrayLength]], returnfalse . - Return
true .
10.4.5.10 IntegerIndexedElementGet (O,index )
The abstract operation IntegerIndexedElementGet takes argumentsO andindex (a Number). It performs the following steps when called:
Assert :O is anInteger-Indexed exotic object .- If !
IsValidIntegerIndex (O,index) isfalse , returnundefined . - Letoffset beO.[[ByteOffset]].
- LetarrayTypeName be the String value ofO.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 forarrayTypeName. - LetindexedPosition be (
ℝ (index) ×elementSize) +offset. - LetelementType be the Element Type value in
Table 60 forarrayTypeName. - Return
GetValueFromBuffer (O.[[ViewedArrayBuffer]],indexedPosition,elementType,true ,Unordered ).
10.4.5.11 IntegerIndexedElementSet (O,index,value )
The abstract operation IntegerIndexedElementSet takes argumentsO,index (a Number), andvalue. It performs the following steps when called:
Assert :O is anInteger-Indexed exotic object .- IfO.[[ContentType]] is
BigInt , letnumValue be ?ToBigInt (value). - Otherwise, letnumValue be ?
ToNumber (value). - If !
IsValidIntegerIndex (O,index) istrue , then- Letoffset beO.[[ByteOffset]].
- LetarrayTypeName be the String value ofO.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 forarrayTypeName. - LetindexedPosition be (
ℝ (index) ×elementSize) +offset. - LetelementType be the Element Type value in
Table 60 forarrayTypeName. - Perform
SetValueInBuffer (O.[[ViewedArrayBuffer]],indexedPosition,elementType,numValue,true ,Unordered ).
- Return
NormalCompletion (undefined ).
This operation always appears to succeed, but it has no effect when attempting to write past the end of a TypedArray or to a TypedArray which is backed by a detached ArrayBuffer.
10.4.6 Module Namespace Exotic Objects
Aexport * export items. Each String-valued own property key is the
An object is amodule namespace exotic object if its [[SetPrototypeOf]], [[IsExtensible]], [[PreventExtensions]], [[GetOwnProperty]], [[DefineOwnProperty]], [[HasProperty]], [[Get]], [[Set]], [[Delete]], and [[OwnPropertyKeys]] internal methods use the definitions in this section, and its other essential internal methods use the definitions found in
Module namespace exotic objects have the internal slots defined in
| Internal Slot | Type | Description |
|---|---|---|
| [[Module]] | The | |
| [[Exports]] | A | |
| [[Prototype]] | Null | This slot always contains the value |
Module namespace exotic objects provide alternative definitions for all of the internal methods except [[GetPrototypeOf]], which behaves as defined in
10.4.6.1 [[SetPrototypeOf]] (V )
The [[SetPrototypeOf]] internal method of a
- Return ?
SetImmutablePrototype (O,V).
10.4.6.2 [[IsExtensible]] ( )
The [[IsExtensible]] internal method of a
- Return
false .
10.4.6.3 [[PreventExtensions]] ( )
The [[PreventExtensions]] internal method of a
- Return
true .
10.4.6.4 [[GetOwnProperty]] (P )
The [[GetOwnProperty]] internal method of a
- If
Type (P) is Symbol, returnOrdinaryGetOwnProperty (O,P). - Letexports beO.[[Exports]].
- IfP is not an element ofexports, return
undefined . - Letvalue be ?O.[[Get]](P,O).
- Return PropertyDescriptor { [[Value]]:value, [[Writable]]:
true , [[Enumerable]]:true , [[Configurable]]:false }.
10.4.6.5 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of a
- If
Type (P) is Symbol, returnOrdinaryDefineOwnProperty (O,P,Desc). - Letcurrent be ?O.[[GetOwnProperty]](P).
- Ifcurrent is
undefined , returnfalse . - IfDesc.[[Configurable]] is present and has value
true , returnfalse . - IfDesc.[[Enumerable]] is present and has value
false , returnfalse . - If !
IsAccessorDescriptor (Desc) istrue , returnfalse . - IfDesc.[[Writable]] is present and has value
false , returnfalse . - IfDesc.[[Value]] is present, return
SameValue (Desc.[[Value]],current.[[Value]]). - Return
true .
10.4.6.6 [[HasProperty]] (P )
The [[HasProperty]] internal method of a
- If
Type (P) is Symbol, returnOrdinaryHasProperty (O,P). - Letexports beO.[[Exports]].
- IfP is an element ofexports, return
true . - Return
false .
10.4.6.7 [[Get]] (P,Receiver )
The [[Get]] internal method of a
Assert :IsPropertyKey (P) istrue .- If
Type (P) is Symbol, then- Return ?
OrdinaryGet (O,P,Receiver).
- Return ?
- Letexports beO.[[Exports]].
- IfP is not an element ofexports, return
undefined . - Letm beO.[[Module]].
- Letbinding be !m.ResolveExport(P).
Assert :binding is aResolvedBinding Record .- LettargetModule bebinding.[[Module]].
Assert :targetModule is notundefined .- Ifbinding.[[BindingName]] is
"*namespace*" , then- Return ?
GetModuleNamespace (targetModule).
- Return ?
- LettargetEnv betargetModule.[[Environment]].
- IftargetEnv is
undefined , throw aReferenceError exception. - Return ?targetEnv.GetBindingValue(binding.[[BindingName]],
true ).
ResolveExport is side-effect free. Each time this operation is called with a specificexportName,resolveSet pair as arguments it must return the same result. An implementation might choose to pre-compute or cache the ResolveExport results for the [[Exports]] of each
10.4.6.8 [[Set]] (P,V,Receiver )
The [[Set]] internal method of a
- Return
false .
10.4.6.9 [[Delete]] (P )
The [[Delete]] internal method of a
Assert :IsPropertyKey (P) istrue .- If
Type (P) is Symbol, then- Return ?
OrdinaryDelete (O,P).
- Return ?
- Letexports beO.[[Exports]].
- IfP is an element ofexports, return
false . - Return
true .
10.4.6.10 [[OwnPropertyKeys]] ( )
The [[OwnPropertyKeys]] internal method of a
- Letexports be a copy ofO.[[Exports]].
- LetsymbolKeys be !
OrdinaryOwnPropertyKeys (O). - Append all the entries ofsymbolKeys to the end ofexports.
- Returnexports.
10.4.6.11 ModuleNamespaceCreate (module,exports )
The abstract operation ModuleNamespaceCreate takes argumentsmodule andexports. It is used to specify the creation of new module namespace exotic objects. It performs the following steps when called:
Assert :module is aModule Record .Assert :module.[[Namespace]] isundefined .Assert :exports is aList of String values.- LetinternalSlotsList be the internal slots listed in
Table 31 . - LetM be !
MakeBasicObject (internalSlotsList). - SetM's essential internal methods to the definitions specified in
10.4.6 . - SetM.[[Prototype]] to
null . - SetM.[[Module]] tomodule.
- LetsortedExports be a
List whose elements are the elements ofexports ordered as if an Array of the same values had been sorted using %Array.prototype.sort% usingundefined ascomparefn. - SetM.[[Exports]] tosortedExports.
- Create own properties ofM corresponding to the definitions in
28.3 . - Setmodule.[[Namespace]] toM.
- ReturnM.
10.4.7 Immutable Prototype Exotic Objects
An
An object is animmutable prototype exotic object if its [[SetPrototypeOf]] internal method uses the following implementation. (Its other essential internal methods may use any implementation, depending on the specific
Unlike other exotic objects, there is not a dedicated creation abstract operation provided for immutable prototype exotic objects. This is because they are only used by
10.4.7.1 [[SetPrototypeOf]] (V )
The [[SetPrototypeOf]] internal method of an
- Return ?
SetImmutablePrototype (O,V).
10.4.7.2 SetImmutablePrototype (O,V )
The abstract operation SetImmutablePrototype takes argumentsO andV. It performs the following steps when called:
10.5 Proxy Object Internal Methods and Internal Slots
A proxy object is an
An object is aProxy exotic object if its essential internal methods (including [[Call]] and [[Construct]], if applicable) use the definitions in this section. These internal methods are installed in
| Internal Method | Handler Method |
|---|---|
| [[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 |
When a handler method is called to provide the implementation of a proxy object internal method, the handler method is passed the proxy's target object as a parameter. A proxy's handler object does not necessarily have a method corresponding to every essential internal method. Invoking an internal method on the proxy results in the invocation of the corresponding internal method on the proxy's target object if the handler object does not have a method corresponding to the internal trap.
The [[ProxyHandler]] and [[ProxyTarget]] internal slots of a proxy object are always initialized when the object is created and typically may not be modified. Some proxy objects are created in a manner that permits them to be subsequentlyrevoked. When a proxy is revoked, its [[ProxyHandler]] and [[ProxyTarget]] internal slots are set to
Because proxy objects permit the implementation of internal methods to be provided by arbitrary ECMAScript code, it is possible to define a proxy object whose handler methods violates the invariants defined in
In the following algorithm descriptions, assumeO is an ECMAScript proxy object,P is a property key value,V is any
10.5.1 [[GetPrototypeOf]] ( )
The [[GetPrototypeOf]] internal method of a
- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"getPrototypeOf" ). - Iftrap is
undefined , then- Return ?target.[[GetPrototypeOf]]().
- LethandlerProto be ?
Call (trap,handler, «target »). - If
Type (handlerProto) is neither Object nor Null, throw aTypeError exception. - LetextensibleTarget be ?
IsExtensible (target). - IfextensibleTarget is
true , returnhandlerProto. - LettargetProto be ?target.[[GetPrototypeOf]]().
- If
SameValue (handlerProto,targetProto) isfalse , throw aTypeError exception. - ReturnhandlerProto.
[[GetPrototypeOf]] for proxy objects enforces the following invariants:
- The result of [[GetPrototypeOf]] must be either an Object or
null . - If the target object is not extensible, [[GetPrototypeOf]] applied to the proxy object must return the same value as [[GetPrototypeOf]] applied to the proxy object's target object.
10.5.2 [[SetPrototypeOf]] (V )
The [[SetPrototypeOf]] internal method of a
Assert : EitherType (V) is Object orType (V) is Null.- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"setPrototypeOf" ). - Iftrap is
undefined , then- Return ?target.[[SetPrototypeOf]](V).
- LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target,V »)). - IfbooleanTrapResult is
false , returnfalse . - LetextensibleTarget be ?
IsExtensible (target). - IfextensibleTarget is
true , returntrue . - LettargetProto be ?target.[[GetPrototypeOf]]().
- If
SameValue (V,targetProto) isfalse , throw aTypeError exception. - Return
true .
[[SetPrototypeOf]] for proxy objects enforces the following invariants:
- The result of [[SetPrototypeOf]] is a Boolean value.
- If the target object is not extensible, the argument value must be the same as the result of [[GetPrototypeOf]] applied to target object.
10.5.3 [[IsExtensible]] ( )
The [[IsExtensible]] internal method of a
- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"isExtensible" ). - Iftrap is
undefined , then- Return ?
IsExtensible (target).
- Return ?
- LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target »)). - LettargetResult be ?
IsExtensible (target). - If
SameValue (booleanTrapResult,targetResult) isfalse , throw aTypeError exception. - ReturnbooleanTrapResult.
[[IsExtensible]] for proxy objects enforces the following invariants:
- The result of [[IsExtensible]] is a Boolean value.
- [[IsExtensible]] applied to the proxy object must return the same value as [[IsExtensible]] applied to the proxy object's target object with the same argument.
10.5.4 [[PreventExtensions]] ( )
The [[PreventExtensions]] internal method of a
- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"preventExtensions" ). - Iftrap is
undefined , then- Return ?target.[[PreventExtensions]]().
- LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target »)). - IfbooleanTrapResult is
true , then- LetextensibleTarget be ?
IsExtensible (target). - IfextensibleTarget is
true , throw aTypeError exception.
- LetextensibleTarget be ?
- ReturnbooleanTrapResult.
[[PreventExtensions]] for proxy objects enforces the following invariants:
- The result of [[PreventExtensions]] is a Boolean value.
- [[PreventExtensions]] applied to the proxy object only returns
true if [[IsExtensible]] applied to the proxy object's target object isfalse .
10.5.5 [[GetOwnProperty]] (P )
The [[GetOwnProperty]] internal method of a
Assert :IsPropertyKey (P) istrue .- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"getOwnPropertyDescriptor" ). - Iftrap is
undefined , then- Return ?target.[[GetOwnProperty]](P).
- LettrapResultObj be ?
Call (trap,handler, «target,P »). - If
Type (trapResultObj) is neither Object nor Undefined, throw aTypeError exception. - LettargetDesc be ?target.[[GetOwnProperty]](P).
- IftrapResultObj is
undefined , then- IftargetDesc is
undefined , returnundefined . - IftargetDesc.[[Configurable]] is
false , throw aTypeError exception. - LetextensibleTarget be ?
IsExtensible (target). - IfextensibleTarget is
false , throw aTypeError exception. - Return
undefined .
- IftargetDesc is
- LetextensibleTarget be ?
IsExtensible (target). - LetresultDesc be ?
ToPropertyDescriptor (trapResultObj). - Call
CompletePropertyDescriptor (resultDesc). - Letvalid be
IsCompatiblePropertyDescriptor (extensibleTarget,resultDesc,targetDesc). - Ifvalid is
false , throw aTypeError exception. - IfresultDesc.[[Configurable]] is
false , then- IftargetDesc is
undefined ortargetDesc.[[Configurable]] istrue , then- Throw a
TypeError exception.
- Throw a
- IfresultDesc has a [[Writable]] field andresultDesc.[[Writable]] is
false , then- IftargetDesc.[[Writable]] is
true , throw aTypeError exception.
- IftargetDesc.[[Writable]] is
- IftargetDesc is
- ReturnresultDesc.
[[GetOwnProperty]] for proxy objects enforces the following invariants:
- The result of [[GetOwnProperty]] must be either an Object or
undefined . - A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.
- A property cannot be reported as non-existent, if the target object is not extensible, unless it does not exist as an own property of the target object.
- A property cannot be reported as existent, if the target object is not extensible, unless it exists as an own property of the target object.
- A property cannot be reported as non-configurable, unless it exists as a non-configurable own property of the target object.
- A property cannot be reported as both non-configurable and non-writable, unless it exists as a non-configurable, non-writable own property of the target object.
10.5.6 [[DefineOwnProperty]] (P,Desc )
The [[DefineOwnProperty]] internal method of a
Assert :IsPropertyKey (P) istrue .- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"defineProperty" ). - Iftrap is
undefined , then- Return ?target.[[DefineOwnProperty]](P,Desc).
- LetdescObj be
FromPropertyDescriptor (Desc). - LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target,P,descObj »)). - IfbooleanTrapResult is
false , returnfalse . - LettargetDesc be ?target.[[GetOwnProperty]](P).
- LetextensibleTarget be ?
IsExtensible (target). - IfDesc has a [[Configurable]] field and ifDesc.[[Configurable]] is
false , then- LetsettingConfigFalse be
true .
- LetsettingConfigFalse be
- Else, letsettingConfigFalse be
false . - IftargetDesc is
undefined , then- IfextensibleTarget is
false , throw aTypeError exception. - IfsettingConfigFalse is
true , throw aTypeError exception.
- IfextensibleTarget is
- Else,
- If
IsCompatiblePropertyDescriptor (extensibleTarget,Desc,targetDesc) isfalse , throw aTypeError exception. - IfsettingConfigFalse is
true andtargetDesc.[[Configurable]] istrue , throw aTypeError exception. - If
IsDataDescriptor (targetDesc) istrue ,targetDesc.[[Configurable]] isfalse , andtargetDesc.[[Writable]] istrue , then- IfDesc has a [[Writable]] field andDesc.[[Writable]] is
false , throw aTypeError exception.
- IfDesc has a [[Writable]] field andDesc.[[Writable]] is
- If
- Return
true .
[[DefineOwnProperty]] for proxy objects enforces the following invariants:
- The result of [[DefineOwnProperty]] is a Boolean value.
- A property cannot be added, if the target object is not extensible.
- A property cannot be non-configurable, unless there exists a corresponding non-configurable own property of the target object.
- A non-configurable property cannot be non-writable, unless there exists a corresponding non-configurable, non-writable own property of the target object.
- If a property has a corresponding target object property then applying the
Property Descriptor of the property to the target object using [[DefineOwnProperty]] will not throw an exception.
10.5.7 [[HasProperty]] (P )
The [[HasProperty]] internal method of a
Assert :IsPropertyKey (P) istrue .- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"has" ). - Iftrap is
undefined , then- Return ?target.[[HasProperty]](P).
- LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target,P »)). - IfbooleanTrapResult is
false , then- LettargetDesc be ?target.[[GetOwnProperty]](P).
- IftargetDesc is not
undefined , then- IftargetDesc.[[Configurable]] is
false , throw aTypeError exception. - LetextensibleTarget be ?
IsExtensible (target). - IfextensibleTarget is
false , throw aTypeError exception.
- IftargetDesc.[[Configurable]] is
- ReturnbooleanTrapResult.
[[HasProperty]] for proxy objects enforces the following invariants:
- The result of [[HasProperty]] is a Boolean value.
- A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object.
- A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible.
10.5.8 [[Get]] (P,Receiver )
The [[Get]] internal method of a
Assert :IsPropertyKey (P) istrue .- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"get" ). - Iftrap is
undefined , then- Return ?target.[[Get]](P,Receiver).
- LettrapResult be ?
Call (trap,handler, «target,P,Receiver »). - LettargetDesc be ?target.[[GetOwnProperty]](P).
- IftargetDesc is not
undefined andtargetDesc.[[Configurable]] isfalse , then- If
IsDataDescriptor (targetDesc) istrue andtargetDesc.[[Writable]] isfalse , then- If
SameValue (trapResult,targetDesc.[[Value]]) isfalse , throw aTypeError exception.
- If
- If
IsAccessorDescriptor (targetDesc) istrue andtargetDesc.[[Get]] isundefined , then- IftrapResult is not
undefined , throw aTypeError exception.
- IftrapResult is not
- If
- ReturntrapResult.
[[Get]] for proxy objects enforces the following invariants:
- The value reported for a property must be the same as the value of the corresponding target object property if the target object property is a non-writable, non-configurable own
data property . - The value reported for a property must be
undefined if the corresponding target object property is a non-configurable ownaccessor property that hasundefined as its [[Get]] attribute.
10.5.9 [[Set]] (P,V,Receiver )
The [[Set]] internal method of a
Assert :IsPropertyKey (P) istrue .- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"set" ). - Iftrap is
undefined , then- Return ?target.[[Set]](P,V,Receiver).
- LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target,P,V,Receiver »)). - IfbooleanTrapResult is
false , returnfalse . - LettargetDesc be ?target.[[GetOwnProperty]](P).
- IftargetDesc is not
undefined andtargetDesc.[[Configurable]] isfalse , then- If
IsDataDescriptor (targetDesc) istrue andtargetDesc.[[Writable]] isfalse , then- If
SameValue (V,targetDesc.[[Value]]) isfalse , throw aTypeError exception.
- If
- If
IsAccessorDescriptor (targetDesc) istrue , then- IftargetDesc.[[Set]] is
undefined , throw aTypeError exception.
- IftargetDesc.[[Set]] is
- If
- Return
true .
[[Set]] for proxy objects enforces the following invariants:
- The result of [[Set]] is a Boolean value.
- Cannot change the value of a property to be different from the value of the corresponding target object property if the corresponding target object property is a non-writable, non-configurable own
data property . - Cannot set the value of a property if the corresponding target object property is a non-configurable own
accessor property that hasundefined as its [[Set]] attribute.
10.5.10 [[Delete]] (P )
The [[Delete]] internal method of a
Assert :IsPropertyKey (P) istrue .- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"deleteProperty" ). - Iftrap is
undefined , then- Return ?target.[[Delete]](P).
- LetbooleanTrapResult be !
ToBoolean (?Call (trap,handler, «target,P »)). - IfbooleanTrapResult is
false , returnfalse . - LettargetDesc be ?target.[[GetOwnProperty]](P).
- IftargetDesc is
undefined , returntrue . - IftargetDesc.[[Configurable]] is
false , throw aTypeError exception. - LetextensibleTarget be ?
IsExtensible (target). - IfextensibleTarget is
false , throw aTypeError exception. - Return
true .
[[Delete]] for proxy objects enforces the following invariants:
- The result of [[Delete]] is a Boolean value.
- A property cannot be reported as deleted, if it exists as a non-configurable own property of the target object.
- A property cannot be reported as deleted, if it exists as an own property of the target object and the target object is non-extensible.
10.5.11 [[OwnPropertyKeys]] ( )
The [[OwnPropertyKeys]] internal method of a
- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"ownKeys" ). - Iftrap is
undefined , then- Return ?target.[[OwnPropertyKeys]]().
- LettrapResultArray be ?
Call (trap,handler, «target »). - LettrapResult be ?
CreateListFromArrayLike (trapResultArray, « String, Symbol »). - IftrapResult contains any duplicate entries, throw a
TypeError exception. - LetextensibleTarget be ?
IsExtensible (target). - LettargetKeys be ?target.[[OwnPropertyKeys]]().
Assert :targetKeys is aList whose elements are only String and Symbol values.Assert :targetKeys contains no duplicate entries.- LettargetConfigurableKeys be a new empty
List . - LettargetNonconfigurableKeys be a new empty
List . - For each elementkey oftargetKeys, do
- Letdesc be ?target.[[GetOwnProperty]](key).
- Ifdesc is not
undefined anddesc.[[Configurable]] isfalse , then- Appendkey as an element oftargetNonconfigurableKeys.
- Else,
- Appendkey as an element oftargetConfigurableKeys.
- IfextensibleTarget is
true andtargetNonconfigurableKeys is empty, then- ReturntrapResult.
- LetuncheckedResultKeys be a
List whose elements are the elements oftrapResult. - For each elementkey oftargetNonconfigurableKeys, do
- Ifkey is not an element ofuncheckedResultKeys, throw a
TypeError exception. - Removekey fromuncheckedResultKeys.
- Ifkey is not an element ofuncheckedResultKeys, throw a
- IfextensibleTarget is
true , returntrapResult. - For each elementkey oftargetConfigurableKeys, do
- Ifkey is not an element ofuncheckedResultKeys, throw a
TypeError exception. - Removekey fromuncheckedResultKeys.
- Ifkey is not an element ofuncheckedResultKeys, throw a
- IfuncheckedResultKeys is not empty, throw a
TypeError exception. - ReturntrapResult.
[[OwnPropertyKeys]] for proxy objects enforces the following invariants:
- The result of [[OwnPropertyKeys]] is a
List . - The returned
List contains no duplicate entries. - The Type of each result
List element is either String or Symbol. - The result
List must contain the keys of all non-configurable own properties of the target object. - If the target object is not extensible, then the result
List must contain all the keys of the own properties of the target object and no other values.
10.5.12 [[Call]] (thisArgument,argumentsList )
The [[Call]] internal method of a
- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
- Lettrap be ?
GetMethod (handler,"apply" ). - Iftrap is
undefined , then- Return ?
Call (target,thisArgument,argumentsList).
- Return ?
- LetargArray be !
CreateArrayFromList (argumentsList). - Return ?
Call (trap,handler, «target,thisArgument,argArray »).
A
10.5.13 [[Construct]] (argumentsList,newTarget )
The [[Construct]] internal method of a
- Lethandler beO.[[ProxyHandler]].
- Ifhandler is
null , throw aTypeError exception. Assert :Type (handler) is Object.- Lettarget beO.[[ProxyTarget]].
Assert :IsConstructor (target) istrue .- Lettrap be ?
GetMethod (handler,"construct" ). - Iftrap is
undefined , then- Return ?
Construct (target,argumentsList,newTarget).
- Return ?
- LetargArray be !
CreateArrayFromList (argumentsList). - LetnewObj be ?
Call (trap,handler, «target,argArray,newTarget »). - If
Type (newObj) is not Object, throw aTypeError exception. - ReturnnewObj.
A
[[Construct]] for proxy objects enforces the following invariants:
- The result of [[Construct]] must be an Object.
10.5.14 ProxyCreate (target,handler )
The abstract operation ProxyCreate takes argumentstarget andhandler. It is used to specify the creation of new Proxy exotic objects. It performs the following steps when called:
- If
Type (target) is not Object, throw aTypeError exception. - If
Type (handler) is not Object, throw aTypeError exception. - LetP be !
MakeBasicObject (« [[ProxyHandler]], [[ProxyTarget]] »). - SetP's essential internal methods, except for [[Call]] and [[Construct]], to the definitions specified in
10.5 . - If
IsCallable (target) istrue , then- SetP.[[Call]] as specified in
10.5.12 . - If
IsConstructor (target) istrue , then- SetP.[[Construct]] as specified in
10.5.13 .
- SetP.[[Construct]] as specified in
- SetP.[[Call]] as specified in
- SetP.[[ProxyTarget]] totarget.
- SetP.[[ProxyHandler]] tohandler.
- ReturnP.
11 ECMAScript Language: Source Code
11.1 Source Text
Syntax
ECMAScript code is expressed using Unicode. ECMAScript source text is a sequence of code points. All Unicode code point values from U+0000 to U+10FFFF, including surrogate code points, may occur in source text where permitted by the ECMAScript grammars. The actual encodings used to store and interchange ECMAScript source text is not relevant to this specification. Regardless of the external source text encoding, a conforming ECMAScript implementation processes the source text as if it was an equivalent sequence of
The components of a combining character sequence are treated as individual Unicode code points even though a user might think of the whole sequence as a single character.
In string literals, regular expression literals, template literals and identifiers, any Unicode code point may also be expressed using Unicode escape sequences that explicitly express a code point's numeric value. Within a comment, such an escape sequence is effectively ignored as part of the comment.
ECMAScript differs from the Java programming language in the behaviour of Unicode escape sequences. In a Java program, if the Unicode escape sequence\u000A, for example, occurs within a single-line comment, it is interpreted as a line terminator (Unicode code point U+000A is LINE FEED (LF)) and therefore the next code point is not part of the comment. Similarly, if the Unicode escape sequence\u000A occurs within a string literal in a Java program, it is likewise interpreted as a line terminator, which is not allowed within a string literal—one must write\n instead of\u000A to cause a LINE FEED (LF) to be part of the String value of a string literal. In an ECMAScript program, a Unicode escape sequence occurring within a comment is never interpreted and therefore cannot contribute to termination of the comment. Similarly, a Unicode escape sequence occurring within a string literal in an ECMAScript program always contributes to the literal and is never interpreted as a line terminator or as a code point that might terminate the string literal.
11.1.1 Static Semantics: UTF16EncodeCodePoint (cp )
The abstract operation UTF16EncodeCodePoint takes argumentcp (a Unicode code point). It performs the following steps when called:
Assert : 0 ≤cp ≤ 0x10FFFF.- Ifcp ≤ 0xFFFF, return the String value consisting of the code unit whose value iscp.
- Letcu1 be the code unit whose value is
floor ((cp - 0x10000) / 0x400) + 0xD800. - Letcu2 be the code unit whose value is ((cp - 0x10000)
modulo 0x400) + 0xDC00. - Return the
string-concatenation ofcu1 andcu2.
11.1.2 Static Semantics: CodePointsToString (text )
The abstract operation CodePointsToString takes argumenttext (a sequence of Unicode code points). It convertstext into a String value, as described in
- Letresult be the empty String.
- For each code pointcp oftext, do
- Setresult to the
string-concatenation ofresult and !UTF16EncodeCodePoint (cp).
- Setresult to the
- Returnresult.
11.1.3 Static Semantics: UTF16SurrogatePairToCodePoint (lead,trail )
The abstract operation UTF16SurrogatePairToCodePoint takes argumentslead (a code unit) andtrail (a code unit). Two code units that form a UTF-16
Assert :lead is aleading surrogate andtrail is atrailing surrogate .- Letcp be (lead - 0xD800) × 0x400 + (trail - 0xDC00) + 0x10000.
- Return the code pointcp.
11.1.4 Static Semantics: CodePointAt (string,position )
The abstract operation CodePointAt takes argumentsstring (a String) andposition (a non-negative
- Letsize be the length ofstring.
Assert :position ≥ 0 andposition <size.- Letfirst be the code unit at indexposition withinstring.
- Letcp be the code point whose numeric value is that offirst.
- Iffirst is not a
leading surrogate ortrailing surrogate , then- Return the
Record { [[CodePoint]]:cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]:false }.
- Return the
- Iffirst is a
trailing surrogate orposition + 1 =size, then- Return the
Record { [[CodePoint]]:cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]:true }.
- Return the
- Letsecond be the code unit at indexposition + 1 withinstring.
- Ifsecond is not a
trailing surrogate , then- Return the
Record { [[CodePoint]]:cp, [[CodeUnitCount]]: 1, [[IsUnpairedSurrogate]]:true }.
- Return the
- Setcp to !
UTF16SurrogatePairToCodePoint (first,second). - Return the
Record { [[CodePoint]]:cp, [[CodeUnitCount]]: 2, [[IsUnpairedSurrogate]]:false }.
11.1.5 Static Semantics: StringToCodePoints (string )
The abstract operation StringToCodePoints takes argumentstring (a String). It returns the sequence of Unicode code points that results from interpretingstring as UTF-16 encoded Unicode text as described in
- LetcodePoints be a new empty
List . - Letsize be the length ofstring.
- Letposition be 0.
- Repeat, whileposition <size,
- Letcp be !
CodePointAt (string,position). - Appendcp.[[CodePoint]] tocodePoints.
- Setposition toposition +cp.[[CodeUnitCount]].
- Letcp be !
- ReturncodePoints.
11.1.6 Static Semantics: ParseText (sourceText,goalSymbol )
The abstract operation ParseText takes argumentssourceText (a sequence of Unicode code points) andgoalSymbol (a nonterminal in one of the ECMAScript grammars). It performs the following steps when called:
- Attempt to parsesourceText usinggoalSymbol as the
goal symbol , and analyse the parse result for anyearly error conditions. Parsing andearly error detection may be interleaved in animplementation-defined manner. - If the parse succeeded and no early errors were found, return the
Parse Node (an instance ofgoalSymbol) at the root of the parse tree resulting from the parse. - Otherwise, return a
List of one or moreSyntaxError objects representing the parsing errors and/or early errors. If more than one parsing error orearly error is present, the number and ordering of error objects in the list isimplementation-defined , but at least one must be present.
Consider a text that has an
See also clause
11.2 Types of Source Code
There are four types of ECMAScript code:
- Global code is source text that is treated as an ECMAScript
Script . The global code of a particularScript does not include any source text that is parsed as part of aFunctionDeclaration ,FunctionExpression ,GeneratorDeclaration ,GeneratorExpression ,AsyncFunctionDeclaration ,AsyncFunctionExpression ,AsyncGeneratorDeclaration ,AsyncGeneratorExpression ,MethodDefinition ,ArrowFunction ,AsyncArrowFunction ,ClassDeclaration , orClassExpression . - Eval code is the source text supplied to the built-in
evalfunction. More precisely, if the parameter to the built-inevalfunction is a String, it is treated as an ECMAScriptScript . The eval code for a particular invocation ofevalis the global code portion of thatScript . Function code is source text that is parsed to supply the value of the [[ECMAScriptCode]] and [[FormalParameters]] internal slots (see
10.2 ) of an ECMAScriptfunction object . The function code of a particular ECMAScript function does not include any source text that is parsed as the function code of a nestedFunctionDeclaration ,FunctionExpression ,GeneratorDeclaration ,GeneratorExpression ,AsyncFunctionDeclaration ,AsyncFunctionExpression ,AsyncGeneratorDeclaration ,AsyncGeneratorExpression ,MethodDefinition ,ArrowFunction ,AsyncArrowFunction ,ClassDeclaration , orClassExpression .In addition, if the source text referred to above is parsed as:
- the
FormalParameters andFunctionBody of aFunctionDeclaration orFunctionExpression , - the
FormalParameters andGeneratorBody of aGeneratorDeclaration orGeneratorExpression , - the
FormalParameters andAsyncFunctionBody of anAsyncFunctionDeclaration orAsyncFunctionExpression , or - the
FormalParameters andAsyncGeneratorBody of anAsyncGeneratorDeclaration orAsyncGeneratorExpression ,
then the source text matching the
BindingIdentifier (if any) of that declaration or expression is also included in the function code of the corresponding function.- the
- Module code is source text that is code that is provided as a
ModuleBody . It is the code that is directly evaluated when a module is initialized. The module code of a particular module does not include any source text that is parsed as part of a nestedFunctionDeclaration ,FunctionExpression ,GeneratorDeclaration ,GeneratorExpression ,AsyncFunctionDeclaration ,AsyncFunctionExpression ,AsyncGeneratorDeclaration ,AsyncGeneratorExpression ,MethodDefinition ,ArrowFunction ,AsyncArrowFunction ,ClassDeclaration , orClassExpression .
Function code is generally provided as the bodies of Function Definitions (
The practical effect of including the
11.2.1 Directive Prologues and the Use Strict Directive
ADirective Prologue is the longest sequence of
AUse Strict Directive is an"use strict" or'use strict'. A
A
The
11.2.2 Strict Mode Code
An ECMAScript syntactic unit may be processed using either unrestricted or strict mode syntax and semantics (
- Global code is strict mode code if it begins with a
Directive Prologue that contains aUse Strict Directive . - Module code is always strict mode code.
- All parts of a
ClassDeclaration or aClassExpression are strict mode code. - Eval code is strict mode code if it begins with a
Directive Prologue that contains aUse Strict Directive or if the call toevalis adirect eval that is contained in strict mode code. - Function code is strict mode code if the associated
FunctionDeclaration ,FunctionExpression ,GeneratorDeclaration ,GeneratorExpression ,AsyncFunctionDeclaration ,AsyncFunctionExpression ,AsyncGeneratorDeclaration ,AsyncGeneratorExpression ,MethodDefinition ,ArrowFunction , orAsyncArrowFunction is contained in strict mode code or if the code that produces the value of the function's [[ECMAScriptCode]] internal slot begins with aDirective Prologue that contains aUse Strict Directive . - Function code that is supplied as the arguments to the built-in Function, Generator, AsyncFunction, and AsyncGenerator constructors is strict mode code if the last argument is a String that when processed is a
FunctionBody that begins with aDirective Prologue that contains aUse Strict Directive .
ECMAScript code that is not strict mode code is callednon-strict code.
11.2.3 Non-ECMAScript Functions
An ECMAScript implementation may support the evaluation of function exotic objects whose evaluative behaviour is expressed in some
12 ECMAScript Language: Lexical Grammar
The source text of an ECMAScript
There are several situations where the identification of lexical input elements is sensitive to the syntactic grammar context that is consuming the input elements. This requires multiple goal symbols for the lexical grammar. The
The use of multiple lexical goals ensures that there are no lexical ambiguities that would affect automatic semicolon insertion. For example, there are no syntactic grammar contexts where both a leading division or division-assignment, and a leading
a = b/hi/g.exec(c).map(d);where the first non-whitespace, non-comment code point after a
a = b / hi / g.exec(c).map(d);Syntax
12.1 Unicode Format-Control Characters
The Unicode format-control characters (i.e., the characters in category “Cf” in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT MARK) are control codes used to control the formatting of a range of text in the absence of higher-level protocols for this (such as mark-up languages).
It is useful to allow format-control characters in source text to facilitate editing and display. All format control characters may be used within comments, and within string literals, template literals, and regular expression literals.
U+200C (ZERO WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER) are format-control characters that are used to make necessary distinctions when forming words or phrases in certain languages. In ECMAScript source text these code points may also be used in an
U+FEFF (ZERO WIDTH NO-BREAK SPACE) is a format-control character used primarily at the start of a text to mark it as Unicode and to allow detection of the text's encoding and byte order. <ZWNBSP> characters intended for this purpose can sometimes also appear after the start of a text, for example as a result of concatenating files. In ECMAScript source text <ZWNBSP> code points are treated as white space characters (see
The special treatment of certain format-control characters outside of comments, string literals, and regular expression literals is summarized in
| Code Point | Name | Abbreviation | Usage |
|---|---|---|---|
U+200C | ZERO WIDTH NON-JOINER | <ZWNJ> | |
U+200D | ZERO WIDTH JOINER | <ZWJ> | |
U+FEFF | ZERO WIDTH NO-BREAK SPACE | <ZWNBSP> |
12.2 White Space
White space code points are used to improve source text readability and to separate tokens (indivisible lexical units) from each other, but are otherwise insignificant. White space code points may occur between any two tokens and at the start or end of input. White space code points may occur within a
The ECMAScript white space code points are listed in
| Code Point | Name | Abbreviation |
|---|---|---|
U+0009 | CHARACTER TABULATION | <TAB> |
U+000B | LINE TABULATION | <VT> |
U+000C | FORM FEED (FF) | <FF> |
U+0020 | SPACE | <SP> |
U+00A0 | NO-BREAK SPACE | <NBSP> |
U+FEFF | ZERO WIDTH NO-BREAK SPACE | <ZWNBSP> |
| Other category “Zs” | Any other Unicode “Space_Separator” code point | <USP> |
ECMAScript implementations must recognize as
Other than for the code points listed in
Syntax
12.3 Line Terminators
Like white space code points, line terminator code points are used to improve source text readability and to separate tokens (indivisible lexical units) from each other. However, unlike white space code points, line terminators have some influence over the behaviour of the syntactic grammar. In general, line terminators may occur between any two tokens, but there are a few places where they are forbidden by the syntactic grammar. Line terminators also affect the process of automatic semicolon insertion (
A line terminator can occur within a
Line terminators are included in the set of white space code points that are matched by the\s class in regular expressions.
The ECMAScript line terminator code points are listed in
| Code Point | Unicode Name | Abbreviation |
|---|---|---|
U+000A | LINE FEED (LF) | <LF> |
U+000D | CARRIAGE RETURN (CR) | <CR> |
U+2028 | LINE SEPARATOR | <LS> |
U+2029 | PARAGRAPH SEPARATOR | <PS> |
Only the Unicode code points in
Syntax
12.4 Comments
Comments can be either single or multi-line. Multi-line comments cannot nest.
Because a single-line comment can contain any Unicode code point except a// marker to the end of the line. However, the
Comments behave like white space and are discarded except that, if a
Syntax
A number of productions in this section are given alternative definitions in section
12.5 Tokens
Syntax
The
12.6 Names and Keywords
This standard specifies specific code point additions: U+0024 (DOLLAR SIGN) and U+005F (LOW LINE) are permitted anywhere in an
Unicode escape sequences are permitted in an\ preceding theu and{ } code units, if they appear, do not contribute code points to the\
Two
Syntax
The definitions of the nonterminal
The nonterminal_ via
The sets of code points with Unicode properties “ID_Start” and “ID_Continue” include, respectively, the code points with Unicode properties “Other_ID_Start” and “Other_ID_Continue”.
12.6.1 Identifier Names
12.6.1.1 Static Semantics: Early Errors
- It is a Syntax Error if the
SV ofUnicodeEscapeSequence is none of"$" , or"_" , or !UTF16EncodeCodePoint (cp) for some Unicode code pointcp matched by theUnicodeIDStart lexical grammar production.
- It is a Syntax Error if the
SV ofUnicodeEscapeSequence is none of"$" ,"_" , !UTF16EncodeCodePoint (<ZWNJ>), !UTF16EncodeCodePoint (<ZWJ>), or !UTF16EncodeCodePoint (cp) for some Unicode code pointcp that would be matched by theUnicodeIDContinue lexical grammar production.
12.6.2 Keywords and Reserved Words
Akeyword is a token that matchesfixed width font, in some syntactic production. The keywords of ECMAScript includeif,while,async,await, and many others.
Areserved word is anif andwhile are reserved words.await is reserved only inside async functions and modules.async is not reserved; it can be used as a variable name or statement label without restriction.
This specification uses a combination of grammatical productions andawait andyield, are unconditionally reserved. Exceptions forawait andyield are specified in
Those that are always allowed as identifiers, and are not keywords, such as
Math,window,toString, and_;Those that are never allowed as identifiers, namely the
ReservedWord s listed below exceptawaitandyield;Those that are contextually allowed as identifiers, namely
awaitandyield;Those that are contextually disallowed as identifiers, in
strict mode code :let,static,implements,interface,package,private,protected, andpublic;Those that are always allowed as identifiers, but also appear as keywords within certain syntactic productions, at places where
Identifier is not allowed:as,async,from,get,of,set, andtarget.
The termconditional keyword, orcontextual keyword, is sometimes used to refer to the keywords that fall in the last three categories, and thus can be used as identifiers in some contexts and as keywords in others.
Syntax
Per\
An\els\u{65}. The
enum is not currently used as a keyword in this specification. It is afuture reserved word, set aside for use as a keyword in future language extensions.
Similarly,implements,interface,package,private,protected, andpublic are future reserved words in
12.7 Punctuators
Syntax
12.8 Literals
12.8.1 Null Literals
Syntax
12.8.2 Boolean Literals
Syntax
12.8.3 Numeric Literals
Syntax
The
For example:3in is an error and not the two input elements3 andin.
A conforming implementation, when processing
12.8.3.1 Static Semantics: MV
A numeric literal stands for a value of the Number type or the BigInt type.
- The MV of
NumericLiteral :: DecimalLiteral DecimalLiteral . - The MV of
NonDecimalIntegerLiteral :: BinaryIntegerLiteral BinaryIntegerLiteral . - The MV of
NonDecimalIntegerLiteral :: OctalIntegerLiteral OctalIntegerLiteral . - The MV of
NonDecimalIntegerLiteral :: HexIntegerLiteral HexIntegerLiteral . - The MV of
DecimalLiteral :: DecimalIntegerLiteral . DecimalIntegerLiteral . - The MV of
DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits DecimalIntegerLiteral plus (the MV ofDecimalDigits × 10-n), wheren is the number of code points inDecimalDigits , excluding all occurrences ofNumericLiteralSeparator . - The MV of
DecimalLiteral :: DecimalIntegerLiteral . ExponentPart DecimalIntegerLiteral × 10e, wheree is the MV ofExponentPart . - The MV of
DecimalLiteral :: DecimalIntegerLiteral . DecimalDigits ExponentPart DecimalIntegerLiteral plus (the MV ofDecimalDigits × 10-n)) × 10e, wheren is the number of code points inDecimalDigits , excluding all occurrences ofNumericLiteralSeparator ande is the MV ofExponentPart . - The MV of
DecimalLiteral :: . DecimalDigits DecimalDigits × 10-n, wheren is the number of code points inDecimalDigits , excluding all occurrences ofNumericLiteralSeparator . - The MV of
DecimalLiteral :: . DecimalDigits ExponentPart DecimalDigits × 10e -n, wheren is the number of code points inDecimalDigits , excluding all occurrences ofNumericLiteralSeparator , ande is the MV ofExponentPart . - The MV of
DecimalLiteral :: DecimalIntegerLiteral DecimalIntegerLiteral . - The MV of
DecimalLiteral :: DecimalIntegerLiteral ExponentPart DecimalIntegerLiteral × 10e, wheree is the MV ofExponentPart . - The MV of
DecimalIntegerLiteral :: 0 - The MV of
DecimalIntegerLiteral :: NonZeroDigit NonZeroDigit . - The MV of
DecimalIntegerLiteral :: NonZeroDigit NumericLiteralSeparator opt DecimalDigits NonZeroDigit × 10n) plus the MV ofDecimalDigits , wheren is the number of code points inDecimalDigits , excluding all occurrences ofNumericLiteralSeparator . - The MV of
DecimalDigits :: DecimalDigit DecimalDigit . - The MV of
DecimalDigits :: DecimalDigits DecimalDigit DecimalDigits × 10) plus the MV ofDecimalDigit . - The MV of
DecimalDigits :: DecimalDigits NumericLiteralSeparator DecimalDigit DecimalDigits × 10) plus the MV ofDecimalDigit . - The MV of
ExponentPart :: ExponentIndicator SignedInteger SignedInteger . - The MV of
SignedInteger :: DecimalDigits DecimalDigits . - The MV of
SignedInteger :: + DecimalDigits DecimalDigits . - The MV of
SignedInteger :: - DecimalDigits DecimalDigits . - The MV of
DecimalDigit :: 0 HexDigit :: 0 OctalDigit :: 0 BinaryDigit :: 0 - The MV of
DecimalDigit :: 1 NonZeroDigit :: 1 HexDigit :: 1 OctalDigit :: 1 BinaryDigit :: 1 - The MV of
DecimalDigit :: 2 NonZeroDigit :: 2 HexDigit :: 2 OctalDigit :: 2 - The MV of
DecimalDigit :: 3 NonZeroDigit :: 3 HexDigit :: 3 OctalDigit :: 3 - The MV of
DecimalDigit :: 4 NonZeroDigit :: 4 HexDigit :: 4 OctalDigit :: 4 - The MV of
DecimalDigit :: 5 NonZeroDigit :: 5 HexDigit :: 5 OctalDigit :: 5 - The MV of
DecimalDigit :: 6 NonZeroDigit :: 6 HexDigit :: 6 OctalDigit :: 6 - The MV of
DecimalDigit :: 7 NonZeroDigit :: 7 HexDigit :: 7 OctalDigit :: 7 - The MV of
DecimalDigit :: 8 NonZeroDigit :: 8 HexDigit :: 8 - The MV of
DecimalDigit :: 9 NonZeroDigit :: 9 HexDigit :: 9 - The MV of
HexDigit :: a HexDigit :: A - The MV of
HexDigit :: b HexDigit :: B - The MV of
HexDigit :: c HexDigit :: C - The MV of
HexDigit :: d HexDigit :: D - The MV of
HexDigit :: e HexDigit :: E - The MV of
HexDigit :: f HexDigit :: F - The MV of
BinaryIntegerLiteral :: 0b BinaryDigits BinaryDigits . - The MV of
BinaryIntegerLiteral :: 0B BinaryDigits BinaryDigits . - The MV of
BinaryDigits :: BinaryDigit BinaryDigit . - The MV of
BinaryDigits :: BinaryDigits BinaryDigit BinaryDigits × 2) plus the MV ofBinaryDigit . - The MV of
BinaryDigits :: BinaryDigits NumericLiteralSeparator BinaryDigit BinaryDigits × 2) plus the MV ofBinaryDigit . - The MV of
OctalIntegerLiteral :: 0o OctalDigits OctalDigits . - The MV of
OctalIntegerLiteral :: 0O OctalDigits OctalDigits . - The MV of
OctalDigits :: OctalDigit OctalDigit . - The MV of
OctalDigits :: OctalDigits OctalDigit OctalDigits × 8) plus the MV ofOctalDigit . - The MV of
OctalDigits :: OctalDigits NumericLiteralSeparator OctalDigit OctalDigits × 8) plus the MV ofOctalDigit . - The MV of
HexIntegerLiteral :: 0x HexDigits HexDigits . - The MV of
HexIntegerLiteral :: 0X HexDigits HexDigits . - The MV of
HexDigits :: HexDigit HexDigit . - The MV of
HexDigits :: HexDigits HexDigit HexDigits × 16) plus the MV ofHexDigit . - The MV of
HexDigits :: HexDigits NumericLiteralSeparator HexDigit HexDigits × 16) plus the MV ofHexDigit .
12.8.3.2 Static Semantics: NumericValue
- Return the
Number value that results from rounding the MV ofDecimalLiteral as described below.
- Return the
Number value that results from rounding the MV ofNonDecimalIntegerLiteral as described below.
Once the exact MV for a numeric literal has been determined, it is then rounded to a value of the Number type. If the MV is 0, then the rounded value is0 digit or the0 digit and then incrementing the literal at the 20th significant digit position. A digit issignificant if it is not part of an
- it is not
0; or - there is a non-zero digit to its left and there is a non-zero digit, not in the
ExponentPart , to its right.
- Return the BigInt value that represents the MV of
NonDecimalIntegerLiteral .
- Return
0 ℤ.
- Return the BigInt value that represents the MV of
NonZeroDigit .
- Letn be the number of code points in
DecimalDigits , excluding all occurrences ofNumericLiteralSeparator . - Letmv be (the MV of
NonZeroDigit × 10) plus the MV ofDecimalDigits . - Return
ℤ (mv).
12.8.4 String Literals
A string literal is 0 or more Unicode code points enclosed in single or double quotes. Unicode code points may also be represented by an escape sequence. All code points may appear literally in a string literal except for the closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), and U+000A (LINE FEED). Any code points may appear in the form of an escape sequence. String literals evaluate to ECMAScript String values. When generating these String values Unicode code points are UTF-16 encoded as defined in
Syntax
A conforming implementation, when processing
The definition of the nonterminal
<LF> and <CR> cannot appear in a string literal, except as part of a\n or\u000A.
12.8.4.1 Static Semantics: SV
A string literal stands for a value of the String type. The String value (SV) of the literal is described in terms of String values contributed by the various parts of the string literal. As part of this process, some Unicode code points within the string literal are interpreted as having a
- The SV of
StringLiteral :: " " - The SV of
StringLiteral :: ' ' - The SV of
DoubleStringCharacters :: DoubleStringCharacter DoubleStringCharacters string-concatenation of the SV ofDoubleStringCharacter and the SV ofDoubleStringCharacters . - The SV of
SingleStringCharacters :: SingleStringCharacter SingleStringCharacters string-concatenation of the SV ofSingleStringCharacter and the SV ofSingleStringCharacters . - The SV of
DoubleStringCharacter :: SourceCharacter but not one of " or\ orLineTerminator UTF16EncodeCodePoint on the code point value ofSourceCharacter . - The SV of
DoubleStringCharacter :: <LS> - The SV of
DoubleStringCharacter :: <PS> - The SV of
DoubleStringCharacter :: LineContinuation - The SV of
SingleStringCharacter :: SourceCharacter but not one of ' or\ orLineTerminator UTF16EncodeCodePoint on the code point value ofSourceCharacter . - The SV of
SingleStringCharacter :: <LS> - The SV of
SingleStringCharacter :: <PS> - The SV of
SingleStringCharacter :: LineContinuation - The SV of
EscapeSequence :: 0 - The SV of
CharacterEscapeSequence :: SingleEscapeCharacter SingleEscapeCharacter according toTable 36 .
| Escape Sequence | Code Unit Value | Unicode Character Name | Symbol |
|---|---|---|---|
\b | 0x0008 | BACKSPACE | <BS> |
\t | 0x0009 | CHARACTER TABULATION | <HT> |
\n | 0x000A | LINE FEED (LF) | <LF> |
\v | 0x000B | LINE TABULATION | <VT> |
\f | 0x000C | FORM FEED (FF) | <FF> |
\r | 0x000D | CARRIAGE RETURN (CR) | <CR> |
\" | 0x0022 | QUOTATION MARK | " |
\' | 0x0027 | APOSTROPHE | ' |
\\ | 0x005C | REVERSE SOLIDUS | \ |
- The SV of
NonEscapeCharacter :: SourceCharacter but not one of EscapeCharacter orLineTerminator UTF16EncodeCodePoint on the code point value ofSourceCharacter . - The SV of
HexEscapeSequence :: x HexDigit HexDigit HexEscapeSequence . - The SV of
Hex4Digits :: HexDigit HexDigit HexDigit HexDigit Hex4Digits . - The SV of
UnicodeEscapeSequence :: u{ CodePoint } UTF16EncodeCodePoint on the MV ofCodePoint .
12.8.4.2 Static Semantics: MV
- The MV of
HexEscapeSequence :: x HexDigit HexDigit HexDigit ) plus the MV of the secondHexDigit . - The MV of
Hex4Digits :: HexDigit HexDigit HexDigit HexDigit HexDigit ) plus (0x100 × the MV of the secondHexDigit ) plus (0x10 × the MV of the thirdHexDigit ) plus the MV of the fourthHexDigit .
12.8.5 Regular Expression Literals
A regular expression literal is an input element that is converted to a RegExp object (see=== to each other even if the two literals' contents are identical. A RegExp object may also be created at runtime bynew RegExp or calling the RegExp
The productions below describe the syntax for a regular expression literal and are used by the input element scanner to find the end of the regular expression literal. The source text comprising the
An implementation may extend the ECMAScript Regular Expression grammar defined in
Syntax
Regular expression literals may not be empty; instead of representing an empty regular expression literal, the code unit sequence// starts a single-line comment. To specify an empty regular expression, use:/(?:)/.
12.8.5.1 Static Semantics: Early Errors
- It is a Syntax Error if
IdentifierPart contains a Unicode escape sequence.
12.8.5.2 Static Semantics: BodyText
- Return the source text that was recognized as
RegularExpressionBody .
12.8.5.3 Static Semantics: FlagText
- Return the source text that was recognized as
RegularExpressionFlags .
12.8.6 Template Literal Lexical Components
Syntax
A conforming implementation must not use the extended definition of
12.8.6.1 Static Semantics: TV and TRV
A template literal component is interpreted as a sequence of Unicode code points. The Template Value (TV) of a literal component is described in terms of String values (
- The TV and TRV of
NoSubstitutionTemplate :: ` ` - The TV and TRV of
TemplateHead :: ` ${ - The TV and TRV of
TemplateMiddle :: } ${ - The TV and TRV of
TemplateTail :: } ` - The TV of
TemplateCharacters :: TemplateCharacter TemplateCharacters undefined if either the TV ofTemplateCharacter isundefined or the TV ofTemplateCharacters isundefined . Otherwise, it is thestring-concatenation of the TV ofTemplateCharacter and the TV ofTemplateCharacters . - The TV of
TemplateCharacter :: SourceCharacter but not one of ` or\ or$ orLineTerminator UTF16EncodeCodePoint on the code point value ofSourceCharacter . - The TV of
TemplateCharacter :: $ - The TV of
TemplateCharacter :: \ EscapeSequence SV ofEscapeSequence . - The TV of
TemplateCharacter :: \ NotEscapeSequence undefined . - The TV of
TemplateCharacter :: LineTerminatorSequence LineTerminatorSequence . - The TV of
LineContinuation :: \ LineTerminatorSequence - The TRV of
TemplateCharacters :: TemplateCharacter TemplateCharacters string-concatenation of the TRV ofTemplateCharacter and the TRV ofTemplateCharacters . - The TRV of
TemplateCharacter :: SourceCharacter but not one of ` or\ or$ orLineTerminator UTF16EncodeCodePoint on the code point value ofSourceCharacter . - The TRV of
TemplateCharacter :: $ - The TRV of
TemplateCharacter :: \ EscapeSequence string-concatenation of the code unit 0x005C (REVERSE SOLIDUS) and the TRV ofEscapeSequence . - The TRV of
TemplateCharacter :: \ NotEscapeSequence string-concatenation of the code unit 0x005C (REVERSE SOLIDUS) and the TRV ofNotEscapeSequence . - The TRV of
EscapeSequence :: 0 - The TRV of
NotEscapeSequence :: 0 DecimalDigit string-concatenation of the code unit 0x0030 (DIGIT ZERO) and the TRV ofDecimalDigit . - The TRV of
NotEscapeSequence :: x [lookahead ∉ HexDigit ] - The TRV of
NotEscapeSequence :: x HexDigit [lookahead ∉ HexDigit ]string-concatenation of the code unit 0x0078 (LATIN SMALL LETTER X) and the TRV ofHexDigit . - The TRV of
NotEscapeSequence :: u [lookahead ∉ HexDigit ][lookahead ≠ { ] - The TRV of
NotEscapeSequence :: u HexDigit [lookahead ∉ HexDigit ]string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U) and the TRV ofHexDigit . - The TRV of
NotEscapeSequence :: u HexDigit HexDigit [lookahead ∉ HexDigit ]string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U), the TRV of the firstHexDigit , and the TRV of the secondHexDigit . - The TRV of
NotEscapeSequence :: u HexDigit HexDigit HexDigit [lookahead ∉ HexDigit ]string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U), the TRV of the firstHexDigit , the TRV of the secondHexDigit , and the TRV of the thirdHexDigit . - The TRV of
NotEscapeSequence :: u { [lookahead ∉ HexDigit ]string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U) and the code unit 0x007B (LEFT CURLY BRACKET). - The TRV of
NotEscapeSequence :: u { NotCodePoint [lookahead ∉ HexDigit ]string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U), the code unit 0x007B (LEFT CURLY BRACKET), and the TRV ofNotCodePoint . - The TRV of
NotEscapeSequence :: u { CodePoint [lookahead ∉ HexDigit ][lookahead ≠ } ]string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U), the code unit 0x007B (LEFT CURLY BRACKET), and the TRV ofCodePoint . - The TRV of
DecimalDigit :: one of 0 1 2 3 4 5 6 7 8 9 UTF16EncodeCodePoint on the single code point matched by this production. - The TRV of
CharacterEscapeSequence :: NonEscapeCharacter SV ofNonEscapeCharacter . - The TRV of
SingleEscapeCharacter :: one of ' " \ b f n r t v UTF16EncodeCodePoint on the single code point matched by this production. - The TRV of
HexEscapeSequence :: x HexDigit HexDigit string-concatenation of the code unit 0x0078 (LATIN SMALL LETTER X), the TRV of the firstHexDigit , and the TRV of the secondHexDigit . - The TRV of
UnicodeEscapeSequence :: u Hex4Digits string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U) and the TRV ofHex4Digits . - The TRV of
UnicodeEscapeSequence :: u{ CodePoint } string-concatenation of the code unit 0x0075 (LATIN SMALL LETTER U), the code unit 0x007B (LEFT CURLY BRACKET), the TRV ofCodePoint , and the code unit 0x007D (RIGHT CURLY BRACKET). - The TRV of
Hex4Digits :: HexDigit HexDigit HexDigit HexDigit string-concatenation of the TRV of the firstHexDigit , the TRV of the secondHexDigit , the TRV of the thirdHexDigit , and the TRV of the fourthHexDigit . - The TRV of
HexDigits :: HexDigits HexDigit string-concatenation of the TRV ofHexDigits and the TRV ofHexDigit . - The TRV of
HexDigit :: one of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F UTF16EncodeCodePoint on the single code point matched by this production. - The TRV of
LineContinuation :: \ LineTerminatorSequence string-concatenation of the code unit 0x005C (REVERSE SOLIDUS) and the TRV ofLineTerminatorSequence . - The TRV of
LineTerminatorSequence :: <LF> - The TRV of
LineTerminatorSequence :: <CR> - The TRV of
LineTerminatorSequence :: <LS> - The TRV of
LineTerminatorSequence :: <PS> - The TRV of
LineTerminatorSequence :: <CR> <LF>
TV excludes the code units of
12.9 Automatic Semicolon Insertion
Most ECMAScript statements and declarations must be terminated with a semicolon. Such semicolons may always appear explicitly in the source text. For convenience, however, such semicolons may be omitted from the source text in certain situations. These situations are described by saying that semicolons are automatically inserted into the source code token stream in those situations.
12.9.1 Rules of Automatic Semicolon Insertion
In the following rules, “token” means the actual recognized lexical token determined using the current lexical
There are three basic rules of semicolon insertion:
When, as the source text is parsed from left to right, a token (called theoffending token) is encountered that is not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending token if one or more of the following conditions is true:
- The offending token is separated from the previous token by at least one
LineTerminator . - The offending token is
}. - The previous token is
)and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement (14.7.2 ).
- The offending token is separated from the previous token by at least one
- When, as the source text is parsed from left to right, the end of the input stream of tokens is encountered and the parser is unable to parse the input token stream as a single instance of the goal nonterminal, then a semicolon is automatically inserted at the end of the input stream.
- When, as the source text is parsed from left to right, a token is encountered that is allowed by some production of the grammar, but the production is arestricted production and the token would be the first token for a terminal or nonterminal immediately following the annotation “[no
LineTerminator here]” within the restricted production (and therefore such a token is called a restricted token), and the restricted token is separated from the previous token by at least oneLineTerminator , then a semicolon is automatically inserted before the restricted token.
However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of afor statement (see
The following are the only restricted productions in the grammar:
The practical effect of these restricted productions is as follows:
- When a
++or--token is encountered where the parser would treat it as a postfix operator, and at least oneLineTerminator occurred between the preceding token and the++or--token, then a semicolon is automatically inserted before the++or--token. - When a
continue,break,return,throw, oryieldtoken is encountered and aLineTerminator is encountered before the next token, a semicolon is automatically inserted after thecontinue,break,return,throw, oryieldtoken.
The resulting practical advice to ECMAScript programmers is:
- A postfix
++or--operator should appear on the same line as its operand. - An
Expression in areturnorthrowstatement or anAssignmentExpression in ayieldexpression should start on the same line as thereturn,throw, oryieldtoken. - A
LabelIdentifier in abreakorcontinuestatement should be on the same line as thebreakorcontinuetoken.
12.9.2 Examples of Automatic Semicolon Insertion
This section is non-normative.The source
{12 }3is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source
{12 }3is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:
{1;2 ;}3;which is a valid ECMAScript sentence.
The source
for (a; b)is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion because the semicolon is needed for the header of afor statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of afor statement.
The source
returna + bis transformed by automatic semicolon insertion into the following:
return;a + b;The expressiona + b is not treated as a value to be returned by thereturn statement, because areturn.
The source
a = b++cis transformed by automatic semicolon insertion into the following:
a = b;++c;The token++ is not treated as a postfix operator applying to the variableb, because ab and++.
The source
if (a > b)else c = dis not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before theelse token, even though no production of the grammar applies at that point, because an automatically inserted semicolon would then be parsed as an empty statement.
The source
a = b + c(d + e).print()isnot transformed by automatic semicolon insertion, because the parenthesized expression that begins the second line can be interpreted as an argument list for a function call:
a = b + c(d + e).print()In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.
12.9.3 Interesting Cases of Automatic Semicolon Insertion
This section is non-normative.ECMAScript programs can be written in a style with very few semicolons by relying on automatic semicolon insertion. As described above, semicolons are not inserted at every newline, and automatic semicolon insertion can depend on multiple tokens across line terminators.
As new syntactic features are added to ECMAScript, additional grammar productions could be added that cause lines relying on automatic semicolon insertion preceding them to change grammar productions when parsed.
For the purposes of this section, a case of automatic semicolon insertion is considered interesting if it is a place where a semicolon may or may not be inserted, depending on the source text which precedes it. The rest of this section describes a number of interesting cases of automatic semicolon insertion in this version of ECMAScript.
12.9.3.1 Interesting Cases of Automatic Semicolon Insertion in Statement Lists
In a
- An opening parenthesis (
(). Without a semicolon, the two lines together are treated as aCallExpression . - An opening square bracket (
[). Without a semicolon, the two lines together are treated as property access, rather than anArrayLiteral orArrayAssignmentPattern . - A template literal (
`). Without a semicolon, the two lines together are interpreted as a tagged Template (13.3.11 ), with the previous expression as theMemberExpression . - Unary
+or-. Without a semicolon, the two lines together are interpreted as a usage of the corresponding binary operator. - A RegExp literal. Without a semicolon, the two lines together may be parsed instead as the
/MultiplicativeOperator , for example if the RegExp has flags.
12.9.3.2 Cases of Automatic Semicolon Insertion and “[noLineTerminator here]”
This section is non-normative.ECMAScript contains grammar productions which include “[no
The rest of this section describes a number of productions using “[no
12.9.3.2.1 List of Grammar Productions with Optional Operands and “[noLineTerminator here]”
UpdateExpression .ContinueStatement .BreakStatement .ReturnStatement .YieldExpression .- Async Function Definitions (
15.8 ) with relation to Function Definitions (15.2 )
13 ECMAScript Language: Expressions
13.1 Identifiers
Syntax
yield andawait are permitted as
letawait0;13.1.1 Static Semantics: Early Errors
- It is a Syntax Error if the code matched by this production is contained in
strict mode code and theStringValue ofIdentifier is"arguments" or"eval" .
- It is a Syntax Error if the code matched by this production is contained in
strict mode code .
- It is a Syntax Error if the
goal symbol of the syntactic grammar isModule .
- It is a Syntax Error if this production has a[Yield] parameter.
- It is a Syntax Error if this production has an[Await] parameter.
- It is a Syntax Error if this production has a[Yield] parameter and
StringValue ofIdentifier is"yield" . - It is a Syntax Error if this production has an[Await] parameter and
StringValue ofIdentifier is"await" .
- It is a Syntax Error if this phrase is contained in
strict mode code and theStringValue ofIdentifierName is:"implements" ,"interface" ,"let" ,"package" ,"private" ,"protected" ,"public" ,"static" , or"yield" . - It is a Syntax Error if the
goal symbol of the syntactic grammar isModule and theStringValue ofIdentifierName is"await" . - It is a Syntax Error if
StringValue ofIdentifierName is the same String value as theStringValue of anyReservedWord except foryieldorawait.
13.1.2 Static Semantics: StringValue
- LetidText be the
source text matched by IdentifierName . - LetidTextUnescaped be the result of replacing any occurrences of
\UnicodeEscapeSequence inidText with the code point represented by theUnicodeEscapeSequence . - Return !
CodePointsToString (idTextUnescaped).
- Return
"yield" .
- Return
"await" .
- Return the
StringValue ofIdentifierName .
13.1.3 Runtime Semantics: Evaluation
- Return ?
ResolveBinding (StringValue ofIdentifier ).
- Return ?
ResolveBinding ("yield" ).
- Return ?
ResolveBinding ("await" ).
The result of evaluating an
Inyield may be used as an identifier. Evaluating theyield as if it was an
13.2 Primary Expression
Syntax
Supplemental Syntax
When processing an instance of the production
the interpretation of
13.2.1 Semantics
13.2.1.1 Static Semantics: CoveredParenthesizedExpression
- Return the
ParenthesizedExpression that iscovered byCoverParenthesizedExpressionAndArrowParameterList .
13.2.2 Thethis Keyword
13.2.2.1 Runtime Semantics: Evaluation
- Return ?
ResolveThisBinding ().
13.2.3 Identifier Reference
See
13.2.4 Literals
Syntax
13.2.4.1 Runtime Semantics: Evaluation
- Return
null .
- If
BooleanLiteral is the tokenfalse, returnfalse . - If
BooleanLiteral is the tokentrue, returntrue .
- Return the
NumericValue ofNumericLiteral as defined in12.8.3 .
- Return the
SV ofStringLiteral as defined in12.8.4.1 .
13.2.5 Array Initializer
An
Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an
Syntax
13.2.5.1 Runtime Semantics: ArrayAccumulation
With parametersarray andnextIndex.
- Return the result of performing
ArrayAccumulation forElision with argumentsarray andnextIndex + 1.
- If
Elision is present, then- SetnextIndex to the result of performing
ArrayAccumulation forElision with argumentsarray andnextIndex. ReturnIfAbrupt (nextIndex).
- SetnextIndex to the result of performing
- LetinitResult be the result of evaluating
AssignmentExpression . - LetinitValue be ?
GetValue (initResult). - Letcreated be !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (nextIndex)),initValue). - ReturnnextIndex + 1.
- If
Elision is present, then- SetnextIndex to the result of performing
ArrayAccumulation forElision with argumentsarray andnextIndex. ReturnIfAbrupt (nextIndex).
- SetnextIndex to the result of performing
- Return the result of performing
ArrayAccumulation forSpreadElement with argumentsarray andnextIndex.
- SetnextIndex to the result of performing
ArrayAccumulation forElementList with argumentsarray andnextIndex. ReturnIfAbrupt (nextIndex).- If
Elision is present, then- SetnextIndex to the result of performing
ArrayAccumulation forElision with argumentsarray andnextIndex. ReturnIfAbrupt (nextIndex).
- SetnextIndex to the result of performing
- LetinitResult be the result of evaluating
AssignmentExpression . - LetinitValue be ?
GetValue (initResult). - Letcreated be !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (nextIndex)),initValue). - ReturnnextIndex + 1.
- SetnextIndex to the result of performing
ArrayAccumulation forElementList with argumentsarray andnextIndex. ReturnIfAbrupt (nextIndex).- If
Elision is present, then- SetnextIndex to the result of performing
ArrayAccumulation forElision with argumentsarray andnextIndex. ReturnIfAbrupt (nextIndex).
- SetnextIndex to the result of performing
- Return the result of performing
ArrayAccumulation forSpreadElement with argumentsarray andnextIndex.
- LetspreadRef be the result of evaluating
AssignmentExpression . - LetspreadObj be ?
GetValue (spreadRef). - LetiteratorRecord be ?
GetIterator (spreadObj). - Repeat,
- Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , returnnextIndex. - LetnextValue be ?
IteratorValue (next). - Perform !
CreateDataPropertyOrThrow (array, !ToString (𝔽 (nextIndex)),nextValue). - SetnextIndex tonextIndex + 1.
- Letnext be ?
13.2.5.2 Runtime Semantics: Evaluation
- Letarray be !
ArrayCreate (0). - If
Elision is present, then- Letlen be the result of performing
ArrayAccumulation forElision with argumentsarray and 0. ReturnIfAbrupt (len).
- Letlen be the result of performing
- Returnarray.
- Letarray be !
ArrayCreate (0). - Letlen be the result of performing
ArrayAccumulation forElementList with argumentsarray and 0. ReturnIfAbrupt (len).- Returnarray.
- Letarray be !
ArrayCreate (0). - LetnextIndex be the result of performing
ArrayAccumulation forElementList with argumentsarray and 0. ReturnIfAbrupt (nextIndex).- If
Elision is present, then- Letlen be the result of performing
ArrayAccumulation forElision with argumentsarray andnextIndex. ReturnIfAbrupt (len).
- Letlen be the result of performing
- Returnarray.
13.2.6 Object Initializer
An object initializer is an expression describing the initialization of an Object, written in a form resembling a literal. It is a list of zero or more pairs of property keys and associated values, enclosed in curly brackets. The values need not be literals; they are evaluated each time the object initializer is evaluated.
Syntax
In certain contexts,
13.2.6.1 Static Semantics: Early Errors
- It is a Syntax Error if
HasDirectSuper ofMethodDefinition istrue .
In addition to describing an actual object initializer the
- Always throw a Syntax Error if code matches this production.
This production exists so that
13.2.6.2 Static Semantics: IsComputedPropertyKey
- Return
false .
- Return
true .
13.2.6.3 Static Semantics: PropertyNameList
- If
PropName ofPropertyDefinition isempty , return a new emptyList . - Return a
List whose sole element isPropName ofPropertyDefinition .
- Letlist be
PropertyNameList ofPropertyDefinitionList . - If
PropName ofPropertyDefinition isempty , returnlist. - Append
PropName ofPropertyDefinition to the end oflist. - Returnlist.
13.2.6.4 Runtime Semantics: Evaluation
- Return !
OrdinaryObjectCreate (%Object.prototype% ).
- Letobj be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform ?
PropertyDefinitionEvaluation ofPropertyDefinitionList with argumentsobj andtrue . - Returnobj.
- Return
StringValue ofIdentifierName .
- Return the
SV ofStringLiteral .
- Letnbr be the
NumericValue ofNumericLiteral . - Return !
ToString (nbr).
- LetexprValue be the result of evaluating
AssignmentExpression . - LetpropName be ?
GetValue (exprValue). - Return ?
ToPropertyKey (propName).
13.2.6.5 Runtime Semantics: PropertyDefinitionEvaluation
With parametersobject andenumerable.
- Perform ?
PropertyDefinitionEvaluation ofPropertyDefinitionList with argumentsobject andenumerable. - Return the result of performing
PropertyDefinitionEvaluation ofPropertyDefinition with argumentsobject andenumerable.
- LetexprValue be the result of evaluating
AssignmentExpression . - LetfromValue be ?
GetValue (exprValue). - LetexcludedNames be a new empty
List . - Return ?
CopyDataProperties (object,fromValue,excludedNames).
- LetpropName be
StringValue ofIdentifierReference . - LetexprValue be the result of evaluating
IdentifierReference . - LetpropValue be ?
GetValue (exprValue). Assert :enumerable istrue .Assert :object is an ordinary, extensible object with no non-configurable properties.- Return !
CreateDataPropertyOrThrow (object,propName,propValue).
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue , then- LetpropValue be ?
NamedEvaluation ofAssignmentExpression with argumentpropKey.
- LetpropValue be ?
- Else,
- LetexprValueRef be the result of evaluating
AssignmentExpression . - LetpropValue be ?
GetValue (exprValueRef).
- LetexprValueRef be the result of evaluating
Assert :enumerable istrue .Assert :object is an ordinary, extensible object with no non-configurable properties.- Return !
CreateDataPropertyOrThrow (object,propKey,propValue).
An alternative semantics for this production is given in
- Return ?
MethodDefinitionEvaluation ofMethodDefinition with argumentsobject andenumerable.
- Return ?
MethodDefinitionEvaluation ofGeneratorMethod with argumentsobject andenumerable.
- Return ?
MethodDefinitionEvaluation ofAsyncGeneratorMethod with argumentsobject andenumerable.
- Return ?
MethodDefinitionEvaluation ofAsyncMethod with argumentsobject andenumerable.
13.2.7 Function Defining Expressions
See
See
See
13.2.8 Regular Expression Literals
Syntax
See
13.2.8.1 Static Semantics: Early Errors
- It is a Syntax Error if
IsValidRegularExpressionLiteral (RegularExpressionLiteral ) isfalse .
13.2.8.2 Static Semantics: IsValidRegularExpressionLiteral (literal )
The abstract operation IsValidRegularExpressionLiteral takes argumentliteral. It determines if its argument is a valid regular expression literal. It performs the following steps when called:
Assert :literal is aRegularExpressionLiteral .- If
FlagText ofliteral contains any code points other thang,i,m,s,u, ory, or if it contains the same code point more than once, returnfalse . - LetpatternText be
BodyText ofliteral. - If
FlagText ofliteral containsu, letu betrue ; else letu befalse . - Ifu is
false , then- LetstringValue be
CodePointsToString (patternText). - SetpatternText to the sequence of code points resulting from interpreting each of the 16-bit elements ofstringValue as a Unicode BMP code point. UTF-16 decoding is not applied to the elements.
- LetstringValue be
- LetparseResult be
ParsePattern (patternText,u). - IfparseResult is a
Parse Node , returntrue ; else returnfalse .
13.2.8.3 Runtime Semantics: Evaluation
- Letpattern be !
CodePointsToString (BodyText ofRegularExpressionLiteral ). - Letflags be !
CodePointsToString (FlagText ofRegularExpressionLiteral ). - Return
RegExpCreate (pattern,flags).
13.2.9 Template Literals
Syntax
13.2.9.1 Static Semantics: Early Errors
- It is a Syntax Error if the[Tagged] parameter was not set and
NoSubstitutionTemplate Contains NotEscapeSequence .
- It is a Syntax Error if the number of elements in the result of
TemplateStrings ofTemplateLiteral with argumentfalse is greater than 232 - 1.
- It is a Syntax Error if the[Tagged] parameter was not set and
TemplateHead Contains NotEscapeSequence .
- It is a Syntax Error if the[Tagged] parameter was not set and
TemplateTail Contains NotEscapeSequence .
- It is a Syntax Error if the[Tagged] parameter was not set and
TemplateMiddle Contains NotEscapeSequence .
13.2.9.2 Static Semantics: TemplateStrings
With parameterraw.
- Ifraw is
false , then- Letstring be the TV of
NoSubstitutionTemplate .
- Letstring be the TV of
- Else,
- Letstring be the TRV of
NoSubstitutionTemplate .
- Letstring be the TRV of
- Return a
List whose sole element isstring.
- Ifraw is
false , then- Lethead be the TV of
TemplateHead .
- Lethead be the TV of
- Else,
- Lethead be the TRV of
TemplateHead .
- Lethead be the TRV of
- Lettail be
TemplateStrings ofTemplateSpans with argumentraw. - Return a
List whose elements arehead followed by the elements oftail.
- Ifraw is
false , then- Lettail be the TV of
TemplateTail .
- Lettail be the TV of
- Else,
- Lettail be the TRV of
TemplateTail .
- Lettail be the TRV of
- Return a
List whose sole element istail.
- Letmiddle be
TemplateStrings ofTemplateMiddleList with argumentraw. - Ifraw is
false , then- Lettail be the TV of
TemplateTail .
- Lettail be the TV of
- Else,
- Lettail be the TRV of
TemplateTail .
- Lettail be the TRV of
- Return a
List whose elements are the elements ofmiddle followed bytail.
- Ifraw is
false , then- Letstring be the TV of
TemplateMiddle .
- Letstring be the TV of
- Else,
- Letstring be the TRV of
TemplateMiddle .
- Letstring be the TRV of
- Return a
List whose sole element isstring.
- Letfront be
TemplateStrings ofTemplateMiddleList with argumentraw. - Ifraw is
false , then- Letlast be the TV of
TemplateMiddle .
- Letlast be the TV of
- Else,
- Letlast be the TRV of
TemplateMiddle .
- Letlast be the TRV of
- Appendlast as the last element of the
List front. - Returnfront.
13.2.9.3 GetTemplateObject (templateLiteral )
The abstract operation GetTemplateObject takes argumenttemplateLiteral (a
- Letrealm be
the current Realm Record . - LettemplateRegistry berealm.[[TemplateMap]].
- For each elemente oftemplateRegistry, do
- Ife.[[Site]] is
the same Parse Node astemplateLiteral, then- Returne.[[Array]].
- Ife.[[Site]] is
- LetrawStrings be
TemplateStrings oftemplateLiteral with argumenttrue . - LetcookedStrings be
TemplateStrings oftemplateLiteral with argumentfalse . - Letcount be the number of elements in the
List cookedStrings. Assert :count ≤ 232 - 1.- Lettemplate be !
ArrayCreate (count). - LetrawObj be !
ArrayCreate (count). - Letindex be 0.
- Repeat, whileindex <count,
- Letprop be !
ToString (𝔽 (index)). - LetcookedValue becookedStrings[index].
- Perform !
DefinePropertyOrThrow (template,prop, PropertyDescriptor { [[Value]]:cookedValue, [[Writable]]:false , [[Enumerable]]:true , [[Configurable]]:false }). - LetrawValue be the String valuerawStrings[index].
- Perform !
DefinePropertyOrThrow (rawObj,prop, PropertyDescriptor { [[Value]]:rawValue, [[Writable]]:false , [[Enumerable]]:true , [[Configurable]]:false }). - Setindex toindex + 1.
- Letprop be !
- Perform !
SetIntegrityLevel (rawObj,frozen ). - Perform !
DefinePropertyOrThrow (template,"raw" , PropertyDescriptor { [[Value]]:rawObj, [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:false }). - Perform !
SetIntegrityLevel (template,frozen ). - Append the
Record { [[Site]]:templateLiteral, [[Array]]:template } totemplateRegistry. - Returntemplate.
The creation of a template object cannot result in an
Each
Future editions of this specification may define additional non-enumerable properties of template objects.
13.2.9.4 Runtime Semantics: SubstitutionEvaluation
- Return a new empty
List .
- Return the result of
SubstitutionEvaluation ofTemplateMiddleList .
- LetsubRef be the result of evaluating
Expression . - Letsub be ?
GetValue (subRef). - Return a
List whose sole element issub.
- Letpreceding be ?
SubstitutionEvaluation ofTemplateMiddleList . - LetnextRef be the result of evaluating
Expression . - Letnext be ?
GetValue (nextRef). - Appendnext as the last element of the
List preceding. - Returnpreceding.
13.2.9.5 Runtime Semantics: Evaluation
- Return the TV of
NoSubstitutionTemplate as defined in12.8.6 .
- Lethead be the TV of
TemplateHead as defined in12.8.6 . - LetsubRef be the result of evaluating
Expression . - Letsub be ?
GetValue (subRef). - Letmiddle be ?
ToString (sub). - Lettail be the result of evaluating
TemplateSpans . ReturnIfAbrupt (tail).- Return the
string-concatenation ofhead,middle, andtail.
The string conversion semantics applied to theString.prototype.concat rather than the+ operator.
- Return the TV of
TemplateTail as defined in12.8.6 .
- Lethead be the result of evaluating
TemplateMiddleList . ReturnIfAbrupt (head).- Lettail be the TV of
TemplateTail as defined in12.8.6 . - Return the
string-concatenation ofhead andtail.
- Lethead be the TV of
TemplateMiddle as defined in12.8.6 . - LetsubRef be the result of evaluating
Expression . - Letsub be ?
GetValue (subRef). - Letmiddle be ?
ToString (sub). - Return the
string-concatenation ofhead andmiddle.
The string conversion semantics applied to theString.prototype.concat rather than the+ operator.
- Letrest be the result of evaluating
TemplateMiddleList . ReturnIfAbrupt (rest).- Letmiddle be the TV of
TemplateMiddle as defined in12.8.6 . - LetsubRef be the result of evaluating
Expression . - Letsub be ?
GetValue (subRef). - Letlast be ?
ToString (sub). - Return the
string-concatenation ofrest,middle, andlast.
The string conversion semantics applied to theString.prototype.concat rather than the+ operator.
13.2.10 The Grouping Operator
13.2.10.1 Static Semantics: Early Errors
- It is a Syntax Error if
CoverParenthesizedExpressionAndArrowParameterList is notcovering aParenthesizedExpression . - All Early Error rules for
ParenthesizedExpression and its derived productions also apply toCoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList .
13.2.10.2 Runtime Semantics: Evaluation
- Letexpr be
CoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList . - Return the result of evaluatingexpr.
- Return the result of evaluating
Expression . This may be of typeReference .
This algorithm does not applydelete andtypeof may be applied to parenthesized expressions.
13.3 Left-Hand-Side Expressions
Syntax
Supplemental Syntax
When processing an instance of the production
the interpretation of
13.3.1 Static Semantics
13.3.1.1 Static Semantics: Early Errors
- It is a Syntax Error if any code matches this production.
This production exists in order to prevent automatic semicolon insertion rules (
a?.b`c`so that it would be interpreted as two valid statements. The purpose is to maintain consistency with similar code without optional chaining:
a.b`c`which is a valid statement and where automatic semicolon insertion does not apply.
- It is a Syntax Error if the syntactic
goal symbol is notModule .
13.3.1.2 Static Semantics: CoveredCallExpression
- Return the
CallMemberExpression that iscovered byCoverCallExpressionAndAsyncArrowHead .
13.3.2 Property Accessors
Properties are accessed by name, using either the dot notation:
or the bracket notation:
The dot notation is explained by the following syntactic conversion:
is identical in its behaviour to
and similarly
is identical in its behaviour to
where <identifier-name-string> is the result of evaluating
13.3.2.1 Runtime Semantics: Evaluation
- LetbaseReference be the result of evaluating
MemberExpression . - LetbaseValue be ?
GetValue (baseReference). - If the code matched by this
MemberExpression isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithExpressionKey (baseValue,Expression ,strict).
- LetbaseReference be the result of evaluating
MemberExpression . - LetbaseValue be ?
GetValue (baseReference). - If the code matched by this
MemberExpression isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithIdentifierKey (baseValue,IdentifierName ,strict).
- LetbaseReference be the result of evaluating
CallExpression . - LetbaseValue be ?
GetValue (baseReference). - If the code matched by this
CallExpression isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithExpressionKey (baseValue,Expression ,strict).
- LetbaseReference be the result of evaluating
CallExpression . - LetbaseValue be ?
GetValue (baseReference). - If the code matched by this
CallExpression isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithIdentifierKey (baseValue,IdentifierName ,strict).
13.3.3 EvaluatePropertyAccessWithExpressionKey (baseValue,expression,strict )
The abstract operation EvaluatePropertyAccessWithExpressionKey takes argumentsbaseValue (an
- LetpropertyNameReference be the result of evaluatingexpression.
- LetpropertyNameValue be ?
GetValue (propertyNameReference). - Letbv be ?
RequireObjectCoercible (baseValue). - LetpropertyKey be ?
ToPropertyKey (propertyNameValue). - Return the
Reference Record { [[Base]]:bv, [[ReferencedName]]:propertyKey, [[Strict]]:strict, [[ThisValue]]:empty }.
13.3.4 EvaluatePropertyAccessWithIdentifierKey (baseValue,identifierName,strict )
The abstract operation EvaluatePropertyAccessWithIdentifierKey takes argumentsbaseValue (an
Assert :identifierName is anIdentifierName .- Letbv be ?
RequireObjectCoercible (baseValue). - LetpropertyNameString be
StringValue ofidentifierName. - Return the
Reference Record { [[Base]]:bv, [[ReferencedName]]:propertyNameString, [[Strict]]:strict, [[ThisValue]]:empty }.
13.3.5 Thenew Operator
13.3.5.1 Runtime Semantics: Evaluation
- Return ?
EvaluateNew (NewExpression ,empty ).
- Return ?
EvaluateNew (MemberExpression ,Arguments ).
13.3.5.1.1 EvaluateNew (constructExpr,arguments )
The abstract operation EvaluateNew takes argumentsconstructExpr andarguments. It performs the following steps when called:
Assert :constructExpr is either aNewExpression or aMemberExpression .Assert :arguments is eitherempty or anArguments .- Letref be the result of evaluatingconstructExpr.
- Letconstructor be ?
GetValue (ref). - Ifarguments is
empty , letargList be a new emptyList . - Else,
- LetargList be ?
ArgumentListEvaluation ofarguments.
- LetargList be ?
- If
IsConstructor (constructor) isfalse , throw aTypeError exception. - Return ?
Construct (constructor,argList).
13.3.6 Function Calls
13.3.6.1 Runtime Semantics: Evaluation
- Letexpr be
CoveredCallExpression ofCoverCallExpressionAndAsyncArrowHead . - LetmemberExpr be the
MemberExpression ofexpr. - Letarguments be the
Arguments ofexpr. - Letref be the result of evaluatingmemberExpr.
- Letfunc be ?
GetValue (ref). - Ifref is a
Reference Record ,IsPropertyReference (ref) isfalse , andref.[[ReferencedName]] is"eval" , then- If
SameValue (func,%eval% ) istrue , then- LetargList be ?
ArgumentListEvaluation ofarguments. - IfargList has no elements, return
undefined . - LetevalArg be the first element ofargList.
- If the source code matching this
CallExpression isstrict mode code , letstrictCaller betrue . Otherwise letstrictCaller befalse . - LetevalRealm be
the current Realm Record . - Return ?
PerformEval (evalArg,evalRealm,strictCaller,true ).
- LetargList be ?
- If
- LetthisCall be this
CallExpression . - LettailCall be
IsInTailPosition (thisCall). - Return ?
EvaluateCall (func,ref,arguments,tailCall).
A
- Letref be the result of evaluating
CallExpression . - Letfunc be ?
GetValue (ref). - LetthisCall be this
CallExpression . - LettailCall be
IsInTailPosition (thisCall). - Return ?
EvaluateCall (func,ref,Arguments ,tailCall).
13.3.6.2 EvaluateCall (func,ref,arguments,tailPosition )
The abstract operation EvaluateCall takes argumentsfunc (an
- Ifref is a
Reference Record , then- If
IsPropertyReference (ref) istrue , then- LetthisValue be
GetThisValue (ref).
- LetthisValue be
- Else,
- LetrefEnv beref.[[Base]].
Assert :refEnv is anEnvironment Record .- LetthisValue berefEnv.WithBaseObject().
- If
- Else,
- LetthisValue be
undefined .
- LetthisValue be
- LetargList be ?
ArgumentListEvaluation ofarguments. - If
Type (func) is not Object, throw aTypeError exception. - If
IsCallable (func) isfalse , throw aTypeError exception. - IftailPosition is
true , performPrepareForTailCall (). - Letresult be
Call (func,thisValue,argList). Assert : IftailPosition istrue , the above call will not return here, but instead evaluation will continue as if the following return has already occurred.Assert : Ifresult is not anabrupt completion , thenType (result) is anECMAScript language type .- Returnresult.
13.3.7 Thesuper Keyword
13.3.7.1 Runtime Semantics: Evaluation
- Letenv be
GetThisEnvironment (). - LetactualThis be ?env.GetThisBinding().
- LetpropertyNameReference be the result of evaluating
Expression . - LetpropertyNameValue be ?
GetValue (propertyNameReference). - LetpropertyKey be ?
ToPropertyKey (propertyNameValue). - If the code matched by this
SuperProperty isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
MakeSuperPropertyReference (actualThis,propertyKey,strict).
- Letenv be
GetThisEnvironment (). - LetactualThis be ?env.GetThisBinding().
- LetpropertyKey be
StringValue ofIdentifierName . - If the code matched by this
SuperProperty isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
MakeSuperPropertyReference (actualThis,propertyKey,strict).
- LetnewTarget be
GetNewTarget (). Assert :Type (newTarget) is Object.- Letfunc be !
GetSuperConstructor (). - LetargList be ?
ArgumentListEvaluation ofArguments . - If
IsConstructor (func) isfalse , throw aTypeError exception. - Letresult be ?
Construct (func,argList,newTarget). - LetthisER be
GetThisEnvironment (). - Return ?thisER.BindThisValue(result).
13.3.7.2 GetSuperConstructor ( )
The abstract operation GetSuperConstructor takes no arguments. It performs the following steps when called:
- LetenvRec be
GetThisEnvironment (). Assert :envRec is afunction Environment Record .- LetactiveFunction beenvRec.[[FunctionObject]].
Assert :activeFunction is an ECMAScriptfunction object .- LetsuperConstructor be !activeFunction.[[GetPrototypeOf]]().
- ReturnsuperConstructor.
13.3.7.3 MakeSuperPropertyReference (actualThis,propertyKey,strict )
The abstract operation MakeSuperPropertyReference takes argumentsactualThis,propertyKey, andstrict. It performs the following steps when called:
- Letenv be
GetThisEnvironment (). Assert :env.HasSuperBinding() istrue .- LetbaseValue be ?env.GetSuperBase().
- Letbv be ?
RequireObjectCoercible (baseValue). - Return the
Reference Record { [[Base]]:bv, [[ReferencedName]]:propertyKey, [[Strict]]:strict, [[ThisValue]]:actualThis }. - NOTE: This returns a
Super Reference Record .
13.3.8 Argument Lists
The evaluation of an argument list produces a
13.3.8.1 Runtime Semantics: ArgumentListEvaluation
- Return a new empty
List .
- Letref be the result of evaluating
AssignmentExpression . - Letarg be ?
GetValue (ref). - Return a
List whose sole element isarg.
- Letlist be a new empty
List . - LetspreadRef be the result of evaluating
AssignmentExpression . - LetspreadObj be ?
GetValue (spreadRef). - LetiteratorRecord be ?
GetIterator (spreadObj). - Repeat,
- Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , returnlist. - LetnextArg be ?
IteratorValue (next). - AppendnextArg as the last element oflist.
- Letnext be ?
- LetprecedingArgs be ?
ArgumentListEvaluation ofArgumentList . - Letref be the result of evaluating
AssignmentExpression . - Letarg be ?
GetValue (ref). - Appendarg to the end ofprecedingArgs.
- ReturnprecedingArgs.
- LetprecedingArgs be ?
ArgumentListEvaluation ofArgumentList . - LetspreadRef be the result of evaluating
AssignmentExpression . - LetiteratorRecord be ?
GetIterator (?GetValue (spreadRef)). - Repeat,
- Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , returnprecedingArgs. - LetnextArg be ?
IteratorValue (next). - AppendnextArg as the last element ofprecedingArgs.
- Letnext be ?
- LettemplateLiteral be this
TemplateLiteral . - LetsiteObj be
GetTemplateObject (templateLiteral). - Return a
List whose sole element issiteObj.
- LettemplateLiteral be this
TemplateLiteral . - LetsiteObj be
GetTemplateObject (templateLiteral). - Letremaining be ?
ArgumentListEvaluation ofSubstitutionTemplate . - Return a
List whose first element issiteObj and whose subsequent elements are the elements ofremaining.
- LetfirstSubRef be the result of evaluating
Expression . - LetfirstSub be ?
GetValue (firstSubRef). - LetrestSub be ?
SubstitutionEvaluation ofTemplateSpans . Assert :restSub is aList .- Return a
List whose first element isfirstSub and whose subsequent elements are the elements ofrestSub.restSub may contain no elements.
13.3.9 Optional Chains
?..13.3.9.1 Runtime Semantics: Evaluation
- LetbaseReference be the result of evaluating
MemberExpression . - LetbaseValue be ?
GetValue (baseReference). - IfbaseValue is
undefined ornull , then- Return
undefined .
- Return
- Return the result of performing
ChainEvaluation ofOptionalChain with argumentsbaseValue andbaseReference.
- LetbaseReference be the result of evaluating
CallExpression . - LetbaseValue be ?
GetValue (baseReference). - IfbaseValue is
undefined ornull , then- Return
undefined .
- Return
- Return the result of performing
ChainEvaluation ofOptionalChain with argumentsbaseValue andbaseReference.
- LetbaseReference be the result of evaluating
OptionalExpression . - LetbaseValue be ?
GetValue (baseReference). - IfbaseValue is
undefined ornull , then- Return
undefined .
- Return
- Return the result of performing
ChainEvaluation ofOptionalChain with argumentsbaseValue andbaseReference.
13.3.9.2 Runtime Semantics: ChainEvaluation
With parametersbaseValue andbaseReference.
- LetthisChain be this
OptionalChain . - LettailCall be
IsInTailPosition (thisChain). - Return ?
EvaluateCall (baseValue,baseReference,Arguments ,tailCall).
- If the code matched by this
OptionalChain isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithExpressionKey (baseValue,Expression ,strict).
- If the code matched by this
OptionalChain isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithIdentifierKey (baseValue,IdentifierName ,strict).
- LetoptionalChain be
OptionalChain . - LetnewReference be ?
ChainEvaluation ofoptionalChain with argumentsbaseValue andbaseReference. - LetnewValue be ?
GetValue (newReference). - LetthisChain be this
OptionalChain . - LettailCall be
IsInTailPosition (thisChain). - Return ?
EvaluateCall (newValue,newReference,Arguments ,tailCall).
- LetoptionalChain be
OptionalChain . - LetnewReference be ?
ChainEvaluation ofoptionalChain with argumentsbaseValue andbaseReference. - LetnewValue be ?
GetValue (newReference). - If the code matched by this
OptionalChain isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithExpressionKey (newValue,Expression ,strict).
- LetoptionalChain be
OptionalChain . - LetnewReference be ?
ChainEvaluation ofoptionalChain with argumentsbaseValue andbaseReference. - LetnewValue be ?
GetValue (newReference). - If the code matched by this
OptionalChain isstrict mode code , letstrict betrue ; else letstrict befalse . - Return ?
EvaluatePropertyAccessWithIdentifierKey (newValue,IdentifierName ,strict).
13.3.10 Import Calls
13.3.10.1 Runtime Semantics: Evaluation
- LetreferencingScriptOrModule be !
GetActiveScriptOrModule (). - LetargRef be the result of evaluating
AssignmentExpression . - Letspecifier be ?
GetValue (argRef). - LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - LetspecifierString be
ToString (specifier). IfAbruptRejectPromise (specifierString,promiseCapability).- Perform !
HostImportModuleDynamically (referencingScriptOrModule,specifierString,promiseCapability). - ReturnpromiseCapability.[[Promise]].
13.3.11 Tagged Templates
A tagged template is a function call where the arguments of the call are derived from a
13.3.11.1 Runtime Semantics: Evaluation
- LettagRef be the result of evaluating
MemberExpression . - LettagFunc be ?
GetValue (tagRef). - LetthisCall be this
MemberExpression . - LettailCall be
IsInTailPosition (thisCall). - Return ?
EvaluateCall (tagFunc,tagRef,TemplateLiteral ,tailCall).
- LettagRef be the result of evaluating
CallExpression . - LettagFunc be ?
GetValue (tagRef). - LetthisCall be this
CallExpression . - LettailCall be
IsInTailPosition (thisCall). - Return ?
EvaluateCall (tagFunc,tagRef,TemplateLiteral ,tailCall).
13.3.12 Meta Properties
13.3.12.1 Runtime Semantics: Evaluation
- Return
GetNewTarget ().
- Letmodule be !
GetActiveScriptOrModule (). Assert :module is aSource Text Module Record .- LetimportMeta bemodule.[[ImportMeta]].
- IfimportMeta is
empty , then- SetimportMeta to !
OrdinaryObjectCreate (null ). - LetimportMetaValues be !
HostGetImportMetaProperties (module). - For each
Record { [[Key]], [[Value]] }p ofimportMetaValues, do- Perform !
CreateDataPropertyOrThrow (importMeta,p.[[Key]],p.[[Value]]).
- Perform !
- Perform !
HostFinalizeImportMeta (importMeta,module). - Setmodule.[[ImportMeta]] toimportMeta.
- ReturnimportMeta.
- SetimportMeta to !
- Else,
13.3.12.1.1 HostGetImportMetaProperties (moduleRecord )
Theimport.meta.
The implementation of HostGetImportMetaProperties must conform to the following requirements:
- It must return a
List , whose values are all Records with two fields, [[Key]] and [[Value]]. - Each such
Record 's [[Key]] field must be a property key, i.e.,IsPropertyKey must returntrue when applied to it. - Each such
Record 's [[Value]] field must be an ECMAScript value. - It must always complete normally (i.e., not return an
abrupt completion ).
The default implementation of HostGetImportMetaProperties is to return a new empty
13.3.12.1.2 HostFinalizeImportMeta (importMeta,moduleRecord )
Theimport.meta.
Most hosts will be able to simply define
The implementation of HostFinalizeImportMeta must conform to the following requirements:
- It must always complete normally (i.e., not return an
abrupt completion ).
The default implementation of HostFinalizeImportMeta is to return
13.4 Update Expressions
Syntax
13.4.1 Static Semantics: Early Errors
- It is an early Syntax Error if
AssignmentTargetType ofLeftHandSideExpression is notsimple .
- It is an early Syntax Error if
AssignmentTargetType ofUnaryExpression is notsimple .
13.4.2 Postfix Increment Operator
13.4.2.1 Runtime Semantics: Evaluation
13.4.3 Postfix Decrement Operator
13.4.3.1 Runtime Semantics: Evaluation
13.4.4 Prefix Increment Operator
13.4.4.1 Runtime Semantics: Evaluation
13.4.5 Prefix Decrement Operator
13.4.5.1 Runtime Semantics: Evaluation
13.5 Unary Operators
Syntax
13.5.1 Thedelete Operator
13.5.1.1 Static Semantics: Early Errors
- It is a Syntax Error if the
UnaryExpression is contained instrict mode code and the derivedUnaryExpression isPrimaryExpression : IdentifierReference It is a Syntax Error if the derived
UnaryExpression isPrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
andCoverParenthesizedExpressionAndArrowParameterList ultimately derives a phrase that, if used in place ofUnaryExpression , would produce a Syntax Error according to these rules. This rule is recursively applied.
The last rule means that expressions such asdelete (((foo))) produce early errors because of recursive application of the first rule.
13.5.1.2 Runtime Semantics: Evaluation
- Letref be the result of evaluating
UnaryExpression . ReturnIfAbrupt (ref).- Ifref is not a
Reference Record , returntrue . - If
IsUnresolvableReference (ref) istrue , thenAssert :ref.[[Strict]] isfalse .- Return
true .
- If
IsPropertyReference (ref) istrue , then- If
IsSuperReference (ref) istrue , throw aReferenceError exception. - LetbaseObj be !
ToObject (ref.[[Base]]). - LetdeleteStatus be ?baseObj.[[Delete]](ref.[[ReferencedName]]).
- IfdeleteStatus is
false andref.[[Strict]] istrue , throw aTypeError exception. - ReturndeleteStatus.
- If
- Else,
- Letbase beref.[[Base]].
Assert :base is anEnvironment Record .- Return ?base.DeleteBinding(ref.[[ReferencedName]]).
When adelete operator occurs withindelete operator occurs within
The object that may be created in step
13.5.2 Thevoid Operator
13.5.2.1 Runtime Semantics: Evaluation
- Letexpr be the result of evaluating
UnaryExpression . - Perform ?
GetValue (expr). - Return
undefined .
13.5.3 Thetypeof Operator
13.5.3.1 Runtime Semantics: Evaluation
- Letval be the result of evaluating
UnaryExpression . - Ifval is a
Reference Record , then- If
IsUnresolvableReference (val) istrue , return"undefined" .
- If
- Setval to ?
GetValue (val). - Return a String according to
Table 37 .
| Type ofval | Result |
|---|---|
| Undefined | |
| Null | |
| Boolean | |
| Number | |
| String | |
| Symbol | |
| BigInt | |
| Object (does not implement [[Call]]) | |
| Object (implements [[Call]]) |
An additional entry related to [[IsHTMLDDA]] Internal Slot can be found in
13.5.4 Unary+ Operator
The unary + operator converts its operand to Number type.
13.5.4.1 Runtime Semantics: Evaluation
- Letexpr be the result of evaluating
UnaryExpression . - Return ?
ToNumber (?GetValue (expr)).
13.5.5 Unary- Operator
The unary- operator converts its operand to Number type and then negates it. Negating
13.5.5.1 Runtime Semantics: Evaluation
- Letexpr be the result of evaluating
UnaryExpression . - LetoldValue be ?
ToNumeric (?GetValue (expr)). - LetT be
Type (oldValue). - Return !T::unaryMinus(oldValue).
13.5.6 Bitwise NOT Operator (~ )
13.5.6.1 Runtime Semantics: Evaluation
- Letexpr be the result of evaluating
UnaryExpression . - LetoldValue be ?
ToNumeric (?GetValue (expr)). - LetT be
Type (oldValue). - Return !T::bitwiseNOT(oldValue).
13.5.7 Logical NOT Operator (! )
13.5.7.1 Runtime Semantics: Evaluation
- Letexpr be the result of evaluating
UnaryExpression . - LetoldValue be !
ToBoolean (?GetValue (expr)). - IfoldValue is
true , returnfalse . - Return
true .
13.6 Exponentiation Operator
Syntax
13.6.1 Runtime Semantics: Evaluation
13.7 Multiplicative Operators
Syntax
- The
*operator performs multiplication, producing the product of its operands. - The
/operator performs division, producing the quotient of its operands. - The
%operator yields the remainder of its operands from an implied division.
13.7.1 Runtime Semantics: Evaluation
- LetopText be the
source text matched by MultiplicativeOperator . - Return ?
EvaluateStringOrNumericBinaryExpression (MultiplicativeExpression ,opText,ExponentiationExpression ).
13.8 Additive Operators
Syntax
13.8.1 The Addition Operator (+ )
The addition operator either performs string concatenation or numeric addition.
13.8.1.1 Runtime Semantics: Evaluation
13.8.2 The Subtraction Operator (- )
The- operator performs subtraction, producing the difference of its operands.
13.8.2.1 Runtime Semantics: Evaluation
13.9 Bitwise Shift Operators
Syntax
13.9.1 The Left Shift Operator (<< )
Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.
13.9.1.1 Runtime Semantics: Evaluation
13.9.2 The Signed Right Shift Operator (>> )
Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
13.9.2.1 Runtime Semantics: Evaluation
13.9.3 The Unsigned Right Shift Operator (>>> )
Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
13.9.3.1 Runtime Semantics: Evaluation
13.10 Relational Operators
The result of evaluating a relational operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
Syntax
The[In] grammar parameter is needed to avoid confusing thein operator in a relational expression with thein operator in afor statement.
13.10.1 Runtime Semantics: Evaluation
- Letlref be the result of evaluating
RelationalExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
ShiftExpression . - Letrval be ?
GetValue (rref). - Letr be the result of performing
Abstract Relational Comparison lval <rval. ReturnIfAbrupt (r).- Ifr is
undefined , returnfalse . Otherwise, returnr.
- Letlref be the result of evaluating
RelationalExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
ShiftExpression . - Letrval be ?
GetValue (rref). - Letr be the result of performing
Abstract Relational Comparison rval <lval withLeftFirst equal tofalse . ReturnIfAbrupt (r).- Ifr is
undefined , returnfalse . Otherwise, returnr.
- Letlref be the result of evaluating
RelationalExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
ShiftExpression . - Letrval be ?
GetValue (rref). - Letr be the result of performing
Abstract Relational Comparison rval <lval withLeftFirst equal tofalse . ReturnIfAbrupt (r).- Ifr is
true orundefined , returnfalse . Otherwise, returntrue .
- Letlref be the result of evaluating
RelationalExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
ShiftExpression . - Letrval be ?
GetValue (rref). - Letr be the result of performing
Abstract Relational Comparison lval <rval. ReturnIfAbrupt (r).- Ifr is
true orundefined , returnfalse . Otherwise, returntrue .
- Letlref be the result of evaluating
RelationalExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
ShiftExpression . - Letrval be ?
GetValue (rref). - Return ?
InstanceofOperator (lval,rval).
- Letlref be the result of evaluating
RelationalExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
ShiftExpression . - Letrval be ?
GetValue (rref). - If
Type (rval) is not Object, throw aTypeError exception. - Return ?
HasProperty (rval, ?ToPropertyKey (lval)).
13.10.2 InstanceofOperator (V,target )
The abstract operation InstanceofOperator takes argumentsV (an
- If
Type (target) is not Object, throw aTypeError exception. - LetinstOfHandler be ?
GetMethod (target,@@hasInstance ). - IfinstOfHandler is not
undefined , then - If
IsCallable (target) isfalse , throw aTypeError exception. - Return ?
OrdinaryHasInstance (target,V).
Stepsinstanceof operator semantics. If an object does not define or inheritinstanceof semantics.
13.11 Equality Operators
The result of evaluating an equality operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
Syntax
13.11.1 Runtime Semantics: Evaluation
- Letlref be the result of evaluating
EqualityExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
RelationalExpression . - Letrval be ?
GetValue (rref). - Return the result of performing
Abstract Equality Comparison rval ==lval.
- Letlref be the result of evaluating
EqualityExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
RelationalExpression . - Letrval be ?
GetValue (rref). - Letr be the result of performing
Abstract Equality Comparison rval ==lval. ReturnIfAbrupt (r).- Ifr is
true , returnfalse . Otherwise, returntrue .
- Letlref be the result of evaluating
EqualityExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
RelationalExpression . - Letrval be ?
GetValue (rref). - Return the result of performing
Strict Equality Comparison rval ===lval.
- Letlref be the result of evaluating
EqualityExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
RelationalExpression . - Letrval be ?
GetValue (rref). - Letr be the result of performing
Strict Equality Comparison rval ===lval. Assert :r is a normal completion.- Ifr.[[Value]] is
true , returnfalse . Otherwise, returntrue .
Given the above definition of equality:
- String comparison can be forced by:
`${a}` == `${b}`. - Numeric comparison can be forced by:
+a == +b. - Boolean comparison can be forced by:
!a == !b.
The equality operators maintain the following invariants:
A != Bis equivalent to!(A == B).A == Bis equivalent toB == A, except in the order of evaluation ofAandB.
The equality operator is not always transitive. For example, there might be two distinct String objects, each representing the same String value; each String object would be considered equal to the String value by the== operator, but the two String objects would not be equal to each other. For example:
new String("a") == "a"and"a" == new String("a")are bothtrue .new String("a") == new String("a")isfalse .
Comparison of Strings uses a simple equality test on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore Strings values that are canonically equal according to the Unicode standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form.
13.12 Binary Bitwise Operators
Syntax
13.12.1 Runtime Semantics: Evaluation
13.13 Binary Logical Operators
Syntax
The value produced by a&& or|| operator is not necessarily of type Boolean. The value produced will always be the value of one of the two operand expressions.
13.13.1 Runtime Semantics: Evaluation
- Letlref be the result of evaluating
LogicalANDExpression . - Letlval be ?
GetValue (lref). - Letlbool be !
ToBoolean (lval). - Iflbool is
false , returnlval. - Letrref be the result of evaluating
BitwiseORExpression . - Return ?
GetValue (rref).
- Letlref be the result of evaluating
LogicalORExpression . - Letlval be ?
GetValue (lref). - Letlbool be !
ToBoolean (lval). - Iflbool is
true , returnlval. - Letrref be the result of evaluating
LogicalANDExpression . - Return ?
GetValue (rref).
- Letlref be the result of evaluating
CoalesceExpressionHead . - Letlval be ?
GetValue (lref). - Iflval is
undefined ornull , then- Letrref be the result of evaluating
BitwiseORExpression . - Return ?
GetValue (rref).
- Letrref be the result of evaluating
- Otherwise, returnlval.
13.14 Conditional Operator (? : )
Syntax
The grammar for a
13.14.1 Runtime Semantics: Evaluation
- Letlref be the result of evaluating
ShortCircuitExpression . - Letlval be !
ToBoolean (?GetValue (lref)). - Iflval is
true , then- LettrueRef be the result of evaluating the first
AssignmentExpression . - Return ?
GetValue (trueRef).
- LettrueRef be the result of evaluating the first
- Else,
- LetfalseRef be the result of evaluating the second
AssignmentExpression . - Return ?
GetValue (falseRef).
- LetfalseRef be the result of evaluating the second
13.15 Assignment Operators
Syntax
13.15.1 Static Semantics: Early Errors
If
- It is a Syntax Error if
LeftHandSideExpression is notcovering anAssignmentPattern . - All Early Error rules for
AssignmentPattern and its derived productions also apply to theAssignmentPattern that iscovered byLeftHandSideExpression .
If
- It is a Syntax Error if
AssignmentTargetType ofLeftHandSideExpression is notsimple .
- It is a Syntax Error if
AssignmentTargetType ofLeftHandSideExpression is notsimple .
13.15.2 Runtime Semantics: Evaluation
- If
LeftHandSideExpression is neither anObjectLiteral nor anArrayLiteral , then- Letlref be the result of evaluating
LeftHandSideExpression . ReturnIfAbrupt (lref).- If
IsAnonymousFunctionDefinition (AssignmentExpression ) andIsIdentifierRef ofLeftHandSideExpression are bothtrue , then- Letrval be
NamedEvaluation ofAssignmentExpression with argumentlref.[[ReferencedName]].
- Letrval be
- Else,
- Letrref be the result of evaluating
AssignmentExpression . - Letrval be ?
GetValue (rref).
- Letrref be the result of evaluating
- Perform ?
PutValue (lref,rval). - Returnrval.
- Letlref be the result of evaluating
- LetassignmentPattern be the
AssignmentPattern that iscovered byLeftHandSideExpression . - Letrref be the result of evaluating
AssignmentExpression . - Letrval be ?
GetValue (rref). - Perform ?
DestructuringAssignmentEvaluation ofassignmentPattern usingrval as the argument. - Returnrval.
- Letlref be the result of evaluating
LeftHandSideExpression . - Letlval be ?
GetValue (lref). - Letrref be the result of evaluating
AssignmentExpression . - Letrval be ?
GetValue (rref). - LetassignmentOpText be the
source text matched by AssignmentOperator . - LetopText be the sequence of Unicode code points associated withassignmentOpText in the following table:
assignmentOpText opText **=***=*/=/%=%+=+-=-<<=<<>>=>>>>>=>>>&=&^=^|=| - Letr be
ApplyStringOrNumericBinaryOperator (lval,opText,rval). - Perform ?
PutValue (lref,r). - Returnr.
- Letlref be the result of evaluating
LeftHandSideExpression . - Letlval be ?
GetValue (lref). - Letlbool be !
ToBoolean (lval). - Iflbool is
false , returnlval. - If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue andIsIdentifierRef ofLeftHandSideExpression istrue , then- Letrval be
NamedEvaluation ofAssignmentExpression with argumentlref.[[ReferencedName]].
- Letrval be
- Else,
- Letrref be the result of evaluating
AssignmentExpression . - Letrval be ?
GetValue (rref).
- Letrref be the result of evaluating
- Perform ?
PutValue (lref,rval). - Returnrval.
- Letlref be the result of evaluating
LeftHandSideExpression . - Letlval be ?
GetValue (lref). - Letlbool be !
ToBoolean (lval). - Iflbool is
true , returnlval. - If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue andIsIdentifierRef ofLeftHandSideExpression istrue , then- Letrval be
NamedEvaluation ofAssignmentExpression with argumentlref.[[ReferencedName]].
- Letrval be
- Else,
- Letrref be the result of evaluating
AssignmentExpression . - Letrval be ?
GetValue (rref).
- Letrref be the result of evaluating
- Perform ?
PutValue (lref,rval). - Returnrval.
- Letlref be the result of evaluating
LeftHandSideExpression . - Letlval be ?
GetValue (lref). - Iflval is neither
undefined nornull , returnlval. - If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue andIsIdentifierRef ofLeftHandSideExpression istrue , then- Letrval be
NamedEvaluation ofAssignmentExpression with argumentlref.[[ReferencedName]].
- Letrval be
- Else,
- Letrref be the result of evaluating
AssignmentExpression . - Letrval be ?
GetValue (rref).
- Letrref be the result of evaluating
- Perform ?
PutValue (lref,rval). - Returnrval.
When this expression occurs within
13.15.3 ApplyStringOrNumericBinaryOperator (lval,opText,rval )
The abstract operation ApplyStringOrNumericBinaryOperator takes argumentslval (an
Assert :opText is present in the table in step8 .- IfopText is
+, then- Letlprim be ?
ToPrimitive (lval). - Letrprim be ?
ToPrimitive (rval). - If
Type (lprim) is String orType (rprim) is String, then- Letlstr be ?
ToString (lprim). - Letrstr be ?
ToString (rprim). - Return the
string-concatenation oflstr andrstr.
- Letlstr be ?
- Setlval tolprim.
- Setrval torprim.
- Letlprim be ?
- NOTE: At this point, it must be a numeric operation.
- Letlnum be ?
ToNumeric (lval). - Letrnum be ?
ToNumeric (rval). - If
Type (lnum) is different fromType (rnum), throw aTypeError exception. - LetT be
Type (lnum). - Letoperation be the abstract operation associated withopText in the following table:
opText operation **T::exponentiate *T::multiply /T::divide %T::remainder +T::add -T::subtract <<T::leftShift >>T::signedRightShift >>>T::unsignedRightShift &T::bitwiseAND ^T::bitwiseXOR |T::bitwiseOR - Return ?operation(lnum,rnum).
No hint is provided in the calls to
Step
13.15.4 EvaluateStringOrNumericBinaryExpression (leftOperand,opText,rightOperand )
The abstract operation EvaluateStringOrNumericBinaryExpression takes argumentsleftOperand (a
- Letlref be the result of evaluatingleftOperand.
- Letlval be ?
GetValue (lref). - Letrref be the result of evaluatingrightOperand.
- Letrval be ?
GetValue (rref). - Return ?
ApplyStringOrNumericBinaryOperator (lval,opText,rval).
13.15.5 Destructuring Assignment
Supplemental Syntax
In certain circumstances when processing an instance of the production
the interpretation of
13.15.5.1 Static Semantics: Early Errors
- It is a Syntax Error if
AssignmentTargetType ofIdentifierReference is notsimple .
- It is a Syntax Error if
DestructuringAssignmentTarget is anArrayLiteral or anObjectLiteral .
If
- It is a Syntax Error if
LeftHandSideExpression is notcovering anAssignmentPattern . - All Early Error rules for
AssignmentPattern and its derived productions also apply to theAssignmentPattern that iscovered byLeftHandSideExpression .
If
- It is a Syntax Error if
AssignmentTargetType ofLeftHandSideExpression is notsimple .
13.15.5.2 Runtime Semantics: DestructuringAssignmentEvaluation
With parametervalue.
- Perform ?
RequireObjectCoercible (value). - Return
NormalCompletion (empty ).
- Perform ?
RequireObjectCoercible (value). - Perform ?
PropertyDestructuringAssignmentEvaluation forAssignmentPropertyList usingvalue as the argument. - Return
NormalCompletion (empty ).
- LetiteratorRecord be ?
GetIterator (value). - Return ?
IteratorClose (iteratorRecord,NormalCompletion (empty )).
- LetiteratorRecord be ?
GetIterator (value). - Letresult be
IteratorDestructuringAssignmentEvaluation ofElision with argumentiteratorRecord. - IfiteratorRecord.[[Done]] is
false , return ?IteratorClose (iteratorRecord,result). - Returnresult.
- LetiteratorRecord be ?
GetIterator (value). - If
Elision is present, then- Letstatus be
IteratorDestructuringAssignmentEvaluation ofElision with argumentiteratorRecord. - Ifstatus is an
abrupt completion , thenAssert :iteratorRecord.[[Done]] istrue .- Return
Completion (status).
- Letstatus be
- Letresult be
IteratorDestructuringAssignmentEvaluation ofAssignmentRestElement with argumentiteratorRecord. - IfiteratorRecord.[[Done]] is
false , return ?IteratorClose (iteratorRecord,result). - Returnresult.
- LetiteratorRecord be ?
GetIterator (value). - Letresult be
IteratorDestructuringAssignmentEvaluation ofAssignmentElementList with argumentiteratorRecord. - IfiteratorRecord.[[Done]] is
false , return ?IteratorClose (iteratorRecord,result). - Returnresult.
- LetiteratorRecord be ?
GetIterator (value). - Letstatus be
IteratorDestructuringAssignmentEvaluation ofAssignmentElementList with argumentiteratorRecord. - Ifstatus is an
abrupt completion , then- IfiteratorRecord.[[Done]] is
false , return ?IteratorClose (iteratorRecord,status). - Return
Completion (status).
- IfiteratorRecord.[[Done]] is
- If
Elision is present, then- Setstatus to the result of performing
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument. - Ifstatus is an
abrupt completion , thenAssert :iteratorRecord.[[Done]] istrue .- Return
Completion (status).
- Setstatus to the result of performing
- If
AssignmentRestElement is present, then- Setstatus to the result of performing
IteratorDestructuringAssignmentEvaluation ofAssignmentRestElement withiteratorRecord as the argument.
- Setstatus to the result of performing
- IfiteratorRecord.[[Done]] is
false , return ?IteratorClose (iteratorRecord,status). - Return
Completion (status).
- Perform ?
RequireObjectCoercible (value). - LetexcludedNames be a new empty
List . - Return the result of performing
RestDestructuringAssignmentEvaluation ofAssignmentRestProperty withvalue andexcludedNames as the arguments.
- Perform ?
RequireObjectCoercible (value). - LetexcludedNames be ?
PropertyDestructuringAssignmentEvaluation ofAssignmentPropertyList with argumentvalue. - Return the result of performing
RestDestructuringAssignmentEvaluation ofAssignmentRestProperty with argumentsvalue andexcludedNames.
13.15.5.3 Runtime Semantics: PropertyDestructuringAssignmentEvaluation
With parametervalue.
- LetpropertyNames be ?
PropertyDestructuringAssignmentEvaluation ofAssignmentPropertyList with argumentvalue. - LetnextNames be ?
PropertyDestructuringAssignmentEvaluation ofAssignmentProperty with argumentvalue. - Append each item innextNames to the end ofpropertyNames.
- ReturnpropertyNames.
- LetP be
StringValue ofIdentifierReference . - Letlref be ?
ResolveBinding (P). - Letv be ?
GetV (value,P). - If
Initializer is present andv isopt undefined , then- If
IsAnonymousFunctionDefinition (Initializer ) istrue , then- Setv to the result of performing
NamedEvaluation forInitializer with argumentP.
- Setv to the result of performing
- Else,
- LetdefaultValue be the result of evaluating
Initializer . - Setv to ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- If
- Perform ?
PutValue (lref,v). - Return a
List whose sole element isP.
- Letname be the result of evaluating
PropertyName . ReturnIfAbrupt (name).- Perform ?
KeyedDestructuringAssignmentEvaluation ofAssignmentElement withvalue andname as the arguments. - Return a
List whose sole element isname.
13.15.5.4 Runtime Semantics: RestDestructuringAssignmentEvaluation
With parametersvalue andexcludedNames.
- Letlref be the result of evaluating
DestructuringAssignmentTarget . ReturnIfAbrupt (lref).- LetrestObj be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform ?
CopyDataProperties (restObj,value,excludedNames). - Return
PutValue (lref,restObj).
13.15.5.5 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
With parameteriteratorRecord.
- Return the result of performing
IteratorDestructuringAssignmentEvaluation ofAssignmentElisionElement usingiteratorRecord as the argument.
- Perform ?
IteratorDestructuringAssignmentEvaluation ofAssignmentElementList usingiteratorRecord as the argument. - Return the result of performing
IteratorDestructuringAssignmentEvaluation ofAssignmentElisionElement usingiteratorRecord as the argument.
- Return the result of performing
IteratorDestructuringAssignmentEvaluation ofAssignmentElement withiteratorRecord as the argument.
- Perform ?
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument. - Return the result of performing
IteratorDestructuringAssignmentEvaluation ofAssignmentElement withiteratorRecord as the argument.
- IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue .
- Letnext be
- Return
NormalCompletion (empty ).
- Perform ?
IteratorDestructuringAssignmentEvaluation ofElision withiteratorRecord as the argument. - IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue .
- Letnext be
- Return
NormalCompletion (empty ).
- If
DestructuringAssignmentTarget is neither anObjectLiteral nor anArrayLiteral , then- Letlref be the result of evaluating
DestructuringAssignmentTarget . ReturnIfAbrupt (lref).
- Letlref be the result of evaluating
- IfiteratorRecord.[[Done]] is
false , then- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue . - Else,
- Letvalue be
IteratorValue (next). - Ifvalue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (value).
- Letvalue be
- Letnext be
- IfiteratorRecord.[[Done]] is
true , letvalue beundefined . - If
Initializer is present andvalue isundefined , then- If
IsAnonymousFunctionDefinition (Initializer ) istrue andIsIdentifierRef ofDestructuringAssignmentTarget istrue , then- Letv be ?
NamedEvaluation ofInitializer with argumentlref.[[ReferencedName]].
- Letv be ?
- Else,
- LetdefaultValue be the result of evaluating
Initializer . - Letv be ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- If
- Else, letv bevalue.
- If
DestructuringAssignmentTarget is anObjectLiteral or anArrayLiteral , then- LetnestedAssignmentPattern be the
AssignmentPattern that iscovered byDestructuringAssignmentTarget . - Return the result of performing
DestructuringAssignmentEvaluation ofnestedAssignmentPattern withv as the argument.
- LetnestedAssignmentPattern be the
- Return ?
PutValue (lref,v).
Left to right evaluation order is maintained by evaluating a
- If
DestructuringAssignmentTarget is neither anObjectLiteral nor anArrayLiteral , then- Letlref be the result of evaluating
DestructuringAssignmentTarget . ReturnIfAbrupt (lref).
- Letlref be the result of evaluating
- LetA be !
ArrayCreate (0). - Letn be 0.
- Repeat, whileiteratorRecord.[[Done]] is
false ,- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , setiteratorRecord.[[Done]] totrue . - Else,
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),nextValue). - Setn ton + 1.
- LetnextValue be
- Letnext be
- If
DestructuringAssignmentTarget is neither anObjectLiteral nor anArrayLiteral , then- Return ?
PutValue (lref,A).
- Return ?
- LetnestedAssignmentPattern be the
AssignmentPattern that iscovered byDestructuringAssignmentTarget . - Return the result of performing
DestructuringAssignmentEvaluation ofnestedAssignmentPattern withA as the argument.
13.15.5.6 Runtime Semantics: KeyedDestructuringAssignmentEvaluation
With parametersvalue andpropertyName.
- If
DestructuringAssignmentTarget is neither anObjectLiteral nor anArrayLiteral , then- Letlref be the result of evaluating
DestructuringAssignmentTarget . ReturnIfAbrupt (lref).
- Letlref be the result of evaluating
- Letv be ?
GetV (value,propertyName). - If
Initializer is present andv isundefined , then- If
IsAnonymousFunctionDefinition (Initializer ) andIsIdentifierRef ofDestructuringAssignmentTarget are bothtrue , then- LetrhsValue be ?
NamedEvaluation ofInitializer with argumentlref.[[ReferencedName]].
- LetrhsValue be ?
- Else,
- LetdefaultValue be the result of evaluating
Initializer . - LetrhsValue be ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- If
- Else, letrhsValue bev.
- If
DestructuringAssignmentTarget is anObjectLiteral or anArrayLiteral , then- LetassignmentPattern be the
AssignmentPattern that iscovered byDestructuringAssignmentTarget . - Return the result of performing
DestructuringAssignmentEvaluation ofassignmentPattern withrhsValue as the argument.
- LetassignmentPattern be the
- Return ?
PutValue (lref,rhsValue).
13.16 Comma Operator (, )
Syntax
13.16.1 Runtime Semantics: Evaluation
- Letlref be the result of evaluating
Expression . - Perform ?
GetValue (lref). - Letrref be the result of evaluating
AssignmentExpression . - Return ?
GetValue (rref).
14 ECMAScript Language: Statements and Declarations
Syntax
14.1 Statement Semantics
14.1.1 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
- Return the result of evaluating
FunctionDeclaration .
- LetnewLabelSet be a new empty
List . - Return the result of performing
LabelledEvaluation of thisBreakableStatement with argumentnewLabelSet.
14.2 Block
Syntax
14.2.1 Static Semantics: Early Errors
- It is a Syntax Error if the
LexicallyDeclaredNames ofStatementList contains any duplicate entries. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofStatementList also occurs in theVarDeclaredNames ofStatementList .
14.2.2 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
- LetoldEnv be the
running execution context 's LexicalEnvironment. - LetblockEnv be
NewDeclarativeEnvironment (oldEnv). - Perform
BlockDeclarationInstantiation (StatementList ,blockEnv). - Set the
running execution context 's LexicalEnvironment toblockEnv. - LetblockValue be the result of evaluating
StatementList . - Set the
running execution context 's LexicalEnvironment tooldEnv. - ReturnblockValue.
No matter how control leaves the
- Letsl be the result of evaluating
StatementList . ReturnIfAbrupt (sl).- Lets be the result of evaluating
StatementListItem . - Return
Completion (UpdateEmpty (s,sl)).
The value of aeval function all return the value 1:
eval("1;;;;;")eval("1;{}")eval("1;var a;")14.2.3 BlockDeclarationInstantiation (code,env )
When a
The abstract operation BlockDeclarationInstantiation takes argumentscode (a
Assert :env is adeclarative Environment Record .- Letdeclarations be the
LexicallyScopedDeclarations ofcode. - For each elementd ofdeclarations, do
- For each elementdn of the
BoundNames ofd, do- If
IsConstantDeclaration ofd istrue , then- Perform !env.CreateImmutableBinding(dn,
true ).
- Perform !env.CreateImmutableBinding(dn,
- Else,
- Perform !env.CreateMutableBinding(dn,
false ). NOTE: This step is replaced in sectionB.3.3.6 .
- Perform !env.CreateMutableBinding(dn,
- If
- Ifd is a
FunctionDeclaration , aGeneratorDeclaration , anAsyncFunctionDeclaration , or anAsyncGeneratorDeclaration , then- Letfn be the sole element of the
BoundNames ofd. - Letfo be
InstantiateFunctionObject ofd with argumentenv. - Performenv.InitializeBinding(fn,fo). NOTE: This step is replaced in section
B.3.3.6 .
- Letfn be the sole element of the
- For each elementdn of the
14.3 Declarations and the Variable Statement
14.3.1 Let and Const Declarations
let andconst declarations define variables that are scoped to thelet declaration does not have an
Syntax
14.3.1.1 Static Semantics: Early Errors
- It is a Syntax Error if the
BoundNames ofBindingList contains"let" . - It is a Syntax Error if the
BoundNames ofBindingList contains any duplicate entries.
- It is a Syntax Error if
Initializer is not present andIsConstantDeclaration of theLexicalDeclaration containing thisLexicalBinding istrue .
14.3.1.2 Runtime Semantics: Evaluation
- Letnext be the result of evaluating
BindingList . ReturnIfAbrupt (next).- Return
NormalCompletion (empty ).
- Letnext be the result of evaluating
BindingList . ReturnIfAbrupt (next).- Return the result of evaluating
LexicalBinding .
- Letlhs be
ResolveBinding (StringValue ofBindingIdentifier ). - Return
InitializeReferencedBinding (lhs,undefined ).
Aconst declaration.
- LetbindingId be
StringValue ofBindingIdentifier . - Letlhs be
ResolveBinding (bindingId). - If
IsAnonymousFunctionDefinition (Initializer ) istrue , then- Letvalue be
NamedEvaluation ofInitializer with argumentbindingId.
- Letvalue be
- Else,
- Letrhs be the result of evaluating
Initializer . - Letvalue be ?
GetValue (rhs).
- Letrhs be the result of evaluating
- Return
InitializeReferencedBinding (lhs,value).
- Letrhs be the result of evaluating
Initializer . - Letvalue be ?
GetValue (rhs). - Letenv be the
running execution context 's LexicalEnvironment. - Return the result of performing
BindingInitialization forBindingPattern usingvalue andenv as the arguments.
14.3.2 Variable Statement
Avar statement declares variables that are scoped to the
Syntax
14.3.2.1 Runtime Semantics: Evaluation
- Letnext be the result of evaluating
VariableDeclarationList . ReturnIfAbrupt (next).- Return
NormalCompletion (empty ).
- Letnext be the result of evaluating
VariableDeclarationList . ReturnIfAbrupt (next).- Return the result of evaluating
VariableDeclaration .
- Return
NormalCompletion (empty ).
- LetbindingId be
StringValue ofBindingIdentifier . - Letlhs be ?
ResolveBinding (bindingId). - If
IsAnonymousFunctionDefinition (Initializer ) istrue , then- Letvalue be
NamedEvaluation ofInitializer with argumentbindingId.
- Letvalue be
- Else,
- Letrhs be the result of evaluating
Initializer . - Letvalue be ?
GetValue (rhs).
- Letrhs be the result of evaluating
- Return ?
PutValue (lhs,value).
If a
- Letrhs be the result of evaluating
Initializer . - Letrval be ?
GetValue (rhs). - Return the result of performing
BindingInitialization forBindingPattern passingrval andundefined as arguments.
14.3.3 Destructuring Binding Patterns
Syntax
14.3.3.1 Runtime Semantics: PropertyBindingInitialization
With parametersvalue andenvironment.
- LetboundNames be ?
PropertyBindingInitialization ofBindingPropertyList with argumentsvalue andenvironment. - LetnextNames be ?
PropertyBindingInitialization ofBindingProperty with argumentsvalue andenvironment. - Append each item innextNames to the end ofboundNames.
- ReturnboundNames.
- Letname be the string that is the only element of
BoundNames ofSingleNameBinding . - Perform ?
KeyedBindingInitialization forSingleNameBinding usingvalue,environment, andname as the arguments. - Return a
List whose sole element isname.
- LetP be the result of evaluating
PropertyName . ReturnIfAbrupt (P).- Perform ?
KeyedBindingInitialization ofBindingElement withvalue,environment, andP as the arguments. - Return a
List whose sole element isP.
14.3.3.2 Runtime Semantics: RestBindingInitialization
With parametersvalue,environment, andexcludedNames.
- Letlhs be ?
ResolveBinding (StringValue ofBindingIdentifier ,environment). - LetrestObj be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform ?
CopyDataProperties (restObj,value,excludedNames). - Ifenvironment is
undefined , returnPutValue (lhs,restObj). - Return
InitializeReferencedBinding (lhs,restObj).
14.3.3.3 Runtime Semantics: KeyedBindingInitialization
With parametersvalue,environment, andpropertyName.
When
- Letv be ?
GetV (value,propertyName). - If
Initializer is present andv isundefined , then- LetdefaultValue be the result of evaluating
Initializer . - Setv to ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- Return the result of performing
BindingInitialization forBindingPattern passingv andenvironment as arguments.
- LetbindingId be
StringValue ofBindingIdentifier . - Letlhs be ?
ResolveBinding (bindingId,environment). - Letv be ?
GetV (value,propertyName). - If
Initializer is present andv isundefined , then- If
IsAnonymousFunctionDefinition (Initializer ) istrue , then- Setv to the result of performing
NamedEvaluation forInitializer with argumentbindingId.
- Setv to the result of performing
- Else,
- LetdefaultValue be the result of evaluating
Initializer . - Setv to ?
GetValue (defaultValue).
- LetdefaultValue be the result of evaluating
- If
- Ifenvironment is
undefined , return ?PutValue (lhs,v). - Return
InitializeReferencedBinding (lhs,v).
14.4 Empty Statement
Syntax
14.4.1 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
14.5 Expression Statement
Syntax
Anfunction orclass keywords because that would make it ambiguous with aasync function because that would make it ambiguous with anlet [ because that would make it ambiguous with alet
14.5.1 Runtime Semantics: Evaluation
- LetexprRef be the result of evaluating
Expression . - Return ?
GetValue (exprRef).
14.6 Theif Statement
Syntax
else] resolves the classic "dangling else" problem in the usual way. That is, when the choice of associatedif is otherwise ambiguous, theelse is associated with the nearest (innermost) of the candidateifs14.6.1 Static Semantics: Early Errors
- It is a Syntax Error if
IsLabelledFunction (Statement ) istrue .
It is only necessary to apply this rule if the extension specified in
14.6.2 Runtime Semantics: Evaluation
- LetexprRef be the result of evaluating
Expression . - LetexprValue be !
ToBoolean (?GetValue (exprRef)). - IfexprValue is
true , then- LetstmtCompletion be the result of evaluating the first
Statement .
- LetstmtCompletion be the result of evaluating the first
- Else,
- LetstmtCompletion be the result of evaluating the second
Statement .
- LetstmtCompletion be the result of evaluating the second
- Return
Completion (UpdateEmpty (stmtCompletion,undefined )).
- LetexprRef be the result of evaluating
Expression . - LetexprValue be !
ToBoolean (?GetValue (exprRef)). - IfexprValue is
false , then- Return
NormalCompletion (undefined ).
- Return
- Else,
- LetstmtCompletion be the result of evaluating
Statement . - Return
Completion (UpdateEmpty (stmtCompletion,undefined )).
- LetstmtCompletion be the result of evaluating
14.7 Iteration Statements
Syntax
14.7.1 Semantics
14.7.1.1 LoopContinues (completion,labelSet )
The abstract operation LoopContinues takes argumentscompletion andlabelSet. It performs the following steps when called:
- Ifcompletion.[[Type]] is
normal , returntrue . - Ifcompletion.[[Type]] is not
continue , returnfalse . - Ifcompletion.[[Target]] is
empty , returntrue . - Ifcompletion.[[Target]] is an element oflabelSet, return
true . - Return
false .
Within the
14.7.1.2 Runtime Semantics: LoopEvaluation
With parameterlabelSet.
- Return ?
DoWhileLoopEvaluation ofDoWhileStatement with argumentlabelSet.
- Return ?
WhileLoopEvaluation ofWhileStatement with argumentlabelSet.
- Return ?
ForLoopEvaluation ofForStatement with argumentlabelSet.
- Return ?
ForInOfLoopEvaluation ofForInOfStatement with argumentlabelSet.
14.7.2 Thedo-while Statement
Syntax
14.7.2.1 Static Semantics: Early Errors
- It is a Syntax Error if
IsLabelledFunction (Statement ) istrue .
It is only necessary to apply this rule if the extension specified in
14.7.2.2 Runtime Semantics: DoWhileLoopEvaluation
With parameterlabelSet.
- LetV be
undefined . - Repeat,
- LetstmtResult be the result of evaluating
Statement . - If
LoopContinues (stmtResult,labelSet) isfalse , returnCompletion (UpdateEmpty (stmtResult,V)). - IfstmtResult.[[Value]] is not
empty , setV tostmtResult.[[Value]]. - LetexprRef be the result of evaluating
Expression . - LetexprValue be ?
GetValue (exprRef). - If !
ToBoolean (exprValue) isfalse , returnNormalCompletion (V).
- LetstmtResult be the result of evaluating
14.7.3 Thewhile Statement
Syntax
14.7.3.1 Static Semantics: Early Errors
- It is a Syntax Error if
IsLabelledFunction (Statement ) istrue .
It is only necessary to apply this rule if the extension specified in
14.7.3.2 Runtime Semantics: WhileLoopEvaluation
With parameterlabelSet.
- LetV be
undefined . - Repeat,
- LetexprRef be the result of evaluating
Expression . - LetexprValue be ?
GetValue (exprRef). - If !
ToBoolean (exprValue) isfalse , returnNormalCompletion (V). - LetstmtResult be the result of evaluating
Statement . - If
LoopContinues (stmtResult,labelSet) isfalse , returnCompletion (UpdateEmpty (stmtResult,V)). - IfstmtResult.[[Value]] is not
empty , setV tostmtResult.[[Value]].
- LetexprRef be the result of evaluating
14.7.4 Thefor Statement
Syntax
14.7.4.1 Static Semantics: Early Errors
- It is a Syntax Error if
IsLabelledFunction (Statement ) istrue .
It is only necessary to apply this rule if the extension specified in
- It is a Syntax Error if any element of the
BoundNames ofLexicalDeclaration also occurs in theVarDeclaredNames ofStatement .
14.7.4.2 Runtime Semantics: ForLoopEvaluation
With parameterlabelSet.
- If the first
Expression is present, then- LetexprRef be the result of evaluating the first
Expression . - Perform ?
GetValue (exprRef).
- LetexprRef be the result of evaluating the first
- Return ?
ForBodyEvaluation (the secondExpression , the thirdExpression ,Statement , « »,labelSet).
- LetvarDcl be the result of evaluating
VariableDeclarationList . ReturnIfAbrupt (varDcl).- Return ?
ForBodyEvaluation (the firstExpression , the secondExpression ,Statement , « »,labelSet).
- LetoldEnv be the
running execution context 's LexicalEnvironment. - LetloopEnv be
NewDeclarativeEnvironment (oldEnv). - LetisConst be
IsConstantDeclaration ofLexicalDeclaration . - LetboundNames be the
BoundNames ofLexicalDeclaration . - For each elementdn ofboundNames, do
- IfisConst is
true , then- Perform !loopEnv.CreateImmutableBinding(dn,
true ).
- Perform !loopEnv.CreateImmutableBinding(dn,
- Else,
- Perform !loopEnv.CreateMutableBinding(dn,
false ).
- Perform !loopEnv.CreateMutableBinding(dn,
- IfisConst is
- Set the
running execution context 's LexicalEnvironment toloopEnv. - LetforDcl be the result of evaluating
LexicalDeclaration . - IfforDcl is an
abrupt completion , then- Set the
running execution context 's LexicalEnvironment tooldEnv. - Return
Completion (forDcl).
- Set the
- IfisConst is
false , letperIterationLets beboundNames; otherwise letperIterationLets be « ». - LetbodyResult be
ForBodyEvaluation (the firstExpression , the secondExpression ,Statement ,perIterationLets,labelSet). - Set the
running execution context 's LexicalEnvironment tooldEnv. - Return
Completion (bodyResult).
14.7.4.3 ForBodyEvaluation (test,increment,stmt,perIterationBindings,labelSet )
The abstract operation ForBodyEvaluation takes argumentstest,increment,stmt,perIterationBindings, andlabelSet. It performs the following steps when called:
- LetV be
undefined . - Perform ?
CreatePerIterationEnvironment (perIterationBindings). - Repeat,
- Iftest is not
[empty] , then- LettestRef be the result of evaluatingtest.
- LettestValue be ?
GetValue (testRef). - If !
ToBoolean (testValue) isfalse , returnNormalCompletion (V).
- Letresult be the result of evaluatingstmt.
- If
LoopContinues (result,labelSet) isfalse , returnCompletion (UpdateEmpty (result,V)). - Ifresult.[[Value]] is not
empty , setV toresult.[[Value]]. - Perform ?
CreatePerIterationEnvironment (perIterationBindings). - Ifincrement is not
[empty] , then- LetincRef be the result of evaluatingincrement.
- Perform ?
GetValue (incRef).
- Iftest is not
14.7.4.4 CreatePerIterationEnvironment (perIterationBindings )
The abstract operation CreatePerIterationEnvironment takes argumentperIterationBindings. It performs the following steps when called:
- IfperIterationBindings has any elements, then
- LetlastIterationEnv be the
running execution context 's LexicalEnvironment. - Letouter belastIterationEnv.[[OuterEnv]].
Assert :outer is notnull .- LetthisIterationEnv be
NewDeclarativeEnvironment (outer). - For each elementbn ofperIterationBindings, do
- Perform !thisIterationEnv.CreateMutableBinding(bn,
false ). - LetlastValue be ?lastIterationEnv.GetBindingValue(bn,
true ). - PerformthisIterationEnv.InitializeBinding(bn,lastValue).
- Perform !thisIterationEnv.CreateMutableBinding(bn,
- Set the
running execution context 's LexicalEnvironment tothisIterationEnv.
- LetlastIterationEnv be the
- Return
undefined .
14.7.5 Thefor-in,for-of, andfor-await-of Statements
Syntax
This section is extended by Annex
14.7.5.1 Static Semantics: Early Errors
- It is a Syntax Error if
IsLabelledFunction (Statement ) istrue .
It is only necessary to apply this rule if the extension specified in
If
- It is a Syntax Error if
LeftHandSideExpression is notcovering anAssignmentPattern . - All Early Error rules for
AssignmentPattern and its derived productions also apply to theAssignmentPattern that iscovered byLeftHandSideExpression .
If
- It is a Syntax Error if
AssignmentTargetType ofLeftHandSideExpression is notsimple .
- It is a Syntax Error if the
BoundNames ofForDeclaration contains"let" . - It is a Syntax Error if any element of the
BoundNames ofForDeclaration also occurs in theVarDeclaredNames ofStatement . - It is a Syntax Error if the
BoundNames ofForDeclaration contains any duplicate entries.
14.7.5.2 Static Semantics: IsDestructuring
- If
PrimaryExpression is either anObjectLiteral or anArrayLiteral , returntrue . - Return
false .
- Return
false .
- Return
IsDestructuring ofForBinding .
- Return
false .
- Return
true .
This section is extended by Annex
14.7.5.3 Runtime Semantics: ForDeclarationBindingInitialization
With parametersvalue andenvironment.
var statements and the formal parameter lists of some non-strict functions (see
- Return the result of performing
BindingInitialization forForBinding passingvalue andenvironment as the arguments.
14.7.5.4 Runtime Semantics: ForDeclarationBindingInstantiation
With parameterenvironment.
Assert :environment is adeclarative Environment Record .- For each elementname of the
BoundNames ofForBinding , do- If
IsConstantDeclaration ofLetOrConst istrue , then- Perform !environment.CreateImmutableBinding(name,
true ).
- Perform !environment.CreateImmutableBinding(name,
- Else,
- Perform !environment.CreateMutableBinding(name,
false ).
- Perform !environment.CreateMutableBinding(name,
- If
14.7.5.5 Runtime Semantics: ForInOfLoopEvaluation
With parameterlabelSet.
- LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,Expression ,enumerate ). - Return ?
ForIn/OfBodyEvaluation (LeftHandSideExpression ,Statement ,keyResult,enumerate ,assignment ,labelSet).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,Expression ,enumerate ). - Return ?
ForIn/OfBodyEvaluation (ForBinding ,Statement ,keyResult,enumerate ,varBinding ,labelSet).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (BoundNames ofForDeclaration ,Expression ,enumerate ). - Return ?
ForIn/OfBodyEvaluation (ForDeclaration ,Statement ,keyResult,enumerate ,lexicalBinding ,labelSet).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,iterate ). - Return ?
ForIn/OfBodyEvaluation (LeftHandSideExpression ,Statement ,keyResult,iterate ,assignment ,labelSet).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,iterate ). - Return ?
ForIn/OfBodyEvaluation (ForBinding ,Statement ,keyResult,iterate ,varBinding ,labelSet).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (BoundNames ofForDeclaration ,AssignmentExpression ,iterate ). - Return ?
ForIn/OfBodyEvaluation (ForDeclaration ,Statement ,keyResult,iterate ,lexicalBinding ,labelSet).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,async-iterate ). - Return ?
ForIn/OfBodyEvaluation (LeftHandSideExpression ,Statement ,keyResult,iterate ,assignment ,labelSet,async ).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,AssignmentExpression ,async-iterate ). - Return ?
ForIn/OfBodyEvaluation (ForBinding ,Statement ,keyResult,iterate ,varBinding ,labelSet,async ).
- LetkeyResult be ?
ForIn/OfHeadEvaluation (BoundNames ofForDeclaration ,AssignmentExpression ,async-iterate ). - Return ?
ForIn/OfBodyEvaluation (ForDeclaration ,Statement ,keyResult,iterate ,lexicalBinding ,labelSet,async ).
This section is extended by Annex
14.7.5.6 ForIn/OfHeadEvaluation (uninitializedBoundNames,expr,iterationKind )
The abstract operation ForIn/OfHeadEvaluation takes argumentsuninitializedBoundNames,expr, anditerationKind (either
- LetoldEnv be the
running execution context 's LexicalEnvironment. - IfuninitializedBoundNames is not an empty
List , thenAssert :uninitializedBoundNames has no duplicate entries.- LetnewEnv be
NewDeclarativeEnvironment (oldEnv). - For each Stringname ofuninitializedBoundNames, do
- Perform !newEnv.CreateMutableBinding(name,
false ).
- Perform !newEnv.CreateMutableBinding(name,
- Set the
running execution context 's LexicalEnvironment tonewEnv.
- LetexprRef be the result of evaluatingexpr.
- Set the
running execution context 's LexicalEnvironment tooldEnv. - LetexprValue be ?
GetValue (exprRef). - IfiterationKind is
enumerate , then- IfexprValue is
undefined ornull , then- Return
Completion { [[Type]]:break , [[Value]]:empty , [[Target]]:empty }.
- Return
- Letobj be !
ToObject (exprValue). - Letiterator be ?
EnumerateObjectProperties (obj). - LetnextMethod be !
GetV (iterator,"next" ). - Return the
Record { [[Iterator]]:iterator, [[NextMethod]]:nextMethod, [[Done]]:false }.
- IfexprValue is
- Else,
Assert :iterationKind isiterate orasync-iterate .- IfiterationKind is
async-iterate , letiteratorHint beasync . - Else, letiteratorHint be
sync . - Return ?
GetIterator (exprValue,iteratorHint).
14.7.5.7 ForIn/OfBodyEvaluation (lhs,stmt,iteratorRecord,iterationKind,lhsKind,labelSet [ ,iteratorKind ] )
The abstract operation ForIn/OfBodyEvaluation takes argumentslhs,stmt,iteratorRecord,iterationKind,lhsKind (either
- IfiteratorKind is not present, setiteratorKind to
sync . - LetoldEnv be the
running execution context 's LexicalEnvironment. - LetV be
undefined . - Letdestructuring be
IsDestructuring oflhs. - Ifdestructuring is
true and iflhsKind isassignment , thenAssert :lhs is aLeftHandSideExpression .- LetassignmentPattern be the
AssignmentPattern that iscovered bylhs.
- Repeat,
- LetnextResult be ?
Call (iteratorRecord.[[NextMethod]],iteratorRecord.[[Iterator]]). - IfiteratorKind is
async , setnextResult to ?Await (nextResult). - If
Type (nextResult) is not Object, throw aTypeError exception. - Letdone be ?
IteratorComplete (nextResult). - Ifdone is
true , returnNormalCompletion (V). - LetnextValue be ?
IteratorValue (nextResult). - IflhsKind is either
assignment orvarBinding , then- Ifdestructuring is
false , then- LetlhsRef be the result of evaluatinglhs. (It may be evaluated repeatedly.)
- Ifdestructuring is
- Else,
Assert :lhsKind islexicalBinding .Assert :lhs is aForDeclaration .- LetiterationEnv be
NewDeclarativeEnvironment (oldEnv). - Perform
ForDeclarationBindingInstantiation forlhs passingiterationEnv as the argument. - Set the
running execution context 's LexicalEnvironment toiterationEnv. - Ifdestructuring is
false , thenAssert :lhs binds a single name.- LetlhsName be the sole element of
BoundNames oflhs. - LetlhsRef be !
ResolveBinding (lhsName).
- Ifdestructuring is
false , then- IflhsRef is an
abrupt completion , then- Letstatus belhsRef.
- Else iflhsKind is
lexicalBinding , then- Letstatus be
InitializeReferencedBinding (lhsRef,nextValue).
- Letstatus be
- Else,
- Letstatus be
PutValue (lhsRef,nextValue).
- Letstatus be
- IflhsRef is an
- Else,
- IflhsKind is
assignment , then- Letstatus be
DestructuringAssignmentEvaluation ofassignmentPattern with argumentnextValue.
- Letstatus be
- Else iflhsKind is
varBinding , thenAssert :lhs is aForBinding .- Letstatus be
BindingInitialization oflhs with argumentsnextValue andundefined .
- Else,
Assert :lhsKind islexicalBinding .Assert :lhs is aForDeclaration .- Letstatus be
ForDeclarationBindingInitialization oflhs with argumentsnextValue anditerationEnv.
- IflhsKind is
- Ifstatus is an
abrupt completion , then- Set the
running execution context 's LexicalEnvironment tooldEnv. - IfiteratorKind is
async , return ?AsyncIteratorClose (iteratorRecord,status). - IfiterationKind is
enumerate , then- Returnstatus.
- Else,
Assert :iterationKind isiterate .- Return ?
IteratorClose (iteratorRecord,status).
- Set the
- Letresult be the result of evaluatingstmt.
- Set the
running execution context 's LexicalEnvironment tooldEnv. - If
LoopContinues (result,labelSet) isfalse , then- IfiterationKind is
enumerate , then- Return
Completion (UpdateEmpty (result,V)).
- Return
- Else,
Assert :iterationKind isiterate .- Setstatus to
UpdateEmpty (result,V). - IfiteratorKind is
async , return ?AsyncIteratorClose (iteratorRecord,status). - Return ?
IteratorClose (iteratorRecord,status).
- IfiterationKind is
- Ifresult.[[Value]] is not
empty , setV toresult.[[Value]].
- LetnextResult be ?
14.7.5.8 Runtime Semantics: Evaluation
- LetbindingId be
StringValue ofBindingIdentifier . - Return ?
ResolveBinding (bindingId).
14.7.5.9 EnumerateObjectProperties (O )
The abstract operation EnumerateObjectProperties takes argumentO. It performs the following steps when called:
Assert :Type (O) is Object.- Return an Iterator object (
27.1.1.2 ) whosenextmethod iterates over all the String-valued keys of enumerable properties ofO. The iterator object is never directly accessible to ECMAScript code. The mechanics and order of enumerating the properties is not specified but must conform to the rules specified below.
The iterator'sthrow andreturn methods arenext method processes object properties to determine whether the property key should be returned as an iterator value. Returned property keys do not include keys that are Symbols. Properties of the target object may be deleted during enumeration. A property that is deleted before it is processed by the iterator'snext method is ignored. If new properties are added to the target object during enumeration, the newly added properties are not guaranteed to be processed in the active enumeration. Anext method at most once in any enumeration.
Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively; but a property of a prototype is not processed if it has the same name as a property that has already been processed by the iterator'snext method. The values of [[Enumerable]] attributes are not considered when determining if a property of a prototype object has already been processed. The enumerable property names of prototype objects must be obtained by invoking EnumerateObjectProperties passing the prototype object as the argument. EnumerateObjectProperties must obtain the own property keys of the target object by calling its [[OwnPropertyKeys]] internal method. Property attributes of the target object must be obtained by calling its [[GetOwnProperty]] internal method.
In addition, if neitherO nor any object in its prototype chain is a
- the value of the [[Prototype]] internal slot ofO or an object in its prototype chain changes,
- a property is removed fromO or an object in its prototype chain,
- a property is added to an object inO's prototype chain, or
- the value of the [[Enumerable]] attribute of a property ofO or an object in its prototype chain changes.
ECMAScript implementations are not required to implement the algorithm in
The following is an informative definition of an ECMAScript generator function that conforms to these rules:
function*EnumerateObjectProperties(obj){const visited =newSet();for (const keyofReflect.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 protoKeyof EnumerateObjectProperties(proto)) {if (!visited.has(protoKey))yield protoKey; }}14.7.5.10 For-In Iterator Objects
A For-In Iterator is an object that represents a specific iteration over some specific object. For-In Iterator objects are never directly accessible to ECMAScript code; they exist solely to illustrate the behaviour of
14.7.5.10.1 CreateForInIterator (object )
The abstract operation CreateForInIterator takes argumentobject. It is used to create a For-In Iterator object which iterates over the own and inherited enumerable string properties ofobject in a specific order. It performs the following steps when called:
Assert :Type (object) is Object.- Letiterator be !
OrdinaryObjectCreate (%ForInIteratorPrototype% , « [[Object]], [[ObjectWasVisited]], [[VisitedKeys]], [[RemainingKeys]] »). - Setiterator.[[Object]] toobject.
- Setiterator.[[ObjectWasVisited]] to
false . - Setiterator.[[VisitedKeys]] to a new empty
List . - Setiterator.[[RemainingKeys]] to a new empty
List . - Returniterator.
14.7.5.10.2 The %ForInIteratorPrototype% Object
The%ForInIteratorPrototype% object:
- has properties that are inherited by all For-In Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - is never directly accessible to ECMAScript code.
- has the following properties:
14.7.5.10.2.1 %ForInIteratorPrototype%.next ( )
- LetO be the
this value. Assert :Type (O) is Object.Assert :O has all of the internal slots of a For-In Iterator Instance (14.7.5.10.3 ).- Letobject beO.[[Object]].
- Letvisited beO.[[VisitedKeys]].
- Letremaining beO.[[RemainingKeys]].
- Repeat,
- IfO.[[ObjectWasVisited]] is
false , then- Letkeys be ?object.[[OwnPropertyKeys]]().
- For each elementkey ofkeys, do
- If
Type (key) is String, then- Appendkey toremaining.
- If
- SetO.[[ObjectWasVisited]] to
true .
- Repeat, whileremaining is not empty,
- Letr be the first element ofremaining.
- Remove the first element fromremaining.
- If there does not exist an elementv ofvisited such that
SameValue (r,v) istrue , then- Letdesc be ?object.[[GetOwnProperty]](r).
- Ifdesc is not
undefined , then- Appendr tovisited.
- Ifdesc.[[Enumerable]] is
true , returnCreateIterResultObject (r,false ).
- Setobject to ?object.[[GetPrototypeOf]]().
- SetO.[[Object]] toobject.
- SetO.[[ObjectWasVisited]] to
false . - Ifobject is
null , returnCreateIterResultObject (undefined ,true ).
- IfO.[[ObjectWasVisited]] is
14.7.5.10.3 Properties of For-In Iterator Instances
For-In Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[Object]] | The Object value whose properties are being iterated. |
| [[ObjectWasVisited]] | |
| [[VisitedKeys]] | A list of String values which have been emitted by this iterator thus far. |
| [[RemainingKeys]] | A list of String values remaining to be emitted for the current object, before iterating the properties of its prototype (if its prototype is not |
14.8 Thecontinue Statement
Syntax
14.8.1 Static Semantics: Early Errors
- It is a Syntax Error if this
ContinueStatement is not nested, directly or indirectly (but not crossing function boundaries), within anIterationStatement .
14.8.2 Runtime Semantics: Evaluation
- Return
Completion { [[Type]]:continue , [[Value]]:empty , [[Target]]:empty }.
- Letlabel be the
StringValue ofLabelIdentifier . - Return
Completion { [[Type]]:continue , [[Value]]:empty , [[Target]]:label }.
14.9 Thebreak Statement
Syntax
14.9.1 Static Semantics: Early Errors
- It is a Syntax Error if this
BreakStatement is not nested, directly or indirectly (but not crossing function boundaries), within anIterationStatement or aSwitchStatement .
14.9.2 Runtime Semantics: Evaluation
- Return
Completion { [[Type]]:break , [[Value]]:empty , [[Target]]:empty }.
- Letlabel be the
StringValue ofLabelIdentifier . - Return
Completion { [[Type]]:break , [[Value]]:empty , [[Target]]:label }.
14.10 Thereturn Statement
Syntax
Areturn statement causes a function to cease execution and, in most cases, returns a value to the caller. Ifreturn statement may not actually return a value to the caller depending on surrounding context. For example, in atry block, areturn statement's completion record may be replaced with another completion record during evaluation of thefinally block.
14.10.1 Runtime Semantics: Evaluation
- Return
Completion { [[Type]]:return , [[Value]]:undefined , [[Target]]:empty }.
- LetexprRef be the result of evaluating
Expression . - LetexprValue be ?
GetValue (exprRef). - If !
GetGeneratorKind () isasync , setexprValue to ?Await (exprValue). - Return
Completion { [[Type]]:return , [[Value]]:exprValue, [[Target]]:empty }.
14.11 Thewith Statement
Syntax
Thewith statement adds an
14.11.1 Static Semantics: Early Errors
- It is a Syntax Error if the code that matches this production is contained in
strict mode code . - It is a Syntax Error if
IsLabelledFunction (Statement ) istrue .
It is only necessary to apply the second rule if the extension specified in
14.11.2 Runtime Semantics: Evaluation
- Letval be the result of evaluating
Expression . - Letobj be ?
ToObject (?GetValue (val)). - LetoldEnv be the
running execution context 's LexicalEnvironment. - LetnewEnv be
NewObjectEnvironment (obj,oldEnv). - Set thewithEnvironment flag ofnewEnv to
true . - Set the
running execution context 's LexicalEnvironment tonewEnv. - LetC be the result of evaluating
Statement . - Set the
running execution context 's LexicalEnvironment tooldEnv. - Return
Completion (UpdateEmpty (C,undefined )).
No matter how control leaves the embedded
14.12 Theswitch Statement
Syntax
14.12.1 Static Semantics: Early Errors
- It is a Syntax Error if the
LexicallyDeclaredNames ofCaseBlock contains any duplicate entries. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofCaseBlock also occurs in theVarDeclaredNames ofCaseBlock .
14.12.2 Runtime Semantics: CaseBlockEvaluation
With parameterinput.
- Return
NormalCompletion (undefined ).
- LetV be
undefined . - LetA be the
List ofCaseClause items inCaseClauses , in source text order. - Letfound be
false . - For each
CaseClause C ofA, do- Iffound is
false , then- Setfound to ?
CaseClauseIsSelected (C,input).
- Setfound to ?
- Iffound is
true , then- LetR be the result of evaluatingC.
- IfR.[[Value]] is not
empty , setV toR.[[Value]]. - IfR is an
abrupt completion , returnCompletion (UpdateEmpty (R,V)).
- Iffound is
- Return
NormalCompletion (V).
- LetV be
undefined . - If the first
CaseClauses is present, then- LetA be the
List ofCaseClause items in the firstCaseClauses , in source text order.
- LetA be the
- Else,
- LetA be « ».
- Letfound be
false . - For each
CaseClause C ofA, do- Iffound is
false , then- Setfound to ?
CaseClauseIsSelected (C,input).
- Setfound to ?
- Iffound is
true , then- LetR be the result of evaluatingC.
- IfR.[[Value]] is not
empty , setV toR.[[Value]]. - IfR is an
abrupt completion , returnCompletion (UpdateEmpty (R,V)).
- Iffound is
- LetfoundInB be
false . - If the second
CaseClauses is present, then- LetB be the
List ofCaseClause items in the secondCaseClauses , in source text order.
- LetB be the
- Else,
- LetB be « ».
- Iffound is
false , then- For each
CaseClause C ofB, do- IffoundInB is
false , then- SetfoundInB to ?
CaseClauseIsSelected (C,input).
- SetfoundInB to ?
- IffoundInB is
true , then- LetR be the result of evaluating
CaseClause C. - IfR.[[Value]] is not
empty , setV toR.[[Value]]. - IfR is an
abrupt completion , returnCompletion (UpdateEmpty (R,V)).
- LetR be the result of evaluating
- IffoundInB is
- For each
- IffoundInB is
true , returnNormalCompletion (V). - LetR be the result of evaluating
DefaultClause . - IfR.[[Value]] is not
empty , setV toR.[[Value]]. - IfR is an
abrupt completion , returnCompletion (UpdateEmpty (R,V)). - NOTE: The following is another complete iteration of the second
CaseClauses . - For each
CaseClause C ofB, do- LetR be the result of evaluating
CaseClause C. - IfR.[[Value]] is not
empty , setV toR.[[Value]]. - IfR is an
abrupt completion , returnCompletion (UpdateEmpty (R,V)).
- LetR be the result of evaluating
- Return
NormalCompletion (V).
14.12.3 CaseClauseIsSelected (C,input )
The abstract operation CaseClauseIsSelected takes argumentsC (a
Assert :C is an instance of the productionCaseClause : case Expression : StatementList opt - LetexprRef be the result of evaluating the
Expression ofC. - LetclauseSelector be ?
GetValue (exprRef). - Return the result of performing
Strict Equality Comparison input ===clauseSelector.
This operation does not executeC's
14.12.4 Runtime Semantics: Evaluation
- LetexprRef be the result of evaluating
Expression . - LetswitchValue be ?
GetValue (exprRef). - LetoldEnv be the
running execution context 's LexicalEnvironment. - LetblockEnv be
NewDeclarativeEnvironment (oldEnv). - Perform
BlockDeclarationInstantiation (CaseBlock ,blockEnv). - Set the
running execution context 's LexicalEnvironment toblockEnv. - LetR be
CaseBlockEvaluation ofCaseBlock with argumentswitchValue. - Set the
running execution context 's LexicalEnvironment tooldEnv. - ReturnR.
No matter how control leaves the
- Return
NormalCompletion (empty ).
- Return the result of evaluating
StatementList .
- Return
NormalCompletion (empty ).
- Return the result of evaluating
StatementList .
14.13 Labelled Statements
Syntax
Abreak andcontinue statements. ECMAScript has nogoto statement. A
14.13.1 Static Semantics: Early Errors
- It is a Syntax Error if any source text matches this rule.
An alternative definition for this rule is provided in
14.13.2 Static Semantics: IsLabelledFunction (stmt )
The abstract operation IsLabelledFunction takes argumentstmt. It performs the following steps when called:
- Ifstmt is not a
LabelledStatement , returnfalse . - Letitem be the
LabelledItem ofstmt. - Ifitem is
LabelledItem : FunctionDeclaration true . - LetsubStmt be the
Statement ofitem. - Return
IsLabelledFunction (subStmt).
14.13.3 Runtime Semantics: Evaluation
- LetnewLabelSet be a new empty
List . - Return
LabelledEvaluation of thisLabelledStatement with argumentnewLabelSet.
14.13.4 Runtime Semantics: LabelledEvaluation
With parameterlabelSet.
- LetstmtResult be
LoopEvaluation ofIterationStatement with argumentlabelSet. - IfstmtResult.[[Type]] is
break , then- IfstmtResult.[[Target]] is
empty , then- IfstmtResult.[[Value]] is
empty , setstmtResult toNormalCompletion (undefined ). - Else, setstmtResult to
NormalCompletion (stmtResult.[[Value]]).
- IfstmtResult.[[Value]] is
- IfstmtResult.[[Target]] is
- Return
Completion (stmtResult).
- LetstmtResult be the result of evaluating
SwitchStatement . - IfstmtResult.[[Type]] is
break , then- IfstmtResult.[[Target]] is
empty , then- IfstmtResult.[[Value]] is
empty , setstmtResult toNormalCompletion (undefined ). - Else, setstmtResult to
NormalCompletion (stmtResult.[[Value]]).
- IfstmtResult.[[Value]] is
- IfstmtResult.[[Target]] is
- Return
Completion (stmtResult).
A
- Letlabel be the
StringValue ofLabelIdentifier . - Appendlabel as an element oflabelSet.
- LetstmtResult be
LabelledEvaluation ofLabelledItem with argumentlabelSet. - IfstmtResult.[[Type]] is
break andSameValue (stmtResult.[[Target]],label) istrue , then- SetstmtResult to
NormalCompletion (stmtResult.[[Value]]).
- SetstmtResult to
- Return
Completion (stmtResult).
- Return the result of evaluating
FunctionDeclaration .
- Return the result of evaluating
Statement .
The only two productions of
14.14 Thethrow Statement
Syntax
14.14.1 Runtime Semantics: Evaluation
- LetexprRef be the result of evaluating
Expression . - LetexprValue be ?
GetValue (exprRef). - Return
ThrowCompletion (exprValue).
14.15 Thetry Statement
Syntax
Thetry statement encloses a block of code in which an exceptional condition can occur, such as a runtime error or athrow statement. Thecatch clause provides the exception-handling code. When a catch clause catches an exception, its
14.15.1 Static Semantics: Early Errors
- It is a Syntax Error if
BoundNames ofCatchParameter contains any duplicate elements. - It is a Syntax Error if any element of the
BoundNames ofCatchParameter also occurs in theLexicallyDeclaredNames ofBlock . - It is a Syntax Error if any element of the
BoundNames ofCatchParameter also occurs in theVarDeclaredNames ofBlock .
An alternative
14.15.2 Runtime Semantics: CatchClauseEvaluation
With parameterthrownValue.
- LetoldEnv be the
running execution context 's LexicalEnvironment. - LetcatchEnv be
NewDeclarativeEnvironment (oldEnv). - For each elementargName of the
BoundNames ofCatchParameter , do- Perform !catchEnv.CreateMutableBinding(argName,
false ).
- Perform !catchEnv.CreateMutableBinding(argName,
- Set the
running execution context 's LexicalEnvironment tocatchEnv. - Letstatus be
BindingInitialization ofCatchParameter with argumentsthrownValue andcatchEnv. - Ifstatus is an
abrupt completion , then- Set the
running execution context 's LexicalEnvironment tooldEnv. - Return
Completion (status).
- Set the
- LetB be the result of evaluating
Block . - Set the
running execution context 's LexicalEnvironment tooldEnv. - Return
Completion (B).
- Return the result of evaluating
Block .
No matter how control leaves the
14.15.3 Runtime Semantics: Evaluation
- LetB be the result of evaluating
Block . - IfB.[[Type]] is
throw , letC beCatchClauseEvaluation ofCatch with argumentB.[[Value]]. - Else, letC beB.
- Return
Completion (UpdateEmpty (C,undefined )).
- LetB be the result of evaluating
Block . - LetF be the result of evaluating
Finally . - IfF.[[Type]] is
normal , setF toB. - Return
Completion (UpdateEmpty (F,undefined )).
- LetB be the result of evaluating
Block . - IfB.[[Type]] is
throw , letC beCatchClauseEvaluation ofCatch with argumentB.[[Value]]. - Else, letC beB.
- LetF be the result of evaluating
Finally . - IfF.[[Type]] is
normal , setF toC. - Return
Completion (UpdateEmpty (F,undefined )).
14.16 Thedebugger Statement
Syntax
14.16.1 Runtime Semantics: Evaluation
Evaluating a
- If an
implementation-defined debugging facility is available and enabled, then- Perform an
implementation-defined debugging action. - Letresult be an
implementation-defined Completion value.
- Perform an
- Else,
- Letresult be
NormalCompletion (empty ).
- Letresult be
- Returnresult.
15 ECMAScript Language: Functions and Classes
15.1 Parameter Lists
Syntax
15.1.1 Static Semantics: Early Errors
- It is a Syntax Error if
BoundNames ofFormalParameters contains any duplicate elements.
- It is a Syntax Error if
IsSimpleParameterList ofFormalParameterList isfalse andBoundNames ofFormalParameterList contains any duplicate elements.
Multiple occurrences of the same
15.1.2 Static Semantics: ContainsExpression
- Return
false .
- Return
ContainsExpression ofBindingPropertyList .
- Return
false .
- Return
ContainsExpression ofBindingRestElement .
- Return
ContainsExpression ofBindingElementList .
- Lethas be
ContainsExpression ofBindingElementList . - Ifhas is
true , returntrue . - Return
ContainsExpression ofBindingRestElement .
- Lethas be
ContainsExpression ofBindingPropertyList . - Ifhas is
true , returntrue . - Return
ContainsExpression ofBindingProperty .
- Lethas be
ContainsExpression ofBindingElementList . - Ifhas is
true , returntrue . - Return
ContainsExpression ofBindingElisionElement .
- Return
ContainsExpression ofBindingElement .
- Lethas be
IsComputedPropertyKey ofPropertyName . - Ifhas is
true , returntrue . - Return
ContainsExpression ofBindingElement .
- Return
true .
- Return
false .
- Return
true .
- Return
false .
- Return
ContainsExpression ofBindingPattern .
- Return
false .
- If
ContainsExpression ofFormalParameterList istrue , returntrue . - Return
ContainsExpression ofFunctionRestParameter .
- If
ContainsExpression ofFormalParameterList istrue , returntrue . - Return
ContainsExpression ofFormalParameter .
- Return
false .
- Letformals be
CoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList . - Return
ContainsExpression offormals.
- Return
false .
15.1.3 Static Semantics: IsSimpleParameterList
- Return
false .
- Return
false .
- Return
true .
- Return
false .
- Return
true .
- Return
false .
- Return
false .
- If
IsSimpleParameterList ofFormalParameterList isfalse , returnfalse . - Return
IsSimpleParameterList ofFormalParameter .
- Return
IsSimpleParameterList ofBindingElement .
- Return
true .
- Letformals be
CoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList . - Return
IsSimpleParameterList offormals.
- Return
true .
- Lethead be
CoveredAsyncArrowHead ofCoverCallExpressionAndAsyncArrowHead . - Return
IsSimpleParameterList ofhead.
15.1.4 Static Semantics: HasInitializer
- Return
false .
- Return
true .
- Return
false .
- Return
true .
- If
HasInitializer ofFormalParameterList istrue , returntrue . - Return
HasInitializer ofFormalParameter .
15.1.5 Static Semantics: ExpectedArgumentCount
- Return 0.
- Return
ExpectedArgumentCount ofFormalParameterList .
The ExpectedArgumentCount of a
- If
HasInitializer ofFormalParameter istrue , return 0. - Return 1.
- Letcount be
ExpectedArgumentCount ofFormalParameterList . - If
HasInitializer ofFormalParameterList istrue orHasInitializer ofFormalParameter istrue , returncount. - Returncount + 1.
- Return 1.
- Letformals be
CoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList . - Return
ExpectedArgumentCount offormals.
- If
HasInitializer ofFormalParameter istrue , return 0. - Return 1.
- Return 1.
15.2 Function Definitions
Syntax
15.2.1 Static Semantics: Early Errors
- If the source code matching
FormalParameters isstrict mode code , the Early Error rules forUniqueFormalParameters : FormalParameters - If
BindingIdentifier is present and the source code matchingBindingIdentifier isstrict mode code , it is a Syntax Error if theStringValue ofBindingIdentifier is"eval" or"arguments" . - It is a Syntax Error if
FunctionBodyContainsUseStrict ofFunctionBody istrue andIsSimpleParameterList ofFormalParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofFormalParameters also occurs in theLexicallyDeclaredNames ofFunctionBody . - It is a Syntax Error if
FormalParameters Contains SuperProperty istrue . - It is a Syntax Error if
FunctionBody Contains SuperProperty istrue . - It is a Syntax Error if
FormalParameters Contains SuperCall istrue . - It is a Syntax Error if
FunctionBody Contains SuperCall istrue .
The
- It is a Syntax Error if the
LexicallyDeclaredNames ofFunctionStatementList contains any duplicate entries. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofFunctionStatementList also occurs in theVarDeclaredNames ofFunctionStatementList . - It is a Syntax Error if
ContainsDuplicateLabels ofFunctionStatementList with argument « » istrue . - It is a Syntax Error if
ContainsUndefinedBreakTarget ofFunctionStatementList with argument « » istrue . - It is a Syntax Error if
ContainsUndefinedContinueTarget ofFunctionStatementList with arguments « » and « » istrue .
15.2.2 Static Semantics: FunctionBodyContainsUseStrict
- If the
Directive Prologue ofFunctionBody contains aUse Strict Directive , returntrue ; otherwise, returnfalse .
15.2.3 Runtime Semantics: EvaluateFunctionBody
With parametersfunctionObject andargumentsList (a
- Perform ?
FunctionDeclarationInstantiation (functionObject,argumentsList). - Return the result of evaluating
FunctionStatementList .
15.2.4 Runtime Semantics: InstantiateOrdinaryFunctionObject
With parameterscope.
- Letname be
StringValue ofBindingIdentifier . - LetsourceText be the
source text matched by FunctionDeclaration . - LetF be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,FormalParameters ,FunctionBody ,non-lexical-this ,scope). - Perform
SetFunctionName (F,name). - Perform
MakeConstructor (F). - ReturnF.
- LetsourceText be the
source text matched by FunctionDeclaration . - LetF be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,FormalParameters ,FunctionBody ,non-lexical-this ,scope). - Perform
SetFunctionName (F,"default" ). - Perform
MakeConstructor (F). - ReturnF.
An anonymousexport default declaration, and its function code is therefore always
15.2.5 Runtime Semantics: InstantiateOrdinaryFunctionExpression
With optional parametername.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by FunctionExpression . - Letclosure be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,FormalParameters ,FunctionBody ,non-lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Perform
MakeConstructor (closure). - Returnclosure.
Assert :name is not present.- Setname to
StringValue ofBindingIdentifier . - Letscope be the
running execution context 's LexicalEnvironment. - LetfuncEnv be
NewDeclarativeEnvironment (scope). - PerformfuncEnv.CreateImmutableBinding(name,
false ). - LetsourceText be the
source text matched by FunctionExpression . - Letclosure be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,FormalParameters ,FunctionBody ,non-lexical-this ,funcEnv). - Perform
SetFunctionName (closure,name). - Perform
MakeConstructor (closure). - PerformfuncEnv.InitializeBinding(name,closure).
- Returnclosure.
The
15.2.6 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
An alternative semantics is provided in
- Return
NormalCompletion (empty ).
A
- Return
NormalCompletion (undefined ).
15.3 Arrow Function Definitions
Syntax
Supplemental Syntax
When processing an instance of the production
the interpretation of
15.3.1 Static Semantics: Early Errors
- It is a Syntax Error if
ArrowParameters Contains YieldExpression istrue . - It is a Syntax Error if
ArrowParameters Contains AwaitExpression istrue . - It is a Syntax Error if
ConciseBodyContainsUseStrict ofConciseBody istrue andIsSimpleParameterList ofArrowParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofArrowParameters also occurs in theLexicallyDeclaredNames ofConciseBody .
- It is a Syntax Error if
CoverParenthesizedExpressionAndArrowParameterList is notcovering anArrowFormalParameters . - All
early error rules forArrowFormalParameters and its derived productions also apply toCoveredFormalsList ofCoverParenthesizedExpressionAndArrowParameterList .
15.3.2 Static Semantics: ConciseBodyContainsUseStrict
- Return
false .
15.3.3 Static Semantics: CoveredFormalsList
- Return this
ArrowParameters .
- Return the
ArrowFormalParameters that iscovered byCoverParenthesizedExpressionAndArrowParameterList .
15.3.4 Runtime Semantics: EvaluateConciseBody
With parametersfunctionObject andargumentsList (a
- Perform ?
FunctionDeclarationInstantiation (functionObject,argumentsList). - Return the result of evaluating
ExpressionBody .
15.3.5 Runtime Semantics: InstantiateArrowFunctionExpression
With optional parametername.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by ArrowFunction . - Letparameters be
CoveredFormalsList ofArrowParameters . - Letclosure be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,parameters,ConciseBody ,lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Returnclosure.
Anarguments,super,this, ornew.target. Any reference toarguments,super,this, ornew.target within ansuper, thesuper is always contained within a non-super is accessible via thescope that is captured by the
15.3.6 Runtime Semantics: Evaluation
- LetexprRef be the result of evaluating
AssignmentExpression . - LetexprValue be ?
GetValue (exprRef). - Return
Completion { [[Type]]:return , [[Value]]:exprValue, [[Target]]:empty }.
15.4 Method Definitions
Syntax
15.4.1 Static Semantics: Early Errors
- It is a Syntax Error if
FunctionBodyContainsUseStrict ofFunctionBody istrue andIsSimpleParameterList ofUniqueFormalParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofUniqueFormalParameters also occurs in theLexicallyDeclaredNames ofFunctionBody .
- It is a Syntax Error if
BoundNames ofPropertySetParameterList contains any duplicate elements. - It is a Syntax Error if
FunctionBodyContainsUseStrict ofFunctionBody istrue andIsSimpleParameterList ofPropertySetParameterList isfalse . - It is a Syntax Error if any element of the
BoundNames ofPropertySetParameterList also occurs in theLexicallyDeclaredNames ofFunctionBody .
15.4.2 Static Semantics: HasDirectSuper
- If
UniqueFormalParameters Contains SuperCall istrue , returntrue . - Return
FunctionBody Contains SuperCall .
- If
PropertySetParameterList Contains SuperCall istrue , returntrue . - Return
FunctionBody Contains SuperCall .
- If
UniqueFormalParameters Contains SuperCall istrue , returntrue . - Return
GeneratorBody Contains SuperCall .
- If
UniqueFormalParameters Contains SuperCall istrue , returntrue . - Return
AsyncGeneratorBody Contains SuperCall .
- If
UniqueFormalParameters Contains SuperCall istrue , returntrue . - Return
AsyncFunctionBody Contains SuperCall .
15.4.3 Static Semantics: SpecialMethod
- Return
false .
- Return
true .
15.4.4 Runtime Semantics: DefineMethod
With parameterobject and optional parameterfunctionPrototype.
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- Letscope be the
running execution context 's LexicalEnvironment. - IffunctionPrototype is present, then
- Letprototype befunctionPrototype.
- Else,
- Letprototype be
%Function.prototype% .
- Letprototype be
- LetsourceText be the
source text matched by MethodDefinition . - Letclosure be
OrdinaryFunctionCreate (prototype,sourceText,UniqueFormalParameters ,FunctionBody ,non-lexical-this ,scope). - Perform
MakeMethod (closure,object). - Return the
Record { [[Key]]:propKey, [[Closure]]:closure }.
15.4.5 Runtime Semantics: MethodDefinitionEvaluation
With parametersobject andenumerable.
- LetmethodDef be ?
DefineMethod ofMethodDefinition with argumentobject. - Perform
SetFunctionName (methodDef.[[Closure]],methodDef.[[Key]]). - Letdesc be the PropertyDescriptor { [[Value]]:methodDef.[[Closure]], [[Writable]]:
true , [[Enumerable]]:enumerable, [[Configurable]]:true }. - Return ?
DefinePropertyOrThrow (object,methodDef.[[Key]],desc).
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- Letscope be the
running execution context 's LexicalEnvironment. - LetsourceText be the
source text matched by MethodDefinition . - LetformalParameterList be an instance of the production
FormalParameters : [empty] - Letclosure be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,formalParameterList,FunctionBody ,non-lexical-this ,scope). - Perform
MakeMethod (closure,object). - Perform
SetFunctionName (closure,propKey,"get" ). - Letdesc be the PropertyDescriptor { [[Get]]:closure, [[Enumerable]]:enumerable, [[Configurable]]:
true }. - Return ?
DefinePropertyOrThrow (object,propKey,desc).
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- Letscope be the
running execution context 's LexicalEnvironment. - LetsourceText be the
source text matched by MethodDefinition . - Letclosure be
OrdinaryFunctionCreate (%Function.prototype% ,sourceText,PropertySetParameterList ,FunctionBody ,non-lexical-this ,scope). - Perform
MakeMethod (closure,object). - Perform
SetFunctionName (closure,propKey,"set" ). - Letdesc be the PropertyDescriptor { [[Set]]:closure, [[Enumerable]]:enumerable, [[Configurable]]:
true }. - Return ?
DefinePropertyOrThrow (object,propKey,desc).
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- Letscope be the
running execution context 's LexicalEnvironment. - LetsourceText be the
source text matched by GeneratorMethod . - Letclosure be
OrdinaryFunctionCreate (%GeneratorFunction.prototype% ,sourceText,UniqueFormalParameters ,GeneratorBody ,non-lexical-this ,scope). - Perform
MakeMethod (closure,object). - Perform
SetFunctionName (closure,propKey). - Letprototype be !
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - Letdesc be the PropertyDescriptor { [[Value]]:closure, [[Writable]]:
true , [[Enumerable]]:enumerable, [[Configurable]]:true }. - Return ?
DefinePropertyOrThrow (object,propKey,desc).
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- Letscope be the
running execution context 's LexicalEnvironment. - LetsourceText be the
source text matched by AsyncGeneratorMethod . - Letclosure be !
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% ,sourceText,UniqueFormalParameters ,AsyncGeneratorBody ,non-lexical-this ,scope). - Perform !
MakeMethod (closure,object). - Perform !
SetFunctionName (closure,propKey). - Letprototype be !
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% ). - Perform !
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - Letdesc be PropertyDescriptor { [[Value]]:closure, [[Writable]]:
true , [[Enumerable]]:enumerable, [[Configurable]]:true }. - Return ?
DefinePropertyOrThrow (object,propKey,desc).
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by AsyncMethod . - Letclosure be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,UniqueFormalParameters ,AsyncFunctionBody ,non-lexical-this ,scope). - Perform !
MakeMethod (closure,object). - Perform !
SetFunctionName (closure,propKey). - Letdesc be the PropertyDescriptor { [[Value]]:closure, [[Writable]]:
true , [[Enumerable]]:enumerable, [[Configurable]]:true }. - Return ?
DefinePropertyOrThrow (object,propKey,desc).
15.5 Generator Function Definitions
Syntax
The syntactic context immediately followingyield requires use of the
15.5.1 Static Semantics: Early Errors
- It is a Syntax Error if
HasDirectSuper ofGeneratorMethod istrue . - It is a Syntax Error if
UniqueFormalParameters Contains YieldExpression istrue . - It is a Syntax Error if
FunctionBodyContainsUseStrict ofGeneratorBody istrue andIsSimpleParameterList ofUniqueFormalParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofUniqueFormalParameters also occurs in theLexicallyDeclaredNames ofGeneratorBody .
- If the source code matching
FormalParameters isstrict mode code , the Early Error rules forUniqueFormalParameters : FormalParameters - If
BindingIdentifier is present and the source code matchingBindingIdentifier isstrict mode code , it is a Syntax Error if theStringValue ofBindingIdentifier is"eval" or"arguments" . - It is a Syntax Error if
FunctionBodyContainsUseStrict ofGeneratorBody istrue andIsSimpleParameterList ofFormalParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofFormalParameters also occurs in theLexicallyDeclaredNames ofGeneratorBody . - It is a Syntax Error if
FormalParameters Contains YieldExpression istrue . - It is a Syntax Error if
FormalParameters Contains SuperProperty istrue . - It is a Syntax Error if
GeneratorBody Contains SuperProperty istrue . - It is a Syntax Error if
FormalParameters Contains SuperCall istrue . - It is a Syntax Error if
GeneratorBody Contains SuperCall istrue .
15.5.2 Runtime Semantics: EvaluateGeneratorBody
With parametersfunctionObject andargumentsList (a
- Perform ?
FunctionDeclarationInstantiation (functionObject,argumentsList). - LetG be ?
OrdinaryCreateFromConstructor (functionObject,"%GeneratorFunction.prototype.prototype%" , « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] »). - SetG.[[GeneratorBrand]] to
empty . - Perform
GeneratorStart (G,FunctionBody ). - Return
Completion { [[Type]]:return , [[Value]]:G, [[Target]]:empty }.
15.5.3 Runtime Semantics: InstantiateGeneratorFunctionObject
With parameterscope.
- Letname be
StringValue ofBindingIdentifier . - LetsourceText be the
source text matched by GeneratorDeclaration . - LetF be
OrdinaryFunctionCreate (%GeneratorFunction.prototype% ,sourceText,FormalParameters ,GeneratorBody ,non-lexical-this ,scope). - Perform
SetFunctionName (F,name). - Letprototype be !
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - ReturnF.
- LetsourceText be the
source text matched by GeneratorDeclaration . - LetF be
OrdinaryFunctionCreate (%GeneratorFunction.prototype% ,sourceText,FormalParameters ,GeneratorBody ,non-lexical-this ,scope). - Perform
SetFunctionName (F,"default" ). - Letprototype be !
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - ReturnF.
An anonymousexport default declaration, and its function code is therefore always
15.5.4 Runtime Semantics: InstantiateGeneratorFunctionExpression
With optional parametername.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by GeneratorExpression . - Letclosure be
OrdinaryFunctionCreate (%GeneratorFunction.prototype% ,sourceText,FormalParameters ,GeneratorBody ,non-lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Letprototype be !
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - Returnclosure.
Assert :name is not present.- Setname to
StringValue ofBindingIdentifier . - Letscope be the
running execution context 's LexicalEnvironment. - LetfuncEnv be
NewDeclarativeEnvironment (scope). - PerformfuncEnv.CreateImmutableBinding(name,
false ). - LetsourceText be the
source text matched by GeneratorExpression . - Letclosure be
OrdinaryFunctionCreate (%GeneratorFunction.prototype% ,sourceText,FormalParameters ,GeneratorBody ,non-lexical-this ,funcEnv). - Perform
SetFunctionName (closure,name). - Letprototype be !
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - PerformfuncEnv.InitializeBinding(name,closure).
- Returnclosure.
The
15.5.5 Runtime Semantics: Evaluation
- Return ?
Yield (undefined ).
- LetexprRef be the result of evaluating
AssignmentExpression . - Letvalue be ?
GetValue (exprRef). - Return ?
Yield (value).
- LetgeneratorKind be !
GetGeneratorKind (). - LetexprRef be the result of evaluating
AssignmentExpression . - Letvalue be ?
GetValue (exprRef). - LetiteratorRecord be ?
GetIterator (value,generatorKind). - Letiterator beiteratorRecord.[[Iterator]].
- Letreceived be
NormalCompletion (undefined ). - Repeat,
- Ifreceived.[[Type]] is
normal , then- LetinnerResult be ?
Call (iteratorRecord.[[NextMethod]],iteratorRecord.[[Iterator]], «received.[[Value]] »). - IfgeneratorKind is
async , setinnerResult to ?Await (innerResult). - If
Type (innerResult) is not Object, throw aTypeError exception. - Letdone be ?
IteratorComplete (innerResult). - Ifdone is
true , then- Return ?
IteratorValue (innerResult).
- Return ?
- IfgeneratorKind is
async , setreceived toAsyncGeneratorYield (?IteratorValue (innerResult)). - Else, setreceived to
GeneratorYield (innerResult).
- LetinnerResult be ?
- Else ifreceived.[[Type]] is
throw , then- Letthrow be ?
GetMethod (iterator,"throw" ). - Ifthrow is not
undefined , then- LetinnerResult be ?
Call (throw,iterator, «received.[[Value]] »). - IfgeneratorKind is
async , setinnerResult to ?Await (innerResult). - NOTE: Exceptions from the inner iterator
throwmethod are propagated. Normal completions from an innerthrowmethod are processed similarly to an innernext. - If
Type (innerResult) is not Object, throw aTypeError exception. - Letdone be ?
IteratorComplete (innerResult). - Ifdone is
true , then- Return ?
IteratorValue (innerResult).
- Return ?
- IfgeneratorKind is
async , setreceived toAsyncGeneratorYield (?IteratorValue (innerResult)). - Else, setreceived to
GeneratorYield (innerResult).
- LetinnerResult be ?
- Else,
- NOTE: Ifiterator does not have a
throwmethod, this throw is going to terminate theyield*loop. But first we need to giveiterator a chance to clean up. - LetcloseCompletion be
Completion { [[Type]]:normal , [[Value]]:empty , [[Target]]:empty }. - IfgeneratorKind is
async , perform ?AsyncIteratorClose (iteratorRecord,closeCompletion). - Else, perform ?
IteratorClose (iteratorRecord,closeCompletion). - NOTE: The next step throws a
TypeError to indicate that there was ayield*protocol violation:iterator does not have athrowmethod. - Throw a
TypeError exception.
- NOTE: Ifiterator does not have a
- Letthrow be ?
- Else,
Assert :received.[[Type]] isreturn .- Letreturn be ?
GetMethod (iterator,"return" ). - Ifreturn is
undefined , then- IfgeneratorKind is
async , setreceived.[[Value]] to ?Await (received.[[Value]]). - Return
Completion (received).
- IfgeneratorKind is
- LetinnerReturnResult be ?
Call (return,iterator, «received.[[Value]] »). - IfgeneratorKind is
async , setinnerReturnResult to ?Await (innerReturnResult). - If
Type (innerReturnResult) is not Object, throw aTypeError exception. - Letdone be ?
IteratorComplete (innerReturnResult). - Ifdone is
true , then- Letvalue be ?
IteratorValue (innerReturnResult). - Return
Completion { [[Type]]:return , [[Value]]:value, [[Target]]:empty }.
- Letvalue be ?
- IfgeneratorKind is
async , setreceived toAsyncGeneratorYield (?IteratorValue (innerReturnResult)). - Else, setreceived to
GeneratorYield (innerReturnResult).
- Ifreceived.[[Type]] is
15.6 Async Generator Function Definitions
Syntax
15.6.1 Static Semantics: Early Errors
- It is a Syntax Error if
HasDirectSuper ofAsyncGeneratorMethod istrue . - It is a Syntax Error if
UniqueFormalParameters Contains YieldExpression istrue . - It is a Syntax Error if
UniqueFormalParameters Contains AwaitExpression istrue . - It is a Syntax Error if
FunctionBodyContainsUseStrict ofAsyncGeneratorBody istrue andIsSimpleParameterList ofUniqueFormalParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofUniqueFormalParameters also occurs in theLexicallyDeclaredNames ofAsyncGeneratorBody .
- If the source code matching
FormalParameters isstrict mode code , the Early Error rules forUniqueFormalParameters : FormalParameters - If
BindingIdentifier is present and the source code matchingBindingIdentifier isstrict mode code , it is a Syntax Error if theStringValue ofBindingIdentifier is"eval" or"arguments" . - It is a Syntax Error if
FunctionBodyContainsUseStrict ofAsyncGeneratorBody istrue andIsSimpleParameterList ofFormalParameters isfalse . - It is a Syntax Error if any element of the
BoundNames ofFormalParameters also occurs in theLexicallyDeclaredNames ofAsyncGeneratorBody . - It is a Syntax Error if
FormalParameters Contains YieldExpression istrue . - It is a Syntax Error if
FormalParameters Contains AwaitExpression istrue . - It is a Syntax Error if
FormalParameters Contains SuperProperty istrue . - It is a Syntax Error if
AsyncGeneratorBody Contains SuperProperty istrue . - It is a Syntax Error if
FormalParameters Contains SuperCall istrue . - It is a Syntax Error if
AsyncGeneratorBody Contains SuperCall istrue .
15.6.2 Runtime Semantics: EvaluateAsyncGeneratorBody
With parametersfunctionObject andargumentsList (a
- Perform ?
FunctionDeclarationInstantiation (functionObject,argumentsList). - Letgenerator be ?
OrdinaryCreateFromConstructor (functionObject,"%AsyncGeneratorFunction.prototype.prototype%" , « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] »). - Setgenerator.[[GeneratorBrand]] to
empty . - Perform !
AsyncGeneratorStart (generator,FunctionBody ). - Return
Completion { [[Type]]:return , [[Value]]:generator, [[Target]]:empty }.
15.6.3 Runtime Semantics: InstantiateAsyncGeneratorFunctionObject
With parameterscope.
- Letname be
StringValue ofBindingIdentifier . - LetsourceText be the
source text matched by AsyncGeneratorDeclaration . - LetF be !
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% ,sourceText,FormalParameters ,AsyncGeneratorBody ,non-lexical-this ,scope). - Perform !
SetFunctionName (F,name). - Letprototype be !
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% ). - Perform !
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - ReturnF.
- LetsourceText be the
source text matched by AsyncGeneratorDeclaration . - LetF be
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% ,sourceText,FormalParameters ,AsyncGeneratorBody ,non-lexical-this ,scope). - Perform
SetFunctionName (F,"default" ). - Letprototype be !
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - ReturnF.
An anonymousexport default declaration.
15.6.4 Runtime Semantics: InstantiateAsyncGeneratorFunctionExpression
With optional parametername.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by AsyncGeneratorExpression . - Letclosure be !
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% ,sourceText,FormalParameters ,AsyncGeneratorBody ,non-lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Letprototype be !
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% ). - Perform !
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - Returnclosure.
Assert :name is not present.- Setname to
StringValue ofBindingIdentifier . - Letscope be the
running execution context 's LexicalEnvironment. - LetfuncEnv be !
NewDeclarativeEnvironment (scope). - Perform !funcEnv.CreateImmutableBinding(name,
false ). - LetsourceText be the
source text matched by AsyncGeneratorExpression . - Letclosure be !
OrdinaryFunctionCreate (%AsyncGeneratorFunction.prototype% ,sourceText,FormalParameters ,AsyncGeneratorBody ,non-lexical-this ,funcEnv). - Perform !
SetFunctionName (closure,name). - Letprototype be !
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% ). - Perform !
DefinePropertyOrThrow (closure,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - Perform !funcEnv.InitializeBinding(name,closure).
- Returnclosure.
The
15.6.5 Runtime Semantics: Evaluation
15.7 Class Definitions
Syntax
A class definition is always
15.7.1 Static Semantics: Early Errors
It is a Syntax Error if
ClassHeritage is not present and the following algorithm evaluates totrue :- Letconstructor be
ConstructorMethod ofClassBody . - Ifconstructor is
empty , returnfalse . - Return
HasDirectSuper ofconstructor.
- Letconstructor be
- It is a Syntax Error if
PrototypePropertyNameList ofClassElementList contains more than one occurrence of"constructor" .
- It is a Syntax Error if
PropName ofMethodDefinition is not"constructor" andHasDirectSuper ofMethodDefinition istrue . - It is a Syntax Error if
PropName ofMethodDefinition is"constructor" andSpecialMethod ofMethodDefinition istrue .
- It is a Syntax Error if
HasDirectSuper ofMethodDefinition istrue . - It is a Syntax Error if
PropName ofMethodDefinition is"prototype" .
15.7.2 Static Semantics: ClassElementKind
- If
PropName ofMethodDefinition is"constructor" , returnConstructorMethod . - Return
NonConstructorMethod .
- Return
NonConstructorMethod .
- Return
empty .
15.7.3 Static Semantics: ConstructorMethod
- If
ClassElementKind ofClassElement isConstructorMethod , returnClassElement . - Return
empty .
- Lethead be
ConstructorMethod ofClassElementList . - Ifhead is not
empty , returnhead. - If
ClassElementKind ofClassElement isConstructorMethod , returnClassElement . - Return
empty .
Early Error rules ensure that there is only one method definition named
15.7.4 Static Semantics: IsStatic
- Return
false .
- Return
true .
- Return
false .
15.7.5 Static Semantics: NonConstructorMethodDefinitions
- If
ClassElementKind ofClassElement isNonConstructorMethod , then- Return a
List whose sole element isClassElement .
- Return a
- Return a new empty
List .
- Letlist be
NonConstructorMethodDefinitions ofClassElementList . - If
ClassElementKind ofClassElement isNonConstructorMethod , then- Append
ClassElement to the end oflist.
- Append
- Returnlist.
15.7.6 Static Semantics: PrototypePropertyNameList
- If
PropName ofClassElement isempty , return a new emptyList . - If
IsStatic ofClassElement istrue , return a new emptyList . - Return a
List whose sole element isPropName ofClassElement .
- Letlist be
PrototypePropertyNameList ofClassElementList . - If
PropName ofClassElement isempty , returnlist. - If
IsStatic ofClassElement istrue , returnlist. - Append
PropName ofClassElement to the end oflist. - Returnlist.
15.7.7 Runtime Semantics: ClassDefinitionEvaluation
With parametersclassBinding andclassName.
- Letenv be the LexicalEnvironment of the
running execution context . - LetclassScope be
NewDeclarativeEnvironment (env). - IfclassBinding is not
undefined , then- PerformclassScope.CreateImmutableBinding(classBinding,
true ).
- PerformclassScope.CreateImmutableBinding(classBinding,
- If
ClassHeritage is not present, thenopt - LetprotoParent be
%Object.prototype% . - LetconstructorParent be
%Function.prototype% .
- LetprotoParent be
- Else,
- Set the
running execution context 's LexicalEnvironment toclassScope. - LetsuperclassRef be the result of evaluating
ClassHeritage . - Set the
running execution context 's LexicalEnvironment toenv. - Letsuperclass be ?
GetValue (superclassRef). - Ifsuperclass is
null , then- LetprotoParent be
null . - LetconstructorParent be
%Function.prototype% .
- LetprotoParent be
- Else if
IsConstructor (superclass) isfalse , throw aTypeError exception. - Else,
- Set the
- Letproto be !
OrdinaryObjectCreate (protoParent). - If
ClassBody is not present, letconstructor beopt empty . - Else, letconstructor be
ConstructorMethod ofClassBody . - Set the
running execution context 's LexicalEnvironment toclassScope. - Ifconstructor is
empty , then- Letsteps be the algorithm steps defined in
Default Constructor Functions . - LetF be !
CreateBuiltinFunction (steps, 0,className, « [[ConstructorKind]], [[SourceText]] »,empty ,constructorParent).
- Letsteps be the algorithm steps defined in
- Else,
- LetconstructorInfo be !
DefineMethod ofconstructor with argumentsproto andconstructorParent. - LetF beconstructorInfo.[[Closure]].
- Perform !
MakeClassConstructor (F). - Perform !
SetFunctionName (F,className).
- LetconstructorInfo be !
- Perform !
MakeConstructor (F,false ,proto). - If
ClassHeritage is present, setF.[[ConstructorKind]] toopt derived . - Perform !
CreateMethodProperty (proto,"constructor" ,F). - If
ClassBody is not present, letmethods be a new emptyopt List . - Else, letmethods be
NonConstructorMethodDefinitions ofClassBody . - For each
ClassElement m ofmethods, do- If
IsStatic ofm isfalse , then- Letstatus be
PropertyDefinitionEvaluation ofm with argumentsproto andfalse .
- Letstatus be
- Else,
- Letstatus be
PropertyDefinitionEvaluation ofm with argumentsF andfalse .
- Letstatus be
- Ifstatus is an
abrupt completion , then- Set the
running execution context 's LexicalEnvironment toenv. - Return
Completion (status).
- Set the
- If
- Set the
running execution context 's LexicalEnvironment toenv. - IfclassBinding is not
undefined , then- PerformclassScope.InitializeBinding(classBinding,F).
- ReturnF.
15.7.7.1 Default Constructor Functions
When a Default
- If NewTarget is
undefined , throw aTypeError exception. - LetF be the
active function object . - IfF.[[ConstructorKind]] is
derived , then- NOTE: This branch behaves similarly to
constructor(...args) { super(...args); }. The most notable distinction is that while the aforementioned ECMAScript source text observably calls the@@iterator method on%Array.prototype%, a DefaultConstructor Function does not. - Letfunc be !F.[[GetPrototypeOf]]().
- If
IsConstructor (func) isfalse , throw aTypeError exception. - Return ?
Construct (func,args, NewTarget).
- NOTE: This branch behaves similarly to
- Else,
- NOTE: This branch behaves similarly to
constructor() {}. - Return ?
OrdinaryCreateFromConstructor (NewTarget,"%Object.prototype%" ).
- NOTE: This branch behaves similarly to
The
15.7.8 Runtime Semantics: BindingClassDeclarationEvaluation
- LetclassName be
StringValue ofBindingIdentifier . - Letvalue be ?
ClassDefinitionEvaluation ofClassTail with argumentsclassName andclassName. - Setvalue.[[SourceText]] to the
source text matched by ClassDeclaration . - Letenv be the
running execution context 's LexicalEnvironment. - Perform ?
InitializeBoundName (className,value,env). - Returnvalue.
- Letvalue be ?
ClassDefinitionEvaluation ofClassTail with argumentsundefined and"default" . - Setvalue.[[SourceText]] to the
source text matched by ClassDeclaration . - Returnvalue.
15.7.9 Runtime Semantics: Evaluation
- Perform ?
BindingClassDeclarationEvaluation of thisClassDeclaration . - Return
NormalCompletion (empty ).
- Letvalue be ?
ClassDefinitionEvaluation ofClassTail with argumentsundefined and"" . - Setvalue.[[SourceText]] to the
source text matched by ClassExpression . - Returnvalue.
- LetclassName be
StringValue ofBindingIdentifier . - Letvalue be ?
ClassDefinitionEvaluation ofClassTail with argumentsclassName andclassName. - Setvalue.[[SourceText]] to the
source text matched by ClassExpression . - Returnvalue.
15.8 Async Function Definitions
Syntax
await is parsed as an
- In an
AsyncFunctionBody . - In the
FormalParameters of anAsyncFunctionDeclaration ,AsyncFunctionExpression ,AsyncGeneratorDeclaration , orAsyncGeneratorExpression .AwaitExpression in this position is a Syntax error viastatic semantics .
Whenawait is parsed as aawait may be parsed as an identifier when the[Await] parameter is absent. This includes the following contexts:
- Anywhere outside of an
AsyncFunctionBody orFormalParameters of anAsyncFunctionDeclaration ,AsyncFunctionExpression ,AsyncGeneratorDeclaration , orAsyncGeneratorExpression . - In the
BindingIdentifier of aFunctionExpression ,GeneratorExpression , orAsyncGeneratorExpression .
Unlike
15.8.1 Static Semantics: Early Errors
- It is a Syntax Error if
FunctionBodyContainsUseStrict ofAsyncFunctionBody istrue andIsSimpleParameterList ofUniqueFormalParameters isfalse . - It is a Syntax Error if
HasDirectSuper ofAsyncMethod istrue . - It is a Syntax Error if
UniqueFormalParameters Contains AwaitExpression istrue . - It is a Syntax Error if any element of the
BoundNames ofUniqueFormalParameters also occurs in theLexicallyDeclaredNames ofAsyncFunctionBody .
- It is a Syntax Error if
FunctionBodyContainsUseStrict ofAsyncFunctionBody istrue andIsSimpleParameterList ofFormalParameters isfalse . - It is a Syntax Error if
FormalParameters Contains AwaitExpression istrue . - If the source code matching
FormalParameters isstrict mode code , the Early Error rules forUniqueFormalParameters : FormalParameters - If
BindingIdentifier is present and the source code matchingBindingIdentifier isstrict mode code , it is a Syntax Error if theStringValue ofBindingIdentifier is"eval" or"arguments" . - It is a Syntax Error if any element of the
BoundNames ofFormalParameters also occurs in theLexicallyDeclaredNames ofAsyncFunctionBody . - It is a Syntax Error if
FormalParameters Contains SuperProperty istrue . - It is a Syntax Error if
AsyncFunctionBody Contains SuperProperty istrue . - It is a Syntax Error if
FormalParameters Contains SuperCall istrue . - It is a Syntax Error if
AsyncFunctionBody Contains SuperCall istrue .
15.8.2 Runtime Semantics: InstantiateAsyncFunctionObject
With parameterscope.
- Letname be
StringValue ofBindingIdentifier . - LetsourceText be the
source text matched by AsyncFunctionDeclaration . - LetF be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,FormalParameters ,AsyncFunctionBody ,non-lexical-this ,scope). - Perform !
SetFunctionName (F,name). - ReturnF.
- LetsourceText be the
source text matched by AsyncFunctionDeclaration . - LetF be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,FormalParameters ,AsyncFunctionBody ,non-lexical-this ,scope). - Perform !
SetFunctionName (F,"default" ). - ReturnF.
15.8.3 Runtime Semantics: InstantiateAsyncFunctionExpression
With optional parametername.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by AsyncFunctionExpression . - Letclosure be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,FormalParameters ,AsyncFunctionBody ,non-lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Returnclosure.
Assert :name is not present.- Setname to
StringValue ofBindingIdentifier . - Letscope be the LexicalEnvironment of the
running execution context . - LetfuncEnv be !
NewDeclarativeEnvironment (scope). - Perform !funcEnv.CreateImmutableBinding(name,
false ). - LetsourceText be the
source text matched by AsyncFunctionExpression . - Letclosure be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,FormalParameters ,AsyncFunctionBody ,non-lexical-this ,funcEnv). - Perform !
SetFunctionName (closure,name). - Perform !funcEnv.InitializeBinding(name,closure).
- Returnclosure.
The
15.8.4 Runtime Semantics: EvaluateAsyncFunctionBody
With parametersfunctionObject andargumentsList (a
- LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - LetdeclResult be
FunctionDeclarationInstantiation (functionObject,argumentsList). - IfdeclResult is not an
abrupt completion , then- Perform !
AsyncFunctionStart (promiseCapability,FunctionBody ).
- Perform !
- Else,
- Perform !
Call (promiseCapability.[[Reject]],undefined , «declResult.[[Value]] »).
- Perform !
- Return
Completion { [[Type]]:return , [[Value]]:promiseCapability.[[Promise]], [[Target]]:empty }.
15.8.5 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
- Return
NormalCompletion (empty ).
- LetexprRef be the result of evaluating
UnaryExpression . - Letvalue be ?
GetValue (exprRef). - Return ?
Await (value).
15.9 Async Arrow Function Definitions
Syntax
Supplemental Syntax
When processing an instance of the production
the interpretation of
15.9.1 Static Semantics: Early Errors
- It is a Syntax Error if any element of the
BoundNames ofAsyncArrowBindingIdentifier also occurs in theLexicallyDeclaredNames ofAsyncConciseBody .
- It is a Syntax Error if
CoverCallExpressionAndAsyncArrowHead Contains YieldExpression istrue . - It is a Syntax Error if
CoverCallExpressionAndAsyncArrowHead Contains AwaitExpression istrue . - It is a Syntax Error if
CoverCallExpressionAndAsyncArrowHead is notcovering anAsyncArrowHead . - It is a Syntax Error if any element of the
BoundNames ofCoverCallExpressionAndAsyncArrowHead also occurs in theLexicallyDeclaredNames ofAsyncConciseBody . - It is a Syntax Error if
AsyncConciseBodyContainsUseStrict ofAsyncConciseBody istrue andIsSimpleParameterList ofCoverCallExpressionAndAsyncArrowHead isfalse . - All Early Error rules for
AsyncArrowHead and its derived productions apply toCoveredAsyncArrowHead ofCoverCallExpressionAndAsyncArrowHead .
15.9.2 Static Semantics: CoveredAsyncArrowHead
- Return the
AsyncArrowHead that iscovered byCoverCallExpressionAndAsyncArrowHead .
15.9.3 Static Semantics: AsyncConciseBodyContainsUseStrict
- Return
false .
15.9.4 Runtime Semantics: EvaluateAsyncConciseBody
With parametersfunctionObject andargumentsList (a
- LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - LetdeclResult be
FunctionDeclarationInstantiation (functionObject,argumentsList). - IfdeclResult is not an
abrupt completion , then- Perform !
AsyncFunctionStart (promiseCapability,ExpressionBody ).
- Perform !
- Else,
- Perform !
Call (promiseCapability.[[Reject]],undefined , «declResult.[[Value]] »).
- Perform !
- Return
Completion { [[Type]]:return , [[Value]]:promiseCapability.[[Promise]], [[Target]]:empty }.
15.9.5 Runtime Semantics: InstantiateAsyncArrowFunctionExpression
With optional parametername.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by AsyncArrowFunction . - Letparameters be
AsyncArrowBindingIdentifier . - Letclosure be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,parameters,AsyncConciseBody ,lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Returnclosure.
- Ifname is not present, setname to
"" . - Letscope be the LexicalEnvironment of the
running execution context . - LetsourceText be the
source text matched by AsyncArrowFunction . - Lethead be
CoveredAsyncArrowHead ofCoverCallExpressionAndAsyncArrowHead . - Letparameters be the
ArrowFormalParameters ofhead. - Letclosure be !
OrdinaryFunctionCreate (%AsyncFunction.prototype% ,sourceText,parameters,AsyncConciseBody ,lexical-this ,scope). - Perform
SetFunctionName (closure,name). - Returnclosure.
15.9.6 Runtime Semantics: Evaluation
15.10 Tail Position Calls
15.10.1 Static Semantics: IsInTailPosition (call )
The abstract operation IsInTailPosition takes argumentcall. It performs the following steps when called:
Assert :call is aParse Node .- If the source code matchingcall is
non-strict code , returnfalse . - Ifcall is not contained within a
FunctionBody ,ConciseBody , orAsyncConciseBody , returnfalse . - Letbody be the
FunctionBody ,ConciseBody , orAsyncConciseBody that most closely containscall. - Ifbody is the
FunctionBody of aGeneratorBody , returnfalse . - Ifbody is the
FunctionBody of anAsyncFunctionBody , returnfalse . - Ifbody is the
FunctionBody of anAsyncGeneratorBody , returnfalse . - Ifbody is an
AsyncConciseBody , returnfalse . - Return the result of
HasCallInTailPosition ofbody with argumentcall.
Tail Position calls are only defined in
15.10.2 Static Semantics: HasCallInTailPosition
With parametercall.
call is a
15.10.2.1 Statement Rules
- Lethas be
HasCallInTailPosition ofStatementList with argumentcall. - Ifhas is
true , returntrue . - Return
HasCallInTailPosition ofStatementListItem with argumentcall.
- Return
false .
- Lethas be
HasCallInTailPosition of the firstStatement with argumentcall. - Ifhas is
true , returntrue . - Return
HasCallInTailPosition of the secondStatement with argumentcall.
- Return
HasCallInTailPosition ofStatement with argumentcall.
- Return
HasCallInTailPosition ofLabelledItem with argumentcall.
- Return
HasCallInTailPosition ofExpression with argumentcall.
- Return
HasCallInTailPosition ofCaseBlock with argumentcall.
- Lethas be
false . - If the first
CaseClauses is present, lethas beHasCallInTailPosition of the firstCaseClauses with argumentcall. - Ifhas is
true , returntrue . - Lethas be
HasCallInTailPosition ofDefaultClause with argumentcall. - Ifhas is
true , returntrue . - If the second
CaseClauses is present, lethas beHasCallInTailPosition of the secondCaseClauses with argumentcall. - Returnhas.
- Lethas be
HasCallInTailPosition ofCaseClauses with argumentcall. - Ifhas is
true , returntrue . - Return
HasCallInTailPosition ofCaseClause with argumentcall.
- If
StatementList is present, returnHasCallInTailPosition ofStatementList with argumentcall. - Return
false .
- Return
HasCallInTailPosition ofCatch with argumentcall.
- Return
HasCallInTailPosition ofFinally with argumentcall.
- Return
HasCallInTailPosition ofBlock with argumentcall.
15.10.2.2 Expression Rules
A potential tail position call that is immediately followed by return
- Return
false .
- Return
HasCallInTailPosition ofAssignmentExpression with argumentcall.
- Lethas be
HasCallInTailPosition of the firstAssignmentExpression with argumentcall. - Ifhas is
true , returntrue . - Return
HasCallInTailPosition of the secondAssignmentExpression with argumentcall.
- Return
HasCallInTailPosition ofBitwiseORExpression with argumentcall.
- Return
HasCallInTailPosition ofLogicalANDExpression with argumentcall.
- Return
HasCallInTailPosition ofBitwiseORExpression with argumentcall.
- If this
CallExpression iscall, returntrue . - Return
false .
- Return
HasCallInTailPosition ofOptionalChain with argumentcall.
- Return
false .
- If this
OptionalChain iscall, returntrue . - Return
false .
- If this
MemberExpression iscall, returntrue . - Return
false .
- Letexpr be
CoveredParenthesizedExpression ofCoverParenthesizedExpressionAndArrowParameterList . - Return
HasCallInTailPosition ofexpr with argumentcall.
- Return
HasCallInTailPosition ofExpression with argumentcall.
15.10.3 PrepareForTailCall ( )
The abstract operation PrepareForTailCall takes no arguments. It performs the following steps when called:
- LetleafContext be the
running execution context . Suspend leafContext.- PopleafContext from the
execution context stack . Theexecution context now on the top of the stack becomes therunning execution context . Assert :leafContext has no further use. It will never be activated as therunning execution context .
A tail position call must either release any transient internal resources associated with the currently executing function
For example, a tail position call should only grow an implementation's activation record stack by the amount that the size of the target function's activation record exceeds the size of the calling function's activation record. If the target function's activation record is smaller, then the total size of the stack should decrease.
16 ECMAScript Language: Scripts and Modules
16.1 Scripts
Syntax
16.1.1 Static Semantics: Early Errors
- It is a Syntax Error if the
LexicallyDeclaredNames ofScriptBody contains any duplicate entries. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofScriptBody also occurs in theVarDeclaredNames ofScriptBody .
- It is a Syntax Error if
StatementList Contains superunless the source code containingsuperis eval code that is being processed by adirect eval . Additionalearly error rules forsuperwithindirect eval are defined in19.2.1.1 . - It is a Syntax Error if
StatementList Contains NewTarget unless the source code containingNewTarget is eval code that is being processed by adirect eval . Additionalearly error rules forNewTarget indirect eval are defined in19.2.1.1 . - It is a Syntax Error if
ContainsDuplicateLabels ofStatementList with argument « » istrue . - It is a Syntax Error if
ContainsUndefinedBreakTarget ofStatementList with argument « » istrue . - It is a Syntax Error if
ContainsUndefinedContinueTarget ofStatementList with arguments « » and « » istrue .
16.1.2 Static Semantics: IsStrict
- If
ScriptBody is present and theDirective Prologue ofScriptBody contains aUse Strict Directive , returntrue ; otherwise, returnfalse .
16.1.3 Runtime Semantics: Evaluation
- Return
NormalCompletion (undefined ).
16.1.4 Script Records
AScript Record encapsulates information about a script being evaluated. Each script record contains the fields listed in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[Realm]] | The | |
| [[Environment]] | The | |
| [[ECMAScriptCode]] | a | The result of parsing the source text of this script using |
| [[HostDefined]] | Any, default value is | Field reserved for use by |
16.1.5 ParseScript (sourceText,realm,hostDefined )
The abstract operation ParseScript takes argumentssourceText,realm, andhostDefined. It creates a
An implementation may parse script source text and analyse it for Early Error conditions prior to evaluation of ParseScript for that script source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseScript upon that source text.
16.1.6 ScriptEvaluation (scriptRecord )
The abstract operation ScriptEvaluation takes argumentscriptRecord. It performs the following steps when called:
- LetglobalEnv bescriptRecord.[[Realm]].[[GlobalEnv]].
- LetscriptContext be a new ECMAScript code
execution context . - Set the Function ofscriptContext to
null . - Set the
Realm ofscriptContext toscriptRecord.[[Realm]]. - Set the ScriptOrModule ofscriptContext toscriptRecord.
- Set the VariableEnvironment ofscriptContext toglobalEnv.
- Set the LexicalEnvironment ofscriptContext toglobalEnv.
Suspend the currentlyrunning execution context .- PushscriptContext onto the
execution context stack ;scriptContext is now therunning execution context . - LetscriptBody bescriptRecord.[[ECMAScriptCode]].
- Letresult be
GlobalDeclarationInstantiation (scriptBody,globalEnv). - Ifresult.[[Type]] is
normal , then- Setresult to the result of evaluatingscriptBody.
- Ifresult.[[Type]] is
normal andresult.[[Value]] isempty , then- Setresult to
NormalCompletion (undefined ).
- Setresult to
Suspend scriptContext and remove it from theexecution context stack .Assert : Theexecution context stack is not empty.- Resume the context that is now on the top of the
execution context stack as therunning execution context . - Return
Completion (result).
16.1.7 GlobalDeclarationInstantiation (script,env )
When an
The abstract operation GlobalDeclarationInstantiation takes argumentsscript (a
Assert :env is aglobal Environment Record .- LetlexNames be the
LexicallyDeclaredNames ofscript. - LetvarNames be the
VarDeclaredNames ofscript. - For each elementname oflexNames, do
- Ifenv.HasVarDeclaration(name) is
true , throw aSyntaxError exception. - Ifenv.HasLexicalDeclaration(name) is
true , throw aSyntaxError exception. - LethasRestrictedGlobal be ?env.HasRestrictedGlobalProperty(name).
- IfhasRestrictedGlobal is
true , throw aSyntaxError exception.
- Ifenv.HasVarDeclaration(name) is
- For each elementname ofvarNames, do
- Ifenv.HasLexicalDeclaration(name) is
true , throw aSyntaxError exception.
- Ifenv.HasLexicalDeclaration(name) is
- LetvarDeclarations be the
VarScopedDeclarations ofscript. - LetfunctionsToInitialize be a new empty
List . - LetdeclaredFunctionNames be a new empty
List . - For each elementd ofvarDeclarations, in reverse
List order, do- Ifd is neither a
VariableDeclaration nor aForBinding nor aBindingIdentifier , thenAssert :d is either aFunctionDeclaration , aGeneratorDeclaration , anAsyncFunctionDeclaration , or anAsyncGeneratorDeclaration .- NOTE: If there are multiple function declarations for the same name, the last declaration is used.
- Letfn be the sole element of the
BoundNames ofd. - Iffn is not an element ofdeclaredFunctionNames, then
- LetfnDefinable be ?env.CanDeclareGlobalFunction(fn).
- IffnDefinable is
false , throw aTypeError exception. - Appendfn todeclaredFunctionNames.
- Insertd as the first element offunctionsToInitialize.
- Ifd is neither a
- LetdeclaredVarNames be a new empty
List . - For each elementd ofvarDeclarations, do
- Ifd is a
VariableDeclaration , aForBinding , or aBindingIdentifier , then- For each Stringvn of the
BoundNames ofd, do- Ifvn is not an element ofdeclaredFunctionNames, then
- LetvnDefinable be ?env.CanDeclareGlobalVar(vn).
- IfvnDefinable is
false , throw aTypeError exception. - Ifvn is not an element ofdeclaredVarNames, then
- Appendvn todeclaredVarNames.
- Ifvn is not an element ofdeclaredFunctionNames, then
- For each Stringvn of the
- Ifd is a
- NOTE: No abnormal terminations occur after this algorithm step if the
global object is anordinary object . However, if theglobal object is aProxy exotic object it may exhibit behaviours that cause abnormal terminations in some of the following steps. - NOTE: Annex
B.3.3.2 adds additional steps at this point. - LetlexDeclarations be the
LexicallyScopedDeclarations ofscript. - For each elementd oflexDeclarations, do
- NOTE: Lexically declared names are only instantiated here but not initialized.
- For each elementdn of the
BoundNames ofd, do- If
IsConstantDeclaration ofd istrue , then- Perform ?env.CreateImmutableBinding(dn,
true ).
- Perform ?env.CreateImmutableBinding(dn,
- Else,
- Perform ?env.CreateMutableBinding(dn,
false ).
- Perform ?env.CreateMutableBinding(dn,
- If
- For each
Parse Node f offunctionsToInitialize, do- Letfn be the sole element of the
BoundNames off. - Letfo be
InstantiateFunctionObject off with argumentenv. - Perform ?env.CreateGlobalFunctionBinding(fn,fo,
false ).
- Letfn be the sole element of the
- For each Stringvn ofdeclaredVarNames, do
- Perform ?env.CreateGlobalVarBinding(vn,
false ).
- Perform ?env.CreateGlobalVarBinding(vn,
- Return
NormalCompletion (empty ).
Early errors specified in
Unlike explicit var or function declarations, properties that are directly created on the
16.2 Modules
Syntax
16.2.1 Module Semantics
16.2.1.1 Static Semantics: Early Errors
- It is a Syntax Error if the
LexicallyDeclaredNames ofModuleItemList contains any duplicate entries. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofModuleItemList also occurs in theVarDeclaredNames ofModuleItemList . - It is a Syntax Error if the
ExportedNames ofModuleItemList contains any duplicate entries. - It is a Syntax Error if any element of the
ExportedBindings ofModuleItemList does not also occur in either theVarDeclaredNames ofModuleItemList , or theLexicallyDeclaredNames ofModuleItemList . - It is a Syntax Error if
ModuleItemList Contains super. - It is a Syntax Error if
ModuleItemList Contains NewTarget . - It is a Syntax Error if
ContainsDuplicateLabels ofModuleItemList with argument « » istrue . - It is a Syntax Error if
ContainsUndefinedBreakTarget ofModuleItemList with argument « » istrue . - It is a Syntax Error if
ContainsUndefinedContinueTarget ofModuleItemList with arguments « » and « » istrue .
The duplicateexport default
16.2.1.2 Static Semantics: ImportedLocalNames (importEntries )
The abstract operation ImportedLocalNames takes argumentimportEntries (a
- LetlocalNames be a new empty
List . - For each
ImportEntry Record i ofimportEntries, do- Appendi.[[LocalName]] tolocalNames.
- ReturnlocalNames.
16.2.1.3 Static Semantics: ModuleRequests
- Return a new empty
List .
- Return
ModuleRequests ofModuleItem .
- LetmoduleNames be
ModuleRequests ofModuleItemList . - LetadditionalNames be
ModuleRequests ofModuleItem . - Append tomoduleNames each element ofadditionalNames that is not already an element ofmoduleNames.
- ReturnmoduleNames.
- Return a new empty
List .
- Return
ModuleRequests ofFromClause .
- Return a
List whose sole element is theSV ofStringLiteral .
- Return the
ModuleRequests ofFromClause .
- Return a new empty
List .
16.2.1.4 Abstract Module Records
AModule Record encapsulates structural information about the imports and exports of a single module. This information is used to link the imports and exports of sets of connected modules. A Module Record includes four fields that are only used when evaluating a module.
For specification purposes Module Record values are values of the
Module Record defines the fields listed in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[Realm]] | The | |
| [[Environment]] | The | |
| [[Namespace]] | Object | | The Module Namespace Object ( |
| [[HostDefined]] | Any, default value is | Field reserved for use by |
| Method | Purpose |
|---|---|
| GetExportedNames([exportStarSet]) | Return a list of all names that are either directly or indirectly exported from this module. |
| ResolveExport(exportName [,resolveSet]) | Return the binding of a name exported by this module. Bindings are represented by aResolvedBinding Record, of the form { [[Module]]: Each time this operation is called with a specificexportName,resolveSet pair as arguments it must return the same result if it completes normally. |
| Link() | Prepare the module for evaluation by transitively resolving all module dependencies and creating a |
| Evaluate() | If this module has already been evaluated successfully, return Link must have completed successfully prior to invoking this method. |
16.2.1.5 Cyclic Module Records
ACyclic Module Record is used to represent information about a module that can participate in dependency cycles with other modules that are subclasses of the
In addition to the fields defined in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[Status]] | Initially | |
| [[EvaluationError]] | An | A completion of type |
| [[DFSIndex]] | Auxiliary field used during Link and Evaluate only. If [[Status]] is | |
| [[DFSAncestorIndex]] | Auxiliary field used during Link and Evaluate only. If [[Status]] is | |
| [[RequestedModules]] | A |
In addition to the methods defined in
| Method | Purpose |
|---|---|
| Initialize the | |
| Evaluate the module's code within its |
16.2.1.5.1 Link ( ) Concrete Method
The Link concrete method of a
Assert :module.[[Status]] is notlinking orevaluating .- Letstack be a new empty
List . - Letresult be
InnerModuleLinking (module,stack, 0). - Ifresult is an
abrupt completion , then- For each
Cyclic Module Record m ofstack, doAssert :m.[[Status]] islinking .- Setm.[[Status]] to
unlinked . - Setm.[[Environment]] to
undefined . - Setm.[[DFSIndex]] to
undefined . - Setm.[[DFSAncestorIndex]] to
undefined .
Assert :module.[[Status]] isunlinked .- Returnresult.
- For each
Assert :module.[[Status]] islinked orevaluated .Assert :stack is empty.- Return
undefined .
16.2.1.5.1.1 InnerModuleLinking (module,stack,index )
The abstract operation InnerModuleLinking takes argumentsmodule (a
- Ifmodule is not a
Cyclic Module Record , then- Perform ?module.Link().
- Returnindex.
- Ifmodule.[[Status]] is
linking ,linked , orevaluated , then- Returnindex.
Assert :module.[[Status]] isunlinked .- Setmodule.[[Status]] to
linking . - Setmodule.[[DFSIndex]] toindex.
- Setmodule.[[DFSAncestorIndex]] toindex.
- Setindex toindex + 1.
- Appendmodule tostack.
- For each Stringrequired ofmodule.[[RequestedModules]], do
- LetrequiredModule be ?
HostResolveImportedModule (module,required). - Setindex to ?
InnerModuleLinking (requiredModule,stack,index). - IfrequiredModule is a
Cyclic Module Record , then
- LetrequiredModule be ?
- Perform ?module.
InitializeEnvironment (). Assert :module occurs exactly once instack.Assert :module.[[DFSAncestorIndex]] ≤module.[[DFSIndex]].- Ifmodule.[[DFSAncestorIndex]] =module.[[DFSIndex]], then
- Letdone be
false . - Repeat, whiledone is
false ,- LetrequiredModule be the last element instack.
- Remove the last element ofstack.
Assert :requiredModule is aCyclic Module Record .- SetrequiredModule.[[Status]] to
linked . - IfrequiredModule andmodule are the same
Module Record , setdone totrue .
- Letdone be
- Returnindex.
16.2.1.5.2 Evaluate ( ) Concrete Method
The Evaluate concrete method of a
Assert : This call to Evaluate is not happening at the same time as another call to Evaluate within thesurrounding agent .Assert :module.[[Status]] islinked orevaluated .- Letstack be a new empty
List . - Letresult be
InnerModuleEvaluation (module,stack, 0). - Ifresult is an
abrupt completion , then- For each
Cyclic Module Record m ofstack, doAssert :m.[[Status]] isevaluating .- Setm.[[Status]] to
evaluated . - Setm.[[EvaluationError]] toresult.
Assert :module.[[Status]] isevaluated andmodule.[[EvaluationError]] isresult.- Returnresult.
- For each
Assert :module.[[Status]] isevaluated andmodule.[[EvaluationError]] isundefined .Assert :stack is empty.- Return
undefined .
16.2.1.5.2.1 InnerModuleEvaluation (module,stack,index )
The abstract operation InnerModuleEvaluation takes argumentsmodule (a
- Ifmodule is not a
Cyclic Module Record , then- Perform ?module.Evaluate().
- Returnindex.
- Ifmodule.[[Status]] is
evaluated , then- Ifmodule.[[EvaluationError]] is
undefined , returnindex. - Otherwise, returnmodule.[[EvaluationError]].
- Ifmodule.[[EvaluationError]] is
- Ifmodule.[[Status]] is
evaluating , returnindex. Assert :module.[[Status]] islinked .- Setmodule.[[Status]] to
evaluating . - Setmodule.[[DFSIndex]] toindex.
- Setmodule.[[DFSAncestorIndex]] toindex.
- Setindex toindex + 1.
- Appendmodule tostack.
- For each Stringrequired ofmodule.[[RequestedModules]], do
- LetrequiredModule be !
HostResolveImportedModule (module,required). - NOTE: Link must be completed successfully prior to invoking this method, so every requested module is guaranteed to resolve successfully.
- Setindex to ?
InnerModuleEvaluation (requiredModule,stack,index). - IfrequiredModule is a
Cyclic Module Record , then
- LetrequiredModule be !
- Perform ?module.
ExecuteModule (). Assert :module occurs exactly once instack.Assert :module.[[DFSAncestorIndex]] ≤module.[[DFSIndex]].- Ifmodule.[[DFSAncestorIndex]] =module.[[DFSIndex]], then
- Letdone be
false . - Repeat, whiledone is
false ,- LetrequiredModule be the last element instack.
- Remove the last element ofstack.
Assert :requiredModule is aCyclic Module Record .- SetrequiredModule.[[Status]] to
evaluated . - IfrequiredModule andmodule are the same
Module Record , setdone totrue .
- Letdone be
- Returnindex.
16.2.1.5.3 Example Cyclic Module Record Graphs
This non-normative section gives a series of examples of the linking and evaluation of a few common module graphs, with a specific focus on how errors can occur.
First consider the following simple module graph:
Let's first assume that there are no error conditions. When a
Consider then cases involving linking errors. If
Finally, consider a case involving evaluation errors. If
The difference here between linking and evaluation errors is due to how evaluation must be only performed once, as it can cause side effects; it is thus important to remember whether evaluation has already been performed, even if unsuccessfully. (In the error case, it makes sense to also remember the exception because otherwise subsequent Evaluate() calls would have to synthesize a new one.) Linking, on the other hand, is side-effect-free, and thus even if it fails, it can be retried at a later time with no issues.
Now consider a different type of error condition:
In this scenario, moduleA declares a dependency on some other module, but no
Lastly, consider a module graph with a cycle:
Here we assume that the entry point is moduleA, so that the
An analogous story occurs for the evaluation phase of a cyclic module graph, in the success case.
Now consider a case whereA has an linking error; for example, it tries to import a binding fromC that does not exist. In that case, the above steps still occur, including the early return from the second call to
Finally, consider a case whereA has an evaluation error; for example, its source code throws an exception. In that case, the evaluation-time analog of the above steps still occurs, including the early return from the second call to
16.2.1.6 Source Text Module Records
ASource Text Module Record is used to represent information about a module that was defined from ECMAScript source text (
A
In addition to the fields defined in
| Field Name | Value Type | Meaning |
|---|---|---|
| [[ECMAScriptCode]] | a | The result of parsing the source text of this module using |
| [[Context]] | An ECMAScript | The |
| [[ImportMeta]] | Object | An object exposed through theimport.meta meta property. It is |
| [[ImportEntries]] | A | |
| [[LocalExportEntries]] | A | |
| [[IndirectExportEntries]] | Aexport * as namespace declarations. | |
| [[StarExportEntries]] | Aexport * declarations that occur within the module, not includingexport * as namespace declarations. |
AnImportEntry Record is a
| Field Name | Value Type | Meaning |
|---|---|---|
| [[ModuleRequest]] | String | String value of the |
| [[ImportName]] | String | The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. The value |
| [[LocalName]] | String | The name that is used to locally access the imported value from within the importing module. |
| Import Statement Form | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|
import v from "mod"; | |||
import * as ns from "mod"; | |||
import {x} from "mod"; | |||
import {x as v} from "mod"; | |||
import "mod"; | An | ||
AnExportEntry Record is a
| Field Name | Value Type | Meaning |
|---|---|---|
| [[ExportName]] | String | null | The name used to export this binding by this module. |
| [[ModuleRequest]] | String | null | The String value of the |
| [[ImportName]] | String | null | The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. |
| [[LocalName]] | String | null | The name that is used to locally access the exported value from within the importing module. |
| Export Statement Form | [[ExportName]] | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
|---|---|---|---|---|
export var v; | ||||
export default function f() {} | ||||
export default function () {} | ||||
export default 42; | ||||
export {x}; | ||||
export {v as x}; | ||||
export {x} from "mod"; | ||||
export {v as x} from "mod"; | ||||
export * from "mod"; | ||||
export * as ns from "mod"; |
The following definitions specify the required concrete methods and other
16.2.1.6.1 ParseModule (sourceText,realm,hostDefined )
The abstract operation ParseModule takes argumentssourceText (ECMAScript source text),realm, andhostDefined. It creates a
Assert :sourceText is an ECMAScript source text (see clause11 ).- Letbody be
ParseText (sourceText,Module ). - Ifbody is a
List of errors, returnbody. - LetrequestedModules be the
ModuleRequests ofbody. - LetimportEntries be
ImportEntries ofbody. - LetimportedBoundNames be
ImportedLocalNames (importEntries). - LetindirectExportEntries be a new empty
List . - LetlocalExportEntries be a new empty
List . - LetstarExportEntries be a new empty
List . - LetexportEntries be
ExportEntries ofbody. - For each
ExportEntry Record ee ofexportEntries, do- Ifee.[[ModuleRequest]] is
null , then- Ifee.[[LocalName]] is not an element ofimportedBoundNames, then
- Appendee tolocalExportEntries.
- Else,
- Letie be the element ofimportEntries whose [[LocalName]] is the same asee.[[LocalName]].
- Ifie.[[ImportName]] is
"*" , then- NOTE: This is a re-export of an imported module namespace object.
- Appendee tolocalExportEntries.
- Else,
- NOTE: This is a re-export of a single name.
- Append the
ExportEntry Record { [[ModuleRequest]]:ie.[[ModuleRequest]], [[ImportName]]:ie.[[ImportName]], [[LocalName]]:null , [[ExportName]]:ee.[[ExportName]] } toindirectExportEntries.
- Ifee.[[LocalName]] is not an element ofimportedBoundNames, then
- Else ifee.[[ImportName]] is
"*" andee.[[ExportName]] isnull , then- Appendee tostarExportEntries.
- Else,
- Appendee toindirectExportEntries.
- Ifee.[[ModuleRequest]] is
- Return
Source Text Module Record { [[Realm]]:realm, [[Environment]]:undefined , [[Namespace]]:undefined , [[Status]]:unlinked , [[EvaluationError]]:undefined , [[HostDefined]]:hostDefined, [[ECMAScriptCode]]:body, [[Context]]:empty , [[ImportMeta]]:empty , [[RequestedModules]]:requestedModules, [[ImportEntries]]:importEntries, [[LocalExportEntries]]:localExportEntries, [[IndirectExportEntries]]:indirectExportEntries, [[StarExportEntries]]:starExportEntries, [[DFSIndex]]:undefined , [[DFSAncestorIndex]]:undefined }.
An implementation may parse module source text and analyse it for Early Error conditions prior to the evaluation of ParseModule for that module source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that source text.
16.2.1.6.2 GetExportedNames ( [exportStarSet ] ) Concrete Method
The GetExportedNames concrete method of a
- IfexportStarSet is not present, setexportStarSet to a new empty
List . Assert :exportStarSet is aList of Source Text Module Records.- IfexportStarSet containsmodule, then
- Appendmodule toexportStarSet.
- LetexportedNames be a new empty
List . - For each
ExportEntry Record e ofmodule.[[LocalExportEntries]], doAssert :module provides the direct binding for this export.- Appende.[[ExportName]] toexportedNames.
- For each
ExportEntry Record e ofmodule.[[IndirectExportEntries]], doAssert :module imports a specific binding for this export.- Appende.[[ExportName]] toexportedNames.
- For each
ExportEntry Record e ofmodule.[[StarExportEntries]], do- LetrequestedModule be ?
HostResolveImportedModule (module,e.[[ModuleRequest]]). - LetstarNames be ?requestedModule.GetExportedNames(exportStarSet).
- For each elementn ofstarNames, do
- If
SameValue (n,"default" ) isfalse , then- Ifn is not an element ofexportedNames, then
- Appendn toexportedNames.
- Ifn is not an element ofexportedNames, then
- If
- LetrequestedModule be ?
- ReturnexportedNames.
GetExportedNames does not filter out or throw an exception for names that have ambiguous star export bindings.
16.2.1.6.3 ResolveExport (exportName [ ,resolveSet ] ) Concrete Method
The ResolveExport concrete method of a
ResolveExport attempts to resolve an imported binding to the actual defining module and local binding name. The defining module may be the module represented by the
If a defining module is found, a
This concrete method performs the following steps when called:
- IfresolveSet is not present, setresolveSet to a new empty
List . Assert :resolveSet is aList ofRecord { [[Module]], [[ExportName]] }.- For each
Record { [[Module]], [[ExportName]] }r ofresolveSet, do- Ifmodule andr.[[Module]] are the same
Module Record andSameValue (exportName,r.[[ExportName]]) istrue , thenAssert : This is a circular import request.- Return
null .
- Ifmodule andr.[[Module]] are the same
- Append the
Record { [[Module]]:module, [[ExportName]]:exportName } toresolveSet. - For each
ExportEntry Record e ofmodule.[[LocalExportEntries]], do- If
SameValue (exportName,e.[[ExportName]]) istrue , thenAssert :module provides the direct binding for this export.- Return
ResolvedBinding Record { [[Module]]:module, [[BindingName]]:e.[[LocalName]] }.
- If
- For each
ExportEntry Record e ofmodule.[[IndirectExportEntries]], do- If
SameValue (exportName,e.[[ExportName]]) istrue , then- LetimportedModule be ?
HostResolveImportedModule (module,e.[[ModuleRequest]]). - Ife.[[ImportName]] is
"*" , thenAssert :module does not provide the direct binding for this export.- Return
ResolvedBinding Record { [[Module]]:importedModule, [[BindingName]]:"*namespace*" }.
- Else,
Assert :module imports a specific binding for this export.- ReturnimportedModule.ResolveExport(e.[[ImportName]],resolveSet).
- LetimportedModule be ?
- If
- If
SameValue (exportName,"default" ) istrue , thenAssert : Adefaultexport was not explicitly defined by this module.- Return
null . - NOTE: A
defaultexport cannot be provided by anexport *orexport * from "mod"declaration.
- LetstarResolution be
null . - For each
ExportEntry Record e ofmodule.[[StarExportEntries]], do- LetimportedModule be ?
HostResolveImportedModule (module,e.[[ModuleRequest]]). - Letresolution be ?importedModule.ResolveExport(exportName,resolveSet).
- Ifresolution is
"ambiguous" , return"ambiguous" . - Ifresolution is not
null , thenAssert :resolution is aResolvedBinding Record .- IfstarResolution is
null , setstarResolution toresolution. - Else,
Assert : There is more than one*import that includes the requested name.- Ifresolution.[[Module]] andstarResolution.[[Module]] are not the same
Module Record orSameValue (resolution.[[BindingName]],starResolution.[[BindingName]]) isfalse , return"ambiguous" .
- LetimportedModule be ?
- ReturnstarResolution.
16.2.1.6.4 InitializeEnvironment ( ) Concrete Method
The InitializeEnvironment concrete method of a
- For each
ExportEntry Record e ofmodule.[[IndirectExportEntries]], do- Letresolution be ?module.ResolveExport(e.[[ExportName]]).
- Ifresolution is
null or"ambiguous" , throw aSyntaxError exception. Assert :resolution is aResolvedBinding Record .
Assert : All named exports frommodule are resolvable.- Letrealm bemodule.[[Realm]].
Assert :realm is notundefined .- Letenv be
NewModuleEnvironment (realm.[[GlobalEnv]]). - Setmodule.[[Environment]] toenv.
- For each
ImportEntry Record in ofmodule.[[ImportEntries]], do- LetimportedModule be !
HostResolveImportedModule (module,in.[[ModuleRequest]]). - NOTE: The above call cannot fail because imported module requests are a subset ofmodule.[[RequestedModules]], and these have been resolved earlier in this algorithm.
- Ifin.[[ImportName]] is
"*" , then- Letnamespace be ?
GetModuleNamespace (importedModule). - Perform !env.CreateImmutableBinding(in.[[LocalName]],
true ). - Callenv.InitializeBinding(in.[[LocalName]],namespace).
- Letnamespace be ?
- Else,
- Letresolution be ?importedModule.ResolveExport(in.[[ImportName]]).
- Ifresolution is
null or"ambiguous" , throw aSyntaxError exception. - Ifresolution.[[BindingName]] is
"*namespace*" , then- Letnamespace be ?
GetModuleNamespace (resolution.[[Module]]). - Perform !env.CreateImmutableBinding(in.[[LocalName]],
true ). - Callenv.InitializeBinding(in.[[LocalName]],namespace).
- Letnamespace be ?
- Else,
- Callenv.CreateImportBinding(in.[[LocalName]],resolution.[[Module]],resolution.[[BindingName]]).
- LetimportedModule be !
- LetmoduleContext be a new ECMAScript code
execution context . - Set the Function ofmoduleContext to
null . Assert :module.[[Realm]] is notundefined .- Set the
Realm ofmoduleContext tomodule.[[Realm]]. - Set the ScriptOrModule ofmoduleContext tomodule.
- Set the VariableEnvironment ofmoduleContext tomodule.[[Environment]].
- Set the LexicalEnvironment ofmoduleContext tomodule.[[Environment]].
- Setmodule.[[Context]] tomoduleContext.
- PushmoduleContext onto the
execution context stack ;moduleContext is now therunning execution context . - Letcode bemodule.[[ECMAScriptCode]].
- LetvarDeclarations be the
VarScopedDeclarations ofcode. - LetdeclaredVarNames be a new empty
List . - For each elementd ofvarDeclarations, do
- For each elementdn of the
BoundNames ofd, do- Ifdn is not an element ofdeclaredVarNames, then
- Perform !env.CreateMutableBinding(dn,
false ). - Callenv.InitializeBinding(dn,
undefined ). - Appenddn todeclaredVarNames.
- Perform !env.CreateMutableBinding(dn,
- Ifdn is not an element ofdeclaredVarNames, then
- For each elementdn of the
- LetlexDeclarations be the
LexicallyScopedDeclarations ofcode. - For each elementd oflexDeclarations, do
- For each elementdn of the
BoundNames ofd, do- If
IsConstantDeclaration ofd istrue , then- Perform !env.CreateImmutableBinding(dn,
true ).
- Perform !env.CreateImmutableBinding(dn,
- Else,
- Perform !env.CreateMutableBinding(dn,
false ).
- Perform !env.CreateMutableBinding(dn,
- Ifd is a
FunctionDeclaration , aGeneratorDeclaration , anAsyncFunctionDeclaration , or anAsyncGeneratorDeclaration , then- Letfo be
InstantiateFunctionObject ofd with argumentenv. - Callenv.InitializeBinding(dn,fo).
- Letfo be
- If
- For each elementdn of the
- RemovemoduleContext from the
execution context stack . - Return
NormalCompletion (empty ).
16.2.1.6.5 ExecuteModule ( ) Concrete Method
The ExecuteModule concrete method of a
Suspend the currentlyrunning execution context .- LetmoduleContext bemodule.[[Context]].
- PushmoduleContext onto the
execution context stack ;moduleContext is now therunning execution context . - Letresult be the result of evaluatingmodule.[[ECMAScriptCode]].
Suspend moduleContext and remove it from theexecution context stack .- Resume the context that is now on the top of the
execution context stack as therunning execution context . - Return
Completion (result).
16.2.1.7 HostResolveImportedModule (referencingScriptOrModule,specifier )
Theimport()
An example of whenreferencingScriptOrModule can be
<buttontype="button"onclick="import('./foo.mjs')">Click me</button>there will be noimport()
The implementation of HostResolveImportedModule must conform to the following requirements:
- The normal return value must be an instance of a concrete subclass of
Module Record . - If a
Module Record corresponding to the pairreferencingScriptOrModule,specifier does not exist or cannot be created, an exception must be thrown. - Each time this operation is called with a specificreferencingScriptOrModule,specifier pair as arguments it must return the same
Module Record instance if it completes normally.
Multiple differentreferencingScriptOrModule,specifier pairs may map to the same
16.2.1.8 HostImportModuleDynamically (referencingScriptOrModule,specifier,promiseCapability )
Theimport()
The implementation of HostImportModuleDynamically must conform to the following requirements:
- The abstract operation must always complete normally with
undefined . Success or failure must instead be signaled as discussed below. - The
host environment must conform to one of the two following sets of requirements:- Success path
- At some future time, the
host environment must performFinishDynamicImport (referencingScriptOrModule,specifier,promiseCapability,NormalCompletion (undefined )). - Any subsequent call to
HostResolveImportedModule afterFinishDynamicImport has completed, given the argumentsreferencingScriptOrModule andspecifier, must complete normally. - The completion value of any subsequent call to
HostResolveImportedModule afterFinishDynamicImport has completed, given the argumentsreferencingScriptOrModule andspecifier, must be a module which has already been evaluated, i.e. whose Evaluate concrete method has already been called and returned a normal completion.
- At some future time, the
- Failure path
- At some future time, the
host environment must performFinishDynamicImport (referencingScriptOrModule,specifier,promiseCapability, anabrupt completion ), with theabrupt completion representing the cause of failure.
- At some future time, the
- If the
host environment takes the success path once for a givenreferencingScriptOrModule,specifier pair, it must always do so for subsequent calls. - The operation must not callpromiseCapability.[[Resolve]] orpromiseCapability.[[Reject]], but instead must treatpromiseCapability as an opaque identifying value to be passed through to
FinishDynamicImport .
The actual process performed is
16.2.1.9 FinishDynamicImport (referencingScriptOrModule,specifier,promiseCapability,completion )
The abstract operation FinishDynamicImport takes argumentsreferencingScriptOrModule,specifier,promiseCapability (aimport()
- Ifcompletion is an
abrupt completion , perform !Call (promiseCapability.[[Reject]],undefined , «completion.[[Value]] »). - Else,
Assert :completion is a normal completion andcompletion.[[Value]] isundefined .- LetmoduleRecord be !
HostResolveImportedModule (referencingScriptOrModule,specifier). Assert : Evaluate has already been invoked onmoduleRecord and successfully completed.- Letnamespace be
GetModuleNamespace (moduleRecord). - Ifnamespace is an
abrupt completion , perform !Call (promiseCapability.[[Reject]],undefined , «namespace.[[Value]] »). - Else, perform !
Call (promiseCapability.[[Resolve]],undefined , «namespace.[[Value]] »).
16.2.1.10 GetModuleNamespace (module )
The abstract operation GetModuleNamespace takes argumentmodule. It retrieves the Module Namespace Object representingmodule's exports, lazily creating it the first time it was requested, and storing it inmodule.[[Namespace]] for future retrieval. It performs the following steps when called:
Assert :module is an instance of a concrete subclass ofModule Record .Assert : Ifmodule is aCyclic Module Record , thenmodule.[[Status]] is notunlinked .- Letnamespace bemodule.[[Namespace]].
- Ifnamespace is
undefined , then- LetexportedNames be ?module.GetExportedNames().
- LetunambiguousNames be a new empty
List . - For each elementname ofexportedNames, do
- Letresolution be ?module.ResolveExport(name).
- Ifresolution is a
ResolvedBinding Record , appendname tounambiguousNames.
- Setnamespace to
ModuleNamespaceCreate (module,unambiguousNames).
- Returnnamespace.
The only way GetModuleNamespace can throw is via one of the triggered
16.2.1.11 Runtime Semantics: Evaluation
- Return
NormalCompletion (undefined ).
- Letresult be the result of evaluating
ModuleItemList . - Ifresult.[[Type]] is
normal andresult.[[Value]] isempty , then- Return
NormalCompletion (undefined ).
- Return
- Return
Completion (result).
- Letsl be the result of evaluating
ModuleItemList . ReturnIfAbrupt (sl).- Lets be the result of evaluating
ModuleItem . - Return
Completion (UpdateEmpty (s,sl)).
The value of a
- Return
NormalCompletion (empty ).
16.2.2 Imports
Syntax
16.2.2.1 Static Semantics: Early Errors
- It is a Syntax Error if the
BoundNames ofImportDeclaration contains any duplicate entries.
16.2.2.2 Static Semantics: ImportEntries
- Return a new empty
List .
- Letentries be
ImportEntries ofModuleItemList . - Append toentries the elements of the
ImportEntries ofModuleItem . - Returnentries.
- Return a new empty
List .
- Letmodule be the sole element of
ModuleRequests ofFromClause . - Return
ImportEntriesForModule ofImportClause with argumentmodule.
- Return a new empty
List .
16.2.2.3 Static Semantics: ImportEntriesForModule
With parametermodule.
- Letentries be
ImportEntriesForModule ofImportedDefaultBinding with argumentmodule. - Append toentries the elements of the
ImportEntriesForModule ofNameSpaceImport with argumentmodule. - Returnentries.
- Letentries be
ImportEntriesForModule ofImportedDefaultBinding with argumentmodule. - Append toentries the elements of the
ImportEntriesForModule ofNamedImports with argumentmodule. - Returnentries.
- LetlocalName be the sole element of
BoundNames ofImportedBinding . - LetdefaultEntry be the
ImportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:"default" , [[LocalName]]:localName }. - Return a
List whose sole element isdefaultEntry.
- LetlocalName be the
StringValue ofImportedBinding . - Letentry be the
ImportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:"*" , [[LocalName]]:localName }. - Return a
List whose sole element isentry.
- Return a new empty
List .
- Letspecs be the
ImportEntriesForModule ofImportsList with argumentmodule. - Append tospecs the elements of the
ImportEntriesForModule ofImportSpecifier with argumentmodule. - Returnspecs.
- LetlocalName be the sole element of
BoundNames ofImportedBinding . - Letentry be the
ImportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:localName, [[LocalName]]:localName }. - Return a
List whose sole element isentry.
- LetimportName be the
StringValue ofIdentifierName . - LetlocalName be the
StringValue ofImportedBinding . - Letentry be the
ImportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:importName, [[LocalName]]:localName }. - Return a
List whose sole element isentry.
16.2.3 Exports
Syntax
16.2.3.1 Static Semantics: Early Errors
- For each
IdentifierName n inReferencedBindings ofNamedExports : It is a Syntax Error ifStringValue ofn is aReservedWord or if theStringValue ofn is one of:"implements" ,"interface" ,"let" ,"package" ,"private" ,"protected" ,"public" , or"static" .
The above rule means that each
16.2.3.2 Static Semantics: ExportedBindings
ExportedBindings are the locally bound names that are explicitly associated with a
- Letnames be
ExportedBindings ofModuleItemList . - Append tonames the elements of the
ExportedBindings ofModuleItem . - Returnnames.
- Return a new empty
List .
- Return a new empty
List .
- Return the
ExportedBindings ofNamedExports .
- Return the
BoundNames ofVariableStatement .
- Return the
BoundNames ofDeclaration .
- Return the
BoundNames of thisExportDeclaration .
- Return a new empty
List .
- Letnames be the
ExportedBindings ofExportsList . - Append tonames the elements of the
ExportedBindings ofExportSpecifier . - Returnnames.
- Return a
List whose sole element is theStringValue ofIdentifierName .
- Return a
List whose sole element is theStringValue of the firstIdentifierName .
16.2.3.3 Static Semantics: ExportedNames
ExportedNames are the externally visible names that a
- Letnames be
ExportedNames ofModuleItemList . - Append tonames the elements of the
ExportedNames ofModuleItem . - Returnnames.
- Return the
ExportedNames ofExportDeclaration .
- Return a new empty
List .
- Return the
ExportedNames ofExportFromClause .
- Return a new empty
List .
- Return a
List whose sole element is theStringValue ofIdentifierName .
- Return the
ExportedNames ofNamedExports .
- Return the
BoundNames ofVariableStatement .
- Return the
BoundNames ofDeclaration .
- Return «
"default" ».
- Return a new empty
List .
- Letnames be the
ExportedNames ofExportsList . - Append tonames the elements of the
ExportedNames ofExportSpecifier . - Returnnames.
- Return a
List whose sole element is theStringValue ofIdentifierName .
- Return a
List whose sole element is theStringValue of the secondIdentifierName .
16.2.3.4 Static Semantics: ExportEntries
- Return a new empty
List .
- Letentries be
ExportEntries ofModuleItemList . - Append toentries the elements of the
ExportEntries ofModuleItem . - Returnentries.
- Return a new empty
List .
- Letmodule be the sole element of
ModuleRequests ofFromClause . - Return
ExportEntriesForModule ofExportFromClause with argumentmodule.
- Return
ExportEntriesForModule ofNamedExports with argumentnull .
- Letentries be a new empty
List . - Letnames be the
BoundNames ofVariableStatement . - For each elementname ofnames, do
- Append the
ExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]:name, [[ExportName]]:name } toentries.
- Append the
- Returnentries.
- Letentries be a new empty
List . - Letnames be the
BoundNames ofDeclaration . - For each elementname ofnames, do
- Append the
ExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]:name, [[ExportName]]:name } toentries.
- Append the
- Returnentries.
- Letnames be
BoundNames ofHoistableDeclaration . - LetlocalName be the sole element ofnames.
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]:localName, [[ExportName]]:"default" }.
- Letnames be
BoundNames ofClassDeclaration . - LetlocalName be the sole element ofnames.
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]:localName, [[ExportName]]:"default" }.
- Letentry be the
ExportEntry Record { [[ModuleRequest]]:null , [[ImportName]]:null , [[LocalName]]:"*default*" , [[ExportName]]:"default" }. - Return a
List whose sole element isentry.
16.2.3.5 Static Semantics: ExportEntriesForModule
With parametermodule.
- Letentry be the
ExportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:"*" , [[LocalName]]:null , [[ExportName]]:null }. - Return a
List whose sole element isentry.
- LetexportName be the
StringValue ofIdentifierName . - Letentry be the
ExportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:"*" , [[LocalName]]:null , [[ExportName]]:exportName }. - Return a
List whose sole element isentry.
- Return a new empty
List .
- Letspecs be the
ExportEntriesForModule ofExportsList with argumentmodule. - Append tospecs the elements of the
ExportEntriesForModule ofExportSpecifier with argumentmodule. - Returnspecs.
- LetsourceName be the
StringValue ofIdentifierName . - Ifmodule is
null , then- LetlocalName besourceName.
- LetimportName be
null .
- Else,
- LetlocalName be
null . - LetimportName besourceName.
- LetlocalName be
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:importName, [[LocalName]]:localName, [[ExportName]]:sourceName }.
- LetsourceName be the
StringValue of the firstIdentifierName . - LetexportName be the
StringValue of the secondIdentifierName . - Ifmodule is
null , then- LetlocalName besourceName.
- LetimportName be
null .
- Else,
- LetlocalName be
null . - LetimportName besourceName.
- LetlocalName be
- Return a
List whose sole element is theExportEntry Record { [[ModuleRequest]]:module, [[ImportName]]:importName, [[LocalName]]:localName, [[ExportName]]:exportName }.
16.2.3.6 Static Semantics: ReferencedBindings
- Return a new empty
List .
- Letnames be the
ReferencedBindings ofExportsList . - Append tonames the elements of the
ReferencedBindings ofExportSpecifier . - Returnnames.
- Return a
List whose sole element is theIdentifierName .
- Return a
List whose sole element is the firstIdentifierName .
16.2.3.7 Runtime Semantics: Evaluation
- Return
NormalCompletion (empty ).
- Return the result of evaluating
VariableStatement .
- Return the result of evaluating
Declaration .
- Return the result of evaluating
HoistableDeclaration .
- Letvalue be ?
BindingClassDeclarationEvaluation ofClassDeclaration . - LetclassName be the sole element of
BoundNames ofClassDeclaration . - IfclassName is
"*default*" , then- Letenv be the
running execution context 's LexicalEnvironment. - Perform ?
InitializeBoundName ("*default*" ,value,env).
- Letenv be the
- Return
NormalCompletion (empty ).
- If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue , then- Letvalue be ?
NamedEvaluation ofAssignmentExpression with argument"default" .
- Letvalue be ?
- Else,
- Letrhs be the result of evaluating
AssignmentExpression . - Letvalue be ?
GetValue (rhs).
- Letrhs be the result of evaluating
- Letenv be the
running execution context 's LexicalEnvironment. - Perform ?
InitializeBoundName ("*default*" ,value,env). - Return
NormalCompletion (empty ).
17 Error Handling and Language Extensions
An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. Anearly error is an error that can be detected and reported prior to the evaluation of any construct in theeval is called and prevent evaluation of theeval code. All errors that are not early errors are runtime errors.
An implementation must report as an
An implementation shall not treat other kinds of errors as early errors even if the compiler can prove that a construct cannot execute without error under any circumstances. An implementation may issue an early warning in such a case, but it should not report the error until the relevant construct is actually executed.
An implementation shall report all errors as specified, except for the following:
- Except as restricted in
17.1 , ahost or implementation may extendScript syntax,Module syntax, and regular expression pattern or flag syntax. To permit this, all operations (such as callingeval, using a regular expression literal, or using the Function or RegExpconstructor ) that are allowed to throwSyntaxError are permitted to exhibithost-defined behaviour instead of throwingSyntaxError when they encounter ahost-defined extension to the script syntax or regular expression pattern or flag syntax. - Except as restricted in
17.1 , ahost or implementation may provide additional types, values, objects, properties, and functions beyond those described in this specification. This may cause constructs (such as looking up a variable in the global scope) to havehost-defined behaviour instead of throwing an error (such asReferenceError ).
17.1 Forbidden Extensions
An implementation must not extend this specification in the following ways:
- ECMAScript function objects defined using syntactic constructors in
strict mode code must not be created with own properties named"caller" or"arguments" . Such own properties also must not be created for function objects defined using anArrowFunction ,MethodDefinition ,GeneratorDeclaration ,GeneratorExpression ,AsyncGeneratorDeclaration ,AsyncGeneratorExpression ,ClassDeclaration ,ClassExpression ,AsyncFunctionDeclaration ,AsyncFunctionExpression , orAsyncArrowFunction regardless of whether the definition is contained instrict mode code . Built-in functions, strict functions created using the Functionconstructor , generator functions created using the Generatorconstructor , async functions created using the AsyncFunctionconstructor , and functions created using thebindmethod also must not be created with such own properties. - If an implementation extends any
function object with an own property named"caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be astrict function object. If it is anaccessor property , the function that is the value of the property's [[Get]] attribute must never return astrict function when called. - Neither mapped nor unmapped arguments objects may be created with an own property named
"caller" . - The behaviour of built-in methods which are specified in ECMA-402, such as those named
toLocaleString, must not be extended except as specified in ECMA-402. - The RegExp pattern grammars in
22.2.1 andB.1.4 must not be extended to recognize any of the source characters A-Z or a-z asIdentityEscape when the[U] grammar parameter is present.[+U] - The Syntactic Grammar must not be extended in any manner that allows the token
:to immediately follow source text that matches theBindingIdentifier nonterminal symbol. - When processing
strict mode code , the syntax ofNumericLiteral must not be extended to includeLegacyOctalIntegerLiteral DecimalIntegerLiteral must not be extended to includeNonOctalDecimalIntegerLiteral B.1.1 . TemplateCharacter must not be extended to includeLegacyOctalEscapeSequence NonOctalDecimalEscapeSequence B.1.2 .- When processing
strict mode code , the extensions defined inB.3.2 ,B.3.3 ,B.3.4 , andB.3.6 must not be supported. - When parsing for the
Module goal symbol , the lexical grammar extensions defined inB.1.3 must not be supported. ImportCall must not be extended.
18 ECMAScript Standard Built-in Objects
There are certain built-in objects available whenever an ECMAScript
Unless specified otherwise, a built-in object that is callable as a function is a built-in
Many built-in objects are functions: they can be invoked with arguments. Some of them furthermore are constructors: they are functions intended for use with thenew operator. For each built-in function, this specification describes the arguments required by that function and the properties of thatnew expression that invokes that
Unless otherwise specified in the description of a particular function, if a built-in function or
Unless otherwise specified in the description of a particular function, if a built-in function or
Implementations that add additional capabilities to the set of built-in functions are encouraged to do so by adding new functions rather than adding new parameters to existing functions.
Unless otherwise specified every built-in function and every built-inFunction.prototype (
Unless otherwise specified every built-in prototype object has theObject.prototype (
Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function.
Each built-in function defined in this specification is created by calling the
Every built-in
For example, the
Unless otherwise specified, the
Every built-in
The value of the
Unless otherwise specified, the
Every other
Every
19 The Global Object
Theglobal object:
- is created before control enters any
execution context . - does not have a [[Construct]] internal method; it cannot be used as a
constructor with thenewoperator. - does not have a [[Call]] internal method; it cannot be invoked as a function.
- has a [[Prototype]] internal slot whose value is
host-defined . - may have
host defined properties in addition to the properties defined in this specification. This may include a property whose value is the global object itself.
19.1 Value Properties of the Global Object
19.1.1 globalThis
The initial value of the
This property has the attributes { [[Writable]]:
19.1.2 Infinity
The value ofInfinity is
19.1.3 NaN
The value ofNaN is
19.1.4 undefined
The value ofundefined is
19.2 Function Properties of the Global Object
19.2.1 eval (x )
Theeval function is the%eval% intrinsic object. When theeval function is called with one argumentx, the following steps are taken:
Assert : Theexecution context stack has at least two elements.- LetcallerContext be the second to top element of the
execution context stack . - LetcallerRealm becallerContext's
Realm . - Return ?
PerformEval (x,callerRealm,false ,false ).
19.2.1.1 PerformEval (x,callerRealm,strictCaller,direct )
The abstract operation PerformEval takes argumentsx,callerRealm,strictCaller, anddirect. It performs the following steps when called:
Assert : Ifdirect isfalse , thenstrictCaller is alsofalse .- If
Type (x) is not String, returnx. - LetevalRealm be
the current Realm Record . - Perform ?
HostEnsureCanCompileStrings (callerRealm,evalRealm). - LetinFunction be
false . - LetinMethod be
false . - LetinDerivedConstructor be
false . - Ifdirect is
true , then- LetthisEnvRec be !
GetThisEnvironment (). - IfthisEnvRec is a
function Environment Record , then- LetF bethisEnvRec.[[FunctionObject]].
- SetinFunction to
true . - SetinMethod tothisEnvRec.HasSuperBinding().
- IfF.[[ConstructorKind]] is
derived , setinDerivedConstructor totrue .
- LetthisEnvRec be !
- Perform the following substeps in an
implementation-defined order, possibly interleaving parsing and error detection:- Letscript be
ParseText (!StringToCodePoints (x),Script ). - Ifscript is a
List of errors, throw aSyntaxError exception. - Ifscript
Contains ScriptBody isfalse , returnundefined . - Letbody be the
ScriptBody ofscript. - IfinFunction is
false , andbodyContains NewTarget , throw aSyntaxError exception. - IfinMethod is
false , andbodyContains SuperProperty , throw aSyntaxError exception. - IfinDerivedConstructor is
false , andbodyContains SuperCall , throw aSyntaxError exception.
- Letscript be
- IfstrictCaller is
true , letstrictEval betrue . - Else, letstrictEval be
IsStrict ofscript. - LetrunningContext be the
running execution context . - NOTE: Ifdirect is
true ,runningContext will be theexecution context that performed thedirect eval . Ifdirect isfalse ,runningContext will be theexecution context for the invocation of theevalfunction. - Ifdirect is
true , then- LetlexEnv be
NewDeclarativeEnvironment (runningContext's LexicalEnvironment). - LetvarEnv berunningContext's VariableEnvironment.
- LetlexEnv be
- Else,
- LetlexEnv be
NewDeclarativeEnvironment (evalRealm.[[GlobalEnv]]). - LetvarEnv beevalRealm.[[GlobalEnv]].
- LetlexEnv be
- IfstrictEval is
true , setvarEnv tolexEnv. - IfrunningContext is not already suspended, suspendrunningContext.
- LetevalContext be a new ECMAScript code
execution context . - SetevalContext's Function to
null . - SetevalContext's
Realm toevalRealm. - SetevalContext's ScriptOrModule torunningContext's ScriptOrModule.
- SetevalContext's VariableEnvironment tovarEnv.
- SetevalContext's LexicalEnvironment tolexEnv.
- PushevalContext onto the
execution context stack ;evalContext is now therunning execution context . - Letresult be
EvalDeclarationInstantiation (body,varEnv,lexEnv,strictEval). - Ifresult.[[Type]] is
normal , then- Setresult to the result of evaluatingbody.
- Ifresult.[[Type]] is
normal andresult.[[Value]] isempty , then- Setresult to
NormalCompletion (undefined ).
- Setresult to
Suspend evalContext and remove it from theexecution context stack .- Resume the context that is now on the top of the
execution context stack as therunning execution context . - Return
Completion (result).
The eval code cannot instantiate variable or function bindings in the variable environment of the calling context that invoked the eval if the calling context is evaluating formal parameter initializers or if either the code of the calling context or the eval code islet,const, orclass declarations are always instantiated in a new LexicalEnvironment.
19.2.1.2 HostEnsureCanCompileStrings (callerRealm,calleeRealm )
The
An implementation of HostEnsureCanCompileStrings may complete normally or abruptly. Any abrupt completions will be propagated to its callers. The default implementation of HostEnsureCanCompileStrings is to unconditionally return an empty normal completion.
19.2.1.3 EvalDeclarationInstantiation (body,varEnv,lexEnv,strict )
The abstract operation EvalDeclarationInstantiation takes argumentsbody,varEnv,lexEnv, andstrict. It performs the following steps when called:
- LetvarNames be the
VarDeclaredNames ofbody. - LetvarDeclarations be the
VarScopedDeclarations ofbody. - Ifstrict is
false , then- IfvarEnv is a
global Environment Record , then- For each elementname ofvarNames, do
- IfvarEnv.HasLexicalDeclaration(name) is
true , throw aSyntaxError exception. - NOTE:
evalwill not create a global var declaration that would be shadowed by a global lexical declaration.
- IfvarEnv.HasLexicalDeclaration(name) is
- For each elementname ofvarNames, do
- LetthisEnv belexEnv.
Assert : The following loop will terminate.- Repeat, whilethisEnv is not the same asvarEnv,
- IfthisEnv is not an
object Environment Record , then- NOTE: The environment of with statements cannot contain any lexical declaration so it doesn't need to be checked for var/let hoisting conflicts.
- For each elementname ofvarNames, do
- IfthisEnv.HasBinding(name) is
true , then- Throw a
SyntaxError exception. - NOTE: Annex
B.3.5 defines alternate semantics for the above step.
- Throw a
- NOTE: A
direct eval will not hoist var declaration over a like-named lexical declaration.
- IfthisEnv.HasBinding(name) is
- SetthisEnv tothisEnv.[[OuterEnv]].
- IfthisEnv is not an
- IfvarEnv is a
- LetfunctionsToInitialize be a new empty
List . - LetdeclaredFunctionNames be a new empty
List . - For each elementd ofvarDeclarations, in reverse
List order, do- Ifd is neither a
VariableDeclaration nor aForBinding nor aBindingIdentifier , thenAssert :d is either aFunctionDeclaration , aGeneratorDeclaration , anAsyncFunctionDeclaration , or anAsyncGeneratorDeclaration .- NOTE: If there are multiple function declarations for the same name, the last declaration is used.
- Letfn be the sole element of the
BoundNames ofd. - Iffn is not an element ofdeclaredFunctionNames, then
- IfvarEnv is a
global Environment Record , then- LetfnDefinable be ?varEnv.CanDeclareGlobalFunction(fn).
- IffnDefinable is
false , throw aTypeError exception.
- Appendfn todeclaredFunctionNames.
- Insertd as the first element offunctionsToInitialize.
- IfvarEnv is a
- Ifd is neither a
- NOTE: Annex
B.3.3.3 adds additional steps at this point. - LetdeclaredVarNames be a new empty
List . - For each elementd ofvarDeclarations, do
- Ifd is a
VariableDeclaration , aForBinding , or aBindingIdentifier , then- For each Stringvn of the
BoundNames ofd, do- Ifvn is not an element ofdeclaredFunctionNames, then
- IfvarEnv is a
global Environment Record , then- LetvnDefinable be ?varEnv.CanDeclareGlobalVar(vn).
- IfvnDefinable is
false , throw aTypeError exception.
- Ifvn is not an element ofdeclaredVarNames, then
- Appendvn todeclaredVarNames.
- IfvarEnv is a
- Ifvn is not an element ofdeclaredFunctionNames, then
- For each Stringvn of the
- Ifd is a
- NOTE: No abnormal terminations occur after this algorithm step unlessvarEnv is a
global Environment Record and theglobal object is aProxy exotic object . - LetlexDeclarations be the
LexicallyScopedDeclarations ofbody. - For each elementd oflexDeclarations, do
- NOTE: Lexically declared names are only instantiated here but not initialized.
- For each elementdn of the
BoundNames ofd, do- If
IsConstantDeclaration ofd istrue , then- Perform ?lexEnv.CreateImmutableBinding(dn,
true ).
- Perform ?lexEnv.CreateImmutableBinding(dn,
- Else,
- Perform ?lexEnv.CreateMutableBinding(dn,
false ).
- Perform ?lexEnv.CreateMutableBinding(dn,
- If
- For each
Parse Node f offunctionsToInitialize, do- Letfn be the sole element of the
BoundNames off. - Letfo be
InstantiateFunctionObject off with argumentlexEnv. - IfvarEnv is a
global Environment Record , then- Perform ?varEnv.CreateGlobalFunctionBinding(fn,fo,
true ).
- Perform ?varEnv.CreateGlobalFunctionBinding(fn,fo,
- Else,
- LetbindingExists bevarEnv.HasBinding(fn).
- IfbindingExists is
false , then- Letstatus be !varEnv.CreateMutableBinding(fn,
true ). Assert :status is not anabrupt completion because of validation preceding step10 .- Perform !varEnv.InitializeBinding(fn,fo).
- Letstatus be !varEnv.CreateMutableBinding(fn,
- Else,
- Perform !varEnv.SetMutableBinding(fn,fo,
false ).
- Perform !varEnv.SetMutableBinding(fn,fo,
- Letfn be the sole element of the
- For each Stringvn ofdeclaredVarNames, do
- IfvarEnv is a
global Environment Record , then- Perform ?varEnv.CreateGlobalVarBinding(vn,
true ).
- Perform ?varEnv.CreateGlobalVarBinding(vn,
- Else,
- LetbindingExists bevarEnv.HasBinding(vn).
- IfbindingExists is
false , then- Letstatus be !varEnv.CreateMutableBinding(vn,
true ). Assert :status is not anabrupt completion because of validation preceding step10 .- Perform !varEnv.InitializeBinding(vn,
undefined ).
- Letstatus be !varEnv.CreateMutableBinding(vn,
- IfvarEnv is a
- Return
NormalCompletion (empty ).
An alternative version of this algorithm is described in
19.2.2 isFinite (number )
TheisFinite function is the%isFinite% intrinsic object. When theisFinite function is called with one argumentnumber, the following steps are taken:
- Letnum be ?
ToNumber (number). - Ifnum is
NaN ,+∞ 𝔽, or-∞ 𝔽, returnfalse . - Otherwise, return
true .
19.2.3 isNaN (number )
TheisNaN function is the%isNaN% intrinsic object. When theisNaN function is called with one argumentnumber, the following steps are taken:
- Letnum be ?
ToNumber (number). - Ifnum is
NaN , returntrue . - Otherwise, return
false .
A reliable way for ECMAScript code to test if a valueX is aX !== X. The result will beX is a
19.2.4 parseFloat (string )
TheparseFloat function produces a
TheparseFloat function is the%parseFloat% intrinsic object. When theparseFloat function is called with one argumentstring, the following steps are taken:
- LetinputString be ?
ToString (string). - LettrimmedString be !
TrimString (inputString,start ). - If neithertrimmedString nor any prefix oftrimmedString satisfies the syntax of a
StrDecimalLiteral (see7.1.4.1 ), returnNaN . - LetnumberString be the longest prefix oftrimmedString, which might betrimmedString itself, that satisfies the syntax of a
StrDecimalLiteral . - LetmathFloat be MV ofnumberString.
- IfmathFloat = 0, then
- If the first code unit oftrimmedString is the code unit 0x002D (HYPHEN-MINUS), return
-0 𝔽. - Return
+0 𝔽.
- If the first code unit oftrimmedString is the code unit 0x002D (HYPHEN-MINUS), return
- Return
𝔽 (mathFloat).
parseFloat may interpret only a leading portion ofstring as a
19.2.5 parseInt (string,radix )
TheparseInt function produces an0x or0X, in which case a radix of 16 is assumed. Ifradix is 16, the number may also optionally begin with the code unit pairs0x or0X.
TheparseInt function is the%parseInt% intrinsic object. When theparseInt function is called, the following steps are taken:
- LetinputString be ?
ToString (string). - LetS be !
TrimString (inputString,start ). - Letsign be 1.
- IfS is not empty and the first code unit ofS is the code unit 0x002D (HYPHEN-MINUS), setsign to -1.
- IfS is not empty and the first code unit ofS is the code unit 0x002B (PLUS SIGN) or the code unit 0x002D (HYPHEN-MINUS), remove the first code unit fromS.
- LetR be
ℝ (?ToInt32 (radix)). - LetstripPrefix be
true . - IfR ≠ 0, then
- IfR < 2 orR > 36, return
NaN . - IfR ≠ 16, setstripPrefix to
false .
- IfR < 2 orR > 36, return
- Else,
- SetR to 10.
- IfstripPrefix is
true , then- If the length ofS is at least 2 and the first two code units ofS are either
"0x" or"0X" , then- Remove the first two code units fromS.
- SetR to 16.
- If the length ofS is at least 2 and the first two code units ofS are either
- IfS contains a code unit that is not a radix-R digit, letend be the index withinS of the first such code unit; otherwise, letend be the length ofS.
- LetZ be the
substring ofS from 0 toend. - IfZ is empty, return
NaN . - LetmathInt be the
integer value that is represented byZ in radix-R notation, using the lettersA-Z anda-z for digits with values 10 through 35. (However, ifR is 10 andZ contains more than 20 significant digits, every significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation; and ifR is not 2, 4, 8, 10, 16, or 32, thenmathInt may be animplementation-approximated value representing theinteger value that is represented byZ in radix-R notation.) - IfmathInt = 0, then
- Ifsign = -1, return
-0 𝔽. - Return
+0 𝔽.
- Ifsign = -1, return
- Return
𝔽 (sign ×mathInt).
19.2.6 URI Handling Functions
Uniform Resource Identifiers, or URIs, are Strings that identify resources (e.g. web pages or files) and transport protocols by which to access them (e.g. HTTP or FTP) on the Internet. The ECMAScript language itself does not provide any support for using URIs except for functions that encode and decode URIs as described in
Many implementations of ECMAScript provide additional functions and methods that manipulate web pages; these functions are beyond the scope of this standard.
19.2.6.1 URI Syntax and Semantics
A URI is composed of a sequence of components separated by component separators. The general form is:
:First/Second;Third?Fourthwhere the italicized names represent components and “:”, “/”, “;” and “?” are reserved for use as separators. TheencodeURI anddecodeURI functions are intended to work with complete URIs; they assume that any reserved code units in the URI are intended to have special meaning and so are not encoded. TheencodeURIComponent anddecodeURIComponent functions are intended to work with the individual component parts of a URI; they assume that any reserved code units represent text and so must be encoded so that they are not interpreted as reserved code units when the component is part of a complete URI.
The following lexical grammar specifies the form of encoded URIs.
Syntax
The above syntax is based upon RFC 2396 and does not reflect changes introduced by the more recent RFC 3986.
Runtime Semantics
When a code unit to be included in a URI is not listed above or is not intended to have the special meaning sometimes given to the reserved code units, that code unit must be encoded. The code unit is transformed into its UTF-8 encoding, with
19.2.6.1.1 Encode (string,unescapedSet )
The abstract operation Encode takes argumentsstring (a String) andunescapedSet (a String). It performs URI encoding and escaping. It performs the following steps when called:
- LetstrLen be the number of code units instring.
- LetR be the empty String.
- Letk be 0.
- Repeat,
- Ifk =strLen, returnR.
- LetC be the code unit at indexk withinstring.
- IfC is inunescapedSet, then
- Setk tok + 1.
- SetR to the
string-concatenation ofR andC.
- Else,
- Letcp be !
CodePointAt (string,k). - Ifcp.[[IsUnpairedSurrogate]] is
true , throw aURIError exception. - Setk tok +cp.[[CodeUnitCount]].
- LetOctets be the
List of octets resulting by applying the UTF-8 transformation tocp.[[CodePoint]]. - For each elementoctet ofOctets, do
- SetR to the
string-concatenation of:- R
"%" - the String representation ofoctet, formatted as a two-digit uppercase hexadecimal number, padded to the left with a zero if necessary
- SetR to the
- Letcp be !
19.2.6.1.2 Decode (string,reservedSet )
The abstract operation Decode takes argumentsstring (a String) andreservedSet (a String). It performs URI unescaping and decoding. It performs the following steps when called:
- LetstrLen be the length ofstring.
- LetR be the empty String.
- Letk be 0.
- Repeat,
- Ifk =strLen, returnR.
- LetC be the code unit at indexk withinstring.
- IfC is not the code unit 0x0025 (PERCENT SIGN), then
- LetS be the String value containing only the code unitC.
- Else,
- Letstart bek.
- Ifk + 2 ≥strLen, throw a
URIError exception. - If the code units at index (k + 1) and (k + 2) withinstring do not represent hexadecimal digits, throw a
URIError exception. - LetB be the 8-bit value represented by the two hexadecimal digits at index (k + 1) and (k + 2).
- Setk tok + 2.
- Letn be the number of leading 1 bits inB.
- Ifn = 0, then
- LetC be the code unit whose value isB.
- IfC is not inreservedSet, then
- LetS be the String value containing only the code unitC.
- Else,
- LetS be the
substring ofstring fromstart tok + 1.
- LetS be the
- Else,
- Ifn = 1 orn > 4, throw a
URIError exception. - Ifk + (3 × (n - 1)) ≥strLen, throw a
URIError exception. - LetOctets be a
List whose sole element isB. - Letj be 1.
- Repeat, whilej <n,
- Setk tok + 1.
- If the code unit at indexk withinstring is not the code unit 0x0025 (PERCENT SIGN), throw a
URIError exception. - If the code units at index (k + 1) and (k + 2) withinstring do not represent hexadecimal digits, throw a
URIError exception. - LetB be the 8-bit value represented by the two hexadecimal digits at index (k + 1) and (k + 2).
- Setk tok + 2.
- AppendB toOctets.
- Setj toj + 1.
Assert : The length ofOctets isn.- IfOctets does not contain a valid UTF-8 encoding of a Unicode code point, throw a
URIError exception. - LetV be the code point obtained by applying the UTF-8 transformation toOctets, that is, from a
List of octets into a 21-bit value. - LetS be
UTF16EncodeCodePoint (V).
- Ifn = 1 orn > 4, throw a
- SetR to the
string-concatenation ofR andS. - Setk tok + 1.
This syntax of Uniform Resource Identifiers is based upon RFC 2396 and does not reflect the more recent RFC 3986 which replaces RFC 2396. A formal description and implementation of UTF-8 is given in RFC 3629.
In UTF-8, characters are encoded using sequences of 1 to 6 octets. The only octet of a sequence of one has the higher-order bit set to 0, the remaining 7 bits being used to encode the character value. In a sequence of n octets, n > 1, the initial octet has the n higher-order bits set to 1, followed by a bit set to 0. The remaining bits of that octet contain bits from the value of the character to be encoded. The following octets all have the higher-order bit set to 1 and the following bit set to 0, leaving 6 bits in each to contain bits from the character to be encoded. The possible UTF-8 encodings of ECMAScript characters are specified in
| Code Unit Value | Representation | 1st Octet | 2nd Octet | 3rd Octet | 4th Octet |
|---|---|---|---|---|---|
0x0000 - 0x007F | 00000000 0zzzzzzz | 0zzzzzzz | |||
0x0080 - 0x07FF | 00000yyy yyzzzzzz | 110yyyyy | 10zzzzzz | ||
0x0800 - 0xD7FF | xxxxyyyy yyzzzzzz | 1110xxxx | 10yyyyyy | 10zzzzzz | |
0xD800 - 0xDBFFfollowed by 0xDC00 - 0xDFFF | 110110vv vvwwwwxxfollowed by 110111yy yyzzzzzz | 11110uuu | 10uuwwww | 10xxyyyy | 10zzzzzz |
0xD800 - 0xDBFFnot followed by 0xDC00 - 0xDFFF | causesURIError | ||||
0xDC00 - 0xDFFF | causesURIError | ||||
0xE000 - 0xFFFF | xxxxyyyy yyzzzzzz | 1110xxxx | 10yyyyyy | 10zzzzzz |
Where
uuuuu =vvvv + 1
to account for the addition of 0x10000 as in section 3.8 of the Unicode Standard (Surrogates).
The above transformation combines each
RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. For example, the invalid sequence C0 80 must not decode into the code unit 0x0000. Implementations of the Decode algorithm are required to throw a
19.2.6.2 decodeURI (encodedURI )
ThedecodeURI function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by theencodeURI function is replaced with the UTF-16 encoding of the code points that it represents. Escape sequences that could not have been introduced byencodeURI are not replaced.
ThedecodeURI function is the%decodeURI% intrinsic object. When thedecodeURI function is called with one argumentencodedURI, the following steps are taken:
- LeturiString be ?
ToString (encodedURI). - LetreservedURISet be a String containing one instance of each code unit valid in
uriReserved plus"#" . - Return ?
Decode (uriString,reservedURISet).
The code point# is not decoded from escape sequences even though it is not a reserved URI code point.
19.2.6.3 decodeURIComponent (encodedURIComponent )
ThedecodeURIComponent function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by theencodeURIComponent function is replaced with the UTF-16 encoding of the code points that it represents.
ThedecodeURIComponent function is the%decodeURIComponent% intrinsic object. When thedecodeURIComponent function is called with one argumentencodedURIComponent, the following steps are taken:
19.2.6.4 encodeURI (uri )
TheencodeURI function computes a new version of a UTF-16 encoded (
TheencodeURI function is the%encodeURI% intrinsic object. When theencodeURI function is called with one argumenturi, the following steps are taken:
- LeturiString be ?
ToString (uri). - LetunescapedURISet be a String containing one instance of each code unit valid in
uriReserved anduriUnescaped plus"#" . - Return ?
Encode (uriString,unescapedURISet).
The code point# is not encoded to an escape sequence even though it is not a reserved or unescaped URI code point.
19.2.6.5 encodeURIComponent (uriComponent )
TheencodeURIComponent function computes a new version of a UTF-16 encoded (
TheencodeURIComponent function is the%encodeURIComponent% intrinsic object. When theencodeURIComponent function is called with one argumenturiComponent, the following steps are taken:
- LetcomponentString be ?
ToString (uriComponent). - LetunescapedURIComponentSet be a String containing one instance of each code unit valid in
uriUnescaped . - Return ?
Encode (componentString,unescapedURIComponentSet).
19.3 Constructor Properties of the Global Object
19.3.1 Array ( . . . )
See
19.3.2 ArrayBuffer ( . . . )
See
19.3.3 BigInt ( . . . )
See
19.3.4 BigInt64Array ( . . . )
See
19.3.5 BigUint64Array ( . . . )
See
19.3.6 Boolean ( . . . )
See
19.3.7 DataView ( . . . )
See
19.3.8 Date ( . . . )
See
19.3.9 Error ( . . . )
See
19.3.10 EvalError ( . . . )
See
19.3.11 FinalizationRegistry ( . . . )
See
19.3.12 Float32Array ( . . . )
See
19.3.13 Float64Array ( . . . )
See
19.3.14 Function ( . . . )
See
19.3.15 Int8Array ( . . . )
See
19.3.16 Int16Array ( . . . )
See
19.3.17 Int32Array ( . . . )
See
19.3.18 Map ( . . . )
See
19.3.19 Number ( . . . )
See
19.3.20 Object ( . . . )
See
19.3.21 Promise ( . . . )
See
19.3.22 Proxy ( . . . )
See
19.3.23 RangeError ( . . . )
See
19.3.24 ReferenceError ( . . . )
See
19.3.25 RegExp ( . . . )
See
19.3.26 Set ( . . . )
See
19.3.27 SharedArrayBuffer ( . . . )
See
19.3.28 String ( . . . )
See
19.3.29 Symbol ( . . . )
See
19.3.30 SyntaxError ( . . . )
See
19.3.31 TypeError ( . . . )
See
19.3.32 Uint8Array ( . . . )
See
19.3.33 Uint8ClampedArray ( . . . )
See
19.3.34 Uint16Array ( . . . )
See
19.3.35 Uint32Array ( . . . )
See
19.3.36 URIError ( . . . )
See
19.3.37 WeakMap ( . . . )
See
19.3.38 WeakRef ( . . . )
See
19.3.39 WeakSet ( . . . )
See
19.4 Other Properties of the Global Object
19.4.1 Atomics
See
19.4.2 JSON
See
19.4.3 Math
See
19.4.4 Reflect
See
20 Fundamental Objects
20.1 Object Objects
20.1.1 The Object Constructor
The Object
- is%Object%.
- is the initial value of the
"Object" property of theglobal object . - creates a new
ordinary object when called as aconstructor . - performs a type conversion when called as a function rather than as a
constructor . - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition.
20.1.1.1 Object ( [value ] )
When theObject function is called with optional argumentvalue, the following steps are taken:
- If NewTarget is neither
undefined nor the active function, then- Return ?
OrdinaryCreateFromConstructor (NewTarget,"%Object.prototype%" ).
- Return ?
- Ifvalue is
undefined ornull , return !OrdinaryObjectCreate (%Object.prototype% ). - Return !
ToObject (value).
TheObject function is
20.1.2 Properties of the Object Constructor
The Object
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has a
"length" property. - has the following additional properties:
20.1.2.1 Object.assign (target, ...sources )
Theassign function is used to copy the values of all of the enumerable own properties from one or more source objects to atarget object. When theassign function is called, the following steps are taken:
- Letto be ?
ToObject (target). - If only one argument was passed, returnto.
- For each elementnextSource ofsources, do
- IfnextSource is neither
undefined nornull , then
- IfnextSource is neither
- Returnto.
Theassign function is
20.1.2.2 Object.create (O,Properties )
Thecreate function creates a new object with a specified prototype. When thecreate function is called, the following steps are taken:
- If
Type (O) is neither Object nor Null, throw aTypeError exception. - Letobj be !
OrdinaryObjectCreate (O). - IfProperties is not
undefined , then- Return ?
ObjectDefineProperties (obj,Properties).
- Return ?
- Returnobj.
20.1.2.3 Object.defineProperties (O,Properties )
ThedefineProperties function is used to add own properties and/or update the attributes of existing own properties of an object. When thedefineProperties function is called, the following steps are taken:
- If
Type (O) is not Object, throw aTypeError exception. - Return ?
ObjectDefineProperties (O,Properties).
20.1.2.3.1 ObjectDefineProperties (O,Properties )
The abstract operation ObjectDefineProperties takes argumentsO andProperties. It performs the following steps when called:
Assert :Type (O) is Object.- Letprops be ?
ToObject (Properties). - Letkeys be ?props.[[OwnPropertyKeys]]().
- Letdescriptors be a new empty
List . - For each elementnextKey ofkeys, do
- LetpropDesc be ?props.[[GetOwnProperty]](nextKey).
- IfpropDesc is not
undefined andpropDesc.[[Enumerable]] istrue , then- LetdescObj be ?
Get (props,nextKey). - Letdesc be ?
ToPropertyDescriptor (descObj). - Append the pair (a two element
List ) consisting ofnextKey anddesc to the end ofdescriptors.
- LetdescObj be ?
- For each elementpair ofdescriptors, do
- LetP be the first element ofpair.
- Letdesc be the second element ofpair.
- Perform ?
DefinePropertyOrThrow (O,P,desc).
- ReturnO.
20.1.2.4 Object.defineProperty (O,P,Attributes )
ThedefineProperty function is used to add an own property and/or update the attributes of an existing own property of an object. When thedefineProperty function is called, the following steps are taken:
- If
Type (O) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (P). - Letdesc be ?
ToPropertyDescriptor (Attributes). - Perform ?
DefinePropertyOrThrow (O,key,desc). - ReturnO.
20.1.2.5 Object.entries (O )
When theentries function is called with argumentO, the following steps are taken:
- Letobj be ?
ToObject (O). - LetnameList be ?
EnumerableOwnPropertyNames (obj,key+value ). - Return
CreateArrayFromList (nameList).
20.1.2.6 Object.freeze (O )
When thefreeze function is called, the following steps are taken:
- If
Type (O) is not Object, returnO. - Letstatus be ?
SetIntegrityLevel (O,frozen ). - Ifstatus is
false , throw aTypeError exception. - ReturnO.
20.1.2.7 Object.fromEntries (iterable )
When thefromEntries method is called with argumentiterable, the following steps are taken:
- Perform ?
RequireObjectCoercible (iterable). - Letobj be !
OrdinaryObjectCreate (%Object.prototype% ). Assert :obj is an extensibleordinary object with no own properties.- LetstepsDefine be the algorithm steps defined in
CreateDataPropertyOnObject Functions . - LetlengthDefine be the number of non-optional parameters of the function definition in
CreateDataPropertyOnObject Functions . - Letadder be !
CreateBuiltinFunction (stepsDefine,lengthDefine,"" , « »). - Return ?
AddEntriesFromIterable (obj,iterable,adder).
20.1.2.7.1 CreateDataPropertyOnObject Functions
A CreateDataPropertyOnObject function is an anonymous built-in function. When a CreateDataPropertyOnObject function is called with argumentskey andvalue, the following steps are taken:
- LetO be the
this value. Assert :Type (O) is Object.Assert :O is an extensibleordinary object .- LetpropertyKey be ?
ToPropertyKey (key). - Perform !
CreateDataPropertyOrThrow (O,propertyKey,value). - Return
undefined .
20.1.2.8 Object.getOwnPropertyDescriptor (O,P )
When thegetOwnPropertyDescriptor function is called, the following steps are taken:
- Letobj be ?
ToObject (O). - Letkey be ?
ToPropertyKey (P). - Letdesc be ?obj.[[GetOwnProperty]](key).
- Return
FromPropertyDescriptor (desc).
20.1.2.9 Object.getOwnPropertyDescriptors (O )
When thegetOwnPropertyDescriptors function is called, the following steps are taken:
- Letobj be ?
ToObject (O). - LetownKeys be ?obj.[[OwnPropertyKeys]]().
- Letdescriptors be !
OrdinaryObjectCreate (%Object.prototype% ). - For each elementkey ofownKeys, do
- Letdesc be ?obj.[[GetOwnProperty]](key).
- Letdescriptor be !
FromPropertyDescriptor (desc). - Ifdescriptor is not
undefined , perform !CreateDataPropertyOrThrow (descriptors,key,descriptor).
- Returndescriptors.
20.1.2.10 Object.getOwnPropertyNames (O )
When thegetOwnPropertyNames function is called, the following steps are taken:
- Return ?
GetOwnPropertyKeys (O,string ).
20.1.2.11 Object.getOwnPropertySymbols (O )
When thegetOwnPropertySymbols function is called with argumentO, the following steps are taken:
- Return ?
GetOwnPropertyKeys (O,symbol ).
20.1.2.11.1 GetOwnPropertyKeys (O,type )
The abstract operation GetOwnPropertyKeys takes argumentsO andtype (either
- Letobj be ?
ToObject (O). - Letkeys be ?obj.[[OwnPropertyKeys]]().
- LetnameList be a new empty
List . - For each elementnextKey ofkeys, do
- Return
CreateArrayFromList (nameList).
20.1.2.12 Object.getPrototypeOf (O )
When thegetPrototypeOf function is called with argumentO, the following steps are taken:
- Letobj be ?
ToObject (O). - Return ?obj.[[GetPrototypeOf]]().
20.1.2.13 Object.is (value1,value2 )
When theis function is called with argumentsvalue1 andvalue2, the following steps are taken:
- Return
SameValue (value1,value2).
20.1.2.14 Object.isExtensible (O )
When theisExtensible function is called with argumentO, the following steps are taken:
- If
Type (O) is not Object, returnfalse . - Return ?
IsExtensible (O).
20.1.2.15 Object.isFrozen (O )
When theisFrozen function is called with argumentO, the following steps are taken:
- If
Type (O) is not Object, returntrue . - Return ?
TestIntegrityLevel (O,frozen ).
20.1.2.16 Object.isSealed (O )
When theisSealed function is called with argumentO, the following steps are taken:
- If
Type (O) is not Object, returntrue . - Return ?
TestIntegrityLevel (O,sealed ).
20.1.2.17 Object.keys (O )
When thekeys function is called with argumentO, the following steps are taken:
- Letobj be ?
ToObject (O). - LetnameList be ?
EnumerableOwnPropertyNames (obj,key ). - Return
CreateArrayFromList (nameList).
20.1.2.18 Object.preventExtensions (O )
When thepreventExtensions function is called, the following steps are taken:
- If
Type (O) is not Object, returnO. - Letstatus be ?O.[[PreventExtensions]]().
- Ifstatus is
false , throw aTypeError exception. - ReturnO.
20.1.2.19 Object.prototype
The initial value ofObject.prototype is the
This property has the attributes { [[Writable]]:
20.1.2.20 Object.seal (O )
When theseal function is called, the following steps are taken:
- If
Type (O) is not Object, returnO. - Letstatus be ?
SetIntegrityLevel (O,sealed ). - Ifstatus is
false , throw aTypeError exception. - ReturnO.
20.1.2.21 Object.setPrototypeOf (O,proto )
When thesetPrototypeOf function is called with argumentsO andproto, the following steps are taken:
- SetO to ?
RequireObjectCoercible (O). - If
Type (proto) is neither Object nor Null, throw aTypeError exception. - If
Type (O) is not Object, returnO. - Letstatus be ?O.[[SetPrototypeOf]](proto).
- Ifstatus is
false , throw aTypeError exception. - ReturnO.
20.1.2.22 Object.values (O )
When thevalues function is called with argumentO, the following steps are taken:
- Letobj be ?
ToObject (O). - LetnameList be ?
EnumerableOwnPropertyNames (obj,value ). - Return
CreateArrayFromList (nameList).
20.1.3 Properties of the Object Prototype Object
TheObject prototype object:
- is%Object.prototype%.
- has an [[Extensible]] internal slot whose value is
true . - has the internal methods defined for ordinary objects, except for the [[SetPrototypeOf]] method, which is as defined in
10.4.7.1 . (Thus, it is animmutable prototype exotic object .) - has a [[Prototype]] internal slot whose value is
null .
20.1.3.1 Object.prototype.constructor
The initial value ofObject.prototype.constructor is
20.1.3.2 Object.prototype.hasOwnProperty (V )
When thehasOwnProperty method is called with argumentV, the following steps are taken:
- LetP be ?
ToPropertyKey (V). - LetO be ?
ToObject (this value). - Return ?
HasOwnProperty (O,P).
20.1.3.3 Object.prototype.isPrototypeOf (V )
When theisPrototypeOf method is called with argumentV, the following steps are taken:
20.1.3.4 Object.prototype.propertyIsEnumerable (V )
When thepropertyIsEnumerable method is called with argumentV, the following steps are taken:
- LetP be ?
ToPropertyKey (V). - LetO be ?
ToObject (this value). - Letdesc be ?O.[[GetOwnProperty]](P).
- Ifdesc is
undefined , returnfalse . - Returndesc.[[Enumerable]].
This method does not consider objects in the prototype chain.
20.1.3.5 Object.prototype.toLocaleString ( [reserved1 [ ,reserved2 ] ] )
When thetoLocaleString method is called, the following steps are taken:
- LetO be the
this value. - Return ?
Invoke (O,"toString" ).
The optional parameters to this function are not used but are intended to correspond to the parameter pattern used by ECMA-402toLocaleString functions. Implementations that do not include ECMA-402 support must not use those parameter positions for other purposes.
This function provides a generictoLocaleString implementation for objects that have no locale-specifictoString behaviour.Array,Number,Date, andtoLocaleString methods.
ECMA-402 intentionally does not provide an alternative to this default implementation.
20.1.3.6 Object.prototype.toString ( )
When thetoString method is called, the following steps are taken:
- If the
this value isundefined , return"[object Undefined]" . - If the
this value isnull , return"[object Null]" . - LetO be !
ToObject (this value). - LetisArray be ?
IsArray (O). - IfisArray is
true , letbuiltinTag be"Array" . - Else ifO has a [[ParameterMap]] internal slot, letbuiltinTag be
"Arguments" . - Else ifO has a [[Call]] internal method, letbuiltinTag be
"Function" . - Else ifO has an [[ErrorData]] internal slot, letbuiltinTag be
"Error" . - Else ifO has a [[BooleanData]] internal slot, letbuiltinTag be
"Boolean" . - Else ifO has a [[NumberData]] internal slot, letbuiltinTag be
"Number" . - Else ifO has a [[StringData]] internal slot, letbuiltinTag be
"String" . - Else ifO has a [[DateValue]] internal slot, letbuiltinTag be
"Date" . - Else ifO has a [[RegExpMatcher]] internal slot, letbuiltinTag be
"RegExp" . - Else, letbuiltinTag be
"Object" . - Lettag be ?
Get (O,@@toStringTag ). - If
Type (tag) is not String, settag tobuiltinTag. - Return the
string-concatenation of"[object " ,tag, and"]" .
Historically, this function was occasionally used to access the String value of the [[Class]] internal slot that was used in previous editions of this specification as a nominal type tag for various built-in objects. The above definition oftoString preserves compatibility for legacy code that usestoString as a test for those specific kinds of built-in objects. It does not provide a reliable type testing mechanism for other kinds of built-in or program defined objects. In addition, programs can use
20.1.3.7 Object.prototype.valueOf ( )
When thevalueOf method is called, the following steps are taken:
- Return ?
ToObject (this value).
20.1.4 Properties of Object Instances
Object instances have no special properties beyond those inherited from the
20.2 Function Objects
20.2.1 The Function Constructor
The Function
- is%Function%.
- is the initial value of the
"Function" property of theglobal object . - creates and initializes a new
function object when called as a function rather than as aconstructor . Thus the function callFunction(…)is equivalent to the object creation expressionnew Function(…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Function behaviour must include asupercall to the Functionconstructor to create and initialize a subclass instance with the internal slots necessary for built-in function behaviour. All ECMAScript syntactic forms for defining function objects create instances of Function. There is no syntactic means to create instances of Function subclasses except for the built-in GeneratorFunction, AsyncFunction, and AsyncGeneratorFunction subclasses.
20.2.1.1 Function (p1,p2, … ,pn,body )
The last argument specifies the body (executable code) of a function; any preceding arguments specify formal parameters.
When theFunction function is called with some argumentsp1,p2, … ,pn,body (wheren might be 0, that is, there are no “p ” arguments, and wherebody might also not be provided), the following steps are taken:
- LetC be the
active function object . - Letargs be theargumentsList that was passed to this function by [[Call]] or [[Construct]].
- Return ?
CreateDynamicFunction (C, NewTarget,normal ,args).
It is permissible but not necessary to have one argument for each formal parameter to be specified. For example, all three of the following expressions produce the same result:
newFunction("a","b","c","return a+b+c")newFunction("a, b, c","return a+b+c")newFunction("a,b","c","return a+b+c")20.2.1.1.1 CreateDynamicFunction (constructor,newTarget,kind,args )
The abstract operation CreateDynamicFunction takes argumentsconstructor (anew was initially applied to.args is the argument values that were passed toconstructor. It performs the following steps when called:
Assert : Theexecution context stack has at least two elements.- LetcallerContext be the second to top element of the
execution context stack . - LetcallerRealm becallerContext's
Realm . - LetcalleeRealm be
the current Realm Record . - Perform ?
HostEnsureCanCompileStrings (callerRealm,calleeRealm). - IfnewTarget is
undefined , setnewTarget toconstructor. - Ifkind is
normal , then- Letgoal be the grammar symbol
FunctionBody .[~Yield, ~Await] - LetparameterGoal be the grammar symbol
FormalParameters .[~Yield, ~Await] - LetfallbackProto be
"%Function.prototype%" .
- Letgoal be the grammar symbol
- Else ifkind is
generator , then- Letgoal be the grammar symbol
GeneratorBody . - LetparameterGoal be the grammar symbol
FormalParameters .[+Yield, ~Await] - LetfallbackProto be
"%GeneratorFunction.prototype%" .
- Letgoal be the grammar symbol
- Else ifkind is
async , then- Letgoal be the grammar symbol
AsyncFunctionBody . - LetparameterGoal be the grammar symbol
FormalParameters .[~Yield, +Await] - LetfallbackProto be
"%AsyncFunction.prototype%" .
- Letgoal be the grammar symbol
- Else,
Assert :kind isasyncGenerator .- Letgoal be the grammar symbol
AsyncGeneratorBody . - LetparameterGoal be the grammar symbol
FormalParameters .[+Yield, +Await] - LetfallbackProto be
"%AsyncGeneratorFunction.prototype%" .
- LetargCount be the number of elements inargs.
- LetP be the empty String.
- IfargCount = 0, letbodyArg be the empty String.
- Else ifargCount = 1, letbodyArg beargs[0].
- Else,
Assert :argCount > 1.- LetfirstArg beargs[0].
- SetP to ?
ToString (firstArg). - Letk be 1.
- Repeat, whilek <argCount - 1,
- LetnextArg beargs[k].
- LetnextArgString be ?
ToString (nextArg). - SetP to the
string-concatenation ofP,"," (a comma), andnextArgString. - Setk tok + 1.
- LetbodyArg beargs[k].
- LetbodyString be the
string-concatenation of 0x000A (LINE FEED), ?ToString (bodyArg), and 0x000A (LINE FEED). - Letprefix be the prefix associated withkind in
Table 50 . - LetsourceString be the
string-concatenation ofprefix," anonymous(" ,P, 0x000A (LINE FEED),") {" ,bodyString, and"}" . - LetsourceText be !
StringToCodePoints (sourceString). - Perform the following substeps in an
implementation-defined order, possibly interleaving parsing and error detection:- Letparameters be
ParseText (!StringToCodePoints (P),parameterGoal). - Ifparameters is a
List of errors, throw aSyntaxError exception. - Letbody be
ParseText (!StringToCodePoints (bodyString),goal). - Ifbody is a
List of errors, throw aSyntaxError exception. - Letstrict be
FunctionBodyContainsUseStrict ofbody. - Ifstrict is
true , apply theearly error rules forUniqueFormalParameters : FormalParameters - Ifstrict is
true andIsSimpleParameterList ofparameters isfalse , throw aSyntaxError exception. - If any element of the
BoundNames ofparameters also occurs in theLexicallyDeclaredNames ofbody, throw aSyntaxError exception. - Ifbody
Contains SuperCall istrue , throw aSyntaxError exception. - Ifparameters
Contains SuperCall istrue , throw aSyntaxError exception. - Ifbody
Contains SuperProperty istrue , throw aSyntaxError exception. - Ifparameters
Contains SuperProperty istrue , throw aSyntaxError exception. - Ifkind is
generator orasyncGenerator , then- Ifparameters
Contains YieldExpression istrue , throw aSyntaxError exception.
- Ifparameters
- Ifkind is
async orasyncGenerator , then- Ifparameters
Contains AwaitExpression istrue , throw aSyntaxError exception.
- Ifparameters
- Ifstrict is
true , then- If
BoundNames ofparameters contains any duplicate elements, throw aSyntaxError exception.
- If
- Letparameters be
- Letproto be ?
GetPrototypeFromConstructor (newTarget,fallbackProto). - LetrealmF be
the current Realm Record . - Letscope berealmF.[[GlobalEnv]].
- LetF be !
OrdinaryFunctionCreate (proto,sourceText,parameters,body,non-lexical-this ,scope). - Perform
SetFunctionName (F,"anonymous" ). - Ifkind is
generator , then- Letprototype be !
OrdinaryObjectCreate (%GeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }).
- Letprototype be !
- Else ifkind is
asyncGenerator , then- Letprototype be !
OrdinaryObjectCreate (%AsyncGeneratorFunction.prototype.prototype% ). - Perform
DefinePropertyOrThrow (F,"prototype" , PropertyDescriptor { [[Value]]:prototype, [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }).
- Letprototype be !
- Else ifkind is
normal , performMakeConstructor (F). - NOTE: Functions whosekind is
async are not constructible and do not have a [[Construct]] internal method or a"prototype" property. - ReturnF.
CreateDynamicFunction defines a
| Kind | Prefix |
|---|---|
20.2.2 Properties of the Function Constructor
The Function
- is itself a built-in
function object . - has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
20.2.2.1 Function.length
This is a
20.2.2.2 Function.prototype
The value ofFunction.prototype is the
This property has the attributes { [[Writable]]:
20.2.3 Properties of the Function Prototype Object
TheFunction prototype object:
- is%Function.prototype%.
- is itself a built-in
function object . - accepts any arguments and returns
undefined when invoked. - does not have a [[Construct]] internal method; it cannot be used as a
constructor with thenewoperator. - has a [[Prototype]] internal slot whose value is
%Object.prototype% . - does not have a
"prototype" property. - has a
"length" property whose value is+0 𝔽. - has a
"name" property whose value is the empty String.
The Function prototype object is specified to be a
20.2.3.1 Function.prototype.apply (thisArg,argArray )
When theapply method is called with argumentsthisArg andargArray, the following steps are taken:
- Letfunc be the
this value. - If
IsCallable (func) isfalse , throw aTypeError exception. - IfargArray is
undefined ornull , then- Perform
PrepareForTailCall (). - Return ?
Call (func,thisArg).
- Perform
- LetargList be ?
CreateListFromArrayLike (argArray). - Perform
PrepareForTailCall (). - Return ?
Call (func,thisArg,argList).
ThethisArg value is passed without modification as the
Iffunc is an arrow function or a
20.2.3.2 Function.prototype.bind (thisArg, ...args )
When thebind method is called with argumentthisArg and zero or moreargs, it performs the following steps:
- LetTarget be the
this value. - If
IsCallable (Target) isfalse , throw aTypeError exception. - LetF be ?
BoundFunctionCreate (Target,thisArg,args). - LetL be 0.
- LettargetHasLength be ?
HasOwnProperty (Target,"length" ). - IftargetHasLength is
true , then- LettargetLen be ?
Get (Target,"length" ). - If
Type (targetLen) is Number, then- IftargetLen is
+∞ 𝔽, setL to +∞. - Else iftargetLen is
-∞ 𝔽, setL to 0. - Else,
- LettargetLenAsInt be !
ToIntegerOrInfinity (targetLen). Assert :targetLenAsInt is finite.- LetargCount be the number of elements inargs.
- SetL to
max (targetLenAsInt -argCount, 0).
- LettargetLenAsInt be !
- IftargetLen is
- LettargetLen be ?
- Perform !
SetFunctionLength (F,L). - LettargetName be ?
Get (Target,"name" ). - If
Type (targetName) is not String, settargetName to the empty String. - Perform
SetFunctionName (F,targetName,"bound" ). - ReturnF.
Function objects created usingFunction.prototype.bind are exotic objects. They also do not have a
IfTarget is an arrow function or a
20.2.3.3 Function.prototype.call (thisArg, ...args )
When thecall method is called with argumentthisArg and zero or moreargs, the following steps are taken:
- Letfunc be the
this value. - If
IsCallable (func) isfalse , throw aTypeError exception. - Perform
PrepareForTailCall (). - Return ?
Call (func,thisArg,args).
ThethisArg value is passed without modification as the
Iffunc is an arrow function or a
20.2.3.4 Function.prototype.constructor
The initial value ofFunction.prototype.constructor is
20.2.3.5 Function.prototype.toString ( )
When thetoString method is called, the following steps are taken:
- Letfunc be the
this value. - If
Type (func) is Object andfunc has a [[SourceText]] internal slot andfunc.[[SourceText]] is a sequence of Unicode code points and !HostHasSourceTextAvailable (func) istrue , then- Return !
CodePointsToString (func.[[SourceText]]).
- Return !
- Iffunc is a
built-in function object , return animplementation-defined String source code representation offunc. The representation must have the syntax of aNativeFunction . Additionally, iffunc has an [[InitialName]] internal slot andfunc.[[InitialName]] is a String, the portion of the returned String that would be matched byNativeFunctionAccessor opt PropertyName must be the value offunc.[[InitialName]]. - If
Type (func) is Object andIsCallable (func) istrue , return animplementation-defined String source code representation offunc. The representation must have the syntax of aNativeFunction . - Throw a
TypeError exception.
20.2.3.6 Function.prototype [ @@hasInstance ] (V )
When the@@hasInstance method of an objectF is called with valueV, the following steps are taken:
- LetF be the
this value. - Return ?
OrdinaryHasInstance (F,V).
The value of the
This property has the attributes { [[Writable]]:
This is the default implementation of@@hasInstance that most functions inherit.@@hasInstance is called by theinstanceof operator to determine whether a value is an instance of a specific
vinstanceof Fevaluates as
F[@@hasInstance](v)Ainstanceof by exposing a different@@hasInstance method on the function.
This property is non-writable and non-configurable to prevent tampering that could be used to globally expose the target function of a
20.2.4 Function Instances
Every Function instance is an ECMAScriptFunction.prototype.bind method (
Function instances have the following properties:
20.2.4.1 length
The value of the
20.2.4.2 name
The value of the
Anonymous functions objects that do not have a contextual name associated with them by this specification use the empty String as the value of the
20.2.4.3 prototype
Function instances that can be used as a
This property has the attributes { [[Writable]]:
Function objects created usingFunction.prototype.bind, or by evaluating a
20.2.5 HostHasSourceTextAvailable (func )
The
An implementation of HostHasSourceTextAvailable must complete normally in all cases. This operation must be deterministic with respect to its parameters. Each time it is called with a specificfunc as its argument, it must return the same completion record. The default implementation of HostHasSourceTextAvailable is to unconditionally return a normal completion with a value of
20.3 Boolean Objects
20.3.1 The Boolean Constructor
The Boolean
- is%Boolean%.
- is the initial value of the
"Boolean" property of theglobal object . - creates and initializes a new Boolean object when called as a
constructor . - performs a type conversion when called as a function rather than as a
constructor . - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Boolean behaviour must include asupercall to the Booleanconstructor to create and initialize the subclass instance with a [[BooleanData]] internal slot.
20.3.1.1 Boolean (value )
WhenBoolean is called with argumentvalue, the following steps are taken:
- Letb be !
ToBoolean (value). - If NewTarget is
undefined , returnb. - LetO be ?
OrdinaryCreateFromConstructor (NewTarget,"%Boolean.prototype%" , « [[BooleanData]] »). - SetO.[[BooleanData]] tob.
- ReturnO.
20.3.2 Properties of the Boolean Constructor
The Boolean
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
20.3.2.1 Boolean.prototype
The initial value ofBoolean.prototype is the
This property has the attributes { [[Writable]]:
20.3.3 Properties of the Boolean Prototype Object
TheBoolean prototype object:
- is%Boolean.prototype%.
- is an
ordinary object . - is itself a Boolean object; it has a [[BooleanData]] internal slot with the value
false . - has a [[Prototype]] internal slot whose value is
%Object.prototype% .
The abstract operationthisBooleanValue takes argumentvalue. It performs the following steps when called:
20.3.3.1 Boolean.prototype.constructor
The initial value ofBoolean.prototype.constructor is
20.3.3.2 Boolean.prototype.toString ( )
The following steps are taken:
- Letb be ?
thisBooleanValue (this value). - Ifb is
true , return"true" ; else return"false" .
20.3.3.3 Boolean.prototype.valueOf ( )
The following steps are taken:
- Return ?
thisBooleanValue (this value).
20.3.4 Properties of Boolean Instances
Boolean instances are ordinary objects that inherit properties from the
20.4 Symbol Objects
20.4.1 The Symbol Constructor
The Symbol
- is%Symbol%.
- is the initial value of the
"Symbol" property of theglobal object . - returns a new Symbol value when called as a function.
- is not intended to be used with the
newoperator. - is not intended to be subclassed.
- may be used as the value of an
extendsclause of a class definition but asupercall to it will cause an exception.
20.4.1.1 Symbol ( [description ] )
WhenSymbol is called with optional argumentdescription, the following steps are taken:
- If NewTarget is not
undefined , throw aTypeError exception. - Ifdescription is
undefined , letdescString beundefined . - Else, letdescString be ?
ToString (description). - Return a new unique Symbol value whose [[Description]] value isdescString.
20.4.2 Properties of the Symbol Constructor
The Symbol
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
20.4.2.1 Symbol.asyncIterator
The initial value ofSymbol.asyncIterator is the well known symbol
This property has the attributes { [[Writable]]:
20.4.2.2 Symbol.for (key )
WhenSymbol.for is called with argumentkey it performs the following steps:
- LetstringKey be ?
ToString (key). - For each elemente of the GlobalSymbolRegistry
List , do- If
SameValue (e.[[Key]],stringKey) istrue , returne.[[Symbol]].
- If
Assert : GlobalSymbolRegistry does not currently contain an entry forstringKey.- LetnewSymbol be a new unique Symbol value whose [[Description]] value isstringKey.
- Append the
Record { [[Key]]:stringKey, [[Symbol]]:newSymbol } to the GlobalSymbolRegistryList . - ReturnnewSymbol.
The GlobalSymbolRegistry is a
20.4.2.3 Symbol.hasInstance
The initial value ofSymbol.hasInstance is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.4 Symbol.isConcatSpreadable
The initial value ofSymbol.isConcatSpreadable is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.5 Symbol.iterator
The initial value ofSymbol.iterator is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.6 Symbol.keyFor (sym )
WhenSymbol.keyFor is called with argumentsym it performs the following steps:
20.4.2.7 Symbol.match
The initial value ofSymbol.match is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.8 Symbol.matchAll
The initial value ofSymbol.matchAll is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.9 Symbol.prototype
The initial value ofSymbol.prototype is the
This property has the attributes { [[Writable]]:
20.4.2.10 Symbol.replace
The initial value ofSymbol.replace is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.11 Symbol.search
The initial value ofSymbol.search is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.12 Symbol.species
The initial value ofSymbol.species is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.13 Symbol.split
The initial value ofSymbol.split is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.14 Symbol.toPrimitive
The initial value ofSymbol.toPrimitive is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.15 Symbol.toStringTag
The initial value ofSymbol.toStringTag is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.2.16 Symbol.unscopables
The initial value ofSymbol.unscopables is the well-known symbol
This property has the attributes { [[Writable]]:
20.4.3 Properties of the Symbol Prototype Object
TheSymbol prototype object:
- is%Symbol.prototype%.
- is an
ordinary object . - is not a Symbol instance and does not have a [[SymbolData]] internal slot.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% .
The abstract operationthisSymbolValue takes argumentvalue. It performs the following steps when called:
20.4.3.1 Symbol.prototype.constructor
The initial value ofSymbol.prototype.constructor is
20.4.3.2 get Symbol.prototype.description
Symbol.prototype.description is an
- Lets be the
this value. - Letsym be ?
thisSymbolValue (s). - Returnsym.[[Description]].
20.4.3.3 Symbol.prototype.toString ( )
The following steps are taken:
- Letsym be ?
thisSymbolValue (this value). - Return
SymbolDescriptiveString (sym).
20.4.3.3.1 SymbolDescriptiveString (sym )
The abstract operation SymbolDescriptiveString takes argumentsym. It performs the following steps when called:
Assert :Type (sym) is Symbol.- Letdesc besym's [[Description]] value.
- Ifdesc is
undefined , setdesc to the empty String. Assert :Type (desc) is String.- Return the
string-concatenation of"Symbol(" ,desc, and")" .
20.4.3.4 Symbol.prototype.valueOf ( )
The following steps are taken:
- Return ?
thisSymbolValue (this value).
20.4.3.5 Symbol.prototype [ @@toPrimitive ] (hint )
This function is called by ECMAScript language operators to convert a Symbol object to a primitive value.
When the@@toPrimitive method is called with argumenthint, the following steps are taken:
- Return ?
thisSymbolValue (this value).
The value of the
This property has the attributes { [[Writable]]:
The argument is ignored.
20.4.3.6 Symbol.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
20.4.4 Properties of Symbol Instances
Symbol instances are ordinary objects that inherit properties from the
20.5 Error Objects
Instances of Error objects are thrown as exceptions when runtime errors occur. The Error objects may also serve as base objects for user-defined exception classes.
When an ECMAScript implementation detects a runtime error, it throws a new instance of one of theNativeError objects defined inname property of the prototype object, in themessage property of the prototype object, and in the presence of theerrors property.
20.5.1 The Error Constructor
The Error
- is%Error%.
- is the initial value of the
"Error" property of theglobal object . - creates and initializes a new Error object when called as a function rather than as a
constructor . Thus the function callError(…)is equivalent to the object creation expressionnew Error(…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Error behaviour must include asupercall to the Errorconstructor to create and initialize subclass instances with an [[ErrorData]] internal slot.
20.5.1.1 Error (message )
When theError function is called with argumentmessage, the following steps are taken:
- If NewTarget is
undefined , letnewTarget be theactive function object ; else letnewTarget be NewTarget. - LetO be ?
OrdinaryCreateFromConstructor (newTarget,"%Error.prototype%" , « [[ErrorData]] »). - Ifmessage is not
undefined , then- Letmsg be ?
ToString (message). - LetmsgDesc be the PropertyDescriptor { [[Value]]:msg, [[Writable]]:
true , [[Enumerable]]:false , [[Configurable]]:true }. - Perform !
DefinePropertyOrThrow (O,"message" ,msgDesc).
- Letmsg be ?
- ReturnO.
20.5.2 Properties of the Error Constructor
The Error
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
20.5.2.1 Error.prototype
The initial value ofError.prototype is the
This property has the attributes { [[Writable]]:
20.5.3 Properties of the Error Prototype Object
TheError prototype object:
- is%Error.prototype%.
- is an
ordinary object . - is not an Error instance and does not have an [[ErrorData]] internal slot.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% .
20.5.3.1 Error.prototype.constructor
The initial value ofError.prototype.constructor is
20.5.3.2 Error.prototype.message
The initial value ofError.prototype.message is the empty String.
20.5.3.3 Error.prototype.name
The initial value ofError.prototype.name is
20.5.3.4 Error.prototype.toString ( )
The following steps are taken:
- LetO be the
this value. - If
Type (O) is not Object, throw aTypeError exception. - Letname be ?
Get (O,"name" ). - Ifname is
undefined , setname to"Error" ; otherwise setname to ?ToString (name). - Letmsg be ?
Get (O,"message" ). - Ifmsg is
undefined , setmsg to the empty String; otherwise setmsg to ?ToString (msg). - Ifname is the empty String, returnmsg.
- Ifmsg is the empty String, returnname.
- Return the
string-concatenation ofname, the code unit 0x003A (COLON), the code unit 0x0020 (SPACE), andmsg.
20.5.4 Properties of Error Instances
Error instances are ordinary objects that inherit properties from theObject.prototype.toString.
20.5.5 Native Error Types Used in This Standard
A new instance of one of theNativeError objects below or of the AggregateError object is thrown when a runtime error is detected. AllNativeError objects share the same structure, as described in
20.5.5.1 EvalError
The EvalError
This exception is not currently used within this specification. This object remains for compatibility with previous editions of this specification.
20.5.5.2 RangeError
The RangeError
Indicates a value that is not in the set or range of allowable values.
20.5.5.3 ReferenceError
The ReferenceError
Indicate that an invalid reference has been detected.
20.5.5.4 SyntaxError
The SyntaxError
Indicates that a parsing error has occurred.
20.5.5.5 TypeError
The TypeError
TypeError is used to indicate an unsuccessful operation when none of the otherNativeError objects are an appropriate indication of the failure cause.
20.5.5.6 URIError
The URIError
Indicates that one of the global URI handling functions was used in a way that is incompatible with its definition.
20.5.6NativeError Object Structure
When an ECMAScript implementation detects a runtime error, it throws a new instance of one of theNativeError objects defined in
For each error object, references toNativeError in the definition should be replaced with the appropriate error object name from
20.5.6.1 TheNativeError Constructors
EachNativeError
- creates and initializes a newNativeError object when called as a function rather than as a
constructor . A call of the object as a function is equivalent to calling it as aconstructor with the same arguments. Thus the function callNativeError(…)is equivalent to the object creation expressionnewNativeError(…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specifiedNativeError behaviour must include asupercall to theNativeErrorconstructor to create and initialize subclass instances with an [[ErrorData]] internal slot.
20.5.6.1.1NativeError (message )
When aNativeError function is called with argumentmessage, the following steps are taken:
- If NewTarget is
undefined , letnewTarget be theactive function object ; else letnewTarget be NewTarget. - LetO be ?
OrdinaryCreateFromConstructor (newTarget,"%NativeError.prototype%", « [[ErrorData]] »). - Ifmessage is not
undefined , then- Letmsg be ?
ToString (message). - LetmsgDesc be the PropertyDescriptor { [[Value]]:msg, [[Writable]]:
true , [[Enumerable]]:false , [[Configurable]]:true }. - Perform !
DefinePropertyOrThrow (O,"message" ,msgDesc).
- Letmsg be ?
- ReturnO.
The actual value of the string passed in step
20.5.6.2 Properties of theNativeError Constructors
EachNativeError
- has a [[Prototype]] internal slot whose value is
%Error% . - has a
"name" property whose value is the String value"NativeError" . - has the following properties:
20.5.6.2.1NativeError.prototype
The initial value ofNativeError.prototype is aNativeError prototype object (
This property has the attributes { [[Writable]]:
20.5.6.3 Properties of theNativeError Prototype Objects
EachNativeError prototype object:
- is an
ordinary object . - is not an Error instance and does not have an [[ErrorData]] internal slot.
- has a [[Prototype]] internal slot whose value is
%Error.prototype% .
20.5.6.3.1NativeError.prototype.constructor
The initial value of the
20.5.6.3.2NativeError.prototype.message
The initial value of the
20.5.6.3.3NativeError.prototype.name
The initial value of the
20.5.6.4 Properties ofNativeError Instances
NativeError instances are ordinary objects that inherit properties from theirNativeError prototype object and have an [[ErrorData]] internal slot whose value isObject.prototype.toString (
20.5.7 AggregateError Objects
20.5.7.1 The AggregateError Constructor
The AggregateError
- is%AggregateError%.
- is the initial value of the
"AggregateError" property of theglobal object . - creates and initializes a new AggregateError object when called as a function rather than as a
constructor . Thus the function callAggregateError(…)is equivalent to the object creation expressionnew AggregateError(…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified AggregateError behaviour must include asupercall to the AggregateErrorconstructor to create and initialize subclass instances with an [[ErrorData]] internal slot.
20.5.7.1.1 AggregateError (errors,message )
When the
- If NewTarget is
undefined , letnewTarget be theactive function object ; else letnewTarget be NewTarget. - LetO be ?
OrdinaryCreateFromConstructor (newTarget,"%AggregateError.prototype%" , « [[ErrorData]] »). - Ifmessage is not
undefined , then- Letmsg be ?
ToString (message). - LetmsgDesc be the PropertyDescriptor { [[Value]]:msg, [[Writable]]:
true , [[Enumerable]]:false , [[Configurable]]:true }. - Perform !
DefinePropertyOrThrow (O,"message" ,msgDesc).
- Letmsg be ?
- LeterrorsList be ?
IterableToList (errors). - Perform !
DefinePropertyOrThrow (O,"errors" , PropertyDescriptor { [[Configurable]]:true , [[Enumerable]]:false , [[Writable]]:true , [[Value]]: !CreateArrayFromList (errorsList) }). - ReturnO.
20.5.7.2 Properties of the AggregateError Constructor
The AggregateError
- has a [[Prototype]] internal slot whose value is
%Error% . - has the following properties:
20.5.7.2.1 AggregateError.prototype
The initial value ofAggregateError.prototype is
This property has the attributes { [[Writable]]:
20.5.7.3 Properties of the AggregateError Prototype Object
TheAggregateError prototype object:
- is%AggregateError.prototype%.
- is an
ordinary object . - is not an Error instance or an AggregateError instance and does not have an [[ErrorData]] internal slot.
- has a [[Prototype]] internal slot whose value is
%Error.prototype% .
20.5.7.3.1 AggregateError.prototype.constructor
The initial value ofAggregateError.prototype.constructor is
20.5.7.3.2 AggregateError.prototype.message
The initial value ofAggregateError.prototype.message is the empty String.
20.5.7.3.3 AggregateError.prototype.name
The initial value ofAggregateError.prototype.name is
20.5.7.4 Properties of AggregateError Instances
AggregateError instances are ordinary objects that inherit properties from theirObject.prototype.toString (
21 Numbers and Dates
21.1 Number Objects
21.1.1 The Number Constructor
The Number
- is%Number%.
- is the initial value of the
"Number" property of theglobal object . - creates and initializes a new Number object when called as a
constructor . - performs a type conversion when called as a function rather than as a
constructor . - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Number behaviour must include asupercall to the Numberconstructor to create and initialize the subclass instance with a [[NumberData]] internal slot.
21.1.1.1 Number (value )
WhenNumber is called with argumentvalue, the following steps are taken:
- Ifvalue is present, then
- Else,
- Letn be
+0 𝔽.
- Letn be
- If NewTarget is
undefined , returnn. - LetO be ?
OrdinaryCreateFromConstructor (NewTarget,"%Number.prototype%" , « [[NumberData]] »). - SetO.[[NumberData]] ton.
- ReturnO.
21.1.2 Properties of the Number Constructor
The Number
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
21.1.2.1 Number.EPSILON
The value ofNumber.EPSILON is the
This property has the attributes { [[Writable]]:
21.1.2.2 Number.isFinite (number )
WhenNumber.isFinite is called with one argumentnumber, the following steps are taken:
- If
Type (number) is not Number, returnfalse . - Ifnumber is
NaN ,+∞ 𝔽, or-∞ 𝔽, returnfalse . - Otherwise, return
true .
21.1.2.3 Number.isInteger (number )
WhenNumber.isInteger is called with one argumentnumber, the following steps are taken:
- Return !
IsIntegralNumber (number).
21.1.2.4 Number.isNaN (number )
WhenNumber.isNaN is called with one argumentnumber, the following steps are taken:
- If
Type (number) is not Number, returnfalse . - Ifnumber is
NaN , returntrue . - Otherwise, return
false .
This function differs from the global isNaN function (
21.1.2.5 Number.isSafeInteger (number )
WhenNumber.isSafeInteger is called with one argumentnumber, the following steps are taken:
- If !
IsIntegralNumber (number) istrue , then - Return
false .
21.1.2.6 Number.MAX_SAFE_INTEGER
The value ofNumber.MAX_SAFE_INTEGER is the largest
The value ofNumber.MAX_SAFE_INTEGER is
This property has the attributes { [[Writable]]:
21.1.2.7 Number.MAX_VALUE
The value ofNumber.MAX_VALUE is the largest positive finite value of the Number type, which is approximately
This property has the attributes { [[Writable]]:
21.1.2.8 Number.MIN_SAFE_INTEGER
The value ofNumber.MIN_SAFE_INTEGER is the smallest
The value ofNumber.MIN_SAFE_INTEGER is
This property has the attributes { [[Writable]]:
21.1.2.9 Number.MIN_VALUE
The value ofNumber.MIN_VALUE is the smallest positive value of the Number type, which is approximately
In theNumber.MIN_VALUE must be the smallest non-zero positive value that can actually be represented by the implementation.
This property has the attributes { [[Writable]]:
21.1.2.10 Number.NaN
The value ofNumber.NaN is
This property has the attributes { [[Writable]]:
21.1.2.11 Number.NEGATIVE_INFINITY
The value ofNumber.NEGATIVE_INFINITY is
This property has the attributes { [[Writable]]:
21.1.2.12 Number.parseFloat (string )
The value of theNumber.parseFloat
21.1.2.13 Number.parseInt (string,radix )
The value of theNumber.parseInt
21.1.2.14 Number.POSITIVE_INFINITY
The value ofNumber.POSITIVE_INFINITY is
This property has the attributes { [[Writable]]:
21.1.2.15 Number.prototype
The initial value ofNumber.prototype is the
This property has the attributes { [[Writable]]:
21.1.3 Properties of the Number Prototype Object
TheNumber prototype object:
- is%Number.prototype%.
- is an
ordinary object . - is itself a Number object; it has a [[NumberData]] internal slot with the value
+0 𝔽. - has a [[Prototype]] internal slot whose value is
%Object.prototype% .
Unless explicitly stated otherwise, the methods of the Number prototype object defined below are not generic and the
The abstract operationthisNumberValue takes argumentvalue. It performs the following steps when called:
The phrase “this
21.1.3.1 Number.prototype.constructor
The initial value ofNumber.prototype.constructor is
21.1.3.2 Number.prototype.toExponential (fractionDigits )
Return a String containing this
- Letx be ?
thisNumberValue (this value). - Letf be ?
ToIntegerOrInfinity (fractionDigits). Assert : IffractionDigits isundefined , thenf is 0.- Ifx is not finite, return !
Number::toString (x). - Iff < 0 orf > 100, throw a
RangeError exception. - Setx to
ℝ (x). - Lets be the empty String.
- Ifx < 0, then
- Sets to
"-" . - Setx to -x.
- Sets to
- Ifx = 0, then
- Letm be the String value consisting off + 1 occurrences of the code unit 0x0030 (DIGIT ZERO).
- Lete be 0.
- Else,
- IffractionDigits is not
undefined , then- Lete andn be integers such that 10f ≤n < 10f + 1 and for whichn × 10e -n -x is as close to zero as possible. If there are two such sets ofe andn, pick thee andn for whichn × 10e -f is larger.
- Else,
- Lete,n, andf be integers such thatf ≥ 0, 10f ≤n < 10f + 1,n × 10e -f isx, andf is as small as possible. Note that the decimal representation ofn hasf + 1 digits,n is not divisible by 10, and the least significant digit ofn is not necessarily uniquely determined by these criteria.
- Letm be the String value consisting of the digits of the decimal representation ofn (in order, with no leading zeroes).
- IffractionDigits is not
- Iff ≠ 0, then
- Leta be the first code unit ofm.
- Letb be the otherf code units ofm.
- Setm to the
string-concatenation ofa,"." , andb.
- Ife = 0, then
- Letc be
"+" . - Letd be
"0" .
- Letc be
- Else,
- Ife > 0, letc be
"+" . - Else,
Assert :e < 0.- Letc be
"-" . - Sete to -e.
- Letd be the String value consisting of the digits of the decimal representation ofe (in order, with no leading zeroes).
- Ife > 0, letc be
- Setm to the
string-concatenation ofm,"e" ,c, andd. - Return the
string-concatenation ofs andm.
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step
- Lete,n, andf be integers such thatf ≥ 0, 10f ≤n < 10f + 1,n × 10e -f isx, andf is as small as possible. If there are multiple possibilities forn, choose the value ofn for whichn × 10e -f is closest in value tox. If there are two such possible values ofn, choose the one that is even.
21.1.3.3 Number.prototype.toFixed (fractionDigits )
toFixed returns a String containing this
The following steps are performed:
- Letx be ?
thisNumberValue (this value). - Letf be ?
ToIntegerOrInfinity (fractionDigits). Assert : IffractionDigits isundefined , thenf is 0.- Iff is not finite, throw a
RangeError exception. - Iff < 0 orf > 100, throw a
RangeError exception. - Ifx is not finite, return !
Number::toString (x). - Setx to
ℝ (x). - Lets be the empty String.
- Ifx < 0, then
- Sets to
"-" . - Setx to -x.
- Sets to
- Ifx ≥ 1021, then
- Else,
- Letn be an
integer for whichn / 10f -x is as close to zero as possible. If there are two suchn, pick the largern. - Ifn = 0, letm be the String
"0" . Otherwise, letm be the String value consisting of the digits of the decimal representation ofn (in order, with no leading zeroes). - Iff ≠ 0, then
- Letk be the length ofm.
- Ifk ≤f, then
- Letz be the String value consisting off + 1 -k occurrences of the code unit 0x0030 (DIGIT ZERO).
- Setm to the
string-concatenation ofz andm. - Setk tof + 1.
- Leta be the firstk -f code units ofm.
- Letb be the otherf code units ofm.
- Setm to the
string-concatenation ofa,"." , andb.
- Letn be an
- Return the
string-concatenation ofs andm.
The output oftoFixed may be more precise thantoString for some values because toString only prints enough significant digits to distinguish the number from adjacent Number values. For example,
(1000000000000000128).toString() returns(1000000000000000128).toFixed(0) returns
21.1.3.4 Number.prototype.toLocaleString ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement theNumber.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleString method is used.
Produces a String value that represents thistoString.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
21.1.3.5 Number.prototype.toPrecision (precision )
Return a String containing this
- Letx be ?
thisNumberValue (this value). - Ifprecision is
undefined , return !ToString (x). - Letp be ?
ToIntegerOrInfinity (precision). - Ifx is not finite, return !
Number::toString (x). - Ifp < 1 orp > 100, throw a
RangeError exception. - Setx to
ℝ (x). - Lets be the empty String.
- Ifx < 0, then
- Sets to the code unit 0x002D (HYPHEN-MINUS).
- Setx to -x.
- Ifx = 0, then
- Letm be the String value consisting ofp occurrences of the code unit 0x0030 (DIGIT ZERO).
- Lete be 0.
- Else,
- Lete andn be integers such that 10p - 1 ≤n < 10p and for whichn × 10e -p + 1 -x is as close to zero as possible. If there are two such sets ofe andn, pick thee andn for whichn × 10e -p + 1 is larger.
- Letm be the String value consisting of the digits of the decimal representation ofn (in order, with no leading zeroes).
- Ife < -6 ore ≥p, then
Assert :e ≠ 0.- Ifp ≠ 1, then
- Leta be the first code unit ofm.
- Letb be the otherp - 1 code units ofm.
- Setm to the
string-concatenation ofa,"." , andb.
- Ife > 0, then
- Letc be the code unit 0x002B (PLUS SIGN).
- Else,
Assert :e < 0.- Letc be the code unit 0x002D (HYPHEN-MINUS).
- Sete to -e.
- Letd be the String value consisting of the digits of the decimal representation ofe (in order, with no leading zeroes).
- Return the
string-concatenation ofs,m, the code unit 0x0065 (LATIN SMALL LETTER E),c, andd.
- Ife =p - 1, return the
string-concatenation ofs andm. - Ife ≥ 0, then
- Setm to the
string-concatenation of the firste + 1 code units ofm, the code unit 0x002E (FULL STOP), and the remainingp - (e + 1) code units ofm.
- Setm to the
- Else,
- Setm to the
string-concatenation of the code unit 0x0030 (DIGIT ZERO), the code unit 0x002E (FULL STOP), -(e + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and the Stringm.
- Setm to the
- Return the
string-concatenation ofs andm.
21.1.3.6 Number.prototype.toString ( [radix ] )
The optionalradix should be an
The following steps are performed:
- Letx be ?
thisNumberValue (this value). - Ifradix is
undefined , letradixMV be 10. - Else, letradixMV be ?
ToIntegerOrInfinity (radix). - IfradixMV < 2 orradixMV > 36, throw a
RangeError exception. - IfradixMV = 10, return !
ToString (x). - Return the String representation of this
Number value using the radix specified byradixMV. Lettersa-zare used for digits with values 10 through 35. The precise algorithm isimplementation-defined , however the algorithm should be a generalization of that specified in6.1.6.1.20 .
ThetoString function is not generic; it throws a
ThetoString method is
21.1.3.7 Number.prototype.valueOf ( )
- Return ?
thisNumberValue (this value).
21.1.4 Properties of Number Instances
Number instances are ordinary objects that inherit properties from the
21.2 BigInt Objects
21.2.1 The BigInt Constructor
The BigInt
- is%BigInt%.
- is the initial value of the
"BigInt" property of theglobal object . - performs a type conversion when called as a function rather than as a
constructor . - is not intended to be used with the
newoperator or to be subclassed. It may be used as the value of anextendsclause of a class definition but asupercall to the BigIntconstructor will cause an exception.
21.2.1.1 BigInt (value )
WhenBigInt is called with argumentvalue, the following steps are taken:
- If NewTarget is not
undefined , throw aTypeError exception. - Letprim be ?
ToPrimitive (value,number ). - If
Type (prim) is Number, return ?NumberToBigInt (prim). - Otherwise, return ?
ToBigInt (value).
21.2.1.1.1 NumberToBigInt (number )
The abstract operation NumberToBigInt takes argumentnumber (a Number). It performs the following steps when called:
- If
IsIntegralNumber (number) isfalse , throw aRangeError exception. - Return the BigInt value that represents
ℝ (number).
21.2.2 Properties of the BigInt Constructor
The value of the [[Prototype]] internal slot of the BigInt
The BigInt
21.2.2.1 BigInt.asIntN (bits,bigint )
When theBigInt.asIntN function is called with two argumentsbits andbigint, the following steps are taken:
21.2.2.2 BigInt.asUintN (bits,bigint )
When theBigInt.asUintN function is called with two argumentsbits andbigint, the following steps are taken:
21.2.2.3 BigInt.prototype
The initial value ofBigInt.prototype is the
This property has the attributes { [[Writable]]:
21.2.3 Properties of the BigInt Prototype Object
TheBigInt prototype object:
- is%BigInt.prototype%.
- is an
ordinary object . - is not a BigInt object; it does not have a [[BigIntData]] internal slot.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% .
The abstract operationthisBigIntValue takes argumentvalue. It performs the following steps when called:
The phrase “this BigInt value” within the specification of a method refers to the result returned by calling the abstract operation
21.2.3.1 BigInt.prototype.constructor
The initial value ofBigInt.prototype.constructor is
21.2.3.2 BigInt.prototype.toLocaleString ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement theBigInt.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleString method is used.
Produces a String value that represents this BigInt value formatted according to the conventions of thetoString.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
21.2.3.3 BigInt.prototype.toString ( [radix ] )
The optionalradix should be an
The following steps are performed:
- Letx be ?
thisBigIntValue (this value). - Ifradix is
undefined , letradixMV be 10. - Else, letradixMV be ?
ToIntegerOrInfinity (radix). - IfradixMV < 2 orradixMV > 36, throw a
RangeError exception. - IfradixMV = 10, return !
ToString (x). - Return the String representation of this
Number value using the radix specified byradixMV. Lettersa-zare used for digits with values 10 through 35. The precise algorithm isimplementation-defined , however the algorithm should be a generalization of that specified in6.1.6.2.23 .
ThetoString function is not generic; it throws a
21.2.3.4 BigInt.prototype.valueOf ( )
- Return ?
thisBigIntValue (this value).
21.2.3.5 BigInt.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
21.3 The Math Object
The Math object:
- is%Math%.
- is the initial value of the
"Math" property of theglobal object . - is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is not a
function object . - does not have a [[Construct]] internal method; it cannot be used as a
constructor with thenewoperator. - does not have a [[Call]] internal method; it cannot be invoked as a function.
In this specification, the phrase “the
21.3.1 Value Properties of the Math Object
21.3.1.1 Math.E
The
This property has the attributes { [[Writable]]:
21.3.1.2 Math.LN10
The
This property has the attributes { [[Writable]]:
21.3.1.3 Math.LN2
The
This property has the attributes { [[Writable]]:
21.3.1.4 Math.LOG10E
The
This property has the attributes { [[Writable]]:
The value ofMath.LOG10E is approximately the reciprocal of the value ofMath.LN10.
21.3.1.5 Math.LOG2E
The
This property has the attributes { [[Writable]]:
The value ofMath.LOG2E is approximately the reciprocal of the value ofMath.LN2.
21.3.1.6 Math.PI
The
This property has the attributes { [[Writable]]:
21.3.1.7 Math.SQRT1_2
The
This property has the attributes { [[Writable]]:
The value ofMath.SQRT1_2 is approximately the reciprocal of the value ofMath.SQRT2.
21.3.1.8 Math.SQRT2
The
This property has the attributes { [[Writable]]:
21.3.1.9 Math [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
21.3.2 Function Properties of the Math Object
The behaviour of the functionsacos,acosh,asin,asinh,atan,atanh,atan2,cbrt,cos,cosh,exp,expm1,hypot,log,log1p,log2,log10,pow,random,sin,sinh,sqrt,tan, andtanh is not precisely specified here except to require specific results for certain argument values that represent boundary cases of interest. For other argument values, these functions are intended to compute approximations to the results of familiar mathematical functions, but some latitude is allowed in the choice of approximation algorithms. The general intent is that an implementer should be able to use the same mathematical library for ECMAScript on a given hardware platform that is available to C programmers on that platform.
Although the choice of algorithms is left to the implementation, it is recommended (but not specified by this standard) that implementations use the approximation algorithms forfdlibm, the freely distributable mathematical library from Sun Microsystems (http://www.netlib.org/fdlibm).
21.3.2.1 Math.abs (x )
Returns the absolute value ofx; the result has the same magnitude asx but has positive sign.
When theMath.abs method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN , returnNaN . - Ifn is
-0 𝔽, return+0 𝔽. - Ifn is
-∞ 𝔽, return+∞ 𝔽. - Ifn <
+0 𝔽, return -n. - Returnn.
21.3.2.2 Math.acos (x )
Returns the inverse cosine ofx. The result is expressed in radians and ranges from
When theMath.acos method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n >1 𝔽, orn <-1 𝔽, returnNaN . - Ifn is
1 𝔽, return+0 𝔽. - Return an
implementation-approximated value representing the result of the inverse cosine ofℝ (n).
21.3.2.3 Math.acosh (x )
Returns the inverse hyperbolic cosine ofx.
When theMath.acosh method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN orn is+∞ 𝔽, returnn. - Ifn is
1 𝔽, return+0 𝔽. - Ifn <
1 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the inverse hyperbolic cosine ofℝ (n).
21.3.2.4 Math.asin (x )
Returns the inverse sine ofx. The result is expressed in radians and ranges from
When theMath.asin method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn >
1 𝔽 orn <-1 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the inverse sine ofℝ (n).
21.3.2.5 Math.asinh (x )
Returns the inverse hyperbolic sine ofx.
When theMath.asinh method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Return an
implementation-approximated value representing the result of the inverse hyperbolic sine ofℝ (n).
21.3.2.6 Math.atan (x )
Returns the inverse tangent ofx. The result is expressed in radians and ranges from
When theMath.atan method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn is
+∞ 𝔽, return animplementation-approximated value representing π / 2. - Ifn is
-∞ 𝔽, return animplementation-approximated value representing -π / 2. - Return an
implementation-approximated value representing the result of the inverse tangent ofℝ (n).
21.3.2.7 Math.atanh (x )
Returns the inverse hyperbolic tangent ofx.
When theMath.atanh method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn >
1 𝔽 orn <-1 𝔽, returnNaN . - Ifn is
1 𝔽, return+∞ 𝔽. - Ifn is
-1 𝔽, return-∞ 𝔽. - Return an
implementation-approximated value representing the result of the inverse hyperbolic tangent ofℝ (n).
21.3.2.8 Math.atan2 (y,x )
Returns the inverse tangent of the quotient
When theMath.atan2 method is called with argumentsy andx, the following steps are taken:
- Letny be ?
ToNumber (y). - Letnx be ?
ToNumber (x). - Ifny is
NaN ornx isNaN , returnNaN . - Ifny is
+∞ 𝔽, then- Ifnx is
+∞ 𝔽, return animplementation-approximated value representing π / 4. - Ifnx is
-∞ 𝔽, return animplementation-approximated value representing 3π / 4. - Return an
implementation-approximated value representing π / 2.
- Ifnx is
- Ifny is
-∞ 𝔽, then- Ifnx is
+∞ 𝔽, return animplementation-approximated value representing -π / 4. - Ifnx is
-∞ 𝔽, return animplementation-approximated value representing -3π / 4. - Return an
implementation-approximated value representing -π / 2.
- Ifnx is
- Ifny is
+0 𝔽, then- Ifnx >
+0 𝔽 ornx is+0 𝔽, return+0 𝔽. - Return an
implementation-approximated value representing π.
- Ifnx >
- Ifny is
-0 𝔽, then- Ifnx >
+0 𝔽 ornx is+0 𝔽, return-0 𝔽. - Return an
implementation-approximated value representing -π.
- Ifnx >
Assert :ny is finite and is neither+0 𝔽 nor-0 𝔽.- Ifny >
+0 𝔽, then- Ifnx is
+∞ 𝔽, return+0 𝔽. - Ifnx is
-∞ 𝔽, return animplementation-approximated value representing π. - Ifnx is
+0 𝔽 ornx is-0 𝔽, return animplementation-approximated value representing π / 2.
- Ifnx is
- Ifny <
+0 𝔽, then- Ifnx is
+∞ 𝔽, return-0 𝔽. - Ifnx is
-∞ 𝔽, return animplementation-approximated value representing -π. - Ifnx is
+0 𝔽 ornx is-0 𝔽, return animplementation-approximated value representing -π / 2.
- Ifnx is
Assert :nx is finite and is neither+0 𝔽 nor-0 𝔽.- Return an
implementation-approximated value representing the result of the inverse tangent of the quotientℝ (ny) /ℝ (nx).
21.3.2.9 Math.cbrt (x )
Returns the cube root ofx.
When theMath.cbrt method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Return an
implementation-approximated value representing the result of the cube root ofℝ (n).
21.3.2.10 Math.ceil (x )
Returns the smallest (closest to -∞)
When theMath.ceil method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Ifn <
+0 𝔽 andn >-1 𝔽, return-0 𝔽. - Ifn is an
integral Number , returnn. - Return the smallest (closest to -∞)
integral Number value that is not less thann.
The value ofMath.ceil(x) is the same as the value of-Math.floor(-x).
21.3.2.11 Math.clz32 (x )
When theMath.clz32 method is called with argumentx, the following steps are taken:
Ifn is
21.3.2.12 Math.cos (x )
Returns the cosine ofx. The argument is expressed in radians.
When theMath.cos method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn is
+∞ 𝔽 orn is-∞ 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the cosine ofℝ (n).
21.3.2.13 Math.cosh (x )
Returns the hyperbolic cosine ofx.
When theMath.cosh method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Ifn is
+0 𝔽 orn is-0 𝔽, return1 𝔽. - Return an
implementation-approximated value representing the result of the hyperbolic cosine ofℝ (n).
The value ofMath.cosh(x) is the same as the value of(Math.exp(x) + Math.exp(-x)) / 2.
21.3.2.14 Math.exp (x )
Returns the exponential function ofx (e raised to the power ofx, wheree is the base of the natural logarithms).
When theMath.exp method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN orn is+∞ 𝔽, returnn. - Ifn is
+0 𝔽 orn is-0 𝔽, return1 𝔽. - Ifn is
-∞ 𝔽, return+0 𝔽. - Return an
implementation-approximated value representing the result of the exponential function ofℝ (n).
21.3.2.15 Math.expm1 (x )
Returns the result of subtracting 1 from the exponential function ofx (e raised to the power ofx, wheree is the base of the natural logarithms). The result is computed in a way that is accurate even when the value ofx is close to 0.
When theMath.expm1 method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽, orn is+∞ 𝔽, returnn. - Ifn is
-∞ 𝔽, return-1 𝔽. - Return an
implementation-approximated value representing the result of subtracting 1 from the exponential function ofℝ (n).
21.3.2.16 Math.floor (x )
Returns the greatest (closest to +∞)
When theMath.floor method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Ifn <
1 𝔽 andn >+0 𝔽, return+0 𝔽. - Ifn is an
integral Number , returnn. - Return the greatest (closest to +∞)
integral Number value that is not greater thann.
The value ofMath.floor(x) is the same as the value of-Math.ceil(-x).
21.3.2.17 Math.fround (x )
When theMath.fround method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN , returnNaN . - Ifn is one of
+0 𝔽,-0 𝔽,+∞ 𝔽, or-∞ 𝔽, returnn. - Letn32 be the result of convertingn to a value in
IEEE 754-2019 binary32 format using roundTiesToEven mode. - Letn64 be the result of convertingn32 to a value in
IEEE 754-2019 binary64 format. - Return the ECMAScript
Number value corresponding ton64.
21.3.2.18 Math.hypot ( ...args )
Returns the square root of the sum of squares of its arguments.
When theMath.hypot method is called with zero or more arguments which form the rest parameter ...args, the following steps are taken:
- Letcoerced be a new empty
List . - For each elementarg ofargs, do
- Letn be ?
ToNumber (arg). - Appendn tocoerced.
- Letn be ?
- LetonlyZero be
true . - For each elementnumber ofcoerced, do
- Ifnumber is
NaN ornumber is+∞ 𝔽, returnnumber. - Ifnumber is
-∞ 𝔽, return+∞ 𝔽. - Ifnumber is neither
+0 𝔽 nor-0 𝔽, setonlyZero tofalse .
- Ifnumber is
- IfonlyZero is
true , return+0 𝔽. - Return an
implementation-approximated value representing the square root of the sum of squares of the mathematical values of the elements ofcoerced.
Thehypot method is
Implementations should take care to avoid the loss of precision from overflows and underflows that are prone to occur in naive implementations when this function is called with two or more arguments.
21.3.2.19 Math.imul (x,y )
WhenMath.imul is called with argumentsx andy, the following steps are taken:
21.3.2.20 Math.log (x )
Returns the natural logarithm ofx.
When theMath.log method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN orn is+∞ 𝔽, returnn. - Ifn is
1 𝔽, return+0 𝔽. - Ifn is
+0 𝔽 orn is-0 𝔽, return-∞ 𝔽. - Ifn <
+0 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the natural logarithm ofℝ (n).
21.3.2.21 Math.log1p (x )
Returns the natural logarithm of 1 +x. The result is computed in a way that is accurate even when the value of x is close to zero.
When theMath.log1p method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽, orn is+∞ 𝔽, returnn. - Ifn is
-1 𝔽, return-∞ 𝔽. - Ifn <
-1 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the natural logarithm of 1 +ℝ (n).
21.3.2.22 Math.log10 (x )
Returns the base 10 logarithm ofx.
When theMath.log10 method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN orn is+∞ 𝔽, returnn. - Ifn is
1 𝔽, return+0 𝔽. - Ifn is
+0 𝔽 orn is-0 𝔽, return-∞ 𝔽. - Ifn <
+0 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the base 10 logarithm ofℝ (n).
21.3.2.23 Math.log2 (x )
Returns the base 2 logarithm ofx.
When theMath.log2 method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN orn is+∞ 𝔽, returnn. - Ifn is
1 𝔽, return+0 𝔽. - Ifn is
+0 𝔽 orn is-0 𝔽, return-∞ 𝔽. - Ifn <
+0 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the base 2 logarithm ofℝ (n).
21.3.2.24 Math.max ( ...args )
Given zero or more arguments, calls
When theMath.max method is called with zero or more arguments which form the rest parameter ...args, the following steps are taken:
The comparison of values to determine the largest value is done using the
Themax method is
21.3.2.25 Math.min ( ...args )
Given zero or more arguments, calls
When theMath.min method is called with zero or more arguments which form the rest parameter ...args, the following steps are taken:
The comparison of values to determine the largest value is done using the
Themin method is
21.3.2.26 Math.pow (base,exponent )
When theMath.pow method is called with argumentsbase andexponent, the following steps are taken:
21.3.2.27 Math.random ( )
Returns a
EachMath.random function created for distinct realms must produce a distinct sequence of values from successive calls.
21.3.2.28 Math.round (x )
Returns the
When theMath.round method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,+∞ 𝔽,-∞ 𝔽, or anintegral Number , returnn. - Ifn <
0.5 𝔽 andn >+0 𝔽, return+0 𝔽. - Ifn <
+0 𝔽 andn ≥-0.5 𝔽, return-0 𝔽. - Return the
integral Number closest ton, preferring the Number closer to +∞ in the case of a tie.
Math.round(3.5) returns 4, butMath.round(-3.5) returns -3.
The value ofMath.round(x) is not always the same as the value ofMath.floor(x + 0.5). Whenx isMath.round(x) returnsMath.floor(x + 0.5) returnsMath.round(x) may also differ from the value ofMath.floor(x + 0.5)because of internal rounding when computingx + 0.5.
21.3.2.29 Math.sign (x )
Returns the sign ofx, indicating whetherx is positive, negative, or zero.
When theMath.sign method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn <
+0 𝔽, return-1 𝔽. - Return
1 𝔽.
21.3.2.30 Math.sin (x )
Returns the sine ofx. The argument is expressed in radians.
When theMath.sin method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn is
+∞ 𝔽 orn is-∞ 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the sine ofℝ (n).
21.3.2.31 Math.sinh (x )
Returns the hyperbolic sine ofx.
When theMath.sinh method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Return an
implementation-approximated value representing the result of the hyperbolic sine ofℝ (n).
The value ofMath.sinh(x) is the same as the value of(Math.exp(x) - Math.exp(-x)) / 2.
21.3.2.32 Math.sqrt (x )
Returns the square root ofx.
When theMath.sqrt method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽, orn is+∞ 𝔽, returnn. - Ifn <
+0 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the square root ofℝ (n).
21.3.2.33 Math.tan (x )
Returns the tangent ofx. The argument is expressed in radians.
When theMath.tan method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn is
+∞ 𝔽, orn is-∞ 𝔽, returnNaN . - Return an
implementation-approximated value representing the result of the tangent ofℝ (n).
21.3.2.34 Math.tanh (x )
Returns the hyperbolic tangent ofx.
When theMath.tanh method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽, orn is-0 𝔽, returnn. - Ifn is
+∞ 𝔽, return1 𝔽. - Ifn is
-∞ 𝔽, return-1 𝔽. - Return an
implementation-approximated value representing the result of the hyperbolic tangent ofℝ (n).
The value ofMath.tanh(x) is the same as the value of(Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)).
21.3.2.35 Math.trunc (x )
Returns the integral part of the numberx, removing any fractional digits. Ifx is already integral, the result isx.
When theMath.trunc method is called with argumentx, the following steps are taken:
- Letn be ?
ToNumber (x). - Ifn is
NaN ,n is+0 𝔽,n is-0 𝔽,n is+∞ 𝔽, orn is-∞ 𝔽, returnn. - Ifn <
1 𝔽 andn >+0 𝔽, return+0 𝔽. - Ifn <
+0 𝔽 andn >-1 𝔽, return-0 𝔽. - Return the
integral Number nearestn in the direction of+0 𝔽.
21.4 Date Objects
21.4.1 Overview of Date Objects and Definitions of Abstract Operations
The following functions are
21.4.1.1 Time Values and Time Range
Time measurement in ECMAScript is analogous to time measurement in POSIX, in particular sharing definition in terms of the proleptic Gregorian calendar, an epoch of midnight at the beginning of 1 January 1970 UTC, and an accounting of every day as comprising exactly 86,400 seconds (each of which is 1000 milliseconds long).
An ECMAScripttime value is a Number, either a finite
Time values do not account for UTC leap seconds—there are no time values representing instants within positive leap seconds, and there are time values representing instants removed from the UTC timeline by negative leap seconds. However, the definition of time values nonetheless yields piecewise alignment with UTC, with discontinuities only at leap second boundaries and zero difference outside of leap seconds.
A Number can exactly represent all integers from -9,007,199,254,740,992 to 9,007,199,254,740,992 (
The exact moment of midnight at the beginning of 1 January 1970 UTC is represented by the time value
The 400 year cycle of the proleptic Gregorian calendar contains 97 leap years. This yields an average of 365.2425 days per year, which is 31,556,952,000 milliseconds. Therefore, the maximum range a Number could represent exactly with millisecond precision is approximately -285,426 to 285,426 years relative to 1970. The smaller range supported by a time value as specified in this section is approximately -273,790 to 273,790 years relative to 1970.
21.4.1.2 Day Number and Time within Day
A given
where the number of milliseconds per day is
The remainder is called the time within the day:
21.4.1.3 Year Number
ECMAScript uses a proleptic Gregorian calendar to map a day number to a year number and to determine the month and date within that year. In this calendar, leap years are precisely those which are (divisible by 4) and ((not divisible by 100) or (divisible by 400)). The number of days in year numbery is therefore defined by
All non-leap years have 365 days with the usual number of days per month and leap years have an extra day in February. The day number of the first day of yeary is given by:
The
A
The leap-year function is
21.4.1.4 Month Number
Months are identified by an
where
A month value of
21.4.1.5 Date Number
A date number is identified by an
21.4.1.6 Week Day
The weekday for a particular
A weekday value of
21.4.1.7 LocalTZA (t,isUTC )
LocalTZA(t,isUTC ) is an
WhenisUTC is true,
WhenisUTC is false,
Inputt is nominally a
When
If an implementation does not support a conversion described above or if political rules for timet are not available within the implementation, the result must be
It is recommended that implementations use the time zone information of the IANA Time Zone Databasehttps://www.iana.org/time-zones/.
1:30 AM on 5 November 2017 in America/New_York is repeated twice (fall backward), but it must be interpreted as 1:30 AM UTC-04 instead of 1:30 AM UTC-05. LocalTZA(
2:30 AM on 12 March 2017 in America/New_York does not exist, but it must be interpreted as 2:30 AM UTC-05 (equivalent to 3:30 AM UTC-04). LocalTZA(
Local time zone offset values may be positiveor negative.
21.4.1.8 LocalTime (t )
The abstract operation LocalTime takes argumentt. It convertst from UTC to local time. It performs the following steps when called:
- Returnt +
LocalTZA (t,true ).
Two different input time values
21.4.1.9 UTC (t )
The abstract operation UTC takes argumentt. It convertst from local time to UTC. It performs the following steps when called:
- Returnt -
LocalTZA (t,false ).
21.4.1.10 Hours, Minutes, Second, and Milliseconds
The following
where
21.4.1.11 MakeTime (hour,min,sec,ms )
The abstract operation MakeTime takes argumentshour (a Number),min (a Number),sec (a Number), andms (a Number). It calculates a number of milliseconds. It performs the following steps when called:
- Ifhour is not finite ormin is not finite orsec is not finite orms is not finite, return
NaN . - Leth be
𝔽 (!ToIntegerOrInfinity (hour)). - Letm be
𝔽 (!ToIntegerOrInfinity (min)). - Lets be
𝔽 (!ToIntegerOrInfinity (sec)). - Letmilli be
𝔽 (!ToIntegerOrInfinity (ms)). - Lett be ((h
*msPerHour +m*msPerMinute )+s*msPerSecond )+milli, performing the arithmetic according toIEEE 754-2019 rules (that is, as if using the ECMAScript operators*and+). - Returnt.
21.4.1.12 MakeDay (year,month,date )
The abstract operation MakeDay takes argumentsyear (a Number),month (a Number), anddate (a Number). It calculates a number of days. It performs the following steps when called:
- Ifyear is not finite ormonth is not finite ordate is not finite, return
NaN . - Lety be
𝔽 (!ToIntegerOrInfinity (year)). - Letm be
𝔽 (!ToIntegerOrInfinity (month)). - Letdt be
𝔽 (!ToIntegerOrInfinity (date)). - Letym bey +
𝔽 (floor (ℝ (m) / 12)). - Ifym is not finite, return
NaN . - Letmn be
𝔽 (ℝ (m)modulo 12). - Find a finite
time value t such thatYearFromTime (t) isym andMonthFromTime (t) ismn andDateFromTime (t) is1 𝔽; but if this is not possible (because some argument is out of range), returnNaN . - Return
Day (t) +dt -1 𝔽.
21.4.1.13 MakeDate (day,time )
The abstract operation MakeDate takes argumentsday (a Number) andtime (a Number). It calculates a number of milliseconds. It performs the following steps when called:
- Ifday is not finite ortime is not finite, return
NaN . - Lettv beday ×
msPerDay +time. - Iftv is not finite, return
NaN . - Returntv.
21.4.1.14 TimeClip (time )
The abstract operation TimeClip takes argumenttime (a Number). It calculates a number of milliseconds. It performs the following steps when called:
- Iftime is not finite, return
NaN . - If
abs (ℝ (time)) > 8.64 × 1015, returnNaN . - Return
𝔽 (!ToIntegerOrInfinity (time)).
21.4.1.15 Date Time String Format
ECMAScript defines a string interchange format for date-times based upon a simplification of the ISO 8601 calendar date extended format. The format is as follows:YYYY-MM-DDTHH:mm:ss.sssZ
Where the elements are as follows:
YYYY | is the year in the proleptic Gregorian calendar as four decimal digits from 0000 to 9999, or as an |
- | |
MM | is the month of the year as two decimal digits from 01 (January) to 12 (December). |
DD | is the day of the month as two decimal digits from 01 to 31. |
T | |
HH | is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24. |
: | |
mm | is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59. |
ss | is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59. |
. | |
sss | is the number of complete milliseconds since the start of the second as three decimal digits. |
Z | is the UTC offset representation specified asHH:mm (indicating local time ahead of or behind UTC, respectively) |
This format includes date-only forms:
YYYYYYYY-MMYYYY-MM-DD
It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional UTC offset representation appended:
THH:mmTHH:mm:ssTHH:mm:ss.sss
A string containing out-of-bounds or nonconforming elements is not a valid instance of this format.
As every day both starts and ends with midnight, the two notations00:00 and24:00 are available to distinguish the two midnights that can be associated with one date. This means that the following two notations refer to exactly the same point in time:1995-02-04T24:00 and1995-02-05T00:00. This interpretation of the latter form as "end of a calendar day" is consistent with ISO 8601, even though that specification reserves it for describing time intervals and does not permit it within representations of single points in time.
There exists no international standard that specifies abbreviations for civil time zones like CET, EST, etc. and sometimes the same abbreviation is even used for two very different time zones. For this reason, both ISO 8601 and this format specify numeric representations of time zone offsets.
21.4.1.15.1 Expanded Years
Date.parse
Examples of date-time values with expanded years:
| -271821-04-20T00:00:00Z | 271822 B.C. |
| -000001-01-01T00:00:00Z | 2 B.C. |
| +000000-01-01T00:00:00Z | 1 B.C. |
| +000001-01-01T00:00:00Z | 1 A.D. |
| +001970-01-01T00:00:00Z | 1970 A.D. |
| +002009-12-15T00:00:00Z | 2009 A.D. |
| +275760-09-13T00:00:00Z | 275760 A.D. |
21.4.2 The Date Constructor
The Date
- is%Date%.
- is the initial value of the
"Date" property of theglobal object . - creates and initializes a new Date object when called as a
constructor . - returns a String representing the current time (UTC) when called as a function rather than as a
constructor . - is a function whose behaviour differs based upon the number and types of its arguments.
- is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Date behaviour must include asupercall to the Dateconstructor to create and initialize the subclass instance with a [[DateValue]] internal slot. - has a
"length" property whose value is7 𝔽.
21.4.2.1 Date ( ...values )
When theDate function is called, the following steps are taken:
- If NewTarget is
undefined , then- Letnow be the
time value (UTC) identifying the current time. - Return
ToDateString (now).
- Letnow be the
- LetnumberOfArgs be the number of elements invalues.
- IfnumberOfArgs = 0, then
- Letdv be the
time value (UTC) identifying the current time.
- Letdv be the
- Else ifnumberOfArgs = 1, then
- Letvalue bevalues[0].
- If
Type (value) is Object andvalue has a [[DateValue]] internal slot, then- Lettv be !
thisTimeValue (value).
- Lettv be !
- Else,
- Letv be ?
ToPrimitive (value). - If
Type (v) is String, thenAssert : The next step never returns anabrupt completion becauseType (v) is String.- Lettv be the result of parsingv as a date, in exactly the same manner as for the
parsemethod (21.4.3.2 ).
- Else,
- Lettv be ?
ToNumber (v).
- Lettv be ?
- Letv be ?
- Letdv be
TimeClip (tv).
- Else,
Assert :numberOfArgs ≥ 2.- Lety be ?
ToNumber (values[0]). - Letm be ?
ToNumber (values[1]). - IfnumberOfArgs > 2, letdt be ?
ToNumber (values[2]); else letdt be1 𝔽. - IfnumberOfArgs > 3, leth be ?
ToNumber (values[3]); else leth be+0 𝔽. - IfnumberOfArgs > 4, letmin be ?
ToNumber (values[4]); else letmin be+0 𝔽. - IfnumberOfArgs > 5, lets be ?
ToNumber (values[5]); else lets be+0 𝔽. - IfnumberOfArgs > 6, letmilli be ?
ToNumber (values[6]); else letmilli be+0 𝔽. - Ify is
NaN , letyr beNaN . - Else,
- Letyi be !
ToIntegerOrInfinity (y). - If 0 ≤yi ≤ 99, letyr be
1900 𝔽 +𝔽 (yi); otherwise, letyr bey.
- Letyi be !
- LetfinalDate be
MakeDate (MakeDay (yr,m,dt),MakeTime (h,min,s,milli)). - Letdv be
TimeClip (UTC (finalDate)).
- LetO be ?
OrdinaryCreateFromConstructor (NewTarget,"%Date.prototype%" , « [[DateValue]] »). - SetO.[[DateValue]] todv.
- ReturnO.
21.4.3 Properties of the Date Constructor
The Date
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
21.4.3.1 Date.now ( )
Thenow function returns thenow.
21.4.3.2 Date.parse (string )
Theparse function applies theparse interprets the resulting String as a date and time; it returns a Number, the UTCDate.parse to return
If the String conforms to theMM orDD elements are absent,HH,mm, orss elements are absent,sss element is absent,
Ifx is any Date object whose milliseconds amount is zero within a particular implementation of ECMAScript, then all of the following expressions should produce the same numeric value in that implementation, if all the properties referenced have their initial values:
x.valueOf()Date.parse(x.toString())Date.parse(x.toUTCString())Date.parse(x.toISOString())However, the expression
Date.parse(x.toLocaleString())is not required to produce the sameDate.parse istoString ortoUTCString method.
21.4.3.3 Date.prototype
The initial value ofDate.prototype is the
This property has the attributes { [[Writable]]:
21.4.3.4 Date.UTC (year [ ,month [ ,date [ ,hours [ ,minutes [ ,seconds [ ,ms ] ] ] ] ] ] )
When theUTC function is called, the following steps are taken:
- Lety be ?
ToNumber (year). - Ifmonth is present, letm be ?
ToNumber (month); else letm be+0 𝔽. - Ifdate is present, letdt be ?
ToNumber (date); else letdt be1 𝔽. - Ifhours is present, leth be ?
ToNumber (hours); else leth be+0 𝔽. - Ifminutes is present, letmin be ?
ToNumber (minutes); else letmin be+0 𝔽. - Ifseconds is present, lets be ?
ToNumber (seconds); else lets be+0 𝔽. - Ifms is present, letmilli be ?
ToNumber (ms); else letmilli be+0 𝔽. - Ify is
NaN , letyr beNaN . - Else,
- Letyi be !
ToIntegerOrInfinity (y). - If 0 ≤yi ≤ 99, letyr be
1900 𝔽 +𝔽 (yi); otherwise, letyr bey.
- Letyi be !
- Return
TimeClip (MakeDate (MakeDay (yr,m,dt),MakeTime (h,min,s,milli))).
TheUTC function is
TheUTC function differs from the Date
21.4.4 Properties of the Date Prototype Object
TheDate prototype object:
- is%Date.prototype%.
- is itself an
ordinary object . - is not a Date instance and does not have a [[DateValue]] internal slot.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% .
Unless explicitly defined otherwise, the methods of the Date prototype object defined below are not generic and the
The abstract operationthisTimeValue takes argumentvalue. It performs the following steps when called:
- If
Type (value) is Object andvalue has a [[DateValue]] internal slot, then- Returnvalue.[[DateValue]].
- Throw a
TypeError exception.
In following descriptions of functions that are properties of the Date prototype object, the phrase “this Date object” refers to the object that is the
21.4.4.1 Date.prototype.constructor
The initial value ofDate.prototype.constructor is
21.4.4.2 Date.prototype.getDate ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
DateFromTime (LocalTime (t)).
21.4.4.3 Date.prototype.getDay ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
WeekDay (LocalTime (t)).
21.4.4.4 Date.prototype.getFullYear ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
YearFromTime (LocalTime (t)).
21.4.4.5 Date.prototype.getHours ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
HourFromTime (LocalTime (t)).
21.4.4.6 Date.prototype.getMilliseconds ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
msFromTime (LocalTime (t)).
21.4.4.7 Date.prototype.getMinutes ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
MinFromTime (LocalTime (t)).
21.4.4.8 Date.prototype.getMonth ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
MonthFromTime (LocalTime (t)).
21.4.4.9 Date.prototype.getSeconds ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
SecFromTime (LocalTime (t)).
21.4.4.10 Date.prototype.getTime ( )
The following steps are performed:
- Return ?
thisTimeValue (this value).
21.4.4.11 Date.prototype.getTimezoneOffset ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return (t -
LocalTime (t)) /msPerMinute .
21.4.4.12 Date.prototype.getUTCDate ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
DateFromTime (t).
21.4.4.13 Date.prototype.getUTCDay ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
WeekDay (t).
21.4.4.14 Date.prototype.getUTCFullYear ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
YearFromTime (t).
21.4.4.15 Date.prototype.getUTCHours ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
HourFromTime (t).
21.4.4.16 Date.prototype.getUTCMilliseconds ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
msFromTime (t).
21.4.4.17 Date.prototype.getUTCMinutes ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
MinFromTime (t).
21.4.4.18 Date.prototype.getUTCMonth ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
MonthFromTime (t).
21.4.4.19 Date.prototype.getUTCSeconds ( )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
SecFromTime (t).
21.4.4.20 Date.prototype.setDate (date )
The following steps are performed:
- Lett be
LocalTime (?thisTimeValue (this value)). - Letdt be ?
ToNumber (date). - LetnewDate be
MakeDate (MakeDay (YearFromTime (t),MonthFromTime (t),dt),TimeWithinDay (t)). - Letu be
TimeClip (UTC (newDate)). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
21.4.4.21 Date.prototype.setFullYear (year [ ,month [ ,date ] ] )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , sett to+0 𝔽; otherwise, sett toLocalTime (t). - Lety be ?
ToNumber (year). - Ifmonth is not present, letm be
MonthFromTime (t); otherwise, letm be ?ToNumber (month). - Ifdate is not present, letdt be
DateFromTime (t); otherwise, letdt be ?ToNumber (date). - LetnewDate be
MakeDate (MakeDay (y,m,dt),TimeWithinDay (t)). - Letu be
TimeClip (UTC (newDate)). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
ThesetFullYear method is
Ifmonth is not present, this method behaves as ifmonth was present with the valuegetMonth(). Ifdate is not present, it behaves as ifdate was present with the valuegetDate().
21.4.4.22 Date.prototype.setHours (hour [ ,min [ ,sec [ ,ms ] ] ] )
The following steps are performed:
- Lett be
LocalTime (?thisTimeValue (this value)). - Leth be ?
ToNumber (hour). - Ifmin is not present, letm be
MinFromTime (t); otherwise, letm be ?ToNumber (min). - Ifsec is not present, lets be
SecFromTime (t); otherwise, lets be ?ToNumber (sec). - Ifms is not present, letmilli be
msFromTime (t); otherwise, letmilli be ?ToNumber (ms). - Letdate be
MakeDate (Day (t),MakeTime (h,m,s,milli)). - Letu be
TimeClip (UTC (date)). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
ThesetHours method is
Ifmin is not present, this method behaves as ifmin was present with the valuegetMinutes(). Ifsec is not present, it behaves as ifsec was present with the valuegetSeconds(). Ifms is not present, it behaves as ifms was present with the valuegetMilliseconds().
21.4.4.23 Date.prototype.setMilliseconds (ms )
The following steps are performed:
- Lett be
LocalTime (?thisTimeValue (this value)). - Setms to ?
ToNumber (ms). - Lettime be
MakeTime (HourFromTime (t),MinFromTime (t),SecFromTime (t),ms). - Letu be
TimeClip (UTC (MakeDate (Day (t),time))). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
21.4.4.24 Date.prototype.setMinutes (min [ ,sec [ ,ms ] ] )
The following steps are performed:
- Lett be
LocalTime (?thisTimeValue (this value)). - Letm be ?
ToNumber (min). - Ifsec is not present, lets be
SecFromTime (t); otherwise, lets be ?ToNumber (sec). - Ifms is not present, letmilli be
msFromTime (t); otherwise, letmilli be ?ToNumber (ms). - Letdate be
MakeDate (Day (t),MakeTime (HourFromTime (t),m,s,milli)). - Letu be
TimeClip (UTC (date)). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
ThesetMinutes method is
Ifsec is not present, this method behaves as ifsec was present with the valuegetSeconds(). Ifms is not present, this behaves as ifms was present with the valuegetMilliseconds().
21.4.4.25 Date.prototype.setMonth (month [ ,date ] )
The following steps are performed:
- Lett be
LocalTime (?thisTimeValue (this value)). - Letm be ?
ToNumber (month). - Ifdate is not present, letdt be
DateFromTime (t); otherwise, letdt be ?ToNumber (date). - LetnewDate be
MakeDate (MakeDay (YearFromTime (t),m,dt),TimeWithinDay (t)). - Letu be
TimeClip (UTC (newDate)). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
ThesetMonth method is
Ifdate is not present, this method behaves as ifdate was present with the valuegetDate().
21.4.4.26 Date.prototype.setSeconds (sec [ ,ms ] )
The following steps are performed:
- Lett be
LocalTime (?thisTimeValue (this value)). - Lets be ?
ToNumber (sec). - Ifms is not present, letmilli be
msFromTime (t); otherwise, letmilli be ?ToNumber (ms). - Letdate be
MakeDate (Day (t),MakeTime (HourFromTime (t),MinFromTime (t),s,milli)). - Letu be
TimeClip (UTC (date)). - Set the [[DateValue]] internal slot of
this Date object tou. - Returnu.
ThesetSeconds method is
Ifms is not present, this method behaves as ifms was present with the valuegetMilliseconds().
21.4.4.27 Date.prototype.setTime (time )
The following steps are performed:
- Perform ?
thisTimeValue (this value). - Lett be ?
ToNumber (time). - Letv be
TimeClip (t). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
21.4.4.28 Date.prototype.setUTCDate (date )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Letdt be ?
ToNumber (date). - LetnewDate be
MakeDate (MakeDay (YearFromTime (t),MonthFromTime (t),dt),TimeWithinDay (t)). - Letv be
TimeClip (newDate). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
21.4.4.29 Date.prototype.setUTCFullYear (year [ ,month [ ,date ] ] )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , sett to+0 𝔽. - Lety be ?
ToNumber (year). - Ifmonth is not present, letm be
MonthFromTime (t); otherwise, letm be ?ToNumber (month). - Ifdate is not present, letdt be
DateFromTime (t); otherwise, letdt be ?ToNumber (date). - LetnewDate be
MakeDate (MakeDay (y,m,dt),TimeWithinDay (t)). - Letv be
TimeClip (newDate). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
ThesetUTCFullYear method is
Ifmonth is not present, this method behaves as ifmonth was present with the valuegetUTCMonth(). Ifdate is not present, it behaves as ifdate was present with the valuegetUTCDate().
21.4.4.30 Date.prototype.setUTCHours (hour [ ,min [ ,sec [ ,ms ] ] ] )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Leth be ?
ToNumber (hour). - Ifmin is not present, letm be
MinFromTime (t); otherwise, letm be ?ToNumber (min). - Ifsec is not present, lets be
SecFromTime (t); otherwise, lets be ?ToNumber (sec). - Ifms is not present, letmilli be
msFromTime (t); otherwise, letmilli be ?ToNumber (ms). - LetnewDate be
MakeDate (Day (t),MakeTime (h,m,s,milli)). - Letv be
TimeClip (newDate). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
ThesetUTCHours method is
Ifmin is not present, this method behaves as ifmin was present with the valuegetUTCMinutes(). Ifsec is not present, it behaves as ifsec was present with the valuegetUTCSeconds(). Ifms is not present, it behaves as ifms was present with the valuegetUTCMilliseconds().
21.4.4.31 Date.prototype.setUTCMilliseconds (ms )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Letmilli be ?
ToNumber (ms). - Lettime be
MakeTime (HourFromTime (t),MinFromTime (t),SecFromTime (t),milli). - Letv be
TimeClip (MakeDate (Day (t),time)). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
21.4.4.32 Date.prototype.setUTCMinutes (min [ ,sec [ ,ms ] ] )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Letm be ?
ToNumber (min). - Ifsec is not present, lets be
SecFromTime (t). - Else,
- Lets be ?
ToNumber (sec).
- Lets be ?
- Ifms is not present, letmilli be
msFromTime (t). - Else,
- Letmilli be ?
ToNumber (ms).
- Letmilli be ?
- Letdate be
MakeDate (Day (t),MakeTime (HourFromTime (t),m,s,milli)). - Letv be
TimeClip (date). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
ThesetUTCMinutes method is
Ifsec is not present, this method behaves as ifsec was present with the valuegetUTCSeconds(). Ifms is not present, it function behaves as ifms was present with the value return bygetUTCMilliseconds().
21.4.4.33 Date.prototype.setUTCMonth (month [ ,date ] )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Letm be ?
ToNumber (month). - Ifdate is not present, letdt be
DateFromTime (t). - Else,
- Letdt be ?
ToNumber (date).
- Letdt be ?
- LetnewDate be
MakeDate (MakeDay (YearFromTime (t),m,dt),TimeWithinDay (t)). - Letv be
TimeClip (newDate). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
ThesetUTCMonth method is
Ifdate is not present, this method behaves as ifdate was present with the valuegetUTCDate().
21.4.4.34 Date.prototype.setUTCSeconds (sec [ ,ms ] )
The following steps are performed:
- Lett be ?
thisTimeValue (this value). - Lets be ?
ToNumber (sec). - Ifms is not present, letmilli be
msFromTime (t). - Else,
- Letmilli be ?
ToNumber (ms).
- Letmilli be ?
- Letdate be
MakeDate (Day (t),MakeTime (HourFromTime (t),MinFromTime (t),s,milli)). - Letv be
TimeClip (date). - Set the [[DateValue]] internal slot of
this Date object tov. - Returnv.
ThesetUTCSeconds method is
Ifms is not present, this method behaves as ifms was present with the valuegetUTCMilliseconds().
21.4.4.35 Date.prototype.toDateString ( )
The following steps are performed:
- LetO be
this Date object . - Lettv be ?
thisTimeValue (O). - Iftv is
NaN , return"Invalid Date" . - Lett be
LocalTime (tv). - Return
DateString (t).
21.4.4.36 Date.prototype.toISOString ( )
If
21.4.4.37 Date.prototype.toJSON (key )
This function provides a String representation of a Date object for use byJSON.stringify (
When thetoJSON method is called with argumentkey, the following steps are taken:
- LetO be ?
ToObject (this value). - Lettv be ?
ToPrimitive (O,number ). - If
Type (tv) is Number andtv is not finite, returnnull . - Return ?
Invoke (O,"toISOString" ).
The argument is ignored.
ThetoJSON function is intentionally generic; it does not require that itstoISOString method.
21.4.4.38 Date.prototype.toLocaleDateString ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement theDate.prototype.toLocaleDateString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleDateString method is used.
This function returns a String value. The contents of the String are
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
21.4.4.39 Date.prototype.toLocaleString ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement theDate.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleString method is used.
This function returns a String value. The contents of the String are
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
21.4.4.40 Date.prototype.toLocaleTimeString ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement theDate.prototype.toLocaleTimeString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleTimeString method is used.
This function returns a String value. The contents of the String are
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
21.4.4.41 Date.prototype.toString ( )
The following steps are performed:
- Lettv be ?
thisTimeValue (this value). - Return
ToDateString (tv).
For any Date objectd such thatd.[[DateValue]] is evenly divisible by 1000, the result ofDate.parse(d.toString()) =d.valueOf(). See
ThetoString function is not generic; it throws a
21.4.4.41.1 TimeString (tv )
The abstract operation TimeString takes argumenttv. It performs the following steps when called:
Assert :Type (tv) is Number.Assert :tv is notNaN .- Lethour be the String representation of
HourFromTime (tv), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - Letminute be the String representation of
MinFromTime (tv), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - Letsecond be the String representation of
SecFromTime (tv), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - Return the
string-concatenation ofhour,":" ,minute,":" ,second, the code unit 0x0020 (SPACE), and"GMT" .
21.4.4.41.2 DateString (tv )
The abstract operation DateString takes argumenttv. It performs the following steps when called:
Assert :Type (tv) is Number.Assert :tv is notNaN .- Letweekday be the Name of the entry in
Table 52 with the NumberWeekDay (tv). - Letmonth be the Name of the entry in
Table 53 with the NumberMonthFromTime (tv). - Letday be the String representation of
DateFromTime (tv), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - Letyv be
YearFromTime (tv). - Ifyv ≥
+0 𝔽, letyearSign be the empty String; otherwise, letyearSign be"-" . - Letyear be the String representation of
abs (ℝ (yv)), formatted as a decimal number. - LetpaddedYear be !
StringPad (year,4 𝔽,"0" ,start ). - Return the
string-concatenation ofweekday, the code unit 0x0020 (SPACE),month, the code unit 0x0020 (SPACE),day, the code unit 0x0020 (SPACE),yearSign, andpaddedYear.
| Number | Name |
|---|---|
| Number | Name |
|---|---|
21.4.4.41.3 TimeZoneString (tv )
The abstract operation TimeZoneString takes argumenttv. It performs the following steps when called:
Assert :Type (tv) is Number.Assert :tv is notNaN .- Letoffset be
LocalTZA (tv,true ). - Ifoffset ≥
+0 𝔽, then- LetoffsetSign be
"+" . - LetabsOffset beoffset.
- LetoffsetSign be
- Else,
- LetoffsetSign be
"-" . - LetabsOffset be -offset.
- LetoffsetSign be
- LetoffsetMin be the String representation of
MinFromTime (absOffset), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - LetoffsetHour be the String representation of
HourFromTime (absOffset), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - LettzName be an
implementation-defined string that is either the empty String or thestring-concatenation of the code unit 0x0020 (SPACE), the code unit 0x0028 (LEFT PARENTHESIS), animplementation-defined timezone name, and the code unit 0x0029 (RIGHT PARENTHESIS). - Return the
string-concatenation ofoffsetSign,offsetHour,offsetMin, andtzName.
21.4.4.41.4 ToDateString (tv )
The abstract operation ToDateString takes argumenttv. It performs the following steps when called:
Assert :Type (tv) is Number.- Iftv is
NaN , return"Invalid Date" . - Lett be
LocalTime (tv). - Return the
string-concatenation ofDateString (t), the code unit 0x0020 (SPACE),TimeString (t), andTimeZoneString (tv).
21.4.4.42 Date.prototype.toTimeString ( )
The following steps are performed:
- LetO be
this Date object . - Lettv be ?
thisTimeValue (O). - Iftv is
NaN , return"Invalid Date" . - Lett be
LocalTime (tv). - Return the
string-concatenation ofTimeString (t) andTimeZoneString (tv).
21.4.4.43 Date.prototype.toUTCString ( )
ThetoUTCString method returns a String value representing the instance in time corresponding to
- LetO be
this Date object . - Lettv be ?
thisTimeValue (O). - Iftv is
NaN , return"Invalid Date" . - Letweekday be the Name of the entry in
Table 52 with the NumberWeekDay (tv). - Letmonth be the Name of the entry in
Table 53 with the NumberMonthFromTime (tv). - Letday be the String representation of
DateFromTime (tv), formatted as a two-digit decimal number, padded to the left with the code unit 0x0030 (DIGIT ZERO) if necessary. - Letyv be
YearFromTime (tv). - Ifyv ≥
+0 𝔽, letyearSign be the empty String; otherwise, letyearSign be"-" . - Letyear be the String representation of
abs (ℝ (yv)), formatted as a decimal number. - LetpaddedYear be !
StringPad (year,4 𝔽,"0" ,start ). - Return the
string-concatenation ofweekday,"," , the code unit 0x0020 (SPACE),day, the code unit 0x0020 (SPACE),month, the code unit 0x0020 (SPACE),yearSign,paddedYear, the code unit 0x0020 (SPACE), andTimeString (tv).
21.4.4.44 Date.prototype.valueOf ( )
The following steps are performed:
- Return ?
thisTimeValue (this value).
21.4.4.45 Date.prototype [ @@toPrimitive ] (hint )
This function is called by ECMAScript language operators to convert a Date object to a primitive value. The allowed values forhint are
When the@@toPrimitive method is called with argumenthint, the following steps are taken:
- LetO be the
this value. - If
Type (O) is not Object, throw aTypeError exception. - Ifhint is
"string" or"default" , then- LettryFirst be
string .
- LettryFirst be
- Else ifhint is
"number" , then- LettryFirst be
number .
- LettryFirst be
- Else, throw a
TypeError exception. - Return ?
OrdinaryToPrimitive (O,tryFirst).
The value of the
This property has the attributes { [[Writable]]:
21.4.5 Properties of Date Instances
Date instances are ordinary objects that inherit properties from the
22 Text Processing
22.1 String Objects
22.1.1 The String Constructor
The String
- is%String%.
- is the initial value of the
"String" property of theglobal object . - creates and initializes a new String object when called as a
constructor . - performs a type conversion when called as a function rather than as a
constructor . - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified String behaviour must include asupercall to the Stringconstructor to create and initialize the subclass instance with a [[StringData]] internal slot.
22.1.1.1 String (value )
WhenString is called with argumentvalue, the following steps are taken:
- Ifvalue is not present, lets be the empty String.
- Else,
- If NewTarget is
undefined andType (value) is Symbol, returnSymbolDescriptiveString (value). - Lets be ?
ToString (value).
- If NewTarget is
- If NewTarget is
undefined , returns. - Return !
StringCreate (s, ?GetPrototypeFromConstructor (NewTarget,"%String.prototype%" )).
22.1.2 Properties of the String Constructor
The String
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
22.1.2.1 String.fromCharCode ( ...codeUnits )
TheString.fromCharCode function may be called with any number of arguments which form the rest parametercodeUnits. The following steps are taken:
ThefromCharCode function is
22.1.2.2 String.fromCodePoint ( ...codePoints )
TheString.fromCodePoint function may be called with any number of arguments which form the rest parametercodePoints. The following steps are taken:
- Letresult be the empty String.
- For each elementnext ofcodePoints, do
- LetnextCP be ?
ToNumber (next). - If !
IsIntegralNumber (nextCP) isfalse , throw aRangeError exception. - If
ℝ (nextCP) < 0 orℝ (nextCP) > 0x10FFFF, throw aRangeError exception. - Setresult to the
string-concatenation ofresult and !UTF16EncodeCodePoint (ℝ (nextCP)).
- LetnextCP be ?
Assert : IfcodePoints is empty, thenresult is the empty String.- Returnresult.
ThefromCodePoint function is
22.1.2.3 String.prototype
The initial value ofString.prototype is the
This property has the attributes { [[Writable]]:
22.1.2.4 String.raw (template, ...substitutions )
TheString.raw function may be called with a variable number of arguments. The first argument istemplate and the remainder of the arguments form the
- LetnumberOfSubstitutions be the number of elements insubstitutions.
- Letcooked be ?
ToObject (template). - Letraw be ?
ToObject (?Get (cooked,"raw" )). - LetliteralSegments be ?
LengthOfArrayLike (raw). - IfliteralSegments ≤ 0, return the empty String.
- LetstringElements be a new empty
List . - LetnextIndex be 0.
- Repeat,
- LetnextKey be !
ToString (𝔽 (nextIndex)). - LetnextSeg be ?
ToString (?Get (raw,nextKey)). - Append the code unit elements ofnextSeg to the end ofstringElements.
- IfnextIndex + 1 =literalSegments, then
- Return the String value whose code units are the elements in the
List stringElements. IfstringElements has no elements, the empty String is returned.
- Return the String value whose code units are the elements in the
- IfnextIndex <numberOfSubstitutions, letnext besubstitutions[nextIndex].
- Else, letnext be the empty String.
- LetnextSub be ?
ToString (next). - Append the code unit elements ofnextSub to the end ofstringElements.
- SetnextIndex tonextIndex + 1.
- LetnextKey be !
Theraw function is intended for use as a tag function of a Tagged Template (
22.1.3 Properties of the String Prototype Object
TheString prototype object:
- is%String.prototype%.
- is a
String exotic object and has the internal methods specified for such objects. - has a [[StringData]] internal slot whose value is the empty String.
- has a
"length" property whose initial value is+0 𝔽 and whose attributes are { [[Writable]]:false , [[Enumerable]]:false , [[Configurable]]:false }. - has a [[Prototype]] internal slot whose value is
%Object.prototype% .
Unless explicitly stated otherwise, the methods of the String prototype object defined below are not generic and the
The abstract operationthisStringValue takes argumentvalue. It performs the following steps when called:
22.1.3.1 String.prototype.charAt (pos )
Returns a single element String containing the code unit at indexpos within the String value resulting from converting this object to a String. If there is no element at that index, the result is the empty String. The result is a String value, not a String object.
Ifpos is anx.charAt(pos) is equivalent to the result ofx.substring(pos, pos + 1).
When thecharAt method is called with one argumentpos, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letposition be ?
ToIntegerOrInfinity (pos). - Letsize be the length ofS.
- Ifposition < 0 orposition ≥size, return the empty String.
- Return the String value of length 1, containing one code unit fromS, namely the code unit at indexposition.
ThecharAt function is intentionally generic; it does not require that its
22.1.3.2 String.prototype.charCodeAt (pos )
Returns a Number (a non-negative
When thecharCodeAt method is called with one argumentpos, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letposition be ?
ToIntegerOrInfinity (pos). - Letsize be the length ofS.
- Ifposition < 0 orposition ≥size, return
NaN . - Return the
Number value for the numeric value of the code unit at indexposition within the StringS.
ThecharCodeAt function is intentionally generic; it does not require that its
22.1.3.3 String.prototype.codePointAt (pos )
Returns a non-negative
When thecodePointAt method is called with one argumentpos, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letposition be ?
ToIntegerOrInfinity (pos). - Letsize be the length ofS.
- Ifposition < 0 orposition ≥size, return
undefined . - Letcp be !
CodePointAt (S,position). - Return
𝔽 (cp.[[CodePoint]]).
ThecodePointAt function is intentionally generic; it does not require that its
22.1.3.4 String.prototype.concat ( ...args )
When theconcat method is called it returns the String value consisting of the code units of the
When theconcat method is called with zero or more arguments, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetR beS.
- For each elementnext ofargs, do
- LetnextString be ?
ToString (next). - SetR to the
string-concatenation ofR andnextString.
- LetnextString be ?
- ReturnR.
Theconcat method is
Theconcat function is intentionally generic; it does not require that its
22.1.3.5 String.prototype.constructor
The initial value ofString.prototype.constructor is
22.1.3.6 String.prototype.endsWith (searchString [ ,endPosition ] )
The following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetisRegExp be ?
IsRegExp (searchString). - IfisRegExp is
true , throw aTypeError exception. - LetsearchStr be ?
ToString (searchString). - Letlen be the length ofS.
- IfendPosition is
undefined , letpos belen; else letpos be ?ToIntegerOrInfinity (endPosition). - Letend be the result of
clamping pos between 0 andlen. - LetsearchLength be the length ofsearchStr.
- IfsearchLength = 0, return
true . - Letstart beend -searchLength.
- Ifstart < 0, return
false . - Letsubstring be the
substring ofS fromstart toend. - Return !
SameValueNonNumeric (substring,searchStr).
Returns
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
TheendsWith function is intentionally generic; it does not require that its
22.1.3.7 String.prototype.includes (searchString [ ,position ] )
Theincludes method takes two arguments,searchString andposition, and performs the following steps:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetisRegExp be ?
IsRegExp (searchString). - IfisRegExp is
true , throw aTypeError exception. - LetsearchStr be ?
ToString (searchString). - Letpos be ?
ToIntegerOrInfinity (position). Assert : Ifposition isundefined , thenpos is 0.- Letlen be the length ofS.
- Letstart be the result of
clamping pos between 0 andlen. - Letindex be !
StringIndexOf (S,searchStr,start). - Ifindex is not -1, return
true . - Return
false .
IfsearchString appears as a
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
Theincludes function is intentionally generic; it does not require that its
22.1.3.8 String.prototype.indexOf (searchString [ ,position ] )
IfsearchString appears as a
TheindexOf method takes two arguments,searchString andposition, and performs the following steps:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetsearchStr be ?
ToString (searchString). - Letpos be ?
ToIntegerOrInfinity (position). Assert : Ifposition isundefined , thenpos is 0.- Letlen be the length ofS.
- Letstart be the result of
clamping pos between 0 andlen. - Return
𝔽 (!StringIndexOf (S,searchStr,start)).
TheindexOf function is intentionally generic; it does not require that its
22.1.3.9 String.prototype.lastIndexOf (searchString [ ,position ] )
IfsearchString appears as a
ThelastIndexOf method takes two arguments,searchString andposition, and performs the following steps:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetsearchStr be ?
ToString (searchString). - LetnumPos be ?
ToNumber (position). Assert : Ifposition isundefined , thennumPos isNaN .- IfnumPos is
NaN , letpos be +∞; otherwise, letpos be !ToIntegerOrInfinity (numPos). - Letlen be the length ofS.
- Letstart be the result of
clamping pos between 0 andlen. - LetsearchLen be the length ofsearchStr.
- Letk be the largest possible non-negative
integer not larger thanstart such thatk +searchLen ≤len, and for all non-negative integersj such thatj <searchLen, the code unit at indexk +j withinS is the same as the code unit at indexj withinsearchStr; but if there is no suchinteger , letk be -1. - Return
𝔽 (k).
ThelastIndexOf function is intentionally generic; it does not require that its
22.1.3.10 String.prototype.localeCompare (that [ ,reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement thelocaleCompare method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thelocaleCompare method is used.
When thelocaleCompare method is called with argumentthat, it returns a Number other than
Before performing the comparisons, the following steps are performed to prepare the Strings:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetThat be ?
ToString (that).
The meaning of the optional second and third parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not assign any other interpretation to those parameter positions.
ThelocaleCompare method, if considered as a function of two arguments
The actual return values are0 when comparing Strings that are considered canonically equivalent.
ThelocaleCompare method itself is not directly suitable as an argument toArray.prototype.sort because the latter requires a function of two arguments.
This function is intended to rely on whatever language-sensitive comparison functionality is available to the ECMAScript environment from the
ThelocaleCompare function is intentionally generic; it does not require that its
22.1.3.11 String.prototype.match (regexp )
When thematch method is called with argumentregexp, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - Ifregexp is neither
undefined nornull , then - LetS be ?
ToString (O). - Letrx be ?
RegExpCreate (regexp,undefined ). - Return ?
Invoke (rx,@@match , «S »).
Thematch function is intentionally generic; it does not require that its
22.1.3.12 String.prototype.matchAll (regexp )
Performs a regular expression match of the String representing the
When thematchAll method is called, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - Ifregexp is neither
undefined nornull , then- LetisRegExp be ?
IsRegExp (regexp). - IfisRegExp is
true , then- Letflags be ?
Get (regexp,"flags" ). - Perform ?
RequireObjectCoercible (flags). - If ?
ToString (flags) does not contain"g" , throw aTypeError exception.
- Letflags be ?
- Letmatcher be ?
GetMethod (regexp,@@matchAll ). - Ifmatcher is not
undefined , then- Return ?
Call (matcher,regexp, «O »).
- Return ?
- LetisRegExp be ?
- LetS be ?
ToString (O). - Letrx be ?
RegExpCreate (regexp,"g" ). - Return ?
Invoke (rx,@@matchAll , «S »).
matchAll function is intentionally generic, it does not require that itsString.prototype.split,String.prototype.matchAll is designed to typically act without mutating its inputs.22.1.3.13 String.prototype.normalize ( [form ] )
When thenormalize method is called with one argumentform, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Ifform is
undefined , letf be"NFC" . - Else, letf be ?
ToString (form). - Iff is not one of
"NFC" ,"NFD" ,"NFKC" , or"NFKD" , throw aRangeError exception. - Letns be the String value that is the result of normalizingS into the normalization form named byf as specified inhttps://unicode.org/reports/tr15/.
- Returnns.
Thenormalize function is intentionally generic; it does not require that its
22.1.3.14 String.prototype.padEnd (maxLength [ ,fillString ] )
When thepadEnd method is called, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - Return ?
StringPad (O,maxLength,fillString,end ).
22.1.3.15 String.prototype.padStart (maxLength [ ,fillString ] )
When thepadStart method is called, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - Return ?
StringPad (O,maxLength,fillString,start ).
22.1.3.15.1 StringPad (O,maxLength,fillString,placement )
The abstract operation StringPad takes argumentsO,maxLength,fillString, andplacement. It performs the following steps when called:
Assert :placement isstart orend .- LetS be ?
ToString (O). - LetintMaxLength be
ℝ (?ToLength (maxLength)). - LetstringLength be the length ofS.
- IfintMaxLength ≤stringLength, returnS.
- IffillString is
undefined , letfiller be the String value consisting solely of the code unit 0x0020 (SPACE). - Else, letfiller be ?
ToString (fillString). - Iffiller is the empty String, returnS.
- LetfillLen beintMaxLength -stringLength.
- LettruncatedStringFiller be the String value consisting of repeated concatenations offiller truncated to lengthfillLen.
- Ifplacement is
start , return thestring-concatenation oftruncatedStringFiller andS. - Else, return the
string-concatenation ofS andtruncatedStringFiller.
The argumentmaxLength will be clamped such that it can be no smaller than the length ofS.
The argumentfillString defaults to
22.1.3.16 String.prototype.repeat (count )
The following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letn be ?
ToIntegerOrInfinity (count). - Ifn < 0 orn is +∞, throw a
RangeError exception. - Ifn is 0, return the empty String.
- Return the String value that is made fromn copies ofS appended together.
This method creates the String value consisting of the code units of the
Therepeat function is intentionally generic; it does not require that its
22.1.3.17 String.prototype.replace (searchValue,replaceValue )
When thereplace method is called with argumentssearchValue andreplaceValue, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - IfsearchValue is neither
undefined nornull , then - Letstring be ?
ToString (O). - LetsearchString be ?
ToString (searchValue). - LetfunctionalReplace be
IsCallable (replaceValue). - IffunctionalReplace is
false , then- SetreplaceValue to ?
ToString (replaceValue).
- SetreplaceValue to ?
- LetsearchLength be the length ofsearchString.
- Letposition be !
StringIndexOf (string,searchString, 0). - Ifposition is -1, returnstring.
- Letpreserved be the
substring ofstring from 0 toposition. - IffunctionalReplace is
true , then - Else,
Assert :Type (replaceValue) is String.- Letcaptures be a new empty
List . - Letreplacement be !
GetSubstitution (searchString,string,position,captures,undefined ,replaceValue).
- Return the
string-concatenation ofpreserved,replacement, and thesubstring ofstring fromposition +searchLength.
Thereplace function is intentionally generic; it does not require that its
22.1.3.17.1 GetSubstitution (matched,str,position,captures,namedCaptures,replacement )
The abstract operation GetSubstitution takes argumentsmatched,str,position (a non-negative
Assert :Type (matched) is String.- LetmatchLength be the number of code units inmatched.
Assert :Type (str) is String.- LetstringLength be the number of code units instr.
Assert :position ≤stringLength.Assert :captures is a possibly emptyList of Strings.Assert :Type (replacement) is String.- LettailPos beposition +matchLength.
- Letm be the number of elements incaptures.
- Letresult be the String value derived fromreplacement by copying code unit elements fromreplacement toresult while performing replacements as specified in
Table 54 . These$replacements are done left-to-right, and, once such a replacement is performed, the new replacement text is not subject to further replacements. - Returnresult.
| Code units | Unicode Characters | Replacement text |
|---|---|---|
| 0x0024, 0x0024 | $$ | $ |
| 0x0024, 0x0026 | $& | matched |
| 0x0024, 0x0060 | $` | The replacement is the |
| 0x0024, 0x0027 | $' | IftailPos ≥stringLength, the replacement is the empty String. Otherwise the replacement is the |
| 0x0024, N Where 0x0031 ≤ N ≤ 0x0039 | $n wheren is one of1 2 3 4 5 6 7 8 9 and$n is not followed by a decimal digit | Thenth element ofcaptures, wheren is a single digit in the range 1 to 9. Ifn ≤m and thenth element ofcaptures is |
| 0x0024, N, N Where 0x0030 ≤ N ≤ 0x0039 | $nn wheren is one of0 1 2 3 4 5 6 7 8 9 | Thennth element ofcaptures, wherenn is a two-digit decimal number in the range 01 to 99. Ifnn ≤m and thennth element ofcaptures is |
| 0x0024, 0x003C | $< | |
| 0x0024 | $ in any context that does not match any of the above. | $ |
22.1.3.18 String.prototype.replaceAll (searchValue,replaceValue )
When thereplaceAll method is called with argumentssearchValue andreplaceValue, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - IfsearchValue is neither
undefined nornull , then- LetisRegExp be ?
IsRegExp (searchValue). - IfisRegExp is
true , then- Letflags be ?
Get (searchValue,"flags" ). - Perform ?
RequireObjectCoercible (flags). - If ?
ToString (flags) does not contain"g" , throw aTypeError exception.
- Letflags be ?
- Letreplacer be ?
GetMethod (searchValue,@@replace ). - Ifreplacer is not
undefined , then- Return ?
Call (replacer,searchValue, «O,replaceValue »).
- Return ?
- LetisRegExp be ?
- Letstring be ?
ToString (O). - LetsearchString be ?
ToString (searchValue). - LetfunctionalReplace be
IsCallable (replaceValue). - IffunctionalReplace is
false , then- SetreplaceValue to ?
ToString (replaceValue).
- SetreplaceValue to ?
- LetsearchLength be the length ofsearchString.
- LetadvanceBy be
max (1,searchLength). - LetmatchPositions be a new empty
List . - Letposition be !
StringIndexOf (string,searchString, 0). - Repeat, whileposition is not -1,
- Appendposition to the end ofmatchPositions.
- Setposition to !
StringIndexOf (string,searchString,position +advanceBy).
- LetendOfLastMatch be 0.
- Letresult be the empty String.
- For each elementp ofmatchPositions, do
- Letpreserved be the
substring ofstring fromendOfLastMatch top. - IffunctionalReplace is
true , then - Else,
Assert :Type (replaceValue) is String.- Letcaptures be a new empty
List . - Letreplacement be !
GetSubstitution (searchString,string,p,captures,undefined ,replaceValue).
- Setresult to the
string-concatenation ofresult,preserved, andreplacement. - SetendOfLastMatch top +searchLength.
- Letpreserved be the
- IfendOfLastMatch < the length ofstring, then
- Setresult to the
string-concatenation ofresult and thesubstring ofstring fromendOfLastMatch.
- Setresult to the
- Returnresult.
22.1.3.19 String.prototype.search (regexp )
When thesearch method is called with argumentregexp, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - Ifregexp is neither
undefined nornull , then - Letstring be ?
ToString (O). - Letrx be ?
RegExpCreate (regexp,undefined ). - Return ?
Invoke (rx,@@search , «string »).
Thesearch function is intentionally generic; it does not require that its
22.1.3.20 String.prototype.slice (start,end )
Theslice method takes two arguments,start andend, and returns a
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letlen be the length ofS.
- LetintStart be ?
ToIntegerOrInfinity (start). - IfintStart is -∞, letfrom be 0.
- Else ifintStart < 0, letfrom be
max (len +intStart, 0). - Else, letfrom be
min (intStart,len). - Ifend is
undefined , letintEnd belen; else letintEnd be ?ToIntegerOrInfinity (end). - IfintEnd is -∞, letto be 0.
- Else ifintEnd < 0, letto be
max (len +intEnd, 0). - Else, letto be
min (intEnd,len). - Iffrom ≥to, return the empty String.
- Return the
substring ofS fromfrom toto.
Theslice function is intentionally generic; it does not require that its
22.1.3.21 String.prototype.split (separator,limit )
Returns an Array object into which substrings of the result of converting this object to a String have been stored. The substrings are determined by searching from left to right for occurrences ofseparator; these occurrences are not part of any String in the returned array, but serve to divide up the String value. The value ofseparator may be a String of any length or it may be an object, such as a RegExp, that has a
When thesplit method is called, the following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - Ifseparator is neither
undefined nornull , then - LetS be ?
ToString (O). - LetA be !
ArrayCreate (0). - LetlengthA be 0.
- Iflimit is
undefined , letlim be 232 - 1; else letlim beℝ (?ToUint32 (limit)). - LetR be ?
ToString (separator). - Iflim = 0, returnA.
- Ifseparator is
undefined , then- Perform !
CreateDataPropertyOrThrow (A,"0" ,S). - ReturnA.
- Perform !
- Lets be the length ofS.
- Ifs = 0, then
- IfR is not the empty String, then
- Perform !
CreateDataPropertyOrThrow (A,"0" ,S).
- Perform !
- ReturnA.
- IfR is not the empty String, then
- Letp be 0.
- Letq bep.
- Repeat, whileq ≠s,
- Lete be
SplitMatch (S,q,R). - Ife is
not-matched , setq toq + 1. - Else,
- Lete be
- LetT be the
substring ofS fromp tos. - Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (lengthA)),T). - ReturnA.
The value ofseparator may be an empty String. In this case,separator does not match the empty
If the
Ifseparator is
Thesplit function is intentionally generic; it does not require that its
22.1.3.21.1 SplitMatch (S,q,R )
The abstract operation SplitMatch takes argumentsS (a String),q (a non-negative
- Letr be the number of code units inR.
- Lets be the number of code units inS.
- Ifq +r >s, return
not-matched . - If there exists an
integer i between 0 (inclusive) andr (exclusive) such that the code unit at indexq +i withinS is different from the code unit at indexi withinR, returnnot-matched . - Returnq +r.
22.1.3.22 String.prototype.startsWith (searchString [ ,position ] )
The following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetisRegExp be ?
IsRegExp (searchString). - IfisRegExp is
true , throw aTypeError exception. - LetsearchStr be ?
ToString (searchString). - Letlen be the length ofS.
- Ifposition is
undefined , letpos be 0; else letpos be ?ToIntegerOrInfinity (position). - Letstart be the result of
clamping pos between 0 andlen. - LetsearchLength be the length ofsearchStr.
- IfsearchLength = 0, return
true . - Letend bestart +searchLength.
- Ifend >len, return
false . - Letsubstring be the
substring ofS fromstart toend. - Return !
SameValueNonNumeric (substring,searchStr).
This method returns
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
ThestartsWith function is intentionally generic; it does not require that its
22.1.3.23 String.prototype.substring (start,end )
Thesubstring method takes two arguments,start andend, and returns a
If either argument is
Ifstart is larger thanend, they are swapped.
The following steps are taken:
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letlen be the length ofS.
- LetintStart be ?
ToIntegerOrInfinity (start). - Ifend is
undefined , letintEnd belen; else letintEnd be ?ToIntegerOrInfinity (end). - LetfinalStart be the result of
clamping intStart between 0 andlen. - LetfinalEnd be the result of
clamping intEnd between 0 andlen. - Letfrom be
min (finalStart,finalEnd). - Letto be
max (finalStart,finalEnd). - Return the
substring ofS fromfrom toto.
Thesubstring function is intentionally generic; it does not require that its
22.1.3.24 String.prototype.toLocaleLowerCase ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement thetoLocaleLowerCase method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleLowerCase method is used.
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
This function works exactly the same astoLowerCase except that its result is intended to yield the correct result for the
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
ThetoLocaleLowerCase function is intentionally generic; it does not require that its
22.1.3.25 String.prototype.toLocaleUpperCase ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement thetoLocaleUpperCase method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleUpperCase method is used.
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
This function works exactly the same astoUpperCase except that its result is intended to yield the correct result for the
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
ThetoLocaleUpperCase function is intentionally generic; it does not require that its
22.1.3.26 String.prototype.toLowerCase ( )
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - LetsText be !
StringToCodePoints (S). - LetlowerText be the result of toLowercase(sText), according to the Unicode Default Case Conversion algorithm.
- LetL be !
CodePointsToString (lowerText). - ReturnL.
The result must be derived according to the locale-insensitive case mappings in the Unicode Character Database (this explicitly includes not only the UnicodeData.txt file, but also all locale-insensitive mappings in the SpecialCasings.txt file that accompanies it).
The case mapping of some code points may produce multiple code points. In this case the result String may not be the same length as the source String. Because bothtoUpperCase andtoLowerCase have context-sensitive behaviour, the functions are not symmetrical. In other words,s.toUpperCase().toLowerCase() is not necessarily equal tos.toLowerCase().
ThetoLowerCase function is intentionally generic; it does not require that its
22.1.3.27 String.prototype.toString ( )
When thetoString method is called, the following steps are taken:
- Return ?
thisStringValue (this value).
For a String object, thetoString method happens to return the same thing as thevalueOf method.
22.1.3.28 String.prototype.toUpperCase ( )
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
This function behaves in exactly the same way asString.prototype.toLowerCase, except that the String is mapped using the toUppercase algorithm of the Unicode Default Case Conversion.
ThetoUpperCase function is intentionally generic; it does not require that its
22.1.3.29 String.prototype.trim ( )
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The following steps are taken:
- LetS be the
this value. - Return ?
TrimString (S,start+end ).
Thetrim function is intentionally generic; it does not require that its
22.1.3.29.1 TrimString (string,where )
The abstract operation TrimString takes argumentsstring andwhere. It interpretsstring as a sequence of UTF-16 encoded code points, as described in
- Letstr be ?
RequireObjectCoercible (string). - LetS be ?
ToString (str). - Ifwhere is
start , letT be the String value that is a copy ofS with leading white space removed. - Else ifwhere is
end , letT be the String value that is a copy ofS with trailing white space removed. - Else,
Assert :where isstart+end .- LetT be the String value that is a copy ofS with both leading and trailing white space removed.
- ReturnT.
The definition of white space is the union of
22.1.3.30 String.prototype.trimEnd ( )
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The following steps are taken:
- LetS be the
this value. - Return ?
TrimString (S,end ).
ThetrimEnd function is intentionally generic; it does not require that its
22.1.3.31 String.prototype.trimStart ( )
This function interprets a String value as a sequence of UTF-16 encoded code points, as described in
The following steps are taken:
- LetS be the
this value. - Return ?
TrimString (S,start ).
ThetrimStart function is intentionally generic; it does not require that its
22.1.3.32 String.prototype.valueOf ( )
When thevalueOf method is called, the following steps are taken:
- Return ?
thisStringValue (this value).
22.1.3.33 String.prototype [ @@iterator ] ( )
When the@@iterator method is called it returns an Iterator object (
- LetO be ?
RequireObjectCoercible (this value). - Lets be ?
ToString (O). - Letclosure be a new
Abstract Closure with no parameters that capturess and performs the following steps when called:- Letposition be 0.
- Letlen be the length ofs.
- Repeat, whileposition <len,
- Letcp be !
CodePointAt (s,position). - LetnextIndex beposition +cp.[[CodeUnitCount]].
- LetresultString be the
substring ofs fromposition tonextIndex. - Setposition tonextIndex.
- Perform ?
Yield (resultString).
- Letcp be !
- Return
undefined .
- Return !
CreateIteratorFromClosure (closure,"%StringIteratorPrototype%" ,%StringIteratorPrototype% ).
The value of the
22.1.4 Properties of String Instances
String instances are String exotic objects and have the internal methods specified for such objects. String instances inherit properties from the
String instances have a
22.1.4.1 length
The number of elements in the String value represented by this String object.
Once a String object is initialized, this property is unchanging. It has the attributes { [[Writable]]:
22.1.5 String Iterator Objects
A String Iterator is an object, that represents a specific iteration over some specific String instance object. There is not a named
22.1.5.1 The %StringIteratorPrototype% Object
The%StringIteratorPrototype% object:
- has properties that are inherited by all String Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - has the following properties:
22.1.5.1.1 %StringIteratorPrototype%.next ( )
- Return ?
GeneratorResume (this value,empty ,"%StringIteratorPrototype%" ).
22.1.5.1.2 %StringIteratorPrototype% [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
22.2 RegExp (Regular Expression) Objects
A RegExp object contains a regular expression and the associated flags.
The form and functionality of regular expressions is modelled after the regular expression facility in the Perl 5 programming language.
22.2.1 Patterns
The RegExp
Syntax
Each\uuu\u
A number of productions in this section are given alternative definitions in section
22.2.1.1 Static Semantics: Early Errors
This section is amended in
- It is a Syntax Error ifNcapturingParens ≥ 232 - 1.
- It is a Syntax Error if
Pattern contains multipleGroupSpecifier s whose enclosedRegExpIdentifierName s have the sameCapturingGroupName .
- It is a Syntax Error if the MV of the first
DecimalDigits is larger than the MV of the secondDecimalDigits .
- It is a Syntax Error if the enclosing
Pattern does not contain aGroupSpecifier with an enclosedRegExpIdentifierName whoseCapturingGroupName equals theCapturingGroupName of theRegExpIdentifierName of this production'sGroupName .
- It is a Syntax Error if the
CapturingGroupNumber ofDecimalEscape is larger thanNcapturingParens (22.2.2.1 ).
- It is a Syntax Error if
IsCharacterClass of the firstClassAtom istrue orIsCharacterClass of the secondClassAtom istrue . - It is a Syntax Error if
IsCharacterClass of the firstClassAtom isfalse andIsCharacterClass of the secondClassAtom isfalse and theCharacterValue of the firstClassAtom is larger than theCharacterValue of the secondClassAtom .
- It is a Syntax Error if
IsCharacterClass ofClassAtomNoDash istrue orIsCharacterClass ofClassAtom istrue . - It is a Syntax Error if
IsCharacterClass ofClassAtomNoDash isfalse andIsCharacterClass ofClassAtom isfalse and theCharacterValue ofClassAtomNoDash is larger than theCharacterValue ofClassAtom .
- It is a Syntax Error if the
CharacterValue ofRegExpUnicodeEscapeSequence is not the code point value of"$" ,"_" , or some code point matched by theUnicodeIDStart lexical grammar production.
- It is a Syntax Error if the result of performing
UTF16SurrogatePairToCodePoint on the two code points matched byUnicodeLeadSurrogate andUnicodeTrailSurrogate respectively is not matched by theUnicodeIDStart lexical grammar production.
- It is a Syntax Error if the
CharacterValue ofRegExpUnicodeEscapeSequence is not the code point value of"$" ,"_" , <ZWNJ>, <ZWJ>, or some code point matched by theUnicodeIDContinue lexical grammar production.
- It is a Syntax Error if the result of performing
UTF16SurrogatePairToCodePoint on the two code points matched byUnicodeLeadSurrogate andUnicodeTrailSurrogate respectively is not matched by theUnicodeIDContinue lexical grammar production.
- It is a Syntax Error if the
List of Unicode code points that isSourceText ofUnicodePropertyName is not identical to aList of Unicode code points that is a Unicodeproperty name or property alias listed in the “Property name and aliases” column ofTable 56 . - It is a Syntax Error if the
List of Unicode code points that isSourceText ofUnicodePropertyValue is not identical to aList of Unicode code points that is a value or value alias for the Unicode property or property alias given bySourceText ofUnicodePropertyName listed in the “Property value and aliases” column of the corresponding tablesTable 58 orTable 59 .
- It is a Syntax Error if the
List of Unicode code points that isSourceText ofLoneUnicodePropertyNameOrValue is not identical to aList of Unicode code points that is a Unicode general category or general category alias listed in the “Property value and aliases” column ofTable 58 , nor a binary property or binary property alias listed in the “Property name and aliases” column ofTable 57 .
22.2.1.2 Static Semantics: CapturingGroupNumber
This section is amended in
- Return the MV of
NonZeroDigit .
- Letn be the number of code points in
DecimalDigits . - Return (the MV of
NonZeroDigit × 10n plus the MV ofDecimalDigits ).
The definitions of “the MV of
22.2.1.3 Static Semantics: IsCharacterClass
This section is amended in
- Return
false .
- Return
true .
22.2.1.4 Static Semantics: CharacterValue
This section is amended in
- Return the code point value of U+002D (HYPHEN-MINUS).
- Letch be the code point matched by
SourceCharacter . - Return the code point value ofch.
- Return the code point value of U+0008 (BACKSPACE).
- Return the code point value of U+002D (HYPHEN-MINUS).
- Return the code point value according to
Table 55 .
| ControlEscape | Code Point Value | Code Point | Unicode Name | Symbol |
|---|---|---|---|---|
t | 9 | U+0009 | CHARACTER TABULATION | <HT> |
n | 10 | U+000A | LINE FEED (LF) | <LF> |
v | 11 | U+000B | LINE TABULATION | <VT> |
f | 12 | U+000C | FORM FEED (FF) | <FF> |
r | 13 | U+000D | CARRIAGE RETURN (CR) | <CR> |
- Letch be the code point matched by
ControlLetter . - Leti bech's code point value.
- Return the remainder of dividingi by 32.
- Return the code point value of U+0000 (NULL).
\0 represents the <NUL> character and cannot be followed by a decimal digit.
- Return the MV of
HexEscapeSequence .
- Letlead be the
CharacterValue ofHexLeadSurrogate . - Lettrail be the
CharacterValue ofHexTrailSurrogate . - Letcp be
UTF16SurrogatePairToCodePoint (lead,trail). - Return the code point value ofcp.
- Return the MV of
Hex4Digits .
- Return the MV of
CodePoint .
- Return the MV of
HexDigits .
- Letch be the code point matched by
IdentityEscape . - Return the code point value ofch.
22.2.1.5 Static Semantics: SourceText
- Return the
List , in source text order, of Unicode code points in thesource text matched by this production.
22.2.1.6 Static Semantics: CapturingGroupName
- LetidText be the
source text matched by RegExpIdentifierName . - LetidTextUnescaped be the result of replacing any occurrences of
\RegExpUnicodeEscapeSequence inidText with the code point represented by theRegExpUnicodeEscapeSequence . - Return !
CodePointsToString (idTextUnescaped).
22.2.2 Pattern Semantics
This section is amended in
A regular expression pattern is converted into an
Au. A BMP pattern matches against a String interpreted as consisting of a sequence of 16-bit values that are Unicode code points in the range of the Basic Multilingual Plane. A Unicode pattern matches against a String interpreted as consisting of Unicode code points encoded using UTF-16. In the context of describing the behaviour of a BMP pattern “character” means a single 16-bit Unicode BMP code point. In the context of describing the behaviour of a Unicode pattern “character” means a UTF-16 encoded code point (
The syntax and semantics of
For example, consider a pattern expressed in source text as the single non-BMP character U+1D11E (MUSICAL SYMBOL G CLEF). Interpreted as a Unicode pattern, it would be a single element (character)
Patterns are passed to the RegExp
An implementation may not actually perform such translations to or from UTF-16, but the semantics of this specification requires that the result of pattern matching be as if such translations were performed.
22.2.2.1 Notation
The descriptions below use the following aliases:
- Input is a
List whose elements are the characters of the String being matched by the regular expression pattern. Each character is either a code unit or a code point, depending upon the kind of pattern involved. The notationInput[n] means thenth character ofInput, wheren can range between 0 (inclusive) andInputLength (exclusive). - InputLength is the number of characters inInput.
- NcapturingParens is the total number of left-capturing parentheses (i.e. the total number of
Atom :: ( GroupSpecifier Disjunction ) (pattern character that is matched by the(terminal of theAtom :: ( GroupSpecifier Disjunction ) - DotAll is
true if the RegExp object's [[OriginalFlags]] internal slot contains"s" and otherwise isfalse . - IgnoreCase is
true if the RegExp object's [[OriginalFlags]] internal slot contains"i" and otherwise isfalse . - Multiline is
true if the RegExp object's [[OriginalFlags]] internal slot contains"m" and otherwise isfalse . - Unicode is
true if the RegExp object's [[OriginalFlags]] internal slot contains"u" and otherwise isfalse . - WordCharacters is the mathematical set that is the union of all sixty-three characters in
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_" (letters, numbers, and U+005F (LOW LINE) in the Unicode Basic Latin block) and all charactersc for whichc is not in that set butCanonicalize (c) is.WordCharacters cannot contain more than sixty-three characters unlessUnicode andIgnoreCase are bothtrue .
Furthermore, the descriptions below use the following internal data structures:
- ACharSet is a mathematical set of characters. When theUnicode flag is
true , “all characters” means the CharSet containing all code point values; otherwise “all characters” means the CharSet containing all code unit values. - AState is an ordered pair (endIndex,captures) whereendIndex is an
integer andcaptures is aList ofNcapturingParens values. States are used to represent partial match states in the regular expression matching algorithms. TheendIndex is one plus the index of the last input character matched so far by the pattern, whilecaptures holds the results of capturing parentheses. Thenth element ofcaptures is either aList of characters that represents the value obtained by thenth set of capturing parentheses orundefined if thenth set of capturing parentheses hasn't been reached yet. Due to backtracking, many States may be in use at any time during the matching process. - AMatchResult is either a State or the special token
failure that indicates that the match failed. - AContinuation is an
Abstract Closure that takes one State argument and returns a MatchResult result. The Continuation attempts to match the remaining portion (specified by the closure's captured values) of the pattern againstInput, starting at the intermediate state given by its State argument. If the match succeeds, the Continuation returns the final State that it reached; if the match fails, the Continuation returnsfailure . - AMatcher is an
Abstract Closure that takes two arguments—a State and a Continuation—and returns a MatchResult result. A Matcher attempts to match a middle subpattern (specified by the closure's captured values) of the pattern againstInput, starting at the intermediate state given by its State argument. The Continuation argument should be a closure that matches the rest of the pattern. After matching the subpattern of a pattern to obtain a new State, the Matcher then calls Continuation on that new State to test if the rest of the pattern can match as well. If it can, the Matcher returns the State returned by Continuation; if not, the Matcher may try different choices at its choice points, repeatedly calling Continuation until it either succeeds or all possibilities have been exhausted.
22.2.2.2 Pattern
The production
- Evaluate
Disjunction with 1 as itsdirection argument to obtain a Matcherm. - Return a new
Abstract Closure with parameters (str,index) that capturesm and performs the following steps when called:Assert :Type (str) is String.Assert :index is a non-negativeinteger which is ≤ the length ofstr.- IfUnicode is
true , letInput be !StringToCodePoints (str). Otherwise, letInput be aList whose elements are the code units that are the elements ofstr.Input will be used throughout the algorithms in22.2.2 . Each element ofInput is considered to be a character. - LetInputLength be the number of characters contained inInput. This alias will be used throughout the algorithms in
22.2.2 . - LetlistIndex be the index intoInput of the character that was obtained from elementindex ofstr.
- Letc be a new Continuation with parameters (y) that captures nothing and performs the following steps when called:
Assert :y is a State.- Returny.
- Letcap be a
List ofNcapturingParensundefined values, indexed 1 throughNcapturingParens. - Letx be the State (listIndex,cap).
- Returnm(x,c).
A Pattern evaluates (“compiles”) to an
22.2.2.3 Disjunction
With parameterdirection.
The production
- Evaluate
Alternative with argumentdirection to obtain a Matcherm. - Returnm.
The production
- Evaluate
Alternative with argumentdirection to obtain a Matcherm1. - Evaluate
Disjunction with argumentdirection to obtain a Matcherm2. - Return a new Matcher with parameters (x,c) that capturesm1 andm2 and performs the following steps when called:
The| regular expression operator separates two alternatives. The pattern first tries to match the left| produce
/a|ab/.exec("abc")returns the result
/((a)|(ab))((c)|(bc))/.exec("abc")returns the array
["abc","a","a",undefined,"bc",undefined,"bc"]and not
["abc","ab",undefined,"ab","c","c",undefined]The order in which the two alternatives are tried is independent of the value ofdirection.
22.2.2.4 Alternative
With parameterdirection.
The production
The production
- Evaluate
Alternative with argumentdirection to obtain a Matcherm1. - Evaluate
Term with argumentdirection to obtain a Matcherm2. - Ifdirection = 1, then
- Return a new Matcher with parameters (x,c) that capturesm1 andm2 and performs the following steps when called:
- Else,
Assert :direction is -1.- Return a new Matcher with parameters (x,c) that capturesm1 andm2 and performs the following steps when called:
Consecutive
22.2.2.5 Term
With parameterdirection.
The production
- Return the Matcher that is the result of evaluating
Assertion .
The resulting Matcher is independent ofdirection.
The production
- Return the Matcher that is the result of evaluating
Atom with argumentdirection.
The production
- Evaluate
Atom with argumentdirection to obtain a Matcherm. - Evaluate
Quantifier to obtain the three results: a non-negativeinteger min, a non-negativeinteger (or +∞)max, and Booleangreedy. Assert :min ≤max.- LetparenIndex be the number of left-capturing parentheses in the entire regular expression that occur to the left of this
Term . This is the total number ofAtom :: ( GroupSpecifier Disjunction ) Term . - LetparenCount be the number of left-capturing parentheses in
Atom . This is the total number ofAtom :: ( GroupSpecifier Disjunction ) Atom . - Return a new Matcher with parameters (x,c) that capturesm,min,max,greedy,parenIndex, andparenCount and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Return !
RepeatMatcher (m,min,max,greedy,x,c,parenIndex,parenCount).
22.2.2.5.1 RepeatMatcher (m,min,max,greedy,x,c,parenIndex,parenCount )
The abstract operation RepeatMatcher takes argumentsm (a Matcher),min (a non-negative
- Ifmax = 0, returnc(x).
- Letd be a new Continuation with parameters (y) that capturesm,min,max,greedy,x,c,parenIndex, andparenCount and performs the following steps when called:
Assert :y is a State.- Ifmin = 0 andy'sendIndex =x'sendIndex, return
failure . - Ifmin = 0, letmin2 be 0; otherwise letmin2 bemin - 1.
- Ifmax is +∞, letmax2 be +∞; otherwise letmax2 bemax - 1.
- Return !
RepeatMatcher (m,min2,max2,greedy,y,c,parenIndex,parenCount).
- Letcap be a copy ofx'scaptures
List . - For each
integer k such thatparenIndex <k andk ≤parenIndex +parenCount, setcap[k] toundefined . - Lete bex'sendIndex.
- Letxr be the State (e,cap).
- Ifmin ≠ 0, returnm(xr,d).
- Ifgreedy is
false , then- Letz bec(x).
- Ifz is not
failure , returnz. - Returnm(xr,d).
- Letz bem(xr,d).
- Ifz is not
failure , returnz. - Returnc(x).
An
If the
Compare
/a[a-z]{2,4}/.exec("abcdefghi")which returns
/a[a-z]{2,4}?/.exec("abcdefghi")which returns
Consider also
/(aa|aabaac|ba|b|c)*/.exec("aabaac")which, by the choice point ordering above, returns the array
["aaba","ba"]and not any of:
["aabaac","aabaac"]["aabaac","c"]The above ordering of choice points can be used to write a regular expression that calculates the greatest common divisor of two numbers (represented in unary notation). The following example calculates the gcd of 10 and 15:
"aaaaaaaaaa,aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/,"$1")which returns the gcd in unary notation
Step
/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")which returns the array
["zaacbbbcac","z","ac","a",undefined,"c"]and not
["zaacbbbcac","z","ac","a","bbb","c"]because each iteration of the outermost* clears all captured Strings contained in the quantified
Step
/(a*)*/.exec("b")or the slightly more complicated:
/(a*)b\1+/.exec("baaaac")which returns the array
["b",""]22.2.2.6 Assertion
The production
- Return a new Matcher with parameters (x,c) that captures nothing and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Lete bex'sendIndex.
- Ife = 0, or ifMultiline is
true and the characterInput[e - 1] is one ofLineTerminator , then- Returnc(x).
- Return
failure .
Even when they flag is used with a pattern,^ always matches only at the beginning ofInput, or (ifMultiline is
The production
- Return a new Matcher with parameters (x,c) that captures nothing and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Lete bex'sendIndex.
- Ife =InputLength, or ifMultiline is
true and the characterInput[e] is one ofLineTerminator , then- Returnc(x).
- Return
failure .
The production
- Return a new Matcher with parameters (x,c) that captures nothing and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Lete bex'sendIndex.
- Leta be !
IsWordChar (e - 1). - Letb be !
IsWordChar (e). - Ifa is
true andb isfalse , or ifa isfalse andb istrue , returnc(x). - Return
failure .
The production
- Return a new Matcher with parameters (x,c) that captures nothing and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Lete bex'sendIndex.
- Leta be !
IsWordChar (e - 1). - Letb be !
IsWordChar (e). - Ifa is
true andb istrue , or ifa isfalse andb isfalse , returnc(x). - Return
failure .
The production
- Evaluate
Disjunction with 1 as itsdirection argument to obtain a Matcherm. - Return a new Matcher with parameters (x,c) that capturesm and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Letd be a new Continuation with parameters (y) that captures nothing and performs the following steps when called:
Assert :y is a State.- Returny.
- Letr bem(x,d).
- Ifr is
failure , returnfailure . - Lety ber's State.
- Letcap bey'scaptures
List . - Letxe bex'sendIndex.
- Letz be the State (xe,cap).
- Returnc(z).
The production
- Evaluate
Disjunction with 1 as itsdirection argument to obtain a Matcherm. - Return a new Matcher with parameters (x,c) that capturesm and performs the following steps when called:
The production
- Evaluate
Disjunction with -1 as itsdirection argument to obtain a Matcherm. - Return a new Matcher with parameters (x,c) that capturesm and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Letd be a new Continuation with parameters (y) that captures nothing and performs the following steps when called:
Assert :y is a State.- Returny.
- Letr bem(x,d).
- Ifr is
failure , returnfailure . - Lety ber's State.
- Letcap bey'scaptures
List . - Letxe bex'sendIndex.
- Letz be the State (xe,cap).
- Returnc(z).
The production
- Evaluate
Disjunction with -1 as itsdirection argument to obtain a Matcherm. - Return a new Matcher with parameters (x,c) that capturesm and performs the following steps when called:
22.2.2.6.1 IsWordChar (e )
The abstract operation IsWordChar takes argumente (an
- Ife = -1 ore isInputLength, return
false . - Letc be the characterInput[e].
- Ifc is inWordCharacters, return
true . - Return
false .
22.2.2.7 Quantifier
The production
- Evaluate
QuantifierPrefix to obtain the two results: aninteger min and aninteger (or +∞)max. - Return the three resultsmin,max, and
true .
The production
- Evaluate
QuantifierPrefix to obtain the two results: aninteger min and aninteger (or +∞)max. - Return the three resultsmin,max, and
false .
The production
- Return the two results 0 and +∞.
The production
- Return the two results 1 and +∞.
The production
- Return the two results 0 and 1.
The production
- Leti be the MV of
DecimalDigits (see12.8.3 ). - Return the two resultsi andi.
The production
- Leti be the MV of
DecimalDigits . - Return the two resultsi and +∞.
The production
- Leti be the MV of the first
DecimalDigits . - Letj be the MV of the second
DecimalDigits . - Return the two resultsi andj.
22.2.2.8 Atom
With parameterdirection.
The production
- Letch be the character matched by
PatternCharacter . - LetA be a one-element CharSet containing the characterch.
- Return !
CharacterSetMatcher (A,false ,direction).
The production
- LetA be the CharSet of all characters.
- IfDotAll is not
true , then- Remove fromA all characters corresponding to a code point on the right-hand side of the
LineTerminator production.
- Remove fromA all characters corresponding to a code point on the right-hand side of the
- Return !
CharacterSetMatcher (A,false ,direction).
The production
- Return the Matcher that is the result of evaluating
AtomEscape with argumentdirection.
The production
- Evaluate
CharacterClass to obtain a CharSetA and a Booleaninvert. - Return !
CharacterSetMatcher (A,invert,direction).
The production
- Evaluate
Disjunction with argumentdirection to obtain a Matcherm. - LetparenIndex be the number of left-capturing parentheses in the entire regular expression that occur to the left of this
Atom . This is the total number ofAtom :: ( GroupSpecifier Disjunction ) Atom . - Return a new Matcher with parameters (x,c) that capturesdirection,m, andparenIndex and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Letd be a new Continuation with parameters (y) that capturesx,c,direction, andparenIndex and performs the following steps when called:
- Returnm(x,d).
The production
- Return the Matcher that is the result of evaluating
Disjunction with argumentdirection.
22.2.2.8.1 CharacterSetMatcher (A,invert,direction )
The abstract operation CharacterSetMatcher takes argumentsA (a CharSet),invert (a Boolean), anddirection (1 or -1). It performs the following steps when called:
- Return a new Matcher with parameters (x,c) that capturesA,invert, anddirection and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Lete bex'sendIndex.
- Letf bee +direction.
- Iff < 0 orf >InputLength, return
failure . - Letindex be
min (e,f). - Letch be the characterInput[index].
- Letcc be
Canonicalize (ch). - If there exists a membera ofA such that
Canonicalize (a) iscc, letfound betrue . Otherwise, letfound befalse . - Ifinvert is
false andfound isfalse , returnfailure . - Ifinvert is
true andfound istrue , returnfailure . - Letcap bex'scaptures
List . - Lety be the State (f,cap).
- Returnc(y).
22.2.2.8.2 Canonicalize (ch )
The abstract operation Canonicalize takes argumentch (a character). It performs the following steps when called:
- IfUnicode is
true andIgnoreCase istrue , then- If the file CaseFolding.txt of the Unicode Character Database provides a simple or common case folding mapping forch, return the result of applying that mapping toch.
- Returnch.
- IfIgnoreCase is
false , returnch. Assert :ch is a UTF-16 code unit.- Letcp be the code point whose numeric value is that ofch.
- Letu be the result of toUppercase(«cp »), according to the Unicode Default Case Conversion algorithm.
- LetuStr be !
CodePointsToString (u). - IfuStr does not consist of a single code unit, returnch.
- Letcu beuStr's single code unit element.
- If the numeric value ofch ≥ 128 and the numeric value ofcu < 128, returnch.
- Returncu.
Parentheses of the form() serve both to group the components of the\ followed by a non-zero decimal number), referenced in a replace String, or returned as part of an array from the regular expression matching(?:) instead.
The form(?=) specifies a zero-width positive lookahead. In order for it to succeed, the pattern inside(?= form (this unusual behaviour is inherited from Perl). This only matters when the
For example,
/(?=(a+))/.exec("baaabac")matches the empty String immediately after the firstb and therefore returns the array:
["","aaa"]To illustrate the lack of backtracking into the lookahead, consider:
/(?=(a+))a*b\1/.exec("baaabac")This expression returns
["aba","a"]and not:
["aaaba","a"]The form(?!) specifies a zero-width negative lookahead. In order for it to succeed, the pattern inside
/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")looks for ana not immediately followed by some positive number n ofa's, ab, another na's (specified by the first\2) and ac. The second\2 is outside the negative lookahead, so it matches against
["baaabaac","ba",undefined,"abaac"]In case-insignificant matches whenUnicode isß (U+00DF) toSS. It may however map a code point outside the Basic Latin range to a character within, for example,ſ (U+017F) tos. Such characters are not mapped ifUnicode is/[a-z]/i, but they will match/[a-z]/ui.
22.2.2.8.3 UnicodeMatchProperty (p )
The abstract operation UnicodeMatchProperty takes argumentp (a
Assert :p is aList of Unicode code points that is identical to aList of Unicode code points that is a Unicodeproperty name or property alias listed in the “Property name and aliases” column ofTable 56 orTable 57 .- Letc be the canonical
property name ofp as given in the “Canonicalproperty name ” column of the corresponding row. - Return the
List of Unicode code points ofc.
Implementations must support the Unicode property names and aliases listed in
For example,Script_Extensions (scx (property alias) are valid, butscript_extensions orScx aren't.
The listed properties form a superset of whatUTS18 RL1.2 requires.
| Canonical | |
|---|---|
General_Category | General_Category |
gc | |
Script | Script |
sc | |
Script_Extensions | Script_Extensions |
scx |
| Canonical | |
|---|---|
ASCII | ASCII |
ASCII_Hex_Digit | ASCII_Hex_Digit |
AHex | |
Alphabetic | Alphabetic |
Alpha | |
Any | Any |
Assigned | Assigned |
Bidi_Control | Bidi_Control |
Bidi_C | |
Bidi_Mirrored | Bidi_Mirrored |
Bidi_M | |
Case_Ignorable | Case_Ignorable |
CI | |
Cased | Cased |
Changes_When_Casefolded | Changes_When_Casefolded |
CWCF | |
Changes_When_Casemapped | Changes_When_Casemapped |
CWCM | |
Changes_When_Lowercased | Changes_When_Lowercased |
CWL | |
Changes_When_NFKC_Casefolded | Changes_When_NFKC_Casefolded |
CWKCF | |
Changes_When_Titlecased | Changes_When_Titlecased |
CWT | |
Changes_When_Uppercased | Changes_When_Uppercased |
CWU | |
Dash | Dash |
Default_Ignorable_Code_Point | Default_Ignorable_Code_Point |
DI | |
Deprecated | Deprecated |
Dep | |
Diacritic | Diacritic |
Dia | |
Emoji | Emoji |
Emoji_Component | Emoji_Component |
EComp | |
Emoji_Modifier | Emoji_Modifier |
EMod | |
Emoji_Modifier_Base | Emoji_Modifier_Base |
EBase | |
Emoji_Presentation | Emoji_Presentation |
EPres | |
Extended_Pictographic | Extended_Pictographic |
ExtPict | |
Extender | Extender |
Ext | |
Grapheme_Base | Grapheme_Base |
Gr_Base | |
Grapheme_Extend | Grapheme_Extend |
Gr_Ext | |
Hex_Digit | Hex_Digit |
Hex | |
IDS_Binary_Operator | IDS_Binary_Operator |
IDSB | |
IDS_Trinary_Operator | IDS_Trinary_Operator |
IDST | |
ID_Continue | ID_Continue |
IDC | |
ID_Start | ID_Start |
IDS | |
Ideographic | Ideographic |
Ideo | |
Join_Control | Join_Control |
Join_C | |
Logical_Order_Exception | Logical_Order_Exception |
LOE | |
Lowercase | Lowercase |
Lower | |
Math | Math |
Noncharacter_Code_Point | Noncharacter_Code_Point |
NChar | |
Pattern_Syntax | Pattern_Syntax |
Pat_Syn | |
Pattern_White_Space | Pattern_White_Space |
Pat_WS | |
Quotation_Mark | Quotation_Mark |
QMark | |
Radical | Radical |
Regional_Indicator | Regional_Indicator |
RI | |
Sentence_Terminal | Sentence_Terminal |
STerm | |
Soft_Dotted | Soft_Dotted |
SD | |
Terminal_Punctuation | Terminal_Punctuation |
Term | |
Unified_Ideograph | Unified_Ideograph |
UIdeo | |
Uppercase | Uppercase |
Upper | |
Variation_Selector | Variation_Selector |
VS | |
White_Space | White_Space |
space | |
XID_Continue | XID_Continue |
XIDC | |
XID_Start | XID_Start |
XIDS |
22.2.2.8.4 UnicodeMatchPropertyValue (p,v )
The abstract operation UnicodeMatchPropertyValue takes argumentsp (a
Assert :p is aList of Unicode code points that is identical to aList of Unicode code points that is a canonical, unaliased Unicodeproperty name listed in the “Canonicalproperty name ” column ofTable 56 .Assert :v is aList of Unicode code points that is identical to aList of Unicode code points that is a property value or property value alias for Unicode propertyp listed in the “Property value and aliases” column ofTable 58 orTable 59 .- Letvalue be the canonical property value ofv as given in the “Canonical property value” column of the corresponding row.
- Return the
List of Unicode code points ofvalue.
Implementations must support the Unicode property value names and aliases listed in
For example,Xpeo andOld_Persian are validScript_Extensions values, butxpeo andOld Persian aren't.
This algorithm differs fromthe matching rules for symbolic values listed in UAX44: case,Is prefix is not supported.
General_Category| Property value and aliases | Canonical property value |
|---|---|
Cased_Letter | Cased_Letter |
LC | |
Close_Punctuation | Close_Punctuation |
Pe | |
Connector_Punctuation | Connector_Punctuation |
Pc | |
Control | Control |
Cc | |
cntrl | |
Currency_Symbol | Currency_Symbol |
Sc | |
Dash_Punctuation | Dash_Punctuation |
Pd | |
Decimal_Number | Decimal_Number |
Nd | |
digit | |
Enclosing_Mark | Enclosing_Mark |
Me | |
Final_Punctuation | Final_Punctuation |
Pf | |
Format | Format |
Cf | |
Initial_Punctuation | Initial_Punctuation |
Pi | |
Letter | Letter |
L | |
Letter_Number | Letter_Number |
Nl | |
Line_Separator | Line_Separator |
Zl | |
Lowercase_Letter | Lowercase_Letter |
Ll | |
Mark | Mark |
M | |
Combining_Mark | |
Math_Symbol | Math_Symbol |
Sm | |
Modifier_Letter | Modifier_Letter |
Lm | |
Modifier_Symbol | Modifier_Symbol |
Sk | |
Nonspacing_Mark | Nonspacing_Mark |
Mn | |
Number | Number |
N | |
Open_Punctuation | Open_Punctuation |
Ps | |
Other | Other |
C | |
Other_Letter | Other_Letter |
Lo | |
Other_Number | Other_Number |
No | |
Other_Punctuation | Other_Punctuation |
Po | |
Other_Symbol | Other_Symbol |
So | |
Paragraph_Separator | Paragraph_Separator |
Zp | |
Private_Use | Private_Use |
Co | |
Punctuation | Punctuation |
P | |
punct | |
Separator | Separator |
Z | |
Space_Separator | Space_Separator |
Zs | |
Spacing_Mark | Spacing_Mark |
Mc | |
Surrogate | Surrogate |
Cs | |
Symbol | Symbol |
S | |
Titlecase_Letter | Titlecase_Letter |
Lt | |
Unassigned | Unassigned |
Cn | |
Uppercase_Letter | Uppercase_Letter |
Lu |
Script andScript_Extensions| Property value and aliases | Canonical property value |
|---|---|
Adlam | Adlam |
Adlm | |
Ahom | Ahom |
Anatolian_Hieroglyphs | Anatolian_Hieroglyphs |
Hluw | |
Arabic | Arabic |
Arab | |
Armenian | Armenian |
Armn | |
Avestan | Avestan |
Avst | |
Balinese | Balinese |
Bali | |
Bamum | Bamum |
Bamu | |
Bassa_Vah | Bassa_Vah |
Bass | |
Batak | Batak |
Batk | |
Bengali | Bengali |
Beng | |
Bhaiksuki | Bhaiksuki |
Bhks | |
Bopomofo | Bopomofo |
Bopo | |
Brahmi | Brahmi |
Brah | |
Braille | Braille |
Brai | |
Buginese | Buginese |
Bugi | |
Buhid | Buhid |
Buhd | |
Canadian_Aboriginal | Canadian_Aboriginal |
Cans | |
Carian | Carian |
Cari | |
Caucasian_Albanian | Caucasian_Albanian |
Aghb | |
Chakma | Chakma |
Cakm | |
Cham | Cham |
Chorasmian | Chorasmian |
Chrs | |
Cherokee | Cherokee |
Cher | |
Common | Common |
Zyyy | |
Coptic | Coptic |
Copt | |
Qaac | |
Cuneiform | Cuneiform |
Xsux | |
Cypriot | Cypriot |
Cprt | |
Cyrillic | Cyrillic |
Cyrl | |
Deseret | Deseret |
Dsrt | |
Devanagari | Devanagari |
Deva | |
Dives_Akuru | Dives_Akuru |
Diak | |
Dogra | Dogra |
Dogr | |
Duployan | Duployan |
Dupl | |
Egyptian_Hieroglyphs | Egyptian_Hieroglyphs |
Egyp | |
Elbasan | Elbasan |
Elba | |
Elymaic | Elymaic |
Elym | |
Ethiopic | Ethiopic |
Ethi | |
Georgian | Georgian |
Geor | |
Glagolitic | Glagolitic |
Glag | |
Gothic | Gothic |
Goth | |
Grantha | Grantha |
Gran | |
Greek | Greek |
Grek | |
Gujarati | Gujarati |
Gujr | |
Gunjala_Gondi | Gunjala_Gondi |
Gong | |
Gurmukhi | Gurmukhi |
Guru | |
Han | Han |
Hani | |
Hangul | Hangul |
Hang | |
Hanifi_Rohingya | Hanifi_Rohingya |
Rohg | |
Hanunoo | Hanunoo |
Hano | |
Hatran | Hatran |
Hatr | |
Hebrew | Hebrew |
Hebr | |
Hiragana | Hiragana |
Hira | |
Imperial_Aramaic | Imperial_Aramaic |
Armi | |
Inherited | Inherited |
Zinh | |
Qaai | |
Inscriptional_Pahlavi | Inscriptional_Pahlavi |
Phli | |
Inscriptional_Parthian | Inscriptional_Parthian |
Prti | |
Javanese | Javanese |
Java | |
Kaithi | Kaithi |
Kthi | |
Kannada | Kannada |
Knda | |
Katakana | Katakana |
Kana | |
Kayah_Li | Kayah_Li |
Kali | |
Kharoshthi | Kharoshthi |
Khar | |
Khitan_Small_Script | Khitan_Small_Script |
Kits | |
Khmer | Khmer |
Khmr | |
Khojki | Khojki |
Khoj | |
Khudawadi | Khudawadi |
Sind | |
Lao | Lao |
Laoo | |
Latin | Latin |
Latn | |
Lepcha | Lepcha |
Lepc | |
Limbu | Limbu |
Limb | |
Linear_A | Linear_A |
Lina | |
Linear_B | Linear_B |
Linb | |
Lisu | Lisu |
Lycian | Lycian |
Lyci | |
Lydian | Lydian |
Lydi | |
Mahajani | Mahajani |
Mahj | |
Makasar | Makasar |
Maka | |
Malayalam | Malayalam |
Mlym | |
Mandaic | Mandaic |
Mand | |
Manichaean | Manichaean |
Mani | |
Marchen | Marchen |
Marc | |
Medefaidrin | Medefaidrin |
Medf | |
Masaram_Gondi | Masaram_Gondi |
Gonm | |
Meetei_Mayek | Meetei_Mayek |
Mtei | |
Mende_Kikakui | Mende_Kikakui |
Mend | |
Meroitic_Cursive | Meroitic_Cursive |
Merc | |
Meroitic_Hieroglyphs | Meroitic_Hieroglyphs |
Mero | |
Miao | Miao |
Plrd | |
Modi | Modi |
Mongolian | Mongolian |
Mong | |
Mro | Mro |
Mroo | |
Multani | Multani |
Mult | |
Myanmar | Myanmar |
Mymr | |
Nabataean | Nabataean |
Nbat | |
Nandinagari | Nandinagari |
Nand | |
New_Tai_Lue | New_Tai_Lue |
Talu | |
Newa | Newa |
Nko | Nko |
Nkoo | |
Nushu | Nushu |
Nshu | |
Nyiakeng_Puachue_Hmong | Nyiakeng_Puachue_Hmong |
Hmnp | |
Ogham | Ogham |
Ogam | |
Ol_Chiki | Ol_Chiki |
Olck | |
Old_Hungarian | Old_Hungarian |
Hung | |
Old_Italic | Old_Italic |
Ital | |
Old_North_Arabian | Old_North_Arabian |
Narb | |
Old_Permic | Old_Permic |
Perm | |
Old_Persian | Old_Persian |
Xpeo | |
Old_Sogdian | Old_Sogdian |
Sogo | |
Old_South_Arabian | Old_South_Arabian |
Sarb | |
Old_Turkic | Old_Turkic |
Orkh | |
Oriya | Oriya |
Orya | |
Osage | Osage |
Osge | |
Osmanya | Osmanya |
Osma | |
Pahawh_Hmong | Pahawh_Hmong |
Hmng | |
Palmyrene | Palmyrene |
Palm | |
Pau_Cin_Hau | Pau_Cin_Hau |
Pauc | |
Phags_Pa | Phags_Pa |
Phag | |
Phoenician | Phoenician |
Phnx | |
Psalter_Pahlavi | Psalter_Pahlavi |
Phlp | |
Rejang | Rejang |
Rjng | |
Runic | Runic |
Runr | |
Samaritan | Samaritan |
Samr | |
Saurashtra | Saurashtra |
Saur | |
Sharada | Sharada |
Shrd | |
Shavian | Shavian |
Shaw | |
Siddham | Siddham |
Sidd | |
SignWriting | SignWriting |
Sgnw | |
Sinhala | Sinhala |
Sinh | |
Sogdian | Sogdian |
Sogd | |
Sora_Sompeng | Sora_Sompeng |
Sora | |
Soyombo | Soyombo |
Soyo | |
Sundanese | Sundanese |
Sund | |
Syloti_Nagri | Syloti_Nagri |
Sylo | |
Syriac | Syriac |
Syrc | |
Tagalog | Tagalog |
Tglg | |
Tagbanwa | Tagbanwa |
Tagb | |
Tai_Le | Tai_Le |
Tale | |
Tai_Tham | Tai_Tham |
Lana | |
Tai_Viet | Tai_Viet |
Tavt | |
Takri | Takri |
Takr | |
Tamil | Tamil |
Taml | |
Tangut | Tangut |
Tang | |
Telugu | Telugu |
Telu | |
Thaana | Thaana |
Thaa | |
Thai | Thai |
Tibetan | Tibetan |
Tibt | |
Tifinagh | Tifinagh |
Tfng | |
Tirhuta | Tirhuta |
Tirh | |
Ugaritic | Ugaritic |
Ugar | |
Vai | Vai |
Vaii | |
Wancho | Wancho |
Wcho | |
Warang_Citi | Warang_Citi |
Wara | |
Yezidi | Yezidi |
Yezi | |
Yi | Yi |
Yiii | |
Zanabazar_Square | Zanabazar_Square |
Zanb |
22.2.2.9 AtomEscape
With parameterdirection.
The production
- Evaluate
DecimalEscape to obtain aninteger n. Assert :n ≤NcapturingParens.- Return !
BackreferenceMatcher (n,direction).
The production
- Evaluate
CharacterEscape to obtain a characterch. - LetA be a one-element CharSet containing the characterch.
- Return !
CharacterSetMatcher (A,false ,direction).
The production
- Evaluate
CharacterClassEscape to obtain a CharSetA. - Return !
CharacterSetMatcher (A,false ,direction).
An escape sequence of the form\ followed by a non-zero decimal numbern matches the result of thenth set of capturing parentheses (
The production
- Search the enclosing
Pattern for an instance of aGroupSpecifier containing aRegExpIdentifierName which has aCapturingGroupName equal to theCapturingGroupName of theRegExpIdentifierName contained inGroupName . Assert : A unique suchGroupSpecifier is found.- LetparenIndex be the number of left-capturing parentheses in the entire regular expression that occur to the left of the located
GroupSpecifier . This is the total number ofAtom :: ( GroupSpecifier Disjunction ) GroupSpecifier , including its immediately enclosingAtom . - Return !
BackreferenceMatcher (parenIndex,direction).
22.2.2.9.1 BackreferenceMatcher (n,direction )
The abstract operation BackreferenceMatcher takes argumentsn (a positive
Assert :n ≥ 1.- Return a new Matcher with parameters (x,c) that capturesn anddirection and performs the following steps when called:
Assert :x is a State.Assert :c is a Continuation.- Letcap bex'scaptures
List . - Lets becap[n].
- Ifs is
undefined , returnc(x). - Lete bex'sendIndex.
- Letlen be the number of elements ins.
- Letf bee +direction ×len.
- Iff < 0 orf >InputLength, return
failure . - Letg be
min (e,f). - If there exists an
integer i between 0 (inclusive) andlen (exclusive) such thatCanonicalize (s[i]) is not the same character value asCanonicalize (Input[g +i]), returnfailure . - Lety be the State (f,cap).
- Returnc(y).
22.2.2.10 CharacterEscape
The
- Letcv be the
CharacterValue of thisCharacterEscape . - Return the character whose character value iscv.
22.2.2.11 DecimalEscape
The
- Return the
CapturingGroupNumber of thisDecimalEscape .
If\ is followed by a decimal numbern whose first digit is not0, then the escape sequence is considered to be a backreference. It is an error ifn is greater than the total number of left-capturing parentheses in the entire regular expression.
22.2.2.12 CharacterClassEscape
The production
- Return the ten-element CharSet containing the characters
0through9inclusive.
The production
- Return the CharSet containing all characters not in the CharSet returned by
CharacterClassEscape :: d
The production
- Return the CharSet containing all characters corresponding to a code point on the right-hand side of the
WhiteSpace orLineTerminator productions.
The production
- Return the CharSet containing all characters not in the CharSet returned by
CharacterClassEscape :: s
The production
- ReturnWordCharacters.
The production
- Return the CharSet containing all characters not in the CharSet returned by
CharacterClassEscape :: w
The production
- Return the CharSet containing all Unicode code points included in the CharSet returned by
UnicodePropertyValueExpression .
The production
- Return the CharSet containing all Unicode code points not included in the CharSet returned by
UnicodePropertyValueExpression .
The production
- Letps be
SourceText ofUnicodePropertyName . - Letp be !
UnicodeMatchProperty (ps). Assert :p is a Unicodeproperty name or property alias listed in the “Property name and aliases” column ofTable 56 .- Letvs be
SourceText ofUnicodePropertyValue . - Letv be !
UnicodeMatchPropertyValue (p,vs). - Return the CharSet containing all Unicode code points whose character database definition includes the propertyp with valuev.
The production
- Lets be
SourceText ofLoneUnicodePropertyNameOrValue . - If !
UnicodeMatchPropertyValue (General_Category,s) is identical to aList of Unicode code points that is the name of a Unicode general category or general category alias listed in the “Property value and aliases” column ofTable 58 , then- Return the CharSet containing all Unicode code points whose character database definition includes the property “General_Category” with values.
- Letp be !
UnicodeMatchProperty (s). Assert :p is a binary Unicode property or binary property alias listed in the “Property name and aliases” column ofTable 57 .- Return the CharSet containing all Unicode code points whose character database definition includes the propertyp with value “True”.
22.2.2.13 CharacterClass
The production
- Evaluate
ClassRanges to obtain a CharSetA. - Return the two resultsA and
false .
The production
- Evaluate
ClassRanges to obtain a CharSetA. - Return the two resultsA and
true .
22.2.2.14 ClassRanges
The production
- Return the empty CharSet.
The production
- Return the CharSet that is the result of evaluating
NonemptyClassRanges .
22.2.2.15 NonemptyClassRanges
The production
- Return the CharSet that is the result of evaluating
ClassAtom .
The production
- Evaluate
ClassAtom to obtain a CharSetA. - Evaluate
NonemptyClassRangesNoDash to obtain a CharSetB. - Return the union of CharSetsA andB.
The production
- Evaluate the first
ClassAtom to obtain a CharSetA. - Evaluate the second
ClassAtom to obtain a CharSetB. - Evaluate
ClassRanges to obtain a CharSetC. - LetD be !
CharacterRange (A,B). - Return the union ofD andC.
22.2.2.15.1 CharacterRange (A,B )
The abstract operation CharacterRange takes argumentsA (a CharSet) andB (a CharSet). It performs the following steps when called:
Assert :A andB each contain exactly one character.- Leta be the one character in CharSetA.
- Letb be the one character in CharSetB.
- Leti be the character value of charactera.
- Letj be the character value of characterb.
Assert :i ≤j.- Return the CharSet containing all characters with a character value greater than or equal toi and less than or equal toj.
22.2.2.16 NonemptyClassRangesNoDash
The production
- Return the CharSet that is the result of evaluating
ClassAtom .
The production
- Evaluate
ClassAtomNoDash to obtain a CharSetA. - Evaluate
NonemptyClassRangesNoDash to obtain a CharSetB. - Return the union of CharSetsA andB.
The production
- Evaluate
ClassAtomNoDash to obtain a CharSetA. - Evaluate
ClassAtom to obtain a CharSetB. - Evaluate
ClassRanges to obtain a CharSetC. - LetD be !
CharacterRange (A,B). - Return the union ofD andC.
Even if the pattern ignores case, the case of the two ends of a range is significant in determining which characters belong to the range. Thus, for example, the pattern/[E-F]/i matches only the lettersE,F,e, andf, while the pattern/[E-f]/i matches all upper and lower-case letters in the Unicode Basic Latin block as well as the symbols[,\,],^,_, and`.
A- character can be treated literally or it can denote a range. It is treated literally if it is the first or last character of
22.2.2.17 ClassAtom
The production
- Return the CharSet containing the single character
-U+002D (HYPHEN-MINUS).
The production
- Return the CharSet that is the result of evaluating
ClassAtomNoDash .
22.2.2.18 ClassAtomNoDash
The production
- Return the CharSet containing the character matched by
SourceCharacter .
The production
- Return the CharSet that is the result of evaluating
ClassEscape .
22.2.2.19 ClassEscape
The
- Letcv be the
CharacterValue of thisClassEscape . - Letc be the character whose character value iscv.
- Return the CharSet containing the single characterc.
- Return the CharSet that is the result of evaluating
CharacterClassEscape .
A\b,\B, and backreferences. Inside a\b means the backspace character, while\B and backreferences raise errors. Using a backreference inside a
22.2.3 The RegExp Constructor
The RegExp
- is%RegExp%.
- is the initial value of the
"RegExp" property of theglobal object . - creates and initializes a new RegExp object when called as a function rather than as a
constructor . Thus the function callRegExp(…)is equivalent to the object creation expressionnew RegExp(…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified RegExp behaviour must include asupercall to the RegExpconstructor to create and initialize subclass instances with the necessary internal slots.
22.2.3.1 RegExp (pattern,flags )
The following steps are taken:
- LetpatternIsRegExp be ?
IsRegExp (pattern). - If NewTarget is
undefined , then- LetnewTarget be the
active function object . - IfpatternIsRegExp is
true andflags isundefined , then
- LetnewTarget be the
- Else, letnewTarget be NewTarget.
- If
Type (pattern) is Object andpattern has a [[RegExpMatcher]] internal slot, then- LetP bepattern.[[OriginalSource]].
- Ifflags is
undefined , letF bepattern.[[OriginalFlags]]. - Else, letF beflags.
- Else ifpatternIsRegExp is
true , then - Else,
- LetP bepattern.
- LetF beflags.
- LetO be ?
RegExpAlloc (newTarget). - Return ?
RegExpInitialize (O,P,F).
If pattern is supplied using a
22.2.3.2 Abstract Operations for the RegExp Constructor
22.2.3.2.1 RegExpAlloc (newTarget )
The abstract operation RegExpAlloc takes argumentnewTarget. It performs the following steps when called:
- Letobj be ?
OrdinaryCreateFromConstructor (newTarget,"%RegExp.prototype%" , « [[RegExpMatcher]], [[OriginalSource]], [[OriginalFlags]] »). - Perform !
DefinePropertyOrThrow (obj,"lastIndex" , PropertyDescriptor { [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }). - Returnobj.
22.2.3.2.2 RegExpInitialize (obj,pattern,flags )
The abstract operation RegExpInitialize takes argumentsobj,pattern, andflags. It performs the following steps when called:
- Ifpattern is
undefined , letP be the empty String. - Else, letP be ?
ToString (pattern). - Ifflags is
undefined , letF be the empty String. - Else, letF be ?
ToString (flags). - IfF contains any code unit other than
"g" ,"i" ,"m" ,"s" ,"u" , or"y" or if it contains the same code unit more than once, throw aSyntaxError exception. - IfF contains
"u" , letu betrue ; else letu befalse . - Ifu is
true , then- LetpatternText be !
StringToCodePoints (P). - LetpatternCharacters be a
List whose elements are the code points ofpatternText.
- LetpatternText be !
- Else,
- LetpatternText be the result of interpreting each ofP's 16-bit elements as a Unicode BMP code point. UTF-16 decoding is not applied to the elements.
- LetpatternCharacters be a
List whose elements are the code unit elements ofP.
- LetparseResult be
ParsePattern (patternText,u). - IfparseResult is a non-empty
List ofSyntaxError objects, throw aSyntaxError exception. Assert :parseResult is aParse Node forPattern .- Setobj.[[OriginalSource]] toP.
- Setobj.[[OriginalFlags]] toF.
- Setobj.[[RegExpMatcher]] to the
Abstract Closure that evaluatesparseResult by applying the semantics provided in22.2.2 usingpatternCharacters as the pattern'sList ofSourceCharacter values andF as the flag parameters. - Perform ?
Set (obj,"lastIndex" ,+0 𝔽,true ). - Returnobj.
22.2.3.2.3 Static Semantics: ParsePattern (patternText,u )
The abstract operation ParsePattern takes argumentspatternText (a sequence of Unicode code points) andu (a Boolean). It performs the following steps when called:
22.2.3.2.4 RegExpCreate (P,F )
The abstract operation RegExpCreate takes argumentsP andF. It performs the following steps when called:
- Letobj be ?
RegExpAlloc (%RegExp% ). - Return ?
RegExpInitialize (obj,P,F).
22.2.3.2.5 EscapeRegExpPattern (P,F )
The abstract operation EscapeRegExpPattern takes argumentsP andF. It performs the following steps when called:
- LetS be a String in the form of a
Pattern ([~U] Pattern ifF contains[+U] "u" ) equivalent toP interpreted as UTF-16 encoded Unicode code points (6.1.4 ), in which certain code points are escaped as described below.S may or may not be identical toP; however, theAbstract Closure that would result from evaluatingS as aPattern ([~U] Pattern ifF contains[+U] "u" ) must behave identically to theAbstract Closure given by the constructed object's [[RegExpMatcher]] internal slot. Multiple calls to this abstract operation using the same values forP andF must produce identical results. - The code points
/or anyLineTerminator occurring in the pattern shall be escaped inS as necessary to ensure that thestring-concatenation of"/" ,S,"/" , andF can be parsed (in an appropriate lexical context) as aRegularExpressionLiteral that behaves identically to the constructed regular expression. For example, ifP is"/" , thenS could be"\/" or"\u002F" , among other possibilities, but not"/" , because///followed byF would be parsed as aSingleLineComment rather than aRegularExpressionLiteral . IfP is the empty String, this specification can be met by lettingS be"(?:)" . - ReturnS.
22.2.4 Properties of the RegExp Constructor
The RegExp
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
22.2.4.1 RegExp.prototype
The initial value ofRegExp.prototype is the
This property has the attributes { [[Writable]]:
22.2.4.2 get RegExp [ @@species ]
RegExp[@@species] is an
- Return the
this value.
The value of the
RegExp prototype methods normally use their
22.2.5 Properties of the RegExp Prototype Object
TheRegExp prototype object:
- is%RegExp.prototype%.
- is an
ordinary object . - is not a RegExp instance and does not have a [[RegExpMatcher]] internal slot or any of the other internal slots of RegExp instance objects.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% .
The RegExp prototype object does not have a
22.2.5.1 RegExp.prototype.constructor
The initial value ofRegExp.prototype.constructor is
22.2.5.2 RegExp.prototype.exec (string )
Performs a regular expression match ofstring against the regular expression and returns an Array object containing the results of the match, or
The String
- LetR be the
this value. - Perform ?
RequireInternalSlot (R, [[RegExpMatcher]]). - LetS be ?
ToString (string). - Return ?
RegExpBuiltinExec (R,S).
22.2.5.2.1 RegExpExec (R,S )
The abstract operation RegExpExec takes argumentsR andS. It performs the following steps when called:
Assert :Type (R) is Object.Assert :Type (S) is String.- Letexec be ?
Get (R,"exec" ). - If
IsCallable (exec) istrue , then - Perform ?
RequireInternalSlot (R, [[RegExpMatcher]]). - Return ?
RegExpBuiltinExec (R,S).
If a callable
22.2.5.2.2 RegExpBuiltinExec (R,S )
The abstract operation RegExpBuiltinExec takes argumentsR andS. It performs the following steps when called:
Assert :R is an initialized RegExp instance.Assert :Type (S) is String.- Letlength be the number of code units inS.
- LetlastIndex be
ℝ (?ToLength (?Get (R,"lastIndex" ))). - Letflags beR.[[OriginalFlags]].
- Ifflags contains
"g" , letglobal betrue ; else letglobal befalse . - Ifflags contains
"y" , letsticky betrue ; else letsticky befalse . - Ifglobal is
false andsticky isfalse , setlastIndex to 0. - Letmatcher beR.[[RegExpMatcher]].
- Ifflags contains
"u" , letfullUnicode betrue ; else letfullUnicode befalse . - LetmatchSucceeded be
false . - Repeat, whilematchSucceeded is
false ,- IflastIndex >length, then
- Ifglobal is
true orsticky istrue , then- Perform ?
Set (R,"lastIndex" ,+0 𝔽,true ).
- Perform ?
- Return
null .
- Ifglobal is
- Letr bematcher(S,lastIndex).
- Ifr is
failure , then- Ifsticky is
true , then- Perform ?
Set (R,"lastIndex" ,+0 𝔽,true ). - Return
null .
- Perform ?
- SetlastIndex to
AdvanceStringIndex (S,lastIndex,fullUnicode).
- Ifsticky is
- Else,
Assert :r is a State.- SetmatchSucceeded to
true .
- IflastIndex >length, then
- Lete ber'sendIndex value.
- IffullUnicode is
true , then- e is an index into theInput character list, derived fromS, matched bymatcher. LeteUTF be the smallest index intoS that corresponds to the character at elemente ofInput. Ife is greater than or equal to the number of elements inInput, theneUTF is the number of code units inS.
- Sete toeUTF.
- Ifglobal is
true orsticky istrue , then - Letn be the number of elements inr'scaptures
List . (This is the same value as22.2.2.1 'sNcapturingParens.) Assert :n < 232 - 1.- LetA be !
ArrayCreate (n + 1). Assert : Themathematical value ofA's"length" property isn + 1.- Perform !
CreateDataPropertyOrThrow (A,"index" ,𝔽 (lastIndex)). - Perform !
CreateDataPropertyOrThrow (A,"input" ,S). - LetmatchedSubstr be the
substring ofS fromlastIndex toe. - Perform !
CreateDataPropertyOrThrow (A,"0" ,matchedSubstr). - IfR contains any
GroupName , then- Letgroups be !
OrdinaryObjectCreate (null ).
- Letgroups be !
- Else,
- Letgroups be
undefined .
- Letgroups be
- Perform !
CreateDataPropertyOrThrow (A,"groups" ,groups). - For each
integer i such thati ≥ 1 andi ≤n, do- LetcaptureI beith element ofr'scaptures
List . - IfcaptureI is
undefined , letcapturedValue beundefined . - Else iffullUnicode is
true , thenAssert :captureI is aList of code points.- LetcapturedValue be !
CodePointsToString (captureI).
- Else,
- Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (i)),capturedValue). - If theith capture ofR was defined with a
GroupName , then- Lets be the
CapturingGroupName of the correspondingRegExpIdentifierName . - Perform !
CreateDataPropertyOrThrow (groups,s,capturedValue).
- Lets be the
- LetcaptureI beith element ofr'scaptures
- ReturnA.
22.2.5.2.3 AdvanceStringIndex (S,index,unicode )
The abstract operation AdvanceStringIndex takes argumentsS (a String),index (a non-negative
Assert :index ≤ 253 - 1.- Ifunicode is
false , returnindex + 1. - Letlength be the number of code units inS.
- Ifindex + 1 ≥length, returnindex + 1.
- Letcp be !
CodePointAt (S,index). - Returnindex +cp.[[CodeUnitCount]].
22.2.5.3 get RegExp.prototype.dotAll
RegExp.prototype.dotAll is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalFlags]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , returnundefined . - Otherwise, throw a
TypeError exception.
- If
- Letflags beR.[[OriginalFlags]].
- Ifflags contains the code unit 0x0073 (LATIN SMALL LETTER S), return
true . - Return
false .
22.2.5.4 get RegExp.prototype.flags
RegExp.prototype.flags is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - Letresult be the empty String.
- Letglobal be !
ToBoolean (?Get (R,"global" )). - Ifglobal is
true , append the code unit 0x0067 (LATIN SMALL LETTER G) as the last code unit ofresult. - LetignoreCase be !
ToBoolean (?Get (R,"ignoreCase" )). - IfignoreCase is
true , append the code unit 0x0069 (LATIN SMALL LETTER I) as the last code unit ofresult. - Letmultiline be !
ToBoolean (?Get (R,"multiline" )). - Ifmultiline is
true , append the code unit 0x006D (LATIN SMALL LETTER M) as the last code unit ofresult. - LetdotAll be !
ToBoolean (?Get (R,"dotAll" )). - IfdotAll is
true , append the code unit 0x0073 (LATIN SMALL LETTER S) as the last code unit ofresult. - Letunicode be !
ToBoolean (?Get (R,"unicode" )). - Ifunicode is
true , append the code unit 0x0075 (LATIN SMALL LETTER U) as the last code unit ofresult. - Letsticky be !
ToBoolean (?Get (R,"sticky" )). - Ifsticky is
true , append the code unit 0x0079 (LATIN SMALL LETTER Y) as the last code unit ofresult. - Returnresult.
22.2.5.5 get RegExp.prototype.global
RegExp.prototype.global is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalFlags]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , returnundefined . - Otherwise, throw a
TypeError exception.
- If
- Letflags beR.[[OriginalFlags]].
- Ifflags contains the code unit 0x0067 (LATIN SMALL LETTER G), return
true . - Return
false .
22.2.5.6 get RegExp.prototype.ignoreCase
RegExp.prototype.ignoreCase is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalFlags]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , returnundefined . - Otherwise, throw a
TypeError exception.
- If
- Letflags beR.[[OriginalFlags]].
- Ifflags contains the code unit 0x0069 (LATIN SMALL LETTER I), return
true . - Return
false .
22.2.5.7 RegExp.prototype [ @@match ] (string )
When the@@match method is called with argumentstring, the following steps are taken:
- Letrx be the
this value. - If
Type (rx) is not Object, throw aTypeError exception. - LetS be ?
ToString (string). - Letglobal be !
ToBoolean (?Get (rx,"global" )). - Ifglobal is
false , then- Return ?
RegExpExec (rx,S).
- Return ?
- Else,
Assert :global istrue .- LetfullUnicode be !
ToBoolean (?Get (rx,"unicode" )). - Perform ?
Set (rx,"lastIndex" ,+0 𝔽,true ). - LetA be !
ArrayCreate (0). - Letn be 0.
- Repeat,
- Letresult be ?
RegExpExec (rx,S). - Ifresult is
null , then- Ifn = 0, return
null . - ReturnA.
- Ifn = 0, return
- Else,
- LetmatchStr be ?
ToString (?Get (result,"0" )). - Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),matchStr). - IfmatchStr is the empty String, then
- Setn ton + 1.
- LetmatchStr be ?
- Letresult be ?
The value of the
The
22.2.5.8 RegExp.prototype [ @@matchAll ] (string )
When the@@matchAll method is called with argumentstring, the following steps are taken:
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - LetS be ?
ToString (string). - LetC be ?
SpeciesConstructor (R,%RegExp% ). - Letflags be ?
ToString (?Get (R,"flags" )). - Letmatcher be ?
Construct (C, «R,flags »). - LetlastIndex be ?
ToLength (?Get (R,"lastIndex" )). - Perform ?
Set (matcher,"lastIndex" ,lastIndex,true ). - Ifflags contains
"g" , letglobal betrue . - Else, letglobal be
false . - Ifflags contains
"u" , letfullUnicode betrue . - Else, letfullUnicode be
false . - Return !
CreateRegExpStringIterator (matcher,S,global,fullUnicode).
The value of the
22.2.5.9 get RegExp.prototype.multiline
RegExp.prototype.multiline is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalFlags]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , returnundefined . - Otherwise, throw a
TypeError exception.
- If
- Letflags beR.[[OriginalFlags]].
- Ifflags contains the code unit 0x006D (LATIN SMALL LETTER M), return
true . - Return
false .
22.2.5.10 RegExp.prototype [ @@replace ] (string,replaceValue )
When the@@replace method is called with argumentsstring andreplaceValue, the following steps are taken:
- Letrx be the
this value. - If
Type (rx) is not Object, throw aTypeError exception. - LetS be ?
ToString (string). - LetlengthS be the number of code unit elements inS.
- LetfunctionalReplace be
IsCallable (replaceValue). - IffunctionalReplace is
false , then- SetreplaceValue to ?
ToString (replaceValue).
- SetreplaceValue to ?
- Letglobal be !
ToBoolean (?Get (rx,"global" )). - Ifglobal is
true , then - Letresults be a new empty
List . - Letdone be
false . - Repeat, whiledone is
false ,- Letresult be ?
RegExpExec (rx,S). - Ifresult is
null , setdone totrue . - Else,
- Appendresult to the end ofresults.
- Ifglobal is
false , setdone totrue . - Else,
- Letresult be ?
- LetaccumulatedResult be the empty String.
- LetnextSourcePosition be 0.
- For each elementresult ofresults, do
- LetresultLength be ?
LengthOfArrayLike (result). - LetnCaptures be
max (resultLength - 1, 0). - Letmatched be ?
ToString (?Get (result,"0" )). - LetmatchLength be the number of code units inmatched.
- Letposition be ?
ToIntegerOrInfinity (?Get (result,"index" )). - Setposition to the result of
clamping position between 0 andlengthS. - Letn be 1.
- Letcaptures be a new empty
List . - Repeat, whilen ≤nCaptures,
- LetnamedCaptures be ?
Get (result,"groups" ). - IffunctionalReplace is
true , then- LetreplacerArgs be «matched ».
- Append in
List order the elements ofcaptures to the end of theList replacerArgs. - Append
𝔽 (position) andS toreplacerArgs. - IfnamedCaptures is not
undefined , then- AppendnamedCaptures as the last element ofreplacerArgs.
- LetreplValue be ?
Call (replaceValue,undefined ,replacerArgs). - Letreplacement be ?
ToString (replValue).
- Else,
- IfnamedCaptures is not
undefined , then- SetnamedCaptures to ?
ToObject (namedCaptures).
- SetnamedCaptures to ?
- Letreplacement be ?
GetSubstitution (matched,S,position,captures,namedCaptures,replaceValue).
- IfnamedCaptures is not
- Ifposition ≥nextSourcePosition, then
- NOTE:position should not normally move backwards. If it does, it is an indication of an ill-behaving RegExp subclass or use of an access triggered side-effect to change the global flag or other characteristics ofrx. In such cases, the corresponding substitution is ignored.
- SetaccumulatedResult to the
string-concatenation ofaccumulatedResult, thesubstring ofS fromnextSourcePosition toposition, andreplacement. - SetnextSourcePosition toposition +matchLength.
- LetresultLength be ?
- IfnextSourcePosition ≥lengthS, returnaccumulatedResult.
- Return the
string-concatenation ofaccumulatedResult and thesubstring ofS fromnextSourcePosition.
The value of the
22.2.5.11 RegExp.prototype [ @@search ] (string )
When the@@search method is called with argumentstring, the following steps are taken:
- Letrx be the
this value. - If
Type (rx) is not Object, throw aTypeError exception. - LetS be ?
ToString (string). - LetpreviousLastIndex be ?
Get (rx,"lastIndex" ). - If
SameValue (previousLastIndex,+0 𝔽) isfalse , then- Perform ?
Set (rx,"lastIndex" ,+0 𝔽,true ).
- Perform ?
- Letresult be ?
RegExpExec (rx,S). - LetcurrentLastIndex be ?
Get (rx,"lastIndex" ). - If
SameValue (currentLastIndex,previousLastIndex) isfalse , then- Perform ?
Set (rx,"lastIndex" ,previousLastIndex,true ).
- Perform ?
- Ifresult is
null , return-1 𝔽. - Return ?
Get (result,"index" ).
The value of the
The
22.2.5.12 get RegExp.prototype.source
RegExp.prototype.source is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalSource]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , return"(?:)" . - Otherwise, throw a
TypeError exception.
- If
Assert :R has an [[OriginalFlags]] internal slot.- Letsrc beR.[[OriginalSource]].
- Letflags beR.[[OriginalFlags]].
- Return
EscapeRegExpPattern (src,flags).
22.2.5.13 RegExp.prototype [ @@split ] (string,limit )
Returns an Array object into which substrings of the result of convertingstring to a String have been stored. The substrings are determined by searching from left to right for matches of the
The/a*?/[Symbol.split]("ab") evaluates to the array["a", "b"], while/a*/[Symbol.split]("ab") evaluates to the array["","b"].)
Ifstring is (or converts to) the empty String, the result depends on whether the regular expression can match the empty String. If it can, the result array contains no elements. Otherwise, the result array contains one element, which is the empty String.
If the regular expression contains capturing parentheses, then each timeseparator is matched the results (including any
/<(\/)?([^<>]+)>/[Symbol.split]("A<B>bold</B>and<CODE>coded</CODE>")evaluates to the array
["A",undefined,"B","bold","/","B","and",undefined,"CODE","coded","/","CODE",""]Iflimit is not
When the@@split method is called, the following steps are taken:
- Letrx be the
this value. - If
Type (rx) is not Object, throw aTypeError exception. - LetS be ?
ToString (string). - LetC be ?
SpeciesConstructor (rx,%RegExp% ). - Letflags be ?
ToString (?Get (rx,"flags" )). - Ifflags contains
"u" , letunicodeMatching betrue . - Else, letunicodeMatching be
false . - Ifflags contains
"y" , letnewFlags beflags. - Else, letnewFlags be the
string-concatenation offlags and"y" . - Letsplitter be ?
Construct (C, «rx,newFlags »). - LetA be !
ArrayCreate (0). - LetlengthA be 0.
- Iflimit is
undefined , letlim be 232 - 1; else letlim beℝ (?ToUint32 (limit)). - Iflim is 0, returnA.
- Letsize be the length ofS.
- Ifsize is 0, then
- Letz be ?
RegExpExec (splitter,S). - Ifz is not
null , returnA. - Perform !
CreateDataPropertyOrThrow (A,"0" ,S). - ReturnA.
- Letz be ?
- Letp be 0.
- Letq bep.
- Repeat, whileq <size,
- Perform ?
Set (splitter,"lastIndex" ,𝔽 (q),true ). - Letz be ?
RegExpExec (splitter,S). - Ifz is
null , setq toAdvanceStringIndex (S,q,unicodeMatching). - Else,
- Lete be
ℝ (?ToLength (?Get (splitter,"lastIndex" ))). - Sete to
min (e,size). - Ife =p, setq to
AdvanceStringIndex (S,q,unicodeMatching). - Else,
- LetT be the
substring ofS fromp toq. - Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (lengthA)),T). - SetlengthA tolengthA + 1.
- IflengthA =lim, returnA.
- Setp toe.
- LetnumberOfCaptures be ?
LengthOfArrayLike (z). - SetnumberOfCaptures to
max (numberOfCaptures - 1, 0). - Leti be 1.
- Repeat, whilei ≤numberOfCaptures,
- Setq top.
- LetT be the
- Lete be
- Perform ?
- LetT be the
substring ofS fromp tosize. - Perform !
CreateDataPropertyOrThrow (A, !ToString (𝔽 (lengthA)),T). - ReturnA.
The value of the
The@@split method ignores the value of the
22.2.5.14 get RegExp.prototype.sticky
RegExp.prototype.sticky is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalFlags]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , returnundefined . - Otherwise, throw a
TypeError exception.
- If
- Letflags beR.[[OriginalFlags]].
- Ifflags contains the code unit 0x0079 (LATIN SMALL LETTER Y), return
true . - Return
false .
22.2.5.15 RegExp.prototype.test (S )
The following steps are taken:
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - Letstring be ?
ToString (S). - Letmatch be ?
RegExpExec (R,string). - Ifmatch is not
null , returntrue ; else returnfalse .
22.2.5.16 RegExp.prototype.toString ( )
The returned String has the form of a
22.2.5.17 get RegExp.prototype.unicode
RegExp.prototype.unicode is an
- LetR be the
this value. - If
Type (R) is not Object, throw aTypeError exception. - IfR does not have an [[OriginalFlags]] internal slot, then
- If
SameValue (R,%RegExp.prototype% ) istrue , returnundefined . - Otherwise, throw a
TypeError exception.
- If
- Letflags beR.[[OriginalFlags]].
- Ifflags contains the code unit 0x0075 (LATIN SMALL LETTER U), return
true . - Return
false .
22.2.6 Properties of RegExp Instances
RegExp instances are ordinary objects that inherit properties from the
Prior to ECMAScript 2015, RegExp instances were specified as having the own data propertiesRegExp.prototype.
RegExp instances also have the following property:
22.2.6.1 lastIndex
The value of the
22.2.7 RegExp String Iterator Objects
A RegExp String Iterator is an object, that represents a specific iteration over some specific String instance object, matching against some specific RegExp instance object. There is not a named
22.2.7.1 CreateRegExpStringIterator (R,S,global,fullUnicode )
The abstract operation CreateRegExpStringIterator takes argumentsR,S,global, andfullUnicode. It performs the following steps when called:
Assert :Type (S) is String.Assert :Type (global) is Boolean.Assert :Type (fullUnicode) is Boolean.- Letclosure be a new
Abstract Closure with no parameters that capturesR,S,global, andfullUnicode and performs the following steps when called:- Repeat,
- Letmatch be ?
RegExpExec (R,S). - Ifmatch is
null , returnundefined . - Ifglobal is
false , then- Perform ?
Yield (match). - Return
undefined .
- Perform ?
- LetmatchStr be ?
ToString (?Get (match,"0" )). - IfmatchStr is the empty String, then
- Perform ?
Yield (match).
- Letmatch be ?
- Repeat,
- Return !
CreateIteratorFromClosure (closure,"%RegExpStringIteratorPrototype%" ,%RegExpStringIteratorPrototype% ).
22.2.7.2 The %RegExpStringIteratorPrototype% Object
The%RegExpStringIteratorPrototype% object:
- has properties that are inherited by all RegExp String Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - has the following properties:
22.2.7.2.1 %RegExpStringIteratorPrototype%.next ( )
- Return ?
GeneratorResume (this value,empty ,"%RegExpStringIteratorPrototype%" ).
22.2.7.2.2 %RegExpStringIteratorPrototype% [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
23 Indexed Collections
23.1 Array Objects
Array objects are exotic objects that give special treatment to a certain class of property names. See
23.1.1 The Array Constructor
The Array
- is%Array%.
- is the initial value of the
"Array" property of theglobal object . - creates and initializes a new
Array exotic object when called as aconstructor . - also creates and initializes a new Array object when called as a function rather than as a
constructor . Thus the function callArray(…)is equivalent to the object creation expressionnew Array(…)with the same arguments. - is a function whose behaviour differs based upon the number and types of its arguments.
- is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the exotic Array behaviour must include asupercall to the Arrayconstructor to initialize subclass instances that are Array exotic objects. However, most of theArray.prototypemethods are generic methods that are not dependent upon theirthis value being anArray exotic object . - has a
"length" property whose value is1 𝔽.
23.1.1.1 Array ( ...values )
When theArray function is called, the following steps are taken:
- If NewTarget is
undefined , letnewTarget be theactive function object ; else letnewTarget be NewTarget. - Letproto be ?
GetPrototypeFromConstructor (newTarget,"%Array.prototype%" ). - LetnumberOfArgs be the number of elements invalues.
- IfnumberOfArgs = 0, then
- Return !
ArrayCreate (0,proto).
- Return !
- Else ifnumberOfArgs = 1, then
- Letlen bevalues[0].
- Letarray be !
ArrayCreate (0,proto). - If
Type (len) is not Number, then- Perform !
CreateDataPropertyOrThrow (array,"0" ,len). - LetintLen be
1 𝔽.
- Perform !
- Else,
- LetintLen be !
ToUint32 (len). - IfintLen is not the same value aslen, throw a
RangeError exception.
- LetintLen be !
- Perform !
Set (array,"length" ,intLen,true ). - Returnarray.
- Else,
Assert :numberOfArgs ≥ 2.- Letarray be ?
ArrayCreate (numberOfArgs,proto). - Letk be 0.
- Repeat, whilek <numberOfArgs,
- LetPk be !
ToString (𝔽 (k)). - LetitemK bevalues[k].
- Perform !
CreateDataPropertyOrThrow (array,Pk,itemK). - Setk tok + 1.
- LetPk be !
Assert : Themathematical value ofarray's"length" property isnumberOfArgs.- Returnarray.
23.1.2 Properties of the Array Constructor
The Array
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
23.1.2.1 Array.from (items [ ,mapfn [ ,thisArg ] ] )
When thefrom method is called with argumentitems and optional argumentsmapfn andthisArg, the following steps are taken:
- LetC be the
this value. - Ifmapfn is
undefined , letmapping befalse . - Else,
- If
IsCallable (mapfn) isfalse , throw aTypeError exception. - Letmapping be
true .
- If
- LetusingIterator be ?
GetMethod (items,@@iterator ). - IfusingIterator is not
undefined , then- If
IsConstructor (C) istrue , then- LetA be ?
Construct (C).
- LetA be ?
- Else,
- LetA be !
ArrayCreate (0).
- LetA be !
- LetiteratorRecord be ?
GetIterator (items,sync ,usingIterator). - Letk be 0.
- Repeat,
- Ifk ≥ 253 - 1, then
- Leterror be
ThrowCompletion (a newly createdTypeError object). - Return ?
IteratorClose (iteratorRecord,error).
- Leterror be
- LetPk be !
ToString (𝔽 (k)). - Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , then - LetnextValue be ?
IteratorValue (next). - Ifmapping is
true , then- LetmappedValue be
Call (mapfn,thisArg, «nextValue,𝔽 (k) »). - IfmappedValue is an
abrupt completion , return ?IteratorClose (iteratorRecord,mappedValue). - SetmappedValue tomappedValue.[[Value]].
- LetmappedValue be
- Else, letmappedValue benextValue.
- LetdefineStatus be
CreateDataPropertyOrThrow (A,Pk,mappedValue). - IfdefineStatus is an
abrupt completion , return ?IteratorClose (iteratorRecord,defineStatus). - Setk tok + 1.
- Ifk ≥ 253 - 1, then
- If
- NOTE:items is not an Iterable so assume it is an
array-like object . - LetarrayLike be !
ToObject (items). - Letlen be ?
LengthOfArrayLike (arrayLike). - If
IsConstructor (C) istrue , then - Else,
- LetA be ?
ArrayCreate (len).
- LetA be ?
- Letk be 0.
- Repeat, whilek <len,
- Perform ?
Set (A,"length" ,𝔽 (len),true ). - ReturnA.
Thefrom function is an intentionally generic factory method; it does not require that its
23.1.2.2 Array.isArray (arg )
TheisArray function takes one argumentarg, and performs the following steps:
- Return ?
IsArray (arg).
23.1.2.3 Array.of ( ...items )
When theof method is called with any number of arguments, the following steps are taken:
- Letlen be the number of elements initems.
- LetlenNumber be
𝔽 (len). - LetC be the
this value. - If
IsConstructor (C) istrue , then- LetA be ?
Construct (C, «lenNumber »).
- LetA be ?
- Else,
- LetA be ?
ArrayCreate (len).
- LetA be ?
- Letk be 0.
- Repeat, whilek <len,
- LetkValue beitems[k].
- LetPk be !
ToString (𝔽 (k)). - Perform ?
CreateDataPropertyOrThrow (A,Pk,kValue). - Setk tok + 1.
- Perform ?
Set (A,"length" ,lenNumber,true ). - ReturnA.
Theof function is an intentionally generic factory method; it does not require that its
23.1.2.4 Array.prototype
The value ofArray.prototype is the
This property has the attributes { [[Writable]]:
23.1.2.5 get Array [ @@species ]
Array[@@species] is an
- Return the
this value.
The value of the
Array prototype methods normally use their
23.1.3 Properties of the Array Prototype Object
TheArray prototype object:
- is%Array.prototype%.
- is an
Array exotic object and has the internal methods specified for such objects. - has a
"length" property whose initial value is+0 𝔽 and whose attributes are { [[Writable]]:true , [[Enumerable]]:false , [[Configurable]]:false }. - has a [[Prototype]] internal slot whose value is
%Object.prototype% .
The Array prototype object is specified to be an
23.1.3.1 Array.prototype.concat ( ...items )
When theconcat method is called with zero or more arguments, it returns an array containing the array elements of the object followed by the array elements of each argument.
The following steps are taken:
- LetO be ?
ToObject (this value). - LetA be ?
ArraySpeciesCreate (O, 0). - Letn be 0.
- PrependO toitems.
- For each elementE ofitems, do
- Letspreadable be ?
IsConcatSpreadable (E). - Ifspreadable is
true , then- Letk be 0.
- Letlen be ?
LengthOfArrayLike (E). - Ifn +len > 253 - 1, throw a
TypeError exception. - Repeat, whilek <len,
- LetP be !
ToString (𝔽 (k)). - Letexists be ?
HasProperty (E,P). - Ifexists is
true , then- LetsubElement be ?
Get (E,P). - Perform ?
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),subElement).
- LetsubElement be ?
- Setn ton + 1.
- Setk tok + 1.
- LetP be !
- Else,
- NOTE:E is added as a single item rather than spread.
- Ifn ≥ 253 - 1, throw a
TypeError exception. - Perform ?
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),E). - Setn ton + 1.
- Letspreadable be ?
- Perform ?
Set (A,"length" ,𝔽 (n),true ). - ReturnA.
Theconcat method is
The explicit setting of the
Theconcat function is intentionally generic; it does not require that its
23.1.3.1.1 IsConcatSpreadable (O )
The abstract operation IsConcatSpreadable takes argumentO. It performs the following steps when called:
- If
Type (O) is not Object, returnfalse . - Letspreadable be ?
Get (O,@@isConcatSpreadable ). - Ifspreadable is not
undefined , return !ToBoolean (spreadable). - Return ?
IsArray (O).
23.1.3.2 Array.prototype.constructor
The initial value ofArray.prototype.constructor is
23.1.3.3 Array.prototype.copyWithin (target,start [ ,end ] )
ThecopyWithin method takes up to three argumentstarget,start andend.
Theend argument is optional with the length of the
The following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - LetrelativeTarget be ?
ToIntegerOrInfinity (target). - IfrelativeTarget is -∞, letto be 0.
- Else ifrelativeTarget < 0, letto be
max (len +relativeTarget, 0). - Else, letto be
min (relativeTarget,len). - LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letfrom be 0.
- Else ifrelativeStart < 0, letfrom be
max (len +relativeStart, 0). - Else, letfrom be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - Letcount be
min (final -from,len -to). - Iffrom <to andto <from +count, then
- Letdirection be -1.
- Setfrom tofrom +count - 1.
- Setto toto +count - 1.
- Else,
- Letdirection be 1.
- Repeat, whilecount > 0,
- LetfromKey be !
ToString (𝔽 (from)). - LettoKey be !
ToString (𝔽 (to)). - LetfromPresent be ?
HasProperty (O,fromKey). - IffromPresent is
true , then - Else,
Assert :fromPresent isfalse .- Perform ?
DeletePropertyOrThrow (O,toKey).
- Setfrom tofrom +direction.
- Setto toto +direction.
- Setcount tocount - 1.
- LetfromKey be !
- ReturnO.
ThecopyWithin function is intentionally generic; it does not require that its
23.1.3.4 Array.prototype.entries ( )
The following steps are taken:
- LetO be ?
ToObject (this value). - Return
CreateArrayIterator (O,key+value ).
23.1.3.5 Array.prototype.every (callbackfn [ ,thisArg ] )
callbackfn should be a function that accepts three arguments and returns a value that is coercible to a Boolean value.every callscallbackfn once for each element present in the array, in ascending order, until it finds one wherecallbackfn returnsevery immediately returnsevery will return
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
every does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed byevery is set before the first call tocallbackfn. Elements which are appended to the array after the call toevery begins will not be visited bycallbackfn. If existing elements of the array are changed, their value as passed tocallbackfn will be the value at the timeevery visits them; elements that are deleted after the call toevery begins and before being visited are not visited.every acts like the "for all" quantifier in mathematics. In particular, for an empty array, it returns
When theevery method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
true .
Theevery function is intentionally generic; it does not require that its
23.1.3.6 Array.prototype.fill (value [ ,start [ ,end ] ] )
Thefill method takes up to three argumentsvalue,start andend.
Thestart andend arguments are optional with default values of 0 and the length of the
The following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letk be 0.
- Else ifrelativeStart < 0, letk be
max (len +relativeStart, 0). - Else, letk be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - Repeat, whilek <final,
- ReturnO.
Thefill function is intentionally generic; it does not require that its
23.1.3.7 Array.prototype.filter (callbackfn [ ,thisArg ] )
callbackfn should be a function that accepts three arguments and returns a value that is coercible to a Boolean value.filter callscallbackfn once for each element in the array, in ascending order, and constructs a new array of all the values for whichcallbackfn returns
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
filter does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed byfilter is set before the first call tocallbackfn. Elements which are appended to the array after the call tofilter begins will not be visited bycallbackfn. If existing elements of the array are changed their value as passed tocallbackfn will be the value at the timefilter visits them; elements that are deleted after the call tofilter begins and before being visited are not visited.
When thefilter method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - LetA be ?
ArraySpeciesCreate (O, 0). - Letk be 0.
- Letto be 0.
- Repeat, whilek <len,
- LetPk be !
ToString (𝔽 (k)). - LetkPresent be ?
HasProperty (O,Pk). - IfkPresent is
true , then - Setk tok + 1.
- LetPk be !
- ReturnA.
Thefilter function is intentionally generic; it does not require that its
23.1.3.8 Array.prototype.find (predicate [ ,thisArg ] )
Thefind method is called with one or two arguments,predicate andthisArg.
predicate should be a function that accepts three arguments and returns a value that is coercible to a Boolean value.find callspredicate once for each element of the array, in ascending order, until it finds one wherepredicate returnsfind immediately returns that element value. Otherwise,find returns
If athisArg parameter is provided, it will be used as the
predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.
find does not directly mutate the object on which it is called but the object may be mutated by the calls topredicate.
The range of elements processed byfind is set before the first call topredicate. Elements that are appended to the array after the call tofind begins will not be visited bypredicate. If existing elements of the array are changed, their value as passed topredicate will be the value at the time thatfind visits them; elements that are deleted after the call tofind begins and before being visited are not visited.
When thefind method is called, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (predicate) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
undefined .
Thefind function is intentionally generic; it does not require that its
23.1.3.9 Array.prototype.findIndex (predicate [ ,thisArg ] )
predicate should be a function that accepts three arguments and returns a value that is coercible to a Boolean value.findIndex callspredicate once for each element of the array, in ascending order, until it finds one wherepredicate returnsfindIndex immediately returns the index of that element value. Otherwise,findIndex returns -1.
If athisArg parameter is provided, it will be used as the
predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.
findIndex does not directly mutate the object on which it is called but the object may be mutated by the calls topredicate.
The range of elements processed byfindIndex is set before the first call topredicate. Elements that are appended to the array after the call tofindIndex begins will not be visited bypredicate. If existing elements of the array are changed, their value as passed topredicate will be the value at the time thatfindIndex visits them; elements that are deleted after the call tofindIndex begins and before being visited are not visited.
When thefindIndex method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (predicate) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
-1 𝔽.
ThefindIndex function is intentionally generic; it does not require that its
23.1.3.10 Array.prototype.flat ( [depth ] )
When theflat method is called with zero or one arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - LetsourceLen be ?
LengthOfArrayLike (O). - LetdepthNum be 1.
- Ifdepth is not
undefined , then- SetdepthNum to ?
ToIntegerOrInfinity (depth). - IfdepthNum < 0, setdepthNum to 0.
- SetdepthNum to ?
- LetA be ?
ArraySpeciesCreate (O, 0). - Perform ?
FlattenIntoArray (A,O,sourceLen, 0,depthNum). - ReturnA.
23.1.3.10.1 FlattenIntoArray (target,source,sourceLen,start,depth [ ,mapperFunction,thisArg ] )
The abstract operation FlattenIntoArray takes argumentstarget,source,sourceLen (a non-negative
Assert :Type (target) is Object.Assert :Type (source) is Object.Assert : IfmapperFunction is present, then !IsCallable (mapperFunction) istrue ,thisArg is present, anddepth is 1.- LettargetIndex bestart.
- LetsourceIndex be
+0 𝔽. - Repeat, while
ℝ (sourceIndex) <sourceLen,- LetP be !
ToString (sourceIndex). - Letexists be ?
HasProperty (source,P). - Ifexists is
true , then- Letelement be ?
Get (source,P). - IfmapperFunction is present, then
- Setelement to ?
Call (mapperFunction,thisArg, «element,sourceIndex,source »).
- Setelement to ?
- LetshouldFlatten be
false . - Ifdepth > 0, then
- SetshouldFlatten to ?
IsArray (element).
- SetshouldFlatten to ?
- IfshouldFlatten is
true , then- Ifdepth is +∞, letnewDepth be +∞.
- Else, letnewDepth bedepth - 1.
- LetelementLen be ?
LengthOfArrayLike (element). - SettargetIndex to ?
FlattenIntoArray (target,element,elementLen,targetIndex,newDepth).
- Else,
- IftargetIndex ≥ 253 - 1, throw a
TypeError exception. - Perform ?
CreateDataPropertyOrThrow (target, !ToString (𝔽 (targetIndex)),element). - SettargetIndex totargetIndex + 1.
- IftargetIndex ≥ 253 - 1, throw a
- Letelement be ?
- SetsourceIndex tosourceIndex +
1 𝔽.
- LetP be !
- ReturntargetIndex.
23.1.3.11 Array.prototype.flatMap (mapperFunction [ ,thisArg ] )
When theflatMap method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - LetsourceLen be ?
LengthOfArrayLike (O). - If !
IsCallable (mapperFunction) isfalse , throw aTypeError exception. - LetA be ?
ArraySpeciesCreate (O, 0). - Perform ?
FlattenIntoArray (A,O,sourceLen, 0, 1,mapperFunction,thisArg). - ReturnA.
23.1.3.12 Array.prototype.forEach (callbackfn [ ,thisArg ] )
callbackfn should be a function that accepts three arguments.forEach callscallbackfn once for each element present in the array, in ascending order.callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
forEach does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed byforEach is set before the first call tocallbackfn. Elements which are appended to the array after the call toforEach begins will not be visited bycallbackfn. If existing elements of the array are changed, their value as passed tocallbackfn will be the value at the timeforEach visits them; elements that are deleted after the call toforEach begins and before being visited are not visited.
When theforEach method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
undefined .
TheforEach function is intentionally generic; it does not require that its
23.1.3.13 Array.prototype.includes (searchElement [ ,fromIndex ] )
includes comparessearchElement to the elements of the array, in ascending order, using the
The optional second argumentfromIndex defaults to
When theincludes method is called, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Iflen is 0, return
false . - Letn be ?
ToIntegerOrInfinity (fromIndex). Assert : IffromIndex isundefined , thenn is 0.- Ifn is +∞, return
false . - Else ifn is -∞, setn to 0.
- Ifn ≥ 0, then
- Letk ben.
- Else,
- Letk belen +n.
- Ifk < 0, setk to 0.
- Repeat, whilek <len,
- LetelementK be ?
Get (O, !ToString (𝔽 (k))). - If
SameValueZero (searchElement,elementK) istrue , returntrue . - Setk tok + 1.
- LetelementK be ?
- Return
false .
Theincludes function is intentionally generic; it does not require that its
Theincludes method intentionally differs from the similarindexOf method in two ways. First, it uses the
23.1.3.14 Array.prototype.indexOf (searchElement [ ,fromIndex ] )
indexOf comparessearchElement to the elements of the array, in ascending order, using the
The optional second argumentfromIndex defaults to
When theindexOf method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Iflen is 0, return
-1 𝔽. - Letn be ?
ToIntegerOrInfinity (fromIndex). Assert : IffromIndex isundefined , thenn is 0.- Ifn is +∞, return
-1 𝔽. - Else ifn is -∞, setn to 0.
- Ifn ≥ 0, then
- Letk ben.
- Else,
- Letk belen +n.
- Ifk < 0, setk to 0.
- Repeat, whilek <len,
- LetkPresent be ?
HasProperty (O, !ToString (𝔽 (k))). - IfkPresent is
true , then- LetelementK be ?
Get (O, !ToString (𝔽 (k))). - Letsame be the result of performing
Strict Equality Comparison searchElement ===elementK. - Ifsame is
true , return𝔽 (k).
- LetelementK be ?
- Setk tok + 1.
- LetkPresent be ?
- Return
-1 𝔽.
TheindexOf function is intentionally generic; it does not require that its
23.1.3.15 Array.prototype.join (separator )
The elements of the array are converted to Strings, and these Strings are then concatenated, separated by occurrences of theseparator. If no separator is provided, a single comma is used as the separator.
Thejoin method takes one argument,separator, and performs the following steps:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Ifseparator is
undefined , letsep be the single-element String"," . - Else, letsep be ?
ToString (separator). - LetR be the empty String.
- Letk be 0.
- Repeat, whilek <len,
- Ifk > 0, setR to the
string-concatenation ofR andsep. - Letelement be ?
Get (O, !ToString (𝔽 (k))). - Ifelement is
undefined ornull , letnext be the empty String; otherwise, letnext be ?ToString (element). - SetR to the
string-concatenation ofR andnext. - Setk tok + 1.
- Ifk > 0, setR to the
- ReturnR.
Thejoin function is intentionally generic; it does not require that its
23.1.3.16 Array.prototype.keys ( )
The following steps are taken:
- LetO be ?
ToObject (this value). - Return
CreateArrayIterator (O,key ).
23.1.3.17 Array.prototype.lastIndexOf (searchElement [ ,fromIndex ] )
lastIndexOf comparessearchElement to the elements of the array in descending order using the
The optional second argumentfromIndex defaults to the array's length minus one (i.e. the whole array is searched). If it is greater than or equal to the length of the array, the whole array will be searched. If it is less than
When thelastIndexOf method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Iflen is 0, return
-1 𝔽. - IffromIndex is present, letn be ?
ToIntegerOrInfinity (fromIndex); else letn belen - 1. - Ifn is -∞, return
-1 𝔽. - Ifn ≥ 0, then
- Letk be
min (n,len - 1).
- Letk be
- Else,
- Letk belen +n.
- Repeat, whilek ≥ 0,
- LetkPresent be ?
HasProperty (O, !ToString (𝔽 (k))). - IfkPresent is
true , then- LetelementK be ?
Get (O, !ToString (𝔽 (k))). - Letsame be the result of performing
Strict Equality Comparison searchElement ===elementK. - Ifsame is
true , return𝔽 (k).
- LetelementK be ?
- Setk tok - 1.
- LetkPresent be ?
- Return
-1 𝔽.
ThelastIndexOf function is intentionally generic; it does not require that its
23.1.3.18 Array.prototype.map (callbackfn [ ,thisArg ] )
callbackfn should be a function that accepts three arguments.map callscallbackfn once for each element in the array, in ascending order, and constructs a new Array from the results.callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
map does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed bymap is set before the first call tocallbackfn. Elements which are appended to the array after the call tomap begins will not be visited bycallbackfn. If existing elements of the array are changed, their value as passed tocallbackfn will be the value at the timemap visits them; elements that are deleted after the call tomap begins and before being visited are not visited.
When themap method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - LetA be ?
ArraySpeciesCreate (O,len). - Letk be 0.
- Repeat, whilek <len,
- LetPk be !
ToString (𝔽 (k)). - LetkPresent be ?
HasProperty (O,Pk). - IfkPresent is
true , then- LetkValue be ?
Get (O,Pk). - LetmappedValue be ?
Call (callbackfn,thisArg, «kValue,𝔽 (k),O »). - Perform ?
CreateDataPropertyOrThrow (A,Pk,mappedValue).
- LetkValue be ?
- Setk tok + 1.
- LetPk be !
- ReturnA.
Themap function is intentionally generic; it does not require that its
23.1.3.19 Array.prototype.pop ( )
The last element of the array is removed from the array and returned.
When thepop method is called, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Iflen = 0, then
- Perform ?
Set (O,"length" ,+0 𝔽,true ). - Return
undefined .
- Perform ?
- Else,
Thepop function is intentionally generic; it does not require that its
23.1.3.20 Array.prototype.push ( ...items )
The arguments are appended to the end of the array, in the order in which they appear. The new length of the array is returned as the result of the call.
When thepush method is called with zero or more arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - LetargCount be the number of elements initems.
- Iflen +argCount > 253 - 1, throw a
TypeError exception. - For each elementE ofitems, do
- Perform ?
Set (O,"length" ,𝔽 (len),true ). - Return
𝔽 (len).
Thepush method is
Thepush function is intentionally generic; it does not require that its
23.1.3.21 Array.prototype.reduce (callbackfn [ ,initialValue ] )
callbackfn should be a function that takes four arguments.reduce calls the callback, as a function, once for each element after the first element present in the array, in ascending order.
callbackfn is called with four arguments: thepreviousValue (value from the previous call tocallbackfn), thecurrentValue (value of the current element), thecurrentIndex, and the object being traversed. The first time that callback is called, thepreviousValue andcurrentValue can be one of two values. If aninitialValue was supplied in the call toreduce, thenpreviousValue will be equal toinitialValue andcurrentValue will be equal to the first value in the array. If noinitialValue was supplied, thenpreviousValue will be equal to the first value in the array andcurrentValue will be equal to the second. It is a
reduce does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed byreduce is set before the first call tocallbackfn. Elements that are appended to the array after the call toreduce begins will not be visited bycallbackfn. If existing elements of the array are changed, their value as passed tocallbackfn will be the value at the timereduce visits them; elements that are deleted after the call toreduce begins and before being visited are not visited.
When thereduce method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Iflen = 0 andinitialValue is not present, throw a
TypeError exception. - Letk be 0.
- Letaccumulator be
undefined . - IfinitialValue is present, then
- Setaccumulator toinitialValue.
- Else,
- LetkPresent be
false . - Repeat, whilekPresent is
false andk <len,- LetPk be !
ToString (𝔽 (k)). - SetkPresent to ?
HasProperty (O,Pk). - IfkPresent is
true , then- Setaccumulator to ?
Get (O,Pk).
- Setaccumulator to ?
- Setk tok + 1.
- LetPk be !
- IfkPresent is
false , throw aTypeError exception.
- LetkPresent be
- Repeat, whilek <len,
- Returnaccumulator.
Thereduce function is intentionally generic; it does not require that its
23.1.3.22 Array.prototype.reduceRight (callbackfn [ ,initialValue ] )
callbackfn should be a function that takes four arguments.reduceRight calls the callback, as a function, once for each element after the first element present in the array, in descending order.
callbackfn is called with four arguments: thepreviousValue (value from the previous call tocallbackfn), thecurrentValue (value of the current element), thecurrentIndex, and the object being traversed. The first time the function is called, thepreviousValue andcurrentValue can be one of two values. If aninitialValue was supplied in the call toreduceRight, thenpreviousValue will be equal toinitialValue andcurrentValue will be equal to the last value in the array. If noinitialValue was supplied, thenpreviousValue will be equal to the last value in the array andcurrentValue will be equal to the second-to-last value. It is a
reduceRight does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed byreduceRight is set before the first call tocallbackfn. Elements that are appended to the array after the call toreduceRight begins will not be visited bycallbackfn. If existing elements of the array are changed bycallbackfn, their value as passed tocallbackfn will be the value at the timereduceRight visits them; elements that are deleted after the call toreduceRight begins and before being visited are not visited.
When thereduceRight method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Iflen is 0 andinitialValue is not present, throw a
TypeError exception. - Letk belen - 1.
- Letaccumulator be
undefined . - IfinitialValue is present, then
- Setaccumulator toinitialValue.
- Else,
- LetkPresent be
false . - Repeat, whilekPresent is
false andk ≥ 0,- LetPk be !
ToString (𝔽 (k)). - SetkPresent to ?
HasProperty (O,Pk). - IfkPresent is
true , then- Setaccumulator to ?
Get (O,Pk).
- Setaccumulator to ?
- Setk tok - 1.
- LetPk be !
- IfkPresent is
false , throw aTypeError exception.
- LetkPresent be
- Repeat, whilek ≥ 0,
- Returnaccumulator.
ThereduceRight function is intentionally generic; it does not require that its
23.1.3.23 Array.prototype.reverse ( )
The elements of the array are rearranged so as to reverse their order. The object is returned as the result of the call.
When thereverse method is called, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Letmiddle be
floor (len / 2). - Letlower be 0.
- Repeat, whilelower ≠middle,
- Letupper belen -lower - 1.
- LetupperP be !
ToString (𝔽 (upper)). - LetlowerP be !
ToString (𝔽 (lower)). - LetlowerExists be ?
HasProperty (O,lowerP). - IflowerExists is
true , then- LetlowerValue be ?
Get (O,lowerP).
- LetlowerValue be ?
- LetupperExists be ?
HasProperty (O,upperP). - IfupperExists is
true , then- LetupperValue be ?
Get (O,upperP).
- LetupperValue be ?
- IflowerExists is
true andupperExists istrue , then - Else iflowerExists is
false andupperExists istrue , then- Perform ?
Set (O,lowerP,upperValue,true ). - Perform ?
DeletePropertyOrThrow (O,upperP).
- Perform ?
- Else iflowerExists is
true andupperExists isfalse , then- Perform ?
DeletePropertyOrThrow (O,lowerP). - Perform ?
Set (O,upperP,lowerValue,true ).
- Perform ?
- Else,
Assert :lowerExists andupperExists are bothfalse .- No action is required.
- Setlower tolower + 1.
- ReturnO.
Thereverse function is intentionally generic; it does not require that its
23.1.3.24 Array.prototype.shift ( )
The first element of the array is removed from the array and returned.
When theshift method is called, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - Iflen = 0, then
- Perform ?
Set (O,"length" ,+0 𝔽,true ). - Return
undefined .
- Perform ?
- Letfirst be ?
Get (O,"0" ). - Letk be 1.
- Repeat, whilek <len,
- Letfrom be !
ToString (𝔽 (k)). - Letto be !
ToString (𝔽 (k - 1)). - LetfromPresent be ?
HasProperty (O,from). - IffromPresent is
true , then - Else,
Assert :fromPresent isfalse .- Perform ?
DeletePropertyOrThrow (O,to).
- Setk tok + 1.
- Letfrom be !
- Perform ?
DeletePropertyOrThrow (O, !ToString (𝔽 (len - 1))). - Perform ?
Set (O,"length" ,𝔽 (len - 1),true ). - Returnfirst.
Theshift function is intentionally generic; it does not require that its
23.1.3.25 Array.prototype.slice (start,end )
Theslice method takes two arguments,start andend, and returns an array containing the elements of the array from elementstart up to, but not including, elementend (or through the end of the array ifend is
The following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letk be 0.
- Else ifrelativeStart < 0, letk be
max (len +relativeStart, 0). - Else, letk be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - Letcount be
max (final -k, 0). - LetA be ?
ArraySpeciesCreate (O,count). - Letn be 0.
- Repeat, whilek <final,
- LetPk be !
ToString (𝔽 (k)). - LetkPresent be ?
HasProperty (O,Pk). - IfkPresent is
true , then- LetkValue be ?
Get (O,Pk). - Perform ?
CreateDataPropertyOrThrow (A, !ToString (𝔽 (n)),kValue).
- LetkValue be ?
- Setk tok + 1.
- Setn ton + 1.
- LetPk be !
- Perform ?
Set (A,"length" ,𝔽 (n),true ). - ReturnA.
The explicit setting of the
Theslice function is intentionally generic; it does not require that its
23.1.3.26 Array.prototype.some (callbackfn [ ,thisArg ] )
callbackfn should be a function that accepts three arguments and returns a value that is coercible to a Boolean value.some callscallbackfn once for each element present in the array, in ascending order, until it finds one wherecallbackfn returnssome immediately returnssome returns
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.
some does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
The range of elements processed bysome is set before the first call tocallbackfn. Elements that are appended to the array after the call tosome begins will not be visited bycallbackfn. If existing elements of the array are changed, their value as passed tocallbackfn will be the value at the time thatsome visits them; elements that are deleted after the call tosome begins and before being visited are not visited.some acts like the "exists" quantifier in mathematics. In particular, for an empty array, it returns
When thesome method is called with one or two arguments, the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
false .
Thesome function is intentionally generic; it does not require that its
23.1.3.27 Array.prototype.sort (comparefn )
The elements of this array are sorted. The sort must be stable (that is, elements that compare equal must remain in their original order). Ifcomparefn is not
The following steps are taken:
- Ifcomparefn is not
undefined andIsCallable (comparefn) isfalse , throw aTypeError exception. - Letobj be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (obj). - Letitems be a new empty
List . - Letk be 0.
- Repeat, whilek <len,
- LetPk be !
ToString (𝔽 (k)). - LetkPresent be ?
HasProperty (obj,Pk). - IfkPresent is
true , then- LetkValue be ?
Get (obj,Pk). - AppendkValue toitems.
- LetkValue be ?
- Setk tok + 1.
- LetPk be !
- LetitemCount be the number of elements initems.
- Sortitems using an
implementation-defined sequence of calls toSortCompare . If any such call returns anabrupt completion , stop before performing any further calls toSortCompare or steps in this algorithm and return that completion. - Letj be 0.
- Repeat, whilej <itemCount,
- Repeat, whilej <len,
- Perform ?
DeletePropertyOrThrow (obj, !ToString (𝔽 (j))). - Setj toj + 1.
- Perform ?
- Returnobj.
Thesort order is the ordering, after completion of this function, of thesort function is then determined as follows:
The sort order is
- Ifcomparefn is not
undefined and is not a consistent comparison function for the elements ofitems (see below). - Ifcomparefn is
undefined andSortCompare does not act as a consistent comparison function. - Ifcomparefn is
undefined and all applications ofToString , to any specific value passed as an argument toSortCompare , do not produce the same result.
Unless the sort order is specified above to be
- There must be some mathematical permutation π of the non-negative integers less thanitemCount, such that for every non-negative
integer j less thanitemCount, the elementold[j] is exactly the same asnew[π(j)] . - Then for all non-negative integersj andk, each less thanitemCount, if
SortCompare (old[j], old[k]) < 0SortCompare below), thenπ(j) < π(k) .
Here the notation
A functioncomparefn is a consistent comparison function for a set of valuesS if all of the requirements below are met for all valuesa,b, andc (possibly the same value) in the setS: The notation
- Callingcomparefn(a,b) always returns the same valuev when given a specific pair of valuesa andb as its two arguments. Furthermore,
Type (v) is Number, andv is notNaN . Note that this implies that exactly one ofa <CFb,a =CFb, anda >CFb will be true for a given pair ofa andb. - Callingcomparefn(a,b) does not modifyobj or any object onobj's prototype chain.
- a =CFa (reflexivity)
- Ifa =CFb, thenb =CFa (symmetry)
- Ifa =CFb andb =CFc, thena =CFc (transitivity of =CF)
- Ifa <CFb andb <CFc, thena <CFc (transitivity of <CF)
- Ifa >CFb andb >CFc, thena >CFc (transitivity of >CF)
The above conditions are necessary and sufficient to ensure thatcomparefn divides the setS into equivalence classes and that these equivalence classes are totally ordered.
Thesort function is intentionally generic; it does not require that its
23.1.3.27.1 SortCompare (x,y )
The abstract operation SortCompare takes argumentsx andy. It also has access to thecomparefn argument passed to the current invocation of thesort method. It performs the following steps when called:
- Ifx andy are both
undefined , return+0 𝔽. - Ifx is
undefined , return1 𝔽. - Ify is
undefined , return-1 𝔽. - Ifcomparefn is not
undefined , then - LetxString be ?
ToString (x). - LetyString be ?
ToString (y). - LetxSmaller be the result of performing
Abstract Relational Comparison xString <yString. - IfxSmaller is
true , return-1 𝔽. - LetySmaller be the result of performing
Abstract Relational Comparison yString <xString. - IfySmaller is
true , return1 𝔽. - Return
+0 𝔽.
Because non-existent property values always compare greater than
Method calls performed by the
23.1.3.28 Array.prototype.splice (start,deleteCount, ...items )
When thesplice method is called with two or more argumentsstart,deleteCount and zero or moreitems, thedeleteCount elements of the array starting at
The following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letactualStart be 0.
- Else ifrelativeStart < 0, letactualStart be
max (len +relativeStart, 0). - Else, letactualStart be
min (relativeStart,len). - Ifstart is not present, then
- LetinsertCount be 0.
- LetactualDeleteCount be 0.
- Else ifdeleteCount is not present, then
- LetinsertCount be 0.
- LetactualDeleteCount belen -actualStart.
- Else,
- LetinsertCount be the number of elements initems.
- Letdc be ?
ToIntegerOrInfinity (deleteCount). - LetactualDeleteCount be the result of
clamping dc between 0 andlen -actualStart.
- Iflen +insertCount -actualDeleteCount > 253 - 1, throw a
TypeError exception. - LetA be ?
ArraySpeciesCreate (O,actualDeleteCount). - Letk be 0.
- Repeat, whilek <actualDeleteCount,
- Letfrom be !
ToString (𝔽 (actualStart +k)). - LetfromPresent be ?
HasProperty (O,from). - IffromPresent is
true , then- LetfromValue be ?
Get (O,from). - Perform ?
CreateDataPropertyOrThrow (A, !ToString (𝔽 (k)),fromValue).
- LetfromValue be ?
- Setk tok + 1.
- Letfrom be !
- Perform ?
Set (A,"length" ,𝔽 (actualDeleteCount),true ). - LetitemCount be the number of elements initems.
- IfitemCount <actualDeleteCount, then
- Setk toactualStart.
- Repeat, whilek < (len -actualDeleteCount),
- Letfrom be !
ToString (𝔽 (k +actualDeleteCount)). - Letto be !
ToString (𝔽 (k +itemCount)). - LetfromPresent be ?
HasProperty (O,from). - IffromPresent is
true , then - Else,
Assert :fromPresent isfalse .- Perform ?
DeletePropertyOrThrow (O,to).
- Setk tok + 1.
- Letfrom be !
- Setk tolen.
- Repeat, whilek > (len -actualDeleteCount +itemCount),
- Perform ?
DeletePropertyOrThrow (O, !ToString (𝔽 (k - 1))). - Setk tok - 1.
- Perform ?
- Else ifitemCount >actualDeleteCount, then
- Setk to (len -actualDeleteCount).
- Repeat, whilek >actualStart,
- Letfrom be !
ToString (𝔽 (k +actualDeleteCount - 1)). - Letto be !
ToString (𝔽 (k +itemCount - 1)). - LetfromPresent be ?
HasProperty (O,from). - IffromPresent is
true , then - Else,
Assert :fromPresent isfalse .- Perform ?
DeletePropertyOrThrow (O,to).
- Setk tok - 1.
- Letfrom be !
- Setk toactualStart.
- For each elementE ofitems, do
- Perform ?
Set (O,"length" ,𝔽 (len -actualDeleteCount +itemCount),true ). - ReturnA.
The explicit setting of the
Thesplice function is intentionally generic; it does not require that its
23.1.3.29 Array.prototype.toLocaleString ( [reserved1 [ ,reserved2 ] ] )
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement theArray.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of thetoLocaleString method is used.
The first edition of ECMA-402 did not include a replacement specification for theArray.prototype.toLocaleString method.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
The following steps are taken:
- Letarray be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (array). - Letseparator be the String value for the list-separator String appropriate for the
host environment 's current locale (this is derived in animplementation-defined way). - LetR be the empty String.
- Letk be 0.
- Repeat, whilek <len,
- Ifk > 0, then
- SetR to the
string-concatenation ofR andseparator.
- SetR to the
- LetnextElement be ?
Get (array, !ToString (𝔽 (k))). - IfnextElement is not
undefined ornull , then- LetS be ?
ToString (?Invoke (nextElement,"toLocaleString" )). - SetR to the
string-concatenation ofR andS.
- LetS be ?
- Setk tok + 1.
- Ifk > 0, then
- ReturnR.
The elements of the array are converted to Strings using theirtoLocaleString methods, and these Strings are then concatenated, separated by occurrences of a separator String that has been derived in antoString, except that the result of this function is intended to be locale-specific.
ThetoLocaleString function is intentionally generic; it does not require that its
23.1.3.30 Array.prototype.toString ( )
When thetoString method is called, the following steps are taken:
- Letarray be ?
ToObject (this value). - Letfunc be ?
Get (array,"join" ). - If
IsCallable (func) isfalse , setfunc to the intrinsic function %Object.prototype.toString%. - Return ?
Call (func,array).
ThetoString function is intentionally generic; it does not require that its
23.1.3.31 Array.prototype.unshift ( ...items )
The arguments are prepended to the start of the array, such that their order within the array is the same as the order in which they appear in the argument list.
When theunshift method is called with zero or more argumentsitem1,item2, etc., the following steps are taken:
- LetO be ?
ToObject (this value). - Letlen be ?
LengthOfArrayLike (O). - LetargCount be the number of elements initems.
- IfargCount > 0, then
- Iflen +argCount > 253 - 1, throw a
TypeError exception. - Letk belen.
- Repeat, whilek > 0,
- Letfrom be !
ToString (𝔽 (k - 1)). - Letto be !
ToString (𝔽 (k +argCount - 1)). - LetfromPresent be ?
HasProperty (O,from). - IffromPresent is
true , then - Else,
Assert :fromPresent isfalse .- Perform ?
DeletePropertyOrThrow (O,to).
- Setk tok - 1.
- Letfrom be !
- Letj be
+0 𝔽. - For each elementE ofitems, do
- Iflen +argCount > 253 - 1, throw a
- Perform ?
Set (O,"length" ,𝔽 (len +argCount),true ). - Return
𝔽 (len +argCount).
Theunshift method is
Theunshift function is intentionally generic; it does not require that its
23.1.3.32 Array.prototype.values ( )
The following steps are taken:
- LetO be ?
ToObject (this value). - Return
CreateArrayIterator (O,value ).
23.1.3.33 Array.prototype [ @@iterator ] ( )
The initial value of theArray.prototype.values property.
23.1.3.34 Array.prototype [ @@unscopables ]
The initial value of the
- LetunscopableList be !
OrdinaryObjectCreate (null ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"copyWithin" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"entries" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"fill" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"find" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"findIndex" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"flat" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"flatMap" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"includes" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"keys" ,true ). - Perform !
CreateDataPropertyOrThrow (unscopableList,"values" ,true ). - ReturnunscopableList.
This property has the attributes { [[Writable]]:
The own property names of this object are property names that were not included as standard properties ofArray.prototype prior to the ECMAScript 2015 specification. These names are ignored forwith statement binding purposes in order to preserve the behaviour of existing code that might use one of these names as a binding in an outer scope that is shadowed by awith statement whose binding object is an Array object.
23.1.4 Properties of Array Instances
Array instances are Array exotic objects and have the internal methods specified for such objects. Array instances inherit properties from the
Array instances have a
23.1.4.1 length
The
The
Reducing the value of the
23.1.5 Array Iterator Objects
An Array Iterator is an object, that represents a specific iteration over some specific Array instance object. There is not a named
23.1.5.1 CreateArrayIterator (array,kind )
The abstract operation CreateArrayIterator takes argumentsarray andkind. This operation is used to create iterator objects for Array methods that return such iterators. It performs the following steps when called:
Assert :Type (array) is Object.Assert :kind iskey+value ,key , orvalue .- Letclosure be a new
Abstract Closure with no parameters that captureskind andarray and performs the following steps when called:- Letindex be 0.
- Repeat,
- Ifarray has a [[TypedArrayName]] internal slot, then
- If
IsDetachedBuffer (array.[[ViewedArrayBuffer]]) istrue , throw aTypeError exception. - Letlen bearray.[[ArrayLength]].
- If
- Else,
- Letlen be ?
LengthOfArrayLike (array).
- Letlen be ?
- Ifindex ≥len, return
undefined . - Ifkind is
key , perform ?Yield (𝔽 (index)). - Else,
- Setindex toindex + 1.
- Ifarray has a [[TypedArrayName]] internal slot, then
- Return !
CreateIteratorFromClosure (closure,"%ArrayIteratorPrototype%" ,%ArrayIteratorPrototype% ).
23.1.5.2 The %ArrayIteratorPrototype% Object
The%ArrayIteratorPrototype% object:
- has properties that are inherited by all Array Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - has the following properties:
23.1.5.2.1 %ArrayIteratorPrototype%.next ( )
- Return ?
GeneratorResume (this value,empty ,"%ArrayIteratorPrototype%" ).
23.1.5.2.2 %ArrayIteratorPrototype% [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
23.2 TypedArray Objects
TypedArray objects present an array-like view of an underlying binary data buffer (
| Element Type | Element Size | Conversion Operation | Description | |
|---|---|---|---|---|
| Int8Array %Int8Array% | 1 | 8-bit two's complement signed | ||
| Uint8Array %Uint8Array% | 1 | 8-bit unsigned | ||
| Uint8ClampedArray %Uint8ClampedArray% | 1 | 8-bit unsigned | ||
| Int16Array %Int16Array% | 2 | 16-bit two's complement signed | ||
| Uint16Array %Uint16Array% | 2 | 16-bit unsigned | ||
| Int32Array %Int32Array% | 4 | 32-bit two's complement signed | ||
| Uint32Array %Uint32Array% | 4 | 32-bit unsigned | ||
| BigInt64Array %BigInt64Array% | 8 | 64-bit two's complement signed | ||
| BigUint64Array %BigUint64Array% | 8 | 64-bit unsigned | ||
| Float32Array %Float32Array% | 4 | 32-bit IEEE floating point | ||
| Float64Array %Float64Array% | 8 | 64-bit IEEE floating point |
In the definitions below, references toTypedArray should be replaced with the appropriate
23.2.1 The %TypedArray% Intrinsic Object
The%TypedArray% intrinsic object:
- is a
constructor function object that all of theTypedArrayconstructor objects inherit from. - along with its corresponding prototype object, provides common properties that are inherited by allTypedArray constructors and their instances.
- does not have a global name or appear as a property of the
global object . - acts as the abstract superclass of the variousTypedArray constructors.
- will throw an error when invoked, because it is an abstract class
constructor . TheTypedArray constructors do not perform asupercall to it.
23.2.1.1 %TypedArray% ( )
The
- Throw a
TypeError exception.
The
23.2.2 Properties of the %TypedArray% Intrinsic Object
The
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has a
"name" property whose value is"TypedArray" . - has the following properties:
23.2.2.1 %TypedArray%.from (source [ ,mapfn [ ,thisArg ] ] )
When thefrom method is called with argumentsource, and optional argumentsmapfn andthisArg, the following steps are taken:
- LetC be the
this value. - If
IsConstructor (C) isfalse , throw aTypeError exception. - Ifmapfn is
undefined , letmapping befalse . - Else,
- If
IsCallable (mapfn) isfalse , throw aTypeError exception. - Letmapping be
true .
- If
- LetusingIterator be ?
GetMethod (source,@@iterator ). - IfusingIterator is not
undefined , then- Letvalues be ?
IterableToList (source,usingIterator). - Letlen be the number of elements invalues.
- LettargetObj be ?
TypedArrayCreate (C, «𝔽 (len) »). - Letk be 0.
- Repeat, whilek <len,
Assert :values is now an emptyList .- ReturntargetObj.
- Letvalues be ?
- NOTE:source is not an Iterable so assume it is already an
array-like object . - LetarrayLike be !
ToObject (source). - Letlen be ?
LengthOfArrayLike (arrayLike). - LettargetObj be ?
TypedArrayCreate (C, «𝔽 (len) »). - Letk be 0.
- Repeat, whilek <len,
- ReturntargetObj.
23.2.2.2 %TypedArray%.of ( ...items )
When theof method is called with any number of arguments, the following steps are taken:
- Letlen be the number of elements initems.
- LetC be the
this value. - If
IsConstructor (C) isfalse , throw aTypeError exception. - LetnewObj be ?
TypedArrayCreate (C, «𝔽 (len) »). - Letk be 0.
- Repeat, whilek <len,
- ReturnnewObj.
23.2.2.3 %TypedArray%.prototype
The initial value of.prototype is the
This property has the attributes { [[Writable]]:
23.2.2.4 get %TypedArray% [ @@species ]
[@@species] is an
- Return the
this value.
The value of the
23.2.3 Properties of the %TypedArray% Prototype Object
The%TypedArray% prototype object:
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is%TypedArray.prototype%.
- is an
ordinary object . - does not have a [[ViewedArrayBuffer]] or any other of the internal slots that are specific toTypedArray instance objects.
23.2.3.1 get %TypedArray%.prototype.buffer
.prototype.buffer is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[TypedArrayName]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- Returnbuffer.
23.2.3.2 get %TypedArray%.prototype.byteLength
.prototype.byteLength is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[TypedArrayName]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , return+0 𝔽. - Letsize beO.[[ByteLength]].
- Return
𝔽 (size).
23.2.3.3 get %TypedArray%.prototype.byteOffset
.prototype.byteOffset is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[TypedArrayName]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , return+0 𝔽. - Letoffset beO.[[ByteOffset]].
- Return
𝔽 (offset).
23.2.3.4 %TypedArray%.prototype.constructor
The initial value of.prototype.constructor is the
23.2.3.5 %TypedArray%.prototype.copyWithin (target,start [ ,end ] )
The interpretation and use of the arguments of.prototype.copyWithin are the same as forArray.prototype.copyWithin as defined in
The following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- LetrelativeTarget be ?
ToIntegerOrInfinity (target). - IfrelativeTarget is -∞, letto be 0.
- Else ifrelativeTarget < 0, letto be
max (len +relativeTarget, 0). - Else, letto be
min (relativeTarget,len). - LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letfrom be 0.
- Else ifrelativeStart < 0, letfrom be
max (len +relativeStart, 0). - Else, letfrom be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - Letcount be
min (final -from,len -to). - Ifcount > 0, then
- NOTE: The copying must be performed in a manner that preserves the bit-level encoding of the source data.
- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - LettypedArrayName be the String value ofO.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 fortypedArrayName. - LetbyteOffset beO.[[ByteOffset]].
- LettoByteIndex beto ×elementSize +byteOffset.
- LetfromByteIndex befrom ×elementSize +byteOffset.
- LetcountBytes becount ×elementSize.
- IffromByteIndex <toByteIndex andtoByteIndex <fromByteIndex +countBytes, then
- Letdirection be -1.
- SetfromByteIndex tofromByteIndex +countBytes - 1.
- SettoByteIndex totoByteIndex +countBytes - 1.
- Else,
- Letdirection be 1.
- Repeat, whilecountBytes > 0,
- Letvalue be
GetValueFromBuffer (buffer,fromByteIndex,Uint8 ,true ,Unordered ). - Perform
SetValueInBuffer (buffer,toByteIndex,Uint8 ,value,true ,Unordered ). - SetfromByteIndex tofromByteIndex +direction.
- SettoByteIndex totoByteIndex +direction.
- SetcountBytes tocountBytes - 1.
- Letvalue be
- ReturnO.
23.2.3.6 %TypedArray%.prototype.entries ( )
The following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Return
CreateArrayIterator (O,key+value ).
23.2.3.7 %TypedArray%.prototype.every (callbackfn [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.every are the same as forArray.prototype.every as defined in
When theevery method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
true .
This function is not generic. The
23.2.3.8 %TypedArray%.prototype.fill (value [ ,start [ ,end ] ] )
The interpretation and use of the arguments of.prototype.fill are the same as forArray.prototype.fill as defined in
The following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- IfO.[[ContentType]] is
BigInt , setvalue to ?ToBigInt (value). - Otherwise, setvalue to ?
ToNumber (value). - LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letk be 0.
- Else ifrelativeStart < 0, letk be
max (len +relativeStart, 0). - Else, letk be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - If
IsDetachedBuffer (O.[[ViewedArrayBuffer]]) istrue , throw aTypeError exception. - Repeat, whilek <final,
- ReturnO.
23.2.3.9 %TypedArray%.prototype.filter (callbackfn [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.filter are the same as forArray.prototype.filter as defined in
When thefilter method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letkept be a new empty
List . - Letk be 0.
- Letcaptured be 0.
- Repeat, whilek <len,
- LetA be ?
TypedArraySpeciesCreate (O, «𝔽 (captured) »). - Letn be 0.
- For each elemente ofkept, do
- ReturnA.
This function is not generic. The
23.2.3.10 %TypedArray%.prototype.find (predicate [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.find are the same as forArray.prototype.find as defined in
When thefind method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (predicate) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
undefined .
This function is not generic. The
23.2.3.11 %TypedArray%.prototype.findIndex (predicate [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.findIndex are the same as forArray.prototype.findIndex as defined in
When thefindIndex method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (predicate) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
-1 𝔽.
This function is not generic. The
23.2.3.12 %TypedArray%.prototype.forEach (callbackfn [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.forEach are the same as forArray.prototype.forEach as defined in
When theforEach method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
undefined .
This function is not generic. The
23.2.3.13 %TypedArray%.prototype.includes (searchElement [ ,fromIndex ] )
The interpretation and use of the arguments of.prototype.includes are the same as forArray.prototype.includes as defined in
When theincludes method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- Iflen is 0, return
false . - Letn be ?
ToIntegerOrInfinity (fromIndex). Assert : IffromIndex isundefined , thenn is 0.- Ifn is +∞, return
false . - Else ifn is -∞, setn to 0.
- Ifn ≥ 0, then
- Letk ben.
- Else,
- Letk belen +n.
- Ifk < 0, setk to 0.
- Repeat, whilek <len,
- LetelementK be !
Get (O, !ToString (𝔽 (k))). - If
SameValueZero (searchElement,elementK) istrue , returntrue . - Setk tok + 1.
- LetelementK be !
- Return
false .
This function is not generic. The
23.2.3.14 %TypedArray%.prototype.indexOf (searchElement [ ,fromIndex ] )
The interpretation and use of the arguments of.prototype.indexOf are the same as forArray.prototype.indexOf as defined in
When theindexOf method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- Iflen is 0, return
-1 𝔽. - Letn be ?
ToIntegerOrInfinity (fromIndex). Assert : IffromIndex isundefined , thenn is 0.- Ifn is +∞, return
-1 𝔽. - Else ifn is -∞, setn to 0.
- Ifn ≥ 0, then
- Letk ben.
- Else,
- Letk belen +n.
- Ifk < 0, setk to 0.
- Repeat, whilek <len,
- LetkPresent be !
HasProperty (O, !ToString (𝔽 (k))). - IfkPresent is
true , then- LetelementK be !
Get (O, !ToString (𝔽 (k))). - Letsame be the result of performing
Strict Equality Comparison searchElement ===elementK. - Ifsame is
true , return𝔽 (k).
- LetelementK be !
- Setk tok + 1.
- LetkPresent be !
- Return
-1 𝔽.
This function is not generic. The
23.2.3.15 %TypedArray%.prototype.join (separator )
The interpretation and use of the arguments of.prototype.join are the same as forArray.prototype.join as defined in
When thejoin method is called with one argumentseparator, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- Ifseparator is
undefined , letsep be the single-element String"," . - Else, letsep be ?
ToString (separator). - LetR be the empty String.
- Letk be 0.
- Repeat, whilek <len,
- Ifk > 0, setR to the
string-concatenation ofR andsep. - Letelement be !
Get (O, !ToString (𝔽 (k))). - Ifelement is
undefined , letnext be the empty String; otherwise, letnext be !ToString (element). - SetR to the
string-concatenation ofR andnext. - Setk tok + 1.
- Ifk > 0, setR to the
- ReturnR.
This function is not generic. The
23.2.3.16 %TypedArray%.prototype.keys ( )
The following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Return
CreateArrayIterator (O,key ).
23.2.3.17 %TypedArray%.prototype.lastIndexOf (searchElement [ ,fromIndex ] )
The interpretation and use of the arguments of.prototype.lastIndexOf are the same as forArray.prototype.lastIndexOf as defined in
When thelastIndexOf method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- Iflen is 0, return
-1 𝔽. - IffromIndex is present, letn be ?
ToIntegerOrInfinity (fromIndex); else letn belen - 1. - Ifn is -∞, return
-1 𝔽. - Ifn ≥ 0, then
- Letk be
min (n,len - 1).
- Letk be
- Else,
- Letk belen +n.
- Repeat, whilek ≥ 0,
- LetkPresent be !
HasProperty (O, !ToString (𝔽 (k))). - IfkPresent is
true , then- LetelementK be !
Get (O, !ToString (𝔽 (k))). - Letsame be the result of performing
Strict Equality Comparison searchElement ===elementK. - Ifsame is
true , return𝔽 (k).
- LetelementK be !
- Setk tok - 1.
- LetkPresent be !
- Return
-1 𝔽.
This function is not generic. The
23.2.3.18 get %TypedArray%.prototype.length
.prototype.length is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[TypedArrayName]]). Assert :O has [[ViewedArrayBuffer]] and [[ArrayLength]] internal slots.- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , return+0 𝔽. - Letlength beO.[[ArrayLength]].
- Return
𝔽 (length).
This function is not generic. The
23.2.3.19 %TypedArray%.prototype.map (callbackfn [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.map are the same as forArray.prototype.map as defined in
When themap method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - LetA be ?
TypedArraySpeciesCreate (O, «𝔽 (len) »). - Letk be 0.
- Repeat, whilek <len,
- ReturnA.
This function is not generic. The
23.2.3.20 %TypedArray%.prototype.reduce (callbackfn [ ,initialValue ] )
The interpretation and use of the arguments of.prototype.reduce are the same as forArray.prototype.reduce as defined in
When thereduce method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Iflen = 0 andinitialValue is not present, throw a
TypeError exception. - Letk be 0.
- Letaccumulator be
undefined . - IfinitialValue is present, then
- Setaccumulator toinitialValue.
- Else,
- Repeat, whilek <len,
- Returnaccumulator.
This function is not generic. The
23.2.3.21 %TypedArray%.prototype.reduceRight (callbackfn [ ,initialValue ] )
The interpretation and use of the arguments of.prototype.reduceRight are the same as forArray.prototype.reduceRight as defined in
When thereduceRight method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Iflen is 0 andinitialValue is not present, throw a
TypeError exception. - Letk belen - 1.
- Letaccumulator be
undefined . - IfinitialValue is present, then
- Setaccumulator toinitialValue.
- Else,
- Repeat, whilek ≥ 0,
- Returnaccumulator.
This function is not generic. The
23.2.3.22 %TypedArray%.prototype.reverse ( )
The interpretation and use of the arguments of.prototype.reverse are the same as forArray.prototype.reverse as defined in
When thereverse method is called, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- Letmiddle be
floor (len / 2). - Letlower be 0.
- Repeat, whilelower ≠middle,
- ReturnO.
This function is not generic. The
23.2.3.23 %TypedArray%.prototype.set (source [ ,offset ] )
.prototype.set is a function whose behaviour differs based upon the type of its first argument.
This function is not generic. The
Sets multiple values in thisTypedArray, reading the values fromsource. The optionaloffset value indicates the first element index in thisTypedArray where values are written. If omitted, it is assumed to be 0.
- Lettarget be the
this value. - Perform ?
RequireInternalSlot (target, [[TypedArrayName]]). Assert :target has a [[ViewedArrayBuffer]] internal slot.- LettargetOffset be ?
ToIntegerOrInfinity (offset). - IftargetOffset < 0, throw a
RangeError exception. - Ifsource is an Object that has a [[TypedArrayName]] internal slot, then
- Perform ?
SetTypedArrayFromTypedArray (target,targetOffset,source).
- Perform ?
- Else,
- Perform ?
SetTypedArrayFromArrayLike (target,targetOffset,source).
- Perform ?
- Return
undefined .
23.2.3.23.1 SetTypedArrayFromTypedArray (target,targetOffset,source )
The abstract operation SetTypedArrayFromTypedArray takes argumentstarget (a TypedArray object),targetOffset (a non-negative
Assert :source is an Object that has a [[TypedArrayName]] internal slot.- LettargetBuffer betarget.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (targetBuffer) istrue , throw aTypeError exception. - LettargetLength betarget.[[ArrayLength]].
- LetsrcBuffer besource.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (srcBuffer) istrue , throw aTypeError exception. - LettargetName be the String value oftarget.[[TypedArrayName]].
- LettargetType be the Element Type value in
Table 60 fortargetName. - LettargetElementSize be the Element Size value specified in
Table 60 fortargetName. - LettargetByteOffset betarget.[[ByteOffset]].
- LetsrcName be the String value ofsource.[[TypedArrayName]].
- LetsrcType be the Element Type value in
Table 60 forsrcName. - LetsrcElementSize be the Element Size value specified in
Table 60 forsrcName. - LetsrcLength besource.[[ArrayLength]].
- LetsrcByteOffset besource.[[ByteOffset]].
- IftargetOffset is +∞, throw a
RangeError exception. - IfsrcLength +targetOffset >targetLength, throw a
RangeError exception. - Iftarget.[[ContentType]] ≠source.[[ContentType]], throw a
TypeError exception. - If both
IsSharedArrayBuffer (srcBuffer) andIsSharedArrayBuffer (targetBuffer) aretrue , then- IfsrcBuffer.[[ArrayBufferData]] andtargetBuffer.[[ArrayBufferData]] are the same
Shared Data Block values, letsame betrue ; else letsame befalse .
- IfsrcBuffer.[[ArrayBufferData]] andtargetBuffer.[[ArrayBufferData]] are the same
- Else, letsame be
SameValue (srcBuffer,targetBuffer). - Ifsame is
true , then- LetsrcByteLength besource.[[ByteLength]].
- SetsrcBuffer to ?
CloneArrayBuffer (srcBuffer,srcByteOffset,srcByteLength,%ArrayBuffer% ). - NOTE:
%ArrayBuffer% is used to clonesrcBuffer because is it known to not have any observable side-effects. - LetsrcByteIndex be 0.
- Else, letsrcByteIndex besrcByteOffset.
- LettargetByteIndex betargetOffset ×targetElementSize +targetByteOffset.
- Letlimit betargetByteIndex +targetElementSize ×srcLength.
- IfsrcType is the same astargetType, then
- NOTE: IfsrcType andtargetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
- Repeat, whiletargetByteIndex <limit,
- Letvalue be
GetValueFromBuffer (srcBuffer,srcByteIndex,Uint8 ,true ,Unordered ). - Perform
SetValueInBuffer (targetBuffer,targetByteIndex,Uint8 ,value,true ,Unordered ). - SetsrcByteIndex tosrcByteIndex + 1.
- SettargetByteIndex totargetByteIndex + 1.
- Letvalue be
- Else,
- Repeat, whiletargetByteIndex <limit,
- Letvalue be
GetValueFromBuffer (srcBuffer,srcByteIndex,srcType,true ,Unordered ). - Perform
SetValueInBuffer (targetBuffer,targetByteIndex,targetType,value,true ,Unordered ). - SetsrcByteIndex tosrcByteIndex +srcElementSize.
- SettargetByteIndex totargetByteIndex +targetElementSize.
- Letvalue be
- Repeat, whiletargetByteIndex <limit,
23.2.3.23.2 SetTypedArrayFromArrayLike (target,targetOffset,source )
The abstract operation SetTypedArrayFromArrayLike takes argumentstarget (a TypedArray object),targetOffset (a non-negative
Assert :source is anyECMAScript language value other than an Object with a [[TypedArrayName]] internal slot.- LettargetBuffer betarget.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (targetBuffer) istrue , throw aTypeError exception. - LettargetLength betarget.[[ArrayLength]].
- LettargetName be the String value oftarget.[[TypedArrayName]].
- LettargetElementSize be the Element Size value specified in
Table 60 fortargetName. - LettargetType be the Element Type value in
Table 60 fortargetName. - LettargetByteOffset betarget.[[ByteOffset]].
- Letsrc be ?
ToObject (source). - LetsrcLength be ?
LengthOfArrayLike (src). - IftargetOffset is +∞, throw a
RangeError exception. - IfsrcLength +targetOffset >targetLength, throw a
RangeError exception. - LettargetByteIndex betargetOffset ×targetElementSize +targetByteOffset.
- Letk be 0.
- Letlimit betargetByteIndex +targetElementSize ×srcLength.
- Repeat, whiletargetByteIndex <limit,
- LetPk be !
ToString (𝔽 (k)). - Letvalue be ?
Get (src,Pk). - Iftarget.[[ContentType]] is
BigInt , setvalue to ?ToBigInt (value). - Otherwise, setvalue to ?
ToNumber (value). - If
IsDetachedBuffer (targetBuffer) istrue , throw aTypeError exception. - Perform
SetValueInBuffer (targetBuffer,targetByteIndex,targetType,value,true ,Unordered ). - Setk tok + 1.
- SettargetByteIndex totargetByteIndex +targetElementSize.
- LetPk be !
23.2.3.24 %TypedArray%.prototype.slice (start,end )
The interpretation and use of the arguments of.prototype.slice are the same as forArray.prototype.slice as defined in
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letk be 0.
- Else ifrelativeStart < 0, letk be
max (len +relativeStart, 0). - Else, letk be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - Letcount be
max (final -k, 0). - LetA be ?
TypedArraySpeciesCreate (O, «𝔽 (count) »). - Ifcount > 0, then
- If
IsDetachedBuffer (O.[[ViewedArrayBuffer]]) istrue , throw aTypeError exception. - LetsrcName be the String value ofO.[[TypedArrayName]].
- LetsrcType be the Element Type value in
Table 60 forsrcName. - LettargetName be the String value ofA.[[TypedArrayName]].
- LettargetType be the Element Type value in
Table 60 fortargetName. - IfsrcType is different fromtargetType, then
- Else,
- LetsrcBuffer beO.[[ViewedArrayBuffer]].
- LettargetBuffer beA.[[ViewedArrayBuffer]].
- LetelementSize be the Element Size value specified in
Table 60 for Element TypesrcType. - NOTE: IfsrcType andtargetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
- LetsrcByteOffset beO.[[ByteOffset]].
- LettargetByteIndex beA.[[ByteOffset]].
- LetsrcByteIndex be (k ×elementSize) +srcByteOffset.
- Letlimit betargetByteIndex +count ×elementSize.
- Repeat, whiletargetByteIndex <limit,
- Letvalue be
GetValueFromBuffer (srcBuffer,srcByteIndex,Uint8 ,true ,Unordered ). - Perform
SetValueInBuffer (targetBuffer,targetByteIndex,Uint8 ,value,true ,Unordered ). - SetsrcByteIndex tosrcByteIndex + 1.
- SettargetByteIndex totargetByteIndex + 1.
- Letvalue be
- If
- ReturnA.
This function is not generic. The
23.2.3.25 %TypedArray%.prototype.some (callbackfn [ ,thisArg ] )
The interpretation and use of the arguments of.prototype.some are the same as forArray.prototype.some as defined in
When thesome method is called with one or two arguments, the following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Letlen beO.[[ArrayLength]].
- If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letk be 0.
- Repeat, whilek <len,
- Return
false .
This function is not generic. The
23.2.3.26 %TypedArray%.prototype.sort (comparefn )
.prototype.sort is a distinct function that, except as described below, implements the same requirements as those ofArray.prototype.sort as defined in.prototype.sort specification may be optimized with the knowledge that the
This function is not generic. The
Upon entry, the following steps are performed to initialize evaluation of thesort function. These steps are used instead of steps
- Ifcomparefn is not
undefined andIsCallable (comparefn) isfalse , throw aTypeError exception. - Letobj be the
this value. - Letbuffer be ?
ValidateTypedArray (obj). - Letlen beobj.[[ArrayLength]].
The following version of.prototype.sort. It performs a numeric comparison rather than the string comparison used in
The abstract operation TypedArraySortCompare takes argumentsx andy. It also has access to thecomparefn andbuffer values of the current invocation of thesort method. It performs the following steps when called:
Assert : BothType (x) andType (y) are Number or both are BigInt.- Ifcomparefn is not
undefined , then- Letv be ?
ToNumber (?Call (comparefn,undefined , «x,y »)). - If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - Ifv is
NaN , return+0 𝔽. - Returnv.
- Letv be ?
- Ifx andy are both
NaN , return+0 𝔽. - Ifx is
NaN , return1 𝔽. - Ify is
NaN , return-1 𝔽. - Ifx <y, return
-1 𝔽. - Ifx >y, return
1 𝔽. - Ifx is
-0 𝔽 andy is+0 𝔽, return-1 𝔽. - Ifx is
+0 𝔽 andy is-0 𝔽, return1 𝔽. - Return
+0 𝔽.
Because
23.2.3.27 %TypedArray%.prototype.subarray (begin,end )
Returns a newTypedArray object whose element type is the same as thisTypedArray and whose ArrayBuffer is the same as the ArrayBuffer of thisTypedArray, referencing the elements atbegin, inclusive, up toend, exclusive. If eitherbegin orend is negative, it refers to an index from the end of the array, as opposed to from the beginning.
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[TypedArrayName]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- LetsrcLength beO.[[ArrayLength]].
- LetrelativeBegin be ?
ToIntegerOrInfinity (begin). - IfrelativeBegin is -∞, letbeginIndex be 0.
- Else ifrelativeBegin < 0, letbeginIndex be
max (srcLength +relativeBegin, 0). - Else, letbeginIndex be
min (relativeBegin,srcLength). - Ifend is
undefined , letrelativeEnd besrcLength; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letendIndex be 0.
- Else ifrelativeEnd < 0, letendIndex be
max (srcLength +relativeEnd, 0). - Else, letendIndex be
min (relativeEnd,srcLength). - LetnewLength be
max (endIndex -beginIndex, 0). - LetconstructorName be the String value ofO.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 forconstructorName. - LetsrcByteOffset beO.[[ByteOffset]].
- LetbeginByteOffset besrcByteOffset +beginIndex ×elementSize.
- LetargumentsList be «buffer,
𝔽 (beginByteOffset),𝔽 (newLength) ». - Return ?
TypedArraySpeciesCreate (O,argumentsList).
This function is not generic. The
23.2.3.28 %TypedArray%.prototype.toLocaleString ( [reserved1 [ ,reserved2 ] ] )
.prototype.toLocaleString is a distinct function that implements the same algorithm asArray.prototype.toLocaleString as defined in
This function is not generic.
If the ECMAScript implementation includes the ECMA-402 Internationalization API this function is based upon the algorithm forArray.prototype.toLocaleString that is in the ECMA-402 specification.
23.2.3.29 %TypedArray%.prototype.toString ( )
The initial value of the.prototype.toStringArray.prototype.toString method defined in
23.2.3.30 %TypedArray%.prototype.values ( )
The following steps are taken:
- LetO be the
this value. - Perform ?
ValidateTypedArray (O). - Return
CreateArrayIterator (O,value ).
23.2.3.31 %TypedArray%.prototype [ @@iterator ] ( )
The initial value of the.prototype.values property.
23.2.3.32 get %TypedArray%.prototype [ @@toStringTag ]
.prototype[@@toStringTag] is an
This property has the attributes { [[Enumerable]]:
The initial value of the
23.2.4 Abstract Operations for TypedArray Objects
23.2.4.1 TypedArraySpeciesCreate (exemplar,argumentList )
The abstract operation TypedArraySpeciesCreate takes argumentsexemplar andargumentList. It is used to specify the creation of a new TypedArray object using a
Assert :exemplar is an Object that has [[TypedArrayName]] and [[ContentType]] internal slots.- LetdefaultConstructor be the intrinsic object listed in column one of
Table 60 forexemplar.[[TypedArrayName]]. - Letconstructor be ?
SpeciesConstructor (exemplar,defaultConstructor). - Letresult be ?
TypedArrayCreate (constructor,argumentList). Assert :result has [[TypedArrayName]] and [[ContentType]] internal slots.- Ifresult.[[ContentType]] ≠exemplar.[[ContentType]], throw a
TypeError exception. - Returnresult.
23.2.4.2 TypedArrayCreate (constructor,argumentList )
The abstract operation TypedArrayCreate takes argumentsconstructor andargumentList. It is used to specify the creation of a new TypedArray object using a
- LetnewTypedArray be ?
Construct (constructor,argumentList). - Perform ?
ValidateTypedArray (newTypedArray). - IfargumentList is a
List of a single Number, then- IfnewTypedArray.[[ArrayLength]] <
ℝ (argumentList[0]), throw aTypeError exception.
- IfnewTypedArray.[[ArrayLength]] <
- ReturnnewTypedArray.
23.2.4.3 ValidateTypedArray (O )
The abstract operation ValidateTypedArray takes argumentO. It performs the following steps when called:
- Perform ?
RequireInternalSlot (O, [[TypedArrayName]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - Returnbuffer.
23.2.5 TheTypedArray Constructors
EachTypedArray
- is an intrinsic object that has the structure described below, differing only in the name used as the
constructor name instead ofTypedArray, inTable 60 . - is a function whose behaviour differs based upon the number and types of its arguments. The actual behaviour of a call ofTypedArray depends upon the number and kind of arguments that are passed to it.
- is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specifiedTypedArray behaviour must include asupercall to theTypedArrayconstructor to create and initialize the subclass instance with the internal state necessary to support the%TypedArray% .prototypebuilt-in methods. - has a
"length" property whose value is3 𝔽.
23.2.5.1TypedArray ( ...args )
EachTypedArray
- If NewTarget is
undefined , throw aTypeError exception. - LetconstructorName be the String value of the
Constructor Name value specified inTable 60 for thisTypedArrayconstructor . - Letproto be
"%TypedArray.prototype%". - LetnumberOfArgs be the number of elements inargs.
- IfnumberOfArgs = 0, then
- Return ?
AllocateTypedArray (constructorName, NewTarget,proto, 0).
- Return ?
- Else,
- LetfirstArgument beargs[0].
- If
Type (firstArgument) is Object, then- LetO be ?
AllocateTypedArray (constructorName, NewTarget,proto). - IffirstArgument has a [[TypedArrayName]] internal slot, then
- Perform ?
InitializeTypedArrayFromTypedArray (O,firstArgument).
- Perform ?
- Else iffirstArgument has an [[ArrayBufferData]] internal slot, then
- IfnumberOfArgs > 1, letbyteOffset beargs[1]; else letbyteOffset be
undefined . - IfnumberOfArgs > 2, letlength beargs[2]; else letlength be
undefined . - Perform ?
InitializeTypedArrayFromArrayBuffer (O,firstArgument,byteOffset,length).
- IfnumberOfArgs > 1, letbyteOffset beargs[1]; else letbyteOffset be
- Else,
Assert :Type (firstArgument) is Object andfirstArgument does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] internal slot.- LetusingIterator be ?
GetMethod (firstArgument,@@iterator ). - IfusingIterator is not
undefined , then- Letvalues be ?
IterableToList (firstArgument,usingIterator). - Perform ?
InitializeTypedArrayFromList (O,values).
- Letvalues be ?
- Else,
- NOTE:firstArgument is not an Iterable so assume it is already an
array-like object . - Perform ?
InitializeTypedArrayFromArrayLike (O,firstArgument).
- NOTE:firstArgument is not an Iterable so assume it is already an
- ReturnO.
- LetO be ?
- Else,
Assert :firstArgument is not an Object.- LetelementLength be ?
ToIndex (firstArgument). - Return ?
AllocateTypedArray (constructorName, NewTarget,proto,elementLength).
23.2.5.1.1 AllocateTypedArray (constructorName,newTarget,defaultProto [ ,length ] )
The abstract operation AllocateTypedArray takes argumentsconstructorName (a String which is the name of a TypedArray
- Letproto be ?
GetPrototypeFromConstructor (newTarget,defaultProto). - Letobj be !
IntegerIndexedObjectCreate (proto). Assert :obj.[[ViewedArrayBuffer]] isundefined .- Setobj.[[TypedArrayName]] toconstructorName.
- IfconstructorName is
"BigInt64Array" or"BigUint64Array" , setobj.[[ContentType]] toBigInt . - Otherwise, setobj.[[ContentType]] to
Number . - Iflength is not present, then
- Setobj.[[ByteLength]] to 0.
- Setobj.[[ByteOffset]] to 0.
- Setobj.[[ArrayLength]] to 0.
- Else,
- Perform ?
AllocateTypedArrayBuffer (obj,length).
- Perform ?
- Returnobj.
23.2.5.1.2 InitializeTypedArrayFromTypedArray (O,srcArray )
The abstract operation InitializeTypedArrayFromTypedArray takes argumentsO (a TypedArray object) andsrcArray (a TypedArray object). It performs the following steps when called:
Assert :O is an Object that has a [[TypedArrayName]] internal slot.Assert :srcArray is an Object that has a [[TypedArrayName]] internal slot.- LetsrcData besrcArray.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (srcData) istrue , throw aTypeError exception. - LetconstructorName be the String value ofO.[[TypedArrayName]].
- LetelementType be the Element Type value in
Table 60 forconstructorName. - LetelementLength besrcArray.[[ArrayLength]].
- LetsrcName be the String value ofsrcArray.[[TypedArrayName]].
- LetsrcType be the Element Type value in
Table 60 forsrcName. - LetsrcElementSize be the Element Size value specified in
Table 60 forsrcName. - LetsrcByteOffset besrcArray.[[ByteOffset]].
- LetelementSize be the Element Size value specified in
Table 60 forconstructorName. - LetbyteLength beelementSize ×elementLength.
- If
IsSharedArrayBuffer (srcData) isfalse , then- LetbufferConstructor be ?
SpeciesConstructor (srcData,%ArrayBuffer% ).
- LetbufferConstructor be ?
- Else,
- LetbufferConstructor be
%ArrayBuffer% .
- LetbufferConstructor be
- IfelementType is the same assrcType, then
- Letdata be ?
CloneArrayBuffer (srcData,srcByteOffset,byteLength,bufferConstructor).
- Letdata be ?
- Else,
- Letdata be ?
AllocateArrayBuffer (bufferConstructor,byteLength). - If
IsDetachedBuffer (srcData) istrue , throw aTypeError exception. - IfsrcArray.[[ContentType]] ≠O.[[ContentType]], throw a
TypeError exception. - LetsrcByteIndex besrcByteOffset.
- LettargetByteIndex be 0.
- Letcount beelementLength.
- Repeat, whilecount > 0,
- Letvalue be
GetValueFromBuffer (srcData,srcByteIndex,srcType,true ,Unordered ). - Perform
SetValueInBuffer (data,targetByteIndex,elementType,value,true ,Unordered ). - SetsrcByteIndex tosrcByteIndex +srcElementSize.
- SettargetByteIndex totargetByteIndex +elementSize.
- Setcount tocount - 1.
- Letvalue be
- Letdata be ?
- SetO.[[ViewedArrayBuffer]] todata.
- SetO.[[ByteLength]] tobyteLength.
- SetO.[[ByteOffset]] to 0.
- SetO.[[ArrayLength]] toelementLength.
23.2.5.1.3 InitializeTypedArrayFromArrayBuffer (O,buffer,byteOffset,length )
The abstract operation InitializeTypedArrayFromArrayBuffer takes argumentsO (a TypedArray object),buffer (an ArrayBuffer object),byteOffset (an
Assert :O is an Object that has a [[TypedArrayName]] internal slot.Assert :buffer is an Object that has an [[ArrayBufferData]] internal slot.- LetconstructorName be the String value ofO.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 forconstructorName. - Letoffset be ?
ToIndex (byteOffset). - Ifoffset
modulo elementSize ≠ 0, throw aRangeError exception. - Iflength is not
undefined , then- LetnewLength be ?
ToIndex (length).
- LetnewLength be ?
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - LetbufferByteLength bebuffer.[[ArrayBufferByteLength]].
- Iflength is
undefined , then- IfbufferByteLength
modulo elementSize ≠ 0, throw aRangeError exception. - LetnewByteLength bebufferByteLength -offset.
- IfnewByteLength < 0, throw a
RangeError exception.
- IfbufferByteLength
- Else,
- LetnewByteLength benewLength ×elementSize.
- Ifoffset +newByteLength >bufferByteLength, throw a
RangeError exception.
- SetO.[[ViewedArrayBuffer]] tobuffer.
- SetO.[[ByteLength]] tonewByteLength.
- SetO.[[ByteOffset]] tooffset.
- SetO.[[ArrayLength]] tonewByteLength /elementSize.
23.2.5.1.4 InitializeTypedArrayFromList (O,values )
The abstract operation InitializeTypedArrayFromList takes argumentsO (a TypedArray object) andvalues (a
Assert :O is an Object that has a [[TypedArrayName]] internal slot.- Letlen be the number of elements invalues.
- Perform ?
AllocateTypedArrayBuffer (O,len). - Letk be 0.
- Repeat, whilek <len,
Assert :values is now an emptyList .
23.2.5.1.5 InitializeTypedArrayFromArrayLike (O,arrayLike )
The abstract operation InitializeTypedArrayFromArrayLike takes argumentsO (a TypedArray object) andarrayLike (an Object that is neither a TypedArray object nor an ArrayBuffer object). It performs the following steps when called:
Assert :O is an Object that has a [[TypedArrayName]] internal slot.- Letlen be ?
LengthOfArrayLike (arrayLike). - Perform ?
AllocateTypedArrayBuffer (O,len). - Letk be 0.
- Repeat, whilek <len,
23.2.5.1.6 AllocateTypedArrayBuffer (O,length )
The abstract operation AllocateTypedArrayBuffer takes argumentsO (a TypedArray object) andlength (a non-negative
Assert :O is an Object that has a [[ViewedArrayBuffer]] internal slot.Assert :O.[[ViewedArrayBuffer]] isundefined .- LetconstructorName be the String value ofO.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 forconstructorName. - LetbyteLength beelementSize ×length.
- Letdata be ?
AllocateArrayBuffer (%ArrayBuffer% ,byteLength). - SetO.[[ViewedArrayBuffer]] todata.
- SetO.[[ByteLength]] tobyteLength.
- SetO.[[ByteOffset]] to 0.
- SetO.[[ArrayLength]] tolength.
- ReturnO.
23.2.6 Properties of theTypedArray Constructors
EachTypedArray
- has a [[Prototype]] internal slot whose value is
%TypedArray% . - has a
"name" property whose value is the String value of theconstructor name specified for it inTable 60 . - has the following properties:
23.2.6.1TypedArray.BYTES_PER_ELEMENT
The value ofTypedArray.BYTES_PER_ELEMENT is the Element Size value specified in
This property has the attributes { [[Writable]]:
23.2.6.2TypedArray.prototype
The initial value ofTypedArray.prototype is the correspondingTypedArray prototype intrinsic object (
This property has the attributes { [[Writable]]:
23.2.7 Properties of theTypedArray Prototype Objects
EachTypedArray prototype object:
- has a [[Prototype]] internal slot whose value is
%TypedArray.prototype% . - is an
ordinary object . - does not have a [[ViewedArrayBuffer]] or any other of the internal slots that are specific toTypedArray instance objects.
23.2.7.1TypedArray.prototype.BYTES_PER_ELEMENT
The value ofTypedArray.prototype.BYTES_PER_ELEMENT is the Element Size value specified in
This property has the attributes { [[Writable]]:
23.2.7.2TypedArray.prototype.constructor
The initial value of aTypedArray.prototype.constructor is the corresponding
23.2.8 Properties ofTypedArray Instances
TypedArray instances are
24 Keyed Collections
24.1 Map Objects
Map objects are collections of key/value pairs where both the keys and values may be arbitrary ECMAScript language values. A distinct key value may only occur in one key/value pair within the Map's collection. Distinct key values are discriminated using the
Map object must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structures used in this Map objects specification is only intended to describe the required observable semantics of Map objects. It is not intended to be a viable implementation model.
24.1.1 The Map Constructor
The Map
- is%Map%.
- is the initial value of the
"Map" property of theglobal object . - creates and initializes a new Map object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Map behaviour must include asupercall to the Mapconstructor to create and initialize the subclass instance with the internal state necessary to support theMap.prototypebuilt-in methods.
24.1.1.1 Map ( [iterable ] )
When theMap function is called with optional argumentiterable, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - Letmap be ?
OrdinaryCreateFromConstructor (NewTarget,"%Map.prototype%" , « [[MapData]] »). - Setmap.[[MapData]] to a new empty
List . - Ifiterable is either
undefined ornull , returnmap. - Letadder be ?
Get (map,"set" ). - Return ?
AddEntriesFromIterable (map,iterable,adder).
If the parameteriterable is present, it is expected to be an object that implements an
24.1.1.2 AddEntriesFromIterable (target,iterable,adder )
The abstract operation AddEntriesFromIterable takes argumentstarget,iterable, andadder (a
- If
IsCallable (adder) isfalse , throw aTypeError exception. Assert :iterable is present, and is neitherundefined nornull .- LetiteratorRecord be ?
GetIterator (iterable). - Repeat,
- Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , returntarget. - LetnextItem be ?
IteratorValue (next). - If
Type (nextItem) is not Object, then- Leterror be
ThrowCompletion (a newly createdTypeError object). - Return ?
IteratorClose (iteratorRecord,error).
- Leterror be
- Letk be
Get (nextItem,"0" ). - Ifk is an
abrupt completion , return ?IteratorClose (iteratorRecord,k). - Letv be
Get (nextItem,"1" ). - Ifv is an
abrupt completion , return ?IteratorClose (iteratorRecord,v). - Letstatus be
Call (adder,target, «k.[[Value]],v.[[Value]] »). - Ifstatus is an
abrupt completion , return ?IteratorClose (iteratorRecord,status).
- Letnext be ?
The parameteriterable is expected to be an object that implements an
24.1.2 Properties of the Map Constructor
The Map
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
24.1.2.1 Map.prototype
The initial value ofMap.prototype is the
This property has the attributes { [[Writable]]:
24.1.2.2 get Map [ @@species ]
Map[@@species] is an
- Return the
this value.
The value of the
Methods that create derived collection objects should call
24.1.3 Properties of the Map Prototype Object
TheMap prototype object:
- is%Map.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[MapData]] internal slot.
24.1.3.1 Map.prototype.clear ( )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - Letentries be the
List that isM.[[MapData]]. - For each
Record { [[Key]], [[Value]] }p ofentries, do- Setp.[[Key]] to
empty . - Setp.[[Value]] to
empty .
- Setp.[[Key]] to
- Return
undefined .
24.1.3.2 Map.prototype.constructor
The initial value ofMap.prototype.constructor is
24.1.3.3 Map.prototype.delete (key )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - Letentries be the
List that isM.[[MapData]]. - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValueZero (p.[[Key]],key) istrue , then- Setp.[[Key]] to
empty . - Setp.[[Value]] to
empty . - Return
true .
- Setp.[[Key]] to
- Ifp.[[Key]] is not
- Return
false .
The value
24.1.3.4 Map.prototype.entries ( )
The following steps are taken:
- LetM be the
this value. - Return ?
CreateMapIterator (M,key+value ).
24.1.3.5 Map.prototype.forEach (callbackfn [ ,thisArg ] )
When theforEach method is called with one or two arguments, the following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letentries be the
List that isM.[[MapData]]. - For each
Record { [[Key]], [[Value]] }e ofentries, do- Ife.[[Key]] is not
empty , then- Perform ?
Call (callbackfn,thisArg, «e.[[Value]],e.[[Key]],M »).
- Perform ?
- Ife.[[Key]] is not
- Return
undefined .
callbackfn should be a function that accepts three arguments.forEach callscallbackfn once for each key/value pair present in the map object, in key insertion order.callbackfn is called only for keys of the map which actually exist; it is not called for keys that have been deleted from the map.
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the value of the item, the key of the item, and the Map object being traversed.
forEach does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn. Each entry of a map's [[MapData]] is only visited once. New keys added after the call toforEach begins are visited. A key will be revisited if it is deleted after it has been visited and then re-added before theforEach call completes. Keys that are deleted after the call toforEach begins and before being visited are not visited unless the key is added again before theforEach call completes.
24.1.3.6 Map.prototype.get (key )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - Letentries be the
List that isM.[[MapData]]. - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValueZero (p.[[Key]],key) istrue , returnp.[[Value]].
- Ifp.[[Key]] is not
- Return
undefined .
24.1.3.7 Map.prototype.has (key )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - Letentries be the
List that isM.[[MapData]]. - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValueZero (p.[[Key]],key) istrue , returntrue .
- Ifp.[[Key]] is not
- Return
false .
24.1.3.8 Map.prototype.keys ( )
The following steps are taken:
- LetM be the
this value. - Return ?
CreateMapIterator (M,key ).
24.1.3.9 Map.prototype.set (key,value )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - Letentries be the
List that isM.[[MapData]]. - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValueZero (p.[[Key]],key) istrue , then- Setp.[[Value]] tovalue.
- ReturnM.
- Ifp.[[Key]] is not
- Ifkey is
-0 𝔽, setkey to+0 𝔽. - Letp be the
Record { [[Key]]:key, [[Value]]:value }. - Appendp as the last element ofentries.
- ReturnM.
24.1.3.10 get Map.prototype.size
Map.prototype.size is an
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[MapData]]). - Letentries be the
List that isM.[[MapData]]. - Letcount be 0.
- For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty , setcount tocount + 1.
- Ifp.[[Key]] is not
- Return
𝔽 (count).
24.1.3.11 Map.prototype.values ( )
The following steps are taken:
- LetM be the
this value. - Return ?
CreateMapIterator (M,value ).
24.1.3.12 Map.prototype [ @@iterator ] ( )
The initial value of the
24.1.3.13 Map.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
24.1.4 Properties of Map Instances
Map instances are ordinary objects that inherit properties from the Map prototype. Map instances also have a [[MapData]] internal slot.
24.1.5 Map Iterator Objects
A Map Iterator is an object, that represents a specific iteration over some specific Map instance object. There is not a named
24.1.5.1 CreateMapIterator (map,kind )
The abstract operation CreateMapIterator takes argumentsmap andkind. This operation is used to create iterator objects for Map methods that return such iterators. It performs the following steps when called:
Assert :kind iskey+value ,key , orvalue .- Perform ?
RequireInternalSlot (map, [[MapData]]). - Letclosure be a new
Abstract Closure with no parameters that capturesmap andkind and performs the following steps when called:- Letentries be the
List that ismap.[[MapData]]. - Letindex be 0.
- LetnumEntries be the number of elements ofentries.
- Repeat, whileindex <numEntries,
- Lete be the
Record { [[Key]], [[Value]] } that is the value ofentries[index]. - Setindex toindex + 1.
- Ife.[[Key]] is not
empty , then- Ifkind is
key , letresult bee.[[Key]]. - Else ifkind is
value , letresult bee.[[Value]]. - Else,
Assert :kind iskey+value .- Letresult be !
CreateArrayFromList («e.[[Key]],e.[[Value]] »).
- Perform ?
Yield (result). - NOTE: the number of elements inentries may have changed while execution of this abstract operation was paused by
Yield . - SetnumEntries to the number of elements ofentries.
- Ifkind is
- Lete be the
- Return
undefined .
- Letentries be the
- Return !
CreateIteratorFromClosure (closure,"%MapIteratorPrototype%" ,%MapIteratorPrototype% ).
24.1.5.2 The %MapIteratorPrototype% Object
The%MapIteratorPrototype% object:
- has properties that are inherited by all Map Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - has the following properties:
24.1.5.2.1 %MapIteratorPrototype%.next ( )
- Return ?
GeneratorResume (this value,empty ,"%MapIteratorPrototype%" ).
24.1.5.2.2 %MapIteratorPrototype% [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
24.2 Set Objects
Set objects are collections of ECMAScript language values. A distinct value may only occur once as an element of a Set's collection. Distinct values are discriminated using the
Set objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structures used in this Set objects specification is only intended to describe the required observable semantics of Set objects. It is not intended to be a viable implementation model.
24.2.1 The Set Constructor
The Set
- is%Set%.
- is the initial value of the
"Set" property of theglobal object . - creates and initializes a new Set object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Set behaviour must include asupercall to the Setconstructor to create and initialize the subclass instance with the internal state necessary to support theSet.prototypebuilt-in methods.
24.2.1.1 Set ( [iterable ] )
When theSet function is called with optional argumentiterable, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - Letset be ?
OrdinaryCreateFromConstructor (NewTarget,"%Set.prototype%" , « [[SetData]] »). - Setset.[[SetData]] to a new empty
List . - Ifiterable is either
undefined ornull , returnset. - Letadder be ?
Get (set,"add" ). - If
IsCallable (adder) isfalse , throw aTypeError exception. - LetiteratorRecord be ?
GetIterator (iterable). - Repeat,
- Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , returnset. - LetnextValue be ?
IteratorValue (next). - Letstatus be
Call (adder,set, «nextValue »). - Ifstatus is an
abrupt completion , return ?IteratorClose (iteratorRecord,status).
- Letnext be ?
24.2.2 Properties of the Set Constructor
The Set
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
24.2.2.1 Set.prototype
The initial value ofSet.prototype is the
This property has the attributes { [[Writable]]:
24.2.2.2 get Set [ @@species ]
Set[@@species] is an
- Return the
this value.
The value of the
Methods that create derived collection objects should call
24.2.3 Properties of the Set Prototype Object
TheSet prototype object:
- is%Set.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[SetData]] internal slot.
24.2.3.1 Set.prototype.add (value )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[SetData]]). - Letentries be the
List that isS.[[SetData]]. - For each elemente ofentries, do
- Ife is not
empty andSameValueZero (e,value) istrue , then- ReturnS.
- Ife is not
- Ifvalue is
-0 𝔽, setvalue to+0 𝔽. - Appendvalue as the last element ofentries.
- ReturnS.
24.2.3.2 Set.prototype.clear ( )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[SetData]]). - Letentries be the
List that isS.[[SetData]]. - For each elemente ofentries, do
- Replace the element ofentries whose value ise with an element whose value is
empty .
- Replace the element ofentries whose value ise with an element whose value is
- Return
undefined .
24.2.3.3 Set.prototype.constructor
The initial value ofSet.prototype.constructor is
24.2.3.4 Set.prototype.delete (value )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[SetData]]). - Letentries be the
List that isS.[[SetData]]. - For each elemente ofentries, do
- Ife is not
empty andSameValueZero (e,value) istrue , then- Replace the element ofentries whose value ise with an element whose value is
empty . - Return
true .
- Replace the element ofentries whose value ise with an element whose value is
- Ife is not
- Return
false .
The value
24.2.3.5 Set.prototype.entries ( )
The following steps are taken:
- LetS be the
this value. - Return ?
CreateSetIterator (S,key+value ).
For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.
24.2.3.6 Set.prototype.forEach (callbackfn [ ,thisArg ] )
When theforEach method is called with one or two arguments, the following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[SetData]]). - If
IsCallable (callbackfn) isfalse , throw aTypeError exception. - Letentries be the
List that isS.[[SetData]]. - For each elemente ofentries, do
- Ife is not
empty , then- Perform ?
Call (callbackfn,thisArg, «e,e,S »).
- Perform ?
- Ife is not
- Return
undefined .
callbackfn should be a function that accepts three arguments.forEach callscallbackfn once for each value present in the set object, in value insertion order.callbackfn is called only for values of the Set which actually exist; it is not called for keys that have been deleted from the set.
If athisArg parameter is provided, it will be used as the
callbackfn is called with three arguments: the first two arguments are a value contained in the Set. The same value is passed for both arguments. The Set object being traversed is passed as the third argument.
Thecallbackfn is called with three arguments to be consistent with the call back functions used byforEach methods for Map and Array. For Sets, each item value is considered to be both the key and the value.
forEach does not directly mutate the object on which it is called but the object may be mutated by the calls tocallbackfn.
Each value is normally visited only once. However, a value will be revisited if it is deleted after it has been visited and then re-added before theforEach call completes. Values that are deleted after the call toforEach begins and before being visited are not visited unless the value is added again before theforEach call completes. New values added after the call toforEach begins are visited.
24.2.3.7 Set.prototype.has (value )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[SetData]]). - Letentries be the
List that isS.[[SetData]]. - For each elemente ofentries, do
- Ife is not
empty andSameValueZero (e,value) istrue , returntrue .
- Ife is not
- Return
false .
24.2.3.8 Set.prototype.keys ( )
The initial value of the
For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.
24.2.3.9 get Set.prototype.size
Set.prototype.size is an
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[SetData]]). - Letentries be the
List that isS.[[SetData]]. - Letcount be 0.
- For each elemente ofentries, do
- Ife is not
empty , setcount tocount + 1.
- Ife is not
- Return
𝔽 (count).
24.2.3.10 Set.prototype.values ( )
The following steps are taken:
- LetS be the
this value. - Return ?
CreateSetIterator (S,value ).
24.2.3.11 Set.prototype [ @@iterator ] ( )
The initial value of the
24.2.3.12 Set.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
24.2.4 Properties of Set Instances
Set instances are ordinary objects that inherit properties from the Set prototype. Set instances also have a [[SetData]] internal slot.
24.2.5 Set Iterator Objects
A Set Iterator is an
24.2.5.1 CreateSetIterator (set,kind )
The abstract operation CreateSetIterator takes argumentsset andkind. This operation is used to create iterator objects for Set methods that return such iterators. It performs the following steps when called:
Assert :kind iskey+value orvalue .- Perform ?
RequireInternalSlot (set, [[SetData]]). - Letclosure be a new
Abstract Closure with no parameters that capturesset andkind and performs the following steps when called:- Letindex be 0.
- Letentries be the
List that isset.[[SetData]]. - LetnumEntries be the number of elements ofentries.
- Repeat, whileindex <numEntries,
- Lete beentries[index].
- Setindex toindex + 1.
- Ife is not
empty , then- Ifkind is
key+value , then- Perform ?
Yield (!CreateArrayFromList («e,e »)).
- Perform ?
- Else,
- NOTE: the number of elements inentries may have changed while execution of this abstract operation was paused by
Yield . - SetnumEntries to the number of elements ofentries.
- Ifkind is
- Return
undefined .
- Return !
CreateIteratorFromClosure (closure,"%SetIteratorPrototype%" ,%SetIteratorPrototype% ).
24.2.5.2 The %SetIteratorPrototype% Object
The%SetIteratorPrototype% object:
- has properties that are inherited by all Set Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - has the following properties:
24.2.5.2.1 %SetIteratorPrototype%.next ( )
- Return ?
GeneratorResume (this value,empty ,"%SetIteratorPrototype%" ).
24.2.5.2.2 %SetIteratorPrototype% [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
24.3 WeakMap Objects
WeakMap objects are collections of key/value pairs where the keys are objects and values may be arbitrary ECMAScript language values. A WeakMap may be queried to see if it contains a key/value pair with a specific key, but no mechanism is provided for enumerating the objects it holds as keys. In certain conditions, objects which are not
An implementation may impose an arbitrarily determined latency between the time a key/value pair of a WeakMap becomes inaccessible and the time when the key/value pair is removed from the WeakMap. If this latency was observable to ECMAScript program, it would be a source of indeterminacy that could impact program execution. For that reason, an ECMAScript implementation must not provide any means to observe a key of a WeakMap that does not require the observer to present the observed key.
WeakMap objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of key/value pairs in the collection. The data structure used in this WeakMap objects specification are only intended to describe the required observable semantics of WeakMap objects. It is not intended to be a viable implementation model.
WeakMap and WeakSets are intended to provide mechanisms for dynamically associating state with an object in a manner that does not “leak” memory resources if, in the absence of the WeakMap or WeakSet, the object otherwise became inaccessible and subject to resource reclamation by the implementation's garbage collection mechanisms. This characteristic can be achieved by using an inverted per-object mapping of weak map instances to keys. Alternatively each weak map may internally store its key to value mappings but this approach requires coordination between the WeakMap or WeakSet implementation and the garbage collector. The following references describe mechanism that may be useful to implementations of WeakMap and WeakSets:
Barry Hayes. 1997. Ephemerons: a new finalization mechanism. InProceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '97), A. Michael Berman (Ed.). ACM, New York, NY, USA, 176-183,http://doi.acm.org/10.1145/263698.263733.
Alexandra Barros, Roberto Ierusalimschy, Eliminating Cycles in Weak Tables. Journal of Universal Computer Science - J.UCS, vol. 14, no. 21, pp. 3481-3497, 2008,http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak
24.3.1 The WeakMap Constructor
The WeakMap
- is%WeakMap%.
- is the initial value of the
"WeakMap" property of theglobal object . - creates and initializes a new WeakMap object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified WeakMap behaviour must include asupercall to the WeakMapconstructor to create and initialize the subclass instance with the internal state necessary to support theWeakMap.prototypebuilt-in methods.
24.3.1.1 WeakMap ( [iterable ] )
When theWeakMap function is called with optional argumentiterable, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - Letmap be ?
OrdinaryCreateFromConstructor (NewTarget,"%WeakMap.prototype%" , « [[WeakMapData]] »). - Setmap.[[WeakMapData]] to a new empty
List . - Ifiterable is either
undefined ornull , returnmap. - Letadder be ?
Get (map,"set" ). - Return ?
AddEntriesFromIterable (map,iterable,adder).
If the parameteriterable is present, it is expected to be an object that implements an
24.3.2 Properties of the WeakMap Constructor
The WeakMap
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
24.3.2.1 WeakMap.prototype
The initial value ofWeakMap.prototype is the
This property has the attributes { [[Writable]]:
24.3.3 Properties of the WeakMap Prototype Object
TheWeakMap prototype object:
- is%WeakMap.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[WeakMapData]] internal slot.
24.3.3.1 WeakMap.prototype.constructor
The initial value ofWeakMap.prototype.constructor is
24.3.3.2 WeakMap.prototype.delete (key )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[WeakMapData]]). - Letentries be the
List that isM.[[WeakMapData]]. - If
Type (key) is not Object, returnfalse . - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValue (p.[[Key]],key) istrue , then- Setp.[[Key]] to
empty . - Setp.[[Value]] to
empty . - Return
true .
- Setp.[[Key]] to
- Ifp.[[Key]] is not
- Return
false .
The value
24.3.3.3 WeakMap.prototype.get (key )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[WeakMapData]]). - Letentries be the
List that isM.[[WeakMapData]]. - If
Type (key) is not Object, returnundefined . - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValue (p.[[Key]],key) istrue , returnp.[[Value]].
- Ifp.[[Key]] is not
- Return
undefined .
24.3.3.4 WeakMap.prototype.has (key )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[WeakMapData]]). - Letentries be the
List that isM.[[WeakMapData]]. - If
Type (key) is not Object, returnfalse . - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValue (p.[[Key]],key) istrue , returntrue .
- Ifp.[[Key]] is not
- Return
false .
24.3.3.5 WeakMap.prototype.set (key,value )
The following steps are taken:
- LetM be the
this value. - Perform ?
RequireInternalSlot (M, [[WeakMapData]]). - Letentries be the
List that isM.[[WeakMapData]]. - If
Type (key) is not Object, throw aTypeError exception. - For each
Record { [[Key]], [[Value]] }p ofentries, do- Ifp.[[Key]] is not
empty andSameValue (p.[[Key]],key) istrue , then- Setp.[[Value]] tovalue.
- ReturnM.
- Ifp.[[Key]] is not
- Letp be the
Record { [[Key]]:key, [[Value]]:value }. - Appendp as the last element ofentries.
- ReturnM.
24.3.3.6 WeakMap.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
24.3.4 Properties of WeakMap Instances
WeakMap instances are ordinary objects that inherit properties from the WeakMap prototype. WeakMap instances also have a [[WeakMapData]] internal slot.
24.4 WeakSet Objects
WeakSet objects are collections of objects. A distinct object may only occur once as an element of a WeakSet's collection. A WeakSet may be queried to see if it contains a specific object, but no mechanism is provided for enumerating the objects it holds. In certain conditions, objects which are not
An implementation may impose an arbitrarily determined latency between the time an object contained in a WeakSet becomes inaccessible and the time when the object is removed from the WeakSet. If this latency was observable to ECMAScript program, it would be a source of indeterminacy that could impact program execution. For that reason, an ECMAScript implementation must not provide any means to determine if a WeakSet contains a particular object that does not require the observer to present the observed object.
WeakSet objects must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structure used in this WeakSet objects specification is only intended to describe the required observable semantics of WeakSet objects. It is not intended to be a viable implementation model.
See the NOTE in
24.4.1 The WeakSet Constructor
The WeakSet
- is%WeakSet%.
- is the initial value of the
"WeakSet" property of theglobal object . - creates and initializes a new WeakSet object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified WeakSet behaviour must include asupercall to the WeakSetconstructor to create and initialize the subclass instance with the internal state necessary to support theWeakSet.prototypebuilt-in methods.
24.4.1.1 WeakSet ( [iterable ] )
When theWeakSet function is called with optional argumentiterable, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - Letset be ?
OrdinaryCreateFromConstructor (NewTarget,"%WeakSet.prototype%" , « [[WeakSetData]] »). - Setset.[[WeakSetData]] to a new empty
List . - Ifiterable is either
undefined ornull , returnset. - Letadder be ?
Get (set,"add" ). - If
IsCallable (adder) isfalse , throw aTypeError exception. - LetiteratorRecord be ?
GetIterator (iterable). - Repeat,
- Letnext be ?
IteratorStep (iteratorRecord). - Ifnext is
false , returnset. - LetnextValue be ?
IteratorValue (next). - Letstatus be
Call (adder,set, «nextValue »). - Ifstatus is an
abrupt completion , return ?IteratorClose (iteratorRecord,status).
- Letnext be ?
24.4.2 Properties of the WeakSet Constructor
The WeakSet
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
24.4.2.1 WeakSet.prototype
The initial value ofWeakSet.prototype is the
This property has the attributes { [[Writable]]:
24.4.3 Properties of the WeakSet Prototype Object
TheWeakSet prototype object:
- is%WeakSet.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[WeakSetData]] internal slot.
24.4.3.1 WeakSet.prototype.add (value )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[WeakSetData]]). - If
Type (value) is not Object, throw aTypeError exception. - Letentries be the
List that isS.[[WeakSetData]]. - For each elemente ofentries, do
- Ife is not
empty andSameValue (e,value) istrue , then- ReturnS.
- Ife is not
- Appendvalue as the last element ofentries.
- ReturnS.
24.4.3.2 WeakSet.prototype.constructor
The initial value ofWeakSet.prototype.constructor is the
24.4.3.3 WeakSet.prototype.delete (value )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[WeakSetData]]). - If
Type (value) is not Object, returnfalse . - Letentries be the
List that isS.[[WeakSetData]]. - For each elemente ofentries, do
- Ife is not
empty andSameValue (e,value) istrue , then- Replace the element ofentries whose value ise with an element whose value is
empty . - Return
true .
- Replace the element ofentries whose value ise with an element whose value is
- Ife is not
- Return
false .
The value
24.4.3.4 WeakSet.prototype.has (value )
The following steps are taken:
- LetS be the
this value. - Perform ?
RequireInternalSlot (S, [[WeakSetData]]). - Letentries be the
List that isS.[[WeakSetData]]. - If
Type (value) is not Object, returnfalse . - For each elemente ofentries, do
- Ife is not
empty andSameValue (e,value) istrue , returntrue .
- Ife is not
- Return
false .
24.4.3.5 WeakSet.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
24.4.4 Properties of WeakSet Instances
WeakSet instances are ordinary objects that inherit properties from the WeakSet prototype. WeakSet instances also have a [[WeakSetData]] internal slot.
25 Structured Data
25.1 ArrayBuffer Objects
25.1.1 Notation
The descriptions below in this section,
Aread-modify-write modification function is a mathematical function that is notationally represented as an abstract closure that takes two Lists of byte values as arguments and returns a
- They perform all their algorithm steps atomically.
- Their individual algorithm steps are not observable.
To aid verifying that a read-modify-write modification function's algorithm steps constitute a pure, mathematical function, the following editorial conventions are recommended:
- They do not access, directly or transitively via invoked
abstract operations and abstract closures, any language or specification values except their parameters and captured values. - They do not return completion values.
25.1.2 Abstract Operations For ArrayBuffer Objects
25.1.2.1 AllocateArrayBuffer (constructor,byteLength )
The abstract operation AllocateArrayBuffer takes argumentsconstructor andbyteLength (a non-negative
- Letobj be ?
OrdinaryCreateFromConstructor (constructor,"%ArrayBuffer.prototype%" , « [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferDetachKey]] »). - Letblock be ?
CreateByteDataBlock (byteLength). - Setobj.[[ArrayBufferData]] toblock.
- Setobj.[[ArrayBufferByteLength]] tobyteLength.
- Returnobj.
25.1.2.2 IsDetachedBuffer (arrayBuffer )
The abstract operation IsDetachedBuffer takes argumentarrayBuffer. It performs the following steps when called:
25.1.2.3 DetachArrayBuffer (arrayBuffer [ ,key ] )
The abstract operation DetachArrayBuffer takes argumentarrayBuffer and optional argumentkey. It performs the following steps when called:
Assert :Type (arrayBuffer) is Object and it has [[ArrayBufferData]], [[ArrayBufferByteLength]], and [[ArrayBufferDetachKey]] internal slots.Assert :IsSharedArrayBuffer (arrayBuffer) isfalse .- Ifkey is not present, setkey to
undefined . - If
SameValue (arrayBuffer.[[ArrayBufferDetachKey]],key) isfalse , throw aTypeError exception. - SetarrayBuffer.[[ArrayBufferData]] to
null . - SetarrayBuffer.[[ArrayBufferByteLength]] to 0.
- Return
NormalCompletion (null ).
Detaching an ArrayBuffer instance disassociates the
25.1.2.4 CloneArrayBuffer (srcBuffer,srcByteOffset,srcLength,cloneConstructor )
The abstract operation CloneArrayBuffer takes argumentssrcBuffer (an ArrayBuffer object),srcByteOffset (a non-negative
Assert :Type (srcBuffer) is Object and it has an [[ArrayBufferData]] internal slot.Assert :IsConstructor (cloneConstructor) istrue .- LettargetBuffer be ?
AllocateArrayBuffer (cloneConstructor,srcLength). - If
IsDetachedBuffer (srcBuffer) istrue , throw aTypeError exception. - LetsrcBlock besrcBuffer.[[ArrayBufferData]].
- LettargetBlock betargetBuffer.[[ArrayBufferData]].
- Perform
CopyDataBlockBytes (targetBlock, 0,srcBlock,srcByteOffset,srcLength). - ReturntargetBuffer.
25.1.2.5 IsUnsignedElementType (type )
The abstract operation IsUnsignedElementType takes argumenttype. It verifies if the argumenttype is an unsigned
- Iftype is
Uint8 ,Uint8C ,Uint16 ,Uint32 , orBigUint64 , returntrue . - Return
false .
25.1.2.6 IsUnclampedIntegerElementType (type )
The abstract operation IsUnclampedIntegerElementType takes argumenttype. It verifies if the argumenttype is an
- Iftype is
Int8 ,Uint8 ,Int16 ,Uint16 ,Int32 , orUint32 , returntrue . - Return
false .
25.1.2.7 IsBigIntElementType (type )
The abstract operation IsBigIntElementType takes argumenttype. It verifies if the argumenttype is a BigInt
- Iftype is
BigUint64 orBigInt64 , returntrue . - Return
false .
25.1.2.8 IsNoTearConfiguration (type,order )
The abstract operation IsNoTearConfiguration takes argumentstype andorder. It performs the following steps when called:
- If !
IsUnclampedIntegerElementType (type) istrue , returntrue . - If !
IsBigIntElementType (type) istrue andorder is notInit orUnordered , returntrue . - Return
false .
25.1.2.9 RawBytesToNumeric (type,rawBytes,isLittleEndian )
The abstract operation RawBytesToNumeric takes argumentstype (a
- LetelementSize be the Element Size value specified in
Table 60 for Element Typetype. - IfisLittleEndian is
false , reverse the order of the elements ofrawBytes. - Iftype is
Float32 , then- Letvalue be the byte elements ofrawBytes concatenated and interpreted as a little-endian bit string encoding of an
IEEE 754-2019 binary32 value. - Ifvalue is an
IEEE 754-2019 binary32 NaN value, return theNaN Number value . - Return the
Number value that corresponds tovalue.
- Letvalue be the byte elements ofrawBytes concatenated and interpreted as a little-endian bit string encoding of an
- Iftype is
Float64 , then- Letvalue be the byte elements ofrawBytes concatenated and interpreted as a little-endian bit string encoding of an
IEEE 754-2019 binary64 value. - Ifvalue is an
IEEE 754-2019 binary64 NaN value, return theNaN Number value . - Return the
Number value that corresponds tovalue.
- Letvalue be the byte elements ofrawBytes concatenated and interpreted as a little-endian bit string encoding of an
- If !
IsUnsignedElementType (type) istrue , then- LetintValue be the byte elements ofrawBytes concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
- Else,
- LetintValue be the byte elements ofrawBytes concatenated and interpreted as a bit string encoding of a binary little-endian two's complement number of bit lengthelementSize × 8.
- If !
IsBigIntElementType (type) istrue , return the BigInt value that corresponds tointValue. - Otherwise, return the
Number value that corresponds tointValue.
25.1.2.10 GetValueFromBuffer (arrayBuffer,byteIndex,type,isTypedArray,order [ ,isLittleEndian ] )
The abstract operation GetValueFromBuffer takes argumentsarrayBuffer (an ArrayBuffer or SharedArrayBuffer),byteIndex (a non-negative
Assert :IsDetachedBuffer (arrayBuffer) isfalse .Assert : There are sufficient bytes inarrayBuffer starting atbyteIndex to represent a value oftype.- Letblock bearrayBuffer.[[ArrayBufferData]].
- LetelementSize be the Element Size value specified in
Table 60 for Element Typetype. - If
IsSharedArrayBuffer (arrayBuffer) istrue , then- Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventList be the [[EventList]] field of the element inexecution.[[EventsRecords]] whose [[AgentSignifier]] is
AgentSignifier (). - IfisTypedArray is
true andIsNoTearConfiguration (type,order) istrue , letnoTear betrue ; otherwise letnoTear befalse . - LetrawValue be a
List of lengthelementSize whose elements are nondeterministically chosen byte values. - NOTE: In implementations,rawValue is the result of a non-atomic or atomic read instruction on the underlying hardware. The nondeterminism is a semantic prescription of the
memory model to describe observable behaviour of hardware with weak consistency. - LetreadEvent be
ReadSharedMemory { [[Order]]:order, [[NoTear]]:noTear, [[Block]]:block, [[ByteIndex]]:byteIndex, [[ElementSize]]:elementSize }. - AppendreadEvent toeventList.
- Append
Chosen Value Record { [[Event]]:readEvent, [[ChosenValue]]:rawValue } toexecution.[[ChosenValues]].
- Letexecution be the [[CandidateExecution]] field of the
- Else, letrawValue be a
List whose elements are bytes fromblock at indicesbyteIndex (inclusive) throughbyteIndex +elementSize (exclusive). Assert : The number of elements inrawValue iselementSize.- IfisLittleEndian is not present, setisLittleEndian to the value of the [[LittleEndian]] field of the
surrounding agent 'sAgent Record . - Return
RawBytesToNumeric (type,rawValue,isLittleEndian).
25.1.2.11 NumericToRawBytes (type,value,isLittleEndian )
The abstract operation NumericToRawBytes takes argumentstype (a
- Iftype is
Float32 , then- LetrawBytes be a
List whose elements are the 4 bytes that are the result of convertingvalue toIEEE 754-2019 binary32 format using roundTiesToEven mode. IfisLittleEndian isfalse , the bytes are arranged in big endian order. Otherwise, the bytes are arranged in little endian order. Ifvalue isNaN ,rawBytes may be set to any implementation chosenIEEE 754-2019 binary32 format Not-a-Number encoding. An implementation must always choose the same encoding for each implementation distinguishableNaN value.
- LetrawBytes be a
- Else iftype is
Float64 , then- LetrawBytes be a
List whose elements are the 8 bytes that are theIEEE 754-2019 binary64 format encoding ofvalue. IfisLittleEndian isfalse , the bytes are arranged in big endian order. Otherwise, the bytes are arranged in little endian order. Ifvalue isNaN ,rawBytes may be set to any implementation chosenIEEE 754-2019 binary64 format Not-a-Number encoding. An implementation must always choose the same encoding for each implementation distinguishableNaN value.
- LetrawBytes be a
- Else,
- Letn be the Element Size value specified in
Table 60 for Element Typetype. - LetconvOp be the abstract operation named in the Conversion Operation column in
Table 60 for Element Typetype. - LetintValue be
ℝ (convOp(value)). - IfintValue ≥ 0, then
- LetrawBytes be a
List whose elements are then-byte binary encoding ofintValue. IfisLittleEndian isfalse , the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
- LetrawBytes be a
- Else,
- LetrawBytes be a
List whose elements are then-byte binary two's complement encoding ofintValue. IfisLittleEndian isfalse , the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
- LetrawBytes be a
- Letn be the Element Size value specified in
- ReturnrawBytes.
25.1.2.12 SetValueInBuffer (arrayBuffer,byteIndex,type,value,isTypedArray,order [ ,isLittleEndian ] )
The abstract operation SetValueInBuffer takes argumentsarrayBuffer (an ArrayBuffer or SharedArrayBuffer),byteIndex (a non-negative
Assert :IsDetachedBuffer (arrayBuffer) isfalse .Assert : There are sufficient bytes inarrayBuffer starting atbyteIndex to represent a value oftype.Assert :Type (value) is BigInt if !IsBigIntElementType (type) istrue ; otherwise,Type (value) is Number.- Letblock bearrayBuffer.[[ArrayBufferData]].
- LetelementSize be the Element Size value specified in
Table 60 for Element Typetype. - IfisLittleEndian is not present, setisLittleEndian to the value of the [[LittleEndian]] field of the
surrounding agent 'sAgent Record . - LetrawBytes be
NumericToRawBytes (type,value,isLittleEndian). - If
IsSharedArrayBuffer (arrayBuffer) istrue , then- Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventList be the [[EventList]] field of the element inexecution.[[EventsRecords]] whose [[AgentSignifier]] is
AgentSignifier (). - IfisTypedArray is
true andIsNoTearConfiguration (type,order) istrue , letnoTear betrue ; otherwise letnoTear befalse . - Append
WriteSharedMemory { [[Order]]:order, [[NoTear]]:noTear, [[Block]]:block, [[ByteIndex]]:byteIndex, [[ElementSize]]:elementSize, [[Payload]]:rawBytes } toeventList.
- Letexecution be the [[CandidateExecution]] field of the
- Else, store the individual bytes ofrawBytes intoblock, starting atblock[byteIndex].
- Return
NormalCompletion (undefined ).
25.1.2.13 GetModifySetValueInBuffer (arrayBuffer,byteIndex,type,value,op [ ,isLittleEndian ] )
The abstract operation GetModifySetValueInBuffer takes argumentsarrayBuffer (an ArrayBuffer object or a SharedArrayBuffer object),byteIndex (a non-negative
Assert :IsDetachedBuffer (arrayBuffer) isfalse .Assert : There are sufficient bytes inarrayBuffer starting atbyteIndex to represent a value oftype.Assert :Type (value) is BigInt if !IsBigIntElementType (type) istrue ; otherwise,Type (value) is Number.- Letblock bearrayBuffer.[[ArrayBufferData]].
- LetelementSize be the Element Size value specified in
Table 60 for Element Typetype. - IfisLittleEndian is not present, setisLittleEndian to the value of the [[LittleEndian]] field of the
surrounding agent 'sAgent Record . - LetrawBytes be
NumericToRawBytes (type,value,isLittleEndian). - If
IsSharedArrayBuffer (arrayBuffer) istrue , then- Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventList be the [[EventList]] field of the element inexecution.[[EventsRecords]] whose [[AgentSignifier]] is
AgentSignifier (). - LetrawBytesRead be a
List of lengthelementSize whose elements are nondeterministically chosen byte values. - NOTE: In implementations,rawBytesRead is the result of a load-link, of a load-exclusive, or of an operand of a read-modify-write instruction on the underlying hardware. The nondeterminism is a semantic prescription of the
memory model to describe observable behaviour of hardware with weak consistency. - LetrmwEvent be
ReadModifyWriteSharedMemory { [[Order]]:SeqCst , [[NoTear]]:true , [[Block]]:block, [[ByteIndex]]:byteIndex, [[ElementSize]]:elementSize, [[Payload]]:rawBytes, [[ModifyOp]]:op }. - AppendrmwEvent toeventList.
- Append
Chosen Value Record { [[Event]]:rmwEvent, [[ChosenValue]]:rawBytesRead } toexecution.[[ChosenValues]].
- Letexecution be the [[CandidateExecution]] field of the
- Else,
- LetrawBytesRead be a
List of lengthelementSize whose elements are the sequence ofelementSize bytes starting withblock[byteIndex]. - LetrawBytesModified beop(rawBytesRead,rawBytes).
- Store the individual bytes ofrawBytesModified intoblock, starting atblock[byteIndex].
- LetrawBytesRead be a
- Return
RawBytesToNumeric (type,rawBytesRead,isLittleEndian).
25.1.3 The ArrayBuffer Constructor
The ArrayBuffer
- is%ArrayBuffer%.
- is the initial value of the
"ArrayBuffer" property of theglobal object . - creates and initializes a new ArrayBuffer object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified ArrayBuffer behaviour must include asupercall to the ArrayBufferconstructor to create and initialize subclass instances with the internal state necessary to support theArrayBuffer.prototypebuilt-in methods.
25.1.3.1 ArrayBuffer (length )
When theArrayBuffer function is called with argumentlength, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - LetbyteLength be ?
ToIndex (length). - Return ?
AllocateArrayBuffer (NewTarget,byteLength).
25.1.4 Properties of the ArrayBuffer Constructor
The ArrayBuffer
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
25.1.4.1 ArrayBuffer.isView (arg )
TheisView function takes one argumentarg, and performs the following steps:
- If
Type (arg) is not Object, returnfalse . - Ifarg has a [[ViewedArrayBuffer]] internal slot, return
true . - Return
false .
25.1.4.2 ArrayBuffer.prototype
The initial value ofArrayBuffer.prototype is the
This property has the attributes { [[Writable]]:
25.1.4.3 get ArrayBuffer [ @@species ]
ArrayBuffer[@@species] is an
- Return the
this value.
The value of the
ArrayBuffer prototype methods normally use their
25.1.5 Properties of the ArrayBuffer Prototype Object
TheArrayBuffer prototype object:
- is%ArrayBuffer.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] internal slot.
25.1.5.1 get ArrayBuffer.prototype.byteLength
ArrayBuffer.prototype.byteLength is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[ArrayBufferData]]). - If
IsSharedArrayBuffer (O) istrue , throw aTypeError exception. - If
IsDetachedBuffer (O) istrue , return+0 𝔽. - Letlength beO.[[ArrayBufferByteLength]].
- Return
𝔽 (length).
25.1.5.2 ArrayBuffer.prototype.constructor
The initial value ofArrayBuffer.prototype.constructor is
25.1.5.3 ArrayBuffer.prototype.slice (start,end )
The following steps are taken:
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[ArrayBufferData]]). - If
IsSharedArrayBuffer (O) istrue , throw aTypeError exception. - If
IsDetachedBuffer (O) istrue , throw aTypeError exception. - Letlen beO.[[ArrayBufferByteLength]].
- LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letfirst be 0.
- Else ifrelativeStart < 0, letfirst be
max (len +relativeStart, 0). - Else, letfirst be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - LetnewLen be
max (final -first, 0). - Letctor be ?
SpeciesConstructor (O,%ArrayBuffer% ). - Letnew be ?
Construct (ctor, «𝔽 (newLen) »). - Perform ?
RequireInternalSlot (new, [[ArrayBufferData]]). - If
IsSharedArrayBuffer (new) istrue , throw aTypeError exception. - If
IsDetachedBuffer (new) istrue , throw aTypeError exception. - If
SameValue (new,O) istrue , throw aTypeError exception. - Ifnew.[[ArrayBufferByteLength]] <newLen, throw a
TypeError exception. - NOTE: Side-effects of the above steps may have detachedO.
- If
IsDetachedBuffer (O) istrue , throw aTypeError exception. - LetfromBuf beO.[[ArrayBufferData]].
- LettoBuf benew.[[ArrayBufferData]].
- Perform
CopyDataBlockBytes (toBuf, 0,fromBuf,first,newLen). - Returnnew.
25.1.5.4 ArrayBuffer.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
25.1.6 Properties of ArrayBuffer Instances
ArrayBuffer instances inherit properties from the
ArrayBuffer instances whose [[ArrayBufferData]] is
ArrayBuffer instances whose [[ArrayBufferDetachKey]] is set to a value other than
25.2 SharedArrayBuffer Objects
25.2.1 Abstract Operations for SharedArrayBuffer Objects
25.2.1.1 AllocateSharedArrayBuffer (constructor,byteLength )
The abstract operation AllocateSharedArrayBuffer takes argumentsconstructor andbyteLength (a non-negative
- Letobj be ?
OrdinaryCreateFromConstructor (constructor,"%SharedArrayBuffer.prototype%" , « [[ArrayBufferData]], [[ArrayBufferByteLength]] »). - Letblock be ?
CreateSharedByteDataBlock (byteLength). - Setobj.[[ArrayBufferData]] toblock.
- Setobj.[[ArrayBufferByteLength]] tobyteLength.
- Returnobj.
25.2.1.2 IsSharedArrayBuffer (obj )
The abstract operation IsSharedArrayBuffer takes argumentobj. It tests whether an object is an ArrayBuffer, a SharedArrayBuffer, or a subtype of either. It performs the following steps when called:
Assert :Type (obj) is Object and it has an [[ArrayBufferData]] internal slot.- LetbufferData beobj.[[ArrayBufferData]].
- IfbufferData is
null , returnfalse . - IfbufferData is a
Data Block , returnfalse . Assert :bufferData is aShared Data Block .- Return
true .
25.2.2 The SharedArrayBuffer Constructor
The SharedArrayBuffer
- is%SharedArrayBuffer%.
- is the initial value of the
"SharedArrayBuffer" property of theglobal object , if that property is present (see below). - creates and initializes a new SharedArrayBuffer object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified SharedArrayBuffer behaviour must include asupercall to the SharedArrayBufferconstructor to create and initialize subclass instances with the internal state necessary to support theSharedArrayBuffer.prototypebuilt-in methods.
Whenever a
Unlike anArrayBuffer, aSharedArrayBuffer cannot become detached, and its internal [[ArrayBufferData]] slot is never
25.2.2.1 SharedArrayBuffer ( [length ] )
When theSharedArrayBuffer function is called with optional argumentlength, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - LetbyteLength be ?
ToIndex (length). - Return ?
AllocateSharedArrayBuffer (NewTarget,byteLength).
25.2.3 Properties of the SharedArrayBuffer Constructor
The SharedArrayBuffer
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
25.2.3.1 SharedArrayBuffer.prototype
The initial value ofSharedArrayBuffer.prototype is the
This property has the attributes { [[Writable]]:
25.2.3.2 get SharedArrayBuffer [ @@species ]
SharedArrayBuffer[@@species] is an
- Return the
this value.
The value of the
25.2.4 Properties of the SharedArrayBuffer Prototype Object
TheSharedArrayBuffer prototype object:
- is%SharedArrayBuffer.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] internal slot.
25.2.4.1 get SharedArrayBuffer.prototype.byteLength
SharedArrayBuffer.prototype.byteLength is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[ArrayBufferData]]). - If
IsSharedArrayBuffer (O) isfalse , throw aTypeError exception. - Letlength beO.[[ArrayBufferByteLength]].
- Return
𝔽 (length).
25.2.4.2 SharedArrayBuffer.prototype.constructor
The initial value ofSharedArrayBuffer.prototype.constructor is
25.2.4.3 SharedArrayBuffer.prototype.slice (start,end )
The following steps are taken:
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[ArrayBufferData]]). - If
IsSharedArrayBuffer (O) isfalse , throw aTypeError exception. - Letlen beO.[[ArrayBufferByteLength]].
- LetrelativeStart be ?
ToIntegerOrInfinity (start). - IfrelativeStart is -∞, letfirst be 0.
- Else ifrelativeStart < 0, letfirst be
max (len +relativeStart, 0). - Else, letfirst be
min (relativeStart,len). - Ifend is
undefined , letrelativeEnd belen; else letrelativeEnd be ?ToIntegerOrInfinity (end). - IfrelativeEnd is -∞, letfinal be 0.
- Else ifrelativeEnd < 0, letfinal be
max (len +relativeEnd, 0). - Else, letfinal be
min (relativeEnd,len). - LetnewLen be
max (final -first, 0). - Letctor be ?
SpeciesConstructor (O,%SharedArrayBuffer% ). - Letnew be ?
Construct (ctor, «𝔽 (newLen) »). - Perform ?
RequireInternalSlot (new, [[ArrayBufferData]]). - If
IsSharedArrayBuffer (new) isfalse , throw aTypeError exception. - Ifnew.[[ArrayBufferData]] andO.[[ArrayBufferData]] are the same
Shared Data Block values, throw aTypeError exception. - Ifnew.[[ArrayBufferByteLength]] <newLen, throw a
TypeError exception. - LetfromBuf beO.[[ArrayBufferData]].
- LettoBuf benew.[[ArrayBufferData]].
- Perform
CopyDataBlockBytes (toBuf, 0,fromBuf,first,newLen). - Returnnew.
25.2.4.4 SharedArrayBuffer.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
25.2.5 Properties of SharedArrayBuffer Instances
SharedArrayBuffer instances inherit properties from the
SharedArrayBuffer instances, unlike ArrayBuffer instances, are never detached.
25.3 DataView Objects
25.3.1 Abstract Operations For DataView Objects
25.3.1.1 GetViewValue (view,requestIndex,isLittleEndian,type )
The abstract operation GetViewValue takes argumentsview,requestIndex,isLittleEndian, andtype. It is used by functions on DataView instances to retrieve values from the view's buffer. It performs the following steps when called:
- Perform ?
RequireInternalSlot (view, [[DataView]]). Assert :view has a [[ViewedArrayBuffer]] internal slot.- LetgetIndex be ?
ToIndex (requestIndex). - SetisLittleEndian to !
ToBoolean (isLittleEndian). - Letbuffer beview.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - LetviewOffset beview.[[ByteOffset]].
- LetviewSize beview.[[ByteLength]].
- LetelementSize be the Element Size value specified in
Table 60 for Element Typetype. - IfgetIndex +elementSize >viewSize, throw a
RangeError exception. - LetbufferIndex begetIndex +viewOffset.
- Return
GetValueFromBuffer (buffer,bufferIndex,type,false ,Unordered ,isLittleEndian).
25.3.1.2 SetViewValue (view,requestIndex,isLittleEndian,type,value )
The abstract operation SetViewValue takes argumentsview,requestIndex,isLittleEndian,type, andvalue. It is used by functions on DataView instances to store values into the view's buffer. It performs the following steps when called:
- Perform ?
RequireInternalSlot (view, [[DataView]]). Assert :view has a [[ViewedArrayBuffer]] internal slot.- LetgetIndex be ?
ToIndex (requestIndex). - If !
IsBigIntElementType (type) istrue , letnumberValue be ?ToBigInt (value). - Otherwise, letnumberValue be ?
ToNumber (value). - SetisLittleEndian to !
ToBoolean (isLittleEndian). - Letbuffer beview.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - LetviewOffset beview.[[ByteOffset]].
- LetviewSize beview.[[ByteLength]].
- LetelementSize be the Element Size value specified in
Table 60 for Element Typetype. - IfgetIndex +elementSize >viewSize, throw a
RangeError exception. - LetbufferIndex begetIndex +viewOffset.
- Return
SetValueInBuffer (buffer,bufferIndex,type,numberValue,false ,Unordered ,isLittleEndian).
25.3.2 The DataView Constructor
The DataView
- is%DataView%.
- is the initial value of the
"DataView" property of theglobal object . - creates and initializes a new DataView object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified DataView behaviour must include asupercall to the DataViewconstructor to create and initialize subclass instances with the internal state necessary to support theDataView.prototypebuilt-in methods.
25.3.2.1 DataView (buffer [ ,byteOffset [ ,byteLength ] ] )
When theDataView function is called with at least one argumentbuffer, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - Perform ?
RequireInternalSlot (buffer, [[ArrayBufferData]]). - Letoffset be ?
ToIndex (byteOffset). - If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - LetbufferByteLength bebuffer.[[ArrayBufferByteLength]].
- Ifoffset >bufferByteLength, throw a
RangeError exception. - IfbyteLength is
undefined , then- LetviewByteLength bebufferByteLength -offset.
- Else,
- LetviewByteLength be ?
ToIndex (byteLength). - Ifoffset +viewByteLength >bufferByteLength, throw a
RangeError exception.
- LetviewByteLength be ?
- LetO be ?
OrdinaryCreateFromConstructor (NewTarget,"%DataView.prototype%" , « [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]] »). - If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - SetO.[[ViewedArrayBuffer]] tobuffer.
- SetO.[[ByteLength]] toviewByteLength.
- SetO.[[ByteOffset]] tooffset.
- ReturnO.
25.3.3 Properties of the DataView Constructor
The DataView
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
25.3.3.1 DataView.prototype
The initial value ofDataView.prototype is the
This property has the attributes { [[Writable]]:
25.3.4 Properties of the DataView Prototype Object
TheDataView prototype object:
- is%DataView.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], or [[ByteOffset]] internal slot.
25.3.4.1 get DataView.prototype.buffer
DataView.prototype.buffer is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[DataView]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- Returnbuffer.
25.3.4.2 get DataView.prototype.byteLength
DataView.prototype.byteLength is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[DataView]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - Letsize beO.[[ByteLength]].
- Return
𝔽 (size).
25.3.4.3 get DataView.prototype.byteOffset
DataView.prototype.byteOffset is an
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[DataView]]). Assert :O has a [[ViewedArrayBuffer]] internal slot.- Letbuffer beO.[[ViewedArrayBuffer]].
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - Letoffset beO.[[ByteOffset]].
- Return
𝔽 (offset).
25.3.4.4 DataView.prototype.constructor
The initial value ofDataView.prototype.constructor is
25.3.4.5 DataView.prototype.getBigInt64 (byteOffset [ ,littleEndian ] )
When thegetBigInt64 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - Return ?
GetViewValue (v,byteOffset,littleEndian,BigInt64 ).
25.3.4.6 DataView.prototype.getBigUint64 (byteOffset [ ,littleEndian ] )
When thegetBigUint64 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - Return ?
GetViewValue (v,byteOffset,littleEndian,BigUint64 ).
25.3.4.7 DataView.prototype.getFloat32 (byteOffset [ ,littleEndian ] )
When thegetFloat32 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
GetViewValue (v,byteOffset,littleEndian,Float32 ).
25.3.4.8 DataView.prototype.getFloat64 (byteOffset [ ,littleEndian ] )
When thegetFloat64 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
GetViewValue (v,byteOffset,littleEndian,Float64 ).
25.3.4.9 DataView.prototype.getInt8 (byteOffset )
When thegetInt8 method is called with argumentbyteOffset, the following steps are taken:
- Letv be the
this value. - Return ?
GetViewValue (v,byteOffset,true ,Int8 ).
25.3.4.10 DataView.prototype.getInt16 (byteOffset [ ,littleEndian ] )
When thegetInt16 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
GetViewValue (v,byteOffset,littleEndian,Int16 ).
25.3.4.11 DataView.prototype.getInt32 (byteOffset [ ,littleEndian ] )
When thegetInt32 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
GetViewValue (v,byteOffset,littleEndian,Int32 ).
25.3.4.12 DataView.prototype.getUint8 (byteOffset )
When thegetUint8 method is called with argumentbyteOffset, the following steps are taken:
- Letv be the
this value. - Return ?
GetViewValue (v,byteOffset,true ,Uint8 ).
25.3.4.13 DataView.prototype.getUint16 (byteOffset [ ,littleEndian ] )
When thegetUint16 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
GetViewValue (v,byteOffset,littleEndian,Uint16 ).
25.3.4.14 DataView.prototype.getUint32 (byteOffset [ ,littleEndian ] )
When thegetUint32 method is called with argumentbyteOffset and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
GetViewValue (v,byteOffset,littleEndian,Uint32 ).
25.3.4.15 DataView.prototype.setBigInt64 (byteOffset,value [ ,littleEndian ] )
When thesetBigInt64 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - Return ?
SetViewValue (v,byteOffset,littleEndian,BigInt64 ,value).
25.3.4.16 DataView.prototype.setBigUint64 (byteOffset,value [ ,littleEndian ] )
When thesetBigUint64 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - Return ?
SetViewValue (v,byteOffset,littleEndian,BigUint64 ,value).
25.3.4.17 DataView.prototype.setFloat32 (byteOffset,value [ ,littleEndian ] )
When thesetFloat32 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
SetViewValue (v,byteOffset,littleEndian,Float32 ,value).
25.3.4.18 DataView.prototype.setFloat64 (byteOffset,value [ ,littleEndian ] )
When thesetFloat64 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
SetViewValue (v,byteOffset,littleEndian,Float64 ,value).
25.3.4.19 DataView.prototype.setInt8 (byteOffset,value )
When thesetInt8 method is called with argumentsbyteOffset andvalue, the following steps are taken:
- Letv be the
this value. - Return ?
SetViewValue (v,byteOffset,true ,Int8 ,value).
25.3.4.20 DataView.prototype.setInt16 (byteOffset,value [ ,littleEndian ] )
When thesetInt16 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
SetViewValue (v,byteOffset,littleEndian,Int16 ,value).
25.3.4.21 DataView.prototype.setInt32 (byteOffset,value [ ,littleEndian ] )
When thesetInt32 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
SetViewValue (v,byteOffset,littleEndian,Int32 ,value).
25.3.4.22 DataView.prototype.setUint8 (byteOffset,value )
When thesetUint8 method is called with argumentsbyteOffset andvalue, the following steps are taken:
- Letv be the
this value. - Return ?
SetViewValue (v,byteOffset,true ,Uint8 ,value).
25.3.4.23 DataView.prototype.setUint16 (byteOffset,value [ ,littleEndian ] )
When thesetUint16 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
SetViewValue (v,byteOffset,littleEndian,Uint16 ,value).
25.3.4.24 DataView.prototype.setUint32 (byteOffset,value [ ,littleEndian ] )
When thesetUint32 method is called with argumentsbyteOffset andvalue and optional argumentlittleEndian, the following steps are taken:
- Letv be the
this value. - IflittleEndian is not present, setlittleEndian to
false . - Return ?
SetViewValue (v,byteOffset,littleEndian,Uint32 ,value).
25.3.4.25 DataView.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
25.3.5 Properties of DataView Instances
DataView instances are ordinary objects that inherit properties from the
The value of the [[DataView]] internal slot is not used within this specification. The simple presence of that internal slot is used within the specification to identify objects created using the DataView
25.4 The Atomics Object
The Atomics object:
- is%Atomics%.
- is the initial value of the
"Atomics" property of theglobal object . - is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%Object.prototype% . - does not have a [[Construct]] internal method; it cannot be used as a
constructor with thenewoperator. - does not have a [[Call]] internal method; it cannot be invoked as a function.
The Atomics object provides functions that operate indivisibly (atomically) on shared memory array cells as well as functions that let agents wait for and dispatch primitive events. When used with discipline, the Atomics functions allow multi-
For informative guidelines for programming and implementing shared memory in ECMAScript, please see the notes at the end of the
25.4.1 Abstract Operations for Atomics
25.4.1.1 ValidateIntegerTypedArray (typedArray [ ,waitable ] )
The abstract operation ValidateIntegerTypedArray takes argumenttypedArray and optional argumentwaitable (a Boolean). It performs the following steps when called:
- Ifwaitable is not present, setwaitable to
false . - Letbuffer be ?
ValidateTypedArray (typedArray). - LettypeName betypedArray.[[TypedArrayName]].
- Lettype be the Element Type value in
Table 60 fortypeName. - Ifwaitable is
true , then- IftypeName is not
"Int32Array" or"BigInt64Array" , throw aTypeError exception.
- IftypeName is not
- Else,
- If !
IsUnclampedIntegerElementType (type) isfalse and !IsBigIntElementType (type) isfalse , throw aTypeError exception.
- If !
- Returnbuffer.
25.4.1.2 ValidateAtomicAccess (typedArray,requestIndex )
The abstract operation ValidateAtomicAccess takes argumentstypedArray andrequestIndex. It performs the following steps when called:
Assert :typedArray is an Object that has a [[ViewedArrayBuffer]] internal slot.- Letlength betypedArray.[[ArrayLength]].
- LetaccessIndex be ?
ToIndex (requestIndex). Assert :accessIndex ≥ 0.- IfaccessIndex ≥length, throw a
RangeError exception. - LetarrayTypeName betypedArray.[[TypedArrayName]].
- LetelementSize be the Element Size value specified in
Table 60 forarrayTypeName. - Letoffset betypedArray.[[ByteOffset]].
- Return (accessIndex ×elementSize) +offset.
25.4.1.3 GetWaiterList (block,i )
AWaiterList is a semantic object that contains an ordered list of those agents that are waiting on a location (block,i) in shared memory;block is a
Initially a WaiterList object has an empty list and no
The
Each WaiterList has acritical section that controls exclusive access to that WaiterList during evaluation. Only a single
The abstract operation GetWaiterList takes argumentsblock (a
Assert :block is aShared Data Block .Assert :i andi + 3 are valid byte offsets within the memory ofblock.Assert :i is divisible by 4.- Return the
WaiterList that is referenced by the pair (block,i).
25.4.1.4 EnterCriticalSection (WL )
The abstract operation EnterCriticalSection takes argumentWL (a
Assert : The callingagent is not in thecritical section for anyWaiterList .- Wait until no
agent is in thecritical section forWL, then enter thecritical section forWL (without allowing any otheragent to enter). - IfWL has a
Synchronize event , then- NOTE: AWL whose
critical section has been entered at least once has aSynchronize event set byLeaveCriticalSection . - Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventsRecord be the
Agent Events Record inexecution.[[EventsRecords]] whose [[AgentSignifier]] isAgentSignifier (). - LetentererEventList beeventsRecord.[[EventList]].
- LetenterEvent be a new
Synchronize event . - AppendenterEvent toentererEventList.
- LetleaveEvent be the
Synchronize event inWL. - Append (leaveEvent,enterEvent) toeventsRecord.[[AgentSynchronizesWith]].
- NOTE: AWL whose
EnterCriticalSection hascontention when an
25.4.1.5 LeaveCriticalSection (WL )
The abstract operation LeaveCriticalSection takes argumentWL (a
Assert : The callingagent is in thecritical section forWL.- Letexecution be the [[CandidateExecution]] field of the calling surrounding's
Agent Record . - LeteventsRecord be the
Agent Events Record inexecution.[[EventsRecords]] whose [[AgentSignifier]] isAgentSignifier (). - LetleaverEventList beeventsRecord.[[EventList]].
- LetleaveEvent be a new
Synchronize event . - AppendleaveEvent toleaverEventList.
- Set the
Synchronize event inWL toleaveEvent. - Leave the
critical section forWL.
25.4.1.6 AddWaiter (WL,W )
The abstract operation AddWaiter takes argumentsWL (a
Assert : The callingagent is in thecritical section forWL.Assert :W is not on the list of waiters in anyWaiterList .- AddW to the end of the list of waiters inWL.
25.4.1.7 RemoveWaiter (WL,W )
The abstract operation RemoveWaiter takes argumentsWL (a
Assert : The callingagent is in thecritical section forWL.Assert :W is on the list of waiters inWL.- RemoveW from the list of waiters inWL.
25.4.1.8 RemoveWaiters (WL,c )
The abstract operation RemoveWaiters takes argumentsWL (a
Assert : The callingagent is in thecritical section forWL.- LetL be a new empty
List . - LetS be a reference to the list of waiters inWL.
- Repeat, whilec > 0 andS is not an empty
List ,- LetW be the first waiter inS.
- AddW to the end ofL.
- RemoveW fromS.
- Ifc is finite, setc toc - 1.
- ReturnL.
25.4.1.9 SuspendAgent (WL,W,timeout )
The abstract operation SuspendAgent takes argumentsWL (a
Assert : The callingagent is in thecritical section forWL.Assert :W is equivalent toAgentSignifier ().Assert :W is on the list of waiters inWL.Assert :AgentCanSuspend () istrue .- Perform
LeaveCriticalSection (WL) and suspendW for up totimeout milliseconds, performing the combined operation in such a way that a notification that arrives after thecritical section is exited but before the suspension takes effect is not lost.W can notify either because the timeout expired or because it was notified explicitly by anotheragent callingNotifyWaiter (WL,W), and not for any other reasons at all. - Perform
EnterCriticalSection (WL). - IfW was notified explicitly by another
agent callingNotifyWaiter (WL,W), returntrue . - Return
false .
25.4.1.10 NotifyWaiter (WL,W )
The abstract operation NotifyWaiter takes argumentsWL (a
Assert : The callingagent is in thecritical section forWL.- Notify the
agent W.
The embedding may delay notifyingW, e.g. for resource management reasons, butW must eventually be notified in order to guarantee forward progress.
25.4.1.11 AtomicReadModifyWrite (typedArray,index,value,op )
The abstract operation AtomicReadModifyWrite takes argumentstypedArray,index,value, andop (a
- Letbuffer be ?
ValidateIntegerTypedArray (typedArray). - LetindexedPosition be ?
ValidateAtomicAccess (typedArray,index). - LetarrayTypeName betypedArray.[[TypedArrayName]].
- IftypedArray.[[ContentType]] is
BigInt , letv be ?ToBigInt (value). - Otherwise, letv be
𝔽 (?ToIntegerOrInfinity (value)). - If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - NOTE: The above check is not redundant with the check in
ValidateIntegerTypedArray because the call toToBigInt orToIntegerOrInfinity on the preceding lines can have arbitrary side effects, which could cause the buffer to become detached. - LetelementType be the Element Type value in
Table 60 forarrayTypeName. - Return
GetModifySetValueInBuffer (buffer,indexedPosition,elementType,v,op).
25.4.1.12 ByteListBitwiseOp (op,xBytes,yBytes )
The abstract operation ByteListBitwiseOp takes argumentsop (a sequence of Unicode code points),xBytes (a
Assert :op is&,^, or|.Assert :xBytes andyBytes have the same number of elements.- Letresult be a new empty
List . - Leti be 0.
- For each elementxByte ofxBytes, do
- LetyByte beyBytes[i].
- Ifop is
&, letresultByte be the result of applying the bitwise AND operation toxByte andyByte. - Else ifop is
^, letresultByte be the result of applying the bitwise exclusive OR (XOR) operation toxByte andyByte. - Else,op is
|. LetresultByte be the result of applying the bitwise inclusive OR operation toxByte andyByte. - Seti toi + 1.
- AppendresultByte to the end ofresult.
- Returnresult.
25.4.1.13 ByteListEqual (xBytes,yBytes )
The abstract operation ByteListEqual takes argumentsxBytes (a
- IfxBytes andyBytes do not have the same number of elements, return
false . - Leti be 0.
- For each elementxByte ofxBytes, do
- LetyByte beyBytes[i].
- IfxByte ≠yByte, return
false . - Seti toi + 1.
- Return
true .
25.4.2 Atomics.add (typedArray,index,value )
The following steps are taken:
- Lettype be the Element Type value in
Table 60 fortypedArray.[[TypedArrayName]]. - LetisLittleEndian be the value of the [[LittleEndian]] field of the
surrounding agent 'sAgent Record . - Letadd be a new
read-modify-write modification function with parameters (xBytes,yBytes) that capturestype andisLittleEndian and performs the following steps atomically when called:- Letx be
RawBytesToNumeric (type,xBytes,isLittleEndian). - Lety be
RawBytesToNumeric (type,yBytes,isLittleEndian). - LetT be
Type (x). - Letsum beT::add(x,y).
- LetsumBytes be
NumericToRawBytes (type,sum,isLittleEndian). Assert :sumBytes,xBytes, andyBytes have the same number of elements.- ReturnsumBytes.
- Letx be
- Return ?
AtomicReadModifyWrite (typedArray,index,value,add).
25.4.3 Atomics.and (typedArray,index,value )
The following steps are taken:
- Letand be a new
read-modify-write modification function with parameters (xBytes,yBytes) that captures nothing and performs the following steps atomically when called:- Return
ByteListBitwiseOp (&,xBytes,yBytes).
- Return
- Return ?
AtomicReadModifyWrite (typedArray,index,value,and).
25.4.4 Atomics.compareExchange (typedArray,index,expectedValue,replacementValue )
The following steps are taken:
- Letbuffer be ?
ValidateIntegerTypedArray (typedArray). - Letblock bebuffer.[[ArrayBufferData]].
- LetindexedPosition be ?
ValidateAtomicAccess (typedArray,index). - LetarrayTypeName betypedArray.[[TypedArrayName]].
- IftypedArray.[[ContentType]] is
BigInt , then - Else,
- Letexpected be
𝔽 (?ToIntegerOrInfinity (expectedValue)). - Letreplacement be
𝔽 (?ToIntegerOrInfinity (replacementValue)).
- Letexpected be
- If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - NOTE: The above check is not redundant with the check in
ValidateIntegerTypedArray because the call toToBigInt orToIntegerOrInfinity on the preceding lines can have arbitrary side effects, which could cause the buffer to become detached. - LetelementType be the Element Type value in
Table 60 forarrayTypeName. - LetelementSize be the Element Size value specified in
Table 60 for Element TypeelementType. - LetisLittleEndian be the value of the [[LittleEndian]] field of the
surrounding agent 'sAgent Record . - LetexpectedBytes be
NumericToRawBytes (elementType,expected,isLittleEndian). - LetreplacementBytes be
NumericToRawBytes (elementType,replacement,isLittleEndian). - If
IsSharedArrayBuffer (buffer) istrue , then- Letexecution be the [[CandidateExecution]] field of the
surrounding agent 'sAgent Record . - LeteventList be the [[EventList]] field of the element inexecution.[[EventsRecords]] whose [[AgentSignifier]] is
AgentSignifier (). - LetrawBytesRead be a
List of lengthelementSize whose elements are nondeterministically chosen byte values. - NOTE: In implementations,rawBytesRead is the result of a load-link, of a load-exclusive, or of an operand of a read-modify-write instruction on the underlying hardware. The nondeterminism is a semantic prescription of the
memory model to describe observable behaviour of hardware with weak consistency. - NOTE: The comparison of the expected value and the read value is performed outside of the
read-modify-write modification function to avoid needlessly strong synchronization when the expected value is not equal to the read value. - If
ByteListEqual (rawBytesRead,expectedBytes) istrue , then- Letsecond be a new
read-modify-write modification function with parameters (oldBytes,newBytes) that captures nothing and performs the following steps atomically when called:- ReturnnewBytes.
- Letevent be
ReadModifyWriteSharedMemory { [[Order]]:SeqCst , [[NoTear]]:true , [[Block]]:block, [[ByteIndex]]:indexedPosition, [[ElementSize]]:elementSize, [[Payload]]:replacementBytes, [[ModifyOp]]:second }.
- Letsecond be a new
- Else,
- Letevent be
ReadSharedMemory { [[Order]]:SeqCst , [[NoTear]]:true , [[Block]]:block, [[ByteIndex]]:indexedPosition, [[ElementSize]]:elementSize }.
- Letevent be
- Appendevent toeventList.
- Append
Chosen Value Record { [[Event]]:event, [[ChosenValue]]:rawBytesRead } toexecution.[[ChosenValues]].
- Letexecution be the [[CandidateExecution]] field of the
- Else,
- LetrawBytesRead be a
List of lengthelementSize whose elements are the sequence ofelementSize bytes starting withblock[indexedPosition]. - If
ByteListEqual (rawBytesRead,expectedBytes) istrue , then- Store the individual bytes ofreplacementBytes intoblock, starting atblock[indexedPosition].
- LetrawBytesRead be a
- Return
RawBytesToNumeric (elementType,rawBytesRead,isLittleEndian).
25.4.5 Atomics.exchange (typedArray,index,value )
The following steps are taken:
- Letsecond be a new
read-modify-write modification function with parameters (oldBytes,newBytes) that captures nothing and performs the following steps atomically when called:- ReturnnewBytes.
- Return ?
AtomicReadModifyWrite (typedArray,index,value,second).
25.4.6 Atomics.isLockFree (size )
The following steps are taken:
- Letn be ?
ToIntegerOrInfinity (size). - LetAR be the
Agent Record of thesurrounding agent . - Ifn = 1, returnAR.[[IsLockFree1]].
- Ifn = 2, returnAR.[[IsLockFree2]].
- Ifn = 4, return
true . - Ifn = 8, returnAR.[[IsLockFree8]].
- Return
false .
Atomics.isLockFree() is an optimization primitive. The intuition is that if the atomic step of an atomic primitive (compareExchange,load,store,add,sub,and,or,xor, orexchange) on a datum of sizen bytes will be performed without the callingAtomics.isLockFree(n) will returnAtomics.isLockFree to determine whether to use locks or atomic operations in critical sections. If an atomic primitive is not lock-free then it is often more efficient for an algorithm to provide its own locking.
Atomics.isLockFree(4) always returns
Regardless of the value ofAtomics.isLockFree, all atomic operations are guaranteed to be atomic. For example, they will never have a visible operation take place in the middle of the operation (e.g., "tearing").
25.4.7 Atomics.load (typedArray,index )
The following steps are taken:
- Letbuffer be ?
ValidateIntegerTypedArray (typedArray). - LetindexedPosition be ?
ValidateAtomicAccess (typedArray,index). - If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - NOTE: The above check is not redundant with the check in
ValidateIntegerTypedArray because the call toValidateAtomicAccess on the preceding line can have arbitrary side effects, which could cause the buffer to become detached. - LetarrayTypeName betypedArray.[[TypedArrayName]].
- LetelementType be the Element Type value in
Table 60 forarrayTypeName. - Return
GetValueFromBuffer (buffer,indexedPosition,elementType,true ,SeqCst ).
25.4.8 Atomics.or (typedArray,index,value )
The following steps are taken:
- Letor be a new
read-modify-write modification function with parameters (xBytes,yBytes) that captures nothing and performs the following steps atomically when called:- Return
ByteListBitwiseOp (|,xBytes,yBytes).
- Return
- Return ?
AtomicReadModifyWrite (typedArray,index,value,or).
25.4.9 Atomics.store (typedArray,index,value )
The following steps are taken:
- Letbuffer be ?
ValidateIntegerTypedArray (typedArray). - LetindexedPosition be ?
ValidateAtomicAccess (typedArray,index). - LetarrayTypeName betypedArray.[[TypedArrayName]].
- IfarrayTypeName is
"BigUint64Array" or"BigInt64Array" , letv be ?ToBigInt (value). - Otherwise, letv be
𝔽 (?ToIntegerOrInfinity (value)). - If
IsDetachedBuffer (buffer) istrue , throw aTypeError exception. - NOTE: The above check is not redundant with the check in
ValidateIntegerTypedArray because the call toToBigInt orToIntegerOrInfinity on the preceding lines can have arbitrary side effects, which could cause the buffer to become detached. - LetelementType be the Element Type value in
Table 60 forarrayTypeName. - Perform
SetValueInBuffer (buffer,indexedPosition,elementType,v,true ,SeqCst ). - Returnv.
25.4.10 Atomics.sub (typedArray,index,value )
The following steps are taken:
- Lettype be the Element Type value in
Table 60 fortypedArray.[[TypedArrayName]]. - LetisLittleEndian be the value of the [[LittleEndian]] field of the
surrounding agent 'sAgent Record . - Letsubtract be a new
read-modify-write modification function with parameters (xBytes,yBytes) that capturestype andisLittleEndian and performs the following steps atomically when called:- Letx be
RawBytesToNumeric (type,xBytes,isLittleEndian). - Lety be
RawBytesToNumeric (type,yBytes,isLittleEndian). - LetT be
Type (x). - Letdifference beT::subtract(x,y).
- LetdifferenceBytes be
NumericToRawBytes (type,difference,isLittleEndian). Assert :differenceBytes,xBytes, andyBytes have the same number of elements.- ReturndifferenceBytes.
- Letx be
- Return ?
AtomicReadModifyWrite (typedArray,index,value,subtract).
25.4.11 Atomics.wait (typedArray,index,value,timeout )
Atomics.wait puts the calling
- Letbuffer be ?
ValidateIntegerTypedArray (typedArray,true ). - If
IsSharedArrayBuffer (buffer) isfalse , throw aTypeError exception. - LetindexedPosition be ?
ValidateAtomicAccess (typedArray,index). - LetarrayTypeName betypedArray.[[TypedArrayName]].
- IfarrayTypeName is
"BigInt64Array" , letv be ?ToBigInt64 (value). - Otherwise, letv be ?
ToInt32 (value). - Letq be ?
ToNumber (timeout). - Ifq is
NaN or+∞ 𝔽, lett be +∞; else ifq is-∞ 𝔽, lett be 0; else lett bemax (ℝ (q), 0). - LetB be
AgentCanSuspend (). - IfB is
false , throw aTypeError exception. - Letblock bebuffer.[[ArrayBufferData]].
- LetWL be
GetWaiterList (block,indexedPosition). - Perform
EnterCriticalSection (WL). - LetelementType be the Element Type value in
Table 60 forarrayTypeName. - Letw be !
GetValueFromBuffer (buffer,indexedPosition,elementType,true ,SeqCst ). - Ifv ≠w, then
- Perform
LeaveCriticalSection (WL). - Return the String
"not-equal" .
- Perform
- LetW be
AgentSignifier (). - Perform
AddWaiter (WL,W). - Letnotified be
SuspendAgent (WL,W,t). - Ifnotified is
true , thenAssert :W is not on the list of waiters inWL.
- Else,
- Perform
RemoveWaiter (WL,W).
- Perform
- Perform
LeaveCriticalSection (WL). - Ifnotified is
true , return the String"ok" . - Return the String
"timed-out" .
25.4.12 Atomics.notify (typedArray,index,count )
Atomics.notify notifies some agents that are sleeping in the wait queue. The following steps are taken:
- Letbuffer be ?
ValidateIntegerTypedArray (typedArray,true ). - LetindexedPosition be ?
ValidateAtomicAccess (typedArray,index). - Ifcount is
undefined , letc be +∞. - Else,
- LetintCount be ?
ToIntegerOrInfinity (count). - Letc be
max (intCount, 0).
- LetintCount be ?
- Letblock bebuffer.[[ArrayBufferData]].
- LetarrayTypeName betypedArray.[[TypedArrayName]].
- If
IsSharedArrayBuffer (buffer) isfalse , return+0 𝔽. - LetWL be
GetWaiterList (block,indexedPosition). - Letn be 0.
- Perform
EnterCriticalSection (WL). - LetS be
RemoveWaiters (WL,c). - Repeat, whileS is not an empty
List ,- LetW be the first
agent inS. - RemoveW from the front ofS.
- Perform
NotifyWaiter (WL,W). - Setn ton + 1.
- LetW be the first
- Perform
LeaveCriticalSection (WL). - Return
𝔽 (n).
25.4.13 Atomics.xor (typedArray,index,value )
The following steps are taken:
- Letxor be a new
read-modify-write modification function with parameters (xBytes,yBytes) that captures nothing and performs the following steps atomically when called:- Return
ByteListBitwiseOp (^,xBytes,yBytes).
- Return
- Return ?
AtomicReadModifyWrite (typedArray,index,value,xor).
25.4.14 Atomics [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
25.5 The JSON Object
The JSON object:
- is%JSON%.
- is the initial value of the
"JSON" property of theglobal object . - is an
ordinary object . - contains two functions,
parseandstringify, that are used to parse and construct JSON texts. - has a [[Prototype]] internal slot whose value is
%Object.prototype% . - does not have a [[Construct]] internal method; it cannot be used as a
constructor with thenewoperator. - does not have a [[Call]] internal method; it cannot be invoked as a function.
The JSON Data Interchange Format is defined in ECMA-404. The JSON interchange format used in this specification is exactly that described by ECMA-404. Conforming implementations ofJSON.parse andJSON.stringify must support the exact interchange format described in the ECMA-404 specification without any deletions or extensions to the format.
25.5.1 JSON.parse (text [ ,reviver ] )
Theparse function parses a JSON text (a JSON-formatted String) and produces an ECMAScript value. The JSON format represents literals, arrays, and objects with a syntax similar to the syntax for ECMAScript literals, Array Initializers, and Object Initializers. After parsing, JSON objects are realized as ECMAScript objects. JSON arrays are realized as ECMAScript Array instances. JSON strings, numbers, booleans, and null are realized as ECMAScript Strings, Numbers, Booleans, and
The optionalreviver parameter is a function that takes two parameters,key andvalue. It can filter and transform the results. It is called with each of thekey/value pairs produced by the parse, and its return value is used instead of the original value. If it returns what it received, the structure is not modified. If it returns
- LetjsonString be ?
ToString (text). - Parse !
StringToCodePoints (jsonString) as a JSON text as specified in ECMA-404. Throw aSyntaxError exception if it is not a valid JSON text as defined in that specification. - LetscriptString be the
string-concatenation of"(" ,jsonString, and");" . - Letscript be
ParseText (!StringToCodePoints (scriptString),Script ). Assert :script is aParse Node .- Letcompletion be the result of evaluatingscript. The extended
PropertyDefinitionEvaluation semantics defined inB.3.1 must not be used during the evaluation. - Letunfiltered becompletion.[[Value]].
Assert :unfiltered is either a String, Number, Boolean, Null, or an Object that is defined by either anArrayLiteral or anObjectLiteral .- If
IsCallable (reviver) istrue , then- Letroot be !
OrdinaryObjectCreate (%Object.prototype% ). - LetrootName be the empty String.
- Perform !
CreateDataPropertyOrThrow (root,rootName,unfiltered). - Return ?
InternalizeJSONProperty (root,rootName,reviver).
- Letroot be !
- Else,
- Returnunfiltered.
Theparse function is
Valid JSON text is a subset of the ECMAScript
However, becauseJSON.parse, the same source text can produce different results when evaluated as aJSON.parse, means that not all texts accepted byJSON.parse are valid as a
25.5.1.1 InternalizeJSONProperty (holder,name,reviver )
The abstract operation InternalizeJSONProperty takes argumentsholder (an Object),name (a String), andreviver (a
This algorithm intentionally does not throw an exception if either [[Delete]] or
- Letval be ?
Get (holder,name). - If
Type (val) is Object, then- LetisArray be ?
IsArray (val). - IfisArray is
true , then- LetI be 0.
- Letlen be ?
LengthOfArrayLike (val). - Repeat, whileI <len,
- Letprop be !
ToString (𝔽 (I)). - LetnewElement be ?
InternalizeJSONProperty (val,prop,reviver). - IfnewElement is
undefined , then- Perform ?val.[[Delete]](prop).
- Else,
- Perform ?
CreateDataProperty (val,prop,newElement).
- Perform ?
- SetI toI + 1.
- Letprop be !
- Else,
- Letkeys be ?
EnumerableOwnPropertyNames (val,key ). - For each StringP ofkeys, do
- LetnewElement be ?
InternalizeJSONProperty (val,P,reviver). - IfnewElement is
undefined , then- Perform ?val.[[Delete]](P).
- Else,
- Perform ?
CreateDataProperty (val,P,newElement).
- Perform ?
- LetnewElement be ?
- Letkeys be ?
- LetisArray be ?
- Return ?
Call (reviver,holder, «name,val »).
It is not permitted for a conforming implementation ofJSON.parse to extend the JSON grammars. If an implementation wishes to support a modified or extended JSON interchange format it must do so by defining a different parse function.
In the case where there are duplicate name Strings within an object, lexically preceding values for the same key shall be overwritten.
25.5.2 JSON.stringify (value [ ,replacer [ ,space ] ] )
Thestringify function returns a String in UTF-16 encoded JSON format representing an ECMAScript value, or
These are the steps in stringifying an object:
- Letstack be a new empty
List . - Letindent be the empty String.
- LetPropertyList andReplacerFunction be
undefined . - If
Type (replacer) is Object, then- If
IsCallable (replacer) istrue , then- SetReplacerFunction toreplacer.
- Else,
- LetisArray be ?
IsArray (replacer). - IfisArray is
true , then- SetPropertyList to a new empty
List . - Letlen be ?
LengthOfArrayLike (replacer). - Letk be 0.
- Repeat, whilek <len,
- Letprop be !
ToString (𝔽 (k)). - Letv be ?
Get (replacer,prop). - Letitem be
undefined . - If
Type (v) is String, setitem tov. - Else if
Type (v) is Number, setitem to !ToString (v). - Else if
Type (v) is Object, then- Ifv has a [[StringData]] or [[NumberData]] internal slot, setitem to ?
ToString (v).
- Ifv has a [[StringData]] or [[NumberData]] internal slot, setitem to ?
- Ifitem is not
undefined anditem is not currently an element ofPropertyList, then- Appenditem to the end ofPropertyList.
- Setk tok + 1.
- Letprop be !
- SetPropertyList to a new empty
- LetisArray be ?
- If
- If
Type (space) is Object, then - If
Type (space) is Number, then- LetspaceMV be !
ToIntegerOrInfinity (space). - SetspaceMV to
min (10,spaceMV). - IfspaceMV < 1, letgap be the empty String; otherwise letgap be the String value containingspaceMV occurrences of the code unit 0x0020 (SPACE).
- LetspaceMV be !
- Else if
Type (space) is String, then- If the length ofspace is 10 or less, letgap bespace; otherwise letgap be the
substring ofspace from 0 to 10.
- If the length ofspace is 10 or less, letgap bespace; otherwise letgap be the
- Else,
- Letgap be the empty String.
- Letwrapper be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform !
CreateDataPropertyOrThrow (wrapper, the empty String,value). - Letstate be the
Record { [[ReplacerFunction]]:ReplacerFunction, [[Stack]]:stack, [[Indent]]:indent, [[Gap]]:gap, [[PropertyList]]:PropertyList }. - Return ?
SerializeJSONProperty (state, the empty String,wrapper).
Thestringify function is
JSON structures are allowed to be nested to any depth, but they must be acyclic. Ifvalue is or contains a cyclic structure, then the stringify function must throw a
a = [];a[0] = a;my_text =JSON.stringify(a);// This must throw a TypeError.Symbolic primitive values are rendered as follows:
- The
null value is rendered in JSON text as the String"null" . - The
undefined value is not rendered. - The
true value is rendered in JSON text as the String"true" . - The
false value is rendered in JSON text as the String"false" .
String values are wrapped in QUOTATION MARK (") code units. The code units" and\ are escaped with\ prefixes. Control characters code units are replaced with escape sequences\uHHHH, or with the shorter forms,\b (BACKSPACE),\f (FORM FEED),\n (LINE FEED),\r (CARRIAGE RETURN),\t (CHARACTER TABULATION).
Finite numbers are stringified as if by calling
Values that do not have a JSON representation (such as
An object is rendered as U+007B (LEFT CURLY BRACKET) followed by zero or more properties, separated with a U+002C (COMMA), closed with a U+007D (RIGHT CURLY BRACKET). A property is a quoted String representing the key or
25.5.2.1 SerializeJSONProperty (state,key,holder )
The abstract operation SerializeJSONProperty takes argumentsstate,key, andholder. It performs the following steps when called:
- Letvalue be ?
Get (holder,key). - If
Type (value) is Object or BigInt, then- LettoJSON be ?
GetV (value,"toJSON" ). - If
IsCallable (toJSON) istrue , then- Setvalue to ?
Call (toJSON,value, «key »).
- Setvalue to ?
- LettoJSON be ?
- Ifstate.[[ReplacerFunction]] is not
undefined , then- Setvalue to ?
Call (state.[[ReplacerFunction]],holder, «key,value »).
- Setvalue to ?
- If
Type (value) is Object, then- Ifvalue has a [[NumberData]] internal slot, then
- Setvalue to ?
ToNumber (value).
- Setvalue to ?
- Else ifvalue has a [[StringData]] internal slot, then
- Setvalue to ?
ToString (value).
- Setvalue to ?
- Else ifvalue has a [[BooleanData]] internal slot, then
- Setvalue tovalue.[[BooleanData]].
- Else ifvalue has a [[BigIntData]] internal slot, then
- Setvalue tovalue.[[BigIntData]].
- Ifvalue has a [[NumberData]] internal slot, then
- Ifvalue is
null , return"null" . - Ifvalue is
true , return"true" . - Ifvalue is
false , return"false" . - If
Type (value) is String, returnQuoteJSONString (value). - If
Type (value) is Number, then- Ifvalue is finite, return !
ToString (value). - Return
"null" .
- Ifvalue is finite, return !
- If
Type (value) is BigInt, throw aTypeError exception. - If
Type (value) is Object andIsCallable (value) isfalse , then- LetisArray be ?
IsArray (value). - IfisArray is
true , return ?SerializeJSONArray (state,value). - Return ?
SerializeJSONObject (state,value).
- LetisArray be ?
- Return
undefined .
25.5.2.2 QuoteJSONString (value )
The abstract operation QuoteJSONString takes argumentvalue. It wrapsvalue in 0x0022 (QUOTATION MARK) code units and escapes certain other code units within it. This operation interpretsvalue as a sequence of UTF-16 encoded code points, as described in
- Letproduct be the String value consisting solely of the code unit 0x0022 (QUOTATION MARK).
- For each code pointC of !
StringToCodePoints (value), do- IfC is listed in the “Code Point” column of
Table 61 , then- Setproduct to the
string-concatenation ofproduct and the escape sequence forC as specified in the “Escape Sequence” column of the corresponding row.
- Setproduct to the
- Else ifC has a numeric value less than 0x0020 (SPACE), or ifC has the same numeric value as a
leading surrogate ortrailing surrogate , then- Letunit be the code unit whose numeric value is that ofC.
- Setproduct to the
string-concatenation ofproduct andUnicodeEscape (unit).
- Else,
- Setproduct to the
string-concatenation ofproduct and !UTF16EncodeCodePoint (C).
- Setproduct to the
- IfC is listed in the “Code Point” column of
- Setproduct to the
string-concatenation ofproduct and the code unit 0x0022 (QUOTATION MARK). - Returnproduct.
| Code Point | Unicode Character Name | Escape Sequence |
|---|---|---|
| U+0008 | BACKSPACE | \b |
| U+0009 | CHARACTER TABULATION | \t |
| U+000A | LINE FEED (LF) | \n |
| U+000C | FORM FEED (FF) | \f |
| U+000D | CARRIAGE RETURN (CR) | \r |
| U+0022 | QUOTATION MARK | \" |
| U+005C | REVERSE SOLIDUS | \\ |
25.5.2.3 UnicodeEscape (C )
The abstract operation UnicodeEscape takes argumentC (a code unit). It representsC as a Unicode escape sequence. It performs the following steps when called:
- Letn be the numeric value ofC.
Assert :n ≤ 0xFFFF.- Return the
string-concatenation of:- the code unit 0x005C (REVERSE SOLIDUS)
"u" - the String representation ofn, formatted as a four-digit lowercase hexadecimal number, padded to the left with zeroes if necessary
25.5.2.4 SerializeJSONObject (state,value )
The abstract operation SerializeJSONObject takes argumentsstate andvalue. It serializes an object. It performs the following steps when called:
- Ifstate.[[Stack]] containsvalue, throw a
TypeError exception because the structure is cyclical. - Appendvalue tostate.[[Stack]].
- Letstepback bestate.[[Indent]].
- Setstate.[[Indent]] to the
string-concatenation ofstate.[[Indent]] andstate.[[Gap]]. - Ifstate.[[PropertyList]] is not
undefined , then- LetK bestate.[[PropertyList]].
- Else,
- LetK be ?
EnumerableOwnPropertyNames (value,key ).
- LetK be ?
- Letpartial be a new empty
List . - For each elementP ofK, do
- LetstrP be ?
SerializeJSONProperty (state,P,value). - IfstrP is not
undefined , then- Letmember be
QuoteJSONString (P). - Setmember to the
string-concatenation ofmember and":" . - Ifstate.[[Gap]] is not the empty String, then
- Setmember to the
string-concatenation ofmember and the code unit 0x0020 (SPACE).
- Setmember to the
- Setmember to the
string-concatenation ofmember andstrP. - Appendmember topartial.
- Letmember be
- LetstrP be ?
- Ifpartial is empty, then
- Letfinal be
"{}" .
- Letfinal be
- Else,
- Ifstate.[[Gap]] is the empty String, then
- Letproperties be the String value formed by concatenating all the element Strings ofpartial with each adjacent pair of Strings separated with the code unit 0x002C (COMMA). A comma is not inserted either before the first String or after the last String.
- Letfinal be the
string-concatenation of"{" ,properties, and"}" .
- Else,
- Letseparator be the
string-concatenation of the code unit 0x002C (COMMA), the code unit 0x000A (LINE FEED), andstate.[[Indent]]. - Letproperties be the String value formed by concatenating all the element Strings ofpartial with each adjacent pair of Strings separated withseparator. Theseparator String is not inserted either before the first String or after the last String.
- Letfinal be the
string-concatenation of"{" , the code unit 0x000A (LINE FEED),state.[[Indent]],properties, the code unit 0x000A (LINE FEED),stepback, and"}" .
- Letseparator be the
- Ifstate.[[Gap]] is the empty String, then
- Remove the last element ofstate.[[Stack]].
- Setstate.[[Indent]] tostepback.
- Returnfinal.
25.5.2.5 SerializeJSONArray (state,value )
The abstract operation SerializeJSONArray takes argumentsstate andvalue. It serializes an array. It performs the following steps when called:
- Ifstate.[[Stack]] containsvalue, throw a
TypeError exception because the structure is cyclical. - Appendvalue tostate.[[Stack]].
- Letstepback bestate.[[Indent]].
- Setstate.[[Indent]] to the
string-concatenation ofstate.[[Indent]] andstate.[[Gap]]. - Letpartial be a new empty
List . - Letlen be ?
LengthOfArrayLike (value). - Letindex be 0.
- Repeat, whileindex <len,
- LetstrP be ?
SerializeJSONProperty (state, !ToString (𝔽 (index)),value). - IfstrP is
undefined , then- Append
"null" topartial.
- Append
- Else,
- AppendstrP topartial.
- Setindex toindex + 1.
- LetstrP be ?
- Ifpartial is empty, then
- Letfinal be
"[]" .
- Letfinal be
- Else,
- Ifstate.[[Gap]] is the empty String, then
- Letproperties be the String value formed by concatenating all the element Strings ofpartial with each adjacent pair of Strings separated with the code unit 0x002C (COMMA). A comma is not inserted either before the first String or after the last String.
- Letfinal be the
string-concatenation of"[" ,properties, and"]" .
- Else,
- Letseparator be the
string-concatenation of the code unit 0x002C (COMMA), the code unit 0x000A (LINE FEED), andstate.[[Indent]]. - Letproperties be the String value formed by concatenating all the element Strings ofpartial with each adjacent pair of Strings separated withseparator. Theseparator String is not inserted either before the first String or after the last String.
- Letfinal be the
string-concatenation of"[" , the code unit 0x000A (LINE FEED),state.[[Indent]],properties, the code unit 0x000A (LINE FEED),stepback, and"]" .
- Letseparator be the
- Ifstate.[[Gap]] is the empty String, then
- Remove the last element ofstate.[[Stack]].
- Setstate.[[Indent]] tostepback.
- Returnfinal.
The representation of arrays includes only the elements between zero andarray.length - 1
25.5.3 JSON [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
26 Managing Memory
26.1 WeakRef Objects
A
26.1.1 The WeakRef Constructor
TheWeakRef
- is%WeakRef%.
- is the initial value of the
"WeakRef" property of theglobal object . - creates and initializes a new WeakRef object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specifiedWeakRefbehaviour must include asupercall to theWeakRefconstructor to create and initialize the subclass instance with the internal state necessary to support theWeakRef.prototypebuilt-in methods.
26.1.1.1 WeakRef (target )
When theWeakRef function is called with argumenttarget, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - If
Type (target) is not Object, throw aTypeError exception. - LetweakRef be ?
OrdinaryCreateFromConstructor (NewTarget,"%WeakRef.prototype%" , « [[WeakRefTarget]] »). - Perform !
AddToKeptObjects (target). - SetweakRef.[[WeakRefTarget]] totarget.
- ReturnweakRef.
26.1.2 Properties of the WeakRef Constructor
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
26.1.2.1 WeakRef.prototype
The initial value ofWeakRef.prototype is the
This property has the attributes { [[Writable]]:
26.1.3 Properties of the WeakRef Prototype Object
TheWeakRef prototype object:
- is%WeakRef.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[WeakRefTarget]] internal slot.
26.1.3.1 WeakRef.prototype.constructor
The initial value ofWeakRef.prototype.constructor is
This property has the attributes { [[Writable]]:
26.1.3.2 WeakRef.prototype.deref ( )
The following steps are taken:
- LetweakRef be the
this value. - Perform ?
RequireInternalSlot (weakRef, [[WeakRefTarget]]). - Return !
WeakRefDeref (weakRef).
If the
target = {foo:function(){} };let weakRef =new WeakRef(target);... later ...if (weakRef.deref()) { weakRef.deref().foo();}In the above example, if the first deref does not evaluate to
26.1.3.3 WeakRef.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
26.1.4 WeakRef Abstract Operations
26.1.4.1 WeakRefDeref (weakRef )
The abstract operation WeakRefDeref takes argumentweakRef (a
- Lettarget beweakRef.[[WeakRefTarget]].
- Iftarget is not
empty , then- Perform !
AddToKeptObjects (target). - Returntarget.
- Perform !
- Return
undefined .
This abstract operation is defined separately from WeakRef.prototype.deref strictly to make it possible to succinctly define liveness.
26.1.5 Properties of WeakRef Instances
26.2 FinalizationRegistry Objects
A
26.2.1 The FinalizationRegistry Constructor
TheFinalizationRegistry
- is%FinalizationRegistry%.
- is the initial value of the
"FinalizationRegistry" property of theglobal object . - creates and initializes a new FinalizationRegistry object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specifiedFinalizationRegistrybehaviour must include asupercall to theFinalizationRegistryconstructor to create and initialize the subclass instance with the internal state necessary to support theFinalizationRegistry.prototypebuilt-in methods.
26.2.1.1 FinalizationRegistry (cleanupCallback )
When theFinalizationRegistry function is called with argumentcleanupCallback, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - If
IsCallable (cleanupCallback) isfalse , throw aTypeError exception. - LetfinalizationRegistry be ?
OrdinaryCreateFromConstructor (NewTarget,"%FinalizationRegistry.prototype%" , « [[Realm]], [[CleanupCallback]], [[Cells]] »). - Letfn be the
active function object . - SetfinalizationRegistry.[[Realm]] tofn.[[Realm]].
- SetfinalizationRegistry.[[CleanupCallback]] tocleanupCallback.
- SetfinalizationRegistry.[[Cells]] to a new empty
List . - ReturnfinalizationRegistry.
26.2.2 Properties of the FinalizationRegistry Constructor
The
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
26.2.2.1 FinalizationRegistry.prototype
The initial value ofFinalizationRegistry.prototype is the
This property has the attributes { [[Writable]]:
26.2.3 Properties of the FinalizationRegistry Prototype Object
TheFinalizationRegistry prototype object:
- is%FinalizationRegistry.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have [[Cells]] and [[CleanupCallback]] internal slots.
26.2.3.1 FinalizationRegistry.prototype.constructor
The initial value ofFinalizationRegistry.prototype.constructor is
26.2.3.2 FinalizationRegistry.prototype.register (target,heldValue [ ,unregisterToken ] )
The following steps are taken:
- LetfinalizationRegistry be the
this value. - Perform ?
RequireInternalSlot (finalizationRegistry, [[Cells]]). - If
Type (target) is not Object, throw aTypeError exception. - If
SameValue (target,heldValue) istrue , throw aTypeError exception. - If
Type (unregisterToken) is not Object, then- IfunregisterToken is not
undefined , throw aTypeError exception. - SetunregisterToken to
empty .
- IfunregisterToken is not
- Letcell be the
Record { [[WeakRefTarget]]:target, [[HeldValue]]:heldValue, [[UnregisterToken]]:unregisterToken }. - Appendcell tofinalizationRegistry.[[Cells]].
- Return
undefined .
Based on the algorithms and definitions in this specification,cell.[[HeldValue]] is
26.2.3.3 FinalizationRegistry.prototype.unregister (unregisterToken )
The following steps are taken:
- LetfinalizationRegistry be the
this value. - Perform ?
RequireInternalSlot (finalizationRegistry, [[Cells]]). - If
Type (unregisterToken) is not Object, throw aTypeError exception. - Letremoved be
false . - For each
Record { [[WeakRefTarget]], [[HeldValue]], [[UnregisterToken]] }cell offinalizationRegistry.[[Cells]], do- Ifcell.[[UnregisterToken]] is not
empty andSameValue (cell.[[UnregisterToken]],unregisterToken) istrue , then- Removecell fromfinalizationRegistry.[[Cells]].
- Setremoved to
true .
- Ifcell.[[UnregisterToken]] is not
- Returnremoved.
26.2.3.4 FinalizationRegistry.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
26.2.4 Properties of FinalizationRegistry Instances
27 Control Abstraction Objects
27.1 Iteration
27.1.1 Common Iteration Interfaces
An interface is a set of property keys whose associated values match a specific specification. Any object that provides all the properties as described by an interface's specificationconforms to that interface. An interface is not represented by a distinct object. There may be many separately implemented objects that conform to any interface. An individual object may conform to multiple interfaces.
27.1.1.1 TheIterable Interface
TheIterable interface includes the property described in
| Property | Value | Requirements |
|---|---|---|
@@iterator | A function that returns anIterator object. | The returned object must conform to theIterator interface. |
27.1.1.2 TheIterator Interface
An object that implements theIterator interface must include the property in
| Property | Value | Requirements |
|---|---|---|
| A function that returns anIteratorResult object. | The returned object must conform to theIteratorResult interface. If a previous call to thenext method of anIterator has returned anIteratorResult object whosenext method of that object should also return anIteratorResult object whose |
Arguments may be passed to thenext function but their interpretation and validity is dependent upon the targetIterator. The for-of statement and other common users ofIterators do not pass any arguments, soIterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.
| Property | Value | Requirements |
|---|---|---|
| A function that returns anIteratorResult object. | The returned object must conform to theIteratorResult interface. Invoking this method notifies theIterator object that the caller does not intend to make any morenext method calls to theIterator. The returnedIteratorResult object will typically have areturn method. However, this requirement is not enforced. | |
| A function that returns anIteratorResult object. | The returned object must conform to theIteratorResult interface. Invoking this method notifies theIterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an exception object. A typical response is tothrow the value passed as the argument. If the method does notthrow, the returnedIteratorResult object will typically have a |
Typically callers of these methods should check for their existence before invoking them. Certain ECMAScript language features includingfor-of,yield*, and array destructuring call these methods after performing an existence check. Most ECMAScript library functions that acceptIterable objects as arguments also conditionally call them.
27.1.1.3 TheAsyncIterable Interface
TheAsyncIterable interface includes the properties described in
| Property | Value | Requirements |
|---|---|---|
@@asyncIterator | A function that returns anAsyncIterator object. | The returned object must conform to theAsyncIterator interface. |
27.1.1.4 TheAsyncIterator Interface
An object that implements theAsyncIterator interface must include the properties in
| Property | Value | Requirements |
|---|---|---|
| A function that returns a promise for anIteratorResult object. | The returned promise, when fulfilled, must fulfill with an object which conforms to theIteratorResult interface. If a previous call to the Additionally, theIteratorResult object that serves as a fulfillment value should have a |
Arguments may be passed to thenext function but their interpretation and validity is dependent upon the targetAsyncIterator. Thefor-await-of statement and other common users ofAsyncIterators do not pass any arguments, soAsyncIterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.
| Property | Value | Requirements |
|---|---|---|
| A function that returns a promise for anIteratorResult object. | The returned promise, when fulfilled, must fulfill with an object which conforms to theIteratorResult interface. Invoking this method notifies theAsyncIterator object that the caller does not intend to make any more Additionally, theIteratorResult object that serves as a fulfillment value should have a | |
| A function that returns a promise for anIteratorResult object. | The returned promise, when fulfilled, must fulfill with an object which conforms to theIteratorResult interface. Invoking this method notifies theAsyncIterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an exception object. A typical response is to return a rejected promise which rejects with the value passed as the argument. If the returned promise is fulfilled, theIteratorResult fulfillment value will typically have a |
Typically callers of these methods should check for their existence before invoking them. Certain ECMAScript language features includingfor-await-of andyield* call these methods after performing an existence check.
27.1.1.5 TheIteratorResult Interface
TheIteratorResult interface includes the properties listed in
| Property | Value | Requirements |
|---|---|---|
| Either | This is the result status of aniteratornext method call. If the end of the iterator was reached | |
| Any | If done is |
27.1.2 The %IteratorPrototype% Object
The%IteratorPrototype% object:
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object .
All objects defined in this specification that implement the Iterator interface also inherit from %IteratorPrototype%. ECMAScript code may also define objects that inherit from %IteratorPrototype%. The %IteratorPrototype% object provides a place where additional methods that are applicable to all iterator objects may be added.
The following expression is one way that ECMAScript code can access the %IteratorPrototype% object:
Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))27.1.2.1 %IteratorPrototype% [ @@iterator ] ( )
The following steps are taken:
- Return the
this value.
The value of the
27.1.3 The %AsyncIteratorPrototype% Object
The%AsyncIteratorPrototype% object:
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object .
All objects defined in this specification that implement the AsyncIterator interface also inherit from %AsyncIteratorPrototype%. ECMAScript code may also define objects that inherit from %AsyncIteratorPrototype%. The %AsyncIteratorPrototype% object provides a place where additional methods that are applicable to all async iterator objects may be added.
27.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )
The following steps are taken:
- Return the
this value.
The value of the
27.1.4 Async-from-Sync Iterator Objects
An Async-from-Sync Iterator object is an async iterator that adapts a specific synchronous iterator. There is not a named
27.1.4.1 CreateAsyncFromSyncIterator (syncIteratorRecord )
The abstract operation CreateAsyncFromSyncIterator takes argumentsyncIteratorRecord. It is used to create an async iterator
- LetasyncIterator be !
OrdinaryObjectCreate (%AsyncFromSyncIteratorPrototype% , « [[SyncIteratorRecord]] »). - SetasyncIterator.[[SyncIteratorRecord]] tosyncIteratorRecord.
- LetnextMethod be !
Get (asyncIterator,"next" ). - LetiteratorRecord be the
Record { [[Iterator]]:asyncIterator, [[NextMethod]]:nextMethod, [[Done]]:false }. - ReturniteratorRecord.
27.1.4.2 The %AsyncFromSyncIteratorPrototype% Object
The%AsyncFromSyncIteratorPrototype% object:
- has properties that are inherited by all Async-from-Sync Iterator Objects.
- is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%AsyncIteratorPrototype% . - has the following properties:
27.1.4.2.1 %AsyncFromSyncIteratorPrototype%.next ( [value ] )
- LetO be the
this value. Assert :Type (O) is Object andO has a [[SyncIteratorRecord]] internal slot.- LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - LetsyncIteratorRecord beO.[[SyncIteratorRecord]].
- Ifvalue is present, then
- Letresult be
IteratorNext (syncIteratorRecord,value).
- Letresult be
- Else,
- Letresult be
IteratorNext (syncIteratorRecord).
- Letresult be
IfAbruptRejectPromise (result,promiseCapability).- Return !
AsyncFromSyncIteratorContinuation (result,promiseCapability).
27.1.4.2.2 %AsyncFromSyncIteratorPrototype%.return ( [value ] )
- LetO be the
this value. Assert :Type (O) is Object andO has a [[SyncIteratorRecord]] internal slot.- LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - LetsyncIterator beO.[[SyncIteratorRecord]].[[Iterator]].
- Letreturn be
GetMethod (syncIterator,"return" ). IfAbruptRejectPromise (return,promiseCapability).- Ifreturn is
undefined , then- LetiterResult be !
CreateIterResultObject (value,true ). - Perform !
Call (promiseCapability.[[Resolve]],undefined , «iterResult »). - ReturnpromiseCapability.[[Promise]].
- LetiterResult be !
- Ifvalue is present, then
- Letresult be
Call (return,syncIterator, «value »).
- Letresult be
- Else,
- Letresult be
Call (return,syncIterator).
- Letresult be
IfAbruptRejectPromise (result,promiseCapability).- If
Type (result) is not Object, then- Perform !
Call (promiseCapability.[[Reject]],undefined , « a newly createdTypeError object »). - ReturnpromiseCapability.[[Promise]].
- Perform !
- Return !
AsyncFromSyncIteratorContinuation (result,promiseCapability).
27.1.4.2.3 %AsyncFromSyncIteratorPrototype%.throw ( [value ] )
- LetO be the
this value. Assert :Type (O) is Object andO has a [[SyncIteratorRecord]] internal slot.- LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - LetsyncIterator beO.[[SyncIteratorRecord]].[[Iterator]].
- Letthrow be
GetMethod (syncIterator,"throw" ). IfAbruptRejectPromise (throw,promiseCapability).- Ifthrow is
undefined , then- Perform !
Call (promiseCapability.[[Reject]],undefined , «value »). - ReturnpromiseCapability.[[Promise]].
- Perform !
- Ifvalue is present, then
- Letresult be
Call (throw,syncIterator, «value »).
- Letresult be
- Else,
- Letresult be
Call (throw,syncIterator).
- Letresult be
IfAbruptRejectPromise (result,promiseCapability).- If
Type (result) is not Object, then- Perform !
Call (promiseCapability.[[Reject]],undefined , « a newly createdTypeError object »). - ReturnpromiseCapability.[[Promise]].
- Perform !
- Return !
AsyncFromSyncIteratorContinuation (result,promiseCapability).
27.1.4.2.4 Async-from-Sync Iterator Value Unwrap Functions
An async-from-sync iterator value unwrap function is an anonymous built-in function that is used by
When an async-from-sync iterator value unwrap function is called with argumentvalue, the following steps are taken:
- LetF be the
active function object . - Return !
CreateIterResultObject (value,F.[[Done]]).
27.1.4.3 Properties of Async-from-Sync Iterator Instances
Async-from-Sync Iterator instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[SyncIteratorRecord]] | A |
27.1.4.4 AsyncFromSyncIteratorContinuation (result,promiseCapability )
The abstract operation AsyncFromSyncIteratorContinuation takes argumentsresult andpromiseCapability (a
- Letdone be
IteratorComplete (result). IfAbruptRejectPromise (done,promiseCapability).- Letvalue be
IteratorValue (result). IfAbruptRejectPromise (value,promiseCapability).- LetvalueWrapper be
PromiseResolve (%Promise% ,value). IfAbruptRejectPromise (valueWrapper,promiseCapability).- Letsteps be the algorithm steps defined in
Async-from-Sync Iterator Value Unwrap Functions . - Letlength be the number of non-optional parameters of the function definition in
Async-from-Sync Iterator Value Unwrap Functions . - LetonFulfilled be !
CreateBuiltinFunction (steps,length,"" , « [[Done]] »). - SetonFulfilled.[[Done]] todone.
- Perform !
PerformPromiseThen (valueWrapper,onFulfilled,undefined ,promiseCapability). - ReturnpromiseCapability.[[Promise]].
27.2 Promise Objects
A Promise is an object that is used as a placeholder for the eventual results of a deferred (and possibly asynchronous) computation.
Any Promise object is in one of three mutually exclusive states:fulfilled,rejected, andpending:
- A promise
pis fulfilled ifp.then(f, r)will immediately enqueue aJob to call the functionf. - A promise
pis rejected ifp.then(f, r)will immediately enqueue aJob to call the functionr. - A promise is pending if it is neither fulfilled nor rejected.
A promise is said to besettled if it is not pending, i.e. if it is either fulfilled or rejected.
A promise isresolved if it is settled or if it has been “locked in” to match the state of another promise. Attempting to resolve or reject a resolved promise has no effect. A promise isunresolved if it is not resolved. An unresolved promise is always in the pending state. A resolved promise may be pending, fulfilled or rejected.
27.2.1 Promise Abstract Operations
27.2.1.1 PromiseCapability Records
APromiseCapability Record is a
PromiseCapability Records have the fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[Promise]] | An object | An object that is usable as a promise. |
| [[Resolve]] | A | The function that is used to resolve the given promise object. |
| [[Reject]] | A | The function that is used to reject the given promise object. |
27.2.1.1.1 IfAbruptRejectPromise (value,capability )
IfAbruptRejectPromise is a shorthand for a sequence of algorithm steps that use a
IfAbruptRejectPromise (value,capability).
means the same thing as:
- Ifvalue is an
abrupt completion , then- Perform ?
Call (capability.[[Reject]],undefined , «value.[[Value]] »). - Returncapability.[[Promise]].
- Perform ?
- Else ifvalue is a
Completion Record , setvalue tovalue.[[Value]].
27.2.1.2 PromiseReaction Records
The PromiseReaction is a
PromiseReaction records have the fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[Capability]] | A | The capabilities of the promise for which this record provides a reaction handler. |
| [[Type]] | The [[Type]] is used when [[Handler]] is | |
| [[Handler]] | A | The function that should be applied to the incoming value, and whose return value will govern what happens to the derived promise. If [[Handler]] is |
27.2.1.3 CreateResolvingFunctions (promise )
The abstract operation CreateResolvingFunctions takes argumentpromise. It performs the following steps when called:
- LetalreadyResolved be the
Record { [[Value]]:false }. - LetstepsResolve be the algorithm steps defined in
Promise Resolve Functions . - LetlengthResolve be the number of non-optional parameters of the function definition in
Promise Resolve Functions . - Letresolve be !
CreateBuiltinFunction (stepsResolve,lengthResolve,"" , « [[Promise]], [[AlreadyResolved]] »). - Setresolve.[[Promise]] topromise.
- Setresolve.[[AlreadyResolved]] toalreadyResolved.
- LetstepsReject be the algorithm steps defined in
Promise Reject Functions . - LetlengthReject be the number of non-optional parameters of the function definition in
Promise Reject Functions . - Letreject be !
CreateBuiltinFunction (stepsReject,lengthReject,"" , « [[Promise]], [[AlreadyResolved]] »). - Setreject.[[Promise]] topromise.
- Setreject.[[AlreadyResolved]] toalreadyResolved.
- Return the
Record { [[Resolve]]:resolve, [[Reject]]:reject }.
27.2.1.3.1 Promise Reject Functions
A promise reject function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.
When a promise reject function is called with argumentreason, the following steps are taken:
- LetF be the
active function object . Assert :F has a [[Promise]] internal slot whose value is an Object.- Letpromise beF.[[Promise]].
- LetalreadyResolved beF.[[AlreadyResolved]].
- IfalreadyResolved.[[Value]] is
true , returnundefined . - SetalreadyResolved.[[Value]] to
true . - Return
RejectPromise (promise,reason).
The
27.2.1.3.2 Promise Resolve Functions
A promise resolve function is an anonymous built-in function that has [[Promise]] and [[AlreadyResolved]] internal slots.
When a promise resolve function is called with argumentresolution, the following steps are taken:
- LetF be the
active function object . Assert :F has a [[Promise]] internal slot whose value is an Object.- Letpromise beF.[[Promise]].
- LetalreadyResolved beF.[[AlreadyResolved]].
- IfalreadyResolved.[[Value]] is
true , returnundefined . - SetalreadyResolved.[[Value]] to
true . - If
SameValue (resolution,promise) istrue , then- LetselfResolutionError be a newly created
TypeError object. - Return
RejectPromise (promise,selfResolutionError).
- LetselfResolutionError be a newly created
- If
Type (resolution) is not Object, then- Return
FulfillPromise (promise,resolution).
- Return
- Letthen be
Get (resolution,"then" ). - Ifthen is an
abrupt completion , then- Return
RejectPromise (promise,then.[[Value]]).
- Return
- LetthenAction bethen.[[Value]].
- If
IsCallable (thenAction) isfalse , then- Return
FulfillPromise (promise,resolution).
- Return
- LetthenJobCallback be
HostMakeJobCallback (thenAction). - Letjob be
NewPromiseResolveThenableJob (promise,resolution,thenJobCallback). - Perform
HostEnqueuePromiseJob (job.[[Job]],job.[[Realm]]). - Return
undefined .
The
27.2.1.4 FulfillPromise (promise,value )
The abstract operation FulfillPromise takes argumentspromise andvalue. It performs the following steps when called:
Assert : The value ofpromise.[[PromiseState]] ispending .- Letreactions bepromise.[[PromiseFulfillReactions]].
- Setpromise.[[PromiseResult]] tovalue.
- Setpromise.[[PromiseFulfillReactions]] to
undefined . - Setpromise.[[PromiseRejectReactions]] to
undefined . - Setpromise.[[PromiseState]] to
fulfilled . - Return
TriggerPromiseReactions (reactions,value).
27.2.1.5 NewPromiseCapability (C )
The abstract operation NewPromiseCapability takes argumentC. It attempts to useC as aresolve andreject functions. The Promise object plus theresolve andreject functions are used to initialize a new
- If
IsConstructor (C) isfalse , throw aTypeError exception. - NOTE:C is assumed to be a
constructor function that supports the parameter conventions of the Promiseconstructor (see27.2.3.1 ). - LetpromiseCapability be the
PromiseCapability Record { [[Promise]]:undefined , [[Resolve]]:undefined , [[Reject]]:undefined }. - Letsteps be the algorithm steps defined in
GetCapabilitiesExecutor Functions . - Letlength be the number of non-optional parameters of the function definition in
GetCapabilitiesExecutor Functions . - Letexecutor be !
CreateBuiltinFunction (steps,length,"" , « [[Capability]] »). - Setexecutor.[[Capability]] topromiseCapability.
- Letpromise be ?
Construct (C, «executor »). - If
IsCallable (promiseCapability.[[Resolve]]) isfalse , throw aTypeError exception. - If
IsCallable (promiseCapability.[[Reject]]) isfalse , throw aTypeError exception. - SetpromiseCapability.[[Promise]] topromise.
- ReturnpromiseCapability.
This abstract operation supports Promise subclassing, as it is generic on any
27.2.1.5.1 GetCapabilitiesExecutor Functions
A GetCapabilitiesExecutor function is an anonymous built-in function that has a [[Capability]] internal slot.
When a GetCapabilitiesExecutor function is called with argumentsresolve andreject, the following steps are taken:
- LetF be the
active function object . Assert :F has a [[Capability]] internal slot whose value is aPromiseCapability Record .- LetpromiseCapability beF.[[Capability]].
- IfpromiseCapability.[[Resolve]] is not
undefined , throw aTypeError exception. - IfpromiseCapability.[[Reject]] is not
undefined , throw aTypeError exception. - SetpromiseCapability.[[Resolve]] toresolve.
- SetpromiseCapability.[[Reject]] toreject.
- Return
undefined .
The
27.2.1.6 IsPromise (x )
The abstract operation IsPromise takes argumentx. It checks for the promise brand on an object. It performs the following steps when called:
- If
Type (x) is not Object, returnfalse . - Ifx does not have a [[PromiseState]] internal slot, return
false . - Return
true .
27.2.1.7 RejectPromise (promise,reason )
The abstract operation RejectPromise takes argumentspromise andreason. It performs the following steps when called:
Assert : The value ofpromise.[[PromiseState]] ispending .- Letreactions bepromise.[[PromiseRejectReactions]].
- Setpromise.[[PromiseResult]] toreason.
- Setpromise.[[PromiseFulfillReactions]] to
undefined . - Setpromise.[[PromiseRejectReactions]] to
undefined . - Setpromise.[[PromiseState]] to
rejected . - Ifpromise.[[PromiseIsHandled]] is
false , performHostPromiseRejectionTracker (promise,"reject" ). - Return
TriggerPromiseReactions (reactions,reason).
27.2.1.8 TriggerPromiseReactions (reactions,argument )
The abstract operation TriggerPromiseReactions takes argumentsreactions (a
- For each elementreaction ofreactions, do
- Letjob be
NewPromiseReactionJob (reaction,argument). - Perform
HostEnqueuePromiseJob (job.[[Job]],job.[[Realm]]).
- Letjob be
- Return
undefined .
27.2.1.9 HostPromiseRejectionTracker (promise,operation )
The
An implementation of HostPromiseRejectionTracker must complete normally in all cases. The default implementation of HostPromiseRejectionTracker is to unconditionally return an empty normal completion.
HostPromiseRejectionTracker is called in two scenarios:
- When a promise is rejected without any handlers, it is called with itsoperation argument set to
"reject" . - When a handler is added to a rejected promise for the first time, it is called with itsoperation argument set to
"handle" .
A typical implementation of HostPromiseRejectionTracker might try to notify developers of unhandled rejections, while also being careful to notify them if such previous notifications are later invalidated by new handlers being attached.
Ifoperation is
27.2.2 Promise Jobs
27.2.2.1 NewPromiseReactionJob (reaction,argument )
The abstract operation NewPromiseReactionJob takes argumentsreaction andargument. It returns a new
- Letjob be a new
Job Abstract Closure with no parameters that capturesreaction andargument and performs the following steps when called:Assert :reaction is a PromiseReactionRecord .- LetpromiseCapability bereaction.[[Capability]].
- Lettype bereaction.[[Type]].
- Lethandler bereaction.[[Handler]].
- Ifhandler is
empty , then- Iftype is
Fulfill , lethandlerResult beNormalCompletion (argument). - Else,
Assert :type isReject .- LethandlerResult be
ThrowCompletion (argument).
- Iftype is
- Else, lethandlerResult be
HostCallJobCallback (handler,undefined , «argument »). - IfpromiseCapability is
undefined , thenAssert :handlerResult is not anabrupt completion .- Return
NormalCompletion (empty ).
Assert :promiseCapability is aPromiseCapability Record .- IfhandlerResult is an
abrupt completion , then- Letstatus be
Call (promiseCapability.[[Reject]],undefined , «handlerResult.[[Value]] »).
- Letstatus be
- Else,
- Letstatus be
Call (promiseCapability.[[Resolve]],undefined , «handlerResult.[[Value]] »).
- Letstatus be
- Return
Completion (status).
- LethandlerRealm be
null . - Ifreaction.[[Handler]] is not
empty , then- LetgetHandlerRealmResult be
GetFunctionRealm (reaction.[[Handler]].[[Callback]]). - IfgetHandlerRealmResult is a normal completion, sethandlerRealm togetHandlerRealmResult.[[Value]].
- Else, sethandlerRealm to
the current Realm Record . - NOTE:handlerRealm is never
null unless the handler isundefined . When the handler is a revoked Proxy and no ECMAScript code runs,handlerRealm is used to create error objects.
- LetgetHandlerRealmResult be
- Return the
Record { [[Job]]:job, [[Realm]]:handlerRealm }.
27.2.2.2 NewPromiseResolveThenableJob (promiseToResolve,thenable,then )
The abstract operation NewPromiseResolveThenableJob takes argumentspromiseToResolve,thenable, andthen. It performs the following steps when called:
- Letjob be a new
Job Abstract Closure with no parameters that capturespromiseToResolve,thenable, andthen and performs the following steps when called:- LetresolvingFunctions be
CreateResolvingFunctions (promiseToResolve). - LetthenCallResult be
HostCallJobCallback (then,thenable, «resolvingFunctions.[[Resolve]],resolvingFunctions.[[Reject]] »). - IfthenCallResult is an
abrupt completion , then- Letstatus be
Call (resolvingFunctions.[[Reject]],undefined , «thenCallResult.[[Value]] »). - Return
Completion (status).
- Letstatus be
- Return
Completion (thenCallResult).
- LetresolvingFunctions be
- LetgetThenRealmResult be
GetFunctionRealm (then.[[Callback]]). - IfgetThenRealmResult is a normal completion, letthenRealm begetThenRealmResult.[[Value]].
- Else, letthenRealm be
the current Realm Record . - NOTE:thenRealm is never
null . Whenthen.[[Callback]] is a revoked Proxy and no code runs,thenRealm is used to create error objects. - Return the
Record { [[Job]]:job, [[Realm]]:thenRealm }.
27.2.3 The Promise Constructor
The Promise
- is%Promise%.
- is the initial value of the
"Promise" property of theglobal object . - creates and initializes a new Promise object when called as a
constructor . - is not intended to be called as a function and will throw an exception when called in that manner.
- is designed to be subclassable. It may be used as the value in an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified Promise behaviour must include asupercall to the Promiseconstructor to create and initialize the subclass instance with the internal state necessary to support thePromiseandPromise.prototypebuilt-in methods.
27.2.3.1 Promise (executor )
When thePromise function is called with argumentexecutor, the following steps are taken:
- If NewTarget is
undefined , throw aTypeError exception. - If
IsCallable (executor) isfalse , throw aTypeError exception. - Letpromise be ?
OrdinaryCreateFromConstructor (NewTarget,"%Promise.prototype%" , « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »). - Setpromise.[[PromiseState]] to
pending . - Setpromise.[[PromiseFulfillReactions]] to a new empty
List . - Setpromise.[[PromiseRejectReactions]] to a new empty
List . - Setpromise.[[PromiseIsHandled]] to
false . - LetresolvingFunctions be
CreateResolvingFunctions (promise). - Letcompletion be
Call (executor,undefined , «resolvingFunctions.[[Resolve]],resolvingFunctions.[[Reject]] »). - Ifcompletion is an
abrupt completion , then- Perform ?
Call (resolvingFunctions.[[Reject]],undefined , «completion.[[Value]] »).
- Perform ?
- Returnpromise.
Theexecutor argument must be a
Theresolve function that is passed to anexecutor function accepts a single argument. Theexecutor code may eventually call theresolve function to indicate that it wishes to resolve the associated Promise object. The argument passed to theresolve function represents the eventual value of the deferred action and can be either the actual fulfillment value or another Promise object which will provide the value if it is fulfilled.
Thereject function that is passed to anexecutor function accepts a single argument. Theexecutor code may eventually call thereject function to indicate that the associated Promise is rejected and will never be fulfilled. The argument passed to thereject function is used as the rejection value of the promise. Typically it will be an Error object.
The resolve and reject functions passed to anexecutor function by the Promise
27.2.4 Properties of the Promise Constructor
The Promise
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - has the following properties:
27.2.4.1 Promise.all (iterable )
Theall function returns a new promise which is fulfilled with an array of fulfillment values for the passed promises, or rejects with the reason of the first passed promise that rejects. It resolves all elements of the passed iterable to promises as it runs this algorithm.
- LetC be the
this value. - LetpromiseCapability be ?
NewPromiseCapability (C). - LetpromiseResolve be
GetPromiseResolve (C). IfAbruptRejectPromise (promiseResolve,promiseCapability).- LetiteratorRecord be
GetIterator (iterable). IfAbruptRejectPromise (iteratorRecord,promiseCapability).- Letresult be
PerformPromiseAll (iteratorRecord,C,promiseCapability,promiseResolve). - Ifresult is an
abrupt completion , then- IfiteratorRecord.[[Done]] is
false , setresult toIteratorClose (iteratorRecord,result). IfAbruptRejectPromise (result,promiseCapability).
- IfiteratorRecord.[[Done]] is
- Return
Completion (result).
Theall function requires its
27.2.4.1.1 GetPromiseResolve (promiseConstructor )
The abstract operation GetPromiseResolve takes argumentpromiseConstructor. It performs the following steps when called:
Assert :IsConstructor (promiseConstructor) istrue .- LetpromiseResolve be ?
Get (promiseConstructor,"resolve" ). - If
IsCallable (promiseResolve) isfalse , throw aTypeError exception. - ReturnpromiseResolve.
27.2.4.1.2 PerformPromiseAll (iteratorRecord,constructor,resultCapability,promiseResolve )
The abstract operation PerformPromiseAll takes argumentsiteratorRecord,constructor,resultCapability (a
Assert :IsConstructor (constructor) istrue .Assert :IsCallable (promiseResolve) istrue .- Letvalues be a new empty
List . - LetremainingElementsCount be the
Record { [[Value]]: 1 }. - Letindex be 0.
- Repeat,
- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , then- SetiteratorRecord.[[Done]] to
true . - SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- LetvaluesArray be !
CreateArrayFromList (values). - Perform ?
Call (resultCapability.[[Resolve]],undefined , «valuesArray »).
- LetvaluesArray be !
- ReturnresultCapability.[[Promise]].
- SetiteratorRecord.[[Done]] to
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- Append
undefined tovalues. - LetnextPromise be ?
Call (promiseResolve,constructor, «nextValue »). - Letsteps be the algorithm steps defined in
Promise.allResolve Element Functions - Letlength be the number of non-optional parameters of the function definition in
Promise.allResolve Element Functions - LetonFulfilled be !
CreateBuiltinFunction (steps,length,"" , « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »). - SetonFulfilled.[[AlreadyCalled]] to
false . - SetonFulfilled.[[Index]] toindex.
- SetonFulfilled.[[Values]] tovalues.
- SetonFulfilled.[[Capability]] toresultCapability.
- SetonFulfilled.[[RemainingElements]] toremainingElementsCount.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] + 1.
- Perform ?
Invoke (nextPromise,"then" , «onFulfilled,resultCapability.[[Reject]] »). - Setindex toindex + 1.
- Letnext be
27.2.4.1.3Promise.all Resolve Element Functions
APromise.all resolve element function is an anonymous built-in function that is used to resolve a specificPromise.all element. EachPromise.all resolve element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.
When aPromise.all resolve element function is called with argumentx, the following steps are taken:
- LetF be the
active function object . - IfF.[[AlreadyCalled]] is
true , returnundefined . - SetF.[[AlreadyCalled]] to
true . - Letindex beF.[[Index]].
- Letvalues beF.[[Values]].
- LetpromiseCapability beF.[[Capability]].
- LetremainingElementsCount beF.[[RemainingElements]].
- Setvalues[index] tox.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- LetvaluesArray be !
CreateArrayFromList (values). - Return ?
Call (promiseCapability.[[Resolve]],undefined , «valuesArray »).
- LetvaluesArray be !
- Return
undefined .
ThePromise.all resolve element function is
27.2.4.2 Promise.allSettled (iterable )
TheallSettled function returns a promise that is fulfilled with an array of promise state snapshots, but only after all the original promises have settled, i.e. become either fulfilled or rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
- LetC be the
this value. - LetpromiseCapability be ?
NewPromiseCapability (C). - LetpromiseResolve be
GetPromiseResolve (C). IfAbruptRejectPromise (promiseResolve,promiseCapability).- LetiteratorRecord be
GetIterator (iterable). IfAbruptRejectPromise (iteratorRecord,promiseCapability).- Letresult be
PerformPromiseAllSettled (iteratorRecord,C,promiseCapability,promiseResolve). - Ifresult is an
abrupt completion , then- IfiteratorRecord.[[Done]] is
false , setresult toIteratorClose (iteratorRecord,result). IfAbruptRejectPromise (result,promiseCapability).
- IfiteratorRecord.[[Done]] is
- Return
Completion (result).
TheallSettled function requires its
27.2.4.2.1 PerformPromiseAllSettled (iteratorRecord,constructor,resultCapability,promiseResolve )
The abstract operation PerformPromiseAllSettled takes argumentsiteratorRecord,constructor,resultCapability (a
Assert : !IsConstructor (constructor) istrue .Assert :IsCallable (promiseResolve) istrue .- Letvalues be a new empty
List . - LetremainingElementsCount be the
Record { [[Value]]: 1 }. - Letindex be 0.
- Repeat,
- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , then- SetiteratorRecord.[[Done]] to
true . - SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- LetvaluesArray be !
CreateArrayFromList (values). - Perform ?
Call (resultCapability.[[Resolve]],undefined , «valuesArray »).
- LetvaluesArray be !
- ReturnresultCapability.[[Promise]].
- SetiteratorRecord.[[Done]] to
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- Append
undefined tovalues. - LetnextPromise be ?
Call (promiseResolve,constructor, «nextValue »). - LetstepsFulfilled be the algorithm steps defined in
Promise.allSettledResolve Element Functions - LetlengthFulfilled be the number of non-optional parameters of the function definition in
Promise.allSettledResolve Element Functions - LetonFulfilled be !
CreateBuiltinFunction (stepsFulfilled,lengthFulfilled,"" , « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »). - LetalreadyCalled be the
Record { [[Value]]:false }. - SetonFulfilled.[[AlreadyCalled]] toalreadyCalled.
- SetonFulfilled.[[Index]] toindex.
- SetonFulfilled.[[Values]] tovalues.
- SetonFulfilled.[[Capability]] toresultCapability.
- SetonFulfilled.[[RemainingElements]] toremainingElementsCount.
- LetstepsRejected be the algorithm steps defined in
Promise.allSettledReject Element Functions - LetlengthRejected be the number of non-optional parameters of the function definition in
Promise.allSettledReject Element Functions - LetonRejected be !
CreateBuiltinFunction (stepsRejected,lengthRejected,"" , « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »). - SetonRejected.[[AlreadyCalled]] toalreadyCalled.
- SetonRejected.[[Index]] toindex.
- SetonRejected.[[Values]] tovalues.
- SetonRejected.[[Capability]] toresultCapability.
- SetonRejected.[[RemainingElements]] toremainingElementsCount.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] + 1.
- Perform ?
Invoke (nextPromise,"then" , «onFulfilled,onRejected »). - Setindex toindex + 1.
- Letnext be
27.2.4.2.2Promise.allSettled Resolve Element Functions
APromise.allSettled resolve element function is an anonymous built-in function that is used to resolve a specificPromise.allSettled element. EachPromise.allSettled resolve element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.
When aPromise.allSettled resolve element function is called with argumentx, the following steps are taken:
- LetF be the
active function object . - LetalreadyCalled beF.[[AlreadyCalled]].
- IfalreadyCalled.[[Value]] is
true , returnundefined . - SetalreadyCalled.[[Value]] to
true . - Letindex beF.[[Index]].
- Letvalues beF.[[Values]].
- LetpromiseCapability beF.[[Capability]].
- LetremainingElementsCount beF.[[RemainingElements]].
- Letobj be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform !
CreateDataPropertyOrThrow (obj,"status" ,"fulfilled" ). - Perform !
CreateDataPropertyOrThrow (obj,"value" ,x). - Setvalues[index] toobj.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- LetvaluesArray be !
CreateArrayFromList (values). - Return ?
Call (promiseCapability.[[Resolve]],undefined , «valuesArray »).
- LetvaluesArray be !
- Return
undefined .
ThePromise.allSettled resolve element function is
27.2.4.2.3Promise.allSettled Reject Element Functions
APromise.allSettled reject element function is an anonymous built-in function that is used to reject a specificPromise.allSettled element. EachPromise.allSettled reject element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.
When aPromise.allSettled reject element function is called with argumentx, the following steps are taken:
- LetF be the
active function object . - LetalreadyCalled beF.[[AlreadyCalled]].
- IfalreadyCalled.[[Value]] is
true , returnundefined . - SetalreadyCalled.[[Value]] to
true . - Letindex beF.[[Index]].
- Letvalues beF.[[Values]].
- LetpromiseCapability beF.[[Capability]].
- LetremainingElementsCount beF.[[RemainingElements]].
- Letobj be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform !
CreateDataPropertyOrThrow (obj,"status" ,"rejected" ). - Perform !
CreateDataPropertyOrThrow (obj,"reason" ,x). - Setvalues[index] toobj.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- LetvaluesArray be !
CreateArrayFromList (values). - Return ?
Call (promiseCapability.[[Resolve]],undefined , «valuesArray »).
- LetvaluesArray be !
- Return
undefined .
ThePromise.allSettled reject element function is
27.2.4.3 Promise.any (iterable )
Theany function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with anAggregateError holding the rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
- LetC be the
this value. - LetpromiseCapability be ?
NewPromiseCapability (C). - LetpromiseResolve be
GetPromiseResolve (C). IfAbruptRejectPromise (promiseResolve,promiseCapability).- LetiteratorRecord be
GetIterator (iterable). IfAbruptRejectPromise (iteratorRecord,promiseCapability).- Letresult be
PerformPromiseAny (iteratorRecord,C,promiseCapability,promiseResolve). - Ifresult is an
abrupt completion , then- IfiteratorRecord.[[Done]] is
false , setresult toIteratorClose (iteratorRecord,result). IfAbruptRejectPromise (result,promiseCapability).
- IfiteratorRecord.[[Done]] is
- Return
Completion (result).
Theany function requires itsPromise
27.2.4.3.1 PerformPromiseAny (iteratorRecord,constructor,resultCapability,promiseResolve )
The abstract operation PerformPromiseAny takes argumentsiteratorRecord,constructor,resultCapability (a
Assert : !IsConstructor (constructor) istrue .Assert : !IsCallable (promiseResolve) istrue .- Leterrors be a new empty
List . - LetremainingElementsCount be the
Record { [[Value]]: 1 }. - Letindex be 0.
- Repeat,
- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , then- SetiteratorRecord.[[Done]] to
true . - SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- Leterror be a newly created
AggregateErrorobject. - Perform !
DefinePropertyOrThrow (error,"errors" , PropertyDescriptor { [[Configurable]]:true , [[Enumerable]]:false , [[Writable]]:true , [[Value]]: !CreateArrayFromList (errors) }). - Return
ThrowCompletion (error).
- Leterror be a newly created
- ReturnresultCapability.[[Promise]].
- SetiteratorRecord.[[Done]] to
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- Append
undefined toerrors. - LetnextPromise be ?
Call (promiseResolve,constructor, «nextValue »). - LetstepsRejected be the algorithm steps defined in
Promise.anyReject Element Functions - LetlengthRejected be the number of non-optional parameters of the function definition in
Promise.anyReject Element Functions - LetonRejected be !
CreateBuiltinFunction (stepsRejected,lengthRejected,"" , « [[AlreadyCalled]], [[Index]], [[Errors]], [[Capability]], [[RemainingElements]] »). - SetonRejected.[[AlreadyCalled]] to
false . - SetonRejected.[[Index]] toindex.
- SetonRejected.[[Errors]] toerrors.
- SetonRejected.[[Capability]] toresultCapability.
- SetonRejected.[[RemainingElements]] toremainingElementsCount.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] + 1.
- Perform ?
Invoke (nextPromise,"then" , «resultCapability.[[Resolve]],onRejected »). - Setindex toindex + 1.
- Letnext be
27.2.4.3.2Promise.any Reject Element Functions
APromise.any reject element function is an anonymous built-in function that is used to reject a specificPromise.any element. EachPromise.any reject element function has [[Index]], [[Errors]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.
When aPromise.any reject element function is called with argumentx, the following steps are taken:
- LetF be the
active function object . - IfF.[[AlreadyCalled]] is
true , returnundefined . - SetF.[[AlreadyCalled]] to
true . - Letindex beF.[[Index]].
- Leterrors beF.[[Errors]].
- LetpromiseCapability beF.[[Capability]].
- LetremainingElementsCount beF.[[RemainingElements]].
- Seterrors[index] tox.
- SetremainingElementsCount.[[Value]] toremainingElementsCount.[[Value]] - 1.
- IfremainingElementsCount.[[Value]] is 0, then
- Leterror be a newly created
AggregateErrorobject. - Perform !
DefinePropertyOrThrow (error,"errors" , PropertyDescriptor { [[Configurable]]:true , [[Enumerable]]:false , [[Writable]]:true , [[Value]]: !CreateArrayFromList (errors) }). - Return ?
Call (promiseCapability.[[Reject]],undefined , «error »).
- Leterror be a newly created
- Return
undefined .
ThePromise.any reject element function is
27.2.4.4 Promise.prototype
The initial value ofPromise.prototype is the
This property has the attributes { [[Writable]]:
27.2.4.5 Promise.race (iterable )
Therace function returns a new promise which is settled in the same way as the first passed promise to settle. It resolves all elements of the passediterable to promises as it runs this algorithm.
- LetC be the
this value. - LetpromiseCapability be ?
NewPromiseCapability (C). - LetpromiseResolve be
GetPromiseResolve (C). IfAbruptRejectPromise (promiseResolve,promiseCapability).- LetiteratorRecord be
GetIterator (iterable). IfAbruptRejectPromise (iteratorRecord,promiseCapability).- Letresult be
PerformPromiseRace (iteratorRecord,C,promiseCapability,promiseResolve). - Ifresult is an
abrupt completion , then- IfiteratorRecord.[[Done]] is
false , setresult toIteratorClose (iteratorRecord,result). IfAbruptRejectPromise (result,promiseCapability).
- IfiteratorRecord.[[Done]] is
- Return
Completion (result).
If theiterable argument is empty or if none of the promises initerable ever settle then the pending promise returned by this method will never be settled.
Therace function expects itsresolve method.
27.2.4.5.1 PerformPromiseRace (iteratorRecord,constructor,resultCapability,promiseResolve )
The abstract operation PerformPromiseRace takes argumentsiteratorRecord,constructor,resultCapability (a
Assert :IsConstructor (constructor) istrue .Assert :IsCallable (promiseResolve) istrue .- Repeat,
- Letnext be
IteratorStep (iteratorRecord). - Ifnext is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (next).- Ifnext is
false , then- SetiteratorRecord.[[Done]] to
true . - ReturnresultCapability.[[Promise]].
- SetiteratorRecord.[[Done]] to
- LetnextValue be
IteratorValue (next). - IfnextValue is an
abrupt completion , setiteratorRecord.[[Done]] totrue . ReturnIfAbrupt (nextValue).- LetnextPromise be ?
Call (promiseResolve,constructor, «nextValue »). - Perform ?
Invoke (nextPromise,"then" , «resultCapability.[[Resolve]],resultCapability.[[Reject]] »).
- Letnext be
27.2.4.6 Promise.reject (r )
Thereject function returns a new promise rejected with the passed argument.
- LetC be the
this value. - LetpromiseCapability be ?
NewPromiseCapability (C). - Perform ?
Call (promiseCapability.[[Reject]],undefined , «r »). - ReturnpromiseCapability.[[Promise]].
Thereject function expects its
27.2.4.7 Promise.resolve (x )
Theresolve function returns either a new promise resolved with the passed argument, or the argument itself if the argument is a promise produced by this
- LetC be the
this value. - If
Type (C) is not Object, throw aTypeError exception. - Return ?
PromiseResolve (C,x).
Theresolve function expects its
27.2.4.7.1 PromiseResolve (C,x )
The abstract operation PromiseResolve takes argumentsC (a
27.2.4.8 get Promise [ @@species ]
Promise[@@species] is an
- Return the
this value.
The value of the
Promise prototype methods normally use their
27.2.5 Properties of the Promise Prototype Object
ThePromise prototype object:
- is%Promise.prototype%.
- has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is an
ordinary object . - does not have a [[PromiseState]] internal slot or any of the other internal slots of Promise instances.
27.2.5.1 Promise.prototype.catch (onRejected )
When thecatch method is called with argumentonRejected, the following steps are taken:
- Letpromise be the
this value. - Return ?
Invoke (promise,"then" , «undefined ,onRejected »).
27.2.5.2 Promise.prototype.constructor
The initial value ofPromise.prototype.constructor is
27.2.5.3 Promise.prototype.finally (onFinally )
When thefinally method is called with argumentonFinally, the following steps are taken:
- Letpromise be the
this value. - If
Type (promise) is not Object, throw aTypeError exception. - LetC be ?
SpeciesConstructor (promise,%Promise% ). Assert :IsConstructor (C) istrue .- If
IsCallable (onFinally) isfalse , then- LetthenFinally beonFinally.
- LetcatchFinally beonFinally.
- Else,
- LetstepsThenFinally be the algorithm steps defined in
Then Finally Functions . - LetlengthThenFinally be the number of non-optional parameters of the function definition in
Then Finally Functions . - LetthenFinally be !
CreateBuiltinFunction (stepsThenFinally,lengthThenFinally,"" , « [[Constructor]], [[OnFinally]] »). - SetthenFinally.[[Constructor]] toC.
- SetthenFinally.[[OnFinally]] toonFinally.
- LetstepsCatchFinally be the algorithm steps defined in
Catch Finally Functions . - LetlengthCatchFinally be the number of non-optional parameters of the function definition in
Catch Finally Functions . - LetcatchFinally be !
CreateBuiltinFunction (stepsCatchFinally,lengthCatchFinally,"" , « [[Constructor]], [[OnFinally]] »). - SetcatchFinally.[[Constructor]] toC.
- SetcatchFinally.[[OnFinally]] toonFinally.
- LetstepsThenFinally be the algorithm steps defined in
- Return ?
Invoke (promise,"then" , «thenFinally,catchFinally »).
27.2.5.3.1 Then Finally Functions
A Then Finally function is an anonymous built-in function that has a [[Constructor]] and an [[OnFinally]] internal slot. The value of the [[Constructor]] internal slot is aPromise-like
When a Then Finally function is called with argumentvalue, the following steps are taken:
- LetF be the
active function object . - LetonFinally beF.[[OnFinally]].
Assert :IsCallable (onFinally) istrue .- Letresult be ?
Call (onFinally,undefined ). - LetC beF.[[Constructor]].
Assert :IsConstructor (C) istrue .- Letpromise be ?
PromiseResolve (C,result). - LetvalueThunk be equivalent to a function that returnsvalue.
- Return ?
Invoke (promise,"then" , «valueThunk »).
The
27.2.5.3.2 Catch Finally Functions
A Catch Finally function is an anonymous built-in function that has a [[Constructor]] and an [[OnFinally]] internal slot. The value of the [[Constructor]] internal slot is aPromise-like
When a Catch Finally function is called with argumentreason, the following steps are taken:
- LetF be the
active function object . - LetonFinally beF.[[OnFinally]].
Assert :IsCallable (onFinally) istrue .- Letresult be ?
Call (onFinally,undefined ). - LetC beF.[[Constructor]].
Assert :IsConstructor (C) istrue .- Letpromise be ?
PromiseResolve (C,result). - Letthrower be equivalent to a function that throwsreason.
- Return ?
Invoke (promise,"then" , «thrower »).
The
27.2.5.4 Promise.prototype.then (onFulfilled,onRejected )
When thethen method is called with argumentsonFulfilled andonRejected, the following steps are taken:
- Letpromise be the
this value. - If
IsPromise (promise) isfalse , throw aTypeError exception. - LetC be ?
SpeciesConstructor (promise,%Promise% ). - LetresultCapability be ?
NewPromiseCapability (C). - Return
PerformPromiseThen (promise,onFulfilled,onRejected,resultCapability).
27.2.5.4.1 PerformPromiseThen (promise,onFulfilled,onRejected [ ,resultCapability ] )
The abstract operation PerformPromiseThen takes argumentspromise,onFulfilled, andonRejected and optional argumentresultCapability (a
Assert :IsPromise (promise) istrue .- IfresultCapability is not present, then
- SetresultCapability to
undefined .
- SetresultCapability to
- If
IsCallable (onFulfilled) isfalse , then- LetonFulfilledJobCallback be
empty .
- LetonFulfilledJobCallback be
- Else,
- LetonFulfilledJobCallback be
HostMakeJobCallback (onFulfilled).
- LetonFulfilledJobCallback be
- If
IsCallable (onRejected) isfalse , then- LetonRejectedJobCallback be
empty .
- LetonRejectedJobCallback be
- Else,
- LetonRejectedJobCallback be
HostMakeJobCallback (onRejected).
- LetonRejectedJobCallback be
- LetfulfillReaction be the PromiseReaction { [[Capability]]:resultCapability, [[Type]]:
Fulfill , [[Handler]]:onFulfilledJobCallback }. - LetrejectReaction be the PromiseReaction { [[Capability]]:resultCapability, [[Type]]:
Reject , [[Handler]]:onRejectedJobCallback }. - Ifpromise.[[PromiseState]] is
pending , then - Else ifpromise.[[PromiseState]] is
fulfilled , then- Letvalue bepromise.[[PromiseResult]].
- LetfulfillJob be
NewPromiseReactionJob (fulfillReaction,value). - Perform
HostEnqueuePromiseJob (fulfillJob.[[Job]],fulfillJob.[[Realm]]).
- Else,
Assert : The value ofpromise.[[PromiseState]] isrejected .- Letreason bepromise.[[PromiseResult]].
- Ifpromise.[[PromiseIsHandled]] is
false , performHostPromiseRejectionTracker (promise,"handle" ). - LetrejectJob be
NewPromiseReactionJob (rejectReaction,reason). - Perform
HostEnqueuePromiseJob (rejectJob.[[Job]],rejectJob.[[Realm]]).
- Setpromise.[[PromiseIsHandled]] to
true . - IfresultCapability is
undefined , then- Return
undefined .
- Return
- Else,
- ReturnresultCapability.[[Promise]].
27.2.5.5 Promise.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
27.2.6 Properties of Promise Instances
Promise instances are ordinary objects that inherit properties from the
| Internal Slot | Description |
|---|---|
| [[PromiseState]] | One ofthen method. |
| [[PromiseResult]] | The value with which the promise has been fulfilled or rejected, if any. Only meaningful if [[PromiseState]] is not |
| [[PromiseFulfillReactions]] | A |
| [[PromiseRejectReactions]] | A |
| [[PromiseIsHandled]] | A boolean indicating whether the promise has ever had a fulfillment or rejection handler; used in unhandled rejection tracking. |
27.3 GeneratorFunction Objects
GeneratorFunction objects are functions that are usually created by evaluating
27.3.1 The GeneratorFunction Constructor
The GeneratorFunction
- is%GeneratorFunction%.
- is a subclass of
Function. - creates and initializes a new GeneratorFunction object when called as a function rather than as a
constructor . Thus the function callGeneratorFunction (…)is equivalent to the object creation expressionnew GeneratorFunction (…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified GeneratorFunction behaviour must include asupercall to the GeneratorFunctionconstructor to create and initialize subclass instances with the internal slots necessary for built-in GeneratorFunction behaviour. All ECMAScript syntactic forms for defining generator function objects create direct instances of GeneratorFunction. There is no syntactic means to create instances of GeneratorFunction subclasses.
27.3.1.1 GeneratorFunction (p1,p2, … ,pn,body )
The last argument specifies the body (executable code) of a generator function; any preceding arguments specify formal parameters.
When theGeneratorFunction function is called with some argumentsp1,p2, … ,pn,body (wheren might be 0, that is, there are no “p” arguments, and wherebody might also not be provided), the following steps are taken:
- LetC be the
active function object . - Letargs be theargumentsList that was passed to this function by [[Call]] or [[Construct]].
- Return ?
CreateDynamicFunction (C, NewTarget,generator ,args).
See NOTE for
27.3.2 Properties of the GeneratorFunction Constructor
The GeneratorFunction
- is a standard built-in
function object that inherits from the Functionconstructor . - has a [[Prototype]] internal slot whose value is
%Function% . - has a
"name" property whose value is"GeneratorFunction" . - has the following properties:
27.3.2.1 GeneratorFunction.length
This is a
27.3.2.2 GeneratorFunction.prototype
The initial value ofGeneratorFunction.prototype is the
This property has the attributes { [[Writable]]:
27.3.3 Properties of the GeneratorFunction Prototype Object
TheGeneratorFunction prototype object:
- is%GeneratorFunction.prototype% (see
Figure 5 ). - is an
ordinary object . - is not a
function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed inTable 29 orTable 73 . - has a [[Prototype]] internal slot whose value is
%Function.prototype% .
27.3.3.1 GeneratorFunction.prototype.constructor
The initial value ofGeneratorFunction.prototype.constructor is
This property has the attributes { [[Writable]]:
27.3.3.2 GeneratorFunction.prototype.prototype
The initial value ofGeneratorFunction.prototype.prototype is the
This property has the attributes { [[Writable]]:
27.3.3.3 GeneratorFunction.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
27.3.4 GeneratorFunction Instances
Every GeneratorFunction instance is an ECMAScript
Each GeneratorFunction instance has the following own properties:
27.3.4.1 length
The specification for the
27.3.4.2 name
The specification for the
27.3.4.3 prototype
Whenever a GeneratorFunction instance is created another
This property has the attributes { [[Writable]]:
Unlike Function instances, the object that is the value of the a GeneratorFunction's
27.4 AsyncGeneratorFunction Objects
AsyncGeneratorFunction objects are functions that are usually created by evaluating
27.4.1 The AsyncGeneratorFunction Constructor
The AsyncGeneratorFunction
- is%AsyncGeneratorFunction%.
- is a subclass of
Function. - creates and initializes a new AsyncGeneratorFunction object when called as a function rather than as a
constructor . Thus the function callAsyncGeneratorFunction (...)is equivalent to the object creation expressionnew AsyncGeneratorFunction (...)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified AsyncGeneratorFunction behaviour must include asupercall to the AsyncGeneratorFunctionconstructor to create and initialize subclass instances with the internal slots necessary for built-in AsyncGeneratorFunction behaviour. All ECMAScript syntactic forms for defining async generator function objects create direct instances of AsyncGeneratorFunction. There is no syntactic means to create instances of AsyncGeneratorFunction subclasses.
27.4.1.1 AsyncGeneratorFunction (p1,p2, … ,pn,body )
The last argument specifies the body (executable code) of an async generator function; any preceding arguments specify formal parameters.
When theAsyncGeneratorFunction function is called with some argumentsp1,p2, … ,pn,body (wheren might be 0, that is, there are no "p" arguments, and wherebody might also not be provided), the following steps are taken:
- LetC be the
active function object . - Letargs be theargumentsList that was passed to this function by [[Call]] or [[Construct]].
- Return ?
CreateDynamicFunction (C, NewTarget,asyncGenerator ,args).
See NOTE for
27.4.2 Properties of the AsyncGeneratorFunction Constructor
The AsyncGeneratorFunction
- is a standard built-in
function object that inherits from the Functionconstructor . - has a [[Prototype]] internal slot whose value is
%Function% . - has a
"name" property whose value is"AsyncGeneratorFunction" . - has the following properties:
27.4.2.1 AsyncGeneratorFunction.length
This is a
27.4.2.2 AsyncGeneratorFunction.prototype
The initial value ofAsyncGeneratorFunction.prototype is the
This property has the attributes { [[Writable]]:
27.4.3 Properties of the AsyncGeneratorFunction Prototype Object
TheAsyncGeneratorFunction prototype object:
- is%AsyncGeneratorFunction.prototype%.
- is an
ordinary object . - is not a
function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed inTable 29 orTable 74 . - has a [[Prototype]] internal slot whose value is
%Function.prototype% .
27.4.3.1 AsyncGeneratorFunction.prototype.constructor
The initial value ofAsyncGeneratorFunction.prototype.constructor is
This property has the attributes { [[Writable]]:
27.4.3.2 AsyncGeneratorFunction.prototype.prototype
The initial value ofAsyncGeneratorFunction.prototype.prototype is the
This property has the attributes { [[Writable]]:
27.4.3.3 AsyncGeneratorFunction.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
27.4.4 AsyncGeneratorFunction Instances
Every AsyncGeneratorFunction instance is an ECMAScript
Each AsyncGeneratorFunction instance has the following own properties:
27.4.4.1 length
The value of the
This property has the attributes { [[Writable]]:
27.4.4.2 name
The specification for the
27.4.4.3 prototype
Whenever an AsyncGeneratorFunction instance is created another
This property has the attributes { [[Writable]]:
Unlike function instances, the object that is the value of the an AsyncGeneratorFunction's
27.5 Generator Objects
A Generator object is an instance of a generator function and conforms to both theIterator andIterable interfaces.
Generator instances directly inherit properties from the object that is the initial value of the
27.5.1 Properties of the Generator Prototype Object
TheGenerator prototype object:
- is%GeneratorFunction.prototype.prototype%.
- is an
ordinary object . - is not a Generator instance and does not have a [[GeneratorState]] internal slot.
- has a [[Prototype]] internal slot whose value is
%IteratorPrototype% . - has properties that are indirectly inherited by all Generator instances.
27.5.1.1 Generator.prototype.constructor
The initial value ofGenerator.prototype.constructor is
This property has the attributes { [[Writable]]:
27.5.1.2 Generator.prototype.next (value )
Thenext method performs the following steps:
- Letg be the
this value. - Return ?
GeneratorResume (g,value,empty ).
27.5.1.3 Generator.prototype.return (value )
Thereturn method performs the following steps:
- Letg be the
this value. - LetC be
Completion { [[Type]]:return , [[Value]]:value, [[Target]]:empty }. - Return ?
GeneratorResumeAbrupt (g,C,empty ).
27.5.1.4 Generator.prototype.throw (exception )
Thethrow method performs the following steps:
- Letg be the
this value. - LetC be
ThrowCompletion (exception). - Return ?
GeneratorResumeAbrupt (g,C,empty ).
27.5.1.5 Generator.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
27.5.2 Properties of Generator Instances
Generator instances are initially created with the internal slots described in
| Internal Slot | Description |
|---|---|
| [[GeneratorState]] | The current execution state of the generator. The possible values are: |
| [[GeneratorContext]] | The |
| [[GeneratorBrand]] | A brand used to distinguish different kinds of generators. The [[GeneratorBrand]] of generators declared by ECMAScript source text is always |
27.5.3 Generator Abstract Operations
27.5.3.1 GeneratorStart (generator,generatorBody )
The abstract operation GeneratorStart takes argumentsgenerator andgeneratorBody (a
Assert : The value ofgenerator.[[GeneratorState]] isundefined .- LetgenContext be the
running execution context . - Set the Generator component ofgenContext togenerator.
- Set the code evaluation state ofgenContext such that when evaluation is resumed for that
execution context the following steps will be performed:- IfgeneratorBody is a
Parse Node , then- Letresult be the result of evaluatinggeneratorBody.
- Else,
Assert :generatorBody is anAbstract Closure with no parameters.- Letresult begeneratorBody().
Assert : If we return here, the generator either threw an exception or performed either an implicit or explicit return.- RemovegenContext from the
execution context stack and restore theexecution context that is at the top of theexecution context stack as therunning execution context . - Setgenerator.[[GeneratorState]] to
completed . - Once a generator enters the
completed state it never leaves it and its associatedexecution context is never resumed. Any execution state associated withgenerator can be discarded at this point. - Ifresult.[[Type]] is
normal , letresultValue beundefined . - Else ifresult.[[Type]] is
return , letresultValue beresult.[[Value]]. - Else,
Assert :result.[[Type]] isthrow .- Return
Completion (result).
- Return
CreateIterResultObject (resultValue,true ).
- IfgeneratorBody is a
- Setgenerator.[[GeneratorContext]] togenContext.
- Setgenerator.[[GeneratorState]] to
suspendedStart . - Return
NormalCompletion (undefined ).
27.5.3.2 GeneratorValidate (generator,generatorBrand )
The abstract operation GeneratorValidate takes argumentsgenerator andgeneratorBrand. It performs the following steps when called:
- Perform ?
RequireInternalSlot (generator, [[GeneratorState]]). - Perform ?
RequireInternalSlot (generator, [[GeneratorBrand]]). - Ifgenerator.[[GeneratorBrand]] is not the same value asgeneratorBrand, throw a
TypeError exception. Assert :generator also has a [[GeneratorContext]] internal slot.- Letstate begenerator.[[GeneratorState]].
- Ifstate is
executing , throw aTypeError exception. - Returnstate.
27.5.3.3 GeneratorResume (generator,value,generatorBrand )
The abstract operation GeneratorResume takes argumentsgenerator,value, andgeneratorBrand. It performs the following steps when called:
- Letstate be ?
GeneratorValidate (generator,generatorBrand). - Ifstate is
completed , returnCreateIterResultObject (undefined ,true ). Assert :state is eithersuspendedStart orsuspendedYield .- LetgenContext begenerator.[[GeneratorContext]].
- LetmethodContext be the
running execution context . Suspend methodContext.- Setgenerator.[[GeneratorState]] to
executing . - PushgenContext onto the
execution context stack ;genContext is now therunning execution context . - Resume the suspended evaluation ofgenContext using
NormalCompletion (value) as the result of the operation that suspended it. Letresult be the value returned by the resumed computation. Assert : When we return here,genContext has already been removed from theexecution context stack andmethodContext is the currentlyrunning execution context .- Return
Completion (result).
27.5.3.4 GeneratorResumeAbrupt (generator,abruptCompletion,generatorBrand )
The abstract operation GeneratorResumeAbrupt takes argumentsgenerator,abruptCompletion (a
- Letstate be ?
GeneratorValidate (generator,generatorBrand). - Ifstate is
suspendedStart , then- Setgenerator.[[GeneratorState]] to
completed . - Once a generator enters the
completed state it never leaves it and its associatedexecution context is never resumed. Any execution state associated withgenerator can be discarded at this point. - Setstate to
completed .
- Setgenerator.[[GeneratorState]] to
- Ifstate is
completed , then- IfabruptCompletion.[[Type]] is
return , then- Return
CreateIterResultObject (abruptCompletion.[[Value]],true ).
- Return
- Return
Completion (abruptCompletion).
- IfabruptCompletion.[[Type]] is
Assert :state issuspendedYield .- LetgenContext begenerator.[[GeneratorContext]].
- LetmethodContext be the
running execution context . Suspend methodContext.- Setgenerator.[[GeneratorState]] to
executing . - PushgenContext onto the
execution context stack ;genContext is now therunning execution context . - Resume the suspended evaluation ofgenContext usingabruptCompletion as the result of the operation that suspended it. Letresult be the completion record returned by the resumed computation.
Assert : When we return here,genContext has already been removed from theexecution context stack andmethodContext is the currentlyrunning execution context .- Return
Completion (result).
27.5.3.5 GetGeneratorKind ( )
The abstract operation GetGeneratorKind takes no arguments. It performs the following steps when called:
- LetgenContext be the
running execution context . - IfgenContext does not have a Generator component, return
non-generator . - Letgenerator be the Generator component ofgenContext.
- Ifgenerator has an [[AsyncGeneratorState]] internal slot, return
async . - Else, return
sync .
27.5.3.6 GeneratorYield (iterNextObj )
The abstract operation GeneratorYield takes argumentiterNextObj. It performs the following steps when called:
Assert :iterNextObj is an Object that implements theIteratorResult interface.- LetgenContext be the
running execution context . Assert :genContext is theexecution context of a generator.- Letgenerator be the value of the Generator component ofgenContext.
Assert :GetGeneratorKind () issync .- Setgenerator.[[GeneratorState]] to
suspendedYield . - RemovegenContext from the
execution context stack and restore theexecution context that is at the top of theexecution context stack as therunning execution context . - Set the code evaluation state ofgenContext such that when evaluation is resumed with a
Completion resumptionValue the following steps will be performed:- ReturnresumptionValue.
- NOTE: This returns to the evaluation of the
YieldExpression that originally called this abstract operation.
- Return
NormalCompletion (iterNextObj). - NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation ofgenContext.
27.5.3.7 Yield (value )
The abstract operation Yield takes argumentvalue (an
- LetgeneratorKind be !
GetGeneratorKind (). - IfgeneratorKind is
async , return ?AsyncGeneratorYield (value). - Otherwise, return ?
GeneratorYield (!CreateIterResultObject (value,false )).
27.5.3.8 CreateIteratorFromClosure (closure,generatorBrand,generatorPrototype )
The abstract operation CreateIteratorFromClosure takes argumentsclosure (an
- NOTE:closure can contain uses of the
Yield shorthand to yield an IteratorResult object. - LetinternalSlotsList be « [[GeneratorState]], [[GeneratorContext]], [[GeneratorBrand]] ».
- Letgenerator be !
OrdinaryObjectCreate (generatorPrototype,internalSlotsList). - Setgenerator.[[GeneratorBrand]] togeneratorBrand.
- Setgenerator.[[GeneratorState]] to
undefined . - Perform !
GeneratorStart (generator,closure). - Returngenerator.
27.6 AsyncGenerator Objects
An AsyncGenerator object is an instance of an async generator function and conforms to both the AsyncIterator and AsyncIterable interfaces.
AsyncGenerator instances directly inherit properties from the object that is the initial value of the
27.6.1 Properties of the AsyncGenerator Prototype Object
TheAsyncGenerator prototype object:
- is%AsyncGeneratorFunction.prototype.prototype%.
- is an
ordinary object . - is not an AsyncGenerator instance and does not have an [[AsyncGeneratorState]] internal slot.
- has a [[Prototype]] internal slot whose value is
%AsyncIteratorPrototype% . - has properties that are indirectly inherited by all AsyncGenerator instances.
27.6.1.1 AsyncGenerator.prototype.constructor
The initial value ofAsyncGenerator.prototype.constructor is
This property has the attributes { [[Writable]]:
27.6.1.2 AsyncGenerator.prototype.next (value )
- Letgenerator be the
this value. - Letcompletion be
NormalCompletion (value). - Return !
AsyncGeneratorEnqueue (generator,completion,empty ).
27.6.1.3 AsyncGenerator.prototype.return (value )
- Letgenerator be the
this value. - Letcompletion be
Completion { [[Type]]:return , [[Value]]:value, [[Target]]:empty }. - Return !
AsyncGeneratorEnqueue (generator,completion,empty ).
27.6.1.4 AsyncGenerator.prototype.throw (exception )
- Letgenerator be the
this value. - Letcompletion be
ThrowCompletion (exception). - Return !
AsyncGeneratorEnqueue (generator,completion,empty ).
27.6.1.5 AsyncGenerator.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
27.6.2 Properties of AsyncGenerator Instances
AsyncGenerator instances are initially created with the internal slots described below:
| Internal Slot | Description |
|---|---|
| [[AsyncGeneratorState]] | The current execution state of the async generator. The possible values are: |
| [[AsyncGeneratorContext]] | The |
| [[AsyncGeneratorQueue]] | A |
| [[GeneratorBrand]] | A brand used to distinguish different kinds of async generators. The [[GeneratorBrand]] of async generators declared by ECMAScript source text is always |
27.6.3 AsyncGenerator Abstract Operations
27.6.3.1 AsyncGeneratorRequest Records
The AsyncGeneratorRequest is a
They have the following fields:
| Field Name | Value | Meaning |
|---|---|---|
| [[Completion]] | A | The completion which should be used to resume the async generator. |
| [[Capability]] | A | The promise capabilities associated with this request. |
27.6.3.2 AsyncGeneratorStart (generator,generatorBody )
The abstract operation AsyncGeneratorStart takes argumentsgenerator andgeneratorBody (a
Assert :generator is an AsyncGenerator instance.Assert :generator.[[AsyncGeneratorState]] isundefined .- LetgenContext be the
running execution context . - Set the Generator component ofgenContext togenerator.
- Set the code evaluation state ofgenContext such that when evaluation is resumed for that
execution context the following steps will be performed:- IfgeneratorBody is a
Parse Node , then- Letresult be the result of evaluatinggeneratorBody.
- Else,
Assert :generatorBody is anAbstract Closure with no parameters.- Letresult begeneratorBody().
Assert : If we return here, the async generator either threw an exception or performed either an implicit or explicit return.- RemovegenContext from the
execution context stack and restore theexecution context that is at the top of theexecution context stack as therunning execution context . - Setgenerator.[[AsyncGeneratorState]] to
completed . - Ifresult is a normal completion, letresultValue be
undefined . - Else,
- LetresultValue beresult.[[Value]].
- Ifresult.[[Type]] is not
return , then- Return !
AsyncGeneratorReject (generator,resultValue).
- Return !
- Return !
AsyncGeneratorResolve (generator,resultValue,true ).
- IfgeneratorBody is a
- Setgenerator.[[AsyncGeneratorContext]] togenContext.
- Setgenerator.[[AsyncGeneratorState]] to
suspendedStart . - Setgenerator.[[AsyncGeneratorQueue]] to a new empty
List . - Return
undefined .
27.6.3.3 AsyncGeneratorValidate (generator,generatorBrand )
The abstract operation AsyncGeneratorValidate takes argumentsgenerator andgeneratorBrand. It performs the following steps when called:
- Perform ?
RequireInternalSlot (generator, [[AsyncGeneratorContext]]). - Perform ?
RequireInternalSlot (generator, [[AsyncGeneratorState]]). - Perform ?
RequireInternalSlot (generator, [[AsyncGeneratorQueue]]). - Ifgenerator.[[GeneratorBrand]] is not the same value asgeneratorBrand, throw a
TypeError exception.
27.6.3.4 AsyncGeneratorResolve (generator,value,done )
The abstract operation AsyncGeneratorResolve takes argumentsgenerator,value, anddone (a Boolean). It performs the following steps when called:
Assert :generator is an AsyncGenerator instance.- Letqueue begenerator.[[AsyncGeneratorQueue]].
Assert :queue is not an emptyList .- Letnext be the first element ofqueue.
- Remove the first element fromqueue.
- LetpromiseCapability benext.[[Capability]].
- LetiteratorResult be !
CreateIterResultObject (value,done). - Perform !
Call (promiseCapability.[[Resolve]],undefined , «iteratorResult »). - Perform !
AsyncGeneratorResumeNext (generator). - Return
undefined .
27.6.3.5 AsyncGeneratorReject (generator,exception )
The abstract operation AsyncGeneratorReject takes argumentsgenerator andexception. It performs the following steps when called:
Assert :generator is an AsyncGenerator instance.- Letqueue begenerator.[[AsyncGeneratorQueue]].
Assert :queue is not an emptyList .- Letnext be the first element ofqueue.
- Remove the first element fromqueue.
- LetpromiseCapability benext.[[Capability]].
- Perform !
Call (promiseCapability.[[Reject]],undefined , «exception »). - Perform !
AsyncGeneratorResumeNext (generator). - Return
undefined .
27.6.3.6 AsyncGeneratorResumeNext (generator )
The abstract operation AsyncGeneratorResumeNext takes argumentgenerator. It performs the following steps when called:
Assert :generator is an AsyncGenerator instance.- Letstate begenerator.[[AsyncGeneratorState]].
Assert :state is notexecuting .- Ifstate is
awaiting-return , returnundefined . - Letqueue begenerator.[[AsyncGeneratorQueue]].
- Ifqueue is an empty
List , returnundefined . - Letnext be the value of the first element ofqueue.
Assert :next is an AsyncGeneratorRequest record.- Letcompletion benext.[[Completion]].
- Ifcompletion is an
abrupt completion , then- Ifstate is
suspendedStart , then- Setgenerator.[[AsyncGeneratorState]] to
completed . - Setstate to
completed .
- Setgenerator.[[AsyncGeneratorState]] to
- Ifstate is
completed , then- Ifcompletion.[[Type]] is
return , then- Setgenerator.[[AsyncGeneratorState]] to
awaiting-return . - Letpromise be ?
PromiseResolve (%Promise% ,completion.[[Value]]). - LetstepsFulfilled be the algorithm steps defined in
AsyncGeneratorResumeNext Return Processor Fulfilled Functions . - LetlengthFulfilled be the number of non-optional parameters of the function definition in
AsyncGeneratorResumeNext Return Processor Fulfilled Functions . - LetonFulfilled be !
CreateBuiltinFunction (stepsFulfilled,lengthFulfilled,"" , « [[Generator]] »). - SetonFulfilled.[[Generator]] togenerator.
- LetstepsRejected be the algorithm steps defined in
AsyncGeneratorResumeNext Return Processor Rejected Functions . - LetlengthRejected be the number of non-optional parameters of the function definition in
AsyncGeneratorResumeNext Return Processor Rejected Functions . - LetonRejected be !
CreateBuiltinFunction (stepsRejected,lengthRejected,"" , « [[Generator]] »). - SetonRejected.[[Generator]] togenerator.
- Perform !
PerformPromiseThen (promise,onFulfilled,onRejected). - Return
undefined .
- Setgenerator.[[AsyncGeneratorState]] to
- Else,
Assert :completion.[[Type]] isthrow .- Perform !
AsyncGeneratorReject (generator,completion.[[Value]]). - Return
undefined .
- Ifcompletion.[[Type]] is
- Ifstate is
- Else ifstate is
completed , return !AsyncGeneratorResolve (generator,undefined ,true ). Assert :state is eithersuspendedStart orsuspendedYield .- LetgenContext begenerator.[[AsyncGeneratorContext]].
- LetcallerContext be the
running execution context . Suspend callerContext.- Setgenerator.[[AsyncGeneratorState]] to
executing . - PushgenContext onto the
execution context stack ;genContext is now therunning execution context . - Resume the suspended evaluation ofgenContext usingcompletion as the result of the operation that suspended it. Letresult be the completion record returned by the resumed computation.
Assert :result is never anabrupt completion .Assert : When we return here,genContext has already been removed from theexecution context stack andcallerContext is the currentlyrunning execution context .- Return
undefined .
27.6.3.6.1 AsyncGeneratorResumeNext Return Processor Fulfilled Functions
An
When an
- LetF be the
active function object . - SetF.[[Generator]].[[AsyncGeneratorState]] to
completed . - Return !
AsyncGeneratorResolve (F.[[Generator]],value,true ).
The
27.6.3.6.2 AsyncGeneratorResumeNext Return Processor Rejected Functions
An
When an
- LetF be the
active function object . - SetF.[[Generator]].[[AsyncGeneratorState]] to
completed . - Return !
AsyncGeneratorReject (F.[[Generator]],reason).
The
27.6.3.7 AsyncGeneratorEnqueue (generator,completion,generatorBrand )
The abstract operation AsyncGeneratorEnqueue takes argumentsgenerator,completion (a
- LetpromiseCapability be !
NewPromiseCapability (%Promise% ). - Letcheck be
AsyncGeneratorValidate (generator,generatorBrand). - Ifcheck is an
abrupt completion , then- LetbadGeneratorError be a newly created
TypeError object. - Perform !
Call (promiseCapability.[[Reject]],undefined , «badGeneratorError »). - ReturnpromiseCapability.[[Promise]].
- LetbadGeneratorError be a newly created
- Letqueue begenerator.[[AsyncGeneratorQueue]].
- Letrequest be AsyncGeneratorRequest { [[Completion]]:completion, [[Capability]]:promiseCapability }.
- Appendrequest to the end ofqueue.
- Letstate begenerator.[[AsyncGeneratorState]].
- Ifstate is not
executing , then- Perform !
AsyncGeneratorResumeNext (generator).
- Perform !
- ReturnpromiseCapability.[[Promise]].
27.6.3.8 AsyncGeneratorYield (value )
The abstract operation AsyncGeneratorYield takes argumentvalue. It performs the following steps when called:
- LetgenContext be the
running execution context . Assert :genContext is theexecution context of a generator.- Letgenerator be the value of the Generator component ofgenContext.
Assert :GetGeneratorKind () isasync .- Setvalue to ?
Await (value). - Setgenerator.[[AsyncGeneratorState]] to
suspendedYield . - RemovegenContext from the
execution context stack and restore theexecution context that is at the top of theexecution context stack as therunning execution context . - Set the code evaluation state ofgenContext such that when evaluation is resumed with a
Completion resumptionValue the following steps will be performed:- IfresumptionValue.[[Type]] is not
return , returnCompletion (resumptionValue). - Letawaited be
Await (resumptionValue.[[Value]]). - Ifawaited.[[Type]] is
throw , returnCompletion (awaited). Assert :awaited.[[Type]] isnormal .- Return
Completion { [[Type]]:return , [[Value]]:awaited.[[Value]], [[Target]]:empty }. - NOTE: When one of the above steps returns, it returns to the evaluation of the
YieldExpression production that originally called this abstract operation.
- IfresumptionValue.[[Type]] is not
- Return !
AsyncGeneratorResolve (generator,value,false ). - NOTE: This returns to the evaluation of the operation that had most previously resumed evaluation ofgenContext.
27.6.3.9 CreateAsyncIteratorFromClosure (closure,generatorBrand,generatorPrototype )
The abstract operation CreateAsyncIteratorFromClosure takes argumentsclosure (an
- NOTE:closure can contain uses of the
Await shorthand and uses of theYield shorthand to yield an IteratorResult object. - LetinternalSlotsList be « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]], [[GeneratorBrand]] ».
- Letgenerator be !
OrdinaryObjectCreate (generatorPrototype,internalSlotsList). - Setgenerator.[[GeneratorBrand]] togeneratorBrand.
- Setgenerator.[[AsyncGeneratorState]] to
undefined . - Perform !
AsyncGeneratorStart (generator,closure). - Returngenerator.
27.7 AsyncFunction Objects
AsyncFunction objects are functions that are usually created by evaluating
27.7.1 The AsyncFunction Constructor
The AsyncFunction
- is%AsyncFunction%.
- is a subclass of
Function. - creates and initializes a new AsyncFunction object when called as a function rather than as a
constructor . Thus the function callAsyncFunction(…)is equivalent to the object creation expressionnew AsyncFunction(…)with the same arguments. - is designed to be subclassable. It may be used as the value of an
extendsclause of a class definition. Subclass constructors that intend to inherit the specified AsyncFunction behaviour must include asupercall to the AsyncFunctionconstructor to create and initialize a subclass instance with the internal slots necessary for built-in async function behaviour. All ECMAScript syntactic forms for defining async function objects create direct instances of AsyncFunction. There is no syntactic means to create instances of AsyncFunction subclasses.
27.7.1.1 AsyncFunction (p1,p2, … ,pn,body )
The last argument specifies the body (executable code) of an async function. Any preceding arguments specify formal parameters.
When theAsyncFunction function is called with some argumentsp1,p2, … ,pn,body (wheren might be 0, that is, there are nop arguments, and wherebody might also not be provided), the following steps are taken:
- LetC be the
active function object . - Letargs be theargumentsList that was passed to this function by [[Call]] or [[Construct]].
- Return
CreateDynamicFunction (C, NewTarget,async ,args).
27.7.2 Properties of the AsyncFunction Constructor
The AsyncFunction
- is a standard built-in
function object that inherits from the Functionconstructor . - has a [[Prototype]] internal slot whose value is
%Function% . - has a
"name" property whose value is"AsyncFunction" . - has the following properties:
27.7.2.1 AsyncFunction.length
This is a
27.7.2.2 AsyncFunction.prototype
The initial value ofAsyncFunction.prototype is the
This property has the attributes { [[Writable]]:
27.7.3 Properties of the AsyncFunction Prototype Object
TheAsyncFunction prototype object:
- is%AsyncFunction.prototype%.
- is an
ordinary object . - is not a
function object and does not have an [[ECMAScriptCode]] internal slot or any other of the internal slots listed inTable 29 . - has a [[Prototype]] internal slot whose value is
%Function.prototype% .
27.7.3.1 AsyncFunction.prototype.constructor
The initial value ofAsyncFunction.prototype.constructor is
This property has the attributes { [[Writable]]:
27.7.3.2 AsyncFunction.prototype [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
27.7.4 AsyncFunction Instances
Every AsyncFunction instance is an ECMAScript
Each AsyncFunction instance has the following own properties:
27.7.4.1 length
The specification for the
27.7.4.2 name
The specification for the
27.7.5 Async Functions Abstract Operations
27.7.5.1 AsyncFunctionStart (promiseCapability,asyncFunctionBody )
The abstract operation AsyncFunctionStart takes argumentspromiseCapability (a
- LetrunningContext be the
running execution context . - LetasyncContext be a copy ofrunningContext.
- NOTE: Copying the execution state is required for the step below to resume its execution. It is ill-defined to resume a currently executing context.
- Set the code evaluation state ofasyncContext such that when evaluation is resumed for that
execution context the following steps will be performed:- Letresult be the result of evaluatingasyncFunctionBody.
Assert : If we return here, the async function either threw an exception or performed an implicit or explicit return; all awaiting is done.- RemoveasyncContext from the
execution context stack and restore theexecution context that is at the top of theexecution context stack as therunning execution context . - Ifresult.[[Type]] is
normal , then- Perform !
Call (promiseCapability.[[Resolve]],undefined , «undefined »).
- Perform !
- Else ifresult.[[Type]] is
return , then- Perform !
Call (promiseCapability.[[Resolve]],undefined , «result.[[Value]] »).
- Perform !
- Else,
- Return.
- PushasyncContext onto the
execution context stack ;asyncContext is now therunning execution context . - Resume the suspended evaluation ofasyncContext. Letresult be the value returned by the resumed computation.
Assert : When we return here,asyncContext has already been removed from theexecution context stack andrunningContext is the currentlyrunning execution context .Assert :result is a normal completion with a value ofundefined . The possible sources of completion values areAwait or, if the async function doesn't await anything, step4.g above.- Return.
28 Reflection
28.1 The Reflect Object
The Reflect object:
- is%Reflect%.
- is the initial value of the
"Reflect" property of theglobal object . - is an
ordinary object . - has a [[Prototype]] internal slot whose value is
%Object.prototype% . - is not a
function object . - does not have a [[Construct]] internal method; it cannot be used as a
constructor with thenewoperator. - does not have a [[Call]] internal method; it cannot be invoked as a function.
28.1.1 Reflect.apply (target,thisArgument,argumentsList )
When theapply function is called with argumentstarget,thisArgument, andargumentsList, the following steps are taken:
- If
IsCallable (target) isfalse , throw aTypeError exception. - Letargs be ?
CreateListFromArrayLike (argumentsList). - Perform
PrepareForTailCall (). - Return ?
Call (target,thisArgument,args).
28.1.2 Reflect.construct (target,argumentsList [ ,newTarget ] )
When theconstruct function is called with argumentstarget,argumentsList, andnewTarget, the following steps are taken:
- If
IsConstructor (target) isfalse , throw aTypeError exception. - IfnewTarget is not present, setnewTarget totarget.
- Else if
IsConstructor (newTarget) isfalse , throw aTypeError exception. - Letargs be ?
CreateListFromArrayLike (argumentsList). - Return ?
Construct (target,args,newTarget).
28.1.3 Reflect.defineProperty (target,propertyKey,attributes )
When thedefineProperty function is called with argumentstarget,propertyKey, andattributes, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (propertyKey). - Letdesc be ?
ToPropertyDescriptor (attributes). - Return ?target.[[DefineOwnProperty]](key,desc).
28.1.4 Reflect.deleteProperty (target,propertyKey )
When thedeleteProperty function is called with argumentstarget andpropertyKey, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (propertyKey). - Return ?target.[[Delete]](key).
28.1.5 Reflect.get (target,propertyKey [ ,receiver ] )
When theget function is called with argumentstarget,propertyKey, andreceiver, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (propertyKey). - Ifreceiver is not present, then
- Setreceiver totarget.
- Return ?target.[[Get]](key,receiver).
28.1.6 Reflect.getOwnPropertyDescriptor (target,propertyKey )
When thegetOwnPropertyDescriptor function is called with argumentstarget andpropertyKey, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (propertyKey). - Letdesc be ?target.[[GetOwnProperty]](key).
- Return
FromPropertyDescriptor (desc).
28.1.7 Reflect.getPrototypeOf (target )
When thegetPrototypeOf function is called with argumenttarget, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Return ?target.[[GetPrototypeOf]]().
28.1.8 Reflect.has (target,propertyKey )
When thehas function is called with argumentstarget andpropertyKey, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (propertyKey). - Return ?target.[[HasProperty]](key).
28.1.9 Reflect.isExtensible (target )
When theisExtensible function is called with argumenttarget, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Return ?target.[[IsExtensible]]().
28.1.10 Reflect.ownKeys (target )
When theownKeys function is called with argumenttarget, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkeys be ?target.[[OwnPropertyKeys]]().
- Return
CreateArrayFromList (keys).
28.1.11 Reflect.preventExtensions (target )
When thepreventExtensions function is called with argumenttarget, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Return ?target.[[PreventExtensions]]().
28.1.12 Reflect.set (target,propertyKey,V [ ,receiver ] )
When theset function is called with argumentstarget,V,propertyKey, andreceiver, the following steps are taken:
- If
Type (target) is not Object, throw aTypeError exception. - Letkey be ?
ToPropertyKey (propertyKey). - Ifreceiver is not present, then
- Setreceiver totarget.
- Return ?target.[[Set]](key,V,receiver).
28.1.13 Reflect.setPrototypeOf (target,proto )
When thesetPrototypeOf function is called with argumentstarget andproto, the following steps are taken:
28.1.14 Reflect [ @@toStringTag ]
The initial value of the
This property has the attributes { [[Writable]]:
28.2 Proxy Objects
28.2.1 The Proxy Constructor
The Proxy
- is%Proxy%.
- is the initial value of the
"Proxy" property of theglobal object . - creates and initializes a new
Proxy exotic object when called as aconstructor . - is not intended to be called as a function and will throw an exception when called in that manner.
28.2.1.1 Proxy (target,handler )
WhenProxy is called with argumentstarget andhandler, it performs the following steps:
- If NewTarget is
undefined , throw aTypeError exception. - Return ?
ProxyCreate (target,handler).
28.2.2 Properties of the Proxy Constructor
The Proxy
- has a [[Prototype]] internal slot whose value is
%Function.prototype% . - does not have a
"prototype" property because Proxy exotic objects do not have a [[Prototype]] internal slot that requires initialization. - has the following properties:
28.2.2.1 Proxy.revocable (target,handler )
TheProxy.revocable function is used to create a revocable Proxy object. WhenProxy.revocable is called with argumentstarget andhandler, the following steps are taken:
- Letp be ?
ProxyCreate (target,handler). - Letsteps be the algorithm steps defined in
Proxy Revocation Functions . - Letlength be the number of non-optional parameters of the function definition in
Proxy Revocation Functions . - Letrevoker be !
CreateBuiltinFunction (steps,length,"" , « [[RevocableProxy]] »). - Setrevoker.[[RevocableProxy]] top.
- Letresult be !
OrdinaryObjectCreate (%Object.prototype% ). - Perform !
CreateDataPropertyOrThrow (result,"proxy" ,p). - Perform !
CreateDataPropertyOrThrow (result,"revoke" ,revoker). - Returnresult.
28.2.2.1.1 Proxy Revocation Functions
A Proxy revocation function is an anonymous built-in function that has the ability to invalidate a specific Proxy object.
Each Proxy revocation function has a [[RevocableProxy]] internal slot.
When a Proxy revocation function is called, the following steps are taken:
- LetF be the
active function object . - Letp beF.[[RevocableProxy]].
- Ifp is
null , returnundefined . - SetF.[[RevocableProxy]] to
null . Assert :p is a Proxy object.- Setp.[[ProxyTarget]] to
null . - Setp.[[ProxyHandler]] to
null . - Return
undefined .
The
28.3 Module Namespace Objects
A Module Namespace Object is a
In addition to the properties specified in
28.3.1 @@toStringTag
The initial value of the
This property has the attributes { [[Writable]]:
29 Memory Model
The memory consistency model, ormemory model, specifies the possible orderings of
The memory model is defined as relational constraints on events introduced by
This section provides an axiomatic model on events introduced by the
29.1 Memory Model Fundamentals
Shared memory accesses (reads and writes) are divided into two groups, atomic accesses and data accesses, defined below. Atomic accesses are sequentially consistent, i.e., there is a strict total ordering of events agreed upon by all agents in an
No orderings weaker than sequentially consistent and stronger than unordered, such as release-acquire, are supported.
AShared Data Block event is either aReadSharedMemory,WriteSharedMemory, orReadModifyWriteSharedMemory
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] | The weakest ordering guaranteed by the | |
| [[NoTear]] | A Boolean | Whether this event is allowed to read from multiple write events on equal range as this event. |
| [[Block]] | A | The block the event operates on. |
| [[ByteIndex]] | A non-negative | The byte address of the read in [[Block]]. |
| [[ElementSize]] | A non-negative | The size of the read. |
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] | The weakest ordering guaranteed by the | |
| [[NoTear]] | A Boolean | Whether this event is allowed to be read from multiple read events with equal range as this event. |
| [[Block]] | A | The block the event operates on. |
| [[ByteIndex]] | A non-negative | The byte address of the write in [[Block]]. |
| [[ElementSize]] | A non-negative | The size of the write. |
| [[Payload]] | A | The |
| Field Name | Value | Meaning |
|---|---|---|
| [[Order]] | Read-modify-write events are always sequentially consistent. | |
| [[NoTear]] | Read-modify-write events cannot tear. | |
| [[Block]] | A | The block the event operates on. |
| [[ByteIndex]] | A non-negative | The byte address of the read-modify-write in [[Block]]. |
| [[ElementSize]] | A non-negative | The size of the read-modify-write. |
| [[Payload]] | A | The |
| [[ModifyOp]] | A | An abstract closure that returns a modified |
These events are introduced by
Some operations may also introduceSynchronize events. ASynchronize event has no fields, and exists purely to directly constrain the permitted orderings of other events.
In addition to
Let the range of a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory event be the Set of contiguous integers from its [[ByteIndex]] to [[ByteIndex]] + [[ElementSize]] - 1. Two events' ranges are equal when the events have the same [[Block]], and the ranges are element-wise equal. Two events' ranges are overlapping when the events have the same [[Block]], the ranges are not equal and their intersection is non-empty. Two events' ranges are disjoint when the events do not have the same [[Block]] or their ranges are neither equal nor overlapping.
Examples ofpostMessage in a browser), starting and stopping agents, and communicating within the
Events are ordered within candidate executions by the relations defined below.
29.2 Agent Events Records
AnAgent Events Record is a
| Field Name | Value | Meaning |
|---|---|---|
| [[AgentSignifier]] | A value that admits equality testing | The |
| [[EventList]] | A | Events are appended to the list during evaluation. |
| [[AgentSynchronizesWith]] | A |
29.3 Chosen Value Records
AChosen Value Record is a
| Field Name | Value | Meaning |
|---|---|---|
| [[Event]] | A | The |
| [[ChosenValue]] | A | The bytes that were nondeterministically chosen during evaluation. |
29.4 Candidate Executions
Acandidate execution of the evaluation of an
| Field Name | Value | Meaning |
|---|---|---|
| [[EventsRecords]] | A | Maps an |
| [[ChosenValues]] | A | Maps |
| [[AgentOrder]] | An | Defined below. |
| [[ReadsBytesFrom]] | A | Defined below. |
| [[ReadsFrom]] | A | Defined below. |
| [[HostSynchronizesWith]] | A | Defined below. |
| [[SynchronizesWith]] | A | Defined below. |
| [[HappensBefore]] | A | Defined below. |
Anempty candidate execution is a candidate execution
29.5 Abstract Operations for the Memory Model
29.5.1 EventSet (execution )
The abstract operation EventSet takes argumentexecution (a
- Letevents be an empty Set.
- For each
Agent Events Record aer ofexecution.[[EventsRecords]], do- For each eventE ofaer.[[EventList]], do
- AddE toevents.
- For each eventE ofaer.[[EventList]], do
- Returnevents.
29.5.2 SharedDataBlockEventSet (execution )
The abstract operation SharedDataBlockEventSet takes argumentexecution (a
- Letevents be an empty Set.
- For each eventE of
EventSet (execution), do- IfE is a
ReadSharedMemory ,WriteSharedMemory , orReadModifyWriteSharedMemory event, addE toevents.
- IfE is a
- Returnevents.
29.5.3 HostEventSet (execution )
The abstract operation HostEventSet takes argumentexecution (a
- Letevents be an empty Set.
- For each eventE of
EventSet (execution), do- IfE is not in
SharedDataBlockEventSet (execution), addE toevents.
- IfE is not in
- Returnevents.
29.5.4 ComposeWriteEventBytes (execution,byteIndex,Ws )
The abstract operation ComposeWriteEventBytes takes argumentsexecution (a
- LetbyteLocation bebyteIndex.
- LetbytesRead be a new empty
List . - For each elementW ofWs, do
Assert :W hasbyteLocation in its range.- LetpayloadIndex bebyteLocation -W.[[ByteIndex]].
- IfW is a
WriteSharedMemory event, then- Letbyte beW.[[Payload]][payloadIndex].
- Else,
Assert :W is aReadModifyWriteSharedMemory event.- Letbytes be
ValueOfReadEvent (execution,W). - LetbytesModified beW.[[ModifyOp]](bytes,W.[[Payload]]).
- Letbyte bebytesModified[payloadIndex].
- Appendbyte tobytesRead.
- SetbyteLocation tobyteLocation + 1.
- ReturnbytesRead.
The read-modify-write modification [[ModifyOp]] is given by the function properties on the Atomics object that introduce
This abstract operation composes a
29.5.5 ValueOfReadEvent (execution,R )
The abstract operation ValueOfReadEvent takes argumentsexecution (a
Assert :R is aReadSharedMemory orReadModifyWriteSharedMemory event.- LetWs beexecution.[[ReadsBytesFrom]](R).
Assert :Ws is aList ofWriteSharedMemory orReadModifyWriteSharedMemory events with length equal toR.[[ElementSize]].- Return
ComposeWriteEventBytes (execution,R.[[ByteIndex]],Ws).
29.6 Relations of Candidate Executions
29.6.1 agent-order
For a
- For each pair (E,D) in
EventSet (execution), (E,D) is inexecution.[[AgentOrder]] if there is someAgent Events Record aer inexecution.[[EventsRecords]] such thatE andD are inaer.[[EventList]] andE is beforeD inList order ofaer.[[EventList]].
Each
29.6.2 reads-bytes-from
For a
For each
ReadSharedMemory orReadModifyWriteSharedMemory eventR inSharedDataBlockEventSet (execution),execution.[[ReadsBytesFrom]](R) is aList of lengthR.[[ElementSize]] whose elements areWriteSharedMemory orReadModifyWriteSharedMemory eventsWs such that all of the following are true.- Each eventW with indexi inWs hasR.[[ByteIndex]] +i in its range.
- R is not inWs.
29.6.3 reads-from
For a
- For each pair (R,W) in
SharedDataBlockEventSet (execution), (R,W) is inexecution.[[ReadsFrom]] ifW is inexecution.[[ReadsBytesFrom]](R).
29.6.4 host-synchronizes-with
For a
- If (E,D) is inexecution.[[HostSynchronizesWith]],E andD are in
HostEventSet (execution). - There is no cycle in the union ofexecution.[[HostSynchronizesWith]] andexecution.[[AgentOrder]].
For two
The host-synchronizes-with relation allows thepostMessage between HTML workers.
29.6.5 synchronizes-with
For a
- For each pair (R,W) inexecution.[[ReadsFrom]], (W,R) is inexecution.[[SynchronizesWith]] ifR.[[Order]] is
SeqCst ,W.[[Order]] isSeqCst , andR andW have equal ranges. - For each elementeventsRecord ofexecution.[[EventsRecords]], the following is true.
- For each pair (S,Sw) ineventsRecord.[[AgentSynchronizesWith]], (S,Sw) is inexecution.[[SynchronizesWith]].
- For each pair (E,D) inexecution.[[HostSynchronizesWith]], (E,D) is inexecution.[[SynchronizesWith]].
Owing to convention, write events synchronizes-with read events, instead of read events synchronizes-with write events.
Not all
For
29.6.6 happens-before
For a
- For each pair (E,D) inexecution.[[AgentOrder]], (E,D) is inexecution.[[HappensBefore]].
- For each pair (E,D) inexecution.[[SynchronizesWith]], (E,D) is inexecution.[[HappensBefore]].
- For each pair (E,D) in
SharedDataBlockEventSet (execution), (E,D) is inexecution.[[HappensBefore]] ifE.[[Order]] isInit andE andD have overlapping ranges. - For each pair (E,D) in
EventSet (execution), (E,D) is inexecution.[[HappensBefore]] if there is an eventF such that the pairs (E,F) and (F,D) are inexecution.[[HappensBefore]].
Because happens-before is a superset of
29.7 Properties of Valid Executions
29.7.1 Valid Chosen Reads
A
- For each
ReadSharedMemory orReadModifyWriteSharedMemory eventR ofSharedDataBlockEventSet (execution), do- LetchosenValueRecord be the element ofexecution.[[ChosenValues]] whose [[Event]] field isR.
- LetchosenValue bechosenValueRecord.[[ChosenValue]].
- LetreadValue be
ValueOfReadEvent (execution,R). - LetchosenLen be the number of elements ofchosenValue.
- LetreadLen be the number of elements ofreadValue.
- IfchosenLen ≠readLen, then
- Return
false .
- Return
- IfchosenValue[i] ≠readValue[i] for any
integer valuei in the range 0 throughchosenLen, exclusive, then- Return
false .
- Return
- Return
true .
29.7.2 Coherent Reads
A
- For each
ReadSharedMemory orReadModifyWriteSharedMemory eventR ofSharedDataBlockEventSet (execution), do- LetWs beexecution.[[ReadsBytesFrom]](R).
- LetbyteLocation beR.[[ByteIndex]].
- For each elementW ofWs, do
- If (R,W) is inexecution.[[HappensBefore]], then
- Return
false .
- Return
- If there is a
WriteSharedMemory orReadModifyWriteSharedMemory eventV that hasbyteLocation in its range such that the pairs (W,V) and (V,R) are inexecution.[[HappensBefore]], then- Return
false .
- Return
- SetbyteLocation tobyteLocation + 1.
- If (R,W) is inexecution.[[HappensBefore]], then
- Return
true .
29.7.3 Tear Free Reads
A
- For each
ReadSharedMemory orReadModifyWriteSharedMemory eventR ofSharedDataBlockEventSet (execution), do- IfR.[[NoTear]] is
true , thenAssert : The remainder of dividingR.[[ByteIndex]] byR.[[ElementSize]] is 0.- For each eventW such that (R,W) is inexecution.[[ReadsFrom]] andW.[[NoTear]] is
true , do- IfR andW have equal ranges, and there is an eventV such thatV andW have equal ranges,V.[[NoTear]] is
true ,W is notV, and (R,V) is inexecution.[[ReadsFrom]], then- Return
false .
- Return
- IfR andW have equal ranges, and there is an eventV such thatV andW have equal ranges,V.[[NoTear]] is
- IfR.[[NoTear]] is
- Return
true .
An event's [[NoTear]] field is
Intuitively, this requirement says when a memory range is accessed in an aligned fashion via an
29.7.4 Sequentially Consistent Atomics
For a
- For each pair (E,D) inexecution.[[HappensBefore]], (E,D) is in memory-order.
For each pair (R,W) inexecution.[[ReadsFrom]], there is no
WriteSharedMemory orReadModifyWriteSharedMemory eventV inSharedDataBlockEventSet (execution) such thatV.[[Order]] isSeqCst , the pairs (W,V) and (V,R) are in memory-order, and any of the following conditions are true.- The pair (W,R) is inexecution.[[SynchronizesWith]], andV andR have equal ranges.
- The pairs (W,R) and (V,R) are inexecution.[[HappensBefore]],W.[[Order]] is
SeqCst , andW andV have equal ranges. - The pairs (W,R) and (W,V) are inexecution.[[HappensBefore]],R.[[Order]] is
SeqCst , andV andR have equal ranges.
Note 1 This clause additionally constrains
SeqCst events on equal ranges.For each
WriteSharedMemory orReadModifyWriteSharedMemory eventW inSharedDataBlockEventSet (execution), ifW.[[Order]] isSeqCst , then it is not the case that there is an infinite number ofReadSharedMemory orReadModifyWriteSharedMemory events inSharedDataBlockEventSet (execution) with equal range that is memory-order beforeW.Note 2 This clause together with the forward progress guarantee on agents ensure the liveness condition that
SeqCst writes become visible toSeqCst reads with equal range in finite time.
A
While memory-order includes all events in
29.7.5 Valid Executions
A
- The
host provides ahost-synchronizes-with Relation forexecution.[[HostSynchronizesWith]]. - execution.[[HappensBefore]] is a
strict partial order . - execution has valid chosen reads.
- execution has coherent reads.
- execution has tear free reads.
- execution has sequentially consistent atomics.
All programs have at least one valid execution.
29.8 Races
For an executionexecution, two eventsE andD in
- IfE is notD, then
- If the pairs (E,D) and (D,E) are not inexecution.[[HappensBefore]], then
- IfE andD are both
WriteSharedMemory orReadModifyWriteSharedMemory events andE andD do not have disjoint ranges, then- Return
true .
- Return
- If either (E,D) or (D,E) is inexecution.[[ReadsFrom]], then
- Return
true .
- Return
- IfE andD are both
- If the pairs (E,D) and (D,E) are not inexecution.[[HappensBefore]], then
- Return
false .
29.9 Data Races
For an executionexecution, two eventsE andD in
- IfE andD are in a race inexecution, then
- IfE.[[Order]] is not
SeqCst orD.[[Order]] is notSeqCst , then- Return
true .
- Return
- IfE andD have overlapping ranges, then
- Return
true .
- Return
- IfE.[[Order]] is not
- Return
false .
29.10 Data Race Freedom
An executionexecution is data race free if there are no two events in
A program is data race free if all its executions are data race free.
The
29.11 Shared Memory Guidelines
The following are guidelines for ECMAScript programmers working with shared memory.
We recommend programs be kept data race free, i.e., make it so that it is impossible for there to be concurrent non-atomic operations on the same memory location. Data race free programs have interleaving semantics where each step in the evaluation semantics of each
More generally, even if a program is not data race free it may have predictable behaviour, so long as atomic operations are not involved in any data races and the operations that race all have the same access size. The simplest way to arrange for atomics not to be involved in races is to ensure that different memory cells are used by atomic and non-atomic operations and that atomic accesses of different sizes are not used to access the same cells at the same time. Effectively, the program should treat shared memory as strongly typed as much as possible. One still cannot depend on the ordering and timing of non-atomic accesses that race, but if memory is treated as strongly typed the racing accesses will not "tear" (bits of their values will not be mixed).
The following are guidelines for ECMAScript implementers writing compiler transformations for programs using shared memory.
It is desirable to allow most program transformations that are valid in a single-
Let anagent-order slice be the subset of the
Letpossible read values of a read event be the set of all values of
Any transformation of an agent-order slice that is valid in the absence of shared memory is valid in the presence of shared memory, with the following exceptions.
Atomics are carved in stone: Program transformations must not cause the
SeqCst events in an agent-order slice to be reordered with itsUnordered operations, nor itsSeqCst operations to be reordered with each other, nor may a program transformation remove aSeqCst operation from theagent-order .(In practice, the prohibition on reorderings forces a compiler to assume that every
SeqCst operation is a synchronization and included in the finalmemory-order , which it would usually have to assume anyway in the absence of inter-agent program analysis. It also forces the compiler to assume that every call where the callee's effects on thememory-order are unknown may containSeqCst operations.)Reads must be stable: Any given shared memory read must only observe a single value in an execution.
(For example, if what is semantically a single read in the program is executed multiple times then the program is subsequently allowed to observe only one of the values read. A transformation known as rematerialization can violate this rule.)
Writes must be stable: All observable writes to shared memory must follow from program semantics in an execution.
(For example, a transformation may not introduce certain observable writes, such as by using read-modify-write operations on a larger location to write a smaller datum, writing a value to memory that the program could not have written, or writing a just-read value back to the location it was read from, if that location could have been overwritten by another
agent after the read.)Possible read values must be nonempty: Program transformations cannot cause the possible read values of a shared memory read to become empty.
(Counterintuitively, this rule in effect restricts transformations on writes, because writes have force in
memory model insofar as to be read by read events. For example, writes may be moved and coalesced and sometimes reordered between twoSeqCst operations, but the transformation may not remove every write that updates a location; some write must be preserved.)
Examples of transformations that remain valid are: merging multiple non-atomic reads from the same location, reordering non-atomic reads, introducing speculative non-atomic reads, merging multiple non-atomic writes to the same location, reordering non-atomic writes to different locations, and hoisting non-atomic reads out of loops even if that affects termination. Note in general that aliased TypedArrays make it hard to prove that locations are different.
The following are guidelines for ECMAScript implementers generating machine code for shared memory accesses.
For architectures with memory models no weaker than those of ARM or Power, non-atomic stores and loads may be compiled to bare stores and loads on the target architecture. Atomic stores and loads may be compiled down to instructions that guarantee sequential consistency. If no such instructions exist, memory barriers are to be employed, such as placing barriers on both sides of a bare store or load. Read-modify-write operations may be compiled to read-modify-write instructions on the target architecture, such asLOCK-prefixed instructions on x86, load-exclusive/store-exclusive instructions on ARM, and load-link/store-conditional instructions on Power.
Specifically, the
- Every atomic operation in the program is assumed to be necessary.
- Atomic operations are never rearranged with each other or with non-atomic operations.
- Functions are always assumed to perform atomic operations.
- Atomic operations are never implemented as read-modify-write operations on larger data, but as non-lock-free atomics if the platform does not have atomic operations of the appropriate size. (We already assume that every platform has normal memory access operations of every interesting size.)
Naive code generation uses these patterns:
- Regular loads and stores compile to single load and store instructions.
- Lock-free atomic loads and stores compile to a full (sequentially consistent) fence, a regular load or store, and a full fence.
- Lock-free atomic read-modify-write accesses compile to a full fence, an atomic read-modify-write instruction sequence, and a full fence.
- Non-lock-free atomics compile to a spinlock acquire, a full fence, a series of non-atomic load and store instructions, a full fence, and a spinlock release.
That mapping is correct so long as an atomic operation on an address range does not race with a non-atomic write or with an atomic operation of different size. However, that is all we need: the
A number of local improvements to those basic patterns are also intended to be legal:
- There are obvious platform-dependent improvements that remove redundant fences. For example, on x86 the fences around lock-free atomic loads and stores can always be omitted except for the fence following a store, and no fence is needed for lock-free read-modify-write instructions, as these all use LOCK-prefixed instructions. On many platforms there are fences of several strengths, and weaker fences can be used in certain contexts without destroying sequential consistency.
- Most modern platforms support lock-free atomics for all the data sizes required by ECMAScript atomics. Should non-lock-free atomics be needed, the fences surrounding the body of the atomic operation can usually be folded into the lock and unlock steps. The simplest solution for non-lock-free atomics is to have a single lock word per SharedArrayBuffer.
- There are also more complicated platform-dependent local improvements, requiring some code analysis. For example, two back-to-back fences often have the same effect as a single fence, so if code is generated for two atomic operations in sequence, only a single fence need separate them. On x86, even a single fence separating atomic stores can be omitted, as the fence following a store is only needed to separate the store from a subsequent load.
A Grammar Summary
A.1 Lexical Grammar
A.2 Expressions
When processing an instance of the production
the interpretation of
When processing an instance of the production
the interpretation of
In certain circumstances when processing an instance of the production
the interpretation of
A.3 Statements
A.4 Functions and Classes
When processing an instance of the production
the interpretation of
When processing an instance of the production
the interpretation of
A.5 Scripts and Modules
A.6 Number Conversions
All grammar symbols not explicitly defined by the
A.7 Universal Resource Identifier Character Classes
A.8 Regular Expressions
Each\uuu\u
B Additional ECMAScript Features for Web Browsers
The ECMAScript language syntax and semantics defined in this annex are required when the ECMAScript
This annex describes various legacy features and other characteristics of web browser ECMAScript hosts. All of the language features and behaviours specified in this annex have one or more undesirable characteristics and in the absence of legacy usage would be removed from this specification. However, the usage of these features by large numbers of existing web pages means that web browsers must continue to support them. The specifications in this annex define the requirements for interoperable implementations of these legacy features.
These features are not considered part of the core ECMAScript language. Programmers should not use or assume the existence of these features and behaviours when writing new ECMAScript code. ECMAScript implementations are discouraged from implementing these features unless the implementation is part of a web browser or is required to run the same legacy ECMAScript code that web browsers encounter.
B.1 Additional Syntax
B.1.1 Numeric Literals
The syntax and semantics of
Syntax
B.1.1.1 Static Semantics
- The MV of
LegacyOctalIntegerLiteral :: 0 OctalDigit OctalDigit . - The MV of
LegacyOctalIntegerLiteral :: LegacyOctalIntegerLiteral OctalDigit LegacyOctalIntegerLiteral times 8) plus the MV ofOctalDigit . - The MV of
DecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral NonOctalDecimalIntegerLiteral . - The MV of
NonOctalDecimalIntegerLiteral :: 0 NonOctalDigit NonOctalDigit . - The MV of
NonOctalDecimalIntegerLiteral :: LegacyOctalLikeDecimalIntegerLiteral NonOctalDigit LegacyOctalLikeDecimalIntegerLiteral times 10) plus the MV ofNonOctalDigit . - The MV of
NonOctalDecimalIntegerLiteral :: NonOctalDecimalIntegerLiteral DecimalDigit NonOctalDecimalIntegerLiteral times 10) plus the MV ofDecimalDigit . - The MV of
LegacyOctalLikeDecimalIntegerLiteral :: 0 OctalDigit OctalDigit . - The MV of
LegacyOctalLikeDecimalIntegerLiteral :: LegacyOctalLikeDecimalIntegerLiteral OctalDigit LegacyOctalLikeDecimalIntegerLiteral times 10) plus the MV ofOctalDigit . - The MV of
NonOctalDigit :: 8 - The MV of
NonOctalDigit :: 9
B.1.2 String Literals
The syntax and semantics of
Syntax
This definition of
It is possible for string literals to precede a
functioninvalid(){"\7";"use strict"; }B.1.2.1 Static Semantics
- The
SV ofEscapeSequence :: LegacyOctalEscapeSequence LegacyOctalEscapeSequence . - The MV of
LegacyOctalEscapeSequence :: ZeroToThree OctalDigit ZeroToThree ) plus the MV ofOctalDigit . - The MV of
LegacyOctalEscapeSequence :: FourToSeven OctalDigit FourToSeven ) plus the MV ofOctalDigit . - The MV of
LegacyOctalEscapeSequence :: ZeroToThree OctalDigit OctalDigit ZeroToThree ) plus (8 times the MV of the firstOctalDigit ) plus the MV of the secondOctalDigit . - The
SV ofNonOctalDecimalEscapeSequence :: 8 - The
SV ofNonOctalDecimalEscapeSequence :: 9 - The MV of
ZeroToThree :: 0 - The MV of
ZeroToThree :: 1 - The MV of
ZeroToThree :: 2 - The MV of
ZeroToThree :: 3 - The MV of
FourToSeven :: 4 - The MV of
FourToSeven :: 5 - The MV of
FourToSeven :: 6 - The MV of
FourToSeven :: 7
B.1.3 HTML-like Comments
The syntax and semantics of
Syntax
Similar to a
B.1.4 Regular Expressions Patterns
The syntax of
This alternative pattern grammar and semantics only changes the syntax and semantics of BMP patterns. The following grammar extensions include productions parameterized with the [U] parameter. However, none of these extensions change the syntax of Unicode patterns recognized when parsing with the [U] parameter present on the
Syntax
When the same left hand sides occurs with both [+U] and [~U] guards it is to control the disambiguation priority.
B.1.4.1 Static Semantics: Early Errors
The semantics of
- It is a Syntax Error if any source text matches this rule.
Additionally, the rules for the following productions are modified with the addition of thehighlighted text:
- It is a Syntax Error if
IsCharacterClass of the firstClassAtom istrue orIsCharacterClass of the secondClassAtom istrue and this production has a[U] parameter. - It is a Syntax Error if
IsCharacterClass of the firstClassAtom isfalse andIsCharacterClass of the secondClassAtom isfalse and theCharacterValue of the firstClassAtom is larger than theCharacterValue of the secondClassAtom .
- It is a Syntax Error if
IsCharacterClass ofClassAtomNoDash istrue orIsCharacterClass ofClassAtom istrue and this production has a[U] parameter. - It is a Syntax Error if
IsCharacterClass ofClassAtomNoDash isfalse andIsCharacterClass ofClassAtom isfalse and theCharacterValue ofClassAtomNoDash is larger than theCharacterValue ofClassAtom .
B.1.4.2 Static Semantics: IsCharacterClass
The semantics of
- Return
false .
B.1.4.3 Static Semantics: CharacterValue
The semantics of
- Return the code point value of U+005C (REVERSE SOLIDUS).
- Letch be the code point matched by
ClassControlLetter . - Leti bech's code point value.
- Return the remainder of dividingi by 32.
- Return the MV of
LegacyOctalEscapeSequence (seeB.1.2 ).
B.1.4.4 Pattern Semantics
The semantics of
Within
Term (
The production
The production
The production
Assertion (
The production
- Evaluate
QuantifiableAssertion to obtain a Matcherm. - Returnm.
Assertion (
Atom (
The production
- LetA be the CharSet containing the single character
\U+005C (REVERSE SOLIDUS). - Return !
CharacterSetMatcher (A,false ,direction).
The production
- Letch be the character represented by
ExtendedPatternCharacter . - LetA be a one-element CharSet containing the characterch.
- Return !
CharacterSetMatcher (A,false ,direction).
CharacterEscape (
The production
- Letcv be the
CharacterValue of thisCharacterEscape . - Return the character whose character value iscv.
NonemptyClassRanges (
The production
- Evaluate the first
ClassAtom to obtain a CharSetA. - Evaluate the second
ClassAtom to obtain a CharSetB. - Evaluate
ClassRanges to obtain a CharSetC. - LetD be !
CharacterRangeOrUnion (A,B). - Return the union ofD andC.
NonemptyClassRangesNoDash (
The production
- Evaluate
ClassAtomNoDash to obtain a CharSetA. - Evaluate
ClassAtom to obtain a CharSetB. - Evaluate
ClassRanges to obtain a CharSetC. - LetD be !
CharacterRangeOrUnion (A,B). - Return the union ofD andC.
ClassEscape (
The production
- Letcv be the
CharacterValue of thisClassEscape . - Letc be the character whose character value iscv.
- Return the CharSet containing the single characterc.
ClassAtomNoDash (
The production
- Return the CharSet containing the single character
\U+005C (REVERSE SOLIDUS).
\c within a character class where it is not followed by an acceptable control character.B.1.4.4.1 CharacterRangeOrUnion (A,B )
The abstract operation CharacterRangeOrUnion takes argumentsA (a CharSet) andB (a CharSet). It performs the following steps when called:
- IfUnicode is
false , then- IfA does not contain exactly one character orB does not contain exactly one character, then
- LetC be the CharSet containing the single character
-U+002D (HYPHEN-MINUS). - Return the union of CharSetsA,B andC.
- LetC be the CharSet containing the single character
- IfA does not contain exactly one character orB does not contain exactly one character, then
- Return !
CharacterRange (A,B).
B.2 Additional Built-in Properties
When the ECMAScript
B.2.1 Additional Properties of the Global Object
The entries in
| Intrinsic Name | Global Name | ECMAScript Language Association |
|---|---|---|
escape | Theescape function ( | |
unescape | Theunescape function ( |
B.2.1.1 escape (string )
Theescape function is a property of the
For those code units being replaced whose value is0x00FF or less, a two-digit escape sequence of the form%xx is used. For those characters being replaced whose code unit value is greater than0x00FF, a four-digit escape sequence of the form%uxxxx is used.
Theescape function is the%escape% intrinsic object. When theescape function is called with one argumentstring, the following steps are taken:
- Setstring to ?
ToString (string). - Letlength be the number of code units instring.
- LetR be the empty String.
- Letk be 0.
- Repeat, whilek <length,
- Letchar be the code unit (represented as a 16-bit unsigned
integer ) at indexk withinstring. - Ifchar is one of the code units in
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./" , then- LetS be the String value containing the single code unitchar.
- Else ifchar ≥ 256, then
- Letn be the numeric value ofchar.
- LetS be the
string-concatenation of:"%u" - the String representation ofn, formatted as a four-digit uppercase hexadecimal number, padded to the left with zeroes if necessary
- Else,
Assert :char < 256.- Letn be the numeric value ofchar.
- LetS be the
string-concatenation of:"%" - the String representation ofn, formatted as a two-digit uppercase hexadecimal number, padded to the left with a zero if necessary
- SetR to the
string-concatenation ofR andS. - Setk tok + 1.
- Letchar be the code unit (represented as a 16-bit unsigned
- ReturnR.
The encoding is partly based on the encoding described in RFC 1738, but the entire encoding specified in this standard is described above without regard to the contents of RFC 1738. This encoding does not reflect changes to RFC 1738 made by RFC 3986.
B.2.1.2 unescape (string )
Theunescape function is a property of theescape function is replaced with the code unit that it represents.
Theunescape function is the%unescape% intrinsic object. When theunescape function is called with one argumentstring, the following steps are taken:
- Setstring to ?
ToString (string). - Letlength be the number of code units instring.
- LetR be the empty String.
- Letk be 0.
- Repeat, whilek ≠length,
- Letc be the code unit at indexk withinstring.
- Ifc is the code unit 0x0025 (PERCENT SIGN), then
- LethexEscape be the empty String.
- Letskip be 0.
- Ifk ≤length - 6 and the code unit at indexk + 1 withinstring is the code unit 0x0075 (LATIN SMALL LETTER U), then
- SethexEscape to the
substring ofstring fromk + 2 tok + 6. - Setskip to 5.
- SethexEscape to the
- Else ifk ≤length - 3, then
- SethexEscape to the
substring ofstring fromk + 1 tok + 3. - Setskip to 2.
- SethexEscape to the
- IfhexEscape can be interpreted as an expansion of
HexDigits , then[~Sep] - LethexIntegerLiteral be the
string-concatenation of"0x" andhexEscape. - Letn be !
ToNumber (hexIntegerLiteral). - Setc to the code unit whose value is
ℝ (n). - Setk tok +skip.
- LethexIntegerLiteral be the
- SetR to the
string-concatenation ofR andc. - Setk tok + 1.
- ReturnR.
B.2.2 Additional Properties of the Object.prototype Object
B.2.2.1 Object.prototype.__proto__
Object.prototype.__proto__ is an
B.2.2.1.1 get Object.prototype.__proto__
The value of the [[Get]] attribute is a built-in function that requires no arguments. It performs the following steps when called:
- LetO be ?
ToObject (this value). - Return ?O.[[GetPrototypeOf]]().
B.2.2.1.2 set Object.prototype.__proto__
The value of the [[Set]] attribute is a built-in function that takes an argumentproto. It performs the following steps when called:
- LetO be ?
RequireObjectCoercible (this value). - If
Type (proto) is neither Object nor Null, returnundefined . - If
Type (O) is not Object, returnundefined . - Letstatus be ?O.[[SetPrototypeOf]](proto).
- Ifstatus is
false , throw aTypeError exception. - Return
undefined .
B.2.2.2 Object.prototype.__defineGetter__ (P,getter )
When the__defineGetter__ method is called with argumentsP andgetter, the following steps are taken:
- LetO be ?
ToObject (this value). - If
IsCallable (getter) isfalse , throw aTypeError exception. - Letdesc be PropertyDescriptor { [[Get]]:getter, [[Enumerable]]:
true , [[Configurable]]:true }. - Letkey be ?
ToPropertyKey (P). - Perform ?
DefinePropertyOrThrow (O,key,desc). - Return
undefined .
B.2.2.3 Object.prototype.__defineSetter__ (P,setter )
When the__defineSetter__ method is called with argumentsP andsetter, the following steps are taken:
- LetO be ?
ToObject (this value). - If
IsCallable (setter) isfalse , throw aTypeError exception. - Letdesc be PropertyDescriptor { [[Set]]:setter, [[Enumerable]]:
true , [[Configurable]]:true }. - Letkey be ?
ToPropertyKey (P). - Perform ?
DefinePropertyOrThrow (O,key,desc). - Return
undefined .
B.2.2.4 Object.prototype.__lookupGetter__ (P )
When the__lookupGetter__ method is called with argumentP, the following steps are taken:
- LetO be ?
ToObject (this value). - Letkey be ?
ToPropertyKey (P). - Repeat,
- Letdesc be ?O.[[GetOwnProperty]](key).
- Ifdesc is not
undefined , then- If
IsAccessorDescriptor (desc) istrue , returndesc.[[Get]]. - Return
undefined .
- If
- SetO to ?O.[[GetPrototypeOf]]().
- IfO is
null , returnundefined .
B.2.2.5 Object.prototype.__lookupSetter__ (P )
When the__lookupSetter__ method is called with argumentP, the following steps are taken:
- LetO be ?
ToObject (this value). - Letkey be ?
ToPropertyKey (P). - Repeat,
- Letdesc be ?O.[[GetOwnProperty]](key).
- Ifdesc is not
undefined , then- If
IsAccessorDescriptor (desc) istrue , returndesc.[[Set]]. - Return
undefined .
- If
- SetO to ?O.[[GetPrototypeOf]]().
- IfO is
null , returnundefined .
B.2.3 Additional Properties of the String.prototype Object
B.2.3.1 String.prototype.substr (start,length )
Thesubstr method takes two arguments,start andlength, and returns a
- LetO be ?
RequireObjectCoercible (this value). - LetS be ?
ToString (O). - Letsize be the length ofS.
- LetintStart be ?
ToIntegerOrInfinity (start). - IfintStart is -∞, setintStart to 0.
- Else ifintStart < 0, setintStart to
max (size +intStart, 0). - Iflength is
undefined , letintLength besize; otherwise letintLength be ?ToIntegerOrInfinity (length). - IfintStart is +∞,intLength ≤ 0, orintLength is +∞, return the empty String.
- LetintEnd be
min (intStart +intLength,size). - IfintStart ≥intEnd, return the empty String.
- Return the
substring ofS fromintStart tointEnd.
Thesubstr function is intentionally generic; it does not require that its
B.2.3.2 String.prototype.anchor (name )
When theanchor method is called with argumentname, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"a" ,"name" ,name).
B.2.3.2.1 CreateHTML (string,tag,attribute,value )
The abstract operation CreateHTML takes argumentsstring,tag (a String),attribute (a String), andvalue. It performs the following steps when called:
- Letstr be ?
RequireObjectCoercible (string). - LetS be ?
ToString (str). - Letp1 be the
string-concatenation of"<" andtag. - Ifattribute is not the empty String, then
- LetV be ?
ToString (value). - LetescapedV be the String value that is the same asV except that each occurrence of the code unit 0x0022 (QUOTATION MARK) inV has been replaced with the six code unit sequence
""" . - Setp1 to the
string-concatenation of:- p1
- the code unit 0x0020 (SPACE)
- attribute
- the code unit 0x003D (EQUALS SIGN)
- the code unit 0x0022 (QUOTATION MARK)
- escapedV
- the code unit 0x0022 (QUOTATION MARK)
- LetV be ?
- Letp2 be the
string-concatenation ofp1 and">" . - Letp3 be the
string-concatenation ofp2 andS. - Letp4 be the
string-concatenation ofp3,"</" ,tag, and">" . - Returnp4.
B.2.3.3 String.prototype.big ( )
When thebig method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"big" ,"" ,"" ).
B.2.3.4 String.prototype.blink ( )
When theblink method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"blink" ,"" ,"" ).
B.2.3.5 String.prototype.bold ( )
When thebold method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"b" ,"" ,"" ).
B.2.3.6 String.prototype.fixed ( )
When thefixed method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"tt" ,"" ,"" ).
B.2.3.7 String.prototype.fontcolor (color )
When thefontcolor method is called with argumentcolor, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"font" ,"color" ,color).
B.2.3.8 String.prototype.fontsize (size )
When thefontsize method is called with argumentsize, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"font" ,"size" ,size).
B.2.3.9 String.prototype.italics ( )
When theitalics method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"i" ,"" ,"" ).
B.2.3.10 String.prototype.link (url )
When thelink method is called with argumenturl, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"a" ,"href" ,url).
B.2.3.11 String.prototype.small ( )
When thesmall method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"small" ,"" ,"" ).
B.2.3.12 String.prototype.strike ( )
When thestrike method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"strike" ,"" ,"" ).
B.2.3.13 String.prototype.sub ( )
When thesub method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"sub" ,"" ,"" ).
B.2.3.14 String.prototype.sup ( )
When thesup method is called with no arguments, the following steps are taken:
- LetS be the
this value. - Return ?
CreateHTML (S,"sup" ,"" ,"" ).
B.2.3.15 String.prototype.trimLeft ( )
The property
The initial value of theString.prototype.trimStart property.
B.2.3.16 String.prototype.trimRight ( )
The property
The initial value of theString.prototype.trimEnd property.
B.2.4 Additional Properties of the Date.prototype Object
B.2.4.1 Date.prototype.getYear ( )
ThegetFullYear method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”
When thegetYear method is called with no arguments, the following steps are taken:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , returnNaN . - Return
YearFromTime (LocalTime (t)) -1900 𝔽.
B.2.4.2 Date.prototype.setYear (year )
ThesetFullYear method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”
When thesetYear method is called with one argumentyear, the following steps are taken:
- Lett be ?
thisTimeValue (this value). - Ift is
NaN , sett to+0 𝔽; otherwise, sett toLocalTime (t). - Lety be ?
ToNumber (year). - Ify is
NaN , then- Set the [[DateValue]] internal slot of
this Date object toNaN . - Return
NaN .
- Set the [[DateValue]] internal slot of
- Letyi be !
ToIntegerOrInfinity (y). - If 0 ≤yi ≤ 99, letyyyy be
1900 𝔽 +𝔽 (yi). - Else, letyyyy bey.
- Letd be
MakeDay (yyyy,MonthFromTime (t),DateFromTime (t)). - Letdate be
UTC (MakeDate (d,TimeWithinDay (t))). - Set the [[DateValue]] internal slot of
this Date object toTimeClip (date). - Return the value of the [[DateValue]] internal slot of
this Date object .
B.2.4.3 Date.prototype.toGMTString ( )
ThetoUTCString method is preferred. ThetoGMTString method is provided principally for compatibility with old code.
TheDate.prototype.toGMTString is the sameDate.prototype.toUTCString.
B.2.5 Additional Properties of the RegExp.prototype Object
B.2.5.1 RegExp.prototype.compile (pattern,flags )
When thecompile method is called with argumentspattern andflags, the following steps are taken:
- LetO be the
this value. - Perform ?
RequireInternalSlot (O, [[RegExpMatcher]]). - If
Type (pattern) is Object andpattern has a [[RegExpMatcher]] internal slot, then- Ifflags is not
undefined , throw aTypeError exception. - LetP bepattern.[[OriginalSource]].
- LetF bepattern.[[OriginalFlags]].
- Ifflags is not
- Else,
- LetP bepattern.
- LetF beflags.
- Return ?
RegExpInitialize (O,P,F).
Thecompile method completely reinitializes the
B.3 Other Additional Features
B.3.1 __proto__ Property Names in Object Initializers
The following Early Error rule is added to those in
- when
ObjectLiteral appears in a context whereObjectAssignmentPattern is required, - when initially parsing a
CoverParenthesizedExpressionAndArrowParameterList or aCoverCallExpressionAndAsyncArrowHead , or - when parsing text for
JSON.parse .
- It is a Syntax Error if
PropertyNameList ofPropertyDefinitionList contains any duplicate entries for"__proto__" and at least two of those entries were obtained from productions of the formPropertyDefinition : PropertyName : AssignmentExpression
The
In
is replaced with the following definition:
- LetpropKey be the result of evaluating
PropertyName . ReturnIfAbrupt (propKey).- IfpropKey is the String value
"__proto__" and ifIsComputedPropertyKey (PropertyName ) isfalse , then- LetisProtoSetter be
true .
- LetisProtoSetter be
- Else,
- LetisProtoSetter be
false .
- LetisProtoSetter be
- If
IsAnonymousFunctionDefinition (AssignmentExpression ) istrue andisProtoSetter isfalse , then- LetpropValue be ?
NamedEvaluation ofAssignmentExpression with argumentpropKey.
- LetpropValue be ?
- Else,
- LetexprValueRef be the result of evaluating
AssignmentExpression . - LetpropValue be ?
GetValue (exprValueRef).
- LetexprValueRef be the result of evaluating
- IfisProtoSetter is
true , then- If
Type (propValue) is either Object or Null, then- Returnobject.[[SetPrototypeOf]](propValue).
- Return
NormalCompletion (empty ).
- If
Assert :enumerable istrue .Assert :object is an ordinary, extensible object with no non-configurable properties.- Return !
CreateDataPropertyOrThrow (object,propKey,propValue).
B.3.2 Labelled Function Declarations
Prior to ECMAScript 2015, the specification of
- It is a Syntax Error if anystrict mode source code matches this rule.
The
B.3.3 Block-Level Function Declarations Web Legacy Compatibility Semantics
Prior to ECMAScript 2015, the ECMAScript specification did not define the occurrence of a
A function is declared and only referenced within a single block
- One or more
FunctionDeclaration s whoseBindingIdentifier is the namef occur within the function code of an enclosing functiong and that declaration is nested within aBlock . - No other declaration off that is not a
vardeclaration occurs within the function code ofg - All occurrences off as an
IdentifierReference are within theStatementList of theBlock containing the declaration off.
- One or more
A function is declared and possibly used within a single
Block but also referenced by an inner function definition that is not contained within that sameBlock .- One or more
FunctionDeclaration s whoseBindingIdentifier is the namef occur within the function code of an enclosing functiong and that declaration is nested within aBlock . - No other declaration off that is not a
vardeclaration occurs within the function code ofg - There may be occurrences off as an
IdentifierReference within theStatementList of theBlock containing the declaration off. - There is at least one occurrence off as an
IdentifierReference within another functionh that is nested withing and no other declaration off shadows the references tof from withinh. - All invocations ofh occur after the declaration off has been evaluated.
- One or more
A function is declared and possibly used within a single block but also referenced within subsequent blocks.
- One or more
FunctionDeclaration whoseBindingIdentifier is the namef occur within the function code of an enclosing functiong and that declaration is nested within aBlock . - No other declaration off that is not a
vardeclaration occurs within the function code ofg - There may be occurrences off as an
IdentifierReference within theStatementList of theBlock containing the declaration off. - There is at least one occurrence off as an
IdentifierReference within the function code ofg that lexically follows theBlock containing the declaration off.
- One or more
The first use case is interoperable with the semantics of
ECMAScript 2015 interoperability for the second and third use cases requires the following extensions to the clause
If an ECMAScript implementation has a mechanism for reporting diagnostic warning messages, a warning should be produced when code contains a
B.3.3.1 Changes to FunctionDeclarationInstantiation
During
- Ifstrict is
false , then- For each
FunctionDeclaration f that is directly contained in theStatementList of aBlock ,CaseClause , orDefaultClause , do- LetF be
StringValue of theBindingIdentifier off. - If replacing the
FunctionDeclaration f with aVariableStatement that hasF as aBindingIdentifier would not produce any Early Errors forfunc andF is not an element ofparameterNames, then- NOTE: A var binding forF is only instantiated here if it is neither a VarDeclaredName, the name of a formal parameter, or another
FunctionDeclaration . - IfinitializedBindings does not containF andF is not
"arguments" , then- Perform !varEnv.CreateMutableBinding(F,
false ). - PerformvarEnv.InitializeBinding(F,
undefined ). - AppendF toinstantiatedVarNames.
- Perform !varEnv.CreateMutableBinding(F,
- When the
FunctionDeclaration f is evaluated, perform the following steps in place of theFunctionDeclaration Evaluation algorithm provided in15.2.6 :- Letfenv be the
running execution context 's VariableEnvironment. - Letbenv be the
running execution context 's LexicalEnvironment. - Letfobj be !benv.GetBindingValue(F,
false ). - Perform !fenv.SetMutableBinding(F,fobj,
false ). - Return
NormalCompletion (empty ).
- Letfenv be the
- NOTE: A var binding forF is only instantiated here if it is neither a VarDeclaredName, the name of a formal parameter, or another
- LetF be
- For each
B.3.3.2 Changes to GlobalDeclarationInstantiation
During
- Letstrict be
IsStrict ofscript. - Ifstrict is
false , then- LetdeclaredFunctionOrVarNames be a new empty
List . - Append todeclaredFunctionOrVarNames the elements ofdeclaredFunctionNames.
- Append todeclaredFunctionOrVarNames the elements ofdeclaredVarNames.
- For each
FunctionDeclaration f that is directly contained in theStatementList of aBlock ,CaseClause , orDefaultClause Contained withinscript, do- LetF be
StringValue of theBindingIdentifier off. - If replacing the
FunctionDeclaration f with aVariableStatement that hasF as aBindingIdentifier would not produce any Early Errors forscript, then- Ifenv.HasLexicalDeclaration(F) is
false , then- LetfnDefinable be ?env.CanDeclareGlobalVar(F).
- IffnDefinable is
true , then- NOTE: A var binding forF is only instantiated here if it is neither a VarDeclaredName nor the name of another
FunctionDeclaration . - IfdeclaredFunctionOrVarNames does not containF, then
- Perform ?env.CreateGlobalVarBinding(F,
false ). - AppendF todeclaredFunctionOrVarNames.
- Perform ?env.CreateGlobalVarBinding(F,
- When the
FunctionDeclaration f is evaluated, perform the following steps in place of theFunctionDeclaration Evaluation algorithm provided in15.2.6 :- Letgenv be the
running execution context 's VariableEnvironment. - Letbenv be the
running execution context 's LexicalEnvironment. - Letfobj be !benv.GetBindingValue(F,
false ). - Perform ?genv.SetMutableBinding(F,fobj,
false ). - Return
NormalCompletion (empty ).
- Letgenv be the
- NOTE: A var binding forF is only instantiated here if it is neither a VarDeclaredName nor the name of another
- Ifenv.HasLexicalDeclaration(F) is
- LetF be
- LetdeclaredFunctionOrVarNames be a new empty
B.3.3.3 Changes to EvalDeclarationInstantiation
During
- Ifstrict is
false , then- LetdeclaredFunctionOrVarNames be a new empty
List . - Append todeclaredFunctionOrVarNames the elements ofdeclaredFunctionNames.
- Append todeclaredFunctionOrVarNames the elements ofdeclaredVarNames.
- For each
FunctionDeclaration f that is directly contained in theStatementList of aBlock ,CaseClause , orDefaultClause Contained withinbody, do- LetF be
StringValue of theBindingIdentifier off. - If replacing the
FunctionDeclaration f with aVariableStatement that hasF as aBindingIdentifier would not produce any Early Errors forbody, then- LetbindingExists be
false . - LetthisEnv belexEnv.
Assert : The following loop will terminate.- Repeat, whilethisEnv is not the same asvarEnv,
- IfthisEnv is not an
object Environment Record , then- IfthisEnv.HasBinding(F) is
true , then- LetbindingExists be
true .
- LetbindingExists be
- IfthisEnv.HasBinding(F) is
- SetthisEnv tothisEnv.[[OuterEnv]].
- IfthisEnv is not an
- IfbindingExists is
false andvarEnv is aglobal Environment Record , then- IfvarEnv.HasLexicalDeclaration(F) is
false , then- LetfnDefinable be ?varEnv.CanDeclareGlobalVar(F).
- Else,
- LetfnDefinable be
false .
- LetfnDefinable be
- IfvarEnv.HasLexicalDeclaration(F) is
- Else,
- LetfnDefinable be
true .
- LetfnDefinable be
- IfbindingExists is
false andfnDefinable istrue , then- IfdeclaredFunctionOrVarNames does not containF, then
- IfvarEnv is a
global Environment Record , then- Perform ?varEnv.CreateGlobalVarBinding(F,
true ).
- Perform ?varEnv.CreateGlobalVarBinding(F,
- Else,
- LetbindingExists bevarEnv.HasBinding(F).
- IfbindingExists is
false , then- Perform !varEnv.CreateMutableBinding(F,
true ). - Perform !varEnv.InitializeBinding(F,
undefined ).
- Perform !varEnv.CreateMutableBinding(F,
- AppendF todeclaredFunctionOrVarNames.
- IfvarEnv is a
- When the
FunctionDeclaration f is evaluated, perform the following steps in place of theFunctionDeclaration Evaluation algorithm provided in15.2.6 :- Letgenv be the
running execution context 's VariableEnvironment. - Letbenv be the
running execution context 's LexicalEnvironment. - Letfobj be !benv.GetBindingValue(F,
false ). - Perform ?genv.SetMutableBinding(F,fobj,
false ). - Return
NormalCompletion (empty ).
- Letgenv be the
- IfdeclaredFunctionOrVarNames does not containF, then
- LetbindingExists be
- LetF be
- LetdeclaredFunctionOrVarNames be a new empty
B.3.3.4 Changes to Block Static Semantics: Early Errors
The rules for the following production in
- It is a Syntax Error if the
LexicallyDeclaredNames ofStatementList contains any duplicate entries, unless the source code matching this production is notstrict mode code and the duplicate entries are only bound by FunctionDeclarations. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofStatementList also occurs in theVarDeclaredNames ofStatementList .
B.3.3.5 Changes toswitch Statement Static Semantics: Early Errors
The rules for the following production in
- It is a Syntax Error if the
LexicallyDeclaredNames ofCaseBlock contains any duplicate entries, unless the source code matching this production is notstrict mode code and the duplicate entries are only bound by FunctionDeclarations. - It is a Syntax Error if any element of the
LexicallyDeclaredNames ofCaseBlock also occurs in theVarDeclaredNames ofCaseBlock .
B.3.3.6 Changes to BlockDeclarationInstantiation
During
- Ifenv.HasBinding(dn) is
false , then- Perform !env.CreateMutableBinding(dn,
false ).
- Perform !env.CreateMutableBinding(dn,
During
- If the binding forfn inenv is an uninitialized binding, then
- Performenv.InitializeBinding(fn,fo).
- Else,
Assert :d is aFunctionDeclaration .- Performenv.SetMutableBinding(fn,fo,
false ).
B.3.4 FunctionDeclarations in IfStatement Statement Clauses
The following augments the
This production only applies when parsing
B.3.5 VariableStatements in Catch Blocks
The content of subclause
- It is a Syntax Error if
BoundNames ofCatchParameter contains any duplicate elements. - It is a Syntax Error if any element of the
BoundNames ofCatchParameter also occurs in theLexicallyDeclaredNames ofBlock . - It is a Syntax Error if any element of the
BoundNames ofCatchParameter also occurs in theVarDeclaredNames ofBlock unlessCatchParameter isCatchParameter : BindingIdentifier
Thevar declarations that bind a name that is also bound by thevar declarations will assign to the corresponding catch parameter rather than thevar binding.
This modified behaviour also applies tovar andfunction declarations introduced by
Step
- IfthisEnv is not the
Environment Record for aCatch clause, throw aSyntaxError exception.
Step
- IfthisEnv is not the
Environment Record for aCatch clause, letbindingExists betrue .
B.3.6 Initializers in ForIn Statement Heads
The following augments the
This production only applies when parsing
The
- Return
ContainsDuplicateLabels ofStatement with argumentlabelSet.
The
- Return
ContainsUndefinedBreakTarget ofStatement with argumentlabelSet.
The
- Return
ContainsUndefinedContinueTarget ofStatement with argumentsiterationSet and « ».
The
- Return
false .
The
- Letnames be the
BoundNames ofBindingIdentifier . - Append tonames the elements of the
VarDeclaredNames ofStatement . - Returnnames.
The
- Letdeclarations be a
List whose sole element isBindingIdentifier . - Append todeclarations the elements of the
VarScopedDeclarations ofStatement . - Returndeclarations.
The
- LetbindingId be
StringValue ofBindingIdentifier . - Letlhs be ?
ResolveBinding (bindingId). - If
IsAnonymousFunctionDefinition (Initializer ) istrue , then- Letvalue be
NamedEvaluation ofInitializer with argumentbindingId.
- Letvalue be
- Else,
- Letrhs be the result of evaluating
Initializer . - Letvalue be ?
GetValue (rhs).
- Letrhs be the result of evaluating
- Perform ?
PutValue (lhs,value). - LetkeyResult be ?
ForIn/OfHeadEvaluation (« »,Expression ,enumerate ). - Return ?
ForIn/OfBodyEvaluation (BindingIdentifier ,Statement ,keyResult,enumerate ,varBinding ,labelSet).
B.3.7 The [[IsHTMLDDA]] Internal Slot
An[[IsHTMLDDA]] internal slot may exist ontypeof operator
Objects with an [[IsHTMLDDA]] internal slot are never created by this specification. However, thedocument.all object in web browsers is adocument.all.
B.3.7.1 Changes to ToBoolean
The result column in
- Ifargument has an
[[IsHTMLDDA]] internal slot , returnfalse . - Return
true .
B.3.7.2 Changes to Abstract Equality Comparison
The following steps replace step
- If
Type (x) is Object andx has an[[IsHTMLDDA]] internal slot andy is eithernull orundefined , returntrue . - Ifx is either
null orundefined andType (y) is Object andy has an[[IsHTMLDDA]] internal slot , returntrue .
B.3.7.3 Changes to thetypeof Operator
The following table entry is inserted into
typeof| Type ofval | Result |
|---|---|
| Object (has an |
C The Strict Mode of ECMAScript
The strict mode restriction and exceptions
implements,interface,let,package,private,protected,public,static, andyieldare reserved words withinstrict mode code . (12.6.2 ).- A conforming implementation, when processing
strict mode code , must not extend, as described inB.1.1 , the syntax ofNumericLiteral to includeLegacyOctalIntegerLiteral DecimalIntegerLiteral to includeNonOctalDecimalIntegerLiteral - A conforming implementation, when processing
strict mode code , may not extend the syntax ofEscapeSequence to includeLegacyOctalEscapeSequence NonOctalDecimalEscapeSequence B.1.2 . - Assignment to an undeclared identifier or otherwise unresolvable reference does not create a property in the
global object . When a simple assignment occurs withinstrict mode code , itsLeftHandSideExpression must not evaluate to an unresolvableReference . If it does aReferenceError exception is thrown (6.2.4.5 ). TheLeftHandSideExpression also may not be a reference to adata property with the attribute value { [[Writable]]:false }, to anaccessor property with the attribute value { [[Set]]:undefined }, nor to a non-existent property of an object whose [[Extensible]] internal slot has the valuefalse . In these cases aTypeErrorexception is thrown (13.15 ). - An
IdentifierReference with theStringValue "eval" or"arguments" may not appear as theLeftHandSideExpression of an Assignment operator (13.15 ) or of anUpdateExpression (13.4 ) or as theUnaryExpression operated upon by a Prefix Increment (13.4.4 ) or a Prefix Decrement (13.4.5 ) operator. - Arguments objects for strict functions define a non-configurable
accessor property "callee" which throws aTypeError exception on access (10.4.4.6 ). - Arguments objects for strict functions do not dynamically share their
array-indexed property values with the corresponding formal parameter bindings of their functions. (10.4.4 ). - For strict functions, if an arguments object is created the binding of the local identifier
argumentsto the arguments object is immutable and hence may not be the target of an assignment expression. (10.2.10 ). - It is a
SyntaxError if theStringValue of aBindingIdentifier is"eval" or"arguments" withinstrict mode code (13.1.1 ). - Strict mode eval code cannot instantiate variables or functions in the variable environment of the caller to eval. Instead, a new variable environment is created and that environment is used for declaration binding instantiation for the eval code (
19.2.1 ). - If
this is evaluated withinstrict mode code , then thethis value is not coerced to an object. Athis value ofundefined ornull is not converted to theglobal object and primitive values are not converted to wrapper objects. Thethis value passed via a function call (including calls made usingFunction.prototype.applyandFunction.prototype.call) do not coerce the passedthis value to an object (10.2.1.2 ,20.2.3.1 ,20.2.3.3 ). - When a
deleteoperator occurs withinstrict mode code , aSyntaxError is thrown if itsUnaryExpression is a direct reference to a variable, function argument, or function name (13.5.1.1 ). - When a
deleteoperator occurs withinstrict mode code , aTypeError is thrown if the property to be deleted has the attribute { [[Configurable]]:false } or otherwise cannot be deleted (13.5.1.2 ). Strict mode code may not include aWithStatement . The occurrence of aWithStatement in such a context is aSyntaxError (14.11.1 ).- It is a
SyntaxError if aCatchParameter occurs withinstrict mode code andBoundNames ofCatchParameter contains eitherevalorarguments(14.15.1 ). - It is a
SyntaxError if the sameBindingIdentifier appears more than once in theFormalParameters of astrict function . An attempt to create such a function using a Function, Generator, or AsyncFunctionconstructor is aSyntaxError (15.2.1 ,20.2.1.1.1 ). - An implementation may not extend, beyond that defined in this specification, the meanings within strict functions of properties named
"caller" or"arguments" of function instances.
D Host Layering Points
See
D.1 Host Hooks
D.2 Host-defined Fields
[[HostDefined]] on
[[HostDefined]] on Script Records: See
[[HostDefined]] on Module Records: See
[[HostDefined]] on JobCallback Records: See
[[HostSynchronizesWith]] on Candidate Executions: See
[[IsHTMLDDA]]: See
D.3 Host-defined Objects
The
D.4 Running Jobs
Preparation steps before, and cleanup steps after, invocation of
D.5 Internal Methods of Exotic Objects
Any of the essential internal methods in
D.6 Built-in Objects and Methods
Any built-in objects and methods not defined within this specification, except as restricted in
E Corrections and Clarifications in ECMAScript 2015 with Possible Compatibility Impact
Date.prototype.toString when
/.
String.prototype.match andString.prototype.replace was incorrect for cases where the pattern argument was a RegExp value whoseglobal flag is set. The previous specifications stated that for each attempt to match the pattern, iflastIndex did not change it should be incremented by 1. The correct behaviour is thatlastIndex should be incremented by one only if the pattern matched the empty String.
Array.prototype.sort. ECMAScript 2015 specifies that such as value is treated as if
F Additions and Changes That Introduce Incompatibilities with Prior Editions
Space_Separator (Zs) category and thus treated as whitespace in ECMAScript 2015, to be moved to theFormat (Cf) category (as of Unicode 6.3.0). This causes whitespace-sensitive methods to behave differently. For example,"\u180E".trim().length was0 in previous editions, but1 in ECMAScript 2016 and later. Additionally, ECMAScript 2017 mandated always using the latest version of the Unicode standard.
let followed by the token[ is the start of a
( token of a for statement is immediately followed by the token sequencelet [ then thelet is treated as the start of a
let [ then thelet is treated as the start of a
in
var declaration for the same
eval whose eval code includes avar orFunctionDeclaration declaration that binds the same
Object.freeze is not an object it is treated as if it was a non-extensible
Object.getOwnPropertyDescriptor is not an object an attempt is made to coerce the argument using
Object.getOwnPropertyNames is not an object an attempt is made to coerce the argument using
Object.getPrototypeOf is not an object an attempt is made to coerce the argument using
Object.isExtensible is not an object it is treated as if it was a non-extensible
Object.isFrozen is not an object it is treated as if it was a non-extensible
Object.isSealed is not an object it is treated as if it was a non-extensible
Object.keys is not an object an attempt is made to coerce the argument using
Object.preventExtensions is not an object it is treated as if it was a non-extensible
Object.seal is not an object it is treated as if it was a non-extensible
String.prototype.localeCompare function must treat Strings that are canonically equivalent according to the Unicode standard as being identical. In previous editions implementations were permitted to ignore canonical equivalence and could instead use a bit-wise comparison.
String.prototype.trim method is defined to recognize white space code points that may exists outside of the Unicode BMP. However, as of Unicode 7 no such code points are defined. In previous editions such code points would not have been recognized as white space.
Atomics.wake has been renamed toAtomics.notify to prevent confusion withAtomics.wait.
await was reduced, which could create an observable difference in resolution order between athen() call and anawait expression.
G Colophon
This specification is authored onGitHub in a plaintext source format calledEcmarkup. Ecmarkup is an HTML and Markdown dialect that provides a framework and toolset for authoring ECMAScript specifications in plaintext and processing the specification into a full-featured HTML rendering that follows the editorial conventions for this document. Ecmarkup builds on and integrates a number of other formats and technologies includingGrammarkdown for defining syntax andEcmarkdown for authoring algorithm steps. PDF renderings of this specification are produced by printing the HTML rendering to a PDF.
Prior editions of this specification were authored using Word—the Ecmarkup source text that formed the basis of this edition was produced by converting the ECMAScript 2015 Word document to Ecmarkup using an automated conversion tool.
H Bibliography
- IEEE 754-2019:IEEE Standard for Floating-Point Arithmetic. Institute of Electrical and Electronic Engineers, New York (2019)
Note There are no normative changes between IEEE 754-2008 and IEEE 754-2019 that affect the ECMA-262 specification.
- The Unicode Standard, available at <https://unicode.org/versions/latest>
- Unicode Technical Note #5: Canonical Equivalence in Applications, available at <https://unicode.org/notes/tn5/>
- Unicode Technical Standard #10: Unicode Collation Algorithm, available at <https://unicode.org/reports/tr10/>
- Unicode Standard Annex #15, Unicode Normalization Forms, available at <https://unicode.org/reports/tr15/>
- Unicode Standard Annex #18: Unicode Regular Expressions, available at <https://unicode.org/reports/tr18/>
- Unicode Standard Annex #24: Unicode
ScriptProperty, available at <https://unicode.org/reports/tr24/> - Unicode Standard Annex #31, Unicode Identifiers and Pattern Syntax, available at <https://unicode.org/reports/tr31/>
- Unicode Standard Annex #44: Unicode Character Database, available at <https://unicode.org/reports/tr44/>
- Unicode Technical Standard #51: Unicode Emoji, available at <https://unicode.org/reports/tr51/>
- IANA Time Zone Database, available at <https://www.iana.org/time-zones>
- ISO 8601:2004(E)Data elements and interchange formats — Information interchange — Representation of dates and times
- RFC 1738 “Uniform Resource Locators (URL)”, available at <https://tools.ietf.org/html/rfc1738>
- RFC 2396 “Uniform Resource Identifiers (URI): Generic Syntax”, available at <https://tools.ietf.org/html/rfc2396>
- RFC 3629 “UTF-8, a transformation format of ISO 10646”, available at <https://tools.ietf.org/html/rfc3629>
- RFC 7231 “Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content”, available at <https://tools.ietf.org/html/rfc7231>
I Copyright & Software License
Ecma International
Rue du Rhone 114
CH-1204 Geneva
Tel: +41 22 849 6000
Fax: +41 22 849 6001
Web:https://ecma-international.org/
Copyright Notice
© 2021 Ecma International
This document may be copied, published and distributed to others, and certain derivative works of it may be prepared, copied, published, and distributed, in whole or in part, provided that the above copyright notice and this Copyright License and Disclaimer are included on all such copies and derivative works. The only derivative works that are permissible under this Copyright License and Disclaimer are:
(i) works which incorporate all or portion of this document for the purpose of providing commentary or explanation (such as an annotated version of the document),
(ii) works which incorporate all or portion of this document for the purpose of incorporating features that provide accessibility,
(iii) translations of this document into languages other than English and into different formats and
(iv) works by making use of this specification in standard conformant products by implementing (e.g. by copy and paste wholly or partly) the functionality therein.
However, the content of this document itself may not be modified in any way, including by removing the copyright notice or references to Ecma International, except as required to translate it into languages other than English or into a different format.
The official version of an Ecma International document is the English language version on the Ecma International website. In the event of discrepancies between a translated version and the official version, the official version shall govern.
The limited permissions granted above are perpetual and will not be revoked by Ecma International or its successors or assigns.
This document and the information contained herein is provided on an "AS IS" basis and ECMA INTERNATIONAL DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY OWNERSHIP RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Software License
All Software contained in this document ("Software") is protected by copyright and is being made available under the "BSD License", included below. This Software may be subject to third party rights (rights from parties other than Ecma International), including patent rights, and no licenses under such third party rights are granted under this license even if the third party concerned is a member of Ecma International. SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://ecma-international.org/memento/codeofconduct.htm FOR INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
- Neither the name of the authors nor Ecma International may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.