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

 

 

 

 

 

阅读更多
个人分类: javascript
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭