JavaScript异步Async

1 Sep

ES7的async函数就是Generator函数的语法糖,使得异步操作的流程更加清晰。本篇参照了阮一峰的《ES6标准入门》的async篇幅里的大量内容,这是一本不可多得的好书,建议大家购买学习。你可以从Github上获取本篇例子代码。

仍旧以读取本地文件内容为例,用Generator函数定义依次读取两个文件的异步操作:

var fs = require('fs');

var readFile = function (fileName, options) {
    return new Promise(function (resolve, reject){
        fs.readFile(fileName, options, function(error, data){
            if (error) return reject(error);
            resolve(data);
        });
    });
};

var gen = function* () {
    var f1 = yield readFile('./apples.txt', 'utf8');
    console.log(f1);
    var f2 = yield readFile('./oranges.txt', 'utf8');
    console.log(f2);
};

var g = gen();
g.next().value.then(function(data) {
    g.next(data).value.then(function(data) {
        g.next(data);
    });
});

写成async函数,就是下面这样:

var asyncReadFile = async function (){
    var f1 = await readFile('./apples.txt', 'utf8');
    var f2 = await readFile('./oranges.txt', 'utf8');
    console.log(f1);
    console.log(f2);
};

asyncReadFile();

先看async函数的定义,和Generator相比语法上来说,将*星号改成了关键字async。将yield改成了await。这主要是为了让其语义上更可读一点。熟悉C++的程序员,看到*星号容易想到函数指针,用关键字async不容易有歧义。另外熟悉Java的程序员,看到yield容易想到暂停线程,用await表示等待异步执行的结果,结合async自动执行的特性,显然await的语义更加贴切。

再看运行,相比Generator一步步next,async的运行可方便多了,上面一行代码搞定。因为async 函数本质上就是将 Generator 函数和自动执行器,包装在一个spawn函数里:

async function fn(args){... }

// 等同于
function fn(args){
    return spawn(function*() { ... });
}

所有的async函数都可以写成上面的第二种形式,其中的spawn函数就是自动执行器。实现如下,基本就是co模块的翻版:

function spawn(genF) {
    return new Promise(function(resolve, reject) {
        var gen = genF();
        function step(nextF) {
            try {
                var next = nextF();
            } catch(e) {
                return reject(e);
            }
            if(next.done) {return resolve(next.value); }
            Promise.resolve(next.value).then(function(v) {
                step(function() { return gen.next(v); });
            }, function(e) {
                step(function() { return gen.throw(e); });
            });
        }
        step(function() { return gen.next(undefined); });
    });
}

自动执行的内容在Generator里有详细介绍。就算不理解也没关系,不影响使用async。

async函数的await命令后面是Promise对象(如果是原始类型的值,会自动将其转成Promise对象并立即将状态设成Resolved,效果等于同步操作)。进一步说,async函数完全可以看作多个异步操作,包装成的一个Promise对象,而await命令就是内部then命令的语法糖。因为await命令后面是Promise对象,需要考虑rejected的情况,毕竟谁也不能断言异步操作中不会出现异常,所以最好把await命令包进try…catch中:

async function myAsyncFun() {
    try {
        await somePromise();
    } catch (err) {
        console.log(err);
    }
}

//另一种写法
async function myAsyncFun() {
    await somePromise().catch(function (err) {console.log(err);});
}

为了提高效率,async函数的await命令间如果不存在依赖关系,即,后一个异步操作不依赖于前一个异步操作的结果的话,可以让这些异步操作并发执行。怎么并发呢?依次写await命令不会并发执行,而是依次执行。要并发可以依赖于await命令后是一个Promise对象的事实,用Promise.all来包装一下,例如:

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

上面这样getFoo和getBar会同时触发执行,可以缩短程序的执行时间。

async函数的返回值是一个Promise对象,这比Generator函数的返回值是Iterator对象方便多了。你可以为其添加then方法:

var f = async function () {
    return 'hello world';
}
f().then(v => console.log(v))   // "hello world"

需要注意的是,async函数返回的Promise对象,必须等到内部所有await命令的Promise对象执行完,才会发生状态改变。即async函数内部的异步操作执行完,才会执行返回值的then方法。例如:

var asyncReadFile = async function (){
    var f1 = await readFile('./apples.txt', 'utf8');
    var f2 = await readFile('./oranges.txt', 'utf8');
    var arr = new Array();
    arr.push(f1);
    arr.push(f2);
    return arr;
};

asyncReadFile().then(function(value) {
    value.forEach(function(v){
        console.log(v);
    });
});

上例中等两个异步操作读取完文件内容后,才触发then回调函数。

只要一个await语句后面的Promise变为Rejected状态,那么整个async函数都会中断执行:

var f = async function () {
    await Promise.reject('出错了');
    return await Promise.resolve('成功了');   // 不会被执行
};

f().then(v => console.log(v))
   .catch(e => console.log(e));     //出错了

如果不想一个异步操作出错导致整个async函数中断,可以将await包在try…catch里,这样后续的await就继续被执行:

var f = async function () {
    try {
        await Promise.reject('出错了');
    } catch(e) {
        return await Promise.resolve('成功了');
    }
};

f().then(v => console.log(v))
    .catch(e => console.log(e));     //成功了

另一种方法是await后面的Promise对象再跟一个catch来处理可能出现的异常:

var f = async function () {
    await Promise.reject('出错了').catch(e => console.log(e));
    return await Promise.resolve('成功了');
};

f().then(v => console.log(v))
    .catch(e => console.log(e));
//出错了
//成功了

最后,参照阮一峰《ES6标准入门》的一个例子(几乎照扒原书,请大家支持该书)。来看Async函数与Promise,Generator函数的区别。假定某个DOM元素上面,部署了一系列的动画,前一个动画结束,才能开始后一个。如果当中有一个动画出错,就不再往下执行,返回上一个成功执行的动画的返回值。

首先是Promise的写法。

function chainAnimationsPromise(elem, animations) {
    var ret = null;		    // 变量ret用来保存上一个动画的返回值
    var p = Promise.resolve();	    // 新建一个空的Promise
    for(var anim of animations) {   // 使用then方法,添加所有动画
        p = p.then(function(val) {
            ret = val;
            return anim(elem);
        });
    }
    return p.catch(function(e) {    // 返回一个部署了错误捕捉机制的Promise
        /* 忽略错误,继续执行 */
    }).then(function() {
        return ret;
    });
}

虽然Promise的写法比回调函数的写法大大改进,但是一眼看上去,代码完全都是Promise的API(then、catch等等),操作本身的语义反而不容易看出来。接着是Generator函数的写法:

function chainAnimationsGenerator(elem, animations) {
    return spawn(function*() {
        var ret = null;
        try {
            for(var anim of animations) {
                ret = yield anim(elem);
            }
        } catch(e) {
            /* 忽略错误,继续执行 */
        }
        return ret;
    });
}

上面代码使用Generator函数遍历了每个动画,语义比Promise写法更清晰,用户定义的操作全部都出现在spawn函数的内部。这个写法的问题在于,必须有一个任务运行器,自动执行Generator函数,上面代码的spawn函数就是自动执行器,它返回一个Promise对象,而且必须保证yield语句后面的表达式,必须返回一个Promise。最后是Async函数的写法:

async function chainAnimationsAsync(elem, animations) {
    var ret = null;
    try {
        for(var anim of animations) {
            ret = await anim(elem);
        }
    } catch(e) {
        /* 忽略错误,继续执行 */
    }
    return ret;
}

可以看到Async函数的实现最简洁,最符合语义,几乎没有语义不相关的代码。它将Generator写法中的自动执行器,改在语言层面提供,不暴露给用户,因此代码量最少。如果使用Generator写法,自动执行器需要用户自己提供。

Leave a Reply

Your email address will not be published. Required fields are marked *