精华内容
下载资源
问答
  • 一:js原型继承四步曲 //js模拟类的创建以及继承 //动物(Animal),有头这个属性,eat方法 //名字这个属性 //猫有名字属性,继承Animal,抓老鼠方法 //第一步:创建父类 function Animal(name){ this.name =...
  • JavaScript 是基于原型的面向对象语言。也就是说,每个实例对象都具有一个原型。对象从该原型继承属性和方法。这一篇将具体说说构造函数的继承
  • 在实际的项目中,我们通常都是用构造函数来创建一个对象,再将一些常用的方法添加到其原型对象上。最后要么直接实例化该对象,要么将它作为父类,再申明一个对象,继承该父类。 而在继承的时候有两种常用方式,今天...
  • js代码-手写代码练习-----原型继承 ,class 继承
  • 不是原型继承那么简单!!prototype的深度探索
  • 这篇文章主要介绍了JavaScript原型继承和原型链原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在讨论原型继承之前,先回顾一下关于创建自定义类型的...
  • JavaScript 原型继承练习。
  • 再谈javascript原型继承

    2020-12-11 09:43:45
    真正意义上来说Javascript并不是一门面向对象的语言,没有提供传统的继承方式,但是它提供了一种原型继承的方式,利用自身提供的原型属性来实现继承。 原型与原型链 说原型继承之前还是要先说说原型和原型链,毕竟这...
  • 关于原型相关属性的含义: - prototype:原型,只有构造函数才有的属性,指向该构造函数的原型对象。 - \_\_proto\_\_:原型链,只有实例对象才有的属性,指向new这个实例的构造函数的原型对象 。 - constructor:...

    前言

    继承是面向对象中一个比较核心的概念。其他正统面向对象语言都会有两种方式实现继承:一个是接口实现,一个是继承。而JS只是继承,不支持接口实现,JS实现继承的方式依靠原型链完成。

    关于原型相关属性的含义:

    • prototype:原型,只有构造函数才有的属性,指向该构造函数的原型对象。
    • __proto__:原型链,只有实例对象才有的属性,指向new这个实例的构造函数的原型对象 。
    • constructor:原型对象中的属性,指向该原型对象的构造函数。

    关于原型方面的几句话:

    • 当 new 一个函数的时候会创建出一个对象,所以【被创建对象.__proto__】等于【函数.prototype】。
    • 一切函数都是由 Function 这个函数创建的,所以【被创建的函数.__proto__】等于【Function.prototype】。
    • 一切函数的原型对象都是由 Object 这个函数创建的,所以【一切函数.prototype.__proto__】等于【Object.prototype】。

    在ES6中,我们使用 extends 来实现类的继承,继承后,子类具有超类的所有属性和方法,也包括超类的静态属性和静态方法。

    class Box{
    	constructor(){}
    	play(){}
    }
    //Ball继承了Box的所有属性和方法
    class Ball extends Box{
    	constructor(){
    		//调用超类的构造函数
    	    super();
    	}
    }
    

    ES5中,在给构造函数设置原型属性和方法时,尽量避免采用对象的形式来写,因为这样会覆盖该函数原来的 prototype 内容。

    function Box(_r){
        this.r=_r;
    }
    Box.prototype.b=10;
    Box.prototype.play=function(){
        console.log(this.b);
    }
    console.dir(Box);//打印如果如下
    

    在这里插入图片描述
    如果采用对象的方式来设置 prototype时:

    function Box(_r) {
        this.r = _r;
    }
    Box.prototype={
         b:10,
         play:function(){}
     }
    console.dir(Box);//打印如果如下
    

    在这里插入图片描述
    我们会发现打印结果的 prototype 中少了constructor 属性;

    • 如果是基类,也可以直接这样写,但是后面还必须重新定义constructor为当前类的构造函数,要注意这个属性不可修改、不可删除、不可被遍历。
    • 如果不是基类,就不能直接使用 prototype 重设置对象。
    Object.defineProperty(Box.prototype,"constructor",{
        value:Box
    })
    

    现在我们来看ES5中继承是怎样实现的。

    组合式继承

    原型链继承的基本思路就是利用原型让一个引用类型继承另一个引用类型的属性和方法。
    原型链+借用构造函数的模式,这种模式称为组合继承。

    function Box(_r){
        this.r=_r;
        console.log("aa");
    }
    Box.a=3;
    Box.run=function(){console.log(Box.a);}
    Box.prototype.b=10;
    Box.prototype.play=function(){console.log(this.b);}
    
    function Ball(_r){
    	Box.call(this,_r);//冒充,给超类传参
    } 
    //实例对象的原型链就是类的原型
    Ball.prototype=new Box(3);
    var c=new Ball(10);
    console.log(c);//打印结果如下
    

    可以看到超类的构造函数被执行两遍,所以这种继承方式是有问题的,这种继承只适用于超类的构造函数中没有任何语句的情况。
    在这里插入图片描述

    原型继承

    这种继承借助原型并基于已有的对象创建新对象,同时还不必因此创建自定义类型。

    function Box(_r){
        this.r=_r;
        console.log("aa");
    }
    Box.a=3;
    Box.run=function(){console.log(Box.a);}
    Box.prototype.b=10;
    Box.prototype.play=function(){console.log(this.b);}
    
    function F(){ }
    F.prototype=Box.prototype;
    
    function Ball(){ }
    Ball.prototype=new F();
    
    var b=new Ball();
    console.log(b);//打印结果如下
    

    对比组合式继承来讲,这种方式就不用执行两遍超类的构造函数,但是一遍都没执行,只完成了原型的继承。
    在这里插入图片描述

    Object.create

    ES5提供了另外一种简便的集成方法Object.create(),因为该方法在创建对象的同时会将其所有原型链传入,因此,继承后不会出现二次调用基类构造函数的情况。

    子类继承的时候,给原型链赋值为Object.create(父类.原型链),Object.create()会创建一个对象,并关联到参数对象中,避免了new操作符与生成对应的constructor,prototype。

    function Box(_r){
        this.r=_r;
        console.log("aa");
    }
    Box.a=3;
    Box.run=function(){console.log(Box.a);}
    Box.prototype.b=10;
    Box.prototype.play=function(){console.log(this.b);}
    
    function Ball(_r){
        Box.call(this,_r);//冒充,给超类传参
    }
    
    Ball.prototype=Object.create(Box.prototype);
    
    var b=new Ball(10);
    console.log(b);//打印结果如下
    

    这种继承写法中,执行一遍超类的构造函数,也完成了原型的继承。但是只能用于IE9以上浏览器,如果这样的话,直接使用ES6 类的继承更方便。
    在这里插入图片描述

    寄生式继承

    寄生式继承把原型式+工厂模式结合而来,目的是为了封装创建对象的过程。

    function Box(_r){
        this.r=_r;
        console.log("aa");
    }
    Box.a=3;
    Box.run=function(){console.log(Box.a);}
    Box.prototype.b=10;
    Box.prototype.play=function(){console.log(this.b);}
    
    function Ball(_r) {
        //执行超类的构造函数
        this.superClass.apply(this, arguments);
    }
    Ball.prototype.walk = function () {
        console.log("walk");
    }
    
    //寄生式继承
    extend_1(Ball,Box);
    
    Ball.prototype.play = function () {
        //执行超类的play方法
        this.superClass.prototype.play.apply(this,arguments);
    }
    
    var b = new Ball(10);
    console.log(b);//打印结果如下
    
    function extend_1(subClass,supClass) {
        //函数F类似于一个中间变量
        function F() {}
        //将超类的prototype赋值给中间变量
        F.prototype = supClass.prototype;
        //先把子类的prototype存储起来
        var o = subClass.prototype;
        //子类的prototype继承超类
        subClass.prototype = new F();
        //再将子类原来的prototype添加回来
        for (var prop in o) {
            subClass.prototype[prop] = o[prop]
        }
        //将超类存储在子类的原型上,用来调用超类的函数
        subClass.prototype.superClass = supClass;
        //设置子类的构造函数是它自己
        subClass.prototype.constructor = subClass;
        //如果在写超类的时候直接设置它的原型是一个对象。这样它的构造函数就会被覆盖掉。
        //在子类继承超类的时候。看看超类是不是这个被覆盖掉了,如果被覆盖掉了,就让它的构造函数恢复。
        if (supClass.prototype.constructor === Object) {
            supClass.prototype.constructor = supClass;
        }
    }
    

    可以将它写成函数的一个方法,直接调用。

    Function.prototype.extend_1 = function (supClass) {
        function F() { }
        F.prototype = supClass.prototype;
        var o = this.prototype;
        this.prototype = new F();
        for (var prop in o) {
            this.prototype[prop] = o[prop]
        }
        this.prototype.superClass = supClass
        this.prototype.constructor = this;
        if (supClass.prototype.constructor === Object) {
            supClass.prototype.constructor = supClass;
        }
    }
    //使用方法 子类.extend_1(超类)
    Ball.extend_1(Box);
    
    展开全文
  • JavaScript 原型继承

    2020-12-10 14:06:06
    Object.prototype JavaScript是基于原型继承的,任何对象都有一个prototype属性。Object.prototype是所有对象的根,并且不可改变。 代码如下: Object.prototype=null; alert(Object.prototype);//[object ...
  • 原型继承和Class继承

    千次阅读 2019-02-09 22:27:28
    原型如何实现继承?CLass如何实现继承?Class本质是什么? 首先讲一下class,当初我学习ES6的时候,出现class的时候,我蛮开心的,因为我有JAVA的基础,对class可是非常的理解。后来发现,其实JS中还是没有类的存在的...
    涉及的面试题

    原型如何实现继承?CLass如何实现继承?Class本质是什么?

    首先讲一下class,当初我学习ES6的时候,出现class的时候,我蛮开心的,因为我有JAVA的基础,对class可是非常的理解。后来发现,其实JS中还是没有类的存在的,class只是一个语法糖

    其本质函数还是函数
    class Person {}
    console.log(typeof Person) //function
    

    原型链继承

    
    /**
     * 原型链继承的例子
     * 功能: 1.获取元素改变或者获取他的innerhtml。
     *       2.添加事件。
    
    function Elem(id) {
        this.elem = document.getElementById(id)
    }
    Elem.prototype.html = function(val) {
        let elem = this.elem;
        if (val) {
            elem.innerHTML = val
            return this //链式操作
        } else {
            return elem.innerHTML
        }
    }
    Elem.prototype.on = function(type, fn) {
        let elem = this.elem;
        elem.addEventListener(type, fn)
        return this
    }
    let div1 = new Elem()
    console.log(div1.html())
    div1.html("<p>hello World").on('click', function() {
        alert('Hello')
    })
    
    function Parent()
    {
    this.name="parent"
    }
    function Child()
    {
    this.type='child'
    }
    Child.prototype=new Parent()
    
    缺点在一个类上创建两个实例,在一个实例对象上修改属性,另一个实例对象也会被修改
    function Parent() {
        this.name = "parent"
        this.arr = [1, 2, 3]
    }
    
    function Child() {
        this.type = 'child'
    
    }
    Child.prototype = new Parent()
    let s1 = new Child()
    let s2 = new Child()
    s1.arr.push(2222)
    console.log(s2.arr)//[ 1, 2, 3, 2222 ]
    console.log(s1.arr)//[ 1, 2, 3, 2222 ]
    

    构造函数

    解决引用类型共享问题
    function Parent(name) {
        this.name = name
        this.color = ['pink', 'red']
    }
    
    function Child() {
        Parent.call(this)//父级构造函数的那个类指向子构造函数的实例上(原理)
            //定义自己的属性
        this.value = 'test'
    }
    let child1 = new Child()
    let child2 = new Child()
    child1.color.push("white")
    
    console.log(child1)
        /*
        name: undefined,
        color: ['pink', 'red', 'white'],
            value: 'test'
        }*/
    console.log(child2) //Child { name: undefined, color: [ 'pink', 'red' ], value: 'test' }
    
    缺点就是父类的原型的方法,子类无法继承
    Parent.prototype.say=function(){}
    上面的say方法,子类无法拥有
    
    解决传参问题
    function Parent(name) {
        this.name = name;
        this.color = ['pink', 'red']
    }
    
    function Child(name) {
        Parent.call(this, name)
        this.value = "test"
    }
    
    let child = new Child("温清夜")
    console.log(child.name) //温清夜
    

    组合继承

    组合继承是最常用的继承方式

    function Parent(value) {
        this.val = value
    }
    Parent.prototype.getValue = function() {
        console.log(this.val)
    }
    
    function Child(value) {
        Parent.call(this, value)
    }
    Child.prototype = new Parent()
    const children = new Child(1)
    children.getValue()//1
    console.log(children instanceof Parent)//true
    

    以上继承的方式核心是在子类的构造函数中通过Parent.call(this)继承父类的属性,然后改变子类的原型为new Parent()来继承父类的函数

    这种继承的方式优点在于构造函数可以传参,不会与父类引用属性共享,可以复用父类的函数,但是也存在一个缺点就是在继承父类函数的时候调用了父类构造函数,导致子类的原型上多了不需要的父类属性,存在内存上的浪费。

    寄生组合继承

    这种继承方式对组合继承进行了优化,组合继承缺点是在继承父类函数时调用了构造函数,我们只需要优化这点就可以了

    function Parent(value) {
        this.val = value
    }
    Parent.prototype.getValue = function() {
        console.log(this)
    }
    
    function Child(value) {
        Parent.call(this, value)
    }
    Child.prototype = Object.create(Parent.prototype, {
        constructor: {
            value: Child,
            enumerable: false,
            writable: true,
            configurable: true
        }
    })
    

    以上继承实现的核心就是将父类的原型赋值给子类,并且将构造函数设置为子类,这样既解决了无用的父类属性问题,还能正确的找到子类的构造函数。

    Class继承

    class Parent {
        constructor(value) {
            this.val = value
        }
        getValue() {
            console.log(this.val)
        }
    }
    class Child extends Parent {
        constructor(value) {
            super(value)
            this.val = value
        }
    }
    let child = new Child(2)
    child.getValue()//2
    console.log(child instanceof Parent)//true
    

    class实现继承的核心在于使用extends表明继承来自哪个父类,并且在子类构造函数中必须调用super,因为这段代码可以看成Parent.call(this,value).

    展开全文
  • javascript原型继承,prototype的使用,可以像java一样继承
  • 理解Javascript原型继承原理
  • js原型继承的几种方法

    千次阅读 2018-10-18 16:52:41
    原型继承 首先创建一个构造函数,并为其设置私有属性和公有属性。 // 定义一个人类 function Person (name) { // 属性 this.name = name; // 实例方法 this.sleep = function(){ console.log(this.name + '...

    原型继承

    首先创建一个构造函数,并为其设置私有属性和公有属性。

    // 定义一个人类
        function Person (name) {
          // 属性
          this.name = name;
          // 实例方法
          this.sleep = function(){
            console.log(this.name + '正在睡觉!');
          }
        }
        // 原型方法
        Person.prototype.eat = function(food) {
          console.log(this.name + '正在吃:' + food);
        };
    

    开始继承

    原型继承有很多种方法,接下来就记录下我已知的几种方法。

    第一种 原型链继承

    重点圈起来:将父类实例赋值给子类原型对象

    	// 创建子类、添加子类属性。
       function arrange(name){
         this.name = name;
         this.goShop = function(food){
           console.log(name + '叫你去买'+ food)
         }
       }
       // 将父类实例赋值给子类原型对象
       arrange.prototype = new Person();
       // 将constructor指向本身,保证原型链不断。
       arrange.prototype.constructor = arrange; 
    
       //创建arrange新实例,也是Person实例;
       var newObj = new arrange('李四'); 
       console.log(newObj instanceof Person)  //true
       console.log(newObj instanceof arrange) //true
       // 原型链继承成功,可以访问父类所有属性;
       console.log(newObj)
       console.log(newObj.name) // 李四
       newObj.sleep(); // 李四正在睡觉!
       newObj.eat('苹果'); // 李四正在吃:苹果
       newObj.goShop('香蕉'); // 李四叫你去买香蕉
    

    第二种 构造继承

    重点圈起来:执行父构造,将This指向本身,拉取父私有属性

    	// 创建子类、添加子类属性。
    	function arrange(name){
          Person.call(this,name) // 执行父构造,将This指向本身,拉取父私有属性;
        }
        arrange.prototype.getName = function(){
          console.log('我叫' + this.name)
        }
        var newObj = new arrange('李四');
        console.log(newObj)
        console.log(newObj.name) //李四
        newObj.sleep() // 李四正在睡觉!
        newObj.getName() //我叫李四
    

    第三种 组合继承

    重点圈起来:构造继承与原型继承组合。注意注释区域,切勿在继承时使用此方法重写或添加方法,否则将会修改整个原型,导致崩塌。

    	// 创建子类、添加子类属性。
    	function arrange(name){
          Person.call(this,name) // 执行父构造,将This指向本身,拉取父私有属性;
        }
        // 将父类实例赋值给子类原型对象
        arrange.prototype = new Person(); // 直接拉取父类实例继承原型
        // 将constructor指向本身,保证原型链不断。
        arrange.prototype.constructor = arrange;
        
        // 下面这个方法会替换整个原型对象
        // arrange.prototype = {
        //   init:function(){
        //     console.log('我会替换整个原型')
        //   }
        // }
        // 必须在原型实例继承之后,在给子类原型添加方法,或重写方法,请使用以下方法
        arrange.prototype.eat = function() {
          console.log(this.name + '重写了此方法');
        };
        arrange.prototype.addFn = function(){
          console.log(this.name + '添加了新方法' );
        }
        
        var newObj = new arrange('王五');
        console.log(newObj)
        newObj.eat(); // 王五重写了此方法
        newObj.addFn(); // 王五添加了新方法
    

    第四种 克隆原型链继承

    重点圈起来: 将等待继承的原型对象克隆,再赋值给继承的原型对象。此种方法会脱轨,不在同一原型链上

    	// 创建子类、添加子类属性。
    	function arrange(name){
          this.name = name;
          this.goShop = function(food){
            console.log(name + '叫你去买'+ food)
          }
        }
        // 创建克隆类型
        function Clone(obj){
          for(var key in obj){
            this[key] = typeof obj[key] == 'object' ? new Clone(obj[key]) : obj[key];
          }
        }
        // 使用Clone构造函数继承原型
        arrange.prototype = new Clone(Person.prototype); 
        // 将constructor指向本身,保证原型链不断。
        arrange.prototype.constructor = arrange; 
    
        //创建arrange新实例,也是Clone实例,却不在是Person实例;
        var newObj = new arrange('李四'); 
        console.log(newObj instanceof Person)  //false
        console.log(newObj instanceof arrange) //true
        console.log(newObj instanceof Clone) //true
        // 克隆成功,可以访问克隆对象的原型对象;
        console.log(newObj)
        console.log(newObj.name) // 李四
        newObj.eat('苹果'); // 李四正在吃:苹果
        newObj.goShop('香蕉'); // 李四叫你去买香蕉
    

    第五种 寄生组合继承

    重点圈起来: 将父类原型对象直接赋值给一个空属性的构造函数,再将空属性的构造函数实例赋值给子类原型对象,其根本是为了解决父实例继承的出现的两次构造。

    	// 创建子类、添加子类属性。
    	function arrange(name){
          Person.call(this,name)
          this.shop = function(){
            console.log(this.name + '去买好吃的,好吃就多吃点')
          }
        }
    
        (function(){
          // 创建一个没有实例方法的类
          var nullFn = function(){};
          nullFn.prototype = Person.prototype;
          //将实例作为子类的原型
          arrange.prototype = new nullFn();
           // 将constructor指向本身,保证原型链不断。
          arrange.prototype.constructor = arrange;
        })();
        
        var newObj = new arrange('老王');
        console.log(newObj)
        newObj.shop(); // 老王去买好吃的,好吃就多吃点
        newObj.sleep(); // 老王正在睡觉!
        newObj.eat('芭蕉'); // 老王正在吃:芭蕉
    

    学习犹如逆水行舟,有舟就上。别问为什么,吾乃不踩坑学不会系列。

    展开全文
  • 类、属性、原型这些要素,而类中又有封装、继承、多态这些玩法 封装:就是把类(也叫函数)中的一个功能的代码进行封装,从而实现低耦合高内聚 多态:重写、重载 重写:子类重写父类上的方法(伴随着继承运行的) ...

    js也是一门面向对象的编程语言.

    既然是面向对象,那它一定具备 --> 类、属性、原型这些要素,而类中又有封装、继承、多态这些玩法

    封装:就是把类(也叫函数)中的一个功能的代码进行封装,从而实现低耦合高内聚

    多态:重写、重载

            重写:子类重写父类上的方法(伴随着继承运行的)

            重载:相同的方法,由于参数或者返回值不同,具备了不同的功能(或调用了不同的方法),其实js不具备严格意义上的重载 (只能在同一个方法内,根据传参不同实现不同功能) why?

          继承:子类继承父类中的方法

    那么继承我们可以有几种方法实现呢?

    1.原型继承:

    让子类的prototype指向父类的实例(管道式链接),这样我们就可以拿到了父类中的x属性和getX方法,如图:

    我们发现x属性在子类的原型上,而getX方法则在子类原型的原型上,这样目的是达到了,但是有一个重大的缺陷,假如我们要修改x属性或者getX方法呢?

    只能通过sonExample.__proto__.x或者sonExample.__proto__.__proto__.getX 这样去修改,显然这大大违背了低耦合高内聚的原则(原型被修改,所有用到这个原型的实例都会受影响,且IE不支持这样做)。那我们再看看其它办法-----

    2.call继承

    这样我们就能拿到父类中的x变为自己的私有属性了,但是与父类的原型就无关了,故拿不到getX方法,所以call方法继承的缺点在于:只能继承私有方法,不能继承公有方法。

    综合以上两种方法,能不能既拿到私有属性,又拿到公有属性(拷贝过来呢)?

    3.组合式继承

        利用原型指向+call私有属性继承

            

       这里我们可以看到Son类原来的prototype的__proto__是指向Object的,如果让它指向父类的prototype,岂不实现了公有属性的继承?

      

    这样子我们既可以实现私有属性的继承,又可以实现公有的继承,而且修改原型上的属性不会影响父类原本的方法

    但是在IE中不支持操作__proto__,怎么办呢?

    在这可以利用Object.create(obj) 这个方法 --> 创建一个空对象,让其原型链指向obj

    Son.prototype.__proto__ = Father.prototype 就等同于 Son.prototype = Object.create(Father.prototype)

    这样相当于重定向了子类原型的指向,会使子类原型上缺失constructor属性,手动加上即可

         

    最后用ES6的class方法实现下

               

    注意:class创建的是类,不能当作普通函数执行,只能用new执行。

    完......

     

     

     

    展开全文
  • 下面小编就为大家带来一篇浅析JS原型继承与类的继承。小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 这篇文章目的就是说清楚什么是原型继承,和怎么在js中使用原型继承原型继承的定义 当你读到关于js的原型继承,经常能看到如下定义: 当访问对象的属性时,JavaScript将向上遍历原型链,直到找到具...
  • * JS里的继承主要依靠是的原型链。让原型对象(每一个构造函数都有一个原型对象)的值,等于另一个类型的实例,即实现了继承;另外一个类型的原型再指向第三个类型的实例,以此类推,也就形成了一个原型链 ...
  • JavaScript默认采用原型继承。虽然没有类(class)的概念,它的函数(function)可以充当构造器(constructor)。构造器结合this,new可以构建出类似Java的类。因此,JavaScript通过扩展自身能模拟类式(class-based)继承。...
  • 一般在原型继承中,子构造函数的原型对象是父构造函数,或者子构造函数的原型对象 [[Prototype]] 链接到父构造函数的原型对象。 this 创造顺序不同 ES5 的继承,实质是先创造子类的实例对象this,然后再...
  • 证明你对JavaScript面向对象已经有一定的了解,如还有什么不理解的可以参考《面向对象JS基础讲解,工厂模式、构造函数模式、原型模式、混合模式、动态原型模式》,接下来讲一般通过那些方法完成JavaScript的继承。...
  • JavaScript原型继承

    2018-06-06 06:35:36
    在传统的基于Class的语言如Java...但是,JavaScript由于采用原型继承,我们无法直接扩展一个Class,因为根本不存在Class这种类型。 但是办法还是有的。我们先回顾Student构造函数: function Student(props) { ...
  • 最近接触了一下html5,当然,接触过html5的人都知道,html5也不过是提供一些新的标签而已,至于整下实现的核心,还是在javascript这里。
  • 原型继承

    2015-07-06 18:48:53
    在传统的基于Class的语言如Java、C++...但是,JavaScript由于采用原型继承,我们无法直接扩展一个Class,因为根本不存在Class这种类型。 但是办法还是有的。我们先回顾Student构造函数: function Student(props)
  • 主要详细介绍了JavaScript的原型继承的相关资料,十分详细,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 169,700
精华内容 67,880
关键字:

原型继承