JavaScript笔记：函数表达式

函数表达式是JavaScript中一个很强大又容易令人困惑的特性。
创建函数有两种方式：

// 方式1
function sayHi(){
    alert("Hi!");
}
// 方式2
var sayHi = function(){
    alert("Hi!");
};

函数有个很重要的特性就是函数声明提升：意思就是说，在执行代码之前会先读取函数的声明。

闭包

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

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;
        } 
    };
}
// 请注意下面这两行代码：
//var value1 = object1[propertyName];
//var value2 = object2[propertyName];

这段代码中，需要注意的两行代码如上所示，这两行代码访问了外部的函数属性propertyName。即使这个内部的函数被返回了，并且在其他地方被调用了，它仍然可以访问变量propertyName。

1、闭包与变量

注意，闭包只能取得包含函数变量中任何变量的最后一个值。也就是说，闭包保存的是整个变量对象，而不是某个特殊的变量。
下面这段代码很能说明问题：

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

createFunctions函数返回后，result中的所有返回值都是10；如果我们想要返回值是期望的0-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;
}

上面这段代码通过创建匿名函数达到了目的。

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

如果在getNameFunc想返回object的name，该如何做呢？只需要在闭包中，将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"

3、内存泄漏

由于IE9之前的版本对JS对象和DOM对象使用不同的垃圾收集例程，因此闭包在这些IE浏览器下就会有一些特殊的问题。具体来说就是，如果闭包的作用域链中保存了HTML元素，那么就意味着，该元素不会被销毁。
看下面的例子：

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

上述代码创建了一个作为element元素事件处理的闭包。由于匿名函数保存了一个对assignHandler活动对象的引用，因此就会导致无法减少element元素的引用数，那么它所占用的内存就永远不会被回收。因此，这段代码应该修改为：

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

模仿块级作用域

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

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

这个函数中定义了一个for循环，在java语言中，一旦for循环结束，变量i也会被销毁。但是在js语言中，i变量会在函数中一直存在，不会被销毁。

匿名函数可以模仿块级作用域来避免这个问题。

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

以上代码创建了一个匿名函数并立即调用了这个函数。

利用匿名函数，上面的一段代码可以修改为：

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

这种技术经常用来限制向全局作用域中添加过多的变量和函数。一般来说，我们应该少向全局作用域中添加变量和函数，因为在多人参加的大型项目中，这样很容易导致命名冲突的错误。通过创建私有域，大家不必担心搞乱全局作用域，又可以愉快地使用自己的变量。

私有变量

任何在函数内部定义的变量，可以成为私有变量，因为在函数外部不能访问这些变量。
另外，我们把有权访问函数内部私有变量和私有方法的方法称为特权方法。

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

利用私有和特权成员，可以隐藏那些不可以被直接修改的数据。

1、静态私有变量。

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

(function(){
    // 私有变量和函数
    var privateVariable = 10;
    function privateFunction(){
        return false;
    }
    // 构造函数
    MyObject = function(){ };
    // 公有／特权方法
    MyObject.prototype.publicMethod = function(){
        privateVariable++;
        return privateFunction();
    };
})();

需要注意的是，在定义构造函数的时候，我们没有使用函数声明，而是使用了函数表达式。函数声明只能创建局部函数，但那并不是我们想要的。

上面这种方式定义和在构造函数中定义特权方法的区别在于，私有变量和函数是所有对象共享的：

(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"

我们可以发现了：当对象2修改了name变量，对象1也跟着受到影响。

2、模块模式

为单例创建私有变量和方法：（所谓单例，就是只有一个实例的对象）

var singleton = function(){
    // 私有变量和私有函数
    var privateVariable = 10;
    function privateFunction(){
            return false;
    }
    //特权／公有
    return {
        publicProperty: true,
        publicMethod : function(){
            privateVariable++;
            return privateFunction();
        }
     }; 
}();

从本质上讲，这个对象字面量定义的是单例的公共接口。

3、增强的模块模式

单例必须是某种类型，并且还需要添加某些方法和属性的情况。

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