Step.js 使用教程(附源码解析)

Step.js(https://github.com/creationix/step)是控制流程工具(大小仅 150 行代码),解决回调嵌套层次过多等问题。适用于读文件、查询数据库等回调函数相互依赖,或者分别获取内容最后组合数据返回等应用情景。异步执行简单地可以分为“串行执行”和“并行”执行,下面我们分别去看看。

串行执行

这个库只有一个方法 Step(fns...)。Step 方法其参数 fns 允许是多个函数,这些函数被依次执行。Step 利用 this 对象指针来封装工作流,如下例:

Step(
  function readSelf() {
    fs.readFile(__filename, this); // 把 this 送入 readFile 的异步参数中。此时 this 其类型为 function
    // 注意这里无须 return 任何值
  },
  function capitalize(err, text) { // err 为错误信息,如果有则抛出异常
    if (err) throw err;
    return text.toUpperCase();     // text 为 上个步骤 readFile 的值也就是文件内容。注意此处有返回值供下一步所用。
  },
  function showIt(err, newText) {
    if (err) throw err;
    console.log(newText);
  }
);

可见,回调函数顺序依赖、依次执行,适用于下一个回调函数依赖于上一个函数执行的结果。Step 的一个约定,回调函数的第一个参数总是 err,第二个才是值(沿用 Node 回调的风格)。如果上一个步骤发生异常,那么异常对象将被送入到下一个步骤中。因此我们应该检查 err 是否有意义,如果 err 存在值,应抛出异常用于处理错误信息,中止下面执行下面的逻辑;如果 err 为 null 或者 undefined,则表示第二个参数才有意义。

为什么要大家注意有 return 和无 return 的区别呢?因为这将要揭示 Step 的一个思想:只要是同步的工作,我们只需直接 return 即可。如果需要异步的话,则调用对象指针 this,此时 this 是一个函数类型的对象。

像上例一个 fn 接着一个 fn 执行,称为“串行执行”。

并行执行

所谓并行执行,就是等待所有回调产生的结果,并把所有结果按调用次序组成数组,作为参数传给最后一个函数处理。组装回调函数的结果,此方法不同于上面的依赖串联执行,所有的回调是并行执行的, 只不过是在最后一个回调返回结果时,才调用最终处理函数。

并行执行有点类似于 Promise 模式的 when 场景,要求所有条件为“并 AND”的逻辑关系时方执行。

Step(
  // 同时执行两项任务 Loads two files in parallel
  function loadStuff() {
    fs.readFile(__filename, this.parallel());
    fs.readFile("/etc/passwd", this.parallel());
  },
  // 获取结果 Show the result when done
  function showStuff(err, code, users) {
    if (err) throw err;
    console.log(code);
    console.log(users);
  }
)

我们用 Step.js API 提供的 this.parallel() 方法代替了 上一例的 this。this.parallel() 可以帮助解决我们上一例中只能产生一次异步函数的困窘,适合多个异步步骤的分发,最后完成阶段由最后一个回调收集结果数据。可见,调用了 n 次的 this.parallel(),就调用了 n 次的收集 results 的函数。如果任何一个异步分支发生异常,那个异常都会被收集到 results 中,并且特别地声明到 err 参数中,表示任务失败,最后一个回调不执行。

在两个步骤直接的值或者异常如何传递,我们可以总结一下三个场景:

  • 既不使用 this,又无 return 任何值,任务中断
  • 直接 return 值,此时无任何异步过程发生
  • 调用 this : Function,产生一个异步过程,此异步过程完成后,进入下一个 step
  • 用 this.parallel() : Function,产生多个异步过程,等待这些异步过程通通完成之后,才进入下一个 step

由此可见,Step.js 可以很好地结合同步与异步的任务组织技术。

并行执行_高阶

如果不确定多个异步任务的数量,可以使用 this.group()。

Step(
  function readDir() {
    fs.readdir(__dirname, this);
  },
  function readFiles(err, results) {
    if (err) throw err;
    // 创建 group,其实内部创建一个 results 数组,保存结果
    var group = this.group();
    results.forEach(function (filename) {
      if (/\.js$/.test(filename)) {
        fs.readFile(__dirname + "/" + filename, 'utf8', group()); // group() 内部其逻辑与 this.parallel,也是调度 index/pending。
      }
    });
  },
  function showAll(err , files) {
    if (err) throw err;
    console.dir(files);
  }
);

this.group 与 this.parallel 非常类似都是用于异步场景,至于区别的地方,在于 this.parallel 会把结果作为一个个单独的参数来提供,而 this.group 会将结果合并为数组 Array。所以从表面上看它们之间的区别有点象 fn.call() 与 fn.apply() 之间的区别,——不知道大家有没有这种感受;而按照使用场景的角度看,两者的真正区别是 thsi.group 用于不太确定异步任务数量的场景。运用 this.group 又一例,等价的 map():

function stepMAp(arr, iterator, callback){
  Step(
    function(){

    var group = this.group();
    for(var i = 0, j = arr.length; i < j; i++)
      iterator(arr[i], group());
    }),
   callback
}
//

另外注意 group() 不宜直接调用,如 group()(args),这样会终止流程。

源码解析

实际上 Step.js 的原理并不复杂,主要是递归函数来遍历函数列表。用计算器标记异步任务是否完成。比较巧妙的地方就是善用了对象指针 this。

Step.js 虽不如 Async.js(https://github.com/caolan/async) 提供诸多函数,但胜在够简单,用户可以自己继续封装新的函数来完善它。笔者认同这一观点,通过 Step.js 能鼓励我们透彻地思考问题并编写出优雅高效方案。

// Inspired by http://github.com/willconant/flow-js, but reimplemented and
// modified to fit my taste and the node.JS error handling system.
function Step() {
  var steps = Array.prototype.slice.call(arguments), // 参数列表
      counter, pending, results, lock;               // 全局的四个变量

  // 定义主函数 Define the main callback that's given as `this` to the steps.
  function next() {
    counter = pending = 0; // counter 和 pendig 是用于并行步骤任务:保存数据的索引和是否执行完毕的计数器

    // 看看是否还有剩余的 steps Check if there are no steps left
    if (steps.length === 0) {
      // 抛出未捕获的异常 Throw uncaught errors
      if (arguments[0]) {
        throw arguments[0];
      }
      return;
    }

    // 得到要执行的步骤 Get the next step to execute
    var fn = steps.shift();
    results = [];

    // try...catch 捕获异常 Run the step in a try..catch block so exceptions don't get out of hand.
    try {
      lock = true;
      var result = fn.apply(next, arguments); // 此的 args 是 next 的擦参数列表
    } catch (e) {
      // 如果有异常,把捕捉到的异常送入下一个回调 Pass any exceptions on through the next callback
      next(e);
    }

    if (counter > 0 && pending == 0) { // couter > 0 表示有并行任务,pending == 0 表示全部运行完毕
      // 如果执行了并行任务(异步的意思),而且全部分支都同步执行完毕后,立刻执行下一步
      // If parallel() was called, and all parallel branches executed
      // synchronously, go on to the next step immediately.
      next.apply(null, results); // 足以注意这里是 results 数组。此时 results 已经包含了全部的结果
    } else if (result !== undefined) {
      // 如发现有 return 执行(串行的意思),将其送入到回调 If a synchronous return is used, pass it to the callback
      next(undefined, result);
    }
    lock = false;
  }

  // 用于并行的生成器 Add a special callback generator `this.parallel()` that groups stuff.
  next.parallel = function () {
    var index = 1 + counter++;
    pending++; // 开启了一个新的异步任务

    return function () {
      pending--;// 计算器减 1,表示执行完毕
      // 如果有错误,则保存在结果数组的第一个元素中 Compress the error from any result to the first argument
      if (arguments[0]) {
        results[0] = arguments[0];
      }
      // 按次序保存结果 Send the other results as arguments
      results[index] = arguments[1];
      if (!lock && pending === 0) {// 最后才执行 
        // 当所有分支都搞定,执行最后一个回调。When all parallel branches done, call the callback
        next.apply(null, results);
      }
    };
  };

  // Generates a callback generator for grouped results
  next.group = function () {
    var localCallback = next.parallel();
    var counter = 0;
    var pending = 0;
    var result = [];
    var error = undefined;

    function check() {
      if (pending === 0) {
        // When group is done, call the callback
        localCallback(error, result);
      }
    }
    process.nextTick(check); // Ensures that check is called at least once

    // Generates a callback for the group
    return function () {
      var index = counter++;
      pending++;
      return function () {
        pending--;
        // Compress the error from any result to the first argument
        if (arguments[0]) {
          error = arguments[0];
        }
        // Send the other results as arguments
        result[index] = arguments[1];
        if (!lock) { check(); }
      };
    };
  };

  // 开始工作流 Start the engine an pass nothing to the first step.
  next();
}

/**

相当于一个包装步骤列表的工厂
*/
// Tack on leading and tailing steps for input and output and return
// the whole thing as a function. Basically turns step calls into function
// factories.
Step.fn = function StepFn() {
  var steps = Array.prototype.slice.call(arguments);
  return function () {
    var args = Array.prototype.slice.call(arguments);

    // Insert a first step that primes the data stream
    var toRun = [function () {
      this.apply(null, args);
    }].concat(steps);

    // 加入最后的步骤 If the last arg is a function add it as a last step
    if (typeof args[args.length-1] === 'function') {
      toRun.push(args.pop());
    }


    Step.apply(null, toRun);
  }
}


// CommonJS模块系统的钩子 Hook into commonJS module systems
if (typeof module !== 'undefined' && "exports" in module) {
  module.exports = Step;
}

我为适应 sea.js 包机制,加入define() 调用,见:http://naturaljs.googlecode.com/svn/trunk/libs/step.js

原来 Step.js 也是参考了别人的代码,https://github.com/willconant/flow-js,站在巨人的肩膀上啊。参见同类型的开源库:

简单测试 代码

Step(function(a){
	throw 'err';
	return 1;
}, function(err, b){
	console.log(err);
	return [b, 2];
}, function(err, c){
	console.log(err);
	alert(c);
});

Step 缺点是使用 try...catch 包裹业务代码,使得异常全部被捕获,在调试阶段,这是不友好的。那么怎么破?可以将调试器设置为“Pause on all exception”。

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zhangxin09/article/details/13018739
个人分类: JavaScript & 编码
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭