자바스크립트 객체지향 새로운 데이터 캡슐화

오늘은 주로 JavaScript 스크립트에서 데이터 캡슐화를 구현하는 방법에 대해 논의합니다.
데이터 캡슐화는 단순히 호출자에게 표시하고 싶지 않은 콘텐츠를 숨기는 것을 의미합니다. 이는 객체 지향 프로그래밍의 세 가지 요소 중 첫 번째 요소이며 나머지 두 가지는 상속과 다형성입니다.
데이터 캡슐화 구현은 C++, Java, C# 및 기타 언어에서 public, private, static 등의 키워드를 통해 구현됩니다. JavaScript에서는 완전히 다른 형식을 취합니다. 특정 형태의 데이터 캡슐화를 구현하는 방법을 논의하기 전에 먼저 잘 알려져 있지만 쉽게 간과되는 몇 가지 간단한 JavaScript 개념에 대해 이야기해 보겠습니다.
1 몇 가지 기본 개념
1.1 변수 정의
자바스크립트 언어에서 변수는 var 키워드를 통해 정의됩니다.
그러나 var를 사용하여 정의되지 않은 변수에 직접 값을 할당하면 이 변수는 전역 변수가 됩니다.
일반적으로 var로 정의되지 않은 변수의 사용은 피해야 합니다. 주된 이유는 전역 변수에 대한 액세스가 로컬 변수에 비해 훨씬 느리기 때문에 프로그램의 실행 효율성에 영향을 미치기 때문입니다.
그러나 이 사용법을 사용하면 변수가 전역 변수여야 함을 보장할 수 있습니다.
또한 속도를 보장하기 위해 전역 변수를 사용할 때 var를 통해 지역 변수를 정의한 후 여기에 전역 변수를 할당함으로써 전역 변수의 로컬 참조를 얻을 수 있습니다.
1.2 변수 유형
정의되지 않은 변수는 정의되지 않은 유형을 갖습니다.
변수의 값은 함수일 수 있습니다.
함수는 JavaScript에서 클래스 역할을 할 수 있습니다.
1.3 변수 범위
변수 범위는 변수 수명주기의 유효 범위를 의미합니다.
단순히 { }로 생성된 블록은 범위를 생성할 수 없습니다.
with는 현재 범위 체인에 포함된 개체의 범위를 추가하지만 새 범위를 생성하지는 않습니다. with 블록이 끝나면 개체 범위가 현재 범위 체인에서 제거됩니다.
try-catch에서 catch의 오류 개체는 catch 블록에서만 유효하지만 catch 블록에 정의된 변수는 현재 범위에 속합니다.
if, for, for-in, while, do-while, switch 등과 같은 다른 제어문으로 생성된 블록은 범위를 생성할 수 없습니다.
함수로 생성된 함수는 새로운 범위를 생성하여 현재 범위에 추가합니다.
2개의 포장
구체적인 포장에 대해 논의해 보겠습니다. 먼저 가장 친숙한 캡슐화인 프라이빗 인스턴스 멤버, 퍼블릭 인스턴스 멤버, 퍼블릭 정적 멤버에 대해 이야기해 보겠습니다. 마지막으로 누구에게나 생소한 private static 멤버와 static 클래스의 캡슐화 방법에 대해 논의하겠습니다. 아래에서 논의할 내용은 객체지향 프로그래밍이므로, 함수를 클래스로 정의하여 사용하는 경우 임시로 클래스라고 부르도록 하겠습니다.
2.1 프라이빗 인스턴스 멤버
JavaScript의 프라이빗 인스턴스 멤버는 실제로 클래스의 프라이빗 인스턴스 멤버와 동일한 함수 내 지역 변수를 사용하여 구현할 수 있습니다. 예:

class1 = function() { 
// private fields 
var m_first = 1; 
var m_second = 2; 
// private methods 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 
// constructor 
{ 
method1(); 
method2(); 
} 
} 
var o = new class1(); 
// error 
alert(o.m_first); 
o.method1();

여기서 m_first와 m_second는 class1의 두 개의 프라이빗 인스턴스 필드이고, method1과 method2는 두 개의 프라이빗 인스턴스 메서드입니다. 이 클래스의 객체 내부에서만 사용할 수 있으며 객체 외부에서는 사용할 수 없습니다.
여기서 프라이빗 메소드를 생성하는 방법에는 두 가지가 있습니다. 하나는 클래스에서 직접 메소드를 정의하는 것이고, 다른 하나는 먼저 지역 변수(프라이빗 인스턴스 필드)를 정의한 다음 익명 메소드를 정의하는 것입니다. 그것을 할당합니다.
클래스에서 직접 메소드를 정의하는 경우 메소드의 범위는 이 클래스이므로 이 메소드는 이 클래스 외부에서 액세스할 수 없으며 클래스의 모든 비공개 인스턴스 필드에 액세스할 수 있습니다. 인스턴스 메소드.
프라이빗 인스턴스 메서드를 만드는 두 번째 방법은 첫 번째 방법과 효과는 동일하지만 두 번째 방법이 더 유연합니다.
또한 class1의 생성자 코드가 { }로 묶여 있다는 점에 주목해야 합니다. 비록 이것이 필요하지는 않지만 코드가 더 명확해 보입니다.
이 생성자 코드에 대해 설명해야 할 두 가지 사항이 있습니다.
1. 생성자 코드는 전체 클래스 정의의 끝에 배치되어야 합니다. 한정된. 자바스크립트는 해석형 언어이기 때문에 위에서 아래로 순서대로 실행되므로 생성자 코드가 다른 메서드 정의 앞에 배치되면 호출하는 문이 실행될 때 호출할 메서드를 찾을 수 없습니다. 잘못되었습니다.
2. { }에 의해 생성된 블록은 범위를 변경하지 않는다는 것을 이미 알고 있으므로 이러한 생성자 코드에서 지역 변수를 생성하면 실제로 전체 클래스에 비공개 인스턴스 멤버가 생성되므로 로컬 변수의 경우 프라이빗 인스턴스 메서드를 정의해야 합니다. 예를 들어 constructor()의 프라이빗 인스턴스 메서드에서 로컬 변수와 원본에서 실행할 코드를 정의합니다. } 생성자를 만든 다음 클래스 끝에서 직접 호출하면 됩니다. 따라서 이를 작성하는 더 좋은 방법은 다음과 같습니다.

class1 = function() { 
// private fields 
var m_first = 1; 
var m_second = 2; 
// private methods 
function constructor() { 
method1(); 
method2(); 
} 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 
constructor(); 
} 
var o = new class1(); 
// error 
alert(o.m_first); 
o.method1();

最后，你可能还会发现 class1 的定义我们没有用 var，这样做我们就可以保证它是个全局的类了。 
2.2 公有实例成员 
公有实例成员可以通过两种方式来创建，我们先来看下面这个例子： 

class2 = function() { 
// private fields 
var m_first = 1; 
var m_second = 2; 
// private methods 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 
// public fields 
this.first = "first"; 
this.second = ['s','e','c','o','n','d']; 

// public methods 
this.method1 = method2; 

this.method2 = function() { 
alert(this.second); 
} 
// constructor 
{ 
method1(); 
method2(); 
} 
} 
// public method 
class1.prototype.method3 = function() { 
alert(this.first); 
} 

var o = new class2(); 

o.method1(); 
o.method2(); 
o.method3(); 
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 公有静态成员 
公有静态成员的定义很简单，例如： 

class3 = function() { 
// private fields 
var m_first = 1; 
var m_second = 2; 
// private methods 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 
// constructor 
{ 
method1(); 
method2(); 
} 
} 

// public static field 
class3.field1 = 1; 

// public static method 
class3.method1 = function() { 
alert(class3.field1); 
} 

class3.method1();

这个例子的 class3 跟 class1 很像。不同的是 class3 的外面，我们又给 class3 定义了一个静态字段和静态方法。 
定义的方式就是给 className.memberName 直接赋值。 
这里定义的静态字段和静态方法都是可以被直接通过类名引用来存取的，而不需要创建对象。因此它们是公有静态成员。 
不过有点要记住，一定不要将公有静态成员定义在它所在的类的内部，否则你会得到非你所期望的结果。我们可以看下面这个例子： 

class4 = function() { 
// private fields 
var m_first = 1; 
var m_second = 2; 

var s_second = 2; 

// private methods 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 
class4.method1 = function() { 
s_second++; 
} 
class4.method2 = function() { 
alert(s_second); 
} 
} 
var o1 = new class4(); 
class4.method2(); // 2 
class4.method1(); 
class4.method2(); // 3 
var o2 = new class4(); 
class4.method2(); // 2 
class4.method1(); 
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 创建函数，才能创建一个新的作用域，而要创建私有成员（不论是静态成员，还是实例成员），都需要通过创建新的作用域才能够起到数据隐藏的目的。下面所采用的方法就是基于这一点来实现的。 
实现私有静态成员是通过创建一个匿名函数函数来创建一个新的作用域来实现的。 
通常我们使用匿名函数时都是将它赋值给一个变量，然后通过这个变量引用该匿名函数。这种情况下，该匿名函数可以被反复调用或者作为类去创建对象。而这里，我们创建的匿名函数不赋值给任何变量，在它创建后立即执行，或者立即实例化为一个对象，并且该对象也不赋值给任何变量，这种情况下，该函数本身或者它实例化后的对象都不能够被再次存取，因此它唯一的作用就是创建了一个新的作用域，并隔离了它内部的所有局部变量和函数。因此，这些局部变量和函数就成了我们所需要的私有静态成员。而这个立即执行的匿名函数或者立即实例化的匿名函数我们称它为静态封装环境。 
下面我们先来看通过直接调用匿名函数方式来创建带有私有静态成员的类的例子： 

class5 = (function() { 
// private static fields 
var s_first = 1; 
var s_second = 2; 

// private static methods 
function s_method1() { 
s_first++; 
} 
var s_second = 2; 

function constructor() { 
// private fields 
var m_first = 1; 
javascript面向对象全新理练（二） 
var m_second = 2; 

// private methods 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 

// public fields 
this.first = "first"; 
this.second = ['s','e','c','o','n','d']; 

// public methods 
this.method1 = function() { 
s_second--; 
} 

this.method2 = function() { 
alert(this.second); 
} 

// constructor 
{ 
s_method1(); 
this.method1(); 
} 
} 
// public static methods 
constructor.method1 = function() { 
s_first++; 
alert(s_first); 
} 
constructor.method2 = function() { 
alert(s_second); 
} 

return constructor; 
})(); 

var o1 = new class5(); 
class5.method1(); 
class5.method2(); 
o1.method2(); 
var o2 = new class5(); 
class5.method1(); 
class5.method2(); 
o2.method2(); 
这个例子中，通过 
(function() { 
... 
function contructor () { 
... 
} 
return constructor; 
})();

来创建了一个静态封装环境，实际的类是在这个环境中定义的，并且在最后通过 return 语句将最后的类返回给我们的全局变量 class5，然后我们就可以通过 class5 来引用这个带有静态私有成员的类了。 
为了区分私有静态成员和私有实例成员，我们在私有静态成员前面用了 s_ 前缀，在私有实例成员前面加了 m_ 前缀，这样避免了重名，因此在对象中总是可以存取私有静态成员的。 
但是这种命名方式不是必须的，只是推荐的，私有静态成员可以跟私有实例成员同名，在重名的情况下，在类构造器和在类中定义的实例方法中存取的都是私有实例成员，在静态方法（不论是公有静态方法还是私有静态方法）中存取的都是私有静态成员。 
在类外并且在静态封装环境中通过 prototype 方式定义的公有实例方法存取的是私有静态成员。 
在静态封装环境外定义的公有静态方法和通过 prototype 方式定义的公有实例方法无法直接存取私有静态成员。 
另外一种方式通过直接实例化匿名函数方式来创建带有私有静态成员的类的例子跟上面的例子很相似： 

new function() { 
// private static fields 
var s_first = 1; 
var s_second = 2; 

// private static methods 
function s_method1() { 
s_first++; 
} 
var s_second = 2; 

class6 = function() { 
// private fields 
var m_first = 1; 
var m_second = 2; 

// private methods 
function method1() { 
alert(m_first); 
} 
var method2 = function() { 
alert(m_second); 
} 

// public fields 
this.first = "first"; 
this.second = ['s','e','c','o','n','d']; 

// public methods 
this.method1 = function() { 
s_second--; 
} 

this.method2 = function() { 
alert(this.second); 
} 

// constructor 
{ 
s_method1(); 
this.method1(); 
} 
} 
// public static methods 
class6.method1 = function() { 
s_first++; 
alert(s_first); 
} 
class6.method2 = function() { 
alert(s_second); 
} 
}; 

var o1 = new class6(); 
class6.method1(); 
class6.method2(); 
o1.method2(); 
var o2 = new class6(); 
class6.method1(); 
class6.method2(); 
o2.method2();

这个例子的结果跟通过第一种方式创建的例子是相同的。只不过它的静态封装环境是这样的： 
new function() { 
... 
}; 
在这里，该函数没有返回值，并且对于 class5 的定义是直接在静态封装环境内部通过给一个没有用 var 定义的变量赋值的方式实现的。 
当然，也完全可以在 
(function() { 
... 
})(); 
这种方式中，不给该函数定义返回值，而直接在静态封装环境内部通过给一个没有用 var 定义的变量赋值的方式来实现带有私有静态成员的类的定义。 
这两种方式在这里是等价的。 
2.5 静态类 
所谓的静态类，是一种不能够被实例化，并且只包含有静态成员的类。 
在 JavaScript 中我们通过直接实例化一个匿名函数的对象，就可以实现静态类了。例如： 

class7 = new function() { 
// private static fields 
var s_first = 1; 
var s_second = 2; 
// private static method 
function method1() { 
alert(s_first); 
} 
// public static method 
this.method1 = function() { 
method1(); 
alert(s_second); 
} 
} 
class7.method1();

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

更多javascript 面向对象全新理练之数据的封装相关文章请关注PHP中文网！