序列

Seq 是一个异步流控制库，具有用于顺序和并行操作的可链接接口。甚至错误处理也是可链接的。

链中的每个操作都对一组值进行操作。还有一个变量散列用于按名称存储值。

[目录]

例子

stat_all.js

var fs = require('fs');
var Hash = require('hashish');
var Seq = require('seq');
 
Seq()
    .seq(function () {
        fs.readdir(__dirname, this);
    })
    .flatten()
    .parEach(function (file) {
        fs.stat(__dirname + '/' + file, this.into(file));
    })
    .seq(function () {
        var sizes = Hash.map(this.vars, function (s) { return s.size })
        console.dir(sizes);
    })
;

输出：

{ 'stat_all.js': 404, 'parseq.js': 464 }

解析器

var fs = require('fs');
var exec = require('child_process').exec;
 
var Seq = require('seq');
Seq()
    .seq(function () {
        exec('whoami', this)
    })
    .par(function (who) {
        exec('groups ' + who, this);
    })
    .par(function (who) {
        fs.readFile(__filename, 'ascii', this);
    })
    .seq(function (groups, src) {
        console.log('Groups: ' + groups.trim());
        console.log('This file has ' + src.length + ' bytes');
    })
;

输出：

Groups: substack : substack dialout cdrom floppy audio src video plugdev games netdev fuse www
This file has 464 bytes

应用程序接口

每个方法都使用this下一节中描述的上下文（its ）执行回调。每个方法都返回this.

每当this()使用非假的第一个参数调用时，错误值向下传播到catch它看到的第一个，跳过其间的所有操作。在catch所有链的末尾有一个隐式，如果可用则打印错误堆栈，否则只打印错误。

序列(xs=[])

构造函数Seq使用下面描述的方法创建一个新链。可选的数组参数成为新的上下文堆栈。

数组参数是 0.3 中的新内容。Seq()现在表现得像Seq.ap().

.seq(cb)

.seq(key, cb, *args)

这个同名函数按顺序执行操作。一旦所有正在运行的并行操作完成执行，提供的回调将apply()与上下文堆栈一起使用。

要执行链中的下一个操作，请调用this()。第一个参数必须是错误值。其余的值将成为链中下一个操作的堆栈，也可在this.args.

如果key被指定，第二个参数发送到this进入
this.vars[key]除了堆栈和this.args。
this.vars除非被覆盖，否则会在所有请求中持续存在。

之后的所有参数cb都将绑定到cb，这很有用，因为
.bind()您可以设置this. 如果你传入Seq参数列表，它会被转换成this这样你可以：

Seq()
    .seq(fs.readdir, __dirname, Seq)
    .seq(function (files) { console.dir(files) })
;

它在__dirname.

.par(cb)

.par(key, cb, *args)

用于par并行执行操作。将多个并行操作链接在一起，并使用诸如 的顺序操作收集堆栈上的所有响应seq。

每个都par将堆栈中的一个元素与第二个参数设置this()为按照它出现的顺序，因此par可以将多个s 链接在一起。

和 一样seq，第一个参数this()应该是错误值，第二个参数将被压入堆栈。中提供了更多参数
this.args。

如果key指定，则第二个参数的结果发送this()到this.vars[key]。
this.vars除非被覆盖，否则会在所有请求中持续存在。

之后的所有参数cb都将绑定到cb，这很有用，因为
.bind()您可以设置this. 就像.seq()，您可以传递Seq这些绑定参数，它将被转换为this.

.catch(cb)

捕捉错误。每当一个函数调用this一个非假的第一个参数时，消息就会沿着链传播到catch它看到的第一个。回调cb以错误对象作为其第一个参数和导致错误的操作正在填充的键触发，这可能是未定义的。

catch是一个连续的动作，进一步的动作可能会出现在catch链中的 a之后。如果执行到达catch链中的 a 并且没有发生错误，catch则跳过 。

为方便起见，所有链的末尾都有一个默认的错误处理程序。此默认错误处理程序如下所示：

.catch(function (err) {
    console.error(err.stack ? err.stack : err)
})

.forEach(cb)

在链对象的上下文下执行堆栈中的每个动作。
forEach不等待任何操作完成并且本身不会改变堆栈，但回调可能会通过修改
this.stack.

回调被执行cb(x,i)，其中x是该元件和i是索引。

forEach是一个类似的顺序操作，seq并且在所有挂起的并行请求产生结果之前不会运行。

.seqEach(cb)

类似于forEach，调用cb堆栈中的每个元素，但与 不同的是forEach，
在移动到堆栈中的下一个元素之前seqEach等待回调让this出。

回调被执行cb(x,i)，其中x是该元件和i是索引。

如果this()提供了非假错误，则错误向下传播，但忽略任何其他参数。seqEach不修改堆栈本身。

.parEach(cb)

.parEach（限制，CB）

就像forEach，为堆栈中的每个元素调用 cb 并且this()在继续下一次迭代之前不等待回调产生结果。与 不同forEach，在移动到链中的下一个动作之前，parEach等待所有动作被调用this()。

回调被执行cb(x,i)，其中x是该元件和i是索引。

parEach不修改堆栈本身和提供this()
传播的错误。

可选地，如果将限制提供给parEach，则最多一次limit回调将处于活动状态。

.seqMap(cb)

类似seqEach，但收集提供给的值this并将堆栈设置为这些值。

.parMap(cb)

.parMap（限制，CB）

类似parEach，但收集提供给的值this并将堆栈设置为这些值。

.seqFilter(cb)

cb(x, idx)对堆栈上的每个元素执行回调，this在移动到下一个元素之前等待回调产生。如果回调返回错误或 falsey 值，则该元素将不会包含在结果堆栈中。

回调中的任何错误都会被消耗并且不会传播。

this.into(i)如果回调接受，调用将把值放置在结果的索引处，就好像它在过滤之前在堆栈上的第 i 个索引处排序（通过值打破联系）。这意味着this.into即使它们的索引发生冲突也永远不会覆盖另一个堆栈值。最后，只有i当回调在 之前接受或移动足够多的值时，该值才会实际出现i。

.parFilter(cb)

.parFilter（限制，CB）

cb(x, idx)对堆栈上的每个元素执行回调，但
在移动到下一个元素之前不等待它让步。如果回调返回错误或 falsey 值，则该元素将不会包含在结果堆栈中。

回调中的任何错误都会被消耗并且不会传播。

this.into(i)如果回调接受，调用将把值放置在结果的索引处，就好像它在过滤之前在堆栈上的第 i 个索引处排序（通过值打破联系）。这意味着this.into即使它们的索引发生冲突也永远不会覆盖另一个堆栈值。最后，只有i当回调在 之前接受或移动足够多的值时，该值才会实际出现i。

可选地，如果将限制提供给parEach，则最多一次limit回调将处于活动状态。

.do(cb)

创建一个新的嵌套上下文。cb的第一个参数是前一个上下文，并且this
是嵌套Seq对象。

.flatten（完全=真）

递归地展平堆栈中的所有数组。设置fully=false为仅展平一层。

.unflatten()

将堆栈的内容转换为单个数组项。您可以将其视为 的倒数flatten(false)。

.extend([x,y…])

像push，但需要一个数组。这就像 python 的[].extend().

.set(xs)

将堆栈设置为新数组。这分配了引用，它不复制。

。空的（）

将堆栈设置为 []。

.push(x,y…), .pop(), .shift(), .unshift(x), .splice(…), reverse()

.map(…), .filter(…), .reduce(…)

在堆栈上执行数组操作。

方法map、filter和reduce也是它们对应的 Array 方法的代理：它们与 Array 方法具有相同的签名，在上下文堆栈上同步操作，并且不传递 Context 对象（与seqMap和不同parMap）。

转换的结果分配给上下文堆栈；在 的情况下reduce，如果您不返回数组，则该值将被包装为 1。

Seq([1, 2, 3])
    .reduce(function(sum, x){ return sum + x; }, 0)
    .seq(function(sum){
        console.log('sum: %s', sum);
        // sum: 6
        console.log('stack is Array?', Array.isArray(this.stack));
        // stack is Array: true
        console.log('stack:', this.stack);
        // stack: [6]
    })
;

显式参数

对于像咖啡脚本或嵌套逻辑这样线程this很麻烦的环境，您可以使用：

• 序列_
• par_
• forEach_
• seqEach_
• parEach_
• 序列映射_
• 参数映射_

除了提供的回调的第一个参数设置为上下文之外，它们的工作方式与它们的无下划线对应物完全相同this。

上下文对象

每个回调都会在其this设置为一个函数的情况下执行，以产生结果、错误值和控制。该函数还有这些有用的字段：

这个.stack

执行栈。

这个.stack_

以前的堆栈值，主要在内部用于黑客目的。

这个.vars

用par(key, ...),seq(key, ...)和
填充的键/值的散列this.into(key)。

this.into(key)

不是将值发送到堆栈，而是设置一个键并返回this。使用this.into(key)与互换this的产生键结果。
into覆盖由par(key, ...)和设置的可选键seq(key, ...)。

这个.ok

设置err为空。相当于this.bind(this, null)。

这个.args

this.args就像this.stack，但它包含所有this()
超过错误值的参数，而不仅仅是第一个。this.args是一个与this.stack上次顺序操作具有相同索引但也存储键控值的数组。中的每个元素this.array都设置为[].slice.call(arguments, 1)
from inside this()。

这个错误

这用于错误传播。你可能不应该惹它。

安装

使用npm，只需执行以下操作：

npm install seq

或者在 github 上克隆这个项目：

git clone http://github.com/substack/node-seq.git

要使用expresso运行测试，只需执行以下操作：

expresso

依赖关系

该模块使用电锯
时npm install seq会自动安装此依赖项。