Pins

Table of Contents

Introduction
1 Scope
+2 Conformance
1. 2.1 Example Normative Optional Clause Heading
2. 2.2 Example Legacy Clause Heading
3. 2.3 Example Legacy Normative Optional Clause Heading
3 Normative References
+4 Overview
1. 4.1 Web Scripting
2. 4.2 Hosts and Implementations
3. +4.3 ECMAScript Overview
  1. 4.3.1 Objects
  2. 4.3.2 The Strict Variant of ECMAScript
4. +4.4 Terms and Definitions
5. 4.5 Organization of This Specification
+5 Notational Conventions
1. +5.1 Syntactic and Lexical Grammars
2. +5.2 Algorithm Conventions
+6 ECMAScript Data Types and Values
1. +6.1 ECMAScript Language Types
2. +6.2 ECMAScript Specification Types
+7 Abstract Operations
1. +7.1 Type Conversion
2. +7.2 Testing and Comparison Operations
3. +7.3 Operations on Objects
4. +7.4 Operations on Iterator Objects
+8 Syntax-Directed Operations
1. 8.1 RS: Evaluation
2. +8.2 Scope Analysis
3. +8.3 Labels
4. +8.4 Function Name Inference
5. +8.5 Contains
  1. 8.5.1 SS: Contains
  2. 8.5.2 SS: ComputedPropertyContains
6. +8.6 Miscellaneous
+9 Executable Code and Execution Contexts
1. +9.1 Environment Records
  1. +9.1.1 The Environment Record Type Hierarchy
  2. +9.1.2 Environment Record Operations
2. +9.2 PrivateEnvironment Records
  1. +9.2.1 PrivateEnvironment Record Operations
    1. 9.2.1.1 NewPrivateEnvironment (outerPrivateEnv )
    2. 9.2.1.2 ResolvePrivateIdentifier (privateEnv,identifier )
3. +9.3 Realms
4. +9.4 Execution Contexts
5. +9.5 Jobs and Host Operations to Enqueue Jobs
6. +9.6 Agents
7. 9.7 Agent Clusters
8. 9.8 Forward Progress
9. +9.9 Processing Model of WeakRef and FinalizationRegistry Targets
10. 9.10 ClearKeptObjects ( )
11. 9.11 AddToKeptObjects (value )
12. 9.12 CleanupFinalizationRegistry (finalizationRegistry )
13. 9.13 CanBeHeldWeakly (v )
+10 Ordinary and Exotic Objects Behaviours
1. +10.1 Ordinary Object Internal Methods and Internal Slots
2. +10.2 ECMAScript Function Objects
3. +10.3 Built-in Function Objects
4. +10.4 Built-in Exotic Object Internal Methods and Slots
5. +10.5 Proxy Object Internal Methods and Internal Slots
+11 ECMAScript Language: Source Text
1. +11.1 Source Text
2. +11.2 Types of Source Code
+12 ECMAScript Language: Lexical Grammar
1. 12.1 Unicode Format-Control Characters
2. 12.2 White Space
3. 12.3 Line Terminators
4. 12.4 Comments
5. 12.5 Hashbang Comments
6. 12.6 Tokens
7. +12.7 Names and Keywords
  1. +12.7.1 Identifier Names
  2. 12.7.2 Keywords and Reserved Words
8. 12.8 Punctuators
9. +12.9 Literals
10. +12.10 Automatic Semicolon Insertion
+13 ECMAScript Language: Expressions
1. +13.1 Identifiers
2. +13.2 Primary Expression
3. +13.3 Left-Hand-Side Expressions
4. +13.4 Update Expressions
5. +13.5 Unary Operators
6. +13.6 Exponentiation Operator
  1. 13.6.1 RS: Evaluation
7. +13.7 Multiplicative Operators
  1. 13.7.1 RS: Evaluation
8. +13.8 Additive Operators
  1. +13.8.1 The Addition Operator (+ )
    1. 13.8.1.1 RS: Evaluation
  2. +13.8.2 The Subtraction Operator (- )
    1. 13.8.2.1 RS: Evaluation
9. +13.9 Bitwise Shift Operators
10. +13.10 Relational Operators
  1. 13.10.1 RS: Evaluation
  2. 13.10.2 InstanceofOperator (V,target )
11. +13.11 Equality Operators
  1. 13.11.1 RS: Evaluation
12. +13.12 Binary Bitwise Operators
  1. 13.12.1 RS: Evaluation
13. +13.13 Binary Logical Operators
  1. 13.13.1 RS: Evaluation
14. +13.14 Conditional Operator (? : )
  1. 13.14.1 RS: Evaluation
15. +13.15 Assignment Operators
16. +13.16 Comma Operator (, )
  1. 13.16.1 RS: Evaluation
+14 ECMAScript Language: Statements and Declarations
1. +14.1 Statement Semantics
  1. 14.1.1 RS: Evaluation
2. +14.2 Block
3. +14.3 Declarations and the Variable Statement
4. +14.4 Empty Statement
  1. 14.4.1 RS: Evaluation
5. +14.5 Expression Statement
  1. 14.5.1 RS: Evaluation
6. +14.6 Theif Statement
  1. 14.6.1 SS: Early Errors
  2. 14.6.2 RS: Evaluation
7. +14.7 Iteration Statements
8. +14.8 Thecontinue Statement
  1. 14.8.1 SS: Early Errors
  2. 14.8.2 RS: Evaluation
9. +14.9 Thebreak Statement
  1. 14.9.1 SS: Early Errors
  2. 14.9.2 RS: Evaluation
10. +14.10 Thereturn Statement
  1. 14.10.1 RS: Evaluation
11. +14.11 Thewith Statement
  1. 14.11.1 SS: Early Errors
  2. 14.11.2 RS: Evaluation
12. +14.12 Theswitch Statement
13. +14.13 Labelled Statements
14. +14.14 Thethrow Statement
  1. 14.14.1 RS: Evaluation
15. +14.15 Thetry Statement
16. +14.16 Thedebugger Statement
  1. 14.16.1 RS: Evaluation
+15 ECMAScript Language: Functions and Classes
1. +15.1 Parameter Lists
2. +15.2 Function Definitions
3. +15.3 Arrow Function Definitions
4. +15.4 Method Definitions
5. +15.5 Generator Function Definitions
6. +15.6 Async Generator Function Definitions
7. +15.7 Class Definitions
8. +15.8 Async Function Definitions
9. +15.9 Async Arrow Function Definitions
10. +15.10 Tail Position Calls
+16 ECMAScript Language: Scripts and Modules
1. +16.1 Scripts
2. +16.2 Modules
+17 Error Handling and Language Extensions
1. 17.1 Forbidden Extensions
18 ECMAScript Standard Built-in Objects
+19 The Global Object
1. +19.1 Value Properties of the Global Object
2. +19.2 Function Properties of the Global Object
3. +19.3 Constructor Properties of the Global Object
4. +19.4 Other Properties of the Global Object
+20 Fundamental Objects
1. +20.1 Object Objects
2. +20.2 Function Objects
3. +20.3 Boolean Objects
4. +20.4 Symbol Objects
5. +20.5 Error Objects
+21 Numbers and Dates
1. +21.1 Number Objects
2. +21.2 BigInt Objects
3. +21.3 The Math Object
  1. +21.3.1 Value Properties of the Math Object
  2. +21.3.2 Function Properties of the Math Object
4. +21.4 Date Objects
+22 Text Processing
1. +22.1 String Objects
2. +22.2 RegExp (Regular Expression) Objects
+23 Indexed Collections
1. +23.1 Array Objects
2. +23.2 TypedArray Objects
3. +23.3 Uint8Array Objects
+24 Keyed Collections
1. +24.1 Map Objects
2. +24.2 Set Objects
3. +24.3 WeakMap Objects
4. +24.4 WeakSet Objects
5. +24.5 Abstract Operations for Keyed Collections
  1. 24.5.1 CanonicalizeKeyedCollectionKey (key )
+25 Structured Data
1. +25.1 ArrayBuffer Objects
2. +25.2 SharedArrayBuffer Objects
3. +25.3 DataView Objects
4. +25.4 The Atomics Object
5. +25.5 The JSON Object
+26 Managing Memory
1. +26.1 WeakRef Objects
2. +26.2 FinalizationRegistry Objects
+27 Control Abstraction Objects
1. +27.1 Iteration
2. +27.2 Promise Objects
3. +27.3 GeneratorFunction Objects
4. +27.4 AsyncGeneratorFunction Objects
5. +27.5 Generator Objects
6. +27.6 AsyncGenerator Objects
7. +27.7 AsyncFunction Objects
+28 Reflection
1. +28.1 The Reflect Object
2. +28.2 Proxy Objects
  1. +28.2.1 The Proxy Constructor
    1. 28.2.1.1 Proxy (target,handler )
  2. +28.2.2 Properties of the Proxy Constructor
    1. 28.2.2.1 Proxy.revocable (target,handler )
3. +28.3 Module Namespace Objects
  1. 28.3.1 %Symbol.toStringTag%
+29 Memory Model
1. 29.1 Memory Model Fundamentals
2. 29.2 Agent Events Records
3. 29.3 Chosen Value Records
4. 29.4 Candidate Executions
5. +29.5 Abstract Operations for the Memory Model
6. +29.6 Relations of Candidate Executions
7. +29.7 Properties of Valid Executions
8. 29.8 Races
9. 29.9 Data Races
10. 29.10 Data Race Freedom
11. 29.11 Shared Memory Guidelines
+Annex A(informative) Grammar Summary
1. A.1 Lexical Grammar
2. A.2 Expressions
3. A.3 Statements
4. A.4 Functions and Classes
5. A.5 Scripts and Modules
6. A.6 Number Conversions
7. A.7 Time Zone Offset String Format
8. A.8 Regular Expressions
+Annex B(normative) Additional ECMAScript Features for Web Browsers
1. +B.1 Additional Syntax
  1. B.1.1 HTML-like Comments
  2. +B.1.2 Regular Expressions Patterns
2. +B.2 Additional Built-in Properties
3. +B.3 Other Additional Features
Annex C(informative) The Strict Mode of ECMAScript
+Annex D(informative) Host Layering Points
1. D.1 Host Hooks
2. D.2 Host-defined Fields
3. D.3 Host-defined Objects
4. D.4 Running Jobs
5. D.5 Internal Methods of Exotic Objects
6. D.6 Built-in Objects and Methods
Annex E(informative) Corrections and Clarifications in ECMAScript 2015 with Possible Compatibility Impact
Annex F(informative) Additions and Changes That Introduce Incompatibilities with Prior Editions
Bibliography
Colophon
Copyright & Software License

11 ECMAScript Language: Source Text

11.1 Source Text

Syntax

any Unicode code point

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 ofSourceCharacter values, eachSourceCharacter being a Unicode code point. Conforming ECMAScript implementations are not required to perform any normalization of source text, or behave as though they were performing normalization of source text.

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.

Note

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.

11.1.1 Static Semantics: UTF16EncodeCodePoint (`cp` )

The abstract operation UTF16EncodeCodePoint takes argumentcp (a Unicode code point) and returns a String. It performs the following steps when called:

Assert: 0 ≤cp ≤ 0x10FFFF.
Ifcp ≤ 0xFFFF, return the String value consisting of the code unit whose numeric value iscp.
Letcu1 be the code unit whose numeric value isfloor((cp - 0x10000) / 0x400) + 0xD800.
Letcu2 be the code unit whose numeric value is ((cp - 0x10000)modulo 0x400) + 0xDC00.
Return thestring-concatenation ofcu1 andcu2.

11.1.2 Static Semantics: CodePointsToString (`text` )

The abstract operation CodePointsToString takes argumenttext (a sequence of Unicode code points) and returns a String. It convertstext into a String value, as described in6.1.4. It performs the following steps when called:

Letresult be the empty String.
For each code pointcp oftext, do
1. Setresult to thestring-concatenation ofresult andUTF16EncodeCodePoint(cp).
Returnresult.

11.1.3 Static Semantics: UTF16SurrogatePairToCodePoint (`lead`,`trail` )

The abstract operation UTF16SurrogatePairToCodePoint takes argumentslead (a code unit) andtrail (a code unit) and returns a code point. Two code units that form a UTF-16surrogate pair are converted to a code point. It performs the following steps when called:

Assert:lead is aleading surrogate andtrail is atrailing surrogate.
Letcp be (lead - 0xD800) × 0x400 + (trail - 0xDC00) + 0x10000.
Return the code pointcp.

11.1.4 Static Semantics: CodePointAt (`string`,`position` )

The abstract operation CodePointAt takes argumentsstring (a String) andposition (a non-negativeinteger) and returns aRecord with fields[[CodePoint]] (a code point),[[CodeUnitCount]] (a positiveinteger), and[[IsUnpairedSurrogate]] (a Boolean). It interpretsstring as a sequence of UTF-16 encoded code points, as described in6.1.4, and reads from it a single code point starting with the code unit at indexposition. It performs the following steps when called:

Letsize be the length ofstring.
Assert:position ≥ 0 andposition <size.
Letfirst be the code unit at indexposition withinstring.
Letcp be the code point whose numeric value is the numeric value offirst.
Iffirst is neither aleading surrogate nor atrailing surrogate, then
1. Return theRecord {[[CodePoint]]:cp,[[CodeUnitCount]]: 1,[[IsUnpairedSurrogate]]:false }.
Iffirst is atrailing surrogate orposition + 1 =size, then
1. Return theRecord {[[CodePoint]]:cp,[[CodeUnitCount]]: 1,[[IsUnpairedSurrogate]]:true }.
Letsecond be the code unit at indexposition + 1 withinstring.
Ifsecond is not atrailing surrogate, then
1. Return theRecord {[[CodePoint]]:cp,[[CodeUnitCount]]: 1,[[IsUnpairedSurrogate]]:true }.
Setcp toUTF16SurrogatePairToCodePoint(first,second).
Return theRecord {[[CodePoint]]:cp,[[CodeUnitCount]]: 2,[[IsUnpairedSurrogate]]:false }.

11.1.5 Static Semantics: StringToCodePoints (`string` )

The abstract operation StringToCodePoints takes argumentstring (a String) and returns aList of code points. It returns the sequence of Unicode code points that results from interpretingstring as UTF-16 encoded Unicode text as described in6.1.4. It performs the following steps when called:

LetcodePoints be a new emptyList.
Letsize be the length ofstring.
Letposition be 0.
Repeat, whileposition <size,
1. Letcp beCodePointAt(string,position).
2. Appendcp.[[CodePoint]] tocodePoints.
3. Setposition toposition +cp.[[CodeUnitCount]].
ReturncodePoints.

11.1.6 Static Semantics: ParseText (`sourceText`,`goalSymbol` )

The abstract operation ParseText takes argumentssourceText (a String or a sequence of Unicode code points) andgoalSymbol (a nonterminal in one of the ECMAScript grammars) and returns aParse Node or a non-emptyList ofSyntaxError objects. It performs the following steps when called:

IfsourceTextis a String, setsourceText toStringToCodePoints(sourceText).
Attempt to parsesourceText usinggoalSymbol as thegoal symbol, and analyse the parse result for anyearly error conditions. Parsing andearly error detection may be interleaved in animplementation-defined manner.
If the parse succeeded and noearly errors were found, return theParse Node (an instance ofgoalSymbol) at the root of the parse tree resulting from the parse.
Otherwise, return aList of one or moreSyntaxError objects representing the parsing errors and/orearly errors. If more than one parsing error orearly error is present, the number and ordering of error objects in the list isimplementation-defined, but at least one must be present.

Note 1

Consider a text that has anearly error at a particular point, and also a syntax error at a later point. An implementation that does a parse pass followed by anearly errors pass might report the syntax error and not proceed to theearly errors pass. An implementation that interleaves the two activities might report theearly error and not proceed to find the syntax error. A third implementation might report both errors. All of these behaviours are conformant.

Note 2

11.2 Types of Source Code

There are four types of ECMAScript code:

Global code is source text that is treated as an ECMAScriptScript. The global code of a particularScript does not include any source text that is parsed as part of aFunctionDeclaration,FunctionExpression,GeneratorDeclaration,GeneratorExpression,AsyncFunctionDeclaration,AsyncFunctionExpression,AsyncGeneratorDeclaration,AsyncGeneratorExpression,MethodDefinition,ArrowFunction,AsyncArrowFunction,ClassDeclaration, orClassExpression.
Eval code is the source text supplied to the built-ineval function. More precisely, if the parameter to the built-ineval functionis a String, it is treated as an ECMAScriptScript. The eval code for a particular invocation ofeval is the global code portion of thatScript.
Function code is source text that is parsed to supply the value of the[[ECMAScriptCode]] and[[FormalParameters]] internal slots (see10.2) of an ECMAScriptfunction object. The function code of a particular ECMAScript function does not include any source text that is parsed as the function code of a nestedFunctionDeclaration,FunctionExpression,GeneratorDeclaration,GeneratorExpression,AsyncFunctionDeclaration,AsyncFunctionExpression,AsyncGeneratorDeclaration,AsyncGeneratorExpression,MethodDefinition,ArrowFunction,AsyncArrowFunction,ClassDeclaration, orClassExpression.
In addition, if the source text referred to above is parsed as:
- theFormalParameters andFunctionBody of aFunctionDeclaration orFunctionExpression,
- theFormalParameters andGeneratorBody of aGeneratorDeclaration orGeneratorExpression,
- theFormalParameters andAsyncFunctionBody of anAsyncFunctionDeclaration orAsyncFunctionExpression, or
- theFormalParameters andAsyncGeneratorBody of anAsyncGeneratorDeclaration orAsyncGeneratorExpression,
then thesource text matched by theBindingIdentifier (if any) of that declaration or expression is also included in the function code of the corresponding function.
Module code is source text that is code that is provided as aModuleBody. It is the code that is directly evaluated when a module is initialized. The module code of a particular module does not include any source text that is parsed as part of a nestedFunctionDeclaration,FunctionExpression,GeneratorDeclaration,GeneratorExpression,AsyncFunctionDeclaration,AsyncFunctionExpression,AsyncGeneratorDeclaration,AsyncGeneratorExpression,MethodDefinition,ArrowFunction,AsyncArrowFunction,ClassDeclaration, orClassExpression.

Note 1

Function code is generally provided as the bodies of Function Definitions (15.2), Arrow Function Definitions (15.3), Method Definitions (15.4), Generator Function Definitions (15.5), Async Function Definitions (15.8), Async Generator Function Definitions (15.6), and Async Arrow Functions (15.9). Function code is also derived from the arguments to the Functionconstructor (20.2.1.1), the GeneratorFunctionconstructor (27.3.1.1), the AsyncFunctionconstructor (27.7.1.1), and the AsyncGeneratorFunctionconstructor (27.4.1.1).

Note 2

The practical effect of including theBindingIdentifier in function code is that the Early Errors forstrict mode code are applied to aBindingIdentifier that is the name of a function whose body contains a "use strict" directive, even if the surrounding code is notstrict mode code.

11.2.1 Directive Prologues and the Use Strict Directive

ADirective Prologue is the longest sequence ofExpressionStatements occurring as the initialStatementListItems orModuleItems of aFunctionBody, aScriptBody, or aModuleBody and where eachExpressionStatement in the sequence consists entirely of aStringLiteral token followed by a semicolon. The semicolon may appear explicitly or may be inserted by automatic semicolon insertion (12.10). ADirective Prologue may be an empty sequence.

AUse Strict Directive is anExpressionStatement in aDirective Prologue whoseStringLiteral is either of the exact code point sequences"use strict" or'use strict'. AUse Strict Directive may not contain anEscapeSequence orLineContinuation.

ADirective Prologue may contain more than oneUse Strict Directive. However, an implementation may issue a warning if this occurs.

Note

TheExpressionStatements of aDirective Prologue are evaluated normally during evaluation of the containing production. Implementations may define implementation specific meanings forExpressionStatements which are not aUse Strict Directive and which occur in aDirective Prologue. If an appropriate notification mechanism exists, an implementation should issue a warning if it encounters in aDirective Prologue anExpressionStatement that is not aUse Strict Directive and which does not have a meaning defined by the implementation.

11.2.2 Strict Mode Code

An ECMAScript syntactic unit may be processed using either unrestricted or strict mode syntax and semantics (4.3.2). Code is interpreted asstrict mode code in the following situations:

Global code is strict mode code if it begins with aDirective Prologue that contains aUse Strict Directive.
Module code is always strict mode code.
All parts of aClassDeclaration or aClassExpression are strict mode code.
Eval code is strict mode code if it begins with aDirective Prologue that contains aUse Strict Directive or if the call toeval is adirect eval that is contained in strict mode code.
Function code is strict mode code if the associatedFunctionDeclaration,FunctionExpression,GeneratorDeclaration,GeneratorExpression,AsyncFunctionDeclaration,AsyncFunctionExpression,AsyncGeneratorDeclaration,AsyncGeneratorExpression,MethodDefinition,ArrowFunction, orAsyncArrowFunction is contained in strict mode code or if the code that produces the value of the function's[[ECMAScriptCode]] internal slot begins with aDirective Prologue that contains aUse Strict Directive.
Function code that is supplied as the arguments to the built-in Function, Generator, AsyncFunction, and AsyncGeneratorconstructors is strict mode code if the last argumentis a String that when processed is aFunctionBody that begins with aDirective Prologue that contains aUse Strict Directive.

ECMAScript code that is not strict mode code is callednon-strict code.

11.2.2.1 Static Semantics: IsStrict (`node` )

The abstract operation IsStrict takes argumentnode (aParse Node) and returns a Boolean. It performs the following steps when called:

If thesource text matched bynode isstrict mode code, returntrue; else returnfalse.

11.2.3 Non-ECMAScript Functions

An ECMAScript implementation may support the evaluation of functionexotic objects whose evaluative behaviour is expressed in somehost-defined form of executable code other thanECMAScript source text. Whether afunction object is defined within ECMAScript code or is a built-in function is not observable from the perspective of ECMAScript code that calls or is called by such afunction object.

Movatterモバイル変換

11 ECMAScript Language: Source Text

11.1 Source Text

Syntax

11.1.1 Static Semantics: UTF16EncodeCodePoint (cp )

11.1.2 Static Semantics: CodePointsToString (text )

11.1.3 Static Semantics: UTF16SurrogatePairToCodePoint (lead,trail )

11.1.4 Static Semantics: CodePointAt (string,position )

11.1.5 Static Semantics: StringToCodePoints (string )

11.1.6 Static Semantics: ParseText (sourceText,goalSymbol )