一. 关于原型

记住以下几点：

  1. 所有的引用类型（数组，对象，函数）都有一个__proto__（隐式原型）属性,属性值是一个普通的对象。

  2. 所有的函数都有一个prototype(显式原型)属性，属性值也是一个普通对象

  3. 所有的引用类型（数组，对象，函数），他的proto属性指向它的构造函数的prototype属性

  4. 基础类型没有proto属性(也没有instanceof之类的，但是new出来的有)

1
2
3
4
const obj = new Object()


obj.__proto__ === Object.prototype    //true
1
2
3
4
5
6
7
8
let a = 1;
a instanceof Number //false
let b = new Number(1)
b instanceof Number //true
typeof a //number
typeof b //object
a == b //true
a === b //false

当试图得到一个对象的某个属性的时候，如果这个对象本身没有这个属性，那么会去它的proto（即它的prototype）中去寻找 

1
2
3
4
5
6
7
function Foo(){}
let f = new Foo();
//f的构造函数是Foo
f.__proto__ === Foo.prototype;  //true

//f.__proto__是一个普通对象
f.__proto__.__proto__ === Object.prototype    //true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
function Foo(name){
    this.name = name;
}
Foo.prototype.printName = function(){
    console.log(this.name)
}

var f = new Foo('Alice');
f.alertName = function(){
    alert(this.name)
}

f.printName();
f.alertName()

二. 关于原型链

1
2
3
function Foo(){}
let f = new Foo()
f.toString()

这个f就是从f.__proto__.__proto__上找到的；

f.proto 就是一个普通对象，它的proto就是Object.prototype

xxxxxx

三. 相关的方法

instanceof

f instanceof Abc : f 的proto一层一层往上看能否对应上Abc的prototype.。即看Abc.prototype是不是在f的原型链上

1
2
3
4
function Foo(){}
var f = new Foo()
f instance of Foo //true
f instance of Object //true

四. 原型链继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
function Animal(){
    
}
Animal.prototype.eat = function(){
    console.log('animal eat')
}

function Dog(){
    this.bark = function(){
        console.log('dog bark');
    }
}


//new Animal出来的对象本身就有eat属性
//即Dog.prototype.__proto__ = new Animal().__ proto__ = Animal.prototype
Dog.prototype = new Animal()

var hashiqi = new Dog()

//调用eat方法的时候，他自身没有，去hashiqi.__proto__ == Dog.prototype == new Animal()上去找，还是没有，再去new Animal().__proto__即Animal.prototype上去找，找到了
hashiqi.eat()