La différence entre erreur et exception en JavaScript

https://github.com/Ray-D-Song

L'erreur et l'exception sont des concepts nés de la pratique, visant à gérer les "erreurs programmables".

Erreur

Du point de vue du code, les erreurs ont tendance à être traitées manuellement avec précision.

Par exemple, fnA appelle fnB et fnC. Les deux méthodes peuvent rencontrer des erreurs et le code de traitement est à peu près le suivant :

function fnA() {
  const { err: bErr, res: bRes } = fnB()
  if (bErr) {
    // ...
    // error handling
  }

  const { err: cErr, res: cRes } = fnC()
  if (cErr) {
    // ...
    // error handling
  }
  // normal logic
}

La clé de "erreur" est de renvoyer un objet ou un tableau à partir de la fonction, avec un champ représentant "une erreur s'est produite". Tant que ce champ n'est pas vide, les programmeurs savent que le flux normal a été interrompu.

JavaScript a un objet et un constructeur Error internes, mais il n'est pas nécessaire que le champ représentant l'erreur soit un objet Error. Au lieu de cela, l'objet Error est plus souvent utilisé dans la gestion des exceptions.

Exception

Nous avons déjà une gestion des erreurs, pourquoi avons-nous besoin d'une exception ?

Imaginez un scénario dans lequel vous avez un bouton. Lorsque vous cliquez sur le bouton, il déclenche la fonction A. Après avoir parcouru plusieurs couches d'appels (peut-être 10 couches), une erreur se produit dans la fonction X. Vous ne voulez pas dire à l'utilisateur "erreur inconnue", mais plutôt fournir des informations spécifiques sur ce qui n'a pas fonctionné.

Vous pouvez obtenir cet effet avec des erreurs, mais vous devez écrire dix fois ce code :

function fnA() {
  const { err, res } = fnB()
  if (err) {
    // display error to user
    showErr(err)
  }
}

function fnB() {
  const { err, res } = fnC()
  if (err)
    // propagate error
    return { err, null }
}

// ... 10 similar passes

function fnY() {
  const { err, res } = fnX()
  if (err)
    // propagate error
    return { err, null }
}

Ce type de code passe-partout est très inefficace. Une meilleure méthode consiste à utiliser des exceptions.

Vous n'avez besoin de lever une exception que lorsqu'une erreur se produit dans fnY. Au plus haut niveau, vous pouvez l'attraper.

function fnA() {
  try {
    fnB()
  } catch (e) {
    showErr(e)
  }
}

// ...

function fnY() {
  const { err, res } = fnX()
  if (err)
    // 抛出
    throw err
}

De cette façon, peu importe où une erreur se produit, elle peut être détectée au niveau supérieur et le code des autres couches n'est pas affecté.

Évitez de polluer toute la structure du code avec des erreurs à un seul endroit.

Pourquoi faire la distinction entre les deux ?

Nous avons déjà expliqué pourquoi nous avons besoin d'exceptions, mais pourquoi devons-nous faire la distinction entre les erreurs et les exceptions ?

La meilleure pratique consiste à faire une distinction stricte entre les deux. Si une erreur n’a pas besoin d’être transmise couche par couche, elle doit être traitée directement dans la couche actuelle. Par exemple, l'erreur de fnC n'a pas besoin d'être utilisée dans fnA, elle doit donc être traitée comme une erreur directement dans B.

Supposons que toutes les erreurs sont traitées au niveau supérieur, alors toute la logique est empilée dans le bloc catch au niveau supérieur, ce qui est difficile à maintenir.

function main() {
  try {
    task1()
    task2()
    task3()
  } catch(e) {
    switch(e) {
      case "type A":
        //...
        break;
      case "type B":
        //...
        break;
      case "type C":
        //...
        break;
    }
  }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!