Thunk函数
求值策略
var x = 1;
function f(m){
return m * 2;
}
f(x + 5)
传值调用:
f(x + 5)
// 传值调用时，等同于
f(6)
先把参数的值算出来，然后传到函数中。
传名调用：
f(x + 5)
// 传名调用时，等同于
(x + 5) * 2
直接把 x+5 传进去 然后在函数被调用的时候计算值
传值调用和传名调用，哪一种比较好？回答是各有利弊。传值调用比较简单，但是对参数求值的时候，实际上还没用到这个参数，有可能造成性能损失。
function f(a, b){
return b;
}
f(3 * x * x - 2 * x - 1, x);
上面代码中f 传入了一个很复杂的参数 但是在函数中根本没用到，如果我们先计算在传入，那么就是在浪费性能。
Thunk 函数的含义
把一个参数放入到一个临时函数中，然后把这个函数当作参数传入到另一个函数中，这个临时函数就叫做Thunk函数。
function f(m){
return m * 2;
}
f(x + 5);
// 等同于
var thunk = function () {
return x + 5;
};
function f(thunk){
return thunk() * 2;
}
上面代码把 x+5 放入到临时函数中，然后传入到f中。
js中使用Thunk函数
在 JavaScript 语言中，Thunk 函数替换的不是表达式，而是多参数函数，将其替换成单参数的版本，且只接受回调函数作为参数。
// 正常版本的readFile（多参数版本）
fs.readFile(fileName, callback);
// Thunk版本的readFile（单参数版本）
var readFileThunk = Thunk(fileName);
readFileThunk(callback);
var Thunk = function (fileName){
return function (callback){
return fs.readFile(fileName, callback);
};
};
上面函数就相当于柯里化， 先固定一个非回调函数的参数，返回一个函数，这个函数接受剩下的那个回调函数作为参数。
一个简单的Thunk函数转换器
var Thunk = function(fn){
return function (){
var args = Array.prototype.slice.call(arguments);//获取第一次传入的参数（下面的fileA），组成数组。
return function (callback){ //第一次传入参数后会返回一个函数 这个函数接受一个回调作为参数
args.push(callback); //把回调也放入数组中
return fn.apply(this, args); //把这个数组用apply的调用方式传入最开始的函数中
}
};
};
var readFileThunk = Thunk(fs.readFile);
readFileThunk(fileA)(callback);
Thunkify 模块
安装：
$ npm install 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; //调用第一次后 called 变为true 无法调用第二次
done.apply(null, arguments); //这段代码等于 console.log.apply(null,arguments) arguments 是一个数组 就是sum的值
});
try {
fn.apply(ctx, args);
} catch (err) {
done(err);
}
}
}
};
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 函数的自动流程管理
var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile); //得到一个Thunk函数
var gen = function* (){
var r1 = yield readFile('/etc/fstab'); //先传入第一个非回调参数 ，其返回值是一个函数 并且这个函数接受一个回调作为参数
console.log(r1.toString());
var r2 = yield readFile('/etc/shells');
console.log(r2.toString());
};
var g = gen();
//变量 g 是 Generator 函数的内部指针，表示目前执行到哪一步。next 方法负责将指针移动到下一步，并返回该步的信息（value 属性和 done 属性）。
var r1 = g.next(); // 运行到r1 部分
r1.value(function(err, data){ //r1.value 返回的就是一个函数 接受一个回调作为参数
if (err) throw err;
var r2 = g.next(data);//data就是上一阶段异步操作的返回结果传入到 r2中
r2.value(function(err, data){ //r2 部分同样接受到回调函数 并且 把接受到的数据传入到下一个next中
if (err) throw err;
g.next(data); //传入数据 函数最后阶段结束
});
});
Thunk 函数真正的威力，在于可以自动执行 Generator 函数。
function run(fn) {
var gen = fn();
function next(err, data) {
var result = gen.next(data); //第一次data没有参数，且done为false
if (result.done) return; //done为false 时候继续下面的代码
result.value(next); //那next当作回调传入到 f1 的返回函数中当f1 的异步操作结束时候会调用这个回调函数 并且把data传入到gen.next(data)中 就这样递归运行
}
next(); //1.先运行next
}
run(gen);
var gen = function* (){
var f1 = yield readFile('fileA');
var f2 = yield readFile('fileB');
// ...
var fn = yield readFile('fileN');
};
run(gen);
当Thunk函数传入第一个非回调参数，并且异步操作结束时，会调用第二个回调函数参数，根据这一点 我们可以在Thunk函数结束第一阶段的异步操作时，拿到异步结果让不到next()中 在把next(data)放入到回调函数中，让他自动触发进行下一步。
