理解async

写在前面

本文将要实现一个顺序读取文件的最优方法，实现方式从最古老的回调方式到目前的async，也会与你们分享下本人对于thunk库与co库的理解。实现的效果：顺序读取出a.txt与b.txt，将读出的内容拼接成为一个字符串。

同步读取

const readTwoFile = () => {
    const f1 = fs.readFileSync('./a.txt'),
        f2 = fs.readFileSync('./b.txt');
    return Buffer.concat([f1, f2]).toString();
};

这种方式最利于咱们理解，代码也很清楚，没有过多的嵌套，很好的维护，可是这种有着最大的问题，那就是性能，node所倡导的就是异步i/o来处理密集i/o，而同步的读取，很大的程度上浪费着服务器的cpu，这种方式的弊端明显的大于好处，因此直接pass掉。（其实node的任何异步编程的解决方案的目标都是要达到同步的语义，异步的执行。）

利用回调读取

const readTwoFile = () => {
    let str = null;
    fs.readFile('./a.txt', (err, data) => {
        if (err) throw new Error(err);
        str = data;
        fs.readFile('./b.txt', (err, data) => {
            if (err) throw new Error(err);
            str = Buffer.concat([str, data]).toString();
        });
    });
};

利用回调的方式，实现起来很简单，直接的嵌套下去就好，可是这种状况下很容易形成的就是不易维护，难以读懂的状况，最为极致的状况的就是回调地狱。

Promise实现

const readFile = file => 
    new Promise((reslove, reject) => {
        fs.readFile(file, (err, data) => {
            if (err) reject(err);
            reslove(data);
        });
    });
const readTwoFile = () => {
    let bf = null;
    readFile('./a.txt')
        .then(
            data => {
                bf = data;
                return readFile('./b.txt');
            }, 
            err => { throw new Error(err) }
        )
        .then(
            data => {
                console.log(Buffer.concat([bf, data]).toString())
            }, 
            err => { throw new Error(err) }
        );
};

Promise能够将横向增加的回调转化为纵向增加，能解决一些问题，可是Promise形成的问题就是代码冗余，一眼看过去，所有是then，也不是很爽，可是相比于回调函数嵌套来讲，已经有了很大的提高。

yield

Generator不少语言中都有，本质上是协程，下面就来看一下协程，线程，进程的区别与联系：

• 进程：操做系统中分配资源的基本单位

• 线程：操做系统中调度资源的基本单位

• 协程：比线程更小的的执行单元，自带cpu上下文，一个协程一个栈

一个进程中可能存在多个线程，一个线程中可能存在多个协程，进程、线程的切换由操做系统控制，而协程的切换由程序员自身控制。异步i/o利用回调的方式来应对i/o密集，一样的使用协程也能够来应对，协程的切换并无很大的资源浪费，将一个i/o操做写成一个协程，这样进行i/o时能够吧cpu让给其余协程。
js一样支持协程，那就是yield。使用yield给咱们直观的感觉就是，执行到了这个地方停了下来，其余的代码继续跑，到你想让他继续执行了，他就是会继续执行。

function *readTwoFile() {
    const f1 = yield readFile('./a.txt');
    const f2 = yield readFile('./b.txt');  
    return Buffer.concat([f1, f2]).toString();
}

yield下的顺序读取呈现的也是一种顺序读取的方式，对于readFile来看有两种不一样的实现方式，

• 利用thunkify

const thunkify = (fn, ctx) => (...items) => (done) => {
    ctx = ctx || null;
    let called = false;
    items.push((...args) => {
        if (called) return void 0;
        called = true;
        done.apply(ctx, args);
    });
    try {
        fn.apply(ctx, items);    
    } catch(err) {
        done(err);
    }
};

thunkify函数就是一种柯里化得思想，最后的传入参数done就为回调函数，利用thunkify能够很轻松的实现yield函数的自动化流程：

const run = fn => {
    const gen = fn();
    let res;
    (function next(err, data) {
        let g = gen.next(data);
        if (g.done) return void 0;
        g.value(next);
    })();
};

• 利用Promise

const readFile = file => 
    new Promise((reslove, reject) => {
        fs.readFile(file, (err, data) => {
            if (err) reject(err);
            reslove(data);
        });
    });
const run = fn => {
    const gen = fn();
    let str = null;
    (function next(err, data) {
        let res = gen.next(data);
        if (res.done) return void 0;
        res.value.then(
            data => {
                next(null, data);
            }, 
            err => { throw new Error(err); }
        );
    })();
};
run(readTwoFile);

上面两种方式均可以达到自动执行yield的过程，那么有没有一种方式，能够兼容这两种实现方式呢，tj大神又给出了一个库，那就是co库，先来看下用法：

// readTwoFile的实现与上面相似,readFile既能够利用Promise也能够利用thunkify
// co库返回一个Promise对象
co(readTwoFile).then(data => console.log(data));

来看下co库的实现，co库默认会返回一个Promise对象，对于yield以后的值（如上面的res.value），co库会将其转换为一个Promise。实现思想很简单，基本仍是利用递归的方式，大致的思路以下：

const baseHandle = handle => res => {
    let ret;
    try {
        ret = gen[handle](res);
    } catch(e) {
        reject(e);
    }
    next(ret);
};
function co(gen) {
    const ctx = this,
        args = Array.prototype.slice.call(arguments, 1);
    return new Promise((reslove, reject) => {
        if (typeof gen === 'function') gen = gen.apply(ctx, args);
        if (!gen || typeof gen.next !== 'function') return resolve(gen);

        const onFulfilled = baseHandle('next'),
            onRejected = baseHandle('throw');

        onFulfilled();

        function next(ret) {
            if (ret.done) reslove(ret.value);
            // 将yield的返回值转换为Proimse
            const value = toPromise.call(ctx, ret.value);
            if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
            return onRejected(new TypeError('yield type error'));
        }
    });
}

toPromise就是将一些类型转换为Promise，从这里咱们能够看出的是能够将哪些类型放在yield后面，这里就来看一个经常使用的：

// 把thunkify以后的函数转化为Promise的形式
function thunkToPromise(fn) {
    const ctx = this;
    return new Promise(function (resolve, reject) {
        fn.call(ctx, function (err, res) {
            if (err) return reject(err);
            if (arguments.length > 2) res = slice.call(arguments, 1);
            resolve(res);
        });
    });
}

最近Node已经支持了async/await，能够利用其来作异步操做：

终极解决

const readFile = file => 
    new Promise((reslove, reject) => {
        fs.readFile(file, (err, data) => {
            if (err) reject(err);
            reslove(data);
        });
    });
const readTwoFile = async function() {
    const f1 = await readFile('./a.txt');
    const f2 = await readFile('./b.txt');    
    return Buffer.concat([f1, f2]).toString();
};
readTwoFile().then(data => {
    console.log(data);
});

async/await作的就是将Promise对象给串联起来，避免了then的调用方式，代码很是的易读，就是一种同步的方式。再也不须要借助其余外界类库（好比co库）就能够优雅的解决回调的问题。