node.js 7 async / await

写文章详情页面的时候的一个场景：首先更改文章详情中的 PV，然后读取文章详情，然后根据文章详情中文章 Id 查阅该文章评论和该文章作者信息。

获取全部数据之后渲染文章详情页。数据库操作都是异步的，最直接想到的办法就是一层一层的回调函数，

问题出来了：十分不雅观，要是层再多一点还会有更多麻烦。怎么解决？

nodejs 7.6已经默认支持ES7中的 async/await 了，

Ascny/Await关键词必须配合使用,await等待promise执行完成

Async/await的主要益处是可以避免回调地狱（callback hell）问题。

Promise 异常必须处理 try ... catch()

1. 基本概念：

• async 表示这是一个async函数，await只能用在这个函数里面。
• await 表示在这里等待promise返回结果了，再继续执行。
• await 后面跟着的应该是一个promise对象（当然，其他返回值也没关系，不过那样就没有意义了…）

var sleep = function (time) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            // 返回 ‘ok’
            resolve('ok');
        }, time);
    })
};
var start = async function () {
    let result = await sleep(3000);
    console.log(result); // 收到 ‘ok’
};

 

var sleep = function (time) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            // 模拟出错了，返回 ‘error’
            reject('error');
        }, time);
    })
};
var start = async function () {
    try {
        console.log('start');
        await sleep(3000); // 这里得到了一个返回错误
        
        // 所以以下代码不会被执行了
        console.log('end');
    } catch (err) {
        console.log(err); // 这里捕捉到错误 `error`
    }
};

var start = async function () {
    for (var i = 1; i <= 10; i++) {
        console.log(`当前是第${i}次等待..`);
        await sleep(1000);
    }
};

再循环中使用不需要闭包，每次循环会被阻塞。

var showArticle = async function () {

        await new Promise(function (resolve, reject) {

            PostModel.incPv(postId, function (result) {

                resolve(result);

            });

        });// pv 加 1

        var post = await new Promise(function (resolve, reject) {

            PostModel.getPostById(postId, function (article) {

                resolve(article);

            });

        });// 获取文章信息

        await new Promise(function (resolve, reject) {

            userModel.getUserById(post.author,function (author) {

                post.author=author;

                resolve();

            })

        });//获取文章作者

        var comments = await new Promise(function (resolve, reject) {

            CommentModel.getComments(post._id, function (comment) {

                resolve(comment);

            });

        });// 获取该文章所有留言

        for(var i=0;i<comments.length;i++){

            await new Promise(function (resolve, reject) {

                userModel.getUserById(comments[i].author,function (author) {

                    comments[i].author=author;

                    resolve();

                })

            });//获取文章留言作者

        }

        if (!post) {

            req.session.error = '该文章不存在';

            return res.redirect('/post');

        }

        res.render('post',{post: post, comments: comments});

    };

 

    showArticle();

Async/Await

Ascny/Await关键词必须配合使用,await等待promise执行完成,这有点像ES2016的promise和generator的解决方案,yield promise后再传回generator

class Demo {  
  async greeting() {
    let  h = await this.world();
    console.log(h); //hello world
  }
  world() {
    return Promise.resolve('hello world');
  }
}

除此之外async总是返回promise,在async的返回值作为promise的resolve方法的参数返回,比如在下面的示例中

async function asyncFun () {  
  var value = await Promise
    .resolve(1)
    .then(x => x * 3)
    .then(x => x + 5)
    .then(x => x / 2);
  return value;
}
asyncFun().then(x => console.log(`x: ${x}`));  
// <- 'x: 4'

因此也可以再次在async方法中await之前的async方法

async function combination() {  
    let value = await  new Demo().greeting();
    console.log(value);

}
combination();  

并行的异步任务

在异步的编程中,同时执行多个任务是常见的事情,在promise中可以使用promise.all同时执行多个异步任务,在async函数中也可以使用Promise.all

async function tasks () {  
  let  [v1, v2] = await Promise.all([Promise.resolve(1), Promise.resolve(2)]);
  console.log(v1,v2);
}

//或者
const all = Promise.all.bind(Promise);  
async function tasks () {  
  let  [v1, v2] = await all([Promise.resolve(1), Promise.resolve(2)]);
  console.log(v1,v2);
}

在某些时候,你可以使用await*替代promise.all

async function tasks () {  
  let  [v1, v2] = await* [Promise.resolve(1), Promise.resolve(2)];
  console.log(v1,v2);
}

错误处理

异步错误是不会被 try/catch捕获的,且在Node.js7之后一定处理promise的错误

async function read () {  
    return await  new Promise((resolve, reject) => {
        request('http://www.myfreax.com/', (err, res, body) => {
            if (err) {
                reject(err); return;
            }
            resolve(body);
        });
    }).catch(error =>{
        throw new Error(error.stack);
    });

}