Let's talk about the two functions of try catch in Javascript

The program is executed sequentially from top to bottom, and the execution route can be changed through some control statements. Under the influence of the control statements, the final execution route of the program is the control flow.

The control statements in js include if, for, while, try catch, etc., which will change the direction of the program.

Programs operate on data. The data that changes as the program runs, that is, as the control flow progresses, is called data flow.

Obviously, data flow depends on control flow, and data flow analysis in program analysis must also be done first with control flow analysis.

For example, a piece of code like this:

const a = 1;
let b;

if (a === 1) {
    b = '1111';
} else {
    b = '2222';
}

Because a is 1, b = '1111'; will be executed. This is the control flow, that is, the code that the program finally executes. It can be used to analyze the direction of the program and perform some optimizations such as dead code deletion.

As the control flow is executed, b will be assigned the value 2222. This is the data flow, that is, the process of value change, which can be used to analyze the value of a variable in a certain statement.

The program performs different processing on different data. If the data is wrong, the processing program will not be able to handle it, and an error will be reported, which will interrupt the subsequent control flow. For example, the data is empty, the data format is incorrect, and so on. At this time, try catch is used to handle errors, also known as exception handling.

We do exception handling for two purposes:

1. Provide some backup for erroneous logic.

For example, when there is an error in parameter parsing, assign a default value in the catch. There is no need to report this error again after it has been handled. In this case, try catch is also part of the logic, equivalent to if else.

2. Provide a more scenario-based description of the reported error.

JS errors are thrown by the JS engine. For example, calling a method of a null object will report a TypeError, and using an undeclared variable will report an

ReferenceError. The specific Error is reported in different scenarios and has different meanings:

If this object comes from user input, it means that the user input is wrong. If this object is obtained from the server, it means that the data returned by the server is wrong. In different scenarios, the same Error will have more specific meanings, so we need to do try catch. Then throw a custom error, including the error description with scenario information.

Many libraries and frameworks do a good job in this regard. The reported errors all have specific scenario information and even solutions. Some are also managed by error numbers, and solutions can be queried through errorno. This is a customized handling of errors.

However, many errors reported in business codes are not handled in this way, and the original Error is directly reported. We will use the exception monitoring platform to collect some errors that are thrown globally. These errors are often relatively primitive information. Although they include the error location and stack, we still need to locate the problem by looking at the source code.

For example, an error is reported that an object is empty, but how do I know which object is empty, what is the reason, how to solve it, and whether there is a number.

Wouldn't it be much better if we could catch various errors and then throw some custom errors for specific scenarios? Third-party libraries do this very well, but few people pay attention to scenario-based custom errors in business code.

Of course, users of the front-end business code use the software through the interface, so in fact, it is sufficient to just provide some UI prompts for various errors. The library code is for developers, so it is necessary to make scenario-based descriptions of various errors, and even give error numbers and solutions.

But I think business code should treat errors like third-party library code. Don't report meaningless native errors, but report some custom errors with specific meanings. This will make troubleshooting and solving problems much easier.

However, although scenario-based custom errors can better help troubleshoot problems, it must be based on the understanding of the possible errors reported by the code. If the error message you report is different from the actual cause of the error, it will increase the difficulty of troubleshooting the problem. It is better to report the original error.

Summarize

The execution process of a program is the control flow, which is affected by control statements. Data will change during the execution process. The change in data is called data flow. Control flow and data flow are two aspects that are often analyzed in program analysis.

Errors will interrupt the control flow, and we need to do something about the errors through try catch.

Error handling serves two purposes:

One is to do some fallback processing, which is equivalent to if else, and there is no need to report the error.

One is to make a scenario-based description of the native JS error and create an error object with more specific information and throw it out.

Many libraries do this very well, and even give error numbers and solutions. However, many business codes only provide feedback to users on the UI, without any scenario-based packaging for thrown errors. This results in the errors collected by the error monitoring platform being relatively primitive errors, which require checking the source code for troubleshooting. If we can also do some scenario-based error packaging like the library code, it will be much easier to count and troubleshoot problems, which is something most Javascript engineers have not done.

This is the end of this article about the role of try catch in Javascript. For more information about the role of try catch in Javascript, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!