How the New JavaScript Safe Assignment Operator Eliminates try‑catch

Overview

The ECMAScript proposal‑safe‑assignment‑operator introduces the ?= operator to simplify error handling. When applied to a function or value, the operator returns a two‑element array: [error, null] if the operation throws, or [null, result] on success. The operator works with Promise, async functions, and any object that implements a Symbol.result method.

Operator Semantics

The ?= operator invokes the right‑hand side’s Symbol.result method and expects the method to return an array whose first element is an error (or null) and whose second element is the value (or undefined). When the right‑hand side is a function, all arguments are forwarded to its Symbol.result method; when it is an object, no arguments are passed.

Symbol.result

Any object that defines a Symbol.result method can be used with ?=. The method must return an array [error, value]. Example:

function example() {
  return {
    [Symbol.result]() {
      return [new Error("Error!"), null];
    }
  };
}

const [error, result] ?= example(); // error is Error('Error!')

Recursive Handling

If the returned [null, data] itself implements Symbol.result, the operator recursively invokes that method. This enables seamless handling of nested structures such as Promises or objects that return further [error, result] tuples.

const obj = {
  [Symbol.result]() {
    return [
      null,
      {
        [Symbol.result]() {
          return [new Error("Error"), null];
        }
      }
    ];
  }
};

const [error, data] ?= obj; // error is Error('Error')

Promise Integration

The only non‑function value that can be used with ?= besides plain objects is a Promise. When awaiting a Promise and applying ?=, the resolved value is processed via its Symbol.result method.

const promise = getPromise();
const [error, data] ?= await promise; // equivalent to await promise[Symbol.result]()

Combining await with ?= works reliably because the recursive handling propagates through the Promise chain.

Usage Example

Without ?= the error handling for an async fetch requires multiple try‑catch blocks or manual checks:

async function getData() {
  const response = await fetch("https://blog.conardli.top");
  const json = await response.json();
  return validationSchema.parse(json);
}

Using the safe assignment operator the same logic becomes a linear series of tuple assignments:

async function getData() {
  const [requestError, response] ?= await fetch("https://blog.conardli.top");
  if (requestError) { handleRequestError(requestError); return; }

  const [parseError, json] ?= await response.json();
  if (parseError) { handleParseError(parseError); return; }

  const [validationError, data] ?= validationSchema.parse(json);
  if (validationError) { handleValidationError(validationError); return; }

  return data;
}

Polyfill and Compilation

The proposal is still at an early stage and not part of the official standard. A polyfill that provides Symbol.result implementations is available at

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

. The ?= operator itself cannot be polyfilled; older JavaScript environments must compile the operator into explicit [Symbol.result] calls.

// Original
const [error, data] ?= await asyncAction(arg1, arg2);

// Compiled
const [error, data] = await asyncAction[Symbol.result](arg1, arg2);

The proposal repository is

https://github.com/arthurfiorette/proposal-safe-assignment-operator

.