Understanding try...catch...finally_javascript techniques in javascript

This article analyzes the use of try...catch...finally in javascript and shares it with you for your reference. The specific content is as follows

A little more complicated, you need to use a judgment statement, if else to perform conditional judgment. If condition else else, this kind of judgment is already very familiar to programmers who write program codes.

If you think this is very simple, you may use a mixed if else conditional judgment statement plus try catch to process the statement. Although try catch can handle any object, throw an error statement through throw, and then catch Throw the object or the error of the object. Today we only talk about try...catch. The following examples throw arrays, time, prototype functions, numeric types, etc. respectively.

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

To be more precise, put a statement in try that may cause an error. When the try statement starts executing and an error is thrown, catch executes the internal statement and the corresponding error message in the try. When to execute the finally statement? The finally statement will be executed only after the try statement and the catch statement are executed. The finally statement will be executed regardless of whether the try throws an exception or the catch statement is captured.

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

Throwing an error statement through try, we see that an error message // koringz is captured in catch, but the same finally also outputs // err finally. Although we understand the processing method of try catch workflow, we do not understand the code handler of finally block. According to our consistent way of thinking about finally statements in the past, finally output is not restricted and constrained by try and catch. The following are several output demonstration codes of finally:

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

As shown above, try throws an error statement, and the output result of finally is: // err finally // 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

As shown above, try throws an error statement, and catch captures the error output result as above. // err finally // new finally.

When I modify the try statement:

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

The result is that the output is empty. // void(viod). Because try did not throw an error, catch did not catch the exception, so the output result is empty.

Then let’s take a look at the following case. Through the following example, you may have a better understanding of exception handling in try catch statements.

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

When we nest try catch in a try code block that may cause an error, throw a statement that may cause an error through the nested code block try throw new Error('open');, followed by the nested try Pass the error to the nested catch for processing. After finally running through the nested finally, we see the last result // op open. In fact, the error information captured by the nested catch is thrown to the outermost catch. // op open

That is to say: any given exception will only be caught once by its nearest enclosing catch block.

Of course, any new exceptions thrown in the "inner" block (because the code in the catch block can also throw exceptions) will be caught by the "outer" block.

The above is the entire content of this article. I hope it will be helpful to everyone in learning javascript programming.