DIV CSS 佈局教程網

一次搞懂 JavaScript 原型:从 [[Prototype]] 到原型链
編輯:JavaScript基礎知識     

原型(prototype)大概是 JavaScript 里最让人纠结的概念。有意思的是,不只是初学者,很多经验丰富的开发者、甚至语言作者本人,在解释它的时候都显得小心翼翼。我认为问题的根源在于我们最早接触原型的方式:它总是和 new、constructor 以及那个令人困惑的 prototype 属性捆绑在一起出现。

事实上,原型是一个相当简单的概念。想真正理解它,得先把"学到的那套构造原型"忘掉,回到源头重新看。

什么是原型

原型就是一个被其他对象用来继承属性的对象。

就这么简单。任何对象都可以充当原型,没有类型限制。

哪些对象拥有原型?所有对象。原型本身也是对象,因此原型也有自己的原型,如此层层向上,直到原型链的顶端。唯一的例外是默认的 Object.prototype,它的原型是 null,链到此终止。

顺便明确一下"对象"的定义:在 JavaScript 中,除了 undefined、null、boolean、number、string 这几种原始类型之外,其余都是对象;对象是以键值对形式保存的无序集合。

({}).prototype 为什么是 undefined

很多人写代码时会撞上这一行:

var a = {};
console.log(a.prototype); // undefined

这不是 bug。一个对象真正的原型存放在内部的 [[Prototype]] 槽里,而 prototype 是函数才有的属性,普通对象上并不存在。

访问 [[Prototype]] 有三条路径:

var a = {};

// 标准方法(ES5 引入),现代浏览器均支持
Object.getPrototypeOf(a); // [object Object]

// 非标准但事实通用的写法(IE 除外)
a.__proto__;               // [object Object]

// 通过构造函数间接获取(所有浏览器,但依赖 prototype 未被替换)
a.constructor.prototype;   // [object Object]

请记住:obj.constructor.prototype 之所以常常"看起来对",是因为默认情况下构造函数的 prototype 恰好被赋给了实例;一旦有人替换了 A.prototype,这条路径就会给出错误答案。

原始类型也有原型吗

有。访问原始值的原型时,JavaScript 会临时把它包装成对应的对象:

false.__proto__ === Boolean(false).__proto__; // true

这也是 "abc".toUpperCase() 能工作的原因——字符串字面量被临时装箱为 String 对象,方法查找沿着 String.prototype 完成,用完即弃。

原型如何用于继承

单独给一个实例设置原型几乎没有意义。原型真正的威力在于多个实例共享同一个原型对象:属性只定义一次,所有实例都能继承到。

// 手动挂接(IE 8 及以下不支持 __proto__)
var a = {};
a.__proto__ = Array.prototype;
console.log(a.length); // 0

但手动挂接既不便携也不安全。构造函数提供了一套跨浏览器的标准机制:用 new 创建实例时,引擎会自动把实例的 [[Prototype]] 指向该构造函数的 prototype 属性。

constructor.prototype 到底是什么

JavaScript 不区分构造函数和普通函数——所有函数都有 prototype 属性,而非函数则没有:

Math.max.prototype; // [object Object] —— 方法也有
var A = function(name) { this.name = name; };
A.prototype;          // [object Object] —— 构造函数也有
Math.prototype;       // undefined —— Math 不是函数

于是可以给出定义:函数的 prototype 属性,是当该函数被用作构造函数创建实例时,赋给实例 [[Prototype]] 的那个对象。

这里有一个极其重要、也极易被混淆的区分:函数的 prototype 属性和函数自身的原型毫无关系。

var A = function(name) { this.name = name; };

A.prototype == A.__proto__;  // false
A.__proto__ == Function.prototype; // true —— A 的原型是 Function.prototype

换句话说,A.prototype 是给"未来实例"准备的原型;而 A.__proto__ 是 A 自己作为对象时的原型。两者只是碰巧同名。

一个完整的例子

// 构造函数:this 将作为新对象返回,
// 其内部 [[Prototype]] 会被设置为构造函数的默认 prototype
var Circle = function(radius) {
  this.radius = radius;
  // 下面这行是引擎隐式完成的,写出来只为说明
  // this.__proto__ = Circle.prototype;
};

// 扩展 prototype,等于扩展所有实例的原型
Circle.prototype.area = function() {
  return Math.PI * this.radius * this.radius;
};

var a = new Circle(3), b = new Circle(4);
a.area().toFixed(2); // 28.27
b.area().toFixed(2); // 50.27

两个实例各自持有 radius,但 area 方法只存在一份,位于共享的原型对象上。这就是原型带来的性能与可维护性收益。

改了 prototype,已有实例会跟着变吗

要分两种情况。

给现有原型对象增加或修改属性——会立即生效,因为实例的 __proto__ 引用的就是同一个对象:

var A = function(name) { this.name = name; };
var a = new A('alpha');
a.name;      // 'alpha'
A.prototype.x = 23;
a.x;         // 23

整体替换 prototype 属性——不会影响已有实例,它们的 __proto__ 仍指向旧对象:

var A = function(name) { this.name = name; };
var a = new A('alpha');
a.name;      // 'alpha'
A.prototype = { x: 23 };
a.x;         // undefined(不是 23)

这也解释了一个常见陷阱:替换 prototype 之后,新的原型对象丢失了默认的 constructor 属性,需要手动补回 A.prototype.constructor = A。

默认原型长什么样

就是一个带有 constructor 属性、指回构造函数本身的对象:

var A = function() {};
A.prototype.constructor == A; // true

var a = new A();
a.constructor == A;           // true(继承自原型)

instanceof 与原型的关系

如果 A.prototype 出现在 a 的原型链上,那么 a instanceof A 返回 true。判定依据是原型链,而不是构造函数——这意味着它确实可以被"骗过":

var A = function() {};
var a = new A();

a.__proto__ == A.prototype; // true
a instanceof A;             // true

// 篡改 a 的原型
a.__proto__ = Function.prototype;
a instanceof A;             // false

反过来也成立:把某个构造函数的 prototype 挂到对象的原型链上,instanceof 就会对该构造函数返回 true。所以 instanceof 适合做原型链上的能力判断,不适合做严格的类型校验。

扩展内置构造函数

既然每个构造函数都有 prototype,那么 String、Array、Function 这些内置类型也不例外。通过扩展(而非替换)它们的原型,就能给所有该类型的对象添加方法:

String.prototype.times = function(count) {
  return count < 1 ? '' : new Array(count + 1).join(this);
};

"hello!".times(3);   // "hello!hello!hello!"
"please...".times(6); // "please...please...please...please...please...please..."

需要提醒的是,这种做法在生产环境中要非常谨慎。修改内置原型可能影响第三方库,for...in 遍历时也会多出不可枚举之外的属性(老环境下)。这也是 ES5 引入 Object.defineProperty 控制属性可枚举性的动因之一。

原型链与属性查找

每个对象和每个原型都有原型,一环接一环,就形成了原型链,链的终点永远是 Object.prototype,再往上是 null。

a.__proto__ = b;
b.__proto__ = c;
c.__proto__ = {};      // 默认对象

{}.__proto__.__proto__; // null

属性查找是隐式进行的:访问 a.foo 时,引擎从 a 自身开始,沿着原型链逐环查找 foo,找到就返回;一直查到 null 都没有,则返回 undefined。写入时则相反——赋值永远写在对象自身,不会去改原型:

a.foo = 'bar'; // 在 a 上创建自有属性,原型上的 foo 被遮蔽

如果确实需要写原型上的属性,必须显式定位到原型对象:Object.getPrototypeOf(a).foo = 'bar'。

结语

把原型压缩成一句话:对象通过一条链接到另一个对象的链来查找属性,而构造函数的 prototype 属性决定了 new 出来的实例接到链的哪一环。

今天的 class 语法糖、extends 继承,最终都编译为这套原型操作。理解了这个底层模型,再去看 class、 mixin、原型继承与组合继承的取舍,就不会再觉得它们神秘。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved