鸿蒙开发中Promise,async函数和await，Promise的静态方法的理解与使用

最新推荐文章于 2024-10-09 22:44:51 发布
最新推荐文章于 2024-10-09 22:44:51 发布
阅读量1.2k 收藏 17
点赞数 24
分类专栏： harmonyos 文章标签： 鸿蒙 华为 harmonyos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaw2002/article/details/141781472
版权

Promise

1.1什么是promise

1.Promise 是用来管理异步操作的对象，可以获取成功(或失败)的结果

核心代码：

const p = new Promise<string>((resolve, reject) => {
  // 执行任意代码，主要是异步
  // 成功 resolve(成功结果) then 执行
  // 失败 reject(失败结果) then第二个回调函数或 catch 执行
})
p.then(res => {}, (err: string) => {})
// 或者
p.then(res=>{}).catch((err:string)=>{})

 2.作用： 能够解决回调函数地狱（多层回调函数嵌套）

3.如何用：

用 Promise 来管理异步任伍分 3 步走：

  1. 内部执行异步代码

  2. 传递成功结果

  3. 传递失败结果

//内部执行异步代码
// 实例化 Promise 对象
  const p = new Promise<string>(() => {
    // 执行任意代码，主要是异步
    setTimeout(() => {
      // 比如：获取随机数
      const randomNum = Math.floor(Math.random() * 100)
      console.log('随机数是:', randomNum)
    },2000)
  })
}
//2传递成功结果
const p = new Promise<string>((resolve) => {
    // 执行任意代码，主要是异步
    setTimeout(() => {
      // 比如：获取随机数
      const randomNum = Math.floor(Math.random() * 100)
      resolve(randomNum.toString())
    },2000)
  })

  p.then(res => {
    console.log('res:', res)
  })
//返回失败结果 
 const p = new Promise<string>((resolve,reject) => {
      // 执行任意代码，主要是异步
      setTimeout(() => {
        // 比如：获取随机数
        const randomNum = Math.floor(Math.random() * 100)
        // resolve(randomNum.toString())
        reject(randomNum.toString())
      },2000)
    })

    p.then(res => {
      console.log('res:', res)
    })
    .catch((err:string)=>{
      console.log('err:',err)
    })

再来看看http模块的 request 方法，他返回的就是一个Promise对象所以我们用.then和.catch接收的结果

1.2promise的状态

Promise 必然处于 3 种状态中的某一种，调用resolve,reject 的本质就是更改他的状态

3 种状态:

  1. 待定（pending）: 初始状态，既没有被兑现(resolve)，也没有被拒绝(reject)
  2. 已兑现（fullfilled）: 意味着操作成功完成
  3. 已拒绝（rejected）: 意味着操作失败

 

注意：状态的改变是不可逆的

调用 resolve 之后再调用 reject，状态还是 已兑现，反之亦然

直接得到一个成功或者失败的结果写法：

  1. Promise.resolve(成功信息) 直接得到一个已兑现（fullfilled）的Promise对象
  2. Promise.reject(失败信息)直接得到一个已拒绝（rejected）的Promise对象

不可逆测试 

  const p = new Promise<string>((resolve, reject) => {
    resolve('success')
    reject('err')
  })

  p
    .then(res => {
    console.log('res:', res)
  })
    .catch((err: string) => {
      console.log('err:', err)
    })

 1.3链式编程的使用

作用：前面说过Promise的链式编程是用来解决【回调函数地狱】的一种写法，让多层嵌套的代码变得可读性强

让我们先看看回调地狱的写法：代码结构整体呈现三角行随着我们每一阶段业务代码的处理逻辑增加代码的可读性就如同地狱一般难以分析。

// 回调地狱写法
const req = http.createHttp()
req.request('接口1')
  .then(res1=>{
    req.request('接口2?p=接口1的结果res1')
      .then(res2=>{
        req.request('接口3?p=接口2的结果res2')
          .then(res3=>{
            req.request('接口4?p=接口3的结果res3')
              .then(res4=>{
                req.request('接口5?p=接口4的结果res4')
                  .then(res5=>{
                    req.request('接口6?p=接口5的结果res5')
                      .then(res6=>{

                      })
                  })
              })
          })
      })
  })

那么链式编程的写法呢：可以让每一次的业务处理逻辑都处在同一级使可读性大大滴提升,注意：

  1. Promise 的 then 方法会自动返回一个新Promise 对象
  2. then 方法的返回值会影响这个 新Promise对象的结果是已兑现状态还是已拒绝状态
// 链式编程回调地狱写法
const req = http.createHttp()
req.request('接口1')
  .then(res1 => {
    return req.request('接口2?p=接口1的结果res1')
  })
  .then(res2 => {
    return req.request('接口3?p=接口2的结果res2')
  })
  .then(res3 => {
    return req.request('接口4?p=接口3的结果res3')
  })
  .then(res4 => {
    return req.request('接口5?p=接口4的结果res4')
  })
 .then(res5 => {
    return req.request('接口6?p=接口5的结果res5')
  })
 .then(res6 => {
    
  })

 链式编程的逻辑如下图所示

最后简单的总结一下链式编程的特点吧：copy下来看看结果

let p = new Promise<string>((resolve, reject) => {
  setTimeout(() => {
    resolve('成功1')
  }, 10)
})

// 链式编程
/*
 * 特点：
 * 1. 后面的 .then是可以接受到前面.then返回的成功状态下的值
 * 2. 后面的.catch是可以接受前面.then中返回的失败状态下的值
 * 3. 一旦在某个.then里面返回的是一个失败状态的Pormise，则直接跳过其他
 * 的.then进入到.catch执行
 *
 * 总结：
 * 写法： p.then().then()....catch()
 * 注意点：如果 后一个.then需要用到前一个.then中的结果，需要在前一个
 * .then中 显示return一下
 * */
p
  .then(res1 => {
    console.log('res1--->', res1)
    // return '成功2'  // 等价于：return Promise.resolve('成功2')
    return Promise.reject('失败1')
  })
  .then(res2 => {
    console.log('res2--->', res2)
    return Promise.resolve('成功3')
    // return Promise.reject('失败1')
  })
  .then(res3=>{
    console.log('res3--->', res3)
  })
  .catch((err:string)=>{
    console.log('err--->',err )
  })


@Entry
@Component
struct Index {
  build() {
    Column() {

    }
    .height('100%')
    .width('100%')
    .backgroundColor(Color.Pink)

  }
}

async 函数函数和await

2.1 async/await基础

先来看看async函数和 await能够做什么？

Promise 的链式编程虽然不用嵌套了，但是依旧有回调函数，我们可以使用 async 函数 结合 await来进一步优化，让代码变得简单和易读

Promise 的链式编程

const req = http.createHttp()
req.request('https://hmajax.itheima.net/api/province')
    .then(res=>{
      let obj: iRes = JSON.parse(res.result.toString())
      this.multi[0] = obj.list
      return req.request(`https://hmajax.itheima.net/api/city?pname=${encodeURIComponent('河北省')}`)
    })
    .then(res => {
      let obj: iRes = JSON.parse(res.result.toString())
      this.multi[1] = obj.list
      return  req.request(`https://hmajax.itheima.net/api/area?pname=${encodeURIComponent('河北省')}&cname=${encodeURIComponent('石家庄市')}`)
    })
    .then(res => {
      let obj: iRes = JSON.parse(res.result.toString())
      this.multi[2] = obj.list
    })

async函数和await的结合

 async getData() {
    const req = http.createHttp()
    let res1 = await req.request('https://hmajax.itheima.net/api/province')
    let res2 = await req.request(`https://hmajax.itheima.net/api/city?pname=${encodeURIComponent('河北省')}`)
    let res3 = await req.request(`https://hmajax.itheima.net/api/area?pname=${encodeURIComponent('河北省')}&cname=${encodeURIComponent('石家庄市')}`)

    let prov:iRes = JSON.parse(res1.result.toString())
    let city:iRes = JSON.parse(res2.result.toString())
    let area:iRes = JSON.parse(res3.result.toString())

    this.multi[0] = prov.list
    this.multi[1] = city.list
    this.multi[2] = area.list
  }

可以看到代码更加简洁清晰

async/await是什么？

async/await是一种用于处理异步操作的Promise语法糖。

通过使用async关键字声明一个函数为异步函数（返回值是Promise类型）

使用await关键字等待Promise的解析（完成或拒绝），以同步的方式编写异步操作的代码。 

async/await基本语法

核心步骤：

  1. async 修饰函数
  2. await 等待成功（Promise 对象）
  3. 语法： 
    async function func() {
  // await 获取到的是 之后 Promise 对象的成功结果
  const res1 = await Promise对象1
  const res2 = await Promise对象2
  const res3 = await Promise对象3
}

//执行func函数
func()

运行一下加深印象

// 获取一个随机数，返回一个Promise对象
function randomNum() {
  return new Promise<string>((resolve, reject) => {
    setTimeout(() => {
      const num = Math.floor(Math.random() * 100)
      resolve(num.toString())
    }, 10)
  })
}

// 定义async函数func，里面使用await等待Promise对象返回结果
async function func() {
  const num1 = await randomNum()
  console.log(num1)
}

2.2 async函数和await的特点

如果Promise是失败状态，则不会再往下继续执行

如果想要执行，需要使用try/catch来捕获错误

  1. async修饰的函数默认返回的是Promise对象，所以可以放到await关键字后面来调用
  2. async修饰的函数内部return的数据需要使用 await 或者 .then() 或者.catch 来接收
  3. await关键字必须放在async修饰的函数中才能使用
  4. await关键字后面是一个Promise对象，如果是一个普通值会自动转为Promise对象来执行
  5. await会等待其后面的Promise对象的成功执行状态，将结果值赋值给 = 号前面的变量

//结合1，2观察以下函数

//1. 准备一个Promise对象
async function getRandom() {
  let num = Math.floor(Math.random() * 100)
  return num.toString()  // 本质上是返回了一个Promise.Resolve(num.toString())
}

// 2. 使用一个异步函数来调用，
async function call() {
  let res = await getRandom()
  console.log('成功随机数：--->', res)

  let res1 = await getRandom()
  console.log('成功随机数：--->', res1)
}

 再来看看await函数的特点

// 1. 准备一个Promise对象
function getRandom() {
  return new Promise<string>((resolve, reject) => {
    setTimeout(() => {
      let num = Math.floor(Math.random() * 100)
      // resolve(num.toString())
      reject(num.toString())
    }, 2000)
  })
}

// 2. 使用一个异步函数来调用
async function call() {
  let res = await getRandom()

  console.log('成功随机数：--->', res)

  let res1 = await getRandom()
  console.log('成功随机数：--->', res1)
}

注意：✨✨✨✨✨

     1.await关键字必须放在async修饰的函数中才能使用 （await不能单独使用,async可以单独使用）
      2. await关键字后面是一个Promise对象，如果是一个普通值会自动转为Promise对象来执行
      3. await会等待其后面的Promise对象的成功执行状态(不要在需要花费较长时间的异步函数中使用await)

2.3try/catch捕获错误

基本语法：将要执行的代码放入try中

  try {
    // 需要被执行的语句
    //一旦出错，就会触发catch中的代码执行
  } catch (error) {
    // error 接收错误信息
    // 处理错误信息代码
  }

 

 看看案例：

// 获取一个随机数，返回一个Promise对象
function randomNum(time:number) {
  return new Promise<string>((resolve, reject) => {
    setTimeout(() => {
      const num = Math.floor(Math.random() * 100)
      reject(num.toString())
    }, time)
  })
}

// 定义async函数func，里面使用await等待Promise对象返回结果
async function func() {
  console.log('run--->begin')

  //由于Promise对象的执行状态为拒绝(失败状态)，则后面代码不会再执行
  // 我们需要使用try/catch来捕获异常，让代码能够继续往下执行  
 try {    
    const num1 = await randomNum(300)
    console.log('num1=', num1)
  } catch (err) {
    console.error('err--->',JSON.stringify(err))
  }

  console.log('run--->end')

}

Promise的静态函数

3.1. Promise.resolve

//返回一个成功发promise对象
//语法：
Promise.resolve('成功原因')
  .then(res => {
    AlertDialog.show({ message: res })
  })

3.2. Promise.reject

 

/*返回一个拒绝原因的 Promise 对象
语法：
*/
Promise.reject('拒绝原因')
  .catch((err: string) => {
    AlertDialog.show({ message: err })
  })

3.3. Promise.race

上面2个相信静态方法相信已经相等熟悉了 。

是什么：‌Promise.race()方法‌用于处理一组异步操作，并返回第一个完成的异步操作的结果

场景：多个服务器提供相同的数据，但响应时间不同，你想要最快的那个服务器给你响应数据（只接受第一个成功对象的结果）

 那么我就模拟一下不同服务器的响应：

const p1 = new Promise<string>((resolve, reject) => {
  setTimeout(() => {
    resolve('1')
  }, 2000)
})

const p2 = new Promise<string>((resolve, reject) => {
  setTimeout(() => {
    reject('2')
  }, 1000)
})

// Promise.race方法作用：可以执行一组异步对象，返回第一个执行完成的异步对象的结果
Promise.race([p1, p2])
  .then(res => {
    console.log('race执行结果--->', res)
  })
  .catch((err:string)=>{
    console.log('err race执行结果--->', err)
  })

/*race方法，可以执行一组异步对象
  注意点：最快的那个异步对象如果是成功状态，则使用.then来接受结果
  否则使用.catch来接收结果

  应用场景：多个服务器提供相同的数据，但响应时间不同，你想要最快的那个服务器给你响应数据

 */

3.4. Promise.all

是什么：‌‌Promise.all方法用于处理多个Promise实例，如果所有Promise实例都成功完成，将所有成功的结果作为一个数组返回，如果任何一个Promise实例失败，返回第一个失败的Promise实例的原因

使用场景：（多个数据要么都必须有要么差一个就都不需要）

直接看代码跑跑和它的描述做一下对比：

@Entry
@Component
struct Index {
  build() {
    Column() {
      Button('Promise.all基本语法')
        .onClick(() => {
          /*
           * 总结：
           * Promise.all的作用是？
           *   执行一组p对象，如果所有成功则返回所有的执行结果（数组类型）
           * .them() 接收成功的结果
           * 如果有一个执行失败，直接返回失败的数据 （.catch来接收）
           *
           * 缺点：只要有一个失败了，其他的都拿不到数据
           * 场景：多个请求要么同时拿到成功的数据，要么一个不要
           * */

          const p1 = new Promise<string>((resolve, reject) => {
            setTimeout(() => {
              resolve('1')
            }, 2000)
          })

          const p2 = new Promise<string>((resolve, reject) => {
            setTimeout(() => {
              reject('2')
            }, 1000)
          })

          const p3 = new Promise<string>((resolve, reject) => {
            setTimeout(() => {
              resolve('3')
            }, 1000)
          })

          Promise.all([p1, p2, p3])
            .then(res => {
              AlertDialog.show({ message: JSON.stringify(res, null, 2) })
            })
            .catch((err: string) => {
              AlertDialog.show({ message: '错误：' + err })
            })

        })
    }
    .height('100%')
    .width('100%')
  }
}

3.5. Promise.allSettled

相比于 all 方法，allSettled 可以获取所有的结果，无论成功失败

const p1 = new Promise<string>((resolve, reject) => {
  setTimeout(() => {
    resolve('1')
  }, 2000)
})
const p2 = new Promise<string>((resolve, reject) => {
  setTimeout(() => {
    reject('2')
  }, 1000)
})
Promise.allSettled([p1, p2])
  .then((res) => {
    console.log('res:', JSON.stringify( res))
    //   [{"status":"fulfilled","value":"1"},{"status":"rejected","reason":"2"},{"status":"fulfilled","value":"itheima"}]
  }, (err: string) => {
    console.log('err:', err)
  })

我爱学鸿蒙
关注
专栏目录
【JavaScript】Promise与Async/Await：异步编程的艺术
Allen-
04-18 976
Promise与都是JavaScript中处理异步操作的重要工具，它们都旨在解决回调地狱的问题，提高代码的可读性和可维护性。语法风格Promise采用链式调用的方式，通过.then()和.catch()方法来指定成功和失败的回调函数，连续的异步操作可能会导致多层嵌套。则引入了新的语法特性，使得异步代码看起来更像是同步代码，通过async关键字标记函数，并在函数内部使用await关键字等待Promise的结果。这样可以避免回调函数的嵌套，使得代码更加扁平化和易读。错误处理Promise必须通过。
鸿蒙ArkTS实战开发：异步并发 (Promise和async await)
2401_84160325的博客
04-12 916
有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。为了能够帮助大家快速掌握**鸿蒙（HarmonyOS NEXT）**应用开发技术知识。在此给大家分享一下我结合鸿蒙最新资料整理出来的鸿蒙南北向开发学习路线以及整理的最新版鸿蒙学习文档资料。这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了。
鸿蒙原生应用开发-ArkTS语言基础类库异步并发简述async/await
weixin_69135651的博客
03-06 1305
在async函数内部，可以使用await关键字等待一个Promise对象的解析，并返回其解析值。如果一个async函数抛出异常，那么该函数返回的Promise对象将被拒绝，并且异常信息会被传递给Promise对象的onRejected()方法。通过使用async关键字声明一个函数为异步函数，并使用await关键字等待Promise的解析（完成或拒绝），以同步的方式编写异步操作的代码。下面是一个使用async/await的例子，其中模拟了一个异步操作，该操作会在3秒钟后返回一个字符串。
鸿蒙中的Promise是什么？用在何处？怎么用？解决了什么问题？
2201_75353990的博客
10-07 553
Promise主要解决了异步编程中的回调地狱问题。而Promise提供了一种更加优雅的方式来处理异步操作，它允许开发者通过链式调用的方式处理多个异步操作，使得代码更加清晰和易于理解。综上所述，鸿蒙中的Promise是一种强大的异步编程解决方案，它为开发者提供了一种简洁、高效的异步编程方式。通过Promise的使用，开发者可以更加清晰地表达异步操作的逻辑，提高代码的可读性和可维护性。Promise是一种用于处理异步操作的对象，它可以将异步操作的结果返回给调用者，并提供了更加清晰、可读性更高的代码结构。
【鸿蒙】---鸿蒙Next小课堂之Promise
qq_45774739的博客
06-04 1544
Promise是一种用于处理异步操作的对象，可以将异步操作转换为类似于同步操作的风格，以方便代码编写和维护。简而言之：Promise 用来管理异步，方便编码。
Promise和async/await
酷爱前端的小陈博客
04-20 984
1. 回调地狱 多层回调函数的相互嵌套，就形成了回调地狱。示例代码如下： 回调地狱的缺点： 代码耦合性太强，牵一发而动全身，难以维护 大量冗余的代码相互嵌套，代码的可读性变差 1.1 如何解决回调地狱的问题 为了解决回调地狱的问题，ES6（ECMAScript 2015）中新增了 Promise 的概念。 2.Promise 的基本概念 ① Promise 是一个构造函数 我们可以创建 Promise 的实例const p = new Promise() ...
鸿蒙ArkTS实战开发：异步并发 (Promise和async/await)
shudaoshanQAQ的博客
03-30 7547
Promise和async/await提供异步并发能力，是标准的JS异步语法。
HarmonyOS应用开发-关于鸿蒙中的异步(Promise)和线程（taskPool,worker）
HarmonyOS_002的博客
07-04 2379
这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
终于理清楚了Promise以及async和await
KAMHUNCHAN的博客
02-17 4339
promise理解： 1，是js异步编程的新的解决方案 2，是一个构造函数 3，用来封装一个异步操作，并可以获得其结果 promise三个状态： 1，pendding 未确定 2，resolved 成功 3，rejected 失败 注：状态只能改变一次，成功数据称为value，失败称为reason promise的基本使用 为什么要用Promise： 1.指定回调函数的方式灵活，可以在异步任务前指定也可以在异步任务后指定，而以前指定回调函数必须在异步任务开始前指定。 2.支持链式调用，可以解决
Promise、Async、await使用及源码
java_vava2的博客
05-26 251
作用：多个具有依赖关系的异步任务 状态明确之后无法更改 <script> new Promise(function(resolve,reject){ }) </script>
理解和使用 Promise & async/await
Morgan的技术博客
09-21 807
理解和使用Promise 参考资料：JS.info的 Promise，async/await 章节 1. 一个使用Promise的例子 callbacks 回调（揭露多层回调地狱的问题） Promise-basics（利用Promise解决问题） Promise 链使用 promise 进行错误处理 Promise API（静态方法） Promisification（将接受callback的函数转换为返回promise的函数） Async await
promise ~ async_await ~ 解决跨域的三种方法 ~ 反向代理 (好记性不如烂笔头)
qq_43944285的博客
05-26 531
promise <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <titl
JavaScript异步编程：Promise与Async_Await的使用与实践
# 1. JavaScript异步编程概述 ## 1.1 什么是JavaScript异步编程 ...通过回调函数、Promise、Async/Await等方式来处理异步操作，从而避免阻塞主线程。 ## 1.2 异步编程的优势与挑战 异步编程的优势在于能够提高程序的
【ES6】Promise的入门介绍
qq_22744093的博客
08-31 592
在这个例子中，我们创建了一个新的 Promise，它将在 1 秒后根据随机数决定成功或失败。然后我们调用 then() 和 catch() 方法来处理成功或失败的情况。如果 Promise 成功，then() 里的函数会被执行并打印 “成功！如果 Promise 失败，catch() 里的函数会被执行并打印 “失败！Promise 是 JavaScript 中的一个对象，用于处理异步操作。Promise 对象代表一个最终可能完成（并得到结果）或失败（并被拒绝）的操作，以及其结果的值。
鸿蒙最新鸿蒙ArkTS实战开发：异步并发 (Promise和async await)(1)，普通二本的辛酸HarmonyOS鸿蒙面试之路
2401_84850885的博客
05-13 715
有很多小伙伴不知道学习哪些鸿蒙开发技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？而且学习时频繁踩坑，最终浪费大量时间。所以有一份实用的鸿蒙（HarmonyOS NEXT）资料用来跟着学习是非常有必要的。为了能够帮助大家快速掌握**鸿蒙（HarmonyOS NEXT）**应用开发技术知识。在此给大家分享一下我结合鸿蒙最新资料整理出来的鸿蒙南北向开发学习路线以及整理的最新版鸿蒙学习文档资料。这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了。
promise及手写promise、await/async
sharryling
06-23 336
promise 主要是解决callback中的回调地狱问题。 1.基础概念 /* 1 打印hh 2 timeout结束，打印h1,参数sss 3 由于下面返回的全都是实例w，w在一开始已经执行完，所以 在w.then之后的return w,和之后的w.then return w，都是同时执行的。 */ var w = new Promise((resolve,rejec...
异步场景: promise、async函数与await命令介绍
最新发布
harmonyClassRoom的博客
10-09 899
如果你也对感兴趣，加入“Harmony自习室”吧！扫描下方名片，关注公众号，公众号更新更快，同时也有更多学习资料和技术讨论群。在鸿蒙的开发中，我们时常会遇到promise异步场景，有同学反馈说希望提一下。异步开发这部分的内容比较多，我不确定这位朋友具体想讨论是哪些方面，那我从两部分来讨论下，希望能提供一些帮助：1. 基本的开发角度，常用使用方法；2. 拿一个问题来讨论调用关系。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值