assign-六大继承-类继承-深拷贝

assign-六大继承-类继承-深拷贝

// Object.assign()
// target 目标对象
// sources 源对象
function assign(target, ...sources) {
 if (target === null) {
  throw new TypeError('Cannot convert undefined or null to object');
 }

 let res = new Object(target);
 for (let i = 0; i < sources.length; i++) {
  const source = sources[i];
  if (source) {
   for (let key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
     res[key] = source[key];
    }
   }
  }
 }
 return res;
}

// 原型链继承  （1.子构造函数的prototype  指向 父组件的实例）
function SuperType1() {
  this.name = "father";
  this.habit = ["打小孩"];
}
function SubType1() {
  this.name = "children";
}
SubType1.prototype = new SuperType1();
let child1 = new SubType1();
let child2 = new SubType1();

// 借用构造函数继承（子实例不会共享所有原型对象了，但不接受传参数）
function SuperType2(name) {
  this.name = name;
  this.habit = ["打小孩"];
}
function SubType2(name) {
  this.name = name;
  SuperType2.call(this, name);
}

let child3 = new SubType2(111); //  自己传的参数无效
console.log(child3.name, "childrenname"); //father

// 组合继承 （原型链+借用构造函数）
// 缺点：调用两次父类函数
function SuperType3(name) {
  this.name = name;
  this.habit = ["打小孩"];
}
function SubType3(name) {
  SuperType3.call(this, name); //这里也调用
}
SubType3.prototype = new SuperType3(); // 这里调用
let child4 = new SubType3("组合继承"); //  自己传的参数无效
console.log(child4.name, "childrenname444"); //father

// 原型式继承（object.create)
// 只针对对象共享
function create(obj) {
  function F() {}
  F.prototype = obj;
  return new F();
}

// 寄生式继承(增强某个对象 然后返回这个对象)
function createAnother(original) {
  let clone = create(original); // 通过调用函数创建一个新对象
  clone.sayHi = function () {
    // 以某种方式增强这个对象
    console.log("你吃屁吗 我增强一个屁");
  };
  return clone; // 返回这个对象
}

// 寄生组合式继承
function inheritPrototype(subType, superType) {
  let createObj = null;
  function F() {}
  F.prototype = superType.prototype;
  console.log(F.prototype);
  createObj = new F();
  console.log(createObj.__proto__, "createObj1");
  console.log(createObj.__proto__ === superType.prototype, "createObj1");

  createObj.constructor = subType; // 增强
  subType.prototype = createObj; // 赋值x
  console.log(createObj, "createObj2");
}
function SuperType5(name) {
  this.name = name;
}
function subType5(name) {
  SuperType5.call(this, name); //这里又调用一次
}
inheritPrototype(subType5, SuperType5);

/**
 * 类继承 用extends 和 super
 */
class Person {
  constructor(name) {
    console.log(name);
    this.name = name;
  }
  show() {
    return `name: ${this.name}`;
  }
}
class User extends Person {
  constructor(name) {
    console.log(name);
    super(name);
  }
  run() {
    return super.show();
  }
}

// 深拷贝
function deepClone(obj, map = new WeakMap()) {
 if (typeof obj !== 'object') return

 if (obj instanceof Data) {
  const copyDate = new Date()
  copyDate.setTime(obj.getTime())
  return copyDate
 }

 if (obj instanceof RegExp) {
  const Constructor = obj.constructor
  return new Constructor(obj)
 }

 let newObj = obj instanceof Array ? [] : {}
 if (map.get(obj)) {
  return map.get(obj)
 }
 map.set(obj, newObj)

 for (let key in obj) {
  if (obj.hasOwnProperty(key)) {
   newObj[key] = obj[key] instanceof Object ? deepClone(obj[key]) : obj[key]
  }
 }
 return newObj
}