> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# JavaScript Nullish Coalescing Assignment
The logical nullish assignment (`??=`) operator evaluates the left-hand operand and assigns the right-hand operand to it strictly if the left-hand operand is a nullish value (`null` or `undefined`).
```javascript theme={"dark"}
LeftHandSideExpression ??= AssignmentExpression
```
## Mechanics and Evaluation
The operator relies on short-circuit evaluation. The exact execution steps are:
1. The `LeftHandSideExpression` is evaluated.
2. If the result is strictly `null` or `undefined`, the `AssignmentExpression` is evaluated and its result is assigned to the `LeftHandSideExpression`.
3. If the result is any other value (including non-nullish falsy values like `0`, `""`, `false`, or `NaN`), the operator short-circuits. The `AssignmentExpression` is never evaluated, and no assignment operation occurs.
## Logical Equivalence
The `??=` operator is logically equivalent to the following expression:
```javascript theme={"dark"}
x ?? (x = y)
```
It is a common misconception to equate `x ??= y` with `x = x ?? y`. While the resulting value of `x` is the same, the underlying mechanics differ significantly. The expression `x = x ?? y` will *always* perform an assignment operation, which will trigger object setters or proxy traps on the left-hand side. The `??=` operator guarantees that the assignment (and any associated side effects) only occurs if the left-hand side is actually nullish.
## Behavior Examples
The following examples demonstrate the operator's strict adherence to nullish checks, ignoring standard falsy values:
```javascript theme={"dark"}
let valNull = null;
valNull ??= 10;
// Result: 10 (LHS was null)
let valUndefined = undefined;
valUndefined ??= 20;
// Result: 20 (LHS was undefined)
let valZero = 0;
valZero ??= 30;
// Result: 0 (LHS was falsy, but not nullish)
let valEmptyString = "";
valEmptyString ??= "text";
// Result: "" (LHS was falsy, but not nullish)
let valFalse = false;
valFalse ??= true;
// Result: false (LHS was falsy, but not nullish)
```
## Short-Circuit Demonstration
Because the operator short-circuits, the right-hand side expression is completely ignored if the left-hand side is already initialized with a non-nullish value.
```javascript theme={"dark"}
let initializedVariable = 5;
// The function getFallbackValue() is never called
initializedVariable ??= getFallbackValue();
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
