每日三问之javascript函数表达式之递归、闭包、私有变量

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

函数声明

function functionName(arg0, arg1, arg2) { 
 //函数体
}

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

sayHi(); 
function sayHi(){ 
 alert("Hi!"); 
}

函数表达式

var functionName = function(arg0, arg1, arg2){ 
 //函数体 
};

这种形式看起来好像是常规的变量赋值语句，即创建一个函数并将它赋值给变量 functionName 。 这种情况下创建的函数叫做匿名函数。

函数表达式与其他表达式一样，在使用前必须先赋值。以下代码会导致错误。

sayHi(); //错误：函数还不存在
var sayHi = function(){ 
 alert("Hi!"); 
};

不要这样做！

if(condition){ 
 function sayHi(){ 
 alert("Hi!"); 
 } 
} else { 
 function sayHi(){ 
 alert("Yo!"); 
 } 
}

这在 ECMAScript 中属于无效语法，大多数浏览器会返回第二个声明 ，忽略 condition；

可以这样做！

var sayHi; 
if(condition){ 
 sayHi = function(){ 
 alert("Hi!"); 
 }; 
} else { 
 sayHi = function(){ 
 alert("Yo!"); 
 }; 
}

 递归

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

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

这是一个经典的递归阶乘函数。虽然这个函数表面看来没什么问题，但下面的代码却可能导致它出错。

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

 我们知道，arguments.callee是一个指向正在执行的函数的指针，因此可以用它来实现对函数的递归调用，例如：

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

但在严格模式下，不能通过脚本访问 arguments.callee ，访问这个属性会导致错误。不过，可以使用命名函数表达式来达成相同的结果。例如：

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

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

闭包

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

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

通过将 compareNames 设置为等于 null解除该函数的引用，就等于通知垃圾回收例程将其清除。随着匿名函数的作用域链被销毁，其他作用域（除了全局作用域）也都可以安全地销毁了。

闭包与变量

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

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


表面上看，似乎每个函数都应该返自己的索引值，即位置 0 的函数返回 0，位置 1 的函数返回 1，
以此类推。但实际上，每个函数都返回 10。因为每个函数的作用域链中都保存着
 createFunctions() 函数的活动对象，所以它们引用的都是同一个变量 i 。

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

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

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

在几种特殊情况下， 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"，在非严格模式下

内存泄漏

具体来说，如果闭包的作用域链中保存着一个HTML 元素，那么就意味着该元素将无法被销毁。

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，包含函数的活动对象中也仍然会保存一个引用。因此，有必要把 element 变量设置为 null。这样就能够解除对 DOM 对象的引用，顺利地减少其引用数，确保正常回收其占用的内存。

模仿块级作用域

JavaScript 没有块级作用域的概念，匿名函数可以用来模仿块级作用域。

用作块级作用域（通常称为 私有作用域 ）的匿名函数的语法如下所示。

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

这个例子先定义了一个函数，然后立即调用了它。定义函数的方式是创建一个匿名函数，并把匿名 函数赋值给变量 someFunction 。

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

这段代码会导致语法错误，是因为 JavaScript 将 function 关键字当作一个函数声明的开始，而函 数声明后面不能跟圆括号。然而，函数表达式 的后面可以跟圆括号。要将函数声明转换成函数表达式，只要像下面这样给它加上一对圆括号即可。

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


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

无论在什么地方，只要临时需要一些变量，就可以使用私有作用域，例如：

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

私有变量

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

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

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

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

静态私有变量 

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

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

模块模式

模块模式（ 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); 
 } 
 } 
 }; 
}();

 增强的模块模式

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

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

小结

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

• 在无法确定如何引用函数的情况下，递归函数就会变得比较复杂；
• 递归函数应该始终使用 arguments.callee 来递归地调用自身，不要使用函数名——函数名可 能会发生变化。

当在函数内部定义了其他函数时，就创建了闭包。闭包有权访问包含函数内部的所有变量，原理如下。

• 在后台执行环境中，闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域。
• 通常，函数的作用域及其所有变量都会在函数执行结束后被销毁。
• 但是，当函数返回了一个闭包时，这个函数的作用域将会一直在内存中保存到闭包不存在为止。

使用闭包可以在 JavaScript 中模仿块级作用域（JavaScript 本身没有块级作用域的概念），要点如下。

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

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

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

JavaScript 中的函数表达式和闭包都是极其有用的特性，利用它们可以实现很多功能。不过，因为

创建闭包必须维护额外的作用域，所以过度使用它们可能会占用大量内存。