Expressions and operators - JavaScript | MDN

Spread syntax allows an iterable, such as an array or string, to be expanded in places where zero or more arguments (for function calls) or elements (for array literals) are expected. In an object literal, the spread syntax enumerates the properties of an object and adds the key-value pairs to the object being created.

Comma operator

The comma operator allows multiple expressions to be evaluated in a single statement and returns the result of the last expression.

What are operators?

As the

What are statements, declarations, and expressions?

section explains, an expression is a fundamental building block that evaluates to a value. Statements, declarations, and expressions can all define specific slots where expressions are accepted. Where an expression contains slots for further nested expressions, the part(s) that are not slots are known as operators.

For example, the syntax for an

addition

expression is expression + expression (if you read the spec, the operands are called AdditiveExpression and MultiplicativeExpression, which are both subsets of Expression, but that's the spec's mechanism for defining

precedence and associativity

and is irrelevant for our purposes). Apart from the two expression slots, the code entity it introduces is just +: the addition operator. Similarly, the syntax for a

yield

expression is yield expression, so yield is known as the operator. In other words, each operator corresponds to an expression.

MDN also regards expressions without slots such as

null

as operators per the definition above, although we nearly always just refer to them as "syntax" or "expression".

An expression does not need to take a fixed number of slots. For example, the array literal expression, [expression, expression, expression], can take an arbitrary number of expression slots. The [,,] part might be called an "operator". MDN avoids this usage, but you may see it in functional programming languages like

Haskell

The definition of operators gets fuzzier with certain other code entities: what if an expression has a slot that's not an expression, or a code entity combined with an expression does not make an expression? Do we still refer to that code entity as an operator?

In the

optional chaining

expression foo?.bar, foo is an expression, but bar must be an identifier and is not evaluated to a value. Do we still regard ?. as an operator?

In the

arrow function

expression arg => body, body might be an expression (although it can also be a block body), and arg is just an argument list. Do we still regard => as an operator?

In the

spread syntax

...foo, foo is an expression, but the whole thing is not an expression because it does not evaluate to a value—it only makes sense in certain other expressions like function calls, array literals, and object literals. Do we still regard ... as an operator?

The term "operator" is not precisely defined in JavaScript, so MDN does not give a definitive answer. Our approach is to group all these constructs under "Operators" but avoid formally referring to them as operators. Many useful concepts about operators, such as

precedence

, still apply to them regardless of their exact nature.

Specifications

Specification

ECMAScript® 2027 Language Specification# sec-this-keyword

ECMAScript® 2027 Language Specification# sec-assignment-operators

ECMAScript® 2027 Language Specification# sec-relational-operators

ECMAScript® 2027 Language Specification# sec-unary-plus-operator

ECMAScript® 2027 Language Specification# sec-super-keyword

ECMAScript® 2027 Language Specification# sec-built-in-function-objects

ECMAScript® 2027 Language Specification# sec-typeof-operator

ECMAScript® 2027 Language Specification# prod-PropertyDefinition