js高级第三版（第七章 函数表达式）

函数表达式是 JavaScript 中的一个既强大又容易令人困惑的特性。

定义函数的方式有两种：一种是函数声明，另一种就是函数表达式。

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

    第二种创建函数的方式是使用函数表达式。

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

    理解函数提升的关键，就是理解函数声明与函数表达式之间的区别。（前者返回函数，后者返回函数值）

   7.1 递归

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

    但在严格模式下，使用命名函数表达式来达成结果    

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

    以上代码创建了一个名为 f()的命名函数表达式，然后将它赋值给变量 factorial。即便把函数赋值给了另一个变量，函数的名字 f 仍然有效，所以递归调用照样能正确完成。这种方式在严格模式和非严格模式下都行得通。

    7.2 闭包

    闭包是指有权访问另一个函数作用域中的变量的函数。

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

    无论什么时候在函数中访问一个变量时，就会从作用域链中搜索具有相应名字的变量。一般来讲，当函数执行完毕后，局部活动对象就会被销毁，内存中仅保存全局作用域（全局执行环境的变量对象）。但是，闭包的情况又有所不同。

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

7.2.1 闭包与变量

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

    所以，我们在闭包中，新建一个数组，然后是定义一个匿名函数，并将立即执行该匿名函数的结果赋给数组中，然后再返回。  

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

     7.2.2 关于this对象

    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"，在非严格模式下

    7.2.3 内存泄漏

    因此闭包在 IE 的这些版本中会导致一些特殊的问题。具体来说，如果闭包的作用域链中保存着一个HTML 元素，那么就意味着该元素将无法被销毁。

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

    7.3 模仿块级作用域

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

    JavaScript 从来不会告诉你是否多次声明了同一个变量；遇到这种情况，它只会对后续的声明视而不见（不过，它会执行后续声明中的变量初始化）。匿名函数可以用来模仿块级作用域并避免这个问题。用作块级作用域（通常称为私有作用域）的匿名函数的语法如下所示。

(function(){

 //这里是块级作用域

})();

    以上代码定义并立即调用了一个匿名函数。将函数声明包含在一对圆括号中，表示它实际上是一个函数表达式。而紧随其后的另一对圆括号会立即调用这个函数。

    这种做法可以减少闭包占用的内存问题，因为没有指向匿名函数的引用。只要函数执行完毕，就可以立即销毁其作用域链了。

    7.4 私有变量

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

    我们把有权访问私有变量和私有函数的公有方法称为特权方法（privileged method）。

    有两种在对象上创建特权方法的方式。

    第一种是在构造函数中定义特权方法，基本模式如下。    

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

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

function Person(name){
 this.getName = function(){
 return name;
 };
 this.setName = function (value) {
 name = value;
 };
}
var person = new Person("Nicholas");
alert(person.getName()); //"Nicholas"
person.setName("Greg");
alert(person.getName()); //"Greg" 

7.4.1 静态私有变量

    通过在私有作用域中定义私有变量或函数，同样也可以创建特权方法，其基本模式如下所示。    

(function(){

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

注意的是，这个模式在定义构造函数时并没有使用函数声明，而是使用了函数表达式。

多查找作用域链中的一个层次，就会在一定程度上影响查找速度。而这正是使用闭包和私有变量的一个显明的不足之处。

7.4.2 模块模式

    道格拉斯所说的模块模式（modulepattern）则是为单例创建私有变量和特权方法。

    所谓单例（singleton），指的就是只有一个实例的对象。

    按照惯例，JavaScript 是以对象字面量的方式来创建单例对象的。

    模块模式通过为单例添加私有变量和特权方法能够使其得到增强，其语法形式如下：    

var singleton = function(){

 //私有变量和私有函数
 var privateVariable = 10;

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

    这个模块模式使用了一个返回对象的匿名函数。

    在这个匿名函数内部，首先定义了私有变量和函数。然后，将一个对象字面量作为函数的值返回。返回的对象字面量中只包含可以公开的属性和方法。由于这个对象是在匿名函数内部定义的，因此它的公有方法有权访问私有变量和函数。

    从本质上来讲，这个对象字面量定义的是单例的公共接口。这种模式在需要对单例进行某些初始化，同时又需要维护其私有变量时是非常有用的，

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

如果前面演示模块模式的例子中的 application 对象必须是 BaseComponent 的实例，那么就可以使用以下代码。

var application = function(){
 //私有变量和函数
 var components = new Array();
 //初始化
 components.push(new BaseComponent());
 //创建 application 的一个局部副本
 var app = new BaseComponent();
 //公共接口
 app.getComponentCount = function(){
 return components.length;
 };
 app.registerComponent = function(component){
 if (typeof component == "object"){
 components.push(component);
 }
 };
 //返回这个副本
 return app;
}(); 

        在这个重写后的应用程序（application）单例中，首先也是像前面例子中一样定义了私有变量。主要的不同之处在于命名变量 app 的创建过程，因为它必须是 BaseComponent 的实例。这个实例实际上是 application 对象的局部变量版。此后，我们又为 app 对象添加了能够访问私有变量的公有方法。最后一步是返回 app 对象，结果仍然是将它赋值给全局变量 application。