JavaScript Advanced Custom Exception

Preface:

In our actual programming, throwing exceptions (code errors) is the most normal thing, but how to handle exceptions varies from person to person. Some people encounter exceptions and usually solve the exception or hide it in some way; but in JavaScript , a complete set of exception handling mechanisms is provided, so that the program can be executed correctly when encountering exceptions. Therefore, the importance of exception handling in practical applications is unquestionable. A complete Web application must have a complete exception handling mechanism.

In this article we will introduce JavaScript processing

1. Concept

1.1 What are errors and exceptions?

The so-called error is a state in the programming process that prevents the program from running normally, also known as an exception.

In JavaScript , all exceptions are Error objects. When an exception occurs, an Error object is thrown, which contains a description of the error.

Through the exception handling statements provided by JavaScript , we can capture errors that occur in a structured way and separate the exception handling code from the core business code.

1.2 Classification of anomalies

In actual development, exceptions can be mainly divided into the following three types:

• Logic Errors: Logic errors are the most difficult type of errors to track down. These errors are due to errors in the logic of the program's operation, which causes your script program to not get the results you want.
• JavaScript inherent errors: These are the most common types of errors, such as JavaScript syntax errors, code reference errors, type errors, etc. The JavaScript engine will automatically trigger these errors.
• Errors raised by developers: These are usually errors defined by developers to meet their own needs.
  

2. Exception handling

2.1try...catch statement

The try...catch statement is a standard way to handle exceptions in JavaScript. The syntax structure is as follows:

try {
     // Code block for testing }
 catch(err) {
     // Code block to handle errors } 

parameter:

• try : statement allows you to define a block of code that detects errors while executing.
• catch : statement allows you to define a block of code to be executed if an error occurs in the try block.
• err : An identifier that represents an Error object whose type corresponds to the error in the test code block.
  

The sample code is as follows:

try {
  // Code block used to test if there is any error console.log(v) // v is not defined at this time and an exception will be thrown } catch (error) {
  // Throwing an exception will execute this code block console.log('The above code has an error')
}

It is worth noting that **try** and **catch** statements appear in pairs

2.2 finally statement

The finally statement is also called the termination block. This statement block will be executed after try and catch statements are completed, regardless of whether the result is an error.

The syntax structure is as follows:

try {
     // Code block for testing }
 catch(err) {
     // Code block to handle errors }  
finally {
     // Code block that executes regardless of the try catch result}

The sample code is as follows:

// var v
try {
  // Code block used to test if there is any error console.log(v) // v is not defined at this time and an exception will be thrown } catch (error) {
  // Throwing an exception will execute this code block console.log('The above code has an error')
finally
  console.log('I must be executed')
}

2.3throw statement

The throw**** statement is used to throw a user-defined exception. This exception can be of any data type. When a throw statement is executed, the current execution will be stopped. If there is catch block, catch block will be executed, otherwise the loop will be jumped out.

The syntax format is as follows:

throw expression;

expression : the expression to be thrown

Use the throw statement to throw an exception. When you throw an exception, expression specifies the contents of the exception.

The sample code is as follows:

// throw "error" // output error throw false // output false

Of course, throw can also be followed by an object.

3. Error Object

An error object can be created through the Error constructor. When a runtime error occurs, an instance of Error will be thrown. Generally speaking, errors of Error type are rare, and most of them are other error types, but other error types are inherited from Error.

The Error object is mainly used as the base object for user-defined exceptions.

In addition to the Error object, JavaScript also provides the following predefined types of errors:

Error has two main properties:

The syntax format for creating an instance of an Error object is as follows:

new Error([message)

parameter:

message : optional, describing the error message

The creation syntax of other predefined types is the same as Error

3.1 Custom Exception Types

If the exception type provided by JavaScript cannot satisfy us, we can customize our own exception type. This custom exception type generally inherits the Error exception type, and instanceof keyword can be used to indicate the exception type.

Let's first look at the properties and methods provided in Node.js for custom exception types.

As shown below:

error.stack : Property: Returns a string where the first line of the string is formatted as <error class name>: <error message>， with a series of stack frames (each line starts with "at "). Each frame describes a call point in the code that caused the error to be generated.
Error.captureStackTrace(targetObject[, constructorOpt]) method: targetObject represents an object, and constructorOpt represents the constructor of the object. Purpose: Create a .stack attribute on targetObject

The sample code is as follows:

function MyError(message) {
  this.message = message
  this.name = 'MyError'
  /*
   * Error.captureStackTrace(targetObject[, constructorOpt])
   * Parameter targetObject -> represents an object * Parameter constructorOpt -> represents the constructor of the object * Create a .stack property on targetObject, and the call returns a string of the location where Error.captureStackTrace() is called.
   */
  Error.captureStackTrace(this, MyError)
}

MyError.prototype = new Error()
MyError.prototype.constructor = MyError

// * In the node.js environment, new Error will directly throw an exception. It is not applicable to the node.js environment. // function MyError(message) {
// this.name = 'MyError';
// this.message = message || 'Default Message';
// this.stack = (new Error()).stack;
// }
// MyError.prototype = Object.create(Error.prototype);
// MyError.prototype.constructor = MyError;

try {
  throw new MyError('wrong')
} catch (e) {
  console.log(e)
}

Conclusion:

Exception handling in JavaScript generally only does two things in actual development:

• Change exceptions to prompt messages
• Output the exception to the exception log to view the error information.

This is the end of this article about JavaScript advanced custom exceptions. For more relevant JavaScript custom exception content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!