JS函数式编程之--函数记忆

处理一件事物，有些是过程中已经运算好的，可以将它们存储起来，以便于之后的直接使用。

相信大家都知道阶乘：

n! = n*(n-1)!
n! = n*(n-1)*(n-2)!
...
n! = n*(n-1)*(n-2)*...*1;

阶乘封装成函数：

function factorial1(n){
  if(n === 0 || n === 1){
   return 1;  //函数出口
  }
  return n*factorial1(n-1)
}

接着来看实际的执行次数：

var count = 0;
function factorial2(n){
  count ++;
  if(n === 0 || n ===1){
    return 1;
  }
  return n*factorial2(n-1);
}
for(var i = 1; i <= 5; i++){
  console.log(factorial2(i));
}
console.log(count);  //15，即执行15次
//解释：1! => 1次；2! => 2次；3! => 3次；4! => 4次；5! => 5次；每一次都要进行计算。
//改进方法：保存函数每次的执行结果

进行缓存，执行次数会减少：

var count = 0;
var cache = [];   //结果缓存数组
function factorial3(n){
  count ++;
  if(cache[n]){
    return cache[n];
  }else{
    if(n === 0 || n === 1){
      cache[0] = 1;
      cache[1] = 1;
      return 1;
    }else{
      cache[n] = n*factorial3(n-1);
      return cache[n];
    }
  }
}
for(var i = 1; i <= 5; i++){
  console.log(factorial3(i));
}
console.log(count);  //9，即执行9次
//解释：1！ => 1次；2！ => 2次；3！ => 2次；4！ => 2次；5！ => 2次。
//【重点：计算的数值越大，时间节约越多】

将缓存数组私有，传入一个函数，使得传入的函数具有函数记忆功能：

//传入一个函数，使得传入的函数具有函数记忆的功能。
function memorize(fn){
  var cache = {};  //对象的查找速度比数组快，对象是key-value进行查找。
  return function() {
    var key = arguments.length + Array.prototype.join.call(arguments);  //使得key值唯一。
    if(cache[key]){
      return cache[key];
    }else{
      cache[key] = fn.apply(this, arguments);
      return cache[key];
    }
  }
}
var newF = memorize(factorial1);  //传入后，factorial就具有了函数记忆的功能。传入参数
newF(5);   //120