函数表达式（上篇）

回顾：定义函数的两种方式：1.函数声明。2.函数表达式。

1.函数声明：

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

函数声明，有一个重要特征：函数声明提升。可以把函数声明放在调用它的语句后面。

sayHi();
function sayHi() {
    alert('Hi!');
}

2.函数表达式：

匿名函数,function关键字后面没有标识符。匿名函数的name属性是空字符串。

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

函数表达式和其他表达式一样，使用前必须先赋值。

//错误
sayHi();  
var sayHi = function(){
   alert('hi!');
};

1.递归

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

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

这是一个经典的递归阶乘函数，虽然表面看没什么问题，下面的代码可能导致它出错。

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

var anotherFactorial = factorial;
factorial = null;
alert(anotherFactorial(4));  //Uncaught TypeError: factorial is not a function at factorial 

出错原因：factorial()函数保存在变量anotherFactorial中，将factorial变量设置为null,结果指向原始函数的引用只剩下一个。接下来调用anotherFactorial()时，由于必须执行factorial()，而factorial已经不再是函数，所以就会导致错误，在这种情况下可以使用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);
    }
});
factorial(3);//6

创建一个f()的命名函数表达式，然后将它赋值给变量factorial。即使把函数赋值给另一个变量，函数的名字f仍然有效，所以递归可以正确完成，在严格模式和非严格模式下都可以。

2.闭包

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

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

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

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

各位客官，函数表达式中：模仿块级作用域和私有变量，且看下篇。