您的位置：首页 > Web前端 > JavaScript

javascript递归与闭包

2015-08-13 10:28 513 查看

转自Javascript高级程序设计（第三版）：

定义函数的方法有两种：

一种是函数声明，另一种是函数表达式。

关于函数声明，最重要的特征就是：函数声明提升(function declaration hoisting),也就是在执行代码之前会读取函数声明。这就意味着可以把函数声明放在调用它的语句后面。

function test(){
sayHi();
}
function sayHi(){
alert("hi");
}

这个例子不会抛出错误，因为在代码执行之前会先读取函数声明。

关于函数表达式，常见的形式如下：

var functionname = function(arg0,arg1,arg2){

//函数体

};

这种情况下创建的函数叫做匿名函数，因为function关键字后面没有标识符。（匿名函数有时候也叫做拉姆达函数）

函数表达式与函数声明不一样，在使用之前必须先赋值。

递归：

function test(){
var anotherF=factorial;
factorial=null;
alert(anotherF(4));
}
function factorial(num){
if(num<=1){
return 1;
}
else{
return num*factorial(num-1);
}
}

由于再次调用factorial的时候，它已经不再是函数，因此会导致错误。在这种情况下，使用arguments.callee可以解决这个问题。

function test(){
var anotherF=factorial;
factorial=null;
alert(anotherF(4));
}
function factorial(num){
if(num<=1){
return 1;
}
else{
return num*arguments.callee((num-1);
}
}

arguments.callee 是一个指向正在执行的函数的指针，因此可以用它来实现对函数的递归调用。

匿名函数：通过函数表达式创建的函数，例如：

var functionname = function(arg0,arg1,arg2){

//函数体

};

调用方式为functionname();

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

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

即使这个内部函数被返回了，而且是在其他的地方被调用了，但它仍然可以访问变量propertyName。之所以能够访问这个变量，是因为内部函数的作用域中包含createComparisonFunction()的作用域。

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

在函数执行过程中，为读取和写入变量的值，就需要在作用域中查找变量。例如：

function compare(value1,value2){
if(value1<value2){
return -1;
}
else if(value1>value2){
return 1;
}
else{
return 0;
}
}
}

以上代码定义了compare()函数，然后又在全局作用域中调用了它。全局执行环境的变量对象（包括this,arguments和compare）在compare（）执行环境的作用域中则处于第二位。无论什么时候在函数中访问一个变量时，就会从搜索域链中搜索具有相应名字的变量。一般来讲，当函数执行完毕后，局部活动对象就会被销毁，内存中仅保存全局作用域（全局执行环境的变量对象）。但是，闭包的情况又有所不同。

在另一个函数内部定义的函数会将包含函数（即外部函数）的活动对象添加到它的作用域链中。因此，在createComparisonFunction()函数内部定义的匿名函数的作用域链中，实际上将会包含函数createComparisonFunction()的活动对象。

var compare=createComparisonFunction("name");
var result=compare({name:"Nicholas"},{name:"Greg"});

重要的是，当createComparisonFunction()函数执行完毕后，其活动对象也不会被销毁，因为匿名函数的作用域仍在引用这个活动对象。换句话说，当createComparisonFunction()函数返回后，其执行环境的作用域会被销毁，但它的活动对象仍然会留在内存中；直到匿名函数被销毁后，createComparisonFunction()的活动对象才会被销毁。

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

由于闭包会携带包含它的函数的作用域，因此会比其他函数占用更多的内存。过度使用闭包可能会导致占用内存过多。

作用链的这种配置机制引出了一个值得注意的副作用，即闭包只能取得包含函数中任何变量的最后一个值。

<html>
<head>
<script type="text/javascript">
function createFunctions(){
var result=new Array();
for(var i=0;i<10;i++){
result[i]=function(){
return i;
}
}
return result;

}
function test(){
var result=createFunctions();
for(var i=0;i<10;i++){
alert(result[i]());//10,10,10,10,10,10,10,10,10,10
}
}
</script>
</head>
<body>
<button onclick="test();">hhhh</button>
</body>
</html>

因为result[i]()函数的作用域中都保存这createFunctions()函数的活动对象，所以它们引用的都是最后一个变量i。因而，每个函数内部i的值均为10。

但是，我们可以通过创建另一个匿名函数强制让闭包行为符合预期。

<html>
<head>
<script type="text/javascript">
function createFunctions(){
var result=new Array();
for(var i=0;i<10;i++){
result[i]=function(num){
return function(){
return num;
}
}(i);
}
return result;

}
function test(){
var result=createFunctions();
for(var i=0;i<10;i++){
alert(result[i]());//0,1,2,3,4,5,6,7,8,9
}
}
</script>
</head>
<body>
<button onclick="test();">hhhh</button>
</body>
</html>

在调用每个匿名函数的时候，传入变量i。由于函数参数是按值传递的，所以就会将变量i的值复制给参数num。而在这个匿名函数内部，又创建并且返回了一个访问num的闭包。这样一来，result数组中的每个函数都保存num变量的一个副本，因此就可以返回各自不同的数值了。

相当于在一个闭包函数内部又定义了一个闭包函数，最内层的闭包函数访问的是它外层的闭包函数的变量num。通过函数参数按值传递的特性，使得result数组中的每个函数都保存num变量的一个副本。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航