javascript：如何使用抑制回调中的异常的库？

Question

lots of javascript libs and frameworks accepts functions that are called after some operation is completed. For example:

chrome.storage.local.get( 'foo', function() { console.log( "foo" ); } );

But i just realized that some API's, including google local storage api mentioned above catch and suppress all exceptions in functions being called. For example, if i modify a code above to have an error ( ReferenceError that i want to see in console):

chrome.storage.local.get( 'foo', function() { a.b(); } );

No error will be raised since api suppress it by catching and ignoring all errors. How to debug my code in such situations? Is it any way to bring errors back or all this api's are just not intended to be used with complex code and i need to debug via console.log manually to find what have failed?

UPDATE 1

Simply adding my own try-catch to all callback will add complexity to code that is not really welcome. Also, simple console.log is worse than exception since exception is catched by dev tools, displayed in red, have stack trace attached etc. Of course all this can be emulated with console.log but this will add more complexity.

UPDATE 2

Seems it's a ommon practice for js code to ignore errors, so i was forced to implement ugly solution by adding underscore plugin and using it to envelope each callback:

function _safeblock( block )
{
  console.assert( block );
  return function() {
    try {
      block.apply( this, arguments );
    }
    catch( e ) {
      console.log( e.message, e.stack );
    }
  };
}


function _safecall( block )
{
  console.assert( block );
  _safeblock( block )();
}


_.mixin({
  safeblock: _safeblock,
  safecall: _safecall,
});

Answer 1

You can try catch them yourself.

chrome.storage.local.get( 'foo', function() {
    try{
        a.b();
    }catch(e){
        console.log(e);
        //do whatever
    } 
});

You can automate this, either by overriding storage.local.get or by creating a generic function wrapper.

You can also defer the function manually with setTimeout which would make it impossible (in the browser) for the library to suppress your errors

chrome.storage.local.get( 'foo', function() {
     setTimeout(function(){
           a.b();
     });
});

This would not give you very meaningful stack traces though (anything outside the function will not show) which makes it less useful. It's also likely a performance overhead if you use this in performance sensitive situations (and in browsers setTimeout takes at least a few miliseconds, there is a postMessage hack around it though).

Answer 2

You could simply perform a try-catch and use console.error (works in Firebug and Chrome DevTools, not sure about others):

chrome.storage.local.get('foo', function () 
{   try { a.b(); }
    catch (e) { console.error(e.name + ": " + e.message); }
});

If you didn't need arguments for your callback, you could create a wrapper function:

function wrapTryCatch(func)
{   return function ()
    {   try { func.apply(this, arguments); }
        catch (e)
        {   var err = e.name + ': ' + e.message;
            console.error ? console.error(err)
            : console.log ? console.log(err)
            : alert(err);
        }
    }
}