Assignment (=)

The assignment (=) operator is used to assign a value to a variable or property. The assignment expression itself has a value, which is the assigned value. This allows multiple assignments to be chained in order to assign a single value to multiple variables.

Syntax

x = y

Parameters

x
- : A valid assignment target, including an identifier or a property accessor. It can also be a destructuring assignment pattern.
y
- : An expression specifying the value to be assigned to x.

Return value

The value of y.

Exceptions

ReferenceError
- : Thrown in strict mode if assigning to an identifier that is not declared in the scope.
TypeError
- : Thrown in strict mode if assigning to a property that is not modifiable.

Description

The assignment operator is completely different from the equals (=) sign used as syntactic separators in other locations, which include:

Initializers of var, let, and const declarations
Default values of destructuring
Default parameters
Initializers of class fields

All these places accept an assignment expression on the right-hand side of the =, so if you have multiple equals signs chained together:

const x = y = 5;

This is equivalent to:

const x = (y = 5);

Which means y must be a pre-existing variable, and x is a newly declared const variable. y is assigned the value 5, and x is initialized with the value of the y = 5 expression, which is also 5. If y is not a pre-existing variable, a global variable y is implicitly created in non-strict mode, or a ReferenceError is thrown in strict mode. To declare two variables within the same declaration, use:

const x = 5,
  y = 5;

Examples

Simple assignment and chaining

let x = 5;
let y = 10;
let z = 25;

x = y; // x is 10
x = y = z; // x, y and z are all 25

Value of assignment expressions

The assignment expression itself evaluates to the value of the right-hand side, so you can log the value and assign to a variable at the same time.

let x;
console.log(x); // undefined
console.log(x = 2); // 2
console.log(x); // 2

Unqualified identifier assignment

The global object sits at the top of the scope chain. When attempting to resolve a name to a value, the scope chain is searched. This means that properties on the global object are conveniently visible from every scope, without having to qualify the names with globalThis. or window. or global..

Because the global object has a String property (Object.hasOwn(globalThis, "String")), you can use the following code:

function foo() {
  String("s"); // The function `String` is globally available
}

So the global object will ultimately be searched for unqualified identifiers. You don't have to type globalThis.String; you can just type the unqualified String. To make this feature more conceptually consistent, assignment to unqualified identifiers will assume you want to create a property with that name on the global object (with globalThis. omitted), if there is no variable of the same name declared in the scope chain.

foo = "f"; // In non-strict mode, assumes you want to create a property named `foo` on the global object
Object.hasOwn(globalThis, "foo"); // true

In strict mode, assignment to an unqualified identifier in strict mode will result in a ReferenceError, to avoid the accidental creation of properties on the global object.

Note that the implication of the above is that, contrary to popular misinformation, JavaScript does not have implicit or undeclared variables. It just conflates the global object with the global scope and allows omitting the global object qualifier during property creation.

Assignment with destructuring

The left-hand side of can also be an assignment pattern. This allows assigning to multiple variables at once.

const result = /(a+)(b+)(c+)/.exec("aaabcc");
let a = "",
  b = "",
  c = "";
[, a, b, c] = result;
console.log(a, b, c); // "aaa" "b" "cc"

For more information, see Destructuring assignment.