定义函数有两种方式：函数声明和函数表达式。
Firefox、Chrome、Safari、Opera都给函数定义了一个非标准的name属性，通过这个属性可以访问到函数名。
函数声明最重要的特征就是函数声明提前（function declaration hoisting）。在执行代码之前会先读取函数声明，意味着可以把函数声明放在调用语句的后面。

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

创建一个函数并将它赋值给变量functionName。这种情况下创建的函数叫匿名函数（anonymous function）,有时候也叫Lambda函数。匿名函数的name属性是空字符串。
函数表达式与其他表达式一样，必须先赋值后使用。

递归

---

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

下面的代码可能出错：

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

可以使用arguments.callee来解决这个问题。arguments.callee是一个指向正在执行的函数的指针。

function factorial(num) {
    if(num<=){
        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);
    }
});

闭包

---

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

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

闭包与变量

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

function createFunction () {
    var result = new Array();

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

    return result;
}

事实上result中的每个函数都返回10。但是，我们可以通过创建另一个匿名函数强制让闭包的行为符合预期。

function createFunction () {
    var result = new Array();

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

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

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

这个问题可以通过修改下代码来解决。

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

模仿块级作用域

---

私有变量

---

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

闭包可以通过自己的作用域链也可以访问局部变量，利用这一点，就可以创建用于访问私有变量的公有方法。

我们把有权访问私有变量和私有函数的公有方法称为特权方法（privileged method）。有两种在对象上创建特权方法的方式：
第一种是在构造函数中定义特权方式。

function MyObject () {
    //私有变量和私有函数
    var privateVariable = 10;

    function privateFunction () {
        return false;
    }
    
    //特权方法
    this.publicMethod = function () {
        privateVariable++;
        return privateFunction();
    };
}

不过，在构造函数中定义特权方法也有一个缺点，那就是你必须使用构造函数模式来达到这个目的。构造函数模式的缺点是针对每个实例都会创建同样一组新方法，而使用静态私有变量来实现特权方法就可以避免这个问题。

静态私有变量

通过在私有作用域中定义私有变量和函数，同样也可以创建特权方法。

(function () {
    //私有变量和私有函数
    var privateVariable = 10;
    function privateFunction () {
        return false;
    }

    //构造函数
    MyObject = function () {};
    
    //公有/特权方法
    MyObject.prototype.publicMethod = function () {
        privateVariable++;
        return privateFunction();
    };
})();

模块模式

前面的模式是用于自定义类型创建私有变量和特权方法的。而道格拉斯所说的模块模式（module patten）则是为单例创建私有变量和方法。所谓单例（singleton），指的就是一个实例的对象。

var signleton = function () {
    //私有变量和私有函数
    var privateVariable = 10;

    function privateFunction () {
        return false;
    }

    //公有/特权方法
    return {
        publicProperty : true;
        publicMethod : function() {
            privateVariable++;
            return privateFunction();
        }
    };
}();

增强的模块模式

这种增强的模块模式适合那些单例必须是某种类型的实例，同时还必须添加某些属性和（或）方法对其加以增强的情况。