函数表达式

• 函数声明 sample:

    function functionName(arg0,agr1){
      //contents
    }
  

  函数声明会把函数声明提前。函数声明不要写在if for循环等代码块中，如果一定要
  在if语句或者循环语句中定义函数可以用函数表达式的办法。

• 第二种方法：函数表达式 sample:

    var functionName = function(agr0,arg1,arg2){
      //contents
    };
  

  函数表达式没有声明提前的效果，所以必须先赋值，再使用。像变量一样。

• 递归 建议使用命名函数表达式
  建议使用下面的例子递归 sample:

    var factorial = function f(num){
      if (num <= 1){
        return 1;
      } else {
        return num * f(num - 1);
      }
    }
    factorial(4);//24
  

• 闭包 闭包是指有权访问另一个函数作用域中的变量的函数。创建闭包的常见方式，就是在
  一个函数内部创建另一个函数。
  sample:

    function createComparisonFunction(propertyName){
      return function(obj1,obj2){
        var val1 = obj1[propertyName];    
        var val2 = obj2[propertyName];
        if (val1 < val2){
          return -1;
        } else if (val1 > val2){
          return 1;
        } else {
          return 0;
        }
        
      };
    }
  

  上面这个例子中内部匿名函数可以访问外部的propertyName，是因为
  内部函数的作用域链中包含createComparisonFunction()的作用域。
  再举个例子
  sample:

    function compare(val1,val2){
      if(val1>val2){
        return 1;
      } else if ( val1 > val2 ){
        return -1;
      } else {
        return 0;
      }
      
    }
    var result = compare(5,10);
  

  作用域链如下所示：
  

  作用域链.jpg

后台的每个执行环境都有一个用来表示变量的对象---变量对象。

而全局的变量对象始终存在，而函数的局部环境的变量对象，只有在
函数的执行时存在。在创建compare()函数时，会创建一个预先包含
全局变量对象的作用域链。这个作用域链保存在内部的[[Scope]]
属性中。当调用compare()函数时，会为函数创建一个执行环境，然后通过
复制函数[[Scope]]属性中的对象构建起执行环境的作用域链。此后又有
一个活动对象被创建并推入执行环境作用域链的前面。对于这个例子来说
，其作用域链中包含两个变量对象：本地活动对象和全局变量对象 。
当在函数中访问一个变量时，就会从作用域链中搜索具有相应名字的变量，一般来说
当函数执行完毕后，局部活动对象就会被销毁，内存中仅保存娟娟作用域（全局执行环境的变量对象）
但闭包就不一样了。
内部函数会把外部函数的活动对象添加到它的作用域链中，因此，
在createComparisonFunction()函数内部定义的匿名函数的作用域链中，会包含外部
函数createComparsionFunction()的活动对象

  var compare = 函数createComparsionFunction('name');
  var result = compare({ name: "Tom" },{ name: "Jerry" });

在匿名函数从createComparisonFunction()中被返回后，它的作用域链被初始化为
包含createComparsionFunction()函数的活动对象和全局变量对象。这样匿名函数就可以访问在
createComparisonFunction()中定义的所有变量了。而且更重要的是，外部函数在执行完毕后，
其活动对象也不会被销毁，因为内部匿名函数仍然在引用这个活动对象。直到匿名函数被销毁，外部函数
的活动对象才会销毁。

作用域链2.jpg

所以闭包会占用内存，要合理使用闭包。

function createFunctions(){
  var result = new Array();
  for (var x=0; x < 10; x++){
    result[x] = function(){
    return x*3;
    };
  }
  return result;
}
var z = createFunctions();
z[2]();//30
z[7]();//30

原本希望批量得到一批函数，这些函数返回三倍的输入值。但实际上所有函数返回的
都是30，也就是最后的x的值10*3。因为当调用返回的那个内部匿名函数的时候，x的值是循环
之后的10。
可以改成以下

  function createFunctions(){
    var result = new Array();
    for ( var x = 0;x < 10 ;x++ ){
      result[x] = function(num){
        return function(){
          return num;
        };
      }(x);
    }
    return result;
  }

之所以能成功，是因为最里面的匿名函数搜索num时，会找到他外部的函数，而它
外部函数的num是通过值传递进去的，每循环一次num被赋值不同的值。

• 模仿块级作用域
  javascript没有块级作用域(ES6有了)所以在for循环外面可以访问变量i
  可以使用立即调用匿名函数的方法模拟块级作用域从而防止全局变量污染。

    (function(){
      //这里是块级作用域
    })();
  

  sample:

    function outputNumbers(count){
      (function () {
        for (var i=0 ; i< count;i++){
          alert(i);
        }
      })();
      alert i;//报错，未定义的变量。
    }