Understanding Nullish Coalescing (or ??) in Javascript

In Javascript, the nullish coalescing operator, or ?? operator is used to return the right-hand side whenever the left-hand side is null or undefined. To understand a little bit better, let's look at a few examples:

// Is set to 0
let x = 0 ?? "hello";

// Is set to goodbye
let y = undefined ?? "goodbye";

// Is set to hello
let z = null ?? "hello";

// Is set to false
let a = false ?? "goodbye";

The nullish coalescing operator is useful in situations where something can be returned as either null or undefined, and helps us tighten up our code. For example, a function that returns undefined in some situations can be provided with a default value:

let myFunction = (a) => {
    if(a >= 5) {
        return "hello world";
    }
}

// Will return "goodbye world", since `myFunction(4)` returns undefined.
let runFunction = myFunction(4) ?? "goodbye world";

Differences between the logical OR operator

In the past, we typically set default values in Javascript using the logical OR (||) operator. It has the same kind of functionality, in that it sets a value if the first value on the left doesn't meet certain criteria. However, the || operator returns the right-hand value if the left-hand value is anything falsy - and there are a lot of falsy values, as shown in the list below.

Falsy Values

• false
• 0 or -0 or 0n
• any empty string, i.e. ""
• null
• undefined
• NaN

As such, using the || operator would mean that if a function returned the value 0, and we really did want to use the 0 value, we wouldn't be able to - since 0 is false. With the nullish coalescing operator (??), 0 is a valid value since it only triggers if a value is null or undefined:

// Is set to 0
let x = 0 ?? 5;

// Is set to 5
let y = 0 || 5;

Similarly, if a string is empty, the || operator would default to the right-hand side - which is not always the desired behavior. The ?? operator lets us avoid that:

// Is set to ""
let x = "" ?? "default text";

// Is set to "default text"
let x = "" || "default text";

Chaining the nullish coalescing operator

It is also possible to chain the nullish coalescing operator, as shown below:

// Is set to "default text"
let x = null ?? undefined ?? "default text";

But you cannot chain it with the logical || operator, unless with parenthesis:

// Errors out:
let x = 0 || undefined ?? "default text";

// Returns "default text";
let y = (0 || undefined) ?? "default text";

Also published here.