匿名函数，闭包，自运行

1.匿名函数

• 匿名函数（anonymous）的概念：
  没有名字的函数就是匿名函数。当某个函数，function 关键字后面没有标识符的时候，那么它就是一个匿名函数（lamda，拉姆达函数）。
  如：
  function(){
  alert(“亲，我来自无名函数”);
  }
  以前曾经写过 以下的代码：
  window.onload = function(){
  ……
  }
  这就是把匿名函数赋给了事件属性。

• 看看以下代码：

• 写法一： 定义一个函数，把函数名赋给 onload属性
  function test(){
  alert(“亲1”);
  }
  window.οnlοad=test;

• 写法二 : 定义一个匿名函数，直接赋给 onload属性
  window.onload = function(){
  alert(“亲2”);
  }

• 写法三 ：定义一个匿名函数赋给一个变量；然后把变量赋给onload事件属性； 比写法二多了个中间变量而已
  var test = function(){
  alert(“亲3”);
  }
  window.onload = test;

• 写法四： 定义一个匿名函数赋给一个变量，用变量（当作函数名）来调用函数；
  var test = function(){
  alert(“亲4”);
  }
  test();

• 结论：函数可以赋给一个变量（其实函数是个对象）
  所以，函数名作为另外一个函数的参数就好理解了。
  自运行：

• 什么是自运行（函数）

• 自运行（函数）示例：
  能够自己运行的一个函数。即，不用别人调用就能运行的函数。这是学习闭包的基础。
  (function(){alert(“亲4”);})()
  推导一下：
  1、已知：
  var test = function(){
  alert(“亲4”);
  }
  test();
  2、把test()中的test等量代换就是
  (function(){alert(“亲4”);})()
  不要急着问它的好处，不要急着觉
  得它有点多此一举，因为，还没有
  学习闭包，所以，不能体现它的好处

• 自运行（函数）的其它写法：

• 写法一：最外面加括号
  // (function(){
  // console.log(“123”);
  // }());
  //这是jslint推荐的写法，好处是，能提醒阅读代码的人，这段代码是一个整体。

• 写法二：最后的括号前面加括号；
  // (function(){
  // console.log(“heihei”);
  // })();

• 写法三： function前面加运算符，常见的是!与void 。
  // !function fun(){
  // console.log(“111”);
  // }();
  // void function fun(){
  // console.log(“111”);
  // }();

• 带参匿名函数
  //带参匿名函数
  var test = function(str1,str2){
  return str1+str2;
  }
  window.οnlοad=function(){
  alert(test(12,23));
  alert(test(“hello”," 亲"));
  }

• 匿名函数的常见用法：

  • 函数表达式（var test = function(){}）
  • 事件处理函数 (window.onload = funciont(){})
  • 自运行（立即执行）
  • 闭包里的返回值 （闭包中会讲）
    其实，当把匿名函数赋给一个变量时，就知道还可以用在何处（如：作为另外一个函数的参数），但不能进行运算
    2.闭包

• **官方解释：闭包是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。（函数就是一个表达式）
  JavaScript中所有的function都是一个闭包。不过一般来说，嵌套的function所产生的闭包更为强大，也是大部分时候我们所谓的“闭包”。

• 什么是闭包：闭包是指在函数外部访问函数作用域中变量（局部变量）的函数;或者说闭包就是能够读取其他函数内部变量的函数；或者说闭包是指有权访问另一个函数作用域中的变量的函数；
  由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成“定义在一个函数内部的函数”。**
  通俗解释：
  闭包是指有权访问另外一个函数作用域中的变量的函数.可以理解为(能够读取其他函数内部变量的函数)
  // 记数器:
  //全局变量 全局变量降低函数的独立性
  // var count = 0;
  // function add(){
  // return count++;
  // }
  // console.log(add());
  // console.log(add());
  // console.log(add());

  //局部变量 函数执行外 局部变量销毁
  // function add(){
  // var count = 0;
  // return count++;
  // }
  // console.log(add());
  // console.log(add());
  // console.log(add());
  //plus定义在add的内部，可以访问add局部变量count
  //f为一个全局变量,通过赋值后，成为add的返回值,也就是plus方法
  //访问到了add中的局部变量count
  //所以count虽然是局部变量,但不允许被销毁,plus就是闭包
  // function add(){
  // var count = 0;
  // function plus(){
  // return count++;
  // }
  // return plus;
  // }
  //
  // var f = add();
  //
  // console.log(f());
  // console.log(f());
  // console.log(f());

  //变身
  // function add(){
  // var count = 0;
  // return function(){
  // return count++;
  // }
  // }
  //
  // var f = add();
  //
  // console.log(f());
  // console.log(f());
  // console.log(f());
  //继续变身
  // var f = (function (){
  // var count = 0;
  // return function(){
  // return count++;
  // }
  // }());
  //
  // console.log(f());
  // console.log(f());
  // console.log(f());
  闭包的作用:
  正常函数执行完毕后,里面声明的变量被垃圾回收处理掉,但是闭包可以让作用域里的 变量,在函数执行完之后依旧保持没有被垃圾回收处理掉

• 可以读取函数内部的变量

• 让这些变量的值始终保持在内存中。

• 增加块级作用域
  //java,C,C++都有块作用域,即一对花括号里定义的变量，只在该花括号里起作用。
  //JS中，就算在花括号里定义的变量（会做声明的提前），属于整个函数内部
  //JS中，没有块作用域，但是在闭包的写法里，可以体现出来。
  function outerFunc(){
  var outVar = 10;
  var innerF = function (){
  var innerVar = 20;//该变量虽然隶属于outerFunc内部，但是它的作用域范围只在innerF对应的函数体内，属于块级作用域
  }
  alert(innerVar);
  return innerF;
  }

• 使用闭包的注意事项：

  • 由于闭包会使得函数中的变量都被保存在内存中，内存消耗很大，所以不能滥用闭包，否则会造成网页的性能问题，在IE中可能导致内存泄露。
  • 闭包会在父函数外部改变父函数内部变量的值。所以，如果你把父函数当作对象（object）使用，把闭包当作它的公用方法（Public Method），把内部变量当作它的私有属性（private value），这时一定要小心，不要随便改变父函数内部变量的值。

3.闭包案例

• 示例：局部变量的累加
  看程序分析：

* 示例：事件绑定

• 1111
• 2222
• 3333
• 4444
• 5555

* 用闭包的方式实现mult(5)(6)(7)，表示三个数的乘法（5*6*7） function fun(m){ return function(n){ return function(k){ return m*n*k; }; } } console.log(fun(5)(6)(7))