How the New JavaScript ?= Operator Can Eliminate Try‑Catch Boilerplate

What is the safe‑assignment operator?

The ?= operator is new ECMAScript syntax that captures any error that would be thrown during an assignment, returning a tuple [error, value] instead of propagating an exception.

Basic usage

Traditional error handling with try‑catch:

async function fetchData() {
  try {
    const response = await fetch("https://api.example.com/data");
    if (!response.ok) {
      throw new Error('Network response was not ok');
    }
    return response.json();
  } catch (error) {
    console.error('Fetch error:', error);
    return null;
  }
}

Using the safe‑assignment operator the same logic becomes:

async function fetchData() {
  const [error, data] ?= await fetch("https://api.example.com/data").json();
  if (error) {
    console.error('Fetch error:', error);
    return null;
  }
  return data;
}

Advantages

Reduced nesting – fewer try‑catch blocks produce flatter code.

Improved readability – error handling is expressed as a simple conditional on the captured error value.

Cross‑API consistency – the same pattern works for any API that may throw.

Enhanced safety – errors are captured automatically, lowering the chance of ignored exceptions.

Integration with Symbol.result

Objects that implement a Symbol.result method can supply their own [error, value] tuple, allowing custom error handling:

function example() {
  return {
    [Symbol.result]() {
      return [new Error("Error message"), null];
    },
  };
}
const [error, result] ?= example();
if (error) {
  console.error('Error:', error.message);
}

Recursive error handling

The operator can be applied to nested objects that also define Symbol.result, enabling deep error propagation:

const obj = {
  [Symbol.result]() {
    return [
      null,
      { [Symbol.result]: () => [new Error("Nested error"), null] }
    ];
  },
};
const [error, data] ?= obj;

Async functions and promises

The operator works seamlessly with await and promise values:

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

Practical database example

async function getUserData(userId) {
  const [error, user] ?= await database.getUser(userId);
  if (error) {
    console.error('Database error:', error);
    return null;
  }
  return user;
}

If database.getUser throws, error captures the exception and user is null, allowing graceful handling without a try‑catch block.

Polyfill

A polyfill for experimenting with the proposal is available at:

https://github.com/arthurfiorette/proposal-safe-assignment-operator/blob/main/polyfill.js

Reference

Discussion thread: https://es.discourse.group/t/safe-assignment-operator/2111