JavaScript原型和原型链（重点）

原型对象prototype

• 每一个函数对象都有一个prototype属性，但是普通对象是没有的
• 普通对象都是通过函数创建的

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

JS所有对象分为函数对象和普通对象。凡是通过new Function()创建得来的对象都是函数对象。函数对象拥有prototype属性和proto属性。

prototype

JS设计之初为了实现简单继承，引入了prototype属性，也叫原型对象（显式原型）。

//原型对象
function Animal(){};  

console.log(typeof Animal.prototype) //Object  
console.log(typeof Object.prototype) // Object  

可以看出，从本质上讲，prototype是一个普通对象，是函数对象的构造函数创建的一个实例。相当于在Animal创建的时候，自动创建了一个它的实例，并且把这个实例赋值给了prototype。

但是存在一个特例Function， Function.prototype是原型对象，本质却是函数对象。作为一个函数对象，又没有prototype属性

console.log(typeof Function.prototype) // 特殊 Function  
console.log(typeof Function.prototype.prototype) //undefined 函数对象却没有prototype属性

proto属性
所有的对象obj(null和undefined除外)都具有proto属性（隐式原型），proto属性在本质上为一个指针，指向创造obj对象的函数对象的prototype属性。

//创建构造函数
        function Animal(name,age){
            this.name = name;
            this.age= age;
        }
        Animal.prototype = {
            alertName(){
                alert(this.name);
            }
        }
        //创建实例
        var dog = new Animal("大黄");
        dog .print = function(){
             alert(this.name);
        }
        dog.print();  //大黄
        dog.alertName();  //大黄

print()方法是dog实例本身具有的方法，所以dog.print()输出“大黄”；alertName()不属于dog实例的方法，属于构造函数的方法，dog.alertName()也会输出“大黄”，是因为dog实例继承了构造函数的方法。

实例dog的隐式原型指向它构造函数的显式原型，指向的意思是恒等于，即

dog.__proto__ === Animal.prototype// true

构造器constructor

构造器constructor就是用来构造函数对象的，constructor 属性返回对创建此对象的函数对象的引用。通俗了讲就是指向当前对象的爸爸

function Dog(){};
console.log(a.constructor===Function); //true
console.log(a.prototype.constructor===a); //true

函数a是由Function创造出来,那么它的constructor指向的Function,a.prototype是由new a()方式创造出来,那么a.prototype.constructor理应指向a。

原型链

原型链是JS中实现继承的主要方法。其基本思想就是让一个引用类型继承另一个引用类型的属性和方法。

function Animal(){  
    this.animalType = "animal";  
}  
Animal.prototype.getAnimalType = function(){  
    return this.animalType ;  
}  

function Dog(){  
    this.Dogtype = "dog";  
}  
Dog.prototype = new Animal();  

Dog.prototype.getDogType = function(){  
    return this.Dogtype ;  
}  

var dahuang = new Dog();

alert(dahuang.getAnimalType ());// animal

dahuang.getAnimalType ()打印结果为animal，dahuang自身没有getAnimalType ()方法，那么就会去它的proto(即它的构造函数的prototype)中寻找，发现Dog中也没有，于是顺着proto再往上找，在Animal.prototype.getAnimalType找到，返回结果 。

如果Animal中还是没有，就接着往上找，一直到Object.prototype原型对象终止

• 总结得出原型链就是：
  如果在对象上没有找到需要的属性或者方法引用，引擎就会在[[prototype]]关联的对象上进行查找。同理，如果在后者中也没有找到需要的引用就会继续查找它[[prototype]，以此类推。一直到Object.prototype原型对象终止，这就是原型链。Object.prototype是原型链的顶端。

如果找到Object.prototype上还找不到，原路返回，告诉实例此方法或属性没有找到或者没有定义。如果说在中间的任意一个环节找到了，就停止向上查找直接返回结果

原型对象和原型链的作用

如果构造函数中有很多属性和方法，那么构造函数所有的实例化对象都是公用这些属性和方法的，当有多个实例想用共用这些东西的时候，每个实例都拷贝一份，就造成极大的资源浪费，那是不是可以考虑存把这些需要共用的属性和方法放到一个共同的东西上。这个共同的东西就是原型对象（prototype）。

当然原型链实现继承也会存在一些问题，最主要的问题来自包含引用类型的原型。其次就是在创建子类型的实例时，不能向超类型的构造函数中传递参数。

构造函数、实例对象、原型对象三者之间的关系

任何函数都具有一个 prototype 属性，该属性是一个对象。

function F () {}
console.log(F.prototype) // => object

F.prototype.sayHi = function () {
  console.log('hi!')
}

构造函数的 prototype 对象默认都有一个 constructor 属性，指向 prototype 对象所在函数。

console.log(F.constructor === F) // => true

通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__

var instance = new F()
console.log(instance.__proto__ === F.prototype) // => true

__proto__ 是非标准属性。

实例对象可以直接访问原型对象成员。

instance.sayHi() // => hi!

总结：

• 任何函数都具有一个 prototype 属性，该属性是一个对象
• 构造函数的 prototype 对象默认都有一个 constructor 属性，指向 prototype 对象所在函数
• 通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__
• 所有实例都直接或间接继承了原型对象的成员