Comprendre les techniques try...catch...finally_javascript en javascript

Cet article analyse l'utilisation de try...catch...finally en javascript et le partage avec vous pour votre référence. Le contenu spécifique est le suivant

Un peu plus compliqué, vous devez utiliser une instruction de jugement, if else, pour effectuer un jugement conditionnel If condition else, ce type de jugement est déjà très familier aux programmeurs qui écrivent des codes de programme.

Si vous pensez que c'est très simple, vous pouvez utiliser une instruction de jugement conditionnel if else plus try catch pour traiter l'instruction. Bien que try catch puisse gérer n'importe quel objet, lancez une instruction d'erreur via throw, puis catch Lancez l'objet. ou l'erreur de l'objet. Aujourd'hui, nous ne parlons que de try...catch. Les exemples suivants lancent respectivement des tableaux, du temps, des fonctions prototypes, des types numériques.

function trycatch () {
  var array = [234],
    newdate = new Date(),
    fun = function(){},
    is = 12.22,
    call;
  try{
    throw array + '\n' + newdate.toLocaleString() + ' \n' + fun.prototype.constructor + 
    '\n' + (typeof is == 'number') +' \n' + call ; //小心local后面还有一个'e'
  }
  catch(e){
    console.log(e);
  }
  finally{
    console.log('err finally');
  }
}
trycatch () 

// 输出：

// 234

// 2015/10/12 下午10:07:03 

// function (){}

// true 

// undefined

Pour être plus précis, mettez une instruction dans try qui peut provoquer une erreur. Lorsque l'instruction try commence à s'exécuter et qu'une erreur est générée, catch exécute l'instruction interne et le message d'erreur correspondant dans l'essai. Quand exécuter l'instruction final ? L'instruction final ne sera exécutée qu'après l'exécution de l'instruction try et de l'instruction catch. L'instruction enfin sera exécutée, que l'instruction try lève une exception ou que l'instruction catch soit capturée.

function trycatch () {
  try{
    throw new Error('koringz');
  }
  catch(e){
    console.log(e.message);
  }
  finally{
    console.log('err finally');
  }
}
trycatch ()
// 输出：
// koringz
// err finally

En lançant une déclaration d'erreur via try, nous voyons qu'un message d'erreur // koringz est capturé dans catch, mais le même résultat finit également // err finalement. Bien que nous comprenions la méthode de traitement du workflow try catch, nous ne comprenons pas le gestionnaire de code du bloc final. Selon notre façon cohérente de penser les instructions enfin dans le passé, la sortie finale n'est pas restreinte et contrainte par try et catch. Voici plusieurs codes de démonstration de sortie de finalement :

function trycatch () {
  try{
    throw new Error('koringz');
  }
  finally{
    console.log('err finally');
    return console.log('new finally')
  }
}
trycatch ()
// err finally
// new finally

Comme indiqué ci-dessus, try renvoie une instruction d'erreur et le résultat de finalement est : // err final // new final.

function trycatch () {
  try{
    throw new Error('koringz');
  }
  catch(e){
    console.log('err finally');
    return console.log('new finally')
  }
}
trycatch ()
// err finally
// new finally

Comme indiqué ci-dessus, try renvoie une instruction d'erreur et catch capture le résultat de sortie d'erreur comme ci-dessus. // euh enfin // nouveau enfin.

Quand je modifie l'instruction try :

function trycatch () {
  try{
    // 
  }
  catch(e){
    console.log('err finally');
    return console.log('new finally')
  }
}
trycatch ()
// 空(viod)
// 空(viod)

Le résultat est que la sortie est vide. // vide (viod). Parce que try n'a pas généré d'erreur, catch n'a pas intercepté l'exception, le résultat de sortie est donc vide.

Jetons ensuite un coup d'œil au cas suivant. Grâce à l'exemple suivant, vous aurez peut-être une meilleure compréhension de la gestion des exceptions dans les instructions try catch.

try{
  try{
    throw new Error('open');
  }
  catch(e){
    console.info(e.message);
    throw e
  }
  finally{
    console.log('finally');
  }
}
catch(e){
  console.log('op',e.message);
}
// open
// finally
// op open

Lorsque nous imbriquons try catch dans un bloc de code try pouvant provoquer une erreur, lancez une instruction pouvant provoquer une erreur via le bloc de code imbriqué try throw new Error('open');, suivie de l'imbriqué try Pass the Erreur au catch imbriqué pour le traitement.Après avoir finalement parcouru le catch imbriqué, nous voyons le dernier résultat // opération ouvert. En fait, les informations d'erreur capturées par le catch imbriqué sont renvoyées au catch le plus externe. // opération ouvrir

C'est-à-dire : toute exception donnée ne sera interceptée qu'une seule fois par son bloc catch englobant le plus proche.

Bien sûr, toute nouvelle exception levée dans le bloc « interne » (car le code dans le bloc catch peut également lever des exceptions) sera interceptée par le bloc « externe ».

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à tout le monde dans l'apprentissage de la programmation javascript.