javascript高级程序设计-第七章

注

没有一节一节写的很详细，就总结一些常用的，给自己或者也一起在学习的朋友一起过过眼瘾，一起理理，喜欢的朋友可以点赞关注哦。

递归

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

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

但下面的代码却可能导致它出错。

var anotherFactorial = factorial; 
factorial = null; 
alert(anotherFactorial(4)); //出错！

以上代码先把 factorial()函数保存在变量 anotherFactorial 中，然后将 factorial 变量设置为 null，结果指向原始函数的引用只剩下一个。但在接下来调用 anotherFactorial()时，由于必须执行 factorial()，而 factorial 已经不再是函数，所以就会导致错误。在这种情况下，使用 argu.ments.callee 可以解决这个问题。arguments.callee 是一个指向正在执行的函数的指针，因此可以用它来实现对函数
的递归调用。通过使用 arguments.callee 代替函数名，可以确保无论怎样调用函数都不会出问题。因此，在编写递归函数时，使用 arguments.callee 总比使用函数名更保险

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

但在严格模式下，不能通过脚本访问 arguments.callee，访问这个属性会导致错误。不过，可以使用命名函数表达式来达成相同的结果。创建了一个名为 f()的命名函数表达式，然后将它赋值给变量 factorial。即便把函数赋值给了另一个变量，函数的名字 f 仍然有效，所以递归调用照样能正确完成。这种方式在严格模式和非严格模式下都行得通。

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

闭包

看不懂，愣头青！

this对象

在闭包中使用 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"（在非严格模式下）

每个函数在被调用时都会自动取得两个特殊变量：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" 

内存泄漏

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

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

以上代码创建了一个作为 element 元素事件处理程序的闭包，而这个闭包则又创建了一个循环引用。由于匿名函数保存了一个对 assignHandler()的活动对象的引用，因此就会导致无法减少 element 的引用数。只要匿名函数存在，element 的引用数至少也是 1，因此它所占用的内存就永远不会被回收。不过，这个问题可以通过稍微改写一下代码来解决。

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

通过把 element.id 的一个副本保存在一个变量中，并且在闭包中引用该变量消除了循环引用。但仅仅做到这一步，还是不能解决内存泄漏的问题。必须要记住：闭包会引用包含函数的整个活动对象，而其中包含着 element。即使闭包不直接引用 element，包含函数的活动对象中也仍然会保存一个引用。因此，有必要把 element 变量设置为 null。这样就能够解除对 DOM 对象的引用，顺利地减少其引用数，确保正常回收其占用的内存。

模仿块级作用域

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

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

这个函数中定义了一个 for 循环，而变量 i 的初始值被设置为 0。在 Java、C++等语言中，变量 i只会在 for 循环的语句块中有定义，循环一旦结束，变量 i 就会被销毁。可是在 JavaScrip 中，变量 i是定义在 ouputNumbers()的活动对象中的，因此从它有定义开始，就可以在函数内部随处访问它。即使像下面这样错误地重新声明同一个变量，也不会改变它的值。

function outputNumbers(count){ 
 for (var i=0; i < count; i++){ 
 alert(i); 
 } 
 
 var i; //重新声明变量
 alert(i); //计数
} 

只要临时需要一些变量，就可以使用私有作用域。

function outputNumbers(count){ 
 (function () { 
 for (var i=0; i < count; i++){ 
 alert(i); 
 } 
 })(); 
 
 alert(i); //导致一个错误！
} 

这种技术经常在全局作用域中被用在函数外部，从而限制向全局作用域中添加过多的变量和函数。一般来说，我们都应该尽量少向全局作用域中添加变量和函数。在一个由很多开发人员共同参与的大型应用程序中，过多的全局变量和函数很容易导致命名冲突。而通过创建私有作用域，每个开发人员既可以使用自己的变量，又不必担心搞乱全局作用域。

(function(){ 
 var now = new Date(); 
 if (now.getMonth() == 0 && now.getDate() == 1){ 
 alert("Happy new year!"); 
 } 
})(); 

私有变量

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

function add(num1, num2){ 
 var sum = num1 + num2; 
 return sum; 
} 

在这个函数内部，有 3 个私有变量：num1、num2 和 sum。在函数内部可以访问这几个变量，但在函数外部则不能访问它们。如果在这个函数内部创建一个闭包，那么闭包通过自己的作用域链也可以访问这些变量。而利用这一点，就可以创建用于访问私有变量的公有方法。
我们把有权访问私有变量和私有函数的公有方法称为特权方法（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" 

模块模式

模块模式（module pattern）则是为单例创建私有变量和特权方法。所谓单例（singleton），指的就是只有一个实例的对象。按照惯例，JavaScript 是以对象字面量的方式来创建单例对象的。

var singleton = { 
 name : value, 
 method : function () { 
 //这里是方法的代码
 } 
}; 

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

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; 
 }, 
 registerComponent : function(component){ 
 if (typeof component == "object"){ 
 components.push(component); 
 } 
 } 
 }; 
}(); 

在 Web 应用程序中，经常需要使用一个单例来管理应用程序级的信息。这个简单的例子创建了一个用于管理组件的 application 对象。在创建这个对象的过程中，首先声明了一个私有的 components数组，并向数组中添加了一个 BaseComponent 的新实例（在这里不需要关心 BaseComponent 的代码，我们只是用它来展示初始化操作）。而返回对象的 getComponentCount()和 registerComponent()方法，都是有权访问数组components 的特权方法。前者只是返回已注册的组件数目，后者用于注册新组件。
简言之，如果必须创建一个对象并以某些数据对其进行初始化，同时还要公开一些能够访问这些私有数据的方法，那么就可以使用模块模式。以这种模式创建的每个单例都是 Object 的实例，因为最终要通过一个对象字面量来表示它。事实上，这也没有什么；毕竟，单例通常都是作为全局对象存在的，我们不会将它传递给一个函数。因此，也就没有什么必要使用 instanceof 操作符来检查其对象类型了。

增强的模块模式

有人进一步改进了模块模式，即在返回对象之前加入对其增强的代码。这种增强的模块模式适合那些单例必须是某种类型的实例，同时还必须添加某些属性和（或）方法对其加以增强的情况。来看下面的例子。

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。