Javascript Memoizer

以下来自John Hann的实现，这段代码引起了我的注意，它用巧妙的方法把方法调用的结果缓存起来了。

 

代码解析：

//   memoize: 使用memoization来缓存的通用方法
//   func: 要被缓存的方法
//   context: 方法执行上下文
//   Note: 方法必须是外部可访问的，参数是可字符序列化的
function memoize (func, context) {  
    function memoizeArg (argPos) {   //参数表示原始方法中参数的位置
        var cache = {};   //这个缓存的key是参数，value是执行结果
        return function () {   //返回一个函数闭包
            if (argPos == 0) {   //第一个参数，如果参数在缓存的key中不存在，就执行原始函数并且存储执行结果
                if (!(arguments[argPos] in cache)) {  
                   cache[arguments[argPos]] = func.apply(context, arguments);  
                }  
                return cache[arguments[argPos]];  
            }  
            else {   //不是第一个参数，如果参数在缓存的key中不存在，就递归执行memoizeArg方法，原始方法中参数的位置-1
                if (!(arguments[argPos] in cache)) {  
                    cache[arguments[argPos]] = memoizeArg(argPos - 1);  
                }  
                return cache[arguments[argPos]].apply(this, arguments);  
           }  
        }  
    }   
    var arity = func.arity || func.length;   //func参数的长度，javascript中用length属性，其它的用arity属性
    return memoizeArg(arity - 1);   //从最后一个参数开始递归
} 

 

使用：

var mem = memoize(func, this);
alert(mem.call(this,1,1,2));
alert(mem.call(this,2,1,2));
alert(mem.call(this,3,1,3));
alert(mem.call(this,2,2,4));

 

看似简单，再一看好像也并不易懂，可是如果能对闭包的使用比较熟悉的话，就很好理解了。经过上面几次mem.call的调用之后，形成的是一棵树，每个节点都是一个闭包，每个闭包内有一个cache，每个cache的key都是树分支：

（注：上面图中的“结果”也是一个闭包，只不过argPos为0而已）

 

不过方法有诸多，比如limboy说：

function Memoize(fn){
    var cache = {};
    return function(){
        var key = [];
        for( var i=0, l = arguments.length; i < l; i++ ) 
            key.push(arguments[i]);
        if( !(key in cache) )
            cache[key] = fn.apply(this, arguments);
        return cache[key];
    };
}

 

实现更简易，不过把参数push到一个数组内，再把数组当key，而key是只支持字符串型的，因此这点在使用上需要注意（比如一个对象tostring之后可能只看到"[object Object]"了），它的功能比上面那个要弱一些。

 

改进这一点也不难，把参数另立一个对象即可，而原cache对象和这个另立的参数对象使用一个ID关联起来：

function Memoize(fn){
    var cache = {}, args = {};
    return function(){
        for( var i=0, key = args.length; i < key; i++ ) {
            if( equal( args[i], arguments )  )
                return cache[i];
        }
        args[key] = arguments;
        cache[key] = fn.apply(this, arguments);
        return cache[key];
    };
}

 

还有一些其他的办法，都可以写成简洁的函数式方法。