原型链继承

// 将子类的原型对象 设置为 父类的实例对象  父类的原型对象
//缺点：只能实现方法的继承
function Dog(name) {
  this.name = name
}

function Cat(name) {
  this.name = name
}

function Animal() {}
Animal.prototype.fun = function () {
  console.log('跳')
}

Dog.prototype = new Animal()
Cat.prototype = new Animal()

const dog = new Dog('狗子')
const cat = new Cat('猫子')
console.log(dog)
console.log(cat)

dog.run() //结果：Animal { name: '狗子'}
cat.run() //结果：Animal { name: '猫子'}

借用构造函数继承

//实现方式：把父类构造函数内部的this改成子类构造函数内部的this 通过call()或apply()方法改变this
//缺点：只能实现属性的继承
function Animal(name) {
  this.name = name
}

function Cat(name) {
  // Animal.apply(this,[name])
  Animal.call(this, name)
}

const cat = new Cat()
console.log(cat) //结果:Cat { name: '猫子'}

组合式继承

// 把原型链继承和借用构造函数继承组合在一起
//缺点：属性继承了两次
function Animal(name) {
  this.name = name
}

Animal.prototype.run = function () {
  console.log('跳')
}

function Cat(name) {
  Animal.call(this, name) //借用构造函数继承
}
Cat.prototype = new Animal() //原型链继承

const cat = new Cat('猫子')
console.log(cat) //结果:Animal { name: '猫子' }
cat.run() //跳

寄生组合继承

//使用借用构造函数继承属性和原型链继承去继承方法 使用原型链继承的时候用Object.create()创建一个对象 ，让这个新的对象他的原型对象变成要继承的构造函数的prototype
function Animal(name){
    this.name = name
}

Animal.prototype.run = function({console.log('跳')})

function Cat(name){
    Animal.call(this,name)
}

Cat.prototype = Object.create(Animal.prototype)

const cat = new Cat() //Animal { name: '猫子', age: 6 }
cat.run() //跳

深拷贝

const obj = {
  id: 1,
  name: 'andy',
  msg: {
    age: 21,
  },
  arr: [1, 2, 3],
}

const o = {}

function deepCopy(newobj, oldobj) {
  for (let k in oldobj) {
    let item = oldobj[k]
    if (item instanceof Array) {
      newobj[k] = []
      deepCopy(newobj[k], item)
    } else if (item instanceof Object) {
      newobj[k] = {}
      deepCopy(newobj[k], item)
    } else {
      newobj[k] = item
    }
  }
}

deepCopy(o, obj)
o.msg.age = 210
o.arr = [10, 20, 30]
console.log(o)
console.log(obj)