《JavaScript高级程序设计》函数

1、定义函数

定义函数的方式有两种：函数声明和函数表达式
函数声明的语法是这样的：

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

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

sayHi();
function sayHi(){
    alert("Hi");
}

函数表达式语法：

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

创建一个函数并将它赋值给变量functionName，这种情况下创建的函数叫做匿名函数。

理解函数提升的关键，就是理解函数声明与函数表达式之间的区别。

//不要这样做
if(condition){
    function sayHi(){
        alert("Hi");
    }
} else {
    function sayHi(){
        alert("Hello");
    }
}

//可以这样做
var sayHi;
if(condition){
    sayHi = function(){
        alert("Hi");
    }
} else {
    sayHi = function(){
        alert("Hello");
    }
}

2、递归

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

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()，所以会导致出错，可以使用argument.callee解决问题(argument.callee是一个指向正在执行的函数的指针)。

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

使用匿名函数也能达到相同的效果：

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

3、闭包

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

function createFunction(prototypeName){
    return function(object1,object2){
        var value1 = object1[prototypeName];
        var value2 = object2[prototypeName];
    }
}

作用域与作用域链：当某个函数被调用时，会创建一个执行环境及相应的作用域链，然后，使用arguments和其他命名参数的值来初始化函数的活动对象，但在作用域链中，外部函数的活动对象始终处于第二位，外部函数的外部函数处于第三位，……直至作用域链终点的全局执行环境。

作用域链的这种配置机制引出了一个值得注意的副作用，即闭包只能取得包含函数中任何变量的最后一个值。

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

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

    return result;
}

这个函数会返回一个数组，表面上看每个函数都返回自己都索引值，实际上，每个函数都返回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;
}

关于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"

如果想访问作用域链中的arguments对象，也需要将该对象的引用保存到另一个闭包能访问的变量中。

私有变量

任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数外部访问这些变量。但是，如果在函数内部创建一个闭包，那么闭包可以通过作用域链访问这些变量。我们把有权访问私有变量和私有函数的公有方法称为特权方法，有两种在对象上创建特权方法的方式：

//在构造函数中定义特权方法
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 pattern)则是为单例创建私有变量和特权方法。所谓单例(singleton)，指的是只有一个实例的对象。

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

    function privateFunction(){
        return false;
    }

    //特权方法
    return {
        publicProperty : true,

        publicMethod : function(){
            privateVariable++;
            return privateFunction();
        }
    };
}();