> ## 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
The nullish coalescing operator (`??`) is a logical operator that returns its right-hand operand when its left-hand operand evaluates strictly to a nullish value (`null` or `undefined`). For all other left-hand values—including falsy values such as `0`, `""` (empty string), `NaN`, and `false`—it returns the left-hand operand.
**Syntax**
```javascript theme={"dark"}
leftExpression ?? rightExpression
```
**Evaluation Mechanics**
* **Strict Nullish Check:** Unlike the logical OR operator (`||`), which coerces the left operand to a boolean and evaluates to the right operand for *any* falsy value, `??` strictly checks for the absence of a value (`null` or `undefined`).
* **Short-Circuit Evaluation:** The `??` operator utilizes short-circuiting. If `leftExpression` evaluates to a non-nullish value, the JavaScript engine bypasses the evaluation of `rightExpression` entirely.
**Behavioral Examples**
```javascript theme={"dark"}
// Nullish values trigger the right-hand operand
const a = null ?? 'fallback'; // Evaluates to 'fallback'
const b = undefined ?? 'fallback'; // Evaluates to 'fallback'
// Falsy (but non-nullish) values return the left-hand operand
const c = 0 ?? 42; // Evaluates to 0
const d = "" ?? "fallback text"; // Evaluates to ""
const e = false ?? true; // Evaluates to false
const f = NaN ?? 100; // Evaluates to NaN
```
**Operator Precedence and Grouping**
According to the ECMAScript specification, the `??` operator has lower precedence than the logical AND operator (`&&`), but shares the exact same precedence level as the logical OR operator (`||`). Both `??` and `||` are parsed as immediate productions of `ShortCircuitExpression`.
Because `??` shares a precedence level with `||` but has no defined associativity with either `||` or `&&`, the specification strictly forbids chaining `??` directly with `&&` or `||` operators without explicit grouping. Attempting to mix these operators at the same nesting level results in a `SyntaxError`.
```javascript theme={"dark"}
// SyntaxError: Cannot use unparenthesized `??` within logical OR/AND expressions
null || undefined ?? "foo";
true && undefined ?? "foo";
// Correct usage requires explicit grouping via parentheses
(null || undefined) ?? "foo"; // Evaluates to "foo"
true && (undefined ?? "foo"); // Evaluates to "foo"
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
