|
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.getComponentCount());
//2
|