函数的记忆----函数性能优化

// 用n的阶乘来演示     保存上一步计算的数据，进行下一次计算时候先判断是否有上次执行过的，如果有直接获取保存的值然后再进行下一步计算

// n! n*(n-1)*....*2*1

// 0! = 1

// n! = n*(n-1)!

// 实现记忆前
      var count = 0　　// 执行的次数
      function factorial(n) {
        count ++
        if(n == 0 || n==1) {
          return 1
        }
        return n * factorial(n-1)
      }
      for(var i=1; i<=5; i++) {
        console.log(factorial(i))
      }

// 实现记忆后
        var count = 0　　// 执行的次数
        var cache = []　　//执行过的数据保存起来 ---比如从5开始计算，再计算6的阶乘时候只执行6x5！ 而5的阶乘则直接从保存的数据中获取

        function factorial(n) {
            count++
            if (cache[n]) { // 如果有缓存(cache的值)直接获取缓存内的值
                return cache[n]
            } else {　　//没有则进行计算
                if (n == 0 || n == 1) {
                    cache[0] = 1
                    cache[1] = 1
                    return 1
                } else {
                    cache[n] = n * factorial(n - 1)
                    return cache[n]
                }
            }
        }

        console.time('3')
        console.log(factorial(3))
        console.timeend('3')
        console.log('=================')
        console.time('4')
        console.log(factorial(4))
        console.timeend('4')

　　

// 优化
        function factorial(n) {
            if (n == 0 || n == 1) {
                return 1
            } else {
                return n * factorial(n - 1)
            }
        }
        // 封装函数
        function memorize(fn) {
            var cache = {} // 用对象来存储值
            return function() {
                var key = arguments.length + array.prototype.join.call(arguments) //实现key的唯一标识
                if (cache[key]) {
                    return cache[key]
                } else { // 利用argumens来获取形参的类数组
                    cache[key] = fn.apply(this, arguments)
                    return cache[key]
                }
            }
        }
        var newf = memorize(factorial)