使用eval记忆实现。 eval的使用是否可以接受？

Question

...还是有更好的方法来实现一个Memoization？

Function.memoize = function(callableAsString) 
    { 
    var r = false, callable, code; 
    try 
     { 
     callable = eval(callableAsString); 
     if (typeof callable == "function" && typeof(Function.memoize.cache[callableAsString]) == "undefined") 
      { 
      code = callableAsString + " = function()" + 
       "{" + 
       "var cache = Function.memoize.cache['" + callableAsString + "'];" + 
       "var k = Json.stringify([this].concat(arguments));" + 
       "return cache.r[k] || (cache.r[k] = cache.c.apply(this, arguments));" + 
       "};" + 
       "true;"; 
      if (r = eval(code)) 
       { 
       Function.memoize.cache[callableAsString] = {c: callable, r: {}}; 
       } 
      } 
     } 
    catch (e) {} 
    return r; 
    }; 
Function.memoize.cache = {}; 
Function.memoize("String.prototype.camelize"); 

更新由费利克斯·克林基础上，建议

Function.memoize = function(callable) 
    { 
    var r = false; 
    if (typeof callable == "function") 
     { 
     var hash = callable.toString().hashCode(); 
     r = function() 
      { 
      var cache = Function.memoize.cache[hash]; 
      var key = Json.stringify([this].concat(arguments)); 
      return cache.r[key] || (cache.r[key] = cache.c.apply(this, arguments)); 
      } 
     if (!Function.memoize.cache) 
      { 
      Function.memoize.cache = {}; 
      } 
     r.memoize = callable; 
     Function.memoize.cache[hash] = {c: callable, r: {}}; 
     } 
    return r; 
    }; 

Function.unmemoize = function(callable) 
    { 
    if (callable.memoize && typeof callable.memoize == "function") 
     { 
     return callable.memoize; 
     } 
    else 
     { 
     return false; 
     } 
    }; 

String.prototype.camelize = Function.memoize(String.prototype.camelize); 
String.prototype.camelize = Function.unmemoize(String.prototype.camelize); 

Answer 1

我不认为需要EVAL ...考虑这个实施

function memoize(f, cache) 
{ 
    if (!cache) cache = {}; 
    return function() 
    { 
     var key = JSON.stringify(arguments); 
     return (cache[key] || (cache[key] = [f.apply(this, arguments)]))[0]; 
    } 
} 

注意，我故意在密钥中忽略了this。原因是this可能由于stringify而不能被序列化（例如因为循环），并且这比例外更规则，例如当在全局上下文中时this == window。

什么是IMO有用的是显式地传递缓存的能力，这样就可以例如通过执行类似创建为每个实例或一个共享的缓存所有实例单独的缓存：

function MyObj(...) 
{ 
    // every instance has its own cache 
    this.foo = memoize(function(...) { ... }); 

    // there is one shared cache for all instances 
    this.bar = memoize(function(...) { ... }, MyObj.memoize_cache); 
} 

MyObj.memoize_cache = {};