new Operatorsuper Keyword? : ), )if Statementdo-while Statementwhile Statementfor Statementfor-in,for-of, andfor-await-of Statementscontinue Statementbreak Statementreturn Statementwith Statementswitch Statementthrow Statementtry Statementdebugger Statement?um/p1-90`yield andawait are permitted as
letawait0;yield orawait.The
The
The result of evaluating an
Inyield may be used as an identifier. Evaluating theyield as if it was an
When processing an instance of the production
the interpretation of
this KeywordSee
false, returntrue, returnAn
Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an
The
An object initializer is an expression describing the initialization of an Object, written in a form resembling a literal. It is a list of zero or more pairs of
In certain contexts,
In addition to describing an actual object initializer the
This production exists so that
The
The
The
The
See
See
See
See
The abstract operation IsValidRegularExpressionLiteral takes argumentliteral (a
d,g,i,m,s,u,v, ory, or ifflags contains any code point more than once, returnu, letu bev, letv beThe
The abstract operation TemplateString takes argumentstemplateToken (a
This operation returns
The abstract operation GetTemplateObject takes argumenttemplateLiteral (a
The creation of a template object cannot result in an
Each
Future editions of this specification may define additional non-enumerable properties of template objects.
The
The string conversion semantics applied to theString.prototype.concat rather than the+ operator.
The string conversion semantics applied to theString.prototype.concat rather than the+ operator.
The string conversion semantics applied to theString.prototype.concat rather than the+ operator.
This algorithm does not applydelete andtypeof may be applied to parenthesized expressions.
When processing an instance of the production
the interpretation of
This production exists in order to prevent automatic semicolon insertion rules (
a?.b`c`so that it would be interpreted as two valid statements. The purpose is to maintain consistency with similar code without optional chaining:
a.b`c`which is a valid statement and where automatic semicolon insertion does not apply.
Properties are accessed by name, using either the dot notation:
or the bracket notation:
The dot notation is explained by the following syntactic conversion:
is identical in its behaviour to
and similarly
is identical in its behaviour to
where <identifier-name-string> is the
The abstract operation EvaluatePropertyAccessWithExpressionKey takes argumentsbaseValue (an
a[b] = c, it will not be performed until after evaluation ofc.The abstract operation EvaluatePropertyAccessWithIdentifierKey takes argumentsbaseValue (an
new OperatorThe abstract operation EvaluateNew takes argumentsconstructExpr (a
A
The abstract operation EvaluateCall takes argumentsfunc (an
super Keywordsuper[b] = c, it will not be performed until after evaluation ofc.The abstract operation GetSuperConstructor takes no arguments and returns an
The abstract operation MakeSuperPropertyReference takes argumentsactualThis (an
The evaluation of an argument list produces a
The
?..The
The abstract operation EvaluateImportCall takes argumentspecifierExpression (a
The abstract operation ContinueDynamicImport takes argumentspromiseCapability (aimport()
A tagged template is a function call where the arguments of the call are derived from a
Theimport.meta.
The default implementation of HostGetImportMetaProperties is to return a new empty
Theimport.meta.
Most
The default implementation of HostFinalizeImportMeta is to return
delete Operator It is a Syntax Error if the derived
and
The last rule means that expressions such asdelete (((foo))) produce
When adelete operator occurs withindelete operator occurs within
The object that may be created in step
void Operatortypeof Operator+ OperatorThe unary + operator converts its operand to
- OperatorThe unary- operator converts its operand to a numeric value and then negates it. Negating
~ )! )* operator performs multiplication, producing the product of its operands./ operator performs division, producing the quotient of its operands.% operator yields the remainder of its operands from an implied division.+ )The addition operator either performs string concatenation or numeric addition.
- )The- operator performs subtraction, producing the difference of its operands.
<< )Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.
>> )Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
>>> )Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.
The result of evaluating a relational operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
The[In] grammar parameter is needed to avoid confusing thein operator in a relational expression with thein operator in afor statement.
The abstract operation InstanceofOperator takes argumentsV (an
Stepsinstanceof operator semantics. If an object does not define or inheritinstanceof semantics.
The result of evaluating an equality operator is always of type Boolean, reflecting whether the relationship named by the operator holds between its two operands.
Given the above definition of equality:
`${a}` == `${b}`.+a == +b.!a == !b.The equality operators maintain the following invariants:
A != B is equivalent to!(A == B).A == B is equivalent toB == A, except in the order of evaluation ofA andB.The equality operator is not always transitive. For example, there might be two distinct String objects, each representing the same String value; each String object would be considered equal to the String value by the== operator, but the two String objects would not be equal to each other. For example:
new String("a") == "a" and"a" == new String("a") are bothnew String("a") == new String("a") isComparison of Strings uses a simple equality test on sequences of code unit values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore Strings values that are canonically equal according to the Unicode Standard could test as unequal. In effect this algorithm assumes that both Strings are already in normalized form.
The value produced by a&& or|| operator is not necessarily of type Boolean. The value produced will always be the value of one of the two operand expressions.
? : )The grammar for a
| assignmentOpText | opText |
|---|---|
**= | ** |
*= | * |
/= | / |
%= | % |
+= | + |
-= | - |
<<= | << |
>>= | >> |
>>>= | >>> |
&= | & |
^= | ^ |
|= | | |
When this expression occurs within
The abstract operation ApplyStringOrNumericBinaryOperator takes argumentslVal (an**,*,/,%,+,-,<<,>>,>>>,&,^, or|), andrVal (an
+, then**, return ? /, return ? %, return ? >>>, return ? No hint is provided in the calls to
Step
The abstract operation EvaluateStringOrNumericBinaryExpression takes argumentsleftOperand (a
In certain circumstances when processing an instance of the production
the interpretation of
The
The
The
The
Left to right evaluation order is maintained by evaluating a
The
, )