一. 普通对象与构造函数对象

ECMAScript 中,除了基本数据类型(Undefined, Null, Boolean, Number, String),都是对象类型(Object),分为普通对象函数对象(构造函数),Array、Date、Function 都是 JS 自带的函数对象。

凡是通过new Function()创建的对象都是函数对象(Object 、Array、Date、Function 等),其他的都是普通对象。(原型对象都是普通对象,Function.prototype是函数对象,因为他是通过new Function()创建,它很特殊,他没有prototype属性)。

二. 构造函数

实例的constructor属性指向构造函数

1
2
var 实例 = new 构造函数()
实例.constructor === 构造函数

三. 原型对象

每个函数对象都有一个prototype属性(显式原型),这个属性指向函数的原型对象**

每个对象都有 __proto__ 属性(隐式原型),但只有函数对象才有 prototype 属性

在默认情况下,所有的原型对象都会自动获得一个 constructor(构造函数)属性,这个属性(是一个指针)指向prototype 属性所在的函数,即:

1
2
3
4
Function.prototype.constructor == Function
Object.prototype.constructor == Object
Function.prototype.prototype == undefined
Object.prototype.__proto__ === null
1
2
var A = new Function()
Function.prototype = A

A 表示原型对象

结论:原型对象(Person.prototype)是 构造函数(Person)的一个实例。

四. __proto__属性

即对象的显式原型

实例对象的__proto__属性是构造函数的原型对象(prototype,即显式原型)

1
2
var 实例 = new 构造函数()
实例.__proto__ === 构造函数.prototype

结论:显式原型指向创建这个对象的函数(constructor)的 prototype

五. 构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var a = new Object() //等价于var a = {}
a.constructor === Object
a.__proto__ === Object.prototype

var b = new Array() //等价于var b = []
b.constructor === Array
b.__proto__ === Array.prototype

var c = new Date()
c.constructor === Date
c.__proto__ === Date.prototype

var d = new Function()
d.constructor === Function
d.__proto__ === Function.prototype

//以上构造器都是函数对象
typeof Object // "function"
typeof Array // "function"
typeof Date // "function"
typeof Function // "function"
typeof Number // "function"
typeof String // "function"
typeof Boolean // "function"

六. 原型链

1
2
3
4
5
6
实例.__proto__ === 构造函数.prototype
构造函数.__proto__ === Function.prototype
构造函数.prototype.__proto__ === Object.prototype //构造函数.prototype 是一个普通对象,普通对象的构造函数 === Object
Object.__proto__ === Function.prototype

Object.prototype.__proto__ === null //原型链的终点

七. 函数对象

所有构造函数(函数对象, 包括自定义的函数)的__proto__属性都指向 Function.prototype,它是一个空函数(Empty function)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
String.__proto__ === Function.prototype // true
String.constructor == Function //true

Number.__proto__ === Function.prototype // true
Number.constructor == Function //true

Boolean.__proto__ === Function.prototype // true
Boolean.constructor == Function //true

Object.__proto__ === Function.prototype // true
Object.constructor == Function // true

Array.__proto__ === Function.prototype // true
Array.constructor == Function //true

Function.__proto__ === Function.prototype // true
Function.constructor == Function //true

RegExp.__proto__ === Function.prototype // true
RegExp.constructor == Function //true

Error.__proto__ === Function.prototype // true
Error.constructor == Function //true

Date.__proto__ === Function.prototype // true
Date.constructor == Function //true

// 所有的构造器都来自于Function.prototype,甚至包括根构造器Object及Function自身

JavaScript 中有内置(build-in)构造器/对象共计 12 个String, Number, Boolean, Object, Array, Function, RegExp, Error, Date, Global, Arguments, Math, JSON(ES5 中新加了 JSON),这里列举了可访问的 8 个构造器。剩下如 Global 不能直接访问,Arguments 仅在函数调用时由 JS 引擎创建,Math,JSON 是以对象形式存在的,无需 new。它们的 proto 是 Object.prototype。如下

1
2
3
4
5
Math.__proto__ === Object.prototype // true
Math.construrctor == Object // true

JSON.__proto__ === Object.prototype // true
JSON.construrctor == Object //true

所有构造器都继承了Function.prototype的属性及方法。如length、call、apply、bind...

Function.prototype是唯一一个typeof XXX.prototypefunctionprototype。其它的构造器的prototype都是普通对象object

1
2
3
4
5
6
// 对比理解
Function.prototype.__proto__ === Object.prototype
Function.__proto__ === Function.prototype

Object.prototype.__proto__ === null
Object.__proto__ === Function.prototype

八. Prototype

在 ECMAScript 核心所定义的全部属性中,最耐人寻味的就要数 prototype 属性了。对于 ECMAScript 中的引用类型而言,prototype 是保存着它们所有实例方法的真正所在。换句话所说,诸如 toString()valuseOf() 等方法实际上都保存在 prototype 名下,只不过是通过各自对象的实例访问罢了。

——《JavaScript 高级程序设计》第三版 P116

当我们创建一个函数时:var Person = new Object()

PersonObject 的实例,所以 Person 继承Object 的原型对象Object.prototype上所有的方法。

所以我可以用 Person.constructor 也可以用 Person.hasOwnProperty等等。

九. 复习

1
2
3
4
5
6
7
8
9
10
11
12
function Person(name) {
this.name = name
}
// 修改原型
//Person.prototype.getName = function() {}
// 重写原型
Person.prototype = {
getName: function() {}
}
var p = new Person('jack')
console.log(p.__proto__ === Person.prototype) // true
console.log(p.__proto__ === p.constructor.prototype) // false

这里如果直接重写 Person.prototype(与修改原型对比)。输出结果可以看出p.__proto__仍然指向的是Person.prototype,却不等于p.constructor.prototype

这也很好理解,给Person.prototype赋值的是一个对象直接量{getName: function(){}}使用对象直接量方式定义的对象其构造器(constructor)指向的是根构造器ObjectObject.prototype是一个空对象{}{}自然与{getName: function(){}}不等。

十. 总结

  • 原型和原型链是 JS 实现继承的一种模型。
  • 原型链的形成是真正是靠__proto__ 而非prototype
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function Person() {}
var person1 = new Person()
console.log(person1.__proto__ === Person.prototype) // true
console.log(Person.prototype.__proto__ === Object.prototype) //true
console.log(Object.prototype.__proto__) //null

Person.__proto__ == Function.prototype //true
console.log(Function.prototype) // function(){} (空函数)

var num = new Array()
console.log(num.__proto__ == Array.prototype) // true
console.log(Array.prototype.__proto__ == Object.prototype) // true
console.log(Array.prototype) // [] (空数组)
console.log(Object.prototype.__proto__) //null

console.log(Array.__proto__ == Function.prototype) // true

Function.prototype.__proto__ === Object.prototype//true

其实这一点我也有点困惑,不过也可以试着解释一下。

Function.prototype是个函数对象,理论上他的__proto__应该指向 Function.prototype,就是他自己,自己指向自己,没有意义。

JS 一直强调万物皆对象,函数对象也是对象,给他认个祖宗,指向Object.prototypeObject.prototype.__proto__ === null,保证原型链能够正常结束。

全局对象(Global)是普通对象,没有构造函数,无法实例化。

参考

JS 原型与原型链终极详解