Java
MySQL
Python
大数据
前端
黑科技
    首页 > 互联网 > 前端 > js继承的6种方式

js继承的6种方式

[导读]:script type = text/javascript // 给构造函数添加了参数(name) function Person ( name ) { this . name = name this . sum = function () { alert ( this . name ) } } // 给构造函数添加了原形属性 Person . prototype . age = 10 // 1.原型...
   想要继承,就必须要提供个父类(继承谁,提供继承的属性)
   <script type="text/javascript">
      // 给构造函数添加了参数(name) 父类
      function Person(name) {
        this.name = name
        this.sum = function () {
          alert(this.name)
        }
      }
      // 给构造函数添加了原形属性
      Person.prototype.age = 10
      // 1.原型链继承
      function Per() {
        this.name = 'yan'
      }
      Per.prototype = new Person()
      var per1 = new Per()
      // 10
      console.log(per1.age, '原型链继承')
      // instanceof 判断元素是否在另一个元素的原型链上
      // per1 继承了Person的属性 返回true
      console.log(per1 instanceof Person, '原型链继承')
      /*重点:让新实例的原型等于父类的实例。
             特点:1、实例可继承的属性有:实例的构造函数的属性,父类构造函数属性,父类原型的属性。(新实例不会继承父类实例的属性!)
             缺点:1、新实例无法向父类构造函数传参。
                2、继承单一。
                3、所有新实例都会共享父类实例的属性。(原型上的属性是共享的,一个实例修改了原型属性,另一个实例的原型属性也会被修改!)*/
      // 2.借用构造函数继承
      function Con() {
        Person.call(this, 'yan')
        console.log(this, '构造函数继承')
        /* this 值
                age: 18
                name: "yan"
                sum: ƒ ()
              */
        this.age = 18
      }
      var con1 = new Con()
      console.log(con1.name, '构造函数继承') //yan
      console.log(con1.age, '构造函数继承') //18
      console.log(con1 instanceof Person, '构造函数继承') //false
      /* this 值
          重点:用.call()和.apply()将父类构造函数引入子类函数(在子类函数中做了父类函数的自执行(复制))
          特点:1、只继承了父类构造函数的属性,没有继承父类原型的属性。
             2、解决了原型链继承缺点1、2、3。
             3、可以继承多个构造函数属性(call多个)。
             4、在子实例中可向父实例传参。
          缺点:1、只能继承父类构造函数的属性。
             2、无法实现构造函数的复用。(每次用每次都要重新调用)
             3、每个新实例都有父类构造函数的副本,臃肿。
              */
      // 3.组合继承(组合原型链继承和借用构造函数继承)(常用)
      function SubType(name) {
        Person.call(this, name) //借用构造函数模式
      }
      SubType.prototype = new Person() //原型链继承
      var sub = new SubType('yan')
      console.log(sub.name, '组合继承') //yan 继承了构造函数属性
      console.log(sub.age, '组合继承') //10 继承了父类原型的属性
      /*
            重点:结合了两种模式的优点,传参和复用
          特点:1、可以继承父类原型上的属性,可以传参,可复用。
             2、每个新实例引入的构造函数属性是私有的。
          缺点:调用了两次父类构造函数(耗内存),子类的构造函数会代替原型上的那个父类构造函数。
              */
      // 4.原型式继承
      // 先封装一个函数容器,用来输出对象和承接继承的原型
      function content(obj) {
        function F() {}
        F.prototype = obj //继承了传入的参数
        return new F() //返回函数对象
      }
      var sup = new Person() //拿到父类的实例
      console.log(sup)
      var sup1 = new content(sup)
      console.log(sup1)
      console.log(sup1.age, '原型式继承') //10  继承了父类函数的属性
      /*
              重点:用一个函数包装一个对象,然后返回这个函数的调用,这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。
            特点:类似于复制一个对象,用函数来包装。
            缺点:1、所有实例都会继承原型上的属性。
               2、无法实现复用。(新实例属性都是后面添加的)
            */
      //5.寄生式继承
      function content1(obj) {
        function F() {}
        F.prototype = obj //继承了传入的参数
        return new F()
      }
      // 以上是原型式继承 给原型式继承在套个壳子传递参数
      function subObject(obj) {
        var sub = content1(obj)
        sub.name = 'yan'
        return sub
      }
      var sup2 = subObject(sup)
      console.log(typeof subObject) //function
      console.log(typeof sup2) //object
      console.log(sup2.name) //yan  返回了sub对象 继承了sub属性
      /*
        重点:就是给原型式继承外面套了个壳子。
        优点:没有创建自定义类型,因为只是套了个壳子返回对象(这个),这个函数顺理成章就成了创建的新对象。
        缺点:没用到原型,无法复用。
      */
      /*
      6.寄生组合式继承(常用)
      寄生:在函数内返回对象然后调用
      组合:1、函数的原型等于另一个实例。2、在函数中用apply或者call引入另一个构造函数,可传参
      */
      function content2(obj) {
        function F() {}
        F.prototype = obj
        return new F()
      }
      // content2 就是F实例的另一种表示法
      var con = content2(Person.prototype)
      // con 实例(F实例)的原型继承了父类函数的原型
      // 上述更像是原型链继承 只不过只继承了原形属性
 
      // 组合
      function Sub() {
        Person.call(this) //这个继承了父类构造函数的属性
      } //解决了组合式两次调用构造函数属性的缺点
      // 重点
      Sub.prototype = con //继承了con实例
      con.constructor - Sub //一定要修复实例
      var sub1 = new Sub()
      // Sub的实例就继承了构造函数属性 父类实例  con的函数属性
      console.log(sub1.age, '寄生组合式继承') //10
    </script>

本文来自投稿,不代表阿习进阶博客立场,如若转载,请注明出处:https://www.yanxias.com/qianduan/163.html

说点什么吧
  • 全部评论(0
    还没有评论,快来抢沙发吧!
点击这里给我发消息