13 ECMAScript 言語: 表現式 (Expressions)

13.1 識別子 (Identifiers)

構文 (Syntax)

IdentifierReference[Yield, Await] : Identifier [~Yield] yield [~Await] await BindingIdentifier[Yield, Await] : Identifier yield await LabelIdentifier[Yield, Await] : Identifier [~Yield] yield [~Await] await Identifier : IdentifierName but not ReservedWord Note

yield と await は文法上は BindingIdentifier として許可されるが、以下の静的セマンティクスにより禁止され、次のようなケースで自動セミコロン挿入を許さないためである:

let
await 0;

13.1.1 静的セマンティクス: 早期エラー (Early Errors)

BindingIdentifier : Identifier
  • IsStrict(this production) が true であり、Identifier の StringValue が "arguments" か "eval" のいずれかであるなら構文エラー。
IdentifierReference : yield BindingIdentifier : yield LabelIdentifier : yield
  • IsStrict(this production) が true なら構文エラー。
IdentifierReference : await BindingIdentifier : await LabelIdentifier : await BindingIdentifier[Yield, Await] : yield
  • この生成規則が [Yield] パラメータを持つなら構文エラー。
BindingIdentifier[Yield, Await] : await
  • この生成規則が [Await] パラメータを持つなら構文エラー。
IdentifierReference[Yield, Await] : Identifier BindingIdentifier[Yield, Await] : Identifier LabelIdentifier[Yield, Await] : Identifier
  • この生成規則が [Yield] パラメータを持ち、Identifier の StringValue が "yield" なら構文エラー。
  • この生成規則が [Await] パラメータを持ち、Identifier の StringValue が "await" なら構文エラー。
Identifier : IdentifierName but not ReservedWord
  • IsStrict(this phrase) が true で、IdentifierName の StringValue が "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield" のいずれかなら構文エラー。
  • 構文文法のゴール記号が Module で、IdentifierName の StringValue が "await" なら構文エラー。
  • IdentifierName の StringValue が yield および await を除くいずれかの ReservedWord の StringValue と同じなら構文エラー。
Note

IdentifierName の StringValue は IdentifierName 内の Unicode エスケープシーケンスを正規化するため、エスケープによって ReservedWord と同じコードポイント列の Identifier を作ることはできない。

13.1.2 静的セマンティクス: StringValue : String

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

IdentifierName :: IdentifierStart IdentifierName IdentifierPart
  1. idTextUnescaped を IdentifierName の IdentifierCodePoints とする。
  2. CodePointsToString(idTextUnescaped) を返す。
 IdentifierReference : yield BindingIdentifier : yield LabelIdentifier : yield
  1. "yield" を返す。
 IdentifierReference : await BindingIdentifier : await LabelIdentifier : await
  1. "await" を返す。
 Identifier : IdentifierName but not ReservedWord
  1. IdentifierName の StringValue を返す。
 PrivateIdentifier :: # IdentifierName
  1. 0x0023 (NUMBER SIGN) と IdentifierName の StringValue の文字列連結を返す。
 ModuleExportName : StringLiteral
  1. StringLiteral の SV を返す。

13.1.3 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

IdentifierReference : Identifier
  1. ? ResolveBinding(StringValue of Identifier) を返す。
 IdentifierReference : yield
  1. ? ResolveBinding("yield") を返す。
 IdentifierReference : await
  1. ? ResolveBinding("await") を返す。
 Note 1

IdentifierReference の評価結果は常に Reference 型の値である。

 Note 2

非 strict コードではキーワード yield を識別子として使用できる。IdentifierReference の評価は yield の束縛を Identifier であるかのように解決する。Early Error によりこの評価は非 strict コードでのみ発生し得ることが保証される。

13.2 一次式 (Primary Expression)

構文 (Syntax)

PrimaryExpression[Yield, Await] : this IdentifierReference[?Yield, ?Await] Literal ArrayLiteral[?Yield, ?Await] ObjectLiteral[?Yield, ?Await] FunctionExpression ClassExpression[?Yield, ?Await] GeneratorExpression AsyncFunctionExpression AsyncGeneratorExpression RegularExpressionLiteral TemplateLiteral[?Yield, ?Await, ~Tagged] CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await] CoverParenthesizedExpressionAndArrowParameterList[Yield, Await] : ( Expression[+In, ?Yield, ?Await] ) ( Expression[+In, ?Yield, ?Await] , ) ( ) ( ... BindingIdentifier[?Yield, ?Await] ) ( ... BindingPattern[?Yield, ?Await] ) ( Expression[+In, ?Yield, ?Await] , ... BindingIdentifier[?Yield, ?Await] ) ( Expression[+In, ?Yield, ?Await] , ... BindingPattern[?Yield, ?Await] )

補助構文 (Supplemental Syntax)

次の生成規則インスタンスを処理する際
PrimaryExpression[Yield, Await] : CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]
CoverParenthesizedExpressionAndArrowParameterList の解釈は次の文法で精緻化される:

ParenthesizedExpression[Yield, Await] : ( Expression[+In, ?Yield, ?Await] )

13.2.1 this キーワード

13.2.1.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

PrimaryExpression : this
  1. ? ResolveThisBinding() を返す。

13.2.2 識別子参照 (Identifier Reference)

IdentifierReference については 13.1 を参照。

13.2.3 リテラル (Literals)

構文 (Syntax)

Literal : NullLiteral BooleanLiteral NumericLiteral StringLiteral

13.2.3.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

Literal : NullLiteral
  1. null を返す。
 Literal : BooleanLiteral
  1. BooleanLiteral がトークン false なら false を返す。
  2. BooleanLiteral がトークン true なら true を返す。
 Literal : NumericLiteral
  1. 12.9.3 で定義される NumericLiteral の NumericValue を返す。
 Literal : StringLiteral
  1. 12.9.4.2 で定義される StringLiteral の SV を返す。

13.2.4 配列初期化子 (Array Initializer)

Note

ArrayLiteral は 0 個以上の式（各々が要素を表す）のリストを角括弧で囲んで配列の初期化を記述する式である。要素はリテラルである必要はなく、配列初期化子の評価ごとに評価される。

配列要素は先頭・中間・末尾で省略（elide）できる。要素リスト中のカンマが直前に AssignmentExpression を伴わないとき（先頭、または別のカンマの後）、欠落した要素は配列の length に寄与し、後続要素のインデックスを増やす。省略された配列要素は定義されない。末尾で要素が省略された場合、その要素は length に寄与しない。

構文 (Syntax)

ArrayLiteral[Yield, Await] : [ Elisionopt ] [ ElementList[?Yield, ?Await] ] [ ElementList[?Yield, ?Await] , Elisionopt ] ElementList[Yield, Await] : Elisionopt AssignmentExpression[+In, ?Yield, ?Await] Elisionopt SpreadElement[?Yield, ?Await] ElementList[?Yield, ?Await] , Elisionopt AssignmentExpression[+In, ?Yield, ?Await] ElementList[?Yield, ?Await] , Elisionopt SpreadElement[?Yield, ?Await] Elision : , Elision , SpreadElement[Yield, Await] : ... AssignmentExpression[+In, ?Yield, ?Await]

13.2.4.1 実行時セマンティクス: ArrayAccumulation : 正常完了で整数を含むか、または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

Elision : ,
  1. len を nextIndex + 1 とする。
  2. ? Set(array, "length", 𝔽(len), true) を実行する。
  3. 注: 上の手順は len が 232-1 を超えると投げる。
  4. len を返す。
 Elision : Elision ,
  1. 引数 array, (nextIndex + 1) で Elision の ArrayAccumulation を実行した結果を返す。
 ElementList : Elisionopt AssignmentExpression
  1. Elision が存在するなら
    1. nextIndex を 引数 array, nextIndex で Elision の ArrayAccumulation を実行した結果に設定。
  2. initResult を AssignmentExpression の Evaluation。
  3. initValue を ? GetValue(initResult)。
  4. ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), initValue) を実行。
  5. nextIndex + 1 を返す。
 ElementList : Elisionopt SpreadElement
  1. Elision が存在するなら
    1. nextIndex を 引数 array, nextIndex で Elision の ArrayAccumulation を実行した結果に設定。
  2. 引数 array, nextIndex で SpreadElement の ArrayAccumulation を実行した結果を返す。
 ElementList : ElementList , Elisionopt AssignmentExpression
  1. nextIndex を 引数 array, nextIndex で ElementList の ArrayAccumulation を実行した結果に設定。
  2. Elision が存在するなら
    1. nextIndex を 引数 array, nextIndex で Elision の ArrayAccumulation を実行した結果に設定。
  3. initResult を AssignmentExpression の Evaluation。
  4. initValue を ? GetValue(initResult)。
  5. ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), initValue) を実行。
  6. nextIndex + 1 を返す。
 ElementList : ElementList , Elisionopt SpreadElement
  1. nextIndex を 引数 array, nextIndex で ElementList の ArrayAccumulation を実行した結果に設定。
  2. Elision が存在するなら
    1. nextIndex を 引数 array, nextIndex で Elision の ArrayAccumulation を実行した結果に設定。
  3. 引数 array, nextIndex で SpreadElement の ArrayAccumulation を実行した結果を返す。
 SpreadElement : ... AssignmentExpression
  1. spreadRef を AssignmentExpression の Evaluation。
  2. spreadObj を ? GetValue(spreadRef)。
  3. iteratorRecord を ? GetIterator(spreadObj, sync)。
  4. 反復:
    1. next を ? IteratorStepValue(iteratorRecord)。
    2. next が done なら nextIndex を返す。
    3. ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), next) を実行。
    4. nextIndex を nextIndex + 1 に設定。
 Note

標準組込み Array prototype が [[Set]] による新たな自身プロパティ生成を妨げるよう改変されていても、自身プロパティ確立を保証するため CreateDataPropertyOrThrow が使用される。

13.2.4.2 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ArrayLiteral : [ Elisionopt ]
  1. array を ! ArrayCreate(0) とする。
  2. Elision が存在するなら
    1. 引数 array, 0 で Elision の ArrayAccumulation を実行。
  3. array を返す。
 ArrayLiteral : [ ElementList ]
  1. array を ! ArrayCreate(0)。
  2. 引数 array, 0 で ElementList の ArrayAccumulation を実行。
  3. array を返す。
 ArrayLiteral : [ ElementList , Elisionopt ]
  1. array を ! ArrayCreate(0)。
  2. nextIndex を 引数 array, 0 で ElementList の ArrayAccumulation を実行した結果とする。
  3. Elision が存在するなら
    1. 引数 array, nextIndex で Elision の ArrayAccumulation を実行。
  4. array を返す。

13.2.5 オブジェクト初期化子 (Object Initializer)

Note 1

オブジェクト初期化子はオブジェクトの初期化をリテラル風の書式で表す式であり、波括弧で囲まれた 0 個以上のプロパティキーと対応値の組のリストである。値はリテラルである必要はなく、オブジェクト初期化子の評価ごとに評価される。

構文 (Syntax)

ObjectLiteral[Yield, Await] : { } { PropertyDefinitionList[?Yield, ?Await] } { PropertyDefinitionList[?Yield, ?Await] , } PropertyDefinitionList[Yield, Await] : PropertyDefinition[?Yield, ?Await] PropertyDefinitionList[?Yield, ?Await] , PropertyDefinition[?Yield, ?Await] PropertyDefinition[Yield, Await] : IdentifierReference[?Yield, ?Await] CoverInitializedName[?Yield, ?Await] PropertyName[?Yield, ?Await] : AssignmentExpression[+In, ?Yield, ?Await] MethodDefinition[?Yield, ?Await] ... AssignmentExpression[+In, ?Yield, ?Await] PropertyName[Yield, Await] : LiteralPropertyName ComputedPropertyName[?Yield, ?Await] LiteralPropertyName : IdentifierName StringLiteral NumericLiteral ComputedPropertyName[Yield, Await] : [ AssignmentExpression[+In, ?Yield, ?Await] ] CoverInitializedName[Yield, Await] : IdentifierReference[?Yield, ?Await] Initializer[+In, ?Yield, ?Await] Initializer[In, Yield, Await] : = AssignmentExpression[?In, ?Yield, ?Await] Note 2

MethodDefinition は 15.4 で定義される。

 Note 3

特定の文脈では ObjectLiteral はより制限された二次文法を覆うカバー文法として使われる。CoverInitializedName 生成規則はこれら二次文法を完全に覆うために必要である。しかし通常の実際の ObjectLiteral が期待される場面でこの生成規則が使用されると Early Syntax Error になる。

13.2.5.1 静的セマンティクス: 早期エラー (Early Errors)

PropertyDefinition : MethodDefinition

ObjectLiteral 生成規則は実際のオブジェクト初期化子を記述するだけでなく ObjectAssignmentPattern を覆うカバー文法として、また CoverParenthesizedExpressionAndArrowParameterList の一部として認識され得る。ObjectAssignmentPattern が要求される文脈で ObjectLiteral が現れるとき、以下の Early Error 規則は適用されない。さらに、CoverParenthesizedExpressionAndArrowParameterList や CoverCallExpressionAndAsyncArrowHead の初期パース時にも適用されない。

PropertyDefinition : CoverInitializedName
  • この生成規則にマッチするソーステキストが存在するなら構文エラー。
Note 1

この生成規則は ObjectLiteral を ObjectAssignmentPattern のカバー文法として機能させるために存在し、実際のオブジェクト初期化子には現れない。

 ObjectLiteral : { PropertyDefinitionList } { PropertyDefinitionList , } Note 2

PropertyNameList が返すリストには ComputedPropertyName を用いて定義された名前は含まれない。

13.2.5.2 静的セマンティクス: IsComputedPropertyKey : Boolean

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

PropertyName : LiteralPropertyName
  1. false を返す。
 PropertyName : ComputedPropertyName
  1. true を返す。

13.2.5.3 静的セマンティクス: PropertyNameList : String の List

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

PropertyDefinitionList : PropertyDefinition
  1. propName を PropertyDefinition の PropName とする。
  2. propName が empty なら新しい空 List を返す。
  3. « propName » を返す。
 PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition
  1. list を PropertyDefinitionList の PropertyNameList。
  2. propName を PropertyDefinition の PropName。
  3. propName が empty なら list を返す。
  4. list と « propName » のリスト結合を返す。

13.2.5.4 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ObjectLiteral : { }
  1. OrdinaryObjectCreate(%Object.prototype%) を返す。
 ObjectLiteral : { PropertyDefinitionList } { PropertyDefinitionList , }
  1. obj を OrdinaryObjectCreate(%Object.prototype%)。
  2. 引数 obj で PropertyDefinitionList の PropertyDefinitionEvaluation を実行。
  3. obj を返す。
 LiteralPropertyName : IdentifierName
  1. IdentifierName の StringValue を返す。
 LiteralPropertyName : StringLiteral
  1. StringLiteral の SV を返す。
 LiteralPropertyName : NumericLiteral
  1. nbr を NumericLiteral の NumericValue。
  2. ! ToString(nbr) を返す。
 ComputedPropertyName : [ AssignmentExpression ]
  1. exprValue を AssignmentExpression の Evaluation。
  2. propName を ? GetValue(exprValue)。
  3. ? ToPropertyKey(propName) を返す。

13.2.5.5 実行時セマンティクス: PropertyDefinitionEvaluation : 正常完了で unused を含むか、または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition
  1. 引数 object で PropertyDefinitionList の PropertyDefinitionEvaluation を実行。
  2. 引数 object で PropertyDefinition の PropertyDefinitionEvaluation を実行。
  3. unused を返す。
 PropertyDefinition : ... AssignmentExpression
  1. exprValue を AssignmentExpression の Evaluation。
  2. fromValue を ? GetValue(exprValue)。
  3. excludedNames を新しい空 List。
  4. ? CopyDataProperties(object, fromValue, excludedNames) を実行。
  5. unused を返す。
 PropertyDefinition : IdentifierReference
  1. propName を IdentifierReference の StringValue。
  2. exprValue を IdentifierReference の Evaluation。
  3. propValue を ? GetValue(exprValue)。
  4. 事前条件: object は通常 (ordinary) で拡張可能で非 configurable プロパティを持たない。
  5. ! CreateDataPropertyOrThrow(object, propName, propValue) を実行。
  6. unused を返す。
 PropertyDefinition : PropertyName : AssignmentExpression
  1. propKey を PropertyName の Evaluation。
  2. この PropertyDefinition が ParseJSON のため評価中の Script 内に含まれるなら（ParseJSON の step 6 参照）
    1. isProtoSetter を false。
  3. それ以外で propKey が "__proto__" かつ PropertyName の IsComputedPropertyKey が false なら
    1. isProtoSetter を true。
  4. それ以外
    1. isProtoSetter を false。
  5. IsAnonymousFunctionDefinition(AssignmentExpression) が true かつ isProtoSetter が false なら
    1. propValue を 引数 propKey で AssignmentExpression の NamedEvaluation。
  6. それ以外
    1. exprValueRef を AssignmentExpression の Evaluation。
    2. propValue を ? GetValue(exprValueRef)。
  7. isProtoSetter が true なら
    1. propValue が Object か null なら
      1. ! object.[[SetPrototypeOf]](propValue) を実行。
    2. unused を返す。
  8. 事前条件: object は通常で拡張可能、非 configurable プロパティなし。
  9. ! CreateDataPropertyOrThrow(object, propKey, propValue) を実行。
  10. unused を返す。
 PropertyDefinition : MethodDefinition
  1. 引数 object, true で MethodDefinition の MethodDefinitionEvaluation を実行。
  2. unused を返す。

13.2.6 関数定義式 (Function Defining Expressions)

15.2 の PrimaryExpression : FunctionExpression を参照。

15.5 の PrimaryExpression : GeneratorExpression を参照。

15.7 の PrimaryExpression : ClassExpression を参照。

15.8 の PrimaryExpression : AsyncFunctionExpression を参照。

15.6 の PrimaryExpression : AsyncGeneratorExpression を参照。

13.2.7 正規表現リテラル (Regular Expression Literals)

構文 (Syntax)

12.9.5 を参照。

13.2.7.1 静的セマンティクス: 早期エラー (Early Errors)

PrimaryExpression : RegularExpressionLiteral

13.2.7.2 静的セマンティクス: IsValidRegularExpressionLiteral ( literal: RegularExpressionLiteral Parse Node, ): Boolean

The abstract operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It performs the following steps when called:

  1. flags を literal の FlagText とする。
  2. flags に d, g, i, m, s, u, v, y 以外のコードポイントが含まれるか、同一コードポイントが複数回含まれるなら false を返す。
  3. flags が u を含むなら u = true、そうでなければ false。
  4. flags が v を含むなら v = true、そうでなければ false。
  5. patternText を literal の BodyText とする。
  6. u が false かつ v が false なら
    1. stringValue を CodePointsToString(patternText)。
    2. patternText を stringValue の 16-bit 要素を Unicode BMP コードポイントとして逐次解釈した結果のコードポイント列に設定（UTF-16 デコードは行わない）。
  7. parseResult を ParsePattern(patternText, u, v)。
  8. parseResult が Parse Node なら true、そうでなければ false を返す。

13.2.7.3 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

PrimaryExpression : RegularExpressionLiteral
  1. pattern を CodePointsToString(BodyText of RegularExpressionLiteral)。
  2. flags を CodePointsToString(FlagText of RegularExpressionLiteral)。
  3. ! RegExpCreate(pattern, flags) を返す。

13.2.8 テンプレートリテラル (Template Literals)

構文 (Syntax)

TemplateLiteral[Yield, Await, Tagged] : NoSubstitutionTemplate SubstitutionTemplate[?Yield, ?Await, ?Tagged] SubstitutionTemplate[Yield, Await, Tagged] : TemplateHead Expression[+In, ?Yield, ?Await] TemplateSpans[?Yield, ?Await, ?Tagged] TemplateSpans[Yield, Await, Tagged] : TemplateTail TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateTail TemplateMiddleList[Yield, Await, Tagged] : TemplateMiddle Expression[+In, ?Yield, ?Await] TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateMiddle Expression[+In, ?Yield, ?Await]

13.2.8.1 静的セマンティクス: 早期エラー (Early Errors)

TemplateLiteral[Yield, Await, Tagged] : NoSubstitutionTemplate TemplateLiteral[Yield, Await, Tagged] : SubstitutionTemplate[?Yield, ?Await, ?Tagged]
  • 引数 false での TemplateLiteral の TemplateStrings の要素数が 232 以上なら構文エラー。
SubstitutionTemplate[Yield, Await, Tagged] : TemplateHead Expression[+In, ?Yield, ?Await] TemplateSpans[?Yield, ?Await, ?Tagged] TemplateSpans[Yield, Await, Tagged] : TemplateTail TemplateMiddleList[Yield, Await, Tagged] : TemplateMiddle Expression[+In, ?Yield, ?Await] TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateMiddle Expression[+In, ?Yield, ?Await]

13.2.8.2 静的セマンティクス: TemplateStrings : String または undefined を含む List

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

TemplateLiteral : NoSubstitutionTemplate
  1. « TemplateString(NoSubstitutionTemplate, raw) » を返す。
 SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. head を « TemplateString(TemplateHead, raw) »。
  2. tail を 引数 raw で TemplateSpans の TemplateStrings。
  3. head と tail のリスト結合を返す。
 TemplateSpans : TemplateTail
  1. « TemplateString(TemplateTail, raw) » を返す。
 TemplateSpans : TemplateMiddleList TemplateTail
  1. middle を 引数 raw で TemplateMiddleList の TemplateStrings。
  2. tail を « TemplateString(TemplateTail, raw) »。
  3. middle と tail のリスト結合を返す。
 TemplateMiddleList : TemplateMiddle Expression
  1. « TemplateString(TemplateMiddle, raw) » を返す。
 TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. front を 引数 raw で TemplateMiddleList の TemplateStrings。
  2. last を « TemplateString(TemplateMiddle, raw) »。
  3. front と last のリスト結合を返す。

13.2.8.3 静的セマンティクス: TemplateString ( templateToken: NoSubstitutionTemplate / TemplateHead / TemplateMiddle / TemplateTail Parse Node, raw: Boolean, ): String または undefined

The abstract operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It performs the following steps when called:

  1. raw が true なら
    1. string を templateToken の TRV。
  2. それ以外
    1. string を templateToken の TV。
  3. string を返す。
 Note

raw が false かつ templateToken が NotEscapeSequence を含む場合、この操作は undefined を返す。それ以外は String を返す。

13.2.8.4 GetTemplateObject ( templateLiteral )

The abstract operation GetTemplateObject takes argument templateLiteral (Parse Node) and returns Array. It performs the following steps when called:

  1. realm を現在の Realm Record。
  2. templateRegistry を realm.[[TemplateMap]]。
  3. templateRegistry の各要素 e について
    1. e.[[Site]] が templateLiteral と同じ Parse Node なら
      1. e.[[Array]] を返す。
  4. rawStrings を 引数 true で templateLiteral の TemplateStrings。
  5. 事前条件: rawStrings は String の List。
  6. cookedStrings を 引数 false で templateLiteral の TemplateStrings。
  7. count を cookedStrings の要素数。
  8. 事前条件: count ≤ 232-1。
  9. template を ! ArrayCreate(count)。
  10. rawObj を ! ArrayCreate(count)。
  11. index を 0。
  12. index < count の間繰り返す:
    1. prop を ! ToString(𝔽(index))。
    2. cookedValue を cookedStrings[index]。
    3. ! DefinePropertyOrThrow(template, prop, PropertyDescriptor { [[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false })。
    4. rawValue を String 値 rawStrings[index]。
    5. ! DefinePropertyOrThrow(rawObj, prop, PropertyDescriptor { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false })。
    6. index を index + 1。
  13. ! SetIntegrityLevel(rawObj, frozen)。
  14. ! DefinePropertyOrThrow(template, "raw", PropertyDescriptor { [[Value]]: rawObj, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false })。
  15. ! SetIntegrityLevel(template, frozen)。
  16. Record { [[Site]]: templateLiteral, [[Array]]: template } を realm.[[TemplateMap]] に追加。
  17. template を返す。
 Note 1

テンプレートオブジェクトの生成は突然の完了を引き起こさない。

 Note 2

ある realm のプログラムコード内の各 TemplateLiteral はタグ付きテンプレート評価 (13.2.8.6) に用いられる一意のテンプレートオブジェクトと関連付けられる。テンプレートオブジェクトは凍結され、同一タグ付きテンプレート評価では同じオブジェクトが再利用される。テンプレートオブジェクトが最初の評価時に遅延生成されるか、事前に eager に生成されるかは ECMAScript コードからは観測不能で実装依存。

 Note 3

将来の版ではテンプレートオブジェクトに追加の列挙不可プロパティを定義する可能性がある。

13.2.8.5 実行時セマンティクス: SubstitutionEvaluation

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

TemplateSpans : TemplateTail
  1. 新しい空 List を返す。
 TemplateSpans : TemplateMiddleList TemplateTail
  1. TemplateMiddleList の SubstitutionEvaluation を返す。
 TemplateMiddleList : TemplateMiddle Expression
  1. subRef を Expression の Evaluation。
  2. sub を ? GetValue(subRef)。
  3. « sub » を返す。
 TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. preceding を TemplateMiddleList の SubstitutionEvaluation。
  2. nextRef を Expression の Evaluation。
  3. next を ? GetValue(nextRef)。
  4. preceding と « next » のリスト結合を返す。

13.2.8.6 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

TemplateLiteral : NoSubstitutionTemplate
  1. 12.9.6 で定義される NoSubstitutionTemplate の TV を返す。
 SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. head を 12.9.6 で定義される TemplateHead の TV。
  2. subRef を Expression の Evaluation。
  3. sub を ? GetValue(subRef)。
  4. middle を ? ToString(sub)。
  5. tail を TemplateSpans の Evaluation。
  6. head, middle, tail の文字列連結を返す。
 Note 1

Expression 値への文字列変換は + 演算子ではなく String.prototype.concat と同様のセマンティクス。

 TemplateSpans : TemplateTail
  1. 12.9.6 で定義される TemplateTail の TV を返す。
 TemplateSpans : TemplateMiddleList TemplateTail
  1. head を TemplateMiddleList の Evaluation。
  2. tail を 12.9.6 で定義される TemplateTail の TV。
  3. head と tail の文字列連結を返す。
 TemplateMiddleList : TemplateMiddle Expression
  1. head を 12.9.6 で定義される TemplateMiddle の TV。
  2. subRef を Expression の Evaluation。
  3. sub を ? GetValue(subRef)。
    1. middle を ? ToString(sub)。
  4. head と middle の文字列連結を返す。
 Note 2

Expression 値への文字列変換は + 演算子ではなく String.prototype.concat と同様。

 TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. rest を TemplateMiddleList の Evaluation。
  2. middle を 12.9.6 で定義される TemplateMiddle の TV。
  3. subRef を Expression の Evaluation。
  4. sub を ? GetValue(subRef)。
  5. last を ? ToString(sub)。
  6. rest, middle, last の文字列連結を返す。
 Note 3

Expression 値への文字列変換は String.prototype.concat と同様で + 演算子とは異なる。

13.2.9 グルーピング演算子 (The Grouping Operator)

13.2.9.1 静的セマンティクス: 早期エラー (Early Errors)

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

13.2.9.2 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. expr を CoverParenthesizedExpressionAndArrowParameterList により覆われる ParenthesizedExpression とする。
  2. expr の Evaluation を返す (必要なら ? を付す)。
 ParenthesizedExpression : ( Expression )
  1. Expression の Evaluation を返す（Reference 型であり得る）。
 Note

このアルゴリズムは Expression の Evaluation に GetValue を適用しない。主な動機は delete や typeof などの演算子をかっこ付き式に適用可能とするためである。

13.3 左辺式 (Left-Hand-Side Expressions)

構文 (Syntax)

MemberExpression[Yield, Await] : PrimaryExpression[?Yield, ?Await] MemberExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ] MemberExpression[?Yield, ?Await] . IdentifierName MemberExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged] SuperProperty[?Yield, ?Await] MetaProperty new MemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await] MemberExpression[?Yield, ?Await] . PrivateIdentifier SuperProperty[Yield, Await] : super [ Expression[+In, ?Yield, ?Await] ] super . IdentifierName MetaProperty : NewTarget ImportMeta NewTarget : new . target ImportMeta : import . meta NewExpression[Yield, Await] : MemberExpression[?Yield, ?Await] new NewExpression[?Yield, ?Await] CallExpression[Yield, Await] : CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] SuperCall[?Yield, ?Await] ImportCall[?Yield, ?Await] CallExpression[?Yield, ?Await] Arguments[?Yield, ?Await] CallExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ] CallExpression[?Yield, ?Await] . IdentifierName CallExpression[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged] CallExpression[?Yield, ?Await] . PrivateIdentifier SuperCall[Yield, Await] : super Arguments[?Yield, ?Await] ImportCall[Yield, Await] : import ( AssignmentExpression[+In, ?Yield, ?Await] ,opt ) import ( AssignmentExpression[+In, ?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ,opt ) Arguments[Yield, Await] : ( ) ( ArgumentList[?Yield, ?Await] ) ( ArgumentList[?Yield, ?Await] , ) ArgumentList[Yield, Await] : AssignmentExpression[+In, ?Yield, ?Await] ... AssignmentExpression[+In, ?Yield, ?Await] ArgumentList[?Yield, ?Await] , AssignmentExpression[+In, ?Yield, ?Await] ArgumentList[?Yield, ?Await] , ... AssignmentExpression[+In, ?Yield, ?Await] OptionalExpression[Yield, Await] : MemberExpression[?Yield, ?Await] OptionalChain[?Yield, ?Await] CallExpression[?Yield, ?Await] OptionalChain[?Yield, ?Await] OptionalExpression[?Yield, ?Await] OptionalChain[?Yield, ?Await] OptionalChain[Yield, Await] : ?. Arguments[?Yield, ?Await] ?. [ Expression[+In, ?Yield, ?Await] ] ?. IdentifierName ?. TemplateLiteral[?Yield, ?Await, +Tagged] ?. PrivateIdentifier OptionalChain[?Yield, ?Await] Arguments[?Yield, ?Await] OptionalChain[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ] OptionalChain[?Yield, ?Await] . IdentifierName OptionalChain[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged] OptionalChain[?Yield, ?Await] . PrivateIdentifier LeftHandSideExpression[Yield, Await] : NewExpression[?Yield, ?Await] CallExpression[?Yield, ?Await] OptionalExpression[?Yield, ?Await]

補助構文 (Supplemental Syntax)

次の生成規則インスタンスを処理する際
CallExpression : CoverCallExpressionAndAsyncArrowHead
CoverCallExpressionAndAsyncArrowHead の解釈は以下の文法で精緻化される:

CallMemberExpression[Yield, Await] : MemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await]

13.3.1 静的セマンティクス (Static Semantics)

13.3.1.1 静的セマンティクス: 早期エラー (Early Errors)

OptionalChain : ?. TemplateLiteral OptionalChain TemplateLiteral
  • この生成規則にソーステキストがマッチした場合は構文エラー。
Note

この生成規則は次のコードに自動セミコロン挿入規則（12.10）が適用されて 2 つの有効な文として解釈されることを防ぐために存在する:

a?.b
`c`

これはオプショナルチェイニングを用いない類似コードとの一貫性を保つ目的である:

a.b
`c`

後者は自動セミコロン挿入が適用されず有効な文である。

 ImportMeta : import . meta

13.3.2 プロパティアクセッサ (Property Accessors)

Note

プロパティは名前でアクセスされ、ドット記法:

MemberExpression . IdentifierName
CallExpression . IdentifierName

またはブラケット記法を用いる:

MemberExpression [ Expression ]
CallExpression [ Expression ]

ドット記法は次の構文変換で説明される:

MemberExpression . IdentifierName

これは動作上次と同一である:

MemberExpression [ <identifier-name-string> ]

同様に

CallExpression . IdentifierName

は次と同一である:

CallExpression [ <identifier-name-string> ]

ここで <identifier-name-string> は IdentifierName の StringValue である。

13.3.2.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

MemberExpression : MemberExpression [ Expression ]
  1. baseReference を ? MemberExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. strict を IsStrict(this MemberExpression) とする。
  4. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict) を返す。
 MemberExpression : MemberExpression . IdentifierName
  1. baseReference を ? MemberExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. strict を IsStrict(this MemberExpression)。
  4. EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict) を返す。
 MemberExpression : MemberExpression . PrivateIdentifier
  1. baseReference を ? MemberExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. fieldNameString を PrivateIdentifier の StringValue とする。
  4. MakePrivateReference(baseValue, fieldNameString) を返す。
 CallExpression : CallExpression [ Expression ]
  1. baseReference を ? CallExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. strict を IsStrict(this CallExpression)。
  4. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict) を返す。
 CallExpression : CallExpression . IdentifierName
  1. baseReference を ? CallExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. strict を IsStrict(this CallExpression)。
  4. EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict) を返す。
 CallExpression : CallExpression . PrivateIdentifier
  1. baseReference を ? CallExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. fieldNameString を PrivateIdentifier の StringValue。
  4. MakePrivateReference(baseValue, fieldNameString) を返す。

13.3.3 EvaluatePropertyAccessWithExpressionKey ( baseValue, expression, strict )

The abstract operation EvaluatePropertyAccessWithExpressionKey takes arguments baseValue (ECMAScript 言語値), expression (Expression Parse Node), and strict (Boolean) and returns 正常完了で Reference Record を含むか、または突然の完了. It performs the following steps when called:

  1. propertyNameReference を ? expression の Evaluation。
  2. propertyNameValue を ? GetValue(propertyNameReference)。
  3. 注: 多くの場合この直後に ToPropertyKey が propertyNameValue に対して行われるが、a[b] = c の場合は c の評価後まで行われない。
  4. Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyNameValue, [[Strict]]: strict, [[ThisValue]]: empty } を返す。

13.3.4 EvaluatePropertyAccessWithIdentifierKey ( baseValue, identifierName, strict )

The abstract operation EvaluatePropertyAccessWithIdentifierKey takes arguments baseValue (ECMAScript 言語値), identifierName (IdentifierName Parse Node), and strict (Boolean) and returns Reference Record. It performs the following steps when called:

  1. propertyNameString を identifierName の StringValue。
  2. Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyNameString, [[Strict]]: strict, [[ThisValue]]: empty } を返す。

13.3.5 new 演算子 (The new Operator)

13.3.5.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

NewExpression : new NewExpression
  1. ? EvaluateNew(NewExpression, empty) を返す。
 MemberExpression : new MemberExpression Arguments
  1. ? EvaluateNew(MemberExpression, Arguments) を返す。

13.3.5.1.1 EvaluateNew ( constructExpr, arguments )

The abstract operation EvaluateNew takes arguments constructExpr (NewExpression Parse Node または MemberExpression Parse Node) and arguments (empty 又は Arguments Parse Node) and returns 正常完了で ECMAScript 言語値を含むか、または突然の完了. It performs the following steps when called:

  1. ref を ? constructExpr の Evaluation。
  2. constructor を ? GetValue(ref)。
  3. arguments が empty なら
    1. argList を新しい空 List。
  4. それ以外
    1. argList を ? ArgumentListEvaluation(arguments)。
  5. IsConstructor(constructor) が false なら TypeError 例外を投げる。
  6. ? Construct(constructor, argList) を返す。

13.3.6 関数呼び出し (Function Calls)

13.3.6.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

CallExpression : CoverCallExpressionAndAsyncArrowHead
  1. expr を CoverCallExpressionAndAsyncArrowHead により覆われる CallMemberExpression とする。
  2. memberExpr を expr の MemberExpression。
  3. arguments を expr の Arguments。
  4. ref を ? memberExpr の Evaluation。
  5. func を ? GetValue(ref)。
  6. もし ref が Reference Record で IsPropertyReference(ref) が false かつ ref.[[ReferencedName]] が "eval" なら
    1. SameValue(func, %eval%) が true なら
      1. argList を ? ArgumentListEvaluation(arguments)。
      2. argList が要素を持たないなら undefined を返す。
      3. evalArg を argList の最初の要素。
      4. IsStrict(this CallExpression) が true なら strictCaller = true、そうでなければ false。
      5. ? PerformEval(evalArg, strictCaller, true) を返す。
  7. thisCall を this CallExpression。
  8. tailCall を IsInTailPosition(thisCall)。
  9. ? EvaluateCall(func, ref, arguments, tailCall) を返す。

ステップ 6.a.v を実行する CallExpression の評価は direct eval である。

CallExpression : CallExpression Arguments
  1. ref を ? CallExpression の Evaluation。
  2. func を ? GetValue(ref)。
  3. thisCall を this CallExpression。
  4. tailCall を IsInTailPosition(thisCall)。
  5. ? EvaluateCall(func, ref, Arguments, tailCall) を返す。

13.3.6.2 EvaluateCall ( func, ref, arguments, tailPosition )

The abstract operation EvaluateCall takes arguments func (ECMAScript 言語値), ref (ECMAScript 言語値または Reference Record), arguments (Parse Node), and tailPosition (Boolean) and returns 正常完了で ECMAScript 言語値を含むか、または突然の完了. It performs the following steps when called:

  1. もし ref が Reference Record なら
    1. IsPropertyReference(ref) が true なら
      1. thisValue を GetThisValue(ref)。
    2. それ以外
      1. refEnv を ref.[[Base]]。
      2. 事前条件: refEnv は Environment Record。
      3. thisValue を refEnv.WithBaseObject()。
  2. それ以外
    1. thisValue を undefined。
  3. argList を ? ArgumentListEvaluation(arguments)。
  4. func が Object でなければ TypeError 例外。
  5. IsCallable(func) が false なら TypeError 例外。
  6. tailPosition が true なら PrepareForTailCall() を実行。
  7. ? Call(func, thisValue, argList) を返す。

13.3.7 super キーワード (The super Keyword)

13.3.7.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

SuperProperty : super [ Expression ]
  1. env を GetThisEnvironment()。
  2. actualThis を ? env.GetThisBinding()。
  3. propertyNameReference を ? Expression の Evaluation。
  4. propertyNameValue を ? GetValue(propertyNameReference)。
  5. strict を IsStrict(this SuperProperty)。
  6. 注: 多くの場合ここですぐ ToPropertyKey が行われるが、super[b] = c のケースでは c 評価後。
  7. MakeSuperPropertyReference(actualThis, propertyNameValue, strict) を返す。
 SuperProperty : super . IdentifierName
  1. env を GetThisEnvironment()。
  2. actualThis を ? env.GetThisBinding()。
  3. propertyKey を IdentifierName の StringValue。
  4. strict を IsStrict(this SuperProperty)。
  5. MakeSuperPropertyReference(actualThis, propertyKey, strict) を返す。
 SuperCall : super Arguments
  1. newTarget を GetNewTarget()。
  2. 事前条件: newTarget は constructor。
  3. func を GetSuperConstructor()。
  4. argList を ? ArgumentListEvaluation(Arguments)。
  5. IsConstructor(func) が false なら TypeError 例外。
  6. result を ? Construct(func, argList, newTarget)。
  7. thisER を GetThisEnvironment()。
  8. 事前条件: thisER は Function Environment Record。
  9. ? BindThisValue(thisER, result)。
  10. F を thisER.[[FunctionObject]]。
  11. 事前条件: F は ECMAScript function object。
  12. ? InitializeInstanceElements(result, F)。
  13. result を返す。

13.3.7.2 GetSuperConstructor ( )

The abstract operation GetSuperConstructor takes no arguments and returns ECMAScript 言語値. It performs the following steps when called:

  1. envRec を GetThisEnvironment()。
  2. 事前条件: envRec は Function Environment Record。
  3. activeFunction を envRec.[[FunctionObject]]。
  4. 事前条件: activeFunction は ECMAScript function object。
  5. superConstructor を ! activeFunction.[[GetPrototypeOf]]()。
  6. superConstructor を返す。

13.3.7.3 MakeSuperPropertyReference ( actualThis, propertyKey, strict )

The abstract operation MakeSuperPropertyReference takes arguments actualThis (ECMAScript 言語値), propertyKey (ECMAScript 言語値), and strict (Boolean) and returns Super Reference Record. It performs the following steps when called:

  1. env を GetThisEnvironment()。
  2. 事前条件: env.HasSuperBinding() は true。
  3. 事前条件: env は Function Environment Record。
  4. baseValue を GetSuperBase(env)。
  5. Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis } を返す。

13.3.8 引数リスト (Argument Lists)

Note

引数リストの評価は値の List を生成する。

13.3.8.1 実行時セマンティクス: ArgumentListEvaluation — 正常完了で ECMAScript 言語値の List または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

Arguments : ( )
  1. 新しい空 List を返す。
 ArgumentList : AssignmentExpression
  1. ref を ? AssignmentExpression の Evaluation。
  2. arg を ? GetValue(ref)。
  3. « arg » を返す。
 ArgumentList : ... AssignmentExpression
  1. list を新しい空 List。
  2. spreadRef を ? AssignmentExpression の Evaluation。
  3. spreadObj を ? GetValue(spreadRef)。
  4. iteratorRecord を ? GetIterator(spreadObj, sync)。
  5. 反復:
    1. next を ? IteratorStepValue(iteratorRecord)。
    2. next が done なら list を返す。
    3. next を list に追加。
 ArgumentList : ArgumentList , AssignmentExpression
  1. precedingArgs を ? ArgumentListEvaluation(ArgumentList)。
  2. ref を ? AssignmentExpression の Evaluation。
  3. arg を ? GetValue(ref)。
  4. precedingArgs と « arg » のリスト結合を返す。
 ArgumentList : ArgumentList , ... AssignmentExpression
  1. precedingArgs を ? ArgumentListEvaluation(ArgumentList)。
  2. spreadRef を ? AssignmentExpression の Evaluation。
  3. iteratorRecord を ? GetIterator(? GetValue(spreadRef), sync)。
  4. 反復:
    1. next を ? IteratorStepValue(iteratorRecord)。
    2. next が done なら precedingArgs を返す。
    3. next を precedingArgs に追加。
 TemplateLiteral : NoSubstitutionTemplate
  1. templateLiteral を this TemplateLiteral。
  2. siteObj を GetTemplateObject(templateLiteral)。
  3. « siteObj » を返す。
 TemplateLiteral : SubstitutionTemplate
  1. templateLiteral を this TemplateLiteral。
  2. siteObj を GetTemplateObject(templateLiteral)。
  3. remaining を ? ArgumentListEvaluation(SubstitutionTemplate)。
  4. « siteObj » と remaining のリスト結合を返す。
 SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. firstSubRef を ? Expression の Evaluation。
  2. firstSub を ? GetValue(firstSubRef)。
  3. restSub を ? SubstitutionEvaluation(TemplateSpans)。
  4. 事前条件: restSub は（空かもしれない）List。
  5. « firstSub » と restSub のリスト結合を返す。

13.3.9 オプショナルチェイン (Optional Chains)

Note
オプショナルチェインは 1 つ以上のプロパティアクセスおよび関数呼び出しの連鎖で、最初のものが ?. トークンで始まる。

13.3.9.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

OptionalExpression : MemberExpression OptionalChain
  1. baseReference を ? MemberExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. baseValue が undefined または null なら
    1. undefined を返す。
  4. ? ChainEvaluation(OptionalChain, 引数 baseValue, baseReference) を返す。
 OptionalExpression : CallExpression OptionalChain
  1. baseReference を ? CallExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. baseValue が undefined または null なら
    1. undefined を返す。
  4. ? ChainEvaluation(OptionalChain, 引数 baseValue, baseReference) を返す。
 OptionalExpression : OptionalExpression OptionalChain
  1. baseReference を ? OptionalExpression の Evaluation。
  2. baseValue を ? GetValue(baseReference)。
  3. baseValue が undefined または null なら
    1. undefined を返す。
  4. ? ChainEvaluation(OptionalChain, 引数 baseValue, baseReference) を返す。

13.3.9.2 実行時セマンティクス: ChainEvaluation : 正常完了で ECMAScript 言語値または Reference Record を含むか、または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

OptionalChain : ?. Arguments
  1. thisChain を this OptionalChain。
  2. tailCall を IsInTailPosition(thisChain)。
  3. ? EvaluateCall(baseValue, baseReference, Arguments, tailCall) を返す。
 OptionalChain : ?. [ Expression ]
  1. strict を IsStrict(this OptionalChain)。
  2. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict) を返す。
 OptionalChain : ?. IdentifierName
  1. strict を IsStrict(this OptionalChain)。
  2. EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict) を返す。
 OptionalChain : ?. PrivateIdentifier
  1. fieldNameString を PrivateIdentifier の StringValue。
  2. MakePrivateReference(baseValue, fieldNameString) を返す。
 OptionalChain : OptionalChain Arguments
  1. optionalChain を OptionalChain。
  2. newReference を ? ChainEvaluation(optionalChain, 引数 baseValue, baseReference)。
  3. newValue を ? GetValue(newReference)。
  4. thisChain を this OptionalChain。
  5. tailCall を IsInTailPosition(thisChain)。
  6. ? EvaluateCall(newValue, newReference, Arguments, tailCall) を返す。
 OptionalChain : OptionalChain [ Expression ]
  1. optionalChain を OptionalChain。
  2. newReference を ? ChainEvaluation(optionalChain, 引数 baseValue, baseReference)。
  3. newValue を ? GetValue(newReference)。
  4. strict を IsStrict(this OptionalChain)。
  5. ? EvaluatePropertyAccessWithExpressionKey(newValue, Expression, strict) を返す。
 OptionalChain : OptionalChain . IdentifierName
  1. optionalChain を OptionalChain。
  2. newReference を ? ChainEvaluation(optionalChain, 引数 baseValue, baseReference)。
  3. newValue を ? GetValue(newReference)。
  4. strict を IsStrict(this OptionalChain)。
  5. EvaluatePropertyAccessWithIdentifierKey(newValue, IdentifierName, strict) を返す。
 OptionalChain : OptionalChain . PrivateIdentifier
  1. optionalChain を OptionalChain。
  2. newReference を ? ChainEvaluation(optionalChain, 引数 baseValue, baseReference)。
  3. newValue を ? GetValue(newReference)。
  4. fieldNameString を PrivateIdentifier の StringValue。
  5. MakePrivateReference(newValue, fieldNameString) を返す。

13.3.10 Import 呼び出し (Import Calls)

13.3.10.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ImportCall : import ( AssignmentExpression ,opt )
  1. ? EvaluateImportCall(AssignmentExpression) を返す。
 ImportCall : import ( AssignmentExpression , AssignmentExpression ,opt )
  1. ? EvaluateImportCall(the first AssignmentExpression, the second AssignmentExpression) を返す。

13.3.10.2 EvaluateImportCall ( specifierExpression [ , optionsExpression ] )

The abstract operation EvaluateImportCall takes argument specifierExpression (Parse Node) and optional argument optionsExpression (Parse Node) and returns 正常完了で Promise を含むか、または突然の完了. It performs the following steps when called:

  1. referrer を GetActiveScriptOrModule() とする。
  2. もし referrer が null であれば、referrer を現在の Realm Record に設定する。
  3. specifierRef を ? specifierExpression の評価結果とする。
  4. specifier を ? GetValue(specifierRef) とする。
  5. もし optionsExpression が存在するなら、
    1. optionsRef を ? optionsExpression の評価結果とする。
    2. options を ? GetValue(optionsRef) とする。
  6. そうでなければ、
    1. options を undefined とする。
  7. promiseCapability を ! NewPromiseCapability(%Promise%) とする。
  8. specifierString を Completion(ToString(specifier)) とする。
  9. IfAbruptRejectPromise(specifierString, promiseCapability)。
  10. attributes を新しい空の List とする。
  11. もし options が undefined でないなら、
    1. もし options が Object でないなら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに生成された TypeError オブジェクト ») を実行する。
      2. promiseCapability.[[Promise]] を返す。
    2. attributesObj を Completion(Get(options, "with" )) とする。
    3. IfAbruptRejectPromise(attributesObj, promiseCapability)。
    4. もし attributesObj が undefined でないなら、
      1. もし attributesObj が Object でないなら、
        1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに生成された TypeError オブジェクト ») を実行する。
        2. promiseCapability.[[Promise]] を返す。
      2. entries を Completion(EnumerableOwnProperties(attributesObj, key+value)) とする。
      3. IfAbruptRejectPromise(entries, promiseCapability)。
      4. entries の各要素 entry について、次を行う
        1. key を ! Get(entry, "0") とする。
        2. value を ! Get(entry, "1") とする。
        3. もし key が String なら、
          1. もし value が String でないなら、
            1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに生成された TypeError オブジェクト ») を実行する。
            2. promiseCapability.[[Promise]] を返す。
          2. ImportAttribute Record { [[Key]]: key, [[Value]]: value } を attributes に追加する。
    5. もし AllImportAttributesSupported(attributes) が false なら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに生成された TypeError オブジェクト ») を実行する。
      2. promiseCapability.[[Promise]] を返す。
    6. attributes をその各要素の [[Key]] フィールドの文字順 (各値を UTF-16 のコード単位列として扱う) に従ってソートする。注: このソートは、ホストが属性の列挙順序に基づいて挙動を変更することを禁じられているという点でのみ観測可能である。
  12. moduleRequest を新しい ModuleRequest Record { [[Specifier]]: specifierString, [[Attributes]]: attributes } とする。
  13. HostLoadImportedModule(referrer, moduleRequest, empty, promiseCapability) を実行する。
  14. promiseCapability.[[Promise]] を返す。

13.3.10.3 ContinueDynamicImport ( promiseCapability, moduleCompletion )

The abstract operation ContinueDynamicImport takes arguments promiseCapability (PromiseCapability Record) and moduleCompletion (Module Record を含む正常完了または throw 完了) and returns unused. It performs the following steps when called:

  1. moduleCompletion が abrupt completion なら
    1. ! Call(promiseCapability.[[Reject]], undefined, « moduleCompletion.[[Value]] »)。
    2. unused を返す。
  2. module を moduleCompletion.[[Value]]。
  3. loadPromise を module.LoadRequestedModules()。
  4. rejectedClosure を (reason) をパラメータとし promiseCapability を捕捉する Abstract Closure とし、呼ばれたら:
    1. ! Call(promiseCapability.[[Reject]], undefined, « reason »)。
    2. Return NormalCompletion(undefined)。
  5. onRejected を CreateBuiltinFunction(rejectedClosure, 1, "", « »)。
  6. linkAndEvaluateClosure をパラメータなしで module, promiseCapability, onRejected を捕捉する Abstract Closure とし、呼ばれたら:
    1. link を Completion(module.Link())。
    2. link が abrupt なら
      1. ! Call(promiseCapability.[[Reject]], undefined, « link.[[Value]] »)。
      2. Return NormalCompletion(undefined)。
    3. evaluatePromise を module.Evaluate()。
    4. fulfilledClosure をパラメータなしで module, promiseCapability を捕捉する Abstract Closure とし、呼ばれたら:
      1. namespace を GetModuleNamespace(module)。
      2. ! Call(promiseCapability.[[Resolve]], undefined, « namespace »)。
      3. Return NormalCompletion(undefined)。
    5. onFulfilled を CreateBuiltinFunction(fulfilledClosure, 0, "", « »)。
    6. PerformPromiseThen(evaluatePromise, onFulfilled, onRejected) を実行。
    7. unused を返す。
  7. linkAndEvaluate を CreateBuiltinFunction(linkAndEvaluateClosure, 0, "", « »)。
  8. PerformPromiseThen(loadPromise, linkAndEvaluate, onRejected) を実行。
  9. unused を返す。

13.3.11 タグ付きテンプレート (Tagged Templates)

Note

タグ付きテンプレートは TemplateLiteral (13.2.8) から導出される引数を持つ関数呼び出しである。実際の引数はテンプレートオブジェクト (13.2.8.4) と TemplateLiteral 内に埋め込まれた式の評価結果を含む。

13.3.11.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

MemberExpression : MemberExpression TemplateLiteral
  1. tagRef を ? MemberExpression の Evaluation。
  2. tagFunc を ? GetValue(tagRef)。
  3. thisCall を this MemberExpression。
  4. tailCall を IsInTailPosition(thisCall)。
  5. ? EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall) を返す。
 CallExpression : CallExpression TemplateLiteral
  1. tagRef を ? CallExpression の Evaluation。
  2. tagFunc を ? GetValue(tagRef)。
  3. thisCall を this CallExpression。
  4. tailCall を IsInTailPosition(thisCall)。
  5. ? EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall) を返す。

13.3.12 メタプロパティ (Meta Properties)

13.3.12.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

NewTarget : new . target
  1. GetNewTarget() を返す。
 ImportMeta : import . meta
  1. module を GetActiveScriptOrModule()。
  2. 事前条件: module は Source Text Module Record。
  3. importMeta を module.[[ImportMeta]]。
  4. importMeta が empty なら
    1. importMeta を OrdinaryObjectCreate(null)。
    2. importMetaValues を HostGetImportMetaProperties(module)。
    3. 各 Record { [[Key]], [[Value]] } p について
      1. ! CreateDataPropertyOrThrow(importMeta, p.[[Key]], p.[[Value]])。
    4. HostFinalizeImportMeta(importMeta, module) を実行。
    5. module.[[ImportMeta]] に importMeta を設定。
    6. importMeta を返す。
  5. それ以外
    1. 事前条件: importMeta は Object。
    2. importMeta を返す。

13.3.12.1.1 HostGetImportMetaProperties ( moduleRecord )

The host-defined abstract operation HostGetImportMetaProperties takes argument moduleRecord (Module Record) and returns 各 [[Key]] (property key), [[Value]] (ECMAScript 言語値) を持つ Record の List.

デフォルト実装は新しい空 List を返す。

13.3.12.1.2 HostFinalizeImportMeta ( importMeta, moduleRecord )

The host-defined abstract operation HostFinalizeImportMeta takes arguments importMeta (Object) and moduleRecord (Module Record) and returns unused.

多くのホストは HostGetImportMetaProperties を定義するだけで済み、HostFinalizeImportMeta のデフォルト動作をそのまま利用できる。HostFinalizeImportMeta は公開前に直接オブジェクトを操作する必要があるホスト向けの「エスケープハッチ」を提供する。

デフォルト実装は unused を返す。

13.4 更新式 (Update Expressions)

構文 (Syntax)

UpdateExpression[Yield, Await] : LeftHandSideExpression[?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] [no LineTerminator here] ++ LeftHandSideExpression[?Yield, ?Await] [no LineTerminator here] -- ++ UnaryExpression[?Yield, ?Await] -- UnaryExpression[?Yield, ?Await]

13.4.1 静的セマンティクス: 早期エラー (Static Semantics: Early Errors)

UpdateExpression : LeftHandSideExpression ++ LeftHandSideExpression -- UpdateExpression : ++ UnaryExpression -- UnaryExpression
  • UnaryExpression の AssignmentTargetType が invalid なら早期 Syntax Error とする。

13.4.2 後置インクリメント演算子 (Postfix Increment Operator)

13.4.2.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UpdateExpression : LeftHandSideExpression ++
  1. lhs を ? LeftHandSideExpression の Evaluation とする。
  2. LeftHandSideExpression の AssignmentTargetType が web-compat なら ReferenceError 例外を投げる。
  3. oldValue を ? ToNumeric(? GetValue(lhs)) とする。
  4. oldValue が Number なら
    1. newValue を Number::add(oldValue, 1𝔽) とする。
  5. そうでなければ
    1. Assert: oldValue は BigInt である。
    2. newValue を BigInt::add(oldValue, 1ℤ) とする。
  6. ? PutValue(lhs, newValue) を実行する。
  7. oldValue を返す。

13.4.3 後置デクリメント演算子 (Postfix Decrement Operator)

13.4.3.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UpdateExpression : LeftHandSideExpression --
  1. lhs を ? LeftHandSideExpression の Evaluation とする。
  2. LeftHandSideExpression の AssignmentTargetType が web-compat なら ReferenceError 例外を投げる。
  3. oldValue を ? ToNumeric(? GetValue(lhs)) とする。
  4. oldValue が Number なら
    1. newValue を Number::subtract(oldValue, 1𝔽) とする。
  5. そうでなければ
    1. Assert: oldValue は BigInt。
    2. newValue を BigInt::subtract(oldValue, 1ℤ) とする。
  6. ? PutValue(lhs, newValue) を実行。
  7. oldValue を返す。

13.4.4 前置インクリメント演算子 (Prefix Increment Operator)

13.4.4.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UpdateExpression : ++ UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. UnaryExpression の AssignmentTargetType が web-compat なら ReferenceError 例外を投げる。
  3. oldValue を ? ToNumeric(? GetValue(expr)) とする。
  4. oldValue が Number なら
    1. newValue を Number::add(oldValue, 1𝔽) とする。
  5. そうでなければ
    1. Assert: oldValue は BigInt。
    2. newValue を BigInt::add(oldValue, 1ℤ) とする。
  6. ? PutValue(expr, newValue) を実行。
  7. newValue を返す。

13.4.5 前置デクリメント演算子 (Prefix Decrement Operator)

13.4.5.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UpdateExpression : -- UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. UnaryExpression の AssignmentTargetType が web-compat なら ReferenceError 例外を投げる。
  3. oldValue を ? ToNumeric(? GetValue(expr)) とする。
  4. oldValue が Number なら
    1. newValue を Number::subtract(oldValue, 1𝔽) とする。
  5. そうでなければ
    1. Assert: oldValue は BigInt。
    2. newValue を BigInt::subtract(oldValue, 1ℤ) とする。
  6. ? PutValue(expr, newValue) を実行。
  7. newValue を返す。

13.5 単項演算子 (Unary Operators)

構文 (Syntax)

UnaryExpression[Yield, Await] : UpdateExpression[?Yield, ?Await] delete UnaryExpression[?Yield, ?Await] void UnaryExpression[?Yield, ?Await] typeof UnaryExpression[?Yield, ?Await] + UnaryExpression[?Yield, ?Await] - UnaryExpression[?Yield, ?Await] ~ UnaryExpression[?Yield, ?Await] ! UnaryExpression[?Yield, ?Await] [+Await] AwaitExpression[?Yield]

13.5.1 delete 演算子 (The delete Operator)

13.5.1.1 静的セマンティクス: 早期エラー (Static Semantics: Early Errors)

UnaryExpression : delete UnaryExpression Note

最後の規則により delete (((foo))) のような式は最初の規則が再帰適用されるため早期エラーになる。

13.5.1.2 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : delete UnaryExpression
  1. ref を ? UnaryExpression の Evaluation とする。
  2. ref が Reference Record でなければ true を返す。
  3. IsUnresolvableReference(ref) が true なら
    1. Assert: ref.[[Strict]] は false。
    2. true を返す。
  4. IsPropertyReference(ref) が true なら
    1. Assert: IsPrivateReference(ref) は false。
    2. IsSuperReference(ref) が true なら ReferenceError 例外を投げる。
    3. baseObj を ? ToObject(ref.[[Base]]) とする。
    4. ref.[[ReferencedName]] が property key でなければ
      1. ref.[[ReferencedName]] を ? ToPropertyKey(ref.[[ReferencedName]]) に設定。
    5. deleteStatus を ? baseObj.[[Delete]](ref.[[ReferencedName]]) とする。
    6. deleteStatus が false かつ ref.[[Strict]] が true なら TypeError 例外。
    7. deleteStatus を返す。
  5. そうでなければ
    1. base を ref.[[Base]] とする。
    2. Assert: base は Environment Record。
    3. ? base.DeleteBinding(ref.[[ReferencedName]]) を返す。
 Note 1

strict mode コード内で delete 演算子が出現し、その UnaryExpression が変数・引数・関数名への直接参照であると SyntaxError 例外となる。さらに strict mode で delete の対象プロパティが { [[Configurable]]: false }（または削除不能）である場合 TypeError 例外となる。

 Note 2

手順 4.c で生成されうるオブジェクトは上記抽象操作および通常オブジェクトの [[Delete]] 内部メソッドの外からはアクセスできない。実装はそのオブジェクトの実際の生成を省略してもよい。

13.5.2 void 演算子 (The void Operator)

13.5.2.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : void UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. ? GetValue(expr) を実行。
  3. undefined を返す。
 Note

値を使用しない場合でも副作用が観測され得るため GetValue を呼び出す必要がある。

13.5.3 typeof 演算子 (The typeof Operator)

13.5.3.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : typeof UnaryExpression
  1. val を ? UnaryExpression の Evaluation とする。
  2. val が Reference Record なら
    1. IsUnresolvableReference(val) が true なら "undefined" を返す。
  3. val を ? GetValue(val) に設定。
  4. val が undefined なら "undefined" を返す。
  5. val が null なら "object" を返す。
  6. val が String なら "string" を返す。
  7. val が Symbol なら "symbol" を返す。
  8. val が Boolean なら "boolean" を返す。
  9. val が Number なら "number" を返す。
  10. val が BigInt なら "bigint" を返す。
  11. Assert: val は Object。
  12. Normative Optional
    ホストがウェブブラウザ又は [[IsHTMLDDA]] 内部スロット をサポートするなら
    1. val が [[IsHTMLDDA]] 内部スロットを持つ場合 "undefined" を返す。
  13. val が [[Call]] 内部メソッドを持つなら "function" を返す。
  14. "object" を返す。

13.5.4 単項 + 演算子 (Unary + Operator)

Note

単項 + 演算子は被演算子を Number 型に変換する。

13.5.4.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : + UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. ? ToNumber(? GetValue(expr)) を返す。

13.5.5 単項 - 演算子 (Unary - Operator)

Note

単項 - は被演算子を数値へ変換し符号を反転する。+0𝔽 の反転は -0𝔽、-0𝔽 の反転は +0𝔽 を生成する。

13.5.5.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : - UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. oldValue を ? ToNumeric(? GetValue(expr)) とする。
  3. oldValue が Number なら
    1. Number::unaryMinus(oldValue) を返す。
  4. そうでなければ
    1. Assert: oldValue は BigInt。
    2. BigInt::unaryMinus(oldValue) を返す。

13.5.6 ビット単位 NOT 演算子 ( ~ ) (Bitwise NOT Operator)

13.5.6.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : ~ UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. oldValue を ? ToNumeric(? GetValue(expr)) とする。
  3. oldValue が Number なら
    1. Number::bitwiseNOT(oldValue) を返す。
  4. そうでなければ
    1. Assert: oldValue は BigInt。
    2. BigInt::bitwiseNOT(oldValue) を返す。

13.5.7 論理 NOT 演算子 ( ! ) (Logical NOT Operator)

13.5.7.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

UnaryExpression : ! UnaryExpression
  1. expr を ? UnaryExpression の Evaluation とする。
  2. oldValue を ToBoolean(? GetValue(expr)) とする。
  3. oldValue が true なら false を返す。
  4. true を返す。

13.6 累乗演算子 (Exponentiation Operator)

構文 (Syntax)

ExponentiationExpression[Yield, Await] : UnaryExpression[?Yield, ?Await] UpdateExpression[?Yield, ?Await] ** ExponentiationExpression[?Yield, ?Await]

13.6.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ExponentiationExpression : UpdateExpression ** ExponentiationExpression
  1. ? EvaluateStringOrNumericBinaryExpression(UpdateExpression, **, ExponentiationExpression) を返す。

13.7 乗算系演算子 (Multiplicative Operators)

構文 (Syntax)

MultiplicativeExpression[Yield, Await] : ExponentiationExpression[?Yield, ?Await] MultiplicativeExpression[?Yield, ?Await] MultiplicativeOperator ExponentiationExpression[?Yield, ?Await] MultiplicativeOperator : one of * / % Note
  • * は乗算で被演算子の積を生成する。
  • / は除算で被演算子の商を生成する。
  • % は暗黙の除算に基づく剰余を生成する。

13.7.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

MultiplicativeExpression : MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
  1. opText を MultiplicativeOperator にマッチしたソーステキストとする。
  2. ? EvaluateStringOrNumericBinaryExpression(MultiplicativeExpression, opText, ExponentiationExpression) を返す。

13.8 加算系演算子 (Additive Operators)

構文 (Syntax)

AdditiveExpression[Yield, Await] : MultiplicativeExpression[?Yield, ?Await] AdditiveExpression[?Yield, ?Await] + MultiplicativeExpression[?Yield, ?Await] AdditiveExpression[?Yield, ?Await] - MultiplicativeExpression[?Yield, ?Await]

13.8.1 加算演算子 ( + ) (The Addition Operator)

Note

加算演算子は文字列連結または数値加算を行う。

13.8.1.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

AdditiveExpression : AdditiveExpression + MultiplicativeExpression
  1. ? EvaluateStringOrNumericBinaryExpression(AdditiveExpression, +, MultiplicativeExpression) を返す。

13.8.2 減算演算子 ( - ) (The Subtraction Operator)

Note

- 演算子は減算を行い被演算子の差を生成する。

13.8.2.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

AdditiveExpression : AdditiveExpression - MultiplicativeExpression
  1. ? EvaluateStringOrNumericBinaryExpression(AdditiveExpression, -, MultiplicativeExpression) を返す。

13.9 ビットシフト演算子 (Bitwise Shift Operators)

構文 (Syntax)

ShiftExpression[Yield, Await] : AdditiveExpression[?Yield, ?Await] ShiftExpression[?Yield, ?Await] << AdditiveExpression[?Yield, ?Await] ShiftExpression[?Yield, ?Await] >> AdditiveExpression[?Yield, ?Await] ShiftExpression[?Yield, ?Await] >>> AdditiveExpression[?Yield, ?Await]

13.9.1 左シフト演算子 ( << ) (The Left Shift Operator)

Note

左オペランドを右オペランドで指定された回数だけビット左シフトする。

13.9.1.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ShiftExpression : ShiftExpression << AdditiveExpression
  1. ? EvaluateStringOrNumericBinaryExpression(ShiftExpression, <<, AdditiveExpression) を返す。

13.9.2 算術（符号付き）右シフト演算子 ( >> ) (The Signed Right Shift Operator)

Note

左オペランドを右オペランドで指定された回数だけ符号拡張しつつビット右シフトする。

13.9.2.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ShiftExpression : ShiftExpression >> AdditiveExpression
  1. ? EvaluateStringOrNumericBinaryExpression(ShiftExpression, >>, AdditiveExpression) を返す。

13.9.3 論理（ゼロ埋め）右シフト演算子 ( >>> ) (The Unsigned Right Shift Operator)

Note

左オペランドを右オペランドで指定回数だけゼロ埋めしつつビット右シフトする。

13.9.3.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ShiftExpression : ShiftExpression >>> AdditiveExpression
  1. ? EvaluateStringOrNumericBinaryExpression(ShiftExpression, >>>, AdditiveExpression) を返す。

13.10 関係演算子 (Relational Operators)

Note 1

関係演算子の評価結果は常に Boolean 型で、被演算子間にその関係が成り立つかを示す。

構文 (Syntax)

RelationalExpression[In, Yield, Await] : ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] < ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] > ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] <= ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] >= ShiftExpression[?Yield, ?Await] RelationalExpression[?In, ?Yield, ?Await] instanceof ShiftExpression[?Yield, ?Await] [+In] RelationalExpression[+In, ?Yield, ?Await] in ShiftExpression[?Yield, ?Await] [+In] PrivateIdentifier in ShiftExpression[?Yield, ?Await] Note 2

[In] 文法パラメータは関係式内の in 演算子と for 文の in を混同しないために必要。

13.10.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

RelationalExpression : RelationalExpression < ShiftExpression
  1. lRef を ? RelationalExpression の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. rRef を ? ShiftExpression の Evaluation。
  4. rVal を ? GetValue(rRef)。
  5. r を ? IsLessThan(lVal, rVal, true) とする。
  6. r が undefined なら false、そうでなければ r を返す。
 RelationalExpression : RelationalExpression > ShiftExpression
  1. lRef, lVal, rRef, rVal を上と同様に求める（ただし比較順を反転）。
  2. r を ? IsLessThan(rVal, lVal, false) とする。
  3. r が undefined なら false、そうでなければ r。
 RelationalExpression : RelationalExpression <= ShiftExpression
  1. 左右を評価し r を ? IsLessThan(rVal, lVal, false)。
  2. r が true または undefined なら false、そうでなければ true。
 RelationalExpression : RelationalExpression >= ShiftExpression
  1. 左右を評価し r を ? IsLessThan(lVal, rVal, true)。
  2. r が true または undefined なら false、そうでなければ true。
 RelationalExpression : RelationalExpression instanceof ShiftExpression
  1. 左右を評価し lVal, rVal を得る。
  2. ? InstanceofOperator(lVal, rVal) を返す。
 RelationalExpression : RelationalExpression in ShiftExpression
  1. 左右を評価し lVal, rVal を得る。
  2. rVal が Object でなければ TypeError。
  3. ? HasProperty(rVal, ? ToPropertyKey(lVal)) を返す。
 RelationalExpression : PrivateIdentifier in ShiftExpression
  1. privateIdentifier を PrivateIdentifier の StringValue とする。
  2. rRef, rVal を評価して得る。
  3. rVal が Object でなければ TypeError。
  4. privateEnv を実行中コンテキストの PrivateEnvironment とする。
  5. Assert: privateEnv は null でない。
  6. privateName を ResolvePrivateIdentifier(privateEnv, privateIdentifier)。
  7. PrivateElementFind(rVal, privateName) が empty でなければ true。
  8. false を返す。

13.10.2 InstanceofOperator ( V, target )

The abstract operation InstanceofOperator takes arguments V (ECMAScript 言語値) and target (ECMAScript 言語値) and returns 正常完了で Boolean を含むか throw 完了. It performs the following steps when called:

  1. target が Object でなければ TypeError 例外。
  2. instOfHandler を ? GetMethod(target, %Symbol.hasInstance%) とする。
  3. instOfHandler が undefined でなければ
    1. ToBoolean(? Call(instOfHandler, target, « V »)) を返す。
  4. IsCallable(target) が false なら TypeError。
  5. ? OrdinaryHasInstance(target, V) を返す。
 Note

4 と 5 は %Symbol.hasInstance% が存在しなかった以前の版との互換性を提供する。オブジェクトが %Symbol.hasInstance% を定義・継承しない場合は従来の instanceof 既定セマンティクスを用いる。

13.11 等価演算子 (Equality Operators)

Note

等価演算子の評価結果は常に Boolean 型で、演算子が命名する関係が両被演算子間で成り立つかを表す。

構文 (Syntax)

EqualityExpression[In, Yield, Await] : RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] == RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] != RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] === RelationalExpression[?In, ?Yield, ?Await] EqualityExpression[?In, ?Yield, ?Await] !== RelationalExpression[?In, ?Yield, ?Await]

13.11.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

EqualityExpression : EqualityExpression == RelationalExpression
  1. 左右を評価し lVal, rVal を得る。
  2. ? IsLooselyEqual(rVal, lVal) を返す。
 EqualityExpression : EqualityExpression != RelationalExpression
  1. 左右を評価し lVal, rVal を得る。
  2. r を ? IsLooselyEqual(rVal, lVal)。
  3. r が true なら false、それ以外 true。
 EqualityExpression : EqualityExpression === RelationalExpression
  1. 左右を評価し lVal, rVal を得る。
  2. IsStrictlyEqual(rVal, lVal) を返す。
 EqualityExpression : EqualityExpression !== RelationalExpression
  1. 左右を評価し lVal, rVal を得る。
  2. r を IsStrictlyEqual(rVal, lVal)。
  3. r が true なら false、それ以外 true。
 Note 1

上記定義に関して:

  • 文字列比較は: \`${a}\` == \`${b}\` により強制できる。
  • 数値比較は: +a == +b により強制できる。
  • Boolean 比較は: !a == !b により強制できる。
Note 2

等価演算子は次の不変条件を保持する:

  • A != B は !(A == B) と同値。
  • A == B は評価順序を除き B == A と同値。
Note 3

等価演算子は常に推移的とは限らない。例えば同じ String 値を表す異なる 2 つの String オブジェクトは、それぞれがリテラル文字列とは == で等しいが、互いには等しくない:

  • new String("a") == "a" および "a" == new String("a") は true。
  • new String("a") == new String("a") は false。
Note 4

文字列比較はコードユニット列の単純な同値判定であり、Unicode 仕様の正規等価や照合順序は考慮されない。Unicode の正規等価な String が不等と判定され得る。両 String は既に正規化されているものとみなす。

13.12 ビット単位二項演算子 (Binary Bitwise Operators)

構文 (Syntax)

BitwiseANDExpression[In, Yield, Await] : EqualityExpression[?In, ?Yield, ?Await] BitwiseANDExpression[?In, ?Yield, ?Await] & EqualityExpression[?In, ?Yield, ?Await] BitwiseXORExpression[In, Yield, Await] : BitwiseANDExpression[?In, ?Yield, ?Await] BitwiseXORExpression[?In, ?Yield, ?Await] ^ BitwiseANDExpression[?In, ?Yield, ?Await] BitwiseORExpression[In, Yield, Await] : BitwiseXORExpression[?In, ?Yield, ?Await] BitwiseORExpression[?In, ?Yield, ?Await] | BitwiseXORExpression[?In, ?Yield, ?Await]

13.12.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

BitwiseANDExpression : BitwiseANDExpression & EqualityExpression
  1. ? EvaluateStringOrNumericBinaryExpression(BitwiseANDExpression, &, EqualityExpression) を返す。
 BitwiseXORExpression : BitwiseXORExpression ^ BitwiseANDExpression
  1. ? EvaluateStringOrNumericBinaryExpression(BitwiseXORExpression, ^, BitwiseANDExpression) を返す。
 BitwiseORExpression : BitwiseORExpression | BitwiseXORExpression
  1. ? EvaluateStringOrNumericBinaryExpression(BitwiseORExpression, |, BitwiseXORExpression) を返す。

13.13 論理二項演算子 (Binary Logical Operators)

構文 (Syntax)

LogicalANDExpression[In, Yield, Await] : BitwiseORExpression[?In, ?Yield, ?Await] LogicalANDExpression[?In, ?Yield, ?Await] && BitwiseORExpression[?In, ?Yield, ?Await] LogicalORExpression[In, Yield, Await] : LogicalANDExpression[?In, ?Yield, ?Await] LogicalORExpression[?In, ?Yield, ?Await] || LogicalANDExpression[?In, ?Yield, ?Await] CoalesceExpression[In, Yield, Await] : CoalesceExpressionHead[?In, ?Yield, ?Await] ?? BitwiseORExpression[?In, ?Yield, ?Await] CoalesceExpressionHead[In, Yield, Await] : CoalesceExpression[?In, ?Yield, ?Await] BitwiseORExpression[?In, ?Yield, ?Await] ShortCircuitExpression[In, Yield, Await] : LogicalORExpression[?In, ?Yield, ?Await] CoalesceExpression[?In, ?Yield, ?Await] Note

&& および || 演算子の結果値は必ずしも Boolean 型ではなく、常に 2 つの被演算子のいずれかの値そのものである。

13.13.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

LogicalANDExpression : LogicalANDExpression && BitwiseORExpression
  1. lRef を ? LogicalANDExpression の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. ToBoolean(lVal) が false なら lVal を返す。
  4. rRef を ? BitwiseORExpression の Evaluation。
  5. ? GetValue(rRef) を返す。
 LogicalORExpression : LogicalORExpression || LogicalANDExpression
  1. lRef を ? LogicalORExpression の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. ToBoolean(lVal) が true なら lVal を返す。
  4. rRef を ? LogicalANDExpression の Evaluation。
  5. ? GetValue(rRef) を返す。
 CoalesceExpression : CoalesceExpressionHead ?? BitwiseORExpression
  1. lRef を ? CoalesceExpressionHead の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. lVal が undefined または null なら
    1. rRef を ? BitwiseORExpression の Evaluation。
    2. ? GetValue(rRef) を返す。
  4. そうでなければ
    1. lVal を返す。

13.14 条件演算子 ( ? : ) (Conditional Operator)

構文 (Syntax)

ConditionalExpression[In, Yield, Await] : ShortCircuitExpression[?In, ?Yield, ?Await] ShortCircuitExpression[?In, ?Yield, ?Await] ? AssignmentExpression[+In, ?Yield, ?Await] : AssignmentExpression[?In, ?Yield, ?Await] Note

ECMAScript の ConditionalExpression の文法は C や Java とわずかに異なる。C / Java では第 2 部分式を Expression とできる一方で第 3 部分式を ConditionalExpression に制限する。ECMAScript が異なるのは、条件のどちらの腕でも代入式を許可し、かつ中央の式として（紛らわしくほとんど有用でない）カンマ式となるケースを排除するためである。

13.14.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

ConditionalExpression : ShortCircuitExpression ? AssignmentExpression : AssignmentExpression
  1. lRef を ? ShortCircuitExpression の Evaluation とする。
  2. lVal を ToBoolean(? GetValue(lRef)) とする。
  3. lVal が true なら
    1. trueRef を 1 番目の AssignmentExpression の Evaluation。
    2. ? GetValue(trueRef) を返す。
  4. そうでなければ
    1. falseRef を 2 番目の AssignmentExpression の Evaluation。
    2. ? GetValue(falseRef) を返す。

13.15 代入演算子 (Assignment Operators)

構文 (Syntax)

AssignmentExpression[In, Yield, Await] : ConditionalExpression[?In, ?Yield, ?Await] [+Yield] YieldExpression[?In, ?Await] ArrowFunction[?In, ?Yield, ?Await] AsyncArrowFunction[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] = AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] AssignmentOperator AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] &&= AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] ||= AssignmentExpression[?In, ?Yield, ?Await] LeftHandSideExpression[?Yield, ?Await] ??= AssignmentExpression[?In, ?Yield, ?Await] AssignmentOperator : one of *= /= %= += -= <<= >>= >>>= &= ^= |= **=

13.15.1 静的セマンティクス: 早期エラー (Static Semantics: Early Errors)

AssignmentExpression : LeftHandSideExpression = AssignmentExpression AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression AssignmentExpression : LeftHandSideExpression &&= AssignmentExpression LeftHandSideExpression ||= AssignmentExpression LeftHandSideExpression ??= AssignmentExpression

13.15.2 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

AssignmentExpression : LeftHandSideExpression = AssignmentExpression
  1. LeftHandSideExpression が ObjectLiteral でも ArrayLiteral でもないなら
    1. lRef を ? LeftHandSideExpression の Evaluation。
    2. LeftHandSideExpression の AssignmentTargetType が web-compat なら ReferenceError 例外。
    3. IsAnonymousFunctionDefinition(AssignmentExpression) が true かつ IsIdentifierRef(LeftHandSideExpression) が true なら
      1. lhs を LeftHandSideExpression の StringValue。
      2. rVal を 引数 lhs で AssignmentExpression の NamedEvaluation。
    4. そうでなければ
      1. rRef を ? AssignmentExpression の Evaluation。
      2. rVal を ? GetValue(rRef)。
    5. ? PutValue(lRef, rVal) を実行。
    6. rVal を返す。
  2. assignmentPattern を LeftHandSideExpression が覆う AssignmentPattern とする。
  3. rRef を ? AssignmentExpression の Evaluation。
  4. rVal を ? GetValue(rRef)。
  5. assignmentPattern の DestructuringAssignmentEvaluation を引数 rVal で実行。
  6. rVal を返す。
 AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
  1. lRef を ? LeftHandSideExpression の Evaluation。
  2. LeftHandSideExpression の AssignmentTargetType が web-compat なら ReferenceError。
  3. lVal を ? GetValue(lRef)。
  4. rRef を ? AssignmentExpression の Evaluation。
  5. rVal を ? GetValue(rRef)。
  6. assignmentOpText を AssignmentOperator にマッチしたソーステキスト。
  7. opText を次の表で assignmentOpText に対応する Unicode コードポイント列。
    assignmentOpText opText
    **= **
    *= *
    /= /
    %= %
    += +
    -= -
    <<= <<
    >>= >>
    >>>= >>>
    &= &
    ^= ^
    |= |
  8. r を ? ApplyStringOrNumericBinaryOperator(lVal, opText, rVal) とする。
  9. ? PutValue(lRef, r) を実行。
  10. r を返す。
 AssignmentExpression : LeftHandSideExpression &&= AssignmentExpression
  1. lRef を ? LeftHandSideExpression の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. ToBoolean(lVal) が false なら lVal を返す。
  4. IsAnonymousFunctionDefinition(AssignmentExpression) が true かつ IsIdentifierRef(LeftHandSideExpression) が true なら
    1. lhs を LeftHandSideExpression の StringValue。
    2. rVal を 引数 lhs で AssignmentExpression の NamedEvaluation。
  5. そうでなければ
    1. rRef を ? AssignmentExpression の Evaluation。
    2. rVal を ? GetValue(rRef)。
  6. ? PutValue(lRef, rVal) を実行。
  7. rVal を返す。
 AssignmentExpression : LeftHandSideExpression ||= AssignmentExpression
  1. lRef を ? LeftHandSideExpression の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. ToBoolean(lVal) が true なら lVal を返す。
  4. IsAnonymousFunctionDefinition(AssignmentExpression) が true かつ IsIdentifierRef(LeftHandSideExpression) が true なら
    1. lhs を LeftHandSideExpression の StringValue。
    2. rVal を 引数 lhs で AssignmentExpression の NamedEvaluation。
  5. そうでなければ
    1. rRef を ? AssignmentExpression の Evaluation。
    2. rVal を ? GetValue(rRef)。
  6. ? PutValue(lRef, rVal) を実行。
  7. rVal を返す。
 AssignmentExpression : LeftHandSideExpression ??= AssignmentExpression
  1. lRef を ? LeftHandSideExpression の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. lVal が undefined でも null でもないなら lVal を返す。
  4. IsAnonymousFunctionDefinition(AssignmentExpression) が true かつ IsIdentifierRef(LeftHandSideExpression) が true なら
    1. lhs を LeftHandSideExpression の StringValue。
    2. rVal を 引数 lhs で AssignmentExpression の NamedEvaluation。
  5. そうでなければ
    1. rRef を ? AssignmentExpression の Evaluation。
    2. rVal を ? GetValue(rRef)。
  6. ? PutValue(lRef, rVal) を実行。
  7. rVal を返す。
 Note

strict mode コード内でこの式が現れる場合、手順 1.e, 3, 2, 2, 2 の lRef が解決不能参照なら実行時エラー（ReferenceError 例外）。さらに手順 9, 6, 6, 6 の lRef が [[Writable]]:false のデータプロパティ、[[Set]]:undefined のアクセサプロパティ、あるいは IsExtensible が false を返すオブジェクト上の存在しないプロパティを参照しているなら TypeError 例外を投げる。

13.15.3 ApplyStringOrNumericBinaryOperator ( lVal, opText, rVal )

The abstract operation ApplyStringOrNumericBinaryOperator takes arguments lVal (ECMAScript 言語値), opText (**, *, /, %, +, -, <<, >>, >>>, &, ^, |), and rVal (ECMAScript 言語値) and returns 正常完了で String / BigInt / Number のいずれか、または throw 完了. It performs the following steps when called:

  1. opText が + なら
    1. lPrim を ? ToPrimitive(lVal)。
    2. rPrim を ? ToPrimitive(rVal)。
    3. lPrim が String であるか rPrim が String なら
      1. lStr を ? ToString(lPrim)。
      2. rStr を ? ToString(rPrim)。
      3. lStr と rStr の文字列連結を返す。
    4. lVal を lPrim に設定。
    5. rVal を rPrim に設定。
  2. 注: ここからは数値演算である。
  3. lNum を ? ToNumeric(lVal)。
  4. rNum を ? ToNumeric(rVal)。
  5. SameType(lNum, rNum) が false なら TypeError 例外。
  6. lNum が BigInt なら
    1. opText が ** なら ? BigInt::exponentiate(lNum, rNum) を返す。
    2. opText が / なら ? BigInt::divide(lNum, rNum)。
    3. opText が % なら ? BigInt::remainder(lNum, rNum)。
    4. opText が >>> なら ? BigInt::unsignedRightShift(lNum, rNum)。
    5. operation を次の表で opText に対応する抽象操作とする:
      opText operation
      * BigInt::multiply
      + BigInt::add
      - BigInt::subtract
      << BigInt::leftShift
      >> BigInt::signedRightShift
      & BigInt::bitwiseAND
      ^ BigInt::bitwiseXOR
      | BigInt::bitwiseOR
  7. そうでなければ
    1. Assert: lNum は Number。
    2. operation を次の表で opText に対応する抽象操作とする:
      opText operation
      ** Number::exponentiate
      * Number::multiply
      / Number::divide
      % Number::remainder
      + Number::add
      - Number::subtract
      << Number::leftShift
      >> Number::signedRightShift
      >>> Number::unsignedRightShift
      & Number::bitwiseAND
      ^ Number::bitwiseXOR
      | Number::bitwiseOR
  8. operation(lNum, rNum) を返す。
 Note 1

手順 1.a, 1.b の ToPrimitive 呼出しでは hint を与えない。標準オブジェクト（Date を除く）は hint 省略時 number と同等に扱い、Date は string と同等に扱う。エキゾチックオブジェクトは別の扱いをするかもしれない。

 Note 2

手順 1.c は IsLessThan アルゴリズムの手順 3 と異なり、論理積ではなく論理和を用いる。

13.15.4 EvaluateStringOrNumericBinaryExpression ( leftOperand, opText, rightOperand )

The abstract operation EvaluateStringOrNumericBinaryExpression takes arguments leftOperand (Parse Node), opText (Unicode コードポイント列), and rightOperand (Parse Node) and returns 正常完了で String / BigInt / Number のいずれか、または突然の完了. It performs the following steps when called:

  1. lRef を ? leftOperand の Evaluation。
  2. lVal を ? GetValue(lRef)。
  3. rRef を ? rightOperand の Evaluation。
  4. rVal を ? GetValue(rRef)。
  5. ? ApplyStringOrNumericBinaryOperator(lVal, opText, rVal) を返す。

13.15.5 分割代入 (Destructuring Assignment)

補助構文 (Supplemental Syntax)

次の生成規則インスタンスを処理する特定状況で
AssignmentExpression : LeftHandSideExpression = AssignmentExpression
LeftHandSideExpression の解釈は以下の文法で精緻化される:

AssignmentPattern[Yield, Await] : ObjectAssignmentPattern[?Yield, ?Await] ArrayAssignmentPattern[?Yield, ?Await] ObjectAssignmentPattern[Yield, Await] : { } { AssignmentRestProperty[?Yield, ?Await] } { AssignmentPropertyList[?Yield, ?Await] } { AssignmentPropertyList[?Yield, ?Await] , AssignmentRestProperty[?Yield, ?Await]opt } ArrayAssignmentPattern[Yield, Await] : [ Elisionopt AssignmentRestElement[?Yield, ?Await]opt ] [ AssignmentElementList[?Yield, ?Await] ] [ AssignmentElementList[?Yield, ?Await] , Elisionopt AssignmentRestElement[?Yield, ?Await]opt ] AssignmentRestProperty[Yield, Await] : ... DestructuringAssignmentTarget[?Yield, ?Await] AssignmentPropertyList[Yield, Await] : AssignmentProperty[?Yield, ?Await] AssignmentPropertyList[?Yield, ?Await] , AssignmentProperty[?Yield, ?Await] AssignmentElementList[Yield, Await] : AssignmentElisionElement[?Yield, ?Await] AssignmentElementList[?Yield, ?Await] , AssignmentElisionElement[?Yield, ?Await] AssignmentElisionElement[Yield, Await] : Elisionopt AssignmentElement[?Yield, ?Await] AssignmentProperty[Yield, Await] : IdentifierReference[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt PropertyName[?Yield, ?Await] : AssignmentElement[?Yield, ?Await] AssignmentElement[Yield, Await] : DestructuringAssignmentTarget[?Yield, ?Await] Initializer[+In, ?Yield, ?Await]opt AssignmentRestElement[Yield, Await] : ... DestructuringAssignmentTarget[?Yield, ?Await] DestructuringAssignmentTarget[Yield, Await] : LeftHandSideExpression[?Yield, ?Await]

13.15.5.1 静的セマンティクス: 早期エラー (Static Semantics: Early Errors)

AssignmentProperty : IdentifierReference Initializeropt AssignmentRestProperty : ... DestructuringAssignmentTarget DestructuringAssignmentTarget : LeftHandSideExpression

13.15.5.2 実行時セマンティクス: DestructuringAssignmentEvaluation : 正常完了で unused または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

ObjectAssignmentPattern : { }
  1. ? RequireObjectCoercible(value)。
  2. unused を返す。
 ObjectAssignmentPattern : { AssignmentPropertyList } { AssignmentPropertyList , }
  1. ? RequireObjectCoercible(value)。
  2. AssignmentPropertyList の PropertyDestructuringAssignmentEvaluation を引数 value で実行。
  3. unused を返す。
 ObjectAssignmentPattern : { AssignmentRestProperty }
  1. ? RequireObjectCoercible(value)。
  2. excludedNames を空 List。
  3. AssignmentRestProperty の RestDestructuringAssignmentEvaluation を引数 value, excludedNames で返す。
 ObjectAssignmentPattern : { AssignmentPropertyList , AssignmentRestProperty }
  1. ? RequireObjectCoercible(value)。
  2. excludedNames を AssignmentPropertyList の PropertyDestructuringAssignmentEvaluation(引数 value)。
  3. AssignmentRestProperty の RestDestructuringAssignmentEvaluation(value, excludedNames) を返す。
 ArrayAssignmentPattern : [ ]
  1. iteratorRecord を ? GetIterator(value, sync)。
  2. ? IteratorClose(iteratorRecord, NormalCompletion(unused)) を返す。
 ArrayAssignmentPattern : [ Elision ]
  1. iteratorRecord を ? GetIterator(value, sync)。
  2. result を Completion(Elision の IteratorDestructuringAssignmentEvaluation(iteratorRecord))。
  3. iteratorRecord.[[Done]] が false なら ? IteratorClose(iteratorRecord, result) を返す。
  4. result を返す。
 ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
  1. iteratorRecord を ? GetIterator(value, sync)。
  2. Elision が存在するなら
    1. status を Completion(Elision の IteratorDestructuringAssignmentEvaluation(iteratorRecord))。
    2. status が abrupt なら
      1. Assert: iteratorRecord.[[Done]] は true。
      2. ? status を返す。
  3. result を Completion(AssignmentRestElement の IteratorDestructuringAssignmentEvaluation(iteratorRecord))。
  4. iteratorRecord.[[Done]] が false なら ? IteratorClose(iteratorRecord, result)。
  5. result を返す。
 ArrayAssignmentPattern : [ AssignmentElementList ]
  1. iteratorRecord を ? GetIterator(value, sync)。
  2. result を Completion(AssignmentElementList の IteratorDestructuringAssignmentEvaluation(iteratorRecord))。
  3. iteratorRecord.[[Done]] が false なら ? IteratorClose(iteratorRecord, result)。
  4. result を返す。
 ArrayAssignmentPattern : [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
  1. iteratorRecord を ? GetIterator(value, sync)。
  2. status を Completion(AssignmentElementList の IteratorDestructuringAssignmentEvaluation(iteratorRecord))。
  3. status が abrupt なら
    1. iteratorRecord.[[Done]] が false なら ? IteratorClose(iteratorRecord, status) を返す。
    2. ? status を返す。
  4. Elision が存在するなら
    1. status を Completion(Elision の IteratorDestructuringAssignmentEvaluation(iteratorRecord)) に設定。
    2. status が abrupt なら
      1. Assert: iteratorRecord.[[Done]] は true。
      2. ? status を返す。
  5. AssignmentRestElement が存在するなら
    1. status を Completion(AssignmentRestElement の IteratorDestructuringAssignmentEvaluation(iteratorRecord)) に設定。
  6. iteratorRecord.[[Done]] が false なら ? IteratorClose(iteratorRecord, status)。
  7. ? status を返す。

13.15.5.3 実行時セマンティクス: PropertyDestructuringAssignmentEvaluation : 正常完了でプロパティキーの List または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

AssignmentPropertyList : AssignmentPropertyList , AssignmentProperty
  1. propertyNames を ? PropertyDestructuringAssignmentEvaluation(AssignmentPropertyList, value)。
  2. nextNames を ? PropertyDestructuringAssignmentEvaluation(AssignmentProperty, value)。
  3. propertyNames と nextNames のリスト結合を返す。
 AssignmentProperty : IdentifierReference Initializeropt
  1. P を IdentifierReference の StringValue。
  2. lRef を ? ResolveBinding(P)。
  3. v を ? GetV(value, P)。
  4. Initializer が存在し v が undefined なら
    1. IsAnonymousFunctionDefinition(Initializer) が true なら
      1. v を 引数 P で Initializer の NamedEvaluation。
    2. そうでなければ
      1. defaultValue を ? Initializer の Evaluation。
      2. v を ? GetValue(defaultValue)。
  5. ? PutValue(lRef, v) を実行。
  6. « P » を返す。
 AssignmentProperty : PropertyName : AssignmentElement
  1. name を ? PropertyName の Evaluation。
  2. AssignmentElement の KeyedDestructuringAssignmentEvaluation(value, name) を実行。
  3. « name » を返す。

13.15.5.4 実行時セマンティクス: RestDestructuringAssignmentEvaluation : 正常完了で unused または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

AssignmentRestProperty : ... DestructuringAssignmentTarget
  1. lRef を ? DestructuringAssignmentTarget の Evaluation。
  2. restObj を OrdinaryObjectCreate(%Object.prototype%)。
  3. ? CopyDataProperties(restObj, value, excludedNames)。
  4. ? PutValue(lRef, restObj) を返す。

13.15.5.5 実行時セマンティクス: IteratorDestructuringAssignmentEvaluation : 正常完了で unused または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

AssignmentElementList : AssignmentElisionElement
  1. AssignmentElisionElement の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を返す。
 AssignmentElementList : AssignmentElementList , AssignmentElisionElement
  1. AssignmentElementList の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を実行。
  2. AssignmentElisionElement の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を返す。
 AssignmentElisionElement : AssignmentElement
  1. AssignmentElement の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を返す。
 AssignmentElisionElement : Elision AssignmentElement
  1. Elision の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を実行。
  2. AssignmentElement の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を返す。
 Elision : ,
  1. iteratorRecord.[[Done]] が false なら
    1. ? IteratorStep(iteratorRecord)。
  2. unused を返す。
 Elision : Elision ,
  1. Elision の IteratorDestructuringAssignmentEvaluation(iteratorRecord) を実行。
  2. iteratorRecord.[[Done]] が false なら
    1. ? IteratorStep(iteratorRecord)。
  3. unused を返す。
 AssignmentElement : DestructuringAssignmentTarget Initializeropt
  1. DestructuringAssignmentTarget が ObjectLiteral / ArrayLiteral のいずれでもないなら
    1. lRef を ? DestructuringAssignmentTarget の Evaluation。
  2. value を undefined。
  3. iteratorRecord.[[Done]] が false なら
    1. next を ? IteratorStepValue(iteratorRecord)。
    2. next が done でなければ value を next に設定。
  4. Initializer が存在し value が undefined なら
    1. IsAnonymousFunctionDefinition(Initializer) かつ IsIdentifierRef(DestructuringAssignmentTarget) が true なら
      1. target を DestructuringAssignmentTarget の StringValue。
      2. v を 引数 target で Initializer の NamedEvaluation。
    2. そうでなければ
      1. defaultValue を ? Initializer の Evaluation。
      2. v を ? GetValue(defaultValue)。
  5. そうでなければ
    1. v を value。
  6. DestructuringAssignmentTarget が ObjectLiteral または ArrayLiteral なら
    1. nestedAssignmentPattern を DestructuringAssignmentTarget が覆う AssignmentPattern。
    2. ? DestructuringAssignmentEvaluation(nestedAssignmentPattern, 引数 v) を返す。
  7. ? PutValue(lRef, v) を返す。
 Note

DestructuringAssignmentTarget がパターンでない場合にそれを先に評価してからイテレータアクセスや Initializer の評価を行うことで、左から右への評価順序を維持する。

 AssignmentRestElement : ... DestructuringAssignmentTarget
  1. DestructuringAssignmentTarget が ObjectLiteral / ArrayLiteral でないなら
    1. lRef を ? DestructuringAssignmentTarget の Evaluation。
  2. A を ! ArrayCreate(0)。
  3. n を 0。
  4. iteratorRecord.[[Done]] が false の間繰り返す
    1. next を ? IteratorStepValue(iteratorRecord)。
    2. next が done でなければ
      1. ! CreateDataPropertyOrThrow(A, ! ToString(𝔽(n)), next)。
      2. n を n + 1 に。
  5. DestructuringAssignmentTarget が ObjectLiteral / ArrayLiteral でないなら
    1. ? PutValue(lRef, A) を返す。
  6. nestedAssignmentPattern を DestructuringAssignmentTarget が覆う AssignmentPattern。
  7. ? DestructuringAssignmentEvaluation(nestedAssignmentPattern, 引数 A) を返す。

13.15.5.6 実行時セマンティクス: KeyedDestructuringAssignmentEvaluation : 正常完了で unused または突然の完了

The syntax-directed operation UNKNOWN takes UNPARSEABLE ARGUMENTS. It is defined piecewise over the following productions:

AssignmentElement : DestructuringAssignmentTarget Initializeropt
  1. DestructuringAssignmentTarget が ObjectLiteral / ArrayLiteral でないなら
    1. lRef を ? DestructuringAssignmentTarget の Evaluation。
  2. v を ? GetV(value, propertyName)。
  3. Initializer が存在し v が undefined なら
    1. IsAnonymousFunctionDefinition(Initializer) かつ IsIdentifierRef(DestructuringAssignmentTarget) が true なら
      1. target を DestructuringAssignmentTarget の StringValue。
      2. rhsValue を 引数 target で Initializer の NamedEvaluation。
    2. そうでなければ
      1. defaultValue を ? Initializer の Evaluation。
      2. rhsValue を ? GetValue(defaultValue)。
  4. そうでなければ
    1. rhsValue を v。
  5. DestructuringAssignmentTarget が ObjectLiteral または ArrayLiteral なら
    1. assignmentPattern を DestructuringAssignmentTarget が覆う AssignmentPattern。
    2. ? DestructuringAssignmentEvaluation(assignmentPattern, 引数 rhsValue) を返す。
  6. ? PutValue(lRef, rhsValue) を返す。

13.16 カンマ演算子 ( , ) (Comma Operator)

構文 (Syntax)

Expression[In, Yield, Await] : AssignmentExpression[?In, ?Yield, ?Await] Expression[?In, ?Yield, ?Await] , AssignmentExpression[?In, ?Yield, ?Await]

13.16.1 実行時セマンティクス: 評価 (Runtime Semantics: Evaluation)

Expression : Expression , AssignmentExpression
  1. lRef を ? Expression の Evaluation とする。
  2. ? GetValue(lRef) を実行する。
  3. rRef を ? AssignmentExpression の Evaluation とする。
  4. ? GetValue(rRef) を返す。
 Note

値は使用されないが、副作用が観測可能であるため GetValue を呼び出す必要がある。