原型(prototype)大概是 JavaScript 里最让人纠结的概念。有意思的是,不只是初学者,很多经验丰富的开发者、甚至语言作者本人,在解释它的时候都显得小心翼翼。我认为问题的根源在于我们最早接触原型的方式:它总是和 new、constructor 以及那个令人困惑的 prototype 属性捆绑在一起出现。
事实上,原型是一个相当简单的概念。想真正理解它,得先把"学到的那套构造原型"忘掉,回到源头重新看。
原型就是一个被其他对象用来继承属性的对象。
就这么简单。任何对象都可以充当原型,没有类型限制。
哪些对象拥有原型?所有对象。原型本身也是对象,因此原型也有自己的原型,如此层层向上,直到原型链的顶端。唯一的例外是默认的 Object.prototype,它的原型是 null,链到此终止。
顺便明确一下"对象"的定义:在 JavaScript 中,除了 undefined、null、boolean、number、string 这几种原始类型之外,其余都是对象;对象是以键值对形式保存的无序集合。
很多人写代码时会撞上这一行:
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 属性。
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 方法只存在一份,位于共享的原型对象上。这就是原型带来的性能与可维护性收益。
要分两种情况。
给现有原型对象增加或修改属性——会立即生效,因为实例的 __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(继承自原型)
如果 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、原型继承与组合继承的取舍,就不会再觉得它们神秘。