关于继承

继承的实现方法

• 属性拷贝
• 浅拷贝
• 深拷贝
• 原型继承
• 原型式继承
• 原型链继承
• 组合继承（深拷贝+优化后的原型式继承）

1. 属性拷贝

• 直接赋值和属性拷贝
• 直接赋值

   var obj1 = {name:'aa',...};
   var obj2 = obj1;
  

• 属性拷贝

   var obj1 = {name:'aa',...};
   var obj2 = {};
   for(var i in obj1){
          obj2[i] = obj1[i];
   }
  

• 两种方式的区别及不足：
• 直接赋值：
  • 所有数据共享
  • 重新设置某个对象的引用类型值时，其余对象受影响
• 属性拷贝：
  • 引用类型是共享的

  • 重新设置某个对象的引用类型值时，其余的对象不会受影响。

    
    
    

    属性拷贝.png

2. 原型式继承

• 利用动态特性
• 直接替换原型对象
• 设置子构造函数的原型对象 = 父构造函数的原型对象

注意点（不足）：

1. 原型对象父子共享
2. 子构造函数创建的对象的构造器属性不正确（和父构造函数原型对象的构造属性相同。）

3. 无法获取父构造函数实例对象上的属性和方法（只能获得父构造函数原型对象上的属性和方法。）

   
   
   

   原型式继承.png

3. 原型链继承

子构造函数.prototype = new 父构造函数();

原型链继承.png

延伸

1. 每个对象都是由构造函数创建出来的
2. 每个构造函数都有一个与之相关连的原型对象（prototype）
3. 构造函数的原型对象本身也是对象，因此构造函数的原型对象也有自己的构造函数
4. 构造函数的原型对象的构造函数也有相关联的原型对象，而这个原型对象也是一个对象，因此也有构造函数
5. 构造函数的原型对象的构造函数的原型对象也有构造函数..也有原型对象..也是对象...构造函数....
   以上 会形成一种链式的访问结构，这种结构称为原型链

---

原型链的终点是Object.prototype ，Object.prototype的原型对象是null(Object.prototype.proto == null)所有对象原型链的终点都是Object.prototype

3.1 原型链中属性的搜索规则：

• 对象在访问（读取|写）属性的时候,先遍历当前的对象查找自身有没有指定的属性
• 如果有该属性，那么就直接使用
• 如果没有该属性，那么就遍历当前对象的原型对象，在原型对象身上查询指定的属性
  • 找到那么就直接使用
  • 没有找到，那么就继续向上查询
• 重复这个过程，直到Object.prototype,如果找到那么就使用，如果没有找到那么就返回undefined或者是报错

注意点：

1. 要注意设置原型链继承的位置：先完成原型链继承，再给原型对象添加成员

子构造函数.prototype = new 父构造函数();

2. 完成原型链继承之后最好修正构造器属性

子构造函数.prototype.contructor = 父构造函数名;

3. 完成原型链继承之后，不能使用字面量的方式来替换原型对象（继承会失效）

---

不足：

1. 父构造函数实例成员（属性+方法）会成为子购造函数创建对象的原型成员，有共享的问题
2. 无法对父构造函数传递

4. 组合继承（优化前）

• 借用构造函数 + 原型式继承

//父构造函数
function Person(name,age){
      this.name = name;
      this.age = age;
}
Person.prototype.logName=function(){
        console.log(this.name);
}
//子构造函数
function Children(name,age){
        //构造函数内部会默认创建空对象并赋值给this
        Person.call(this,name,age); //相当于this.name = name;this.age = age;(借用构造函数)
}
//原型式继承
Children.prototype = Person.prototype;
//创建实例对象
var child = new Children("小明",18);

不足：原型对象共享问题。

5. 深拷贝

• 浅拷贝：for...in循环直接拷贝（引用类型属性共享问题）
• 深拷贝：
• 使用for...in遍历被拷贝的对象。
  • 如果是值类型，直接赋值
  • 如果是引用类型，新创建一个对象，再次遍历...重复此过程

function deepCopy(obj1,obj2){
        for(var i in obj1){
            //只拷贝对象自身的属性和方法，不拷贝其原型对象中的属性和方法
            if(obj1.hasOwnProperty(i)){
                 //当为引用类型时，继续遍历-拷贝
                if(typeof obj1[i] == 'object'){
                   //区分数组类型和object类型
                    obj2[i] = Array.isArray() ? [] : {};
                    //递归
                    deepCopy(obj1[i],obj2[i]);
                } else {
                    obj2[i] = obj1[i];
                }
            }
        }
    }

6. 通过深拷贝实现继承（组合继承优化后）

//父构造函数
function Person(name,age){
      this.name = name;
      this.age = age;
}
Person.prototype.logName=function(){
        console.log(this.name);
}
//子构造函数
function Children(name,age){
        //构造函数内部会默认创建空对象并赋值给this
        Person.call(this,name,age); //相当于this.name = name;this.age = age;(借用构造函数)
}
//深拷贝
deepCopy(Person.prototype,Children.prototype);
//创建实例对象
var child = new Children("小明",18);

---

Object方法

1. Object.create()方法

• 作用：创建对象并设置为原型对象
• 用法：

var o = Object.create(obj);
//相当于：创建一个空对象o，并且设置这个对象的原型对象为obj

• 注意兼容性处理。

var o;
    if(typeof Object.create == "function") {
         o = Object.create(obj);
    }else {
        Object.create = function () {
            function F() {};
            F.prototype = obj;
            o = new F();
        }
    }

2. Object.assign()方法

• 作用：拷贝属性，一次性拷贝多个对象的属性。
• 用法：

Object.assign(目标对象，要拷贝属性的对象1，要拷贝属性的对象2，要拷贝属性的对象3)

• 注意点：
  • 新特性有兼容性问题
  • 默认原型(.proto)成员不能拷贝

3.call和apply函数

• 来源：所有的对象方法都拥有这两个函数（方法）,这两个方法写在Function.prototype上面
• 作用：借用其他对象的方法
• 用法：

对象1.方法.call(借用者对象,参数1，参数2，参数3...)   //方法内部的this会绑定给call的第一个参数
    对象1.方法.apply(借用者对象,[参数1，参数2，参数3...])

• 两个函数的区别（传递参数）：
  • 传递参数不同
  • 期望的形参长度不同（函数.length 形参的个数）
    • call：length 1 期望传递一个参数
    • apply:length 2 期望传递两个参数