Recentemente, descobri o novo Operador de Atribuição Segura (?.=) introduzido em JavaScript e estou realmente fascinado por sua simplicidade. ?

O Safe Assignment Operator (SAO) é uma alternativa abreviada ao bloco try...catch tradicional. Ele permite capturar erros in-line sem escrever código explícito de tratamento de erros para cada operação. Aqui está um exemplo:

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

É isso! É muito fácil. Se a solicitação de busca gerar um erro, ele será automaticamente armazenado na constante de erro; caso contrário, a resposta mantém o resultado. Muito legal, certo?

Mas espere... tem mais.

Ao usar SAO, você ainda terá que lidar com erros mais adiante, 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;
}

Embora SAO simplifique o tratamento de erros, ele pode levar a um código mais detalhado. Compare isso com um bloco 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;
}
}

Neste caso, try...catch leva apenas 9 linhas de código, enquanto SAO aproximadamente o dobro.

Então, o que você acha? O Operador de Atribuição Segura economiza tempo ou adiciona complexidade desnecessária?