JS面向对象的支持[转自http://www.cnblogs.com/dwjaissk/archive/2006/12/18/595761.aspx]

*JS面向对象的支持

Javascript面向对象特性（转载）

JavaScript面向对象的支持

~~~~~~~~~~~~~~~~~~

很少有人对JavaScript的面向对象特性进行系统的分析。我希望接下来的文字让你了解到这

个语言最少为人知的一面。

1. JavaScript中的类型

--------

虽然JavaScript是一个基于对象的语言，但对象(Object)在JavaScript中不是第一型的。JS

是以函数(Function)为第一型的语言。这样说，不但是因为JS中的函数具有高级语言中的函

数的各种特性，而且也因为在JS中，Object也是由函数来实现的。——关于这一点，可以在

后文中“构造与析构”部分看到更进一步的说明。

JS中是弱类型的，他的内置类型简单而且清晰：

---------------------------------------------------------

undefined : 未定义

number : 数字

boolean : 布尔值

string : 字符串

function : 函数

object : 对象

1). undefined类型

========================

在IE5及以下版本中，除了直接赋值和typeof()之外，其它任何对undefined的操作都将导致

异常。如果需要知道一个变量是否是undefined，只能采用typeof()的方法：

<script>

var v;

if (typeof(v) == 'undefined') {

// ...

}

</script>

但是在IE5.5及以上版本中，undefined是一个已实现的系统保留字。因此可以用undefined来

比较和运算。检测一个值是否是undefined的更简单方法可以是：

<script>

var v;

if (v === undefined) {

// ...

}

</script>

因此为了使得核心代码能(部分地)兼容IE5及早期版本，Romo核心单元中有一行代码用来

“声明”一个undefined值：

//---------------------------------------------------------

// code from Qomolangma, in JSEnhance.js

//---------------------------------------------------------

var undefined = void null;

这一行代码还有一点是需要说明的，就是void语句的应用。void表明“执行其后的语句，且

忽略返回值”。因此在void之后可以出现能被执行的任何“单个”语句。而执行的结果就是

undefined。当然，如果你愿意，你也可以用下面的代码之一“定义undefined”。

//---------------------------------------------------------

// 1. 较复杂的方法，利用一个匿名的空函数执行的返回

//---------------------------------------------------------

var undefined = function(){}();

//---------------------------------------------------------

// 2. 代码更简洁，但不易懂的方法

//---------------------------------------------------------

var undefined = void 0;

void也能像函数一样使用，因此void(0)也是合法的。有些时候，一些复杂的语句可能不能

使用void的关键字形式，而必须要使用void的函数形式。例如：

//---------------------------------------------------------

// 必须使用void()形式的复杂表达式

//---------------------------------------------------------

void(i=1); // 或如下语句:

void(i=1, i++);

2). number类型

========================

JavaScript中总是处理浮点数，因此它没有象Delphi中的MaxInt这样的常量，反而是有这

样两个常值定义：

Number.MAX_VALUE : 返回 JScript 能表达的最大的数。约等于 1.79E+308。

Number.MIN_VALUE : 返回 JScript 最接近0的数。约等于 2.22E-308。

因为没有整型的缘故，因此在一些关于CSS和DOM属性的运算中，如果你期望取值为整数2，

你可能会得到字符串“2.0”——或者类似于此的一些情况。这种情况下，你可能需要用

到全局对象(Gobal)的parseInt()方法。

全局对象(Gobal)中还有两个属性与number类型的运算有关：

NaN : 算术表达式的运算结果不是数字，则返回NaN值。

Infinity : 比MAX_VALUE更大的数。

如果一个值是NaN，那么他可以通过全局对象(Gobal)的isNaN()方法来检测。然而两个NaN

值之间不是互等的。如下例：

//---------------------------------------------------------

// NaN的运算与检测

//---------------------------------------------------------

var

v1 = 10 * 'a';

v2 = 10 * 'a';

document.writeln(isNaN(v1));

document.writeln(isNaN(v2));

document.writeln(v1 == v2);

全局对象(Gobal)的Infinity表示比最大的数 (Number.MAX_VALUE) 更大的值。在JS中，

它在数学运算时的价值与正无穷是一样的。——在一些实用技巧中，它也可以用来做一

个数组序列的边界检测。

Infinity在Number对象中被定义为POSITIVE_INFINITY。此外，负无穷也在Number中被定

义：

Number.POSITIVE_INFINITY : 比最大正数（Number.MAX_VALUE）更大的值。正无穷。

Number.NEGATIVE_INFINITY : 比最小负数（-Number.MAX_VALUE）更小的值。负无穷。

与NaN不同的是，两个Infinity(或-Infinity)之间是互等的。如下例：

//---------------------------------------------------------

// Infinity的运算与检测

//---------------------------------------------------------

var

v1 = Number.MAX_VALUE * 2;

v2 = Number.MAX_VALUE * 3;

document.writeln(v1);

document.writeln(v2);

document.writeln(v1 == v2);

在Global中其它与number类型相关的方法有：

isFinite() : 如果值是NaN/正无穷/负无穷，返回false，否则返回true。

parseFloat() : 从字符串(的前缀部分)取一个浮点数。不成功则返回NaN。

3). boolean类型

========================

(略)

4). string类型

========================

JavaScript中的String类型原本没有什么特殊的，但是JavaScript为了适应

“浏览器实现的超文本环境”，因此它具有一些奇怪的方法。例如：

link() : 把一个有HREF属性的超链接标签<A>放在String对象中的文本两端。

big() : 把一对<big>标签放在String对象中的文本两端。

以下方法与此类同：

anchor()

blink()

bold()

fixed()

fontcolor()

fontsize()

italics()

small()

strike()

sub()

sup()

除此之外，string的主要复杂性来自于在JavaScript中无所不在的toString()

方法。这也是JavaScript为浏览器环境而提供的一个很重要的方法。例如我们

声明一个对象，但是要用document.writeln()来输出它，在IE中会显示什么呢？

下例说明这个问题：

//---------------------------------------------------------

// toString()的应用

//---------------------------------------------------------

var

s = new Object();

s.v1 = 'hi,';

s.v2 = 'test!';

document.writeln(s);

document.writeln(s.toString());

s.toString = function() {

return s.v1 + s.v2;

}

document.writeln(s);

在这个例子中，我们看到，当一个对象没有重新声明(覆盖)自己toString()方

法的时候，那么它作为字符串型态使用时(例如被writeln)，就会调用Java Script

环境缺省的toString()。反过来，你也可以重新定义JavaScript理解这个对象

的方法。

很多JavaScript框架，在实现“模板”机制的时候，就利用了这个特性。例如

他们用这样定义一个FontElement对象：

//---------------------------------------------------------

// 利用toString()实现模板机制的简单原理

//---------------------------------------------------------

function FontElement(innerHTML) {

this.face = '宋体';

this.color = 'red';

// more...

var ctx = innerHTML;

this.toString = function() {

return '<Font FACE="' + this.face + '" COLOR="' + this.color + '">'

+ ctx

+ '</FONT>';

}

}

var obj = new FontElement('这是一个测试。');

// 留意下面这行代码的写法

document.writeln(obj);

5). function类型

========================

javascript函数具有很多特性，除了面向对象的部分之外(这在后面讲述)，它自

已的一些独特特性应用也很广泛。

首先javascript中的每个函数，在调用过程中可以执有一个arguments对象。这个

对象是由脚本解释环境创建的，你没有别的方法来自己创建一个arguments对象。

arguments可以看成一个数组：它有length属性，并可以通过arguments
的方式

来访问每一个参数。然而它最重要的，却是可以通过 callee 属性来得到正在执行

的函数对象的引用。

接下的问题变得很有趣：Function对象有一个 caller 属性，指向正在调用当前

函数的父函数对象的引用。

——我们已经看到，我们可以在JavaScript里面，通过callee/caller来遍历执行

期的调用栈。由于arguments事实上也是Function的一个属性，因此我们事实上也

能遍历执行期调用栈上的每一个函数的参数。下面的代码是一个简单的示例：

//---------------------------------------------------------

// 调用栈的遍历

//---------------------------------------------------------

function foo1(v1, v2) {

foo2(v1 * 100);

}

function foo2(v1) {

foo3(v1 * 200);

}

function foo3(v1) {

var foo = arguments.callee;

while (foo && (foo != window)) {

document.writeln('调用参数：<br>', '---------------<br>');

var args = foo.arguments, argn = args.length;

for (var i=0; i<argn; i++) {

document.writeln('args[', i, ']: ', args[i], '<br>');

}

document.writeln('<br>');

// 上一级

foo = foo.caller;

}

}

// 运行测试

foo1(1, 2);

2. JavaScript面向对象的支持

--------

在前面的例子中其实已经讲到了object类型的“类型声明”与“实例创建”。

在JavaScript中，我们需要通过一个函数来声明自己的object类型：

//---------------------------------------------------------

// JavaScript中对象的类型声明的形式代码

// (以后的文档中，“对象名”通常用MyObject来替代)

//---------------------------------------------------------

function 对象名(参数表) {

this.属性 = 初始值;

this.方法 = function(方法参数表) {

// 方法实现代码

}

}

然后，我们可以通过这样的代码来创建这个对象类型的一个实例：

//---------------------------------------------------------

// 创建实例的形式代码

// (以后的文档中，“实例变量名”通常用obj来替代)

//---------------------------------------------------------

var 实例变量名 = new 对象名(参数表);

接下来我们来看“对象”在JavaScript中的一些具体实现和奇怪特性。

1). 函数在JavaScript的面向对象机制中的五重身份

------

“对象名”——如MyObject()——这个函数充当了以下语言角色：

(1) 普通函数

(2) 类型声明

(3) 类型的实现

(4) 类引用

(5) 对象的构造函数

一些程序员(例如Delphi程序员)习惯于类型声明与实现分开。例如在delphi

中，Interface节用于声明类型或者变量，而implementation节用于书写类型

的实现代码，或者一些用于执行的函数、代码流程。

但在JavaScript中，类型的声明与实现是混在一起的。一个对象的类型(类)

通过函数来声明，this.xxxx表明了该对象可具有的属性或者方法。

这个函数的同时也是“类引用”。在JavaScript，如果你需要识别一个对象

的具体型别，你需要执有一个“类引用”。——当然，也就是这个函数的名

字。instanceof 运算符就用于识别实例的类型，我们来看一下它的应用：

//---------------------------------------------------------

// JavaScript中对象的类型识别

// 语法: 对象实例 instanceof 类引用

//---------------------------------------------------------

function MyObject() {

this.data = 'test data';

}

// 这里MyObject()作为构造函数使用

var obj = new MyObject();

var arr = new Array();

// 这里MyObject作为类引用使用

document.writeln(obj instanceof MyObject);

document.writeln(arr instanceof MyObject);

================

(未完待续)

================

接下来的内容：

2. JavaScript面向对象的支持

--------

2). 反射机制在JavaScript中的实现

3). this与with关键字的使用

4). 使用in关键字的运算

5). 使用instanceof关键字的运算

6). 其它与面向对象相关的关键字

3. 构造与析构

4. 实例和实例引用

5. 原型问题

6. 函数的上下文环境

7. 对象的类型检查问题

2). 反射机制在JavaScript中的实现

------

JavaScript中通过for..in语法来实现了反射机制。但是JavaScript中并不

明确区分“属性”与“方法”，以及“事件”。因此，对属性的类型考查在JS

中是个问题。下面的代码简单示例for..in的使用与属性识别：

//---------------------------------------------------------

// JavaScript中for..in的使用和属性识别

//---------------------------------------------------------

var _r_event = _r_event = /^[Oo]n.*/;

var colorSetting = {

method: 'red',

event: 'blue',

property: ''

}

var obj2 = {

a_method : function() {},

a_property: 1,

onclick: undefined

}

function propertyKind(obj, p) {

return (_r_event.test(p) && (obj[p]==undefined || typeof(obj[p])=='function')) ? 'event'

: (typeof(obj[p])=='function') ? 'method'

: 'property';

}

var objectArr = ['window', 'obj2'];

for (var i=0; i<objectArr.length; i++) {

document.writeln('<p>for ', objectArr[i], '<hr>');

var obj = eval(objectArr[i]);

for (var p in obj) {

var kind = propertyKind(obj, p);

document.writeln('obj.', p, ' is a ', kind.fontcolor(colorSetting[kind]), ': ', obj[p], '<br>');

}

document.writeln('</p>');

}

一个常常被开发者忽略的事实是：JavaScript本身是没有事件(Event)系统的。通

常我们在JavaScript用到的onclick等事件，其实是IE的DOM模型提供的。从更内核

的角度上讲：IE通过COM的接口属性公布了一组事件接口给DOM。

有两个原因，使得在JS中不能很好的识别“一个属性是不是事件”：

- COM接口中本身只有方法，属性与事件，都是通过一组get/set方法来公布的。

- JavaScript中，本身并没有独立的“事件”机制。

因此我们看到event的识别方法，是检测属性名是否是以'on'字符串开头(以'On'开

头的是Qomo的约定)。接下来，由于DOM对象中的事件是可以不指定处理函数的，这

种情况下事件句柄为null值(Qomo采用相同的约定)；在另外的一些情况下，用户可

能象obj2这样，定义一个值为 undefined的事件。因此“事件”的判定条件被处理

成一个复杂的表达式：

("属性以on/On开头" && ("值为null/undefined" || "类型为function"))

另外，从上面的这段代码的运行结果来看。对DOM对象使用for..in，是不能列举出

对象方法来的。

最后说明一点。事实上，在很多语言的实现中，“事件”都不是“面向对象”的语

言特性，而是由具体的编程模型来提供的。例如Delphi中的事件驱动机制，是由Win32

操作系统中的窗口消息机制来提供，或者由用户代码在Component/Class中主动调用

事件处理函数来实现。

“事件”是一个“如何驱动编程模型”的机制／问题，而不是语言本身的问题。然

而以PME(property/method/event)为框架的OOP概念，已经深入人心，所以当编程语

言或系统表现出这些特性来的时候，就已经没人关心“event究竟是谁实现”的了。

3). this与with关键字的使用

------

在JavaScript的对象系统中，this关键字用在两种地方：

- 在构造器函数中，指代新创建的对象实例

- 在对象的方法被调用时，指代调用该方法的对象实例

如果一个函数被作为普通函数(而不是对象方法)调用，那么在函数中的this关键字

将指向window对象。与此相同的，如果this关键字不在任何函数中，那么他也指向

window对象。

由于在JavaScript中不明确区分函数与方法。因此有些代码看起来很奇怪：

//---------------------------------------------------------

// 函数的几种可能调用形式

//---------------------------------------------------------

function foo() {

// 下面的this指代调用该方法的对象实例

if (this===window) {

document.write('call a function.', '<BR>');

}

else {

document.write('call a method, by object: ', this.name, '<BR>');

}

}

function MyObject(name) {

// 下面的this指代new关键字新创建实例

this.name = name;

this.foo = foo;

}

var obj1 = new MyObject('obj1');

var obj2 = new MyObject('obj2');

// 测试1: 作为函数调用

foo();

// 测试2: 作为对象方法的调用

obj1.foo();

obj2.foo();

// 测试3: 将函数作为“指定对象的”方法调用

foo.call(obj1);

foo.apply(obj2);

在上面的代码里，obj1/obj2对foo()的调用是很普通的调用方法。——也就

是在构造器上，将一个函数指定为对象的方法。

而测试3中的call()与apply()就比较特殊。

在这个测试中，foo()仍然作为普通函数来调用，只是JavaScript的语言特性

允许在call()/apply()时，传入一个对象实例来指定foo()的上下文环境中所

出现的this关键字的引用。——需要注意的是，此时的foo()仍旧是一个普通

函数调用，而不是对象方法调用。

与this“指示调用该方法的对象实例”有些类同的，with()语法也用于限定

“在一段代码片段中默认使用对象实例”。——如果不使用with()语法，那

么这段代码将受到更外层with()语句的影响；如果没有更外层的with()，那

么这段代码的“默认使用的对象实例”将是window。

然而需要注意的是this与with关键字不是互为影响的。如下面的代码：

//---------------------------------------------------------

// 测试: this与with关键字不是互为影响的

//---------------------------------------------------------

function test() {

with (obj2) {

this.value = 8;

}

}

var obj2 = new Object();

obj2.value = 10;

test();

document.writeln('obj2.value: ', obj2.value, '<br>');

document.writeln('window.value: ', window.value, '<br>');

你不能指望这样的代码在调用结束后，会使obj2.value属性置值为8。这几行

代码的结果是：window对象多了一个value属性，并且值为8。

with(obj){...}这个语法，只能限定对obj的既有属性的读取，而不能主动的

声明它。一旦with()里的对象没有指定的属性，或者with()限定了一个不是对

象的数据，那么结果会产生一个异常。

4). 使用in关键字的运算

------

除了用for..in来反射对象的成员信息之外，JavaScript中也允许直接用in

关键字去检测对象是否有指定名字的属性。

in关键字经常被提及的原因并不是它检测属性是否存在的能力，因此在早期

的代码中，很多可喜欢用“if (!obj.propName) {}” 这样的方式来检测propName

是否是有效的属性。——很多时候，检测有效性比检测“是否存有该属性”更

有实用性。因此这种情况下，in只是一个可选的、官方的方案。

in关键字的重要应用是高速字符串检索。尤其是在只需要判定“字符串是否

存在”的情况下。例如10万个字符串，如果存储在数组中，那么检索效率将会

极差。

//---------------------------------------------------------

// 使用对象来检索

//---------------------------------------------------------

function arrayToObject(arr) {

for (var obj=new Object(), i=0, imax=arr.length; i<imax; i++) {

obj[arr[i]]=null;

}

return obj;

}

var

arr = ['abc', 'def', 'ghi']; // more and more...

obj = arrayToObject(arr);

function valueInArray(v) {

for (var i=0, imax=arr.length; i<imax; i++) {

if (arr[i]==v) return true;

}

return false;

}

function valueInObject(v) {

return v in obj;

}

这种使用关键字in的方法，也存在一些限制。例如只能查找字符串，而数

组元素可以是任意值。另外，arrayToObject()也存在一些开销，这使得它

不适合于频繁变动的查找集。最后，(我想你可能已经注意到了)使用对象

来查找的时候并不能准确定位到查找数据，而数组中可以指向结果的下标。

八、JavaScript面向对象的支持

~~~~~~~~~~~~~~~~~~

(续)

2. JavaScript面向对象的支持

--------

(续)

5). 使用instanceof关键字的运算

------

在JavaScript中提供了instanceof关键字来检测实例的类型。这在前面讨

论它的“五重身份”时已经讲过。但instanceof的问题是，它总是列举整个

原型链以检测类型(关于原型继承的原理在“构造与析构”小节讲述)，如：

//---------------------------------------------------------

// instanceof使用中的问题

//---------------------------------------------------------

function MyObject() {

// ...

}

function MyObject2() {

// ...

}

MyObject2.prototype = new MyObject();

obj1 = new MyObject();

obj2 = new MyObject2();

document.writeln(obj1 instanceof MyObject, '<BR>');

document.writeln(obj2 instanceof MyObject, '<BR>');

我们看到，obj1与obj2都是MyObject的实例，但他们是不同的构造函数产生

的。——注意，这在面向对象理论中正确的：因为obj2是MyObject的子类实

例，因此它具有与obj1相同的特性。在应用中这是obj2的多态性的体现之一。

但是，即便如此，我们也必须面临这样的问题：如何知道obj2与obj1是否是

相同类型的实例呢？——也就是说，连构造器都相同？

instanceof关键字不提供这样的机制。一个提供实现这种检测的能力的，是

Object.constructor属性。——但请先记住，它的使用远比你想象的要难。

好的，问题先到这里。constructor属性已经涉及到“构造与析构”的问题，

这个我们后面再讲。“原型继承”、“构造与析构”是JavaScript的OOP中

的主要问题、核心问题，以及“致命问题”。

6). null与undefined

------

在JavaScript中，null与undefined曾一度使我迷惑。下面的文字，有利于

你更清晰的认知它(或者让你更迷惑)：

- null是关键字；undefined是Global对象的一个属性。

- null是对象(空对象, 没有任何属性和方法)；undefined是undefined类

型的值。试试下面的代码：

document.writeln(typeof null);

document.writeln(typeof undefined);

- 对象模型中，所有的对象都是Object或其子类的实例，但null对象例外：

document.writeln(null instanceof Object);

- null“等值(==)”于undefined，但不“全等值(===)”于undefined：

document.writeln(null == undefined);

document.writeln(null == undefined);

- 运算时null与undefined都可以被类型转换为false，但不等值于false：

document.writeln(!null, !undefined);

document.writeln(null==false);

document.writeln(undefined==false);

八、JavaScript面向对象的支持

~~~~~~~~~~~~~~~~~~

(续)

3. 构造、析构与原型问题

--------

我们已经知道一个对象是需要通过构造器函数来产生的。我们先记住几点：

- 构造器是一个普通的函数

- 原型是一个对象实例

- 构造器有原型属性，对象实例没有

- (如果正常地实现继承模型，)对象实例的constructor属性指向构造器

- 从三、四条推出：obj.constructor.prototype指向该对象的原型

好，我们接下来分析一个例子，来说明JavaScript的“继承原型”声明，以

及构造过程。

//---------------------------------------------------------

// 理解原型、构造、继承的示例

//---------------------------------------------------------

function MyObject() {

this.v1 = 'abc';

}

function MyObject2() {

this.v2 = 'def';

}

MyObject2.prototype = new MyObject();

var obj1 = new MyObject();

var obj2 = new MyObject2();

1). new()关键字的形式化代码

------

我们先来看“obj1 = new MyObject()”这行代码中的这个new关键字。

new关键字用于产生一个新的实例（说到这里补充一下，我习惯于把保留字叫关键

字。另外，在JavaScript中new关键字同时也是一个运算符），这个实例的缺省属性

中，(至少)会执有构造器函数的原型属性(prototype)的一个引用(在ECMA Javascript

规范中，对象的这个属性名定义为__proto__)。

每一个函数，无论它是否用作构造器，都会有一个独一无二的原型对象(prototype)。

对于JavaScript“内置对象的构造器”来说，它指向内部的一个原型。缺省时JavaScript

构造出一个“空的初始对象实例(不是null)”并使原型引用指向它。然而如果你给函

数的这个prototype赋一个新的对象，那么新的对象实例将执有它的一个引用。

接下来，构造过程将调用MyObject()来完成初始化。——注意，这里只是“初始

化”。

为了清楚地解释这个过程，我用代码形式化地描述一下这个过程：

//---------------------------------------------------------

// new()关键字的形式化代码

//---------------------------------------------------------

function new(aFunction) {

// 基本对象实例

var _this = {};

// 原型引用

var _proto= aFunction.prototype;

/* if compat ECMA Script

_this.__proto__ = _proto;

*/

// 为存取原型中的属性添加(内部的)getter

_this._js_GetAttributes= function(name) {

if (_existAttribute.call(this, name))

return this[name]

else if (_js_LookupProperty.call(_proto, name))

retrun OBJ_GET_ATTRIBUTES.call(_proto, name)

else

return undefined;

}

// 为存取原型中的属性添加(内部的)setter

_this._js_GetAttributes = function(name, value) {

if (_existAttribute.call(this, name))

this[name] = value

else if (OBJ_GET_ATTRIBUTES.call(_proto, name) !== value) {

this[name] = value // 创建当前实例的新成员

}

}

// 调用构造函数完成初始化, (如果有,)传入args

aFunction.call(_this);

// 返回对象

return _this;

}

所以我们看到以下两点：

- 构造函数(aFunction)本身只是对传入的this实例做“初始化”处理，而

不是构造一个对象实例。

- 构造的过程实际发生在new()关键字/运算符的内部。

而且，构造函数(aFunction)本身并不需要操作prototype，也不需要回传this。

2). 由用户代码维护的原型(prototype)链

------

接下来我们更深入的讨论原型链与构造过程的问题。这就是：

- 原型链是用户代码创建的，new()关键字并不协助维护原型链

以Delphi代码为例，我们在声明继承关系的时候，可以用这样的代码：

//---------------------------------------------------------

// delphi中使用的“类”类型声明

//---------------------------------------------------------

type

TAnimal = class(TObject); // 动物

TMammal = class(TAnimal); // 哺乳动物

TCanine = class(TMammal); // 犬科的哺乳动物

TDog = class(TCanine); // 狗

这时，Delphi的编译器会通过编译技术来维护一个继承关系链表。我们可以通

过类似以下的代码来查询这个链表：

//---------------------------------------------------------

// delphi中使用继关系链表的关键代码

//---------------------------------------------------------

function isAnimal(obj: TObject): boolean;

begin

Result := obj is TAnimal;

end;

var

dog := TDog;

// ...

dog := TDog.Create();

writeln(isAnimal(dog));

可以看到，在Delphi的用户代码中，不需要直接继护继承关系的链表。这是因

为Delphi是强类型语言，在处理用class()关键字声明类型时，delphi的编译器

已经为用户构造了这个继承关系链。——注意，这个过程是声明，而不是执行

代码。

而在JavaScript中，如果需要获知对象“是否是某个基类的子类对象”，那么

你需要手工的来维护(与delphi这个例子类似的)一个链表。当然，这个链表不

叫类型继承树，而叫“(对象的)原型链表”。——在JS中，没有“类”类型。

参考前面的JS和Delphi代码，一个类同的例子是这样：

//---------------------------------------------------------

// JS中“原型链表”的关键代码

//---------------------------------------------------------

// 1. 构造器

function Animal() {};

function Mammal() {};

function Canine() {};

function Dog() {};

// 2. 原型链表

Mammal.prototype = new Animal();

Canine.prototype = new Mammal();

Dog.prototype = new Canine();

// 3. 示例函数

function isAnimal(obj) {

return obj instanceof Animal;

}

var

dog = new Dog();

document.writeln(isAnimal(dog));

可以看到，在JS的用户代码中，“原型链表”的构建方法是一行代码：

"当前类的构造器函数".prototype = "直接父类的实例"

这与Delphi一类的语言不同：维护原型链的实质是在执行代码，而非声明。

那么，“是执行而非声明”到底有什么意义呢？

JavaScript是会有编译过程的。这个过程主要处理的是“语法检错”、“语

法声明”和“条件编译指令”。而这里的“语法声明”，主要处理的就是函

数声明。——这也是我说“函数是第一类的，而对象不是”的一个原因。

如下例：

//---------------------------------------------------------

// 函数声明与执行语句的关系(firefox 兼容)

//---------------------------------------------------------

// 1. 输出1234

testFoo(1234);

// 2. 尝试输出obj1

// 3. 尝试输出obj2

testFoo(obj1);

try {

testFoo(obj2);

}

catch(e) {

document.writeln('Exception: ', e.description, '<BR>');

}

// 声明testFoo()

function testFoo(v) {

document.writeln(v, '<BR>');

}

// 声明object

var obj1 = {};

obj2 = {

toString: function() {return 'hi, object.'}

}

// 4. 输出obj1

// 5. 输出obj2

testFoo(obj1);

testFoo(obj2);

这个示例代码在JS环境中执行的结果是：

------------------------------------

1234

undefined

Exception: 'obj2' 未定义

[object Object]

hi, obj

------------------------------------

问题是，testFoo()是在它被声明之前被执行的；而同样用“直接声明”的

形式定义的object变量，却不能在声明之前引用。——例子中，第二、三

个输入是不正确的。

函数可以在声明之前引用，而其它类型的数值必须在声明之后才能被使用。

这说明“声明”与“执行期引用”在JavaScript中是两个过程。

另外我们也可以发现，使用"var"来声明的时候，编译器会先确认有该变量

存在，但变量的值会是“undefined”。——因此“testFoo(obj1)”不会发

生异常。但是，只有等到关于obj1的赋值语句被执行过，才会有正常的输出。

请对照第二、三与第四、五行输出的差异。

由于JavaScript对原型链的维护是“执行”而不是“声明”，这说明“原型

链是由用户代码来维护的，而不是编译器维护的。

由这个推论，我们来看下面这个例子：

//---------------------------------------------------------

// 示例：错误的原型链

//---------------------------------------------------------

// 1. 构造器

function Animal() {}; // 动物

function Mammal() {}; // 哺乳动物

function Canine() {}; // 犬科的哺乳动物

// 2. 构造原型链

var instance = new Mammal();

Mammal.prototype = new Animal();

Canine.prototype = instance;

// 3. 测试输出

var obj = new Canine();

document.writeln(obj instanceof Animal);

这个输出结果，使我们看到一个错误的原型链导致的结果“犬科的哺乳动

物‘不是’一种动物”。

根源在于“2. 构造原型链”下面的几行代码是解释执行的，而不是象var和

function那样是“声明”并在编译期被理解的。解决问题的方法是修改那三

行代码，使得它的“执行过程”符合逻辑：

//---------------------------------------------------------

// 上例的修正代码(部分)

//---------------------------------------------------------

// 2. 构造原型链

Mammal.prototype = new Animal();

var instance = new Mammal();

Canine.prototype = instance;

3). 原型实例是如何被构造过程使用的

------

仍以Delphi为例。构造过程中，delphi中会首先创建一个指定实例大小的

“空的对象”，然后逐一给属性赋值，以及调用构造过程中的方法、触发事

件等。

JavaScript中的new()关键字中隐含的构造过程，与Delphi的构造过程并不完全一致。但

在构造器函数中发生的行为却与上述的类似：

//---------------------------------------------------------

// JS中的构造过程(形式代码)

//---------------------------------------------------------

function MyObject2() {

this.prop = 3;

this.method = a_method_function;

if (you_want) {

this.method();

this.fire_OnCreate();

}

}

MyObject2.prototype = new MyObject(); // MyObject()的声明略

var obj = new MyObject2();

如果以单个类为参考对象的，这个构造过程中JavaScript可以拥有与Delphi

一样丰富的行为。然而，由于Delphi中的构造过程是“动态的”，因此事实上

Delphi还会调用父类(MyObject)的构造过程，以及触发父类的OnCreate()事件。

JavaScript没有这样的特性。父类的构造过程仅仅发生在为原型(prototype

属性)赋值的那一行代码上。其后，无论有多少个new MyObject2()发生，

MyObject()这个构造器都不会被使用。——这也意味着：

- 构造过程中，原型对象是一次性生成的；新对象只持有这个原型实例的引用

(并用“写复制”的机制来存取其属性)，而并不再调用原型的构造器。

由于不再调用父类的构造器，因此Delphi中的一些特性无法在JavaScript中实现。

这主要影响到构造阶段的一些事件和行为。——无法把一些“对象构造过程中”

的代码写到父类的构造器中。因为无论子类构造多少次，这次对象的构造过程根

本不会激活父类构造器中的代码。

JavaScript中属性的存取是动态的，因为对象存取父类属性依赖于原型链表，构造

过程却是静态的，并不访问父类的构造器；而在Delphi等一些编译型语言中，(不使

用读写器的)属性的存取是静态的，而对象的构造过程则动态地调用父类的构造函数。

所以再一次请大家看清楚new()关键字的形式代码中的这一行：

//---------------------------------------------------------

// new()关键字的形式化代码

//---------------------------------------------------------

function new(aFunction) {

// 原型引用

var _proto= aFunction.prototype;

// ...

}

这个过程中，JavaScript做的是“get a prototype_Ref”，而Delphi等其它语言做

的是“Inherited Create()”。

八、JavaScript面向对象的支持

~~~~~~~~~~~~~~~~~~

(续)

4). 需要用户维护的另一个属性：constructor

------

回顾前面的内容，我们提到过：

- (如果正常地实现继承模型，)对象实例的constructor属性指向构造器

- obj.constructor.prototype指向该对象的原型

- 通过Object.constructor属性，可以检测obj2与obj1是否是相同类型的实例

与原型链要通过用户代码来维护prototype属性一样，实例的构造器属性constructor

也需要用户代码维护。

对于JavaScript的内置对象来说，constructor属性指向内置的构造器函数。如：

//---------------------------------------------------------

// 内置对象实例的constructor属性

//---------------------------------------------------------

var _object_types = {

'function' : Function,

'boolean' : Boolean,

'regexp' : RegExp,

// 'math' : Math,

// 'debug' : Debug,

// 'image' : Image;

// 'undef' : undefined,

// 'dom' : undefined,

// 'activex' : undefined,

'vbarray' : VBArray,

'array' : Array,

'string' : String,

'date' : Date,

'error' : Error,

'enumerator': Enumerator,

'number' : Number,

'object' : Object

}

function objectTypes(obj) {

if (typeof obj !== 'object') return typeof obj;

if (obj === null) return 'null';

for (var i in _object_types) {

if (obj.constructor===_object_types[i]) return i;

}

return 'unknow';

}

// 测试数据和相关代码

function MyObject() {

}

function MyObject2() {

}

MyObject2.prototype = new MyObject();

window.execScript(''+

'Function CreateVBArray()' +

' Dim a(2, 2)' +

' CreateVBArray = a' +

'End Function', 'VBScript');

document.writeln('<div id=dom style="display:none">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), '<br>');

document.writeln(objectTypes(ax), '<br>');

document.writeln(objectTypes(obj), '<br>');

document.writeln(objectTypes(obj2), '<br>');

document.writeln(objectTypes(dom), '<br>');

在这个例子中，我们发现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示例)

//---------------------------------------------------------

<script>

var strSaveLocation = 'file:///E:/1.xls'

function createXLS() {

var excel = new ActiveXObject("Excel.Application");

var wk = excel.Workbooks.Add();

wk.SaveAs(strSaveLocation);

wk.Saved = true;

excel.Quit();

}

function writeXLS() {

var excel = new ActiveXObject("Excel.Application");

var wk = excel.Workbooks.Open(strSaveLocation);

var sheet = wk.Worksheets(1);

sheet.Cells(1, 1).Value = '测试字符串';

wk.SaveAs(strSaveLocation);

wk.Saved = true;

excel.Quit();

}

</script>

<body>

<button onclick="createXLS()">创建</button>

<button onclick="writeXLS()">重写</button>

</body>

在这个例子中，在本地文件操作时并不会出现异常。——最多只是有一些内存垃

圾而已。然而，如果strSaveLocation是一个远程的URL，这时本地将会保存一个

文件存取权限的凭证，而且同时只能一个(远程的)实例来开启该excel文档并存

储。于是如果反复点击"重写"按钮，就会出现异常。

——注意，这是在SPS中操作共享文件时的一个实例的简化代码。因此，它并非

“学术的”无聊讨论，而且工程中的实际问题。

解决这个问题的方法很复杂。它涉及到两个问题：

- 本地凭证的释放

- ActiveX Object实例的释放

下面我们先从JavaScript中对象的“失效”问题说起。简单的说：

- 一个对象在其生存的上下文环境之外，即会失效。

- 一个全局的对象在没有被执用(引用)的情况下，即会失效。

例如：

//---------------------------------------------------------

// JavaScript对象何时失效

//---------------------------------------------------------

function testObject() {

var _obj1 = new Object();

}

function testObject2() {

var _obj2 = new Object();

return _obj2;

}

// 示例1

testObject();

// 示例2

testObject2()

// 示例3

var obj3 = testObject2();

obj3 = null;

// 示例4

var obj4 = testObject2();

var arr = [obj4];

obj3 = null;

arr = [];

在这四个示例中：

- “示例1”在函数testObject()中构造了_obj1，但是在函数退出时，

它就已经离开了函数的上下文环境，因此_obj1失效了；

- “示例2”中，testObject2()中也构造了一个对象_obj2并传出，因

此对象有了“函数外”的上下文环境(和生存周期)，然而由于函数

的返回值没有被其它变量“持有”，因此_obj2也立即失效了；

- “示例3”中，testObject2()构造的_obj2被外部的变量obj3持用了，

这时，直到“obj3=null”这行代码生效时，_obj2才会因为引用关系

消失而失效。

- 与示例3相同的原因，“示例4”中的_obj2会在“arr=[]”这行代码

之后才会失效。

但是，对象的“失效”并不等会“释放”。在JavaScript运行环境的内部，没

有任何方式来确切地告诉用户“对象什么时候会释放”。这依赖于JavaScript

的内存回收机制。——这种策略与.NET中的回收机制是类同的。

在前面的Excel操作示例代码中，对象的所有者，也就是"EXCEL.EXE"这个进程

只能在“ActiveX Object实例的释放”之后才会发生。而文件的锁，以及操作

系统的权限凭证是与进程相关的。因此如果对象仅是“失效”而不是“释放”，

那么其它进程处理文件和引用操作系统的权限凭据时就会出问题。

——有些人说这是JavaScript或者COM机制的BUG。其实不是，这是ＯＳ、ＩＥ

和JavaScript之间的一种复杂关系所导致的，而非独立的问题。

Microsoft公开了解决这种问题的策略：主动调用内存回收过程。

在(微软的)JScript中提供了一个CollectGarbage()过程(通常简称GC过程)，

GC过程用于清理当前IE中的“失效的对象失例”，也就是调用对象的析构过程。

在上例中调用GC过程的代码是：

//---------------------------------------------------------

// 处理ActiveX Object时，GC过程的标准调用方式

//---------------------------------------------------------

function writeXLS() {

//(略...)

excel.Quit();

excel = null;

setTimeout(CollectGarbage, 1);

}

第一行代码调用excel.Quit()方法来使得excel进程中止并退出，这时由于JavaScript

环境执有excel对象实例，因此excel进程并不实际中止。

第二行代码使excel为null，以清除对象引用，从而使对象“失效”。然而由于

对象仍旧在函数上下文环境中，因此如果直接调用GC过程，对象仍然不会被清理。

第三行代码使用setTimeout()来调用CollectGarbage函数，时间间隔设为'1'，只

是使得GC过程发生在writeXLS()函数执行完之后。这样excel对象就满足了“能被

GC清理”的两个条件：没有引用和离开上下文环境。

GC过程的使用，在使用了ActiveX Object的JS环境中很有效。一些潜在的ActiveX

Object包括XML、VML、OWC(Office Web Componet)、flash，甚至包括在JS中的VBArray。

从这一点来看，ajax架构由于采用了XMLHTTP，并且同时要满足“不切换页面”的

特性，因此在适当的时候主动调用GC过程，会得到更好的效率用UI体验。

事实上，即使使用GC过程，前面提到的excel问题仍然不会被完全解决。因为IE还

缓存了权限凭据。使页的权限凭据被更新的唯一方法，只能是“切换到新的页面”，

因此事实上在前面提到的那个SPS项目中，我采用的方法并不是GC，而是下面这一

段代码：

//---------------------------------------------------------

// 处理ActiveX Object时采用的页面切换代码

//---------------------------------------------------------

function writeXLS() {

//(略...)

excel.Quit();

excel = null;

// 下面代码用于解决IE call Excel的一个BUG, MSDN中提供的方法:

// setTimeout(CollectGarbage, 1);

// 由于不能清除(或同步)网页的受信任状态, 所以将导致SaveAs()等方法在

// 下次调用时无效.

location.reload();

}

最后之最后，关于GC的一个补充说明：在IE窗体被最小化时，IE将会主动调用一次

CollectGarbage()函数。这使得IE窗口在最小化之后，内存占用会有明显改善。

八、JavaScript面向对象的支持

~~~~~~~~~~~~~~~~~~

(续)

4. 实例和实例引用

--------

在.NET Framework对CTS(Common Type System)约定“一切都是对象”，并分为“值类型”和“引用类型”两种。其中“值类型”的对象在转换成“引用类型”数据的过程中，需要进行一个“装箱”和“拆箱”的过程。

在JavaScript也有同样的问题。我们看到的typeof关键字，返回以下六种数据类型：

"number"、"string"、"boolean"、"object"、"function" 和 "undefined"。

我
们也发现JavaScript的对象系统中，有String、Number、Function、Boolean这四种对象构造器。那么，我们的问题是：如
果有一个数字A，typeof(A)的结果，到底会是'number'呢，还是一个构造器指向function Number()的对象呢？

//---------------------------------------------------------

// 关于JavaScript的类型的测试代码

//---------------------------------------------------------

function getTypeInfo(V) {

return (typeof V == 'object' ? 'Object, construct by '+V.constructor

: 'Value, type of '+typeof V);

}

var A1 = 100;

var A2 = new Number(100);

document.writeln('A1 is ', getTypeInfo(A1), '<BR>');

document.writeln('A2 is ', getTypeInfo(A2), '<BR>');

document.writeln([A1.constructor === A2.constructor, A2.constructor === Number]);

测试代码的执行结果如下：

-----------

A1 is Value, type of number

A2 is Object, construct by function Number() { [native code] }

true,true

-----------

我们注意到，A1和A2的构造器都指向Number。这意味着通过constructor属性来识别对象，(有时)比typeof更加有效。因为“值类型数据”A1作为一个对象来看待时，与A2有完全相同的特性。

——除了与实例引用有关的问题。

参考JScript手册，我们对其它基础类型和构造器做相同考察，可以发现：

- 基础类型中的undefined、number、boolean和string，是“值类型”变量

- 基础类型中的array、function和object，是“引用类型”变量

- 使用new()方法构造出对象，是“引用类型”变量

下面的代码说明“值类型”与“引用类型”之间的区别：

//---------------------------------------------------------

// 关于JavaScript类型系统中的值/引用问题

//---------------------------------------------------------

var str1 = 'abcdefgh', str2 = 'abcdefgh';

var obj1 = new String('abcdefgh'), obj2 = new String('abcdefgh');

document.writeln([str1==str2, str1===str2], '<br>');

document.writeln([obj1==obj2, obj1===obj2]);

测试代码的执行结果如下：

-----------

true, true

false, false

-----------

我们看到，无论是等值运算(==)，还是全等运算(===)，对“对象”和“值”的理解都是不一样的。

更进一步的理解这种现象，我们知道：

- 运算结果为值类型，或变量为值类型时，等值(或全等)比较可以得到预想结果

- (即使包含相同的数据，)不同的对象实例之间是不等值(或全等)的

- 同一个对象的不同引用之间，是等值(==)且全等(===)的

但
对于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(), '<br>');

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), '<BR>');

// 测试二

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中的问题。

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