This Ecma Standard defines the ECMAScript 2021 Language. It is the twelfth edition of the ECMAScript Language
Specification. Since publication of the first edition in 1997, ECMAScript has grown to be one of the world's most
widely used general-purpose programming languages. It is best known as the language embedded in web browsers
but has also been widely adopted for server and embedded applications.

ECMAScript is based on several originating technologies, the most well-known being JavaScript (Netscape) and
JScript (Microsoft). The language was invented by Brendan Eich at Netscape and first appeared in that company's
Navigator 2.0 browser. It has appeared in all subsequent browsers from Netscape and in all browsers from Microsoft
starting with Internet Explorer 3.0.

The development of the ECMAScript Language Specification started in November 1996. The first edition of this Ecma
Standard was adopted by the Ecma General Assembly of June 1997.

That Ecma Standard was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as
international standard ISO/IEC 16262, in April 1998. The Ecma General Assembly of June 1998 approved the second
edition of ECMA-262 to keep it fully aligned with ISO/IEC 16262. Changes between the first and the second edition
are editorial in nature.

The third edition of the Standard introduced powerful regular expressions, better string handling, new control
statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and minor
changes in anticipation of future language growth. The third edition of the ECMAScript standard was adopted by the
Ecma General Assembly of December 1999 and published as ISO/IEC 16262:2002 in June 2002.

After publication of the third edition, ECMAScript achieved massive adoption in conjunction with the World Wide
Web where it has become the programming language that is supported by essentially all web browsers. Significant
work was done to develop a fourth edition of ECMAScript. However, that work was not completed and not published
as the fourth edition of ECMAScript but some of it was incorporated into the development of the sixth edition.

The fifth edition of ECMAScript (published as ECMA-262 5

edition) codified de facto interpretations of the language

specification that have become common among browser implementations and added support for new features that
had emerged since the publication of the third edition. Such features include accessor properties, reflective creation
and inspection of objects, program control of property attributes, additional array manipulation functions, support for
the JSON object encoding format, and a strict mode that provides enhanced error checking and program security. The
fifth edition was adopted by the Ecma General Assembly of December 2009.

The fifth edition was submitted to ISO/IEC JTC 1 for adoption under the fast-track procedure, and approved as
international standard ISO/IEC 16262:2011. Edition 5.1 of the ECMAScript Standard incorporated minor corrections
and is the same text as ISO/IEC 16262:2011. The 5.1 Edition was adopted by the Ecma General Assembly of June 2011.

Focused development of the sixth edition started in 2009, as the fifth edition was being prepared for publication.
However, this was preceded by significant experimentation and language enhancement design efforts dating to the
publication of the third edition in 1999. In a very real sense, the completion of the sixth edition is the culmination of a
fifteen year effort. The goals for this edition included providing better support for large applications, library creation,
and for use of ECMAScript as a compilation target for other languages. Some of its major enhancements included
modules, class declarations, lexical block scoping, iterators and generators, promises for asynchronous programming,
destructuring patterns, and proper tail calls. The ECMAScript library of built-ins was expanded to support additional
data abstractions including maps, sets, and arrays of binary numeric values as well as additional support for Unicode
supplemental characters in strings and regular expressions. The built-ins were also made extensible via subclassing.

Introduction

The sixth edition provides the foundation for regular, incremental language and library enhancements. The sixth
edition was adopted by the General Assembly of June 2015.

ECMAScript 2016 was the first ECMAScript edition released under Ecma TC39's new yearly release cadence and open
development process. A plain-text source document was built from the ECMAScript 2015 source document to serve as
the base for further development entirely on GitHub. Over the year of this standard's development, hundreds of pull
requests and issues were filed representing thousands of bug fixes, editorial fixes and other improvements.
Additionally, numerous software tools were developed to aid in this effort including Ecmarkup, Ecmarkdown, and
Grammarkdown. ES2016 also included support for a new exponentiation operator and adds a new method to

Array.prototype

called

includes

ECMAScript 2017 introduced Async Functions, Shared Memory, and Atomics along with smaller language and library
enhancements, bug fixes, and editorial updates. Async functions improve the asynchronous programming experience
by providing syntax for promise-returning functions. Shared Memory and Atomics introduce a new

memory model

that allows multi-

agent

programs to communicate using atomic operations that ensure a well-defined execution order

even on parallel CPUs. It also included new static methods on Object:

Object.values

Object.entries

, and

Object.getOwnPropertyDescriptors

ECMAScript 2018 introduced support for asynchronous iteration via the AsyncIterator protocol and async generators.
It also included four new regular expression features: the

dotAll

flag, named capture groups, Unicode property

escapes, and look-behind assertions. Lastly it included object rest and spread properties.

ECMAScript 2019 introduced a few new built-in functions:

flat

and

flatMap

Array.prototype

for

flattening arrays,

Object.fromEntries

for directly turning the return value of

Object.entries

into a new

Object, and

trimStart

and

trimEnd

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 11

edition, introduces the

matchAll

method for Strings, to produce an iterator for all match

objects generated by a global regular expression;

import()

, a syntax to asynchronously import Modules with a

dynamic specifier;

BigInt

, a new number primitive for working with arbitrary precision integers;

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

host

-populated object available in

Modules that may contain contextual information about the Module; as well as adding two new syntax features to
improve working with “nullish” values (

null

undefined

): nullish coalescing, a value selection operator; and

optional chaining, a property access and function invocation operator that short-circuits if the value to access/invoke
is nullish.

This specification, the 12

edition, introduces 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

Content .. 4 5 6 7 ..