Clearing the array in my previously posted code has no affect on the individual caches because of the closures that are created when memoizeArg is called. The only solution I can come up with is to create a function closures that can clear the caches for us. These functions get pushed into an array so that we can call them later… I’m not sure if this qualifies as “better”, but this code has been tested and does work.

// whole-cache reset via setInterval or manual
function memoize(func, context, cacheLifetime) {
    var resetters = [],
        fn = memoizeArg(func.length - 1);
    fn.resetCache = reset;
    function reset() {
        var i = resetters.length;
        while(i--) resetters[i]();
    };
    function memoizeArg(argPos) {
        if(!argPos && cacheLifetime) {
            setInterval(reset, cacheLifetime);
            cacheLifetime = 0;
        }
        var cache = {};
        if(!argPos) resetters.push(function() { cache = {}; });
        return function() {
            var arg = arguments[argPos];
            if(argPos)
            	return (arg in cache ? cache[arg] : cache[arg] = memoizeArg(argPos - 1)).apply(null, arguments);
            else
            	return (arg in cache ? cache[arg] : cache[arg] = func.apply(context, arguments));
        };
    }
    return fn;
}

// whole-cache reset via setInterval
function memoize (func, context, /* msec */ cacheLifetime) {
var cache = [];
function memoizeArg (argPos) {
if(argPos == 0 && cacheLifetime)
setInterval(function () { cache.length = 0; }, cacheLifetime);
var local = cache[argPos] || (cache[argPos] = {});
return function () {
var arg = arguments[argPos];
if (argPos == 0) {
return arg in local ? local[arg] : local[arg] = func.apply(context, arguments);
}
else {
return arg in local ? local[arg].apply(this, arguments) : local[arg] = memoizeArg(argPos – 1);
}
}
}
return memoizeArg(func.length – 1);
}

Did you have any thoughts of adding a manual method for resetting the cache? I know this modifies the function in a way you were trying to avoid, but it is an absolute necessity in some cases:

// whole-cache reset via setInterval or manual
function memoize (func, context, /* msec */ cacheLifetime) {
var cache = [];
var reset = func.resetCache = function () { cache.length = 0; };
function memoizeArg (argPos) {
if(argPos == 0 && cacheLifetime)
setInterval(reset, cacheLifetime);
var local = cache[argPos] || (cache[argPos] = {});
return function () {
var arg = arguments[argPos];
if (argPos == 0) {
return arg in local ? local[arg] : local[arg] = func.apply(context, arguments);
}
else {
return arg in local ? local[arg].apply(this, arguments) : local[arg] = memoizeArg(argPos – 1);
}
}
}
return memoizeArg(func.length – 1);
}

var fn = memoize(function(v) { return v; });
fn.resetCache();