如何使用Await减少回调嵌套

在开发的时候，有时候需要发很多请求，然后经常会面临嵌套回调的问题，即在一个回调里面又嵌了一个回调，导致代码层层缩进得很厉害，如下代码所示：

创新互联建站2013年至今，是专业互联网技术服务公司，拥有项目成都网站设计、网站制作、外贸营销网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元那曲做网站,已为上家服务,为那曲各地企业和个人服务,联系电话:18980820575

 
 
 
 
    
  
  
  
  
  1. ajax({ 
    2. 
  
  
  
  
  2.     url: "/list", 
    3. 
  
  
  
  
  3.     type: "GET", 
    4. 
  
  
  
  
  4.     success: function(data) { 
    5. 
  
  
  
  
  5.        appendToDOM(data); 
    6. 
  
  
  
  
  6.         ajax({ 
    7. 
  
  
  
  
  7.             url: "/update", 
    8. 
  
  
  
  
  8.             type: "POST", 
    9. 
  
  
  
  
  9.             success: function(data) { 
    10. 
  
  
  
  
  10.                 util.toast("Success!"); 
    11. 
  
  
  
  
  11.             }) 
    12. 
  
  
  
  
  12.         }); 
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14. }); 
    15.

这样的代码看起来有点吃力，这种异步回调通常可以用Promise优化一下，可以把上面代码改成：

 
 
 
 
    
  
  
  
  
  1. new Promise(resolve => { 
    2. 
  
  
  
  
  2.     ajax({ 
    3. 
  
  
  
  
  3.         url: "/list", 
    4. 
  
  
  
  
  4.         type: "GET", 
    5. 
  
  
  
  
  5.         success: data => resolve(data); 
    6. 
  
  
  
  
  6.     }) 
    7. 
  
  
  
  
  7. }).then(data => { 
    8. 
  
  
  
  
  8.    appendToDOM(data); 
    9. 
  
  
  
  
  9.     ajax({ 
    10. 
  
  
  
  
  10.         url: "/update", 
    11. 
  
  
  
  
  11.         type: "POST", 
    12. 
  
  
  
  
  12.         success: function(data) { 
    13. 
  
  
  
  
  13.             util.toast("Successfully!"); 
    14. 
  
  
  
  
  14.         })   
    15. 
  
  
  
  
  15.     });  
    16. 
  
  
  
  
  16. }); 
    17.

Promise提供了一个resolve，方便通知什么时候异步结束了，不过本质还是一样的，还是使用回调，只是这个回调放在了then里面。

当需要获取多次异步数据的时候，可以使用Promise.all解决：

 
 
 
 
    
  
  
  
  
  1. let orderPromise = new Promise(resolve => { 
    2. 
  
  
  
  
  2.     ajax("/order", "GET", data => resolve(data)); 
    3. 
  
  
  
  
  3. }); 
    4. 
  
  
  
  
  4. let userPromise = new Promise(resolve => { 
    5. 
  
  
  
  
  5.     ajax("/user", "GET", data => resolve(data)); 
    6. 
  
  
  
  
  6. }); 
    7. 
  
  
  
  
  7.   
    8. 
  
  
  
  
  8. Promise.all([orderPromise, userPromise]).then(values => { 
    9. 
  
  
  
  
  9.     let order = values[0], 
    10. 
  
  
  
  
  10.          user = values[1]; 
    11. 
  
  
  
  
  11. }); 
    12.

但是这里也是使用了回调，有没有比较优雅的解决方式呢?

ES7的await/async可以让异步回调的写法跟写同步代码一样。***个嵌套回调的例子可以用await改成下面的代码：

 
 
 
 
    
  
  
  
  
  1. // 使用await获取异步数据 
    2. 
  
  
  
  
  2. let leadList = await new Promise(resolve => { 
    3. 
  
  
  
  
  3.     ajax({ 
    4. 
  
  
  
  
  4.         url: "/list", 
    5. 
  
  
  
  
  5.         type: "GET", 
    6. 
  
  
  
  
  6.         success: data => resolve(data); 
    7. 
  
  
  
  
  7.     }); 
    8. 
  
  
  
  
  8. }); 
    9. 
  
  
  
  
  9.   
    10. 
  
  
  
  
  10. // await让代码很自然地像瀑布流一样写下来  
    11. 
  
  
  
  
  11. appendToDom(leadList); 
    12. 
  
  
  
  
  12. ajax({ 
    13. 
  
  
  
  
  13.     url: "/update", 
    14. 
  
  
  
  
  14.     type: "POST", 
    15. 
  
  
  
  
  15.     success: () => util.toast("Successfully"); 
    16. 
  
  
  
  
  16. }); 
    17.

Await让代码可以像瀑布流一样很自然地写下来。

第二个例子：获取多次异步数据，可以改成这样：

 
 
 
 
    
  
  
  
  
  1. let order = await new Promise( 
    2. 
  
  
  
  
  2.            resolve => ajax("/order", data => resovle(data))), 
    3. 
  
  
  
  
  3.   
    4. 
  
  
  
  
  4.     user = await new Promise( 
    5. 
  
  
  
  
  5.            resolve => ajax("/user", data => resolve(data))); 
    6. 
  
  
  
  
  6.   
    7. 
  
  
  
  
  7. // do sth. with order/user 
    8.

这种写法就好像从本地获取数据一样，就不用套回调函数了。

Await除了用在发请求之外，还适用于其它异步场景，例如我在创建订单前先弹一个小框询问用户是要创建哪种类型的订单，然后再弹具体的设置订单的框，所以按正常思路这里需要传递一个按钮回调的点击函数，如下图所示：

但其实可以使用await解决，如下代码所示：

 
 
 
 
    
  
  
  
  
  1. let quoteHandler = require("./quote"); 
    2. 
  
  
  
  
  2. // 弹出框询问用户并得到用户的选择 
    3. 
  
  
  
  
  3. let createType = await quoteHandler.confirmCreate(); 
    4.

quote里面返回一个Promise，监听点击事件，并传递createType：

 
 
 
 
    
  
  
  
  
  1. let quoteHandler = { 
    2. 
  
  
  
  
  2.     confirmCreate: function(){ 
    3. 
  
  
  
  
  3.         dialog.showDialog({ 
    4. 
  
  
  
  
  4.             contentTpl: tpl, 
    5. 
  
  
  
  
  5.             className: "confirm-create-quote" 
    6. 
  
  
  
  
  6.         }); 
    7. 
  
  
  
  
  7.         let $quoteDialog = $(".confirm-create-quote form")[0]; 
    8. 
  
  
  
  
  8.         return new Promise(resolve => { 
    9. 
  
  
  
  
  9.             $(form.submit).on("click", function(event){ 
    10. 
  
  
  
  
  10.                 resolve(form.createType.value); 
    11. 
  
  
  
  
  11.             }); 
    12. 
  
  
  
  
  12.         }); 
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14.   
    15. 
  
  
  
  
  15. } 
    16.

这样外部调用者就可以使用await，而不用传递一个点击事件的回调函数了。

但是需要注意的是await的一次性执行特点。相对于回调函数来说，await的执行是一次性的，例如监听点击事件，然后使用await，那么点击事件只会执行一次，因为代码从上往下执行完了，所以当希望点击之后出错了还能继续修改和提交就不能使用await，另外使用await获取异步数据，如果出错了，那么成功的resolve就不会执行，后续的代码也不会执行，所以请求出错的时候基本逻辑不会有问题。

要在babel里面使用await，需要：

(1)安装一个Node包

 
 
 
 
    
  
  
  
  
  1. npm install –save-dev babel-plugin-transform-async-to-generator 
    2.

(2)在工程的根目录添加一个.babelrc文件，内容为：

 
 
 
 
    
  
  
  
  
  1. { 
    2. 
  
  
  
  
  2.   "plugins": ["transform-async-to-generator"] 
    3. 
  
  
  
  
  3. } 
    4.

(3)使用的时候先引入一个模块

 
 
 
 
    
  
  
  
  
  1. require("babel-polyfill"); 
    2.

然后就可以愉快地使用ES7的await了。

使用await的函数前面需要加上async关键字，如下代码：

 
 
 
 
    
  
  
  
  
  1. async showOrderDialog() { 
    2. 
  
  
  
  
  2.      // 获取创建类型 
    3. 
  
  
  
  
  3.      let createType = await quoteHandler.confirmCreate(); 
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5.      // 获取老订单数据  
    6. 
  
  
  
  
  6.      let orderInfo = await orderHandler.getOrderData(); 
    7. 
  
  
  
  
  7. } 
    8.

我们再举一个例子：使用await实现JS版的sleep函数，因为原生是没有提供线程休眠函数的，如下代码所示：

 
 
 
 
    
  
  
  
  
  1. function sleep (time) { 
    2. 
  
  
  
  
  2.     return new Promise(resolve =>  
    3. 
  
  
  
  
  3.                           setTimeout(() => resolve(), time)); 
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5.   
    6. 
  
  
  
  
  6. async function start () { 
    7. 
  
  
  
  
  7.     await sleep(1000); 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9.   
    10. 
  
  
  
  
  10. start(); 
    11.

babel的await实现是转成了ES6的generator，如下关键代码：

 
 
 
 
    
  
  
  
  
  1. while (1) { 
    2. 
  
  
  
  
  2.     switch (_context.prev = _context.next) { 
    3. 
  
  
  
  
  3.         case 0: 
    4. 
  
  
  
  
  4.             _context.next = 2; 
    5. 
  
  
  
  
  5.             // sleep返回一个Promise对象 
    6. 
  
  
  
  
  6.             return sleep(1000); 
    7. 
  
  
  
  
  7.   
    8. 
  
  
  
  
  8.         case 2: 
    9. 
  
  
  
  
  9.         case "end":      
    10. 
  
  
  
  
  10.             return _context.stop(); 
    11. 
  
  
  
  
  11.     } 
    12. 
  
  
  
  
  12. } 
    13.

而babel的generator也是要用ES5实现的，什么是generator呢?如下图所示：

生成器用function*定义，每次执行生成器的next函数的时候会返回当前生成器里用yield返回的值，然后生成器的迭代器往后走一步，直到所有yield完了。

有兴趣的可以继续研究babel是如何把ES7转成ES5的，据说原生的实现还是直接基于Promise.

使用await还有一个好处，可以直接try-catch捕获异步过程抛出的异常，因为我们是不能直接捕获异步回调里面的异常的，如下代码：

 
 
 
 
    
  
  
  
  
  1. let quoteHandler = { 
    2. 
  
  
  
  
  2.     confirmCreate: function(){ 
    3. 
  
  
  
  
  3.         $(form.submit).on("click", function(event){ 
    4. 
  
  
  
  
  4.             // 这里会抛undefined异常：访问了undefined的value属性 
    5. 
  
  
  
  
  5.             callback(form.notFoundInput.value); 
    6. 
  
  
  
  
  6.         }); 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9.   
    10. 
  
  
  
  
  10. try { 
    11. 
  
  
  
  
  11.     // 这里无法捕获到异常 
    12. 
  
  
  
  
  12.     quoteHandler.confirmCreate(); 
    13. 
  
  
  
  
  13. } catch (e) { 
    14. 
  
  
  
  
  14.   
    15. 
  
  
  
  
  15. } 
    16.

上面的try-catch是没有办法捕获到异常的，因为try里的代码已经执行完了，在它执行的过程中并没有异常，因此无法在这里捕获，如果使用Promise的话一般是使用Promise链的catch：

 
 
 
 
    
  
  
  
  
  1. let quoteHandler = { 
    2. 
  
  
  
  
  2.     confirmCreate: function(){ 
    3. 
  
  
  
  
  3.         return new Promise(resolve => { 
    4. 
  
  
  
  
  4.             $(form.submit).on("click", function(event){ 
    5. 
  
  
  
  
  5.                 // 这里会抛undefined异常：访问了undefined的value属性 
    6. 
  
  
  
  
  6.                 resolve(form.notFoundInput.value); 
    7. 
  
  
  
  
  7.             }); 
    8. 
  
  
  
  
  8.         }); 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10. } 
    11. 
  
  
  
  
  11.   
    12. 
  
  
  
  
  12. quoteHandler.confirmCreate().then(createType => { 
    13. 
  
  
  
  
  13.   
    14. 
  
  
  
  
  14. }).catch(e => { 
    15. 
  
  
  
  
  15.     // 这里能捕获异常 
    16. 
  
  
  
  
  16. }); 
    17.

而使用await，我们可以直接用同步的catch，就好像它真的变成同步执行了：

 
 
 
 
    
  
  
  
  
  1. try { 
    2. 
  
  
  
  
  2.     createType = await quoteHandler.confirmCreate("order"); 
    3. 
  
  
  
  
  3. }catch(e){ 
    4. 
  
  
  
  
  4.     console.log(e); 
    5. 
  
  
  
  
  5.     return; 
    6. 
  
  
  
  
  6. } 
    7.

总之使用await让代码少写了很多嵌套，很方便的逻辑处理，纵享丝滑。

原文链接：https://fed.renren.com/2017/10/31/await/

【本文是专栏作者“人人网FED”的原创稿件，转载请通过联系原作者获取授权】

戳这里，看该作者更多好文

当前文章：如何使用Await减少回调嵌套
文章路径：http://www.csdahua.cn/qtweb/news37/396637.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站策划知识

行业网站建设

网站建设推广　　 　成都App定制　　 　成都网站制作　　 　兴宏源活动板房　　 　东电技改　　 　成都网络推广　　 　温江做网站公司　　 　重庆企业网站建设　　 　仿古建筑设计　　 　免备案空间　　 　二枢服务器托管　　 　网站排名　　 　成都响应式网站建设　　 　广告吸塑字　　 　腾讯云香港空间　　 　成都联通服务器托管　　 　成都h5网站建设　　 　网站制作公司　　 　资阳服务器托管　　 　微信小程序开发