13 ECMAScript 言語: 式

13.1 識別子

構文

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

yield および await は、文法上は BindingIdentifier として許可され、以下の静的意味 論により禁止される。これは次のような場合に自動セミコロン 挿入を禁止するためである。 

let
await 0;

13.1.1 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
  • 構文文法の goal symbol が Module である場 合、それは Syntax Error である。
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 sequence を正規化する。したがって、そのような escape は、code point 列が 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(StringValue of Identifier) を返す。
 IdentifierReference : yield
  1. ? ResolveBinding("yield") を返す。
 IdentifierReference : await
  1. ? ResolveBinding("await") を返す。
 Note 1

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

Note 2

non-strict code において、keyword yield は識別子として使用できる。 IdentifierReference の評価は、それが Identifier であるかのように yield の束縛を解決 する。Early Error 制約により、そのような評価は non-strict code に対してのみ起こり得ることが保証さ れる。

13.2 Primary Expression

構文

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] )

補助構文

次の production の instance を処理するとき
PrimaryExpression[Yield, Await] : CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]
CoverParenthesizedExpressionAndArrowParameterList の解釈は、以下の文法を用いて精密化される:

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

13.2.1 this Keyword

13.2.1.1 Runtime Semantics: Evaluation

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

13.2.2 Identifier Reference

IdentifierReference については 13.1 を参照。

13.2.3 リテラル

構文

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 は、Array の初期化を記述する式 であり、0 個以上の式の list を用いて記述される。各 式は array element を表し、全体は角括弧で囲まれ る。element は literal である必要はなく、array initializer が評価されるたびに評価される。

Array element は element list の先頭・中 間・末尾で省略され得る。element list 内の comma の直前に AssignmentExpression がない場合（すなわ ち、先頭の comma または別の comma の直後の comma）、その欠けた array element は Array の length に寄与し、後続 element の index を増やす。 省略された array element は定義されない。array の 末尾で element が省略された場合、その element は Array の length に寄与しない。

構文

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. len を nextIndex + 1 とする。
  2. ? Set(array, "length", 𝔽(len), true) を実行する。
  3. NOTE: 上の手順は、len が 232 - 1 を超える場合 throw す る。
  4. len を返す。
 Elision : Elision ,
  1. array および (nextIndex + 1) を引数と する Elision の ArrayAccumulation を ? 返す。
 ElementList : Elisionopt AssignmentExpression
  1. Elision が存在するなら、
    1. nextIndex を、array および nextIndex を引数とする Elision の ArrayAccumulation の ? に設定する。
  2. initResult を ? Evaluation of AssignmentExpression とする。
  3. initValue を ? GetValue(initResult) とする。
  4. ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), initValue) を実行する。
  5. nextIndex + 1 を返す。
 ElementList : Elisionopt SpreadElement
  1. Elision が存在するなら、
    1. nextIndex を、array および nextIndex を引数とする Elision の ArrayAccumulation の ? に設定する。
  2. array および nextIndex を引数とする SpreadElement の ArrayAccumulation を ? 返す。
 ElementList : ElementList , Elisionopt AssignmentExpression
  1. nextIndex を、array および nextIndex を引数とする、導出された ElementList の ArrayAccumulation の ? に設定する。
  2. Elision が存在するなら、
    1. nextIndex を、array および nextIndex を引数とする Elision の ArrayAccumulation の ? に設定する。
  3. initResult を ? Evaluation of AssignmentExpression とする。
  4. initValue を ? GetValue(initResult) とする。
  5. ! CreateDataPropertyOrThrow(array, ! ToString(𝔽(nextIndex)), initValue) を実行する。
  6. nextIndex + 1 を返す。
 ElementList : ElementList , Elisionopt SpreadElement
  1. nextIndex を、array および nextIndex を引数とする、導出された ElementList の ArrayAccumulation の ? に設定する。
  2. Elision が存在するなら、
    1. nextIndex を、array および nextIndex を引数とする Elision の ArrayAccumulation の ? に設定する。
  3. array および nextIndex を引数とする SpreadElement の ArrayAccumulation を ? 返す。
 SpreadElement : ... AssignmentExpression
  1. spreadRef を ? Evaluation of AssignmentExpression とする。
  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 は、標準組込み Array prototype object が、[[Set]] を用いて新し い own property を作成できないような形に変更されて いた場合でも、array に own property が定義される ことを確実にするために用いられる。

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 の初期化を記述する式である。これ は、0 個以上の property key と、それに対応する値の 組の list を波括弧で囲んだものである。値は literal である必要はなく、object initializer が評価されるた びに評価される。

構文

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

MethodDefinition は 15.4 で定義される。

Note 3

ある文脈では、ObjectLiteral は、より制限 された二次文法に対する cover grammar として用いられ る。CoverInitializedName 生成規則は、これらの二次 文法を完全に cover するために必要である。しかし、こ の生成規則を用いると、実際の ObjectLiteral が期待 される通常文脈では早期の Syntax Error を生じる。

13.2.5.1 Static Semantics: Early Errors

PropertyDefinition : MethodDefinition

実際の object initializer を記述することに加え て、ObjectLiteral 生成規則は ObjectAssignmentPattern に対する cover grammar としても用いられ、 CoverParenthesizedExpressionAndArrowParameterList の一部として認識されることがある。ObjectLiteral が ObjectAssignmentPattern を要求する文脈に現れる 場合、次の Early Error 規則は適用されない。ま た、CoverParenthesizedExpressionAndArrowParameterList または CoverCallExpressionAndAsyncArrowHead を 最初に parse するときにも適用されない。

PropertyDefinition : CoverInitializedName
  • この production に任意の source text が 一致する場合、それは Syntax Error である。
Note 1

この production は、ObjectLiteral が ObjectAssignmentPattern に対する cover grammar として機能できるように存在する。実際の object initializer では現れ得ない。

ObjectLiteral : { PropertyDefinitionList } { PropertyDefinitionList , } Note 2

PropertyNameList によって返される List は、 ComputedPropertyName を用いて定義された property 名を含まない。

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 を、導出された 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. propName を PropertyDefinition の PropName とする。
  2. propName が empty なら、新しい空の List を返す。
  3. « propName » を返す。
 PropertyDefinitionList : PropertyDefinitionList , PropertyDefinition
  1. list を PropertyDefinitionList の PropertyNameList とする。
  2. propName を PropertyDefinition の PropName とする。
  3. propName が empty なら、list を返 す。
  4. list と « propName » の 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. nbr を NumericLiteral の NumericValue とする。
  2. ! ToString(nbr) を返す。
 ComputedPropertyName : [ AssignmentExpression ]
  1. exprValue を ? Evaluation of AssignmentExpression とする。
  2. propName を ? GetValue(exprValue) とする。
  3. ? ToPropertyKey(propName) を返す。

13.2.5.6 Runtime Semantics: PropertyDefinitionEvaluation

The syntax-directed operation PropertyDefinitionEvaluation takes argument object (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. object を引数として PropertyDefinitionList の PropertyDefinitionEvaluation を ? 実行す る。
  2. object を引数として PropertyDefinition の PropertyDefinitionEvaluation を ? 実 行する。
  3. unused を返す。
 PropertyDefinition : ... AssignmentExpression
  1. exprValue を ? Evaluation of AssignmentExpression とする。
  2. fromValue を ? GetValue(exprValue) とする。
  3. excludedNames を新しい空の List とす る。
  4. ? CopyDataProperties(object, fromValue, excludedNames) を実行する。
  5. unused を返す。
 PropertyDefinition : IdentifierReference
  1. propName を IdentifierReference の StringValue とする。
  2. exprValue を ? Evaluation of IdentifierReference とする。
  3. propValue を ? GetValue(exprValue) とする。
  4. Assert: object は、non-configurable property を持たない、通常かつ拡張可能な object である。
  5. ! CreateDataPropertyOrThrow(object, propName, propValue) を実行する。
  6. unused を返す。
 PropertyDefinition : PropertyName : AssignmentExpression
  1. propertyKey を ? Evaluation of PropertyName とする。
  2. この PropertyDefinition が ParseJSON のために評価されている Script の内部に含 まれている場合 （ParseJSON の step 6 を参照）、
    1. isProtoSetter を false とする。
  3. Else if propertyKey が "__proto__" であり、かつ PropertyName の IsComputedPropertyKey が false なら、
    1. isProtoSetter を true とする。
  4. Else,
    1. isProtoSetter を false とする。
  5. IsAnonymousFunctionDefinition( AssignmentExpression) が true かつ isProtoSetter が false なら、
    1. propValue を、propertyKey を引数と する AssignmentExpression の NamedEvaluation の ? とする。
  6. Else,
    1. exprValueRef を ? Evaluation of AssignmentExpression とする。
    2. propValue を ? GetValue(exprValueRef) とする。
  7. isProtoSetter が true なら、
    1. propValue が Object または null な ら、
      1. ! object.[[SetPrototypeOf]](propValue) を実行する。
    2. unused を返す。
  8. Assert: object は、non-configurable property を持たない、通常かつ拡張可能な object である。
  9. ! CreateDataPropertyOrThrow(object, propertyKey, propValue) を実行する。
  10. unused を返す。
 PropertyDefinition : MethodDefinition
  1. object および true を引数として MethodDefinition の MethodDefinitionEvaluation を ? 実行す る。
  2. unused を返す。

13.2.6 関数定義式

PrimaryExpression : FunctionExpression については 15.2 を参照。

PrimaryExpression : GeneratorExpression については 15.5 を参照。

PrimaryExpression : ClassExpression については 15.7 を参照。

PrimaryExpression : AsyncFunctionExpression については 15.8 を参照。

PrimaryExpression : AsyncGeneratorExpression については 15.6 を参照。

13.2.7 正規表現リテラル

構文

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. これは、その引数が妥当な正規表現リテラルかどうかを 判定する。 It performs the following steps when called:

  1. flags を literal の FlagText とする。
  2. flags が d, g, i, m, s, u, v, y 以外の code point を 含むなら、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 要素を Unicode BMP code point として解釈した結果生じる code point 列 に設定する。要素には UTF-16 decoding は適 用しない。
  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(BodyText of RegularExpressionLiteral) とする。
  2. flags を CodePointsToString(FlagText of RegularExpressionLiteral) とする。
  3. ! RegExpCreate(pattern, flags) を返 す。

13.2.8 Template Literal

構文

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]
  • [Tagged] parameter が設定されて おらず、かつ TemplateHead が NotEscapeSequence を含む場合、それは Syntax Error である。
TemplateSpans[Yield, Await, Tagged] : TemplateTail
  • [Tagged] parameter が設定されて おらず、かつ TemplateTail が NotEscapeSequence を含む場合、それは Syntax Error である。
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 を、raw を引数とする TemplateSpans の TemplateStrings とす る。
  3. head と tail の list-concatenation を返す。
 TemplateSpans : TemplateTail
  1. « TemplateString(TemplateTail, raw) » を返す。
 TemplateSpans : TemplateMiddleList TemplateTail
  1. middle を、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 を、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. Else,
    1. string を templateToken の TV とす る。
  3. string を返す。
 Note

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

13.2.8.4 GetTemplateObject ( templateLiteral )

The abstract operation GetTemplateObject takes argument templateLiteral (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 の各要素 e につい て、次を行う
    1. e.[[Site]] が templateLiteral と 同じ Parse Node なら、
      1. e.[[Array]] を返す。
  4. rawStrings を、引数 true を伴う templateLiteral の TemplateStrings とする。
  5. Assert: rawStrings は String の List である。
  6. cookedStrings を、引数 false を伴う templateLiteral の TemplateStrings とする。
  7. count を List cookedStrings の要素 数とする。
  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 のプログラム code 中の各 TemplateLiteral は、一意な template object と 対応付けられており、これはタグ付き Template の評価 （13.2.8.6） において使用される。template object は凍結されてお り、特定のタグ付き Template が評価されるたびに同じ template object が使用される。template object が TemplateLiteral の最初の評価時に遅延生成される か、最初の評価前に eager に生成されるかは、ECMAScript code から観測不可能な実装選択である。

Note 3

この仕様の将来版では、template object の追 加の non-enumerable property が定義されることが ある。

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 を ? Evaluation of Expression とする。
  2. sub を ? GetValue(subRef) とする。
  3. « sub » を返す。
 TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. preceding を TemplateMiddleList の SubstitutionEvaluation の ? とする。
  2. nextRef を ? Evaluation of Expression とする。
  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 を ? Evaluation of Expression とする。
  3. sub を ? GetValue(subRef) とする。
  4. middle を ? ToString(sub) とする。
  5. tail を ? Evaluation of TemplateSpans とする。
  6. head, middle, および tail の string-concatenation を返す。
 Note 1

Expression 値に適用される文字列変換の意味論 は、+ 演算子というより String.prototype.concat に近い。

TemplateSpans : TemplateTail
  1. 12.9.6 で定義される TemplateTail の TV を返 す。
 TemplateSpans : TemplateMiddleList TemplateTail
  1. head を ? Evaluation of TemplateMiddleList とする。
  2. tail を 12.9.6 で定義される TemplateTail の TV とす る。
  3. head と tail の string-concatenation を返す。
 TemplateMiddleList : TemplateMiddle Expression
  1. head を 12.9.6 で定義される TemplateMiddle の TV とす る。
  2. subRef を ? Evaluation of Expression とする。
  3. sub を ? GetValue(subRef) とする。
  4. middle を ? ToString(sub) とする。
  5. head と middle の string-concatenation を返す。
 Note 2

Expression 値に適用される文字列変換の意味論 は、+ 演算子というより String.prototype.concat に近い。

TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. rest を ? Evaluation of TemplateMiddleList とする。
  2. middle を 12.9.6 で定義される TemplateMiddle の TV とす る。
  3. subRef を ? Evaluation of Expression とする。
  4. sub を ? GetValue(subRef) とする。
  5. last を ? ToString(sub) とする。
  6. rest, middle, および last の string-concatenation を返す。
 Note 3

Expression 値に適用される文字列変換の意味論 は、+ 演算子というより String.prototype.concat に近い。

13.2.9 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 のような演算子を括弧付き 式へ適用できるようにすることである。

13.3 Left-Hand-Side Expressions

構文

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]

補助構文

次の production の instance を処理するとき
CallExpression : CoverCallExpressionAndAsyncArrowHead
CoverCallExpressionAndAsyncArrowHead の解釈 は、以下の文法を用いて精密化される:

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 に 一致する場合、それは Syntax Error である。
Note

この production は、次の code に対して自 動セミコロン挿入規則 （12.10） が適用されるのを防ぐために存在する: 

a?.b
`c`

そうでなければ、それが 2 つの妥当な文として解釈さ れてしまうからである。目的は、optional chaining を 持たない類似 code との一貫性を維持することである: 

a.b
`c`

これは妥当な文であり、自動セミコロン挿入は適用され ない。

ImportMeta : import . meta
  • syntactic goal symbol が Module でない場合、それは Syntax Error である。

13.3.2 Property Accessors

Note

property は、名前によってアクセスされ、次のよう な dot notation を用いる:

MemberExpression . IdentifierName
CallExpression . IdentifierName

または、次のような bracket notation を用い る:

MemberExpression [ Expression ]
CallExpression [ Expression ]

dot notation は、次の構文変換によって説明され る:

MemberExpression . IdentifierName

これは、その振る舞いにおいて次と同一である:

MemberExpression [ <identifier-name-string> ]

同様に

CallExpression . IdentifierName

これは、その振る舞いにおいて次と同一である:

CallExpression [ <identifier-name-string> ]

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

13.3.2.1 Runtime Semantics: Evaluation

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

13.3.3 EvaluatePropertyAccessWithExpressionKey ( baseValue, expression, strict )

The abstract operation EvaluatePropertyAccessWithExpressionKey takes arguments baseValue (an ECMAScript language value), expression (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. propertyNameReference を ? Evaluation of expression とする。
  2. propertyNameValue を ? GetValue(propertyNameReference) とす る。
  3. NOTE: ほとんどの場合、 ToPropertyKey はこの手順の直後に propertyNameValue に対して実行される。し かし a[b] = c の場合、それは c の評価後 まで実行されない。
  4. Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyNameValue, [[Strict]]: strict, [[ThisValue]]: empty } を返す。

13.3.4 EvaluatePropertyAccessWithIdentifierKey ( baseValue, identifierName, strict )

The abstract operation EvaluatePropertyAccessWithIdentifierKey takes arguments baseValue (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 new Operator

13.3.5.1 Runtime Semantics: Evaluation

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

13.3.5.1.1 EvaluateNew ( constructExpr, arguments )

The abstract operation EvaluateNew takes arguments constructExpr (a NewExpression Parse Node or a MemberExpression Parse Node) and arguments (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 を ? Evaluation of constructExpr とする。
  2. constructor を ? GetValue(ref) とす る。
  3. arguments が empty なら、
    1. argList を新しい空の List とする。
  4. Else,
    1. argList を ? ArgumentListEvaluation of arguments とする。
  5. IsConstructor(constructor) が false なら、TypeError 例外を送出する。
  6. ? Construct(constructor, argList) を 返す。

13.3.6 関数呼出し

13.3.6.1 Runtime Semantics: Evaluation

CallExpression : CoverCallExpressionAndAsyncArrowHead
  1. expr を CoverCallExpressionAndAsyncArrowHead に よって cover される CallMemberExpression とする。
  2. memberExpr を expr の MemberExpression とする。
  3. arguments を expr の Arguments と する。
  4. ref を ? Evaluation of memberExpr とする。
  5. func を ? GetValue(ref) とする。
  6. ref が Reference Record であり、 IsPropertyReference(ref) が false であ り、かつ ref.[[ReferencedName]] が "eval" なら、
    1. SameValue(func, %eval%) が true なら、
      1. argList を ? ArgumentListEvaluation of arguments とする。
      2. argList が要素を持たないなら、 undefined を返す。
      3. evalArg を argList の最初の要素 とする。
      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, arguments, tailCall) を返す。

step 6.a.v を実行する CallExpression の評価は、 direct eval である。

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

13.3.6.2 EvaluateCall ( func, ref, arguments, tailPosition )

The abstract operation EvaluateCall takes arguments func (an ECMAScript language value), ref (an ECMAScript language value or a Reference Record), arguments (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. ref が Reference Record なら、
    1. IsPropertyReference(ref) が true な ら、
      1. thisValue を GetThisValue(ref) とする。
    2. Else,
      1. refEnv を ref.[[Base]] とする。
      2. Assert: refEnv は Environment Record である。
      3. thisValue を refEnv.WithBaseObject() とする。
  2. Else,
    1. thisValue を undefined とする。
  3. argList を ? ArgumentListEvaluation of arguments とする。
  4. func が Object でなければ、 TypeError 例外を送出する。
  5. IsCallable(func) が false なら、 TypeError 例外を送出する。
  6. tailPosition が true なら、 PrepareForTailCall() を実行する。
  7. ? Call(func, thisValue, argList) を 返す。

13.3.7 super Keyword

13.3.7.1 Runtime Semantics: Evaluation

SuperProperty : super [ Expression ]
  1. env を GetThisEnvironment() とする。
  2. actualThis を ? env.GetThisBinding() とする。
  3. propertyNameReference を ? Evaluation of Expression とする。
  4. propertyNameValue を ? GetValue(propertyNameReference) とす る。
  5. strict を IsStrict(this SuperProperty) とする。
  6. NOTE: ほとんどの場合、 ToPropertyKey はこの手順の直後に propertyNameValue に対して実行される。し かし super[b] = c の場合、それは c の 評価後まで実行されない。
  7. MakeSuperPropertyReference(actualThis, propertyNameValue, strict) を返す。
 SuperProperty : super . IdentifierName
  1. env を GetThisEnvironment() とする。
  2. actualThis を ? env.GetThisBinding() とする。
  3. propertyKey を IdentifierName の StringValue とする。
  4. strict を IsStrict(this SuperProperty) とする。
  5. MakeSuperPropertyReference(actualThis, propertyKey, strict) を返す。
 SuperCall : super Arguments
  1. newTarget を GetNewTarget() とする。
  2. Assert: newTarget は constructor であ る。
  3. superConstructor を GetSuperConstructor() とする。
  4. argList を ? ArgumentListEvaluation of Arguments とする。
  5. IsConstructor(superConstructor) が false なら、TypeError 例外を送出 する。
  6. result を ? Construct(superConstructor, argList, newTarget) とする。
  7. thisER を GetThisEnvironment() とす る。
  8. Assert: thisER は Function Environment Record である。
  9. ? BindThisValue(thisER, result) を 実行する。
  10. funcObj を thisER.[[FunctionObject]] とする。
  11. Assert: funcObj は ECMAScript 関数 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. envRec を GetThisEnvironment() とする。
  2. Assert: envRec は Function Environment Record である。
  3. activeFunction を envRec.[[FunctionObject]] とする。
  4. Assert: activeFunction は ECMAScript 関数 object である。
  5. superConstructor を ! activeFunction.[[GetPrototypeOf]]() とする。
  6. superConstructor を返す。

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. env を GetThisEnvironment() とする。
  2. Assert: env.HasSuperBinding() is true.
  3. Assert: env は Function Environment Record である。
  4. baseValue を GetSuperBase(env) とす る。
  5. Reference Record { [[Base]]: baseValue, [[ReferencedName]]: propertyKey, [[Strict]]: strict, [[ThisValue]]: actualThis } を返す。

13.3.8 Argument List

Note

argument list の評価は、値の 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 を ? Evaluation of AssignmentExpression とする。
  2. arg を ? GetValue(ref) とする。
  3. « arg » を返す。
 ArgumentList : ... AssignmentExpression
  1. list を新しい空の List とする。
  2. spreadRef を ? Evaluation of AssignmentExpression とする。
  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 を ? Evaluation of AssignmentExpression とする。
  3. arg を ? GetValue(ref) とする。
  4. precedingArgs と « arg » の list-concatenation を返す。
 ArgumentList : ArgumentList , ... AssignmentExpression
  1. precedingArgs を ArgumentList の ArgumentListEvaluation の ? とする。
  2. spreadRef を ? Evaluation of AssignmentExpression とする。
  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 を ? ArgumentListEvaluation of SubstitutionTemplate とする。
  4. « siteObj » と remaining の list-concatenation を返す。
 SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. firstSubRef を ? Evaluation of Expression とする。
  2. firstSub を ? GetValue(firstSubRef) とする。
  3. restSub を ? SubstitutionEvaluation of TemplateSpans とする。
  4. Assert: restSub は空である場合もある List である。
  5. « firstSub » と restSub の list-concatenation を返す。

13.3.9 Optional Chain

Note
optional chain とは、1 個以上の property access および function call の連鎖で あり、その最初のものが token ?. で始まるものであ る。

13.3.9.1 Runtime Semantics: Evaluation

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

13.3.9.2 Runtime Semantics: ChainEvaluation

The syntax-directed operation ChainEvaluation takes arguments baseValue (an ECMAScript language value) and baseReference (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, baseReference, Arguments, tailCall) を返す。
 OptionalChain : ?. [ Expression ]
  1. strict を IsStrict(this OptionalChain) とする。
  2. ? EvaluatePropertyAccessWithExpressionKey( baseValue, Expression, strict) を返 す。
 OptionalChain : ?. IdentifierName
  1. strict を IsStrict(this OptionalChain) とする。
  2. EvaluatePropertyAccessWithIdentifierKey( baseValue, IdentifierName, strict) を 返す。
 OptionalChain : ?. PrivateIdentifier
  1. fieldNameString を PrivateIdentifier の StringValue とする。
  2. MakePrivateReference(baseValue, fieldNameString) を返す。
 OptionalChain : OptionalChain Arguments
  1. optionalChain を OptionalChain とする。
  2. newReference を、baseValue および baseReference を引数とする optionalChain の ChainEvaluation の ? とする。
  3. newValue を ? GetValue(newReference) とする。
  4. thisChain を this OptionalChain とす る。
  5. tailCall を IsInTailPosition(thisChain) とする。
  6. ? EvaluateCall(newValue, newReference, Arguments, tailCall) を返す。
 OptionalChain : OptionalChain [ Expression ]
  1. optionalChain を OptionalChain とする。
  2. newReference を、baseValue および baseReference を引数とする optionalChain の ChainEvaluation の ? とする。
  3. newValue を ? GetValue(newReference) とする。
  4. strict を IsStrict(this OptionalChain) とする。
  5. ? EvaluatePropertyAccessWithExpressionKey( newValue, Expression, strict) を返 す。
 OptionalChain : OptionalChain . IdentifierName
  1. optionalChain を OptionalChain とする。
  2. newReference を、baseValue および baseReference を引数とする optionalChain の ChainEvaluation の ? とする。
  3. newValue を ? GetValue(newReference) とする。
  4. strict を IsStrict(this OptionalChain) とする。
  5. EvaluatePropertyAccessWithIdentifierKey( newValue, IdentifierName, strict) を 返す。
 OptionalChain : OptionalChain . PrivateIdentifier
  1. optionalChain を OptionalChain とする。
  2. newReference を、baseValue および baseReference を引数とする optionalChain の ChainEvaluation の ? とする。
  3. newValue を ? GetValue(newReference) とする。
  4. fieldNameString を PrivateIdentifier の StringValue とする。
  5. MakePrivateReference(newValue, fieldNameString) を返す。

13.3.10 Import Call

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 ( specifierExpression [ , optionsExpression ] )

The abstract operation EvaluateImportCall takes argument specifierExpression (a Parse Node) and optional argument optionsExpression (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 を ? Evaluation of specifierExpression とする。
  4. specifier を ? GetValue(specifierRef) とする。
  5. optionsExpression が存在するなら、
    1. optionsRef を ? Evaluation of optionsExpression とする。
    2. options を ? GetValue(optionsRef) とする。
  6. Else,
    1. options を undefined とする。
  7. promiseCapability を ! NewPromiseCapability(%Promise%) とする。
  8. specifierString を Completion(ToString(specifier)) とする。
  9. IfAbruptRejectPromise(specifierString, promiseCapability).
  10. attributes を新しい空の List とする。
  11. options が undefined でないなら、
    1. options が Object でないなら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに作成された TypeError object ») を実行する。
      2. promiseCapability.[[Promise]] を返す。
    2. attributesObj を Completion(Get(options, "with")) とする。
    3. IfAbruptRejectPromise(attributesObj, promiseCapability).
    4. attributesObj が undefined でない なら、
      1. attributesObj が Object でないな ら、
        1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに作成された TypeError object ») を実行する。
        2. promiseCapability.[[Promise]] を返 す。
      2. entries を Completion(EnumerableOwnProperties( attributesObj, key+value)) とす る。
      3. IfAbruptRejectPromise(entries, promiseCapability).
      4. entries の各要素 entry について、 次を行う
        1. key を ! Get(entry, "0") とする。
        2. value を ! Get(entry, "1") とする。
        3. key が String なら、
          1. value が String でないなら、
            1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに作成された TypeError object ») を実行す る。
            2. promiseCapability.[[Promise]] を返す。
          2. ImportAttribute Record { [[Key]]: key, [[Value]]: value } を attributes に append する。
    5. AllImportAttributesSupported(attributes) が false なら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « 新たに作成された TypeError object ») を実行する。
      2. promiseCapability.[[Promise]] を返 す。
    6. attributes を、それぞれの [[Key]] field の値を UTF-16 code unit 値列と して扱ったときの辞書順に従って sort す る。NOTE: この sorting は、host が attribute の列挙順序に基づいて挙動を変えて はならないという点においてのみ観測可能であ る。
  12. moduleRequest を新しい ModuleRequest Record { [[Specifier]]: specifierString, [[Attributes]]: attributes } とする。
  13. HostLoadImportedModule(referrer, moduleRequest, empty, promiseCapability) を実行する。
  14. promiseCapability.[[Promise]] を返す。

13.3.10.3 ContinueDynamicImport ( promiseCapability, moduleCompletion )

The abstract operation ContinueDynamicImport takes arguments promiseCapability (a PromiseCapability Record) and moduleCompletion (either a normal completion containing a Module Record or a throw completion) and returns unused. これは、 import() call によって元々開始された dynamic import の処理 を完了し、その 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. rejectedClosure を、(reason) を引数 とし、promiseCapability を capture し、呼び出されたとき次の手順を実行する新しい Abstract Closure とする:
    1. ! Call(promiseCapability.[[Reject]], undefined, « reason ») を実行す る。
    2. NormalCompletion(undefined) を返 す。
  5. onRejected を CreateBuiltinFunction(rejectedClosure, 1, "", « ») とする。
  6. linkAndEvaluateClosure を、引数を持た ず、module, promiseCapability, およ び onRejected を capture し、呼び出 されたとき次の手順を実行する新しい Abstract Closure とする:
    1. link を Completion(module.Link()) とする。
    2. link が abrupt completion なら、
      1. ! Call(promiseCapability.[[Reject]], undefined, « link.[[Value]] ») を実行する。
      2. NormalCompletion(undefined) を返 す。
    3. evaluatePromise を module.Evaluate() とする。
    4. fulfilledClosure を、引数を持たず、 module および promiseCapability を capture し、呼び出されたとき次の手 順を実行する新しい Abstract Closure と する:
      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 Template

Note

tagged template は function call であ り、その call の引数は TemplateLiteral （13.2.8） から導出される。実際の引数には template object （13.2.8.4） と、TemplateLiteral 内に埋め込まれた式を評価する ことで生成される値が含まれる。

13.3.11.1 Runtime Semantics: Evaluation

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

13.3.12 Meta Property

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]] } p につい て、次を行う
      1. ! CreateDataPropertyOrThrow( importMeta, p.[[Key]], p.[[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). これは、host が import.meta から返される object に対する property key および値を提供できるよ うにする。

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. これは、host が import.meta から返される object を準備するために、任意の特別な操作を実行できるよ うにする。

ほとんどの host は、単に HostGetImportMetaProperties を定義し、 HostFinalizeImportMeta は default の挙動のまま にしておけるだろう。しかし、 HostFinalizeImportMeta は、object が ECMAScript code に公開される前に直接操作する必要が ある host のための “escape hatch” を提供する。

HostFinalizeImportMeta の default implementation は unused を返すことである。

13.4 Update Expression

構文

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 を ? Evaluation of LeftHandSideExpression とする。
  2. LeftHandSideExpression の AssignmentTargetType が web-compat な ら、ReferenceError 例外を送出する。
  3. oldValue を ? ToNumeric(? GetValue(lhs)) とする。
  4. oldValue が Number なら、
    1. newValue を Number::add(oldValue, 1𝔽) とする。
  5. Else,
    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 を ? Evaluation of LeftHandSideExpression とする。
  2. LeftHandSideExpression の AssignmentTargetType が web-compat な ら、ReferenceError 例外を送出する。
  3. oldValue を ? ToNumeric(? GetValue(lhs)) とする。
  4. oldValue が Number なら、
    1. newValue を Number::subtract(oldValue, 1𝔽) とする。
  5. Else,
    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 を ? Evaluation of UnaryExpression とする。
  2. UnaryExpression の AssignmentTargetType が web-compat なら、 ReferenceError 例外を送出する。
  3. oldValue を ? ToNumeric(? GetValue(expr)) とする。
  4. oldValue が Number なら、
    1. newValue を Number::add(oldValue, 1𝔽) とする。
  5. Else,
    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 を ? Evaluation of UnaryExpression とする。
  2. UnaryExpression の AssignmentTargetType が web-compat なら、 ReferenceError 例外を送出する。
  3. oldValue を ? ToNumeric(? GetValue(expr)) とする。
  4. oldValue が Number なら、
    1. newValue を Number::subtract(oldValue, 1𝔽) とする。
  5. Else,
    1. Assert: oldValue は BigInt である。
    2. newValue を BigInt::subtract(oldValue, 1ℤ) とする。
  6. ? PutValue(expr, newValue) を実行す る。
  7. newValue を返す。

13.5 Unary Operator

構文

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

13.5.1 delete Operator

13.5.1.1 Static Semantics: Early Errors

UnaryExpression : delete UnaryExpression Note

最後の規則は、delete (((foo))) のような式 が、最初の規則の再帰的適用により early error を生 じることを意味する。

13.5.1.2 Runtime Semantics: Evaluation

UnaryExpression : delete UnaryExpression
  1. ref を ? Evaluation of UnaryExpression とする。
  2. ref が Reference Record でないなら、 true を返す。
  3. IsUnresolvableReference(ref) が true なら、
    1. Assert: ref.[[Strict]] is false.
    2. true を返す。
  4. IsPropertyReference(ref) が true な ら、
    1. Assert: IsPrivateReference(ref) is false.
    2. IsSuperReference(ref) が true な ら、ReferenceError 例外を送出する。
    3. baseObj を ? ToObject(ref.[[Base]]) とす る。
    4. ref.[[ReferencedName]] が property key でないなら、
      1. ref.[[ReferencedName]] を ? ToPropertyKey(ref.[[ReferencedName]]) に設定する。
    5. deleteStatus を ? baseObj.[[Delete]](ref.[[ReferencedName]]) とする。
    6. deleteStatus が false であり、 かつ ref.[[Strict]] が true な ら、TypeError 例外を送出する。
    7. deleteStatus を返す。
  5. base を ref.[[Base]] とする。
  6. Assert: base は Environment Record である。
  7. ? base.DeleteBinding(ref.[[ReferencedName]]) を返す。
 Note 1

delete 演算子が strict mode code の中 に現れるとき、その UnaryExpression が変数、関数引 数、または関数名への直接参照である場合には SyntaxError 例外が送出される。さらに、delete 演算子が strict mode code の中に現れ、削除対象の property が { [[Configurable]]: false } とい う属性を持つ（またはその他の理由で削除できない）場合に は、TypeError 例外が送出される。

Note 2

step 4.c で作成され得る object は、上記の abstract operation および通常 object の [[Delete]] 内部メ ソッドの外部からはアクセス不能である。実装は、その object の実際の作成を避けることを選んでもよい。

13.5.2 void Operator

13.5.2.1 Runtime Semantics: Evaluation

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

GetValue は、その値が使用されないとしても、観測 可能な副作用を持つことがあるため、呼び出されなければなら ない。

13.5.3 typeof Operator

13.5.3.1 Runtime Semantics: Evaluation

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

13.5.4 Unary + Operator

Note

単項 + 演算子は、その operand を Number 型へ変換する。

13.5.4.1 Runtime Semantics: Evaluation

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

13.5.5 Unary - Operator

Note

単項 - 演算子は、その operand を数値へ変換 し、その後それを negate する。+0𝔽 を negate すると -0𝔽 が生成され、 -0𝔽 を negate すると +0𝔽 が生成される。

13.5.5.1 Runtime Semantics: Evaluation

UnaryExpression : - UnaryExpression
  1. expr を ? Evaluation of UnaryExpression とする。
  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 を ? Evaluation of UnaryExpression とする。
  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 を ? Evaluation of UnaryExpression とする。
  2. oldValue を ToBoolean(? GetValue(expr)) とする。
  3. oldValue が true なら、false を返す。
  4. true を返す。

13.6 Exponentiation Operator

構文

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 Operator

構文

MultiplicativeExpression[Yield, Await] : ExponentiationExpression[?Yield, ?Await] MultiplicativeExpression[?Yield, ?Await] MultiplicativeOperator ExponentiationExpression[?Yield, ?Await] MultiplicativeOperator : one of * / % Note
  • * 演算子は乗算を行い、その operand の積 を生成する。
  • / 演算子は除算を行い、その operand の商 を生成する。
  • % 演算子は、暗黙の除算における operand の余りを生成する。

13.7.1 Runtime Semantics: Evaluation

MultiplicativeExpression : MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
  1. opText を MultiplicativeOperator に 一致した source text とする。
  2. ? EvaluateStringOrNumericBinaryExpression( MultiplicativeExpression, opText, ExponentiationExpression) を返す。

13.8 Additive Operator

構文

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

13.8.1 Addition Operator ( + )

Note

加算演算子は、文字列連結または数値加算のいずれかを行 う。

13.8.1.1 Runtime Semantics: Evaluation

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

13.8.2 Subtraction Operator ( - )

Note

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

13.8.2.1 Runtime Semantics: Evaluation

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

13.9 Bitwise Shift Operator

構文

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 Left Shift Operator ( << )

Note

左 operand に対して、右 operand によって指 定された量だけ bitwise left shift を行う。

13.9.1.1 Runtime Semantics: Evaluation

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

13.9.2 Signed Right Shift Operator ( >> )

Note

左 operand に対して、右 operand によって指 定された量だけ、符号拡張を伴う bitwise right shift を行う。

13.9.2.1 Runtime Semantics: Evaluation

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

13.9.3 Unsigned Right Shift Operator ( >>> )

Note

左 operand に対して、右 operand によって指 定された量だけ、0 埋めの bitwise right shift を 行う。

13.9.3.1 Runtime Semantics: Evaluation

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

13.10 Relational Operator

Note 1

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

構文

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] 文法 parameter は、 relational expression における in 演算子と、 for 文における in 演算子とを混同しないために必 要である。

13.10.1 Runtime Semantics: Evaluation

RelationalExpression : RelationalExpression < ShiftExpression
  1. lRef を ? Evaluation of RelationalExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of ShiftExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. result を ? IsLessThan(lVal, rVal, true) とする。
  6. result が undefined なら、false を返す。
  7. result を返す。
 RelationalExpression : RelationalExpression > ShiftExpression
  1. lRef を ? Evaluation of RelationalExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of ShiftExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. result を ? IsLessThan(rVal, lVal, false) とする。
  6. result が undefined なら、false を返す。
  7. result を返す。
 RelationalExpression : RelationalExpression <= ShiftExpression
  1. lRef を ? Evaluation of RelationalExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of ShiftExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. result を ? IsLessThan(rVal, lVal, false) とする。
  6. result が true または undefined のいずれかなら、false を返す。
  7. true を返す。
 RelationalExpression : RelationalExpression >= ShiftExpression
  1. lRef を ? Evaluation of RelationalExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of ShiftExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. result を ? IsLessThan(lVal, rVal, true) とする。
  6. result が true または undefined のいずれかなら、false を返す。
  7. true を返す。
 RelationalExpression : RelationalExpression instanceof ShiftExpression
  1. lRef を ? Evaluation of RelationalExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of ShiftExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. ? InstanceofOperator(lVal, rVal) を返 す。
 RelationalExpression : RelationalExpression in ShiftExpression
  1. lRef を ? Evaluation of RelationalExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of ShiftExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. rVal が Object でなければ、 TypeError 例外を送出する。
  6. ? HasProperty(rVal, ? ToPropertyKey(lVal)) を返す。
 RelationalExpression : PrivateIdentifier in ShiftExpression
  1. privateIdentifier を PrivateIdentifier の StringValue とする。
  2. rRef を ? Evaluation of ShiftExpression とする。
  3. rVal を ? GetValue(rRef) とする。
  4. rVal が Object でなければ、 TypeError 例外を送出する。
  5. privateEnv を、running execution context の PrivateEnvironment とする。
  6. Assert: privateEnv は null ではな い。
  7. privateName を ResolvePrivateIdentifier(privateEnv, privateIdentifier) とする。
  8. PrivateElementFind(rVal, 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. これは、value が target の instance であるかどうかを判定する一般 algorithm を実装する。そ れは target の %Symbol.hasInstance% method を 参照するか、もしそれが存在しなければ、target の "prototype" property の値が value の prototype chain に存在するかどうかを判定する。 It performs the following steps when called:

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

steps 4 および 5 は、instanceof 演算子の意味論を定義するのに %Symbol.hasInstance% method を使用していなかっ た以前の ECMAScript 版との互換性を提供する。object が %Symbol.hasInstance% を定義も継承もしていない 場合、それは default の instanceof 意味論を用い る。

13.11 Equality Operator

Note

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

構文

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. lRef を ? Evaluation of EqualityExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of RelationalExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. ? IsLooselyEqual(rVal, lVal) を返す。
 EqualityExpression : EqualityExpression != RelationalExpression
  1. lRef を ? Evaluation of EqualityExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of RelationalExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. r を ? IsLooselyEqual(rVal, lVal) とする。
  6. r が true なら、false を返す。
  7. true を返す。
 EqualityExpression : EqualityExpression === RelationalExpression
  1. lRef を ? Evaluation of EqualityExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of RelationalExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. IsStrictlyEqual(rVal, lVal) を返す。
 EqualityExpression : EqualityExpression !== RelationalExpression
  1. lRef を ? Evaluation of EqualityExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of RelationalExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. r を IsStrictlyEqual(rVal, lVal) と する。
  6. r が true なら、false を返す。
  7. true を返す。
 Note 1

equality operator は次の不変条件を維持す る:

  • A != B は !(A == B) と等価である。
  • A == B は、A と B の評価順序を除け ば、B == A と等価である。
Note 2

equality operator は常に推移的であるわけ ではない。たとえば、同じ String 値を表す 2 つの異な る String object があり得る; それぞれの String object は == 演算子によりその String 値と等しい と見なされるが、2 つの String object 同士は互いに 等しくはない。たとえば:

  • new String("a") == "a" および "a" == new String("a") はどちらも true である。
  • new String("a") == new String("a") は false である。
Note 3

String の比較は、code unit 値列に対する単純 な等値判定を用いる。Unicode 仕様で定義される、より複 雑で意味論指向の文字または文字列の等値性および照合順序の 定義を使用しようとはしない。したがって、Unicode Standard によれば正準同値である String 値が、不 等であると判定され得る。実質的に、この algorithm は 両方の String がすでに正規化済みであると仮定してい る。

13.12 Binary Bitwise Operator

構文

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 Operator

構文

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

&& または || 演算子が生成する値は、 必ずしも Boolean 型ではない。生成される値は常に、2 つの operand 式のうちどちらか一方の値である。

13.13.1 Runtime Semantics: Evaluation

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

13.14 Conditional Operator ( ? : )

構文

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

ECMAScript における ConditionalExpression の 文法は、C や Java におけるそれとわずかに異なる。C や Java は 2 番目の部分式として Expression を許可す る一方、3 番目の式を ConditionalExpression に制 限している。ECMAScript におけるこの差異の動機は、代 入式が条件のどちらの枝にも支配され得るようにすること、お よび中央の式として comma expression を使うという混乱 を招きやすく、かつほとんど有用でない場合を排除することで ある。

13.14.1 Runtime Semantics: Evaluation

ConditionalExpression : ShortCircuitExpression ? AssignmentExpression : AssignmentExpression
  1. lRef を ? Evaluation of ShortCircuitExpression とする。
  2. lVal を ToBoolean(? GetValue(lRef)) とする。
  3. lVal が true なら、
    1. trueRef を、最初の AssignmentExpression の Evaluation の ? とする。
    2. ? GetValue(trueRef) を返す。
  4. falseRef を、2 番目の AssignmentExpression の Evaluation の ? とする。
  5. ? GetValue(falseRef) を返す。

13.15 Assignment Operator

構文

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

13.15.1 Static Semantics: Early Errors

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

13.15.2 Runtime Semantics: Evaluation

AssignmentExpression : LeftHandSideExpression = AssignmentExpression
  1. LeftHandSideExpression が ObjectLiteral でも ArrayLiteral でも ないなら、
    1. lRef を ? Evaluation of LeftHandSideExpression とする。
    2. LeftHandSideExpression の AssignmentTargetType が web-compat なら、ReferenceError 例外を送出す る。
    3. IsAnonymousFunctionDefinition( AssignmentExpression) が true であ り、かつ IsIdentifierRef of LeftHandSideExpression が true なら、
      1. lhs を LeftHandSideExpression の StringValue とする。
      2. rVal を、lhs を引数とする AssignmentExpression の NamedEvaluation の ? とする。
    4. Else,
      1. rRef を ? Evaluation of AssignmentExpression とする。
      2. rVal を ? GetValue(rRef) とす る。
    5. ? PutValue(lRef, rVal) を実行する。
    6. rVal を返す。
  2. assignmentPattern を、 LeftHandSideExpression によって cover される AssignmentPattern とする。
  3. rRef を ? Evaluation of AssignmentExpression とする。
  4. rVal を ? GetValue(rRef) とする。
  5. rVal を引数として assignmentPattern の DestructuringAssignmentEvaluation を ? 実行する。
  6. rVal を返す。
 AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
  1. lRef を ? Evaluation of LeftHandSideExpression とする。
  2. LeftHandSideExpression の AssignmentTargetType が web-compat なら、ReferenceError 例外を送出する。
  3. lVal を ? GetValue(lRef) とする。
  4. rRef を ? Evaluation of AssignmentExpression とする。
  5. rVal を ? GetValue(rRef) とする。
  6. assignmentOpText を AssignmentOperator に一致した source text とする。
  7. opText を、以下の表において assignmentOpText に対応付けられる Unicode code point 列とする:
    assignmentOpText opText
    **= **
    *= *
    /= /
    %= %
    += +
    -= -
    <<= <<
    >>= >>
    >>>= >>>
    &= &
    ^= ^
    |= |
  8. r を ? ApplyStringOrNumericBinaryOperator(lVal, opText, rVal) とする。
  9. ? PutValue(lRef, r) を実行す る。
  10. r を返す。
 AssignmentExpression : LeftHandSideExpression &&= AssignmentExpression
  1. lRef を ? Evaluation of LeftHandSideExpression とする。
  2. lVal を ? GetValue(lRef) と する。
  3. ToBoolean(lVal) が false なら、 lVal を返す。
  4. IsAnonymousFunctionDefinition( AssignmentExpression) が true であり、 かつ IsIdentifierRef of LeftHandSideExpression が true なら、
    1. lhs を LeftHandSideExpression の StringValue とする。
    2. rVal を、lhs を引数とする AssignmentExpression の NamedEvaluation の ? とする。
  5. Else,
    1. rRef を ? Evaluation of AssignmentExpression とする。
    2. rVal を ? GetValue(rRef) とする。
  6. ? PutValue(lRef, rVal) を実 行する。
  7. rVal を返す。
 AssignmentExpression : LeftHandSideExpression ||= AssignmentExpression
  1. lRef を ? Evaluation of LeftHandSideExpression とする。
  2. lVal を ? GetValue(lRef) とす る。
  3. ToBoolean(lVal) が true なら、 lVal を返す。
  4. IsAnonymousFunctionDefinition( AssignmentExpression) が true であり、 かつ IsIdentifierRef of LeftHandSideExpression が true なら、
    1. lhs を LeftHandSideExpression の StringValue とする。
    2. rVal を、lhs を引数とする AssignmentExpression の NamedEvaluation の ? とする。
  5. Else,
    1. rRef を ? Evaluation of AssignmentExpression とする。
    2. rVal を ? GetValue(rRef) とする。
  6. ? PutValue(lRef, rVal) を実行 する。
  7. rVal を返す。
 AssignmentExpression : LeftHandSideExpression ??= AssignmentExpression
  1. lRef を ? Evaluation of LeftHandSideExpression とする。
  2. lVal を ? GetValue(lRef) とする。
  3. lVal が undefined でも null でも ないなら、lVal を返す。
  4. IsAnonymousFunctionDefinition( AssignmentExpression) が true であり、 かつ IsIdentifierRef of LeftHandSideExpression が true なら、
    1. lhs を LeftHandSideExpression の StringValue とする。
    2. rVal を、lhs を引数とする AssignmentExpression の NamedEvaluation の ? とする。
  5. Else,
    1. rRef を ? Evaluation of AssignmentExpression とする。
    2. rVal を ? GetValue(rRef) とする。
  6. ? PutValue(lRef, rVal) を 実行する。
  7. rVal を返す。
 Note

この式が strict mode code の内部に現れると き、step 1.e、 3、 2、 2、 2 における lRef が unresolvable reference である 場合、それは runtime error である。その場合、 ReferenceError 例外が送出される。さらに、step 9、 6、 6、 6 における lRef が、 { [[Writable]]: false } という属性値を持つ data property への reference、{ [[Set]]: undefined } という属性値を持つ accessor property への reference、または IsExtensible predicate が false を返す object の存在しない property への reference である場合も runtime error である。これらの場合 には TypeError 例外が送出される。

13.15.3 ApplyStringOrNumericBinaryOperator ( lVal, opText, rVal )

The abstract operation ApplyStringOrNumericBinaryOperator takes arguments lVal (an ECMAScript language value), opText (**, *, /, %, +, -, <<, >>, >>>, &, ^, or |), and rVal (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. lPrim を ? ToPrimitive(lVal) とする。
    2. rPrim を ? ToPrimitive(rVal) とする。
    3. lPrim が String または rPrim が String な ら、
      1. lStr を ? ToString(lPrim) とす る。
      2. rStr を ? ToString(rPrim) とす る。
      3. lStr と rStr の string-concatenation を返す。
    4. lVal を lPrim に設定する。
    5. rVal を rPrim に設定する。
  2. NOTE: この時点で、それは数値演算でなければなら ない。
  3. lNum を ? ToNumeric(lVal) とする。
  4. rNum を ? ToNumeric(rVal) とする。
  5. SameType(lNum, rNum) が false な ら、TypeError 例外を送出する。
  6. lNum が BigInt なら、
    1. opText が ** なら、 ? BigInt::exponentiate(lNum, rNum) を返す。
    2. opText が / なら、 ? BigInt::divide(lNum, rNum) を返 す。
    3. opText が % なら、 ? BigInt::remainder(lNum, rNum) を返す。
    4. opText が >>> なら、 ? BigInt::unsignedRightShift(lNum, rNum) を返す。
    5. operation を、以下の表において opText に対応付けられる abstract operation とする:
      opText operation
      * BigInt::multiply
      + BigInt::add
      - BigInt::subtract
      << BigInt::leftShift
      >> BigInt::signedRightShift
      & BigInt::bitwiseAND
      ^ BigInt::bitwiseXOR
      | BigInt::bitwiseOR
  7. Else,
    1. Assert: lNum は Number である。
    2. operation を、以下の表において 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(lNum, rNum) を返す。
 Note 1

steps 1.a および 1.b における ToPrimitive の呼出しには hint は与えられ ない。Date を除くすべての標準 object は、hint が ない場合を number が与えられた場合と同様に扱う; Date は、hint がない場合を string が与えられた 場合と同様に扱う。特殊 object は、hint がない場合を 別の方法で扱ってもよい。

Note 2

step 1.c は、論理 and 演算の代わりに論理 or 演算を用いる点 で、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. lRef を ? Evaluation of leftOperand とする。
  2. lVal を ? GetValue(lRef) とする。
  3. rRef を ? Evaluation of rightOperand とする。
  4. rVal を ? GetValue(rRef) とする。
  5. ? ApplyStringOrNumericBinaryOperator(lVal, opText, rVal) を返す。

13.15.5 Destructuring Assignment

補助構文

ある特定の状況において、次の production の instance を処理するとき
AssignmentExpression : LeftHandSideExpression = AssignmentExpression
LeftHandSideExpression の解釈は、以下の文法を 用いて精密化される:

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

13.15.5.1 Static Semantics: Early Errors

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

13.15.5.2 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]] is 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]] is 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. これは、destructure されたすべての property key の 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. lRef を ? ResolveBinding(propertyName) とする。
  3. v を ? GetV(value, propertyName) とする。
  4. Initializer が存在し、かつ v が undefined なら、
    1. IsAnonymousFunctionDefinition( Initializer) が true なら、
      1. v を、propertyName を引数とする Initializer の NamedEvaluation の ? に設定する。
    2. Else,
      1. defaultValue を ? Evaluation of Initializer とする。
      2. v を ? GetValue(defaultValue) に設定する。
  5. ? PutValue(lRef, v) を実行する。
  6. « propertyName » を返す。
 AssignmentProperty : PropertyName : AssignmentElement
  1. name を ? Evaluation of PropertyName とする。
  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. lRef を ? Evaluation of DestructuringAssignmentTarget とする。
  2. restObj を OrdinaryObjectCreate(%Object.prototype%) とする。
  3. ? CopyDataProperties(restObj, value, excludedNames) を実行する。
  4. ? PutValue(lRef, 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. lRef を ? Evaluation of DestructuringAssignmentTarget とす る。
  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 であり、か つ IsIdentifierRef of DestructuringAssignmentTarget が true なら、
      1. target を DestructuringAssignmentTarget の StringValue とする。
      2. v を、target を引数とする Initializer の NamedEvaluation の ? とする。
    2. Else,
      1. defaultValue を ? Evaluation of Initializer とする。
      2. v を ? GetValue(defaultValue) とする。
  5. Else,
    1. v を value とする。
  6. DestructuringAssignmentTarget が ObjectLiteral または ArrayLiteral のいずれかなら、
    1. nestedAssignmentPattern を、 DestructuringAssignmentTarget によ って cover される AssignmentPattern とする。
    2. v を引数とする nestedAssignmentPattern の DestructuringAssignmentEvaluation を ? 返す。
  7. ? PutValue(lRef, v) を返す。
 Note

destructuring pattern ではない DestructuringAssignmentTarget を iterator へ のアクセスまたは Initializer の評価より前に評価す ることにより、左から右への評価順序が維持される。

AssignmentRestElement : ... DestructuringAssignmentTarget
  1. DestructuringAssignmentTarget が ObjectLiteral でも ArrayLiteral でもないなら、
    1. lRef を ? Evaluation of DestructuringAssignmentTarget とす る。
  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(lRef, 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. lRef を ? Evaluation of DestructuringAssignmentTarget とす る。
  2. v を ? GetV(value, propertyName) とする。
  3. Initializer が存在し、かつ v が undefined なら、
    1. IsAnonymousFunctionDefinition( Initializer) が true であり、か つ IsIdentifierRef of DestructuringAssignmentTarget が true なら、
      1. target を DestructuringAssignmentTarget の StringValue とする。
      2. rhsValue を、target を引数とす る Initializer の NamedEvaluation の ? とする。
    2. Else,
      1. defaultValue を ? Evaluation of Initializer とする。
      2. rhsValue を ? GetValue(defaultValue) とする。
  4. Else,
    1. rhsValue を v とする。
  5. DestructuringAssignmentTarget が ObjectLiteral または ArrayLiteral のいずれかなら、
    1. assignmentPattern を、 DestructuringAssignmentTarget によ って cover される AssignmentPattern とする。
    2. rhsValue を引数とする assignmentPattern の DestructuringAssignmentEvaluation を ? 返す。
  6. ? PutValue(lRef, rhsValue) を返す。

13.16 Comma Operator ( , )

構文

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

13.16.1 Runtime Semantics: Evaluation

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

GetValue は、その値が使用されないとしても、観測 可能な副作用を持つことがあるため、呼び出されなければなら ない。