(function(a){
    return (a>0)?
        (a*arguments.callee(--a)):
        1;

})(4); // => 24

This is an anonymous function expression, using a lookup of arguments and then a lookup of callee. Another method to do the same thing would be to use a named function expression, and use that local name as selfreference, producing only a single lookup of self.

(function self(a){
    return (a>0)?
        (a*self(--a)):
        1; 
})(4); // => 24

And a clumsier third way would be to use a closure instead, requiring a lookup, scope jump, lookup for both a and f:

(function(a,f){
    return (f=function(){
        return (a>0)?
            (a*f(--a)):
            1;
    })();
})(4); // => 24

Now, both of the first ways, if you apply them to your example, would create a member of the function object itself. If the function object happens to be stored in a variable, you could access it from the outside. However, if you implement it as a closure bound variable a la 3, you get it to be private but still persistent. Thus, double wrapping it in function expressions might ensure privacy. Your example might not need it, but I’m sure there are cases that does.