实现一个Promise，了解Promise原理

最新推荐文章于 2024-04-05 03:27:49 发布
最新推荐文章于 2024-04-05 03:27:49 发布
阅读量245 收藏
点赞数 1
分类专栏： JS基础 文章标签： javascript 前端 typescript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51670675/article/details/124821099
版权

一、前言

  • 其实 Promise 有多种规范，除了前面的 Promise A、promise A+ 还有 Promise/B，Promise/D。
  • 目前我们使用的 Promise 是基于 Promise A+ 规范实现的，感兴趣的移步 Promise A+规范了解一下，这里不赘述。

1. Promise基本使用

const promise = new Promise((resolve, reject) => {
   // 其他代码...
   if (/* 异步操作成功 */){
       resolve(value);
   } else {
       reject(error);
   }
})

promise.then(value => {
  console.log('resolve', value)
}, reason => {
  console.log('reject', reason)
})

// 输出 resolve success

2. 思路

Promise 是一个类，在执行这个类的时候会传入一个执行器，这个执行器会立即执行

Promise 会有三种状态

  • Pending 等待
  • Fulfilled 完成
  • Rejected 失败

状态只能由 Pending --> Fulfilled 或者 Pending --> Rejected，且一但发生改变便不可二次修改；

Promise 中使用 resolve 和 reject 两个函数来更改状态；

then 方法内部做但事情就是状态判断

  • 如果状态是成功，调用成功回调函数
  • 如果状态是失败，调用失败回调函数

二、实现同步版本

1. 传入执行器

  • executor 是实例化时传入的一个执行器，进入会立即执行。

  • 在执行器中传入resolve和reject方法，可以在外部进行调用。

class MyPromise {
  constructor(executor){
     // 调用此方法就是成功
  	let resolve = () => {}
  	// 调用此方法就是失败
  	let reject = () => {}
    try {
       // executor 执行器，传入resolve和reject方法
       executor(resolve, reject) 
    }catch {
       reject(error)
    }
  }
}

状态与结果的管理

// 先定义三个常量表示状态
var PENDING = 'pending';
var FULFILLED = 'fulfilled';
var REJECTED = 'rejected';

class MyPromise {
  constructor(executor) {
    // 初始化状态，为pending
    this.status = PENDING;

    // 结果/原因
    this.value = undefined;
    this.reason = undefined;

    // 修改状态，并执行成功回调
    let resolve = (value) => {
      // 只有状态是等待，才执行状态修改
      if (this.status === PENDING) {
        // 状态修改为成功，并保存结果
        this.status = FULFILLED;
        this.value = value;
      }
    }

    // 修改状态，并执行失败回调
    let reject = (reason) => {
      // 只有状态是等待，才执行状态修改
      if (this.status === PENDING) {
        // 状态修改为失败，保存失败原因
        this.status = REJECTED;
        this.reason = reason;
      }
    }

    // 立即执行，将 resolve 和 reject 函数传给使用者  
    try {
      executor(resolve, reject)
    } catch (error) {
      reject(error)
    }
  }
}

2. then 的简单实现

class MyPromise {
  // 省略...
  // then方法实现
  then(onFulfilled, onRejected) {
    if (this.status === FULFILLED) {
      // 调用成功回调，并且把值返回
      onFulfilled(this.value);
    } else if (this.status === REJECTED) {
      // 调用失败回调，并且把原因返回
      onRejected(this.reason);
    }
  }
}
module.exports = MyPromise

到这里就可以处理简单的同步问题了。

测试

const MyPromise = require('./my-promise.js')

const promise = new MyPromise((resolve, reject) => {
  resolve('success')
  reject('err')
})

promise.then(value => {
  console.log('resolve', value)
}, reason => {
  console.log('reject', reason)
})

执行node test，查看结果

三、加入异步逻辑

1. 缓存成功与失败回调

  • 执行到then方法时，耗时操作还没有结果，这个时候先将回调保存起来。
  • 这里使用数组保存，因为then方法可以调用多次。
class MyPromise {
  constructor(executor) {
    // 用于存储回调函数
    this.onResolvedCallbacks = [];
    this.onRejectedCallbacks = [];

  }
  // 执行回调
  then(onFulfilled, onRejected) {
    if (this.status === FULFILLED) {
      // 调用成功回调，并且把值返回
      onFulfilled(this.value);
    } else if (this.status === REJECTED) {
      // 调用失败回调，并且把原因返回
      onRejected(this.reason);
    } else if (this.status === PENDING) {
      // 存储回调函数
      this.onResolvedCallbacks.push(() => {
        onFulfilled(this.value)
      });
      this.onRejectedCallbacks.push(() => {
        onRejected(this.reason);
      })
    }
  }
}
  • 状态变更的时候触发
// 修改状态，并执行成功回调
let resolve = (value) => {
  // 只有状态是等待，才执行状态修改
  if (this.status === PENDING) {
    // 状态修改为成功，并保存值
    this.status = FULFILLED;
    this.value = value;
    // 执行回调
    this.onResolvedCallbacks.forEach(fn => fn());
  }
}

// 修改状态，并执行失败回调
let reject = (reason) => {
  // 只有状态是等待，才执行状态修改
  if (this.status === PENDING) {
    // 状态修改为失败，并保存原因
    this.status = REJECTED;
    this.reason = reason;
    // 执行回调
    this.onRejectedCallbacks.forEach(fn => fn());
  }
}
  • 到这里，就可以处理异步问题了。

测试

  • 使用定时器模拟耗时操作。
const MyPromise = require('./my-promise.js')

const promise = new MyPromise((resolve, reject) => {
  setTimeout(() => {
    resolve('success')
  }, 2000);
})

promise.then(value => {
  console.log(1)
  console.log('resolve', value)
})

promise.then(value => {
  console.log(2)
  console.log('resolve', value)
})

promise.then(value => {
  console.log(3)
  console.log('resolve', value)
})

结果

1
resolve success
2
resolve success
3
resolve success

这里实现了一个发布订阅模式，收集依赖 => 触发通知 => 取出依赖执行

2. then 的链式调用&值穿透特性

  1. then 方法要链式调用那么就需要返回一个 Promise 对象。
  2. then 方法里面 return 一个返回值作为下一个 then 方法的参数，这就是所谓的值的穿透。
  3. then方法中抛出异常，需要把异常作为参数传递给下一个 then 的失败的回调中。
then(onFulfilled, onRejected) {
  //解决 onFufilled，onRejected 没有传值的问题
  onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v;
  //因为错误的值要让后面访问到，所以这里也要跑出个错误，不然会在之后 then 的 resolve 中捕获
  onRejected = typeof onRejected === 'function' ? onRejected : err => { throw err };

  // 每次调用 then 都返回一个新的 promise
  let promise2 = new Promise((resolve, reject) => {
    if (this.status === FULFILLED) {
      process.nextTick(() => { // 状态变化，添加微任务
        try {
          // 得到then方法的返回值
          let x = onFulfilled(this.value);
          resolve(x) // 先不考虑x为promise的情况
        } catch (e) {
          reject(e)
        }
      });
    }
    if (this.status === REJECTED) {
      process.nextTick(() => {
        try {
          let x = onRejected(this.reason);
          resolve(x) // 先不考虑x为promise的情况
        } catch (e) {
          reject(e)
        }
      });
    }
    if (this.status === PENDING) {
      this.onResolvedCallbacks.push(() => {
        process.nextTick(() => {
          try {
            let x = onFulfilled(this.value);
            resolve(x) // 先不考虑x为promise的情况
          } catch (e) {
            reject(e)
          }
        });
      });
      this.onRejectedCallbacks.push(() => {
        process.nextTick(() => {
          try {
            let x = onRejected(this.reason);
            resolve(x) // 先不考虑x为promise的情况
          } catch (e) {
            reject(e)
          }
        });
      });
    }
  })
  return promise2
}

这里使用process.nextTick()模拟异步

为什么 Promise 的 onFulfilled 和 onRejected 必须是异步的?

我们知道 Promise handler 执行时机其实很容易定义

  1. 如果父亲 Promise 的状态不是 pending, 就立马执行
  2. 否则, 等到父亲 Promise 状态变化时才执行

因此, 理论上 Promise handler 执行不管是异步还是同步都可以完成这个逻辑。

我们把强制异步的标准派当做正方, 把认为同步异步都可以的当做反方。

反方认为: 如果本来是同步的逻辑被强制异步执行, 肯定是会有性能损失, 标准不应该强制异步。

正方则认为: 流程可预测(predictably)是最为重要的, 标准需要强制异步。

最终, 正方胜利, 标准制定者认为 Promise 主要解决的问题是 流程抽象 和 规范一致性, 性能并不是首要考虑的。

我们希望代码执行顺序是完全可以预测的, 流程控制最首要的就是可控!

  • 而回调（then方法中的）如果可能同步、也可能异步，执行顺序就变成了不确定的。

例子1

var foo
promise.then(() => {
  foo = {}
})
console.log(foo.bar) // always crash
// 任何一个 Promise 使用者都应该知道这段代码是会报错的

例子2

console.log(1)
var promise = new Promise(resolve => {
  console.log(2)
  resolve()
})
promise.then(() => {
  console.log(3)
})
console.log(4)
// 我们确保执行输出顺序永远是 `1, 2, 4, 3`

3. then返回值是一个Promise

我们继续完成Promise，再结合 Promise/A+ 规范梳理一下思路：

  1. 如果 then 的返回值 x 是一个 promise，那么会等这个 promise 执行完，promise 如果成功，就走下一个 then 的成功；如果失败，就走下一个 then 的失败；如果抛出异常，就走下一个 then 的失败；「规范 Promise/A+ 2.2.7.3、2.2.7.4」
  2. 如果 then 的返回值 x 和 promise 是同一个引用对象，造成循环引用，则抛出异常，把异常传递给下一个 then 的失败的回调中；「规范 Promise/A+ 2.3.1」
  3. 如果 then 的返回值 x 是一个 promise，且 x 同时调用 resolve 函数和 reject 函数，则第一次调用优先，其他所有调用被忽略；「规范 Promise/A+ 2.3.3.3.3」
const resolvePromise = (promise2, x, resolve, reject) => {
  // 不允许自己引用自己，这样会陷入死循环
  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
  }
  // 一个then方法防止调用多个操作
  let called;

  // x是一个对象或者函数，且不是null
  if ((typeof x === 'object' && x != null) || typeof x === 'function') {
    try {
      // 为了判断 resolve 过的就不用再 reject 了（比如 reject 和 resolve 同时调用的时候）
      let then = x.then;
      // 如果then是函数，就默认是promise了
      if (typeof then === 'function') {
        // 就让then执行 第一个参数是this指向   后面是成功的回调 和 失败的回调
        then.call(x, y => {
          // 成功和失败只能调用一个
          if (called) return;
          called = true;
          // resolve的结果依旧是promise 那就继续解析
          resolvePromise(promise2, y, resolve, reject);
        }, r => {
          // 成功和失败只能调用一个
          if (called) return;
          called = true;
          reject(r);
        });
      } else {
        // 如果 x.then 是个普通值就直接返回 resolve 作为结果(能调用.then，但不是函数，说明不是promise，只是和promise类似)
        resolve(x);
      }
    } catch (e) {
      if (called) return;
      called = true;
      reject(e)
    }
  } else {
    // 如果 x 是个普通值就直接返回 resolve 作为结果
    resolve(x)
  }
}
  • then方法中引入该函数
x.then(resolve, reject) // 先不考虑x为promise的情况
// 修改为
resolvePromise(promise2, x, resolve, reject);

测试

const promise = new MyPromise((resolve, reject) => {
  setTimeout(() => {
    reject('失败');
  }, 1000);
})

promise.then().then().then(data => {
  console.log(data);
}, err => {
  console.log('err', err);
})

打印结果

"失败 err"
  • 至此，我们已经完成了 promise 最关键的部分：then 的链式调用和值的穿透。
  • 搞清楚了 then 的链式调用和值的穿透，你也就搞清楚了 Promise。

四、测试 Promise 是否符合规范

  • Promise/A+规范提供了一个专门的测试脚本，可以测试所编写的代码是否符合Promise/A+的规范。
  • 首先，在 promise 实现的代码中，增加以下代码:
MyPromise.defer = MyPromise.deferred = function() {
  let dfd = {}
  dfd.promise = new MyPromise((resolve, reject) => {
    dfd.resolve = resolve;
    dfd.reject = reject;
  });
  return dfd;
}

下载依赖

yarn add promises-aplus-tests

添加命令

// package.json
"scripts": {
	"test": "promises-aplus-tests my-promise.js"
}

执行yarn test，查看结果

在这里插入图片描述

通过全部872 条测试用例。

五、Promise 的 API

  • Promise.resolve()
  • Promise.reject()
  • Promise.prototype.catch()
  • Promise.prototype.finally()
  • Promise.all()
  • Promise.race()

1. Promise.resolve

  • 默认产生一个成功的 promise。
static resolve(data){
  return new Promise((resolve,reject)=>{
    resolve(data);
  })
}
  • 这里需要注意的是，promise.resolve 是具备等待功能的。（异步）
  • 如果参数是 promise 会等待这个 promise 解析完毕，在向下执行。
let resolve = (value) => {
  // ======新增逻辑======
  // 如果 value 是一个promise，那我们的库中应该也要实现一个递归解析
  if(value instanceof Promise){
      // 递归解析 
      return value.then(resolve,reject)
  }
  // ===================
  if(this.status ===  PENDING) {
    this.status = FULFILLED;
    this.value = value;
    this.onResolvedCallbacks.forEach(fn=>fn());
  }
}

2. Promise.reject

默认产生一个失败的 promise，Promise.reject 是直接将值变成错误结果。

static reject(reason){
  return new Promise((resolve,reject)=>{
    reject(reason);
  })
}

3. Promise.prototype.catch

用来捕获 promise 的异常，就相当于一个没有成功的 then。

Promise.prototype.catch = function(errCallback){
  return this.then(null,errCallback)
}

4. Promise.prototype.finally

不管成功还是失败都会执行。

Promise.prototype.finally = function(callback) {
  return this.then((value)=>{
    return Promise.resolve(callback()).then(()=>value)
  },(reason)=>{
    return Promise.resolve(callback()).then(()=>{throw reason})
  })  
}

5. Promise.all

Promise.all = function(values) {
  if (!Array.isArray(values)) {
    const type = typeof values;
    return new TypeError(`TypeError: ${type} ${values} is not iterable`)
  }
  
  return new Promise((resolve, reject) => {
    let resultArr = [];
    let orderIndex = 0;
    const processResultByKey = (value, index) => {
      resultArr[index] = value;
      if (++orderIndex === values.length) {
          resolve(resultArr)
      }
    }
    for (let i = 0; i < values.length; i++) {
      let value = values[i];
      if (value && typeof value.then === 'function') {
        value.then((value) => {
          processResultByKey(value, i);
        }, reject);
      } else {
        processResultByKey(value, i);
      }
    }
  });
}

6. Promise.race

用来处理多个请求，克隆最快的那一个，但是不会取消其他的promise。

Promise.race = function(promises) {
  return new Promise((resolve, reject) => {
    // 一起执行就是for循环
    for (let i = 0; i < promises.length; i++) {
      let val = promises[i];
      if (val && typeof val.then === 'function') {
        val.then(resolve, reject);
      } else { // 普通值
        resolve(val)
      }
    }
  });
}

参考资料

手写Promise

https://github.com/qiruohan/article/blob/master/promise/promise.js

promise/core.js at master · then/promise · GitHub

Palate
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
promise简单实现
weixin_42619992的博客
04-21 1916
1、最简单的实现 promise有三种状态，分别是Pedding、Fulfilled、Rejected。 Pedding promise对象实例创建时的初始状态 Fulfilled可以理解为成功的状态 Rejected可以理解为失败的状态 2、构造一个Promise实例需要给Promise构造函数传入一个函数。传入的函数需要有两个形参，两个形参都是function类型的参数。分别是resolve和reject 3、Promise上还有then方法，then方法就是用来指定Promise对象的状态
实现一个promise
weixin_44759938的博客
06-27 120
resolve参数是一个函数。当调用resolve函数时，它会将当前Promise对象的状态从pending变为fulfilled,并将传入的参数作为新Promise对象的值。如果传入的参数不是一个Promise对象，那么它会被立即执行，并作为新Promise对象的值。当调用reject函数时，它会将当前Promise对象的状态从pending变为rejected,并将传入的参数作为新Promise对象的值。如果传入的参数不是一个Promise对象，那么它会被立即执行，并作为新Promise对象的值。
一步一步实现自己的Promise(1)，前端开发网页
最新发布
2401_84093248的博客
04-05 651
核心竞争力，怎么才能提高呢？成年人想要改变生活，逆转状态？那就开始学习吧~万事开头难，但是程序员这一条路坚持几年后发展空间还是非常大的，一切重在坚持。为了帮助大家更好更高效的准备面试，特别整理了《前端工程师面试手册》电子稿文件。
关于Promise你必须知道几件事
learntogiveup的博客
07-23 657
关于Promise你必须知道几件事 1.如何声明一个Promise new Promise(function(resolve, reject){ }) 如果想让Promise成功执行下去，需要执行resolve，如果让它失败执行下去，需要执行reject new Promise(function(resolve, reject) { resolve('success') // 成功执行 }).then(result => { alert(result) }) new Promi
Promise、async/await的理解以及区别
ysj1218的博客
03-04 3755
promise、async、await有什么用呢，怎么理解？ 都是为了解决异步回调产生的。 Promise好比容器，里面存放着一些未来才会执行完毕的事件的结果，而这些结果一旦生成是无法改变的。 async和await遵循的是Generator 函数的语法糖，他拥有内置执行器，不需要额外的调用直接会自动执行并输出结果，它返回的是一个Promise对象。 promise与async、await的区别? promise的出现解决了传统callback函数导致的地狱回调问题，但是他的语法导致它纵向发展
js代码-实现一个Promise 类
07-16
首先，我们需要了解Promise的基本状态。一个Promise有三种状态：pending（等待中）、fulfilled（已完成）和rejected（已拒绝）。这些状态是不可变的，一旦改变，就无法再反转。Promise实例创建后，初始状态为pending...
js代码-实现一个Promise
07-14
接下来，我们需要实现Promise的两个静态方法：`resolve`和`reject`，它们用于创建一个已经成功或失败的Promise实例： ```javascript Promise.resolve = function (value) { return new Promise((resolve) => ...
promise详解，手动实现以及上万字笔记.rar
08-16
通过阅读提供的手动实现Promise.js，你可以了解到Promise的基本架构和状态管理。文档.md则可能涵盖了Promise的常见用法、陷阱、最佳实践等深入内容，帮助你更好地理解和应用Promise。 对于初学者和希望提升技能的...
js代码-实现一个基本的Promise
07-16
接下来，我们需要实现Promise的then方法，它用于处理Promise成功或失败后的回调： ```javascript Promise.prototype.then = function(onFulfilled, onRejected) { // 创建一个新的Promise实例，用于处理then的回调...
你能手写一个 Promise 吗？
qq_42239440的博客
08-17 387
转载于:https://zhuanlan.zhihu.com/p/183801144 关于手写 Promise，想必大家都十分熟悉。基本上现在不管是大厂还是小厂，手写 promise 已经成为了面试必考知识点。听说你还不太会？那么走着，带你从零开始解锁 Promise！ 查看原完整代码请进:https://github.com/qiruohan/article/blob/master/promise/promise.js 常见 Promise 面试题 首先，我们以常见的 Promise 面试题为切入点，
promise then err_你不知道的promise
weixin_39538693的博客
11-27 226
Promise基本上现在不管是大厂还是小厂，promise 已经成为了面试必考知识点；关于 Promise，想必大家都又所了解，可是又掌握了多少，真正面试的时候，又能有多少把握呢？，今天小编特意在此整理promise常考知识点，希望对你的面试保驾护航。常见 Promise 面试题首先，我们以常见的 Promise 面试题为切入点，我们看看面试官们都爱考什么：Promise 解决了什么问题 &amp...
Promise进阶——如何实现一个Promise库
weixin_34379433的博客
01-02 237
概述 从上次更新Promise/A+规范后，已经很久没有更新博客了。之前由于业务需要，完成了一个TypeScript语言的Promise库。这次我们来和大家一步一步介绍下，我们如何实现一个符合Promise/A+规范的Promise库。 如果对Promise/A+规范还不太了解的同学，建议先看看上一篇博客—— [译]前端基础知识储备——Promise/A+规范 。 实现流程 首先，我们来看下，在我...
解析 Promise 原理，实现一个Promise
weixin_34388207的博客
09-19 476
解析 Promise 原理，实现一个Promise 概述 这篇文章旨在解析 Promise的异步实现原理，并且以 ES6中的 Promise 为蓝本实现一个简单的 Promise。 通过自己动手实现一个 Promise 对象，可以熟悉很多可能不知道的 Promise 细节，同时也能对异步的理解更提升一步。 本文假设读者对 Promise ...
如何实现一个 Promise
LuckXinXin的博客
08-01 125
// 三种状态 const PENDING = "pending"; const RESOLVED = "resolved"; const REJECTED = "rejected"; // promise 接收一个函数参数，该函数会立即执行 function MyPromise(fn) { let _this = this; _this.currentState = PENDING; _this.value = undefined; // 用于保存 then 中的回调，只有当 promis
手动实现一个Promise，简洁明了
Besam-juajua的博客
09-29 339
JS版本中，更新最大的一个版本就是ES6了，包括了const、let、模板字符串、箭头函数、类、Generator、Promise等等一系列语法糖。 在ES7没出来前，Promise是代替传统回调的主要方式，ES7后更多的是使用async-await，但Pomise的使用仍不在少数 本文章，我们一起实现一个Promise，你可能说，我直接用它就行了，干嘛自己写一个。非也，在我看来，理解代码思想...
如何实现一个简单的promise
jianjieX的博客
07-07 260
一个简单的 Promise 的粗糙实现，关键点在于 当 pending 时， thenable 函数由一个队列维护 当状态变为 resolved(fulfilled) 时，队列中所有 thenable 函数执行 当 resolved 时， thenable 函数直接执行 rejected 状态同理 class Prom { static resolve (value) { if (value && value.then) { return value }
ES6 Promise 编写一个等待函数
HRM2454的博客
01-14 947
// 等待timeSpan毫秒后执行resolve方法，且不会阻塞js执行线程 export async function wait(timeSpan = 600) { return new Promise(resolve => { setTimeout(resolve, timeSpan); }) } 此方法接收一个等待时长参数（默认600毫秒），返回一个Promise对象，等待时长到期后将执行Promise的resolve方法。此方法是一个很好的执行流程控制工具.
Promise 实现原理
热门推荐
weixin_43299180的博客
02-21 2万+
文章目录一、Promise 介绍二、promise 源码实现 一、Promise 介绍 定义 Promise 是异步编程的一种解决方法，比传统的回调函数和事件更合理；它是由社区提出和实现经由 ES6 将其写进语言标准，并在原生提供了 Promise 对象； Promise 可以理解是一个容器，里面保存着某个将来才会结束的事件（异步操作）的结果；从语法上说，Promise 是一个对象通过它可以获取异步操作的消息；Promise 提供了统一的 API ，各种异步操作都可以用同样的方法进行处理。 特点 Pr
手把手教你实现一个promise
qq_36836989的博客
12-03 406
文章目录前言先看一段代码进入主题thenthen的链式调用catch 前言 网上看了很多关于promise的源码讲解，都是上来直接讲的源码实现，本文将带你通过分析promise的使用方法来了解promise的具体实现 先看一段代码 const p = new Promise((resolve, reject) => { resolve('resolve') setTimeout(() => { reject('reject') }) }) p.then(res =>
Promise.all了解吗，说一下他的原理，并且手写一下实现代码
03-28
Promise.all的原理是利用Promise的异步特性，将多个Promise实例并行执行，并将每个Promise实例的结果存储在一个数组中，最后将这个数组作为结果返回给调用者。 以下是手写一个简单的Promise.all实现代码： ```...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值