标签：

简介

函数表达式是JavaScript中的一个既强大又容易令人困惑的特性。定义函数的方式有两种：一种是函数声明，另一种就是函数表达式。函数声明的语法是这样的：

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

//只有在Firefox、Safari、Chrome和Opera有效

alert(functionName.name);//”functionName”

关于函数声明，它的一个重要特征就是函数声明提升，意思是在执行代码前会先读取函数声明。这就意味着可以把函数声明放在调用它的语句后面。

sayHi();

function sayHi(){alert(“Hi”);}

这个例子不会抛出错误，因为在代码执行之前会先读取函数声明。

第二种创建函数的方式是使用函数表达式。函数表达式有几种不同的语法形式，下面是最常见的一种形式：

var functionName = function(arg0 , arg1 ,arg……){

         //函数体

}

这种形式看起来好像是常规的变量赋值语句，即创建一个函数并将它赋值给变量functionName。这种情况下创建的函数叫做匿名函数，因为function关键字后面没有标识符。（匿名函数有时候也叫拉姆达函数。）匿名函数的name属性是空字符串。

函数表达式与其他表达式一样，在使用前必须先赋值，以下代码会报错：

sayHi();

var sayHi = function(){alert(“Hi”);};

进一步理解函数提升可以参考前面的JavaScript基础——引用类型（三）Function类型

递归

递归函数是在一个函数通过名字调用自身的情况下构成的，如：

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

function factorial(num){
     if(num <= 1){
         return 1;
     }else{
         return num*factorial(num-1);
     }
 }
 var anotherFactorial = factorial;
 factorial = null;
 alert(anotherFactorial(4));//出错！

arguments.callee是一个指向正在执行的函数的指针，因此可以用它来实现对函数的递归调用。如：

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

但在严格模式先，不能通过脚本访问arguments.callee，访问这个属性会导致错误。不过，可以使用命名函数表达式来达成相同的结果，如：

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

闭包

有不少开发人员总是搞不清匿名函数heels闭包这两个概念，因此经常混用。闭包是指有权访问另一个函数作用域中的变量的函数。创建闭包的常见方式，就是在一个函数内部创建另一个函数，如：

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

前面介绍过作用域链的概念。而有关如何创建作用域链以及作用域链有什么作用的细节，对彻底理解闭包至关重要。当某个函数第一次被调用时，会创建一个执行环境及相应的作用域链，并把作用域链赋值给一个特殊的内部属性（即[[Scope]]）。然后，使用this、arguments和其他命名参数的值来初始化函数的互动对象。但在作用域链中，外部函数的活动对象始终处于第二位，外部函数的外部函数的活动对象处于第三位，……直至作为作用域链终点的全局执行环境。

在函数执行过程中，为读取和写入变量的值，就需要在作用域链中查找变量。来看下面的例子：

function campare(value1,value2){
     if(value1<value2){
            return -1;
        }else if(value1>value2){
            return 1;
        }else{
            return 0;
        }
 }
var result =compare(5,10);

后台的每个执行环境都有一个表示变量的对象——变量对象。全局玄晶的变量对象始终存在，而像compare()函数这样的局部环境的变量对象，则只在函数执行的过程中存在。在创建compare()函数时，会创建一个预先包含全局变量的作用域链，这个作用域链被保存在内部的[[Scope]]属性中。当调用compare()函数时，会为函数创建一个执行环境，然后通过复制函数的[[Scope]]属性中的对象构建起执行环境的作用域链。此后，又有一个活动对象（在此作为变量对象使用）被创建并被推入执行环境作用域链的前端。对于这个例子中compare()函数的执行环境而言，其作用域链中包含两个变量对像：本地活动对象和全局变量对象。显然，作用域链本质上是一个指向变量对象的指针列表，它只引用但不实际包含变量对象。

无论什么时候在函数中访问一个变量时，就会从作用域链中搜索具有相应名字的变量，一般来讲，当函数执行完毕后，局部活动对象就会被销毁，内存中仅保存全局作用域（全局执行环境的变量对象）。但是，闭包的情况又有所不同。

在另一个函数内部定义的函数会包含函数（即外部函数）的活动对象添加到它的作用域链中，因此，在createComparisonFunction()函数内部定义的匿名函数的作用域链中，实际上将会包含外部函数createComparisonFunction()的活动对象。

闭包与变量

作用域链的这种配置机制引出了一个值得注意的副作用，即闭包只能取得包含函数中任何变量的最后一个值。别忘了闭包所保存的是整个变量对象，而不是某个特殊的变量。下面这个例子可以清晰地说明这个问题。

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

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

关于this对象

在闭包中使用this对象也可能导致一些问题，this对象是在运行时基于函数的执行环境绑定的：在全局函数中，this等于window，而当函数被作为某个对象的方法调用时，this等于那个对象。不过，匿名函数的执行环境具有全局性，因此其this对象通常指向window。但有时候由于编写闭包的方式不同，这一点可能不会那么明显。如：

var name = "The Window";
 var object = {
         name:"My Object",
         getNameFunc:function(){
             return function(){
                 return this.name;
             };
         }
 };
 alert(object.getNameFunc()());//"The Window"(在非严格模式下)

前面曾提到过，每个函数在被调用时，其活动对象都会自动取得两个特殊变量：this和arguments。内部函数在搜索这两个变量时，只会搜索到其活动对象为止，因此永远不能直接访问外部函数中的这两个变量。不过，把外部作用域中的this对象保存在一个闭包能够访问到的变量里，就可以让闭包访问该对象了，如：

var name = "The Window";
 var object = {
         name:"My Object",
         getNameFunc:function(){
             var that = this;
             return function(){
                 return that.name;
             };
         }
 };
 alert(object.getNameFunc()());//"My Object"

this和arguments也存在同样的问题。如果像访问作用域中的arguments对象，必须将对该对象的引用保存到另一个闭包能够访问的变量中。

在几种特殊的情况下，this的值可能会以外地改变。比如，下面的代码是修改前面例子的结果。

var name = "The Window";
 var object = {
         name:"My Object",
         getName:function(){
            return this.name;
         }
 };

alert(object.getName());//"My Object"
 alert((object.getName)());//"My Object"
 alert((object.getName = object.getName)());//"The Window"

第一行代码跟平常一样调用了object.getName()，返回的是”MyObject”，因为this.name就是object.name。第二行代码在调用这个方法前给它加上了括号。虽然加上括号之后，就好像只是在引用改一个函数，但this的值得到了维持，因为object.getName和(object.getName)的定义是相同的。第三行代码先执行了一条赋值语句，然后在调用赋值后的结果。因为这个赋值表达式的值是函数本身，所以this的值不能得到维持，结果就返回了”The Window”。

内存泄漏

由于IE9之前的版本对JScript对象和COM对象使用不同的垃圾收集例程，因此闭包在IE的这些版本中会导致一些特殊的问题。具体来说，如果闭包的作用域链中保存着一个HTML元素，那么就意味着该元素将无法被销毁。如：

function assignHandler(){
     var element = document.getElementById("someElement");
     element.onclick = function(){alert(id);};
 }

function assignHandler(){
     var element = document.getElementById("someElement");
     var id = element.id;
     element.onclick = function(){alert(id);};
     element = null;
 }

模仿块级作用域

如前所述，JavaScript没有块级作用域的概念。这意味着在块语句中定义的变量，实际上是在包含函数中而非语句中创建的，如：

function outputNumbers(count){
    for(var i=0; i < count ; i++){
        alert(i);
    }
    alert(i);//计数
 }

function outputNumbers(count){
    for(var i=0; i < count ; i++){
        alert(i);
    }
    var i;//重新声明变量
    alert(i);//计数
 }

用做块级作用域（通常称为私有作用域）的匿名函数的语法如下所示。

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

var count = 5;

outputNumbers(count);

这里初始化了变量count，将其设置为5。当然，这里的变量是没有必要的，因为可以把值直接传给函数。为了让代码更简洁，在调用函数时用5来代替变量count，如：

outputNumbers(5);

这样之所以可行，是因为变量只不过是值的另一种表现形式，因此用实际的值替换变量没有问题，再看下面的例子：

var someFunction =function(){

    //这里是块级作用域

 };

someFunction();

这个例子先定义了一个函数，然后立即调用了它。定义函数的方式创建一个匿名函数，并把匿名函数赋值给变量someFunction。而调用的方式是在函数名称后面添加一对圆括号，即someFunction()。通过前面的例子知道，可以使用实际的值来取代变量count，那在这里是不是也可以用函数的值直接取代函数名呢？然而，下面的代码却会导致错误。

function(){

    //这里是块级作用域

}();//出错

这段代码会导致语法错误，是因为JavaScript将function关键字当作一个函数声明的开始，而函数声明后面不能跟圆括号。然而，函数表达式的后面可以跟圆括号。要将函数声明转换成函数表达式，只要像下面这样给它加上一对圆括号即可：

(function(){

    //这里是块级作用域

})();

无论在什么地方，只要临时需要一些变量，就可以使用私有作用域，如：

function outputNumbers(count){
     (function(){
            for(var i=0; i < count ; i++){
                alert(i);
            }
     })();
        alert(i);//导致一个错误！
}

这种技术经常在全局作用域中被用在函数外部，从而限制向全局作用域中添加过多的变量和函数。一般来说，我们都应该尽量少向全局作用域中添加变量和函数。在一个由很多开发人员共同参与的大型应用程序中，过多的全局变量和函数很容易导致命名冲突。而通过创建私有作用域，每个开发人员既可以使用自己的变量，又不必担心搞乱全局作用域。

这种做法可以减少闭包占用的内存问题，因为没有指向匿名函数的引用。只要函数执行完毕，就可以立即销毁其作用域了。

私有变量

严格来讲，JavaScript中没有私有成员的概念；所有对象属性都是共有的。不过，倒是有一个私有变量的概念。任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。私有变量包括函数的参数、局部变量和在函数内部定义的其他函数。如：

function add(num1,num2){
     var sum = num1 + num2;
     return sum;
 }

有权限访问私有变量和私有函数的公有方法称为特权方法。有两种在对象上创建特权方法的方式。第一种是在构造函数中定义特权方法，基本模式如下：

function MyObject(){
     //私有变量和私有函数
     var privateVariable = 10;
     function privateFunction(){
         return false;
     }
     //特权方法
     this.publicMethod = function(){
         privateVariable++;
         return privateFunction();
     };
 }

利用私有和特权成员，可以隐藏那些不应该被直接修改的数据，例如：

function Person(name){
     this.getName = function(){
         return name;
     };
     this.setName = function(value){
         name = value;
     };
 }
 var person = new Person("Nicholas");
 alert(person.getName());//"Nicholas"
 person.setName("Greg");
 alert(person.getName());//"Greg"

静态私有变量

通过在私有作用域中定义敌友变量或函数，同样也可以创建特权方法，其基本模式如下：

(function(){
     //私有变量和私有函数
     var privateVariable = 10;
     function privateFunction(){
         return false;
     }
     //构造函数
     MyObject = function(){};
     //公有/特权方法
     MyObject.prototype.publicMethod = function(){
         privateVariable++;
         return privateFunction();
     };
 })();

这个模式与在构造函数中定义特权方法的主要区别，就在于私有变量和函数是由实例共享的。由于特权方法是在原型上定义的，因此所有实例都使用同一个函数。而这个特权方法，作为一个闭包，总是保存着对包含作用域的引用。如：

(function(){
     var name = "";
     Person = function(value){
        name = value;
     };
     Person.prototype.getName = function(){
         return name;
     };
     Person.prototype.setName = function(value){
         name = value;
     };
 })();
 var person1 = new Person("Nicholas");
 alert(person1.getName());//"Nicholas"
 person1.setName("Greg");
 alert(person1.getName());//"Greg"
 
 var person2 = new Person("Michale");
 alert(person1.getName());//"Michale"
 alert(person2.getName());//"Michale"

以这种方式创建静态私有变量会因为使用原型而增进代码复用，但每个实例都没有自己的私有变量。到底是使用实例变量，还是静态私有变量，最终还是要视具体需求而定。

多查找作用域链中的一个层次，就会在一定程度上影响查找速度。而这正是使用闭包和私有变量的一个明显的不足之处。

模块模式

前面的模式是用于为自定义类型创建私有变量和特权方法的。而道格拉斯所说的模块模式则是为单例创建私有变量和特权方法。所谓单例，指的就是只有一个实例的对象。按照惯例，JavaScript是以对象字面量的方式来创建单例对象的。

var singleton = {
         name:value,
         method:function(){
             //方法代码
         }
 };

var singleton = function(){
     //私有变量和私有函数
     var privateVariable = 10;
     function privateFunction(){
         return false;
     }
     //特权/公有方法和属性
     return {
         publicProperty:true,
         publicMethod:function(){
             privateVariable++;
             return privateFunction();
         }
     };
 }();

var application = function(){
    //私有变量和函数
    var components = new Array();
    components.push(new BaseComponent());
    //公共
    return {
        getComponentCount:function(){
            return components.length;
        },
        registerComponent:function(component){
            if(typeof component == "object"){
                components.push(component);
            }
        }
    };
}();

简言之，如果必须创建一个对象并以其某些数据对其进行初始化，同时还要公开一些能够访问这些私有数据的方法，那么就可以使用模块模式。以这种模式创建的每个单例都是Object的实例，因为最终要通过一个对象字面量来表示它。事实上，这也没有什么；毕竟，单例通常都是作为全局对象存在的，我们不会将它传递给一个函数。因此，也就没什么必要使用instanceof操作符来检查其对象类型了。

增强的模块模式

有人进一步改进了模块模式，即在返回对象之前对其增强的代码。这种增强的模块模式适合那些单例必须是某种类型的实例，同时还必须添加某些属性和（或）方法对其加以增强的情况，来看下面的例子。

var singleton = function(){
     //私有变量和私有函数
     var privateVariable = 10;
     function privateFunction(){
         return false;
     }
     //特权/公有方法和属性
     var object = new CustomType();
     //添加特权/公有属性和方法
     object.publicProperty = true;
     object.publicMethod = function(){
         privateVariable++;
         return privateFunction();
     };
     return object;
 }();

var application = function(){
    //私有变量和函数
    var components = new Array();
    //初始化
    components.push(new BaseComponent());
    //创建application的一个局部副本
    var app = new BaseComponent();
    //公共接口
    app.getComponentCount = function(){
        return components.length;
    };
    app.registerComponent = function(component){
        if(typeof component == "object"){
            components.push(component);
        }
    };
    //返回这个副本
    return app;
}();

JavaScript基础——函数表达式、闭包

标签：

原文地址：http://blog.csdn.net/goskalrie/article/details/51681571