?
u
m
/
p
1-9
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 2025 Language. It is the sixteenth 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,
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 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 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
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 Object.hasOwn
, a convenient alternative to Object.prototype.hasOwnProperty
.
ECMAScript 2023, the 14th edition, introduced the toSorted
, toReversed
, with
, findLast
, and findLastIndex
methods on Array.prototype
and TypedArray.prototype
, as well as the toSpliced
method on 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 method for constructing Promises, the Object.groupBy
and Map.groupBy
methods for aggregating data, the Atomics.waitAsync
method for asynchronously waiting for a change to shared memory, and the String.prototype.isWellFormed
and String.prototype.toWellFormed
methods for checking and ensuring that strings contain only well-formed Unicode.
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
Shu-yu Guo
ECMA-262, Project Editor, 12th through 15th Editions
Michael Ficarra
ECMA-262, Project Editor, 12th through 15th Editions
Kevin Gibbons
ECMA-262, Project Editor, 12th through 15th Editions
This Standard defines the ECMAScript 2025 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.
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 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
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 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.
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
There are only two Boolean values,
type consisting of the primitive values
member of the
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
A String value is a member of the
set of all possible String values
member of the
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 Number value is a member of the
set of all possible Number values including
member of the
A Number object is created by using the Number new
expression, supplying a Number value as an argument. The resulting object has an internal slot whose value is the Number value. A Number object can be coerced to a Number value by calling the Number
Number value that is the positive infinite Number value
Number value that is an
primitive value corresponding to an arbitrary-precision
set of all possible BigInt values
member of the
primitive value that represents a unique, non-String Object
set of all possible Symbol values
member of the
member of the
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
built-in function that is a
Examples of built-in Object
and Function
. 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.
A numeric string grammar appears in
Productions of the numeric string grammar are distinguished by having three colons “:::” as punctuation, and are never used for parsing source text.
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
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 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 (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 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
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
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
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
is equivalent to the following steps:
!
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
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 function
The mathematical function
The notation “
The phrase "the result of clamping x between lower and upper" (where x is an
The mathematical function
The mathematical function
Mathematical functions
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.
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 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
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 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 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 using the standard
%Symbol.name%
. In particular, the following names were used: @@asyncIterator, @@hasInstance, @@isConcatSpreadable, @@Specification Name | [[Description]] | Value and Purpose |
---|---|---|
%Symbol.asyncIterator% |
|
A method that returns the default for -await -of statement.
|
%Symbol.hasInstance% |
|
A method that determines if 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 method that returns the default |
%Symbol.match% |
|
A regular expression method that matches the regular expression against a string. Called by the String.prototype.match |
%Symbol.matchAll% |
|
A regular expression method that returns an String.prototype.matchAll |
%Symbol.replace% |
|
A regular expression method that replaces matched substrings of a string. Called by the String.prototype.replace |
%Symbol.search% |
|
A regular expression method that returns the index within a string that matches the regular expression. Called by the String.prototype.search |
%Symbol.species% |
|
A function valued property that is the |
%Symbol.split% |
|
A regular expression method that splits a string at the indices that match the regular expression. Called by the String.prototype.split |
%Symbol.toPrimitive% |
|
A method that converts an object to a corresponding primitive value. Called by the |
%Symbol.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 |
%Symbol.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
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
.)
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
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 of all
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
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
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
&
, then^
, then|
.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 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 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:
&
, 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
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 functions or
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 |
[[Set]] |
|
an Object or |
|
If the value |
[[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
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 |
|
|
The prototype of |
|
|
The |
|
|
The |
|
|
The prototype of async generator objects ( |
|
|
An object that all standard built-in |
|
|
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 |
|
Float16Array
|
The Float16Array |
|
Float32Array
|
The Float32Array |
|
Float64Array
|
The Float64Array |
|
The prototype of |
|
|
Function
|
The Function |
|
The |
|
|
The prototype of generator objects ( |
|
|
Int8Array
|
The Int8Array |
|
Int16Array
|
The Int16Array |
|
Int32Array
|
The Int32Array |
|
isFinite
|
The isFinite function ( |
|
isNaN
|
The isNaN function ( |
|
Iterator
|
The Iterator |
|
The prototype of |
|
|
JSON
|
The JSON object ( |
|
Map
|
The Map |
|
The prototype of |
|
|
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 |
|
|
Set
|
The Set |
|
The prototype of |
|
|
SharedArrayBuffer
|
The SharedArrayBuffer |
|
String
|
The String |
|
The prototype of |
|
|
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 |
|
The prototype of wrapped |
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 using a
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).
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 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 the least Relation 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.
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 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 (a
The object that may be created in step
The abstract operation PutValue takes arguments V (a
The object that may be created in step
The abstract operation GetThisValue takes argument V (a
The abstract operation InitializeReferencedBinding takes arguments V (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 (an
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-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, 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]] |
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, method, or accessor). Each Private Name has an associated immutable [[Description]] which
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 O (an Object) and hint (
The abstract operation ToBoolean takes argument argument (an
The abstract operation ToNumeric takes argument value (an
The abstract operation ToNumber takes argument argument (an
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
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 (an
Given the above definition of ToInt32:
The abstract operation ToUint32 takes argument argument (an
Given the above definition of ToUint32:
The abstract operation ToInt16 takes argument argument (an
The abstract operation ToUint16 takes argument argument (an
The abstract operation ToInt8 takes argument argument (an
The abstract operation ToUint8 takes argument argument (an
The abstract operation ToUint8Clamp takes argument argument (an
Unlike most other ECMAScript Math.round
The abstract operation ToBigInt takes argument argument (an
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 (an
The abstract operation ToBigUint64 takes argument argument (an
The abstract operation ToString takes argument argument (an
The abstract operation ToObject takes argument argument (an
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 (an
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 (an
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 (an
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 IsRegExp takes argument argument (an
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 SameType takes arguments x (an
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 SameValueNonNumber takes arguments x (an
The abstract operation IsLessThan takes arguments x (an
The comparison of Strings uses a simple lexicographic ordering on sequences of UTF-16 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 but not in the same normalization form could test as unequal. Also note that lexicographic ordering by code unit differs from ordering by code point for Strings containing
The abstract operation IsLooselyEqual takes arguments x (an ==
operator. It performs the following steps when called:
The abstract operation IsStrictlyEqual takes arguments x (an ===
operator. It performs the following steps when called:
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 CreateDataPropertyOrThrow 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 CreateNonEnumerableDataPropertyOrThrow 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 except it is not enumerable. Normally, the property will not already exist. If it does exist,
The abstract operation DefinePropertyOrThrow takes arguments O (an Object), P (a
The abstract operation DeletePropertyOrThrow takes arguments O (an Object) and P (a
The abstract operation GetMethod takes arguments V (an
The abstract operation HasProperty takes arguments O (an Object) and P (a
The abstract operation HasOwnProperty takes arguments O (an Object) and P (a
The abstract operation Call takes arguments F (an
The abstract operation Construct takes argument F (a
If newTarget is not present, this operation is equivalent to: new F(...argumentsList)
The abstract operation SetIntegrityLevel takes arguments O (an Object) and level (
The abstract operation TestIntegrityLevel takes arguments O (an Object) and level (
The abstract operation CreateArrayFromList takes argument elements (a
The abstract operation LengthOfArrayLike takes argument obj (an Object) and returns either a
An array-like object is any object for which this operation returns a
The abstract operation CreateListFromArrayLike takes argument obj (an
The abstract operation Invoke takes arguments V (an
The abstract operation OrdinaryHasInstance takes arguments C (an
The abstract operation SpeciesConstructor takes arguments O (an Object) and defaultConstructor (a
The abstract operation EnumerableOwnProperties takes arguments O (an Object) and kind (
The abstract operation GetFunctionRealm takes argument obj (a
Step
The abstract operation CopyDataProperties takes arguments target (an Object), source (an
The target passed in here is always a newly created object which is not directly accessible in case of an error being thrown.
The abstract operation PrivateElementFind takes arguments O (an Object) and P (a
The abstract operation PrivateFieldAdd takes arguments O (an Object), P (a
The abstract operation PrivateMethodOrAccessorAdd takes arguments O (an Object) and method (a
The values for private methods and accessors are shared across instances. This operation does not create a new copy of the method or accessor.
The
An implementation of HostEnsureCanAddPrivateElement must conform to the following requirements:
The default implementation of HostEnsureCanAddPrivateElement is to return
This abstract operation is only invoked by ECMAScript
The abstract operation PrivateGet takes arguments O (an Object) and P (a
The abstract operation PrivateSet takes arguments O (an Object), P (a
The abstract operation DefineField takes arguments receiver (an Object) and fieldRecord (a
The abstract operation InitializeInstanceElements takes arguments O (an Object) and constructor (an ECMAScript
The abstract operation AddValueToKeyedGroup takes arguments groups (a
The abstract operation GroupBy takes arguments items (an
The abstract operation SetterThatIgnoresPrototypeProperties takes arguments thisValue (an
See Common Iteration Interfaces (
An Iterator Record is a next
method.
Iterator Records have the fields listed in
Field Name | Value | Meaning |
---|---|---|
[[Iterator]] | an Object |
An object that conforms to the |
[[NextMethod]] |
an |
The next method of the [[Iterator]] object.
|
[[Done]] | a Boolean |
Whether the |
The abstract operation GetIteratorDirect takes argument obj (an Object) and returns either a
The abstract operation GetIteratorFromMethod takes arguments obj (an
The abstract operation GetIterator takes arguments obj (an
The abstract operation GetIteratorFlattenable takes arguments obj (an
The abstract operation IteratorNext takes argument iteratorRecord (an
The abstract operation IteratorComplete takes argument iteratorResult (an Object) and returns either a
The abstract operation IteratorValue takes argument iteratorResult (an Object) and returns either a
The abstract operation IteratorStep takes argument iteratorRecord (an
The abstract operation IteratorStepValue takes argument iteratorRecord (an
The abstract operation IteratorClose takes arguments iteratorRecord (an
IfAbruptCloseIterator is a shorthand for a sequence of algorithm steps that use an
means the same thing as:
The abstract operation AsyncIteratorClose takes arguments iteratorRecord (an
The abstract operation CreateIteratorResultObject takes arguments value (an
The abstract operation CreateListIteratorRecord takes argument list (a
The list
The abstract operation IteratorToList takes argument iteratorRecord (an
In addition to those defined in this section, specialized
The
The
It is defined piecewise over the following productions:
The
The
It is not necessary to treat export default
The
At the top level of a
The LexicallyDeclaredNames of a
export
At the top level of a
The
The
This section is extended by Annex
export
The
This section is extended by Annex
export
The
At the top level of a function, or script, function declarations are treated like var declarations rather than like lexical declarations.
The
The
At the top level of a function or script, inner function declarations are treated like var declarations.
The
The
This section is extended by Annex
The
This section is extended by Annex
The
This section is extended by Annex
The
The
The abstract operation IsAnonymousFunctionDefinition takes argument expr (an
The
The
The
Every grammar production alternative in this specification which is not listed below implicitly has the following default definition of Contains:
Static semantic rules that depend upon substructure generally do not look into function definitions.
Static semantic rules that depend upon substructure generally do not look into class bodies except for
Static semantic rules that depend upon substructure generally do not look into static
initialization blocks.
super
, or this
, return super
, or this
, return super
, or this
, return Contains is used to detect new.target
, this
, and super
usage within an
super
, return The
These operations are used in multiple places throughout the specification.
The
The
var
statements and formal parameter lists of some
It is defined piecewise over the following productions:
The abstract operation InitializeBoundName takes arguments name (a String), value (an
The
When
It is defined piecewise over the following productions:
The
The
Environment Record is a specification type used to define the association of
Every Environment Record has an [[OuterEnv]] field, which is either
Environment Records are purely specification mechanisms and need not correspond to any specific artefact of an ECMAScript implementation. It is impossible for an ECMAScript program to directly access or manipulate such values.
A
A this
binding. It also captures the state necessary to support super
method invocations.
A
An
A
The
Method | Purpose |
---|---|
HasBinding(N) |
Determine if an |
CreateMutableBinding(N, D) |
Create a new but uninitialized mutable binding in an |
CreateImmutableBinding(N, S) |
Create a new but uninitialized immutable binding in an |
InitializeBinding(N, V) |
Set the value of an already existing but uninitialized binding in an |
SetMutableBinding(N, V, S) |
Set the value of an already existing mutable binding in an |
GetBindingValue(N, S) |
Returns the value of an already existing binding from an |
DeleteBinding(N) |
Delete a binding from an |
HasThisBinding() |
Determine if an this binding. Return |
HasSuperBinding() |
Determine if an super method binding. Return |
WithBaseObject() |
If this with statement, return the with object. Otherwise, return |
Each Declarative Environment Record is associated with an ECMAScript program scope containing variable, constant, let, class, module, import, and/or function declarations. A Declarative Environment Record binds the set of identifiers defined by the declarations contained within its scope.
The HasBinding concrete method of a
The CreateMutableBinding concrete method of a
The CreateImmutableBinding concrete method of a
The InitializeBinding concrete method of a
The SetMutableBinding concrete method of a
An example of ECMAScript code that results in a missing binding at step
function f() { eval("var x; x = (delete x, 0);"); }
The GetBindingValue concrete method of a
The DeleteBinding concrete method of a
The HasThisBinding concrete method of a
A regular this
binding.
The HasSuperBinding concrete method of a
A regular super
binding.
The WithBaseObject concrete method of a
Each Object Environment Record is associated with an object called its binding object. An Object Environment Record binds the set of string identifier names that directly correspond to the property names of its binding object.
Object Environment Records created for with
statements (
Object Environment Records have the additional state fields listed in
Field Name | Value | Meaning |
---|---|---|
[[BindingObject]] | an Object |
The binding object of this |
[[IsWithEnvironment]] | a Boolean |
Indicates whether this with statement.
|
The HasBinding concrete method of an
The CreateMutableBinding concrete method of an
Normally envRec will not have a binding for N but if it does, the semantics of
The CreateImmutableBinding concrete method of an
The InitializeBinding concrete method of an
In this specification, all uses of CreateMutableBinding for
The SetMutableBinding concrete method of an
The GetBindingValue concrete method of an
The DeleteBinding concrete method of an
The HasThisBinding concrete method of an
this
binding.
The HasSuperBinding concrete method of an
super
binding.
The WithBaseObject concrete method of an
A Function Environment Record is a this
binding. If a function is not an super
, its Function Environment Record also contains the state that is used to perform super
method invocations from within the function.
Function Environment Records have the additional state fields listed in
Field Name | Value | Meaning |
---|---|---|
[[ThisValue]] |
an |
This is the |
[[ThisBindingStatus]] |
|
If the value is |
[[FunctionObject]] |
an ECMAScript |
The |
[[NewTarget]] |
a |
If this |
Function Environment Records support all of the
Method | Purpose |
---|---|
GetThisBinding() |
Return the value of this this binding. Throws a this binding has not been initialized.
|
The abstract operation BindThisValue takes arguments envRec (a
The HasThisBinding concrete method of a
The HasSuperBinding concrete method of a
The GetThisBinding concrete method of a
The abstract operation GetSuperBase takes argument envRec (a super
property accesses bound in envRec. The value
A Global Environment Record is used to represent the outer most scope that is shared by all of the ECMAScript
A Global Environment Record is logically a single record but it is specified as a composite encapsulating an
Properties may be created directly on a
Global Environment Records have the additional fields listed in
Field Name | Value | Meaning |
---|---|---|
[[ObjectRecord]] |
an |
Binding object is the |
[[GlobalThisValue]] | an Object |
The value returned by this in global scope. |
[[DeclarativeRecord]] |
a |
|
Method | Purpose |
---|---|
GetThisBinding() |
Return the value of this this binding.
|
The HasBinding concrete method of a
The CreateMutableBinding concrete method of a
The CreateImmutableBinding concrete method of a
The InitializeBinding concrete method of a
The SetMutableBinding concrete method of a
The GetBindingValue concrete method of a
The DeleteBinding concrete method of a
The HasThisBinding concrete method of a
this
binding.
The HasSuperBinding concrete method of a
super
binding.
The WithBaseObject concrete method of a
The GetThisBinding concrete method of a
The abstract operation HasLexicalDeclaration takes arguments envRec (a
The abstract operation HasRestrictedGlobalProperty takes arguments envRec (a
Properties may exist upon a
The abstract operation CanDeclareGlobalVar takes arguments envRec (a
The abstract operation CanDeclareGlobalFunction takes arguments envRec (a
The abstract operation CreateGlobalVarBinding takes arguments envRec (a
The abstract operation CreateGlobalFunctionBinding takes arguments envRec (a
Global function declarations are always represented as own properties of the
A Module Environment Record is a
Module Environment Records support all of the
Method | Purpose |
---|---|
GetThisBinding() |
Return the value of this this binding.
|
The GetBindingValue concrete method of a
S will always be
The DeleteBinding concrete method of a
The HasThisBinding concrete method of a
this
binding.
The GetThisBinding concrete method of a
The abstract operation CreateImportBinding takes arguments envRec (a
The following
The abstract operation GetIdentifierReference takes arguments env (an
The abstract operation NewDeclarativeEnvironment takes argument E (an
The abstract operation NewObjectEnvironment takes arguments O (an Object), W (a Boolean), and E (an
The abstract operation NewFunctionEnvironment takes arguments F (an ECMAScript
The abstract operation NewGlobalEnvironment takes arguments G (an Object) and thisValue (an Object) and returns a
The abstract operation NewModuleEnvironment takes argument E (an
A PrivateEnvironment Record is a specification mechanism used to track
Each
Field Name | Value Type | Meaning |
---|---|---|
[[OuterPrivateEnvironment]] |
a |
The |
[[Names]] |
a |
The |
The following
The abstract operation NewPrivateEnvironment takes argument outerPrivateEnv (a
The abstract operation ResolvePrivateIdentifier takes arguments privateEnv (a
Before it is evaluated, all ECMAScript code must be associated with a realm. Conceptually, a
A
Field Name | Value | Meaning |
---|---|---|
[[AgentSignifier]] |
an |
The |
[[Intrinsics]] |
a |
The intrinsic values used by code associated with this |
[[GlobalObject]] | an Object |
The |
[[GlobalEnv]] |
a |
The global environment for this |
[[TemplateMap]] |
a |
Template objects are canonicalized separately for each Once a |
[[LoadedModules]] |
a |
A map from the specifier strings imported by this
As mentioned in import() expression in a context where there is no |
[[HostDefined]] |
anything (default value is |
Field reserved for use by |
The abstract operation InitializeHostDefinedRealm takes no arguments and returns either a
this
binding in realm's global scope return an object other than the The abstract operation CreateIntrinsics takes argument realmRec (a
The abstract operation SetDefaultGlobalBindings takes argument realmRec (a
An execution context is a specification device that is used to track the runtime evaluation of code by an ECMAScript implementation. At any point in time, there is at most one execution context per
The execution context stack is used to track execution contexts. The
An execution context contains whatever implementation specific state is necessary to track the execution progress of its associated code. Each execution context has at least the state components listed in
Component | Purpose |
---|---|
code evaluation state |
Any state needed to perform, suspend, and resume evaluation of the code associated with this |
Function |
If this |
|
The |
ScriptOrModule |
The |
The value of the
ECMAScript code execution contexts have the additional state components listed in
Component | Purpose |
---|---|
LexicalEnvironment |
Identifies the |
VariableEnvironment |
Identifies the |
PrivateEnvironment |
Identifies the |
The LexicalEnvironment and VariableEnvironment components of an execution context are always
Execution contexts representing the evaluation of Generators have the additional state components listed in
Component | Purpose |
---|---|
Generator |
The Generator that this |
In most situations only the
An execution context is purely a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation. It is impossible for ECMAScript code to directly access or observe an execution context.
The abstract operation GetActiveScriptOrModule takes no arguments and returns a
The abstract operation ResolveBinding takes argument name (a String) and optional argument env (an
The result of ResolveBinding is always a
The abstract operation GetThisEnvironment takes no arguments and returns an this
. It performs the following steps when called:
The loop in step this
binding.
The abstract operation ResolveThisBinding takes no arguments and returns either a this
using the LexicalEnvironment of the
The abstract operation GetNewTarget takes no arguments and returns an Object or
The abstract operation GetGlobalObject takes no arguments and returns an Object. It returns the
A Job is an
At any particular time, scriptOrModule (a
At any particular time, an execution is prepared to evaluate ECMAScript code if all of the following conditions are true:
The specific choice of
Particular kinds of
A JobCallback Record is a
The WHATWG HTML specification (https://html.spec.whatwg.org/), for example, uses the
JobCallback Records have the fields listed in
Field Name | Value | Meaning |
---|---|---|
[[Callback]] |
a |
The function to invoke when the |
[[HostDefined]] |
anything (default value is |
Field reserved for use by |
The
An implementation of HostMakeJobCallback must conform to the following requirements:
The default implementation of HostMakeJobCallback performs the following steps when called:
ECMAScript
This is called at the time that the callback is passed to the function that is responsible for its being eventually scheduled and run. For example, promise.then(thenAction)
calls MakeJobCallback on thenAction
at the time of invoking Promise.prototype.then
, not at the time of scheduling the reaction
The
An implementation of HostCallJobCallback must conform to the following requirements:
This requirement means that
The default implementation of HostCallJobCallback performs the following steps when called:
ECMAScript
The
An implementation of HostEnqueueGenericJob must conform to the requirements in
The
An implementation of HostEnqueuePromiseJob must conform to the requirements in
The realm for
The
An implementation of HostEnqueueTimeoutJob must conform to the requirements in
An agent comprises a set of ECMAScript
An
Some web browsers share a single
While an
An agent signifier is a globally-unique opaque value used to identify an
Field Name | Value | Meaning |
---|---|---|
[[LittleEndian]] | a Boolean | The default value computed for the isLittleEndian parameter when it is needed by the algorithms |
[[CanBlock]] | a Boolean | Determines whether the |
[[Signifier]] | an |
Uniquely identifies the |
[[IsLockFree1]] | a Boolean | |
[[IsLockFree2]] | a Boolean | |
[[IsLockFree8]] | a Boolean | |
[[CandidateExecution]] | a |
See the |
[[KeptAlive]] | a |
Initially a new empty |
[[ModuleAsyncEvaluationCount]] | an |
Initially 0, used to assign unique incrementing values to the [[AsyncEvaluationOrder]] field of modules that are asynchronous or have asynchronous dependencies. |
Once the values of [[Signifier]], [[IsLockFree1]], and [[IsLockFree2]] have been observed by any
The values of [[IsLockFree1]] and [[IsLockFree2]] are not necessarily determined by the hardware, but may also reflect implementation choices that can vary over time and between ECMAScript implementations.
There is no [[IsLockFree4]] field: 4-byte atomic operations are always lock-free.
In practice, if an atomic operation is implemented with any type of lock the operation is not lock-free. Lock-free does not imply wait-free: there is no upper bound on how many machine steps may be required to complete a lock-free atomic operation.
That an atomic access of size n is lock-free does not imply anything about the (perceived) atomicity of non-atomic accesses of size n, specifically, non-atomic accesses may still be performed as a sequence of several separate memory accesses. See
An
The abstract operation AgentSignifier takes no arguments and returns an
The abstract operation AgentCanSuspend takes no arguments and returns a Boolean. It performs the following steps when called:
In some environments it may not be reasonable for a given
The abstract operation IncrementModuleAsyncEvaluationCount takes no arguments and returns an
This value is only used to keep track of the relative evaluation order between pending modules. An implementation may unobservably reset [[ModuleAsyncEvaluationCount]] to 0 whenever there are no pending modules.
An agent cluster is a maximal set of
Programs within different
There may be
Every
All
If different
All
All
An embedding may deactivate (stop forward progress) or activate (resume forward progress) an
The purpose of the preceding restriction is to avoid a situation where an
The implication of the restriction is that it will not be possible to share memory between
An embedding may terminate an
Each of the following specification values, and values transitively reachable from them, belong to exactly one agent cluster.
Prior to any evaluation of any ECMAScript code by any
All
An agent cluster is a specification mechanism and need not correspond to any particular artefact of an ECMAScript implementation.
For an
An
Implementations must ensure that:
This, along with the liveness guarantee in the
This specification does not make any guarantees that any object or symbol will be garbage collected. Objects or symbols which are not
The semantics of
WeakRef.prototype.deref
is called, the referent (if Neither of these actions (
Some ECMAScript implementations include garbage collector implementations which run in the background, including when ECMAScript is idle. Letting the
For some set of objects and/or symbols S a hypothetical WeakRef-oblivious execution with respect to S is an execution whereby the abstract operation
At any point during evaluation, a set of objects and/or symbols S is considered live if either of the following conditions is met:
Presence of an object or a symbol in a field, an internal slot, or a property does not imply that the value is live. For example if the value in question is never passed back to the program, then it cannot be observed.
This is the case for keys in a WeakMap, members of a WeakSet, as well as the [[WeakRefTarget]] and [[UnregisterToken]] fields of a
The above definition implies that, if a key in a WeakMap is not live, then its corresponding value is not necessarily live either.
At any time, if a set of objects and/or symbols S is not
Together with the definition of liveness, this clause prescribes optimizations that an implementation may apply regarding
It is possible to access an object without observing its identity. Optimizations such as dead variable elimination and scalar replacement on properties of non-escaping objects whose identity is not observed are allowed. These optimizations are thus allowed to observably empty
On the other hand, if an object's identity is observable, and that object is in the [[WeakRefTarget]] internal slot of a
Because calling
Implementations are not obligated to empty
If an implementation chooses a non-
The
Let cleanupJob be a new
An implementation of HostEnqueueFinalizationRegistryCleanupJob schedules cleanupJob to be performed at some future time, if possible. It must also conform to the requirements in
The abstract operation ClearKeptObjects takes no arguments and returns
The abstract operation AddToKeptObjects takes argument value (an Object or a Symbol) and returns
The abstract operation CleanupFinalizationRegistry takes argument finalizationRegistry (a
The abstract operation CanBeHeldWeakly takes argument v (an
A language value without
All
Every
In the following algorithm descriptions, assume O is an
Each
The [[GetPrototypeOf]] internal method of an
The abstract operation OrdinaryGetPrototypeOf takes argument O (an Object) and returns an Object or
The [[SetPrototypeOf]] internal method of an
The abstract operation OrdinarySetPrototypeOf takes arguments O (an Object) and V (an Object or
The loop in step
The [[IsExtensible]] internal method of an
The abstract operation OrdinaryIsExtensible takes argument O (an Object) and returns a Boolean. It performs the following steps when called:
The [[PreventExtensions]] internal method of an
The abstract operation OrdinaryPreventExtensions takes argument O (an Object) and returns
The [[GetOwnProperty]] internal method of an
The abstract operation OrdinaryGetOwnProperty takes arguments O (an Object) and P (a
The [[DefineOwnProperty]] internal method of an
The abstract operation OrdinaryDefineOwnProperty takes arguments O (an Object), P (a
The abstract operation IsCompatiblePropertyDescriptor takes arguments Extensible (a Boolean), Desc (a
The abstract operation ValidateAndApplyPropertyDescriptor takes arguments O (an Object or
The [[HasProperty]] internal method of an
The abstract operation OrdinaryHasProperty takes arguments O (an Object) and P (a
The [[Get]] internal method of an
The abstract operation OrdinaryGet takes arguments O (an Object), P (a
The [[Set]] internal method of an
The abstract operation OrdinarySet takes arguments O (an Object), P (a
The abstract operation OrdinarySetWithOwnDescriptor takes arguments O (an Object), P (a
The [[Delete]] internal method of an
The abstract operation OrdinaryDelete takes arguments O (an Object) and P (a
The [[OwnPropertyKeys]] internal method of an
The abstract operation OrdinaryOwnPropertyKeys takes argument O (an Object) and returns a
The abstract operation OrdinaryObjectCreate takes argument proto (an Object or
Although OrdinaryObjectCreate does little more than call
The abstract operation OrdinaryCreateFromConstructor takes arguments constructor (a
The abstract operation GetPrototypeFromConstructor takes arguments constructor (a
If constructor does not supply a [[Prototype]] value, the default value that is used is obtained from the
The abstract operation RequireInternalSlot takes arguments O (an
ECMAScript
In addition to [[Extensible]] and [[Prototype]], ECMAScript
Internal Slot | Type | Description |
---|---|---|
[[Environment]] |
an |
The |
[[PrivateEnvironment]] |
a |
The |
[[FormalParameters]] |
a |
The root parse node of the source text that defines the function's formal parameter list. |
[[ECMAScriptCode]] |
a |
The root parse node of the source text that defines the function's body. |
[[ConstructorKind]] |
|
Whether or not the function is a derived class |
[[Realm]] |
a |
The |
[[ScriptOrModule]] |
a |
The script or module in which the function was created. |
[[ThisMode]] |
|
Defines how this references are interpreted within the formal parameters and code body of the function. this refers to the |
[[Strict]] | a Boolean |
|
[[HomeObject]] | an Object |
If the function uses super , this is the object whose [[GetPrototypeOf]] provides the object where super property lookups begin.
|
[[SourceText]] | a sequence of Unicode code points |
The |
[[Fields]] |
a |
If the function is a class, this is a list of |
[[PrivateMethods]] |
a |
If the function is a class, this is a list representing the non-static private methods and accessors of the class. |
[[ClassFieldInitializerName]] |
a String, a Symbol, a |
If the function is created as the initializer of a class field, the name to use for |
[[IsClassConstructor]] | a Boolean |
Indicates whether the function is a class |
All ECMAScript
The [[Call]] internal method of an ECMAScript
When calleeContext is removed from the
The abstract operation PrepareForOrdinaryCall takes arguments F (an ECMAScript
The abstract operation OrdinaryCallBindThis takes arguments F (an ECMAScript
The
Even though field initializers constitute a function boundary, calling
The abstract operation OrdinaryCallEvaluateBody takes arguments F (an ECMAScript
The [[Construct]] internal method of an ECMAScript
The abstract operation OrdinaryFunctionCreate takes arguments functionPrototype (an Object), sourceText (a sequence of Unicode code points), ParameterList (a
The abstract operation AddRestrictedFunctionProperties takes arguments F (a
This function is the %ThrowTypeError% intrinsic object.
It is an anonymous built-in
It performs the following steps when called:
The value of the [[Extensible]] internal slot of this function is
The
The
The abstract operation MakeConstructor takes argument F (an ECMAScript
The abstract operation MakeClassConstructor takes argument F (an ECMAScript
The abstract operation MakeMethod takes arguments F (an ECMAScript
The abstract operation DefineMethodProperty takes arguments homeObject (an Object), key (a
The abstract operation SetFunctionName takes arguments F (a
The abstract operation SetFunctionLength takes arguments F (a
The abstract operation FunctionDeclarationInstantiation takes arguments func (an ECMAScript
When an
It performs the following steps when called:
eval
in eval
.A built-in
In addition to the internal slots required of every
The initial value of a built-in
A built-in
A built-in
An implementation may provide additional built-in
The [[Call]] internal method of a built-in
The [[Construct]] internal method of a built-in
The abstract operation BuiltinCallOrConstruct takes arguments F (a built-in
When calleeContext is removed from the
The abstract operation CreateBuiltinFunction takes arguments behaviour (an
Each built-in function defined in this specification is created by calling the CreateBuiltinFunction abstract operation.
This specification defines several kinds of built-in
A
An object is a bound function exotic object if its [[Call]] and (if applicable) [[Construct]] internal methods use the following implementations, and its other essential internal methods use the definitions found in
Internal Slot | Type | Description |
---|---|---|
[[BoundTargetFunction]] | a callable Object |
The wrapped |
[[BoundThis]] |
an |
The value that is always passed as the |
[[BoundArguments]] |
a |
A list of values whose elements are used as the first arguments to any call to the wrapped function. |
The [[Call]] internal method of a
The [[Construct]] internal method of a
The abstract operation BoundFunctionCreate takes arguments targetFunction (a
An Array is an
An object is an Array exotic object (or simply, an Array) if its [[DefineOwnProperty]] internal method uses the following implementation, and its other essential internal methods use the definitions found in
The [[DefineOwnProperty]] internal method of an
The abstract operation ArrayCreate takes argument length (a non-negative
The abstract operation ArraySpeciesCreate takes arguments originalArray (an Object) and length (a non-negative
If originalArray was created using the standard built-in Array Array.prototype
methods that now are defined using ArraySpeciesCreate.
The abstract operation ArraySetLength takes arguments A (an Array) and Desc (a
A String object is an
An object is a String exotic object (or simply, a String object) if its [[GetOwnProperty]], [[DefineOwnProperty]], and [[OwnPropertyKeys]] internal methods use the following implementations, and its other essential internal methods use the definitions found in
The [[GetOwnProperty]] internal method of a
The [[DefineOwnProperty]] internal method of a
The [[OwnPropertyKeys]] internal method of a
The abstract operation StringCreate takes arguments value (a String) and prototype (an Object) and returns a
The abstract operation StringGetOwnProperty takes arguments S (an Object that has a [[StringData]] internal slot) and P (a
Most ECMAScript functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an
An object is an arguments exotic object if its internal methods use the following implementations, with the ones not specified here using those found in
While
Object.prototype.toString
(
The
The ParameterMap object and its property values are used as a device for specifying the arguments object correspondence to argument bindings. The ParameterMap object and the objects that are the values of its properties are not directly observable from ECMAScript code. An ECMAScript implementation does not need to actually create or use such objects to implement the specified semantics.
Ordinary arguments objects define a non-configurable
ECMAScript implementations of
The [[GetOwnProperty]] internal method of an
The [[DefineOwnProperty]] internal method of an
The [[Get]] internal method of an
The [[Set]] internal method of an
The [[Delete]] internal method of an
The abstract operation CreateUnmappedArgumentsObject takes argument argumentsList (a
The abstract operation CreateMappedArgumentsObject takes arguments func (an Object), formals (a
The abstract operation MakeArgGetter takes arguments name (a String) and env (an
The abstract operation MakeArgSetter takes arguments name (a String) and env (an
A
An object is a TypedArray if its [[PreventExtensions]], [[GetOwnProperty]], [[HasProperty]], [[DefineOwnProperty]], [[Get]], [[Set]], [[Delete]], and [[OwnPropertyKeys]], internal methods use the definitions in this section, and its other essential internal methods use the definitions found in
The [[PreventExtensions]] internal method of a
The [[GetOwnProperty]] internal method of a
The [[HasProperty]] internal method of a
The [[DefineOwnProperty]] internal method of a
The [[Get]] internal method of a
The [[Set]] internal method of a
The [[Delete]] internal method of a
The [[OwnPropertyKeys]] internal method of a
An TypedArray With Buffer Witness Record is a
TypedArray With Buffer Witness Records have the fields listed in
Field Name | Value | Meaning |
---|---|---|
[[Object]] |
a |
The |
[[CachedBufferByteLength]] |
a non-negative |
The byte length of the object's [[ViewedArrayBuffer]] when the |
The abstract operation MakeTypedArrayWithBufferWitnessRecord takes arguments obj (a
The abstract operation TypedArrayCreate takes argument prototype (an Object) and returns a
The abstract operation TypedArrayByteLength takes argument taRecord (a
The abstract operation TypedArrayLength takes argument taRecord (a
The abstract operation IsTypedArrayOutOfBounds takes argument taRecord (a
The abstract operation IsTypedArrayFixedLength takes argument O (a
The abstract operation IsValidIntegerIndex takes arguments O (a
The abstract operation TypedArrayGetElement takes arguments O (a
The abstract operation TypedArraySetElement takes arguments O (a
This operation always appears to succeed, but it has no effect when attempting to write past the end of a
The abstract operation IsArrayBufferViewOutOfBounds takes argument O (a
A export *
export items. Each String-valued own
An object is a module namespace exotic object if its [[GetPrototypeOf]], [[SetPrototypeOf]], [[IsExtensible]], [[PreventExtensions]], [[GetOwnProperty]], [[DefineOwnProperty]], [[HasProperty]], [[Get]], [[Set]], [[Delete]], and [[OwnPropertyKeys]] internal methods use the definitions in this section, and its other essential internal methods use the definitions found in
Internal Slot | Type | Description |
---|---|---|
[[Module]] |
a |
The |
[[Exports]] |
a |
A |
The [[GetPrototypeOf]] internal method of a
The [[SetPrototypeOf]] internal method of a
The [[IsExtensible]] internal method of a
The [[PreventExtensions]] internal method of a
The [[GetOwnProperty]] internal method of a
The [[DefineOwnProperty]] internal method of a
The [[HasProperty]] internal method of a
The [[Get]] internal method of a
ResolveExport is side-effect free. Each time this operation is called with a specific exportName, resolveSet pair as arguments it must return the same result. An implementation might choose to pre-compute or cache the ResolveExport results for the [[Exports]] of each
The [[Set]] internal method of a
The [[Delete]] internal method of a
The [[OwnPropertyKeys]] internal method of a
The abstract operation ModuleNamespaceCreate takes arguments module (a
An
An object is an immutable prototype exotic object if its [[SetPrototypeOf]] internal method uses the following implementation. (Its other essential internal methods may use any implementation, depending on the specific
Unlike other
The [[SetPrototypeOf]] internal method of an
The abstract operation SetImmutablePrototype takes arguments O (an Object) and V (an Object or
A Proxy object is an
An object is a Proxy exotic object if its essential internal methods (including [[Call]] and [[Construct]], if applicable) use the definitions in this section. These internal methods are installed in
Internal Method | Handler Method |
---|---|
[[GetPrototypeOf]] |
getPrototypeOf
|
[[SetPrototypeOf]] |
setPrototypeOf
|
[[IsExtensible]] |
isExtensible
|
[[PreventExtensions]] |
preventExtensions
|
[[GetOwnProperty]] |
getOwnPropertyDescriptor
|
[[DefineOwnProperty]] |
defineProperty
|
[[HasProperty]] |
has
|
[[Get]] |
get
|
[[Set]] |
set
|
[[Delete]] |
deleteProperty
|
[[OwnPropertyKeys]] |
ownKeys
|
[[Call]] |
apply
|
[[Construct]] |
construct
|
When a handler method is called to provide the implementation of a Proxy object internal method, the handler method is passed the proxy's target object as a parameter. A proxy's handler object does not necessarily have a method corresponding to every essential internal method. Invoking an internal method on the proxy results in the invocation of the corresponding internal method on the proxy's target object if the handler object does not have a method corresponding to the internal trap.
The [[ProxyHandler]] and [[ProxyTarget]] internal slots of a Proxy object are always initialized when the object is created and typically may not be modified. Some Proxy objects are created in a manner that permits them to be subsequently revoked. When a proxy is revoked, its [[ProxyHandler]] and [[ProxyTarget]] internal slots are set to
Because Proxy objects permit the implementation of internal methods to be provided by arbitrary ECMAScript code, it is possible to define a Proxy object whose handler methods violates the invariants defined in
In the following algorithm descriptions, assume O is an ECMAScript Proxy object, P is a
The [[GetPrototypeOf]] internal method of a
[[GetPrototypeOf]] for Proxy objects enforces the following invariants:
The [[SetPrototypeOf]] internal method of a
[[SetPrototypeOf]] for Proxy objects enforces the following invariants:
The [[IsExtensible]] internal method of a
[[IsExtensible]] for Proxy objects enforces the following invariants:
The [[PreventExtensions]] internal method of a
[[PreventExtensions]] for Proxy objects enforces the following invariants:
The [[GetOwnProperty]] internal method of a
[[GetOwnProperty]] for Proxy objects enforces the following invariants:
The [[DefineOwnProperty]] internal method of a
[[DefineOwnProperty]] for Proxy objects enforces the following invariants:
The [[HasProperty]] internal method of a
[[HasProperty]] for Proxy objects enforces the following invariants:
The [[Get]] internal method of a
[[Get]] for Proxy objects enforces the following invariants:
The [[Set]] internal method of a
[[Set]] for Proxy objects enforces the following invariants:
The [[Delete]] internal method of a
[[Delete]] for Proxy objects enforces the following invariants:
The [[OwnPropertyKeys]] internal method of a
[[OwnPropertyKeys]] for Proxy objects enforces the following invariants:
The [[Call]] internal method of a
A
The [[Construct]] internal method of a
A
[[Construct]] for Proxy objects enforces the following invariants:
The abstract operation ValidateNonRevokedProxy takes argument proxy (a
The abstract operation ProxyCreate takes arguments target (an
ECMAScript source text is a sequence of Unicode code points. All Unicode code point values from U+0000 to U+10FFFF, including surrogate code points, may occur in ECMAScript source text where permitted by the ECMAScript grammars. The actual encodings used to store and interchange ECMAScript source text is not relevant to this specification. Regardless of the external source text encoding, a conforming ECMAScript implementation processes the source text as if it was an equivalent sequence of
The components of a combining character sequence are treated as individual Unicode code points even though a user might think of the whole sequence as a single character.
In string literals, regular expression literals, template literals and identifiers, any Unicode code point may also be expressed using Unicode escape sequences that explicitly express a code point's numeric value. Within a comment, such an escape sequence is effectively ignored as part of the comment.
ECMAScript differs from the Java programming language in the behaviour of Unicode escape sequences. In a Java program, if the Unicode escape sequence \u000A
, for example, occurs within a single-line comment, it is interpreted as a line terminator (Unicode code point U+000A is LINE FEED (LF)) and therefore the next code point is not part of the comment. Similarly, if the Unicode escape sequence \u000A
occurs within a string literal in a Java program, it is likewise interpreted as a line terminator, which is not allowed within a string literal—one must write \n
instead of \u000A
to cause a LINE FEED (LF) to be part of the value of a string literal. In an ECMAScript program, a Unicode escape sequence occurring within a comment is never interpreted and therefore cannot contribute to termination of the comment. Similarly, a Unicode escape sequence occurring within a string literal in an ECMAScript program always contributes to the literal and is never interpreted as a line terminator or as a code point that might terminate the string literal.
The abstract operation UTF16EncodeCodePoint takes argument cp (a Unicode code point) and returns a String. It performs the following steps when called:
The abstract operation CodePointsToString takes argument text (a sequence of Unicode code points) and returns a String. It converts text into a String value, as described in
The abstract operation UTF16SurrogatePairToCodePoint takes arguments lead (a code unit) and trail (a code unit) and returns a code point. Two code units that form a UTF-16
The abstract operation CodePointAt takes arguments string (a String) and position (a non-negative
The abstract operation StringToCodePoints takes argument string (a String) and returns a
The abstract operation ParseText takes arguments sourceText (a String or a sequence of Unicode code points) and goalSymbol (a nonterminal in one of the ECMAScript grammars) and returns a
Consider a text that has an
See also clause
There are four types of ECMAScript code:
eval
function. More precisely, if the parameter to the built-in eval
function eval
is the global code portion of that Function code is source text that is parsed to supply the value of the [[ECMAScriptCode]] and [[FormalParameters]] internal slots (see
In addition, if the source text referred to above is parsed as:
then the
Function code is generally provided as the bodies of Function Definitions (
The practical effect of including the
A Directive Prologue is the longest sequence of
A Use Strict Directive is an "use strict"
or 'use strict'
. A
A
The
An ECMAScript syntactic unit may be processed using either unrestricted or strict mode syntax and semantics (
eval
is a ECMAScript code that is not strict mode code is called non-strict code.
The abstract operation IsStrict takes argument node (a
An ECMAScript implementation may support the evaluation of function
The source text of an ECMAScript
There are several situations where the identification of lexical input elements is sensitive to the syntactic grammar context that is consuming the input elements. This requires multiple
The use of multiple lexical goals ensures that there are no lexical ambiguities that would affect automatic semicolon insertion. For example, there are no syntactic grammar contexts where both a leading division or division-assignment, and a leading
a = b
/hi/g.exec(c).map(d);
where the first non-whitespace, non-comment code point after a
a = b / hi / g.exec(c).map(d);
The Unicode format-control characters (i.e., the characters in category “Cf” in the Unicode Character Database such as LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT MARK) are control codes used to control the formatting of a range of text in the absence of higher-level protocols for this (such as mark-up languages).
It is useful to allow format-control characters in source text to facilitate editing and display. All format control characters may be used within comments, and within string literals, template literals, and regular expression literals.
U+FEFF (ZERO WIDTH NO-BREAK SPACE) is a format-control character used primarily at the start of a text to mark it as Unicode and to allow detection of the text's encoding and byte order. <ZWNBSP> characters intended for this purpose can sometimes also appear after the start of a text, for example as a result of concatenating files. In
White space code points are used to improve source text readability and to separate tokens (indivisible lexical units) from each other, but are otherwise insignificant. White space code points may occur between any two tokens and at the start or end of input. White space code points may occur within a
The ECMAScript white space code points are listed in
Code Points | Name | Abbreviation |
---|---|---|
U+0009
|
CHARACTER TABULATION | <TAB> |
U+000B
|
LINE TABULATION | <VT> |
U+000C
|
FORM FEED (FF) | <FF> |
U+FEFF
|
ZERO WIDTH NO-BREAK SPACE | <ZWNBSP> |
any code point in general category “Space_Separator” | <USP> |
U+0020 (SPACE) and U+00A0 (NO-BREAK SPACE) code points are part of <USP>.
Other than for the code points listed in
Like white space code points, line terminator code points are used to improve source text readability and to separate tokens (indivisible lexical units) from each other. However, unlike white space code points, line terminators have some influence over the behaviour of the syntactic grammar. In general, line terminators may occur between any two tokens, but there are a few places where they are forbidden by the syntactic grammar. Line terminators also affect the process of automatic semicolon insertion (
A line terminator can occur within a
Line terminators are included in the set of white space code points that are matched by the \s
class in regular expressions.
The ECMAScript line terminator code points are listed in
Code Point | Unicode Name | Abbreviation |
---|---|---|
U+000A
|
LINE FEED (LF) | <LF> |
U+000D
|
CARRIAGE RETURN (CR) | <CR> |
U+2028
|
LINE SEPARATOR | <LS> |
U+2029
|
PARAGRAPH SEPARATOR | <PS> |
Only the Unicode code points in
Comments can be either single or multi-line. Multi-line comments cannot nest.
Because a single-line comment can contain any Unicode code point except a //
marker to the end of the line. However, the
Comments behave like white space and are discarded except that, if a
A number of productions in this section are given alternative definitions in section
Hashbang Comments are location-sensitive and like other types of comments are discarded from the stream of input elements for the syntactic grammar.
The
This standard specifies specific code point additions: U+0024 (DOLLAR SIGN) and U+005F (LOW LINE) are permitted anywhere in an
The definitions of the nonterminal
The nonterminal _
via
The sets of code points with Unicode properties “ID_Start” and “ID_Continue” include, respectively, the code points with Unicode properties “Other_ID_Start” and “Other_ID_Continue”.
Unicode escape sequences are permitted in an \
preceding the \
Two
The
The
A keyword is a token that matches fixed width
font, in some syntactic production. The keywords of ECMAScript include if
, while
, async
, await
, and many others.
A reserved word is an if
and while
are reserved words. await
is reserved only inside async functions and modules. async
is not reserved; it can be used as a variable name or statement label without restriction.
This specification uses a combination of grammatical productions and await
and yield
, are unconditionally reserved. Exceptions for await
and yield
are specified in
Those that are always allowed as identifiers, and are not keywords, such as Math
, window
, toString
, and _
;
Those that are never allowed as identifiers, namely the await
and yield
;
Those that are contextually allowed as identifiers, namely await
and yield
;
Those that are contextually disallowed as identifiers, in let
, static
, implements
, interface
, package
, private
, protected
, and public
;
Those that are always allowed as identifiers, but also appear as keywords within certain syntactic productions, at places where as
, async
, from
, get
, meta
, of
, set
, and target
.
The term conditional keyword, or contextual keyword, is sometimes used to refer to the keywords that fall in the last three categories, and thus can be used as identifiers in some contexts and as keywords in others.
Per \
An \
els\u{65}
. The
enum
is not currently used as a keyword in this specification. It is a future reserved word, set aside for use as a keyword in future language extensions.
Similarly, implements
, interface
, package
, private
, protected
, and public
are future reserved words in
The
For example: 3in
is an error and not the two input elements 3
and in
.
A numeric literal stands for a value of the
The
A string literal is 0 or more Unicode code points enclosed in single or double quotes. Unicode code points may also be represented by an escape sequence. All code points may appear literally in a string literal except for the closing quote code points, U+005C (REVERSE SOLIDUS), U+000D (CARRIAGE RETURN), and U+000A (LINE FEED). Any code points may appear in the form of an escape sequence. String literals evaluate to ECMAScript String values. When generating these String values Unicode code points are UTF-16 encoded as defined in
The definition of the nonterminal
<LF> and <CR> cannot appear in a string literal, except as part of a \n
or \u000A
.
It is possible for string literals to precede a
function invalid() { "\7"; "use strict"; }
The
A string literal stands for a value of the
Escape Sequence | Code Unit Value | Unicode Character Name | Symbol |
---|---|---|---|
\b
|
0x0008
|
BACKSPACE | <BS> |
\t
|
0x0009
|
CHARACTER TABULATION | <HT> |
\n
|
0x000A
|
LINE FEED (LF) | <LF> |
\v
|
0x000B
|
LINE TABULATION | <VT> |
\f
|
0x000C
|
FORM FEED (FF) | <FF> |
\r
|
0x000D
|
CARRIAGE RETURN (CR) | <CR> |
\"
|
0x0022
|
QUOTATION MARK |
"
|
\'
|
0x0027
|
APOSTROPHE |
'
|
\\
|
0x005C
|
REVERSE SOLIDUS |
\
|
A regular expression literal is an input element that is converted to a RegExp object (see ===
to each other even if the two literals' contents are identical. A RegExp object may also be created at runtime by new RegExp
or calling the RegExp
The productions below describe the syntax for a regular expression literal and are used by the input element scanner to find the end of the regular expression literal. The source text comprising the
An implementation may extend the ECMAScript Regular Expression grammar defined in
Regular expression literals may not be empty; instead of representing an empty regular expression literal, the code unit sequence //
starts a single-line comment. To specify an empty regular expression, use: /(?:)/
.
The
The
The
The
Most ECMAScript statements and declarations must be terminated with a semicolon. Such semicolons may always appear explicitly in the source text. For convenience, however, such semicolons may be omitted from the source text in certain situations. These situations are described by saying that semicolons are automatically inserted into the source code token stream in those situations.
In the following rules, “token” means the actual recognized lexical token determined using the current lexical
There are three basic rules of semicolon insertion:
When, as the source text is parsed from left to right, a token (called the offending token) is encountered that is not allowed by any production of the grammar, then a semicolon is automatically inserted before the offending token if one or more of the following conditions is true:
}
.
)
and the inserted semicolon would then be parsed as the terminating semicolon of a do-while statement (However, there is an additional overriding condition on the preceding rules: a semicolon is never inserted automatically if the semicolon would then be parsed as an empty statement or if that semicolon would become one of the two semicolons in the header of a for
statement (see
The following are the only restricted productions in the grammar:
The practical effect of these restricted productions is as follows:
++
or --
token is encountered where the parser would treat it as a postfix operator, and at least one ++
or --
token, then a semicolon is automatically inserted before the ++
or --
token.
continue
, break
, return
, throw
, or yield
token is encountered and a continue
, break
, return
, throw
, or yield
token.
=>
token, a semicolon is automatically inserted and the punctuator causes a syntax error.
async
token is followed by a function
or (
token, a semicolon is automatically inserted and the async
token is not treated as part of the same expression or class element as the following tokens.
async
token is followed by a *
token, a semicolon is automatically inserted and the punctuator causes a syntax error.
The resulting practical advice to ECMAScript programmers is:
++
or --
operator should be on the same line as its operand.
return
or throw
statement or an yield
expression should start on the same line as the return
, throw
, or yield
token.
break
or continue
statement should be on the same line as the break
or continue
token.
=>
should be on the same line.
async
token preceding an asynchronous function or method should be on the same line as the immediately following token.
The source
{ 1 2 } 3
is not a valid sentence in the ECMAScript grammar, even with the automatic semicolon insertion rules. In contrast, the source
{ 1
2 } 3
is also not a valid ECMAScript sentence, but is transformed by automatic semicolon insertion into the following:
{ 1
;2 ;} 3;
which is a valid ECMAScript sentence.
The source
for (a; b
)
is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion because the semicolon is needed for the header of a for
statement. Automatic semicolon insertion never inserts one of the two semicolons in the header of a for
statement.
The source
return
a + b
is transformed by automatic semicolon insertion into the following:
return;
a + b;
The expression a + b
is not treated as a value to be returned by the return
statement, because a return
.
The source
a = b
++c
is transformed by automatic semicolon insertion into the following:
a = b;
++c;
The token ++
is not treated as a postfix operator applying to the variable b
, because a b
and ++
.
The source
if (a > b)
else c = d
is not a valid ECMAScript sentence and is not altered by automatic semicolon insertion before the else
token, even though no production of the grammar applies at that point, because an automatically inserted semicolon would then be parsed as an empty statement.
The source
a = b + c
(d + e).print()
is not transformed by automatic semicolon insertion, because the parenthesized expression that begins the second line can be interpreted as an argument list for a function call:
a = b + c(d + e).print()
In the circumstance that an assignment statement must begin with a left parenthesis, it is a good idea for the programmer to provide an explicit semicolon at the end of the preceding statement rather than to rely on automatic semicolon insertion.
ECMAScript programs can be written in a style with very few semicolons by relying on automatic semicolon insertion. As described above, semicolons are not inserted at every newline, and automatic semicolon insertion can depend on multiple tokens across line terminators.
As new syntactic features are added to ECMAScript, additional grammar productions could be added that cause lines relying on automatic semicolon insertion preceding them to change grammar productions when parsed.
For the purposes of this section, a case of automatic semicolon insertion is considered interesting if it is a place where a semicolon may or may not be inserted, depending on the source text which precedes it. The rest of this section describes a number of interesting cases of automatic semicolon insertion in this version of ECMAScript.
In a
(
). Without a semicolon, the two lines together are treated as a [
). Without a semicolon, the two lines together are treated as property access, rather than an `
). Without a semicolon, the two lines together are interpreted as a tagged Template (+
or -
. Without a semicolon, the two lines together are interpreted as a usage of the corresponding binary operator./
ECMAScript contains grammar productions which include “[no
The rest of this section describes a number of productions using “[no
yield
and await
are permitted as
let
await 0;
yield
or await
.
The
The
The result of evaluating an
In yield
may be used as an identifier. Evaluating the yield
as if it was an
When processing an instance of the production
the interpretation of
this
KeywordSee
false
, return true
, return An
Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an
The
An object initializer is an expression describing the initialization of an Object, written in a form resembling a literal. It is a list of zero or more pairs of
In certain contexts,
In addition to describing an actual object initializer the
This production exists so that
The
The
The
The
See
See
See
See
See
See
The abstract operation IsValidRegularExpressionLiteral takes argument literal (a
d
, g
, i
, m
, s
, u
, v
, or y
, or if flags contains any code point more than once, return u
, let u be v
, let v be The
The abstract operation TemplateString takes arguments templateToken (a
This operation returns
The abstract operation GetTemplateObject takes argument templateLiteral (a
The creation of a template object cannot result in an
Each
Future editions of this specification may define additional non-enumerable properties of template objects.
The
The string conversion semantics applied to the String.prototype.concat
rather than the +
operator.
The string conversion semantics applied to the String.prototype.concat
rather than the +
operator.
The string conversion semantics applied to the String.prototype.concat
rather than the +
operator.
This algorithm does not apply delete
and typeof
may be applied to parenthesized expressions.
When processing an instance of the production
the interpretation of
This production exists in order to prevent automatic semicolon insertion rules (
a?.b
`c`
so that it would be interpreted as two valid statements. The purpose is to maintain consistency with similar code without optional chaining:
a.b
`c`
which is a valid statement and where automatic semicolon insertion does not apply.
Properties are accessed by name, using either the dot notation:
or the bracket notation:
The dot notation is explained by the following syntactic conversion:
is identical in its behaviour to
and similarly
is identical in its behaviour to
where <identifier-name-string> is the
The abstract operation EvaluatePropertyAccessWithExpressionKey takes arguments baseValue (an
a[b] = c
, it will not be performed until after evaluation of c
.The abstract operation EvaluatePropertyAccessWithIdentifierKey takes arguments baseValue (an
new
OperatorThe abstract operation EvaluateNew takes arguments constructExpr (a
A
The abstract operation EvaluateCall takes arguments func (an
super
Keywordsuper[b] = c
, it will not be performed until after evaluation of c
.The abstract operation GetSuperConstructor takes no arguments and returns an
The abstract operation MakeSuperPropertyReference takes arguments actualThis (an
The evaluation of an argument list produces a
The
?.
.The
The abstract operation EvaluateImportCall takes argument specifierExpression (a
The abstract operation ContinueDynamicImport takes arguments promiseCapability (a import()
A tagged template is a function call where the arguments of the call are derived from a
The import.meta
.
The default implementation of HostGetImportMetaProperties is to return a new empty
The import.meta
.
Most
The default implementation of HostFinalizeImportMeta is to return
delete
Operator
It is a Syntax Error if the derived
and
The last rule means that expressions such as delete (((foo)))
produce
When a delete
operator occurs within delete
operator occurs within
The object that may be created in step
void
Operatortypeof
Operator+
OperatorThe unary + operator converts its operand to
-
OperatorThe unary -
operator converts its operand to a numeric value and then negates it. Negating
~
)!
)*
operator performs multiplication, producing the product of its operands./
operator performs division, producing the quotient of its operands.%
operator yields the remainder of its operands from an implied division.+
)The addition operator either performs string concatenation or numeric addition.
-
)The -
operator performs subtraction, producing the difference of its operands.
<<
)Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.
<<
, >>
)Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
>>
, >>>
)Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
>>>
, The result of evaluating a relational operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
The [In] grammar parameter is needed to avoid confusing the in
operator in a relational expression with the in
operator in a for
statement.
The abstract operation InstanceofOperator takes arguments V (an
Steps instanceof
operator semantics. If an object does not define or inherit instanceof
semantics.
The result of evaluating an equality operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
Given the above definition of equality:
`${a}` == `${b}`
.
+a == +b
.
!a == !b
.
The equality operators maintain the following invariants:
A != B
is equivalent to !(A == B)
.
A == B
is equivalent to B == A
, except in the order of evaluation of A
and B
.
The equality operator is not always transitive. For example, there might be two distinct String objects, each representing the same String value; each String object would be considered equal to the String value by the ==
operator, but the two String objects would not be equal to each other. For example:
new String("a") == "a"
and "a" == new String("a")
are both new String("a") == new String("a")
is Comparison of Strings uses a simple equality test on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore Strings values that are canonically equal according to the Unicode Standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form.
The value produced by a &&
or ||
operator is not necessarily of type Boolean. The value produced will always be the value of one of the two operand expressions.
? :
)The grammar for a
assignmentOpText | opText |
---|---|
**= | ** |
*= | * |
/= | / |
%= | % |
+= | + |
-= | - |
<<= | << |
>>= | >> |
>>>= | >>> |
&= | & |
^= | ^ |
|= | | |
When this expression occurs within
The abstract operation ApplyStringOrNumericBinaryOperator takes arguments lVal (an **
, *
, /
, %
, +
, -
, <<
, >>
, >>>
, &
, ^
, or |
), and rVal (an
+
, then**
, return ? /
, return ? %
, return ? >>>
, return ? opText | operation |
---|---|
* | |
+ | |
- | |
<< | |
>> | |
& | |
^ | |
| | |
opText | operation |
---|---|
** | |
* | |
/ | |
% | |
+ | |
- | |
<< | |
>> | |
>>> | |
& | |
^ | |
| | |
No hint is provided in the calls to
Step
The abstract operation EvaluateStringOrNumericBinaryExpression takes arguments leftOperand (a
In certain circumstances when processing an instance of the production
the interpretation of
The
The
The
The
Left to right evaluation order is maintained by evaluating a
The
,
)No matter how control leaves the
The value of a eval
function all return the value 1:
eval("1;;;;;")
eval("1;{}")
eval("1;var a;")
The abstract operation BlockDeclarationInstantiation takes arguments code (a
When a
It performs the following steps when called:
let
and const
declarations define variables that are scoped to the let
declaration does not have an
A const
declaration.
A var
statement declares variables that are scoped to the
If a
The
The
The
When
It is defined piecewise over the following productions:
An function
or class
async function
because that would make it ambiguous with an let [
because that would make it ambiguous with a let
if
Statementelse
] resolves the classic "dangling else" problem in the usual way. That is, when the choice of associated if
is otherwise ambiguous, the else
is associated with the nearest (innermost) of the candidate if
sIt is only necessary to apply this rule if the extension specified in
The abstract operation LoopContinues takes arguments completion (a
Within the
The
do
-while
StatementIt is only necessary to apply this rule if the extension specified in
The
while
StatementIt is only necessary to apply this rule if the extension specified in
The
for
StatementIt is only necessary to apply this rule if the extension specified in
The
The abstract operation ForBodyEvaluation takes arguments test (an
The abstract operation CreatePerIterationEnvironment takes argument perIterationBindings (a
for
-in
, for
-of
, and for
-await
-of
StatementsThis section is extended by Annex
It is only necessary to apply this rule if the extension specified in
The
This section is extended by Annex
The
var
statements and the formal parameter lists of some
It is defined piecewise over the following productions:
The
The
This section is extended by Annex
The abstract operation ForIn/OfHeadEvaluation takes arguments uninitializedBoundNames (a
The abstract operation ForIn/OfBodyEvaluation takes arguments lhs (a
The abstract operation EnumerateObjectProperties takes argument O (an Object) and returns an
next
method iterates over all the String-valued keys of enumerable properties of O. The The throw
and return
methods are next
method processes object properties to determine whether the next
method is ignored. If new properties are added to the target object during enumeration, the newly added properties are not guaranteed to be processed in the active enumeration. A next
method at most once in any enumeration.
Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively; but a property of a prototype is not processed if it has the same name as a property that has already been processed by the next
method. The values of [[Enumerable]] attributes are not considered when determining if a property of a prototype object has already been processed. The enumerable property names of prototype objects must be obtained by invoking EnumerateObjectProperties passing the prototype object as the argument. EnumerateObjectProperties must obtain the own
In addition, if neither O nor any object in its prototype chain is a
ECMAScript implementations are not required to implement the algorithm in
The following is an informative definition of an ECMAScript generator function that conforms to these rules:
function* EnumerateObjectProperties(obj) {
const visited = new Set();
for (const key of Reflect.ownKeys(obj)) {
if (typeof key === "symbol") continue;
const desc = Reflect.getOwnPropertyDescriptor(obj, key);
if (desc) {
visited.add(key);
if (desc.enumerable) yield key;
}
}
const proto = Reflect.getPrototypeOf(obj);
if (proto === null) return;
for (const protoKey of EnumerateObjectProperties(proto)) {
if (!visited.has(protoKey)) yield protoKey;
}
}
A For-In Iterator is an object that represents a specific iteration over some specific object. For-In Iterator objects are never directly accessible to ECMAScript code; they exist solely to illustrate the behaviour of
The abstract operation CreateForInIterator takes argument object (an Object) and returns a
The %ForInIteratorPrototype% object:
Internal Slot | Type | Description |
---|---|---|
[[Object]] | an Object | The Object value whose properties are being iterated. |
[[ObjectWasVisited]] | a Boolean |
|
[[VisitedKeys]] |
a |
The values that have been emitted by this |
[[RemainingKeys]] |
a |
The values remaining to be emitted for the current object, before iterating the properties of its prototype (if its prototype is not |
continue
Statementstatic
initialization block boundaries), within an break
Statementstatic
initialization block boundaries), within an return
StatementA return
statement causes a function to cease execution and, in most cases, returns a value to the caller. If return
statement may not actually return a value to the caller depending on surrounding context. For example, in a try
block, a return
statement's finally
block.
with
StatementUse of the with
statement is discouraged in new ECMAScript code. Consider alternatives that are permitted in both
The with
statement adds an
It is only necessary to apply the second rule if the extension specified in
No matter how control leaves the embedded
switch
StatementThe
The abstract operation CaseClauseIsSelected takes arguments C (a
This operation does not execute C's
No matter how control leaves the
A break
and continue
statements. ECMAScript has no goto
statement. A
An alternative definition for this rule is provided in
The abstract operation IsLabelledFunction takes argument stmt (a
The
A
The only two productions of
throw
Statementtry
StatementThe try
statement encloses a block of code in which an exceptional condition can occur, such as a runtime error or a throw
statement. The catch
clause provides the exception-handling code. When a catch clause catches an exception, its
An alternative
The
No matter how control leaves the
debugger
StatementEvaluating a
Various ECMAScript language elements cause the creation of ECMAScript
Multiple occurrences of the same
The
The
The
The
The ExpectedArgumentCount of a
The
The
The
The
An anonymous export default
declaration, and its function code is therefore always
The
The
An alternative semantics is provided in
A
When processing an instance of the production
the interpretation of
The
The
The
An arguments
, super
, this
, or new.target
. Any reference to arguments
, super
, this
, or new.target
within an super
, the super
is always contained within a non-super
is accessible via the env that is captured by the
The
The
The
The
The syntactic context immediately following yield
requires use of the
The
The
An anonymous export default
declaration, and its function code is therefore always
The
The
throw
method are propagated. throw
method are processed similarly to an inner next
.throw
method, this throw is going to terminate the yield*
loop. But first we need to give iterator a chance to clean up.yield*
protocol violation: iterator does not have a throw
method.The
The
An anonymous export default
declaration.
The
The
A class definition is always
It is a Syntax Error if
await
is The
The
Early Error rules ensure that there is only one method definition named
The
The
The
The
Every grammar production alternative in this specification which is not listed below implicitly has the following default definition of AllPrivateIdentifiersValid:
The
The
Every grammar production alternative in this specification which is not listed below implicitly has the following default definition of ContainsArguments:
The
The
The
The
The
For ease of specification, private methods and accessors are included alongside private fields in the [[PrivateElements]] slot of class instances. However, any given object has either all or none of the private methods and accessors defined by a given class. This feature has been designed so that implementations may choose to implement private methods and accessors using a strategy which does not require tracking each method or accessor individually.
For example, an implementation could directly associate instance private methods with their corresponding this
value. Looking up an instance private method on an object then consists of checking that the class
This differs from private fields: because field initializers can throw during class instantiation, an individual object may have some proper subset of the private fields of a given class, and so private fields must in general be tracked individually.
It is defined piecewise over the following productions:
constructor(...args) { super(...args); }
. The most notable distinction is that while the aforementioned %Array.prototype%
, this function does not.constructor() {}
.The
await
is parsed as a
When await
may be parsed as an identifier when the [Await] parameter is absent. This includes the following contexts:
Unlike
The
The
The
The
When processing an instance of the production
the interpretation of
The
The
The
The abstract operation IsInTailPosition takes argument call (a
Tail Position calls are only defined in
The
call is a
A potential tail position call that is immediately followed by return
It is defined piecewise over the following productions:
The abstract operation PrepareForTailCall takes no arguments and returns
A tail position call must either release any transient internal resources associated with the currently executing function
For example, a tail position call should only grow an implementation's activation record stack by the amount that the size of the target function's activation record exceeds the size of the calling function's activation record. If the target function's activation record is smaller, then the total size of the stack should decrease.
super
unless the source text containing super
is eval code that is being processed by a super
within The
A Script Record encapsulates information about a script being evaluated. Each script record contains the fields listed in
Field Name | Value Type | Meaning |
---|---|---|
[[Realm]] |
a |
The |
[[ECMAScriptCode]] |
a |
The result of parsing the source text of this script. |
[[LoadedModules]] |
a |
A map from the specifier strings imported by this script to the resolved |
[[HostDefined]] |
anything (default value is |
Field reserved for use by |
The abstract operation ParseScript takes arguments sourceText (
An implementation may parse script source text and analyse it for Early Error conditions prior to evaluation of ParseScript for that script source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseScript upon that source text.
The abstract operation ScriptEvaluation takes argument scriptRecord (a
The abstract operation GlobalDeclarationInstantiation takes arguments script (a
When an
It performs the following steps when called:
var
and function
bindings (except those that are introduced by non-strict Unlike explicit var or function declarations, properties that are directly created on the
super
.
The duplicate export default
The abstract operation ImportedLocalNames takes argument importEntries (a
A ModuleRequest Record represents the request to import a module with given import attributes. It consists of the following fields:
Field Name | Value Type | Meaning |
---|---|---|
[[Specifier]] | a String | The module specifier |
[[Attributes]] |
a |
The import attributes |
A LoadedModuleRequest Record represents the request to import a module together with the resulting
Field Name | Value Type | Meaning |
---|---|---|
[[Specifier]] | a String | The module specifier |
[[Attributes]] |
a |
The import attributes |
[[Module]] |
a |
The loaded module corresponding to this module request |
An ImportAttribute Record consists of the following fields:
Field Name | Value Type | Meaning |
---|---|---|
[[Key]] | a String | The attribute key |
[[Value]] | a String | The attribute value |
The abstract operation ModuleRequestsEqual takes arguments left (a
The
A Module Record encapsulates structural information about the imports and exports of a single module. This information is used to link the imports and exports of sets of connected modules. A Module Record includes four fields that are only used when evaluating a module.
For specification purposes Module Record values are values of the
Module Record defines the fields listed in
Field Name | Value Type | Meaning |
---|---|---|
[[Realm]] |
a |
The |
[[Environment]] |
a |
The |
[[Namespace]] |
an Object or |
The Module Namespace Object ( |
[[HostDefined]] |
anything (default value is |
Field reserved for use by |
Method | Purpose |
---|---|
LoadRequestedModules( [ hostDefined ] ) |
Prepares the module for linking by recursively loading all its dependencies, and returns a promise. |
GetExportedNames([exportStarSet]) |
Return a list of all names that are either directly or indirectly exported from this module. LoadRequestedModules must have completed successfully prior to invoking this method. |
ResolveExport(exportName [, resolveSet]) |
Return the binding of a name exported by this module. Bindings are represented by a ResolvedBinding Record, of the form { [[Module]]: Each time this operation is called with a specific exportName, resolveSet pair as arguments it must return the same result. LoadRequestedModules must have completed successfully prior to invoking this method. |
Link() |
Prepare the module for evaluation by transitively resolving all module dependencies and creating a LoadRequestedModules must have completed successfully prior to invoking this method. |
Evaluate() |
Returns a promise for the evaluation of this module and its dependencies, resolving on successful evaluation or if it has already been evaluated successfully, and rejecting for an evaluation error or if it has already been evaluated unsuccessfully. If the promise is rejected, Link must have completed successfully prior to invoking this method. |
A Cyclic Module Record is used to represent information about a module that can participate in dependency cycles with other modules that are subclasses of the
In addition to the fields defined in
Field Name | Value Type | Meaning |
---|---|---|
[[Status]] |
|
Initially |
[[EvaluationError]] |
a |
A |
[[DFSIndex]] |
an |
Auxiliary field used during Link and Evaluate only. If [[Status]] is either |
[[DFSAncestorIndex]] |
an |
Auxiliary field used during Link and Evaluate only. If [[Status]] is either |
[[RequestedModules]] |
a |
A |
[[LoadedModules]] |
a |
A map from the specifier strings used by the module represented by this record to request the importation of a module with the relative import attributes to the resolved |
[[CycleRoot]] |
a |
The first visited module of the cycle, the root DFS ancestor of the strongly connected component. For a module not in a cycle, this would be the module itself. Once Evaluate has completed, a module's [[DFSAncestorIndex]] is the [[DFSIndex]] of its [[CycleRoot]]. |
[[HasTLA]] | a Boolean |
Whether this module is individually asynchronous (for example, if it's a |
[[AsyncEvaluationOrder]] |
|
This field is initially set to |
[[TopLevelCapability]] |
a |
If this module is the [[CycleRoot]] of some cycle, and Evaluate() was called on some module in that cycle, this field contains the |
[[AsyncParentModules]] |
a |
If this module or a dependency has [[HasTLA]] |
[[PendingAsyncDependencies]] |
an |
If this module has any asynchronous dependencies, this tracks the number of asynchronous dependency modules remaining to execute for this module. A module with asynchronous dependencies will be executed when this field reaches 0 and there are no execution errors. |
In addition to the methods defined in
Method | Purpose |
---|---|
InitializeEnvironment() |
Initialize the |
ExecuteModule( [ promiseCapability ] ) |
Evaluate the module's code within its |
A GraphLoadingState Record is a
Field Name | Value Type | Meaning |
---|---|---|
[[PromiseCapability]] |
a |
The promise to resolve when the loading process finishes. |
[[IsLoading]] | a Boolean | It is true if the loading process has not finished yet, neither successfully nor with an error. |
[[PendingModulesCount]] |
a non-negative |
It tracks the number of pending |
[[Visited]] |
a |
It is a list of the |
[[HostDefined]] |
anything (default value is |
It contains |
The LoadRequestedModules concrete method of a
<link rel="preload" as="...">
tags.
import()
expressions never set the hostDefined parameter.
The abstract operation InnerModuleLoading takes arguments state (a
The abstract operation ContinueModuleLoading takes arguments state (a
The Link concrete method of a
The abstract operation InnerModuleLinking takes arguments module (a
The Evaluate concrete method of a
The abstract operation InnerModuleEvaluation takes arguments module (a
A module is
Any modules depending on a module of an asynchronous cycle when that cycle is not
The abstract operation ExecuteAsyncModule takes argument module (a
The abstract operation GatherAvailableAncestors takes arguments module (a
When an asynchronous execution for a root module is fulfilled, this function determines the list of modules which are able to synchronously execute together on this completion, populating them in execList.
The abstract operation AsyncModuleExecutionFulfilled takes argument module (a
The abstract operation AsyncModuleExecutionRejected takes arguments module (a
This non-normative section gives a series of examples of the linking and evaluation of a few common module graphs, with a specific focus on how errors can occur.
First consider the following simple module graph:
Let's first assume that there are no error conditions. When a
Consider then cases involving linking errors, after a successful call to A.LoadRequestedModules(). If
Finally, consider a case involving evaluation errors after a successful call to Link(). If
Now consider a different type of error condition:
In this scenario, module A declares a dependency on some other module, but no
The difference here between loading, linking and evaluation errors is due to the following characteristic:
Now, consider a module graph with a cycle:
Here we assume that the entry point is module A, so that the
Then the
An analogous story occurs for the evaluation phase of a cyclic module graph, in the success case.
Now consider a case where A has a linking error; for example, it tries to import a binding from C that does not exist. In that case, the above steps still occur, including the early return from the second call to
Alternatively, consider a case where A has an evaluation error; for example, its source code throws an exception. In that case, the evaluation-time analogue of the above steps still occurs, including the early return from the second call to await
through the whole dependency graph through the
Lastly, consider a module graph with a cycle, where all modules complete asynchronously:
Loading and linking happen as before, and all modules end up with [[Status]] set to
Calling A.Evaluate() calls
Field
|
A | B | C | D | E |
---|---|---|---|---|---|
[[DFSIndex]] | 0 | 1 | 3 | 2 | 4 |
[[DFSAncestorIndex]] | 0 | 0 | 0 | 0 | 4 |
[[Status]] | |||||
[[AsyncEvaluationOrder]] | 4 | 1 | 3 | 0 | 2* |
[[AsyncParentModules]] | « » | « A » | « A » | « B, C » | « C » |
[[PendingAsyncDependencies]] | 2 (B and C) | 1 (D) | 2 (D and E) | 0 | 0 |
Let us assume that E finishes executing first. When that happens,
Fields / Modules | C | E |
---|---|---|
[[DFSIndex]] | 3 | 4 |
[[DFSAncestorIndex]] | 0 | 4 |
[[Status]] | ||
[[AsyncEvaluationOrder]] | 3 | 2 |
[[AsyncParentModules]] | « A » | « C » |
[[PendingAsyncDependencies]] | 1 (D) | 0 |
D is next to finish (as it was the only module that was still executing). When that happens, await
). The fields of the updated modules are as given in
Fields / Module | B | C | D |
---|---|---|---|
[[DFSIndex]] | 1 | 3 | 2 |
[[DFSAncestorIndex]] | 0 | 0 | 0 |
[[Status]] | |||
[[AsyncEvaluationOrder]] | 1 | 3 | 0 |
[[AsyncParentModules]] | « A » | « A » | « B, C » |
[[PendingAsyncDependencies]] | 0 | 0 | 0 |
Let us assume that C finishes executing next. When that happens,
Fields / Modules | A | C |
---|---|---|
[[DFSIndex]] | 0 | 3 |
[[DFSAncestorIndex]] | 0 | 0 |
[[Status]] | ||
[[AsyncEvaluationOrder]] | 4 | 3 |
[[AsyncParentModules]] | « » | « A » |
[[PendingAsyncDependencies]] | 1 (B) | 0 |
Then, B finishes executing. When that happens,
Fields / Modules | A | B |
---|---|---|
[[DFSIndex]] | 0 | 1 |
[[DFSAncestorIndex]] | 0 | 0 |
[[Status]] | ||
[[AsyncEvaluationOrder]] | 4 | 1 |
[[AsyncParentModules]] | « » | « A » |
[[PendingAsyncDependencies]] | 0 | 0 |
Finally, A finishes executing. When that happens,
Fields / Modules | A |
---|---|
[[DFSIndex]] | 0 |
[[DFSAncestorIndex]] | 0 |
[[Status]] | |
[[AsyncEvaluationOrder]] | 4 |
[[AsyncParentModules]] | « » |
[[PendingAsyncDependencies]] | 0 |
Alternatively, consider a failure case where C fails execution and returns an error before B has finished executing. When that happens,
Fields / Modules | A | C |
---|---|---|
[[DFSIndex]] | 0 | 3 |
[[DFSAncestorIndex]] | 0 | 0 |
[[Status]] | ||
[[AsyncEvaluationOrder]] | 4 | 3 |
[[AsyncParentModules]] | « » | « A » |
[[PendingAsyncDependencies]] | 1 (B) | 0 |
[[EvaluationError]] | C's evaluation error |
A will be rejected with the same error as C since C will call
Fields / Modules | A |
---|---|
[[DFSIndex]] | 0 |
[[DFSAncestorIndex]] | 0 |
[[Status]] | |
[[AsyncEvaluationOrder]] | 4 |
[[AsyncParentModules]] | « » |
[[PendingAsyncDependencies]] | 0 |
[[EvaluationError]] | C's |
Then, B finishes executing without an error. When that happens,
Fields / Modules | A | B |
---|---|---|
[[DFSIndex]] | 0 | 1 |
[[DFSAncestorIndex]] | 0 | 0 |
[[Status]] | ||
[[AsyncEvaluationOrder]] | 4 | 1 |
[[AsyncParentModules]] | « » | « A » |
[[PendingAsyncDependencies]] | 0 | 0 |
[[EvaluationError]] | C's |
A Source Text Module Record is used to represent information about a module that was defined from
A
In addition to the fields defined in
Field Name | Value Type | Meaning |
---|---|---|
[[ECMAScriptCode]] |
a |
The result of parsing the source text of this module using |
[[Context]] |
an |
The |
[[ImportMeta]] |
an Object or |
An object exposed through the import.meta meta property. It is |
[[ImportEntries]] |
a |
A |
[[LocalExportEntries]] |
a |
A |
[[IndirectExportEntries]] |
a |
A export * as namespace declarations.
|
[[StarExportEntries]] |
a |
A export * declarations that occur within the module, not including export * as namespace declarations.
|
An ImportEntry Record is a
Field Name | Value Type | Meaning |
---|---|---|
[[ModuleRequest]] |
a |
|
[[ImportName]] |
a String or |
The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. The value |
[[LocalName]] | a String | The name that is used to locally access the imported value from within the importing module. |
Import Statement Form | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
---|---|---|---|
import v from "mod";
|
|
|
|
import * as ns from "mod";
|
|
|
|
import {x} from "mod";
|
|
|
|
import {x as v} from "mod";
|
|
|
|
import "mod";
|
An |
An ExportEntry Record is a
Field Name | Value Type | Meaning |
---|---|---|
[[ExportName]] |
a String or |
The name used to export this binding by this module. |
[[ModuleRequest]] |
a |
The |
[[ImportName]] |
a String, |
The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. export * as ns from "mod" declarations. export * from "mod" declarations.
|
[[LocalName]] |
a String or |
The name that is used to locally access the exported value from within the importing module. |
Export Statement Form | [[ExportName]] | [[ModuleRequest]] | [[ImportName]] | [[LocalName]] |
---|---|---|---|---|
export var v;
|
|
|
|
|
export default function f() {}
|
|
|
|
|
export default function () {}
|
|
|
|
|
export default 42;
|
|
|
|
|
export {x};
|
|
|
|
|
export {v as x};
|
|
|
|
|
export {x} from "mod";
|
|
|
|
|
export {v as x} from "mod";
|
|
|
|
|
export * from "mod";
|
|
|
|
|
export * as ns from "mod";
|
|
|
|
|
The following definitions specify the required concrete methods and other
The abstract operation ParseModule takes arguments sourceText (
await
.An implementation may parse module source text and analyse it for Early Error conditions prior to the evaluation of ParseModule for that module source text. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that source text.
The GetExportedNames concrete method of a
GetExportedNames does not filter out or throw an exception for names that have ambiguous star export bindings.
The ResolveExport concrete method of a
ResolveExport attempts to resolve an imported binding to the actual defining module and local binding name. The defining module may be the module represented by the
If a defining module is found, a
It performs the following steps when called:
default
export was not explicitly defined by this module.default
export cannot be provided by an export * from "mod"
declaration.*
import that includes the requested name.The InitializeEnvironment concrete method of a
The ExecuteModule concrete method of a
A Synthetic Module Record is used to represent information about a module that is defined by specifications. Its exported names are statically defined at creation, while their corresponding values can change over time using
In addition to the fields defined in
Field Name | Value Type | Meaning |
---|---|---|
[[ExportNames]] | a |
The names of the exports of the module. This list does not contain duplicates. |
[[EvaluationSteps]] | an |
The initialization logic to perform upon evaluation of the module, taking the |
The abstract operation CreateDefaultExportSyntheticModule takes argument defaultExport (an
The abstract operation ParseJSONModule takes argument source (a String) and returns either a
The abstract operation SetSyntheticModuleExport takes arguments module (a
The following are the concrete methods for
The LoadRequestedModules concrete method of a
The GetExportedNames concrete method of a
The ResolveExport concrete method of a
The Link concrete method of a
The Evaluate concrete method of a
The abstract operation GetImportedModule takes arguments referrer (a
The
An example of when referrer can be a
<button type="button" onclick="import('./foo.mjs')">Click me</button>
there will be no import()
An implementation of HostLoadImportedModule must conform to the following requirements:
If this operation is called multiple times with two (referrer, moduleRequest) pairs such that:
and it performs
If moduleRequest.[[Attributes]] has an entry entry such that entry.[[Key]] is
The actual process performed is
The abstract operation FinishLoadingImportedModule takes arguments referrer (a
The abstract operation AllImportAttributesSupported takes argument attributes (a
The
An implementation of HostGetSupportedImportAttributes must conform to the following requrements:
The default implementation of HostGetSupportedImportAttributes is to return a new empty
The abstract operation GetModuleNamespace takes argument module (an instance of a concrete subclass of
GetModuleNamespace never throws. Instead, unresolvable names are simply excluded from the namespace at this point. They will lead to a real linking error later unless they are all ambiguous star exports that are not explicitly requested anywhere.
The value of a
The
The
The
The above rule means that each
The
ExportedBindings are the locally bound names that are explicitly associated with a
It is defined piecewise over the following productions:
The
ExportedNames are the externally visible names that a
It is defined piecewise over the following productions:
The
The
The
An implementation must report most errors at the time the relevant ECMAScript language construct is evaluated. An early error is an error that can be detected and reported prior to the evaluation of any construct in the eval
is called and prevent evaluation of the eval code. All errors that are not
An implementation must report as an
An implementation shall not treat other kinds of errors as
An implementation shall report all errors as specified, except for the following:
eval
, using a regular expression literal, or using the Function or RegExp An implementation must not extend this specification in the following ways:
bind
method also must not be created with such own properties.
toLocaleString
, must not be extended except as specified in ECMA-402.
:
to immediately follow source text that is matched by the There are certain built-in objects available whenever an ECMAScript
Unless specified otherwise, a built-in object that is callable as a function is a built-in
Many built-in objects are functions: they can be invoked with arguments. Some of them furthermore are new
operator. For each built-in function, this specification describes the arguments required by that function and the properties of that new
expression that invokes that
Unless otherwise specified in the description of a particular function, if a built-in function or
Unless otherwise specified in the description of a particular function, if a built-in function or
Implementations that add additional capabilities to the set of built-in functions are encouraged to do so by adding new functions rather than adding new parameters to existing functions.
Unless otherwise specified every built-in function and every built-in Function.prototype
(
Unless otherwise specified every built-in prototype object has the Object.prototype
(
If this specification defines a built-in
Built-in
Built-in
Each built-in function defined in this specification is created by calling the
Every built-in
For example, the
Unless otherwise specified, the
Every built-in
The value of the
Unless otherwise specified, the
Every other
Every
The global object:
new
operator.The initial value of the
This property has the attributes { [[Writable]]:
The value of Infinity
is
The value of NaN
is
The value of undefined
is
This function is the %eval% intrinsic object.
It performs the following steps when called:
The abstract operation PerformEval takes arguments x (an
eval
and of the eval
function itself.eval
function.The eval code cannot instantiate variable or function bindings in the variable environment of the calling context that invoked the eval if either the code of the calling context or the eval code is let
, const
, or class
declarations are always instantiated in a new LexicalEnvironment.
The
parameterStrings represents the strings that, when using one of the function eval
call.
direct signifies whether the evaluation is a
The default implementation of HostEnsureCanCompileStrings is to return
The abstract operation EvalDeclarationInstantiation takes arguments body (a
eval
will not create a global var declaration that would be shadowed by a global lexical declaration.An alternative version of this algorithm is described in
This function is the %isFinite% intrinsic object.
It performs the following steps when called:
This function is the %isNaN% intrinsic object.
It performs the following steps when called:
A reliable way for ECMAScript code to test if a value X
is X !== X
. The result will be X
is
This function produces a Number value dictated by interpretation of the contents of the string argument as a decimal literal.
It is the %parseFloat% intrinsic object.
It performs the following steps when called:
This function may interpret only a leading portion of string as a Number value; it ignores any code units that cannot be interpreted as part of the notation of a decimal literal, and no indication is given that any such code units were ignored.
This function produces an
It is the %parseInt% intrinsic object.
It performs the following steps when called:
Uniform Resource Identifiers, or URIs, are Strings that identify resources (e.g. web pages or files) and transport protocols by which to access them (e.g. HTTP or FTP) on the Internet. The ECMAScript language itself does not provide any support for using URIs except for functions that encode and decode URIs as described in this section. encodeURI
and decodeURI
are intended to work with complete URIs; they assume that any reserved characters are intended to have special meaning (e.g., as delimiters) and so are not encoded. encodeURIComponent
and decodeURIComponent
are intended to work with the individual components of a URI; they assume that any reserved characters represent text and must be encoded to avoid special meaning when the component is part of a complete URI.
The set of reserved characters is based upon RFC 2396 and does not reflect changes introduced by the more recent RFC 3986.
Many implementations of ECMAScript provide additional functions and methods that manipulate web pages; these functions are beyond the scope of this standard.
This function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the encodeURI
function is replaced with the UTF-16 encoding of the code point that it represents. Escape sequences that could not have been introduced by encodeURI
are not replaced.
It is the %decodeURI% intrinsic object.
It performs the following steps when called:
This function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the encodeURIComponent
function is replaced with the UTF-16 encoding of the code point that it represents.
It is the %decodeURIComponent% intrinsic object.
It performs the following steps when called:
This function computes a new version of a UTF-16 encoded (
It is the %encodeURI% intrinsic object.
It performs the following steps when called:
This function computes a new version of a UTF-16 encoded (
It is the %encodeURIComponent% intrinsic object.
It performs the following steps when called:
The abstract operation Encode takes arguments string (a String) and extraUnescaped (a String) and returns either a
Because percent-encoding is used to represent individual octets, a single code point may be expressed as multiple consecutive escape sequences (one for each of its 8-bit UTF-8 code units).
The abstract operation Decode takes arguments string (a String) and preserveEscapeSet (a String) and returns either a
RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. For example, the invalid sequence 0xC0 0x80 must not decode into the code unit 0x0000. Implementations of the Decode algorithm are required to throw a
The abstract operation ParseHexOctet takes arguments string (a String) and position (a non-negative
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
See
The Object
extends
clause of a class definition.This function performs the following steps when called:
The Object
This function copies the values of all of the enumerable own properties from one or more source objects to a target object.
It performs the following steps when called:
The
This function creates a new object with a specified prototype.
It performs the following steps when called:
This function adds own properties and/or updates the attributes of existing own properties of an object.
It performs the following steps when called:
The abstract operation ObjectDefineProperties takes arguments O (an Object) and Properties (an
This function adds an own property and/or updates the attributes of an existing own property of an object.
It performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
The abstract operation GetOwnPropertyKeys takes arguments O (an
This function performs the following steps when called:
callback should be a function that accepts two arguments. groupBy
calls callback once for each element in items, in ascending order, and constructs a new object. Each value returned by callback is coerced to a
callback is called with two arguments: the value of the element and the index of the element.
The return value of groupBy
is an object that does not inherit from
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
The initial value of Object.prototype
is the
This property has the attributes { [[Writable]]:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
The Object prototype object:
The initial value of Object.prototype.constructor
is
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method does not consider objects in the prototype chain.
This method performs the following steps when called:
The optional parameters to this method are not used but are intended to correspond to the parameter pattern used by ECMA-402 toLocaleString
methods. Implementations that do not include ECMA-402 support must not use those parameter positions for other purposes.
This method provides a generic toLocaleString
implementation for objects that have no locale-sensitive toString
behaviour. Array
, Number
, Date
, and toLocaleString
methods.
ECMA-402 intentionally does not provide an alternative to this default implementation.
This method performs the following steps when called:
Historically, this method was occasionally used to access the String value of the [[Class]] internal slot that was used in previous editions of this specification as a nominal type tag for various built-in objects. The above definition of toString
preserves compatibility for legacy code that uses toString
as a test for those specific kinds of built-in objects. It does not provide a reliable type testing mechanism for other kinds of built-in or program defined objects. In addition, programs can use
This method performs the following steps when called:
Object.prototype.__proto__
is an
The value of the [[Get]] attribute is a built-in function that requires no arguments. It performs the following steps when called:
The value of the [[Set]] attribute is a built-in function that takes an argument proto. It performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
Object instances have no special properties beyond those inherited from the
The Function
Function(…)
is equivalent to the object creation expression new Function(…)
with the same arguments.extends
clause of a class definition. Subclass super
call to the Function The last argument (if any) specifies the body (executable code) of a function; any preceding arguments specify formal parameters.
This function performs the following steps when called:
It is permissible but not necessary to have one argument for each formal parameter to be specified. For example, all three of the following expressions produce the same result:
new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")
The abstract operation CreateDynamicFunction takes arguments constructor (a new
was initially applied to. parameterArgs and bodyArg reflect the argument values that were passed to constructor. It performs the following steps when called:
new Function("/*", "*/ ) {")
does not evaluate to a function.CreateDynamicFunction defines a
The Function
The value of Function.prototype
is the
This property has the attributes { [[Writable]]:
The Function prototype object:
new
operator.The Function prototype object is specified to be a
This method performs the following steps when called:
The thisArg value is passed without modification as the
If func is either an arrow function or a
This method performs the following steps when called:
Function.prototype.bind
are
If Target is either an arrow function or a
This method performs the following steps when called:
The thisArg value is passed without modification as the
If func is either an arrow function or a
The initial value of Function.prototype.constructor
is
This method performs the following steps when called:
This method performs the following steps when called:
This property has the attributes { [[Writable]]:
This is the default implementation of %Symbol.hasInstance%
that most functions inherit. %Symbol.hasInstance%
is called by the instanceof
operator to determine whether a value is an instance of a specific
v instanceof F
evaluates as
F[%Symbol.hasInstance%](v)
A instanceof
by exposing a different %Symbol.hasInstance%
method on the function.
This property is non-writable and non-configurable to prevent tampering that could be used to globally expose the target function of a bound function.
The value of the
Every Function instance is an ECMAScript Function.prototype.bind
method (
Function instances have the following properties:
The value of the
The value of the
Anonymous functions objects that do not have a contextual name associated with them by this specification use the empty String as the value of the
Function instances that can be used as a
This property has the attributes { [[Writable]]:
Function.prototype.bind
, or by evaluating a
The
An implementation of HostHasSourceTextAvailable must conform to the following requirements:
The default implementation of HostHasSourceTextAvailable is to return
The Boolean
extends
clause of a class definition. Subclass super
call to the Boolean This function performs the following steps when called:
The Boolean
The initial value of Boolean.prototype
is the
This property has the attributes { [[Writable]]:
The Boolean prototype object:
The initial value of Boolean.prototype.constructor
is
This method performs the following steps when called:
This method performs the following steps when called:
The abstract operation ThisBooleanValue takes argument value (an
Boolean instances are
The Symbol
new
operator.extends
clause of a class definition but a super
call to it will cause an exception.This function performs the following steps when called:
The Symbol
The initial value of Symbol.asyncIterator
is the well-known symbol
This property has the attributes { [[Writable]]:
This function performs the following steps when called:
The GlobalSymbolRegistry List is an append-only
The initial value of Symbol.hasInstance
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.isConcatSpreadable
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.iterator
is the well-known symbol
This property has the attributes { [[Writable]]:
This function performs the following steps when called:
The initial value of Symbol.match
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.matchAll
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.prototype
is the
This property has the attributes { [[Writable]]:
The initial value of Symbol.replace
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.search
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.species
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.split
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.toPrimitive
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.toStringTag
is the well-known symbol
This property has the attributes { [[Writable]]:
The initial value of Symbol.unscopables
is the well-known symbol
This property has the attributes { [[Writable]]:
The Symbol prototype object:
The initial value of Symbol.prototype.constructor
is
Symbol.prototype.description
is an
This method performs the following steps when called:
The abstract operation SymbolDescriptiveString takes argument sym (a Symbol) and returns a String. It performs the following steps when called:
This method performs the following steps when called:
The abstract operation ThisSymbolValue takes argument value (an
This method is called by ECMAScript language operators to convert a Symbol object to a primitive value.
It performs the following steps when called:
The argument is ignored.
This property has the attributes { [[Writable]]:
The value of the
The initial value of the
This property has the attributes { [[Writable]]:
Symbol instances are
The abstract operation KeyForSymbol takes argument sym (a Symbol) and returns a String or
Instances of Error objects are thrown as exceptions when runtime errors occur. The Error objects may also serve as base objects for user-defined exception classes.
When an ECMAScript implementation detects a runtime error, it throws a new instance of one of the NativeError objects defined in
The Error
Error(…)
is equivalent to the object creation expression new Error(…)
with the same arguments.extends
clause of a class definition. Subclass super
call to the Error This function performs the following steps when called:
The Error
The initial value of Error.prototype
is the
This property has the attributes { [[Writable]]:
The Error prototype object:
The initial value of Error.prototype.constructor
is
The initial value of Error.prototype.message
is the empty String.
The initial value of Error.prototype.name
is
This method performs the following steps when called:
Error instances are Object.prototype.toString
.
A new instance of one of the NativeError objects below or of the AggregateError object is thrown when a runtime error is detected. All NativeError objects share the same structure, as described in
The EvalError
This exception is not currently used within this specification. This object remains for compatibility with previous editions of this specification.
The RangeError
Indicates a value that is not in the set or range of allowable values.
The ReferenceError
Indicate that an invalid reference has been detected.
The SyntaxError
Indicates that a parsing error has occurred.
The TypeError
TypeError is used to indicate an unsuccessful operation when none of the other NativeError objects are an appropriate indication of the failure cause.
The URIError
Indicates that one of the global URI handling functions was used in a way that is incompatible with its definition.
Each of these objects has the structure described below, differing only in the name used as the
For each error object, references to NativeError in the definition should be replaced with the appropriate error object name from
Each NativeError
NativeError(…)
is equivalent to the object creation expression new NativeError(…)
with the same arguments.extends
clause of a class definition. Subclass super
call to the NativeError Each NativeError function performs the following steps when called:
"%NativeError.prototype%"
, « [[ErrorData]] »).The actual value of the string passed in step
Each NativeError
The initial value of NativeError.prototype
is a NativeError prototype object (
This property has the attributes { [[Writable]]:
Each NativeError prototype object:
The initial value of the
The initial value of the
The initial value of the
NativeError instances are Object.prototype.toString
(
The AggregateError
AggregateError(…)
is equivalent to the object creation expression new AggregateError(…)
with the same arguments.extends
clause of a class definition. Subclass super
call to the AggregateError This function performs the following steps when called:
The AggregateError
The initial value of AggregateError.prototype
is
This property has the attributes { [[Writable]]:
The AggregateError prototype object:
The initial value of AggregateError.prototype.constructor
is
The initial value of AggregateError.prototype.message
is the empty String.
The initial value of AggregateError.prototype.name
is
AggregateError instances are Object.prototype.toString
(
The abstract operation InstallErrorCause takes arguments O (an Object) and options (an
The Number
extends
clause of a class definition. Subclass super
call to the Number This function performs the following steps when called:
The Number
The value of Number.EPSILON
is the
This property has the attributes { [[Writable]]:
This function performs the following steps when called:
This function performs the following steps when called:
This function performs the following steps when called:
This function differs from the global isNaN function (
An
This function performs the following steps when called:
Due to rounding behaviour necessitated by precision limitations of Number.MAX_SAFE_INTEGER
is shared with at least one other 9007199254740992
and 9007199254740993
evaluate to the Number value
The value of Number.MAX_SAFE_INTEGER
is
This property has the attributes { [[Writable]]:
The value of Number.MAX_VALUE
is the largest positive
This property has the attributes { [[Writable]]:
Due to rounding behaviour necessitated by precision limitations of Number.MIN_SAFE_INTEGER
is shared with at least one other -9007199254740992
and -9007199254740993
evaluate to the Number value
The value of Number.MIN_SAFE_INTEGER
is
This property has the attributes { [[Writable]]:
The value of Number.MIN_VALUE
is the smallest positive value of the
In the Number.MIN_VALUE
must be the smallest non-zero positive value that can actually be represented by the implementation.
This property has the attributes { [[Writable]]:
The value of Number.NaN
is
This property has the attributes { [[Writable]]:
The value of Number.NEGATIVE_INFINITY
is
This property has the attributes { [[Writable]]:
The initial value of the
The initial value of the
The value of Number.POSITIVE_INFINITY
is
This property has the attributes { [[Writable]]:
The initial value of Number.prototype
is the
This property has the attributes { [[Writable]]:
The Number prototype object:
Unless explicitly stated otherwise, the methods of the Number prototype object defined below are not generic and the
The phrase “this Number value” within the specification of a method refers to the result returned by calling the abstract operation
The initial value of Number.prototype.constructor
is
This method returns a String containing this Number value represented in decimal exponential notation with one digit before the significand's decimal point and fractionDigits digits after the significand's decimal point. If fractionDigits is
It performs the following steps when called:
For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step
This method returns a String containing this Number value represented in decimal fixed-point notation with fractionDigits digits after the decimal point. If fractionDigits is
It performs the following steps when called:
The output of toFixed
may be more precise than toString
for some values because toString only prints enough significant digits to distinguish the number from adjacent Number values. For example,
(1000000000000000128).toString()
returns
(1000000000000000128).toFixed(0)
returns
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method produces a String value that represents this Number value formatted according to the conventions of the toString
.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
This method returns a String containing this Number value represented either in decimal exponential notation with one digit before the significand's decimal point and
It performs the following steps when called:
The optional radix should be an
This method performs the following steps when called:
This method is not generic; it throws a
The
The abstract operation ThisNumberValue takes argument value (an
Number instances are
The BigInt
new
operator or to be subclassed. It may be used as the value of an extends
clause of a class definition but a super
call to the BigInt This function performs the following steps when called:
The abstract operation NumberToBigInt takes argument number (a Number) and returns either a
The BigInt
This function performs the following steps when called:
This function performs the following steps when called:
The initial value of BigInt.prototype
is the
This property has the attributes { [[Writable]]:
The BigInt prototype object:
The phrase “this BigInt value” within the specification of a method refers to the result returned by calling the abstract operation
The initial value of BigInt.prototype.constructor
is
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method produces a String value that represents this BigInt value formatted according to the conventions of the toString
.
The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
The optional radix should be an
This method performs the following steps when called:
This method is not generic; it throws a
The abstract operation ThisBigIntValue takes argument value (an
The initial value of the
This property has the attributes { [[Writable]]:
BigInt instances are
The Math object:
new
operator.In this specification, the phrase “the
The
This property has the attributes { [[Writable]]:
The
This property has the attributes { [[Writable]]:
The
This property has the attributes { [[Writable]]:
The
This property has the attributes { [[Writable]]:
The value of Math.LOG10E
is approximately the reciprocal of the value of Math.LN10
.
The
This property has the attributes { [[Writable]]:
The value of Math.LOG2E
is approximately the reciprocal of the value of Math.LN2
.
The
This property has the attributes { [[Writable]]:
The
This property has the attributes { [[Writable]]:
The value of Math.SQRT1_2
is approximately the reciprocal of the value of Math.SQRT2
.
The
This property has the attributes { [[Writable]]:
The initial value of the
This property has the attributes { [[Writable]]:
The behaviour of the functions acos
, acosh
, asin
, asinh
, atan
, atanh
, atan2
, cbrt
, cos
, cosh
, exp
, expm1
, hypot
, log
, log1p
, log2
, log10
, pow
, random
, sin
, sinh
, tan
, and tanh
is not precisely specified here except to require specific results for certain argument values that represent boundary cases of interest. For other argument values, these functions are intended to compute approximations to the results of familiar mathematical functions, but some latitude is allowed in the choice of approximation algorithms. The general intent is that an implementer should be able to use the same mathematical library for ECMAScript on a given hardware platform that is available to C programmers on that platform.
Although the choice of algorithms is left to the implementation, it is recommended (but not specified by this standard) that implementations use the approximation algorithms for fdlibm
, the freely distributable mathematical library from Sun Microsystems (http://www.netlib.org/fdlibm).
This function returns the absolute value of x; the result has the same magnitude as x but has positive sign.
It performs the following steps when called:
This function returns the inverse cosine of x. The result is expressed in radians and is in the
It performs the following steps when called:
This function returns the inverse hyperbolic cosine of x.
It performs the following steps when called:
This function returns the inverse sine of x. The result is expressed in radians and is in the
It performs the following steps when called:
This function returns the inverse hyperbolic sine of x.
It performs the following steps when called:
This function returns the inverse tangent of x. The result is expressed in radians and is in the
It performs the following steps when called:
This function returns the inverse hyperbolic tangent of x.
It performs the following steps when called:
This function returns the inverse tangent of the quotient
It performs the following steps when called:
This function returns the cube root of x.
It performs the following steps when called:
This function returns the smallest (closest to -∞)
It performs the following steps when called:
The value of Math.ceil(x)
is the same as the value of -Math.floor(-x)
.
This function performs the following steps when called:
If n is either
This function returns the cosine of x. The argument is expressed in radians.
It performs the following steps when called:
This function returns the hyperbolic cosine of x.
It performs the following steps when called:
The value of Math.cosh(x)
is the same as the value of (Math.exp(x) + Math.exp(-x)) / 2
.
This function returns the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms).
It performs the following steps when called:
This function returns the result of subtracting 1 from the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms). The result is computed in a way that is accurate even when the value of x is close to 0.
It performs the following steps when called:
This function returns the greatest (closest to +∞)
It performs the following steps when called:
The value of Math.floor(x)
is the same as the value of -Math.ceil(-x)
.
This function performs the following steps when called:
This function performs the following steps when called:
This operation is not the same as casting to binary32 and then to binary16 because of the possibility of double-rounding: consider the number k =
Not all platforms provide native support for casting from binary64 to binary16. There are various libraries which can provide this, including the MIT-licensed half library. Alternatively, it is possible to first cast from binary64 to binary32 under roundTiesToEven and then check whether the result could lead to incorrect double-rounding. The cases which could can be handled explicitly by adjusting the mantissa of the binary32 value so that it is the value which would be produced by performing the initial cast under roundTiesToOdd. Casting the adjusted value to binary16 under roundTiesToEven then produces the correct value.
Given zero or more arguments, this function returns the square root of the sum of squares of its arguments.
It performs the following steps when called:
The
Implementations should take care to avoid the loss of precision from overflows and underflows that are prone to occur in naive implementations when this function is called with two or more arguments.
This function performs the following steps when called:
This function returns the natural logarithm of x.
It performs the following steps when called:
This function returns the natural logarithm of 1 + x. The result is computed in a way that is accurate even when the value of x is close to zero.
It performs the following steps when called:
This function returns the base 10 logarithm of x.
It performs the following steps when called:
This function returns the base 2 logarithm of x.
It performs the following steps when called:
Given zero or more arguments, this function calls
It performs the following steps when called:
The comparison of values to determine the largest value is done using the
The
Given zero or more arguments, this function calls
It performs the following steps when called:
The comparison of values to determine the largest value is done using the
The
This function performs the following steps when called:
This function returns a Number value with positive sign, greater than or equal to
Each Math.random
function created for distinct
This function returns the Number value that is closest to x and is integral. If two
It performs the following steps when called:
Math.round(3.5)
returns 4, but Math.round(-3.5)
returns -3.
The value of Math.round(x)
is not always the same as the value of Math.floor(x + 0.5)
. When x
is x
is less than Math.round(x)
returns Math.floor(x + 0.5)
returns Math.round(x)
may also differ from the value of Math.floor(x + 0.5)
because of internal rounding when computing x + 0.5
.
This function returns the sign of x, indicating whether x is positive, negative, or zero.
It performs the following steps when called:
This function returns the sine of x. The argument is expressed in radians.
It performs the following steps when called:
This function returns the hyperbolic sine of x.
It performs the following steps when called:
The value of Math.sinh(x)
is the same as the value of (Math.exp(x) - Math.exp(-x)) / 2
.
This function returns the square root of x.
It performs the following steps when called:
This function returns the tangent of x. The argument is expressed in radians.
It performs the following steps when called:
This function returns the hyperbolic tangent of x.
It performs the following steps when called:
The value of Math.tanh(x)
is the same as the value of (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x))
.
This function returns the integral part of the number x, removing any fractional digits. If x is already integral, the result is x.
It performs the following steps when called:
The following
Time measurement in ECMAScript is analogous to time measurement in POSIX, in particular sharing definition in terms of the proleptic Gregorian calendar, an epoch of midnight at the beginning of 1 January 1970 UTC, and an accounting of every day as comprising exactly 86,400 seconds (each of which is 1000 milliseconds long).
An ECMAScript time value
Time values do not account for UTC leap seconds—there are no time values representing instants within positive leap seconds, and there are time values representing instants removed from the UTC timeline by negative leap seconds. However, the definition of time values nonetheless yields piecewise alignment with UTC, with discontinuities only at leap second boundaries and zero difference outside of leap seconds.
A Number can exactly represent all
The exact moment of midnight at the beginning of 1 January 1970 UTC is represented by the time value
In the proleptic Gregorian calendar, leap years are precisely those which are both divisible by 4 and either divisible by 400 or not divisible by 100.
The 400 year cycle of the proleptic Gregorian calendar contains 97 leap years. This yields an average of 365.2425 days per year, which is 31,556,952,000 milliseconds. Therefore, the maximum range a Number could represent exactly with millisecond precision is approximately -285,426 to 285,426 years relative to 1970. The smaller range supported by a time value as specified in this section is approximately -273,790 to 273,790 years relative to 1970.
These constants are referenced by algorithms in the following sections.
The abstract operation Day takes argument t (a
The abstract operation TimeWithinDay takes argument t (a
The abstract operation DaysInYear takes argument y (an
The abstract operation DayFromYear takes argument y (an
The abstract operation TimeFromYear takes argument y (an
The abstract operation YearFromTime takes argument t (a
The abstract operation DayWithinYear takes argument t (a
The abstract operation InLeapYear takes argument t (a
The abstract operation MonthFromTime takes argument t (a
The abstract operation DateFromTime takes argument t (a
The abstract operation WeekDay takes argument t (a
The abstract operation HourFromTime takes argument t (a
The abstract operation MinFromTime takes argument t (a
The abstract operation SecFromTime takes argument t (a
The abstract operation msFromTime takes argument t (a
The abstract operation GetUTCEpochNanoseconds takes arguments year (an
Time zones in ECMAScript are represented by time zone identifiers, which are Strings composed entirely of code units in the
A primary time zone identifier is the preferred identifier for an available named time zone. A non-primary time zone identifier is an identifier for an available named time zone that is not a primary time zone identifier. An available named time zone identifier is either a primary time zone identifier or a non-primary time zone identifier. Each available named time zone identifier is associated with exactly one available named time zone. Each available named time zone is associated with exactly one primary time zone identifier and zero or more non-primary time zone identifiers.
ECMAScript implementations must support an available named time zone with the identifier
Implementations that follow the requirements for time zones as described in the ECMA-402 Internationalization API specification are called time zone aware.
Time zone aware implementations must support available named time zones corresponding to the Zone and Link names of the IANA Time Zone Database, and only such names.
In time zone aware implementations, a primary time zone identifier is a Zone name, and a non-primary time zone identifier is a Link name, respectively, in the IANA Time Zone Database except as specifically overridden by
The
When the input represents a local time occurring more than once because of a negative time zone transition (e.g. when daylight saving time ends or the time zone offset is decreased due to a time zone rule change), the returned
The default implementation of GetNamedTimeZoneEpochNanoseconds, to be used for ECMAScript implementations that do not include local political rules for any time zones, performs the following steps when called:
It is required for
1:30 AM on 5 November 2017 in America/New_York is repeated twice, so GetNamedTimeZoneEpochNanoseconds(
2:30 AM on 12 March 2017 in America/New_York does not exist, so GetNamedTimeZoneEpochNanoseconds(
The
The returned
The default implementation of GetNamedTimeZoneOffsetNanoseconds, to be used for ECMAScript implementations that do not include local political rules for any time zones, performs the following steps when called:
Time zone offset values may be positive or negative.
A Time Zone Identifier Record is a
Time Zone Identifier Records have the fields listed in
Field Name | Value | Meaning |
---|---|---|
[[Identifier]] | a String | An |
[[PrimaryIdentifier]] | a String | The |
If [[Identifier]] is a
The
The
To ensure the level of functionality that implementations commonly provide in the methods of the Date object, it is recommended that SystemTimeZoneIdentifier return an IANA time zone name corresponding to the
For example, if the
The abstract operation LocalTime takes argument t (a
If political rules for the local time t are not available within the implementation, the result is t because
It is required for
Two different input
The abstract operation UTC takes argument t (a Number) and returns a
Input t is nominally a
If political rules for the local time t are not available within the implementation, the result is t because
It is required for
1:30 AM on 5 November 2017 in America/New_York is repeated twice (fall backward), but it must be interpreted as 1:30 AM UTC-04 instead of 1:30 AM UTC-05.
In UTC(
2:30 AM on 12 March 2017 in America/New_York does not exist, but it must be interpreted as 2:30 AM UTC-05 (equivalent to 3:30 AM UTC-04).
In UTC(
The abstract operation MakeTime takes arguments hour (a Number), min (a Number), sec (a Number), and ms (a Number) and returns a Number. It calculates a number of milliseconds. It performs the following steps when called:
The arithmetic in MakeTime is floating-point arithmetic, which is not associative, so the operations must be performed in the correct order.
The abstract operation MakeDay takes arguments year (a Number), month (a Number), and date (a Number) and returns a Number. It calculates a number of days. It performs the following steps when called:
The abstract operation MakeDate takes arguments day (a Number) and time (a Number) and returns a Number. It calculates a number of milliseconds. It performs the following steps when called:
The abstract operation MakeFullYear takes argument year (a Number) and returns an
The abstract operation TimeClip takes argument time (a Number) and returns a Number. It calculates a number of milliseconds. It performs the following steps when called:
ECMAScript defines a string interchange format for date-times based upon a simplification of the ISO 8601 calendar date extended format. The format is as follows: YYYY-MM-DDTHH:mm:ss.sssZ
Where the elements are as follows:
YYYY
|
is the year in the proleptic Gregorian calendar as four decimal digits from 0000 to 9999, or as an |
-
|
|
MM
|
is the month of the year as two decimal digits from 01 (January) to 12 (December). |
DD
|
is the day of the month as two decimal digits from 01 to 31. |
T
|
|
HH
|
is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24. |
:
|
|
mm
|
is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59. |
ss
|
is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59. |
.
|
|
sss
|
is the number of complete milliseconds since the start of the second as three decimal digits. |
Z
|
is the UTC offset representation specified as HH:mm (a subset of the |
This format includes date-only forms:
YYYY YYYY-MM YYYY-MM-DD
It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional UTC offset representation appended:
THH:mm THH:mm:ss THH:mm:ss.sss
A string containing out-of-bounds or nonconforming elements is not a valid instance of this format.
As every day both starts and ends with midnight, the two notations 00:00
and 24:00
are available to distinguish the two midnights that can be associated with one date. This means that the following two notations refer to exactly the same point in time: 1995-02-04T24:00
and 1995-02-05T00:00
. This interpretation of the latter form as "end of a calendar day" is consistent with ISO 8601, even though that specification reserves it for describing time intervals and does not permit it within representations of single points in time.
There exists no international standard that specifies abbreviations for civil time zones like CET, EST, etc. and sometimes the same abbreviation is even used for two very different time zones. For this reason, both ISO 8601 and this format specify numeric representations of time zone offsets.
Covering the full Date.parse
Examples of date-
-271821-04-20T00:00:00Z | 271822 B.C. |
-000001-01-01T00:00:00Z | 2 B.C. |
+000000-01-01T00:00:00Z | 1 B.C. |
+000001-01-01T00:00:00Z | 1 A.D. |
+001970-01-01T00:00:00Z | 1970 A.D. |
+002009-12-15T00:00:00Z | 2009 A.D. |
+275760-09-13T00:00:00Z | 275760 A.D. |
ECMAScript defines a string interchange format for UTC offsets, derived from ISO 8601. The format is described by the following grammar.
The abstract operation IsTimeZoneOffsetString takes argument offsetString (a String) and returns a Boolean. The return value indicates whether offsetString conforms to the grammar given by
The abstract operation ParseTimeZoneOffsetString takes argument offsetString (a String) and returns an
The Date
extends
clause of a class definition. Subclass super
call to the Date This function performs the following steps when called:
parse
method (The Date
This function returns the
This function applies the
If the String conforms to the MM
or DD
elements are absent, HH
, mm
, or ss
elements are absent, sss
element is absent,
If x
is any Date whose milliseconds amount is zero within a particular implementation of ECMAScript, then all of the following expressions should produce the same numeric value in that implementation, if all the properties referenced have their initial values:
x.valueOf()
Date.parse(x.toString())
Date.parse(x.toUTCString())
Date.parse(x.toISOString())
However, the expression
Date.parse(x.toLocaleString())
is not required to produce the same Number value as the preceding three expressions and, in general, the value produced by this function is toString
or toUTCString
method.
The initial value of Date.prototype
is the
This property has the attributes { [[Writable]]:
This function performs the following steps when called:
The
This function differs from the Date
The Date prototype object:
Unless explicitly defined otherwise, the methods of the Date prototype object defined below are not generic and the
The initial value of Date.prototype.constructor
is
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
The
If month is not present, this method behaves as if month was present with the value getMonth()
. If date is not present, it behaves as if date was present with the value getDate()
.
This method performs the following steps when called:
The
If min is not present, this method behaves as if min was present with the value getMinutes()
. If sec is not present, it behaves as if sec was present with the value getSeconds()
. If ms is not present, it behaves as if ms was present with the value getMilliseconds()
.
This method performs the following steps when called:
This method performs the following steps when called:
The
If sec is not present, this method behaves as if sec was present with the value getSeconds()
. If ms is not present, this behaves as if ms was present with the value getMilliseconds()
.
This method performs the following steps when called:
The
If date is not present, this method behaves as if date was present with the value getDate()
.
This method performs the following steps when called:
The
If ms is not present, this method behaves as if ms was present with the value getMilliseconds()
.
This method performs the following steps when called:
This method performs the following steps when called:
This method performs the following steps when called:
The
If month is not present, this method behaves as if month was present with the value getUTCMonth()
. If date is not present, it behaves as if date was present with the value getUTCDate()
.
This method performs the following steps when called:
The
If min is not present, this method behaves as if min was present with the value getUTCMinutes()
. If sec is not present, it behaves as if sec was present with the value getUTCSeconds()
. If ms is not present, it behaves as if ms was present with the value getUTCMilliseconds()
.
This method performs the following steps when called:
This method performs the following steps when called:
The
If sec is not present, this method behaves as if sec was present with the value getUTCSeconds()
. If ms is not present, it behaves as if ms was present with the value return by getUTCMilliseconds()
.
This method performs the following steps when called:
The
If date is not present, this method behaves as if date was present with the value getUTCDate()
.
This method performs the following steps when called:
The
If ms is not present, this method behaves as if ms was present with the value getUTCMilliseconds()
.
This method performs the following steps when called:
This method performs the following steps when called:
This method provides a String representation of a Date for use by JSON.stringify
(
It performs the following steps when called:
The argument is ignored.
This method is intentionally generic; it does not require that its toISOString
method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method returns a String value. The contents of the String are
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method returns a String value. The contents of the String are
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method returns a String value. The contents of the String are
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
This method performs the following steps when called:
For any Date d
such that d.[[DateValue]]
is evenly divisible by 1000, the result of Date.parse(d.toString())
= d.valueOf()
. See
This method is not generic; it throws a
The abstract operation TimeString takes argument tv (a Number, but not
The abstract operation DateString takes argument tv (a Number, but not
Number | Name |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Number | Name |
---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
The abstract operation TimeZoneString takes argument tv (an
The abstract operation ToDateString takes argument tv (an
This method performs the following steps when called:
This method returns a String value representing the instant in time corresponding to the
It performs the following steps when called:
This method performs the following steps when called:
This method is called by ECMAScript language operators to convert a Date to a primitive value. The allowed values for hint are
It performs the following steps when called:
This property has the attributes { [[Writable]]:
The value of the
Date instances are
The String
extends
clause of a class definition. Subclass super
call to the String This function performs the following steps when called:
The String
This function may be called with any number of arguments which form the rest parameter codeUnits.
It performs the following steps when called:
The
This function may be called with any number of arguments which form the rest parameter codePoints.
It performs the following steps when called:
The
The initial value of String.prototype
is the
This property has the attributes { [[Writable]]:
This function may be called with a variable number of arguments. The first argument is template and the remainder of the arguments form the
It performs the following steps when called:
This function is intended for use as a tag function of a Tagged Template (
The String prototype object:
Unless explicitly stated otherwise, the methods of the String prototype object defined below are not generic and the
This method returns a single element String containing the code unit at index pos within the String value resulting from converting this object to a String. If there is no element at that index, the result is the empty String. The result
If pos
is an x.charAt(pos)
is equivalent to the result of x.substring(pos, pos + 1)
.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
This method returns a Number (a non-negative
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
This method returns a non-negative
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
When this method is called it returns the String value consisting of the code units of the
This method performs the following steps when called:
The
This method is intentionally generic; it does not require that its
The initial value of String.prototype.constructor
is
This method performs the following steps when called:
This method returns
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
If searchString appears as a
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
This method is intentionally generic; it does not require that its
If searchString appears as a
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
If searchString appears as a
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method returns a Number other than
Before performing the comparisons, this method performs the following steps to prepare the Strings:
The meaning of the optional second and third parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not assign any other interpretation to those parameter positions.
The actual return values are
This method itself is not directly suitable as an argument to Array.prototype.sort
because the latter requires a function of two arguments.
This method may rely on whatever language- and/or locale-sensitive comparison functionality is available to the ECMAScript environment from the
// Å ANGSTROM SIGN vs.
// Å LATIN CAPITAL LETTER A + COMBINING RING ABOVE
"\u212B".localeCompare("A\u030A")
// Ω OHM SIGN vs.
// Ω GREEK CAPITAL LETTER OMEGA
"\u2126".localeCompare("\u03A9")
// ṩ LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE vs.
// ṩ LATIN SMALL LETTER S + COMBINING DOT ABOVE + COMBINING DOT BELOW
"\u1E69".localeCompare("s\u0307\u0323")
// ḍ̇ LATIN SMALL LETTER D WITH DOT ABOVE + COMBINING DOT BELOW vs.
// ḍ̇ LATIN SMALL LETTER D WITH DOT BELOW + COMBINING DOT ABOVE
"\u1E0B\u0323".localeCompare("\u1E0D\u0307")
// 가 HANGUL CHOSEONG KIYEOK + HANGUL JUNGSEONG A vs.
// 가 HANGUL SYLLABLE GA
"\u1100\u1161".localeCompare("\uAC00")
For a definition and discussion of canonical equivalence see the Unicode Standard, chapters 2 and 3, as well as Unicode Standard Annex #15, Unicode Normalization Forms and Unicode Technical Note #5, Canonical Equivalence in Applications. Also see Unicode Technical Standard #10, Unicode Collation Algorithm.
It is recommended that this method should not honour Unicode compatibility equivalents or compatibility decompositions as defined in the Unicode Standard, chapter 3, section 3.7.
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
This method performs a regular expression match of the String representing the
It performs the following steps when called:
String.prototype.split
, String.prototype.matchAll
is designed to typically act without mutating its inputs.This method performs the following steps when called:
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
This method performs the following steps when called:
The abstract operation StringPaddingBuiltinsImpl takes arguments O (an
The abstract operation StringPad takes arguments S (a String), maxLength (a non-negative
The argument maxLength will be clamped such that it can be no smaller than the length of S.
The argument fillString defaults to
The abstract operation ToZeroPaddedDecimalString takes arguments n (a non-negative
This method performs the following steps when called:
This method creates the String value consisting of the code units of the
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
The abstract operation GetSubstitution takes arguments matched (a String), str (a String), position (a non-negative
This method performs the following steps when called:
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
This method returns a
It performs the following steps when called:
This method is intentionally generic; it does not require that its
This method returns an Array into which substrings of the result of converting this object to a String have been stored. The substrings are determined by searching from left to right for occurrences of separator; these occurrences are not part of any String in the returned array, but serve to divide up the String value. The value of separator may be a String of any length or it may be an object, such as a RegExp, that has a
It performs the following steps when called:
The value of separator may be an empty String. In this case, separator does not match the empty
If the
If separator is
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
This method returns
Throwing an exception if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.
This method is intentionally generic; it does not require that its
This method returns a
If either argument is
If start is strictly greater than end, they are swapped.
It performs the following steps when called:
This method is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It works exactly the same as toLowerCase
except that it is intended to yield a locale-sensitive result corresponding with conventions of the
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
This method is intentionally generic; it does not require that its
An ECMAScript implementation that includes the ECMA-402 Internationalization API must implement this method as specified in the ECMA-402 specification. If an ECMAScript implementation does not include the ECMA-402 API the following specification of this method is used:
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It works exactly the same as toUpperCase
except that it is intended to yield a locale-sensitive result corresponding with conventions of the
The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.
This method is intentionally generic; it does not require that its
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It performs the following steps when called:
The result must be derived according to the locale-insensitive case mappings in the Unicode Character Database (this explicitly includes not only the file UnicodeData.txt
, but also all locale-insensitive mappings in the file SpecialCasing.txt
that accompanies it).
The case mapping of some code points may produce multiple code points. In this case the result String may not be the same length as the source String. Because both toUpperCase
and toLowerCase
have context-sensitive behaviour, the methods are not symmetrical. In other words, s.toUpperCase().toLowerCase()
is not necessarily equal to s.toLowerCase()
.
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
For a String object, this method happens to return the same thing as the valueOf
method.
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It behaves in exactly the same way as String.prototype.toLowerCase
, except that the String is mapped using the toUppercase algorithm of the Unicode Default Case Conversion.
This method is intentionally generic; it does not require that its
This method returns a String representation of this object with all
It performs the following steps when called:
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It performs the following steps when called:
This method is intentionally generic; it does not require that its
The abstract operation TrimString takes arguments string (an
The definition of white space is the union of
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It performs the following steps when called:
This method is intentionally generic; it does not require that its
This method interprets a String value as a sequence of UTF-16 encoded code points, as described in
It performs the following steps when called:
This method is intentionally generic; it does not require that its
This method performs the following steps when called:
The abstract operation ThisStringValue takes argument value (an
This method returns an
It performs the following steps when called:
The value of the
String instances are
String instances have a
The number of elements in the String value represented by this String object.
Once a String object is initialized, this property is unchanging. It has the attributes { [[Writable]]:
A String Iterator is an object that represents a specific iteration over some specific String instance object. There is not a named
The %StringIteratorPrototype% object:
The initial value of the
This property has the attributes { [[Writable]]:
A RegExp object contains a regular expression and the associated flags.
The form and functionality of regular expressions is modelled after the regular expression facility in the Perl 5 programming language.
The RegExp
Each \u
u
u
\u
The first two lines here are equivalent to CharacterClass.
A number of productions in this section are given alternative definitions in section
This section is amended in
PropertyValueAliases.txt
.
PropertyValueAliases.txt
, nor a binary property or binary property alias listed in the “The abstract operation CountLeftCapturingParensWithin takes argument node (a (
pattern character that is matched by the (
terminal of the
This section is amended in
It performs the following steps when called:
The abstract operation CountLeftCapturingParensBefore takes argument node (a
This section is amended in
It performs the following steps when called:
The abstract operation MightBothParticipate takes arguments x (a
The
This section is amended in
It is defined piecewise over the following productions:
The definitions of “the MV of
The
This section is amended in
It is defined piecewise over the following productions:
The
This section is amended in
It is defined piecewise over the following productions:
ControlEscape | Numeric Value | Code Point | Unicode Name | Symbol |
---|---|---|---|---|
t
|
9 |
U+0009
|
CHARACTER TABULATION | <HT> |
n
|
10 |
U+000A
|
LINE FEED (LF) | <LF> |
v
|
11 |
U+000B
|
LINE TABULATION | <VT> |
f
|
12 |
U+000C
|
FORM FEED (FF) | <FF> |
r
|
13 |
U+000D
|
CARRIAGE RETURN (CR) | <CR> |
\0
represents the <NUL> character and cannot be followed by a decimal digit.
The
The abstract operation GroupSpecifiersThatMatch takes argument thisGroupName (a
The
The
The
A regular expression pattern is converted into an
A u
nor a v
. Otherwise, it is a Unicode pattern. A BMP pattern matches against a String interpreted as consisting of a sequence of 16-bit values that are Unicode code points in the range of the Basic Multilingual Plane. A Unicode pattern matches against a String interpreted as consisting of Unicode code points encoded using UTF-16. In the context of describing the behaviour of a BMP pattern “character” means a single 16-bit Unicode BMP code point. In the context of describing the behaviour of a Unicode pattern “character” means a UTF-16 encoded code point (
The syntax and semantics of
For example, consider a pattern expressed in source text as the single non-BMP character U+1D11E (MUSICAL SYMBOL G CLEF). Interpreted as a Unicode pattern, it would be a single element (character)
Patterns are passed to the RegExp
An implementation may not actually perform such translations to or from UTF-16, but the semantics of this specification requires that the result of pattern matching be as if such translations were performed.
The descriptions below use the following internal data structures:
A RegExp Record is a
It has the following fields:
Field Name | Value | Meaning |
---|---|---|
[[IgnoreCase]] | a Boolean | indicates whether |
[[Multiline]] | a Boolean | indicates whether |
[[DotAll]] | a Boolean | indicates whether |
[[Unicode]] | a Boolean | indicates whether |
[[UnicodeSets]] | a Boolean | indicates whether |
[[CapturingGroupsCount]] | a non-negative |
the number of |
The
A Pattern compiles to an
The
This section is amended in
It is defined piecewise over the following productions:
The |
regular expression operator separates two alternatives. The pattern first tries to match the left |
produce
/a|ab/.exec("abc")
returns the result
/((a)|(ab))((c)|(bc))/.exec("abc")
returns the array
["abc", "a", "a", undefined, "bc", undefined, "bc"]
and not
["abc", "ab", undefined, "ab", "c", "c", undefined]
The order in which the two alternatives are tried is independent of the value of direction.
Consecutive
The resulting
The abstract operation RepeatMatcher takes arguments m (a
An
If the
Compare
/a[a-z]{2,4}/.exec("abcdefghi")
which returns
/a[a-z]{2,4}?/.exec("abcdefghi")
which returns
Consider also
/(aa|aabaac|ba|b|c)*/.exec("aabaac")
which, by the choice point ordering above, returns the array
["aaba", "ba"]
and not any of:
["aabaac", "aabaac"]
["aabaac", "c"]
The above ordering of choice points can be used to write a regular expression that calculates the greatest common divisor of two numbers (represented in unary notation). The following example calculates the gcd of 10 and 15:
"aaaaaaaaaa,aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/, "$1")
which returns the gcd in unary notation
Step
/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")
which returns the array
["zaacbbbcac", "z", "ac", "a", undefined, "c"]
and not
["zaacbbbcac", "z", "ac", "a", "bbb", "c"]
because each iteration of the outermost *
clears all captured Strings contained in the quantified
Step
/(a*)*/.exec("b")
or the slightly more complicated:
/(a*)b\1+/.exec("baaaac")
which returns the array
["b", ""]
The abstract operation EmptyMatcher takes no arguments and returns a
The abstract operation MatchTwoAlternatives takes arguments m1 (a
The abstract operation MatchSequence takes arguments m1 (a
The
This section is amended in
It is defined piecewise over the following productions:
Even when the y
flag is used with a pattern, ^
always matches only at the beginning of Input, or (if rer.[[Multiline]] is
The form (?=
)
specifies a zero-width positive lookahead. In order for it to succeed, the pattern inside (?=
form (this unusual behaviour is inherited from Perl). This only matters when the
For example,
/(?=(a+))/.exec("baaabac")
matches the empty String immediately after the first b
and therefore returns the array:
["", "aaa"]
To illustrate the lack of backtracking into the lookahead, consider:
/(?=(a+))a*b\1/.exec("baaabac")
This expression returns
["aba", "a"]
and not:
["aaaba", "a"]
The form (?!
)
specifies a zero-width negative lookahead. In order for it to succeed, the pattern inside
/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")
looks for an a
not immediately followed by some positive number n of a
's, a b
, another n a
's (specified by the first \2
) and a c
. The second \2
is outside the negative lookahead, so it matches against
["baaabaac", "ba", undefined, "abaac"]
The abstract operation IsWordChar takes arguments rer (a
The
The
The
This section is amended in
It is defined piecewise over the following productions:
Parentheses of the form (
)
serve both to group the components of the \
followed by a non-zero decimal number), referenced in a replace String, or returned as part of an array from the regular expression matching (?:
)
instead.
An escape sequence of the form \
followed by a non-zero decimal number n matches the result of the nth set of capturing parentheses (
The abstract operation CharacterSetMatcher takes arguments rer (a
The abstract operation BackreferenceMatcher takes arguments rer (a
The abstract operation Canonicalize takes arguments rer (a
CaseFolding.txt
of the Unicode Character Database provides a simple or common case folding mapping for ch, return the result of applying that mapping to ch.In case-insignificant matches when ß
(U+00DF LATIN SMALL LETTER SHARP S) to ss
or SS
. It may however map code points outside the Basic Latin block to code points within it—for example, ſ
(U+017F LATIN SMALL LETTER LONG S) case-folds to s
(U+0073 LATIN SMALL LETTER S) and K
(U+212A KELVIN SIGN) case-folds to k
(U+006B LATIN SMALL LETTER K). Strings containing those code points are matched by regular expressions such as /[a-z]/ui
.
In case-insignificant matches when Ω
(U+2126 OHM SIGN) is mapped by toUppercase to itself but by toCasefold to ω
(U+03C9 GREEK SMALL LETTER OMEGA) along with Ω
(U+03A9 GREEK CAPITAL LETTER OMEGA), so /[ω]/ui
and /[\u03A9]/ui
but not by /[ω]/i
or /[\u03A9]/i
. Also, no code point outside the Basic Latin block is mapped to a code point within it, so strings such as /[a-z]/i
.
The abstract operation UpdateModifiers takes arguments rer (a
The
The
This section is amended in
It is defined piecewise over the following productions: