Recientemente, descubrí el nuevo Operador de asignación segura (?.=) introducido en JavaScript y estoy realmente fascinado por su simplicidad. ?

El Operador de Asignación Segura (SAO) es una alternativa abreviada al bloque tradicional try...catch. Le permite detectar errores en línea sin escribir código explícito de manejo de errores para cada operación. Aquí tienes un ejemplo:

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

¡Eso es todo! Es así de fácil. Si la solicitud de recuperación arroja un error, se almacena automáticamente en la constante de error; de lo contrario, la respuesta contiene el resultado. Genial, ¿verdad?

Pero espera... hay más.

Cuando usas SAO, aún tienes que manejar errores más adelante, como este:

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;
}

Si bien SAO simplifica el manejo de errores, puede generar un código más detallado. Compare eso con un bloque try...catch tradicional:

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;
}
}

En este caso, try...catch requiere solo 9 líneas de código, mientras que SAO aproximadamente el doble.

Entonces, ¿qué piensas? ¿El Operador de Asignación Segura ahorra tiempo o añade complejidad innecesaria?