How do I skip or ignore errors in javascript / jquery?

Question

Suppose I'm calling 3 javascript (jquery) files like this:

<script type="text/javascript" src="js/file1.js"></script>
<script type="text/javascript" src="js/file2.js"></script>
<script type="text/javascript" src="js/file3.js"></script>

On file2.js there are script errors (or something with a function goes wrong): for example, it says "function does not exist". Because there is an error in file2.js, scripts in file3.js are not executed.

Is there is a way to make sure scripts in file3.js are still executed? Or, is it possible to bypass or ignore the error on file2.js?

Answer 1

You can use a try catch block around the code with the error

try{

//code that causes an error

}catch(e){

functionToHandleError(e);
}
//continue from here

But you should only do that if the error is a known condition/unavoidable problem with an external library or only happens on bad user input. You shouldn't use it to allow the program to keep running at all costs.

Some ways to avoid errors

• check that functions exist before calling them
• check that an object exists before referencing its properties
• if user input is involved, validate the input to check that it's the expected type/range/etc
• if this is a loading order problem consider reordering your scripts, or if this is a larger application using a dependency management system like requireJS
• if objects are undefined after an asynchronous request, remember that code does not wait on an async request and it will not be defined until afterwards. Code dealing with the provided values should be done in a callback function or using deffereds/promises.
• if you're referencing dom elements, consider starting your JS code from within a function that runs when the DOM is loaded such as jQuery's document.ready or the native window.onload.
• if javascript variables are declared without the var keyword, or are attached to a global object, they can be modified in places other than they are declared. Javascript also doesn't have block scope. Make sure you know all the places your variables are being modified, and try to limit the scope of your variables when possible. Especially avoid using too many global variables to hold state, as it can be difficult to know the current state without many null/type checks.

Some ways to handle errors

• If its an expected problem (IE if the input may be empty and requires different handling), ideally check it with an if statement beforehand. If you don't want to do that, you can use try/catch to cast the input, ask for new input, or act on the input given as approperiate.

• if its an unexpected problem (IE you don't know whats going on) a catch block can be a good place to output diagnostic information during development. IE, don't just catch it and let it fail silently, output a message to let you or other developers know where it failed, and then use your favorite browser's web developer tools to inspect the values at the time, figure out what happened, and add handling for that case to fix it.

What not to do

• put the try/catch in, and then just let the program keep on running. If the code that isn't running correctly is unnecessary, get rid of it. If it is necessary and isn't working correctly, fix it.

• use try catches as your input validation (IE if the function is null it will throw an exception and I'll catch it, then I know the function is null). Whenever possible, check for any expected errors. Try/catches should handle "exceptions" when the behavior is unusual and you need to go down an alternative code path or alert the user that something is wrong.

Answer 2

When you don't have time to debug try this:

function stoperror() {
   return true;
}

Call it:

window.onerror = stoperror;

The functionality is very simple: create a function that always returns true, and then whenever an error occurs, call this function (returning true and suppressing the error).

Answer 3

you can use try and catch statements.And check for null by using != null condition

try{


}catch(e){

}

Answer 4

Wrap the call that results in an error in a try...catch block:

try {
   callNonExistentMethod();
}
catch (e) {
   //Handle the error if you wish.
}

Answer 5

you can save yourself from "function is undefined" by using this

//Simple function that will tell if the function is defined or not
function is_function(func) {
    return typeof window[func] !== 'undefined' && $.isFunction(window[func]);
}

//usage

if (is_function("myFunction") {
    alert("myFunction defined");
} else {
    alert("myFunction not defined");
}

Answer 6

I would suggest adding proper null checks around objects(including functions) before assuming they exist,so that the code will fail gracefully.

Here are some ideas: Javascript check if function exists