function SuperFn(name) {    this.name = name || 'super';    this.arr = [1, 2];}SuperFn.prototype.sayName = function () {    console.log(this.name)}/*  基于原型继承: SubFn1.prototype = new SuperFn();    问题点：    - 原型对象的 constructor 属性值变为 Object    - 原型对象中包含引用值，值操作会同时反应到所有继承对象上    - 子类型在实例化时不能给父类型的构造函数传参*/function SubFn1() {}// 继承属性和方法：SubFn1 的原型指向 SuperFn 的实例和方法// 带来的影响：//   - SubFn1 的构造函数变为 Object//   - SuperFn 的实例对象中包含引用值，值操作会同时反应到所有继承对象上SubFn1.prototype = new SuperFn();
const sub1 = new SubFn1();const sub11 = new SubFn1();sub11.name = 'sub11';sub11.arr.push(3);
sub1.sayName(); // 'super'console.log(sub1.name, sub1.arr,sub1.arr === sub11.arr, sub1 instanceof SubFn1, sub1.constructor ===SubFn1); // 'super'  [1,2,3] true true  false

/* 借用构造函数：SuperFn.call(this)   问题点：    - 只能继承父类的实例属性和方法，不能继承原型属性/方法    - 字类构造函数无法实现复用，每个子类都有父类实例函数的副本*/function SubFn2() {   // 继承属性：子类构造函数中调用父类构造函数并绑定 this ，   // 每次创建实例的过程，函数都会重新执行，同一个属性每次都会新建   SuperFn.call(this, ...arguments)}
const sub2 = new SubFn2('sub2');const sub22 = new SubFn2();sub22.name = 'sub22';sub22.arr.push(3);
// sub2.sayName(); // 报错console.log(sub2.name, sub2.arr,sub2.arr === sub22.arr, sub2 instanceof SubFn2, sub2.constructor ===SubFn2); // 'sub2'  [1,2]  false true  true

/* 组合继承：SuperFn.call(this)  SubFn3.prototype.__proto__ = SuperFn.prototype;   问题点：属性重复建立*/function SubFn3() {   // 继承属性：子类构造函数中调用父类构造函数并绑定 this ，   //每次创建实例的过程，函数都会重新执行，同一个属性每次都会新建   SuperFn.call(this, ...arguments)}// 继承方法SubFn3.prototype.__proto__ = SuperFn.prototype;
const sub3 = new SubFn3('sub3');const sub33 = new SubFn3();sub33.name = 'sub33';sub33.arr.push(3);
sub3.sayName(); // 'sub3'console.log(sub3.name, sub3.arr,sub3.arr === sub33.arr, sub3 instanceof SubFn3, sub3.constructor ===SubFn3); // 'sub3'  [1,2]  false true true 

/* 原型式继承:此种方式和 Object.create() 实现的功能相同   问题点：    - 原型对象中包含引用值，值操作会同时反应到所有继承对象上    - 无法传递参数*/
// 此函数用来创建一个对象，对象的原型指向传递的参数（继承的对象）let Fn;function CreateObj(obj) {   // 函数内部定义构造函数   function F() {}   Fn = F;   // 构造函数的原型对象指向传递的进来的对象   F.prototype = obj;   // 创建实例化对象并返回，此实例对象的 __proto__ = F.prototype = obj   return new F();}const SuperObj = {   name: 'super',   arr: [1, 2],   sayName() {       console.log(this.name)   }}
const sub4 = CreateObj(SuperObj); // 等价于 sub4 = Object.create(SuperObj) sub4.__proto__ = SuperObjconst sub44 = CreateObj(SuperObj);
sub44.name = 'sub44';sub44.arr.push(3);
sub4.sayName(); // 'super'console.log(sub4.name, sub4.arr, sub4.arr === sub44.arr,sub4 instanceof Fn, sub4.constructor === Object); // 'super'  [1,2,3] true true true  

/* 5.寄生式组合继承*/
function inheritPrototype(SuperFn, SubFn) {   //此函数实现的目的如下  SubFn.prototype.__proto__ = SuperFn.prototype   SubFn.prototype = Object.create(SuperFn.prototype);   SubFn.prototype.constructor = SubFn;}
function SubFn5() {   SuperFn.call(this, ...arguments);}inheritPrototype(SuperFn, SubFn5);
const sub5 = new SubFn5();const sub55 = new SubFn5();sub55.name = 'sub55';sub55.arr.push(3);
sub5.sayName(); // 'super'console.log(sub5.name, sub5.arr,sub5.arr === sub55.arr, sub5 instanceof SubFn5,sub5.constructor ===SubFn5); // 'super'  [1,2]  false true true