异步的“坑”

最近一段时间参与开发了一个Node.js后台项目，作为一个PHP开发者，上手项目本身并不难，但是开发的过程却并不顺利，不顺利的主要原因在于思路上没有转变，没有从同步的思维转换到异步的思维。

所谓同步，就是程序（进程/线程）在一个任务的处理过程中，不会插入处理其他任务，即使遇到IO等不占CPU的操作，也会一直等待其结束才会继续往下处理。

所谓异步，就是程序（进程/线程）在一个任务的处理过程中，会插入处理其他任务，如遇到IO操作，当前任务会将程序（进程/线程）的控制权释放给其他任务，等IO操作结果返回后再继续往下处理。

简单地讲，同步不会释放控制权，异步会释放控制权。

众所周知，Node.js采用的是单线程的异步模型，在具体代码的写法上自然和PHP等同步模型不一样。在具体项目开发的过程中，各种异步操作相关的关键字层出不穷，如：.then()、function* ... yield、async...await等等。为了写一个类似同步的操作，比如：“在执行完A步骤拿到结果之后再执行B步骤”这么一个简单的需求，却要经过大量的反复调试验证才能解决。究其原因，就是对于这些异步操作的场景和关键字的含义理解不到位，异步操作所提供的选择太多了。

下面就结合代码实例，理一理这些异步操作方案究竟怎么使用。

异步的各种写法

任务说明：项目根目录下有三个文件Jay.txt、Angela.txt、Henry.txt，依次读取这三个文件的内容并打印。

下面使用各种异步处理的方法来完成此任务。

回调函数

const fs = require('fs');

fs.readFile('Jay.txt', 'utf8', function (err, data) {
    if (err) throw err;
    console.log(data);
    fs.readFile('Angela.txt', 'utf8', function (err, data) {
        if (err) throw err;
        console.log(data);
        fs.readFile('Henry.txt', 'utf8', function (err, data) {
            if (err) throw err;
            console.log(data);
        });
    });
});

console.log("finish");

1、函数
fs.readFile() 用于异步读取文件的所有内容，该函数本身没有返回值。读取的文件内容异步返回后通过回调函数处理。

2、函数
fs.readFile()的第二个参数是可选参数，如果指定了编码方式，则返回对应编码方式的字符串；如果没有指定，则返回文件的二进制内容，对应类型为Buffer，可以通过
buf.toString() 方法转换成对应的字符串。

3、回调函数的第一个参数必须是
错误对象，如果没有错误则错误对象的值为
null。

执行程序：

$ node 0A_callback_01.js
finish
Hello, I'm Jay.
Hello, I'm Angela.
Hello, I'm Henry.

程序最先返回finish，是因为函数fs.readFile()是异步处理的，在调用后会直接继续往下处理，在文件内容返回后通过注册的回调函数处理。

串行和并行

通常，人们总是分不清同步、异步、串行、并行之前的区别，朴素地认为：同步就是串行，异步就是并行。这么讲似乎对又似乎不对。

同步和异步是从程序（进程/线程）执行方式的角度来看的，文章开头已经简单讲过同步和异步的概念和区别。如果在程序的执行的过程中不发生任务切换，即：做当前任务的一件事情，等待这件事情完成后，再做当前任务的下一件事情，直到当前任务完成，这种方式就是同步。如果在程序的执行的过程中发生任务切换，即：做当前任务的一件事情，不等待这件事情做完，直接转去做其他任务，再做当前任务的下一件事情，如此往复，直到当前任务完成，这种方式就是异步。

串行和并行是从任务（事情）的角度来看的，如果多个任务（事情）不能同时做，而是做完一个才能做下一个，则就将这几个任务（事情）称作是串行的。如果多个任务（事情）可以同时做，则就将这几个任务（事情）称作是并行的。

同步就是串行这句话在一定程度上是正确的，因为同步程序做完一件事情，才会做下一件事情，从两件事情上看，是不会同时做的，所以同步程序只能串行地做事情。

异步就是并行这句话就不是那么回事了，异步程序可以选择串行地做事情，也可以选择并行地做事情，是串行做还是并行做取决于具体的业务场景。对于一个任务下的两件事情A和B，如果B依赖于A的结果，则需要串行；如果B不依赖于A的结果，则可以并行。还是以本文的读取三个文件为例，上面的代码示例就是串行执行的，依次读取"Jay.txt"、"Angela.txt"、"Henry.txt"的内容并打印出来。如果要改成并行执行该怎么做呢？简单做个改造就行，如下。

const fs = require('fs');

fs.readFile('Jay.txt', 'utf8', function (err, data) {
    if (err) throw err;
    console.log(data);
});

fs.readFile('Angela.txt', 'utf8', function (err, data) {
        if (err) throw err;
        console.log(data);
});

fs.readFile('Henry.txt', 'utf8', function (err, data) {
    if (err) throw err;
    console.log(data);
});

console.log("finish");

执行程序：

finish
Hello, I'm Angela.
Hello, I'm Jay.
Hello, I'm Henry.

从结果也可以看出，由于三个文件是并行读取的，所以哪个先读完是
随机的，和代码写的顺序无关。
按顺序写的代码就会按顺序执行，这是典型的
同步编程思维，要尽快转变过来，否则早晚有一天会“翻车”的。

Promise对象

Promise对象能够表示一个异步操作的状态和结果，使用其提供的.then()方法可以将多个多个异步操作“串联”起来，.then()方法本身也返回一个Promise对象。

同样是按顺序读取三个文件的任务，示例如下：

var readFilePromise = require('fs-readfile-promise');

readFilePromise('Jay.txt', 'utf8')
    .then(function(data) {
        console.log(data);
    })
    .then(function() {
        return readFilePromise('Angela.txt', 'utf8');
    })
    .then(function(data) {
        console.log(data);
    })
    .then(function() {
        return readFilePromise('Henry.txt', 'utf8');
    })
    .then(function(data) {
        console.log(data);
    })
    .catch(function(err) {
        console.log(err);
    });

console.log("finish");

执行程序：

$ node 0B_promise_01.js
finish
Hello, I'm Jay.
Hello, I'm Angela.
Hello, I'm Henry.

Promise对象有pending（初始）、fulfilled（成功）、rejected（失败）三种状态。当异步操作成功时，Promise对象从pending状态变为fulfilled状态，并将成功结果传递给.then()方法的第一个参数（也叫onfulfilled函数）；当异步操作失败时，Promise对象从pending状态变为rejected状态，并将失败信息传递给.then()方法的第二个参数（也叫onrejected函数），如果没有指定第二个参数，则将失败信息传递给.catch()方法的参数（同样也叫onrejected函数）。

上面的程序，可以将上个文件的处理和下个文件的读取合并到一个.then()当中，示例如下：

var readFilePromise = require('fs-readfile-promise');

readFilePromise('Jay.txt', 'utf8')
    .then(function(data) {
        console.log(data);
        return readFilePromise('Angela.txt', 'utf8');
    })
    .then(function(data) {
        console.log(data);
        return readFilePromise('Henry.txt', 'utf8');
    })
    .then(function(data) {
        console.log(data);
    })
    .catch(function(err) {
        console.log(err);
    });

console.log("finish");

.then()当中，可以返回一个Promise对象，可以返回一个基础类型的值（数字、字符串、布尔值），也可以什么都不返回（直接
return;），甚至连
return语句都可以省略。这几种场景下的处理方式参考：
.then()方法的
返回值说明。

Generator函数

Generator函数（生成器函数）使用 function* 关键字定义，函数中使用yield关键字进行流程控制，yield后面可以跟任何表达式（普通同步表达式、Promise对象、Generator函数）。需要特别注意的是，yield关键字必须放在Generator函数当中，否则运行时会报错！

Generator函数的返回值叫做 Generator对象（生成器对象），Generator对象有一个 .next() 方法，每执行一次.next()方法，就会迭代执行至Generator函数的下一个yield语句位置，并返回一个对象。该对象包含两个属性：value和done，value存储了yield后面表达式的值；done是一个布尔值，表示Generator函数是否执行完毕。

同样是按顺序读取三个文件的任务，示例如下：

var readFilePromise = require('fs-readfile-promise');

function* generator() {
    yield readFilePromise('Jay.txt', 'utf8');
    yield readFilePromise('Angela.txt', 'utf8');
    yield readFilePromise('Henry.txt', 'utf8');
}

let gen = generator();

gen.next().value.then(function(data) {
    console.log(data);
    gen.next().value.then(function(data) {
        console.log(data);
        gen.next().value.then(function(data) {
            console.log(data);
            gen.next();  // 返回：{ value: undefined, done: true }，表示生成器函数执行结束
        });
    });
});

console.log("finish");

执行程序：

$ node 0C_generator_01.js
finish
Hello, I'm Jay.
Hello, I'm Angela.
Hello, I'm Henry.

本例中，generator()是一个生成器函数，其返回值gen是一个生成器对象。gen.next()返回的对象结构如下。

{ value: Promise { <pending> }, done: false }

其中，gen.next().value是一个Promise，表示yield后面的readFilePromise()函数所返回的是一个Promise对象。

需要注意的是，生成器函数本身包含的各个异步操作并不能按照顺序串行执行，想要实现串行执行的话，还是需要配合Promise对象及其.then()函数来实现，如本例所示。

co函数库

co函数库是干什么的？co函数库是Generator函数的一种执行器。简单来讲，co函数库用来将上一节中手动执行Generator函数的过程自动化，这样一来，就使得采用同步思维写异步代码的想法成为现实。作为曾经是完全同步思维的程序员终于看到了曙光。

同样是按顺序读取三个文件的任务，示例如下：

var co = require('co');
var readFilePromise = require('fs-readfile-promise');

// generator()是一个生成器函数
function* generator() {
    let data = yield readFilePromise('Jay.txt', 'utf8');
    console.log(data);

    data = yield readFilePromise('Angela.txt', 'utf8');
    console.log(data);

    data = yield readFilePromise('Henry.txt', 'utf8');
    console.log(data);
}

let gen = generator();  // gen是一个生成器对象
co(generator()).then(function() {
    console.log('Generator function is finished!');
});

console.log("finish");

执行程序：

$ node 0D_co_01.js
finish
Hello, I'm Jay.
Hello, I'm Angela.
Hello, I'm Henry.
Generator function is finished!

当然，用好
co的前提是有一些注意事项需要知道的：

1、
co函数配套使用的
Generator函数中，
yield后面的异步操作需要返回一个Promise对象，否则就无法实现期望的
同步效果；

2、
co函数本身会返回一个Promise对象，所以如本例所示，是可以在其后使用
.then()方法增加回调函数的。

async函数

co库函数已经将Generator函数的执行简化了很多，还能更简单一点吗？答案是：有，那就是async函数。

async函数与Generator函数相比，可以简单地理解为：将Generator函数中的*改为async，将yield改为await，就成了async函数。

async函数与Generator函数相比：

• async函数本身内置了执行器，无需再像Generator函数一样需要引入额外的执行器（如：co执行器）；
• async...await与function*...yield相比，语义更加清晰明了：async表示函数中有异步操作，await表示需要等待异步操作返回结果；
• await后面除了可以跟Promise对象之外，也可以跟基础类型的值，如：数字、字符串、布尔值，而yield后面必须要跟Promise对象；
• async函数的返回值也是

同样是按顺序读取三个文件的任务，示例如下：

var readFilePromise = require('fs-readfile-promise');

async function asyncReadFile() {
    let data = await readFilePromise('Jay.txt', 'utf8');
    console.log(data);

    data = await readFilePromise('Angela.txt', 'utf8');
    console.log(data);

    data = await readFilePromise('Henry.txt', 'utf8');
    console.log(data);

    return "Async function is finished!"
}

asyncReadFile().then(function(data) {
    console.log(data);
});

console.log("finish");

执行程序：

$ node 0E_async_await_01.js
finish
Hello, I'm Jay.
Hello, I'm Angela.
Hello, I'm Henry.
Async function is finished!

从本例可以看出，除了
async和
await这两个关键字之外，整体代码的格式与函数调用方式和同步代码完全一样。由此可见，
异步代码写法的终极目标就是
让异步代码写起来和同步代码一样简单方便。然而，悲催的是，作为一个JS新人需要花好久才能把这些逐渐弄清楚，学习成本不可谓不高。