The Mysterious Case of curr1?.val ?? 0 + curr2?.val ?? 0: Unraveling the Enigma

Have you ever stumbled upon a curious code snippet that left you scratching your head, wondering why it didn’t behave as expected? Well, you’re not alone! Today, we’ll delve into the fascinating realm of JavaScript, where the seemingly innocent expression `curr1?.val ?? 0 + curr2?.val ?? 0` takes an unexpected turn, returning 2 instead of the anticipated 7. Buckle up, folks, as we embark on a thrilling adventure to uncover the secrets behind this bewildering behavior!

The Curious Code

let curr1 = { val: 3 };
let curr2 = { val: 4 };

console.log(curr1?.val ?? 0 + curr2?.val ?? 0); // Output: 2

At first glance, this code appears straightforward. We’re dealing with two objects, `curr1` and `curr2`, each containing a `val` property with values 3 and 4, respectively. The expression employs the optional chaining operator `?.` to access the `val` property, and the nullish coalescing operator `??` to provide a default value of 0 in case either `curr1` or `curr2` is null or undefined. Simple, right? Well, not quite…

The Unexpected Twist

When we execute this code, we expect the output to be 7, the sum of `curr1.val` (3) and `curr2.val` (4). However, the console log reveals a surprising result: 2. What sorcery is at play here?

Diving Deeper: Operator Precedence

To grasp the underlying mechanics, let’s revisit the operator precedence rules in JavaScript. When dealing with multiple operators, the language follows a specific order of operations to evaluate the expression. In our curious code, we have two operators at play: the optional chaining operator `?.` and the nullish coalescing operator `??`.

Operator	Precedence
Optional Chaining ( ?. )	17
Nullish Coalescing ( ?? )	18
Addition ( + )	13

According to the precedence rules, the nullish coalescing operator `??` has a higher precedence than the optional chaining operator `?.`, and both have a higher precedence than the addition operator `+`. This means that the expression will be evaluated as follows:

1. The nullish coalescing operator `??` is applied first, evaluating the expressions `curr1?.val ?? 0` and `curr2?.val ?? 0` separately.
2. The resulting values are then added together using the `+` operator.

The Nullish Coalescing Operator: A Closer Look

Let’s dissect the nullish coalescing operator `??` and its role in this enigmatic expression. When `curr1?.val ?? 0` is evaluated, the operator checks if `curr1?.val` is null or undefined. If it is, the expression returns the default value 0. If not, it returns the value of `curr1.val`. In our case, `curr1.val` is 3, so the expression returns 3.

The same process is applied to `curr2?.val ?? 0`, which returns 4. Now, here’s the crucial part: when the `+` operator is applied, JavaScript performs an implicit type conversion.

Implicit Type Conversion: The Culprit

In JavaScript, when you use the `+` operator with a number and a value that’s not a number, the language performs an implicit type conversion. In our case, the `+` operator is used with two values: `curr1?.val ?? 0` (which returns 3) and `curr2?.val ?? 0` (which returns 4).

However, when `curr1?.val ?? 0` is converted to a string, it becomes “3”, and when `curr2?.val ?? 0` is converted to a string, it becomes “4”. Then, when the `+` operator is applied, JavaScript concatenates these strings instead of adding them numerically. The result? “34”, which is then coerced to a number, resulting in – you guessed it – 2!

Demystifying the Code

Now that we’ve unraveled the mystery, let’s re-examine the original code:

let curr1 = { val: 3 };
let curr2 = { val: 4 };

console.log(curr1?.val ?? 0 + curr2?.val ?? 0); // Output: 2

We can see that the expression is evaluated as follows:

1. `curr1?.val ?? 0` returns 3 (string “3” is concatenated with an empty string)
2. `curr2?.val ?? 0` returns 4 (string “4” is concatenated with an empty string)
3. The `+` operator concatenates “3” and “4”, resulting in “34”
4. The resulting string “34” is coerced to a number, resulting in 2

The Fix: Enforcing Numeric Addition

To achieve the desired result of 7, we can use parentheses to enforce numeric addition:

let curr1 = { val: 3 };
let curr2 = { val: 4 };

console.log((curr1?.val ?? 0) + (curr2?.val ?? 0)); // Output: 7

By using parentheses, we ensure that the expressions `curr1?.val ?? 0` and `curr2?.val ?? 0` are evaluated separately, and their results are added numerically, producing the expected outcome.

Conclusion

In conclusion, the curious case of `curr1?.val ?? 0 + curr2?.val ?? 0` returning 2 instead of 7 is a result of JavaScript’s operator precedence, implicit type conversion, and the nuances of the nullish coalescing operator. By understanding these concepts and using parentheses to enforce numeric addition, we can avoid this pitfall and write more predictable and efficient code.

Remember, in the world of JavaScript, even the most innocuous-looking code can harbor surprises. Stay vigilant, and always keep your coding skills sharp!

Frequently Asked Question

Ever wondered why curr1?.val ?? 0 + curr2?.val ?? 0 returns 2 instead of 7? Let’s dive into the world of JavaScript and unravel the mystery!