Thunk函数

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)放入到回调函数中，让他自动触发进行下一步。