闭包的应用斐波拉契数列为例详细讲解

先解释下什么是闭包

闭包是一个受到保护的变量空间.
从字面意思来看就是封闭和包裹

为什么说函数是闭包?

在函数中定义的变量,在函数外部无法访问,因此这个函数就构成闭包
###特点:
在函数体内部允许访问外部的变量,但是外部不能访问外部的变量
###要解决闭包的什么问题
就是要访问到它的数据

###怎么样访问闭包中的数据
两个模型:

返回一个函数,用这个函数获得数据
返回一个对象,这个对象包含函数,来操作这个数据

##闭包的应用有两个模型
1.实现私有数据
2.实现缓存数据
2.1闭包做缓存
2.2函数名做缓存

下面我用斐波拉契数列来煮个栗子 (不知道斐波拉契数列的百度)
####斐波拉契常见的3种做法:1.递归 2.缓存 3.不用递归,直接用循环
写一个带有缓存功能的函数

var fib  = function (n) {
    //使用callee求兔子数列
    if( n < 0) throw new Error('不能输入0');
    if(n===0 || n ===1) return 1;
    return arguments.callee( n - 1) +arguments.callee(n - 2);
  };
  for (var i = 0;i<=10;i++) {
    console.log(fib(i));
  }*/

但是这样做的性能非常低,我们可以测试下调用一次,需要运算多少次

var count = 0;//计数器,只要调用一次函数,就让count++
  var fib  = function (n) {
    count++;

    if( n < 0) throw new Error('不能输入0');
    if(n===0 || n ===1) return 1;
    return arguments.callee( n - 1) +arguments.callee(n - 2);
  };
fib(10);
console.log(count);

当fib(1)的时候,运行1次,fib(2),运行3次,
依次类推 1,3,5,9,15,25
根据运算结果,如果求10项需要运算177次

这样性能会有非常大的问题,每一次计算都要分两步去完成,而且有个特点不管有没有算过都要算一遍,都要这样去计算,那么如果计算的数字非常大会影响到我们计算的结果
###怎么样提高效率呢,让算过的不再算
把这个函数写成一个自调用函数
利用数组缓存,因为存的只是数据

var count;
var fib = (function () {
  var arr = [];//这个数组模拟的就是斐波拉契数列
  return function (n) {
    count++;
    if (n < 0) throw new  Error ('数字不允许是负数');
    var res  = arr[n];//先到数组中去取,如果有把这个数值返回,没有加进去
    if (res != undefined){
      //判断数组中有数据,有就返回,没有就递归
      return res;
    } else {
      //如果是1或0就将1返回给res
      //否则递归结果交给res;
      if( n === 0 || n===1) {
        res =1;
      } else {
         res = arguments.callee( n - 1 ) +
                arguments.callee(n-1);
      }
       arr[n] = res;//将计算的结果放到数组中,那么下一次在计算的时候直接拿来用,就不用重新计算了
       //其实这里使用键值对做缓存,取的时候是取出来n,返回也是给n,没有用push

        return res;

    }

  }
})();
var count = 0;
  for ( var i = 0; i <= 10; i++){
  count = 0;//每次计算的时候让count=0,计算从0-10每次count的值是多少
    console.log(fib(i) + "---" +count+"次");
}

为啥都是计算3次
因为我们都是直接从缓存中去取,而不是通过递归去计算
但是用循环体现不出差异性,因为缓存了,已经计算出了,就不会在计算,等下再给大家画图解释下为什么是3次,现在先让大家体会下这个差异性

/*
var count = 0;
  for ( var i = 0; i <= 10; i++){
  count = 0;//每次计算的时候让count=0,计算从0-10每次count的值是多少
    console.log(fib(i) + "---" +count+"次");
}*/
fib(10);
console.log(count);

0原来是运行177次,现在只要19次,
之前输入100会崩溃,现在输入100只要199次
现在的差异看的很明显了吧,
利用缓存功能很大的提高了效率
大家也可以自己做下测试,原理很简单就是用一个数组将已经计算过的值存起来
现在我们再看看为啥都是计算三次吧

因为前两次[0]和[1]次循环已经有值了,从[2]开始,前两个的值已经有了,所以不用再递归了,
每次要做的事情就是先检查有没有,没有再进行运算,运算就递归两次,
递归两次就累积两次得到的结果马上放回去,加上当前的计算,一共是三次
下面来看看没有用闭包的斐波拉契数列

var fib = function (n) {
    count++;
    if ( n < 0 ) throw new Error('数字不允许是负数');
    if ( n === 0 || n===1) return 1;
    return arguments.callee( n-1 )+
    arguments.callee( n - 2 );
  };
  var count = 0;
  for (var i = 0;i<=10; i++) {
    count  = 0;
    console.log(fib(i) + "---"
     + count + "次");
  }

果然有对比才有伤害啊啊啊

接下来再写个改良版带有缓存的函数
之前是闭包做的缓存,我们做实际开发时没必要
函数也是对象,把共享的数据放到函数名里

var fib = function (n) {
  var res = fib[n];//先到函数名中取
    if (res != undefined){
      //函数名中有数据
      return res;
    } else {
      if( n === 0 || n===1) {
        res =1;
      } else {
         res = arguments.callee( n - 1 ) +
                arguments.callee(n-1);
      }
       fib[n] = res;
       fib.len++;//也可以用slice
        return res;

    }


};
fib.len = 0;//给函数添加一个属性len
console.log(fib(10));

 for ( var i = 0; i <=5; i++){

    console.log(fib(i));
}

优点把闭包去掉了,用函数名存储数据
缺点:这个函数名谁都可以访问,谁都可以修改这个数据
但是用闭包优点是除了fib这个函数谁都不能访问
顺便一提: jQuery里面有个createCache也是用这种实现的哦

利用沙箱模式进行优化,保护数据

var fib = (function () {
    var fibs = [];
    return function ( n ) {
      if(fibs[n]){
        return fibs[n];
      } else {
        var temp;
        if(n==1 || n==0) {
            temp =1;
        } else {
          temp = fib(n-1) + fib(n-2);
        }
        fibs[n] = temp;
        return temp;
      }
    };
  })();
  console.log(fib(10));