Javascript面向对象特性_javascript技巧

dom<', '/div>');

// 测试代码
var ax = new ActiveXObject("Microsoft.XMLHTTP");
var dom = document.getElementById('dom');
var vba = new VBArray(CreateVBArray());
var obj = new MyObject();
var obj2 = new MyObject2();

document.writeln(objectTypes(vba), '
');
document.writeln(objectTypes(ax), '
');
document.writeln(objectTypes(obj), '
');
document.writeln(objectTypes(obj2), '
');
document.writeln(objectTypes(dom), '
');

在这个例子中，我们发现constructor属性被实现得并不完整。对于DOM对象、ActiveX对象
来说这个属性都没有正确的返回。

确切的说，DOM（包括Image)对象与ActiveX对象都不是标准JavaScript的对象体系中的，
因此它们也可能会具有自己的constructor属性，并有着与JavaScript不同的解释。因此，
JavaScript中不维护它们的constructor属性，是具有一定的合理性的。

另外的一些单体对象(而非构造器)，也不具有constructor属性，例如“Math”和“Debug”、
“Global”和“RegExp对象”。他们是JavaScript内部构造的，不应该公开构造的细节。

我们也发现实例obj的constructor指向function MyObject()。这说明JavaScript维护了对
象的constructor属性。——这与一些人想象的不一样。

然而再接下来，我们发现MyObject2()的实例obj2的constructor仍然指向function MyObject()。
尽管这很说不通，然而现实的确如此。——这到底是为什么呢？

事实上，仅下面的代码：
--------
function MyObject2() {
}

obj2 = new MyObject2();
document.writeln(MyObject2.prototype.constructor === MyObject2);
--------
构造的obj2.constructor将正确的指向function MyObject2()。事实上，我们也会注意到这
种情况下，MyObject2的原型属性的constructor也正确的指向该函数。然而，由于JavaScript
要求指定prototype对象来构造原型链：
--------
function MyObject2() {
}
MyObject2.prototype = new MyObject();

obj2 = new MyObject2();
--------
这时，再访问obj2，将会得到新的原型(也就是MyObject2.prototype)的constructor属性。
因此，一切很明了：原型的属性影响到构造过程对对象的constructor的初始设定。

作为一种补充的解决问题的手段，JavaScript开发规范中说“need to remember to reset
the constructor property'，要求用户自行设定该属性。

所以你会看到更规范的JavaScript代码要求这样书写：
//---------------------------------------------------------
// 维护constructor属性的规范代码
//---------------------------------------------------------
function MyObject2() {
}
MyObject2.prototype = new MyObject();
MyObject2.prototype.constructor = MyObject2;

obj2 = new MyObject2();

更外一种解决问题的方法，是在function MyObject()中去重置该值。当然，这样会使
得执行效率稍低一点点：
//---------------------------------------------------------
// 维护constructor属性的第二种方式
//---------------------------------------------------------
function MyObject2() {
this.constructor = arguments.callee;
// or, this.constructor = MyObject2;

// ...
}
MyObject2.prototype = new MyObject();

obj2 = new MyObject2();

5). 析构问题
------
JavaScript中没有析构函数，但却有“对象析构”的问题。也就是说，尽管我们不
知道一个对象什么时候会被析构，也不能截获它的析构过程并处理一些事务。然而，
在一些不多见的时候，我们会遇到“要求一个对象立即析构”的问题。

问题大多数的时候出现在对ActiveX Object的处理上。因为我们可能在JavaScript
里创建了一个ActiveX Object，在做完一些处理之后，我们又需要再创建一个。而
如果原来的对象供应者(Server)不允许创建多个实例，那么我们就需要在JavaScript
中确保先前的实例是已经被释放过了。接下来，即使Server允许创建多个实例，而
在多个实例间允许共享数据(例如OS的授权，或者资源、文件的锁)，那么我们在新
实例中的操作就可能会出问题。

可能还是有人不明白我们在说什么，那么我就举一个例子：如果创建一个Excel对象，
打开文件Ａ，然后我们save它，然后关闭这个实例。然后我们再创建Excel对象并打开
同一文件。——注意这时JavaScript可能还没有来得及析构前一个对象。——这时我们
再想Save这个文件，就发现失败了。下面的代码示例这种情况：
//---------------------------------------------------------
// JavaScript中的析构问题(ActiveX Object示例)
//---------------------------------------------------------
结果为值类型，或变量为值类型时，等值(或全等)比较可以得到预想结果
- (即使包含相同的数据，)不同的对象实例之间是不等值(或全等)的
- 同一个对象的不同引用之间，是等值(==)且全等(===)的

但对于String类型，有一点补充：根据JScript的描述，两个字符串比较时，只要有一个是值类型，则按值比较。这意味着在上面的例子中，代码“str1==obj1”会得到结果true。而全等(===)运算需要检测变量类型的一致性，因此“str1===obj1”的结果返回false。

JavaScript中的函数参数总是传入值参，引用类型(的实例)是作为指针值传入的。因此函数可以随意重写入口变量，而不用担心外部变量被修改。但是，需要留意传入的引用类型的变量，因为对它方法调用和属性读写可能会影响到实例本身。——但，也可以通过引用类型的参数来传出数据。

最后补充说明一下，值类型比较会逐字节检测对象实例中的数据，效率低但准确性高；而引用类型只检测实例指针和数据类型，因此效率高而准确性低。如果你需要检测两个引用类型是否真的包含相同的数据，可能你需要尝试把它转换成“字符串值”再来比较。

6. 函数的上下文环境
--------
只要写过代码，你应该知道变量是有“全局变量”和“局部变量”之分的。绝大多数的
JavaScript程序员也知道下面这些概念：
//---------------------------------------------------------
// JavaScript中的全局变量与局部变量
//---------------------------------------------------------
var v1 = '全局变量-1';
v2 = '全局变量-2';

function foo() {
v3 = '全局变量-3';

var v4 = '只有在函数内部并使用var定义的，才是局部变量';
}

按照通常对语言的理解来说，不同的代码调用函数，都会拥有一套独立的局部变量。
因此下面这段代码很容易理解：
//---------------------------------------------------------
// JavaScript的局部变量
//---------------------------------------------------------
function MyObject() {
var o = new Object;

this.getValue = function() {
return o;
}
}

var obj1 = new MyObject();
var obj2 = new MyObject();
document.writeln(obj1.getValue() == obj2.getValue());

结果显示false，表明不同(实例的方法)调用返回的局部变量“obj1/obj2”是不相同。

变量的局部、全局特性与OOP的封装性中的“私有(private)”、“公开(public)”具有类同性。因此绝大多数资料总是以下面的方式来说明JavaScript的面向对象系统中的“封装权限级别”问题：
//---------------------------------------------------------
// JavaScript中OOP封装性
//---------------------------------------------------------
function MyObject() {
// 1. 私有成员和方法
var private_prop = 0;
var private_method_1 = function() {
// ...
return 1
}
function private_method_2() {
// ...
return 1
}

// 2. 特权方法
this.privileged_method = function () {
private_prop++;
return private_prop + private_method_1() + private_method_2();
}

// 3. 公开成员和方法
this.public_prop_1 = '';
this.public_method_1 = function () {
// ...
}
}

// 4. 公开成员和方法(2)
MyObject.prototype.public_prop_1 = '';
MyObject.prototype.public_method_1 = function () {
// ...
}

var obj1 = new MyObject();
var obj2 = new MyObject();

document.writeln(obj1.privileged_method(), '
');
document.writeln(obj2.privileged_method());

在这里，“私有(private)”表明只有在(构造)函数内部可访问，而“特权(privileged)”是特指一种存取“私有域”的“公开(public)”方法。“公开(public)”表明在(构造)函数外可以调用和存取。

除了上述的封装权限之外，一些文档还介绍了其它两种相关的概念：
- 原型属性：Classname.prototype.propertyName = someValue
- (类)静态属性：Classname.propertyName = someValue

然而，从面向对象的角度上来讲，上面这些概念都很难自圆其说：JavaScript究竟是为何、以及如何划分出这些封装权限和概念来的呢？

——因为我们必须注意到下面这个例子所带来的问题：
//---------------------------------------------------------
// JavaScript中的局部变量
//---------------------------------------------------------
function MyFoo() {
var i;

MyFoo.setValue = function (v) {
i = v;
}
MyFoo.getValue = function () {
return i;
}
}
MyFoo();

var obj1 = new Object();
var obj2 = new Object();

// 测试一
MyFoo.setValue.call(obj1, 'obj1');
document.writeln(MyFoo.getValue.call(obj1), '
');

// 测试二
MyFoo.setValue.call(obj2, 'obj2');
document.writeln(MyFoo.getValue.call(obj2));
document.writeln(MyFoo.getValue.call(obj1));
document.writeln(MyFoo.getValue());

在这个测试代码中，obj1/obj2都是Object()实例。我们使用function.call()的方式来调用setValue/getValue，使得在MyFoo()调用的过程中替换this为obj1/obj2实例。

然而我们发现“测试二”完成之后，obj2、obj1以及function MyFoo()所持有的局部变量都返回了“obj2”。——这表明三个函数使用了同一个局部变量。

由此可见，JavaScript在处理局部变量时，对“普通函数”与“构造器”是分别对待的。这种处理策略在一些JavaScript相关的资料中被解释作“面向对象中的私有域”问题。而事实上，我更愿意从源代码一级来告诉你真相：这是对象的上下文环境的问题。——只不过从表面看去，“上下文环境”的问题被转嫁到对象的封装性问题上了。

(在阅读下面的文字之前，)先做一个概念性的说明：
- 在普通函数中，上下文环境被window对象所持有
　- 在“构造器和对象方法”中，上下文环境被对象实例所持有

在JavaScript的实现代码中，每次创建一个对象，解释器将为对象创建一个上下文环境链，用于存放对象在进入“构造器和对象方法”时对function()内部数据的一个备份。JavaScript保证这个对象在以后再进入“构造器和对象方法”内部时，总是持有该上下文环境，和一个与之相关的this对象。由于对象可能有多个方法，且每个方法可能又存在多层嵌套函数，因此这事实上构成了一个上下文环境的树型链表结构。而在构造器和对象方法之外，JavaScript不提供任何访问(该构造器和对象方法的)上下文环境的方法。

简而言之：
- 上下文环境与对象实例调用“构造器和对象方法”时相关，而与(普通)函数无关
- 上下文环境记录一个对象在“构造函数和对象方法”内部的私有数据
- 上下文环境采用链式结构，以记录多层的嵌套函数中的上下文

由于上下文环境只与构造函数及其内部的嵌套函数有关，重新阅读前面的代码：
//---------------------------------------------------------
// JavaScript中的局部变量
//---------------------------------------------------------
function MyFoo() {
var i;

MyFoo.setValue = function (v) {
i = v;
}
MyFoo.getValue = function () {
return i;
}
}
MyFoo();

var obj1 = new Object();
MyFoo.setValue.call(obj1, 'obj1');

我们发现setValue()的确可以访问到位于MyFoo()函数内部的“局部变量i”，但是由于setValue()方法的执有者是MyFoo对象(记住函数也是对象)，因此MyFoo对象拥有MyFoo()函数的唯一一份“上下文环境”。

接下来MyFoo.setValue.call()调用虽然为setValue()传入了新的this对象，但实际上拥有“上下文环境”的仍旧是MyFoo对象。因此我们看到无论创建多少个obj1/obj2，最终操作的都是同一个私有变量i。

全局函数/变量的“上下文环境”持有者为window，因此下面的代码说明了“为什么全局变量能被任意的对象和函数访问”：
//---------------------------------------------------------
// 全局函数的上下文
//---------------------------------------------------------
/*
function Window() {
*/
var global_i = 0;
var global_j = 1;

function foo_0() {
}

function foo_1() {
}
/*
}

window = new Window();
*/

因此我们可以看到foo_0()与foo_1()能同时访问global_i和global_j。接下来的推论是，上下文环境决定了变量的“全局”与“私有”。而不是反过来通过变量的私有与全局来讨论上下文环境问题。

更进一步的推论是：JavaScript中的全局变量与函数，本质上是window对象的私有变量与方法。而这个上下文环境块，位于所有(window对象内部的)对象实例的上下文环境链表的顶端，因此都可能访问到。

用“上下文环境”的理论，你可以顺利地解释在本小节中，有关变量的“全局／局部”作用域的问题，以及有关对象方法的封装权限问题。事实上，在实现JavaScript的C源代码中，这个“上下文环境”被叫做“JSContext”，并作为函数／方法的第一个参数传入。——如果你有兴趣，你可以从源代码中证实本小节所述的理论。

另外，《JavaScript权威指南》这本书中第4.7节也讲述了这个问题，但被叫做“变量的作用域”。然而重要的是，这本书把问题讲反了。——作者试图用“全局、局部的作用域”，来解释产生这种现象的“上下文环境”的问题。因此这个小节显得凌乱而且难以自圆其说。

不过在4.6.3小节，作者也提到了执行环境(execution context)的问题，这就与我们这里说的“上下文环境”是一致的了。然而更麻烦的是，作者又将读者引错了方法，试图用函数的上下文环境去解释DOM和ScriptEngine中的问题。

但这本书在“上下文环境链表”的查询方式上的讲述，是正确的而合理的。只是把这个叫成“作用域”有点不对，或者不妥。