Try...catch...finally_javascript-Techniken in Javascript verstehen

Dieser Artikel analysiert die Verwendung von try...catch...finally in Javascript und teilt ihn als Referenz mit Ihnen. Der spezifische Inhalt ist wie folgt

Etwas komplizierter: Sie müssen eine Beurteilungsanweisung verwenden, um eine bedingte Beurteilung durchzuführen. Diese Art der Beurteilung ist Programmierern, die Programmcodes schreiben, bereits sehr vertraut.

Wenn Sie der Meinung sind, dass dies sehr einfach ist, können Sie eine gemischte if else-Bedingungsanweisung und try Catch verwenden, um die Anweisung zu verarbeiten. Obwohl try Catch jedes Objekt verarbeiten kann, werfen Sie eine Fehleranweisung über throw und werfen Sie dann das Objekt ab oder der Fehler des Objekts. Heute sprechen wir nur über try...catch. Die folgenden Beispiele werfen Arrays, Zeit, Prototypfunktionen, numerische Typen usw. ab.

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

Um genauer zu sein, geben Sie eine Anweisung in try ein, die einen Fehler verursachen kann. Wenn die Ausführung der Try-Anweisung beginnt und ein Fehler ausgegeben wird, führt Catch die interne Anweisung und die entsprechende Fehlermeldung im Try aus. Wann soll die „final“-Anweisung ausgeführt werden? Die „final“-Anweisung wird erst ausgeführt, nachdem die „try“-Anweisung und die „catch“-Anweisung ausgeführt wurden. Die „final“-Anweisung wird unabhängig davon ausgeführt, ob der „try“ eine Ausnahme auslöst oder die „catch“-Anweisung erfasst wird.

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

Wenn wir durch try eine Fehleranweisung auslösen, sehen wir, dass eine Fehlermeldung // koringz in Catch erfasst wird, aber das Gleiche gibt letztendlich auch // err Finally aus. Obwohl wir die Verarbeitungsmethode des Try-Catch-Workflows verstehen, verstehen wir nicht den Code-Handler des Final-Blocks. Gemäß unserer konsistenten Denkweise über Final-Anweisungen in der Vergangenheit wird die Final-Ausgabe nicht durch Try und Catch eingeschränkt. Im Folgenden finden Sie mehrere Demonstrationscodes für die Ausgabe von „finally“:

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

Wie oben gezeigt, löst try eine Fehleranweisung aus, und das Ausgabeergebnis von „final“ lautet: // err „final“ // „new „finally“.

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

Wie oben gezeigt, löst try eine Fehleranweisung aus und Catch erfasst das Fehlerausgabeergebnis wie oben. // äh endlich // endlich neu.

Wenn ich die try-Anweisung ändere:

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

Das Ergebnis ist, dass die Ausgabe leer ist. // void(viod). Da „try“ keinen Fehler ausgelöst hat, hat „catch“ die Ausnahme nicht abgefangen, sodass das Ausgabeergebnis leer ist.

Dann schauen wir uns den folgenden Fall an. Anhand des folgenden Beispiels können Sie die Ausnahmebehandlung in Try-Catch-Anweisungen besser verstehen.

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

Wenn wir try Catch in einem Try-Codeblock verschachteln, der einen Fehler verursachen kann, werfen wir eine Anweisung, die einen Fehler verursachen kann, durch den verschachtelten Codeblock try throw new Error('open');, gefolgt vom verschachtelten try Übergeben Nachdem wir den verschachtelten Catch schließlich durchlaufen haben, sehen wir das letzte Ergebnis // op open. Tatsächlich werden die vom verschachtelten Catch erfassten Fehlerinformationen an den äußersten Catch geworfen. // op open

Das heißt: Jede Ausnahme wird nur einmal von ihrem nächsten umschließenden Catch-Block abgefangen.

Natürlich werden alle neuen Ausnahmen, die im „inneren“ Block ausgelöst werden (da der Code im Catch-Block auch Ausnahmen auslösen kann), vom „äußeren“ Block abgefangen.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass er für alle beim Erlernen der Javascript-Programmierung hilfreich sein wird.