js之从Promise的基本使用模拟Promise源码

最新推荐文章于 2025-04-05 06:29:42 发布
最新推荐文章于 2025-04-05 06:29:42 发布
阅读量382 收藏 3
点赞数 1
文章标签： javascript 前端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sundaoli_0/article/details/127194603
版权

分析Promise的基本使用

  1. Promise就是一个类
class MyPromise {}
  1. 执行这个类的时候，需要传递一个执行器（回调函数），执行器会立即执行
class MyPromise{
    constructor(executor){ 
        executor()    
    }
}
  1. 执行器有两个参数，resolve和reject 为两个函数
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    resolve = () =>{

    }
    reject = () =>{

    }
}
  1. Promise有三种状态（status）分别为： 成功（fulfilled） 失败（rejected） 等待（pending）。
const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    resolve = () =>{
    }
    reject = () =>{
    }
}

5.resolve ：把Promise 状态改为 fulfilled ；reject把Promise 状态改为rejected

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    resolve = () =>{
        this.status = FULFILLED
    }
    reject = () =>{
        this.status = REJECTED
    }
}
  1. 一旦状态确定就不可更改 比如 pending --> fulfilled ；pending --> rejected
const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    resolve = () =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
    }
    reject = () =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
    }
}
  1. resolve 参数为成功后的数据；reject 参数为失败之后的原因
const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
    }
}
  1. then 方法被定义在原型对象中，then方法内部做的事情就是判断状态，如果成功，调用成功的回调，参数为成功的数据，如果失败，调用失败的回调，参数为失败的原因
const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
    }
    then(successCallback,failCallback){
        if(this.status === FULFILLED){
            successCallback(this.data)
        } else if (this.status === REJECTED){
            failCallback(this.reason)
        }
    }
}

8.执行器中有异步操作时，then不会立即得到成功还是失败的状态，因此需要把成功后的回调和失败后的回调存储起来，等待异步操作完成后再执行对应的回调

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = undefined
    failCallback = undefined
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        this.successCallback && this.successCallback(this.data)
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        this.failCallback && this.failCallback(this.reason)
    }
    then(successCallback,failCallback){
        if(this.status === FULFILLED){
            successCallback(this.data)
        } else if (this.status === REJECTED){
            failCallback(this.reason)
        } else {
            this.successCallback = successCallback
            this.failCallback = failCallback
        }
    }
}

9.同一个Promise对象，多次调用then方法时，异步情况需要添加多个回调函数依次执行，做以下修改
修改成功回调和失败回调的数据类型为数组
then方法中Promise为等待的状态时，push成功回调和失败回调到数组
异步操作完成后，按顺序执行成功或失败的回调函数

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = []
    failCallback = []
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        //this.successCallback && this.successCallback(this.data)
        while(this.successCallback.length) this.successCallback.shift()(this.data)
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        //this.failCallback && this.failCallback(this.reason)
        while(this.failCallback.length) this.failCallback.shift()(this.reason)
    }
    then(successCallback,failCallback){
        if(this.status === FULFILLED){
            successCallback(this.data)
        } else if (this.status === REJECTED){
            failCallback(this.reason)
        } else {
            this.successCallback.push(successCallback)
            this.failCallback.push(failCallback)
        }
    }
}

10.实现then方法的链式调用，做以下修改
then方法每次要返回一个新的Promise对象
处理then方法的返回值（非Promise类型）到新的Promise对象执行器的reslove方法中，以实现链式调用时返回值的传递

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = []
    failCallback = []
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        //this.successCallback && this.successCallback(this.data)
        while(this.successCallback.length) this.successCallback.shift()(this.data)
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        //this.failCallback && this.failCallback(this.reason)
        while(this.failCallback.length) this.failCallback.shift()(this.reason)
    }
    then(successCallback,failCallback){
        return new MyPromise((resolve,reject) => {
            if(this.status === FULFILLED){
               let returnValue = successCallback(this.data)
               resolve(returnValue)
            } else if (this.status === REJECTED){
                failCallback(this.reason)
            } else {
                this.successCallback.push(successCallback)
                this.failCallback.push(failCallback)
            } 
        })
    }
}

10.1 当then 方法成功的回调函数中，返回的是一个Promise对象时，做以下修改
判断returnValue的类型
如果是Promise创建的实例，则需要把成功还是失败的回调传递到新的Promise对象中以实现链式调用
如果是非Promise创建的实例，则需要把返回值（returnValue）传递到reslove中

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = []
    failCallback = []
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        //this.successCallback && this.successCallback(this.data)
        while(this.successCallback.length) this.successCallback.shift()(this.data)
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        //this.failCallback && this.failCallback(this.reason)
        while(this.failCallback.length) this.failCallback.shift()(this.reason)
    }
    then(successCallback,failCallback){
        return new MyPromise((resolve,reject) => {
            if(this.status === FULFILLED){
               let returnValue = successCallback(this.data)
               if(returnValue instanceof MyPromise){
                returnValue.then(resolve,reject)
               } else {
                resolve(returnValue)
               }
            } else if (this.status === REJECTED){
                failCallback(this.reason)
            } else {
                this.successCallback.push(successCallback)
                this.failCallback.push(failCallback)
            } 
        })
    }
}

11.异常处理，当then方法的成功回调函数中，返回then方法返回的Promise对象时，也就是自己调用自己的情况，系统中的Promise对象会抛出TypeError的异常。对我们的MyPromise做以下修改以捕获类似异常
在then方法中做判断，返回新的Promise对象与成功回调返回的值（returnValue）相等的时候，调用新的Promise的rejece方法并传入类型异常
把判断的代码做成异步代码，不然无法拿到新的Promise对象 （setTimeout 0）
添加新方法 resolvePromise 用来判断then方法成功回调的返回值

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        executor(this.resolve,this.reject)
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = []
    failCallback = []
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        //this.successCallback && this.successCallback(this.data)
        while(this.successCallback.length) this.successCallback.shift()(this.data)
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        //this.failCallback && this.failCallback(this.reason)
        while(this.failCallback.length) this.failCallback.shift()(this.reason)
    }
    then(successCallback,failCallback){
        let newMyPromise = new MyPromise((resolve,reject) => {
            if(this.status === FULFILLED){
               setTimeout(() => {
                let returnValue = successCallback(this.data)
                resolvePromise(newMyPromise,returnValue,resolve,reject)
               }, 0);
            } else if (this.status === REJECTED){
                failCallback(this.reason)
            } else {
                this.successCallback.push(successCallback)
                this.failCallback.push(failCallback)
            } 
        })
        return newMyPromise
    }
}
function resolvePromise (newMyPromise,returnValue,resolve,reject){
    if(newMyPromise  === returnValue){
        reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
    }else{
        if(returnValue instanceof MyPromise){
            returnValue.then(resolve,reject)
        } else {
            resolve(returnValue)
        }
    }
}

12 捕获及处理执行器和then方法的成功回调函数的异常以及then方法中失败和等待时链式调用的实现
给执行器和then方法的回调函数加上异常处理
把then方法失败和等待状态的链式调用实现成之前成功状态的代码

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        try{
            executor(this.resolve,this.reject)
        }catch(error){
            this.reject(error)
        }
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = []
    failCallback = []
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        while(this.successCallback.length) this.successCallback.shift()()
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        while(this.failCallback.length) this.failCallback.shift()()
    }
    then(successCallback,failCallback){
        let newMyPromise = new MyPromise((resolve,reject) => {
            if(this.status === FULFILLED){
               setTimeout(() => {
                try{
                    let returnValue = successCallback(this.data)
                    resolvePromise(newMyPromise,returnValue,resolve,reject)
                }catch(error){
                    reject(error)
                }
               }, 0);
            } else if (this.status === REJECTED){
                setTimeout(() => {
                    try{
                        let returnValue = failCallback(this.reason)
                        resolvePromise(newMyPromise,returnValue,resolve,reject)
                    }catch(error){
                        reject(error)
                    }
                   }, 0);
            } else {
                this.successCallback.push(()=>{
                    setTimeout(() => {
                        try{
                            let returnValue = successCallback(this.data)
                            resolvePromise(newMyPromise,returnValue,resolve,reject)
                        }catch(error){
                            reject(error)
                        }
                       }, 0);
                })
                this.failCallback.push(() =>{
                    setTimeout(() => {
                        try{
                            let returnValue = failCallback(this.reason)
                            resolvePromise(newMyPromise,returnValue,resolve,reject)
                        }catch(error){
                            reject(error)
                        }
                       }, 0);
                })
            } 
        })
        return newMyPromise
    }
}
function resolvePromise (newMyPromise,returnValue,resolve,reject){
    if(newMyPromise  === returnValue){
        reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
    }else{
        if(returnValue instanceof MyPromise){
            returnValue.then(resolve,reject)
        } else {
            resolve(returnValue)
        }
    }
}

13.将then 方法的参数变成可选参数，也就是说 当then方法链式调用的时候 先不传参数 后面的then再穿参数，也可以调用then的回调函数
做法就是判断then的参数如果为空，补上成功或失败的回调函数

const PENDING = 'pending' 
const FULFILLED = 'fulfilled' 
const REJECTED = 'rejected' 
class MyPromise{
    constructor(executor){
        try{
            executor(this.resolve,this.reject)
        }catch(error){
            this.reject(error)
        }
    }
    status = PENDING
    data = undefined
    reason = undefined
    successCallback = []
    failCallback = []
    resolve = data =>{
        if(this.status !== PENDING) return
        this.status = FULFILLED
        this.data = data
        while(this.successCallback.length) this.successCallback.shift()()
    }
    reject = reason =>{
        if(this.status !== PENDING) return
        this.status = REJECTED
        this. reason = reason
        while(this.failCallback.length) this.failCallback.shift()()
    }
    then(successCallback,failCallback){
        let newMyPromise = new MyPromise((resolve,reject) => {
            if(this.status === FULFILLED){
               setTimeout(() => {
                try{
                    if(!successCallback) successCallback = value  => value
                    let returnValue = successCallback(this.data)
                    resolvePromise(newMyPromise,returnValue,resolve,reject)
                }catch(error){
                    reject(error)
                }
               }, 0);
            } else if (this.status === REJECTED){
                setTimeout(() => {
                    try{
                        if(!failCallback) failCallback = reason => { throw reason }
                        let returnValue = failCallback(this.reason)
                        resolvePromise(newMyPromise,returnValue,resolve,reject)
                    }catch(error){
                        reject(error)
                    }
                   }, 0);
            } else {
                this.successCallback.push(()=>{
                    setTimeout(() => {
                        try{
                            if(!successCallback) successCallback = value  => value
                            let returnValue = successCallback(this.data)
                            resolvePromise(newMyPromise,returnValue,resolve,reject)
                        }catch(error){
                            reject(error)
                        }
                       }, 0);
                })
                this.failCallback.push(() =>{
                    setTimeout(() => {
                        try{
                            if(!failCallback) failCallback = reason => { throw reason }
                            let returnValue = failCallback(this.reason)
                            resolvePromise(newMyPromise,returnValue,resolve,reject)
                        }catch(error){
                            reject(error)
                        }
                       }, 0);
                })
            } 
        })
        return newMyPromise
    }
}
function resolvePromise (newMyPromise,returnValue,resolve,reject){
    if(newMyPromise  === returnValue){
        reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
    }else{
        if(returnValue instanceof MyPromise){
            returnValue.then(resolve,reject)
        } else {
            resolve(returnValue)
        }
    }
}

14.Promise.all 方法的实现

    static all (array){
        let result = []
        return new MyPromise(async (resolve,reject) =>{
            for(let item of array){
                if(item instanceof MyPromise){
                    try{
                        result.push(await item)
                    }catch(error){
                        reject(error)
                    }
                }else{
                    result.push(item)
                }
            }
            resolve(result)
        })
    }

上面是直接拍扁异步操作或者等待异步操作完成以后，再去resolve，两个方式都可以实现all方法

    static all (array){
        let result = []
        let index = 0
        return new MyPromise((resolve,reject) =>{
            function addData(key,value){
                result[key] = value
                index++
                if(index === array.length){
                    resolve(result)
                }
            }
            for(let i = 0; i < array.length; i++){
                if(array[i] instanceof MyPromise){
                    array[i].then(value => addData(i,value), error => reject(error))
                }else{
                    addData(i,array[i])
                }
            } 
        })
    }

15.Promise.resolve方法的实现

    static resolve(value){
        if(value instanceof MyPromise){
            return value
        }else{
            return new MyPromise(resolve =>resolve(value))
        }
    }

16.finally 方法的实现

    finally(Callback){
        return this.then(value =>{
            return MyPromise.resolve(Callback()).then(() => value) 
        },error =>{
            return MyPromise.resolve(Callback()).then(() => { throw error }) 
        })
    }

17.catch 方法的实现

    catch(failCallback){
        return this.then(undefined,failCallback)
    }
【一键搭建PHP环境】php服务器软件
04-09
一键 PHP环境 服务器软件
七种PHP开发环境搭建工具
10-15
PHP开发环境搭建对于初学者来说是一个重要的起点，本文将介绍七种常见的PHP开发环境搭建工具，帮助新手快速入门并提升开发效率。 1. **phpStudy** phpStudy是一款非常适合PHP初学者的集成环境，它的名字直译为"PHP...
php开发环境及工具
masaichi_的博客
03-10 914
1.php运行环境需要apache服务，数据库看自己需要安装，mysql或者mongo等      windows平台 1.你可以选择单独安装apache ，mysql，php，  2.为了不将时间花费在繁琐的配置环境过程，使用集成开发环境 WampServer 或者XAMPP，打开服务即可运行在浏览器php文件  2.IDE 1.Eclipse for PHP 支持 Window、L
创建PHP运行环境的步骤指南
最新发布
04-05 749
无论开发还是生产环境，都建议遵循“最小权限原则”，并持续关注PHP官方安全通告。对于本地开发测试，可以选择使用集成环境工具，如XAMPP或PHPStudy。数据库连接配置：为MySQL创建独立账户、使用PDO扩展预处理语句、定期备份数据库并设置访问IP白名单。操作系统已更新至稳定版本，如Windows 10+、Ubuntu 20.04+或macOS 12+。PHP代码未解析：检查Web服务器配置中PHP模块是否加载，及文件后缀是否正确。运行安装程序，选择PHP版本，建议7.4或8.1。
PHP搭建开发环境（Windows系统）
heilai4的博客
11-13 6430
要搭建一个完整的PHP动态网站，离不开操作系统、Web服务器、数据库、和PHP软件。以下是本文章的所采用的大概配置。操作系统：Windows11Web服务器： 本文章采用Apache数据库： MySQLPHP软件：用于解析PHP脚本文件。
PHP 入门 - 部署环境搭建与工具
麦客的Blog
04-22 452
文章目录前言一、开发工具二、部署环境搭建1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、开发工具 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、部署环境搭建 1.引入库 代码如下（示例）： import numpy as np import pandas a
对php进行开发的环境,PHP开发环境搭建(一):PHP简介及开发工具
weixin_30284931的博客
03-19 317
一、什么是PHP？PHP现在的全称是hypertext preprocessor，最初它的名称是personal home page。PHP是一种服务器端HTML--嵌入式脚本描述语言，与JSP类似。其最强大和最重要的特征是其数据库集成层，使用它完成一个含有数据库功能的网页是不可置信的简单。在HTML文件中，PHP脚本程序(语法类似于Perl或者c语言)可以使用特别的PHP标签进行引用， 这样网页...
php集成开发环境搭建.docx
01-03
总的来说，搭建PHP集成开发环境是一项基础但至关重要的任务，它为PHP开发提供了一个本地化的测试平台。通过正确配置Apache、PHP和数据库，开发者可以方便地进行代码编写、调试和测试，从而提高开发效率。对于初学者...
PHP 开发环境搭建及开发工具
04-08
PHP 开发环境搭建及开发工具
Mac下搭建php开发环境教程
09-30
在Mac OS X系统下搭建PHP开发环境是一项技术活动，旨在让开发者能够在苹果电脑上快速开发PHP程序。本文从几个方面详细介绍了整个搭建过程，包括启动Apache服务器、运行PHP、安装MySQL数据库以及如何使用phpMyAdmin...
php环境搭建工具有哪些,PHP 环境搭建工具
weixin_42312523的博客
04-13 276
用户、角色、权限三者多对多用hibernate的一对多注解配置用户.角色.权限三者多对多用hibernate的一对多注解配置 //权限表@Table(name = "p")public class P { @Id @GeneratedValu ...zzuli oj 1178 单词数Description 统计一篇文章里不同单词的总数. Input 有多组数据,每组一行,每组就是一篇小文章.每篇小...
搭建PHP开发环境
沉默王二
08-25 2154
前言：之前已经介绍了如何搭建PHP的运行环境，那么接下来要做的，搭建PHP开发环境就简单了，当然我之前在学习的阶段用的是eclipse，但是这一次，我们来使用phpStorm，不过这是一款商业软件，不过你应该不会担心要不要注册。
PHP开发环境搭建及开发工具设置
mafajin的专栏
02-04 659
最近由于项目需要，需要做个数据服务发布管理系统，于是搜了一下，对于一直做C++开发的程序员来说，php相对来说比较合适，比较容易上手，所以搜索了一下，找到几篇不错的文章，把环境搭建，开发工具设置等方法共享下，便于自己查找及大家参考。 1.用Eclipse开发PHP项目，环境搭建方法参考： http://wenku.baidu.com/link?url=pv_BkmuLBih
PHP开发环境搭建及开发工具
weixin_30632899的博客
08-22 149
PHP服务器组件非常多有WampServer、XAMPP、AppServ、phpStudy、phpnow等。 菜鸟教程推荐： WampServer，这也是目前window平台上使用最广泛的，操作也非常简单。WampServer内部还集成了PhpMyAdmin 数据库管理工具。 下载地址：http://www.wampserver.com/en/#download-wrapper ...
PHP开发环境的搭建
wml
04-20 827
1、PHP开发环境的搭建：   （1）在Windows下搭建： Wamp：Apache+PHP（PHP核心，用于支持PHP开发）+MySQL+PHPmyadmin（管理MySQL数据库的图形化工具） （2）在Linux下搭建： Lamp：linux+apache+mysql+php 2、如何在Windows环境下安装： （1）套件安装： 如xampp Appserve  把我们需
搭建PHP开发环境（Apache+PHP+MySQL）
热门推荐
galen2016的博客
06-25 10万+
简介：总结在Windows环境搭建PHP开发环境（Apache+PHP+MySQL） 安装Apache 1、下载Apache，地址：http://www.apachelounge.com/download/，如下图： 2、解压压缩包，最好放到磁盘根目录，不然配置时容易报路径错误，我这里改了文件夹名，方便以后配置，如下图： 安装PHP 1、下载PHP压缩包，地址：https://w...
php环境搭建工具包推荐
angou6476的博客
03-22 165
如题，无论是生产还是测试环境，推荐一下这个： http://www.phpstudy.net/ 同时，也是一个php学习的网站，和w3cschool差不错，但是这里只有php。 转载于:https://www.cnblogs.com/EasonJim/p/5304541.html...
9款一键快速搭建PHP运行环境的好工具
陈万洲的专栏
12-13 5560
一键搭建PHP运行环境工具 1.APMServ http://apmserv.s135.com/ 国内研发，功能强大，操作简单，无需安装，只需鼠标一点，即可在自己的电脑上傻瓜全自动搭建一个完美的PHP的Web服务器。 2.PHPnow http://www.phpnow.org/ 国内研发，集成套件，绿色免费，简易安装、可快速搭建支持虚拟主机的P
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值