CODEWITHSUNDEEP
javascriptdebugging
rosscj2533
rosscj2533

Reputation: 9323

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

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.

Upvotes: 34

Views: 24052

Answers (7)

Alex Jasmin
Alex Jasmin

Reputation: 39506

You can use console.trace()

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

Upvotes: 42

ptrk
ptrk

Reputation: 1840

For nodejs debugging, in Visual Studio Code, as of v.1.14.2, it's View->Debug (Ctrl+Shift+D)

Upvotes: 0

zvi
zvi

Reputation: 11

This will give you all call stack working good for me.

var y = 'arguments.callee.caller';
    while (eval(y) != undefined) {
        stak += eval(y + '.toString()');
        y = y + '.caller';
    }
    alert(stak);

Upvotes: 1

Jeff Walden
Jeff Walden

Reputation: 7108

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(n2), which might matter if you tend to have complex, deep stacks.

Upvotes: 46

phatmanace
phatmanace

Reputation: 5031

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

Upvotes: 3

SLaks
SLaks

Reputation: 887767

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.

Upvotes: 3

Ivan Nevostruev
Ivan Nevostruev

Reputation: 28733

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.

Upvotes: 6

Related Questions