IE accident treatment: I have a relationship, I am wrong

Do you understand the concept of "accident processing"? Accidents are an important feature of advanced programming languages ​​(such as C , Java, and VBScript), which is responsible for controlling what operations should be performed when an application is incorrect. Independent JavaScript does not support accidents, which leads to some programmers prefer to use VBScript instead of JavaScript. But since IE5, this aspect of JavaScript has been supplemented and enhanced. By increasing unexpected processing functions to the grammar, Microsoft enhances JavaScript to C and Java language standards. We have reason to believe that some VBScript programmers will move quickly to JavaScript camp.

Detailed content is:

How to write a JavaScript leading to unexpected accident code

How to write a user leads to unexpected accident code

How to write users in the application leading to unexpected accident code

JavaScript, C and Java accidental processing distinction

Accidental Differences for JavaScript and VBScript

How to avoid contradiction between JavaScript and VBScript

In many programming languages, when trying to execute an illegal instruction, the code will cause a runtime accident. One of the most insignificant illegal operations we may experience is "divided by 0" error. JavaScript does not perform this, it will assign a value to the result variable. Other illegal operations are also common for other programming languages, including JavaScript. Accessing an empty pointer or an empty object is also an example, an array element that accesses an extra-array legal range is another example.

For developers, it is usually necessary to avoid system errors. System information is usually very vague, and the general users don't understand. In fact, system errors will seriously affect a programmer's reputation because they are clear evidence of bugs (bugs). We hope to find these errors in your code, discover them before they attack the operating system to avoid errors. Finding accidents in the code will cause the code to be bloated. When the language does not support accident processing, it is inevitable that the normal code stream and error findings are inevitable. The following code will look for two errors - access an empty object and an array element of the exceeding range:

Var newobject = creteObject (datapiece1, datapiece2, datapiece3);

IF (newObject == null) {

// Do Something Herehen The Object Was Not Created

...

}

Else {

// getElementIndex return an index or -1 for an error

Var index = newobject.getlementIndex ();

IF (INDEX == -1) {

// Handle The Error Case

...

}

Else {

{

// finally, you can do something with index

...

}

The key to supporting accident processing in JavaScript (the same in other languages, this article will explain later) is a try ... catch statement. Try This keyword guides a piece of processed normal processing code, and the catch keyword boots an unexpected processing code. Once in this area, an accident is triggered, and the control of the program process is switched to the first CATCH area followed. But once JavaScript is triggered (this is the programmer opposed), there is no mechanism to determine the type of error. The following is a try ... catch code area used to simulate the above flow: try {

Var newobject = creteObject (datapiece1, datapiece2, datapiece3);

Var index = newobject.getlementIndex ();

// Do Something with INDEX

}

Catch {

Alert ("System Error; Call Your Sw Vendor);

}

Here is another example, you can actually run on your computer: