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

    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使用原型实现继承

    2021-02-03 10:50:38
    // 借用父构造函数继承属性 // 1. 父构造函数 function Father(uname, age) { // this 指向父构造函数的对象实例 this.uname = uname; this.age = age; } Father.prototype.smoke = function() { console....
    // 借用父构造函数继承属性
            // 1. 父构造函数
            function Father(uname, age) {
                // this 指向父构造函数的对象实例
                this.uname = uname;
                this.age = age;
            }
            Father.prototype.smoke = function() {
                console.log('来了老弟,抽根烟');
    
            };
            // 2 .子构造函数 
            function Son(uname, age, score) {
                // this 指向子构造函数的对象实例
                Father.call(this, uname, age);
                this.score = score;
            }
            // Son.prototype = Father.prototype;  这样直接赋值会有问题,如果修改了子原型对象,父原型对象也会跟着一起变化
            Son.prototype = new Father();
            // 如果利用对象的形式修改了原型对象,别忘了利用constructor 指回原来的构造函数
            Son.prototype.constructor = Son;
            // 这个是子构造函数专门的方法
            Son.prototype.study = function() {
                console.log('老弟乖乖学习');
    
            }
            var son = new Son('刘德华', 18, 100);
            console.log(son); //此时的son实例对象中就有了父构造函数中的
    

    分析以上代码:

    call()

    • call()可以调用函数

    • call()可以修改this的指向,使用call()的时候 参数一是修改后的this指向,参数2,参数3…使用逗号隔开连接

    子构造函数继承父构造函数中的属性

    1. 先定义一个父构造函数
    2. 再定义一个子构造函数
    3. 子构造函数继承父构造函数的属性(使用call方法)

    借用原型对象继承方法

    1. Son.prototype = Father.prototype;

      不能直接将父构造函数prototype 直接赋值,这样的话,如果修改了子原型对象,父原型对象也会跟着一起变化

    2. Son.prototype = new Father();应该让子构造函数的prototype指向父构造函数的一个实例,这个实例身上有个__proto__指向了父构造函数的prototype

    在这里插入图片描述

    1. Son.prototype = new Father();如果利用对象的形式修改了原型对象,还需要利用constructor 指回原来的构造函数

    ew Father();`如果利用对象的形式修改了原型对象,还需要利用constructor 指回原来的构造函数

    展开全文
  • JavaScript原型链与继承

    2021-11-21 14:22:33
    一、Javascript原型链 要讲解Javascript原型链我们首先要弄明白几个名词。prototype、__proto__、constructor、原型链。 1、prototype 在JavaScript中,每个函数都有一个prototype属性,这个属性指向函数的原型对象...

    一、Javascript原型链

    要讲解Javascript原型链我们首先要弄明白几个名词。prototype、__proto__、constructor、原型链。

    1、prototype

    在JavaScript中,每个函数都有一个prototype属性,这个属性指向函数的原型对象。
    原型的概念:每一个javascript对象(除null外)创建的时候,就会与之关联另一个对象,这个对象就是我们所说的原型,每一个对象都会从原型中“继承”属性。
    举个例子:

    function Person(age){
    	this.age = age;
    }
    Person.prototype.name = "wenhua"
    var person1 = new Person()
    var person2 = new Person()
    console.log(person1.name)	//wenhua
    console.log(person2.name)	//wenhua
    

    上面的例子可以看出Person构造函数本身没有name属性,但是他构造的实例却可以继承该属性。原因是在Person构造函数在创建的时候,会关联一个对象(原型对象),每个对象都会从原型中"继承"属性。

    2、__proto__

    这是每个对象(除null外)都会有的属性,叫做__proto__,这个属性会指向该对象的原型。但是值得注意的是__proto__是一个绝大多数浏览器都支持的非标准方式,也可以借助ES6中Object.getPrototypeOf(obj)实现。
    举个例子:

    function Person() {
    
    }
    var person = new Person();
    console.log(person.__proto__ === Person.prototype); // true
    console.log(Object.getPrototypeOf(person) === Person.prototype); // true
    

    在这里插入图片描述

    3、constructor

    每个原型都有一个constructor属性,指向该关联的构造函数。
    举个例子:

    function Person() {
    
    }
    console.log(Person===Person.prototype.constructor)  //true
    

    在这里插入图片描述
    下面再举个例子,说明之前三个的关系:

    function Person (){
    
    }
    var person = new Person()
    
    console.log(person.__proto__ == Person.prototype)	//true
    console.log(person.__proto__.constructor == Person)	//true
    console.log(person.constructor == Person)	//true
    

    4、原型链

    当读取实例的属性时,如果找不到,就会查找与对象关联的原型中的属性,如果还查不到,就去找原型的原型,一直找到最顶层为止。
    举个例子:

    function Person(){
    	
    }
    Person.prototype.name = 'wenhua'
    var person = new Person()
    person.name = 'liu'
    console.log(person.name)  //liu
    delete person.name;
    console.log(person.name)  //wenhua
    Object.defineProperty(Object.prototype,'name',{
    	value:'zhangsan'
    })
    delete Person.prototype.name
    console.log(person.name)	//zhangsan
    

    在这个例子中,我们给实例对象 person 添加了 name 属性,当我们打印 person.name 的时候,结果自然为 liu。
    但是当我们删除了 person 的 name 属性时,读取 person.name,从 person 对象中找不到 name 属性就会从 person 的原型也就是 person.__proto__ ,也就是 Person.prototype中查找,幸运的是我们找到了 name 属性,结果为 wenhua。
    当我们删除了Person.prototype.name属性时,再读取person.name时就会继续往顶层找直到Object.prototype为止。首先找的顺序时实例自身,然后是实例的原型Person.prototype,再然后是实例原型的原型Object.prototype中查找。如果还没有找到那么久返回null。
    以下时关系图:
    在这里插入图片描述
    通常来说Object.prototype.__proto__的值是null,代表着对象的原型链终点,它表示着Object.prototype对象没有原型。
    举个例子:

    console.log(Object.prototype.__proto__ === null) // true
    

    在这里插入图片描述
    所以我们更新关系图为:
    在这里插入图片描述

    二、Javascript继承

    javascript的继承主要有以下其中方式。在这里我将列出以下其中的优劣点。

    首先提供一个父类:

    function People(name){
        // 属性
        this.name = name || 'Annie'
        // 实例方法
        this.sleep = function(){
            console.log(this.name + ' is sleeping ');
        }
    }
    // 原型方法
    People.prototype.eat = function(food){
        console.log(this.name + ' is eating ' + food);
    }
    

    1、原型链继承

    // 原型链继承

    function Woman(){
    }
    Woman.prototype = new People()
    Woman.prototype.name = 'Mark'
    let womanObj = new Woman()
    
    womanObj.sleep()
    womanObj.eat("fish")
    console.log(womanObj.name);
    

    在这里插入图片描述

    重点:
    让新实例的原型等于父类的实例。

    特点:
    1、实例可继承的属性有:实例的构造函数的属性,父类构造函数属性,父类原型的属性。(新实例不会继承父类实例的属性!)

    缺点:
    1、新实例无法向父类构造函数传参。
    2、继承单一。
    3、所有新实例都会共享父类实例的属性。(原型上的属性是共享的,一个实例修改了原型属性,另一个实例的原型属性也会被修改!)

    2、借助构造函数继承(经典继承)

    // 借助构造函数继承(经典继承)
    function Woman(name){
        People.call(this)
        this.name = name || 'lucy'
    }
    let womanObj = new Woman()
    womanObj.sleep()
    // 不能继承原型属性/方法,只能继承父类的实例属性和方法
    // womanObj.eat()
    console.log(womanObj.name);
    

    在这里插入图片描述

    重点:
    用.call()和.apply()将父类构造函数引入子类函数(在子类函数中做了父类函数的自执行(复制))

    特点:
    1、只继承了父类构造函数的属性,没有继承父类原型的属性。
    2、解决了原型链继承缺点1、2、3。
    3、可以继承多个构造函数属性(call多个)。
    4、在子实例中可向父实例传参。

    缺点:
    1、只能继承父类构造函数的属性,不能继承父类原型链上的方法和属性。
    2、无法实现构造函数的复用。(每次用每次都要重新调用)
    3、每个新实例都有父类构造函数的副本,臃肿。

    3、组合式继承(组合原型链继承和借用构造函数继承)

    // 组合式继承
    function Woman(name){
        // this.age = age || 22
        People.call(this, name)//第二次调用People构造函数  子类型构造函数内部。
        this.age = 22
    }
    Woman.prototype = new People()
    Woman.prototype.constructor = Woman  //第一次调用People构造函数  创建子类型原型的时候
    let womanObj = new Woman('ren')
    
    womanObj.sleep()
    womanObj.eat("fish")
    console.log(womanObj.name);
    console.log(womanObj.age);
    

    在这里插入图片描述

    在举个例子,非常经典。

    function SuperType(name){
     this.name = name;
     this.colors = ["red", "blue", "green"];
    }
    SuperType.prototype.sayName = function(){
     alert(this.name);
    }
    
    function SubType(name, age){
     SuperType.call(this, name);  //第二次调用SuperType()
     
     this.age = age;
    }
    SubType.prototype = new SuperType();  //第一次调用SuperType()
    SubType.prototype.sayAge = function(){
     alert(this.age);
    }
    

    在第一次调用SuperType构造函数时,SubType.prototype会得到两个属性: name和colors; 他们都是SuperType的实例属性,只不过现在位于SubType的原型中。

    当调用SubType构造函数时,又会调用一次SuperType构造函数,这一次又在新对象上创建了实例属性name和colors。

    于是这两个属性就屏蔽了原型中的两个同名属性。

    重点:
    结合了两种模式的优点,传参和复用

    特点:
    1、可以继承父类原型上的属性,可以传参,可复用。
    2、每个新实例引入的构造函数属性是私有的。

    缺点:
    调用了两次父类构造函数(耗内存),子类的构造函数会代替原型上的那个父类构造函数。

    4、实例继承(原型式继承)

    // 实例继承(原型式继承)
    // 先封装一个函数容器,用来输出对象和承载继承的原型
    function Woman(obj){
       function F(){this.name = 'Bob'}
       F.prototype = obj  //继承了传入的参数
       return new F()  //返回函数对象
    }
    var instance = new People();
    let womanObj = new Woman(instance);  //拿到父类的实例
    
    womanObj.sleep()
    womanObj.eat("fish")
    console.log(womanObj.name);  //继承了父类函数的属性
    

    在这里插入图片描述

    重点:
    用一个函数包装一个对象,然后返回这个函数的调用,这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。

    特点:
    类似于复制一个对象,用函数来包装。

    缺点:
    1、所有实例都会继承原型上的属性。
    2、无法实现复用。(新实例属性都是后面添加的)

    5、寄生式继承

    在cnblog中找到的,这个例子非常的生动形象。

    // 与寄生构造函数和工厂模式类似,创建一个仅用于封装继承过程的函数,该函数在内部以某种方式来增强对象,最后返回对象。
    function createAnother(original){
        var clone = Object.create(original);    //通过调用函数创建一个新对象
        clone.sayHi = function(){               //以某种方式来增强这个对象
            console.log("Hi");
        };
        return clone;                        //返回这个对象
    }
    
    var person = {
        name: "Bob",
        friends: ["Shelby", "Court", "Van"]
    };
    
    var anotherPerson = createAnother(person);
    anotherPerson.sayHi();
    console.log(anotherPerson.name);
    console.log(anotherPerson.friends);
    // createAnother函数接收了一个参数,也就是将要作为新对象基础的对象。
    // anotherPerson是基于person创建的一个新对象,新对象不仅具有person的所有属性和方法,还有自己的sayHi()方法。
    

    在这里插入图片描述

    6、组合寄生式继承

    function object(o){/*在ES5中规范了Object.create()方法*/
       function f(){}
       f.prototype = o;
       return new f();
    }
    
    /*
    function inheritPrototype(subType, superType){
     var protoType = Object.create(superType.prototype); //创建对象
     protoType.constructor = subType;     //增强对象
     subType.prototype = protoType;      //指定对象
    }
    */
    
    function inheritPrototype(subType,superType) {
        var _prototype = object(superType.prototype);  //创建对象
        _prototype.constructor = subType;  //增强对象
        subType.prototype = _prototype;   //指定对象
    }
    //超类构造函数
    function SupperType(name) {
        this.name = name;
        this.colors = ["red","blue","green"];
    }
    //设置超类原型函数
    SupperType.prototype.sayName = function() {
        console.log(this.name);
    };
    function SubType(name,age) {
        //调用超类的构造函数从而继承其属性
        SupperType.call(this,name);
        this.age = age;
    }
    //子类subType继承超类supperType
    inheritPrototype(SubType,SupperType);
    //子类的原型方法
    SubType.prototype.sayAge = function() {
        console.log(this.age);
    }
    //实例化子类
    var person1 = new SubType("李文",26);
    
    person1.sayName();
    

    在这里插入图片描述

    inheritPrototype函数接收两个参数:子类型构造函数和超类型构造函数。

    1. 创建超类型原型的副本。

    2. 为创建的副本添加constructor属性,弥补因重写原型而失去的默认的constructor属性

    3. 将新创建的对象(即副本)赋值给子类型的原型这种方法只调用了一次SuperType构造函数

    7、ES6继承

    // ES6继承
    class People{
        constructor(name ="wang", age = 27){
            this.name =name
            this.age = age
        }
        eat(){
            console.log(`${this.name} ${this.age} eat food`);
        }
        sleep(){
            console.log(`${this.name} is sleeping`);
        }
    }
    class Woman extends People{
        constructor(name = 'Alice', age = 22){
            super(name, age)
        }
        eat(){
            super.eat()
        }
        sleep(){
            console.log(`${this.name} is not sleeping, he is playing`);
        }
    }
    let womanObj = new Woman('jack');
    womanObj.sleep()
    womanObj.eat("fish")
    console.log(womanObj.name);
    

    在这里插入图片描述

    展开全文
  • JavaScript原型继承

    2021-07-19 16:39:32
    JavaScript原型继承 JavaScript中原型可以实现类似于其他语言中的继承。 示例一: // 父类型 function Person() { this.name = 'zs'; this.age = 18; this.sex ='男'; } // 子类型 function Student() { this....

    JavaScript原型可以实现类似于其他语言中的类继承


    示例一:

    // 父类型
    function Person() {
    	this.name = 'zs';
    	this.age = 18;
    	this.sex ='男';
    }
    // 子类型
    function Student() {
    	this.score = 100;
    }
    student.prototype = new Person();
    Student.prototype.constructor = Student;
    
    var s1 =new Student();
    console.log(s1.constructor);
    console.dir(s1);
    

    缺点:这种继承无法对构造函数进行灵活传参。可以通过示例二进行改进。


    示例二:

    //借用构造函数//父类型
    function Person( name, age, sex) {
    	this.name = name;
    	this.age = age;
    	this.sex = sex;
    }
    // 子类型
    function Student(name, age, sex, score) {
    	Person.call(this, name, age, sex);
    	this.score = score;
    }
    var s1 = new Student('zs', 18, '男', 100);
    console.dir(s1);
    

    call()改变函数中的this,直接调用函数
    优点与不足:示例二通过构造函数实现了继承,这种继承方式可以灵活传参,但是无法继承构造函数中的原型对象中的内容。可以通过示例三进行改进。


    示例三:

    组合继承:借用构造函数 + 原型继承
    function Person(name, age, sex) {
    	this.name = name;
    	this.age = age;
    	this.sex = sex;
    }
    Person.prototype.sayHi = function() {
    	console.log('大家好,我是'+ this.name);
    }
    function Student(name,age, sex,score) {
    	// 借用构造函数
    	Person.call(this, name, age, sex);
    	this.score = score;
    }
    Student.prototype = Person.prototype;
    Student.prototype.constructor = Student; // 构造函数原型对象中constructor必须指向构造函数,对象实例能够通过constructor查询实例的数据类型
    var s1 = new Student( 'zs', 18, '男', 100);
    console.dir(s1);
    

    优点与不足:通过构造函数中的原型对象指向另一个构造函数的原型对象虽然能够实现对原型中方法的继承,但是这种继承方式会 改变“父”构造函数的原型对象 ,从而导致“父”构造函数原型对象所有实例对象__proto__的属性改变。可通过示例四进行改进。


    示例四:

    组合继承:借用构造函数 + 原型继承
    function Person(name, age, sex) {
    	this.name = name;
    	this.age = age;
    	this.sex = sex;
    }
    Person.prototype.sayHi = function() {
    	console.log('大家好,我是'+ this.name);
    }
    function Student(name,age, sex,score) {
    	// 借用构造函数
    	Person.call(this, name, age, sex);
    	this.score = score;
    }
    // -------------------------------
    Student.prototype = new Person(); // 替换示例三中的 Student.prototype = Person.prototype;
    // -------------------------------
    Student.prototype.constructor = Student; // 构造函数原型对象中constructor必须指向构造函数,对象实例能够通过constructor查询实例的数据类型
    var s1 = new Student('zs', 18, '男', 100);
    console.dir(s1);
    
    展开全文
  • js 原型继承

    2021-05-25 19:32:23
    <script> function SuperType(){ this.property = true; this.colors = ['red','blue','green']; } SuperType.prototype.getSuperValue = function(){ ...引用原型 2.不能给父类的构造函数中传递参数 */ </script>
  • 其基本思想就是通过原型继承多个引用类型的属性和方法。 原型链 重温一下构造函数、原型和实例的关系:每个构造函数都有一个原型对象,原型有一个constructor 属性指回构造函数,而实例有一个内部指针指向原型。如果...
  • 原型是对象数据类型所有,原型又分为显式原型和隐式原型: // 语法糖形式 class Person { constructor(name, age) { this.name = name; this.age = age; } getName() { return this.name; } getAge() { ...
  • javascript原型继承

    2020-12-24 17:17:30
    原型继承 1.1对象的创建方式 1.1.1 字面量方式 var obj = {}; 此种方式在主要用来创建 json 数据,一般不会用来创建对象 1.1.2 普通模式 基于 Object 创建 var Person=new Object() Person.name='yhb' Person.age...
  • 当 构造函数 A 的 实例 , 使用了 构造函数 B 原型 上书写的属性和方法 => 此时, 我们就说 A 和 B 出现了 继承关系 => 构造函数 A 继承自 构造函数 B => 构造函数 A 是 构造函数 B 的 子类 => 构造函数 ...
  • js原型继承继承构造器带来的缺点 修改Person构造器会影响到继承他的子类 function Person(){this.sex = 'man'}; function Man(){}; Man.prototype = Person; var m1 = new Man(); m1.sex;//'man' // 修改Person...
  • 理解JS原型链到实现继承

    千次阅读 2021-03-22 21:42:06
    理解JS原型链到实现继承 JS是通过原型链的方式能够像一些基于类的语言(如Java、C++)一样实现了类的功能,并且也可以通过原型链进行继承。但是,由于原型链的灵活,在ES5的语法中有许多方式能够实现继承,可能你有...
  • 学习笔记,总结js原型原型链、构造函数、类、继承方面的知识。
  • js 手写 原型继承

    2021-05-28 11:08:51
    new Dog() console.log(dog2.colors) // ['black', 'white', 'brown'] 看图解析 红色线为原型链 总结: 将A构造函数的实例对象赋值给B构造函数的prototype, 即可实现B构造函数的实例对象继承了A构造函数的原型
  • //通过浏览器控制台打印我们可以发现,冒充继承的方式,解决了原型链不能初始化父类属性的问题,但是冒充继承不能继承人类(People)的原型(prototype); //创建一个打工类 function Work(name,age,sex,country,post){...
  • 原型链是实现继承的一种基础方式,是原型搜索机制的扩展。本文以基本原理,代码实现,结构图解三种方式诠释,无论基础如何,都能通过本文对js原型继承达到更深入的理解。
  • 每个函数都会创建一个prototype对象属性,它就是原型对象,也是我们调用构造函数生成的对象的原型,我们直接打印看下: function Person(name) { this.name = name; } console.dir(Person); 我们看上面的图片...
  • 1.原型继承 构造函数、原型和实例的关系:每个构造函数都有一个原型对象,原型有一个属性指回构造函数,而实例有一个内部指针指向原型原型继承(将父类的实例作为子类的原型): //父类 function Animal...
  • js原型链与继承

    2021-12-17 18:12:33
    javaScript中的原型链与继承 一、通过原型链实现继承 ​ 如果我们现在需要实现继承,那么就可以利用原型链来实现了:目前stu的原型是p对象,而p对象的原型是Person默认的原型,里面包含running等函数;注意:步骤4和...
  • JS继承到底有多少种实现方式呢? ES6 的 extends 关键字是用哪种继承方式实现的呢? 第一种:原型继承 原型继承是比较常见的继承方式之一,其中涉及的构造函数、原型和实例,三者之间存在着一定的关系,即每...
  • **定义:**按照JS引擎的分析方式,在访问一个实例的属性的时候,现在实例本身中找,如果没找到就去它的原型中找,还没找到就再往上找,直到找到。这就是原型链。 实例的_protpo_指向的是原型对象。 实例的构造...
  • 面向对象:封装,继承,多态 多态:重载、重写 ...JS中的面向对象,和其它编程语言还是有略微不同的,JS中类和实例是基于原型原型链机制来处理的;而且JS中关于类的重载重写、继承也和其它语言不太一样… 继
  • 一、原型链 理解原型链,首先要理解一个三方关系.三方指的是构造函数,构造函数实例,以及原型prototype,先上图: 1.1 构造函数原型 prototype 我们常用new一个构造函数的方式来创建实例.这样的方式很好用,但是存在...
  • 学习目标 提示:完成对常见面试题的了解,包括,js闭包 es5和es6j继承方式的不同,对构造函数的原型原型链进行学习 文章目录学习目标一、js闭包 一、js闭包
  • 转载1自:https://zhuanlan.zhihu.com/p/35790971 转载2自:https://segmentfault.com/a/1190000014717972 转载3自:... javascript有两大链条,一条是作用域链,一条是原
  • 1. JavaScript的构造函数 1.1 构造函数做了些什么 在JavaScript中,可以直接用new Object()或字面量{}创建对象,但是这样没有解决对象的标识问题(即新创建的对象是什么类型)。 可以使用构造函数和new操作符来...
  • JS原型继承 原型 原型作用:给实例提供共享的方法和属性 1.任何一个函数,都默认会自带一个属性为prototype 2.这个prototype属性对应的值是一个对象 3.只要是通过构造函数new出来的对象可以直接访问原型上的所有...
  • 在es6之前我们是通过构造函数模拟创建类,这种方式叫做构造函数继承,而因为原型可以共享方法,那么也可以使用原型链来实现继承,不仅仅是继承方法,也可以继承原型上的属性,毕竟原型上的方法和属性都能够被相应的...
  • 原型继承关系图详解

    2021-09-25 20:11:28
    原型继承关系图详解 代码+注释 解析 /** * 一个例子说明原型继承的关系 */ function Person(name, age, height) { this.name = name; this.age = age; this.height = height; } /** * 原型上挂载方法 */ Person....
  • prototype 是自身的原型,你的子级被创建出来时它的它的__proto__原型就是你的 prototype 1.原型初步认识 let arr = ["hello"]; console.log(arr.concat("world")); 如下图,__proto__属性就是 Array 对象的原型...
  • 原型继承 其优点,可以共享方法,两个实例后的方法相等。 其缺点,如果有引用类型的属性时,会被所有的实例间共享 function SuperTypeProto(){ //一个引用类型的属性 this.colors = ['red', 'blue']; //一个非...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,023
精华内容 34,809
关键字:

js原型继承

友情链接: susqbnd.rar