javascript

Chapter 14: Error Handling and Debugging
Communication errors can also occur when using Ajax communication. Issues and
errors surrounding Ajax are discussed in Chapter 17 .
Distinguishing between Fatal and Nonfatal Errors
One of the most important parts of any error - handling strategy is to determine whether or not an error is
fatal. One or more of the following identifies a nonfatal error:
❑
❑
❑
❑
It won ’ t interfere with the user ’ s main tasks.
It affects only a portion of the page.
Recovery is possible.
Repeating the action may result in success.
In essence, nonfatal errors aren ’ t a cause for concern. For example, Yahoo! Mail ( http://mail.yahoo.com )
has a feature that allows users to send SMS messages from the interface. If for some reason SMS messages
don ’t work, it ’ s a nonfatal error because that is not the application ’ s primary function. The primary use case
for Yahoo! Mail is to read and write e-mail messages, and as long as the user can do that, there is no reason
to interrupt the user experience. Nonfatal errors don ’ t require you to send an explicit message to the user —
you may be able to replace the area of the page that is affected with a message indicating that the
functionality isn ’ t available, but it ’ s not necessary to interrupt the user.
Fatal errors, on the other hand, are identified by one or more of the following:
❑
❑
❑
The application absolutely cannot continue .
The error significantly interferes with the user ’ s primary objective .
Other errors will occur as a result .
It ’ s vitally important to understand when a fatal error occurs in JavaScript so appropriate action can be
taken. When a fatal error occurs, you should send a message to the user immediately to let them know
that they will not be able to continue what they were doing. If the page must be reloaded for the
application to work, then you should tell the user this and provide a button that automatically reloads
the page.
You must also make sure that your code doesn ’ t dictate what is and is not a fatal error. Nonfatal and fatal
errors are primarily indicated by their affect on the user. Good code design means that an error in one
part of the application shouldn ’ t unnecessarily affect another part that, in reality, isn ’ t related at all. For
example, consider a personalized home page such as My Yahoo! ( http://my.yahoo.com ) that has
multiple independent modules on the page. If each module has to be initialized using a JavaScript call,
you may see code that looks something like this:
for (var i=0, len=mods.length; i < len; i++){
mods[i].init(); //possible fatal error
}
486