函数 闭包 作用域链

函数申明：

function functionName(arg0,arg1,arg2){
    //函数体
}

函数表达式：

var functionName=function(arg0,arg1,arg2){
    // 函数体
}; //注意 ;
functionName(arg0,arg1,arg2);

递归

function factorial(num){
    if(num<=1){
        return 1;
    }else{
        return num*factorial(num-1);
    }
}

function factorial(num){
    if(num<=1){
        return 1;
    }else{
        return arguments.callee(num-1)*num;
    }
}//这种方式在严格模式下会报错

//最佳方法
var factorial = (function f(num){
    if(num<=1){
        return 1;
    }else{
        return num*f(num-1);
    }
});

闭包

闭包是有权访问另一个函数作用域中的变量函数。

function createComparisonFunction(propertyName){
    return function(object1,object2){
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        if(value1<value2){
            return -1;
        }else{
            return 0;
        }
    };
}

即使函数中的匿名函数被返回了，而且在其他地方被调用了，但它仍然可以访问变量propertyName。这是因为内部函数的作用域链中包含了createComparisonFunction()的作用域.

作用域链

• 当某个函数第一次被调用时，会创建一个 执行环境 及相应的 作用域链，并把作用域链赋值给一个特殊的内部属性(执行环境中的[[Scopr]])。然后，使用this、arguments和其他命名参数的值来初始化函数的 活动对象。外部函数的活动对象始终处于第二位，外部函数的外部函数的活动对象处于第三位.....

function compare(value1, value2){
    if(value1 < value2){
        return -1;
    } else{
        return 1;
    }
}

执行环境及相应的作用域链

image

• 后台的每个 执行环境 都有一个表示变量的对象—— 变量对象。全局环境的变量对象始终存在，而想compare()函数这样的局部环境的变量对象，只有在函数执行的过程中存在(活动对象)。

• 在创建compare()函数时，会创建一个预先包含全局变量对象的作用域链，这个作用域链保存在内部的[[Scope]]属性中。当调用compare()时，会为函数创建一个执行环境，然后通过复制函数的[[Scope]]属性中的对象构建执行环境的作用域链。此后，又有一个活动对象(变量对象)被创建并被推入执行环境作用域链的前端。

• 作用域链的前端，始终都是当前执行的代码所在环境的变量对象。如果这个环境是函数，则将其活动对象作为变量对象。 (活动对象就是作用域链上正在被执行和引用的变量对象)

---

function createComparisonFunction(propertyName){
    return function(object1,object2){
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        if(value1<value2){
            return -1;
        }else{
            return 0;
        }
    };
}

Markdown

在匿名函数从createComparisonFunction()中被返回后，它的作用域链被初始化为包含createComparisonFunction()函数的 活动对象 和 全局变量对象。这样，匿名函数就可以访问在createComparisonFunction()中定义的所有变量。当createComparisonFunction()函数返回后，其执行环境的作用域链被销毁，但它的活动对象仍然会留在内存中，直到匿名函数被销毁后，createComparisonFunction()的活动对象才会被销毁。

闭包与变量

闭包只能取得包含函数中任何变量的最后一个值。

function createFunction(){
    var result = new Array();
    for(var i=0; i<10; i++){
        result[i] = function(){
            return i;
        }
    }
    return result;
}

这个函数会返回一个函数数组，每个函数都返回10。因为每个函数的作用域链中都保存着createFuntion函数的活动对象，并返回了createFunction中变量i的值，由于经过for循环i的值变为了10，所以result中每个函数都只会返回10。

通过创建另一个匿名函数强制让闭包的行为符合预期：

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

由于函数参数传递是按值传递的，所以就会将变量i的当前值复制给参数num，而在这个匿名函数内部，又创建并返回了一个访问num的闭包。这样一来，result数组中的每函数都有自己num变量的一个副本，因此就可以返回各自不同的数值了。

this对象

var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc: function(){
    return function(){
      return this.name;
    };
  }
};
alert(object.getNameFunc()()); // The Window
//object.getNameFunc()返回的是一个匿名函数，想要调用该匿名函数还需要加一个()

出现这样的现象的原因分析(自己理解):
在创建匿名函数时，会创建一个预先包含全局变量对象的作用域链(包括this，此时this为GLobal对象)，这个作用域链被保存在内部的[[Scope]]属性中。当调用匿名函数时，会为函数创建一个执行环境，然后通过复制函数的[[Scope]]属性中的对象构建起执行环境的作用域链。因此该例中，匿名函数中的this仍然为Global对象。
在javascript中，函数的调用一共有4种方式：

• Function Invocation Pattern
  诸如foo()的调用形式被称为Function Invocation Pattern，是函数最直接的使用形式，注意这里的foo是作为单独的变量出现，而不是属性。
  在这种模式下，foo函数体中的this永远为Global对象，在浏览器中就是window对象。
• Method Invocation Pattern
  诸如foo.bar()的调用形式被称为Method Invocation Pattern，注意其特点是被调用的函数作为一个对象的属性出现，必然会有“.”或者“[]”这样的关键符号。
  在这种模式下，bar函数体中的this永远为“.”或“[”前的那个对象，如上例中就一定是foo对象。
• Constructor Pattern
  new foo()这种形式的调用被称为Constructor Pattern，其关键字new就很能说明问题，非常容易识别。
  在这种模式下，foo函数内部的this永远是new foo()返回的对象。
• Apply Pattern
  foo.call(this，Object)和foo.apply(this，Object)的形式被称为Apply Pattern，使用了内置的call和apply函数。
  在这种模式下，call和apply的第一个参数就是foo函数体内的this，如果thisObject是null或undefined，那么会变成Global对象。

// 把外部作用域中的this对象保存在一个闭包能够访问到的变量里，就可以让闭包访问该对象了
var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc: function(){
    var that = this;
    return function(){
      return that.name;
    };
  }
};
alert(object.getNameFunc()()); // The Object

模仿块级作用域

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

以上代码定义并立即调用了一个匿名函数。将函数申明包含在一对圆括号中，表示它实际上是一个 函数表达式 。而紧随其后的另一对圆括号会立即调用这个函数。

私有变量

• JavaScript中没有私有成员的概念；所有的对象属性都是公有的。但是有私有变量的概念。私有变量包括函数的参数、局部变量和在函数内部定义的其他函数。
• 如果在函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量，利用这点，可以创建用于访问私有变量的公有方法。

/* demo01 */
function MyObject(){
  var privateVariable = 10;
  function privateFunction(){
    return false;
  }
  this.publicMethod = function(){
    privateVariable++;
    return privateFunction();
  };
}

var object = new MyObject();
object.publicMethod(); //false

如果需要构建多个实例，则需为每个实例创建同样的方法

静态私有变量

(function(){
  var privateVariable = 10;
  function privateFUncion(){
    return false;
  }

  MyObject = function(){

  };

  MyObject.prototype.publicMethod = function(){
    privateVariable++;
    return privateFunction();
  }
})
// 使用
var object = new MyObject();

注意 :定义构造函数时，没有使用函数生命，而是使用了函数表达式。函数声明只能创建局部函数。出于同样的原因，在声明MyObject时也没有使用var关键字。** 记住 ** : ** 初始话未经声明的变量，总是会创建一个全局变量 ** 。因此MyObject就成为一个全局变量，能够在私有作用域之外被访问。 ** 静态私有变量 ** privateVariable时被所有实例共享的，它可以任何实例修改(通过publicMethod方法)

模块模式

模块模式通过为单例添加私有变量和特权方法能够使其得到增强

var singleton = function(){
  var privateVariable = 10;
  function privateFunction(){
    return false;
  }
  // 返回一个对象
  return {
    publicProperty: true;
    publicMethod: function(){
      privateVariable++;
      return privateFunction();
    }
  };
}();
singleton.publicProperty;
singleton.publicMethod();

这个模块模式使用了一个返回对象的匿名函数。

增强的模块模式

返回特定类型的对象

var singleton = function(){
  var privateVariable = 10;
  function privateFunction(){
    return false;
  }
  // 可以返回特定类型的对象
  var object = new CustomType();
  object.publicProperty = true;
  object.publicMethod = function(){
    privateVariable++;
    return privateFunction();
  }
}();
singleton.publicProperty;
singleton.publicMethod();