?
u
m
/
The document at https://tc39.es/ecma262/ is the most accurate and up-to-date ECMAScript specification. It contains the content of the most recent yearly snapshot plus any finished proposals (those that have reached Stage 4 in the proposal process and thus are implemented in several implementations and will be in the next practical revision) since that snapshot was taken.
This document is available as a single page and as multiple pages.
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:
Refer to the
This Ecma Standard defines the ECMAScript 2022 Language. It is the thirteenth 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
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 to Array.prototype
called includes
.
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 new Object.values
, Object.entries
, and Object.getOwnPropertyDescriptors
.
ECMAScript 2018 introduced support for asynchronous iteration via
the AsyncIterator protocol and async generators. It also included four
new regular expression features: the dotAll
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
and flatMap
on Array.prototype
for flattening arrays, Object.fromEntries
for directly turning the return value of Object.entries
into a new Object, and trimStart
and trimEnd
on String.prototype
as better-named alternatives to the widely implemented but non-standard String.prototype.trimLeft
and trimRight
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
that Array.prototype.sort
be a stable sort, requiring that JSON.stringify
return well-formed UTF-8 regardless of input, and clarifying Function.prototype.toString
by requiring that it either return the corresponding original source text or a standard placeholder.
ECMAScript 2020, the 11th edition, introduced the matchAll
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 Promise.allSettled
, a new Promise combinator that does not short-circuit; globalThis
, a universal way to access the global this
value; dedicated export * as ns from 'module'
syntax for use within modules; increased standardization of for-in
enumeration order; import.meta
, a null
or undefined
):
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.
ECMAScript 2021, the 12th edition, introduced the replaceAll
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, and FinalizationRegistry
,
to manage registration and unregistration of cleanup operations
performed when target objects are garbage collected; separators for
numeric literals (1_000
); and Array.prototype.sort
was made more precise, reducing the amount of cases that result in an
ECMAScript 2022, the 13th edition, introduced top-level await
, allowing the #x in obj
syntax, to test for presence of private fields on objects; regular expression match indices via the /d
flag, which provides start and end indices for matched substrings; the cause
property on Error
objects, which can be used to record a causation chain in errors; the at
method for Strings, Arrays, and TypedArrays, which allows relative indexing; and Object.hasOwn
, a convenient alternative to Object.prototype.hasOwnProperty
.
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
This Standard defines the ECMAScript 2022 general-purpose programming language.
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
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 implement Normative 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.
Example clause contents.
A conforming implementation of ECMAScript must implement Legacy subclauses, unless they are also marked as Normative Optional. All of the language features and behaviours specified within Legacy subclauses have one or more undesirable characteristics. However, their continued usage in existing applications prevents their removal from this specification. 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.
Example clause contents.
Example clause contents.
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 10646 Information 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/
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. A scripting 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 a Web 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.
A web browser provides an ECMAScript
A web server provides a different
Each Web browser and server that supports ECMAScript supplies its own
To aid integrating ECMAScript into
An implementation is an external source that further defines facilities enumerated in Annex
An implementation-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.
An implementation-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 as Math.exp
A host is an external source that further defines facilities listed in Annex
A host hook is an abstract operation that is defined in whole or in part by an external source. All
A host-defined facility is one that defers its definition to an external source without further qualification and is listed in Annex
A host 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
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 of built-in objects that round out the definition of ECMAScript entities. These built-in objects include the Object
, Function
, Boolean
, Symbol
, and various Error
objects; objects that represent and manipulate numeric values including Math
, Number
, and Date
; the text processing objects String
and RegExp
; objects that are indexed collections of values including Array
and nine different kinds of Typed Arrays whose elements all have a
specific numeric data representation; keyed collections including Map
and Set
objects; objects supporting structured data including the JSON
object, ArrayBuffer
, SharedArrayBuffer
, and DataView
; objects supporting control abstractions including generator functions and Promise
objects; and reflection objects including Proxy
and Reflect
.
ECMAScript also defines a set of built-in operators. 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 by modules 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.
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 via new Date(2009, 11)
creates a new Date object. Invoking a Date()
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 a new
expressions: cf1, cf2, cf3, cf4, and cf5. 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,
Although ECMAScript objects are not inherently class-based, it
is often convenient to define class-like abstractions based upon a
common pattern of
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 the strict 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.
For the purposes of this document, the following terms and definitions apply.
an
an
same as
Editorially, see clause
set of data values as defined in clause
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.
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.
The value of a
object that provides shared properties for other objects
When a constructor.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
the Object.create
built-in function.
object that has the default behaviour for the essential internal methods that must be supported by all objects
object that does not have the default behaviour for one or more of the essential internal methods
Any object that is not an
object whose semantics are defined by this specification
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. A built-in
primitive value used when a variable has not been assigned a value
type whose sole value is the
primitive value that represents the intentional absence of any object value
type whose sole value is the
member of the Boolean type
There are only two Boolean values,
type consisting of the primitive values
member of the Object type that is an instance of the standard built-in Boolean
A Boolean object is created by using the Boolean new
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.
primitive value that is a finite ordered sequence of zero or more 16-bit unsigned
set of all possible String values
member of the Object type that is an instance of the standard built-in String
A String object is created by using the String new
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
primitive value corresponding to a double-precision 64-bit binary format
A
set of all possible Number values including the special “Not-a-Number” (NaN) value, positive infinity, and negative infinity
member of the Object type that is an instance of the standard built-in Number
A Number object is created by using the Number new
expression, supplying a
primitive value corresponding to an arbitrary-precision
set of all possible BigInt values
member of the Object type that is an instance of the standard built-in BigInt
primitive value that represents a unique, non-String Object
set of all possible Symbol values
member of the Object type that is an instance of the standard built-in Symbol
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.
built-in object that is a function
Examples of built-in functions include parseInt
and Math.exp
. A
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
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
method that is a built-in function
Standard built-in methods are defined in this specification. A
internal value that defines some characteristic of a property
property that is directly contained by its object
property of an object that is not an own property but is a property (either own or inherited) of the object's prototype
The remainder of this specification is organized as follows:
Clause
Clauses
Clauses
Clauses
Clause
A context-free grammar consists of a number of productions. Each production has an abstract symbol called a nonterminal as its left-hand side, and a sequence of zero or more nonterminal and terminal symbols as its right-hand side. For each grammar, the terminal symbols are drawn from a specified alphabet.
A chain 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 the goal symbol, a given context-free grammar specifies a language, 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.
A lexical 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
ECMAScript tokens. These tokens are the /*
…*/
regardless of whether it spans more than one line) is likewise simply discarded if it contains no line terminator; but if a
A RegExp 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.
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.
The syntactic 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 a parse tree, a rooted tree structure in which each node is a Parse Node. Each Parse Node is an instance
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 considered the 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 to eval
converts the value of str
into 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
In the ECMAScript grammars, some terminal symbols are shown in fixed-width
font. These are to appear in a source text 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 \
In grammars whose terminal symbols are individual Unicode code points (i.e., the lexical, RegExp, and numeric string grammars), a contiguous run of multiple fixed-width code points appearing in a production is a simple shorthand for the same sequence of code points, written as standalone terminal symbols.
For example, the production:
is a shorthand for:
In contrast, in the syntactic grammar, a contiguous run of fixed-width code points is a single terminal symbol.
Terminal symbols come in two other forms:
Nonterminal symbols are shown in italic 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 nonterminal while
, 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 was not 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 sequence seq is a prefix of the immediately following input token sequence. Similarly, “[lookahead ∈ set]”, where set is a finite nonempty set of token sequences, indicates that the production may only be used if some element of set 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 if seq is not a prefix of the immediately following input token sequence, and “[lookahead ∉ set]” indicates that the production may only be used if no element of set is a prefix of the immediately following token sequence.
As an example, given the definitions:
the definition:
matches either the letter n
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 a throw
token and the
Unless the presence of a
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:
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 lowercase alphabetic characters and the second level of substeps labelled with lowercase roman numerals. If more than three levels are required these rules repeat with the fourth level using numeric labels. For example:
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 “Let x be someValue”. These aliases are reference-like in that both x and someValue 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: “Let x be a copy of someValue” creates a shallow copy of someValue.
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 “Set x to someOtherValue”.
In order to facilitate their use in multiple parts of this specification, some algorithms, called abstract 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 as someValue.OperationName(arg1, arg2).
A syntax-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. The source text matched by a grammar production or
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
Unless explicitly specified otherwise, all
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
Algorithms which specify semantics that must be called at runtime are called runtime semantics. Runtime semantics are defined by
The abstract operation Completion takes argument completionRecord (a
Algorithms steps that say to throw an exception, such as
mean the same things as:
Algorithms steps that say or are otherwise equivalent to:
mean the same thing as:
Algorithms steps that say or are otherwise equivalent to:
mean the same thing as:
Where hygienicTemp is ephemeral and visible only in the steps pertaining to ReturnIfAbrupt.
Algorithms steps that say or are otherwise equivalent to:
mean the same thing as:
Invocations of ?
indicate that
is equivalent to the following step:
Similarly, for method application style, the step:
is equivalent to:
Similarly, prefix !
is used to indicate that the following invocation of an abstract or syntax-directed operation will never return an
is equivalent to the following steps:
Syntax-directed operations for !
or ?
before the invocation of the operation:
In algorithms within
It is an editorial error if a
means the same things as any of
or
or
Note that, through the
The following example would be an editorial error because a
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 an Early Error Rule.
This specification makes reference to these kinds of numeric values:
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 extended mathematical values, the operators
refer to the usual mathematical operations over the extended real
numbers; indeterminate forms are not defined and their use in this
specification should be considered an editorial error. 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 of y" 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 term integer 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 of clamping x between lower and upper" (where x is an
The mathematical function
Mathematical functions min, max,
In this specification, Function.prototype.apply
or let n = 42;
.
Values which are internal to the specification and not directly observable from ECMAScript code are indicated with a
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
Within this specification, the notation “Type(x)” is used as shorthand for “the type of x” 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”.
An ECMAScript 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. An ECMAScript language value is a value that is characterized by an ECMAScript language type.
The Undefined type has exactly one value, called
The Null type has exactly one value, called
The Boolean type represents a logical entity having two values, called
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 a leading surrogate, or more formally as a high-surrogate code unit) and every code unit with a numeric value in the inclusive range 0xDC00 to 0xDFFF (defined as a trailing surrogate, or more formally as a low-surrogate code unit) using the following rules:
The function String.prototype.normalize
(see String.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 "the string-concatenation of A, 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 "the substring of S from inclusiveStart to exclusiveEnd" (where S is a String value or a sequence of code units and inclusiveStart and exclusiveEnd are
The abstract operation StringIndexOf takes arguments string (a String), searchValue (a String), and fromIndex (a non-negative
If searchValue is the empty String and fromIndex is less than or equal to the length of string, this algorithm returns fromIndex. The empty String is effectively found at every position within a string, including after the last code unit.
This algorithm always returns -1 if fromIndex > the length of string.
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
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
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 the for -await -of statement.
|
@@hasInstance |
|
A method that determines if a instanceof operator.
|
@@isConcatSpreadable |
|
A Boolean valued property that if true indicates that an object should be flattened to its array elements by Array.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 the String.prototype.match |
@@matchAll |
|
A regular expression method that returns an iterator,
that yields matches of the regular expression against a string. Called
by the String.prototype.matchAll |
@@replace |
|
A regular expression method that replaces matched substrings of a string. Called by the String.prototype.replace |
@@search |
|
A regular expression method that returns the index
within a string that matches the regular expression. Called by the String.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 the String.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
method Object.prototype.toString |
@@unscopables |
|
An object valued property whose own and inherited property names are property names that are excluded from the with environment bindings of the associated object.
|
ECMAScript has two built-in numeric types: Number and BigInt. The following
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 call Number
and BigInt
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 generalized value types in a future edition.
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 simply Infinity
) and -Infinity
.)
The other 18,437,736,874,454,810,624 (that is,
Note that there is both a +0
(or simply 0
) and -0
.)
The 18,437,736,874,454,810,622 (that is,
18,428,729,675,200,069,632 (that is,
where s is 1 or -1, m is an
The remaining 9,007,199,254,740,990 (that is,
where s is 1 or -1, m is an
Note that all the positive and negative
A finite number has an odd significand if it is non-zero and the
In this specification, the phrase “the Number value for x” where x represents an exact real mathematical quantity (which might even be an irrational number such as π) means a
The
Some ECMAScript operators deal only with
The abstract operation Number::unaryMinus takes argument x (a Number) and returns a Number. It performs the following steps when called:
The abstract operation Number::bitwiseNOT takes argument x (a Number) and returns an
The abstract operation Number::exponentiate takes arguments base (a Number) and exponent (a Number) and returns a Number. It returns an
The result of base **
exponent when base is
The abstract operation Number::multiply takes arguments x (a Number) and y (a Number) and returns a Number. It performs multiplication according to the rules of
Finite-precision multiplication is commutative, but not always associative.
The abstract operation Number::divide takes arguments x (a Number) and y (a Number) and returns a Number. It performs division according to the rules of
The abstract operation Number::remainder takes arguments n (a Number) and d (a Number) and returns a Number. It yields the remainder from an implied division of its operands where n is the dividend and d is the divisor. It performs the following steps when called:
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 Java The abstract operation Number::add takes arguments x (a Number) and y (a Number) and returns a Number. It performs addition according to the rules of
Finite-precision addition is commutative, but not always associative.
The abstract operation Number::subtract takes arguments x (a Number) and y (a Number) and returns a Number. It performs subtraction, producing the difference of its operands; x is the minuend and y is the subtrahend. It performs the following steps when called:
It is always the case that x - y
produces the same result as x + (-y)
.
The abstract operation Number::leftShift takes arguments x (a Number) and y (a Number) and returns an
The abstract operation Number::signedRightShift takes arguments x (a Number) and y (a Number) and returns an
The abstract operation Number::unsignedRightShift takes arguments x (a Number) and y (a Number) and returns an
The abstract operation Number::lessThan takes arguments x (a Number) and y (a Number) and returns a Boolean or
The abstract operation Number::equal takes arguments x (a Number) and y (a Number) and returns a Boolean. It performs the following steps when called:
The abstract operation Number::sameValue takes arguments x (a Number) and y (a Number) and returns a Boolean. It performs the following steps when called:
The abstract operation Number::sameValueZero takes arguments x (a Number) and y (a Number) and returns a Boolean. It performs the following steps when called:
The abstract operation NumberBitwiseOp takes arguments op (&
, ^
, or |
), x (a Number), and y (a Number) and returns an
&
, let result be the result of applying the bitwise AND operation to lbits and rbits.^
, let result be the result of applying the bitwise exclusive OR (XOR) operation to lbits and rbits.|
. Let result be the result of applying the bitwise inclusive OR operation to lbits and rbits.The abstract operation Number::bitwiseAND takes arguments x (a Number) and y (a Number) and returns an
&
, x, y).The abstract operation Number::bitwiseXOR takes arguments x (a Number) and y (a Number) and returns an
^
, x, y).The abstract operation Number::bitwiseOR takes arguments x (a Number) and y (a Number) and returns an
|
, x, y).The abstract operation Number::toString takes argument x (a Number) and returns a String. It converts x to String format. It performs the following steps when called:
The following observations may be useful as guidelines for implementations, but are not part of the normative requirements of this Standard:
For implementations that provide more accurate
conversions than required by the rules above, it is recommended that the
following alternative version of step
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 various netlib
mirror sites.
The BigInt type represents an
The abstract operation BigInt::unaryMinus takes argument x (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::bitwiseNOT takes argument x (a BigInt) and returns a BigInt. It returns the one's complement of x. It performs the following steps when called:
The abstract operation BigInt::exponentiate takes arguments base (a BigInt) and exponent (a BigInt) and returns either a
The abstract operation BigInt::multiply takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::divide takes arguments x (a BigInt) and y (a BigInt) and returns either a
The abstract operation BigInt::remainder takes arguments n (a BigInt) and d (a BigInt) and returns either a
The abstract operation BigInt::add takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::subtract takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::leftShift takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::signedRightShift takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::unsignedRightShift takes arguments x (a BigInt) and y (a BigInt) and returns a
The abstract operation BigInt::lessThan takes arguments x (a BigInt) and y (a BigInt) and returns a Boolean. It performs the following steps when called:
The abstract operation BigInt::equal takes arguments x (a BigInt) and y (a BigInt) and returns a Boolean. It performs the following steps when called:
The abstract operation BigInt::sameValue takes arguments x (a BigInt) and y (a BigInt) and returns a Boolean. It performs the following steps when called:
The abstract operation BigInt::sameValueZero takes arguments x (a BigInt) and y (a BigInt) and returns a Boolean. It performs the following steps when called:
The abstract operation BinaryAnd takes arguments x (0 or 1) and y (0 or 1) and returns 0 or 1. It performs the following steps when called:
The abstract operation BinaryOr takes arguments x (0 or 1) and y (0 or 1) and returns 0 or 1. It performs the following steps when called:
The abstract operation BinaryXor takes arguments x (0 or 1) and y (0 or 1) and returns 0 or 1. It performs the following steps when called:
The abstract operation BigIntBitwiseOp takes arguments op (&
, ^
, or |
), x (a BigInt), and y (a BigInt) and returns a BigInt. It performs the following steps when called:
&
, let tmp be |
, let tmp be The abstract operation BigInt::bitwiseAND takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
&
, x, y).The abstract operation BigInt::bitwiseXOR takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
^
, x, y).The abstract operation BigInt::bitwiseOR takes arguments x (a BigInt) and y (a BigInt) and returns a BigInt. It performs the following steps when called:
|
, x, y).The abstract operation BigInt::toString takes argument x (a BigInt) and returns a String. It converts x to String format. It performs the following steps when called:
An Object is logically a collection of properties. Each property is either a data property, or an accessor 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. A property name is a property key that is a String value.
An integer 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 and set, corresponding to value retrieval and assignment, respectively. The properties accessible via get and set access includes both own properties that are a direct part of an object and inherited 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
Attributes are used in this specification to define and explain the state of Object properties as described in
Attribute Name | Types of property for which it is present | Value Domain | Default Value | Description |
---|---|---|---|---|
[[Value]] |
|
an |
|
The value retrieved by a get access of the property. |
[[Writable]] |
|
a Boolean |
|
If |
[[Get]] |
|
an Object or |
|
If the value is an Object it must be a |
[[Set]] |
|
an Object or |
|
If the value is an Object it must be a |
[[Enumerable]] |
|
a Boolean |
|
If |
[[Configurable]] |
|
a Boolean |
|
If |
The actual semantics of objects, in ECMAScript, are specified via algorithms called internal 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
All objects have an internal slot named [[PrivateElements]], which is a
Internal methods and internal slots are identified within this specification using names enclosed in double square brackets [[ ]].
An ordinary object is an object that satisfies all of the following criteria:
An exotic object is an object that is not an
This specification recognizes different kinds 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 is propertyKey, to have the state described by PropertyDescriptor. Return |
[[HasProperty]] | (propertyKey) → Boolean | Return a Boolean value indicating whether this object already has either an own or inherited property whose key is propertyKey. |
[[Get]] | (propertyKey, Receiver) → any |
Return the value of the property whose key is propertyKey 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 is propertyKey to value. 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 is propertyKey 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 the new operator or a super call. The first argument to the internal method is a super call. The second argument is the object to which the new operator was initially applied. Objects that implement this internal method are called |
The semantics of the essential internal methods for
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
Any implementation provided
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.
The value returned by any internal method must be a
An internal method must not return a
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
As a consequence of the third invariant, if a property is described as a
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
|
The AggregateError |
|
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
|
The Atomics object ( |
|
BigInt
|
The BigInt |
|
BigInt64Array
|
The BigInt64Array |
|
BigUint64Array
|
The BigUint64Array |
|
Boolean
|
The Boolean |
|
DataView
|
The DataView |
|
Date
|
The Date |
|
decodeURI
|
The decodeURI function ( |
|
decodeURIComponent
|
The decodeURIComponent function ( |
|
encodeURI
|
The encodeURI function ( |
|
encodeURIComponent
|
The encodeURIComponent function ( |
|
Error
|
The Error |
|
eval
|
The eval 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
|
The isFinite function ( |
|
isNaN
|
The isNaN function ( |
|
An object that all standard built-in iterator objects indirectly inherit from | |
|
JSON
|
The JSON object ( |
|
Map
|
The Map |
|
The prototype of Map iterator objects ( |
|
|
Math
|
The Math object ( |
|
Number
|
The Number |
|
Object
|
The Object |
|
parseFloat
|
The parseFloat function ( |
|
parseInt
|
The parseInt function ( |
|
Promise
|
The Promise |
|
Proxy
|
The Proxy |
|
RangeError
|
The RangeError |
|
ReferenceError
|
The ReferenceError |
|
Reflect
|
The Reflect 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 |
|
|
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
A specification type corresponds to meta-values that are used
within algorithms to describe the semantics of ECMAScript language
constructs and
The List type is used to explain the evaluation of argument lists (see new
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 List arguments.
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 « ».
In this specification, the phrase "the list-concatenation of A, B, ..." (where each argument is a possibly empty List) denotes a new List value whose elements are the concatenation of the elements (in order) of each of the arguments (in order).
The Record 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 an
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]]:
The Set type is used to explain a collection of unordered elements for use in the
The Relation 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 Relation R and two values a and b in the value domain of R, a R b is shorthand for saying the ordered pair (a, b) is a member of R. A Relation is least with respect to some conditions when it is the smallest Relation that satisfies those conditions.
A strict partial order is a Relation value R that satisfies the following.
For all a, b, and c in R's domain:
The two properties above are called irreflexivity and transitivity, respectively.
A strict total order is a Relation value R that satisfies the following.
For all a, b, and c in R's domain:
The three properties above are called totality, irreflexivity, and transitivity, respectively.
The Completion Record specification type is used to explain the runtime propagation of values and control flow such as the behaviour of statements (break
, continue
, return
and throw
) that perform nonlocal transfers of control.
Completion Records have the fields defined in
Field Name | Value | Meaning |
---|---|---|
[[Type]] |
|
The type of completion that occurred. |
[[Value]] |
any value except a |
The value that was produced. |
[[Target]] |
a String or |
The target label for directed control transfers. |
The following shorthand terms are sometimes used to refer to Completion Records.
Callable objects that are defined in this specification only return a normal completion or a throw completion. Returning any other kind of Completion Record is considered an editorial error.
Algorithm steps that say
mean the same thing as:
where all aliases in the above steps, with the exception of completion, are ephemeral and visible only in the steps pertaining to Await.
Await can be combined with the ?
and !
prefixes, so that for example
means the same thing as:
The abstract operation NormalCompletion takes argument value and returns a
The abstract operation ThrowCompletion takes argument value (an
The abstract operation UpdateEmpty takes arguments completionRecord (a
The Reference Record type is used to explain the behaviour of such operators as delete
, typeof
, the assignment operators, the super
A Reference Record is a resolved name or property binding; its fields are defined by
Field Name | Value | Meaning |
---|---|---|
[[Base]] | an |
The value or |
[[ReferencedName]] | a String, a Symbol, or a |
The name of the binding. Always a String if [[Base]] value is an |
[[Strict]] | a Boolean | |
[[ThisValue]] | an |
If not super |
The following
The abstract operation IsPropertyReference takes argument V (a
The abstract operation IsUnresolvableReference takes argument V (a
The abstract operation IsSuperReference takes argument V (a
The abstract operation IsPrivateReference takes argument V (a
The abstract operation GetValue takes argument V and returns either a
The object that may be created in step
The abstract operation PutValue takes arguments V and W and returns either a
The object that may be created in step
The abstract operation GetThisValue takes argument V and returns an
The abstract operation InitializeReferencedBinding takes arguments V and W and returns either a
The abstract operation MakePrivateReference takes arguments baseValue (an
The Property Descriptor type is used to explain the manipulation and reification of Object property attributes. A Property Descriptor is a
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 (in which case it is a generic
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 corresponding fields defined in
The following
The abstract operation IsAccessorDescriptor takes argument Desc (a
The abstract operation IsDataDescriptor takes argument Desc (a
The abstract operation IsGenericDescriptor takes argument Desc (a
The abstract operation FromPropertyDescriptor takes argument Desc (a
The abstract operation ToPropertyDescriptor takes argument Obj and returns either a
The abstract operation CompletePropertyDescriptor takes argument Desc (a
The
The Abstract 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 as closure(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.
The Data Block specification type is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. A byte 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
The semantics of Shared Data Blocks is defined using
The following
The abstract operation CreateByteDataBlock takes argument size (a non-negative
The abstract operation CreateSharedByteDataBlock takes argument size (a non-negative
The abstract operation CopyDataBlockBytes takes arguments toBlock (a
The PrivateElement type is a
Values of the PrivateElement type are
Field Name | Values of the [[Kind]] field for which it is present | Value | Meaning |
---|---|---|---|
[[Key]] | All |
a |
The name of the field, method, or accessor. |
[[Kind]] | All |
|
The kind of the element. |
[[Value]] |
|
an |
The value of the field. |
[[Get]] |
|
a |
The getter for a private accessor. |
[[Set]] |
|
a |
The setter for a private accessor. |
The ClassFieldDefinition type is a
Values of the ClassFieldDefinition type are
Field Name | Value | Meaning |
---|---|---|
[[Name]] |
a |
The name of the field. |
[[Initializer]] |
a |
The initializer of the field, if any. |
The Private Name
specification type is used to describe a globally unique value (one
which differs from any other Private Name, even if they are otherwise
indistinguishable) which represents the key of a private class element
(field, method, or accessor). Each Private Name has an associated
immutable [[Description]] which is a String value. A Private Name may be
installed on any ECMAScript object with
A ClassStaticBlockDefinition Record is a
ClassStaticBlockDefinition Records have the fields listed in
Field Name | Value | Meaning |
---|---|---|
[[BodyFunction]] |
a |
The |
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
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.
The abstract operation ToPrimitive takes argument input (an
When ToPrimitive is called without a hint, then it generally behaves as if the hint were
The abstract operation OrdinaryToPrimitive takes arguments O (an Object) and hint (
The abstract operation ToBoolean takes argument argument and returns a Boolean. It converts argument to a value of type Boolean according to
Argument Type | Result |
---|---|
Undefined |
Return |
Null |
Return |
Boolean | Return argument. |
Number |
If argument is |
String |
If argument is the empty String (its length is 0), return |
Symbol |
Return |
BigInt |
If argument is |
Object |
Return An alternate algorithm related to the [[IsHTMLDDA]] internal slot is mandated in section |
The abstract operation ToNumeric takes argument value and returns either a
The abstract operation ToNumber takes argument argument and returns either a
Argument Type | Result |
---|---|
Undefined |
Return |
Null |
Return |
Boolean |
If argument is |
Number | Return argument (no conversion). |
String |
Return ! |
Symbol |
Throw a |
BigInt |
Throw a |
Object |
Apply the following steps:
|
The abstract operation
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
0
digits.
+
or -
to indicate its sign.
Infinity
and -Infinity
are recognized as a The abstract operation StringToNumber takes argument str (a String) and returns a Number. It performs the following steps when called:
The syntax-directed operation StringNumericValue takes no arguments and returns a Number.
The conversion of a
It is defined piecewise over the following productions:
The abstract operation RoundMVResult takes argument n (a
The abstract operation ToIntegerOrInfinity takes argument argument (an
The abstract operation ToInt32 takes argument argument and returns either a
Given the above definition of ToInt32:
The abstract operation ToUint32 takes argument argument and returns either a
Given the above definition of ToUint32:
The abstract operation ToInt16 takes argument argument and returns either a
The abstract operation ToUint16 takes argument argument and returns either a
The abstract operation ToInt8 takes argument argument and returns either a
The abstract operation ToUint8 takes argument argument and returns either a
The abstract operation ToUint8Clamp takes argument argument and returns either a
Unlike the other ECMAScript Math.round
which does “round half up” tie-breaking.
The abstract operation ToBigInt takes argument argument and returns either a
Argument Type | Result |
---|---|
Undefined |
Throw a |
Null |
Throw a |
Boolean |
Return 1n if prim is 0n if prim is |
BigInt | Return prim. |
Number |
Throw a |
String |
|
Symbol |
Throw a |
The abstract operation StringToBigInt takes argument str (a String) and returns a BigInt or
The abstract operation ToBigInt64 takes argument argument and returns either a
The abstract operation ToBigUint64 takes argument argument and returns either a
The abstract operation ToString takes argument argument and returns either a
Argument Type | Result |
---|---|
Undefined |
Return |
Null |
Return |
Boolean |
If argument is If argument is |
Number |
Return |
String | Return argument. |
Symbol |
Throw a |
BigInt |
Return ! |
Object |
Apply the following steps:
|
The abstract operation ToObject takes argument argument and returns either a
Argument Type | Result |
---|---|
Undefined |
Throw a |
Null |
Throw a |
Boolean |
Return a new Boolean object whose [[BooleanData]] internal slot is set to argument. See |
Number |
Return a new Number object whose [[NumberData]] internal slot is set to argument. See |
String |
Return a new String object whose [[StringData]] internal slot is set to argument. See |
Symbol |
Return a new Symbol object whose [[SymbolData]] internal slot is set to argument. See |
BigInt |
Return a new BigInt object whose [[BigIntData]] internal slot is set to argument. See |
Object | Return argument. |
The abstract operation ToPropertyKey takes argument argument and returns either a
The abstract operation ToLength takes argument argument (an
The abstract operation CanonicalNumericIndexString takes argument argument (a String) and returns a Number or
A canonical numeric string is any String value for which the CanonicalNumericIndexString abstract operation does not return
The abstract operation ToIndex takes argument value (an
The abstract operation RequireObjectCoercible takes argument argument and returns either a
Argument Type | Result |
---|---|
Undefined |
Throw a |
Null |
Throw a |
Boolean | Return argument. |
Number | Return argument. |
String | Return argument. |
Symbol | Return argument. |
BigInt | Return argument. |
Object | Return argument. |
The abstract operation IsArray takes argument argument and returns either a
The abstract operation IsCallable takes argument argument (an
The abstract operation IsConstructor takes argument argument (an
The abstract operation IsExtensible takes argument O (an Object) and returns either a
The abstract operation IsIntegralNumber takes argument argument and returns a Boolean. It determines if argument is a finite
The abstract operation IsPropertyKey takes argument argument (an
The abstract operation IsRegExp takes argument argument and returns either a
The abstract operation IsStringPrefix takes arguments p (a String) and q (a String) and returns a Boolean. It determines if p is a prefix of q. It performs the following steps when called:
Any String is a prefix of itself.
The abstract operation IsStringWellFormedUnicode takes argument string (a String) and returns a Boolean. It interprets string as a sequence of UTF-16 encoded code points, as described in
The abstract operation SameValue takes arguments x (an
This algorithm differs from the
The abstract operation SameValueZero takes arguments x (an
SameValueZero differs from
The abstract operation SameValueNonNumeric takes arguments x (an
The abstract operation IsLessThan takes arguments x (an
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.
The abstract operation IsLooselyEqual takes arguments x (an
The abstract operation IsStrictlyEqual takes arguments x (an
This algorithm differs from the
The abstract operation MakeBasicObject takes argument internalSlotsList (a
Within this specification,
The abstract operation Get takes arguments O (an Object) and P (a
The abstract operation GetV takes arguments V (an
The abstract operation Set takes arguments O (an Object), P (a
The abstract operation CreateDataProperty takes arguments O (an Object), P (a
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 if O is not extensible, [[DefineOwnProperty]] will return
The abstract operation CreateMethodProperty takes arguments O (an Object), P (a
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 if O is not extensible, [[DefineOwnProperty]] will return