一、函数防抖
    利用缓存池： 对象，数组都行（实际上还是将数组元素索引作为箭名的方式）

    1. function factorial1 (n) {
    2.     if( n === 0 || n === 1 ){
    3.       return 1
    4.   }
    5.   return n * factorial1 (n - 1)
    6. }
    8. //使用函数记忆
    9. function factorial2 (n) {
    10.     let time = 0, 
    11.       cache = [];
    12.   function compute(n){
    13.     time++;
    14.     if( cache[n] ){
    15.         return cache[n]
    16.     }
    17.       if(n === 0 || n ===1){
    18.       cache[n] = 1
    19.         return cache[n]
    20.     }
    21.     if( !cache[n] ){
    22.         cache[n] = n * compute(n - 1)
    23.       return cache[n]
    24.     }
    25.   }
    27.   let result = compute(n)
    28.   console.log(time, cache)
    29.   return result
    30. }
    32. console.time('first')
    33. factorial1(90)
    34. console.timeEnd('first')
    36. console.time('second')
    37. factorial2(90)
    38. console.timeEnd('second')

    二、函数记忆封装

    1. function factorial(n){
    2.     if(n === 0 || n === 1){
    3.       return 1
    4.   }
    5.   return n * factorial(n - 1)
    6. }
    7. function memory(fn){
    8.     let cache = {};
    9.   return function(){
    10.       let keyName = [].join.call(arguments);
    11.     return cache[keyName] = cache[keyName] || fn.apply(fn, arguments)
    12.   }
    13. }
    15. let test = memory(factorial);
    16. console.log( test(6) )
    1. 对斐波那契数列函数进行记忆封装
    1. function fab(n){
    2.   return n <= 2 ? 1 : fab( n - 1 ) + fab( n -2 )
    3. }
    4. function memory(fn){
    5.     let cache = {};
    6.   return function(){
    7.       let keyName = [].join.call(arguments);
    8.     return cache[keyName] = cache[keyName] || fn.apply(fn, arguments)
    9.   }
    10. }
    11. let test = memory(fab);
    12. console.log( test(6) )