13 ECMAScript Language: 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はgrammar内でBindingIdentifierとして許可され、以下のstatic semanticsで禁止されます。これは、次のような場合にautomatic semicolon insertionを禁止するためです

let
await 0;

13.1.1 Static Semantics: Early Errors

BindingIdentifier : Identifier
  • IsStrict(this production)がtrueであり、かつIdentifierのStringValueが"arguments"または"eval"のいずれかである場合、それはSyntax Errorです。
IdentifierReference : yield BindingIdentifier : yield LabelIdentifier : yield
  • IsStrict(this production)がtrueなら、それはSyntax Errorです。
IdentifierReference : await BindingIdentifier : await LabelIdentifier : await BindingIdentifier[Yield, Await] : yield
  • このproductionが[Yield] parameterを持つ場合、それはSyntax Errorです。
BindingIdentifier[Yield, Await] : await
  • このproductionが[Await] parameterを持つ場合、それはSyntax Errorです。
IdentifierReference[Yield, Await] : Identifier BindingIdentifier[Yield, Await] : Identifier LabelIdentifier[Yield, Await] : Identifier
  • このproductionが[Yield] parameterを持ち、かつIdentifierのStringValueが"yield"である場合、それはSyntax Errorです。
  • このproductionが[Await] parameterを持ち、かつIdentifierのStringValueが"await"である場合、それはSyntax Errorです。
Identifier : IdentifierName but not ReservedWord Note

IdentifierNameのStringValueはIdentifierName内の任意のUnicode escape sequencesをnormalizeするため、そのようなescapesを使用して、code point sequenceがReservedWordと同じであるIdentifierを書くことはできません。

13.1.2 Static Semantics: StringValue

The syntax-directed operation StringValue takes no arguments and returns a String. 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のstring-concatenationを返す。
 ModuleExportName : StringLiteral
  1. StringLiteralのSVを返す。

13.1.3 Runtime Semantics: Evaluation

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

IdentifierReferenceを評価した結果は常にReference型の値です。

 Note 2

non-strict codeでは、keyword yieldをidentifierとして使用できます。IdentifierReferenceを評価すると、yieldがIdentifierであったかのように、そのbindingがresolveされます。Early Error restrictionにより、そのような評価はnon-strict codeでのみ発生し得ることが保証されます。

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

production
PrimaryExpression[Yield, Await] : CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]
のinstanceを処理するとき、CoverParenthesizedExpressionAndArrowParameterListのinterpretationは次のgrammarを使用してrefineされます：

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

13.2.1 The this Keyword

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がtoken falseなら、falseを返す。
  2. BooleanLiteralがtoken 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は、square bracketsで囲まれた、array elementを表す0個以上のexpressionsのlistを使用して、Arrayのinitializationを記述するexpressionです。elementsはliteralsである必要はありません；それらはarray initializerが評価されるたびに評価されます。

Array elementsはelement listのbeginning、middle、またはendでelideされる場合があります。element list内のcommaの直前にAssignmentExpressionがない場合（すなわち、beginningのcomma、または別のcommaの後のcomma）、missing array elementはArrayのlengthに寄与し、後続elementsのindexを増加させます。Elided array elementsは定義されません。arrayのendでelementがelideされる場合、そのelementはArrayの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 Runtime Semantics: ArrayAccumulation

The syntax-directed operation ArrayAccumulation takes arguments array (an Array) and nextIndex (an integer) and returns either a normal completion containing an integer or an abrupt completion. It is defined piecewise over the following productions:

Elision : ,
  1. lengthをnextIndex + 1とする。
  2. ? Set(array, "length", 𝔽(length), true)を実行する。
  3. NOTE: 上記stepは、lengthが232 - 1を超える場合にthrowする。
  4. lengthを返す。
 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を伴うderived 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を伴うderived 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

CreateDataPropertyOrThrowは、standard built-in Array prototype objectが[[Set]]を使用した新しいown propertiesの作成を妨げるような方法で変更されている場合でも、arrayにown propertiesが定義されることを保証するために使用されます。

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

object initializerは、literalに似た形式で書かれた、Objectのinitializationを記述するexpressionです。これは、curly bracketsで囲まれた、0個以上のproperty keysと関連valuesのpairsのlistです。valuesはliteralsである必要はありません；それらはobject initializerが評価されるたびに評価されます。

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

特定のcontextsでは、ObjectLiteralはより制限されたsecondary grammarのcover grammarとして使用されます。CoverInitializedName productionは、これらのsecondary grammarsを完全にcoverするために必要です。ただし、このproductionの使用は、実際のObjectLiteralが期待されるnormal contextsではearly Syntax Errorをもたらします。

13.2.5.1 Static Semantics: Early Errors

PropertyDefinition : MethodDefinition

実際のobject initializerを記述することに加えて、ObjectLiteral productionsはObjectAssignmentPatternのcover grammarとしても使用され、CoverParenthesizedExpressionAndArrowParameterListの一部として認識される場合があります。ObjectAssignmentPatternが必要なcontextにObjectLiteralが現れる場合、次のEarly Error rulesは適用されません。さらに、それらはCoverParenthesizedExpressionAndArrowParameterListまたはCoverCallExpressionAndAsyncArrowHeadを最初にparseするときにも適用されません。

PropertyDefinition : CoverInitializedName
  • 任意のsource textがこのproductionによってmatchされる場合、それはSyntax Errorです。
Note 1

このproductionは、ObjectLiteralがObjectAssignmentPatternのcover grammarとして機能できるように存在します。これは実際のobject initializer内では出現できません。

 ObjectLiteral : { PropertyDefinitionList } { PropertyDefinitionList , } Note 2

PropertyNameListによって返されるListには、ComputedPropertyNameを使用して定義されたproperty namesは含まれません。

13.2.5.2 Static Semantics: IsComputedPropertyKey

The syntax-directed operation IsComputedPropertyKey takes no arguments and returns a Boolean. It is defined piecewise over the following productions:

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

13.2.5.3 Static Semantics: PropertyDefinitionNodes

The syntax-directed operation PropertyDefinitionNodes takes no arguments and returns a List of Parse Nodes. It is defined piecewise over the following productions:

ObjectLiteral : { }
  1. 新しい空のListを返す。
 PropertyDefinitionList : PropertyDefinition
  1. « PropertyDefinition »を返す。
 PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition
  1. headをderived PropertyDefinitionListのPropertyDefinitionNodesとする。
  2. headと« PropertyDefinition »のlist-concatenationを返す。

13.2.5.4 Static Semantics: PropertyNameList

The syntax-directed operation PropertyNameList takes no arguments and returns a List of Strings. It is defined piecewise over the following productions:

PropertyDefinitionList : PropertyDefinition
  1. propertyNameをPropertyDefinitionのPropNameとする。
  2. propertyNameがemptyなら、新しい空のListを返す。
  3. « propertyName »を返す。
 PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition
  1. listをPropertyDefinitionListのPropertyNameListとする。
  2. propertyNameをPropertyDefinitionのPropNameとする。
  3. propertyNameがemptyなら、listを返す。
  4. listと« propertyName »のlist-concatenationを返す。

13.2.5.5 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. numberをNumericLiteralのNumericValueとする。
  2. ! ToString(number)を返す。
 ComputedPropertyName : [ AssignmentExpression ]
  1. exprValueをAssignmentExpressionの ? Evaluationとする。
  2. propertyNameを ? GetValue(exprValue) とする。
  3. ? ToPropertyKey(propertyName)を返す。

13.2.5.6 Runtime Semantics: PropertyDefinitionEvaluation

The syntax-directed operation PropertyDefinitionEvaluation takes argument obj (an Object) and returns either a normal completion containing unused or an abrupt completion. It is defined piecewise over the following productions:

PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition
  1. 引数objを伴うPropertyDefinitionListの ? PropertyDefinitionEvaluationを実行する。
  2. 引数objを伴うPropertyDefinitionの ? PropertyDefinitionEvaluationを実行する。
  3. unusedを返す。
 PropertyDefinition : ... AssignmentExpression
  1. exprValueをAssignmentExpressionの ? Evaluationとする。
  2. fromValueを ? GetValue(exprValue) とする。
  3. excludedNamesを新しい空のListとする。
  4. ? CopyDataProperties(obj, fromValue, excludedNames)を実行する。
  5. unusedを返す。
 PropertyDefinition : IdentifierReference
  1. propertyNameをIdentifierReferenceのStringValueとする。
  2. exprValueをIdentifierReferenceの ? Evaluationとする。
  3. propertyValueを ? GetValue(exprValue) とする。
  4. Assert: objはordinaryでextensibleなobjectであり、non-configurable propertiesを持たない。
  5. ! CreateDataPropertyOrThrow(obj, propertyName, propertyValue)を実行する。
  6. unusedを返す。
 PropertyDefinition : PropertyName : AssignmentExpression
  1. propertyKeyをPropertyNameの ? Evaluationとする。
  2. このPropertyDefinitionがParseJSONのために評価されているScript内に含まれるなら（ParseJSONのstep 6を参照）、
    1. isProtoSetterをfalseとする。
  3. そうでなく、propertyKeyが"__proto__"であり、かつPropertyNameのIsComputedPropertyKeyがfalseなら、
    1. isProtoSetterをtrueとする。
  4. そうでなければ、
    1. isProtoSetterをfalseとする。
  5. IsAnonymousFunctionDefinition(AssignmentExpression)がtrueであり、かつisProtoSetterがfalseなら、
    1. propertyValueを、引数propertyKeyを伴うAssignmentExpressionの ? NamedEvaluationとする。
  6. そうでなければ、
    1. exprValueRefをAssignmentExpressionの ? Evaluationとする。
    2. propertyValueを ? GetValue(exprValueRef) とする。
  7. isProtoSetterがtrueなら、
    1. propertyValueがObjectまたはpropertyValueがnullなら、
      1. ! obj.[[SetPrototypeOf]](propertyValue)を実行する。
    2. unusedを返す。
  8. Assert: objはordinaryでextensibleなobjectであり、non-configurable propertiesを持たない。
  9. ! CreateDataPropertyOrThrow(obj, propertyKey, propertyValue)を実行する。
  10. unusedを返す。
 PropertyDefinition : MethodDefinition
  1. 引数objおよびtrueを伴うMethodDefinitionの ? MethodDefinitionEvaluationを実行する。
  2. unusedを返す。

13.2.6 Function Defining Expressions

PrimaryExpression : FunctionExpression については15.2を参照してください。

PrimaryExpression : GeneratorExpression については15.5を参照してください。

PrimaryExpression : ClassExpression については15.7を参照してください。

PrimaryExpression : AsyncFunctionExpression については15.8を参照してください。

PrimaryExpression : AsyncGeneratorExpression については15.6を参照してください。

13.2.7 Regular Expression Literals

Syntax

12.9.5を参照してください。

13.2.7.1 Static Semantics: Early Errors

PrimaryExpression : RegularExpressionLiteral

13.2.7.2 Static Semantics: IsValidRegularExpressionLiteral ( literal )

The abstract operation IsValidRegularExpressionLiteral takes argument literal (a RegularExpressionLiteral Parse Node) and returns a Boolean. これは、そのargumentがvalid regular expression literalであるかどうかを決定します。 It performs the following steps when called:

  1. flagsをliteralのFlagTextとする。
  2. flagsがd、g、i、m、s、u、v、またはy以外のcode pointsを含むなら、falseを返す。
  3. flagsが任意のcode pointを複数回含むなら、falseを返す。
  4. flagsがuを含むなら、uをtrueとする；そうでなければ、uをfalseとする。
  5. flagsがvを含むなら、vをtrueとする；そうでなければ、vをfalseとする。
  6. patternTextをliteralのBodyTextとする。
  7. uがfalseであり、かつvがfalseなら、
    1. stringValueをCodePointsToString(patternText)とする。
    2. patternTextを、stringValueの16-bit elementsのそれぞれをUnicode BMP code pointとして解釈した結果となるcode pointsのsequenceに設定する。UTF-16 decodingはelementsに適用されない。
  8. parseResultをParsePattern(patternText, u, v)とする。
  9. parseResultがParse Nodeなら、trueを返す。
  10. falseを返す。

13.2.7.3 Runtime Semantics: Evaluation

PrimaryExpression : RegularExpressionLiteral
  1. patternをCodePointsToString(RegularExpressionLiteralのBodyText)とする。
  2. flagsをCodePointsToString(RegularExpressionLiteralのFlagText)とする。
  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 Static Semantics: Early Errors

TemplateLiteral[Yield, Await, Tagged] : NoSubstitutionTemplate TemplateLiteral[Yield, Await, Tagged] : 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] : TemplateMiddle Expression[+In, ?Yield, ?Await] TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateMiddle Expression[+In, ?Yield, ?Await]

13.2.8.2 Static Semantics: TemplateStrings

The syntax-directed operation TemplateStrings takes argument raw (a Boolean) and returns a List of either Strings or undefined. 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を、argument rawを伴うTemplateSpansのTemplateStringsとする。
  3. headとtailのlist-concatenationを返す。
 TemplateSpans : TemplateTail
  1. « TemplateString(TemplateTail, raw) »を返す。
 TemplateSpans : TemplateMiddleList TemplateTail
  1. middleを、argument rawを伴うTemplateMiddleListのTemplateStringsとする。
  2. tailを« TemplateString(TemplateTail, raw) »とする。
  3. middleとtailのlist-concatenationを返す。
 TemplateMiddleList : TemplateMiddle Expression
  1. « TemplateString(TemplateMiddle, raw) »を返す。
 TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. frontを、argument rawを伴うTemplateMiddleListのTemplateStringsとする。
  2. lastを« TemplateString(TemplateMiddle, raw) »とする。
  3. frontとlastのlist-concatenationを返す。

13.2.8.3 Static Semantics: TemplateString ( templateToken, raw )

The abstract operation TemplateString takes arguments templateToken (a NoSubstitutionTemplate Parse Node, a TemplateHead Parse Node, a TemplateMiddle Parse Node, or a TemplateTail Parse Node) and raw (a Boolean) and returns a String or undefined. It performs the following steps when called:

  1. rawがtrueなら、
    1. stringをtemplateTokenのTRVとする。
  2. そうでなければ、
    1. stringをtemplateTokenのTVとする。
  3. stringを返す。
 Note

このoperationは、rawがfalseであり、かつtemplateTokenがNotEscapeSequenceを含む場合、undefinedを返します。それ以外の場合、Stringを返します。

13.2.8.4 GetTemplateObject ( templateLiteral )

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

  1. realmをcurrent Realm Recordとする。
  2. templateRegistryをrealm.[[TemplateMap]]とする。
  3. templateRegistryの各要素elementについて、以下を行う
    1. element.[[Site]]がtemplateLiteralと同じParse Nodeなら、
      1. element.[[Array]]を返す。
  4. rawStringsを、argument trueを伴うtemplateLiteralのTemplateStringsとする。
  5. Assert: rawStringsはStringsのListである。
  6. cookedStringsを、argument falseを伴うtemplateLiteralのTemplateStringsとする。
  7. countをList cookedStrings内のelements数とする。
  8. Assert: count ≤ 232 - 1.
  9. templateを ! ArrayCreate(count) とする。
  10. rawObjを ! ArrayCreate(count) とする。
  11. indexを0とする。
  12. index < countである間、繰り返す
    1. propertyKeyを ! ToString(𝔽(index)) とする。
    2. cookedValueをcookedStrings[index]とする。
    3. ! DefinePropertyOrThrow(template, propertyKey, PropertyDescriptor { [[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false })を実行する。
    4. rawValueをString値rawStrings[index]とする。
    5. ! DefinePropertyOrThrow(rawObj, propertyKey, 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]]へappendする。
  17. templateを返す。
 Note 1

template objectの作成はabrupt completionをもたらすことはありません。

 Note 2

realmのprogram code内の各TemplateLiteralには、tagged Templates（13.2.8.6）のevaluationで使用される一意なtemplate objectが関連付けられます。template objectsはfrozenであり、特定のtagged Templateが評価されるたびに同じtemplate objectが使用されます。template objectsがTemplateLiteralの初回評価時にlazilyに作成されるか、初回評価前にeagerlyに作成されるかは、ECMAScript codeから観測できないimplementation choiceです。

 Note 3

この仕様の将来のeditionsでは、template objectsの追加non-enumerable propertiesを定義する場合があります。

13.2.8.5 Runtime Semantics: SubstitutionEvaluation

The syntax-directed operation SubstitutionEvaluation takes no arguments and returns either a normal completion containing a List of ECMAScript language values or an abrupt completion. 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 »のlist-concatenationを返す。

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のstring-concatenationを返す。
 Note 1

Expression値に適用されるstring conversion semanticsは、+ operatorではなく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のstring-concatenationを返す。
 TemplateMiddleList : TemplateMiddle Expression
  1. headを12.9.6で定義されるTemplateMiddleのTVとする。
  2. subRefをExpressionの ? Evaluationとする。
  3. subを ? GetValue(subRef) とする。
  4. middleを ? ToString(sub) とする。
  5. headとmiddleのstring-concatenationを返す。
 Note 2

Expression値に適用されるstring conversion semanticsは、+ operatorではなく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のstring-concatenationを返す。
 Note 3

Expression値に適用されるstring conversion semanticsは、+ operatorではなくString.prototype.concatに似ています。

13.2.9 The Grouping Operator

13.2.9.1 Static Semantics: Early Errors

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

13.2.9.2 Runtime Semantics: Evaluation

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. exprをCoverParenthesizedExpressionAndArrowParameterListによってcoverされるParenthesizedExpressionとする。
  2. exprの ? Evaluationを返す。
 ParenthesizedExpression : ( Expression )
  1. Expressionの ? Evaluationを返す。これはReference型であり得る。
 Note

このalgorithmはExpressionのEvaluationにGetValueを適用しません。これの主要な動機は、deleteやtypeofなどのoperatorsをparenthesized expressionsに適用できるようにするためです。

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

production
CallExpression : CoverCallExpressionAndAsyncArrowHead
のinstanceを処理するとき、CoverCallExpressionAndAsyncArrowHeadのinterpretationは次のgrammarを使用してrefineされます：

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

13.3.1 Static Semantics

13.3.1.1 Static Semantics: Early Errors

OptionalChain : ?. TemplateLiteral OptionalChain TemplateLiteral
  • 任意のsource textがこのproductionによってmatchされる場合、それはSyntax Errorです。
Note

このproductionは、automatic semicolon insertion rules（12.10）が次のcodeに適用されることを防ぐために存在します：

a?.b
`c`

これにより、それが2つのvalid statementsとして解釈されることを防ぎます。目的は、optional chainingを使用しない類似のcodeとの一貫性を維持することです：

a.b
`c`

これはvalid statementであり、automatic semicolon insertionは適用されません。

 ImportMeta : import . meta

13.3.2 Property Accessors

Note

Propertiesは、dot notationを使用してnameによってaccessされます：

MemberExpression . IdentifierName
CallExpression . IdentifierName

またはbracket notationを使用します：

MemberExpression [ Expression ]
CallExpression [ Expression ]

dot notationは、次のsyntactic conversionによって説明されます：

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. baseRefをMemberExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. strictをIsStrict(this MemberExpression)とする。
  4. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict)を返す。
 MemberExpression : MemberExpression . IdentifierName
  1. baseRefをMemberExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. strictをIsStrict(this MemberExpression)とする。
  4. EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict)を返す。
 MemberExpression : MemberExpression . PrivateIdentifier
  1. baseRefをMemberExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. fieldNameStringをPrivateIdentifierのStringValueとする。
  4. MakePrivateReference(baseValue, fieldNameString)を返す。
 CallExpression : CallExpression [ Expression ]
  1. baseRefをCallExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. strictをIsStrict(this CallExpression)とする。
  4. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression, strict)を返す。
 CallExpression : CallExpression . IdentifierName
  1. baseRefをCallExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. strictをIsStrict(this CallExpression)とする。
  4. EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName, strict)を返す。
 CallExpression : CallExpression . PrivateIdentifier
  1. baseRefをCallExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. fieldNameStringをPrivateIdentifierのStringValueとする。
  4. MakePrivateReference(baseValue, fieldNameString)を返す。

13.3.3 EvaluatePropertyAccessWithExpressionKey ( baseValue, expr, strict )

The abstract operation EvaluatePropertyAccessWithExpressionKey takes arguments baseValue (an ECMAScript language value), expr (an Expression Parse Node), and strict (a Boolean) and returns either a normal completion containing a Reference Record or an abrupt completion. It performs the following steps when called:

  1. propertyNameRefをexprの ? Evaluationとする。
  2. propertyNameValueを ? GetValue(propertyNameRef) とする。
  3. NOTE: ほとんどの場合、ToPropertyKeyはこのstepの直後に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 (an ECMAScript language value), identifierName (an IdentifierName Parse Node), and strict (a Boolean) and returns a 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 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, argumentsNode )

The abstract operation EvaluateNew takes arguments constructExpr (a NewExpression Parse Node or a MemberExpression Parse Node) and argumentsNode (empty or an Arguments Parse Node) and returns either a normal completion containing an Object or an abrupt completion. It performs the following steps when called:

  1. refをconstructExprの ? Evaluationとする。
  2. ctorを ? GetValue(ref) とする。
  3. argumentsNodeがemptyなら、
    1. argListを新しい空のListとする。
  4. そうでなければ、
    1. argListをargumentsNodeの ? ArgumentListEvaluationとする。
  5. IsConstructor(ctor)がfalseなら、TypeError例外をthrowする。
  6. ? Construct(ctor, argList)を返す。

13.3.6 Function Calls

13.3.6.1 Runtime Semantics: Evaluation

CallExpression : CoverCallExpressionAndAsyncArrowHead
  1. exprをCoverCallExpressionAndAsyncArrowHeadによってcoverされるCallMemberExpressionとする。
  2. memberExprをexprのMemberExpressionとする。
  3. argsを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をargsの ? ArgumentListEvaluationとする。
      2. argListがelementsを持たないなら、undefinedを返す。
      3. evalArgをargListの最初のelementとする。
      4. IsStrict(this CallExpression)がtrueなら、strictCallerをtrueとする；そうでなければ、strictCallerをfalseとする。
      5. ? PerformEval(evalArg, strictCaller, true)を返す。
  7. thisCallをthis CallExpressionとする。
  8. tailCallをIsInTailPosition(thisCall)とする。
  9. ? EvaluateCall(func, ref, args, tailCall)を返す。

step 6.a.vを実行するCallExpression evaluationは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, thisValueRef, argumentListNode, tailPosition )

The abstract operation EvaluateCall takes arguments func (an ECMAScript language value), thisValueRef (an ECMAScript language value or a Reference Record), argumentListNode (a Parse Node), and tailPosition (a Boolean) and returns either a normal completion containing an ECMAScript language value or an abrupt completion. It performs the following steps when called:

  1. thisValueRefがReference Recordなら、
    1. IsPropertyReference(thisValueRef)がtrueなら、
      1. thisValueをGetThisValue(thisValueRef)とする。
    2. そうでなければ、
      1. refEnvをthisValueRef.[[Base]]とする。
      2. Assert: refEnvはEnvironment Recordである。
      3. thisValueをrefEnv.WithBaseObject()とする。
  2. そうでなければ、
    1. thisValueをundefinedとする。
  3. argListをargumentListNodeの ? ArgumentListEvaluationとする。
  4. funcがObjectでないなら、TypeError例外をthrowする。
  5. IsCallable(func)がfalseなら、TypeError例外をthrowする。
  6. tailPositionがtrueなら、PrepareForTailCall()を実行する。
  7. ? Call(func, thisValue, argList)を返す。

13.3.7 The super Keyword

13.3.7.1 Runtime Semantics: Evaluation

SuperProperty : super [ Expression ]
  1. envRecordをGetThisEnvironment()とする。
  2. actualThisを ? envRecord.GetThisBinding() とする。
  3. propertyNameRefをExpressionの ? Evaluationとする。
  4. propertyNameValueを ? GetValue(propertyNameRef) とする。
  5. strictをIsStrict(this SuperProperty)とする。
  6. NOTE: ほとんどの場合、ToPropertyKeyはこのstepの直後にpropertyNameValueに対して実行される。しかし、super[b] = cの場合には、cの評価後まで実行されない。
  7. MakeSuperPropertyReference(actualThis, propertyNameValue, strict)を返す。
 SuperProperty : super . IdentifierName
  1. envRecordをGetThisEnvironment()とする。
  2. actualThisを ? envRecord.GetThisBinding() とする。
  3. propertyKeyをIdentifierNameのStringValueとする。
  4. strictをIsStrict(this SuperProperty)とする。
  5. MakeSuperPropertyReference(actualThis, propertyKey, strict)を返す。
 SuperCall : super Arguments
  1. newTargetをGetNewTarget()とする。
  2. Assert: newTargetはconstructorである。
  3. superCtorをGetSuperConstructor()とする。
  4. argListをArgumentsの ? ArgumentListEvaluationとする。
  5. IsConstructor(superCtor)がfalseなら、TypeError例外をthrowする。
  6. resultを ? Construct(superCtor, argList, newTarget) とする。
  7. thisERをGetThisEnvironment()とする。
  8. Assert: thisERはFunction Environment Recordである。
  9. ? BindThisValue(thisER, result)を実行する。
  10. funcObjをthisER.[[FunctionObject]]とする。
  11. Assert: funcObjはECMAScript function objectである。
  12. ? InitializeInstanceElements(result, funcObj)を実行する。
  13. resultを返す。

13.3.7.2 GetSuperConstructor ( )

The abstract operation GetSuperConstructor takes no arguments and returns an Object or null. It performs the following steps when called:

  1. envRecordをGetThisEnvironment()とする。
  2. Assert: envRecordはFunction Environment Recordである。
  3. activeFuncをenvRecord.[[FunctionObject]]とする。
  4. Assert: activeFuncはECMAScript function objectである。
  5. superCtorを ! activeFunc.[[GetPrototypeOf]]() とする。
  6. superCtorを返す。

13.3.7.3 MakeSuperPropertyReference ( actualThis, propertyKey, strict )

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

  1. envRecordをGetThisEnvironment()とする。
  2. Assert: envRecord.HasSuperBinding()はtrueである。
  3. Assert: envRecordはFunction Environment Recordである。
  4. baseValueをGetSuperBase(envRecord)とする。
  5. Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis }を返す。

13.3.8 Argument Lists

Note

argument listのevaluationはvaluesのListを生成します。

13.3.8.1 Runtime Semantics: ArgumentListEvaluation

The syntax-directed operation ArgumentListEvaluation takes no arguments and returns either a normal completion containing a List of ECMAScript language values or an abrupt completion. 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へappendする。
 ArgumentList : ArgumentList , AssignmentExpression
  1. precedingArgsをArgumentListの ? ArgumentListEvaluationとする。
  2. refをAssignmentExpressionの ? Evaluationとする。
  3. argを ? GetValue(ref) とする。
  4. precedingArgsと« arg »のlist-concatenationを返す。
 ArgumentList : ArgumentList , ... AssignmentExpression
  1. precedingArgsをArgumentListの ? ArgumentListEvaluationとする。
  2. spreadRefをAssignmentExpressionの ? Evaluationとする。
  3. iteratorRecordを ? GetIterator(? GetValue(spreadRef), sync) とする。
  4. 繰り返す
    1. nextを ? IteratorStepValue(iteratorRecord) とする。
    2. nextがdoneなら、precedingArgsを返す。
    3. nextをprecedingArgsへappendする。
 TemplateLiteral : NoSubstitutionTemplate
  1. templateLiteralをthis TemplateLiteralとする。
  2. siteObjをGetTemplateObject(templateLiteral)とする。
  3. « siteObj »を返す。
 TemplateLiteral : SubstitutionTemplate
  1. templateLiteralをthis TemplateLiteralとする。
  2. siteObjをGetTemplateObject(templateLiteral)とする。
  3. remainingをSubstitutionTemplateの ? ArgumentListEvaluationとする。
  4. « siteObj »とremainingのlist-concatenationを返す。
 SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. firstSubRefをExpressionの ? Evaluationとする。
  2. firstSubを ? GetValue(firstSubRef) とする。
  3. restSubをTemplateSpansの ? SubstitutionEvaluationとする。
  4. Assert: restSubはpossibly empty Listである。
  5. « firstSub »とrestSubのlist-concatenationを返す。

13.3.9 Optional Chains

Note
optional chainは、1つ以上のproperty accessesおよびfunction callsのchainであり、その最初のものがtoken ?.で始まります。

13.3.9.1 Runtime Semantics: Evaluation

OptionalExpression : MemberExpression OptionalChain
  1. baseRefをMemberExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. baseValueがundefinedまたはnullのいずれかなら、
    1. undefinedを返す。
  4. 引数baseValueおよびbaseRefを伴うOptionalChainの ? ChainEvaluationを返す。
 OptionalExpression : CallExpression OptionalChain
  1. baseRefをCallExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. baseValueがundefinedまたはnullのいずれかなら、
    1. undefinedを返す。
  4. 引数baseValueおよびbaseRefを伴うOptionalChainの ? ChainEvaluationを返す。
 OptionalExpression : OptionalExpression OptionalChain
  1. baseRefをOptionalExpressionの ? Evaluationとする。
  2. baseValueを ? GetValue(baseRef) とする。
  3. baseValueがundefinedまたはnullのいずれかなら、
    1. undefinedを返す。
  4. 引数baseValueおよびbaseRefを伴うOptionalChainの ? ChainEvaluationを返す。

13.3.9.2 Runtime Semantics: ChainEvaluation

The syntax-directed operation ChainEvaluation takes arguments baseValue (an ECMAScript language value) and baseRef (an ECMAScript language value or a Reference Record) and returns either a normal completion containing either an ECMAScript language value or a Reference Record, or an abrupt completion. It is defined piecewise over the following productions:

OptionalChain : ?. Arguments
  1. thisChainをthis OptionalChainとする。
  2. tailCallをIsInTailPosition(thisChain)とする。
  3. ? EvaluateCall(baseValue, baseRef, 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. newRefを、引数baseValueおよびbaseRefを伴うoptionalChainの ? ChainEvaluationとする。
  3. newValueを ? GetValue(newRef) とする。
  4. thisChainをthis OptionalChainとする。
  5. tailCallをIsInTailPosition(thisChain)とする。
  6. ? EvaluateCall(newValue, newRef, Arguments, tailCall)を返す。
 OptionalChain : OptionalChain [ Expression ]
  1. optionalChainをOptionalChainとする。
  2. newRefを、引数baseValueおよびbaseRefを伴うoptionalChainの ? ChainEvaluationとする。
  3. newValueを ? GetValue(newRef) とする。
  4. strictをIsStrict(this OptionalChain)とする。
  5. ? EvaluatePropertyAccessWithExpressionKey(newValue, Expression, strict)を返す。
 OptionalChain : OptionalChain . IdentifierName
  1. optionalChainをOptionalChainとする。
  2. newRefを、引数baseValueおよびbaseRefを伴うoptionalChainの ? ChainEvaluationとする。
  3. newValueを ? GetValue(newRef) とする。
  4. strictをIsStrict(this OptionalChain)とする。
  5. EvaluatePropertyAccessWithIdentifierKey(newValue, IdentifierName, strict)を返す。
 OptionalChain : OptionalChain . PrivateIdentifier
  1. optionalChainをOptionalChainとする。
  2. newRefを、引数baseValueおよびbaseRefを伴うoptionalChainの ? ChainEvaluationとする。
  3. newValueを ? GetValue(newRef) とする。
  4. fieldNameStringをPrivateIdentifierのStringValueとする。
  5. MakePrivateReference(newValue, fieldNameString)を返す。

13.3.10 Import Calls

13.3.10.1 Runtime Semantics: Evaluation

ImportCall : import ( AssignmentExpression ,opt )
  1. ? EvaluateImportCall(AssignmentExpression)を返す。
 ImportCall : import ( AssignmentExpression , AssignmentExpression ,opt )
  1. ? EvaluateImportCall(最初のAssignmentExpression, 2番目のAssignmentExpression)を返す。

13.3.10.2 EvaluateImportCall ( specifierExpr [ , optionsExpr ] )

The abstract operation EvaluateImportCall takes argument specifierExpr (a Parse Node) and optional argument optionsExpr (a Parse Node) and returns either a normal completion containing a Promise or an abrupt completion. It performs the following steps when called:

  1. referrerをGetActiveScriptOrModule()とする。
  2. referrerがnullなら、referrerをcurrent Realm Recordに設定する。
  3. specifierRefをspecifierExprの ? Evaluationとする。
  4. specifierを ? GetValue(specifierRef) とする。
  5. optionsExprが存在するなら、
    1. optionsRefをoptionsExprの ? Evaluationとする。
    2. optionsを ? GetValue(optionsRef) とする。
  6. そうでなければ、
    1. optionsをundefinedとする。
  7. promiseCapabilityを ! NewPromiseCapability(%Promise%) とする。
  8. specifierStringをCompletion(ToString(specifier))とする。
  9. IfAbruptRejectPromise(specifierString, promiseCapability).
  10. attrsを新しい空のListとする。
  11. optionsがundefinedでないなら、
    1. optionsがObjectでないなら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « 新しく作成されたTypeError object »)を実行する。
      2. promiseCapability.[[Promise]]を返す。
    2. attrsObjをCompletion(Get(options, "with")))とする。
    3. IfAbruptRejectPromise(attrsObj, promiseCapability).
    4. attrsObjがundefinedでないなら、
      1. attrsObjがObjectでないなら、
        1. ! Call(promiseCapability.[[Reject]], undefined, « 新しく作成されたTypeError object »)を実行する。
        2. promiseCapability.[[Promise]]を返す。
      2. entriesをCompletion(EnumerableOwnProperties(attrsObj, 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 object »)を実行する。
            2. promiseCapability.[[Promise]]を返す。
          2. ImportAttribute Record { [[Key]]: key, [[Value]]: value }をattrsへappendする。
    5. AllImportAttributesSupported(attrs)がfalseなら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « 新しく作成されたTypeError object »)を実行する。
      2. promiseCapability.[[Promise]]を返す。
    6. attrsを、その[[Key]] fieldのlexicographic orderに従ってsortし、そのような各fieldの値をUTF-16 code unit valuesのsequenceとして扱う。NOTE: このsortingは、hostsがattributesのenumerated順序に基づいてbehaviourを変更することを禁止されているという点でのみobservableです。
  12. moduleRequestを新しいModuleRequest Record { [[Specifier]]: specifierString, [[Attributes]]: attrs }とする。
  13. HostLoadImportedModule(referrer, moduleRequest, empty, promiseCapability)を実行する。
  14. promiseCapability.[[Promise]]を返す。

13.3.10.3 ContinueDynamicImport ( promiseCapability, moduleCompletion )

The abstract operation ContinueDynamicImport takes arguments promiseCapability (a PromiseCapability Record) and moduleCompletion (either a normal completion containing a Module Record or a throw completion) and returns unused. これは、import() callによって最初に開始されたdynamic importのprocessを完了し、そのcallによって返されたpromiseを適切にresolveまたはrejectします。 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. promiseCapabilityをcaptureし、呼び出されたときに次のstepsを実行する、parameters (reason)を持つ新しいAbstract ClosureとしてrejectedClosureを作成する：
    1. ! Call(promiseCapability.[[Reject]], undefined, « reason »)を実行する。
    2. NormalCompletion(undefined)を返す。
  5. onRejectedをCreateBuiltinFunction(rejectedClosure, 1, "", « »)とする。
  6. module、promiseCapability、およびonRejectedをcaptureし、呼び出されたときに次のstepsを実行する、parametersを持たない新しいAbstract ClosureとしてlinkAndEvaluateClosureを作成する：
    1. linkをCompletion(module.Link())とする。
    2. linkがabrupt completionなら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « link.[[Value]] »)を実行する。
      2. NormalCompletion(undefined)を返す。
    3. evaluatePromiseをmodule.Evaluate()とする。
    4. moduleおよびpromiseCapabilityをcaptureし、呼び出されたときに次のstepsを実行する、parametersを持たない新しいAbstract ClosureとしてfulfilledClosureを作成する：
      1. namespaceをGetModuleNamespace(module)とする。
      2. ! Call(promiseCapability.[[Resolve]], undefined, « namespace »)を実行する。
      3. 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

tagged templateは、そのcallのargumentsがTemplateLiteral（13.2.8）からderivedされるfunction callです。実際のargumentsには、template object（13.2.8.4）と、TemplateLiteral内に埋め込まれたexpressionsを評価することによって生成されるvaluesが含まれます。

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. Assert: moduleはSource Text Module Recordである。
  3. importMetaをmodule.[[ImportMeta]]とする。
  4. importMetaがemptyなら、
    1. importMetaをOrdinaryObjectCreate(null)に設定する。
    2. importMetaValuesをHostGetImportMetaProperties(module)とする。
    3. importMetaValuesの各Record { [[Key]], [[Value]] } entryについて、以下を行う
      1. ! CreateDataPropertyOrThrow(importMeta, entry.[[Key]], entry.[[Value]])を実行する。
    4. HostFinalizeImportMeta(importMeta, module)を実行する。
    5. module.[[ImportMeta]]をimportMetaに設定する。
    6. importMetaを返す。
  5. Assert: importMetaはObjectである。
  6. importMetaを返す。

13.3.12.1.1 HostGetImportMetaProperties ( moduleRecord )

The host-defined abstract operation HostGetImportMetaProperties takes argument moduleRecord (a Module Record) and returns a List of Records with fields [[Key]] (a property key) and [[Value]] (an ECMAScript language value). これは、hostsがimport.metaから返されるobjectにproperty keysおよびvaluesを提供できるようにします。

HostGetImportMetaPropertiesのdefault implementationは、新しい空のListを返すことです。

13.3.12.1.2 HostFinalizeImportMeta ( importMeta, moduleRecord )

The host-defined abstract operation HostFinalizeImportMeta takes arguments importMeta (an Object) and moduleRecord (a Module Record) and returns unused. これは、hostsがimport.metaから返されるobjectを準備するために任意のextraordinary operationsを実行できるようにします。

ほとんどのhostsは単にHostGetImportMetaPropertiesを定義し、HostFinalizeImportMetaはそのdefault behaviourのままにできます。ただし、HostFinalizeImportMetaは、ECMAScript codeにexposedされる前にobjectを直接manipulateする必要があるhostsのための“escape hatch”を提供します。

HostFinalizeImportMetaのdefault implementationは、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

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例外をthrowする。
  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例外をthrowする。
  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例外をthrowする。
  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例外をthrowする。
  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] CoverAwaitExpressionAndAwaitUsingDeclarationHead[?Yield] CoverAwaitExpressionAndAwaitUsingDeclarationHead[Yield] : await UnaryExpression[?Yield, +Await]

補足構文

生成規則のインスタンスを処理する際
UnaryExpression : CoverAwaitExpressionAndAwaitUsingDeclarationHead
CoverAwaitExpressionAndAwaitUsingDeclarationHead の解釈は、次の文法を使用して精緻化される:

AwaitExpression[Yield] : await UnaryExpression[?Yield, +Await]

13.5.1 The delete Operator

13.5.1.1 Static Semantics: Early Errors

UnaryExpression : delete UnaryExpression Note

最後のruleは、delete (((foo)))のようなexpressionsが、最初のruleのrecursive applicationによりearly errorsを生じることを意味します。

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例外をthrowする。
    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例外をthrowする。
    7. deleteStatusを返す。
  5. baseをref.[[Base]]とする。
  6. Assert: baseはEnvironment Recordである。
  7. ? base.DeleteBinding(ref.[[ReferencedName]])を返す。
 Note 1

delete operatorがstrict mode code内に出現すると、そのUnaryExpressionがvariable、function argument、またはfunction nameへのdirect referenceである場合、SyntaxError例外がthrowされます。さらに、delete operatorがstrict mode code内に出現し、削除されるpropertyがattribute { [[Configurable]]: false }を持つ（またはその他の理由で削除できない）場合、TypeError例外がthrowされます。

 Note 2

step 4.cで作成される可能性のあるobjectは、上記abstract operationおよびordinary object [[Delete]] internal methodの外部からはaccessできません。実装は、そのobjectの実際の作成を避けることを選択してもよいです。

13.5.2 The void Operator

13.5.2.1 Runtime Semantics: Evaluation

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

その値は使用されませんが、observable side-effectsを持つ場合があるため、GetValueは呼び出されなければなりません。

13.5.3 The typeof Operator

13.5.3.1 Runtime Semantics: Evaluation

UnaryExpression : typeof UnaryExpression
  1. valueをUnaryExpressionの ? Evaluationとする。
  2. valueがReference Recordなら、
    1. IsUnresolvableReference(value)がtrueなら、"undefined"を返す。
  3. valueを ? GetValue(value) に設定する。
  4. valueがundefinedなら、"undefined"を返す。
  5. valueがnullなら、"object"を返す。
  6. valueがStringなら、"string"を返す。
  7. valueがSymbolなら、"symbol"を返す。
  8. valueがBooleanなら、"boolean"を返す。
  9. valueがNumberなら、"number"を返す。
  10. valueがBigIntなら、"bigint"を返す。
  11. Assert: valueはObjectである。
  12. Normative Optional
    hostがweb browserである、またはその他の形で[[IsHTMLDDA]] Internal Slotをサポートするなら、
    1. valueが[[IsHTMLDDA]] internal slotを持つなら、"undefined"を返す。
  13. valueが[[Call]] internal methodを持つなら、"function"を返す。
  14. "object"を返す。

13.5.4 Unary + Operator

Note

unary + operatorは、そのoperandをNumber typeへ変換します。

13.5.4.1 Runtime Semantics: Evaluation

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

13.5.5 Unary - Operator

Note

unary - operatorは、そのoperandをnumeric valueへ変換し、その後それをnegateします。+0𝔽をnegateすると-0𝔽が生成され、-0𝔽をnegateすると+0𝔽が生成されます。

13.5.5.1 Runtime Semantics: Evaluation

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

13.5.6 Bitwise NOT Operator ( ~ )

13.5.6.1 Runtime Semantics: Evaluation

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

13.5.7 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
  • * operatorはmultiplicationを実行し、そのoperandsのproductを生成します。
  • / operatorはdivisionを実行し、そのoperandsのquotientを生成します。
  • % operatorは、暗黙のdivisionからそのoperandsのremainderを生成します。

13.7.1 Runtime Semantics: Evaluation

MultiplicativeExpression : MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
  1. opTextをMultiplicativeOperatorによってmatchされたsource textとする。
  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

addition operatorは、string concatenationまたはnumeric additionのいずれかを実行します。

13.8.1.1 Runtime Semantics: Evaluation

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

13.8.2 The Subtraction Operator ( - )

Note

- operatorはsubtractionを実行し、そのoperandsのdifferenceを生成します。

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

right operandによって指定された量だけ、left operandに対してbitwise left shift operationを実行します。

13.9.1.1 Runtime Semantics: Evaluation

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

13.9.2 The Signed Right Shift Operator ( >> )

Note

right operandによって指定された量だけ、left operandに対してsign-filling bitwise right shift operationを実行します。

13.9.2.1 Runtime Semantics: Evaluation

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

13.9.3 The Unsigned Right Shift Operator ( >>> )

Note

right operandによって指定された量だけ、left operandに対してzero-filling bitwise right shift operationを実行します。

13.9.3.1 Runtime Semantics: Evaluation

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

13.10 Relational Operators

Note 1

relational operatorを評価した結果は常にBoolean型であり、そのoperatorによって名付けられた関係が2つのoperandsの間に成り立つかどうかを反映します。

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] grammar parameterは、relational expression内のin operatorとfor statement内のin operatorを混同することを避けるために必要です。

13.10.1 Runtime Semantics: Evaluation

RelationalExpression : RelationalExpression < ShiftExpression
  1. leftRefをRelationalExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをShiftExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. resultを ? IsLessThan(leftValue, rightValue, true) とする。
  6. resultがundefinedなら、falseを返す。
  7. resultを返す。
 RelationalExpression : RelationalExpression > ShiftExpression
  1. leftRefをRelationalExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをShiftExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. resultを ? IsLessThan(rightValue, leftValue, false) とする。
  6. resultがundefinedなら、falseを返す。
  7. resultを返す。
 RelationalExpression : RelationalExpression <= ShiftExpression
  1. leftRefをRelationalExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをShiftExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. resultを ? IsLessThan(rightValue, leftValue, false) とする。
  6. resultがtrueまたはundefinedのいずれかなら、falseを返す。
  7. trueを返す。
 RelationalExpression : RelationalExpression >= ShiftExpression
  1. leftRefをRelationalExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをShiftExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. resultを ? IsLessThan(leftValue, rightValue, true) とする。
  6. resultがtrueまたはundefinedのいずれかなら、falseを返す。
  7. trueを返す。
 RelationalExpression : RelationalExpression instanceof ShiftExpression
  1. leftRefをRelationalExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをShiftExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. ? InstanceofOperator(leftValue, rightValue)を返す。
 RelationalExpression : RelationalExpression in ShiftExpression
  1. leftRefをRelationalExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをShiftExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. rightValueがObjectでないなら、TypeError例外をthrowする。
  6. ? HasProperty(rightValue, ? ToPropertyKey(leftValue))を返す。
 RelationalExpression : PrivateIdentifier in ShiftExpression
  1. privateIdentifierをPrivateIdentifierのStringValueとする。
  2. rightRefをShiftExpressionの ? Evaluationとする。
  3. rightValueを ? GetValue(rightRef) とする。
  4. rightValueがObjectでないなら、TypeError例外をthrowする。
  5. privateEnvをrunning execution contextのPrivateEnvironmentとする。
  6. Assert: privateEnvはnullでない。
  7. privateNameをResolvePrivateIdentifier(privateEnv, privateIdentifier)とする。
  8. PrivateElementFind(rightValue, privateName)がemptyなら、falseを返す。
  9. trueを返す。

13.10.2 InstanceofOperator ( value, target )

The abstract operation InstanceofOperator takes arguments value (an ECMAScript language value) and target (an ECMAScript language value) and returns either a normal completion containing a Boolean or a throw completion. これは、targetの%Symbol.hasInstance% methodをconsultすることによって、またはそれが存在しない場合には、targetの"prototype" propertyの値がvalueのprototype chain内に存在するかどうかを判定することによって、valueがtargetのinstanceであるかどうかを判定するgeneric algorithmを実装します。 It performs the following steps when called:

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

Steps 4および5は、instanceof operator semanticsを定義するために%Symbol.hasInstance% methodを使用しなかったECMAScriptの以前のeditionsとのcompatibilityを提供します。objectが%Symbol.hasInstance%を定義または継承していない場合、default instanceof semanticsを使用します。

13.11 Equality Operators

Note

equality operatorを評価した結果は常にBoolean型であり、そのoperatorによって名付けられた関係が2つのoperandsの間に成り立つかどうかを反映します。

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. leftRefをEqualityExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをRelationalExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. ? IsLooselyEqual(rightValue, leftValue)を返す。
 EqualityExpression : EqualityExpression != RelationalExpression
  1. leftRefをEqualityExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをRelationalExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. resultを ? IsLooselyEqual(rightValue, leftValue) とする。
  6. resultがtrueなら、falseを返す。
  7. trueを返す。
 EqualityExpression : EqualityExpression === RelationalExpression
  1. leftRefをEqualityExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをRelationalExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. IsStrictlyEqual(rightValue, leftValue)を返す。
 EqualityExpression : EqualityExpression !== RelationalExpression
  1. leftRefをEqualityExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをRelationalExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. resultをIsStrictlyEqual(rightValue, leftValue)とする。
  6. resultがtrueなら、falseを返す。
  7. trueを返す。
 Note 1

equality operatorsは次のinvariantsを維持します：

  • A != Bは!(A == B)と等価です。
  • A == Bは、AおよびBのevaluation順序を除き、B == Aと等価です。
Note 2

equality operatorは常にtransitiveであるとは限りません。例えば、同じString値を表す2つのdistinct String objectsが存在する場合があります；各String objectは== operatorによってString値と等しいとみなされますが、2つのString objectsは互いに等しいとはみなされません。例えば：

  • new String("a") == "a"および"a" == new String("a")はいずれもtrueです。
  • new String("a") == new String("a")はfalseです。
Note 3

Stringsのcomparisonは、code unit valuesのsequencesに対する単純なequality testを使用します。Unicode specificationで定義される、より複雑でsemantically orientedなcharacterまたはstring equalityおよびcollating orderのdefinitionsを使用する試みはありません。したがって、Unicode Standardに従ってcanonically equalであるStrings valuesが、unequalとしてtestされる可能性があります。実際には、このalgorithmは両方のStringsがすでにnormalized formにあると仮定します。

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

&&または|| operatorによって生成される値は、必ずしもBoolean型ではありません。生成される値は常に2つのoperand expressionsのいずれかの値になります。

13.13.1 Runtime Semantics: Evaluation

LogicalANDExpression : LogicalANDExpression && BitwiseORExpression
  1. leftRefをLogicalANDExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. ToBoolean(leftValue)がfalseなら、leftValueを返す。
  4. rightRefをBitwiseORExpressionの ? Evaluationとする。
  5. ? GetValue(rightRef)を返す。
 LogicalORExpression : LogicalORExpression || LogicalANDExpression
  1. leftRefをLogicalORExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. ToBoolean(leftValue)がtrueなら、leftValueを返す。
  4. rightRefをLogicalANDExpressionの ? Evaluationとする。
  5. ? GetValue(rightRef)を返す。
 CoalesceExpression : CoalesceExpressionHead ?? BitwiseORExpression
  1. leftRefをCoalesceExpressionHeadの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. leftValueがundefinedでもnullでもないなら、leftValueを返す。
  4. rightRefをBitwiseORExpressionの ? Evaluationとする。
  5. ? GetValue(rightRef)を返す。

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のgrammarは、CおよびJavaのものとはわずかに異なります。CおよびJavaでは、second subexpressionがExpressionであることを許可しますが、third expressionはConditionalExpressionに制限します。ECMAScriptでこの違いがある動機は、assignment expressionがconditionalのいずれのarmによってもgovernedできるようにし、centre expressionとしてのcomma expressionという紛らわしく、かなり役に立たないcaseを排除するためです。

13.14.1 Runtime Semantics: Evaluation

ConditionalExpression : ShortCircuitExpression ? AssignmentExpression : AssignmentExpression
  1. leftRefをShortCircuitExpressionの ? Evaluationとする。
  2. leftValueをToBoolean(? GetValue(leftRef))とする。
  3. leftValueがtrueなら、
    1. trueRefを最初のAssignmentExpressionの ? Evaluationとする。
    2. ? GetValue(trueRef)を返す。
  4. falseRefを2番目のAssignmentExpressionの ? Evaluationとする。
  5. ? 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. leftRefをLeftHandSideExpressionの ? Evaluationとする。
    2. LeftHandSideExpressionのAssignmentTargetTypeがweb-compatなら、ReferenceError例外をthrowする。
    3. IsAnonymousFunctionDefinition(AssignmentExpression)がtrueであり、かつLeftHandSideExpressionのIsIdentifierRefがtrueなら、
      1. lhsをLeftHandSideExpressionのStringValueとする。
      2. rightValueを、引数lhsを伴うAssignmentExpressionの ? NamedEvaluationとする。
    4. そうでなければ、
      1. rightRefをAssignmentExpressionの ? Evaluationとする。
      2. rightValueを ? GetValue(rightRef) とする。
    5. ? PutValue(leftRef, rightValue)を実行する。
    6. rightValueを返す。
  2. assignmentPatternをLeftHandSideExpressionによってcoverされるAssignmentPatternとする。
  3. rightRefをAssignmentExpressionの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. 引数rightValueを伴うassignmentPatternの ? DestructuringAssignmentEvaluationを実行する。
  6. rightValueを返す。
 AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
  1. leftRefをLeftHandSideExpressionの ? Evaluationとする。
  2. LeftHandSideExpressionのAssignmentTargetTypeがweb-compatなら、ReferenceError例外をthrowする。
  3. leftValueを ? GetValue(leftRef) とする。
  4. rightRefをAssignmentExpressionの ? Evaluationとする。
  5. rightValueを ? GetValue(rightRef) とする。
  6. assignmentOpTextをAssignmentOperatorによってmatchされたsource textとする。
  7. opTextを、次のtable内でassignmentOpTextに関連付けられたUnicode code pointsのsequenceとする：
    assignmentOpText opText
    **= **
    *= *
    /= /
    %= %
    += +
    -= -
    <<= <<
    >>= >>
    >>>= >>>
    &= &
    ^= ^
    |= |
  8. resultを ? ApplyStringOrNumericBinaryOperator(leftValue, opText, rightValue) とする。
  9. ? PutValue(leftRef, result)を実行する。
  10. resultを返す。
 AssignmentExpression : LeftHandSideExpression &&= AssignmentExpression
  1. leftRefをLeftHandSideExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. ToBoolean(leftValue)がfalseなら、leftValueを返す。
  4. IsAnonymousFunctionDefinition(AssignmentExpression)がtrueであり、かつLeftHandSideExpressionのIsIdentifierRefがtrueなら、
    1. lhsをLeftHandSideExpressionのStringValueとする。
    2. rightValueを、引数lhsを伴うAssignmentExpressionの ? NamedEvaluationとする。
  5. そうでなければ、
    1. rightRefをAssignmentExpressionの ? Evaluationとする。
    2. rightValueを ? GetValue(rightRef) とする。
  6. ? PutValue(leftRef, rightValue)を実行する。
  7. rightValueを返す。
 AssignmentExpression : LeftHandSideExpression ||= AssignmentExpression
  1. leftRefをLeftHandSideExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. ToBoolean(leftValue)がtrueなら、leftValueを返す。
  4. IsAnonymousFunctionDefinition(AssignmentExpression)がtrueであり、かつLeftHandSideExpressionのIsIdentifierRefがtrueなら、
    1. lhsをLeftHandSideExpressionのStringValueとする。
    2. rightValueを、引数lhsを伴うAssignmentExpressionの ? NamedEvaluationとする。
  5. そうでなければ、
    1. rightRefをAssignmentExpressionの ? Evaluationとする。
    2. rightValueを ? GetValue(rightRef) とする。
  6. ? PutValue(leftRef, rightValue)を実行する。
  7. rightValueを返す。
 AssignmentExpression : LeftHandSideExpression ??= AssignmentExpression
  1. leftRefをLeftHandSideExpressionの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. leftValueがundefinedでもnullでもないなら、leftValueを返す。
  4. IsAnonymousFunctionDefinition(AssignmentExpression)がtrueであり、かつLeftHandSideExpressionのIsIdentifierRefがtrueなら、
    1. lhsをLeftHandSideExpressionのStringValueとする。
    2. rightValueを、引数lhsを伴うAssignmentExpressionの ? NamedEvaluationとする。
  5. そうでなければ、
    1. rightRefをAssignmentExpressionの ? Evaluationとする。
    2. rightValueを ? GetValue(rightRef) とする。
  6. ? PutValue(leftRef, rightValue)を実行する。
  7. rightValueを返す。
 Note

このexpressionがstrict mode code内に出現する場合、step 1.e、3、2、2、2におけるleftRefがunresolvable referenceであるなら、それはruntime errorです。そうであれば、ReferenceError例外がthrowされます。さらに、step 9、6、6、6におけるleftRefが、attribute value { [[Writable]]: false }を持つdata property、attribute value { [[Set]]: undefined }を持つaccessor property、またはIsExtensible predicateが値falseを返すobjectのnon-existent propertyへのreferenceである場合、それはruntime errorです。これらの場合、TypeError例外がthrowされます。

13.15.3 ApplyStringOrNumericBinaryOperator ( leftValue, opText, rightValue )

The abstract operation ApplyStringOrNumericBinaryOperator takes arguments leftValue (an ECMAScript language value), opText (**, *, /, %, +, -, <<, >>, >>>, &, ^, or |), and rightValue (an ECMAScript language value) and returns either a normal completion containing either a String, a BigInt, or a Number, or a throw completion. It performs the following steps when called:

  1. opTextが+なら、
    1. leftPrimitiveを ? ToPrimitive(leftValue) とする。
    2. rightPrimitiveを ? ToPrimitive(rightValue) とする。
    3. leftPrimitiveがStringまたはrightPrimitiveがStringなら、
      1. leftStringを ? ToString(leftPrimitive) とする。
      2. rightStringを ? ToString(rightPrimitive) とする。
      3. leftStringとrightStringのstring-concatenationを返す。
    4. leftValueをleftPrimitiveに設定する。
    5. rightValueをrightPrimitiveに設定する。
  2. NOTE: この時点では、numeric operationでなければならない。
  3. leftNumberを ? ToNumeric(leftValue) とする。
  4. rightNumberを ? ToNumeric(rightValue) とする。
  5. SameType(leftNumber, rightNumber)がfalseなら、TypeError例外をthrowする。
  6. leftNumberがBigIntなら、
    1. opTextが**なら、? BigInt::exponentiate(leftNumber, rightNumber)を返す。
    2. opTextが/なら、? BigInt::divide(leftNumber, rightNumber)を返す。
    3. opTextが%なら、? BigInt::remainder(leftNumber, rightNumber)を返す。
    4. opTextが>>>なら、? BigInt::unsignedRightShift(leftNumber, rightNumber)を返す。
    5. operationを、次のtable内でopTextに関連付けられたabstract operationとする：
      opText operation
      * BigInt::multiply
      + BigInt::add
      - BigInt::subtract
      << BigInt::leftShift
      >> BigInt::signedRightShift
      & BigInt::bitwiseAND
      ^ BigInt::bitwiseXOR
      | BigInt::bitwiseOR
  7. そうでなければ、
    1. Assert: leftNumberはNumberである。
    2. operationを、次のtable内でopTextに関連付けられたabstract operationとする：
      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(leftNumber, rightNumber)を返す。
 Note 1

steps 1.aおよび1.bにおけるToPrimitiveへのcallsでは、hintは提供されません。Datesを除くすべてのstandard objectsは、hintがないことをnumberが与えられたかのように処理します；Datesは、hintがないことをstringが与えられたかのように処理します。Exotic objectsは、hintがないことを別の方法で処理する場合があります。

 Note 2

Step 1.cは、logical-and operationではなくlogical-or operationを使用する点で、IsLessThan algorithmのstep 3とは異なります。

13.15.4 EvaluateStringOrNumericBinaryExpression ( leftOperand, opText, rightOperand )

The abstract operation EvaluateStringOrNumericBinaryExpression takes arguments leftOperand (a Parse Node), opText (**, *, /, %, +, -, <<, >>, >>>, &, ^, or |), and rightOperand (a Parse Node) and returns either a normal completion containing either a String, a BigInt, or a Number, or an abrupt completion. It performs the following steps when called:

  1. leftRefをleftOperandの ? Evaluationとする。
  2. leftValueを ? GetValue(leftRef) とする。
  3. rightRefをrightOperandの ? Evaluationとする。
  4. rightValueを ? GetValue(rightRef) とする。
  5. ? ApplyStringOrNumericBinaryOperator(leftValue, opText, rightValue)を返す。

13.15.5 Destructuring Assignment

Supplemental Syntax

特定の状況で、production
AssignmentExpression : LeftHandSideExpression = AssignmentExpression
のinstanceを処理するとき、LeftHandSideExpressionのinterpretationは次のgrammarを使用してrefineされます：

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 Runtime Semantics: DestructuringAssignmentEvaluation

The syntax-directed operation DestructuringAssignmentEvaluation takes argument value (an ECMAScript language value) and returns either a normal completion containing unused or an abrupt completion. It is defined piecewise over the following productions:

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

13.15.5.3 Runtime Semantics: PropertyDestructuringAssignmentEvaluation

The syntax-directed operation PropertyDestructuringAssignmentEvaluation takes argument value (an ECMAScript language value) and returns either a normal completion containing a List of property keys or an abrupt completion. これは、destructured property keysすべてのlistを収集します。 It is defined piecewise over the following productions:

AssignmentPropertyList : AssignmentPropertyList , AssignmentProperty
  1. propertyNamesを、引数valueを伴うAssignmentPropertyListの ? PropertyDestructuringAssignmentEvaluationとする。
  2. nextNamesを、引数valueを伴うAssignmentPropertyの ? PropertyDestructuringAssignmentEvaluationとする。
  3. propertyNamesとnextNamesのlist-concatenationを返す。
 AssignmentProperty : IdentifierReference Initializeropt
  1. propertyNameをIdentifierReferenceのStringValueとする。
  2. leftRefを ? ResolveBinding(propertyName) とする。
  3. valueを ? GetV(value, propertyName) に設定する。
  4. Initializerが存在し、かつvalueがundefinedなら、
    1. IsAnonymousFunctionDefinition(Initializer)がtrueなら、
      1. valueを、引数propertyNameを伴うInitializerの ? NamedEvaluationに設定する。
    2. そうでなければ、
      1. defaultValueをInitializerの ? Evaluationとする。
      2. valueを ? GetValue(defaultValue) に設定する。
  5. ? PutValue(leftRef, value)を実行する。
  6. « propertyName »を返す。
 AssignmentProperty : PropertyName : AssignmentElement
  1. nameをPropertyNameの ? Evaluationとする。
  2. 引数valueおよびnameを伴うAssignmentElementの ? KeyedDestructuringAssignmentEvaluationを実行する。
  3. « name »を返す。

13.15.5.4 Runtime Semantics: RestDestructuringAssignmentEvaluation

The syntax-directed operation RestDestructuringAssignmentEvaluation takes arguments value (an ECMAScript language value) and excludedNames (a List of property keys) and returns either a normal completion containing unused or an abrupt completion. It is defined piecewise over the following productions:

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

13.15.5.5 Runtime Semantics: IteratorDestructuringAssignmentEvaluation

The syntax-directed operation IteratorDestructuringAssignmentEvaluation takes argument iteratorRecord (an Iterator Record) and returns either a normal completion containing unused or an abrupt completion. It is defined piecewise over the following productions:

AssignmentElementList : AssignmentElisionElement
  1. 引数iteratorRecordを伴うAssignmentElisionElementの ? IteratorDestructuringAssignmentEvaluationを返す。
 AssignmentElementList : AssignmentElementList , AssignmentElisionElement
  1. 引数iteratorRecordを伴うAssignmentElementListの ? IteratorDestructuringAssignmentEvaluationを実行する。
  2. 引数iteratorRecordを伴うAssignmentElisionElementの ? IteratorDestructuringAssignmentEvaluationを返す。
 AssignmentElisionElement : AssignmentElement
  1. 引数iteratorRecordを伴うAssignmentElementの ? IteratorDestructuringAssignmentEvaluationを返す。
 AssignmentElisionElement : Elision AssignmentElement
  1. 引数iteratorRecordを伴うElisionの ? IteratorDestructuringAssignmentEvaluationを実行する。
  2. 引数iteratorRecordを伴うAssignmentElementの ? IteratorDestructuringAssignmentEvaluationを返す。
 Elision : ,
  1. iteratorRecord.[[Done]]がfalseなら、
    1. ? IteratorStep(iteratorRecord)を実行する。
  2. unusedを返す。
 Elision : Elision ,
  1. 引数iteratorRecordを伴うElisionの ? IteratorDestructuringAssignmentEvaluationを実行する。
  2. iteratorRecord.[[Done]]がfalseなら、
    1. ? IteratorStep(iteratorRecord)を実行する。
  3. unusedを返す。
 AssignmentElement : DestructuringAssignmentTarget Initializeropt
  1. DestructuringAssignmentTargetがObjectLiteralでもArrayLiteralでもないなら、
    1. leftRefをDestructuringAssignmentTargetの ? Evaluationとする。
  2. valueをundefinedとする。
  3. iteratorRecord.[[Done]]がfalseなら、
    1. nextを ? IteratorStepValue(iteratorRecord) とする。
    2. nextがdoneでないなら、
      1. valueをnextに設定する。
  4. Initializerが存在し、かつvalueがundefinedなら、
    1. IsAnonymousFunctionDefinition(Initializer)がtrueであり、かつDestructuringAssignmentTargetのIsIdentifierRefが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によってcoverされるAssignmentPatternとする。
    2. 引数vを伴うnestedAssignmentPatternの ? DestructuringAssignmentEvaluationを返す。
  7. ? PutValue(leftRef, v)を返す。
 Note

left to right evaluation orderは、iteratorへaccessする前、またはInitializerを評価する前に、destructuring patternではないDestructuringAssignmentTargetを評価することによって維持されます。

 AssignmentRestElement : ... DestructuringAssignmentTarget
  1. DestructuringAssignmentTargetがObjectLiteralでもArrayLiteralでもないなら、
    1. leftRefをDestructuringAssignmentTargetの ? Evaluationとする。
  2. arrayを ! ArrayCreate(0) とする。
  3. nを0とする。
  4. iteratorRecord.[[Done]]がfalseである間、繰り返す
    1. nextを ? IteratorStepValue(iteratorRecord) とする。
    2. nextがdoneでないなら、
      1. ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(n)), next)を実行する。
      2. nをn + 1に設定する。
  5. DestructuringAssignmentTargetがObjectLiteralでもArrayLiteralでもないなら、
    1. ? PutValue(leftRef, array)を返す。
  6. nestedAssignmentPatternをDestructuringAssignmentTargetによってcoverされるAssignmentPatternとする。
  7. 引数arrayを伴うnestedAssignmentPatternの ? DestructuringAssignmentEvaluationを返す。

13.15.5.6 Runtime Semantics: KeyedDestructuringAssignmentEvaluation

The syntax-directed operation KeyedDestructuringAssignmentEvaluation takes arguments value (an ECMAScript language value) and propertyName (a property key) and returns either a normal completion containing unused or an abrupt completion. It is defined piecewise over the following productions:

AssignmentElement : DestructuringAssignmentTarget Initializeropt
  1. DestructuringAssignmentTargetがObjectLiteralでもArrayLiteralでもないなら、
    1. leftRefをDestructuringAssignmentTargetの ? Evaluationとする。
  2. valueを ? GetV(value, propertyName) に設定する。
  3. Initializerが存在し、かつvalueがundefinedなら、
    1. IsAnonymousFunctionDefinition(Initializer)がtrueであり、かつDestructuringAssignmentTargetのIsIdentifierRefがtrueなら、
      1. targetをDestructuringAssignmentTargetのStringValueとする。
      2. rhsValueを、引数targetを伴うInitializerの ? NamedEvaluationとする。
    2. そうでなければ、
      1. defaultValueをInitializerの ? Evaluationとする。
      2. rhsValueを ? GetValue(defaultValue) とする。
  4. そうでなければ、
    1. rhsValueをvalueとする。
  5. DestructuringAssignmentTargetがObjectLiteralまたはArrayLiteralのいずれかなら、
    1. assignmentPatternをDestructuringAssignmentTargetによってcoverされるAssignmentPatternとする。
    2. 引数rhsValueを伴うassignmentPatternの ? DestructuringAssignmentEvaluationを返す。
  6. ? PutValue(leftRef, 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. leftRefをExpressionの ? Evaluationとする。
  2. ? GetValue(leftRef)を実行する。
  3. rightRefをAssignmentExpressionの ? Evaluationとする。
  4. ? GetValue(rightRef)を返す。
 Note

その値は使用されませんが、observable side-effectsを持つ場合があるため、GetValueは呼び出されなければなりません。