promise专题05（完结）-自定义promise之resolve、reject、all、race封装，then的异步执行，async，await，async结合await发送ajax请求

最新推荐文章于 2023-10-20 11:11:17 发布
最新推荐文章于 2023-10-20 11:11:17 发布
阅读量352 收藏
点赞数
分类专栏： promise 文章标签： ajax php javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43745804/article/details/120799112
版权
1、resolve方法封装

具体代码：

Promise.resolve = function (value) {
  //返回promise对象
  return new Promise((resolve, reject) => {
    if (value instanceof Promise) {
      value.then(value => {
        resolve(value)
      }, (reason) => {
        reject(reason)
      })
    }else {
      resolve(value)
    }
  })
}
2、reject方法封装
//添加promise的reject静态方法
Promise.reject=function(reason){
  //返回promise对象
  return new Promise((resolve,reject)=>{
    reject(reason)
  })
}

以上两例的全部代码

//相当于重写promise
function Promise(excutor){
  //添加属性
  this.PromiseState='pending'
  this.PromiseResult=''

  //在这里保存一个callback属性用来存放onResolved和onRejected方法
  this.callbacks=[]
  const that=this


  //同步调用执行器函数
  function resolve (data) {
    if (that.PromiseState!=='pending'){
      return
    }
    //修改对象的状态。promiseState
    that.PromiseState='fulfilled'
    //设置对象结果值promiseReuslt
     that.PromiseResult=data
    //异步状态下执行成功的回调函数（这里有点回归的意思）
    that.callbacks.forEach(item=>{
      item.onResolved(data)
    })
  }
  function reject (data) {
    if (that.PromiseState!=='pending'){
      return
    }
    that.PromiseState='rejected'
    that.PromiseResult=data
    //异步状态下执行失败的回调函数
    that.callbacks.forEach(item=>{
      item.onRejected(data)
    })
  }
  //这里要执行这个执行器函数
  try{
    excutor(resolve,reject)
  }
  catch (e) {
    reject(e)//
  }


}

Promise.prototype.then=function(onResolved,onRejected){
  const that=this
  //做异常穿透要判断回调参数
  if (typeof onRejected !=='function'){
    onRejected=(reason)=>{
      throw reason
    }
  }

  if (typeof onResolved !=='function'){
    onResolved=(value)=>{
      return value
    }
  }

  return new Promise((resolve,reject)=>{
    //封装函数
    function callback (type) {
      //获取回调函数的执行结果
      let result=type(that.PromiseResult)
      if (result instanceof  Promise){
        //如果是Promise类型的对象
        result.then(value=>{
          resolve(value)
        },reason => {
          reject(reason)
        })
      }else{
        //结果对象设为成功
        resolve(result)
      }
    }
    try{
      //调用回到函数，需要做对this.PromiseState做条件判断
      if (this.PromiseState=='fulfilled'){
        callback(onResolved)
      }
      if (this.PromiseState=='rejected'){
        callback(onRejected)

      }
      //异步状态下这里先执行
      if (this.PromiseState=='pending'){
        //把两个函数存储到callback属性上去
        //考虑到多次使用then，因此存储以push的方式push到数组中去
        this.callbacks.push({
          onResolved:function(){
            try{
              callback(onResolved)
            }catch (e) {
              reject(e)
            }

        },
          onRejected:function () {
            try{
              callback(onRejected)
            }catch (e) {
              reject(e)
            }

          }
        })
      }
    }
    catch (e) {
      reject(e)
    }

  })


}
//添加promise的catch方法
Promise.prototype.catch=function (onRejected) {
    return this.then(undefined,onRejected)
}

//添加promise的resolve静态方法
Promise.resolve=function (value) {
  //返回promise对象
  return new Promise((resolve,reject)=>{
    if (value instanceof Promise){
      value.then(value => {
        resolve(value)
      },(reason)=>{
        reject(reason)
      })
    }
  })
}
//添加promise的reject静态方法
Promise.reject=function(reason){
  //返回promise对象
  return new Promise((resolve,reject)=>{
    reject(reason)
  })
}
3、all方法封装
  • all方法所有promise成功才能成功，所以需要遍历参数数组
  • 在每一个参数数组元素（promise）执行then的结果，执行计数器加一，并将结果添加到结果数组中
  • 到了计数器和参数数组长度一致的时候，则返回那个结果数组
//添加promise的all静态方法
Promise.all = function (promises) {
  return new Promise((resolve, reject) => {
    //设置一个计数变量
    let count = 0
    //设置接收返回的promise对象数组
    let promisesArry = []
    for (let i = 0; i < promises.length; i++) {
      //遍历每一个promises参数中的promise对象
      promises[i].then((value) => {
        //得知对象成功则计数器加一
        count++
        //把处理结果值依次放到返回的promise对象数组中
        promisesArry[i] = value
        //如果每次都可以返回则循环计数器将最终等于参数数组的长度
        if (count === promises.length) {
          //最后一次性resolve完整个promise数组
          resolve(promisesArry)
        }

      }, (reason) => {
        //只要一旦计入到一个reject，整体就返回reason了
        reject(reason)
      })
    }
  })
}

脚本中执行

<script>

  $('#send_ajax').click(function(){
      let promise1=new Promise((resolve,reject)=>{
      		//resolve（ok）
          setTimeout(()=>{
            resolve('ok')
          },1000)
      })

    // let promise2=new Promise.resolve('成功')
    // let promise3=new Promise.resolve('success')
    let promise2=new Promise((resolve,reject)=>{
      resolve('成功')
    })
    let promise3=new Promise((resolve,reject)=>{
      resolve('succes')
    })
    let result=Promise.all([promise1,promise2,promise3])
    console.log(result)
  })
</script>

结果：
非异步状态下：
在这里插入图片描述

异步状态下：
在这里插入图片描述

4、race方法封装
  • 先返回成功就全部成功，先返回失败就全部失败
  • 由于异步处理，先执行同步代码，所以race的结果肯定是看第一条同步代码的返回值
  • 如果是同步处理，则看第一条同步代码的返回值，所以，异步处理结果一般来说不影响race的执行结果
//添加promise的race静态方法
Promise.race=function (promises) {
  return new Promise((resolve,reject)=>{
    for (let i=0; i<promises.length;i++){
      promises[i].then((value)=>{
        resolve(value)
      },(reason)=>{
        reject(reason)
      })
    }
  })

}

执行代码

<script>

  $('#send_ajax').click(function(){
      let promise1=new Promise((resolve,reject)=>{
      	// reject('fail')
        setTimeout(()=>{
          reject('fail')
        },1000)

      })


    let promise2=new Promise.resolve('成功')
    let promise3=new Promise((resolve,reject)=>{
      resolve('succes')
    })
    let result=Promise.race([promise1,promise2,promise3])
    console.log(result)
  })
</script>

结果：
异步代码情形下
在这里插入图片描述
同步代码情形下
在这里插入图片描述

5、then方法回调的异步执行

then方法修改这里

 //调用回到函数，需要做对this.PromiseState做条件判断
      if (this.PromiseState == 'fulfilled') {
        //异步执行加定时器
        setTimeout(()=>{
          callback(onResolved)
        })
      }
      if (this.PromiseState == 'rejected') {
        setTimeout(()=>{
          callback(onRejected)
        })
      }

主要是在then方法里修改，这里是then方法

Promise.prototype.then = function (onResolved, onRejected) {
  const that = this
  //做异常穿透要判断回调参数
  if (typeof onRejected !== 'function') {
    onRejected = (reason) => {
      throw reason
    }
  }

  if (typeof onResolved !== 'function') {
    onResolved = (value) => {
      return value
    }
  }

  return new Promise((resolve, reject) => {
    //封装函数
    function callback (type) {
      //获取回调函数的执行结果
      let result = type(that.PromiseResult)
      if (result instanceof Promise) {
        //如果是Promise类型的对象
        result.then(value => {
          resolve(value)
        }, reason => {
          reject(reason)
        })
      } else {
        //结果对象设为成功
        resolve(result)
      }
    }

    try {
      //调用回到函数，需要做对this.PromiseState做条件判断
      if (this.PromiseState == 'fulfilled') {
        setTimeout(()=>{

          callback(onResolved)

        })
      }
      if (this.PromiseState == 'rejected') {
        callback(onRejected)

      }
      //异步状态下这里先执行
      if (this.PromiseState == 'pending') {
        //把两个函数存储到callback属性上去
        //考虑到多次使用then，因此存储以push的方式push到数组中去
        this.callbacks.push({
          onResolved: function () {
            try {
              callback(onResolved)
            } catch (e) {
              reject(e)
            }

          },
          onRejected: function () {
            try {
              callback(onRejected)
            } catch (e) {
              reject(e)
            }

          }
        })
      }
    } catch (e) {
      reject(e)
    }

  })

}

此外在resolve和reject里面也要调用一下setimeout方法

  //同步调用执行器函数
  function resolve (data) {
    if (that.PromiseState !== 'pending') {
      return
    }
    //修改对象的状态。promiseState
    that.PromiseState = 'fulfilled'
    //设置对象结果值promiseReuslt
    that.PromiseResult = data
    
    setTimeout(()=>{
      //异步状态下执行成功的回调函数（这里有点回归的意思）
      that.callbacks.forEach(item => {
        item.onResolved(data)
      })
    })
    
    
  }

  function reject (data) {
    if (that.PromiseState !== 'pending') {
      return
    }
    that.PromiseState = 'rejected'
    that.PromiseResult = data
    setTimeout(()=>{
      //异步状态下执行失败的回调函数
      that.callbacks.forEach(item => {
        item.onRejected(data)
      })
    })
    
  }

执行代码：

<script>

  $('#send_ajax').click(function(){
    let promise1=new Promise((resolve,reject)=>{
        resolve('ok')
        console.log(111)
    })

    promise1.then(value=>{
      //console.log(value)
      console.log(2222)
    })

    console.log(333)
  })
</script>

结果
在这里插入图片描述
最终的自定义Promise包为：

//相当于重写promise
function Promise (excutor) {
  //添加属性
  this.PromiseState = 'pending'
  this.PromiseResult = ''

  //在这里保存一个callback属性用来存放onResolved和onRejected方法
  this.callbacks = []
  const that = this

  //同步调用执行器函数
  function resolve (data) {
    if (that.PromiseState !== 'pending') {
      return
    }
    //修改对象的状态。promiseState
    that.PromiseState = 'fulfilled'
    //设置对象结果值promiseReuslt
    that.PromiseResult = data

    setTimeout(()=>{
      //异步状态下执行成功的回调函数（这里有点回归的意思）
      that.callbacks.forEach(item => {
        item.onResolved(data)
      })
    })


  }

  function reject (data) {
    if (that.PromiseState !== 'pending') {
      return
    }
    that.PromiseState = 'rejected'
    that.PromiseResult = data
    setTimeout(()=>{
      //异步状态下执行失败的回调函数
      that.callbacks.forEach(item => {
        item.onRejected(data)
      })
    })

  }

  //这里要执行这个执行器函数
  try {
    excutor(resolve, reject)
  } catch (e) {
    reject(e)//
  }

}

Promise.prototype.then = function (onResolved, onRejected) {
  const that = this
  //做异常穿透要判断回调参数
  if (typeof onRejected !== 'function') {
    onRejected = (reason) => {
      throw reason
    }
  }

  if (typeof onResolved !== 'function') {
    onResolved = (value) => {
      return value
    }
  }

  return new Promise((resolve, reject) => {
    //封装函数
    function callback (type) {
      //获取回调函数的执行结果
      let result = type(that.PromiseResult)
      if (result instanceof Promise) {
        //如果是Promise类型的对象
        result.then(value => {
          resolve(value)
        }, reason => {
          reject(reason)
        })
      } else {
        //结果对象设为成功
        resolve(result)
      }
    }

    try {
      //调用回到函数，需要做对this.PromiseState做条件判断
      if (this.PromiseState == 'fulfilled') {
        //异步执行加定时器
        setTimeout(()=>{
          callback(onResolved)
        })
      }
      if (this.PromiseState == 'rejected') {
        setTimeout(()=>{
          callback(onRejected)
        })
      }
      //异步状态下这里先执行
      if (this.PromiseState == 'pending') {
        //把两个函数存储到callback属性上去
        //考虑到多次使用then，因此存储以push的方式push到数组中去
        this.callbacks.push({
          onResolved: function () {
            try {
              callback(onResolved)
            } catch (e) {
              reject(e)
            }

          },
          onRejected: function () {
            try {
              callback(onRejected)
            } catch (e) {
              reject(e)
            }

          }
        })
      }
    } catch (e) {
      reject(e)
    }

  })

}
//添加promise的catch方法
Promise.prototype.catch = function (onRejected) {
  return this.then(undefined, onRejected)
}

//添加promise的resolve静态方法
Promise.resolve = function (value) {
  //返回promise对象
  return new Promise((resolve, reject) => {
    if (value instanceof Promise) {
      value.then(value => {
        resolve(value)
      }, (reason) => {
        reject(reason)
      })
    }else {
      resolve(value)
    }
  })
}
//添加promise的reject静态方法
Promise.reject = function (reason) {
  //返回promise对象
  return new Promise((resolve, reject) => {
    reject(reason)
  })
}

//添加promise的all静态方法
Promise.all = function (promises) {
  return new Promise((resolve, reject) => {
    //设置一个计数变量
    let count = 0
    //设置接收返回的promise对象数组
    let promisesArry = []
    for (let i = 0; i < promises.length; i++) {
      //遍历每一个promises参数中的promise对象
      promises[i].then((value) => {
        //得知对象成功则计数器加一
        count++
        //把处理结果值依次放到返回的promise对象数组中
        promisesArry[i] = value
        //如果每次都可以返回则循环计数器将最终等于参数数组的长度
        if (count === promises.length) {
          //最后一次性resolve完整个promise数组
          resolve(promisesArry)
        }

      }, (reason) => {
        //只要一旦计入到一个reject，整体就返回reason了
        reject(reason)
      })
    }
  })
}
//添加promise的race静态方法
Promise.race=function (promises) {
  return new Promise((resolve,reject)=>{
    for (let i=0; i<promises.length;i++){
      promises[i].then((value)=>{
        resolve(value)
      },(reason)=>{
        reject(reason)
      })
    }
  })

}
6、async函数
  • 函数的返回值为promise对象
  • promise对象的结果由async函数的返回值决定
async  function main () {
      //如果返回值是一个非promise对象
      //return 333
      //如果返回值是一个promise对象,则函数返回的对象就返回的promise对象的返回值
      return new Promise((resolve,reject)=>{
        //resolve('成功')
        reject('失败')
      })

    }

    let result=main()
    console.log(result)
7、await表达式
  • await右侧的表达式一般为promise对象，但也可以是其他的值
  • 如果表达式是promise对象，await返回的是promise成功的值
  • 如果表达式是其他值，则直接将此值作为await的返回值
  • await必须写在async函数中，但async函数中可以没有await
  • 如果await的promise失败了，就会抛出异常，需要通过try…catch捕获处理
<script>

  $('#send_ajax').click(function(){

    async  function main () {
      let p=new Promise((resolve ,reject)=>{
        reject('fail')
      })
      //1、右侧为promise的情况
      //return await p
      //2、右侧为其他数据的情形
      //return await 111
      //3、右侧promise为失败的状态
      try{
        let result=await p
        return result
      }catch (e) {
        return e
      }


    }

    let result=main()
    console.log(result)
  })
</script>
8、async结合await

传统写法（有回调地狱）：

const fs =require('fs')

let str=fs.readFile('../public/async1.txt',(err1,data1)=>{
  if (err1) throw err1
  fs.readFile('../public/async2.txt',(err2,data2)=>{
    if (err2) throw err2
    fs.readFile('../public/async3.txt',(err3,data3)=>{
      if (err3) throw err3
      console.log(data1+data2+data3)
    })
  })
})

aysnc写法:

const fs =require('fs')
//导入util模块
const util=require('util')
//利用util的promisify将fs.readFile转化为
const mineReadFile=util.promisify(fs.readFile)
async function mytest(){
  let data1=await mineReadFile('../public/async1.txt')
  let data2=await mineReadFile('../public/async2.txt')
  let data3=await mineReadFile('../public/async3.txt')

  console.log(data1+data2+data3)

}

mytest()
9、async结合await发送ajax请求
<script>
//未来这个函数可以使用axios进行封装
  function sendAjax(url) {
    const promise = new Promise((resolve, reject) => {
      $.ajax({
        url: url,
        type: 'GET',
        success (msg) {
          if (msg.status) {
            resolve(msg)
          } else {
            reject('请求失败')
          }
        }
      })
    })

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

  $('#send_ajax').click(async function(){
    let url='http://localhost:3000/test'
    const result=await sendAjax(url)
    console.log(result)

  })


</script>
心湖中的石子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
原生ajax的封装以及结合promise和async/await的使用
qq_19652407的博客
11-12 646
错误封装原生ajax导致无法获取请求结果 一. 前奏——了解ajax文档 ajax文档地址 XMLHttpRequest 的实例对象拥有： 两个请求方法：open(method,url,async)，send(string)； 两种响应字段：responseText（字符串形式），responseXML（xml形式） 三个属性：onreadystatechange（实例状态改变调用的函数），readyState（实例状态），status（状态） 二、错误封装原生ajax ...
ES6的异步操作之promise用法和async函数的具体使用
10-15
在ES6中，异步操作的管理有了显著的改进，主要体现在Promise对象和async/await语法的引入。Promise是处理异步操作的一种模式，它解决了传统异步编程中回调地狱的问题，提供了更清晰的控制流程。Promise有三种状态：...
Promise深入 + 自定义Promise
YOLO
11-12 435
Promise深入 + 自定义Promise 1. 准备 1.1. 函数对象与实例对象 1. 函数对象: 将函数作为对象使用时, 简称为函数对象 2. 实例对象: new 函数产生的对象, 简称为对象 1.2. 回调函数的分类 1. 同步回调: 理解: 立即执行, 完全执行完了才结束, 不会放入回调队列中 例子: 数组遍历相关的回调函数 / Promise的excutor函数 2. 异步回调: 理解: 不会立即执行, 会放入回调队列中将来执行 例子: 定时器回调 / a
async 和 await ：await处理new Promise（(resolve, reject) =＞{...}）对象时，会将resolve()的参数作为返回值处理
最新发布
qq_27361945的博客
10-20 1204
当紧接着输出最终的response时，发现response是json字符串，而不是promise对象，在不了解await的作用时，感到非常诧异。语句等号右边时promise对象，左边是普通对象后，推测唯一的答案来自await，可能await对promise对象进行了处理，使其变成普通对象。await配合Promise对象使用时，会将Promise对象中resolve()的参数作为返回值，以替代定义中返回的Promise对象。如果下一个操作的结果取决于上一个操作的结果，这是必要的，但如果不是这样，像。
async await 异步调用ajax实例
lllsj的博客
07-19 1595
async await 异步调用ajax实例: 检测文件数, 当文件数量>x , 则返回错误信息, 异 则 发请求 进行删除操作 //检查文件数,如果超过x,则 禁止用户操作 async checkFileMount(_tableSelection) { this.filemgtLoading = true; let response; var params = { list: _tableSelection }; await check
Promise中resolve和reject以及异步编程的终极方案(async/await)
Gik99的博客
03-16 351
Promise中resolve和reject以及异步编程的终极方案(async/await)
JS中async/await实现异步调用的方法
12-10
Async/Await不需要写.then，不需要写匿名函数处理Promise的resolve值，也不需要定义多余的data变量，还避免了嵌套代码 async声明一个异步函数 await只能在async函数中使用，后面跟一个promise对象 所以在模拟异步...
uniapp-request.zip-Promise方式封装uniapp请求
06-24
本篇文章将深入探讨如何使用Promise和async/await来封装uniapp的网络请求，以提供更优雅的异步编程体验。 首先，让我们了解Promise。Promise是JavaScript中处理异步操作的一种方式，它代表了一个可能尚未完成但最终...
vue中用 async/await 来处理异步操作
10-15
传统的异步处理方式包括回调函数、Promise等，但随着ES6的引入，`async/await`语法为处理异步操作提供了更优雅的解决方案。`async/await`是基于Promise构建的，它使得异步代码看起来更像同步代码，提高了代码的...
使用async await 封装 axios的方法
08-27
"使用async await 封装axios的方法" async await 是一种异步编程的方式，它可以将异步代码写得像同步代码一样，易于阅读和维护。axios 是一个流行的 HTTP 客户端库，用于发送 HTTP 请求。在 Vue 项目中，我们可以...
从ajax到promise到async await
luo_1010的博客
06-28 926
ajax发送请求的原生简单写法 var xhr = new XMLHttpRequest() xhr.open('get','http://localhost:3000/data1') xhr.send() xhr.onreadystatechange = function(){ if(xhr.readyState===4) { var ret = xhr.responseT...
JavaScript基础 - 28 （promise解决回调地狱、async和await）
欢迎来到猫猫的博客 o_o ，如有问题，欢迎提出改正~
12-02 279
解决回调地狱 回调地狱：传统写法中, 在一个异步方法成功后 调用下一个异步方法，如此多层嵌套，实现异步方法的 同步调用效果。此写法会导致代码过于复杂， 嵌套难以理解 Promise是官方提供的一个构造函数，它生成的对象带有链式写法，可以简化多层嵌套 链式写法：用.关联 obj.skill.name.xxx.xxxx promise基本格式：new Promise((resolve, reject) => { }).then(result =...
Async/Await中的resolve和reject怎么用？
小郭的博客
03-18 3633
Async/Await中的resolve和reject怎么用？ 我们在返回新的Promise的时候可以在param里面声明resolve和reject，resolve代表成功的情况，reject代表失败的情况 resolve的情况 如果我们用try catch去抓的时候，resolve会顺利通过，并执行await getData()后面的代码 function getData(){ console.log("fetch...") return new Promise((resolv.
JavaScript Promise | async / await
weixin_44240581的博客
05-11 124
练习题 const promise = new Promise((resolve, reject) => { resolve('success1') reject('error') resolve('success2') }) promise .then((res) => { console.log('then: ', res) }) .catch((err) => { console.log('catch: ', err) }) /* 结
promise 和 async await方法的用法实例(异步队列,执行有先后顺序)
qq_42750608的博客
09-05 228
// Promise用法和async await的区别 const takeLongTime = (n) => { return new Promise(resolve=>{ setTimeout(() => { resolve(n+200) }, n); }); } const step1=(n) =>{ console.log(`step1 width ${n}`) return takeL.
new Promise处理异步
m0_56347363的博客
02-03 174
异步方法---抽取公共方法调用。
Ajax，axios，promise，formData学习笔记
m0_60505147的博客
10-01 697
Ajax(Asynchronous JavaScript and XML)不是指一种单一的技术，而是有机地利用了一系列相关的技术。虽然其名称包含XML，但实际上数据格式可以由JSON代替，进一步减少数据量，形成所谓的AJAJ。为了使用JavaScript向服务器发出HTTP请求，需要一个提供此功能的类的实例。这就是XMLHttpRequest的由来。这样的类最初是在Internet Explorer中作为一个名为XMLHTTP的ActiveX对象引入的。
前端promise、async重点总结
qq_43176127的博客
07-22 1020
一、promoise 1.注意点1 如果调用then的Promise的状态发生改变，但是then中并没有关于这种状态的回调函数，那么then将创建一个没有经过回调函数处理的新Promise对象，这个新Promise只是简单地接受调用这个then的原Promise的终态作为它的终态。 例：异常穿透 var flag let p=new Promise((resolve,reject)=>{ setTimeout((falg)=>{ if(flag){ ..
Promise 与 async await 面试知识点
阿嚏乱码的地方
02-26 1343
Promise的正常用法 function xx(){ return new Promise((resolve,reject)=>{ setTimeout(()=>{ resovle('成功的输出') reject('失败输出') },3000) }) } xx().then(fn1,...
Promise 和 async/await执行顺序
06-09
`Promise` 和 `async/await` 的执行顺序都基于 JavaScript 事件循环机制。 在 `Promise` 中，异步操作会被添加到事件队列中，然后按照队列中的顺序执行。在执行过程中，如果遇到了异步操作，就会将其添加到事件队列...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值