理解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庫）就能夠優雅的解決回調的問題。