闭包和继承

最新推荐文章于 2024-06-19 23:41:07 发布
最新推荐文章于 2024-06-19 23:41:07 发布
阅读量177 收藏
点赞数
文章标签： 原型模式 javascript 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55836496/article/details/126868628
版权

typora-root-url: images
typora-copy-images-to: images

原型对象的再认识

构造函数
	  function Person(){
		  
	  }
	  let p1 = new Person();
	  console.log(p1);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2WvaYlRn-1663214187825)(/1649409880014.png)]

数组的原型对象

原型对象上的各种方法,让我们声明的数组,可以随便调用

prototype原型继承

所有函数只要创建出来,系统都会分配一个原型对象给整个函数,通过prototype找到原型对象.

我们创建的每个函数都有一个 prototype（原型）属性。使用原型的好处是可以让所有对象实例共享它所包含的属性和方法。

定义:

1 原型是function对象的一个属性,它定义了构造函数制造出的对象的公共祖先,通过该构造函数产生的对象,可以继承该原型的属性和方法.原型也是对象.

2 利用原型的概念和特点可以提取共有属性.

3 实例化对象可通过_ _proto__查看原型

原型与对象

概念1讲解 

     function Person(){
          
       }
      // Person.prototype 原型  祖先
       Person.prototype.age = 18; 
       Person.prototype.say = function(){
           console.log('吃饭了');
       }
       //Person.prototype.age = 22; 
      let p1 = new Person();
      let p2 = new Person();
       console.log(p1);

概念2讲解 ,提取构造函数中的公共属性

第一步:
   function Cart(ower,color){
        this.name="BMW";
        this.lang = '3米'
        this.price = 30000;
        this.ower = ower;
        this.color = color;
    }
    let p1 = new Cart();
    let p2 = new Cart();
    console.log(p1);
    console.log(p2);
    console.log(p1===p2);
    此时可以看出构造函数的多次创建会产生多个相同函数，造成冗余太多。
    利用原型prototype解决。回顾prototype
        console.log(Cart.prototype);
    //constructor表示当前的函数属于谁
    //__proto__  ==  [[prototype]]，书面用语，表示原型指针
    
第二步:直接使用原型提取公共属性
  //  Cart.prototype.name = "BMW";
  //  Cart.prototype.lang = "3米";
  //  Cart.prototype.price = 30000;
    
    Cart.prototype={
        name:'BMW',
        lang:'3m',
        price:30000
    }
    function Cart(ower,color){
      
        this.ower = ower;
        this.color = color;
    }
    let p1 = new Cart();
    let p2 = new Cart();
    console.log(p1);
    console.log(p2);

概念3讲解 ,实例化的对象用__proto__访问原型

 function Cart(own, color) {
      this.name = 'BMW';
      this.lang = '3米';
      this.price = 300000;
      this.own = own;
      this.color = color;
    }

    // 构造函数查看原型  prototype
    console.log(Cart.prototype)
    //实例化对象查看原型  __proto__
    var c1 = new Cart('ls', 'red');
    console.log(c1.__proto__)
原型链继承

JavaScript 中描述了原型链的概念，并将原型链作为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法.

简单回顾一下构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针(proto)

原型链的连接点就是 __ proto __

从近的往远的访问.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-66ply0Zw-1663214187827)(/1563327865157.png)]

_ proto _ 是实例对象,拥有对的指向原型的属性,而构造函数是没有的.

       function Person(name){
           this.name = name;
           this.age = 18;
       }
       var zs = new Person('zs');
    // console.log(Fn.prototype.constructor);
      console.log(zs.__proto__); // {constructor: ƒ} Fn的原型
        console.log(zs.__proto__.__proto__.constructor);  //Object
        console.log(zs.__proto__.__proto__.__proto__);  //null

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5xkKtR2S-1663214187828)(/1567236728534.png)]

绿色的线表示原型链,当zs实例调用一个属性或者方法时,现在自身找,然后一层一层的向上,直至找到null.没有则返回undefined

图中的Objct,是构造方法

原型链的改造

<script>
     Grand.prototype.lastName = 'cheng';
      function Grand(){
      
      }
      var grondObj = new Grand();

      Father.prototype = grondObj;
      function Father(){
         this.name="zs"
      }
      var fatherObj = new Father();
      
       Son.prototype = fatherObj;

      function Son(){
          this.hobbit = 'smoke';
      }
      var sonObj = new Son();
    </script>
  当Son要访问一个属性不存在时,就会找到原型的指针__proto__,然后找到原型继续找
实例属性与原型属性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aJ9wAgkz-1663214187828)(/1563327459646.png)]

原型属性的操作(了解)

查,即获取数据

删,子孙不能删除,其本身可以删除

改,除非自己增,后辈无法增

增,自己增,后辈无法增

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7WA30IkH-1663214187829)(/1563265424339.png)]

更多的原型对象

class

class也是有原型对象的.

			class Person{}
			class Test{}
			class Student extends Person{
				
			}
		   console.log(Person.prototype);

Array的原型

数组的原型上有很多方法,所以新生命的数组就可以额直接调用

字符串的原型对象

原型对象的意义

1 为了方便我们修改原型对象,实现继承.

2 可以手动给原型对象上,添加方法,实例化对象都可以使用

3 可以重构原型对象的方法,实现我们想要的功能.-

call/apply继承

作用:都是改变this的指向,只是传参的形式不同

call方法

作用: 调用该函数,并修改函数中this的指向

**语法: ** 函数名. call(对象,实参1,实参2);

参数详解:

第一个参数: 要让函数中this指向谁,就写谁

后面的参数: 被调用函数要传入的实参,以逗号分隔

    <script>
      function Person(name,age){
         this.name = name;
         this.age = age;
         console.log(this);
      }
      var personObj = new Person('cheng',88);

      let obj = {}
      Person.call(obj,'feng',66);
    </script>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9AqDhrMO-1663214187831)(/1563266567780.png)]

例1:编写person和sudent两个函数,让student中的属性和person的一样,通过call改变调用方法

  第一步:
  function Person(name,age,sex){
         this.name = name;
         this.age = age;
         this.sex = sex;
    }
    function Student(name,age,sex,tel,grade){
        this.name = name;
         this.age = age;
         this.sex = sex;
         this.tel = tel;
         this.grade = grade;
    }
    var student = new Student();
    思考:变量出现了重复怎么才能在Student中直接调用Person中的属性
    
    第二步:在Student中调用call，传递this
       function Person(name,age,sex){
         this.name = name;
         this.age = age;
         this.sex = sex;
         console.log(this);
    }
    function Student(name,age,sex,tel,grade){
         Person.call(this,name,age,sex,);
         this.tel = tel;
         this.grade = grade;
    }
    var student = new Student('cheng',20,'男',18336629253,'A');
    注意:this的指向
apply 方法

作用: 调用该函数,并修改函数中this的指向

**语法: ** 函数名. apply(对象,数组);

参数详解:

第一个参数: 要让函数中this指向谁,就写谁

第二个参数: 要去传入一个数组,里面存放被调用函数需要的实参

function fn(x, y){
    console.log(this); // {a : 1}
    console.log(x + y); //8
}
fn.apply({a : 1}, [3, 5]);
bind方法

作用: 不调用函数,克隆一个新的函数,并修改新函数中this的指向,将新的函数返回

**语法: ** 函数名. bind(对象[,实参]);

参数详解:

第一个参数: 要让函数中this指向谁,就写谁

后面的参数: 被调用函数要传入的实参,以逗号分隔

例1：实现fn中this指向的改变

function fn(x, y){
    //调用newFn时打印结果
    console.log(this);  //{b:2}
    console.log(x + y); //8
}

var newFn = fn.bind({b:2}, 3, 5);
newFn();

例2：给每一个li注册一个点击事件,点击这个li之后,每隔一秒钟,打印一下当前li中的文本

        // 1.1 获取元素
        var lis = document.getElementsByTagName('li');
        // 1.2 给每一个li注册点击事件
        for(var i = 0 ; i < lis.length; i++){
            lis[i].onclick = fn;
        }
        
        //每一个li的事件处理函数
        function fn(){
            // console.log(this);// --> 点击的那个li
            // 1.3 在事件处理函数中,设置一个定时器
            setInterval(function(){
                // 1.4 在定时器的回调函数中,打印当前li的文本
                console.log(this.innerText);
                // console.log(this); //-->window
            }.bind(this), 1000);

            //  setInterval(function(){
            //     // 1.4 在定时器的回调函数中,打印当前li的文本
            //     console.log(this.innerText);
            //     // console.log(this); //-->window
            // }.call(this), 1000);
        }
小结:

1 当我们需要直接调用函数且修改this的指向,使用call或者apply

2 当我们需要修改this的指向,但是不直接调用函数,让js来调用时,使用bind.例如,延时器,定时器,事件函数

继承

构造函数继承

我们工作中要经常创建多个具有相同属性的对象,所以经常要写构造函数.

那么构造函数创建的出来的对象该如何实现继承呢?

例:使用call构造函数的继承

function Person(name, age){
    this.name = name;
    this.age = age;
    this.sayHello = function(){
        console.log('hello, ' + '我是' + this.name );
    }
}

function Student(name, age, score){
    this.score = score;
    Person.call(this, name, age);//借用构造函数
}

var stu = new Student('zs', 18, 100);
console.log(stu); //{score : 100, name : zs, age : 18}
stu.sayHello(); //hello, 我是zs
原型继承
function Person(name, age){
    this.name = name;
    this.age = age;
    this.sayHello = function(){
        console.log('hello, ' + '我是' + this.name );
    }
}

function Student(score){
    this.score = score;
}

Student.prototype = new Person();

var stu = new Student(100);
console.log(stu); //{score : 100}
stu.sayHello(); //hello, 我是undefined
实例化的时候没有传值,所以才会出现这种情况

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vzjYlsFp-1663214187832)(/1563269665581.png)]

我们发现,方法继承下来了,但是属性却没有继承下来

混合继承

借用构造函数 + 原型继承

function Person(name, age){
    this.name = name;
    this.age = age;
    this.sayHello = function(){
        console.log('hello, ' + '我是' + this.name );
    }
}
    //父类的原型对象属性
Person.prototype.id = 10;

function Student(name, age, score){
    this.score = score;
    Person.call(this, name, age); //借用构造函数，继承父类模板
}

Student.prototype = new Person();

var stu = new Student('zs', 18, 100);
console.log(stu.id); //{score : 100, name : zs, age : 18}
stu.sayHello(); //hello, 我是zs

闭包

什么是闭包

在函数外部能够读取其他函数内部变量的函数。

通俗理解的闭包: 一个内部函数引用了外部函数的变量,外部函数形成了一个闭包.

闭包认识
初体验

例:在函数的外部实现函数内部变量的访问

function fun1(){
  var n=999;
  function fn2(){
      console.log(n);
  }
  return fn2;      //fn2 就是一个闭包函数，因为他能够访问到fun1函数的作用域
}
var r=fun1();
r();
原理

js中的变量,函数在执行的时候都会被加载到栈中,执行完毕在弹出,当使用闭包的时候,函数执行完成后,不会弹出,因为其他的地方还要加载其内部变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hnlw9oM0-1663214187833)(/1591502134979.png)]

闭包的特点

1 使用不当会很容易造成内存泄露(内存中能存的东西越来越少,像是其他部分被泄露了一样)

2 设置私有变量(内部函数调用外部函数的局部变量，此时，这个局部变量就会变成内部函数的私有变量)

3 闭包的作用:充当一个摄像头,函数外部可以访问函数内部的变量,减少变量的声明,避免造成污染.

4 内存的占用比较大,浪费内存.

函数柯理化
是什么

只是一种闭包的应用

是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。

怎么用

验证密码是否符合要求

方法1:正常写法

    function check(reg, str) {
      return reg.test(str)
    }

    // 验证密码
    const res = check(/^\w{6,12}$/, 'asdhgfahsd')
    const res2 = check(/^\w{6,12}$/, 'sdfsdf')

方法2:利用闭包

  function fn(reg) {
      return function inner(str) {
        return reg.test(str)
      }
    }
 const nameTest = fn(/^\w{5,11}$/)
 const r3 = nameTest('asd')
 console.log(r3);
上面的示例是一个正则的校验，正常来说直接调用check函数就可以了，但是如果我有很多地方都要校验是否有数字，其实就是需要将第一个参数reg进行复用，这样别的地方就能够直接调用hasNumber，hasLetter等函数，让参数能够复用，调用起来也更方便。
函数的节流和防抖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OpY160I3-1663214187834)(/1649162927143.png)]

以前的做法

  <input type="text" value="" id="user">
  <script>
    let input = document.getElementById('user');
    user.addEventListener('input', function () {
      console.log(this.value);

    });
以输入框为例，我将给input绑定input事件，当键盘松开则在控制台打印此时input框内的内容。
防抖

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q9CoNHaz-1663214187835)(/1649162983732.png)]

在事件触发指定时间之后才会执行相应的处理，若在这指定时间内事件又被调用，则会重新计时执行。
所以如果事件一直在指定时间内连续的执行，则不会触发相应处理。直到一次指定时间内没有事件被执行，才会执行一次相应的处理。

 const anti_shake = function () {
      let timer = null;
      return function (val) {
        if (timer) { // 如果存在定时器，则清除上一次操作的定时器
          clearInterval(timer);
        }
        timer = setTimeout(() => { // 重新开启定时器
          console.log(val);
        }, 500);
      }
    }

    const ctrl = anti_shake();

    document.getElementById("user").addEventListener('input', function (e) {
      ctrl(e.target.value);
    });
节流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nTpCKDj9-1663214187836)(/1649163046718.png)]

 `事件触发后在指定时间后执行相应的事件处理，如果在这个指定时间内再次触发事件，事件不会被执行。`
 直到上一次事件处理完成后，才会执行下一次的事件处理。如果一直触发事件，则事件的处理会很规律的被执行。

    const throttling = function () {
      let lock = false; // 定义锁

      return function (val) {
        if (lock) {
          return;
        }
        lock = true; // 开启锁，阻止其他事件
        // 执行操作
        console.log(val);
        setTimeout(() => {
          lock = false; // 500ms后开锁
        }, 500);
      }
    }

    const ctrl = throttling();

    document.getElementById("user").addEventListener('input', function (e) {
      ctrl(e.target.value);
    });
一直输出的话就会每隔一段时间处理相应的操作。
面试题

使用原生js给每个li绑定onclick事件,点击后输出当前li对应的索引值

一般方式

    function test(){
        var liObj = document.getElementsByTagName('li');
        var len = liObj.length;
        for(var i=0;i<len;i++){
            liObj[i].onclick = function(){
                console.log(i);
            }
        }
    }
    
   test();

闭包写法1:

    <script>
     var liObj = document.getElementsByTagName('li');
    function test(){
        var len = liObj.length;
        for(var i=0;i<len;i++){
             addClick(i);
        }
    }
    function addClick(j){
        liObj[j].onclick = function(){
                console.log(j);
            }
    }
   test();
    </script>

多学一招:自定义匿名函数

(function(){})是一个标准的函数定义，但是没有复制给任何变量。所以是没有名字的函数，叫匿名函数。没有名字就无法像普通函数那样随时随地调用了，所以在他定义完成后就马上调用他，后面的括号()是运行这个函数的意思

扩展

set和get

getter可以得到一些东西的方法，setter可以设置东西

class Person {
    constructor() {
      this._name = '';
    }
    // 获取值的
    get name() {
      console.log("正在访问name");
      return `我的名字是${this._name}`;
    }
    // 设置值的
    set name(val) {
      console.log("正在修改name");
      this._name = val;
    }
  }

  const person = new Person();
  person.name = "歌王";
  console.log(person.name); //先访问set 再访问get

nclick = function(){
console.log(j);
}
}
test();


多学一招:自定义匿名函数

(function(){})是一个标准的函数定义，但是没有复制给任何变量。所以是没有名字的函数，叫匿名函数。没有名字就无法像普通函数那样随时随地调用了，所以在他定义完成后就马上调用他，后面的括号()是运行这个函数的意思








### 扩展

#### set和get

getter可以得到一些东西的方法，setter可以设置东西

class Person {
constructor() {
this._name = ‘’;
}
// 获取值的
get name() {
console.log(“正在访问name”);
return 我的名字是${this._name};
}
// 设置值的
set name(val) {
console.log(“正在修改name”);
this._name = val;
}
}

const person = new Person();
person.name = “歌王”;
console.log(person.name); //先访问set 再访问get
Breeze fly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JS-闭包和继承
itsNekoDeng的博客
10-31 152
函数在创建的时候会创建两个对象，一个是函数对象本身，另一个是作用域链对象 函数在调用的时候会创建一个执行环境对象（活动对象） 闭包（closure） 闭包可以在全局函数里面操作另一个作用域的局部变量, 既能重复使用，又不会污染全局 闭包有三步： 1、外层函数嵌套内层函数 2、内层函数使用外层函数的局部变量 3、把内层函数作为外层函数的返回值 图例展示： 1-预解析 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-763PCw2I-1604109393588)(https://i
闭包和继承.md
02-17
闭包和继承.md
js中的闭包和继承
wdtn5656的博客
11-09 177
js中的闭包和继承
JavaScript闭包和继承
ZhangXiaoTianZC的博客
11-02 463
什么是闭包： 闭包的概念：闭包就是函数嵌套时，让局部变量变成自由变量的环境，是一种让局部变量进化的方式 （简单来说就是在函数内部书写函数，利用函数调用局部的变量） 闭包的应用场景： for (var i = 0; i < 10; i++) { console.log(i); //可以访问到每次的i } 必须满足两个条件： 1.在...
十八、闭包和继承
qq_59614745的博客
04-11 111
函数作用域嵌套，造成变量执行完不被销毁的场景就叫闭包。
JS 闭包和继承
许诺的博客
04-12 178
1.继承 继承 是类与类之间的关系 子类继承父类子类就拥有父类的属性和方法 1.JS中没有类,但是可以通过构造函数模拟类,然后通过原型来实现继承 父类 //人类-父类 function Person(){ this.name 'jack' this.age 20 } Person.prototype ={ constructor:Person, //手动设置constructor:指向构造函数 say:function(){ console.log('说话') } } 子类 //学生-子
JavaScript——闭包和继承
Bb77_的博客
02-28 111
JavaScript——闭包和继承 闭包、闭包的应用（防抖节流、函数柯里化）、继承、继承方式、ES6的类
javascript闭包和继承
m0_73644296的博客
04-11 73
概念：就是让函数不接受全部的实参，只接受部分参数，然后在函数内再次返回一个小函数，来接受剩余部分参数，让函数运行流程，可以分多个步骤执行。节流:事件在频繁触发时，不是每次触发都会执行函数，让函数有节制的执行。函数作用域的嵌套,内部函数访问外部函数作用域的变量。防抖:事件在频繁使用时,函数只执行一次。
JavaScript的模块化:封装(闭包),继承(原型) 介绍
10-27
在复杂的逻辑下， JavaScript 需要被模块化，模块需要封装起来，只留下供外界调用的接口。闭包是 JavaScript 中实现模块封装的关键，也是很多初学者难以理解的要点
JS继承与闭包及JS实现继承的三种方式
10-19
JavaScript中的继承和闭包是两种核心特性，它们在构建复杂应用程序时起着至关重要的作用。继承是面向对象编程的关键组成部分，允许子类继承父类的属性和方法，从而实现代码的复用。而闭包则是一种特殊的函数，它可以...
JavaScript 高级篇之闭包、模拟类,继承（五）
10-28
JavaScript中的闭包是一种强大...闭包提供了一种封装变量和行为的方式，模拟类和继承则帮助我们构建可复用的代码结构，实现面向对象的设计。通过深入理解这些概念，开发者可以更好地编写高效、可维护的JavaScript代码。
nodejs——原型链污染
m0_73756016的博客
06-12 859
参考滑动验证页面。
原型模式--深复制/浅复制
努力的小雨，一个阳光向上的博客不仅仅给你知识更希望带给你快乐
06-13 608
原型模式用于克隆复杂对象，由于new一个实例对象会消耗大部分时间，所以原型模式可以节约大量时间。11 Thu Jan 01 08:00:00 CST 1970 //只对s1修改。13 //深复制。4 //修改后。10 修改后。
Day5——电商日志数据分析
weixin_64365047的博客
06-12 493
今天完成第二，三问统计各个省份的浏览量 （需要解析IP）日志的ETL操作（ETL：数据从来源端经过抽取（Extract）、转换（Transform）、加载（Load）至目的端的过程）为了统计各个省份的浏览量并进行必要的ETL操作，我们设计了一个Mapper类（P2Mapper），其主要功能包括从日志文件中抽取有价值的字段，并解析IP以获取省份信息。完整ETL过程抽取（Extract）：从原始日志文件中抽取数据行。
深入理解抽象工厂模式：概念与金融行业应用
最新发布
qq_40254606的博客
06-19 241
在软件开发过程中，设计模式提供了解决特定问题的通用方案。抽象工厂模式是一种创建型设计模式，它为创建一系列相关或相互依赖的对象提供了一个接口，而无需指定它们的具体类。本文将详细介绍抽象工厂模式的概念、结构和应用，并通过一个金融行业的实际案例展示其使用方法。抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。
【JS重点15】原型对象概述
大前端开发工程师、互联网方向创业者
06-16 945
利用原型对象解决构造函数内存浪费问题
Day4——电商日志数据分析
weixin_64365047的博客
06-12 407
今天完成电商数据分析第一问：统计页面浏览量（每行记录就是一次浏览）这个基于Hadoop的MapReduce程序用于统计网页浏览量。它包含以下组件和功能：PageViewDriver类是程序的入口点，负责设置作业的配置和运行。PageViewMapper类是Mapper的实现，将输入数据处理为键值对。PageViewReducer类是Reducer的实现，对Mapper的输出进行聚合和处理。Mapper和Reducer的输出键值对类型都是Text和IntWritable。
【JS重点18】原型链（面试重点）
大前端开发工程师、互联网方向创业者
06-16 330
原型链的形成的底层原理以及原型链的应用
js闭包和原型链的面试题目
09-02
闭包是指在一个函数内部定义的函数可以访问外部函数的变量和参数，即使外部函数已经执行结束。闭包形成一个封闭的作用域，保留了外部函数的变量和环境。这种特性使得闭包可以解决诸如变量私有化、保存变量状态等问题。 闭包的应用场景有很多，例如在异步编程中，可以使用闭包来保持状态，避免变量提升导致的错误；在模块化开发中，可以使用闭包来实现私有变量和方法的封装。但闭包也有一些注意事项，比如会占用内存，造成内存泄漏；还可能导致变量无法被垃圾回收，影响性能。 原型链是JavaScript中实现继承的机制。每个JavaScript对象都有一个内置的属性__proto__指向它的原型对象，原型对象又有自己的__proto__，形成了原型链。当访问对象的属性或方法时，会先在对象本身查找，如果找不到则沿着原型链向上查找，直到找到或者到达原型链的末尾（即null）。 原型链的好处是可以节省内存，将公共的属性和方法定义在原型对象中，所有实例对象共享这些属性和方法；还可以实现继承，子类对象的原型对象可以指向父类对象，从而共享父类的属性和方法。 原型链的缺点是只能继承父类的实例属性和方法，不能继承构造函数中的私有属性和方法；还有可能出现多个子类实例共享同一个父类实例的情况，导致数据共享的问题。 为了解决原型链继承的缺点，ES6引入了class关键字，可以更方便地实现面向对象编程，并且支持super关键字调用父类的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值