理解thunk函數(shù)的作用及co的實現(xiàn)

張巨偉發(fā)布于2019-08-21 18:36 / 2893人閱讀

摘要：從形式上將函數(shù)的執(zhí)行部分和回調(diào)部分分開，這樣我們就可以在一個地方執(zhí)行執(zhí)行函數(shù)，在另一個地方執(zhí)行回調(diào)函數(shù)。這樣做的價值就在于，在做異步操作的時候，我們只需要知道回調(diào)函數(shù)執(zhí)行的順序和嵌套關(guān)系，就能按順序取得執(zhí)行函數(shù)的結(jié)果。

thunk

thunk 從形式上將函數(shù)的執(zhí)行部分和回調(diào)部分分開，這樣我們就可以在一個地方執(zhí)行執(zhí)行函數(shù)，在另一個地方執(zhí)行回調(diào)函數(shù)。這樣做的價值就在于，在做異步操作的時候，我們只需要知道回調(diào)函數(shù)執(zhí)行的順序和嵌套關(guān)系，就能按順序取得執(zhí)行函數(shù)的結(jié)果。

以下是 thunk 的簡單實現(xiàn)：

function thunkify (fn) {
    return function () {
        var args = Array.prototype.slice(arguments);
        var ctx = this;

        return function (done) {
            var called = false;
            args.push(function() {
                if (called) return;
                called = true;
                done.apply(null, arguments);
            });
            try {
                fn.apply(ctx, args);
            } catch (err) {
                done(err);
            }
        }
    }
}

上面的實現(xiàn)將函數(shù)原有的執(zhí)行變?yōu)榘础皥?zhí)行部分”和“回調(diào)部分”分別執(zhí)行的方式：

fn(a, callback) => thunkify(fn)(a)(callback)

例如：

var fs = require("fs");
var readFile = thunkify(fs.readFile); // 將readFile函數(shù)包進thunkify，變?yōu)閠hunkify函數(shù)

//**這是執(zhí)行函數(shù)集合**//
var f1 = readFile("./a.js");
var f2 = readFile("./b.js");
var f3 = readFile("./c.js");

//**這是回調(diào)函數(shù)集合**//
//利用嵌套控制f1 f2執(zhí)行的順序
f1(function(err, data1) {
    // doSomething
    f2(function(err, data2) {
        // doSomething
        f3(function (err, data3) {
            // doSomething
        })
    })
})

而傳統(tǒng)的寫法為：

//傳統(tǒng)寫法
fs.readFile("./a.js", function(err, data1) {
    // doSomething
    fs.readFile("./b.js", function(err, data2) {
        // doSomething
        fs.readFile("./c.js", function(err, data3) {
            // doSomething
        })
    })
})

在執(zhí)行部分和回調(diào)部分分開之后，就可以使用generator等異步控制技術(shù)方便地進行流程控制，避免回調(diào)黑洞。上述的文件讀取流程就可以用generator進行改造：

var fs = require("fs");
var readFile = thunkify(fs.readFile);

//**函數(shù)的‘執(zhí)行部分’放在一起執(zhí)行**//
var gen = function* () {
    var data1 = yield readFile("./a.js");
    // 用戶獲取數(shù)據(jù)后自定義寫在這里
    console.log(data1.toString());
    
    var data2 = yield readFile("./b.js");
    // 用戶獲取數(shù)據(jù)后自定義寫在這里
    console.log(data2);
    ····
}

// 函數(shù)的‘回調(diào)部分’在另一個地方執(zhí)行，且調(diào)用的形式都一樣
var g = gen();
var d1 = g.next(); // 返回的結(jié)果為{value: func, done: boolean}

// 執(zhí)行value，實際為執(zhí)行`d1.value(callback)`
// 也即`thunkify(fs.readFile)("./a.js")(callback)`
d1.value(function(err, data) {
    if (err) throw err;
    // g.next(data) 可以將參數(shù)data傳回generator函數(shù)體，作為上一個階段異步任務(wù)的執(zhí)行結(jié)果
    // 例子中，data被傳回了gen函數(shù)體，作為data1的值
    var d2 = g.next(data);
    d2.value(function(err, data2) {
        if (err) throw err;
        g.next(data2);
    });
});

在上述的改造中發(fā)現(xiàn)，執(zhí)行回調(diào)部分的時候，依舊存在回調(diào)嵌套：d2.value在d1.value的回調(diào)中執(zhí)行。觀察后發(fā)現(xiàn)，其實在執(zhí)行回調(diào)的時候，也就是g在執(zhí)行next()的時候，執(zhí)行的形式基本相同，都是：

d.value(function(err, data) {
    if (err) throw err;
    g.next(data);
});

這種形式，所以可以通過編寫一個遞歸函數(shù)來整理流程。

function run(fn) {
    var g = fn();
    
    // 下一步控制函數(shù)，實際就是d.value的回調(diào)函數(shù)
    function next(err, data) {
        // 把前面一個數(shù)據(jù)給傳遞到gen()函數(shù)里面
        var result = g.next(data);
        // 判斷是否結(jié)束
        if (result.done) return;
        // 下一句執(zhí)行回調(diào)next的時候 不斷的遞歸
        result.value(next);
    }
    // 執(zhí)行第一步
    next();
}

// 使用
run(gen);

上面代碼中的過程很好理解，就是把gen放到一個遞歸器中去執(zhí)行，在這個遞歸器中有一個核心的函數(shù)next，這個函數(shù)就是遞歸函數(shù)。當(dāng)函數(shù)中的g.next(data)返回的done屬性值為true，就表示當(dāng)前生成器函數(shù)中的yield已經(jīng)執(zhí)行完畢，退出就OK。當(dāng)不為true，表示當(dāng)前生成器函數(shù)還有未執(zhí)行的yield，于是繼續(xù)調(diào)用next函數(shù)繼續(xù)執(zhí)行同樣的流程。

而上述的流程就是異步流控制庫co的簡單實現(xiàn)。