We Keep Coding

"catching is not a function" exception

I'm having an issue on JBoss (6.4.14 GA) running jQuery 3.1.1 (or 3.2.1). As soon as a page loads and the documet.ready function executes I get the following error:
jquery.js:formatted:8142 Uncaught TypeError: aj.then(...).catching is not a function
at bw.fn.init.bw.fn.ready (jquery.js:formatted:8142)
at srs.js:1
The jQuery code throwing this error is:
var readyList = jQuery.Deferred();
jQuery.fn.ready = function( fn ) {
readyList
.then( fn )
// Wrap jQuery.readyException in a function so that the lookup
// happens at the time of error handling instead of callback
// registration.
.catching( function( error ) {
jQuery.readyException( error );
} );
return this;
};
I do not get this error when running my application on Tomcat 7.
I've been researching this error for several days and have been unable to find any references to this specific error (catching is not a function), so looking for some help in determining the cause of this error.
Thanks in advance!

catching is not a method of jquery's deferred, you are maybe looking for catch.
For debugging purpose, you can list properties of an object using Object.getOwnPropertyNames and see which one they have. In your case, executing the code below would have helped you find the error:
var debugValue = aj.then(bS)
console.log(Object.getOwnPropertyNames(debugValue))

Is it possible to override console logs

If I receive an error from a framework or an error from the browser. Basically a runtime error of any kind. Without modifying the framework, is it possible for me to override the console logs that these frameworks make and the browser's errors. I want to use my own framework with own error handling system when informing the user of errors of practically anything runtime (not syntax errors). I don't know if you would class it all as runtime errors because of the way javascript is executed in the browser but hopefully you will get me?
Is this possible if all the frameworks are written in Javascript?
How is this achieved?
What considerations do I have to make between different browsers?
Thanks

You are probably looking for a try-catch block:
try {
alert(foo);
} catch(e) {
alert('The code got the following error: '+e.message);
}
Whenever the code between the try {} receives an error, the catch(e) {} block will execute, with the argument e being the error object for the error that occurred. In this case, the variable foo is not defined, so executing this code will result in an alert message saying "The code got the following error: foo is not defined"

While not over-riding console.log, you may be achieve the same effect by overriding window.onerror.
From the MDN documentation
window.onerror = function myErrorHandler(errorMsg, url, lineNumber) {
// Log the error here -- perhaps using an AJAX call
}

You could try overriding the console.log() function.
//Save original reference
var originalConsole = console;
//Override
console = {};
console.log = function()
{
//According to MDN the console.log function can receive a variable number of params
for(var i=0; i<arguments.length; i++)
{
//Make your changes here, then call the original console.log function
originalConsole.log("Change something: "+arguments[i]);
}
//Or maybe do something here after parsing all the arguments
//...
}
console.log("one", "two");
JSFiddle here.

You can override the console logs by creating a "console" object and overriding it's .log() function:
var console = {};
console.log = function(){};
Some browsers require this to be added to the window object directly; so, for browser compatibility, also add:
window.console = console;
Additionally, you can override other console functions (e.g. console.info, console.warn and console.error) if you're using those too.
Also, consider reading this blog post from Udi Talias on overriding the console functions. Good and quick read!

You can custom your console.log here
// copy the original
let originalConsole = Object.assign({}, console);
// do something with your log.
console.log = (value) => {
//some cool condition
if (true) {
value = "new_log : " + value
}
originalConsole.log(value);
};

AngularJS $LogProvider throws Illegal access error

I have a mobile app that uses cordova + AngularJS 1.2.4 It works perfect on every platform I tested except some Android 2.3.X devices throw a mysterious illegal access exception. Below is the portion of code that raises the error. Precisely speaking, the line return logFn.apply(console, args); seems to be the culprit. If I remove the parameter args code works fine. It seems odd since variable args is defined at the top of the function. I don't understand what is really causing this illegal access error? Any one had a similar problem? Any ideas how to fix it?
ps: Please check out inline comments to better understand the problem. There, I debugged and reported some cases.
function consoleLog(type) {
var console = $window.console || {},
logFn = console[type] || console.log || noop;
if (logFn.apply) {
return function() {
var args = [];
forEach(arguments, function(arg) {
args.push(formatError(arg));
// console.log(typeof arg); -> prints string
// console.log(arg.toString); -> prints function
// console.log(arg); -> throws illegal access error
// console.log(arg.toString()); -> throws illegal access error
});
// console.log(args); -> throws illegal access error
// return logFn.apply(console); -> works fine w/o `args`
return logFn.apply(console, args); -> throws illegal access error
};
}
// we are IE which either doesn't have window.console => this is noop and we do nothing,
// or we are IE where console.log doesn't have apply so we log at least first 2 args
return function(arg1, arg2) {
logFn(arg1, arg2 == null ? '' : arg2);
};
}

The code, you posted isn't the problem. This is Angular's built-in Exception handling. I made the same mistake and tried to dig in here, but Angular's Exception Handlings works fine.
But there is a reported Issue (Github) concerning Android 2.3.x and Firefox OS in 1.2.4 and they fixed it in 1.2.5
Maybe you should try a higher AngularJS Version

How can I override/extend ReferenceError in Chrome's JavaScript?

To make debugging easier, I'm capturing all of the console logs in Chrome so that users who submit a feedback entry will also submit all of the logs to our server. When someone encounters a problem in production, I can first and foremost get them back to work so that I can then sit down and more thoroughly go through all of the logs to determine the root cause of whatever issue the user encountered in production.
The technique I use to capture the logs involves overriding console.log so that all text entered in the first argument gets stored in an array while simultaneously invoking the legacy function so that I can still see the logs in the console too.
The problem is when there's the occasional uncaught exception. These aren't included in the uploaded logs, so it's not always clear what caused the problem. So I tried overriding ReferenceError by writing a JavaScript function that takes a function as an argument, then returns a new function that does stuff with it, like storing data in a variable, and then invoking the legacy function as the last step:
function overrideException(legacyFn) {
/** arguments for original fn **/
return function() {
var args = [];
args[0] = arguments[0];
// pass in as arguments to original function and store result to
// prove we overrode the ReferenceError
output = ">> " + legacyFn.apply(this, args).stack;
return legacyFn.apply(this, arguments);
}
}
To test the overrideException function, I ran the following code on the console:
ReferenceError = overrideException(ReferenceError);
Afterwards, I tested the returned function, the new ReferenceError, by manually throwing a ReferenceError:
throw new ReferenceError("YES!! IT WORKS! HAHAHA!");
The resulting output on the console is:
ReferenceError: YES!! IT WORKS! HAHAHA!
And checking the global variable output from the overrideException function shows that it did indeed run:
output
">> ReferenceError: YES!! IT WORKS! HAHAHA!
at ReferenceError (<anonymous>)
at new <anonymous> (<anonymous>:18:35)
at <anonymous>:2:7
at Object.InjectedScript._evaluateOn (<anonymous>:562:39)
at Object.InjectedScript._evaluateAndWrap (<anonymous>:521:52)
at Object.InjectedScript.evaluate (<anonymous>:440:21)"
Now, here's where things start to fall apart. In our code, we're not going to know when an uncaught exception occurs, so I tested it by attempting to run a function that doesn't exist:
ttt();
Which results in:
ReferenceError: ttt is not defined
However, unlike the case where we explicitly throw an error, in this case, the function doesn't fire, and we're left with only the legacy functionality. The contents of the variable output is the same as in the first test.
So the question seems to be this: How do we override the ReferenceError functionality that the JavaScript engine uses to throw errors so that it's the same one we use when we throw a ReferenceError?
Keep in mind that my problem is limited only to Chrome at this time; I'm building a Chrome Packaged app.

I have done quite a bit of research for the same reason: I wanted to log errors and report them.
"Overriding" a native type (whether ReferenceError, String, or Array) is not possible.
Chrome binds these before any Javascript is run, so redefining window.ReferenceError has no effect.
You can extend ReferenceError with something like ReferenceError.prototype.extension = function() { return 0; }, or even override toString (for consistency, try it on the page, not the Dev Tools).
That doesn't help you much.
But not to worry....
(1) Use window.onerror to get file name, 1-indexed line number, and 0-indexed position of uncaught errors, as well as the error itself.
var errorData = [];
onerror = function(message, file, line, position, error) {
errorData.push({message:message, file:file, line:line, position:position, error:error});
};
See the fiddle for an example. Since the OP was Chrome-specific, this has only been tested to work in Chrome.
(2) Because of improvements to (1), this is no longer necessary, but I leave this second technique here for completeness, and since onerror is not guaranteed to work for all errors on all browsers. You will also sometimes see the following:
var errors = [];
function protectedFunction(f) {
return function() {
try {
f.apply(this, arguments);
} catch(e) {
errors.push(e);
throw e;
}
};
}
setTimeout = protectedFunction(setTimeout);
setInterval = protectedFunction(setInterval);
etc...
FYI, all this is very similar to what has been done in the Google Closure Compiler library, in goog.debug, created during Gmail development with the intent of doing exactly this. Of particular interest is goog.debug.ErrorHandler and goog.debug.ErrorReporter.

Prototype swallows javascript errors (Firefox)

Hey i'm pretty new to prototype.
The problem is that javascript errors within dom:loaded callback functions don't get displayed in firefox (webconsole/errorconsole/firebug).
Sample1:
document.observe("dom:loaded", function() {
syntax() error()
});
Sample2:
document.observe("dom:loaded", function() {
syntax(); error()
});
Now the funny thing:
If I execute Sample1 I get an javascript error "Missing ; before statement" - ofcourse there should be a semicolon before 'error()' - so this type of error seems to work. If I execute Sample2 I don't get any error (actually it's not a syntax error anymore) but I should get a "undefined variable" error which i don't get.
Any clue what's going on here?
IE prints out the error btw

what's happening is that in sample 2 when the semicolon is added the string syntax; error acts as two individual global variables, to the compiler it looks the same as window.syntax; window.error
document.observe('dom:loaded', function() {
syntax = 10; error = 5;
alert(syntax + ' ' + error);
});
Try running the above example. it will help explain the issue more clearly...