JS的寄生组合式继承

什么叫继承

  1. 在很多语言中，都有继承的概念，继承他可以让我们的代码更加简化，没有那么亢余，在实际开发过程中，我们肯定会遇到多个对象拥有共同属性的情况，这个时候我们是每个对象都写一遍重复的代码呢，还是考虑将其抽离出去，给他们一个共同的父类呢？当我们是开发中习惯了这种思维，我相信整个代码的可阅读性和可拓展性都是不可比的。

如何在js中实现继承

首先给出个概念，ES6提出的class，他是一个全新的概念吗？并不是，他只是一种语法糖。一种基于寄生组合式继承的语法糖，下面就详细的看看这到底是一个什么东西？

  1. 首先我们先定义一个普通的构造函数 

    1. //这里有个细节，或者是是一种规范，通常定义的构造函数我们会以大写字母开头，以便和普通的函数加以区分，这时社区的一种不谋而合规范，即便不遵守从代码层面来说也没问题
    2. function People(name, age) {
    3. this.name = name;
    4. this.age = age;
    5. }

  2. 然后我们给这个构造函数的原型上定义一些方法
    ```javascript People.prototype.eating = function () { console.log(“吃就完事了”); };

People.prototype.sleeping = function () { console.log(“睡就完事了”); };

  2. 3.  我们再次定义一个构造函数  
  3. ```javascript
  4. function Student(name, age, number, height, sex) {
  5.   People.call(this, name, age);
  6.   this.number = number;
  7.   this.height = height;
  8.   this.sex = sex;
  9. }
  10. //这里我们用People.call，让Student构造函数能够执行Person的方法，因为name和age我们不想重新再次复写，

  1. 给Student的原型上定义一个自己的方法 

    1. Student.prototype.wan = function () {
    2. console.log("出去玩");
    3. };

  2. 然后我们实例化一个Student对象
    ```javascript let s1 = new Student(“dw”, 18, 100, 1.98, “男”);

//s1 ——>Student { name: ‘dw’, age: 18, number: 100, height: 1.98, sex: ‘男’ }

  2. 6.  好，准备工作我们就做完了，我们做了那么多铺垫，我们的目的是什么呢？我们需要通过s1访问到Person定义的两个方法，这样的话我们就将Student和Person联系在一起了，从某种意义上来说就是实现了继承  
  3. ```javascript
  4.  Student.prototype = Object.create(People.prototype);
  5.  Object.defineProperty(Student.prototype, "constructor", {
  6.    enumerable: false,
  7.    configurable: true,
  8.    writable: true,
  9.    value: Student,
  10.  });
  11. //Object.create方法会返回一个对象，并且将传递进去的对象的原型对象作为返回对象的隐式原型   举个例子
  12. //example
  13. let test = {name:'codeywei',age:18}
  14. const obj = Object.create(test)
  15. console.log(obj.__proto__)  //{ name: 'coderwei', age: 18 }
  16. console.log(obj.prototype === test.prototype);  //true
  1. 现在我们就成功的将原本毫无关系的Person、Student联系到一起，并且实例化的Student可以访问到Person上的方法
  2. 粗略的画了一副s1、Person、Student原型图

提示

  1. 当然这种方法是有弊端的，比如说代码顺序，如果在Object.create之前创建实例对象s1或者是给Student的原型上定义方法，在后续我们是访问不到的
  2. 为什么呢？其实思考一下也能发现，js是单线程语言的解释性语言，解释一行执行一行，当创建实例s1的时候还没有将他们联系到一起，那么这个对象已经创建出来了，后续在通过create函数将Person和Student联系到一起的时候，s1对象的隐式原型依然不是Person.prototype的
  3. 至于为什么访问不到方法，先在Student.prototype添加一个方法，后续创建一个新的对象将其覆盖，之前的方法自然也不会存在。

写在最后

我有个习惯，写完代码会对代码进行审视，最起码站在我先在的知识面，对代码进行审视，何处优化？怎么优化？这就是一个进步的过程，没有绝对完美的代码，只有不断趋近于完美的代码，所以最后，这个代码的Object.create方法我觉得可以进行封装，不可能每次对两个构造函数进行继承处理的时候都复写一遍这样的代码，逻辑还是一模一样的，所以最后的代码我就直接贴在下面了

  1. // 对寄生组合继式承封装
  2. function myextend(newObj, oldObj) {
  3.   newObj.prototype = Object.create(oldObj);
  4.   Object.defineProperty(newObj.prototype, "constructor", {
  5.     enumerable: false,
  6.     configurable: true,
  7.     writable: true,
  8.     value: newObj,
  9.   });
  10. }
  11. function People(name, age) {
  12.   this.name = name;
  13.   this.age = age;
  14. }
  16. People.prototype.eating = function () {
  17.   console.log("吃就完事了");
  18. };
  20. People.prototype.sleeping = function () {
  21.   console.log("谁就完事了");
  22. };
  24. function Student(name, age, number, height, sex) {
  25.   People.call(this, name, age);
  26.   this.number = number;
  27.   this.height = height;
  28.   this.sex = sex;
  29. }
  31. myextend(Student, People.prototype);
  32. Student.prototype.wan = function () {
  33.   console.log("出去玩");
  34. };
  35. let s1 = new Student("dw", 18, 100, 1.98, "男");
  36. console.log(s1);
  37. s1.wan(); //出去玩
  38. s1.eating(); //吃就完事了

最后的最后，恭喜EDG，成功拿下GEN，我们六号决赛见。