While debugging javascript, is there a way to alert current call stack?

Question

For simple javascript debugging I'll use alerts to show variable values and the like. Is there a way to get the current call stack in javascript to be able to display it in an alert?

Thanks.

Answer 1

Use debugger like Firebug for this if you are in Firefox. Chrome and Opera have build-in debugger. And there are Developers Tools for Internet Explorer.

Answer 2

The best way to debug Javascript is to use Firebug, which includes a full Javascript debugger.

If you're debugging in IE, you can use Visual Web Developer Express (or any other edition of Visual Studio).
If you're debugging IE8, you can use its built-in developer tools, which include a debugger.

It is possible to get the call stack in Javascript; see here.

Answer 3

Have you looked at firebug - and a breakpoint. If it's just for debugging, then this might suffice.

Also - you can have a look Here

Answer 4

Quick and dirty in Gecko-based browsers:

new Error().stack

You can also manually trawl some of the stack using Function.prototype.caller:

var thisFunction = arguments.callee;
var caller = thisFunction.caller;
var callerCaller = caller.caller;
// ...and eventually, assuming no recursion:
var bottomCaller = ...;
assert(bottomCaller.caller === null);

One (possibly large) caveat of the .caller trick is that it doesn't handle recursion -- .caller looks from the top of the stack downward to find the first instance of the function in the stack and then returns its immediate caller, so without being careful you can loop infinitely looking up callers.

Another caveat to caller is that, going forward, if any of your code uses ECMAScript 5's strict mode, the caller property of strict mode functions (or of functions which have themselves been called from strict mode functions) is a so-called "poison pill" which throws a TypeError when accessed. The caller property of "bound" functions (those created by ES5's Function.prototype.bind method) is also a poison pill. These restrictions break the generic stack-walking algorithm, although one could imagine use-specific ways to work around this (entry and exit annotating functions, perhaps).

Do note that stack-walking like this isn't a great idea in production code (as a quick hack for debugging it's fine, tho); at the moment walking up the stack as in the latter example is somewhat expensive in Mozilla's JS engine, and it'll probably throw you out of machine code and back into interpreted code. Also, the stack-walk is O(n²), which might matter if you tend to have complex, deep stacks.

Answer 5

On Firefox+Firebug and WebKit you can use console.trace()

It doesn't display an alert() but print the stacktrace on the console.