1
2
3
4
|
function add(num1,num2){
var sum=num1+num2;
return sum;
} |
在这个函数内部,有3个私有变量:num1、num2和sum。如果在这个函数内部创建一个闭包,那么闭包通过自己的作用域链也可以访问这些变量,利用这一点,就可以创建用于访问私有变量的公用方法。
我们把有权访问私有变量和私有函数的公有方法叫做特权方法。
1.构造函数定义法
有两种在对象上创建特权方法的方式。第一种是在构造函数中定义特权方法,基本模式如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
function myobject (){
//私有属性和私有函数
var privateVariable=10;
function privatevateFunction(){
return false ;
}
//特权方法
this .publicMethod= function (){
privateVariable++;
return privatevateFunction();
};
} |
这个模式在函数内部定义了所有私有变量和函数。然后,又继续创建了能够访问这些私有成员的特权方法。能够在构造函数中定义特权方法,是因为特权方法作为闭包有权访问在构造函数中的所有变量和函数。
利用私有和特权方法,可以隐藏那些不该被直接修改的数据,例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
function Persom(name){
this .getName= function (){
return name;
};
this .setName= function (value){
name=value;
};
} var person= new Person( "zxj" );
alert(person.getName()); //zxj
person.setName( "Greg" );
alert(person.getName()); //Greg
|
在以上构造函数中定义了两个特权方法:getName()和setName()。这两个方法都可以在函数外部使用,而且都有权访问私有变量name。
构造函数定义法,也是构造函数,构造函数有的缺点,它同样也存在。
2.静态私有变量
通过在私有作用域中定义私有变量或函数,同样也可以创建特权方法,基本模式如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
( function (){
//私有变量和私有函数
var privateVariable=10;
function privareFunction(){
return false ;
};
//构造函数
MyObject= function (){
};
//公有/特权方法
MyObject.prototype.publicMethod= function (){
privateVariable++;
privareFunction();
};
}
)() |
这 个模式创建了一个私有作用域,并在其中封装了一个构造函数级相应的方法。在私有作用域中,首先定义了私有变量和私有函数,然后定义了一个构造函数及其公有 方法。公有方法是在原型上定义的,这一点体现了典型的原型模式。需要注意的是,这个模式在定义构造函数是并没有使用函数声明,而是使用的函数表达式。函数 声明只能创建局部函数,出于相同原因,在声明MyObject时也没使用var.记住:初始化未经声明的变量,总会创建一个全局变量。因此,MyObject就成了全局变量,能够在私有作用域之外被访问。
与构造函数定义特权的区别在于:私有变量和函数是由实例共享的。由于特权方法是在原型上定义的,因此所有实例都使用同一个函数。而这个特权方法,作为闭包,总是保存着对包含作用域的引用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
( function (){
var name = "" ;
Person = function (value){
name = value;
};
Person.prototype.getName = function (){
return name;
};
Person.prototype.setName = function (value){
name = value;
};
})(); var person1 = new Person( "zxj" );
alert(person1.getName()); //"zxj"
person1.setName( "Greg" );
alert(person1.getName()); //"Greg"
var person2 = new Person( "Michael" );
alert(person1.getName()); //"Michael"
alert(person2.getName()); //"Michael"
|
一这种方式创建静态私有变量会因为使用原型而增进代码的复用,但每个实例都没有自己的私有变量。到底使用实例变量还是静态私有变量,最终还是有具体业务决定。
3.模块模式
前面模式用于自定义类型创建私有变量和特权方法。
模块模式是为单例创建私有变量和特权方法,单例就是指,只有一个实例的对象。
JavaScript是以对象字面量的方式创建单例对象的。
1
2
3
4
5
6
|
var singlton={
name:value,
method: function {
//这是方法的代码
}
} |
模块模式通过单例添加私有变量和特权放哪广发能够使其得到增强,基本形式如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
var singlton= function {
//私有变量和私有函数
var privateVaiable= 10 ;
function privateMethod(){
return false ;
};
//公有/特权方法
return {
publicProperty: true ,
piblicMethod: function (){
privateVaiable++;
return privateMethod();
}
}
}(); |
这 个模块使用了一个返回对象的匿名函数。在这个匿名函数内部,首先定义了私有变量和函数。然后,将一个对象字面量作为函数的值返回。返回的对象字面量中只包 含可以公开的属性和方法。由于这个对象是在匿名函数内部定义的,因此它的公有方法有权访问私有变量和函数。从本质上讲,这个对象字面量定义的是单例的公共 接口。这种模式在需要对单例进行某些初始化,同时有需要维持其私有变量时是非常有用的,如
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
function BaseComponent(){
} function OtherComponent(){
} 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);
}
}
};
}(); application.registerComponent( new OtherComponent());
alert(application.getComponentCount()); //2
|
这 个简单的例子创建了一个用于管理组件的application对象。在创建这个对象的过程中,首先声明了一个私有的components数组,并向数组中 添加一个BaseComponent的新实例(这里不需要关心BaseComponent的代码,我们只是用他来展示初始化操作)。而返回对象的 getComponentCount()和registerComponent ()方法,都有权访问数组components的特权方法。前者只是发那 个会已注册的组件数目,后则用于注册新组件。
一这种模式创建的每一个单例都是Object的实例,因为最终要通过一个对象字面量来表示它。单例通常都是作为全局对象存在的。
4.增强的模块模式
增强的模块模式适合那些单例必须是某种类型的实例,同时还必须添加某些属性或(和)方法对齐加以增强的情况。如下所示:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
var singlton= function {
//私有变量和私有函数
var privateVaiable=10;
function privateMethod(){
return false ;
};
//创建对象
var object= new CustomType();
//公有/特权方法
object.publicProperty= true ;
object.piblicMethod= function (){
privateVaiable++;
return privateMethod();
};
//返回这个对象
return object;
}(); |
如果前面演示模块模式的例子中的application对象必须是BaseComponent的实例,我们可以使用一下代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
function BaseComponent(){
} function OtherComponent(){
} 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;
}(); alert(application instanceof BaseComponent);
application.registerComponent( new OtherComponent());
alert(application.getComponentCou |
相关推荐
匿名函数,也称为拉姆达函数,是一种使用JavaScript函数的强大方式。以下总结了匿名函数的特点: 任何函数表达式从技术上说都是匿名函数,因为没有引用它们的确定的方式; 在无法确定如何引用函数的情况下,递归...
匿名函数 闭包 变量作用域 函数外部访问函数内部的局部变量 用闭包实现私有成员 引入 闭包是用匿名函数来实现。闭包就是一个受到保护的变量空间,由内嵌函数生成。“保护变量”的思想在几乎所有的编程语言中都...
通过定义一个匿名函数,创建了一个“私有”的命名空间,该命名空间的变量和方法,不会破坏全局的命名空间。这点非常有用也是一个 JS 框架必须支持的功能,jQuery 被应用在成千上万的 JavaScript 程序中,必须确保 ...
主要涉及函数表达式的特征、闭包和私有变量等内容。 二.匿名函数 我们知道创建一个函数有两种方法: //函数声明 function function1(a,b,c){ ...... } //函数表达式 var function1 = funcition(a,b,c)...
模块化编程是一种非常常见Javascript...我们将简单地创建一个匿名函数并立即执行它。所有的代码将跑在这个函数内,生存在一个提供私有化的闭包中,它足以使得这些闭包中的变量能够贯穿我们的应用的整个生命周期。 代
1. 总体架构 1.1 自调用匿名函数 self-invoking ... 通过定义一个匿名函数,创建了一个“私有”的命名空间,该命名空间的变量和方法,不会破坏全局的命名空间。这点非常有用也是一个JS框架必须支持的功能,jQuery被
补充: 闭包(closure)是Javascript语言的一个难点,也是它的特色,很多高级应用都要依靠闭包...闭包是javascript语言的一大特点,主要应用闭包场合主要是为了:设计私有的方法和变量。 一般函数执行完毕后,局部活动
何为闭包,所谓闭包就是在一个函数内创建一个新函数,通过这个函数来调用... return function(a){//使用匿名函数实现局部变量驻留内存中,从而实现累加 return a++; }; } var fun = out(); fun();// 1