このページはECMAScript® 2020 Language Specificationの 12 ECMAScript Language: Expressions章をJavaScriptの学習目的で私的に日本語訳したものであり、直訳と意訳および推測が混在しています。そのため内容については正確ではない可能性があります。正確な情報を知りたい場合は、原文をご覧ください。また一部訳者によるコメントが含まれていることがあります。※このサイトの内容で損害や不利益を受けたとしても当方は一切の責任を負いません。

12.1 識別子(Identifiers)

構文：

IdentifierReference[Yield, Await] :
Identifier
[~Yield]yield
[~Await]await
BindingIdentifier[Yield, Await] :
Identifier
yield
await
LabelIdentifier[Yield, Await] :
Identifier
[~Yield]yield
[~Await]await
yield と await は文法で BindingIdentifier として許可され、以降の項の静的セマンティクスでは禁止されており、次のようなときに自動セミコロン挿入を禁止します。

let
await 0;

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

BindingIdentifier : Identifier
  • このプロダクションに一致するコードがstrictモードコードに含まれ、IdentifierのStringValueが"eval"または"arguments"である場合、構文エラーです。
IdentifierReference : yield
BindingIdentifier : yield
LabelIdentifier : yield
  • このプロダクションと一致するコードがstrictモードコードに含まれている場合、構文エラーです。
IdentifierReference : await
BindingIdentifier : await
LabelIdentifier : await
BindingIdentifier[Yield, Await] : yield
  • このプロダクションに[Yield]パラメータがある場合、構文エラーです。
BindingIdentifier[Yield, Await] : await
  • このプロダクションに[Await]パラメータがある場合、構文エラーです。
IdentifierReference[Yield, Await] : Identifier
BindingIdentifier[Yield, Await] : Identifier
LabelIdentifier[Yield, Await] : Identifier
  • このプロダクションに[Yield]パラメータがあり、IdentifierのStringValue が "yield" の場合は、構文エラーです。
  • このプロダクションに[Await]パラメータがあり、IdentifierのStringValue が "await" の場合は、構文エラーです。
Identifier : IdentifierName ReservedWord
  • このフレーズがstrictモードコードに含まれ、IdentifierNameのStringValueが"implements"、 "interface"、 "let"、 "package"、 "private"、 "protected"、 "public"、 "static"、 "yield" の場合は、構文エラーです。
  • 構文文法のゴールシンボルがModuleで、IdentifierNameのStringValueが"await"の場合は、構文エラーです。
  • IdentifierName
    のStringValueが、"yield"または"await"を除いて、ReservedWordのStringValueと同じ値である場合は、構文エラーです。
IdentifierNameのStringValueは、IdentifierNameのUnicodeエスケープシーケンスを正規化します。そのためエスケープを使用して、コードポイントシーケンスがReservedWordと同じであるIdentifierを書き込むことはできません。

12.1.2 静的セマンティクス(Static Semantics)：BoundNames

BindingIdentifier : Identifier
  1. IdentifierのStringValueを含む新しいリストを返す
BindingIdentifier : yield
  1. "yield"を含む新しいリストを返す
BindingIdentifier : await
  1. "await"を含む新しいリストを返す

12.1.3 静的セマンティクス(Static Semantics)：AssignmentTargetType

IdentifierReference : Identifier
  1. IdentifierReferenceがstrictモードコードに含まれていて、IdentifierのStringValueが"eval"または"arguments"の場合、invalidを返す。
  2. simpleを返す
IdentifierReference : yield
  1. simpleを返す
IdentifierReference : await
  1. simpleを返す

12.1.4 静的セマンティクス(Static Semantics)：StringValue

IdentifierReference : yield
BindingIdentifier : yield
LabelIdentifier : yield
  1. "yield"を返す
IdentifierReference : await
BindingIdentifier : await
LabelIdentifier : await
  1. "await"を返す
Identifier : IdentifierName ReservedWord
  1. IdentifierNameのStringValueを返す

12.1.5 ランタイムセマンティクス(Runtime Semantics)：BindingInitialization

パラメータvalue と environmentを使用します。

environmentがundefinedのとき、PutValueで初期化値を割り当てる必要があります。 これは、一部の非strict関数のvarステートメントと仮パラメーターリストの場合です（9.2.10を参照）。 これらの場合、レキシカルバインディングはその初期化子の評価前に巻き上げられ、事前に初期化されます。
BindingIdentifier : Identifier
  1. IdentifierのStringValue を name とする
  2. ? InitializeBoundName(name, value, environment)を返す
BindingIdentifier : yield
  1. ? InitializeBoundName("yield", value, environment)を返す
BindingIdentifier : await
  1. ? InitializeBoundName("await", value, environment)を返す

12.1.5.1 ランタイムセマンティクス(Runtime Semantics)： InitializeBoundName ( name, value, environment )

  1. Assert: Type(name) は String型
  2. environment が undefined でないなら、
    1. environment　の EnvironmentRecord を env とする
    2. env.InitializeBinding(name, value)を実行
    3. NormalCompletion(undefined)を返す
  3. Else,
    1. ResolveBinding(name) を lhs とする
    2. ? PutValue(lhs, value)を返す

12.1.6 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

IdentifierReference : Identifier
  1. ? ResolveBinding(IdentifierのStringValue )を返す
IdentifierReference : yield
  1. ? ResolveBinding( "yield" )を返す
IdentifierReference : await
  1. ? ResolveBinding( "await" )を返す
IdentifierReferenceの評価結果は、常にReference型の値です。
非strictコードでは、キーワードyieldを識別子として使用できます。 IdentifierReferenceを評価すると、Identifierであるかのように、yieldのバインディングが解決されます。 早期エラー制限により、このような評価が非strictコードに対してのみ発生することが保証されます。

12.2 一次式(Primary Expression)

構文：

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

補足構文：

次のプロダクションのインスタンスを処理するとき

PrimaryExpression[Yield, Await] : CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]

CoverParenthesizedExpressionAndArrowParameterListの解釈は、次の文法を使用して改善されます。

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

12.2.1 セマンティクス(Semantics)

12.2.1.1 静的セマンティクス(Static Semantics): CoveredParenthesizedExpression

CoverParenthesizedExpressionAndArrowParameterList : (Expression )
  1. CoverParenthesizedExpressionAndArrowParameterListによってカバーされるParenthesizedExpressionを返す

12.2.1.2 静的セマンティクス(Static Semantics): HasName

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. CoverParenthesizedExpressionAndArrowParameterList の CoveredParenthesizedExpression を expr とする
  2. expr のIsFunctionDefinitionが false なら、 false を返す
  3. expr　の HasName を返す

12.2.1.3 静的セマンティクス(Static Semantics): IsFunctionDefinition

PrimaryExpression :
this
IdentifierReference
Literal
ArrayLiteral
ObjectLiteral
RegularExpressionLiteral
TemplateLiteral
  1. false を返す
PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. CoverParenthesizedExpressionAndArrowParameterList の CoveredParenthesizedExpression　を expr とする
  2. expr の IsFunctionDefinition を返す

12.2.1.4 静的セマンティクス(Static Semantics): IsIdentifierRef

PrimaryExpression :
IdentifierReference
  1. true を返す
PrimaryExpression :
this
Literal
ArrayLiteral
ObjectLiteral
FunctionExpression
ClassExpression
GeneratorExpression
AsyncFunctionExpression
AsyncGeneratorExpression
RegularExpressionLiteral
TemplateLiteral
CoverParenthesizedExpressionAndArrowParameterList
  1. false を返す

12.2.1.5 静的セマンティクス(Static Semantics): AssignmentTargetType

PrimaryExpression :
this
Literal
ArrayLiteral
ObjectLiteral
FunctionExpression
ClassExpression
GeneratorExpression
AsyncFunctionExpression
AsyncGeneratorExpression
RegularExpressionLiteral
TemplateLiteral
  1. invalid を返す
PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. CoverParenthesizedExpressionAndArrowParameterList　の CoveredParenthesizedExpression を expr とする
  2. expr の AssignmentTargetType を返す

12.2.2 thisキーワード(The this Keyword)

12.2.2.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

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

12.2.3 識別子参照(Identifier Reference)

IdentifierReferenceについては、12.1を参照

12.2.4 リテラル(Literals)

構文：

12.2.4.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

Literal : NullLiteral
  1. null を返す
Literal : BooleanLiteral
  1. BooleanLiteral が falseトークンなら、 false を返す
  2. BooleanLiteral が trueトークンなら、 true を返す
Literal : NumericLiteral
  1. 11.8.3で定義されているNumericLiteralのNumericValueを返す
Literal : StringLiteral
  1. 11.8.4.1で定義されているStringLiteralのStringValueを返す

12.2.5 配列初期化子(Array Initializer)

ArrayLiteralは、配列要素を表す0個以上の式を角括弧で囲んだリストを使用して、Arrayオブジェクトの初期化をおこなう式です。 要素はリテラルである必要はありません。 配列初期化子はその都度評価されます。

配列要素は、要素リストの最初、中間、最後を省略できます。 要素リストのカンマの前にAssignmentExpression（つまり、最初または別のカンマの後にあるカンマ）がない場合は、欠落している配列要素が配列の長さに影響し、後続要素のインデックスが増加させます。 省略された配列要素は定義されていません。 要素が配列の最後で省略されている場合、その要素は配列の長さに影響しません。

構文：

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]
SpreadElement[Yield, Await]:
...AssignmentExpression[+In, ?Yield, ?Await]

12.2.5.1 ランタイムセマンティクス(Runtime Semantics): ArrayAccumulation

パラメータ array と nextIndexを使用します。

Elision : ,
  1. nextIndex + 1 を len とする
  2. ? Set(array, "length", len, true)を実行
  3. NOTE: 上のSetは、len が 232-1 をこえるとき、例外が発生する
  4. len を返す
Elision : Elision ,
  1. 引数 array と nextIndex + 1 を使用して Elision の ArrayAccumulationを実行した結果を返す
ElementList : Elisionopt AssignmentExpression
  1. Elision が存在するなら、
    1. 引数 array と nextIndex を使用して Elision のArrayAccumulationを実行した結果 を nextIndex にセットする
    2. ReturnIfAbrupt(nextIndex)
  2. AssignmentExpression の評価結果 を initResult とする
  3. ? GetValue(initResult) を initValue とする
  4. ! CreateDataPropertyOrThrow(array, ! ToString(nextIndex), initValue) を created とする
  5. nextIndex + 1 を返す
ElementList : Elisionopt SpreadElement
  1. Elision が存在するなら、
    1. 引数 array と nextIndex を使用してElision のArrayAccumulationを実行した結果 を nextIndex にセットする
    2. ReturnIfAbrupt(nextIndex)
  2. 引数 array と nextIndex を使用して SpreadElement の ArrayAccumulation を実行した結果を返す
ElementList : ElementList ,Elisionopt AssignmentExpression
  1. 引数 array と nextIndex を使用してElementListのArrayAccumulationを実行した結果 を nextIndex にセットする
  2. ReturnIfAbrupt(nextIndex)
  3. Elision が存在するなら、
    1. 引数 array と nextIndex を使用してElisionのArrayAccumulationを実行した結果 を nextIndex にセットする
    2. ReturnIfAbrupt(nextIndex)
  4. AssignmentExpressionの評価結果 を initResult とする
  5. ? GetValue(initResult) を initValue とする
  6. ! CreateDataPropertyOrThrow(array, !ToString(nextIndex), initValue) を created とする
  7. nextIndex + 1を返す
ElementList : ElementList ,Elisionopt SpreadElement
  1. 引数 array と nextIndex を使用してElementListの ArrayAccumulationを実行した結果を nextIndex にセットする
  2. ReturnIfAbrupt(nextIndex)
  3. Elision が存在するなら、
    1. 引数arrayとnextIndexを使用してElisionのArrayAccumulationを実行した結果 を nextIndex にセットする
    2. ReturnIfAbrupt(nextIndex)
  4. 引数 array と nextIndex を使用して SpreadElement の ArrayAccumulation を実行した結果を返す
SpreadElement : ...AssignmentExpression
  1. AssignmentExpression の評価結果 を spreadRef とする
  2. ? GetValue(spreadRef) を spreadObj とする
  3. ? GetIterator(spreadObj) を iteratorRecord とする
  4. 以下を繰り返す
    1. ? IteratorStep(iteratorRecord) を next とする
    2. next が false なら、nextIndex を返す
    3. ? IteratorValue(next) を nextValue とする
    4. ! CreateDataPropertyOrThrow(array, !ToString(nextIndex), nextValue)を実行
    5. nextIndex + 1 を nextIndex にセット
[[Set]]を使用して新しい独自プロパティを作成できないように標準組み込みArrayプロトタイプオブジェクトが変更されている場合でも、独自プロパティが配列に定義できるようにするためにCreateDataPropertyOrThrowが使用されます。

12.2.5.2 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

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

12.2.6 オブジェクト初期化子(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]
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]
MethodDefinition については、 14.3参照
特定のコンテキストでは、ObjectLiteralは、より制限された二次文法のカバー文法として使用されます。 CoverInitializedNameプロダクションは、これらの二次文法を完全にカバーするために必要です。 ただし、このプロダクションを使用すると、実際のObjectLiteralが予想される通常のコンテキストで初期の構文エラーが発生します。

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

PropertyDefinition : MethodDefinition
  • MethodDefinitionのHasDirectSuperがtrueの場合は、構文エラーです。

ObjectLiteralプロダクションはObjectAssignmentPatternのカバー文法としても使用され、CoverParenthesizedExpressionAndArrowParameterListの一部として認識される場合があります。 ObjectLiteralがObjectAssignmentPatternを必要とするコンテキストで表示される場合、以下の早期エラールールは適用されません。 さらに、CoverParenthesizedExpressionAndArrowParameterListまたはCoverCallExpressionAndAsyncArrowHeadの最初の解析時、これらは適用されません。

PropertyDefinition : CoverInitializedName
  • コードがこのプロダクションと一致する場合は、常に構文エラーをスローします。
このプロダクションは、ObjectLiteralがObjectAssignmentPatternのカバー文法として機能することを目的として存在します。 実際のオブジェクト初期化子では発生しません。

12.2.6.2 静的セマンティクス(Static Semantics): ComputedPropertyContains

パラメータ symbol を使用。

PropertyName : LiteralPropertyName
  1. false を返す
PropertyName : ComputedPropertyName
  1. ComputedPropertyName Contains symbolの結果を返す

12.2.6.3 静的セマンティクス(Static Semantics): Contains

パラメータ symbol を使用。

PropertyDefinition : MethodDefinition
  1. symbol MethodDefinition なら、 true を返す
  2. 引数symbolを使用して MethodDefinitionのComputedPropertyContainsの結果を返す
通常、部分構造に依存する静的セマンティックルールは関数定義を調べません。
LiteralPropertyName : IdentifierName
  1. symbol が ReservedWord , false を返す.
  2. symbol が Identifier で、symbol の StringValue がIdentifierName の StringValue と同じなら、true をす
  3. false を返す

12.2.6.4 静的セマンティクス(Static Semantics): IsComputedPropertyKey

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

12.2.6.5 静的セマンティクス(Static Semantics): PropName

PropertyDefinition : IdentifierReference
  1. IdentifierReference の StringValue を返す
PropertyDefinition : ...AssignmentExpression
  1. emptyを返す
PropertyDefinition : PropertyName :AssignmentExpression
  1. PropertyName の PropName を返す
LiteralPropertyName : IdentifierName
  1. IdentifierName の StringValue を返す
LiteralPropertyName : StringLiteral
  1. コードユニットがStringLiteralのSVであるString値を返す
LiteralPropertyName : NumericLiteral
  1. NumericLiteral の NumericValue を nbr とする
  2. ! ToString(nbr)を返す
ComputedPropertyName : [AssignmentExpression ]
  1. emptyを返す

12.2.6.6 静的セマンティクス(Static Semantics): PropertyNameList

PropertyDefinitionList : PropertyDefinition
  1. PropertyDefinition の PropName　が empty なら、 空の新規 List を返す
  2. PropertyDefinition の PropName を含む新規 Listを返す
PropertyDefinitionList : PropertyDefinitionList ,PropertyDefinition
  1. PropertyDefinitionList の PropertyNameList を list とする
  2. PropertyDefinition の PropName が empty なら、 list を返す
  3. PropertyDefinition の PropName を list の最後に追加する
  4. listを返す

12.2.6.7 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ObjectLiteral : {}
  1. OrdinaryObjectCreate(%Object.prototype%)を返す
ObjectLiteral :
{PropertyDefinitionList }
{PropertyDefinitionList ,}
  1. OrdinaryObjectCreate(%Object.prototype%) を obj とする
  2. 引数 obj と true を使用して ? PropertyDefinitionList の PropertyDefinitionEvaluation を実行
  3. obj　を返す
LiteralPropertyName : IdentifierName
  1. IdentifierName の StringValue を返す
LiteralPropertyName : StringLiteral
  1. コードユニットがStringLiteralのSVであるString値を返す
LiteralPropertyName : NumericLiteral
  1. NumericLiteral の NumericValue を nbr とする
  2. ! ToString(nbr) を返す
ComputedPropertyName : [AssignmentExpression ]
  1. AssignmentExpression の評価結果を exprValue とする
  2. ? GetValue(exprValue) を propName とする
  3. ? ToPropertyKey(propName) を返す

12.2.6.8 ランタイムセマンティクス(Runtime Semantics): PropertyDefinitionEvaluation

パラメータ object と enumerable を使用。

PropertyDefinitionList : PropertyDefinitionList ,PropertyDefinition
  1. 引数object と enumerable を使用して、? PropertyDefinitionList の PropertyDefinitionEvaluation を実行
  2. 引数object と enumerable を使用して、PropertyDefinition の PropertyDefinitionEvaluation の実行結果を返す
PropertyDefinition : ...AssignmentExpression
  1. AssignmentExpression の評価結果 を exprValue とする
  2. ? GetValue(exprValue) を fromValue とする
  3. 空の新規List を excludedNames とする
  4. ? CopyDataProperties(object, fromValue, excludedNames)を返す
PropertyDefinition : IdentifierReference
  1. IdentifierReference の StringValue を propName とする
  2. IdentifierReference の評価結果を exprValue とする
  3. ? GetValue(exprValue) を propValue とする
  4. Assert: enumerable は true
  5. Assert: objectは、構成不可能なプロパティを持っていない、拡張可能な通常のオブジェクト
  6. ! CreateDataPropertyOrThrow(object, propName, propValue)を返す
PropertyDefinition : PropertyName :AssignmentExpression
  1. PropertyName の評価結果を propKey とする
  2. ReturnIfAbrupt(propKey)
  3. IsAnonymousFunctionDefinition(AssignmentExpression ) が true なら、
    1. 引数 propKey を使用して、 AssignmentExpression の NamedEvaluation を propValue とする
  4. Else,
    1. AssignmentExpression の評価結果を exprValueRef とする
    2. ? GetValue(exprValueRef) を propValue とする
  5. Assert: enumerable は true
  6. Assert: objectは、構成不可能なプロパティを持っていない、拡張可能な通常のオブジェクト
  7. ! CreateDataPropertyOrThrow(object, propKey, propValue)を返す
このプロダクションの代替セマンティクスは、B.3.1に示されています。

12.2.7 関数定義式(Function Defining Expressions)

次のプロダクションは14.1を参照

PrimaryExpression : FunctionExpression

次のプロダクションは14.4を参照

PrimaryExpression : GeneratorExpression

次のプロダクションは14.6を参照

PrimaryExpression : ClassExpression

次のプロダクションは14.7を参照

PrimaryExpression : AsyncFunctionExpression

次のプロダクションは14.5を参照

PrimaryExpression : AsyncGeneratorExpression

.

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

構文：

11.8.5を参照

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

PrimaryExpression : RegularExpressionLiteral

12.2.8.2 静的セマンティクス(Static Semantics): IsValidRegularExpressionLiteral ( literal )

抽象演算IsValidRegularExpressionLiteralは、引数literalが有効な正規表現リテラルであるかどうかを判別します。 次の手順を実行します。

  1. Assert: literal は RegularExpressionLiteral
  2. literal の FlagText に g、i、m、s、u、y 以外のコードポイントが含まれている、または同じコードポイントが複数含まれているなら、false を返す
  3. literal の BodyText を P とする
  4. literal の FlagText に u が含まれているなら、
    1. 21.2.1の文法を使用してPを解析する。 その際のゴールシンボル は Pattern[+U, +N]。P が文法に準拠していない、P のいずれかの要素が解析で一致しない、または早期エラー条件が存在するなら false を、 それ以外なら、true を返す
  5. UTF16Encode(P) を stringValue とする
  6. stringValue の各16ビット要素をUnicode BMPコードポイントとして解釈した結果のコードポイントのシーケンス を pText とする。要素にUTF-16デコードは適用されない。
  7. 21.2.1の文法を使用して>pTextを解析する。その際のゴールシンボル は Pattern[~U, ~N]。解析の結果に GroupName が含まれているなら、 ゴールシンボル Pattern[~U, +N] で再解析する。 P が文法に準拠していない、P のいずれかの要素が解析で一致しない、または早期エラー条件が存在するなら false を、 それ以外なら、true を返す

12.2.8.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

PrimaryExpression : RegularExpressionLiteral
  1. ! UTF16Encode(BodyText of RegularExpressionLiteral ) を pattern とする
  2. ! UTF16Encode( RegularExpressionLiteral の FlagText ) を flags とする
  3. RegExpCreate(pattern, flags)を返す

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

構文：

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]

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

TemplateLiteral[Yield, Await, Tagged] : NoSubstitutionTemplate
TemplateLiteral[Yield, Await, Tagged] : SubstitutionTemplate[?Yield, ?Await, ?Tagged]
  • 引数 false を使用して TemplateLiteral の TemplateStrings の 結果 の 要素数が 232-1より大きいなら、構文エラーです。
SubstitutionTemplate[Yield, Await, Tagged] :
TemplateHead Expression[+In, ?Yield, ?Await] TemplateSpans[?Yield, ?Await, ?Tagged]
  • [Tagged]パラメーターが設定されていないとき、TemplateHead に NotEscapeSequence が含まれている場合は、構文エラーです
TemplateSpans[Yield, Await, Tagged] : TemplateTail
  • [Tagged]パラメーターが設定されていないとき、 TemplateTail に NotEscapeSequence が含まれている場合は、構文エラーです
TemplateMiddleList[Yield, Await, Tagged] :
TemplateMiddle Expression[+In, ?Yield, ?Await]
TemplateMiddleList[?Yield, ?Await, ?Tagged] TemplateMiddle Expression[+In, ?Yield, ?Await]
  • [Tagged]パラメーターが設定されていないとき、 TemplateMiddle に NotEscapeSequence が含まれている場合は、構文エラーです

12.2.9.2 静的セマンティクス(Static Semantics): TemplateStrings

パラメータ raw を使用。

TemplateLiteral : NoSubstitutionTemplate
  1. raw が false なら、
    1. NoSubstitutionTemplate の TV を string とする
  2. 1.　でないなら、
    1. NoSubstitutionTemplate の TRV を string とする
  3. stringを含む単一のList を返す
SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. raw が false なら、
    1. TemplateHead のTV を head とする
  2. 1.でないなら
    1. TemplateHead のTRV を head とする
  3. 引数 raw を使用して TemplateSpans の TemplateStrings を tail とする
  4. head の後に、 tail の内容が順番に続く List を返す
TemplateSpans : TemplateTail
  1. raw が false なら、
    1. TemplateTail のTVを tail とする
  2. 1.でないなら
    1. TemplateTail のTRVを tail とする
  3. tail を含む単一のList を返す
TemplateSpans : TemplateMiddleList TemplateTail
  1. 引数 raw を使用して TemplateMiddleList の TemplateStrings を middle とする
  2. raw が false なら、
    1. TemplateTail のTVを tail とする
  3. 2.でないなら
    1. TemplateTail のTRVを tail とする
  4. middle の後に tail が順番に続く List を返す
TemplateMiddleList : TemplateMiddle Expression
  1. raw が false なら、
    1. TemplateMiddle のTVを string とする
  2. 1.でないなら
    1. TemplateMiddle のTRVを string とする
  3. string を含む単一の List を返す
TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. 引数 raw を使用して TemplateMiddleList の TemplateStrings を front とする
  2. raw が false なら、
    1. TemplateMiddle のTVを last とする
  3. 2.でないなら
    1. TemplateMiddle のTRVを last とする
  4. frontの最後に、last を追加する
  5. frontを返す

12.2.9.3 ランタイムセマンティクス(Runtime Semantics): ArgumentListEvaluation

TemplateLiteral : NoSubstitutionTemplate
  1. TemplateLiteral を templateLiteral とする
  2. GetTemplateObject(templateLiteral) を siteObj とする
  3. siteObjを含むListを返す
SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. TemplateLiteral を templateLiteral とする
  2. GetTemplateObject(templateLiteral) を siteObj とする
  3. Expression の評価結果を firstSubRef とする
  4. ? GetValue(firstSubRef) を firstSub とする
  5. ? TemplateSpans の SubstitutionEvaluation を restSub とする
  6. Assert: restSub は List
  7. 最初の要素が siteObj、2番目が firstSub、次がrestSubであるListを返す。restSub には要素を含めることができない。

12.2.9.4 ランタイムセマンティクス(Runtime Semantics): GetTemplateObject ( templateLiteral )

抽象操作GetTemplateObjectは、パースノードtemplateLiteralを引数として呼び出されます。 次の手順を実行します。

  1. 引数 true を使用して templateLiteral の TemplateStrings を rawStrings とする
  2. 現在のレルムレコード を realm とする
  3. realm.[[TemplateMap]] を templateRegistry とする
  4. For each element e of templateRegistry　の要素を e とし、各 e 毎に、
    1. e.[[Site]] が templateLiteral と 同じパースノード なら、
      1. e.[[Array]]を返す
  5. 引数 false を使用して templateLiteral の TemplateStrings を cookedStrings とする
  6. List である cookedStrings の要素数 を count とする
  7. Assert: count ≦ 232 - 1
  8. ! ArrayCreate(count) を template とする
  9. ! ArrayCreate(count) を rawObj とする
  10. 0 を index とする
  11. index ＜ count の間繰り返す
    1. ! ToString(index) を prop とする
    2. cookedStrings[index] のString値を cookedValue とする
    3. template.[[DefineOwnProperty]](prop,プロパティ記述子 { [[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false })　を呼び出す
    4. rawStrings[index] のString値を rawValue とする
    5. rawObj.[[DefineOwnProperty]](prop,プロパティ記述子 { [[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false })を呼び出す
    6. index + 1 を index にセットする
  12. SetIntegrityLevel(rawObj, frozen)を実行
  13. template.[[DefineOwnProperty]]("raw",プロパティ記述子 { [[Value]]: rawObj, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false })を呼び出す
  14. SetIntegrityLevel(template, frozen)を実行
  15. templateRegistryにRecord { [[Site]]: templateLiteral, [[Array]]: template } を追加
  16. templateを返す
テンプレートオブジェクトを作成しても、突然の完了することはありません。
レルムのプログラムコード内の各TemplateLiteralは、タグ付きテンプレートの評価に使用される一意のテンプレートオブジェクトに関連付けられています（12.2.9.6）。 テンプレートオブジェクトはフリーズされ、特定のタグ付きテンプレートが評価されるたびに同じテンプレートオブジェクトが使用されます。 テンプレートオブジェクトがTemplateLiteralの最初の評価時に遅延して作成されるか、最初の評価の前に熱心に作成されるかは、実装での選択です。
この仕様の将来の版では、テンプレートオブジェクトに列挙不可プロパティを追加定義する可能性があります。

12.2.9.5 ランタイムセマンティクス(Runtime Semantics): SubstitutionEvaluation

TemplateSpans : TemplateTail
  1. 空の新規Listを返す
TemplateSpans : TemplateMiddleList TemplateTail
  1. TemplateMiddleList の SubstitutionEvaluation の結果を返す
TemplateMiddleList : TemplateMiddle Expression
  1. Expression の評価結果を subRef とする
  2. ? GetValue(subRef) を sub とする
  3. sub のみを含む List を返す
TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. ? TemplateMiddleList の SubstitutionEvaluation を preceding とする
  2. Expression の評価結果 を nextRef とする
  3. ? GetValue(nextRef) を next とする
  4. Listである preceding の 最後に next を追加する
  5. preceding を返す

12.2.9.6 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

TemplateLiteral : NoSubstitutionTemplate
  1. コードユニットがNoSubstitutionTemplateのTVの要素である文字列値を返す（11.8.6参照）
SubstitutionTemplate : TemplateHead Expression TemplateSpans
  1. the TV of TemplateHead のTVを head とする（11.8.6参照）
  2. Expression の評価結果を subRef とする
  3. ? GetValue(subRef) を sub とする
  4. ? ToString(sub) を middle とする
    5. tail とする
  5. ReturnIfAbrupt(tail)
  6. head、 middle、tail の文字列連結を返す
Expressionの値に適用される文字列変換セマンティクスは、+演算子ではなくString.prototype.concatに似ています。
TemplateSpans : TemplateTail
  1. TemplateTail のTVを tail とする（11.8.6参照）
  2. tail のコードユニットで構成されるString値を返す
TemplateSpans : TemplateMiddleList TemplateTail
  1. TemplateMiddleList の評価結果 を head とする
  2. ReturnIfAbrupt(head)
  3. the TV of TemplateTail のTVを tail とする（11.8.6参照）
  4. head と tail の文字列連結を返す
TemplateMiddleList : TemplateMiddle Expression
  1. the TV of TemplateMiddle のTVを head とする（11.8.6参照）
  2. Expression の評価結果を subRef とする
  3. ? GetValue(subRef) を sub とする
  4. ? ToString(sub) を middle とする
  5. head のコードユニットと、それに続く middle の要素で構成されるコードユニットのシーケンスを返す
Expressionの値に適用される文字列変換セマンティクスは、+演算子ではなくString.prototype.concatに似ています。
TemplateMiddleList : TemplateMiddleList TemplateMiddle Expression
  1. TemplateMiddleList の評価結果を rest とする
  2. ReturnIfAbrupt(rest)
  3. the TV of TemplateMiddle のTVを middle とする（11.8.6参照）/li>
  4. Expression の評価結果を subRef とする
  5. ? GetValue(subRef) を sub とする
  6. ? ToString(sub) を last とする
  7. rest、middle、lastの要素で構成されるコードユニットのシーケンスを返す
Expressionの値に適用される文字列変換セマンティクスは、+演算子ではなくString.prototype.concatに似ています。

12.2.10 グループ化演算子(The Grouping Operator)

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

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList

12.2.10.2 静的セマンティクス(Static Semantics): IsFunctionDefinition

ParenthesizedExpression : (Expression )
  1. Expression の IsFunctionDefinition を返す

12.2.10.3 静的セマンティクス(Static Semantics): AssignmentTargetType

ParenthesizedExpression : (Expression )
  1. Expression の AssignmentTargetType を返す

12.2.10.4 ランタイムセマンティクス(Runtime Semantics): NamedEvaluation

引数 name を使用。

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. of CoverParenthesizedExpressionAndArrowParameterList のCoveredParenthesizedExpression を expr とする
  2. 引数 name を使用して expr の NamedEvaluation を実行した結果を返す
ParenthesizedExpression : (Expression )
  1. Assert: IsAnonymousFunctionDefinition(Expression ) は true
  2. 引数 name を使用して Expression の NamedEvaluation を実行した結果返す

12.2.10.5 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList
  1. of CoverParenthesizedExpressionAndArrowParameterList の CoveredParenthesizedExpression を expr とする
  2. expr の評価結果を返す
ParenthesizedExpression : (Expression )
  1. Expression の評価結果を返す。これはReference型の場合がある。
このアルゴリズムは、Expressionの評価結果に GetValue を適用しません。 これの主な理由は、deleteやtypeofなどの演算子を括弧で囲まれた式に適用できるようにするためです。

12.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
newMemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await]
SuperProperty[Yield, Await] :
super[Expression[+In, ?Yield, ?Await] ]
super.IdentifierName
NewTarget :
new.target
ImportMeta :
import.meta
NewExpression[Yield, Await] :
MemberExpression[?Yield, ?Await]
newNewExpression[?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]
SuperCall[Yield, Await] :
superArguments[?Yield, ?Await]
ImportCall[Yield, Await] :
import(AssignmentExpression[+In, ?Yield, ?Await] )
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]
OptionalChain[?Yield, ?Await] Arguments[?Yield, ?Await]
OptionalChain[?Yield, ?Await] [Expression[+In, ?Yield, ?Await] ]
OptionalChain[?Yield, ?Await] .IdentifierName
OptionalChain[?Yield, ?Await] TemplateLiteral[?Yield, ?Await, +Tagged]
LeftHandSideExpression[Yield, Await] :
NewExpression[?Yield, ?Await]
CallExpression[?Yield, ?Await]
OptionalExpression[?Yield, ?Await]

補足構文：

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

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

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

OptionalChain :
?.TemplateLiteral
OptionalChain TemplateLiteral
  • コードがこのプロダクションに一致する場合、構文エラーです。
このプロダクションは、次のコードが自動セミコロン挿入ルール（11.9）を適用させないために存在します。

a?.b
`c`

上の2行を2つのステートメントとして解釈されるようにします。オプションの連鎖なしで同様のコードとの一貫性を維持するためです。

a.b
`c`

これは有効なステートメントであり、自動セミコロン挿入が適用されません。

ImportMeta :
import.meta

12.3.1.2 静的セマンティクス(Static Semantics): CoveredCallExpression

  1. CoverCallExpressionAndAsyncArrowHead によってカバーされている　CallMemberExpression を返す

12.3.1.3 静的セマンティクス(Static Semantics): Contains

引数 symbol を使用。

MemberExpression : MemberExpression .IdentifierName
  1. MemberExpression の Contains symbol が true なら、 true を返す
  2. symbol が ReservedWord なら false を返す
  3. symbol が Identifier で symbol の StringValue が IdentifierName のStringValue と同じ値なら、 true を返す
  4. false を返す.
SuperProperty : super.IdentifierName
  1. symbol が ReservedWord super なら、 true を返す
  2. symbol が ReservedWord なら false を返す
  3. symbol が Identifier で symbol の StringValue が IdentifierName の StringValue と同じ値なら、 true を返す
  4. false を返す
CallExpression : CallExpression .IdentifierName
  1. CallExpression Contains symbol が true なら、 true を返す
  2. symbol が ReservedWord なら false を返す
  3. symbol が Identifier で symbol　の StringValue が IdentifierName の StringValue と同値なら、 true を返す
  4. false を返す
OptionalChain : ?.IdentifierName
  1. symbol が ReservedWord なら false を返す
  2. symbol が Identifier で symbol　の StringValue が IdentifierName の StringValue と同値なら、 true を返す
  3. false を返す
OptionalChain : OptionalChain .IdentifierName
  1. OptionalChain Contains symbol が true なら、 true を返す
  2. symbol が ReservedWord なら false を返す
  3. symbol が Identifier で symbol　の StringValue が IdentifierName の StringValue と同値なら、 true を返す
  4. false を返す

12.3.1.4 静的セマンティクス(Static Semantics): IsFunctionDefinition

MemberExpression :
MemberExpression [Expression ]
MemberExpression .IdentifierName
MemberExpression TemplateLiteral
SuperProperty
MetaProperty
newMemberExpression Arguments
NewExpression :
newNewExpression
LeftHandSideExpression :
CallExpression
OptionalExpression
  1. false を返す

12.3.1.5 静的セマンティクス(Static Semantics): IsDestructuring

MemberExpression :
PrimaryExpression
  1. PrimaryExpression が ObjectLiteral か ArrayLiteral なら true を返す
  2. false を返す.
MemberExpression :
MemberExpression [Expression ]
MemberExpression .IdentifierName
MemberExpression TemplateLiteral
SuperProperty
MetaProperty
newMemberExpression Arguments
NewExpression :
newNewExpression
LeftHandSideExpression :
CallExpression
OptionalExpression
  1. false を返す

12.3.1.6 静的セマンティクス(Static Semantics): IsIdentifierRef

MemberExpression :
MemberExpression [Expression ]
MemberExpression .IdentifierName
MemberExpression TemplateLiteral
SuperProperty
MetaProperty
newMemberExpression Arguments
NewExpression :
newNewExpression
LeftHandSideExpression :
CallExpression
OptionalExpression
  1. false を返す

12.3.1.7 静的セマンティクス(Static Semantics): AssignmentTargetType

CallExpression :
CallExpression [Expression ]
CallExpression .IdentifierName
MemberExpression :
MemberExpression [Expression ]
MemberExpression .IdentifierName
SuperProperty
  1. simpleを返す
CallExpression :
CoverCallExpressionAndAsyncArrowHead
SuperCall
ImportCall
CallExpression Arguments
CallExpression TemplateLiteral
NewExpression :
newNewExpression
MemberExpression :
MemberExpression TemplateLiteral
newMemberExpression Arguments
NewTarget :
new.target
ImportMeta :
import.meta
LeftHandSideExpression :
OptionalExpression
  1. invalidを返す

12.3.2 プロパティアクセサー(Property Accessors)

プロパティには、ドット + 名前表記でアクセスします。

MemberExpression . IdentifierName
CallExpression . IdentifierName

または角括弧表記でアクセスします。

MemberExpression [ Expression ]
CallExpression [ Expression ]

ドット表記は、次の構文変換によって説明されます。

MemberExpression . IdentifierName

動作は次と同じです。

MemberExpression [ <identifier-name-string> ]

ここで、<identifier-name-string>は、IdentifierName の StringValue を評価した結果です。

同様に

CallExpression . IdentifierName

動作は次と同じです。

CallExpression [ [ <identifier-name-string> ]

12.3.2.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

MemberExpression : MemberExpression [Expression ]
  1. MemberExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. MemberExpression に一致するコードが strictモードコードであるなら、 true を、異なるなら false を strict とする
  4. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression , strict)を返す
MemberExpression : MemberExpression .IdentifierName
  1. MemberExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. MemberExpression に一致するコードが strictモードコードであるなら、true を、異なるなら false を strict とする
  4. ? EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName , strict)を返す
CallExpression : CallExpression [Expression ]
  1. CallExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. CallExpression に一致するコードが strictモードコードであるなら、 true を、異なるなら false を strict とする
  4. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression , strict)を返す
CallExpression : CallExpression .IdentifierName
  1. CallExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. CallExpression に一致するコードが strictモードコードであるなら、 true を、異なるなら false を strict とする
  4. ? EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName , strict)を返す

12.3.3 ランタイムセマンティクス(Runtime Semantics): EvaluatePropertyAccessWithExpressionKey ( baseValue, expression, strict )

抽象操作EvaluatePropertyAccessWithExpressionKeyは、引数として値baseValue、パースノードexpression、およびブール引数strictを取ります。 次の手順を実行します。

  1. expression の評価結果を propertyNameReference とする
  2. ? GetValue(propertyNameReference) を propertyNameValue とする
  3. ? RequireObjectCoercible(baseValue) を bv とする
  4. ? ToPropertyKey(propertyNameValue) を propertyKey とする
  5. 基本値コンポーネントbv、参照名コンポーネントpropertyKey、strict参照フラグstrictのReference型の値を返す

12.3.4 ランタイムセマンティクス(Runtime Semantics): EvaluatePropertyAccessWithIdentifierKey ( baseValue, identifierName, strict )

抽象操作EvaluatePropertyAccessWithIdentifierKeyは、引数として値baseValue、解析ノードidentifierName、およびブール引数strictを取ります。 次の手順を実行します。

  1. Assert: identifierName は IdentifierName
  2. ? RequireObjectCoercible(baseValue) を bv とする
  3. identifierName のStringValueを propertyNameString とする
  4. 基本値コンポーネントbv、参照名コンポーネントpropertyNameString、strict参照フラグstrictのReference型の値を返す

12.3.5 new オペレーター(The new Operator)

12.3.5.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

NewExpression : newNewExpression
  1. ? EvaluateNew(NewExpression , empty)を返す
MemberExpression : newMemberExpression Arguments
  1. ? EvaluateNew(MemberExpression , Arguments )を返す
12.3.5.1.1 ランタイムセマンティクス(Runtime Semantics): EvaluateNew ( constructExpr, arguments )

抽象操作EvaluateNewは引数constructExprとargumentsを使用して、次の手順を実行します。

  1. Assert: constructExpr は NewExpression か MemberExpression
  2. Assert: arguments は empty か Arguments
  3. constructExpr の評価結果を ref とする
  4. ? GetValue(ref) を constructor とする
  5. arguments が empty　なら、 空の新規List を argList とする
  6. 5.でないなら
    1. ? arguments の ArgumentListEvaluation を argList とする
  7. IsConstructor(constructor) が false なら、TypeError例外をスローする
  8. ? Construct(constructor, argList)を返す

12.3.6 関数呼び出し(Function Calls)

12.3.6.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

CallExpression : CoverCallExpressionAndAsyncArrowHead
  1. CoverCallExpressionAndAsyncArrowHead の CoveredCallExpression を expr とする
  2. expr の MemberExpression を memberExpr とする
  3. expr の Arguments を arguments とする
  4. memberExpr の評価結果を ref とする
  5. ? GetValue(ref) を func とする
  6. Type(ref) が Reference型 で、 IsPropertyReference(ref) が false で、 GetReferencedName(ref) が "eval" なら、
    1. SameValue(func, %eval%) が true なら、
      1. ? arguments の ArgumentListEvaluation を argList とする
      2. argList が要素を持っていないなら、 undefined を返す
      3. argList の最初の要素を evalArg とする
      4. CallExpression に一致するソースコードが、 strictモードコード なら、 true を strictCaller とする
        Otherwise false を strictCaller とする
      5. 現在のレルムレコード を evalRealm とする
      6. ? ["18","h-performeval"](evalArg, evalRealm, strictCaller, true)を返す
  7. CallExpression を thisCall とする
  8. IsInTailPosition(thisCall) を tailCall とする
  9. ? EvaluateCall(func, ref, arguments, tailCall)を返す

ダイレクトeval

ステップ6.a.viを実行するCallExpression評価は、ダイレクトevalです。

CallExpression : CallExpression Arguments
  1. CallExpression の評価結果を ref とする
  2. ? GetValue(ref) を func とする
  3. CallExpression を thisCall とする
  4. IsInTailPosition(thisCall) を tailCall とする
  5. ? EvaluateCall(func, ref, Arguments , tailCall)を返す

12.3.6.2 ランタイムセマンティクス(Runtime Semantics): EvaluateCall ( func, ref, arguments, tailPosition )

抽象操作EvaluateCallは、引数として値func、値ref、パースノードarguments、およびブール値tailPositionを取ります。 次の手順を実行します。

  1. Type(ref) が Reference型なら、
    1. IsPropertyReference(ref) が true なら、
      1. GetThisValue(ref) を thisValue とする
    2. a. でないなら、
      1. Assert: ref の ベースは 環境レコード
      2. GetBase(ref) を refEnv とする
      3. refEnv.WithBaseObject() を thisValue とする
        .
  2. 1.でないなら、
    1. undefined を thisValue とする
  3. ? arguments の ArgumentListEvaluation を argList とする
  4. Type(func) が Object型でないなら、TypeError例外をスローする
  5. IsCallable(func) が false なら、TypeError例外をスローする
  6. tailPosition が true なら、PrepareForTailCallCall() を実行する
  7. Call(func, thisValue, argList) を result とする
  8. Assert: tailPosition が true なら、上記の呼び出しはここに戻らない。代わりに、次の戻りがすでに発生したかのように評価が続行される。
  9. Assert: result が 突然の完了 ではないなら、 Type(result) は ECMAScript言語値
  10. resultを返す

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

12.3.7.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

SuperProperty : super[Expression ]
  1. GetThisEnvironment() を env とする
  2. ? env.GetThisBinding() を actualThis とする
  3. Expression の評価結果を propertyNameReference とする
  4. ? GetValue(propertyNameReference) を propertyNameValue とする
  5. ? ToPropertyKey(propertyNameValue) を propertyKey とする
  6. SuperProperty に一致するコードが strictモードコード なら true、異なるなら false を strict とする
  7. ? MakeSuperPropertyReference(actualThis, propertyKey, strict)を返す
SuperProperty : super.IdentifierName
  1. GetThisEnvironment() を env とする
  2. ? env.GetThisBinding() を actualThis とする
  3. IdentifierName の StringValue を propertyKey とする
  4. SuperProperty に一致するコードが、 strictモードコード なら true、異なるなら false を strict とする
  5. ? MakeSuperPropertyReference(actualThis, propertyKey, strict)を返す
SuperCall : superArguments
  1. GetNewTarget() を newTarget とする
  2. Assert: Type(newTarget) は Object型
  3. ! GetSuperConstructor() を func とする
  4. ? Arguments の ArgumentListEvaluation を argList とする
  5. IsConstructor(func) が false なら、TypeError例外をスローする.
  6. ? Construct(func, argList, newTarget) を result とする
  7. GetThisEnvironment() を thisER とする
  8. ? thisER.BindThisValue(result)を返す

12.3.7.2 ランタイムセマンティクス(Runtime Semantics): GetSuperConstructor ( )

抽象操作GetSuperConstructorは、次の手順を実行します。

  1. GetThisEnvironment() を envRec とする
  2. Assert: envRec は 関数環境レコード
  3. envRec.[[FunctionObject]] を activeFunction とする
  4. Assert: activeFunction is an ECMAScript関数オブジェクト.
  5. ! activeFunction.[[GetPrototypeOf]]() を superConstructor とする
  6. superConstructorを返す

12.3.7.3 ランタイムセマンティクス(Runtime Semantics): MakeSuperPropertyReference ( actualThis, propertyKey, strict )

抽象操作MakeSuperPropertyReferenceは引数actualThis、propertyKey、およびstrictを指定し、次の手順を実行します。

  1. GetThisEnvironment() を env とする
  2. Assert: env.HasSuperBinding() は true
  3. ? env.GetSuperBase() を baseValue とする
  4. ? RequireObjectCoercible(baseValue) を bv とする
  5. 基本値コンポーネントbv、参照名コンポーネントpropertyKey、thisValueコンポーネントactualThis、strict参照フラグstrict のスーパーリファレンスであるReference型の値を返す

12.3.8 引数リスト(Argument Lists)

引数リストを評価すると、値のリストが生成されます。

12.3.8.1 ランタイムセマンティクス(Runtime Semantics): ArgumentListEvaluation

Arguments : ()
  1. 空の新規Listを返す
ArgumentList : AssignmentExpression
  1. AssignmentExpression の評価結果を ref とする
  2. ? GetValue(ref) を arg とする
  3. argが単一要素のListを返す
ArgumentList : ...AssignmentExpression
  1. 空の新規List を list とする
  2. AssignmentExpression を spreadRef とする
  3. ? GetValue(spreadRef) の評価結果を spreadObj とする
  4. ? GetIterator(spreadObj) を iteratorRecord とする
  5. 繰り返す
    1. ? IteratorStep(iteratorRecord) を next とする
    2. next が false なら、list を返す
    3. ? IteratorValue(next) を nextArg とする
    4. list の最後に nextArg を追加する
ArgumentList : ArgumentList ,AssignmentExpression
  1. ? of ArgumentList の ArgumentListEvaluation を precedingArgs とする
  2. AssignmentExpression の評価結果を ref とする
  3. ? GetValue(ref) を arg とする
  4. precedingArgs の最後に arg を追加する
  5. precedingArgs を返す
ArgumentList : ArgumentList ,...AssignmentExpression
  1. ? ArgumentList の ArgumentListEvaluation を precedingArgs とする
  2. AssignmentExpression の評価結果を spreadRefとする
  3. ? GetIterator(? GetValue(spreadRef)) を iteratorRecord とする
  4. 繰り返す
    1. ? IteratorStep(iteratorRecord) を next とする
    2. next が false なら、 precedingArgs を返す
    3. ? IteratorValue(next) を nextArg とする
    4. precedingArgs の最後に nextArg を追加する

12.3.9 オプションチェーン(Optional Chains)

オプションのチェーンは、1つ以上のプロパティアクセスと関数呼び出しのチェーンであり、最初のチェーンはトークン？.で始まります。

12.3.9.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

OptionalExpression : MemberExpression OptionalChain
  1. MemberExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. baseValue が undefined か null なら、
    1. undefined を返す
  4. 引数 baseValue と baseReference を使用して OptionalChain の ChainEvaluation の結果を返す
OptionalExpression : CallExpression OptionalChain
  1. CallExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. If baseValue が undefined か null なら、
    1. undefined を返す
  4. 引数 baseValue と baseReference を使用して OptionalChain の ChainEvaluation の結果を返す
OptionalExpression : OptionalExpression OptionalChain
  1. OptionalExpression の評価結果を baseReference とする
  2. ? GetValue(baseReference) を baseValue とする
  3. baseValue が undefined か null なら、
    1. undefined を返す
  4. 引数 baseValue と baseReference を使用して OptionalChain の ChainEvaluation の結果を返す

12.3.9.2 ランタイムセマンティクス(Runtime Semantics): ChainEvaluation

引数 baseValue と baseReference を使用。

OptionalChain : ?.Arguments
  1. OptionalChain を thisChain とする
  2. IsInTailPosition(thisChain) を tailCall とする
  3. ? EvaluateCall(baseValue, baseReference, Arguments , tailCall)を返す
OptionalChain : ?.[Expression ]
  1. OptionalChain に一致するコードが strictモードコード なら true 、異なるなら false を strict とする
  2. ? EvaluatePropertyAccessWithExpressionKey(baseValue, Expression , strict)を返す
OptionalChain : ?.IdentifierName
  1. OptionalChain に一致するコードが strictモードコード なら true、 異なるなら false を strict とする
  2. ? EvaluatePropertyAccessWithIdentifierKey(baseValue, IdentifierName , strict)を返す
OptionalChain : OptionalChain Arguments
  1. OptionalChain を optionalChain とする
  2. 引数 baseValue と baseReference を使用して ? optionalChain の ChainEvaluation を newReference とする
  3. ? GetValue(newReference) を newValue とする
  4. OptionalChain を thisChain とする
  5. IsInTailPosition(thisChain) を tailCall とする
  6. ? EvaluateCall(newValue, newReference, Arguments , tailCall) を返す
OptionalChain : OptionalChain [Expression ]
  1. OptionalChain を optionalChain とする
  2. 引数 baseValue と baseReference を使用して ? optionalChain の ChainEvaluation を newReference とする
  3. ? GetValue(newReference) を newValue とする
  4. OptionalChain に一致するコードが strictモードコード なら true、 異なるなら false を strict とする
  5. ? EvaluatePropertyAccessWithExpressionKey(newValue, Expression , strict) を返す
OptionalChain : OptionalChain .IdentifierName
  1. OptionalChain を optionalChain とする
  2. 引数 baseValue と baseReference を使用して ? optionalChain の ChainEvaluationを newReference とする
  3. ? GetValue(newReference) を newValue とする
  4. OptionalChain に一致するコードが strictモードコード なら true、異なるなら false を strict とする
  5. ? EvaluatePropertyAccessWithIdentifierKey(newValue, IdentifierName , strict)を返す

12.3.10 インポート呼び出し(Import Calls)

12.3.10.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ImportCall : import(AssignmentExpression )
  1. ! GetActiveScriptOrModule() を referencingScriptOrModule とする
  2. AssignmentExpression の評価結果を argRef とする
  3. ? GetValue(argRef) を specifier とする
  4. ! NewPromiseCapability(%Promise%) を promiseCapability とする
  5. ToString(specifier) を specifierString とする
  6. IfAbruptRejectPromise(specifierString, promiseCapability).
  7. ! HostImportModuleDynamically(referencingScriptOrModule, specifierString, promiseCapability)を実行
  8. promiseCapability.[[Promise]] を返す

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

タグ付きテンプレートは、呼び出しの引数がTemplateLiteral（12.2.9）から派生する関数呼び出しです。 実際の引数には、テンプレートオブジェクト（12.2.9.4）と、TemplateLiteral内に埋め込まれた式の評価により生成された値が含まれます。

12.3.11.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

MemberExpression : MemberExpression TemplateLiteral
  1. MemberExpression の評価結果を tagRef とする
  2. ? GetValue(tagRef) を tagFunc とする
  3. MemberExpression を thisCall とする
  4. IsInTailPosition(thisCall) を tailCall とする
  5. ? EvaluateCall(tagFunc, tagRef, TemplateLiteral , tailCall)を返す
CallExpression :
CallExpression TemplateLiteral
  1. 評価結果 CallExpression を tagRef とする
  2. ?GetValue(tagRef) を tagFunc とする
  3. this CallExpression を thisCall とする
  4. IsInTailPosition(thisCall) を tailCall とする
  5. を返す?EvaluateCall(tagFunc, tagRef, TemplateLiteral , tailCall).

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

12.3.12.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

NewTarget : new.target
  1. GetNewTarget()を返す
ImportMeta : import.meta
  1. !GetActiveScriptOrModule() を module とする
  2. Assert: module は ソーステキストモジュールレコード
  3. module.[[ImportMeta]] を importMeta とする
  4. importMeta が empty なら、
    1. ! OrdinaryObjectCreate(null) を importMeta にセットする
    2. ! HostGetImportMetaProperties(module) を importMetaValues とする
    3. mportMetaValues の各Record型{[[Key]],[[Value]]}要素を p とし、各 p ごとに、
      1. !CreateDataPropertyOrThrow(importMeta, p.[[Key]], p.[[Value]])を実行
    4. ! HostFinalizeImportMeta(importMeta, module)を実行
    5. importMeta を module.[[ImportMeta]] にセットする
    6. importMetaを返す
  5. 4. でなければ
    1. Assert:Type(importMeta) は Object型
    2. importMetaを返す
12.3.12.1.1 ランタイムセマンティクス(Runtime Semantics): HostGetImportMetaProperties ( moduleRecord )

HostGetImportMetaPropertiesは、実装で定義された抽象操作であす。import.metaから返されたオブジェクトのプロパティキーと値をホストが提供できるようにします。

HostGetImportMetaPropertiesの実装は、次の要件に準拠させる必要があります。

  • [[Key]]と[[Value]]の2つのフィールドを持つRecordを要素とするListを返す必要があります。
  • 各レコードの[[Key]]フィールドは、プロパティキーです。つまり、IsPropertyKeyを、適用したらtrueを返す必要があります。
  • 各レコードの[[Value]]フィールドは、ECMAScript値である必要があります。
  • 常に正常に完了する必要があります（つまり、突然の完了を返してはいけません）。

HostGetImportMetaPropertiesのデフォルトの実装は、新しい空のリストを返します。

12.3.12.1.2 ランタイムセマンティクス(Runtime Semantics): HostFinalizeImportMeta ( importMeta, moduleRecord )

HostFinalizeImportMetaは、実装で定義された抽象操作です。ホストが特別な操作を実行して、import.metaから返されるオブジェクトを準備できるようにします。

通常、ホストはHostGetImportMetaPropertiesを定義し、HostFinalizeImportMetaはデフォルト動作のみ実装します。ただしHostFinalizeImportMetaは、オブジェクトをECMAScriptコードに公開する前に操作するホストに対して"エスケープ ハッチ" を提供します。

HostFinalizeImportMetaの実装は、次の要件に準拠する必要があります。

  • 常に正常に完了する必要があります（つまり、突然の完了を返してはいけません）

HostFinalizeImportMetaのデフォルトの実装は、NormalCompletion(empty)を返します。

12.4 更新式(Update Expressions)

構文：

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

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

UpdateExpression :
LeftHandSideExpression ++
LeftHandSideExpression --
UpdateExpression :
++UnaryExpression
--UnaryExpression
  • UnaryExpressionのAssignmentTargetTypeがsimpleでないなら、早期構文エラーです

12.4.2 静的セマンティクス(Static Semantics): IsFunctionDefinition

UpdateExpression :
LeftHandSideExpression ++
LeftHandSideExpression --
++UnaryExpression
--UnaryExpression
  1. false を返す

12.4.3 静的セマンティクス(Static Semantics): AssignmentTargetType

UpdateExpression :
LeftHandSideExpression ++
LeftHandSideExpression --
++UnaryExpression
--UnaryExpression
  1. invalidを返す

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

12.4.4.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UpdateExpression : LeftHandSideExpression ++
  1. LeftHandSideExpression の評価結果を lhs とする
  2. ? ToNumeric(? GetValue(lhs)) を oldValue とする
  3. ! Type(oldvalue)::add(oldValue,Type(oldValue)::unit) を newValue とする
  4. ? PutValue(lhs, newValue)を実行
  5. oldValueを返す

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

12.4.5.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UpdateExpression : LeftHandSideExpression --
  1. LeftHandSideExpression の評価結果を lhs とする
  2. ? ToNumeric(? GetValue(lhs)) を oldValue とする
  3. ! Type(oldvalue)::subtract(oldValue, Type(oldValue)::unit) を newValue とする
  4. ? PutValue(lhs, newValue)を実行
  5. oldValueを返す

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

12.4.6.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UpdateExpression : ++UnaryExpression
  1. UnaryExpression の評価結果 を expr とする
  2. ? ToNumeric(? GetValue(expr)) を oldValue とする
  3. ! Type(oldvalue)::add(oldValue, Type(oldValue)::unit) を newValue とする
  4. ? PutValue(expr, newValue)を実行
  5. newValueを返す

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

12.4.7.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UpdateExpression : --UnaryExpression
  1. UnaryExpression の評価結果を expr とする
  2. ? ToNumeric(? GetValue(expr)) を oldValue とする
  3. ! Type(oldvalue)::subtract(oldValue, Type(oldValue)::unit) を newValue とする
  4. ? PutValue(expr, newValue)を実行
  5. newValueを返す

12.5 単項演算子(Unary Operators)

構文：

UnaryExpression[Yield, Await] :
UpdateExpression[?Yield, ?Await]
deleteUnaryExpression[?Yield, ?Await]
voidUnaryExpression[?Yield, ?Await]
typeofUnaryExpression[?Yield, ?Await]
+UnaryExpression[?Yield, ?Await]
-UnaryExpression[?Yield, ?Await]
~UnaryExpression[?Yield, ?Await]
!UnaryExpression[?Yield, ?Await]
[+Await]AwaitExpression[?Yield]

12.5.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

UnaryExpression :
deleteUnaryExpression
voidUnaryExpression
typeofUnaryExpression
+UnaryExpression
-UnaryExpression
~UnaryExpression
!UnaryExpression
AwaitExpression
  1. false を返す

12.5.2 静的セマンティクス(Static Semantics): AssignmentTargetType

UnaryExpression :
deleteUnaryExpression
voidUnaryExpression
typeofUnaryExpression
+UnaryExpression
-UnaryExpression
~UnaryExpression
!UnaryExpression
AwaitExpression
  1. invalidを返す

12.5.3 delete演算子(The delete Operator)

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

UnaryExpression : deleteUnaryExpression
最後のルールは、最初のルールを再帰的に適用するため、delete (((foo))) などの式が初期エラーを生成することを意味します。

12.5.3.2 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : deleteUnaryExpression
  1. UnaryExpression の評価結果を ref とする
  2. ReturnIfAbrupt(ref)
  3. Type(ref) が Reference でないなら、 true を返す
  4. IsUnresolvableReference(ref) が true なら、
    1. Assert: IsStrictReference(ref) は false
    2. true を返す
  5. IsPropertyReference(ref) が true なら、
    1. IsSuperReference(ref) が true なら、ReferenceError例外をスローする
    2. ! ToObject(GetBase(ref)) を baseObj とする
    3. ? baseObj.[[Delete]](GetReferencedName(ref)) を deleteStatus とする
      .
    4. deleteStatus が false で、 IsStrictReference(ref) が true なら、TypeError例外をスローする
    5. deleteStatusを返す
  6. 5.でないなら、
    1. Assert: ref は 環境レコード バインディングへのReference
    2. GetBase(ref) を bindings とする
    3. ? bindings.DeleteBinding(GetReferencedName(ref))を返す
strictモードコード内のでdelete演算子のUnaryExpressionが、変数、関数引数、または関数名への直接参照である場合、SyntaxError例外がスローされます。 さらに、strictモードコード内のdelete演算子で、削除するプロパティの属性が{ [[Configurable]]: false }の場合、TypeError例外がスローされます。

12.5.4 void演算子(The void Operator)

12.5.4.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : voidUnaryExpression
  1. UnaryExpression の評価結果を expr とする
  2. ? GetValue(expr)を実行
  3. undefined を返す
GetValueは、観察可能な副作用がある可能性があります。そのため、値が使用されていない場合でも呼び出す必要があります。

12.5.5 typeof演算子(The typeof Operator)

12.5.5.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : typeofUnaryExpression
  1. UnaryExpression の評価結果を val とする
  2. Type(val) が Reference なら、
    1. IsUnresolvableReference(val) が true なら、"undefined" を返す
  3. ? GetValue(val) を val にセットする
  4. 表35を参照して、対応する文字列を返す
表35: typeof演算の結果
val の型 結果
Undefined "undefined"
Null "object"
Boolean "boolean"
Number "number"
String "string"
Symbol "symbol"
BigInt "bigint"
Object ([[Call]]なし) "object"
Object ([[Call]]あり) "function"

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

単項+演算子は、オペランドを数値型に変換します。

12.5.6.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : +UnaryExpression
  1. UnaryExpression の評価結果を expr とする
  2. ? ToNumber(? GetValue(expr))を返す

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

単項-演算子は、オペランドを数値型に変換してから、否定します。 +0を否定すると-0が生成され、-0を否定すると+0が生成されます。

12.5.7.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : -UnaryExpression
  1. UnaryExpression の評価結果を expr とする
  2. ? ToNumeric(? GetValue(expr)) を oldValue とする
  3. Type(oldValue) を T とする
  4. ! T::unaryMinus(oldValue)を返す

12.5.8 ビット否定演算子(Bitwise NOT Operator) ( ~ )

12.5.8.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : ~UnaryExpression
  1. UnaryExpression の評価結果を expr とする
  2. ? ToNumeric(? GetValue(expr)) を oldValue とする
  3. Type(oldValue) を T とする
  4. ! T::bitwiseNOT(oldValue)を返す

12.5.9 論理否定演算子(Logical NOT Operator) ( ! )

12.5.9.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

UnaryExpression : !UnaryExpression
  1. UnaryExpression の評価結果を expr とする
  2. ! ToBoolean(? GetValue(expr)) を oldValue とする
  3. oldValue が true なら、 false を返す
  4. true を返す

12.6 べき乗演算子(Exponentiation Operator)

構文：

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

12.6.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

ExponentiationExpression : UpdateExpression **ExponentiationExpression
  1. false を返す

12.6.2 静的セマンティクス(Static Semantics): AssignmentTargetType

ExponentiationExpression :
UpdateExpression **ExponentiationExpression
  1. invalidを返す

12.6.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ExponentiationExpression : UpdateExpression **ExponentiationExpression
  1. UpdateExpression の評価結果を left とする
  2. ? GetValue(left) を leftValue とする
  3. ExponentiationExpression の評価結果を right とする
  4. ? GetValue(right) を rightValue とする
  5. ? ToNumeric(leftValue) を base とする
  6. ? ToNumeric(rightValue) を exponent とする
  7. Type(base) が Type(exponent) と異なるなら、 TypeError例外をスローする
  8. ? Type(base)::exponentiate(base, exponent)を返す

12.7 乗算演算子(Multiplicative Operators)

構文：

MultiplicativeOperator : どれかひとつ
*/%

12.7.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

MultiplicativeExpression :
MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
  1. false を返す

12.7.2 静的セマンティクス(Static Semantics): AssignmentTargetType

MultiplicativeExpression :
MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
  1. invalid を返す

12.7.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

MultiplicativeExpression :
MultiplicativeExpression MultiplicativeOperator ExponentiationExpression
  1. MultiplicativeExpression の評価結果を left とする
  2. ? GetValue(left) を leftValue とする
  3. ExponentiationExpression の評価結果を right とする
  4. ? GetValue(right) を rightValue とする
  5. ? ToNumeric(leftValue) を lnum とする
  6. ? ToNumeric(rightValue) を rnum とする
  7. Type(lnum) と Type(rnum) が異なるなら、 TypeError例外をスローする
  8. Type(lnum) を T とする
  9. MultiplicativeOperator が * なら、 T::multiply(lnum, rnum) を返す
  10. MultiplicativeOperator が / なら、T::divide(lnum, rnum) を返す
  11. 10. でないなら、
    1. Assert: MultiplicativeOperator は %
    2. T::remainder(lnum, rnum)を返す

12.8 加算演算子(Additive Operators)

構文：

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

12.8.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

AdditiveExpression :
AdditiveExpression +MultiplicativeExpression
AdditiveExpression -MultiplicativeExpression
  1. false を返す

12.8.2 静的セマンティクス(Static Semantics): AssignmentTargetType

AdditiveExpression :
AdditiveExpression +MultiplicativeExpression
AdditiveExpression -MultiplicativeExpression
  1. invalid を返す

12.8.3 The Addition Operator ( + )

加算演算子は、文字列の連結または数値の加算をおこないます。

12.8.3.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

AdditiveExpression : AdditiveExpression +MultiplicativeExpression
  1. AdditiveExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. MultiplicativeExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? ToPrimitive(lval) を lprim とする
  6. ? ToPrimitive(rval) を rprim とする
  7. Type(lprim) か Type(rprim) が String型なら、
    1. ? ToString(lprim) を lstr とする
    2. ? ToString(rprim) を rstr とする
    3. lstr と rstr の文字列連結を返す
  8. ? ToNumeric(lprim) を lnum とする
  9. ? ToNumeric(rprim) を rnum とする
  10. Type(lnum) と Type(rnum) が異なるなら、 TypeError例外をスローする.
  11. Type(lnum) を T とする
  12. T::add(lnum, rnum)を返す
5と6のToPrimitiveの呼び出しは、ヒントが提供されません。日付オブジェクトは、ヒントがないとき、ヒント文字列が指定されたかのように処理します。その他の標準オブジェクトは、ヒントがないとき、ヒント番号が指定されているかのように処理します。 エキゾチックなオブジェクトは、他の方法で処理する場合があります。
7は、論理積演算の代わりに論理積演算を使用するという点で、抽象関係比較アルゴリズムの3とは異なります。

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

12.8.4.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

AdditiveExpression : AdditiveExpression -MultiplicativeExpression
  1. AdditiveExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. MultiplicativeExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? ToNumeric(lval) を lnum とする
  6. ? ToNumeric(rval) を rnum とする
  7. Type(lnum) と Type(rnum) が異なるなら、 TypeError例外をスローする
  8. Type(lnum)を T とする
  9. T::subtract(lnum, rnum)を返す

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

構文：

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

12.9.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

ShiftExpression :
ShiftExpression <<AdditiveExpression
ShiftExpression >>AdditiveExpression
ShiftExpression >>>AdditiveExpression
  1. false を返す

12.9.2 静的セマンティクス(Static Semantics): AssignmentTargetType

ShiftExpression :
ShiftExpression <<AdditiveExpression
ShiftExpression >>AdditiveExpression
ShiftExpression >>>AdditiveExpression
  1. invalid を返す

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

右オペランドで指定された数だけ、左オペランドに対してビット単位の左シフト演算をおこないます。

12.9.3.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ShiftExpression : ShiftExpression <<AdditiveExpression
  1. ShiftExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. AdditiveExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? ToNumeric(lval) を lnum とする
  6. ? ToNumeric(rval) を rnum とする
  7. Type(lnum) と Type(rnum) が異なるなら、 TypeError例外をスローする
  8. Type(lnum) を T とする
  9. T::leftShift(lnum, rnum)を返す

12.9.4 The Signed Right Shift Operator ( >> )

右のオペランドで指定された数だけ、左のオペランドに対して符号を埋めるビット単位の右シフト演算を実行します。

12.9.4.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ShiftExpression : ShiftExpression >>AdditiveExpression
  1. ShiftExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. AdditiveExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? ToNumeric(lval) を lnum とする
  6. ? ToNumeric(rval) を rnum とする
  7. Type(lnum) と Type(rnum) が異なるなら、 TypeError例外をスローする
  8. Type(lnum) を T とする
  9. T::signedRightShift(lnum, rnum)を返す

12.9.5 T符号なし右シフト演算子(he Unsigned Right Shift Operator) ( >>> )

右のオペランドで指定された数だけ、左のオペランドに対してゼロを埋めるビット単位の右シフト演算をおこないます。

12.9.5.1 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ShiftExpression : ShiftExpression >>>AdditiveExpression
  1. ShiftExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. AdditiveExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? ToNumeric(lval) を lnum とする
  6. ? ToNumeric(rval) を rnum とする
  7. Type(lnum) と Type(rnum) が異なるなら、 TypeError例外をスローする
  8. Type(lnum) を T とする
  9. T::unsignedRightShift(lnum, rnum) を返す

12.10 関係演算子(Relational Operators)

関係演算子の評価結果は常にブール型です。演算子によって指定された関係が、2つのオペランドの間で成立しているかどうかを判断します。

構文：

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] instanceofShiftExpression[?Yield, ?Await]
[+In]RelationalExpression[+In, ?Yield, ?Await] inShiftExpression[?Yield, ?Await]
[In]文法パラメーターは、関係式のin演算子とforステートメントのin演算子を混同しないようにするために必要です。

12.10.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

RelationalExpression :
RelationalExpression <ShiftExpression
RelationalExpression >ShiftExpression
RelationalExpression <=ShiftExpression
RelationalExpression >=ShiftExpression
RelationalExpression instanceofShiftExpression
RelationalExpression inShiftExpression
  1. false を返す

12.10.2 静的セマンティクス(Static Semantics): AssignmentTargetType

RelationalExpression :
RelationalExpression <ShiftExpression
RelationalExpression >ShiftExpression
RelationalExpression <=ShiftExpression
RelationalExpression >=ShiftExpression
RelationalExpression instanceofShiftExpression
RelationalExpression inShiftExpression
  1. invalid を返す

12.10.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

RelationalExpression : RelationalExpression <ShiftExpression
  1. RelationalExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ShiftExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. 抽象関係比較 lval < rval の実行結果を r とする
  6. ReturnIfAbrupt(r)
  7. r が undefined なら false を、 異なるなら r を返す
RelationalExpression : RelationalExpression >ShiftExpression
  1. RelationalExpression 評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ShiftExpression 評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. LeftFirstをfalseとし、抽象関係比較 rval < lval の実行結果を r とする
  6. ReturnIfAbrupt(r)
  7. r が undefined なら false を、 異なるなら r を返す
RelationalExpression : RelationalExpression <=ShiftExpression
  1. RelationalExpression 評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ShiftExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. LeftFirstをfalseとし、抽象関係比較 rval < lval の実行結果を r とする
  6. ReturnIfAbrupt(r)
  7. r が true または undefined なら、 false を、異なるなら true を返す
RelationalExpression : RelationalExpression >=ShiftExpression
  1. RelationalExpression 評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ShiftExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. 抽象関係比較 lval < rval の実行結果 を r とする
  6. ReturnIfAbrupt(r)
  7. r が true または undefined なら、 false を、異なるなら true を返す
RelationalExpression : RelationalExpression instanceofShiftExpression
  1. RelationalExpression 評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ShiftExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? InstanceofOperator(lval, rval)を返す
RelationalExpression : RelationalExpression inShiftExpression
  1. RelationalExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ShiftExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. Type(rval) が Object型でないなら、TypeError例外をスローする
  6. ? HasProperty(rval, ? ToPropertyKey(lval))を返す

12.10.4 ランタイムセマンティクス(Runtime Semantics): InstanceofOperator ( V, target )

抽象操作InstanceofOperatorは、ECMAScript値Vがオブジェクトtargetのインスタンスかどうかを判断する汎用アルゴリズムです。targetの@@hasinstanceメソッドを参照、または、@@hasinstanceメソッドが存在しない場合はVのプロトタイプチェーンにtargetの"prototype"プロパティの値が存在するかどうかで判断します。 この抽象操作は、次の手順を実行します。

  1. Type(target) が Object型でないなら、TypeError例外をスローする
  2. ? GetMethod(target, @@hasInstance) を instOfHandler とする
  3. instOfHandler が undefined でないなら、
    1. ! ToBoolean(? Call(instOfHandler, target, « V »))を返す
  4. IsCallable(target) が false なら、TypeError例外をスローする
  5. ? OrdinaryHasInstance(target, V)を返す
4と5は、以前のエディションのECMAScriptとの互換性を提供します。以前は@@hasInstanceメソッドを使用してinstanceof演算子のセマンティクスを定義していませんでした。オブジェクトが@@hasInstanceを定義または継承しない場合、デフォルトのinstanceofセマンティクスを使用します。

12.11 等値演算子(Equality Operators)

等値演算子の評価結果は常にブール型であす。2つのオペランド間で演算子によって指定された関係がで成立するかどうかをあらわします。

構文：

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]

12.11.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

EqualityExpression :
EqualityExpression ==RelationalExpression
EqualityExpression !=RelationalExpression
EqualityExpression ===RelationalExpression
EqualityExpression !==RelationalExpression
  1. false を返す

12.11.2 静的セマンティクス(Static Semantics): AssignmentTargetType

EqualityExpression :
EqualityExpression ==RelationalExpression
EqualityExpression !=RelationalExpression
EqualityExpression ===RelationalExpression
EqualityExpression !==RelationalExpression
  1. invalid を返す

12.11.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

EqualityExpression : EqualityExpression ==RelationalExpression
  1. EqualityExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. RelationalExpression を rref とする
  4. ? GetValue(rref) の評価結果を rval とする
  5. 抽象等値比較 rval == lval の実行結果を返す
EqualityExpression : EqualityExpression !=RelationalExpression
  1. EqualityExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. RelationalExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. 抽象等値比較 rval == lval の実行結果を r とする
  6. ReturnIfAbrupt(r)
  7. r が true なら、 false を、true を返す
EqualityExpression : EqualityExpression ===RelationalExpression
  1. EqualityExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. RelationalExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. 厳密等値比較 rval === lval の実行結果を返す
EqualityExpression : EqualityExpression !==RelationalExpression
  1. EqualityExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. RelationalExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. 厳密等値比較 rval === lval の実行結果を r とする
  6. Assert: r は通常の完了
  7. r.[[Value]] が true なら、 false を、 true を返す
上記の等値の定義より、

  • 文字列の比較は`${a}` == `${b}`によって強制できます
  • 数値比較は +a == +b によって強制できます
  • ブール比較は !a == !b によって強制できます
等値演算子は、次の不変条件を維持します。

  • A != B と !(A == B) は同等です。
  • A == B は、AとBの評価の順序を除いて、B == A と同等です。
等値演算子は常に推移的であるとは限りません。 たとえば、2つの異なるStringオブジェクトが同じString値を表しているとします。 ==演算子では、StringオブジェクトとString値は等しいと見なされます。しかしStringオブジェクト同士の比較は等しくありません。

例：

  • new String("a") == "a"　と "a" == new String("a") は共に true
  • new String("a") == new String("a") は false
文字列の比較は、コードユニット値のシーケンスに対して単純な同等性テストをおこないます。 Unicode仕様で定義されている、文字または文字列の同等性と照合順序の、より複雑で意味指向の定義は使用しません。 したがって、Unicode標準では等しい文字列値でも、等しくない結果となる可能性があります。 実際のところ、このアルゴリズムは、両方の文字列が正規化された形式であることを前提としています。

12.12 バイナリビット演算子(Binary Bitwise Operators)

構文：

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]

12.12.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

BitwiseANDExpression : BitwiseANDExpression &EqualityExpression
BitwiseXORExpression : BitwiseXORExpression ^BitwiseANDExpression
BitwiseORExpression : BitwiseORExpression |BitwiseXORExpression
  1. false を返す

12.12.2 静的セマンティクス(Static Semantics): AssignmentTargetType

BitwiseANDExpression : BitwiseANDExpression &EqualityExpression
BitwiseXORExpression : BitwiseXORExpression ^BitwiseANDExpression
BitwiseORExpression : BitwiseORExpression |BitwiseXORExpression
  1. invalid を返す

12.12.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

プロダクション A ：A @ B（@はビット演算子の1つ）は、次のように評価されます。

  1. A の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. B の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. ? ToNumeric(lval) を lnum とする
  6. ? ToNumeric(rval) を rnum とする
  7. Type(lnum) と Type(rnum) が異なるなら TypeError例外をスローする
  8. Type(lnum) を T とする
  9. @ が & なら T::bitwiseAND(lnum, rnum) を返す
  10. @ が | なら、 T::bitwiseOR(lnum, rnum) を返す
  11. 9. 10. と異なるなら、
    1. Assert: @ は ^
    2. T::bitwiseXOR(lnum, rnum) を返す

12.13 バイナリ論理演算子(Binary Logical Operators)

構文：

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]
&& または || 演算子によって生成される値は必ずしもブール型である必要はありません。 生成される値は、常に2つのオペランド式のいずれかの値になります。

12.13.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

LogicalANDExpression : LogicalANDExpression &&BitwiseORExpression
LogicalORExpression : LogicalORExpression ||LogicalANDExpression
CoalesceExpression : CoalesceExpressionHead ??BitwiseORExpression
  1. false を返す

12.13.2 静的セマンティクス(Static Semantics): AssignmentTargetType

LogicalANDExpression : LogicalANDExpression &&BitwiseORExpression
LogicalORExpression : LogicalORExpression ||LogicalANDExpression
CoalesceExpression : CoalesceExpressionHead ??BitwiseORExpression
  1. invalid を返す

12.13.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

LogicalANDExpression : LogicalANDExpression &&BitwiseORExpression
  1. LogicalANDExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ! ToBoolean(lval) を lbool とする
  4. lbool が false なら、lval を返す
  5. BitwiseORExpression の評価結果を rref とする
  6. ? GetValue(rref) を返す
LogicalORExpression : LogicalORExpression ||LogicalANDExpression
  1. LogicalORExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. ! ToBoolean(lval) を lbool とする
  4. lbool が true なら、lval を返す
  5. LogicalANDExpression の評価結果を rref とする
  6. ? GetValue(rref) を返す
CoalesceExpression : CoalesceExpressionHead ??BitwiseORExpression
  1. CoalesceExpressionHead の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. lval が undefined か null なら、
    1. BitwiseORExpression の評価結果を rref とする
    2. ? GetValue(rref) を返す
  4. lvalを返す

12.14 三項(条件)演算子(Conditional Operator) ( ? : )

構文：

ConditionalExpression[In, Yield, Await] :
ShortCircuitExpression[?In, ?Yield, ?Await]
ShortCircuitExpression[?In, ?Yield, ?Await] ?AssignmentExpression[+In, ?Yield, ?Await] :AssignmentExpression[?In, ?Yield, ?Await]
ConditionalExpressionの文法は、CおよびJavaと少し異なります。それぞれ、2番目の部分式をExpressionにすることができますが、3番目はConditionalExpressionに制限されます。 この違いは、割り当て式を条件のどちらのアームでも制御できるようにし、中央の式がコンマで混乱して役に立たないケースを排除するためです。

12.14.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

ConditionalExpression : ShortCircuitExpression ?AssignmentExpression :AssignmentExpression
  1. false を返す

12.14.2 静的セマンティクス(Static Semantics): AssignmentTargetType

ConditionalExpression :
ShortCircuitExpression ?AssignmentExpression :AssignmentExpression
  1. invalid を返す

12.14.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

ConditionalExpression : ShortCircuitExpression ?AssignmentExpression :AssignmentExpression
  1. ShortCircuitExpression の評価結果を lref とする
  2. ! ToBoolean(? GetValue(lref)) を lval とする
  3. lval が true なら、
    1. 最初の AssignmentExpression の評価結果を trueRef とする
    2. ? GetValue(trueRef) を返す
  4. 3. でないなら
    1. 2番目の AssignmentExpression の評価結を falseRef とする
    2. ? GetValue(falseRef) を返す/li>

12.15 割り当て演算子(Assignment Operators)

構文：

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]
AssignmentOperator : どれかひとつ
*=/=%=+=-=<<=>>=>>>=&=^=|=**=

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

AssignmentExpression : LeftHandSideExpression =AssignmentExpression

LeftHandSideExpression が ObjectLiteral またはArrayLiteral の場合、次の早期エラールールが適用されます。

LeftHandSideExpression が ObjectLiteral でも ArrayLiteral でもない場合、次の早期エラールールが適用されます。

  • LeftHandSideExpression の AssignmentTargetType が simple でない場合、構文エラーになります。
AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
  • LeftHandSideExpression の AssignmentTargetType が simple でない場合、構文エラーになります。

12.15.2 静的セマンティクス(Static Semantics): IsFunctionDefinition

AssignmentExpression :
ArrowFunction
AsyncArrowFunction
  1. true を返す
AssignmentExpression :
YieldExpression
LeftHandSideExpression =AssignmentExpression
LeftHandSideExpression AssignmentOperator AssignmentExpression
  1. false を返す

12.15.3 静的セマンティクス(Static Semantics): AssignmentTargetType

AssignmentExpression :
YieldExpression
ArrowFunction
AsyncArrowFunction
LeftHandSideExpression =AssignmentExpression
LeftHandSideExpression AssignmentOperator AssignmentExpression
  1. invalid を返す

12.15.4 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

AssignmentExpression : LeftHandSideExpression =AssignmentExpression
  1. LeftHandSideExpression が ObjectLiteral と ArrayLiteral でないなら、
    1. LeftHandSideExpression の評価結果を lref とする
    2. ReturnIfAbrupt(lref)
    3. IsAnonymousFunctionDefinition(AssignmentExpression ) と LeftHandSideExpression の IsIdentifierRef の両方が true なら、
      1. 引数 GetReferencedName(lref) を使用して AssignmentExpression の NamedEvaluation を rval とする
    4. c. でないなら
      1. AssignmentExpression の評価結果を rref とする
      2. ? GetValue(rref) を rval とする
    5. ? PutValue(lref, rval)を実行
    6. rval を返す
  2. LeftHandSideExpression によってカバーされている AssignmentPattern を assignmentPattern とする
  3. AssignmentExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. 引数として rval を使用して ? assignmentPattern の DestructuringAssignmentEvaluation を実行
  6. rval を返す
AssignmentExpression : LeftHandSideExpression AssignmentOperator AssignmentExpression
  1. LeftHandSideExpression の評価結果を lref とする
  2. ? GetValue(lref) を lval とする
  3. AssignmentExpression の評価結果を rref とする
  4. ? GetValue(rref) を rval とする
  5. AssignmentOperator を @= としたときの @ にあたる文字を op とする。
  6. 式 lval op rval の適用結果を r とする
  7. ? PutValue(lref, r) を実行
  8. rを返す
strictモードコード内で割り当てが発生した場合、最初のアルゴリズムのステップ1.eまたは2番目のアルゴリズムのステップ7で lref の参照を解決できないと、ランタイムエラーになりReferenceError例外がスローされます。 LeftHandSideExpressionは、属性値{[[Writable]]:false}のデータプロパティ,属性値{[[Set]]:undefined}のアクセサプロパティ、またはIsExtensibleがfalseを返すオブジェクト内で存在していないプロパティのため、参照できない場合があります。 IsExtensible述部が値falseを返すオブジェクトのプロパティ。 このような場合、TypeError例外がスローされます。

12.15.5 分割代入(Destructuring Assignment)

補足構文：

プロダクション 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]

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

AssignmentProperty : IdentifierReference Initializeropt
  • IdentifierReference の AssignmentTargetType が simple でないなら、構文エラーです。
AssignmentRestProperty : ...DestructuringAssignmentTarget
DestructuringAssignmentTarget : LeftHandSideExpression

LeftHandSideExpression が ObjectLiteral か ArrayLiteral なら、 次の早期エラールールが適用されます。

LeftHandSideExpression が ObjectLiteral でも ArrayLiteral でもない場合、次の早期エラールールが適用されます。

12.15.5.2 ランタイムセマンティクス(Runtime Semantics): DestructuringAssignmentEvaluation

引数 value を使用。

ObjectAssignmentPattern : {}
  1. ? RequireObjectCoercible(value) を実行する
  2. NormalCompletion(empty) を返す
ObjectAssignmentPattern :
{AssignmentPropertyList }
{AssignmentPropertyList ,}
  1. ? RequireObjectCoercible(value) を実行する
  2. 引数 value を使用して ? AssignmentPropertyList の PropertyDestructuringAssignmentEvaluation を実行する
  3. NormalCompletion(empty) を返す
ArrayAssignmentPattern : []
  1. ? GetIterator(value) を iteratorRecord とする
  2. ? IteratorClose(iteratorRecord, NormalCompletion(empty)) を返す
ArrayAssignmentPattern : [Elision ]
  1. ? GetIterator(value) を iteratorRecord とする
  2. 引数 iteratorRecord を使用して Elision の IteratorDestructuringAssignmentEvaluation を result とする
  3. iteratorRecord.[[Done]] が false なら、? IteratorClose(iteratorRecord, result) を返す
  4. result を返す
ArrayAssignmentPattern : [Elisionopt AssignmentRestElement ]
  1. ? GetIterator(value) を iteratorRecord とする
  2. Elision が存在するなら、
    1. 引数 iteratorRecord を使用して Elision の IteratorDestructuringAssignmentEvaluation を status とする
    2. status が 突然の完了 なら、
      1. Assert: iteratorRecord.[[Done]] は true
      2. Completion(status) を返す
  3. 引数 iteratorRecord を使用してof AssignmentRestElement の IteratorDestructuringAssignmentEvaluation を result とする
  4. iteratorRecord.[[Done]] が false なら、? IteratorClose(iteratorRecord, result)を返す
  5. result を返す
ArrayAssignmentPattern : [AssignmentElementList ]
  1. ? GetIterator(value) を iteratorRecord とする
  2. 引数 iteratorRecord を使用して AssignmentElementList IteratorDestructuringAssignmentEvaluation を result とする
  3. iteratorRecord.[[Done]] が false なら、? IteratorClose(iteratorRecord, result) を返す
  4. result を返す
ArrayAssignmentPattern : [AssignmentElementList ,Elisionopt AssignmentRestElementopt ]
  1. ? GetIterator(value) を iteratorRecord とする
  2. 引数 iteratorRecord を使用して AssignmentElementList のIteratorDestructuringAssignmentEvaluation を status とする
  3. status が 突然の完了 なら、
    1. iteratorRecord.[[Done]] が false なら、? IteratorClose(iteratorRecord, status)を返す
    2. Completion(status) を返す
  4. Elision が存在するなら、
    1. 引数 iteratorRecord を使用して Elision のIteratorDestructuringAssignmentEvaluation の実行結果を status にセットする
    2. status が 突然の完了 なら、
      1. Assert: iteratorRecord.[[Done]] は true
      2. Completion(status) を返す
  5. AssignmentRestElement が存在なら、
    1. 引数 iteratorRecord を使用して AssignmentRestElement の IteratorDestructuringAssignmentEvaluation の実行結果を status にセットする
  6. iteratorRecord.[[Done]] が false なら、? IteratorClose(iteratorRecord, status)を返す
  7. Completion(status) を返す
ObjectAssignmentPattern : {AssignmentRestProperty }
  1. ? RequireObjectCoercible(value) を実行する
  2. 空の新規List を excludedNames とする
  3. 引数 value と excludedNames を使用して AssignmentRestProperty RestDestructuringAssignmentEvaluation の実行結果を返す
ObjectAssignmentPattern :
{AssignmentPropertyList ,AssignmentRestProperty }
  1. ? RequireObjectCoercible(value) を実行する
  2. 引数 value を使用して ? AssignmentPropertyList PropertyDestructuringAssignmentEvaluation を excludedNames とする
  3. 引数 value と excludedNames を使用して AssignmentRestProperty の RestDestructuringAssignmentEvaluation の実行結果を返す

12.15.5.3 ランタイムセマンティクス(Runtime Semantics): PropertyDestructuringAssignmentEvaluation

引数 value を使用。

次の操作は、すべての非構造化プロパティ名のリストを収集します。
AssignmentPropertyList : AssignmentPropertyList ,AssignmentProperty
  1. 引数 value を使用して AssignmentPropertyList の ? PropertyDestructuringAssignmentEvaluation を propertyNames とする
  2. 引数 value を使用して AssignmentProperty の ? PropertyDestructuringAssignmentEvaluation を nextNames とする
  3. propertyNames の最後に nextNames の各アイテムを追加する
  4. propertyNames を返す
AssignmentProperty : IdentifierReference Initializeropt
  1. IdentifierReference の StringValue を P とする
  2. ? ResolveBinding(P) を lref とする
  3. ? GetV(value, P) を v とする
  4. Initializeropt が 存在し、 v が undefined なら、
    1. IsAnonymousFunctionDefinition(Initializer ) が true なら、
      1. 引数 P を使用して Initializer の NamedEvaluation　　の実行結果を v にセットする
    2. a. でないなら、
      1. Initializer の評価結果を defaultValue とする
      2. ? GetValue(defaultValue) を v にセットする
  5. ? PutValue(lref, v) を実行する
  6. P を含む新しいリストを返す
AssignmentProperty : PropertyName :AssignmentElement
  1. PropertyName の評価結果を name とする
  2. ReturnIfAbrupt(name)
  3. 引数 value と name を使用して ? AssignmentElement の KeyedDestructuringAssignmentEvaluation を実行する
  4. name を含む新しいリストを返す

12.15.5.4 ランタイムセマンティクス(Runtime Semantics): RestDestructuringAssignmentEvaluation

引数 value と excludedNames を使用。

AssignmentRestProperty : ...DestructuringAssignmentTarget
  1. DestructuringAssignmentTarget の評価結果を lref とする
  2. ReturnIfAbrupt(lref)
  3. OrdinaryObjectCreate(%Object.prototype%) を restObj とする
  4. ? CopyDataProperties(restObj, value, excludedNames) を実行する
  5. PutValue(lref, restObj) を返す

12.15.5.5 ランタイムセマンティクス(Runtime Semantics): IteratorDestructuringAssignmentEvaluation

引数 iteratorRecord を使用。

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) を next とする
    2. next が an 突然の完了 なら、true を iteratorRecord.[[Done]] にセット
    3. ReturnIfAbrupt(next)
    4. next が false なら、true を iteratorRecord.[[Done]] にセット
  2. NormalCompletion(empty) を返す
Elision : Elision ,
  1. 引数 iteratorRecord を使用して ? Elision のIteratorDestructuringAssignmentEvaluation を実行する
  2. iteratorRecord.[[Done]] が false なら、
    1. IteratorStep(iteratorRecord) を next とする
    2. next が 突然の完了 なら、true を iteratorRecord.[[Done]] にセット
    3. ReturnIfAbrupt(next)
    4. next が false なら、true を iteratorRecord.[[Done]] にセット
  3. NormalCompletion(empty) を返す
AssignmentElement : DestructuringAssignmentTarget Initializeropt
  1. DestructuringAssignmentTarget が ObjectLiteral と ArrayLiteral でないなら、
    1. DestructuringAssignmentTarget の評価結果を lref とする
    2. ReturnIfAbrupt(lref)
  2. iteratorRecord.[[Done]] が false なら、
    1. IteratorStep(iteratorRecord) を next とする
    2. next が an 突然の完了 なら、true を iteratorRecord.[[Done]] にセット
    3. ReturnIfAbrupt(next)
    4. next が false なら、、true を iteratorRecord.[[Done]] にセット
    5. d. でないなら、
      1. IteratorValue(next) を value とする
      2. value が 突然の完了 なら、true を iteratorRecord.[[Done]] にセット
      3. ReturnIfAbrupt(value)
  3. iteratorRecord.[[Done]] が true なら、undefined を value とする
  4. Initializer が 存在し、 value が undefined なら、
    1. IsAnonymousFunctionDefinition(Initializer ) と DestructuringAssignmentTarget の IsIdentifierRef の両方が true なら、
      1. 引数 GetReferencedName(lref) を使用して Initializer の NamedEvaluation を v とする
    2. a. でないなら、
      1. Initializer の評価結果を defaultValue とする
      2. ? GetValue(defaultValue) を v とする
  5. 4. でないなら、value を v とする
  6. DestructuringAssignmentTarget が ObjectLiteral か ArrayLiteral なら、
    1. DestructuringAssignmentTarget によってカバーされている AssignmentPattern を nestedAssignmentPattern とする
    2. 引数 v を使用して nestedAssignmentPattern の DestructuringAssignmentEvaluation の実行結果を返す
  7. ? PutValue(lref, v) を返す
左から右への評価順序は、イテレータにアクセスする前、またはイニシャライザを評価する前に、分割パターンではないDestructuringAssignmentTargetを評価することによって維持されます。
AssignmentRestElement : ...DestructuringAssignmentTarget
  1. DestructuringAssignmentTarget が ObjectLiteral と ArrayLiteral でないなら、
    1. DestructuringAssignmentTarget の評価結果を lref とする
    2. ReturnIfAbrupt(lref)
  2. ! ArrayCreate(0) を A とする
  3. 0 を n とする
  4. iteratorRecord.[[Done]] が false の間繰り返し
    1. IteratorStep(iteratorRecord) を next とする
    2. next が 突然の完了 なら、true を iteratorRecord.[[Done]] にセット
    3. ReturnIfAbrupt(next)
    4. next が false なら、true を iteratorRecord.[[Done]] にセット
    5. d. でないなら、
      1. IteratorValue(next) を nextValue とする
      2. nextValue が 突然の完了 なら、true を iteratorRecord.[[Done]] にセット
      3. ReturnIfAbrupt(nextValue)
      4. ! CreateDataPropertyOrThrow(A, ! ToString(n), nextValue) を実行する
      5. n + 1 を n にセットする
  5. DestructuringAssignmentTarget が ObjectLiteral と ArrayLiteral でないなら、
    1. ? PutValue(lref, A) を返す
  6. DestructuringAssignmentTarget によってカバーされている AssignmentPattern を nestedAssignmentPattern とする
  7. 引数 A を使用して nestedAssignmentPattern の DestructuringAssignmentEvaluation の実行結果を返す

12.15.5.6 ランタイムセマンティクス(Runtime Semantics): KeyedDestructuringAssignmentEvaluation

引数 value と propertyName を使用。

AssignmentElement : DestructuringAssignmentTarget Initializeropt
  1. DestructuringAssignmentTarget が ObjectLiteral と ArrayLiteral でないなら、
    1. DestructuringAssignmentTarget の評価結果を lref とする
    2. ReturnIfAbrupt(lref)
  2. ? GetV(value, propertyName) を v とする
  3. Initializer が存在し、v が undefined なら、
    1. IsAnonymousFunctionDefinition(Initializer ) と DestructuringAssignmentTarget の IsIdentifierRef の両方が true なら、
      1. 引数 GetReferencedName(lref) を使用して Initializer の NamedEvaluation を rhsValue とする
    2. a. でないなら、
      1. Initializer の評価結果を defaultValue とする
      2. ? GetValue(defaultValue) を rhsValue とする
  4. 3. でないなら、 v を rhsValue とする
  5. DestructuringAssignmentTarget が ObjectLiteral か ArrayLiteral なら、
    1. DestructuringAssignmentTarget によってカバーされている AssignmentPattern を assignmentPattern とする
    2. 引数 rhsValue を使用して assignmentPattern の DestructuringAssignmentEvaluation の実行結果を返す
  6. ? PutValue(lref, rhsValue) を返す

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

構文：

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

12.16.1 静的セマンティクス(Static Semantics): IsFunctionDefinition

Expression : Expression ,AssignmentExpression
  1. false を返す

12.16.2 静的セマンティクス(Static Semantics): AssignmentTargetType

Expression : Expression ,AssignmentExpression
  1. invalid を返す

12.16.3 ランタイムセマンティクス：評価(Runtime Semantics: Evaluation)

Expression : Expression ,AssignmentExpression
  1. Expression の評価結果を lref とする
  2. ? GetValue(lref) を実行する
  3. AssignmentExpression の評価結果を rref とする
  4. ? GetValue(rref) を返す
GetValueは、観察可能な副作用がある可能性があるため、その値が使用されていない場合でも呼び出す必要があります。