Javascript-11-函数表达式-1

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

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

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

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

函数表达式有几种不同的语法形式。最常见的：

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

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

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

递归

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

function factorial(num) {
    if (num <= 1) {
        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 <= 1) {
        return 1;
    } else {
        return num *  arguments.callee(num - 1);
    }
}

因此，在编写递归函数时，使用arguments.callee总比使用函数名更保险。

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

var factorial = (functon 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;
        }
    }
}

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

作用域链本质上是一个指向变量对象的指针列表，它只引用但不实际包含变量对象。

在另一个函数内部定义的函数会将包含函数(即外部函数)的活动对象添加到它的作用域中。

闭包与变量

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

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

    for(var i = 0; i < 10; i++) {
        result[i] = function() {
            return i;
        }
    }
    return result;
}
// 实际上每个函数都返回10，我们可以通过创建另一个匿名函数强制让闭包的行为符合预期

function createFunctions1(){
    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。当然在通过call()和apply()改变函数执行环境的情况下，this就会指向其他对象。

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'

内存泄漏

function assignhandler() {
    var element = document.getElementById('someElement');
    elment.onclick = function() {
        alert(element.id)
    }
}

循环引用导致element所占用的内存永远不会被回收。

闭包会引用包含函数的整个活动对象，而其中包含着element。即使闭包不直接引用element，包含函数的活动对象中也仍然会保存一个引用。因此，有必要把element变量设置为null。这样就能够解除对DOM对象的引用，顺利地减少其引用数，确保正常回收其占用的内存。