在JavaScript编程中,函数表达式是一种非常有用的技术。使用函数表达式可以无须对函数命名,从而实现动态编程。
匿名函数,是一种使用JavaScript函数的强大方式。以下总结了函数表达式的特点:
1)函数表达式不同于函数声明。函数声明要求有名字,但函数表达式不需要,没有名字的函数表达式也叫匿名函数。
2)在无法确定如何函数的情况下,递归函数就会变得比较复杂;
3)递归函数应该始终使用arguments,callee来递归调用自身,不要使用函数名——函数名可能会发生变化。
当在函数内部定义了其他函数时,就创建了闭包。闭包有权访问包含函数内部的所有变量,原理如下:
1)在后台执行环境中,闭包的作用域链包含着它自己的作用域、包含函数的作用域和全局作用域。
2)通常,函数的作用域及其所有变量都会在函数执行结束后被销毁。
3)但是,当函数返回了一个闭包时,这个函数的作用域将会一直在内存中保存到闭包不存在为止。
使用闭包可以在JavaScript中模仿块级作用域(JavaScript本身没有块级作用域的概念),要点如下:
1)创建并立即调用一个函数,这样既可以执行其中的代码,又不会在内存中留下对函数的引用。
2)结果就是函数内部的所有变量都会被立即销毁——除非将某些变量赋值给了包含作用域(外部作用域)中的变量。
闭包还可以用于在对象中创建私有变量,相关概念和要点如下:
1)即使JavaScript中没有正式的私有对象属性的概念,但可以使用闭包来实现公有方法,而通多公有方法可以访问在包含作用域中定义的变量。
2)有权访问私有变量的公有方法叫做特权方法。
3)可以使用构造函数模式、原型模式来实现自定义类型的特权方法,也可以使用模块模式、增强的模块模式来实现单例的特权方法。
JavaScript中的函数表达式和闭包都是极其有用的特性,利用它们可以实现很多功能。不过,因为创建闭包必须维护额外的作用域,所以过渡使用它们可能会占用大量内存。
/*
* 函数表达式
*/
function cl(x){
console.log(x);
}
//函数声明提升
sayHi();
function sayHi(){
cl('Hi');
}
//函数表达式、匿名函数
var sayHi,result;
if(result==true){
sayHi=function(){
cl('Hi!');
}
}else{
sayHi=function(){
cl('Yo!');
}
}
//7.1 递归
function factorial(num){ //求阶乘
if(num<=1){
return 1;
}else{
// return num*factorial(num-1);
return num*arguments.callee(num-1); //arguments.callee是一个指向正在执行的函数的指针
}
}
cl(factorial(4)); //=>24
//使用命名函数表达式来达成相同的结果
var factorial2=(function f(num){
if(num<=1){
return 1;
}else{
return num*f(num-1);
}
});
cl(factorial2(5)); //=>120
//7.2 闭包
//闭包:是指有权访问另一个函数作用域中的变量的函数
//作用域链:本质上是一个指向变量对象的指针列表,它只引用但不实际包含变量对象
//在另一个函数内部定义的函数会将包含函数(即外部函数)的活动对象添加到它的作用域链中
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;
};
}
}
var compareNames=createComparisonFunction("name");//创建函数
var result=compareNames({name:"Jason"},{name:"Greg"});//调用函数
cl(result);//=>1
compareNames=null;//解除对匿名函数的引用(以便释放内存)
//7.2.1闭包与变量
//闭包只能取得包含函数中任何变量的最后一个值
function createFunctions(){
var result=new Array();
for(var i=0;i<10;i++){
result[i]=function(){
return i;
}
}
return result;
}
var functions=createFunctions();
var result0=functions[0]();
cl(result0); //=>10,而不是0
//通过创建另一个匿名函数强制让闭包的行为符合预期
function createFunctions2(){
var result=new Array();
for(var i=0;i<10;i++){
result[i]=function(num){
return function(){
return num;
}
}(i);
}
return result;
}
var functions2=createFunctions2();
var result0=functions2[0]();
cl(result0);//=>0
//7.2.2 关于this对象
var name="The Window";
var object={
name:"My Object",
getNameFunc:function(){
return function(){
return this.name;
}
}
};
cl(object.getNameFunc()()); //=>The Window
//7.2.3 内存泄露
function assignHandler(){
var element=document.getElementById("someElement");
//把element.id的一个副本保存在一个变量中,并且在闭包中引用该变量消除了循环引用
var id=element.id;
element.οnclick=function(){
cl(id);
}
//将element变量设置为null。这样能解除对dom对象的引用,顺利地减少其引用数,确保正常回收其占用的内存
element=null;
}
//7.3 模仿块级作用域
//在一个由很多开发人员共同参与的大型应用程序中,过多的全局变量和函数很容易导致命名冲突。
//通过创建私有作用域,每个开发人员既可以使用自己的变量,又不必担心搞乱全局作用域
(function(){
var now=new Date();
if(now.getMonth()==0 && now.getDate()==1){
cl("Happy new year!");
}
})();
//7.4 私有变量
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("Jason");
cl(person.getName()); //=>"Jason"
person.setName("Greg");
cl(person.getName()); //=>"Greg"
//7.4.1 静态私有变量
(function(){
//私有变量和私有函数
var privateVariable=10;
function privateFunction(){
return false;
}
//构造函数
MyObject=function(){};
//在原型上定义公有方法
MyObject.prototype.publicMethod=function(){
privateVariable++;
return privateFunction();
}
})();
(function(){
var name="";
Person2=function(value){
name=value;
};
Person2.prototype.getName=function(){
return name;
};
Person2.prototype.setName=function(value){
name=value;
};
})();
var person1=new Person2("Jason");
cl(person1.getName()); //=>"Jason"
person1.setName("Greg");
cl(person1.getName()); //=>"Greg"
var person2=new Person2("Michael");
cl(person1.getName()); //=>"Michael"
cl(person2.getName()); //=>"Michael"
//7.4.2 模块模式
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);
}
}
}
}();
//7.4.3 增强的模块模式
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;
}();