Récemment, j'ai découvert le nouvel opérateur d'affectation sécurisée (?.=) introduit dans JavaScript, et je suis vraiment fasciné par sa simplicité. ?

Le Safe Assignment Operator (SAO) est une alternative abrégée au bloc try...catch traditionnel. Il vous permet de détecter les erreurs en ligne sans écrire de code explicite de gestion des erreurs pour chaque opération. Voici un exemple :

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

C'est ça! C'est aussi simple que cela. Si la requête d'extraction génère une erreur, elle est automatiquement stockée dans la constante d'erreur ; sinon, la réponse contient le résultat. Plutôt cool, non ?

Mais attendez… il y a plus.

Lorsque vous utilisez SAO, vous devez toujours gérer les erreurs plus tard, comme ceci :

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

Bien que SAO simplifie la gestion des erreurs, il peut conduire à un code plus détaillé. Comparez cela avec un bloc try...catch traditionnel :

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

Dans ce cas, try...catch ne prend que 9 lignes de code, alors que SAO en a environ le double.

Alors, qu'en pensez-vous ? L'opérateur d'affectation sécurisée permet-il de gagner du temps ou ajoute-t-il une complexité inutile ?