Async/Await 函数的特点

• 更好的语义，相比较Generator 对象的yield， Async/Await 更好理解。
• 更简洁，相比较Promise 对象then 函数的嵌套，与 Generator 执行的繁琐， Async/Await 在实现non-block 时更加简洁。

如下面的demo，

const fs = require('fs');
const path = require('path');
const fpath1 = path.join(__dirname, './test1.txt');
const fpath2 = path.join(__dirname, './test2.txt');

function readFile(fPath) {
    return new Promise(function (resolve, reject) {
        fs.readFile(fPath, function(err, data) {
            if (err) reject(err);
            else resolve(data);
        });
    });
}

function writeFile(fPath, content) {
    return new Promise(function(resolve, reject) {
        fs.writeFile(fPath, content, function(err, data) {
            if (err) reject(err);
            else resolve("Successed");
        });
    });
}

/**
 * async/await non-block
 */
async function manipulateFile() {
    var content1 = await readFile(fpath1);
    var content2 = await writeFile(fpath2, content1);
    console.log(`${content2}`);
}

manipulateFile();

Async/Await 的语法

• async 函数的返回值是Promise 对象

const fs= require('fs');
const path = require('path');
const fpath = path.join(__dirname, "./test1.txt");
function readFile(fpath) {
    return new Promise(function(resolve, reject) {
        fs.readFile(fpath, function(error, result) {
            if (error) reject(error);
            else resolve(result);
        });
    });
}

async function getContent(fpath) {
    return await readFile(fpath); 
}

var result = getContent(fpath);
console.log(`${typeof result === 'object'}`);  // true
console.log(`${typeof result.then === 'function'}`);  // true

• 内置自动执行器， 相较于Generator 对象要借助co，thunk 开源库才能实现auto perform，Async/Await 自带执行器。也就是说，async函数的执行，与普通函数一模一样，只要一行

• ** async 对象返回Promise 对象的状态，必要要等async 函数体内部所有的await 执行**

• await 命令后面是Promise 对象，如果不是会被转化为Promise对象

async function f() {
  return await 123;  // return Promise.resolve(123)
}

f().then(v => console.log(v))  // 123

处理await 函数时的注意事项

• async 函数内部有多个await，按顺序执行，如果前面的出现exception， 后面就不会被执行

async function getName() {
    await Promise.reject('rejected due to error.');
    return await Promise.resolve('Spursy');  // 这一步不会被执行
}

getName().then(result => {
    console.log(`${result}`);
}).catch(err => {
    console.log(`${err}`);
})

• await命令后面的Promise对象，运行结果可能是rejected，最好对rejected的结果进行处理

/**
 * catch exception.
 */
async function getNameOne() {
    await Promise.reject('Rejected due to error.').catch(error => console.log(`${error}`)); // catch error message.
    return await Promise.resolve('Spursy');
}

getNameOne().then(
    (result) => {
        console.log(`${result}`);
    }
).catch(
    (error) => {
        console.error('${error}');
    }
);

• 多个await命令后面的异步操作，如果不存在继发关系，最好让它们同时触发

// 写法一
let [foo, bar] = await Promise.all([getFoo(), getBar()]);

// 写法二
let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise;
let bar = await barPromise;

// 写法三
async function dbFuc(db) {
  let docs = [{}, {}, {}];
  let promises = docs.map((doc) => db.post(doc));

  let results = [];
  for (let promise of promises) {
    results.push(await promise);
  }
  console.log(results);
}