什么是繼承
大多數使用繼承不外乎是為了獲得兩點好處，代碼的抽象和代碼的復用。
代碼的抽象不用說了，交通工具和汽車這類的例子數不勝數，在傳統的語言中（java）代碼的抽象更多是使用接口來實現，而試驗繼承更多的是為了代碼的復用。
怎么復用的？打個比方，classa繼承了classb，classa便擁有了classb的公有和私有的變量和方法，便是classb將這些屬性和方法直接copy給classa。這樣便實現了繼承。因此我們可以這樣說，繼承實際上是一種類與類之間的copy行為。從另一個方面來說，js的數據類型分文基本數據類型和引用數據類型，我們在對數據進行復制的時候，如果這個數據是基本數據類型那很好辦，直接賦值就好，如果在使用js對對象或數組進行操作的時候，經常要將數組進行備份，事實證明如果只是簡單的將它賦值其他變量，那么我們只要更改其中的任何一個，其他的也會跟著改變，這就導致了問題的發生。
js中的繼承
在js中沒有類的概念，只有對象。雖然，現在人們經常使用class關鍵字，這讓js看起來似乎是擁有了“類”，可表面看到的不一定是本質，class只是一塊糖，嚼碎了才知道里面其實還是原型鏈那一套。因此，js中的繼承只是對象與對象之間的繼承。反觀繼承的本質，繼承便是讓子類擁有父類的一些屬性和方法，那么在js中便是讓一個對象擁有另一個對象的屬性和方法。
所以，這給我們一條十分清晰的思路。js中如何實現繼承？只需讓一個對象擁有另一個對象的屬性和方法，這就實現了。
淺拷貝
既然讓一個對象擁有另一個對象的屬性和方法，首先想到的便是粗暴的方式，直接將對象的屬性和方法強制copy到另一個對象。
var person={
name:'cj';
age:22;
}
var programer={
language:'js'
}
function extend(p,c){
var c={};
for(var prop in p){
c[prop]=p[prop]
}
}
局限性:如果person加上一個adress對象即address{home:'home address'}當programer.address.home='home'即改變時，person.address.home也跟著改變，因為兩個對象指向的是同一個地址，拷貝的只是引用，也就是淺拷貝。
深拷貝
var person={
name:'cj';
age:22;
adderss{name:'home address'}
}
var programer={
language:'js'
}
function extend(p,c){
var c={};
for(var prop in p){
if(typeof p[prop] ==='object'){
c[prop]=p[prop].constructor===Array?[]:{};
extend(p[prop],c[prop])
}else{c[prop]=p[prop]}
}
}
深拷貝用遞歸的方式來復制子對象里面的所有屬性和方法，直到子子屬性為基本數據類型。
原型鏈繼承
如何使用原型鏈來實現繼承呢？這要歸功于js中的委托機制。
當我們獲取一個對象的某個屬性時。比如a.b，會默認調用一個內置的方法，這個內置的方法就是：
在當前對象中查找，找不到則委托給當前對象的proto。再找不到則委托給proto的proto直到object.prototype中也沒有找到，則返回undefind。
因此，我們想讓對象a擁有對象b的屬性和方法，即對象a繼承對象b，只需要把b賦值給a的proto。利用屬性的查找的委托機制，實現了a也擁有了b的屬性和方法。
前面提到，proto是個內置隱藏屬性，設計的本意是不可被讀取和修改的，那么我們如何利用原型鏈來建立繼承關系？js提供了new關鍵字。new關鍵字實現了a.proto=A.prototype這樣只需把a的構造函數的prototype連接到b 就行了。
function A(){
}
var b={
show：function(){
console.log('這是來自b的方法')
}
}
A.prototype=b
A.prototype.constructor=A
var a=new A()
a.show//這是來自b的方法
核心：原型鏈繼承子類只是繼承了父類的原型鏈上的屬性，并且在創建子類的時候不能向父類的構造函數傳遞參數。
call繼承
function Parent(){
this.x=100;
this.y=199
}
Parent.prototype,fn=function(){}
function Child(){
this.a=100;
Parent.call(this)
}
var p=new Parent();
var c=new Child();
console.log(p)//Parent{x:100,y:199}
console.log(c)//Child{d:100,x:100,y:199}
這很好理解，在子類的構造函數中，改變父類的this指向，改變為子類的實例，同時運行父類方法，這樣父類中的this.x就變成了子類的實例.x。這樣只能繼承父類的私有屬性和方法。
call繼承和原型繼承集合在一起。
===》無論是私有還是公有的屬性都拿到了。
function Parent(){
this.x=100;
}
Parent.prototype.getx=function(){}
function Child(){
Parent.call(this)
}
Child.prototype=new Parent();
Child.prototype.constructor=Child;
var p=new Parent();
var c=new Child();
console.log(c)
create繼承
var b={c:1}
var a=Object.create(b)
console.log(a.c)//1
那么create繼承是怎樣實現地呢？
var p={name:'cj'}
function create(p){
var ins;
function F(){
F.prototype=p;
ins=new F();
return ins;
}
}
var c=create(p)
c.name==>'cj'
上例中ins.__proto__=F.prototype又因為F.prototype=p所以c.name==>'cj'
繼承
-
繼承的作用
繼承可以使一個對象直接使用另一個對象的方法和屬性。
-
代碼的區別
//方法1
function People(name, sex){
this.name = name;
this.sex = sex;
this.printName = function(){
console.log(this.name);
}
}
var p1 = new People('饑人谷', 2)
//方法2
function Person(name, sex){
this.name = name;
this.sex = sex;
}
Person.prototype.printName = function(){
console.log(this.name);
}
var p1 = new Person('若愚', 27);
區別： 第二種方法將公有的屬性放在Person的prototype上，當再創建一個對象實例的時候就不用像第一種方法那樣把printName再創建一遍，而是從原型中調用就可以了。
-
Object.create的作用
Object.create() 方法會使用指定的原型對象及其屬性去創建一個新的對象。
兼容性：
-
hasOwnProperty
作用：hasOwnPerperty是Object.prototype的一個方法，可以判斷一個對象是否包含自定義屬性而不是原型鏈上的屬性，hasOwnProperty是JavaScript中唯一一個處理屬性但是不查找原型鏈的函數。
語法：obj.hasOwnProperty(prop)(prop為要檢測的屬性名稱)
-
call的作用
function Person(name, sex){
this.name = name;
this.sex = sex;
}
function Male(name, sex, age){
Person.call(this, name, sex); //在子類的構造函數中，改變父類的this指向，改變為子類的實例，同時運行父類方法，這樣父類中的this.x就變成了子類的實例.x。這樣只能繼承父類的私有屬性和方法。
this.age = age;
}
-
補全代碼
function Person(name, sex){
this.name=name;
this.sex=sex;
}
Person.prototype.getName = function(){
console.log(this.name)
};
function Male(name, sex, age){
Person.call(this,name,sex)
this.age=age
}
Male.prototype=Object.create(Person.prototype)
Male.constructor=Male;
Male.prototype.getAge = function(){
console.log(this.age)
};
var ruoyu = new Male('若愚', '男', 27);
ruoyu.printName();
