Ignore javascript syntax errors in a page and continue executing the script

Question

I develop plugins for WordPress. It uses some jquery in the user side (themes) as a jquery plugin. The problem is, when there is an javascript error with other plugins made by other autors, my plugin's javascript fails to execute.

And the worst thing is people consider that there is a serious fault with my plugin even though it works 100% fine with error handling conditional statements. But it is actually due to some other javascript syntax errors of some other WP plugin/theme authors.

Is there a way to continue execute my plugin JS ignoring other JS errors. Or can i have suggestions to handle this problem ??

Solution 1

Try :

window.onerror = function(){
   return true;
}

That is if you can include this before the bugged script has been executed.

Solution 2

You should correct the old JavaScript error because it may create many problems, not for right now but for next time.

Put your JavaScript file / code at the top (before JS having error), and call it before JavaScript effected by other JavaScript code.

In case you need handle JavaScript exception at run time, best option is

try { /* run js code */ } 
    catch (error){ /* resolve the issue or bug */ }

Solution 3

You should be able to swallow any error using the error event:

$(window).error(function(e){
    e.preventDefault();
});

I've never attempted this, but it should work in theory.

It should be noted that this probably isn't a great solution to your problem. It could be that your plugin is interfering with other plugins. It is, of course, possible that the errors are no fault of your own, but generally speaking (with publicly released plugins) not the case.

Solution 4

I encountered the same problem: There are a bunch of plugins out there that make too many assumptions and cause JavaScript errors on YOUR page, even when you are being a good citizen; these errors have nothing to do with your plugin.

There's no sense trying to handle errors in other plugins -- IMO it is better to be self-contained but resilient to their errors.

In my case, the errors were halting the jquery DOM ready event, and my JavaScript init code wasn't getting executed. The exact form of the error isn't important though -- the solution is just to fire on multiple events.

The solution for me was to have fallbacks in addition to relying on the jQuery DOM ready event:

1. I wrapped any code I wanted to fire on the DOM ready event into their own function -- e.g. my_hardened_init_action();
2. I added a function, my_hardened_init(), that only runs once. It calls my_hardened_init_action() the first time it is called, and does nothing on subsequent calls.
3. I added various methods to call my_hardened_init() in the WordPress footer. In my case, I only needed two. First, trying the usual jQuery DOM init, but falling back to a simple setTimeout(). So if the jQuery DOM init never fires due to broken JavaScript, the timeout will fire shortly after when the page has finished loading.

You could add multiple other fallbacks -- even add the code to the header if needs be. As my_hardened_init() only runs once, you can try as many times as you like to trigger it.

This has worked on a bunch of client sites with a range of other broken plugins.

Hope this helps.

Solution 5

What about window.onerror?

https://developer.mozilla.org/en-US/docs/DOM/window.onerror

View more solutions