第7章 函数表达式

函数声明要求有名字，但函数表达式不需要。没有名字的函数表达式也叫做匿名函数。

1 递归

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

function factorial(num){ 
 if (num <= 1){ 
     return 1; 
 } else { 
     return num * arguments.callee(num-1); //非严格模式：不要使用函数名——函数名可能会发生变化。
 } 
}

var factorial = (function f(num){ //创建了一个名为 f()的命名函数表达式
 if (num <= 1){ 
     return 1; 
 } else { 
     return num * f(num-1); //严格模式
 } 
});

2 闭包

2.1 概念

闭包是指有权访问另一个函数作用域中的变量的函数。由于闭包会携带包含它的函数的作用域，因此会比其他函数占用更多的内存。

闭包有权访问包含函数内部的所有变量， 原理 如下：

闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域。

函数的作用域及其所有变量都会在函数执行结束后被销毁。

但是，当函数返回了一个闭包时，这个函数的作用域将会一直在内存中保存到闭包不存在为止。

function createComparisonFunction(propertyName) { 
 
 return function(object1, object2){ 
     var value1 = object1[propertyName]; //内部函数访问了外部函数中的变量 propertyName
     var value2 = object2[propertyName]; //是因为内部函数的作用域链中包含createComparisonFunction()的作用域
 
     if (value1 < value2){ 
         return -1; 
     } else if (value1 > value2){ 
         return 1; 
     } else { 
         return 0; 
     } 
 }; 
}

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

• 在另一个函数内部定义的函数会将包含函数（即外部函数）的活动对象添加到它的作用域链中。
• createComparisonFunction() 函数在执行完毕后，其执行环境的作用域链会被销毁，其活动对象不会被销毁，因为匿名函数的作用域链仍然在引用这个活动对象。直到匿名函数被销毁后，createComparisonFunction()的活动对象才会被销毁。

2.2 闭包与变量

function createFunctions(){ 
     var result = new Array(); 
     for (var i=0; i < 10; i++){ 
         result[i] = function(){ 
             return i;//10：因为每个函数的作用域链中都保存着 createFunctions() 函数的活动对象，所以它们引用的都是同一个变量 i 。 createFunctions()函数返回后，变量 i 的值是 10
         }; 
     } 
     return result; 
}

function createFunctions(){ 
     var result = new Array(); 
     for (var i=0; i < 10; i++){ 
         result[i] = function(num){ 
             return function(){ //定义了一个匿名函数，并将立即执行该匿名函数的结果赋给数组
                 return num;//创建并返回了一个访问 num 的闭包 
             }; 
         }(i);//调用每个匿名函数时，我们传入了变量 i
     } 
     return result; 
}

2.3 关于this对象

匿名函数的执行环境具有全局性，因此其 this 对象通常指向 window ①。

var name = "The Window"; 
var object = { 
     name : "My Object", 
     getNameFunc : function(){ 
         return function(){ 
             return this.name; 
         }; 
     } 
}; 
alert(object.getNameFunc()()); //"The Window"（在非严格模式下）

var name = "The Window"; 
var object = { 
     name : "My Object", 
     getNameFunc : function(){ 
         var that = this;//在定义了闭包之后，闭包也可以访问这个变量，因为它是我们在包含函数中特意声名的一个变量
         return function(){ 
             return that.name; 
         }; 
     } 
}; 
alert(object.getNameFunc()()); //"My Object"

var object = { 
     name : "My Object", 
     getName: function(){ 
         return this.name;
     } 
}; 
object.getName(); //"My Object"

2.4 内存泄漏

function assignHandler(){ 
     var element = document.getElementById("someElement"); 
     element.onclick = function(){ 
         alert(element.id); //只要匿名函数存在，element 的引用数至少也是 1，因此它所占用的内存就永远不会被回收。
     }; 
}

function assignHandler(){ 
     var element = document.getElementById("someElement"); 
     var id = element.id; //副本保存在一个变量中
     element.onclick = function(){ 
         alert(id); 
     }; 
     element = null; //闭包会引用包含函数的整个活动对象，而其中包含着 element
}

3 模仿块级作用域

使用闭包可以在 JavaScript 中模仿块级作用域，要点如下：

• 创建并立即调用一个函数，这样既可以执行其中的代码，又不会在内存中留下对该函数的引用。
• 结果就是函数内部的所有变量都会被立即销毁——除非将某些变量赋值给了包含作用域（即外 部作用域）中的变量。

function outputNumbers(count){ 
 for (var i=0; i < count; i++){ 
     alert(i); 
 } 
 alert(i); //计数：从它有定义开始，就可以在函数内部随处访问它
}

(function(){ //匿名函数自调用：这种技术经常在全局作用域中被用在函数外部，从而限制向全局作用域中添加过多的变量和函数
 //这里是块级作用域
})();

function outputNumbers(count){ 
 (function () {//在匿名函数中定义的任何变量，都会在执行结束时被销毁 
     for (var i=0; i < count; i++){//在私有作用域中能够访问变量 count，是因为这个匿名函数是一个闭包，它能够访问包含作用域中的所有变量 
         alert(i); 
     } 
 })(); 
 alert(i); //导致一个错误！
}

4 私有变量

任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数的外部访问这些变量。私有变量包括函数的参数、局部变量和在函数内部定义的其他函数。

闭包还可以用于在对象中创建私有变量，相关概念和要点如下：

• 可以使用闭包来实现公有方法，而通过公有方法可以访问在包含作用域中定义的变量。有权访问私有变量的公有方法叫做特权方法。
• 可以使用构造函数模式、原型模式来实现自定义类型的特权方法，也可以使用模块模式、增强的模块模式来实现单例的特权方法。

4.1 构造函数模式

function add(num1, num2){//3 个私有变量：num1、num2 和 sum 
     var sum = num1 + num2; 
     return sum; 
}

function MyObject(){ //构造函数：内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量
     //私有变量和私有函数
     var privateVariable = 10; 
     function privateFunction(){ 
         return false; 
     } 
     //特权方法：是因为特权方法作为闭包有权访问在构造函数中定义的所有变量和函数
     this.publicMethod = function (){ 
         privateVariable++; 
         return privateFunction(); 
     }; 
}

function Person(name){ 
     this.getName = function(){//特权方法都可以在构造函数外部使用 
         return name; //作为闭包能够通过作用域链访问 name
     }; 
     this.setName = function (value) { 
         name = value; 
     }; 
} 
var person = new Person("Nicholas"); 
alert(person.getName()); //"Nicholas" ：私有变量 name在 Person 的每一个实例中都不相同，因为每次调用构造函数都会重新创建这两个方法
person.setName("Greg"); 
alert(person.getName()); //"Greg"

4.2 原型模式 （静态私有变量）

通过在私有作用域中定义私有变量或函数，同样也可以创建特权方法。这个模式与在构造函数中定义特权方法的主要区别，就在于私有变量和函数是由实例共享的，但每个实例都没有自己的私有变量。到底是使用实例变量，还是静态私有变量，最终还是要视你的具体需求而定。

而这个特权方法，作为一个闭包，总是保存着对包含作用域的引用。

(function(){//创建了一个私有作用域 
 
 //私有变量和私有函数
 var privateVariable = 10; 
 function privateFunction(){ 
     return false; 
 } 
 //构造函数：函数声明只能创建局部函数，故没有在声明 MyObject 时使用 var 关键字
 MyObject = function(){ 
 }; 
 //公有/特权方法：在原型上定义的函数表达式，创建一个全局变量，能够在私有作用域之外被访问到
 MyObject.prototype.publicMethod = function(){ 
     privateVariable++; 
     return privateFunction(); 
 }; 
})();

(function(){ 
 
 var name = ""; //私有变量name
 
 Person = function(value){ 
     name = value; 
 }; 
 Person.prototype.getName = function(){ 
     return name; //在这种模式下，变量 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"); //而调用 setName()或新建一个 Person 实例都会赋予 name 属性一个新值。结果就是所有实例都会返回相同的值。
alert(person1.getName()); //"Michael" 
alert(person2.getName()); //"Michael"

4.3 模块模式

模块模式 是为单例创建私有变量和特权方法。所谓单例 ，指的就是只有一个实例的对象。

如果必须创建一个对象并以某些数据对其进行初始化，同时还要公开一些能够访问这些私有

数据的方法，那么就可以使用模块模式。

var singleton = function(){ //模块模式使用了一个返回对象的匿名函数
 
 //私有变量和私有函数
 var privateVariable = 10; 
 function privateFunction(){ 
     return false; 
 }
 //特权/公有方法和属性：有权访问私有变量和函数，对象字面量定义的是单例的公共接口
 return { //将一个对象字面量作为函数的值返回：包含可以公开的属性和方法
     publicProperty: true, 
     publicMethod : function(){ 
         privateVariable++; 
         return privateFunction(); 
     } 
 }; 
}();

var application = function(){ 
 //私有变量和函数
 var components = new Array(); 
 //初始化
 components.push(new BaseComponent()); 
 //公共
 return { 
     getComponentCount : function(){//返回已注册的组件数目 
         return components.length;//是有权访问数组 components 
     }, 
     registerComponent : function(component){//用于注册新组件 
         if (typeof component == "object"){ 
             components.push(component); 
         } 
     } 
 }; 
}();

4.4 增强的模块模式

有人进一步改进了模块模式，即在返回对象之前加入对其增强的代码。这种增强的模块模式适合那

些单例必须是某种类型的实例，同时还必须添加某些属性和（或）方法对其加以增强的情况。

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

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