return arguments.callee.t || (arguments.callee.t = new Date);
It will leak memory because the objects (for example, the intermediate objects in a complex calculation) of the original function will be referred by the new closure and never be GC. In fact, they have no chance to be recycled except assigning them from null in the original function—Oops
the only problem with your solution is that we would be filling the memory with variables that would never be released, just because of the closures
“a,b,c,d,e” will never get released just because of our closure, even if not anymore needed. We just need “result”.
var foo = function()
{
return arguments.callee.t || (arguments.callee.t = (function(){
var result ;
var a,b,c,d,e ;
// using a,b,c,d,e to fill return
return result ;
})());
};
But, in the above example, the calculation will run for all calls if the final “result” is null, false, 0, NaN,
“return a ? a : b”, because in both cases the compiler will have to check the value of “a” before returning it (it means that it is not true that “a” is “immediately” returned in the first case). So, this is not a real shortcut.
a sane proposal, achieving the performance enhancements aimed by your pattern, would be using an old way of avoiding closures, by defining all functions outside foo>
var getScrollY = function() {

if (typeof window.pageYOffset == 'number')
return (getScrollY = getScrollY.case1)();

var compatMode = document.compatMode;
var documentElement = document.documentElement;

if ((typeof compatMode == 'string') &&
(compatMode.indexOf('CSS') >= 0) &&
(documentElement) &&
(typeof documentElement.scrollTop == 'number'))
return (getScrollY = getScrollY.case2)();

var body = document.body ;
if ((body) &&
(typeof body.scrollTop == 'number'))
return (getScrollY = getScrollY.case3)();

return (getScrollY = getScrollY.case4)();
};

getScrollY.case1 = function() {
return window.pageYOffset;
};

getScrollY.case2 = function() {
return documentElement.scrollTop;
};

getScrollY.case3 = function() {
return body.scrollTop;
};

getScrollY.case4 = function() {
return NaN;
};
The core idea of this article is that during the execution of a variable’s function value, it is possible to change that variable’s function value. I believe this idea is solid. Clearly the implementation of this is tricky in particular cases but can lead to very efficient programs.