Try...Catch V/s Safe Assignment (?=): A Boon or a Curse for Modern Development?

Recently, I discovered the new Safe Assignment Operator (?.=) introduced in JavaScript, and I’m really fascinated by its simplicity. 😍

The Safe Assignment Operator (SAO) is a shorthand alternative to the traditional try...catch block. It lets you catch errors inline without writing explicit error-handling code for each operation. Here’s an example:

const [error, response] ?= await fetch("https://api.example.com/data"); 

That’s it! It’s that easy. If the fetch request throws an error, it’s automatically stored in the error constant; otherwise, the response holds the result. Pretty cool, right?

But wait… there’s more.

When using SAO, you still have to handle errors further down the line, like this:

async function getData() { const [requestError, response] ?= await fetch("https://api.example.com/data"); if (requestError) { handleRequestError(requestError); return; } const [parseError, json] ?= await response.json(); if (parseError) { handleParseError(parseError); return; } const [validationError, data] ?= validation.parse(json); if (validationError) { handleValidationError(validationError); return; } return data; } 

While SAO simplifies error handling, it can lead to more verbose code. Compare that with a traditional try...catch block:

async function getData() { try { const response = await fetch("https://api.example.com/data"); const json = await response.json(); const data = validation.parse(json); return data; } catch (error) { handleError(error); return; } } 

In this case, try...catch takes only 9 lines of code, while SAO approximately double of it.

So, what do you think? Is the Safe Assignment Operator a time-saver, or does it add unnecessary complexity?