.JS File Format – Expressions

Precedence and associativity

Higher levels bind first. Associativity decides how operators of the same level group: left means a - b - c is (a - b) - c.

Three rules cut across the table:

• A unary expression may not be the left operand of **. So -2 ** 2 is a syntax error; write (-2) ** 2 or -(2 ** 2).
• ?? may not be mixed with && or || without parentheses: a ?? b || c is a syntax error.
• In the head of a for statement, a bare in is not an operator unless parenthesised, because of the for-in form.

Evaluation order

Operands are evaluated left to right, each fully before the next, and before the operator is applied. In an assignment, the left-hand side’s reference is worked out first, then the right-hand side.

let i = 0;
const a = [];
a[i++] = i;           // a[0] = 1
f() + g() * h();      // calls f, g, h in that order

Primary expressions

const key = 'dynamic', x = 1;
const obj = {
  x,                         // shorthand for  x: x
  [key + 'Name']: 2,         // computed key
  method() { return 3; },    // method
  get value() { return 4; }, // getter
  set value(v) {},           // setter
  async go() {},             // async method
  *gen() {},                 // generator method
  async *agen() {},          // async generator method
  __proto__: Array.prototype, // sets the prototype
  ...other,                  // copy another object’s properties
};
const arr = [1, , 3, ...more];  // holes and spread

Property access and calls

• The left of . or [] goes through ToObject, so accessing a property of null or undefined throws a TypeError.
• a[b] applies ToPropertyKey to b.
• new F and new F() are the same; the first is lower in the table, so new F.g means new (F.g), and new F().g means (new F()).g.
• A call on a member expression sets this; see Functions.
• new.target, super and import.meta are special forms: see Functions, Classes and Modules.

Optional chaining

OptionalExpression:
    MemberExpression OptionalChain
    CallExpression OptionalChain
    OptionalExpression OptionalChain
OptionalChain:
    ?. Arguments
    ?. [ Expression ]
    ?. IdentifierName
    ?. TemplateLiteral          (early error)
    ?. PrivateIdentifier
    OptionalChain Arguments
    OptionalChain [ Expression ]
    OptionalChain . IdentifierName
    OptionalChain TemplateLiteral  (early error)
    OptionalChain . PrivateIdentifier

a?.b, a?.[b] and a?.(b) evaluate to undefined if a is null or undefined, without evaluating the rest (ES2020).

• The whole chain stops at the first nullish link, so a?.b.c(d) does not read .c or evaluate d when a is nullish.
• It tests only the left value. a.b?.() calls b with this as a, if b is not nullish.
• a?.b = 1 is a syntax error. So are new a?.b() and a template directly after ?..
• delete a?.b is allowed, and gives true if the chain stops.

Unary operators

In strict code, delete on a plain name is a syntax error. delete of a private field is a syntax error everywhere, and delete super.x throws a ReferenceError at run time.

++ and -- need a target that can be assigned, apply ToNumeric, and work on BigInts too. Postfix returns the old value and prefix the new one.

Arithmetic

• + applies ToPrimitive with hint "default" to both operands. If either is then a string, the other goes through ToString and they are joined. Otherwise both go through ToNumeric and are added.
• -, *, /, % and ** apply ToNumeric to both.
• Mixing Number and BigInt throws a TypeError.
• % is a truncated remainder, with the sign of the dividend: -7 % 3 is -1.
• ** is right-associative, and 2 ** 3 ** 2 is 512 (ES2016). A negative BigInt exponent throws a RangeError.

Bitwise and shift

For Numbers, &, |, ^, ~ and << work on ToInt32, and >>> on ToUint32. The result is a Number. The shift count is taken modulo 32. On BigInts they operate without a width limit, except that >>> throws a TypeError, since the sign has no fixed position.

Relational and equality

The comparison algorithms are on the Types page.

• x in obj is true if x is a key of obj or its prototype chain. The right operand must be an object.
• #x in obj tests whether obj has the private element #x (ES2022). It is valid only inside the class body.
• x instanceof F uses F[Symbol.hasInstance] if present, and otherwise walks x’s prototype chain looking for F.prototype. The right operand must be callable.

Logical and nullish operators

They return the operand itself, not a boolean. a || b falls through for 0 and "", which a ?? b does not.

Assignment

AssignmentExpression:
    ConditionalExpression
    YieldExpression
    ArrowFunction
    AsyncArrowFunction
    LeftHandSideExpression = AssignmentExpression
    LeftHandSideExpression AssignmentOperator AssignmentExpression
    LeftHandSideExpression &&= AssignmentExpression
    LeftHandSideExpression ||= AssignmentExpression
    LeftHandSideExpression ??= AssignmentExpression

• An assignment’s value is the assigned value, so a = b = 1 works.
• A compound operator such as += evaluates the target once.
• &&=, ||= and ??= (ES2021) evaluate and assign the right side only when needed. If they short-circuit, no write happens, so a setter is not called.
• Assignment to a name that does not resolve creates a global property in sloppy code, and throws a ReferenceError in strict code.
• An anonymous function or class takes its name from the target, so in const f = () => 1, f.name is "f".

Destructuring

Destructuring reads values out of an object or iterable into bindings or targets. Patterns work in var, let and const declarations, parameters, catch clauses, for heads and assignments.

const { a, b: renamed, c = 10, [key]: d, ...others } = obj;
const [x, , y = 2, ...rest] = iterable;

function draw({ width = 100, height = 100 } = {}) { }

let m, n;
[m, n] = [n, m];           // swap, as an assignment
({ m, n } = source);       // needs parentheses at statement start

• An object pattern reads named properties. Keys can be computed. A source of null or undefined throws a TypeError.
• An array pattern uses the iteration protocol, so it works on any iterable. Commas skip elements.
• A default applies only when the value is undefined, not null.
• A rest element must be last, with no trailing comma after it. In an object pattern it copies own enumerable properties not already picked out, and in an array pattern it collects the remaining values in an array.
• A declaration’s pattern binds names. An assignment’s pattern may target any reference: [o.x, a[0]] = pair.
• Patterns can nest.

Spread

Spread is shallow. Object spread defines properties with CopyDataProperties, and does not run setters on the new object. It is not an operator, so it has no value of its own.

Conditional, comma and others

• a ? b : c evaluates only the chosen branch. It is right-associative, so a ? b : c ? d : e is a ? b : (c ? d : e).
• a, b evaluates both and gives b. The comma that separates arguments or declarators is not this operator.
• yield and yield* are valid in generators, and await in async code, as explained in Iterators and generators and Async.