Quick and dirty in Gecko-based browsers:
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.