JavaScript 是一种非常灵活的面向对象程序设计语言，它与传统的强类型的面向对象程序设计语言（如 C++，Java，C# 等）有很大不同，所以要实现如 C++、java、C# 当中的一些特性就需要换一种思考方式来解决。今天主要讨论如何在 JavaScript 脚本中实现数据的封装（encapsulation）。

数据封装说的简单点就是把不希望调用者看见的内容隐藏起来。它是面向对象程序设计的三要素之首，其它两个是继承和多态，关于它们的内容在后面再讨论。

关于数据封装的实现，在 C++、Java、C# 等语言中是通过 public、private、static 等关键字实现的。在 JavaScript 则采用了另外一种截然不同的形式。在讨论如何具体实现某种方式的数据封装前，我们先说几个简单的，大家所熟知却又容易忽略的 JavaScript 的概念。

1 几个基本概念

1.1 变量定义

在 JavaScript 语言中，是通过 var 关键字来定义变量的。

但是如果我们直接给一个没有使用 var 定义的变量赋值，那么这个变量就会成为全局变量。

一般情况下，我们应该避免使用没有用 var 定义的变量，主要原因是它会影响程序的执行效率，因为存取全局变量速度比局部变量要慢得多。

但是这种用法可以保证我们的变量一定是全局变量。

另外，为了保证速度，我们在使用全局变量时，可以通过 var 定义一个局部变量，然后将全局变量赋予之，由此可以得到一个全局变量的局部引用。

1.2 变量类型

没有定义的变量，类型为 undefined。

变量的值可以是函数。

函数在 JavaScript 中可以充当类的角色。

1.3 变量作用域

变量作用域是指变量生存周期的有效范围。

单纯用 { } 创建的块不能创建作用域。

with 将它包含的对象作用域添加到当前作用域链中，但 with 不创建新的作用域。with 块结束后，会将对象作用域从当前作用域链中删除。

try-catch 中，catch 的错误对象只在 catch 块中有效，但 catch 块中定义的变量属于当前作用域。

其它如 if、for、for-in、while、do-while、switch 等控制语句创建的块不能创建作用域。

用 function 创建的函数，会创建一个新的作用域添加到当前作用域中。

2 封装

下面我们就来讨论具体的封装。首先说一下大家最熟悉的几种封装：私有实例成员、公有实例成员和公有静态成员。最后会讨论一下大家所不熟悉的私有静态成员和静态类的封装办法。因为下面要讨论的是面向对象编程，所有当函数作为类来定义和使用时，我们暂且将其成为类。

2.1 私有实例成员

私有实例成员在 JavaScript 中实际上可以用函数内的局部变量来实现，它相当于类的私有实例成员。例如：

  1. class1 = function() {
  2.     // private fields
  3.     var m_first = 1;
  4.     var m_second = 2;
  5.     // private methods
  6.     function method1() {
  7.         alert(m_first);
  8.     }
  9.     var method2 = function() {
  10.         alert(m_second);
  11.     }
  12.     // constructor
  13.     {
  14.         method1();
  15.         method2();
  16.     }
  17. }
  18. var o = new class1();
  19. // error
  20. alert(o.m_first);
  21. o.method1();

这里 m_first 和 m_second 是 class1 的两个私有实例字段，method1 和 method2 是两个私有实例方法。他们只能在该类的对象内部被使用，在对象外无法使用。

这里大家会发现创建私有方法有两种方式，一种是直接在类中定义方法，另一种是先定义一个局部变量（私有实例字段），然后定义一个匿名方法赋值给它。

直接在类中定义方法，则该方法的作用域就是这个类，因此这个方法在此类外不能够被访问，而它又可以存取类中所有的私有实例字段，这就保证了这是个私有实例方法。

第二种创建私有实例方法的方式跟第一种方式的效果是一样的，但是第二种方式更灵活一些。

你应该还会注意到，class1 中把构造器代码用 { } 括起来了，这样做虽然没有必要，但是代码看上去更加清晰。

关于这段构造器代码，还有两点需要说明的地方：

1、构造器代码必须放在整个类定义的最后，这样做是为了保证在它当中被调用的方法都已经被定义了。因为 JavaScript 是解释型语言，所以，它会按照从上到下的顺序执行，因此，如果构造器代码放在其它方法定义的前面，则执行到调用语句时找不到要调用的方法，就会出错。

2、我们已经知道 { } 创建的块不会改变作用域，因此如果在这样的构造器代码中创建局部变量，实际上是在整个类中创建私有实例成员，所以，如果需要用到局部变量，应当定义一个私有实例方法，例如可以命名为 constructor()，在 constructor() 这个私有实例方法中定义局部变量和原来 { } 构造器中要执行的代码，然后在类的最后直接调用它就可以了。所以更好的写法是这样的：

  1. class1 = function() {
  2.     // private fields
  3.     var m_first = 1;
  4.     var m_second = 2;
  5.     // private methods
  6.     function constructor() {
  7.         method1();
  8.         method2();
  9.     }
  10.     function method1() {
  11.         alert(m_first);
  12.     }
  13.     var method2 = function() {
  14.         alert(m_second);
  15.     }
  16.     constructor.call(this);
  17. }
  18. var o = new class1();
  19. // error
  20. alert(o.m_first);
  21. o.method1();

最后，你可能还会发现 class1 的定义我们没有用 var，这样做我们就可以保证它是个全局的类了。

2.2 公有实例成员

公有实例成员可以通过两种方式来创建，我们先来看下面这个例子：

  1. class2 = function() {
  2.     // private fields
  3.     var m_first = 1;
  4.     var m_second = 2;
  5.     // private methods
  6.     function method1() {
  7.         alert(m_first);
  8.     }
  9.     var method2 = function() {
  10.         alert(m_second);
  11.     }
  12.     // public fields
  13.     this.first = "first";
  14.     this.second = ['s','e','c','o','n','d'];
  15.  
  16.     // public methods
  17.     this.method1 = method2;
  18.  
  19.     this.method2 = function() {
  20.         alert(this.second);
  21.     }
  22.  
  23.     // constructor
  24.     {
  25.         method1();
  26.         method2();
  27.     }
  28. }
  29. // public method
  30. class1.prototype.method3 = function() {
  31.     alert(this.first);
  32. }
  33.  
  34. var o = new class2();
  35.  
  36. o.method1();
  37. o.method2();
  38. o.method3();
  39. alert(o.first);

我们发现这个例子是在 class1 的例子上做了一些补充。给它添加了公有实例字段和公有实例方法，我们把它们通称为公有实例成员。

我们应该已经发现，创建公有实例成员其实很简单，一种方式是通过在类中给 this.memberName 来赋值，如果值是函数之外的类型，那就是个公有实例字段，如果值是函数类型，那就是公有实例方法。另外一种方式则是通过给 className.prototype.memberName 赋值，可赋值的类型跟 this.memberName 是相同的。

到底是通过 this 方式定义好呢，还是通过 prototype 方式定义好呢？

其实它们各有各的用途，它们之间不是谁比谁更好的关系。在某些情况下，我们只能用其中特定的一种方式来定义公有实例成员，而不能够使用另一种方式。原因在于它们实际上是有区别的：

1、prototype 方式只应该在类外定义。this 方式只能在类中定义。

2、prototype 方式如果在类中定义时，则存取私有实例成员时，总是存取最后一个对象实例中的私有实例成员。

3、prototype 方式定义的公有实例成员是创建在类的原型之上的成员。this 方式定义的公有实例成员，是直接创建在类的实例对象上的成员。

基于前两点区别，我们可以得到这样的结论：如果要在公有实例方法中存取私有实例成员，那么必须用 this 方式定义。

关于第三点区别，我们后面在讨论继承时再对它进行更深入的剖析。这里只要知道有这个区别就可以了。

我们还会发现，公有实例成员和私有实例成员名字是可以相同的，这样不会有冲突吗？

当然不会。原因在于它们的存取方式不同，公有实例成员在类中存取时，必须要用 this. 前缀来引用。而私有实例成员在类中存取时，不使用也不能够使用 this. 前缀来存取。而在类外存取时，只有公有成员是可以通过类的实例对象存取的，私有成员无法存取。

2.3 公有静态成员

公有静态成员的定义很简单，例如：

  1. class3 = function() {
  2.     // private fields
  3.     var m_first = 1;
  4.     var m_second = 2;
  5.     // private methods
  6.     function method1() {
  7.         alert(m_first);
  8.     }
  9.     var method2 = function() {
  10.         alert(m_second);
  11.     }
  12.     // constructor
  13.     {
  14.         method1();
  15.         method2();
  16.     }
  17. }
  18.  
  19. // public static field
  20. class3.field1 = 1;
  21.  
  22. // public static method
  23. class3.method1 = function() {
  24.     alert(class3.field1);
  25. }
  26.  
  27. class3.method1();

这个例子的 class3 跟 class1 很像。不同的是 class3 的外面，我们又给 class3 定义了一个静态字段和静态方法。

定义的方式就是给 className.memberName 直接赋值。

这里定义的静态字段和静态方法都是可以被直接通过类名引用来存取的，而不需要创建对象。因此它们是公有静态成员。

不过有点要记住，一定不要将公有静态成员定义在它所在的类的内部，否则你会得到非你所期望的结果。我们可以看下面这个例子：

  1. class4 = function() {
  2.     // private fields
  3.     var m_first = 1;
  4.     var m_second = 2;
  5.  
  6.     var s_second = 2;
  7.  
  8.     // private methods
  9.     function method1() {
  10.         alert(m_first);
  11.     }
  12.     var method2 = function() {
  13.         alert(m_second);
  14.     }
  15.     class4.method1 = function() {
  16.         s_second++;
  17.     }
  18.     class4.method2 = function() {
  19.         alert(s_second);
  20.     }
  21. }
  22. var o1 = new class4();
  23. class4.method2();          // 2
  24. class4.method1();
  25. class4.method2();          // 3
  26. var o2 = new class4();
  27. class4.method2();          // 2
  28. class4.method1();
  29. class4.method2();          // 3

这个例子中，我们期望 s_second 能够扮演一个私有静态成员的角色，但是输出结果却不是我们所期望的。我们会发现 s_second 实际上是 class4 的一个私有实例成员，而不是私有静态成员。而 class4 的 method1 和 method2 所存取的私有成员总是类的最后一个实例对象中的这个私有实例成员。

问题出在哪儿呢？

问题出在每次通过 new class4() 创建一个对象实例时，class4 中的所有语句都会重新执行，因此，s_second 被重置，并成为新对象中的一个私有实例成员。而 class4.method1 和 class4.method2 也被重新定义了，而这个定义也将它们的变量作用域切换到了最后一个对象上来。这与把通过 prototype 方式创建的公有实例方法定义在类的内部而产生的错误是一样的。

所以，一定不要将公有静态成员定义在它所在的类的内部！也不要把通过 prototype 方式创建的公有实例方法定义在类的内部！

那如何定义一个私有静态成员呢？

2.4 私有静态成员

前面在基本概念里我们已经清楚了，只有用 function 创建函数，才能创建一个新的作用域，而要创建私有成员（不论是静态成员，还是实例成员），都需要通过创建新的作用域才能够起到数据隐藏的目的。下面所采用的方法就是基于这一点来实现的。

实现私有静态成员是通过创建一个匿名函数函数来创建一个新的作用域来实现的。

通常我们使用匿名函数时都是将它赋值给一个变量，然后通过这个变量引用该匿名函数。这种情况下，该匿名函数可以被反复调用或者作为类去创建对象。而这里，我们创建的匿名函数不赋值给任何变量，在它创建后立即执行，或者立即实例化为一个对象，并且该对象也不赋值给任何变量，这种情况下，该函数本身或者它实例化后的对象都不能够被再次存取，因此它唯一的作用就是创建了一个新的作用域，并隔离了它内部的所有局部变量和函数。因此，这些局部变量和函数就成了我们所需要的私有静态成员。而这个立即执行的匿名函数或者立即实例化的匿名函数我们称它为静态封装环境。

下面我们先来看通过直接调用匿名函数方式来创建带有私有静态成员的类的例子：

  1. class5 = (function() {
  2.     // private static fields
  3.     var s_first = 1;
  4.     var s_second = 2;
  5.  
  6.     // private static methods
  7.     function s_method1() {
  8.         s_first++;
  9.     }
  10.     var s_second = 2;
  11.  
  12.     function constructor() {
  13.         // private fields
  14.         var m_first = 1;
  15.         var m_second = 2;
  16.  
  17.         // private methods
  18.         function method1() {
  19.             alert(m_first);
  20.         }
  21.         var method2 = function() {
  22.             alert(m_second);
  23.         }
  24.  
  25.         // public fields
  26.         this.first = "first";
  27.         this.second = ['s','e','c','o','n','d'];
  28.  
  29.         // public methods
  30.         this.method1 = function() {
  31.             s_second--;
  32.         }
  33.  
  34.         this.method2 = function() {
  35.             alert(this.second);
  36.         }
  37.  
  38.         // constructor
  39.         {
  40.             s_method1();
  41.             this.method1();
  42.         }
  43.     }
  44.     // public static methods
  45.     constructor.method1 = function() {
  46.         s_first++;
  47.         alert(s_first);
  48.     }
  49.     constructor.method2 = function() {
  50.         alert(s_second);
  51.     }
  52.  
  53.     return constructor;
  54. })();
  55.  
  56. var o1 = new class5();
  57. class5.method1();
  58. class5.method2();
  59. o1.method2();
  60. var o2 = new class5();
  61. class5.method1();
  62. class5.method2();
  63. o2.method2();

这个例子中，通过

  1. (function() {
  2.     ...
  3.     function contructor () {
  4.         ...
  5.     }
  6.     return constructor;
  7. })();

来创建了一个静态封装环境，实际的类是在这个环境中定义的，并且在最后通过 return 语句将最后的类返回给我们的全局变量 class5，然后我们就可以通过 class5 来引用这个带有静态私有成员的类了。

为了区分私有静态成员和私有实例成员，我们在私有静态成员前面用了 s_ 前缀，在私有实例成员前面加了 m_ 前缀，这样避免了重名，因此在对象中总是可以存取私有静态成员的。

但是这种命名方式不是必须的，只是推荐的，私有静态成员可以跟私有实例成员同名，在重名的情况下，在类构造器和在类中定义的实例方法中存取的都是私有实例成员，在静态方法（不论是公有静态方法还是私有静态方法）中存取的都是私有静态成员。

在类外并且在静态封装环境中通过 prototype 方式定义的公有实例方法存取的是私有静态成员。

在静态封装环境外定义的公有静态方法和通过 prototype 方式定义的公有实例方法无法直接存取私有静态成员。

另外一种方式通过直接实例化匿名函数方式来创建带有私有静态成员的类的例子跟上面的例子很相似：

  1. new function() {
  2.     // private static fields
  3.     var s_first = 1;
  4.     var s_second = 2;
  5.  
  6.     // private static methods
  7.     function s_method1() {
  8.         s_first++;
  9.     }
  10.     var s_second = 2;
  11.  
  12.     class6 = function() {
  13.         // private fields
  14.         var m_first = 1;
  15.         var m_second = 2;
  16.  
  17.         // private methods
  18.         function method1() {
  19.             alert(m_first);
  20.         }
  21.         var method2 = function() {
  22.             alert(m_second);
  23.         }
  24.  
  25.         // public fields
  26.         this.first = "first";
  27.         this.second = ['s','e','c','o','n','d'];
  28.  
  29.         // public methods
  30.         this.method1 = function() {
  31.             s_second--;
  32.         }
  33.  
  34.         this.method2 = function() {
  35.             alert(this.second);
  36.         }
  37.  
  38.         // constructor
  39.         {
  40.             s_method1();
  41.             this.method1();
  42.         }
  43.     }
  44.     // public static methods
  45.     class6.method1 = function() {
  46.         s_first++;
  47.         alert(s_first);
  48.     }
  49.     class6.method2 = function() {
  50.         alert(s_second);
  51.     }
  52. };
  53.  
  54. var o1 = new class6();
  55. class6.method1();
  56. class6.method2();
  57. o1.method2();
  58. var o2 = new class6();
  59. class6.method1();
  60. class6.method2();
  61. o2.method2();

这个例子的结果跟通过第一种方式创建的例子是相同的。只不过它的静态封装环境是这样的：

  1. new function() {
  2.    ...
  3. };

在这里，该函数没有返回值，并且对于 class5 的定义是直接在静态封装环境内部通过给一个没有用 var 定义的变量赋值的方式实现的。

当然，也完全可以在

  1. (function() {
  2.    ...
  3. })();

这种方式中，不给该函数定义返回值，而直接在静态封装环境内部通过给一个没有用 var 定义的变量赋值的方式来实现带有私有静态成员的类的定义。

这两种方式在这里是等价的。

2.5 静态类

所谓的静态类，是一种不能够被实例化，并且只包含有静态成员的类。

在 JavaScript 中我们通过直接实例化一个匿名函数的对象，就可以实现静态类了。例如：

  1. class7 = new function() {
  2.     // private static fields
  3.     var s_first = 1;
  4.     var s_second = 2;
  5.     // private static method
  6.     function method1() {
  7.         alert(s_first);
  8.     }
  9.     // public static method
  10.     this.method1 = function() {
  11.         method1();
  12.         alert(s_second);
  13.     }
  14. }
  15. class7.method1();

大家会发现，class7 其实就是个对象，只不过这个对象所属的是匿名类，该类在创建完 class7 这个对象后，就不能再被使用了。而 class7 不是一个 function，所以不能够作为一个类被实例化，因此，这里它就相当于一个静态类了。