阮一峰老师：Thunk 函数的含义和用法

var x = 1;
function f(m){
  return m * 2;     
}
f(x + 5)

调用上面的函数：

//传值调用  js属于传值调用
f(x + 5)
// 传值调用时，等同于
f(6)
//传名调用
f(x + 5)
// 传名调用时，等同于
(x + 5) * 2

编译器的”传名调用”实现，往往是将参数放到一个临时函数之中，再将这个临时函数传入函数体。这个临时函数就叫做 Thunk 函数。

通过下面的例子加强理解：

//  正常readFile函数
fs.readFile(fileName, callback);
//  thunk函数处理后的readFile
var readFileThunk = Thunk(fileName);   //  将参数放到一个临时函数。这个readFileThunk就是thunk函数
readFileThunk(callback);    //  只接受回调作为参数
var Thunk = function (fileName){
  return function (callback){
    return fs.readFile(fileName, callback); 
  };
};

理解下上面的thunk转化：
1、传统的readFile函数由一个多参数的函数 => 一个单参函数，只接受回调作为参数。thunk函数其实是柯里化的一个表现。
2、从表现形式上看，其实就是把一个带有回调的传统函数的执行参数和回调分成两个函数。因此只要有回调，就可以用thunk转换

在 JavaScript 语言中，Thunk 函数替换的不是表达式，而是多参数函数，将其替换成单参数的版本，且只接受回调函数作为参数。个单参数版本，就叫做 Thunk 函数。

任何函数，只要参数有回调函数，就能写成 Thunk 函数的形式。下面是一个简单的 Thunk 函数转换器。

var Thunk = function(fn){
  return function (){
    var args = Array.prototype.slice.call(arguments);  // 缓存除回调以外的其他参数
    return function (callback){ // 返回的这个函数就是thunk函数
      args.push(callback);     //把其他参数跟回调再合并
      return fn.apply(this, args);  // 传入合并后的参数，函数真正调用的时候
    }
  };
};

使用上面的转换器，生成 fs.readFile 的 Thunk 函数。这里面其实是柯里化的思想。

var readFileThunk = Thunk(fs.readFile);
readFileThunk(fileA)(callback);  // 连续两次调用

thunkify模块

var thunkify = require('thunkify');
var fs = require('fs');
var read = thunkify(fs.readFile);
read('package.json')(function(err, str){
  // ...
});

Thunkify源码：

function thunkify(fn){
  return function(){
    var args = new Array(arguments.length);
    var ctx = this;
    for(var i = 0; i < args.length; ++i) {
      args[i] = arguments[i];
    }
    return function(done){
      var called;
      args.push(function(){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      });
      try {
        fn.apply(ctx, args);
      } catch (err) {
        done(err);
      }
    }
  }
};

它的源码主要多了一个检查机制，变量 called 确保回调函数只运行一次。这样的设计与下文的 Generator 函数相关。请看下面的例子。

function f(a, b, callback){
  var sum = a + b;
  callback(sum);
  callback(sum);
}
var ft = thunkify(f);
ft(1, 2)(console.log); 
// 3 只输出一次

thunk与generator结合：

generator函数封装异步读取文件：

var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);
var gen = function* (){
  var r1 = yield readFile('/etc/fstab');  // 这里的readFile执行后，返回的是一个thunk函数，只接受回调函数作为参数
  console.log(r1.toString());
  var r2 = yield readFile('/etc/shells');
  console.log(r2.toString());
};

手动执行上面的函数：

var it = gen();
var r1 = it.next();
r1.value(function(err, data){  // r1.value 就是第一个readFile执行后返回的一个thunk函数，只接受回调函数作为参数
  if (err) throw err;
  var r2 = it.next(data);  // 执行下一个yield。it.next的参数会被当作上一个yield表达式的返回值。否则上面的r1将是undefined
  r2.value(function(err, data){
    if (err) throw err;
    it.next(data);  // 这个data的值会赋给r2
  });
});

仔细查看上面的代码，可以发现 Generator 函数的执行过程，其实是将同一个回调函数，反复传入 next 方法的 value 属性。这使得我们可以用递归来自动完成这个过程。那如何使用递归实现呢？

Thunk函数自动流程管理

Thunk 函数真正的威力，在于可以自动执行 Generator 函数。下面就是一个基于 Thunk 函数的 Generator 执行器。

function run(gen) {
  var it = gen();
  function next(err, data) {
    var result = it.next(data);
    if (result.done) return;
    result.value(next);  //  result.value就是thunk函数
  }
  next();
}
run(gen);

上面代码的 run 函数，就是一个 Generator 函数的自动执行器。内部的 next 函数就是 Thunk 的回调函数。 next 函数先将指针移到 Generator 函数的下一步（gen.next 方法），然后判断 Generator 函数是否结束（result.done 属性），如果没结束，就将 next 函数再传入 Thunk 函数（result.value 属性），否则就直接退出。

有了这个执行器，执行 Generator 函数方便多了。不管有多少个异步操作，直接传入 run 函数即可。当然，前提是每一个异步操作，都要是 Thunk 函数，也就是说，跟在 yield 命令后面的必须是 Thunk 函数。redux-saga的实现原理貌似就是基于这个run逻辑来实现的？ 这里面都有柯里化的思想。多个参数的函数转成单个参数的函数。

原文地址：http://www.ruanyifeng.com/blog/2015/05/thunk.html