JS案例-Promise/A+ 规范的手写实现

最新推荐文章于 2025-07-09 14:40:35 发布
最新推荐文章于 2025-07-09 14:40:35 发布
阅读量732 收藏 26
点赞数 8
CC 4.0 BY-SA版权
分类专栏： JS 文章标签： javascript HTML CSS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liudadaxuexi/article/details/147349684

Promise/A+ 规范的手写实现

文章目录

引言

在现代JavaScript开发中，异步编程已成为不可或缺的部分。Promise作为处理异步操作的核心机制，革新了传统的回调函数模式，为开发者提供了更加优雅和可维护的解决方案。深入理解Promise的内部机制，特别是按照Promise/A+规范实现一个Promise，不仅能够帮助开发者更好地使用这一特性，还能提升对JavaScript异步编程本质的认知。

Promise/A+ 规范概述

Promise/A+规范是JavaScript Promise实现的标准规范，它定义了Promise的基本行为和API。规范的核心要求包括：

  1. Promise的三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）
  2. 状态转换的不可逆性：一旦Promise的状态发生改变，就不能再改变
  3. then方法的行为：必须返回一个新的Promise，支持链式调用
  4. promise解析过程的详细规则：如何处理then回调的返回值

核心实现架构设计

一个符合Promise/A+规范的实现需要包含以下几个关键部分：

状态管理机制

Promise需要维护其内部状态，并确保状态转换的正确性。这包括：

  • 状态属性（state）
  • 成功值（value）
  • 失败原因（reason）
  • 回调函数队列（用于存储待执行的回调）

构造函数的设计

构造函数接收一个执行器函数（executor），该函数包含resolve和reject两个参数。这些参数允许用户控制Promise的状态转换。

constructor(executor) {
    // 初始化状态为pending
    this.state = 'pending';
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    
    // resolve函数定义
    const resolve = (value) => {
        if (this.state === 'pending') {
            this.state = 'fulfilled';
            this.value = value;
            this.onFulfilledCallbacks.forEach(fn => fn());
        }
    };
    
    // reject函数定义
    const reject = (reason) => {
        if (this.state === 'pending') {
            this.state = 'rejected';
            this.reason = reason;
            this.onRejectedCallbacks.forEach(fn => fn());
        }
    };
    
    // 执行executor
    try {
        executor(resolve, reject);
    } catch (error) {
        reject(error);
    }
}

then方法的实现

then方法是Promise最核心的部分，它需要：

  1. 返回一个新的Promise实例
  2. 根据当前Promise的状态执行相应的回调
  3. 处理回调函数的返回值
  4. 支持链式调用

Promise解析过程

resolvePromise函数是实现Promise链式调用的关键。它处理以下情况：

  1. 检查循环引用
  2. 处理返回值为Promise的情况
  3. 处理thenable对象
  4. 普通值的处理

关键实现难点

在实现过程中，开发者需要特别注意以下几个技术难点：

1. 异步执行保证

规范要求then方法的回调必须异步执行，即使Promise已经处于resolved或rejected状态。这通常通过setTimeout或微任务机制实现。

2. 链式调用的正确性

确保then方法总是返回一个新的Promise，且新Promise的状态取决于回调函数的执行结果。

3. thenable对象的处理

需要正确识别和处理具有then方法的对象，这要求对JavaScript的类型检查有深入理解。

4. 错误处理机制

确保所有可能的错误都能被正确捕获和传递到下一个Promise。

实现价值与总结

手写Promise不仅是一个技术练习，更是深入理解JavaScript异步编程的重要途径。通过实现Promise，开发者能够：

  1. 深入理解Promise的内部机制和工作原理
  2. 提升对异步编程模式的认知
  3. 增强调试和排错能力
  4. 为处理复杂的异步场景打下坚实基础

效果

在这里插入图片描述

全部代码

HTML

<!DOCTYPE html>
<html lang="zh-CN">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="author" content="刘大大">
  <meta name="date" content="2025-04-19">
  <title>Promise/A+ 规范实现</title>
  <link rel="stylesheet" href="styles.css">
</head>

<body>
  <div class="container">
    <h1>Promise/A+ 规范实现</h1>

    <!-- 测试 1: 基本的 Promise resolve -->
    <div class="test-section">
      <div class="test-title">测试 1: 基本的 Promise resolve</div>
      <button onclick="testBasicResolve()">运行测试 1</button>
      <div id="test1-result" class="test-result"></div>
    </div>

    <!-- 测试 2: 基本的 Promise reject -->
    <div class="test-section">
      <div class="test-title">测试 2: 基本的 Promise reject</div>
      <button onclick="testBasicReject()">运行测试 2</button>
      <div id="test2-result" class="test-result"></div>
    </div>

    <!-- 测试 3: Promise 链式调用 -->
    <div class="test-section">
      <div class="test-title">测试 3: Promise 链式调用</div>
      <button onclick="testChaining()">运行测试 3</button>
      <div id="test3-result" class="test-result"></div>
    </div>

    <!-- 测试 4: Promise.all() -->
    <div class="test-section">
      <div class="test-title">测试 4: Promise.all()</div>
      <button onclick="testPromiseAll()">运行测试 4</button>
      <div id="test4-result" class="test-result"></div>
    </div>

    <!-- 测试 5: Promise.race() -->
    <div class="test-section">
      <div class="test-title">测试 5: Promise.race()</div>
      <button onclick="testPromiseRace()">运行测试 5</button>
      <div id="test5-result" class="test-result"></div>
    </div>
  </div>

  <!-- 引入脚本文件 -->
  <script src="promise.js"></script>
  <script src="tests.js"></script>
</body>

</html>

promise.js

/**
 * MyPromise - Promise/A+ 规范实现
 * @author 刘大大
 * @date 2025-04-19
 */

class MyPromise {
    /**
     * 构造函数
     * @param {Function} executor - 执行器函数，接收resolve和reject两个参数
     */
    constructor(executor) {
        // Promise的三种状态：pending(进行中)、fulfilled(已成功)、rejected(已失败)
        this.state = 'pending';
        // 成功的值
        this.value = undefined;
        // 失败的原因
        this.reason = undefined;
        // 成功回调函数队列
        this.onFulfilledCallbacks = [];
        // 失败回调函数队列
        this.onRejectedCallbacks = [];

        /**
         * resolve函数 - 将Promise状态从pending改为fulfilled
         * @param {any} value - 成功的值
         */
        const resolve = (value) => {
            // 只有在pending状态才能改变状态
            if (this.state === 'pending') {
                this.state = 'fulfilled';
                this.value = value;
                // 执行所有成功回调
                this.onFulfilledCallbacks.forEach(fn => fn());
            }
        };

        /**
         * reject函数 - 将Promise状态从pending改为rejected
         * @param {any} reason - 失败的原因
         */
        const reject = (reason) => {
            // 只有在pending状态才能改变状态
            if (this.state === 'pending') {
                this.state = 'rejected';
                this.reason = reason;
                // 执行所有失败回调
                this.onRejectedCallbacks.forEach(fn => fn());
            }
        };

        try {
            // 立即执行executor
            executor(resolve, reject);
        } catch (error) {
            // 如果executor执行出错，直接reject
            reject(error);
        }
    }

    /**
     * then方法 - 用于处理Promise的结果
     * @param {Function} onFulfilled - 成功的回调函数
     * @param {Function} onRejected - 失败的回调函数
     * @returns {MyPromise} - 返回一个新的Promise以支持链式调用
     */
    then(onFulfilled, onRejected) {
        // 参数校验，如果不是函数则转换为值传递或抛出错误
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
        onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };

        // 创建新的Promise实例用于链式调用
        let promise2 = new MyPromise((resolve, reject) => {
            // 如果Promise已经解决，异步执行回调
            if (this.state === 'fulfilled') {
                setTimeout(() => {
                    try {
                        let x = onFulfilled(this.value);
                        // 处理then回调的返回值
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);
                    }
                }, 0);
            }

            // 如果Promise已经拒绝，异步执行回调
            if (this.state === 'rejected') {
                setTimeout(() => {
                    try {
                        let x = onRejected(this.reason);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);
                    }
                }, 0);
            }

            // 如果Promise还在等待中，将回调加入队列
            if (this.state === 'pending') {
                this.onFulfilledCallbacks.push(() => {
                    setTimeout(() => {
                        try {
                            let x = onFulfilled(this.value);
                            resolvePromise(promise2, x, resolve, reject);
                        } catch (error) {
                            reject(error);
                        }
                    }, 0);
                });

                this.onRejectedCallbacks.push(() => {
                    setTimeout(() => {
                        try {
                            let x = onRejected(this.reason);
                            resolvePromise(promise2, x, resolve, reject);
                        } catch (error) {
                            reject(error);
                        }
                    }, 0);
                });
            }
        });

        return promise2;
    }

    /**
     * catch方法 - 用于捕获Promise的错误
     * @param {Function} onRejected - 错误处理回调函数
     * @returns {MyPromise} - 返回一个新的Promise
     */
    catch(onRejected) {
        return this.then(null, onRejected);
    }

    /**
     * resolve静态方法 - 返回一个以给定值解决的Promise
     * @param {any} value - 要解决的值
     * @returns {MyPromise} - 返回一个新的Promise
     */
    static resolve(value) {
        return new MyPromise((resolve) => {
            resolve(value);
        });
    }

    /**
     * reject静态方法 - 返回一个以给定原因拒绝的Promise
     * @param {any} reason - 拒绝的原因
     * @returns {MyPromise} - 返回一个新的Promise
     */
    static reject(reason) {
        return new MyPromise((resolve, reject) => {
            reject(reason);
        });
    }

    /**
     * all静态方法 - 等待所有Promise完成
     * @param {Array<MyPromise>} promises - Promise数组
     * @returns {MyPromise} - 返回一个新的Promise
     */
    static all(promises) {
        return new MyPromise((resolve, reject) => {
            let results = [];
            let index = 0;
            let processData = (key, value) => {
                results[key] = value;
                if (++index === promises.length) {
                    resolve(results);
                }
            };
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(value => {
                    processData(i, value);
                }, reject);
            }
        });
    }

    /**
     * race静态方法 - 返回最先解决或拒绝的Promise
     * @param {Array<MyPromise>} promises - Promise数组
     * @returns {MyPromise} - 返回一个新的Promise
     */
    static race(promises) {
        return new MyPromise((resolve, reject) => {
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(resolve, reject);
            }
        });
    }
}

/**
 * resolvePromise - Promise解析过程
 * @param {MyPromise} promise2 - 新的Promise实例
 * @param {any} x - then回调返回的值
 * @param {Function} resolve - 新Promise的resolve函数
 * @param {Function} reject - 新Promise的reject函数
 */
function resolvePromise(promise2, x, resolve, reject) {
    // 防止循环引用
    if (promise2 === x) {
        return reject(new TypeError('Chaining cycle detected for promise'));
    }

    // 防止多次调用
    let called = false;
    // 如果x是对象或函数，尝试将其视为thenable
    if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
        try {
            let then = x.then;
            // 如果then是函数，将x视为Promise-like对象
            if (typeof then === 'function') {
                then.call(x, y => {
                    if (called) return;
                    called = true;
                    // 递归解析Promise
                    resolvePromise(promise2, y, resolve, reject);
                }, r => {
                    if (called) return;
                    called = true;
                    reject(r);
                });
            } else {
                resolve(x);
            }
        } catch (error) {
            if (called) return;
            called = true;
            reject(error);
        }
    } else {
        // 如果x不是对象或函数，直接resolve
        resolve(x);
    }
}

tests.js

/**
 * 测试函数集合
 * @author 刘大大
 * @date 2025-04-19
 */

/**
 * 测试基本的Promise resolve功能
 */
function testBasicResolve() {
    const resultDiv = document.getElementById('test1-result');
    resultDiv.innerHTML = '测试开始...\n';

    // 创建一个将在1秒后resolve的Promise
    const promise = new MyPromise((resolve, reject) => {
        setTimeout(() => {
            resolve('成功!');
        }, 1000);
    });

    // 等待Promise resolve并显示结果
    promise.then(value => {
        resultDiv.innerHTML += `<span class="success">✓ Promise resolved with: ${value}</span>`;
    });
}

/**
 * 测试基本的Promise reject功能
 */
function testBasicReject() {
    const resultDiv = document.getElementById('test2-result');
    resultDiv.innerHTML = '测试开始...\n';

    // 创建一个将在1秒后reject的Promise
    const promise = new MyPromise((resolve, reject) => {
        setTimeout(() => {
            reject('错误发生!');
        }, 1000);
    });

    // 捕获Promise rejection并显示错误信息
    promise.catch(error => {
        resultDiv.innerHTML += `<span class="error">✓ Promise rejected with: ${error}</span>`;
    });
}

/**
 * 测试Promise的链式调用
 */
function testChaining() {
    const resultDiv = document.getElementById('test3-result');
    resultDiv.innerHTML = '测试开始...\n';

    // 创建一个resolve为1的Promise
    const promise = new MyPromise((resolve, reject) => {
        setTimeout(() => {
            resolve(1);
        }, 1000);
    });

    // 链式调用，每次将值乘以2
    promise
        .then(value => {
            resultDiv.innerHTML += `第一次 then: ${value}\n`;
            return value * 2;
        })
        .then(value => {
            resultDiv.innerHTML += `第二次 then: ${value}\n`;
            return value * 2;
        })
        .then(value => {
            resultDiv.innerHTML += `<span class="success">✓ 最终结果: ${value}</span>`;
        });
}

/**
 * 测试Promise.all功能
 */
function testPromiseAll() {
    const resultDiv = document.getElementById('test4-result');
    resultDiv.innerHTML = '测试开始...\n';

    // 创建三个不同延迟的Promise
    const promise1 = new MyPromise((resolve, reject) => {
        setTimeout(() => resolve(1), 1000);
    });
    const promise2 = new MyPromise((resolve, reject) => {
        setTimeout(() => resolve(2), 2000);
    });
    const promise3 = new MyPromise((resolve, reject) => {
        setTimeout(() => resolve(3), 1500);
    });

    // 使用Promise.all等待所有Promise完成
    MyPromise.all([promise1, promise2, promise3])
        .then(values => {
            resultDiv.innerHTML += `<span class="success">✓ Promise.all 结果: [${values.join(', ')}]</span>`;
        });
}

/**
 * 测试Promise.race功能
 */
function testPromiseRace() {
    const resultDiv = document.getElementById('test5-result');
    resultDiv.innerHTML = '测试开始...\n';

    // 创建三个不同延迟的Promise
    const promise1 = new MyPromise((resolve, reject) => {
        setTimeout(() => resolve('慢'), 2000);
    });
    const promise2 = new MyPromise((resolve, reject) => {
        setTimeout(() => resolve('快!'), 1000);
    });
    const promise3 = new MyPromise((resolve, reject) => {
        setTimeout(() => resolve('中等'), 1500);
    });

    // 使用Promise.race，返回最先完成的Promise结果
    MyPromise.race([promise1, promise2, promise3])
        .then(value => {
            resultDiv.innerHTML += `<span class="success">✓ Promise.race 结果: ${value}</span>`;
        });
}

css

/**
 * 样式文件
 * @author 刘大大
 * @date 2025-04-19
 */

/* 全局样式 */
body {
  font-family: Arial, sans-serif;
  line-height: 1.6;
  margin: 0;
  padding: 20px;
  background-color: #f5f5f5;
}

/* 容器样式 */
.container {
  /* max-width: 800px; */
  margin: 0 auto;
  background-color: #fff;
  padding: 20px;
  border-radius: 8px;
  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

/* 标题样式 */
h1 {
  color: #333;
  text-align: center;
  margin-bottom: 30px;
}

/* 测试部分容器 */
.test-section {
  margin: 20px 0;
  padding: 15px;
  border: 1px solid #ddd;
  border-radius: 4px;
  background-color: #fafafa;
}

/* 测试标题 */
.test-title {
  font-weight: bold;
  margin-bottom: 10px;
  color: #555;
}

/* 测试结果显示区域 */
.test-result {
  background-color: #f8f9fa;
  padding: 10px;
  border-radius: 4px;
  margin-top: 10px;
  white-space: pre-wrap;
  min-height: 40px;
  font-family: monospace;
}

/* 按钮样式 */
button {
  background-color: #4CAF50;
  color: white;
  padding: 10px 15px;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  margin-right: 10px;
  transition: background-color 0.3s ease;
}

button:hover {
  background-color: #45a049;
}

button:active {
  background-color: #3d8b40;
}

/* 错误消息样式 */
.error {
  color: #d32f2f;
  font-weight: bold;
}

/* 成功消息样式 */
.success {
  color: #2e7d32;
  font-weight: bold;
}
手写Promise：实现符合PromisesA+规范的Promise
dfc_dfc的博客
09-01 1261
手写Promise：实现符合PromiseA+规范的Promise
PromiseA+规范
ChenLingZhi1115的博客
08-16 1231
5.1 promise状态变成 fulfilled 后，所有的 onFulfilled 回调都需要按照then的顺序执行, 也就是按照注册顺序执行(所以在实现的时候需要一个数组来存放多个onFulfilled的回调)catch 的回调里, 打印promise的时候, 整个回调还并没有执行完成(所以此时的状态是pending), 只有当整个回调完成了, 才会更改状态 ==> 第一次打印test时。所以待会实现代码的时候, 同学们注意一下resolvePromise函数具体的实现, 结合代码来看会好很多.
手写一款符合Promise/A+规范的Promise
weixin_33714884的博客
02-19 360
手写一款符合Promise/A+规范的Promise 长篇预警！有点长，可以选择性观看。如果对Promise源码不是很清楚，还是推荐从头看，相信你认真从头看到尾，并且去实际操作了，肯定会有收获的。主要是代码部分有点多，不过好多都是重复的，不必担心 Promise的一些用法在此不多赘述，本篇主要带领你手写一个Promise源码，学完你就会发...
【手写 Promise A+规范实现 - 从零开始构建异步编程基石】
最新发布
weixin_37342647的博客
07-09 985
本文详细介绍了Promise/A+规范及其实现原理。Promise/A+是JavaScript异步编程的核心标准，定义了Promise对象的行为规范。文章首先解释了规范的核心概念、状态转换规则和then方法要求，然后通过代码示例展示了Promise的执行流程。重点包括：1）Promise的三种状态及其不可逆性；2）then方法的异步执行特性；3）规范的测试验证方法；4）实际开发中的价值。通过手写实现Promise，开发者可以深入理解异步编程本质，构建更可靠的异步代码。
PromiseA+规范之手写Promise
程邓楠的博客
11-04 4174
@[TOC](文章目录) 前言 1、Promise 的意义？ 在javascript的世界中，所有代码都是单线程执行的，由于这个“缺陷”，导致JavaScript的所有网络操作，浏览器事件，都必须是异步执行。Ajax可以解决这个问题，但是并不好复用。JQuery的链式调用同样可以解决，每次调用都会返回一个JQuery对象。为了更好的处理Promise 出现了，并且ECMAScript 对其进行了规范。 2、PromiseA+规范是什么？ 其实Promise规范有很多，如Promise/A，...
Promise原理讲解 && 实现一个Promise对象 (遵循Promise/A+规范)
weixin_34199405的博客
03-13 224
1.什么是Promise? Promise是JS异步编程中的重要概念，异步抽象处理对象，是目前比较流行Javascript异步编程解决方案之一 2.对于几种常见异步编程方案 回调函数 事件监听 发布/订阅（深入了解发布/订阅，可以看我的文章用发布订阅模式编写一个可被其他对象拓展复用的自定义事件系统） Promise对象 这里就拿回调函数说说 (1) 对于回调函数 我们用Jquery的aja...
Promise/A+规范
sg392361615的专栏
10-09 2170
1.1.1 Promise/A+规范 规范出现的原因 1、 我们不知道异步请求什么时候返回数据，所以我们就需要些回调函数。但是在某些情况下我们需要知道数据是在什么时候返回的，然后进行一些处理。 2、 当我们在异步回调里面处理的操作还是异步操作的时候，这样就形成了异步回调的嵌套 3、 正是为了杜绝以上两种情况的出现，社区出现了Promise/a+规范   规范的内容是什么 1、 不管进
手写一个符合Promise A+规范的Promise
qq_43792937的博客
05-07 354
手写Promise 此为本人学习手写Promise的笔记，如有错误欢迎指出与讨论！ 参考文章：https://juejin.cn/post/6945319439772434469 前置知识点 宏任务与微任务 JS是单线程的，因此一些高耗时的操作将会导致进程阻塞。为解决这个问题，JS有两种任务的执行模式： 同步模式 和 异步模式 。 在异步模式下，创建的异步任务分为如下两种： 宏任务 和 微任务 。ES6规范中，宏任务（Macrotask）称为Task，是由宿主（浏览器或者Node）发起的，微任务（Micro
Promise A+ 规范
weixin_55541470的博客
12-20 491
如果一个 Promise 实现符合 Promise A+ 规范，那么它可以与其他符合该规范的 Promise 实现进行互操作，可以方便地进行 Promise 链式调用、错误处理等操作，使得异步代码更加清晰和可维护。Promise A+ 规范是关于 JavaScript Promise 实现的一种标准规范，旨在统一不同 Promise 库之间的行为，确保其在使用上的一致性和可互操作性。如果在 then方法中返回了一个新的 Promise，那么后续的 then 方法将会等待这个新的 Promise 完成。
promise学习笔记
菜鸟前端的博客
06-10 169
第一部分 Promise A+ 规范 术语 promise 有then 方法的对象或者函数 thenable 是一个有then方法的对象或者是函数 value promise 状态成功时的值， resolve（value), string number boolean undefined thenable promise reason promise 状态失败时的值， reject(reason） exception 使用throw 抛出的异常 规范 Promise States 有三种状态，
【JavaScript】手写 Promise（Promise\A+测试）
小秀的博客
02-28 934
​ 现在已经不需要了,因为在ES6中已经加入语言标准,我们可以直接使用了:从 Chrome 32、Opera 19、Firefox 29、Safari 8 和 Microsoft Edge 开始，promises 是默认开启的。若要使缺乏完整 promise 实现的浏览器符合规范，或将 promise 添加到其他浏览器和 Node.js 中，请查看。​ 上面提到的库,以及ES6中实现的Promise,还有我们手写的Promise其实都是按照标准进行编写的,那么如何测试是否符合标准呢。
一步一步手写完美符合PromiseA+规范的Promise
程序员成长指北
04-19 234
作者：晴天酱85223来源：https://juejin.cn/post/6900834452901986312前言Promise作为异步编程的一种解决方案，已经变得十分常用。而手写Pro...
Node.js系列--Promise规范解读
Closure 专栏
01-12 804
Promise表示一个异步操作的最终结果。与Promise最主要的交互方法是通过将函数传入它的then方法从而获取得Promise最终的值或Promise最终最拒绝（reject）的原因。 1. 术语 promise是一个包含了兼容promise规范then方法的对象或函数， thenable 是一个包含了then方法的对象或函数。 value 是任何Javascript值。 (包
phen库：实现JavaScript轻量级Promise/A+规范
资源摘要信息:"phen是一个轻量级的Promise/A+实现的JavaScript库。Promise是JavaScript中的一个异步编程解决方案，它提供了一种处理异步操作的模式。Promise/A+则是Promise的一个标准规范，定义了Promise的行为和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

trust Tomorrow

感谢支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值