使用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 = {};