js中有一个话，叫万物皆对象，因为js是基于原型的
原型
当我们创建一个对象时 let obj = { age: 25 }，我们可以发现能使用很多种函数，但是我们明明没有定义过它们，对于这种情况你是否有过疑惑？
image.png
当我们在浏览器中打印 obj 时你会发现，在 obj 上居然还有一个 proto 属性，那么看来之前的疑问就和这个属性有关系了。
其实每个 JS 对象都有 proto 属性，这个属性指向了原型。这个属性在现在来说已经不推荐直接去使用它了，这只是浏览器在早期为了让我们访问到内部属性 [[prototype]] 来实现的一个东西。
讲到这里好像还是没有弄明白什么是原型，接下来让我们再看看 proto 里面有什么吧。
image.png
看到这里你应该明白了，原型也是一个对象，并且这个对象中包含了很多函数，所以我们可以得出一个结论：对于 obj 来说，可以通过 proto 找到一个原型对象，在该对象中定义了很多函数让我们来使用。
在上面的图中我们还可以发现一个 constructor 属性，也就是构造函数
image.png
打开 constructor 属性我们又可以发现其中还有一个 prototype 属性，并且这个属性对应的值和先前我们在 proto 中看到的一模一样。所以我们又可以得出一个结论：原型的 constructor 属性指向构造函数，构造函数又通过 prototype 属性指回原型，但是并不是所有函数都具有这个属性，Function.prototype.bind() 就没有这个属性。
所以每一个构造函数都有一个原型对象(也就是Person.prototype)，每一个原型对象都有一个指针constructor指向构造函数，每一个实例都有一个内部指针（proto），指向原型对象，原型对象上的属性和方法能被实例所访问
继承
类与类之间的关系 基类 父类 子类
//call&apply方法实现继承
function Person(name,age){
this.name = name;
this.age = age;
this.sayHello = function (){
console.log(this.name);
}
}
function Male(name,age){
//继承父类Person call&apply 调用的是父类的构造函数
// Person.call(this,name,age);
Person.apply(this,[name,age]);
}
var male = new Male("ly",20);
male.sayHello();
//这里不能用call&apply的原因是父类的构造函数里边什么也没有 现在要调用的是父类的原型对象
function Person(){
}
//Person.prototype里的属性和方法可以被Person的实例访问到
Person.prototype.name = "jhon";
Person.prototype.age = 20;
Person.prototype.sayHello = function (){
console.log(this.name);
}
function Male(){
this.sayHi=function (){
console.log("aa")
}
}
//Male.prototype.__proto__ 指向Person.prototype
Male.prototype = new Person();
//Male.prototype = Person.prototype;
var male = new Male();
male.sayHello();
console.log(male.__proto__);//正常情况下应该指向Male.prototype 但是现在指向Person.prototype
//male.__proto__ -> Male.prototype Male.prototype.__proto__ -> Person.prototype
//当male调用sayhello方法时会找到Male.prototype，如果Male.prototype没有的话就会继续向它的父类找，直到找到Object.prototype停止，Object.prototype.__proto__为null
//原型链 原型链上的属性和方法都能被实例所访问到
console.log(male.__proto__ == Male.prototype);//true
console.log(Male.prototype.__proto__ == Person.prototype);//true
male.sayHi();
var obj = {};
//将其他类型转换成字符串时，默认会调用toString方法，这个方法是顶层原型对象上的方法，可以改写,改写之后，转换的结果以改写结果为准
obj.toString = function(){
return 111111;
}
document.write(obj);//111111
### 组合继承
function Person(name,age){
this.name = name;
this.age = age;
}
Person.prototype.sayHello = function (){
console.log(this.name);
}
function Male(name,age){
Person.call(this,name,age);
}
//Male.prototype = new Person();
//弊端在于Person.call的时候运行了一次构造函数Person，当Male.prototype = new Person()的时候又运行了一次
// Male.prototype = Person.prototype;
// //这时候Person.call指向的是Person里的name和age，而Male.prototype = Person.prototype指的是sayhello 弊端是这时候相当于传址，父类person的实例也能够访问到子类Male里的原型对象的方法，而这是不合道理的
// Male.prototype.sayHi = function(){
// console.log("aa");
// }
// var person = new Person();
// person.sayHi();
//遍历person.prototype call继承实例属性 这种方式继承原型方法
for(var i in Person.prototype){
Male.prototype[i] = Person.prototype[i];
}
var male = new Male("ly",20);
male.sayHello();
寄生式组合继承 Object.create()
var obj1 = {a:1};
var obj2 = {b:2};
var a = Object.create(obj1);
console.log(a.__proto__);//结果是a:1 这时候的obj1是作为创建出来的实例a的原型对象存在 a.__proto__指obj1
function Person(name,age){
this.name = name;
this.age = age;
}
Person.prototype.sayHello = function (){
console.log(this.name);
}
function Male(name,age){
Person.call(this,name,age);
}
Male.prototype = Object.create(Person.prototype);
Male.prototype.constructor = Male;
var male = new Male("ly",20);
male.sayHello();
console.log(male.__proto__.constructor);//本来应该指向Male 但是现在指向了Person 需要加上Male.prototype.constructor = Male 让它的原型对象指向自己
ES6继承
class Person{
constructor(name,age){
this.name = name;
this.age = age;
}
sayHello(){
console.log(this.name);
}
//static 是一个静态方法 也就是说foo可以认为是这个构造函数自带的一个方法
static foo(){
console.log("aa");
}
}
console.log(Person.prototype)
//用到exends关键字和super方法
class Male extends Person{
constructor(name,age){
//相当于拿到了Person的this.name和this.age 同时改变了this指向
super(name,age)
}
sayHi(){
super.sayHello();
}
}
var male = new Male("ly",20);
male.sayHello();
male.sayHi();//结果一样
