JavaScript-----原型链

最新推荐文章于 2022-11-16 20:11:25 发布
最新推荐文章于 2022-11-16 20:11:25 发布
阅读量154 收藏
点赞数 3
文章标签： 原型模式 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58646138/article/details/125038189
版权

摘要

这篇博客博客我们主要解决以下几个问题：

  • 什么是构造函数的原型对象?
  • 什么是对象的原型对象？
  • 什么是原型对象的原型对象？
  • 如何通过原型链来实现类的继承？

内容补充：

        要解决以上问题我们就先了解JavaScript中类和对象以及类的继承的相关知识，接下来我们先来回顾一下相关知识：（若你对ES5、ES6中类的知识已经了解了可直接看问题解决）

一、ES6的面向对象的语法

「1.面向对象的三大特征」

  • 封装性：对象是属性和行为的封装体
  • 多态性：同一消息被不同对象接收后，表现的结果不同
  •  继承性：子类可以继承父类的属性和方法

「2.ES6中定义类」

类：是具有相同属性和行为的对象的集合(类是对象的抽象)

class Student{
    constructor(id,name,sex){ //构造方法
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = 18;
        this.address = null;
    }
    show(){ //成员方法(成员函数)
        console.log('学号：',this.id)
        console.log('姓名：',this.name)
        console.log('性别：',this.sex)
        console.log('年龄：',this.age)
        console.log('地址：',this.address)
    }
}
  • '类名'：首字母大写
  •  构造方法：对类的对象进行初始化的。不会显式调用。
  •  成员方法：表示某种行为。

「3.ES6中创建对象」 

 对象：是类的实例化，使用new运算符

var s1 = new Student(1001,'郭靖','男')//在内存中开辟了一个存储空间

(1)构造方法：
          A、作用是初始化对象
          B、调用：不能显式调用，而是通过类名调用  

(2)this指针：指当前的对象
(3)属性和方法的使用
     属性：对象名.属性           
     方法：对象名.方法名([参数])

使用new运算符创建实例化对象的过程。在使用new运算符调用类的构造方法是会执行的操作有:
1、在内存中创建新对象,即给对象分配一块存储区。
2、在该对象的内部[prototype]指针指向构造函数的constructor属性
3、构造函数内部的this指针指向该新对象
4、执行构造函数内部的代码(给新对象添加属性和方法)
5、如果构造函数返回非空对象则返回该对象;否则返回刚创建的新对象

s1.show()

s1.age = 22
s1.address = '蒙古'

s1.show()


           
二、ES6中类的继承

子类可以继承父类的部分属性和方法,在继承后子类还可以定义自己独有的属性和方法

「1.子类」

子类又称”派生类“。是继承的类
「2.父类」

父类又称“超类、基类”，是被继承的类
「3.语法格式」

class 子类名 extends 父类名{
          构造方法(){}
          成员方法
        }

   「4.子类访问父类的属性和方法」
（1）使用super关键字调用父类的构造方法: super([参数])
             
          注意：
          
           (a)从父类继承过来的属性必须通过super调用父类的构造方法进行初始化
           
           (b)super([参数])必须作为子类构造方法的第一条语句
           
           (3)无论是父类或子类属性的初始化都必须通过构造方法来完成
        
（2）使用super调用父类的普通成员方法：  super.方法名([参数])
 「5.方法覆盖和方法重载」

     当子类的成员方法和父类的成员方法重名时,子类的方法会覆盖父类的同名方法--方法覆盖(override)。
       方法重载(OverLoad):给同一个方法(函数)传递不同的参数，其执行结果不同。

class Father{  //父类或超类
    constructor(x,y){
        this.x = x  //this.x中的x表示是父类Father的属性
        this.y = y  //this.y中的y表示是父类Father的属性
    }
    money(){
        console.log(100)
    }
    getSum(){ //获取x和y的和
        return this.x + this.y
    }
}
class Son extends Father{ //子类Son继承Father
  //(1)调用父类的构造方法初始化x和y属性
  constructor(x,y,z){ //是子类Son自己的构造方法
    super(x,y) //调用父类的构造方法,x、y是Son从Father中继承的
    this.z = z //this.z中的z是Son自己的属性
  }
  getSum(){ //子类Son自己的成员方法
    let s = super.getSum() + this.z//通过super调用父类的getSum()方法
    console.log(s)
  }
}

//创建子类对象
var s1 = new Son(10,20,30)
s1.getSum()
// s1.money() //子类继承了父类的方法

s1.money运行结果： 

s1.getSum运行结果：  

三、ES5中创建类

    1、创建构造函数，在构造函数中定义属性和方法
       (1)构造方法名就是类名
       (2)和使用class创建类的区别
           a、构造方法创建类：属性和方法都在构造方法中定义  
           b、使用class创建类：属性在构造方法中定义,

//ES5中创建类
function Person(name,sex){ //构造函数,name、sex是构造函数的参数,构造函数名就是类名
    this.name = name  //this.name中的name是Person类的属性
    this.sex = sex //this.sex中的sex是Person类的属性

    this.sleep= function(){ //sleep是成员方法
        console.log(this.name+'在睡觉')
    }
    this.eat = function(){ //eat是成员方法
        console.log(this.name+'在吃饭') 
    }
}
//ES6中创建类
class Person{
    constructor(name,sex){
        this.name = name
        this.sex = sex
    }
    sleep(){ //sleep是成员方法
        console.log(this.name+'在睡觉')
    }
    eat(){ //eat是成员方法
        console.log(this.name+'在吃饭') 
    }
}

四、类的静态成员和实例成员

类的静态成员和实例成员：又称为类成员

「1.实例成员」

实例成员(成员变量和成员方法)：属于类的实例(具体的对象) 
「2.静态成员」

包括静态的成员变量和静态的成员方法。不属于某个具体的对象，而是类的所有对象共享的成员。是通过类名(或构造方法名)访问的成员

 强调：在ES6中定义静态成员方法时必须用static关键字修饰

function Student(s,name,sex){
    // this.school = school  //this.school是实例变量
    Student.school = s //school 是静态的成员变量，Student的所有对象共享该成员

    this.name = name //this.name是实例变量
    this.sex =sex //this.sex是实例变量

    this.diplay = function(){
        let str = '学校：'+Student.school+'\n姓名：'+this.name+'\n性别：'+this.sex
        console.log(str)
    }
    Student.sayHello = function(){ //静态成员函数
        console.log('Hello '+Student.school)
    }
}

var s1 = new Student('西安交通大学','周瑜','男')
var s2 = new Student('西安交通大学','小乔','女')
var s3 = new Student('西安交通大学','黄盖','男')

//Student.school = '西安邮电大学'

s1.diplay()
s2.diplay()
s3.diplay()

Student.sayHello()

 若将Student.school = '西安邮电大学'注释则代码运行结果为

若取消Student.school = '西安邮电大学'代码的额注释则运行结果为

由上诉实验结果可看出静态成员对所有对象共享。 

五、原型对象

「1.原型对象」

每个构造函数都有一个原型对象,是通过构造函数的prototype属性来访问
「2.作用」
       (1)使用原型对象共享方法

「3.对象的原型对象」

  • 每个对象都有一个原型对象,是通过'__proto__'访问
  • 构造方法的原型对象和由该构造方法创建的对象的原型对象是相等的(一样的)
  •  ES6中通过class关键字创建的类其本质还是构造方法
function Person(name){ //构造方法：方法名就是类名
    this.name = name
    this.show = function(){
        console.log('姓名：',this.name)
    }
}

Person.prototype.sayHello = function(){
    console.log('Hello 西安邮电大学')
}

//输出Person的原型对象
// console.log(Person.prototype) //node中输出：{},在浏览器控制台输出：{constructor: ƒ}

var p1 = new Person('高峰')
var p2 = new Person('张宇')

/* let flag1 = (p1.sayHello === p2.sayHello) //判断p1和p2调用的是否是同一函数
console.log('flag1=',flag1) //输出：true

let flag2 = (p1.show === p2.show)
console.log('flag2=',flag2) //输出：false */

//输出p1对象的原型对象
console.log(p1.__proto__) //node中输出：{},在浏览器控制台输出：{constructor: ƒ}

console.log(p1.__proto__ === Person.prototype) //输出：true

六、类的创建

「1.ES5中创建的方法」
构造函数名就是类名

function 函数构造名([参数]){
    成员变量（数据成员）
    成员方法
}

「2.ES6中创建的方法」
(1)

class 类名{
    构造函数([参数]){
        初始化成员变量
    }
   成员方法
}

(2)类表达式

var 变量名 = class{
    构造函数([参数]){
        初始化成员变量
    }
   成员方法
}

通过上面的内容补充我们对ES5、ES6中类的相关知识有了一定的了解那么接下来我们就来解决摘要中要解决的问题。

问题解决

一、构造函数与原型对象


「1.构造函数」

构造函数主要用来创建对象，并为对象的成员赋初始值。

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.sing = function() {
    console.log('我会唱歌');
  };
}
var p1 = new Person('张三', 18);
var p2 = new Person('李四', 19);
console.log(p1.name); // 输出结果：张三
console.log(p2.age); // 输出结果：19
p2.sing(); // 输出结果：我会唱歌

「2.原型对象」

每个构造函数都有一个原型对象存在，这个原型对象通过构造函数的prototype属性来访问。

function Person() {} // 定义函数
console.log(Person.prototype); // 输出结果：{constructor: ƒ}
console.log(typeof Person.prototype); // 输出结果：object

二、原型链

「1.访问对象的原型对象」

对象的原型对象：每个对象都有一个__proto__属性，这个属性指向了对象的原型对象。

function Person() {}
var p1 = new Person();
console.log(p1.__proto__ === Person.prototype); // 输出结果：true

「2.访问对象的构造函数」

对象的构造函数：在原型对象里面有一个constructor属性，该属性指向了构造函数。

function Person() {}
// 通过原型对象访问构造函数
console.log(Person.prototype.constructor === Person);	// 输出结果：true
// 通过实例对象访问构造函数
var p1 = new Person();
console.log(p1.constructor === Person); // 输出结果：true

 「3.原型对象和原型对象」

原型对象的原型对象：原型对象也是对象，那么这个对象应该也会有一个原型对象存在。

function Person() {}
// 查看原型对象的原型对象
console.log(Person.prototype.__proto__);
// 查看原型对象的原型对象的构造函数
console.log(Person.prototype.__proto__.constructor);

 「4.原型链」

原型链结构特点：

  • 每个构造函数都有一个prototype属性指向原型对象。
  • 原型对象通过constructor属性指向构造函数。
  • 通过实例对象的__proto__属性可以访问原型对象。
  • Object的原型对象的__proto__属性为null。

 「5.成员查找机制」

成员查找机制：

  • JavaScript首先会判断实例对象有没有这个成员
  • 如果没有找到，就继续查找原型对象的原型对象
  • 如果直到最后都没有找到，则返回undefined。
function Person() {
     this.name = '张三';
}
Person.prototype.name = '李四';

var p = new Person();
console.log(p.name); // 输出结果：张三

delete p.name; // 删除对象p的name属性
console.log(p.name); // 输出结果：李四

delete Person.prototype.name; // 删除原型对象的name属性
console.log(p.name); // 输出结果：undefined

三、this指向

 「1.分析指针this」

函数中this指向，情况如下：

  • 构造函数内部的this指向新创建的对象。
  • 直接通过函数名调用函数时，this指向的是全局对象window。
  • 如果将函数作为对象的方法调用，this将会指向该对象。
function foo() {
  return this;
}
var o = {name: 'Jim', func: foo};
console.log(foo() === window); // 对应第2种情况，输出结果：true
console.log(o.func() === o);	// 对应第3种情况，输出结果：true

 「2.更改this指向」

更改this指向方法有：apply()方法和call()方法。

function method() {
    console.log(this.name);
  }
  n1={ name: '张三' }
  n2={ name: '李四' }
  method.apply(n1); 	// 输出结果：张三  此时method方法的this指向n1
  method.call(n2);	// 输出结果：李四  此时method方法的this指向n2
  1. 两个方法的区别和联系
  • 在调用函数时第一个参数默认就是对象
  • apply()方法除第一个参数外第一个参数以数组方式传递  
  • c.call()方法除第一个参数外后面的参数   
//apply()和call()的区别
  function method(a, b) {
    console.log(a + b);
  }
  method.apply({}, ['1', '2']); 	// 数组方式传参，输出结果：12
  method.call({}, '3', '4');		// 参数方式传参，输出结果：34

四、继承

ES6的继承

ES6的继承(一个类的直接父类只能有一个)
class 子类名 extends 父类名{构造方法  成员方法}

class Father{
    constructor(name){
        this.name=name
    }
    show(){
        console.log('姓名:'+this.name);
    }
}

class Son extends Father{//子类
    constructor(name){
        super(name)//在子类的构造方法中调用父类的构造方法----经典继承（对象伪造或盗用构造方法）
    }

}

ES5的继承

 「1.借构造函数继承父类属性」

call()方法 ：将父类的this指向子类的this，这样就可以实现子类继承父类的属性。

function Father(name){
    this.colors=['red','green','pink']//colors属性的值是引用值（数组）
    this.name=name
    this.show = function(){
        console.log('姓名:'+this.name);
    }
}
function Son(Subname){
    Father.call(this,Subname)//继承父类  在子类的构造方法中通过call()函数调用父类构造函数
}

var s1=new Son('刘备')
s1.show()//姓名:刘备
console.log(s1.colors);//[ 'red', 'green', 'pink', 'black' ]

 「2.利用原型对象继承父类方法」

原型对象继承父类方法：将父类的实例对象作为子类的原型对象来使用

//通过原型链实现类的继承
//1.定义父类
function SuperType(){
    this.property='中国人民银行'
}
//2.给SuperType的原型对象添加方法
SuperType.prototype.getSuperValue = function(){
    return this.property
}
//3.定义子类构造方法
function SubType(){
    this.subProperty = '中国工商银行'
}
//4.实现SubType对SuperType的继承
SubType.prototype=new SuperType()//通过原型对象实现子类对父类的继承
//5.在子类的原型对象上增加一个方法
SubType.prototype.getSubValue=function(){
    return this.subProperty
}
//子类覆盖父类的
SubType.prototype.getSuperValue=function(){
    return '中国建设银行'
}
//6.创建一个子类实例对象
let sub=new SubType()
let s1=new SuperType()
/* console.log(sub.getSuperValue());//子类的实例对象调用父类的方法
console.log(sub.getSubValue());//子类的实例对象调用子类类的方法 */

/* console.log(sub instanceof Object);//true
console.log(sub instanceof SuperType);//true
console.log(sub instanceof SubType);//true */

/* console.log(s1 instanceof Object);//true 
console.log(s1 instanceof SuperType);//true 
console.log(s1 instanceof SubType);//false */

console.log(Object.prototype.isPrototypeOf(sub));//判断sub的原型对象是不是Object的原型对象   true
console.log(SuperType.prototype.isPrototypeOf(sub));  //true
console.log(SubType.prototype.isPrototypeOf(sub));  //true

3、在原型链继承中实现方法的覆盖(Override)--子类方法和父类方法同名时，子类方法覆盖了父类的方法。
实现方法：在子类的原型对象方法上添加和父类的完全同名的方法
4、在继承过程中确立原型对象和实例对象之间的关系方法 
(1)instanceof运算符:判断实例对象的类型
(2)isPrototypeOf()方法:判断原型对象的类型


五、原型链的缺点和解决办法

「1.原型链的问题」
(1)若原型中包含引用值，则该引用值会在所有的实例对象中共享。这既是属性放在构造方法中定义而不放在原型对象中定义的原因
(2)子类的实例对象不能给父类型的构造方法传参
「2.原型链问题的解决办法」
6、原型链问题的解决办法:盗用父类的构造方法(又称'对象伪造'或'经典继承')
基本思路：在子类的构造方法中调用父类的构造方法。
(1)ES6中 

class Father{
    constructor(name){
        this.name=name
    }
    show(){
        console.log('姓名:'+this.name);
    }
}

class Son extends Father{//子类
    constructor(name){
        super(name)//在子类的构造方法中调用父类的构造方法----经典继承（对象伪造或盗用构造方法）
    }

}

(2)ES5中:将父类的this指向子类的this,这样就可以实现子类继承父类的属性。

function Father(name){
    this.colors=['red','green','pink']//colors属性的值是引用值(数组)
    this.name=name
    this.show = function(){
        console.log('姓名:'+this.name);
    }
}
function Son(Subname){
    Father.call(this,Subname)//继承父类  在子类的构造方法中通过call()函数调用父类构造函数
}
*Miraitowa*
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javascript-原型与原型链
05-18
javascript-原型与原型链
JS高级 之 ES5 实现继承
玄鱼殇
07-20 1305
JS高级 之 ES5实现继承
【JavaScript】 ES6—面向对象、类、构造函数
南栀的博客
06-01 190
文章目录1 面向对象 1 面向对象
构造函数（constructor）与原型链（prototype）关系
weixin_34223655的博客
02-23 372
在Javascript中不存在class的概念，它的class概念是通过构造函数（constructor）与原型链（prototype）来实现。 1.构造函数（constructor）：创建对象时的初始化对象，总是与new 关键是一同出现。 构造函数存在以下特点： 1、构造函数内的this 指向当前实例对象。 2、使用ne...
javascript面向对象——constructor属性（构造函数属性）
待归魔帝的博客
08-22 2420
什么是constructor属性？它来之哪里？又将会指向何处？ 什么是constructor属性？ constructor是构造函数属性。 它来之哪里？ 其实constructor属性是来自 prototy原型属性 所指向的那个对象的属性，如果不明白这里的“那个对象”具体指的是哪个对象，可以看看我上一章将的 javascript面向对象——prototype属性（原型属性
constructor的使用
零点符号
04-19 826
constructor 是一种用于创建和初始化class创建的对象的特殊方法。 语法： constructor([arguments]) { … } 描述： 在一个类中只能有一个名为 “constructor” 的特殊方法。 一个类中出现多次构造函数 (constructor)方法将会抛出一个 SyntaxError 错误。 在一个构造方法中可以使用super关键字来调用一个父类的构造方法。 如果...
javascript-learning-path:javascript学习路径
03-15
:school: :school: :school: JavaScript学习路径 运行JavaScript 脚本标签 浏览器控制台 链接外部文件 宣言 范围 全球的 功能 堵塞 吊装 原始类型 复合类型 空值 功能 目的 数据结构 大批 放 地图 日期 类型转换 ...
戏说JS中的原型-Prototype
02-25
什么是原型：在了解原型链之前我们先来看看一个函数在创建过程中做了哪些事情，举一个空函数的例子：当我们在代码里面声明这么一个空函数，js解析的本质是：1、创建一个对象（有constructor属性及[[Prototype]]属性...
SoftUni-JavaScript-Advanced
03-16
您将看一下JavaScript的OOP部分（继承，原型和原型链）。 获得的技能 使用类和对象 使用函数和JSON格式 使用线性结构 DOM树的信息检索和处理 代码质量测试 面向对象和函数式编程 主题 语法，函数和语句 对象 数组 ...
构造函数和原型以及实例之间的关系
weixin_52026514的博客
11-22 626
构造函数和原型以及实例之间的关系 一、构造函数和普通函数的区别 1.构造函数的函数名首字母大写 来与普通函数进行区分 2.构造函数 通过new来调用 3.构造函数中的this指向这个构造函数　　而普通函数中的this指向window var dog = function(){ //普通函数的定义 console.log("我是一个普通函数"); } dog();
constructor功能及用法
热门推荐
不能再菜
08-11 1万+
我们必须了解的一些概念： 所有的函数都有一个prototype属性，它是一个对象。 prototype有一个constructor的属性，默认是指向prototype所在的构造函数。 constructor会被实例继承。他的作用就是表名某个实例对象是由哪个构造函数产生的。如下，p是没有constructor 的，他的constructor 就指向P function P(){} const p = new P(); p.constructor === P // true 利用constructor
详解Object.constructor
weixin_30778805的博客
01-17 843
对象的constructor属性引用了该对象的构造函数.对于 Object 对象，该指针指向原始的 Object() 函数.如下: var obj = {}; obj.constructor //ƒ Object() { [native code] } obj.constructor == Object //true var arr = []; arr.constructor ...
【JavaScript】JavaScript原型链之原型对象、实例和构造函数三者之间的关系
有心博客
11-16 988
前言：用了这么久js，对于它的原型链一直有种模糊的不确切感，很不爽，隧解析之。 本文主要解决的问题有以下三个： (1)constructor和prototype以及实例之间啥关系？ (2)prototype是啥，proto又是啥，他们之间啥关系？ (3)如果改变一个constructor的prototype，他的实例会发生什么变化？ ok，下面一个一个解决。 (1)constructor和
什么是原型，原型链？原型链是如何实现的？(带图清晰理解)
weixin_51345789的博客
11-16 1394
以下认识都属于个人观点：首先先了解原型对象和原型的概念：一张通俗易懂的原型链图能够了解其中的结构：注：所有的构造函数都是对象，故称为函数对象。如上图中从实例对象中开始寻找：实例对象p1.__proto__ ==>原型对象Person.__proto__ ==>原型对象Object.__proto__ ==>null
js 继承
Kaizd的博客
12-16 83
js 继承 1.原型链继承 --> 子类.prototype= new 父类(“参数”) ​ 优点：（继承所有）继承父类 本身 以及 原型对象上的所有 属性 方法。 ​ 缺点： 不能给父类 的构造函数传参数 。 function Fu(name){ this.name=name } Fu.prototype.say=function(){ console.log("lalala") } funct
构造函数 原型对象 实例三者关系
shbk_的博客
03-10 168
构造函数 原型对象 实例三者关系 每一个构造函数都有一个原型对象 在构造函数内有prototype属性指向它的原型对象 在原型对象中有constructor属性指向它对应的构造函数 在原型对象中有一些属性和方法，是公用的，实例可以调用 实例是通过构造函数创建出来的对象 var obj = new Object(); Object.prototype.constructor === Objectobj.constructor === Object Object.prototy
如何用原型链的方式实现一个 JS 继承？
fe_watermelon的博客
04-14 2009
大家好，我是前端西瓜哥。今天讲一道经典的原型链面试题。原型链是什么？JavaScript 中，每当创建一个对象，都会给这个对象提供一个内置对象 [[Prototype]] 。这个对象就是原型对象，[[Prototype]] 的层层嵌套就形成了原型链。当我们访问一个对象的属性时，如果自身没有，就会通过原型链向上追溯，找到第一个存在该属性原型对象，取出对应值。当然原型链不是无止境的，和单链表一样，最后一个原型对象的值是 null，原型链的所有对象都找不到指定的属性时，我们会拿到 undefined。[[Prot
构造函数、实例、原型对象之间的关系（笔记草稿）
weixin_46554760的博客
10-18 160
每个函数都会创建一个prototype属性，这个属性是一个对象，即原型对象，包含实例共享的数据和方法，实际上这个属性就是实例的原型，使用原型的好处就是定义在原型对象上的属性和方法可以被实例共享 总结 ：每个函数都有一个prototype属性（是一个对象）指向原型对象，所有原型对象都会有一个constructor 属性(指回构造函数)，原型对象上的属性和方法可以被实例共享 Person.prototype.constructor 指向 Person prototype :{ -> 指向原型对象 Cons
构造函数与原型详解（prototype、__proto__、constructor）
泊一的博客
08-13 1210
文章目录1.构造函数1.1 对象创建的三种方式1.2静态成员和实例成员1.2.1实例成员1.2.2静态成员2. 构造函数的问题3.原型相关3.1 构造函数原型对象——prototype3.2 对象原型__proto__3.3 constructor构造函数3.4 三者之间的关系3.5 原型链3.5.1 原型链的查找机制4. 通过原型为数组扩展内置方法 1.构造函数 1.1 对象创建的三种方式 字面量方式 var obj = {}; new关键字 var obj = new Object();
javascript 原型 原型链
最新发布
09-01
- *3* [JavaScript原型链(重要)](https://blog.csdn.net/liyuchenii/article/details/125957625)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值