定义函数的方式有两种：函数声明和函数表达式。

// 函数声明
function fn(){}

函数声明的一个重要特征就是函数声明提升，意思是在执行代码前会先读取函数声明。这就意味着可以把函数声明放在调用它的语句后面。
第二种创建函数的方式是使用函数表达式。这种情况下创建的函数叫匿名函数。

var fn=function(){}

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

sayHi();    //错误：函数还不存在 
var sayHi = function(){ 
    alert("Hi!");
};

能够创建函数再赋值给变量，也就能够把函数作为其他函数的值返回。

function demo(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;
        }
    };
}

demo()就返回了一个匿名函数。返回的函数可能会被赋值给一个变量，或者以其他方式被调用；不过，在demo()函数内部，它是匿名的。在把函数当成值来使用的情况下，都可以使用匿名函数。不过，这并不是匿名函数唯一的用途。

递归

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

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

下面的代码却可能导致它出错。

var anotherFactorial = factorial ;
factorial = null;
alert(anotherFactorial(4)); // 出错

以上代码先把factorial()函数保存在变量anotherFactorial中，然后将factorial变量设置为null，结果指向原始函数的引用只剩下一个。但在接下来调用anotherFactorial()时，由于必须执行factorial()，而factorial已经不再是函数，所以就会导致错误。在这种情况下，使用arguments.callee可以解决这个问题。
arguments.callee是一个指向正在执行的函数的指针，因此可以用它来实现对函数的递归调用。

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

通过使用arguments.callee代替函数名，可以确保无论怎样调用函数都不会出问题。因此，在编写递归函数时，使用arguments.callee总比使用函数名更保险。
但在严格模式下，不能通过脚本访问arguments.callee。访问这个属性会导致错误。不过，可以使用命名函数表达式来达成相同的结果。

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

闭包

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

function demo(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;
        }
    };
}

当某个函数被调用时，会创建一个执行环境及相应的作用域链。然后，使用arguments和其他命名参数的值来初始化函数的活动对象。但在作用域链中，外部函数的活动对象始终处于第二位，外部函数的外部函数的活动对象处于第三位，.....直至作为作用域链终点的全局执行环境。
在函数执行过程中，为读取和写入变量的值，就需要在作用域链中查找变量。

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

当调用compare()时，会创建一个包含arguments、value1和value2的活动对象。全局执行环境的变量对象（包含result和compare）在compare()执行环境的作用域链中则处于第二位。

var compare = demo("name");
var result = compare({ name: "Nicholas" }, { name: "Greg" });

在匿名函数从demo()中被返回后，它的作用域链被初始化为包含demo()函数的活动对象和全局变量对象。这样，匿名函数就可以访问在demo()中定义的所有变量。更为重要的是，demo()函数在执行完毕后，其活动对象也不会被销毁，因为匿名函数的作用域链仍然在引用这个活动对象。换句话说，当demo()函数返回后，其执行环境的作用域链会被销毁，但它的活 动对象仍然会留在内存中；直到匿名函数被销毁后，demo()的活动对象才会被销毁。

//创建函数
var compareNames = demo("name");
//调用函数
var result = compareNames({ name: "Nicholas" }, { name: "Greg" });
//解除对匿名函数的引用（以便释放内存） 
compareNames = null;

首先，创建的比较函数被保存在变量compareNames中。而通过将compareNames设置为等于null解除该函数的引用，就等于通知垃圾回收例程将其清除。随着匿名函数的作用域链被销毁，其他作用域 （除了全局作用域）也都可以安全地销毁了。

调用compareNames()的过程中产生的作用域链之间的关系

由于闭包会携带包含它的函数的作用域，因此会比其他函数占用更多的内存。过度使用闭包可能会导致内存占用过多。

闭包与变量

闭包只能取得包含函数中任何变量的最后一个值。闭包所保存的是整个变量对象，而不是某个特殊的变量。

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

这个函数会返回一个函数数组。表面上看，似乎每个函数都应该返自己的索引值，即位置0的函数返回0，位置1的函数返回1，以此类推。但实际上，每个函数都返回10。因为每个函数的作用域链中都保存createFunctions()函数的活动对象 ， 所以它们引用的都是同一个变量i。 当createFunctions()函数返回后，变量i的值是10，此时每个函数都引用着保存变量i的同一个变量 对象，所以在每个函数内部i的值都是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;
}

在重写了前面的createFunctions()函数后，每个函数就会返回各自不同的索引值了。在这个版本中，我们没有直接把闭包赋值给数组，而是定义了一个匿名函数，并将立即执行该匿名函数的结果赋给数组。这里的匿名函数有一个参数num，也就是最终的函数要返回的值。在调用每个匿名函数时，我们传入了变量i。由于函数参数是按值传递的，所以就会将变量 i 的当前值复制给参数num。而在这个匿名函数内部，又创建并返回了一个访问num的闭包。这样一来，result数组中的每个函数都有自己num变量的一个副本，因此就可以返回各自不同的数值了。

关于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;
    }
};

这里的getName()方法只简单地返回this.name的值。以下是几种调用object.getName()的方式以及各自的结果。

object.getName();   //"My Object"
(object.getName)(); //"My Object"
(object.getName = object.getName)(); //"The Window"，在非严格模式下

内存泄漏

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

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

以上代码创建了一个作为element元素事件处理程序的闭包，而这个闭包则又创建了一个循环引用。由于匿名函数保存了一个对assignHandler()的活动对象的引用，因此就会导致无法减少element的引用数。只要匿名函数存在，element的引用数至少也是1，因此它所占用的内存就永远不会被回收。不过，这个问题可以通过稍微改写一下代码来解决。

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

在上面的代码中，通过把element.id的一个副本保存在一个变量中，并且在闭包中引用该变量消除了循环引用。但仅仅做到这一步，还是不能解决内存泄漏的问题。必须要记住：闭包会引用包含函数的整个活动对象，而其中包含着element。即使闭包不直接引用element，包含函数的活动对象中也仍然会保存一个引用。因此，有必要把element变量设置为null。这样就能够解除对DOM对象的引用，顺利地减少其引用数，确保正常回收其占用的内存。

模仿块级作用域

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

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

在JS中，变量i是定义在ouputNumbers()的活动对象中的，因此从它有定义开始，就可以在函数内部随处访问它。即使像下面这样错误地重新声明同一个变量，也不会改变它的值。

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

JS从来不会告诉你是否多次声明了同一个变量；遇到这种情况，它只会对后续的声明视而不见(不过，它会执行后续声明中的变量初始化)。匿名函数可以用来模仿块级作用域并避免这个问题。
用作块级作用域(通常称为私有作用域)的匿名函数的语法如下所示。

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

以上代码定义并立即调用了一个匿名函数。将函数声明包含在一对圆括号中，表示它实际上是一个函数表达式。而紧随其后的另一对圆括号会立即调用这个函数。
无论在什么地方，只要临时需要一些变量，就可以使用私有作用域，例如：

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

    alert(i);   //导致一个错误！ 
}

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

私有变量

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

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

在这个函数内部有3个私有变量：num1，num2和sum。在函数内部可以访问这几个变量，但在函数外部则不能访问它们。如果在这个函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量。而利用这一点，就可以创建用于访问私有变量的公有方法。
我们把有权访问私有变量和私有函数的公有方法称为特权方法。有两种在对象上创建特权方法的方式。第一种是在构造函数中定义特权方法。

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

这个模式在构造函数内部定义了所有私有变量和函数。然后，又继续创建了能够访问这些私有成员的特权方法。能够在构造函数重定义特权方法，是因为特权方法作为闭包有权访问在构造函数中定义的所有变量和函数。对这个例子而言，变量privateVariable和函数privateFunction()只能通过特权方法publicMethod()来访问。在创建MyObject的实例后，除了使用publicMethod()这一个途径外，没有任何办法可以直接访问privateVariable和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();
    };
})();

这个模式创建了一个私有作用域，并在其中封装了一个构造函数及相应的方法。在私有作用域中， 首先定义了私有变量和私有函数，然后又定义了构造函数及其公有方法。公有方法是在原型上定义的， 这一点体现了典型的原型模式。需要注意的是，这个模式在定义构造函数时并没有使用函数声明，而是 使用了函数表达式。函数声明只能创建局部函数，但那并不是我们想要的。出于同样的原因，我们也没 有在声明MyObject时使用var关键字。记住：初始化未经声明的变量，总是会创建一个全局变量。 因此，MyObject就成了一个全局变量，能够在私有作用域之外被访问到。但也要知道，在严格模式下给未经声明的变量赋值会导致错误。
这个模式与在构造函数中定义特权方法的主要区别，就在于私有变量和函数是由实例共享的。由于特权方法是在原型上定义的，因此所有实例都使用同一个函数。而这个特权方法，作为一个闭包，总是保存着对包含作用域的引用。

(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("Michael"); 
alert(person1.getName()); //"Michael" 
alert(person2.getName()); //"Michael"

这个例子中的Person构造函数与getName()和setName()方法一样，都有权访问私有变量name。
在这种模式下，变量name就变成了一个静态的、由所有实例共享的属性。也就是说，在一个实例上调用setName()会影响所有实例。而调用setName()或新建一个Person实例都会赋予name属性一个新值。结果就是所有实例都会返回相同的值。
以这种方式创建静态私有变量会因为使用原型而增进代码复用，但每个实例都没有自己的私有变量。到底是使用实例变量，还是静态私有变量，最终还是要视你的具体需求而定。
多查找作用域链中的一个层次，就会在一定程度上影响查找速度。而这正是使用闭包和私有变量的一个显明的不足之处。

模块模式

模块模式是为单例创建私有变量和特权方法。所谓单例，指的就是只有一个实例的对象。 按照惯例，JS是以对象字面量的方式来创建单例对象的。

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);
            }
        }
    };
}();

在 Web 应用程序中，经常需要使用一个单例来管理应用程序级的信息。这个简单的例子创建了一个用于管理组件的application对象。在创建这个对象的过程中，首先声明了一个私有的components数组，并向数组中添加了一个BaseComponent的新实例（在这里不需要关心BaseComponent的代码，我们只是用它来展示初始化操作）。而返回对象的getComponentCount()和registerComponent()方法，都是有权访问数组components的特权方法。前者只是返回已注册的组件数目，后者用于注册新组件。
简言之，如果必须创建一个对象并以某些数据对其进行初始化，同时还要公开一些能够访问这些私有数据的方法，那么就可以使用模块模式。以这种模式创建的每个单例都是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; 
}();

如果前面演示模块模式的例子中的application对象必须是BaseComponent的实例，那么就可以使用以下代码。

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; 
}();

在这个重写后的应用程序（application）单例中，首先也是像前面例子中一样定义了私有变量。主要的不同之处在于命名变量app的创建过程，因为它必须是BaseComponent的实例。这个实例实际上是application对象的局部变量版。此后，我们又为app对象添加了能够访问私有变量的公有方法。 最后一步是返回app对象，结果仍然是将它赋值给全局变量application。

小结

在JS编程中，函数表达式是一种非常有用的技术。使用函数表达式可以无须对函数命名， 从而实现动态编程。匿名函数，也称为拉姆达函数，是一种使用JS函数的强大方式。以下总结了函数表达式的特点。

• 函数表达式不同于函数声明。函数声明要求有名字，但函数表达式不需要。没有名字的函数表达式也叫做匿名函数。
• 在无法确定如何引用函数的情况下，递归函数就会变得比较复杂；
• 递归函数应该始终使用arguments.callee来递归地调用自身，不要使用函数名，函数名可能会发生变化。

当在函数内部定义了其他函数时，就创建了闭包。闭包有权访问包含函数内部的所有变量。

• 在后台执行环境中，闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域。
• 通常，函数的作用域及其所有变量都会在函数执行结束后被销毁。
• 但是，当函数返回了一个闭包时，这个函数的作用域将会一直在内存中保存到闭包不存在为止。

使用闭包可以在JS中模仿块级作用域（JS本身没有块级作用域的概念）。

• 创建并立即调用一个函数，这样既可以执行其中的代码，又不会在内存中留下对该函数的引用。
• 结果就是函数内部的所有变量都会被立即销毁——除非将某些变量赋值给了包含作用域（即外部作用域）中的变量。

闭包还可以用于在对象中创建私有变量。

• 即使JS中没有正式的私有对象属性的概念，但可以使用闭包来实现公有方法，而通过公有方法可以访问在包含作用域中定义的变量。
• 有权访问私有变量的公有方法叫做特权方法。
• 可以使用构造函数模式、原型模式来实现自定义类型的特权方法，也可以使用模块模式、增强的模块模式来实现单例的特权方法。

JS中的函数表达式和闭包都是极其有用的特性，利用它们可以实现很多功能。不过，因为创建闭包必须维护额外的作用域，所以过度使用它们可能会占用大量内存。