处理一件事物,有些是过程中已经运算好的,可以将它们存储起来,以便于之后的直接使用。
相信大家都知道阶乘:
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