您的位置:新葡亰496net > 新葡亰官网 > 新葡亰496netjs_脚本之家

新葡亰496netjs_脚本之家

发布时间:2019-12-01 01:16编辑:新葡亰官网浏览(74)

    Async/Await替代Promise的6个理由

    2017/04/02 · JavaScript · async, await

    原来的作品出处: Mostafa Gaafar   译文出处:Fundebug   

    译者按: Node.js的异步编制程序形式可行加强了使用质量;但是回调鬼世界却让人不能越垒池一步,Promise让我们送别回调函数,写出更加高雅的异步代码;在举办进度中,却开采Promise并不康健;本领提升是无边无际的,那时候,我们有了Async/Await。

    Node.js 7.6曾经支撑async/await了,假使您还从未试过,那篇博客将告诉你怎么要用它。

    Async/Await简介

    • async/await是写异步代码的新措施,此前的不二法门有回调函数和Promise。
    • async/await是依赖Promise达成的,它不能够用于常常的回调函数。
    • async/await与Promise同样,是非堵塞的。
    • async/await使得异步代码看起来像一块代码,那就是它的吸重力到处。

    前言

    Async/Await简介

    对于未有传闻过async/await的对象,上面是简单介绍:

    • async/await是写异步代码的新点子,早前的章程有回调函数Promise
    • async/await是基于Promise实现的,它不可能用于普通的回调函数。
    • async/await与Promise同样,是非堵塞的。
    • async/await使得异步代码看起来像豆蔻年华道代码,那正是它的吸重力四处。

    Async/Await语法

    Promise写法:

    const makeRequest = () =>
      getJSON()
        .then(data => {
          console.log(data)
          return "done"
        })
    makeRequest()
    

    Async/Await写法:

    const makeRequest = async () => {
      console.log(await getJSON())
      return "done"
    }
    makeRequest()
    

    演示中,getJSON函数再次来到三个promise,那些promise成功resolve时会重临三个promise对象。大家只是调用那些函数,打字与印刷再次来到的JSON对象,然后回到“done”。

    它们有点细微差别:

    • 函数前边多了叁个async关键字。await关键字只好用在async定义的函数内。async函数会隐式的回到二个promise,该promise的resolve值正是函数return的值。(示例中resolve值正是字符串"done"卡塔尔国
    • 第1点暗中表示我们不可能在最外层代码中央银行使await,因为不在async函数内。
    //不能在最外层代码中使用await
    await makeRequest()
    
    //这是会出事的
    makeRequest().then((result) => {
      //代码
    })
    

    await getJSON(卡塔尔国表示console.log会等到getJSON的promise成功reosolve之后再试行。

    Node.js 7.6 已经支撑 async/await 了,假如您还并未有试过,那篇博客将告诉你为啥要用它。

    Async/Await语法

    示范中,getJSON函数重返三个promise,那些promise成功resolve时会再次来到多个json对象。大家只是调用那几个函数,打字与印刷重回的JSON对象,然后再次回到”done”。

    使用Promise是那样的:

    JavaScript

    const makeRequest = () => getJSON() .then(data => { console.log(data) return "done" }) makeRequest()

    1
    2
    3
    4
    5
    6
    7
    const makeRequest = () =>
      getJSON()
        .then(data => {
          console.log(data)
          return "done"
        })
    makeRequest()

    利用Async/Await是那般的:

    JavaScript

    const makeRequest = async () => { console.log(await getJSON()) return "done" } makeRequest()

    1
    2
    3
    4
    5
    const makeRequest = async () => {
      console.log(await getJSON())
      return "done"
    }
    makeRequest()

    它们有部分细微区别:

    • 函数前边多了八个aync关键字。await关键字只好用在aync定义的函数内。async函数会隐式地再次来到八个promise,该promise的reosolve值正是函数return的值。(示例中reosolve值就是字符串”done”卡塔尔
    • 第1点暗中提示我们不可能在最外层代码中使用await,因为不在async函数内。

    JavaScript

    // 无法在最外层代码中央银行使await await makeRequest(卡塔尔国 // 那是会出事情的 makeRequest(卡塔尔(قطر‎.then((result卡塔尔(英语:State of Qatar) => { // 代码 }卡塔尔国

    1
    2
    3
    4
    5
    6
    // 不能在最外层代码中使用await
    await makeRequest()
    // 这是会出事情的
    makeRequest().then((result) => {
      // 代码
    })

    await getJSON(卡塔尔表示console.log会等到getJSON的promise成功reosolve之后再实践。

    为什么Async/Await更好?

    Async/Await 简介

    为什么Async/Await更好?

    1. 简洁

    由示例可以预知,使用Async/Await分明节约了重重代码。大家不须求写.then,无需写无名氏函数管理Promise的resolve值,也不须求定义多余的data变量,还防止了嵌套代码。这一个小的长处会连忙累加起来,这在事后的代码示例中会越发通晓。

    对此还没据书上说过 async/await 的敌人,上面是简要介绍:

    1. 简洁

    由示例可见,使用Async/Await分明节约了超多代码。我们不须要写.then,没有必要写无名函数管理Promise的resolve值,也无需定义多余的data变量,还幸免了嵌套代码。这几个小的长处会急迅累加起来,那在随后的代码示例中会尤其简明。

    2. 错误管理

    Async/Await让try/catch能够并且处理一同和异步错误。在底下的promise示例中,try/catch不能够管理JSON.parse的不当,因为它在Promise中。大家要求使用.catch,那样错误处理代码极度冗余。而且,在大家的骨子里生育代码会更为头晕目眩。

    const makeRequest = () => {
      try {
        getJSON()
          .then(result => {
            // JSON.parse可能会出错
            const data = JSON.parse(result)
            console.log(data)
          })
          // 取消注释,处理异步代码的错误
          // .catch((err) => {
          //   console.log(err)
          // })
      } catch (err) {
        console.log(err)
      }
    }
    

    使用aync/await的话,catch能处理JSON.parse错误:

    const makeRequest = async () => {
      try {
        // this parse may fail
        const data = JSON.parse(await getJSON())
        console.log(data)
      } catch (err) {
        console.log(err)
      }
    }
    

    async/await 是写异步代码的新点子,从前的不二等秘书诀有回调函数和Promise。 async/await 是依据 Promise 达成的,它无法用来经常的回调函数。 async/await 与 Promise 同样,是非窒碍的。 async/await 使得异步代码看起来像风度翩翩道代码,那正是它的魅力各处。

    2. 错误管理

    Async/Await让try/catch能够同有的时候候管理一起和异步错误。在上边包车型客车promise示例中,try/catch不能管理JSON.parse的谬误,因为它在Promise中。大家供给使用.catch,那样错误管理代码特别冗余。并且,在咱们的实际上生产代码会愈加复杂。

    新葡亰496netjs_脚本之家。JavaScript

    const makeRequest = (卡塔尔(英语:State of Qatar) => { try { getJSON(卡塔尔国 .then(result => { // JSON.parse只怕会出错 const data = JSON.parse(result卡塔尔 console.log(data卡塔尔(قطر‎}卡塔尔国 // 撤废注释,管理异步代码的不当 // .catch((err卡塔尔 => { // console.log(err卡塔尔 // }卡塔尔(قطر‎ } catch (err卡塔尔 { console.log(err卡塔尔(قطر‎ } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    const makeRequest = () => {
      try {
        getJSON()
          .then(result => {
            // JSON.parse可能会出错
            const data = JSON.parse(result)
            console.log(data)
          })
          // 取消注释,处理异步代码的错误
          // .catch((err) => {
          //   console.log(err)
          // })
      } catch (err) {
        console.log(err)
      }
    }

    使用aync/await的话,catch能处理JSON.parse错误:

    JavaScript

    const makeRequest = async () => { try { // this parse may fail const data = JSON.parse(await getJSON()) console.log(data) } catch (err) { console.log(err) } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    const makeRequest = async () => {
      try {
        // this parse may fail
        const data = JSON.parse(await getJSON())
        console.log(data)
      } catch (err) {
        console.log(err)
      }
    }

    3. 原则语句

    下边示例中,必要获取数据,然后依照重返数据调节是一贯回到,还是一连获得越来越多的多少。

    const makeRequest = () => {
      return getJSON()
        .then(data => {
          if (data.needsAnotherRequest) {
            return makeAnotherRequest(data)
              .then(moreData => {
                console.log(moreData)
                return moreData
              })
          } else {
            console.log(data)
            return data
          }
        })
    }
    

    地点的代码嵌套(6层卡塔尔、括号、return语句相当的轻便令人看不懂。

    使用Async/Await编写:

    const makeRequest = async () => {
      const data = await getJSON()
      if (data.needsAnotherRequest) {
        const moreData = await makeAnotherRequest(data);
        console.log(moreData)
        return moreData
      } else {
        console.log(data)
        return data    
      }
    }
    

    Async/Await 语法

    3. 条件语句

    下边示例中,须要获取数据,然后依据重临数据调控是一贯回到,依然一而再三回九转得到越来越多的数码。

    JavaScript

    const makeRequest = () => { return getJSON() .then(data => { if (data.needsAnotherRequest) { return makeAnotherRequest(data) .then(moreData => { console.log(moreData) return moreData }) } else { console.log(data) return data } }) }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    const makeRequest = () => {
      return getJSON()
        .then(data => {
          if (data.needsAnotherRequest) {
            return makeAnotherRequest(data)
              .then(moreData => {
                console.log(moreData)
                return moreData
              })
          } else {
            console.log(data)
            return data
          }
        })
    }

    这一个代码看着就脑瓜疼。嵌套(6层),括号,return语句比较轻巧令人以为迷茫,而它们只是须求将最终结果传递到最外层的Promise。

    地方的代码应用async/await编写能够大大地增加可读性:

    JavaScript

    const makeRequest = async () => { const data = await getJSON() if (data.needsAnotherRequest) { const moreData = await makeAnotherRequest(data); console.log(moreData) return moreData } else { console.log(data) return data } }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    const makeRequest = async () => {
      const data = await getJSON()
      if (data.needsAnotherRequest) {
        const moreData = await makeAnotherRequest(data);
        console.log(moreData)
        return moreData
      } else {
        console.log(data)
        return data    
      }
    }

    4. 中间值

    你也许碰着过这么的情景,调用promise1,使用promise1重返的结果调用promise2,然后采纳两个的结果调用promise3。使用promise的代码是:

    const makeRequest = () => {
      return promise1()
        .then(value1 => {
          return promise2(value1)
            .then(value2 => {        
              return promise3(value1, value2)
            })
        })
    }
    

    什么promise3不应用value1,能够相当粗略的将promise铺平。假设忍受不住嵌套,能够将value1 & value2放进Promise.all来幸免深层嵌套:

    const makeRequest = () => {
      return promise1()
        .then(value1 => {
          return Promise.all([value1, promise2(value1)])
        })
        .then(([value1, value2]) => {      
          return promise3(value1, value2)
        })
    }
    

    新葡亰496netjs_脚本之家。这种方法为了可读性就义了语义,除了制止嵌套,并从未其他理由将value1和value2放在叁个数组中。

    动用async/await的话,代码会变得十分轻松和直观:

    const makeRequest = async () => {
      const value1 = await promise1()
      const value2 = await promise2(value1)
      return promise3(value1, value2)
    }
    

    演示中,getJSON 函数重临一个 promise,那个 promise 成功 resolve 时会重临多少个 json 对象。大家只是调用这么些函数,打字与印刷再次回到的 JSON 对象,然后回到”done”。

    4. 中间值

    你很或许境遇过这么之处,调用promise1,使用promise1重回的结果去调用promise2,然后使用两个的结果去调用promise3。你的代码很可能是如此的:

    JavaScript

    const makeRequest = () => { return promise1() .then(value1 => { return promise2(value1) .then(value2 => { return promise3(value1, value2) }) }) }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    const makeRequest = () => {
      return promise1()
        .then(value1 => {
          return promise2(value1)
            .then(value2 => {        
              return promise3(value1, value2)
            })
        })
    }

    比如promise3无需value1,能够很简单地将promise嵌套铺平。假设您忍受不住嵌套,你能够将value 1 & 2 放进Promise.all来防止深层嵌套:

    JavaScript

    const makeRequest = () => { return promise1() .then(value1 => { return Promise.all([value1, promise2(value1)]) }) .then(([value1, value2]) => { return promise3(value1, value2) }) }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    const makeRequest = () => {
      return promise1()
        .then(value1 => {
          return Promise.all([value1, promise2(value1)])
        })
        .then(([value1, value2]) => {      
          return promise3(value1, value2)
        })
    }

    这种措施为了可读性就义了语义。除了防止嵌套,并不曾别的轮理货公司由将value1和value2放在二个数组中。

    动用async/await的话,代码会变得不得了轻巧和直观。

    JavaScript

    const makeRequest = async () => { const value1 = await promise1() const value2 = await promise2(value1) return promise3(value1, value2) }

    1
    2
    3
    4
    5
    const makeRequest = async () => {
      const value1 = await promise1()
      const value2 = await promise2(value1)
      return promise3(value1, value2)
    }

    5. 错误栈

    const makeRequest = () => {
      return callAPromise()
        .then(() => callAPromise())
        .then(() => callAPromise())
        .then(() => callAPromise())
        .then(() => callAPromise())
        .then(() => {
          throw new Error("oops");
        })
    }
    makeRequest()
      .catch(err => {
        console.log(err);
        // output
        // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13)
      })
    

    上述示范中调用了八个promise,假诺promise链中某些地点抛出了贰个百般,重回的不当栈未有提交错误发生之处音讯。

    async/await中的错误栈会指向错误所在的函数:

    const makeRequest = async () => {
      await callAPromise()
      await callAPromise()
      await callAPromise()
      await callAPromise()
      await callAPromise()
      throw new Error("oops");
    }
    makeRequest()
      .catch(err => {
        console.log(err);
        // output
        // Error: oops at makeRequest (index.js:7:9)
      })
    

    在付出进程中,恐怕那或多或少优势并不是比超大。然而,即使是深入分析分娩情况的荒谬日志时,它将那多少个有效。

    利用 Promise 是如此的:

    5. 错误栈

    上面示例中调用了多少个Promise,要是Promise链中有些地点抛出了一个荒谬:

    JavaScript

    const makeRequest = () => { return callAPromise() .then(() => callAPromise()) .then(() => callAPromise()) .then(() => callAPromise()) .then(() => callAPromise()) .then(() => { throw new Error("oops"); }) } makeRequest() .catch(err => { console.log(err); // output // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13) })

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    const makeRequest = () => {
      return callAPromise()
        .then(() => callAPromise())
        .then(() => callAPromise())
        .then(() => callAPromise())
        .then(() => callAPromise())
        .then(() => {
          throw new Error("oops");
        })
    }
    makeRequest()
      .catch(err => {
        console.log(err);
        // output
        // Error: oops at callAPromise.then.then.then.then.then (index.js:8:13)
      })

    Promise链中回到的谬误栈未有交到错误发生地点的线索。更不佳的是,它会错误的指导我们;错误栈中当世无双的函数名称为callAPromise,然则它和不当未有涉及。(文件名和行号依然有效的卡塔尔。

    唯独,async/await中的错误栈会指向错误所在的函数:

    JavaScript

    const makeRequest = async () => { await callAPromise() await callAPromise() await callAPromise() await callAPromise() await callAPromise() throw new Error("oops"); } makeRequest() .catch(err => { console.log(err); // output // Error: oops at makeRequest (index.js:7:9) })

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    const makeRequest = async () => {
      await callAPromise()
      await callAPromise()
      await callAPromise()
      await callAPromise()
      await callAPromise()
      throw new Error("oops");
    }
    makeRequest()
      .catch(err => {
        console.log(err);
        // output
        // Error: oops at makeRequest (index.js:7:9)
      })

    在开采景况中,那一点优势并十分的小。可是,当您深入深入分析临蓐条件的谬误日志时,它将非常平价。那时,知道不当发生在makeRequest比知道不当爆发在then链中要好。

    6. 调试

    async/await能够使代码更有益调节和测验。
    promise调节和测验相当忧伤:

    • 无法在重临表达式的箭头函数中安装断点
    const makeRequest = () => {
        return callAPromise()
          .then(() => callAPromise())
          .then(() => callAPromise())
          .then(() => callAPromise())
          .then(() => callAPromise())
    }
    
    • 生机勃勃旦在.then代码块中安装断点,使用Step Over火速键,调节和测量检验器不会调到下贰个.then,因为它只会跳过异步代码。

    动用async/await时,不再需求那么多箭头函数,那样就足以像调节和测量试验同步代码相仿跳过await语句。

    const makeRequest = async () => {
        await callAPromise()
        await callAPromise()
        await callAPromise()
        await callAPromise()
    }
    
    const makeRequest = .then(data => {console.log;return "done";});makeRequest();
    

    6. 调试

    最后一点,也是特别首要的一点留意,async/await能够使得代码调节和测量检验更简短。2个理由使得调节和测量试验Promise变得那几个哀痛:

    • 不能在回去表达式的箭头函数中装置断点

    新葡亰496net 1

    • 纵然你在.then代码块中设置断点,使用Step Over飞快键,调节和测验器不会跳到下二个.then,因为它只会跳过异步代码。

    运用await/async时,你不再需求那么多箭头函数,那样您就足以像调节和测量试验同步代码同样跳过await语句。

    新葡亰496net 2

    使用 Async/Await 是这么的:

    结论

    Async/Await是近些日子JavaScript加多的最变革性的的特征之大器晚成。它会让您发掘Promise的语法有多倒霉,何况提供了一个直观的代替格局。

    const makeRequest = async () => {console.log;return "done";};makeRequest();
    

    忧虑

    对于Async/Await,大概你有意气风发部分创制的质疑:

    • 它使得异步代码不在显著: 大家早就习于旧贯了用回调函数恐怕.then来甄别异步代码,大家兴许要求花数个礼拜去习于旧贯新的标识。不过,C#持有那一个特点已经超多年了,熟练它的相恋的人应该掌握近来的多少不便于是值得的。
    • Node 7不是LTS(短时间帮衬版本): 不过,Node 8上个月就能揭橥,将代码迁移到新版本会相当的轻巧。

     

    1 赞 1 收藏 评论

    新葡亰496net 3

    函数后边多了八个 async 关键字。await 关键字只好用在 async 定义的函数内。async 函数会隐式地再次回到七个 promise,该 promise 的 reosolve 值正是函数 return 的值。(示例中 reosolve 值正是字符串”done”卡塔尔

    第 1 点暗指我们无法在最外层代码中动用 await,因为不在 async 函数内。

    // 不能在最外层代码中使用awaitawait makeRequest();// 这是会出事情的makeRequest().then;
    

    await getJSON(卡塔尔(英语:State of Qatar)表示 console.log 会等到 getJSON 的 promise 成功 reosolve 之后再进行。

    为什么 Async/Await 更好?

    1. 简洁

    由示例可见,使用 Async/Await 明显节约了好些个代码。大家不供给写.then,无需写无名函数处理 Promise 的 resolve 值,也不需求定义多余的 data 变量,还制止了嵌套代码。这个小的长处会火速累加起来,那在后头的代码示例中会尤其鲜明。

    2. 错误管理

    Async/Await 让 try/catch 能够同有的时候候管理一齐和异步错误。在底下的 promise 示例中,try/catch 不可能管理 JSON.parse 的大谬不然,因为它在 Promise 中。大家要求使用.catch,那样错误管理代码非常冗余。并且,在大家的实在坐褥代码会越加目眩神摇。

    const makeRequest = .then(result => {// JSON.parse可能会出错const data = JSON.parse;console.log;// 取消注释,处理异步代码的错误// .catch => {// console.log} catch  {console.log;}};
    

    使用 async/await 的话,catch 能处理 JSON.parse 错误:

    const makeRequest = async () => {try {// this parse may failconst data = JSON.parse;console.log {console.log;}};
    

    3. 尺度语句

    上边示例中,须求获取数据,然后遵照再次回到数据调控是平素回到,依然持续获得越来越多的数额。

    const makeRequest = () => {return getJSON().then(data => {if (data.needsAnotherRequest) {return makeAnotherRequest.then(moreData => {console.log;return moreData;});} else {console.log;};
    

    那么些代码瞧着就胃疼。嵌套,括号,return 语句超级轻松令人感到迷茫,而它们只是要求将最终结果传递到最外层的 Promise。

    地点的代码应用 async/await 编写能够大大地拉长可读性:

    const makeRequest = async () => {const data = await getJSON();if (data.needsAnotherRequest) {const moreData = await makeAnotherRequest;console.log;return moreData;} else {console.log;return data;}};
    

    4. 中间值

    你很恐怕境遇过这么的场馆,调用 promise1,使用 promise1 回来的结果去调用 promise2,然后使用两个的结果去调用 promise3。你的代码很也许是如此的:

    const makeRequest = () => {return promise1().then(value1 => {return promise2.then(value2 => {return promise3;};
    

    假如 promise3 不供给 value1,能够十分轻巧地将 promise 嵌套铺开。若是你忍受不住嵌套,你能够将 value 1 & 2 放进 Promise.all 来制止深层嵌套:

    const makeRequest = () => {return promise1().then(value1 => {return Promise.all([value1, promise2.then => {return promise3;};
    

    这种艺术为了可读性就义了语义。除了制止嵌套,并从未别的理由将 value1 和 value2 放在多少个数组中。

    动用 async/await 的话,代码会变得要命轻松和直观。

    const makeRequest = async () => {const value1 = await promise1();const value2 = await promise2;return promise3;};
    

    5. 错误栈

    上面示例中调用了多少个 Promise,假若 Promise 链中有些地点抛出了三个荒谬:

    const makeRequest = () => {return callAPromise => callAPromise => callAPromise => callAPromise => callAPromise => {throw new Error;};makeRequest().catch(err => {console.log;// output// Error: oops at callAPromise.then.then.then.then.then ;
    

    Promise 链中回到的大错特错栈未有交给错误发生地方的线索。更倒霉的是,它会误导大家;错误栈中并世无双的函数名字为callAPromise,不过它和不当未有关系。。

    而是,async/await 中的错误栈会指向错误所在的函数:

    const makeRequest = async () => {await callAPromise();await callAPromise();await callAPromise();await callAPromise();await callAPromise();throw new Error;};makeRequest().catch(err => {console.log;// output// Error: oops at makeRequest ;
    

    在付出条件中,那或多或少优势并非常的小。但是,当你剖析临盆意况的大谬不然日志时,它将那一个有效。那时,知道不当爆发在 makeRequest 比知道不当发生在 then 链中要好。

    6. 调试

    末段一点,也是超重大的某个在意,async/await 能够使得代码调节和测量检验更轻巧。2 个理由使得调节和测验 Promise 变得不行伤心:

    无法在重回表达式的箭头函数中设置断点

    举例你在.then 代码块中装置断点,使用 Step Over 快速键,调节和测量检验器不会跳到下一个.then,因为它只会跳过异步代码。使用 await/async 时,你不再须要那么多箭头函数,那样你就能够像调节和测验同步代码一样跳过 await 语句。

    结论

    Async/Await 是多年来 JavaScript 增添的最革命性的特征之豆蔻梢头。它会让您发觉 Promise 的语法有多不佳,并且提供了三个直观的代表形式。

    忧虑

    对此 Async/Await,恐怕你有生机勃勃对成立的质疑:

    它使得异步代码不再显然: 大家早已习感到常了用回调函数大概.then 来鉴定区别异步代码,大家大概须求花数个礼拜去习贯新的标识。但是,C#新葡亰496net,享有那几个特点已经相当多年了,熟练它的敌人应该明白一时的有一点点不便宜是值得的。Node 7 不是 LTS: 可是,Node 8 本月就能公布,将代码迁移到新版本会特简单。(Fundebug 注:Node 8 是 LTS,已经于 2017 年 10 月规范颁发。卡塔尔(英语:State of Qatar)

    原文: 6 Reasons Why JavaScript's Async/Await Blows Promises Away

    译者: Fundebug

    如上正是本文的全体内容,希望对大家的上学抱有助于,也指望大家多都赐教脚本之家。

    本文由新葡亰496net发布于新葡亰官网,转载请注明出处:新葡亰496netjs_脚本之家

    关键词:

上一篇:Promise才具研究,令你到底精通Promise原理

下一篇:没有了