Can the New ?= Operator Eliminate Try‑Catch in JavaScript?

JavaScript's error handling is about to get a major upgrade. The new ECMAScript safe assignment operator proposal ( ?= ) aims to simplify code by reducing the need for traditional try‑catch blocks, and it will be discussed on August 25.

Let’s see how this proposal can simplify error management and make JavaScript code cleaner and more efficient.

Simple Example

Traditional try‑catch blocks often lead to deep nesting, making code hard to read and maintain. The proposal introduces the new operator ?= , which converts a function's result into a tuple. If an error occurs it returns [error, null] ; otherwise it returns [null, result] .

Direct example:

<code>async function getData() {
  const [error, response] ?= await fetch('https://api.example.com/data');
  if (error) return handleError(error);
  return response;
}
</code>

The ?= operator makes error handling more intuitive, keeping code linear and easy to trace. By returning a standardized tuple, error handling stays consistent across the codebase.

Standardized handling also reduces the chance of missing critical errors.

Error Customization

The proposal also introduces Symbol.result to allow custom error‑handling logic. The Symbol.result method should return a tuple [error, result] .

Example:

<code>function example() {
  return {
    [Symbol.result]() {
      return [new Error('错误信息'), null];
    }
  };
}

const [error, result] ?= example();
</code>

The ?= operator can recursively handle objects that implement Symbol.result , ensuring even complex error scenarios are managed smoothly.

<code>const obj = {
  [Symbol.result]() {
    return {
      [Symbol.result]: () => [new Error('嵌套错误'), null]
    };
  }
};

const [error, data] ?= obj;
</code>

Async Support

The ?= operator works seamlessly with Promises and async/await , making asynchronous error handling straightforward.

Example:

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

Old Browser Handling

The proposal can be polyfilled using code from polyfill.js . However, the ?= operator itself cannot be directly polyfilled; for older JavaScript environments a post‑processor should transform ?= into appropriate [Symbol.result] calls.

<code>const [error, data] ?= await asyncAction(arg1, arg2)
// should become
const [error, data] = await asyncAction[Symbol.result](arg1, arg2)

const [error, data] ?= action()
// should become
const [error, data] = action[Symbol.result]()

const [error, data] ?= obj
// should become
const [error, data] = obj[Symbol.result]()
</code>

Design Philosophy

Placing the error first in the [error, data] structure ensures errors are handled before data, reducing the risk of overlooking them.

<code>const [error, data] ?= someFunction();
</code>

The pattern behind ?= is inspired by similar structures in Go, Rust, and Swift, which have long adopted more structured error handling.

The proposal does not aim to automatically handle errors or introduce new types; it simply seeks to standardize and unify error‑handling practices.

Conclusion

The safe assignment operator ( ?= ) is a potential game‑changer for JavaScript error handling, promising to reduce reliance on bulky try‑catch blocks and make code cleaner and safer. Although still under development, it may soon become a standard tool in every JavaScript developer’s toolbox.

For more details, see: https://github.com/arthurfiorette/proposal-safe-assignment-operator?tab=readme-ov-file