?uem/p1-90`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 included in the next yearly snapshot. Historical snapshots are available at https://ecma-international.org/publications-and-standards/standards/ecma-262/.
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 2027 Language. It is the eighteenth edition of the ECMAScript Language Specification. 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. Though best known as the language embedded in web browsers, it has also been widely adopted for use outside the browser, including server and embedded applications, and has grown to be one of the world's most widely used general-purpose programming languages.
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,
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 Array.prototype called includes.
ECMAScript 2017 introduced Async Object.values, Object.entries, and Object.getOwnPropertyDescriptors.
ECMAScript 2018 introduced support for asynchronous iteration via the dotAll flag, named capture groups, Unicode property escapes, and look-behind assertions. Lastly, it included object rest and spread properties, and Promise.prototype.finally.
ECMAScript 2019 introduced a few new flat and flatMap on Array.prototype for flattening arrays, Object.fromEntries for directly turning the return value of Object.entries into a new Object, trimStart and trimEnd on String.prototype as better-named alternatives to the widely implemented but non-standard String.prototype.trimLeft and trimRight built-ins, and Symbol.prototype.description. 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 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
ECMAScript 2021, the 12th edition, introduced the replaceAll 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 Object.hasOwn, a convenient alternative to Object.prototype.hasOwnProperty.
ECMAScript 2023, the 14th edition, introduced the toSorted, toReversed, with, findLast, and findLastIndex Array.prototype and TypedArray.prototype, as well as the toSpliced Array.prototype; added support for #! comments at the beginning of files to better facilitate executable ECMAScript files; and allowed the use of most Symbols as keys in weak collections.
ECMAScript 2024, the 15th edition, added facilities for resizing and transferring ArrayBuffers and SharedArrayBuffers; added a new RegExp /v flag for creating RegExps with more advanced features for working with sets of strings; and introduced the Promise.withResolvers convenience Object.groupBy and Map.groupBy Atomics.waitAsync String.prototype.isWellFormed and String.prototype.toWellFormed
ECMAScript 2025, the 16th edition, added a new Iterator global with associated static and Set.prototype for performing common operations on Sets; added support for importing JSON modules as well as syntax for declaring RegExp.escape Promise.try Promise and ensuring the result is always a Promise; and added a new Float16Array DataView.prototype.getFloat16, DataView.prototype.setFloat16, and Math.f16round
ECMAScript 2026, the 17th edition, added Math.sumPrecise for summing an Iterator.concat for sequencing Array.fromAsync for constructing Arrays from Error.isError for identifying error objects; Map.prototype and WeakMap.prototype for providing a default value to use during retrieval when a key is not already present; Uint8Array for converting to and from Strings of hexadecimal- and base64-encoded binary data; a parameter to JSON.parse revivers to access the matched segment of JSON source; and JSON.rawJSON for fine control over JSON.stringify output for
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
Kevin Gibbons
ECMA-262, Project Editor, 12th through 17th Editions
Shu-yu Guo
ECMA-262, Project Editor, 12th through 18th Editions
Michael Ficarra
ECMA-262, Project Editor, 12th through 18th Editions
Richard Gibson
ECMA-262, Project Editor, 18th Edition
Ron Buckton
ECMA-262, Project Editor, 18th Edition
Nicolò Ribaudo
ECMA-262, Project Editor, 18th Edition
Linus Groh
ECMA-262, Project Editor, 18th Edition
This Standard defines the ECMAScript 2027 general-purpose programming language.
A conforming implementation of ECMAScript must provide and support all the types, values, objects, properties,
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
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, unless otherwise indicated. Web browsers are generally required to implement all normative optional subclauses. (See Annex
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.
The Unicode Standard.
https://unicode.org/versions/latest
ISO/IEC 10646, Information Technology — Universal Multiple-Octet Coded Character Set (UCS) plus Amendment 1:2005, Amendment 2:2006, Amendment 3:2008, Amendment 4:2008, and additional amendments and corrigenda, or successor.
ECMA-402, ECMAScript Internationalization API Specification, specifically the annual edition corresponding to this edition of this 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 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 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
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,
All objects that do not directly contain a particular property that their
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
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.
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.
An input stream of terminal symbols can be parsed using a
New Parse Nodes are instantiated for each parse and never reused between parses even of identical input. Parse Nodes are considered the same Parse Node if and only if they represent the same span of input, 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
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 “::” after the nonterminal being defined. The lexical and RegExp grammars share some productions.
A grammar used exclusively for
Productions of runtime grammars are distinguished by having three colons “:::” after the nonterminal being defined.
The syntactic grammar for ECMAScript is given in clauses
When a stream of code points is to be parsed as an ECMAScript
Productions of the syntactic grammar are distinguished by having just one colon “:” after the nonterminal being defined.
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 block, 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 (e.g., 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 lexical grammar production:
is a shorthand for:
In contrast, in the syntactic grammar, a contiguous run of fixed-width code points is a single terminal symbol.
For example, in the syntactic grammar production:
the right-hand side is a sequence of three terminal symbols (new, ., and target). Because it is applied to a stream of input elements that does not include new .target, but not new .tar get (because tar and get are independent tokens in the stream derived from that source text).
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 combinatoric 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 non-empty 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 begin with “For each” or “Repeat” to 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. Similarly, a step that begins with “NOTE:” provides pertinent context for nearby steps. Assertion steps and note steps are strictly informative; they add no additional semantic requirements and hence need not be checked by an implementation.
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”.
When complex expressions appear in algorithm steps, these are to be understood as being evaluated in a left-to-right, inside-to-outside order. For example, the step
is equivalent to
where the various tmpN aliases are ephemeral and visible only in these steps.
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
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
Runtime Semantics:
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
In algorithm steps, the word “throw” is shorthand for returning the result of calling
is equivalent to
Algorithm steps that say to throw an exception of a particular type construct an exception of that type to be thrown. For example,
is equivalent to
Prefix “?” and “!” are used as shorthands which unwrap
is equivalent to
Likewise, the step
is equivalent to
When “?” or “!” is used in any other context, first apply the rewrite given in
can be rewritten to
which in turn expands to
In algorithms within
It is an editorial error if a
means the same things as any of
or
or
Note that, through
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
In general, when this specification refers to a numerical value, such as in the phrase, “the length of y” or “the
When the term integer is used in this specification, it refers to a
Numeric operators such as +, ×, =, and ≥ refer to those operations as determined by the type of the operands. When applied to
Conversions between
The mathematical
The mathematical
The mathematical
The notation “
The phrase “the result of clamping x between lower and upper” (where x is an
The mathematical
The mathematical
Mathematical
An interval from lower bound a to upper bound b is a possibly-infinite, possibly-empty set of numeric values of the same numeric type. Each bound will be described as either inclusive or exclusive, but not both. There are four kinds of intervals, as follows:
For example, the
In this specification, Function.prototype.apply or let n = 42;.
In this specification, both specification values and
From the perspective of this specification, the word “is” is used to compare two values for equality, as in “If bool is
From the perspective of the ECMAScript language, language values are compared for equality using the
For specification values, examples of values without specification identity include, but are not limited to:
Specification identity agrees with language identity for all
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 classified into
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. An ECMAScript language value that
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
The 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
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 string from inclusiveStart to exclusiveEnd” (where string is a String value or a sequence of code units and inclusiveStart and exclusiveEnd are
The phrase “the ASCII word characters” denotes the following String value, which consists solely of every letter and number in the Unicode Basic Latin block along with U+005F (LOW LINE):
For historical reasons, it has significance to various algorithms.
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 ≤ 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
The abstract operation StringLastIndexOf takes arguments string (a String), searchValue (a String), and fromIndex (a non-negative
If searchValue is the empty String, this algorithm returns fromIndex. The empty String is effectively found at every position within a string, including after the last code unit.
The Symbol type is the set of all non-String values that may be used as the key of an Object property (
Each Symbol is unique and immutable.
Each Symbol has an immutable [[Description]] internal slot whose value is either a String or
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 using the standard
%Symbol.name%. In particular, the following names were used: @@asyncIterator, @@hasInstance, @@isConcatSpreadable, @@| Specification Name | [[Description]] | Value and Purpose |
|---|---|---|
| %Symbol.asyncDispose% |
|
A await using declarations when evaluation of their containing scope completes.
|
| %Symbol.asyncIterator% |
|
A for-await-of statement.
|
| %Symbol.dispose% |
|
A using declarations when evaluation of their containing scope completes.
|
| %Symbol.hasInstance% |
|
A instanceof operator.
|
| %Symbol.isConcatSpreadable% |
|
A Boolean valued property that if true indicates that an object should be flattened to its array elements by Array.prototype.concat |
| %Symbol.iterator% |
|
A |
| %Symbol.match% |
|
A regular expression String.prototype.match |
| %Symbol.matchAll% |
|
A regular expression String.prototype.matchAll |
| %Symbol.replace% |
|
A regular expression String.prototype.replace |
| %Symbol.search% |
|
A regular expression String.prototype.search |
| %Symbol.species% |
|
A |
| %Symbol.split% |
|
A regular expression String.prototype.split |
| %Symbol.toPrimitive% |
|
A |
| %Symbol.toStringTag% |
|
A String valued property that is used in the creation of the default string description of an object. Accessed by the Object.prototype.toString |
| %Symbol.unscopables% |
|
An object valued property whose own and 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
The first and subsequent editions of ECMAScript have provided, for certain operators, implicit numeric conversions that could lose precision or
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 NaN values, but such behaviour is
There are two other special values, called +Infinity (or simply Infinity) and -Infinity.)
Each of 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,
Note that all the positive and negative
A
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 Number value chosen in the following manner. Consider the set consisting of the union of all
The
Some ECMAScript operators deal only with
The abstract operation Number::unaryMinus takes argument number (a Number) and returns a Number. It performs the following steps when called:
The abstract operation Number::bitwiseNOT takes argument number (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 numerator (a Number) and denominator (a Number) and returns a Number. It yields the remainder from an implied division of its operands where numerator is the dividend and denominator 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
&, thenAND operation to leftBits and rightBits.^, thenXOR (exclusive OR) operation to leftBits and rightBits.|.OR (inclusive OR) operation to leftBits and rightBits.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 arguments x (a Number) and radix (an
1.2e+3.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
https://ampl.com/_archive/first-website/REFS/rounding.pdf. 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 bigint (a BigInt) and returns a BigInt. It performs the following steps when called:
The abstract operation BigInt::bitwiseNOT takes argument bigint (a BigInt) and returns a BigInt. It returns the one's complement of bigint. 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 numerator (a BigInt) and denominator (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 BigIntBitwiseOp takes arguments op (&, ^, or |), x (a BigInt), and y (a BigInt) and returns a BigInt. It performs the following steps when called:
&, thenAND operation to xBit and yBit.^, thenXOR (exclusive OR) operation to xBit and yBit.|.OR (inclusive OR) operation to xBit and yBit.&, then^, thenThe 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 arguments x (a BigInt) and radix (an
Each instance of the Object type, also referred to simply as “an Object”, represents a collection of properties. Each property is either a data property, or an accessor property:
The properties of an object are uniquely identified using
An integer index is a
Every non-negative
An own property is a property directly included within an object. Each
An object's prototype is either an object that provides shared properties for it or
A Object.create
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
In addition, some objects are callable; these are referred to as
A object.method(), the object is passed to the
The state of an Object property is described by a set of attributes, internal values that define its characteristics, as shown in
| 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 |
| [[Getter]] |
|
a |
|
If the value is not |
| [[Setter]] |
|
a |
|
If the value is not |
| [[Enumerable]] |
|
a Boolean |
|
If |
| [[Configurable]] |
|
a Boolean |
|
If |
The actual semantics of objects, in ECMAScript, are specified via algorithms called internal
Internal
Internal slots correspond to internal state that is associated with objects, Symbols, or
All objects have an internal slot named [[PrivateElements]], which is a
Internal
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
In addition to its parameters, an internal
An internal
|
Internal |
Description | Definitions |
|---|---|---|
| [[GetPrototypeOf]] ( ) | The internal |
Within this specification it has definitions in the following types; |
| [[SetPrototypeOf]] ( proto ) | The internal |
Within this specification it has definitions in the following types; |
| [[IsExtensible]] ( ) | The internal |
Within this specification it has definitions in the following types; |
| [[PreventExtensions]] ( ) | The internal |
Within this specification it has definitions in the following types; |
| [[GetOwnProperty]] ( propertyKey ) | The internal |
Within this specification it has definitions in the following types; |
| [[DefineOwnProperty]] ( propertyKey, propertyDesc ) | The internal |
Within this specification it has definitions in the following types; |
| [[HasProperty]] ( propertyKey ) | The internal |
Within this specification it has definitions in the following types; |
| [[Get]] ( propertyKey, receiver ) | The internal |
Within this specification it has definitions in the following types; |
| [[Set]] ( propertyKey, value, receiver ) | The internal |
Within this specification it has definitions in the following types; |
| [[Delete]] ( propertyKey ) | The internal |
Within this specification it has definitions in the following types; |
| [[OwnPropertyKeys]] ( ) | The internal |
Within this specification it has definitions in the following types; |
|
Internal |
Description | Definitions |
|---|---|---|
| [[Call]] ( thisArg, argList ) | The internal |
Within this specification it has definitions in the following types; |
| [[Construct]] ( argList, newTarget ) | The internal new operator or a super call. The first argument to the internal super call. The second argument is the object to which the new operator was initially applied. Objects that implement this internal |
Within this specification it has definitions in the following types; |
The semantics of the essential internal
The Internal
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
The value returned by an internal
An object's
As a consequence of the third invariant, if a property is described as a
Well-known intrinsics are
Within this specification a reference such as %name% means the intrinsic object, associated with the current
| Intrinsic Name | Global Name | ECMAScript Language Association |
|---|---|---|
|
|
|
The AggregateError |
|
|
|
The Array |
|
|
|
The ArrayBuffer |
|
|
The |
|
|
|
|
The AsyncDisposableStack |
|
|
The |
|
|
|
The |
|
|
|
The |
|
|
|
The |
|
|
|
An object that all standard built-in |
|
|
|
|
The Atomics object ( |
|
|
|
The BigInt |
|
|
|
The BigInt64Array |
|
|
|
The BigUint64Array |
|
|
|
The Boolean |
|
|
|
The DataView |
|
|
|
The Date |
|
|
|
The decodeURI |
|
|
|
The decodeURIComponent |
|
|
|
The DisposableStack |
|
|
|
The encodeURI |
|
|
|
The encodeURIComponent |
|
|
|
The Error |
|
|
|
The eval |
|
|
|
The EvalError |
|
|
|
The FinalizationRegistry |
|
|
|
The Float16Array |
|
|
|
The Float32Array |
|
|
|
The Float64Array |
|
|
The |
|
|
|
|
The Function |
|
|
The |
|
|
|
The |
|
|
|
|
The Int8Array |
|
|
|
The Int16Array |
|
|
|
The Int32Array |
|
|
|
The isFinite |
|
|
|
The isNaN |
|
|
|
The Iterator |
|
|
The |
|
|
|
|
The JSON object ( |
|
|
|
The Map |
|
|
The |
|
|
|
|
The Math object ( |
|
|
|
The Number |
|
|
|
The Object |
|
|
|
The parseFloat |
|
|
|
The parseInt |
|
|
|
The Promise |
|
|
|
The Proxy |
|
|
|
The RangeError |
|
|
|
The ReferenceError |
|
|
|
The Reflect object ( |
|
|
|
The RegExp |
|
|
The |
|
|
|
|
The Set |
|
|
The |
|
|
|
|
The SharedArrayBuffer |
|
|
|
The String |
|
|
The |
|
|
|
|
The SuppressedError |
|
|
|
The Symbol |
|
|
|
The SyntaxError |
|
|
A |
|
|
|
The super class of all typed Array |
|
|
|
|
The TypeError |
|
|
|
The Uint8Array |
|
|
|
The Uint8ClampedArray |
|
|
|
The Uint16Array |
|
|
|
The Uint32Array |
|
|
|
The URIError |
|
|
|
The WeakMap |
|
|
|
The WeakRef |
|
|
|
The WeakSet |
|
|
The Iterator.from ( |
Additional entries in
A specification type corresponds to meta-values that are used within algorithms to describe the semantics of ECMAScript language constructs and
Enums are values which are internal to the specification and not directly observable from ECMAScript code. Enums are denoted in upper kebab case using a
The List type is used to explain the evaluation of argument lists (see new expressions, in
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).
As applied to a List of Strings, the phrase “sorted according to lexicographic code unit order” means sorting by the numeric value of each code unit up to the length of the shorter string, and sorting the shorter string before the longer string if all are equal, as described in the abstract operation
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. For example, { [[Field1]]: 42, [[Field2]]:
In specification text and algorithms, dot notation may be used to refer to a specific field of a Record. 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 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
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. It must be |
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.
The abstract operation NormalCompletion takes argument value (any value except a
The abstract operation ThrowCompletion takes argument value (an
The abstract operation ReturnCompletion 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 (possibly not-yet-resolved) property binding; its fields are defined by
| Field Name | Value | Meaning |
|---|---|---|
| [[Base]] | an |
The value or |
| [[ReferencedName]] | an |
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 refRecord (a
The abstract operation IsUnresolvableReference takes argument refRecord (a
The abstract operation IsSuperReference takes argument refRecord (a
The abstract operation IsPrivateReference takes argument refRecord (a
The abstract operation GetValue takes argument refRecord (a
The object that may be created in step
The abstract operation PutValue takes arguments refRecord (a
The object that may be created in step
The abstract operation GetThisValue takes argument refRecord (a
The abstract operation InitializeReferencedBinding takes arguments refRecord (a
The abstract operation MakePrivateReference takes arguments baseValue (an
The Property Descriptor type is used to explain the manipulation and reification of Object property
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 [[Getter]] or [[Setter]]. 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 propertyDesc (a
The abstract operation IsDataDescriptor takes argument propertyDesc (a
The abstract operation IsGenericDescriptor takes argument propertyDesc (a
The abstract operation FromPropertyDescriptor takes argument propertyDesc (a
The abstract operation ToPropertyDescriptor takes argument obj (an
The abstract operation CompletePropertyDescriptor takes argument propertyDesc (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
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-based
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, |
| [[Kind]] | All |
|
The kind of the element. |
| [[Value]] |
|
an |
The value of the field. |
| [[Getter]] |
|
a |
The getter for a private accessor. |
| [[Setter]] |
|
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]] |
an ECMAScript |
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,
A ClassStaticBlockDefinition Record is a
ClassStaticBlockDefinition Records have the fields listed in
| Field Name | Value | Meaning |
|---|---|---|
| [[BodyFunction]] |
an ECMAScript |
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
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 obj (an Object) and hint (