原型对象
Javascript，万事万物皆对象；
但是呢，对象也是有区别滴，它分为普通对象和函数对象；
也就是object和function；
什么是原型对象？
在javascript中，每当定义一个对象的时候，对象都会包含一些自带的属性，
其中，每一个函数对象都有一个属性：prototype属性，这个属性，就是指向函数的原型对象。
在JS里面，每一个对象，都有proto属性，但是只有函数对象，才有prototype属性；
原型对象和普通对象，没啥区别，只要记住原型对象就是：
构造函数.prototype={}
也就是说，原型对象（person.prototype）就是构造函数（person）的一个实例
__ proto__
JS在创建对象的时候，都有一个叫做proto的内置属性，用于指向创建他的构造函数的原型对象；
image.png
通过这个连接图，我们可以看到
Person.prototype.constructor = Person； //构造函数的指针指向他自己
person1._proto_ == Person.prototype； //实例对象的_proto_就是构造函数的原型对象
person1.constructor == Person; //实例对象的指针，是指向构造函数；
那么，这个连接链，它的重点是：他是存在于 “实例和构造函数的原型” 之间，而不是存在于 “实例和构造函数” 之间；
在javascript里面，创建对象有两种方法：
var obj = {};字面量
var obj = new Object();和上面完全相同
那么obj就是构造函数的一个实例，所以
obj.constructor ===Object;
obj._proto_ ===Object.prototype;
也就是说，我们实例化的obj变量（实例化对象），他的指针，指向object这个构造函数
他的我_proto_指向Object的原型对象；
我们用来创建对象的构造函数又称之为构造器；
面向对象继承
第一种方法
/*第一个方法，构造函数的绑定，也是最简单的方法*/
/*使用call或者apply方法，将父对象的构造函数绑定在子对象上， 那么就在子对象加一句话就可以了*/
function Xs(){
this.type = "学生";
}
function Dxs(name,age){
Xs.apply(this,arguments);
this.name = name;
this.age = age;
}
var mmm = new Dxs("某某某",18);
console.log(mmm.type);
第二种方法（常用）
function Xs(){
this.type = "学生";
}
function Dxs(name,age){
this.name = name;
this.age = age;
}
Dxs.prototype = new Xs();
//将我们的Dsx的prototype对象指向Xs的实例，它会删除prototype对象原本的值，并且赋予一个新值（就是替换）
Dxs.prototype.constructor = Dxs();
console.log(Dxs.prototype.constructor==Dxs)；
//任何一个prototype对象，都有一个constructor属性，这个属性指向他的构造函数，前面提到过，这是一个指针，把prototype指向Dxs；
//如果没有Dxs.prototype = new Xs();这一行代码，Dsx.prototype.constructor指向谁？指向大学生
//但是，我们加入Dxs.prototype = new Xs();这一行后，Dxs的prototype是不是指向Xs，那么这个constructor指针是不是指向Xs
//也就是说，我们直接使用prototype继承，会导致继承链非常混乱，那么我们必须手动纠正回来
//必须必须必须注意，在编程的过程中，务必遵循，如果替换了prototype对象，
//那么，下一步必须给这个prototype对象添加上constructor属性，并指回原本自己的构造函数；
var mmm = new Dxs("某某某",18);
console.log(mmm.type);
第三种方法
function Xs(){}
Xs.prototype.type = "学生";
function Dxs(name,age){
this.name = name;
this.age = age;
}
Dxs.prototype = Xs.prototype;
Dxs.prototype.constructor = Dxs;
Dxs.prototype.type = "大学生";
var mmm = new Dxs("某某某",18);
console.log(Xs.prototype.type);
/*优点：效率比较高，不用创建Xs的实例对象，比较省内存*/
/*缺点：Dxs.prototype和Xs的prototype现在指向了同一个对象了*/
/*Dxs.prototype.type = '大学生';
console.log(Xs.prototype.type);*/
//所以，这个方法是有问题的，问题出在哪儿？
//Dxs.prototype.constructor = Dxs;
//这一行代码，把Xs.prototype对象的constructor属性也给改掉了
第四种方法：利用空对象最为中介（常用）
function Xs(){}
Xs.prototype.type = "学生";
function Dxs(name,age){
this.name = name;
this.age = age;
}
//Dxs.prototype = new Kong();
//Dxs.prototype.constructor = Dxs;
function extend(Child,Parent){
var Kong = function(){};
Kong.prototype = Xs.prototype;
Child.prototype = new Kong();
Child.prototype.constructor = Child;
Child.end = Child.prototype;
//意思，为子对象设置一个end属性，这个属性指向父对象的prototype属性，end(自定义属性)是“向上”、“上一层”的意思
//这个就相当于给子对象开了一条路，可以直接调用父对象方法，在这里只是为了实现继承的完整性，属于备用性质，
//因为子对象继承的是空对象，所以要通过这行代码才能调用得到父对象；
}
extend(Dxs,Xs);
var mmm = new Dxs("某某某",18);
console.log(mmm.type);
第五种方法：克隆
function extend(Child,Parent){
var p = Parent.prototype;
var c = Child.prototype;
for(var i in p){
c[i]=p[i];
}
c.uber = p;
}
function Xs(){}
Xs.prototype.type = '学生';
function Dxs(name,age){
this.name = name;
this.age = age;
}
extend(Dxs,Xs);
var wzq = new Dxs('吴泽权',18)
alert(wzq.type);
原型链
function Person(name,age){
this.name = name;
this.age = age;
}
var p1 = new Person('吴泽权',19);
//p1._proto_是什么东西？
//是不是Person.prototype；
/*因为实例对象._proto_等于构造函数的原型对象*/
/*也就是说，p1._proto_等于Person.prototype*/
/*__proto__每一边有两个下划线*/
console.log(p1.__proto__ === Person.prototype)//true
//Person.__proto__又是什么？
//前面说过，实例对象的__proto__等于构造函数的prototype
//因为Person是通过function来写出来的
//也就是说，Person是通过new Function来构造出来的实例对象；
//Person.__proto__===Function.prototype;
console.log(Person.__proto__==Function.prototype);
//Person.prototype.__proto__又是什么呢？
//前面说过，对象分为函数对象和普通对象，prototype他不是函数对象，他只是函数对象衍生的普通对象
//普通对象就是由Object构造的
//那么Person.prototype.__proto__就是等于Object.prototype
console.log(Person.prototype.__proto__==Object.prototype)
//Object.__proto__又是什么？
//和第二题一样，不论是Object还是Function，都是通过函数构造的
console.log(Object.__proto__==Function.prototype);
//Object.prototype.__proto__又是什么呢？
//记住，Object对象的原型对象，已经是处于原型链的顶端了，顶端没有东西了啊，所以是null
console.log(Object.prototype.__proto__==null)
前面说过，所有的函数对象的__proto__(原型)都指向Function.prototype
在JS里面，有十多个构造器：例如Number、Object、Array、Date;
他们这些构造器的原型都是Function.prototype
而Math、JSON是以对象的形式存在，不需要new就可以声明，所以他们的原型（__proto__）就是Object.prototy；
也就是说：
所有的构造器都来自Function.prototype，甚至包括根构造器Object以及Function自身，也就是说，所有的构造器都继承了Function.prototype的属性以及方法，比如说length、call、apply
也就是说，构造器的__proto__就是Function.prototype，那么Function.prototype的原型（__proto__）又是谁呢？
在Javascript里面，函数是一等公民
也就是说，所有的构造器也都是一个普通的JS对象，同时它也继承了Object.prototype上面的所有方法：toString,valueOf
Object.protot又是谁呢？
已经到顶了，就是null
之前学习Js，可以使用很多内置方法
parseInt()、toString()，都可以使用，为什么可以使用呢？
因为，当我们创建一个函数的时候，
var peoson = new Object()；
person是Object的实例，所以继承了Object.prototype的所有方法
例如，当我们创建一个数组的时候，是不是数组就继承了Array.prototype上面的所有方法，所以我们之所以能用那么多的方法，就是因为继承
console.log(Date.__proto__==Function.prototype);
console.log(Math.__proto__==Object.prototype);
console.log(Function.prototype.__proto__==Object.prototype);
console.log(Object.prototype)
console.log(Array.prototype)
var num = [1,2,3,]
console.log(num.hasOwnProperty())
/*虽然Array.prototype没有hasOwnProperty()这个方法，但是他有原型，他的原型是不是__proto__*/
//Array()是继承自Object，那么Array.__proto__==Object.prototype
/*所以,当你使用num.hasOwnProperty()的时候,JS会先找到他的构造函数(Array)的原型对象Array.prototype,看下他有没有hasOwnProperty()
没有的话,一路按照原型对象找下去,下一步就是找Arry.prototype的原型对象,那么就是找Array.prototype.__proto__*/
总结：
原型和原型链是JS实现继承的一种模型
原型链的形成，真正是靠的__proto__,而不是prototype；
