【Node.js】Browserling的开源node.js模块

以下是所有模块的完整列表及其简要说明。我们已经在 GitHub 上发布了所有模块，这是完成工作和协作的最佳工具。所有这些都有大量文档，因此只需单击您感兴趣的内容即可阅读更多内容并查看示例。

1. 节点

DNode 是用于 node.js 的异步面向对象的 RPC 系统，可让您调用远程函数。这是一个例子。你有你的 server.js：

var dnode = require(dnode);var server = dnode({zing : function (n, cb) { cb(n * 100) }});server.listen(5050);

这将在端口上启动 dnode 服务器 5050 并导出异步将 number 乘以的zing 函数。n100

你有你的 client.js：

var dnode = require(dnode);dnode.connect(5050, function (remote) {remote.zing(66, function (n) {console.log(n = + n);});});

这在端口连接到 dnode 服务器 5050，调用该 zing 方法并将其传递给回调函数，然后从服务器和客户端输出调用该回调函数6600。

我们使用 dnode 在 Browserling 构建了所有东西，我们所有的进程都通过 dnode 进行通信。node.js 社区中也有成千上万的人使用 dnode。这是有史以来最棒的图书馆。

github上的dnode[]

2.节点浏览

Node-browserify 是 node 模块和 npm 包的浏览器端 require() 。它会自动将应该通过 node 运行的 node.js 模块转换为在浏览器中运行的代码！它遍历 AST 以递归方式读取所有 require() 并准备一个包含您需要的所有内容的包，包括拉入您可能使用 npm 安装的库！

以下是节点浏览器功能：

相对 require() 就像在 node 中一样在浏览器端工作。

Coffee 脚本会自动编译，您可以注册自己的自定义编译器！

某些核心节点模块（例如路径、事件和 vm）的浏览器版本会根据需要自动包含在内。

命令行捆绑工具。

如果你问我就疯了。

github上的node-browserify[]

3.节点懒惰

Node-lazy 是 node.js 的惰性列表。当您需要像列表一样处理事件流时，它非常方便。最好的用例是从异步函数返回一个惰性列表，并通过事件将数据注入其中。在异步编程中，您不能只返回一个常规列表，因为您还没有数据。到目前为止，通常的解决方案是提供一个在数据可用时调用的回调。但是这样做你会失去链接函数和创建管道的能力，这会导致丑陋的接口。

查看这个玩具示例，首先创建一个 Lazy 对象：

var Lazy = require(lazy);var lazy = new Lazy;lazy.filter(function (item) {return item % 2 == 0}).take(5).map(function (item) {return item*2;}).join(function (xs) {console.log(xs);});

这段代码说这 lazy 将是一个惰性列表，它过滤偶数，取前五个，然后将它们全部乘以 2，然后 join 在最终列表中调用函数（将 join 视为线程中的连接）。

现在您可以在稍后的某个时间发出带有数据的“数据”事件，

[0,1,2,3,4,5,6,7,8,9,10].forEach(function (x) {lazy.emit(data, x);});lazy.emit(end);

输出将由 join 函数生成，该函数将输出预期的 [0, 4, 8, 12, 16].

这是一个具体的例子，在 node-iptables 中使用，

它获取 iptables.stdout 流，通过将其转换为行列表 .lines，然后将此列表转换为 String 对象（因为行是 Buffers），然后 .skip是前两行（iptables 标题行），最后在每一行上映射一个函数来转换将它们转换为数据结构。

github 上的 node-lazy[]

4. 节点卷饼

Burrito 让使用 JavaScript AST 做一些疯狂的事情变得容易。如果您想滚动自己的堆栈跟踪或构建代码覆盖工具，这将非常有用。

这是一个例子，

var burrito = require(burrito);var src = burrito(f() && g(h())\nfoo(), function (node) {if (node.name === call) node.wrap(q(%s));});console.log(src);

这将所有函数调用包装在 q 函数中：

q(f()) && q(g(q(h())));q(foo());

这样你就可以做一些疯狂的事情 q 来找到更多关于代码中函数调用的信息。

我们使用 node-burrito 进行测试。

github 上的节点卷饼[]

5.js-遍历

Js-traverse 通过访问递归遍历中的每个节点来遍历和转换对象。

这是一个例子：

var traverse = require(traverse);var obj = [ 5, 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];traverse(obj).forEach(function (x) {if (x < 0) this.update(x + 128);});console.dir(obj);

此示例遍历 obj 并返回一个带有负值 (+ 128)d 的新对象：

[ 5, 6, 125, [ 7, 8, 126, 1 ], { f: 10, g: 115 } ]

这是另一个例子，

此示例用于 .isLeaf 确定被遍历的节点是否为叶节点。如果是，它会累积它。输出是所有叶子节点：

[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

github 上的 js-traverse[]

6. json化

Jsonify 提供 Douglas Crockford[]的 JSON 实现，无需修改任何全局变量。

在 github 上 jsonify[]

7. 节点垃圾

Node-garbage 生成随机垃圾 json 数据。对模糊测试很有用。

这是在节点解释器中运行的示例：

> var garbage = require(garbage)> garbage()4.8192> garbage()-7.1647> garbage(){ 0\t4$$c(C&s%: {},: 2.6717,!&pQw5: <~.;@,,I$t]hky=: {},{4/li(MDYX": [] }> garbage()false

github上的节点垃圾[]

8.节点本

Node-ben 对同步和异步 node.js 代码片段进行基准测试。

以下是同步基准测试的示例：

var ben = require(ben);var ms = ben(function () {JSON.parse([1,2,3])});console.log(ms + milliseconds per iteration);

输出：

0.0024 milliseconds per iteration

这是一个异步基准测试的示例：

var ben = require(ben);var test = function (done) {setTimeout(done, 10);};ben.async(test, function (ms) {console.log(ms + milliseconds per iteration);});

输出：

10.39 milliseconds per iteration

github上的节点本[]

9. 节点大整数

Node-bigint 为 node.js 实现了任意精度的积分算法。这个库包装了 libgmp 的整数函数来执行无限精度的算术。

这里有几个例子：

var bigint = require(bigint);var b = bigint().sub().div(8);console.log(b);

输出：

github 上的 node-bigint[]

10. 节点-mkdirp

Node-mkdirp 执行 mkdir -p shell 中的操作（如果目录结构不存在，则创建目录结构）。

var mkdirp = require(mkdirp);mkdirp(/tmp/foo/bar/baz, 0755, function (err) {if (err) console.error(err)else console.log(pow!)});

/tmp/foo/bar/baz 如果路径不存在，这将创建路径，并为每个目录提供 perms 0755。

github 上的 node-mkdirp[]

11. npmtop

Npmtop 是一个愚蠢的程序，它根据包的数量对 npm 贡献者进行排名。

github 上的 npmtop[]

12. 节点排序

节点排序 Array 是始终排序的 JavaScript 实现。

这是一个示例，在节点的解释器中运行：

> var sorted = require(sorted)> var xs = sorted([ 3, 1, 2, 0 ])> xs<Sorted [0,1,2,3]>> xs.push(2.5)5> xs<Sorted [0,1,2,2.5,3]>

在 github 上按节点排序[]

13. 节点文件化

Node-fileify 是 browserify 加载模板等非 js 文件的中间件。

github上的node-fileify[]

14. 节点地堡

Bunker 是一个使用原生 JavaScript node-burrito AST 技巧计算代码覆盖率的模块。

这是一个例子：

这会从代码片段创建一个掩体：

var x = 0; for (var i = 0; i < 30; i++) { x++ }

然后计算每条语句执行了多少次。输出是：

1 : var x=0;31 : i<3030 : i++30 : x++;30 : x++

github 上的节点掩体[]

15. 节点帽

Node-hat 生成随机 ID 并避免冲突，因为熵是可怕的。例子：

> var hat = require(hat);> var id = hat();> console.log(id);0c82a54f22f775a3ed8b97b2dea74036

github 上的节点帽[]

16.节点侦探

无论使用正确的 AST 遍历多么疯狂地嵌套，Node-detective 都会找到对 require() 的所有调用。

这是一个例子。假设您有一个名为 program.js 的源文件：

var a = require(a);var b = require(b);var c = require(c);

然后这个使用 node-detective 的程序会找到所有的需求：

var detective = require(detective);var fs = require(fs);var src = fs.readFileSync(__dirname + /program.js);var requires = detective(src);console.dir(requires);

输出：

[ a, b, c ]

github 上的节点侦探[]

17. 节点-isaacs

Node-isaacs 是您的个人 Isaac Schlueter。只是为 npm 的作者 Isaac 在他生日那天写的一个有趣的模块。

github 上的 node-isaacs[]

18. 测试

Testling 是我们在撰写本文时发布的新测试框架。这将是它的开源部分，我们将在幕后运行一些魔法来在 Browserling 浏览器上运行它。

在 github 上测试[]

19.节点-肠

Node-intestine 提供了单元测试框架的核心。使用肠子，使用可插拔运行器以您想要的任何样式滚动您自己的测试框架一点也不难，因此您可以通过节点掩体轻松交换代码覆盖率或通过节点堆栈跟踪交换代码覆盖率。

查看 GitHub 上的复杂代码示例。它们太复杂了，无法在这篇简短的文章中解释。

github上的节点肠[]

20. 节点哈希

Node-hashish 是一个用于操作散列数据结构的库。它是从 Ruby、Perl 和 Haskell 必须通过哈希/映射接口提供的最好的东西中提炼出来的。

Hashish 提供了一个链接接口，您可以在其中执行以下操作：

var Hash = require(hashish);Hash({ a : 1, b : 2, c : 3, d : 4 }).map(function (x) { return x * 10 }).filter(function (x) { return x < 30 }).forEach(function (x, key) {console.log(key + => + x);});

产生输出：

a => 10b => 20

github 上的节点哈希[]

21. 节点二进制

Node-binary 可用于从缓冲区和流中解压缩多字节二进制值。您也可以指定要解包的字段的字节顺序和签名。

这个模块是 bufferlist 的二进制模块的更干净和更完整的版本，它在预分配的缓冲区而不是链表上运行。

我们将此模块用于 node-rfb，它是 VNC 的 RFB 协议的实现。

github 上的节点二进制文件[]

22. 杰普

Jsup 就地更新 JSON 字符串，保留结构。当以编程方式更改配置文件时，它们对于保留配置文件的结构非常有用。

假设您有一个名为 stub.json 的 JSON 文件：

{"a" : [ 1,2,,4 ] ,"b" : [ 3, 4, { "c" : [ 5, 6 ] } ],"c" :,"d" : null}

你有这个jsup程序：

var jsup = require(jsup);var fs = require(fs);var src = fs.readFileSync(__dirname + /stub.json, utf8);var s = jsup(src).set([ a, 2 ], 3).set([ c ], lul).stringify();console.log(s);

运行此程序后，输出为：

{"a" : [ 1,2,3,4 ] ,"b" : [ 3, 4, { "c" : [ 5, 6 ] } ],"c" :"lul","d" : null}

请注意如何更改为 just 3 以及保留之前的两个空格；并注意如何将其更改为字符串“ lul”并再次保留格式。非常棒！

github 上的 jsup[]

23.节点-ent

Node-ent 编码和解码 HTML 实体。核实：

> var ent = require(ent);> console.log(ent.encode(<span>©moo</span>))<span>©moo</span>> console.log(ent.decode(π & ρ));p & ?

github上的node-ent[]

24. 节点电锯

呜呜。

Node-chainsaw 可用于在 node.js 中以简单的方式构建可链接的流畅接口。

使用此元模块，您可以编写具有可链接接口的模块。Chainsaw 负责处理所有无聊的细节，并使嵌套流控制变得超级简单。

只需 Chainsaw 使用如下示例中的构造函数调用即可。在您的方法中，只需 saw.next() 移动到下一个事件并 saw.nest() 创建一个嵌套链。

github 上的节点电锯[]

25. 色彩先生

颜色先生为您生成颜色。就是这样。这是它的外观：

它也可以从命令行使用：

var mr = require(mrcolor);mr.take(5).forEach(function (color) {console.log(rgb( + color.rgb().join(,) + ));});

输出：

rgb(254,1,1)rgb(255,255,0)rgb(0,255,0)rgb(1,254,254)rgb(0,0,255)

github上的mrcolor[]

26. 节点乐观主义者

Node-optimist 为您解析命令行参数。这就是它应该做的方式。没有更多选项古老的解析字符串！

看一下这个：

var argv = require(optimist).argv;

完毕！您的论点被解析为 argv.

想知道我的意思是什么？如果以运行程序 node prog.js --x=5 --y=foo， argv.x 则为“ 5”， argv.y 为“ foo”。

Node-optimist 还会自动生成用法，并且还具有 demand 请求参数的功能：

var argv = require(optimist).usage(Usage: $0 -x [num] -y [num]).demand([x,y]).argv;console.log(argv.x / argv.y);

如果您使用 x and 运行它y：

$ ./divide.js -x 55 -y 115

缺少 y ：

$ node ./divide.js -x 4.91 -z 2.51Usage: node ./divide.js -x [num] -y [num]Options:-x[required]-y[required]Missing required arguments: y

这就是选项解析的方式！

github 上的节点乐观主义者[]

27. node-quack-array

Node-quack-array 检查它是否像数组一样 quaacks，如果是，则返回数组。这是两个示例，在 node.js 解释器中运行。

浅叫声：

> var quack = require(quack-array);> quack({ 0 : a, 1 : b })[ a, b ]> quack({ 0 : a, 1 : b, x : c }){ 0: a, 1: b, x: c }

深嘎嘎：

> var quack = require(quack-array);> quack.deep({ 0 : { 0 : a, 1 : b }, 1 : c })[ [ a, b ], c ]

嘎嘎！

github 上的 node-quack-array[]

28. 节点堆叠

使用 node-stackedy 滚动您自己的堆栈跟踪并通过 AST 操作控制程序执行！

这是一个名为的示例程序 stax.js，

它读取并执行源代码文件 src.js：

function f () { g() }function g () { h() }function h () { throw moo }f();

如您所见， f 调用 g，调用 h，抛出异常“ moo”。

现在 stax.js 运行时，它会通过stackedy生成自定义堆栈跟踪，输出为：

Error: mooin stax.js at line 2in stax.js, h() at line 1in stax.js, g() at line 0in stax.js, f() at line 4

非常非常非常棒。

github 上的 node-stackedy[]

29. node-shimify

Node-shimify 是一个 browserify 中间件，用于预先添加 es5-shim，因此您的 browserified 捆绑包可以在旧浏览器中工作。

github上的node-shimify[]

30. 节点键盘化

Node-keyboardify 是一个显示屏幕键盘的 browserify 中间件。

github上的node-keyboardify[]

31. 节点-keysym

Node-keysym 在 X11 键符、unicode 和字符串名称之间进行转换。我们需要它来向 Browserling 发送正确的键盘代码。

这是一个示例，在节点解释器中运行：

> var ks = require(keysym);> console.dir(ks.fromUnicode(8))[ { keysym: 65288 , unicode: 8 , status: f , names: [ BackSpace ] } ]

github 上的 node-keysym[]

32. node-jadeify

Node-jadeify 是一个浏览器端jade模板的browserify中间件。这是正确的。翡翠在您的浏览器中！

github 上的 node-jadeify[]

33. 节点查找

Node-findit 是 node.js 的递归目录遍历器。使用起来很简单：

require(findit).find(/usr, function (file) {console.log(file);});

这将查找目录树中从开始的所有文件 /usr。它也可以用于事件样式：

var finder = require(findit).find(/usr);finder.on(directory, function (dir) {console.log(dir + /);});finder.on(file, function (file) {console.log(file);});

Node-findit directory 为目录和 file 文件发出事件。

github上的节点拆分[]

34. node-progressify

Node-progressify 是带有 browserify 的 webapps 的手绘进度条！看起来像这样：

github上的node-progressify[]

35. 节点缓冲区

Node-buffers 将 Buffer 集合视为单个连续的部分可变 Buffer。在可能的情况下，操作在不创建新缓冲区并复制所有内容的情况下执行。

这是一个例子：

var Buffers = require(buffers);var bufs = Buffers();bufs.push(new Buffer([1,2,3]));bufs.push(new Buffer([4,5,6,7]));bufs.push(new Buffer([8,9,10]));console.dir(bufs.slice(2,8))

输出：

github 上的节点缓冲区[]

36. 节点命令

Node-commondir 计算一个目录数组中最近的公共父目录。

查看这两个示例，在节点解释器中运行：

> var commondir = require(commondir);> commondir([ /x/y/z, /x/y, /x/y/w/q ])/x/y

也适用于相对路径：

> var commondir = require(commondir)> commondir(/foo/bar, [ ../baz, ../../foo/quux, ./bizzy ])/foo

github 上的 node-commondir[]

37. 节点节点

Node-nub 返回一个数组的所有唯一元素。您也可以使用指定您自己的唯一性比较函数 nub.by。

示例，在节点中运行：

$ node> var nub = require(nub)> nub([1,2,2,3,1,3])[ 1, 2, 3 ]> nub.by([ 2, 3, 5, 7, 8 ], function (x,y) { return x + y === 10 })[ 2, 3, 5 ]

github 上的 node-nub[]

38. 节点解析

Node-resolve 实现了节点 require.resolve() 算法，除了您可以传入文件以计算相对于您自己 require.path的 s 的路径，而无需更新全局副本（甚至在节点> = 0.5 中不起作用）。

github上的节点解析[]

39. 节点序列

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

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

这是目前最强大的异步流控制库。看看这个例子：

这会顺序读取当前目录中的所有文件，然后展平结果列表，然后 stat 对每个文件执行，然后依次查找文件的大小。

输出（假设当前目录中只有两个文件）：

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

github 上的节点序列[]

40. 节点-rfb

Node-rfb 在 node.js 中实现了 VNC 的 RFB 协议。Browserling 是 Browserling 最重要的模块。

github 上的 node-rfb[]

41. 节点自动换行

Node-wordwrap 包装单词。例子：

var wrap = require(wordwrap)(15);console.log(wrap(You and your whole family are made out of meat.));

输出：

You and yourwhole familyare made outof meat.

github 上的节点自动换行[]

42. dnode-perl

Dnode-perl 在 Perl 中实现了 dnode 协议。

github 上的 dnode-perl[-perl]

43. 节点-SSH

Node-ssh 尝试使用 libssh 为 node.js 创建 ssh 服务器。它不起作用，但有人可能会发现代码很有用。

github 上的 node-ssh[]

44.节点歌

Node-song 用合成的声音在 node.js 中唱歌。这是一个如何让它唱歌的例子：

var sing = require(song)();sing([{note : E3,durations : [ { beats : 0.3, text : hello } ]},{note : F#4,durations : [ { beats : 0.3, text : cruel } ]},{note : C3,durations : [ { beats : 0.3, text : world } ]},]);

github上的node-song[]

45. 单曲

Singsong 是 node-singsong 的 Web 界面。

环和 github[]

46.节点自由式

Node-freestyle 是一个非常糟糕的自由式押韵马尔可夫说唱一代。

自由式说唱示例：

$ node examples/rap.jshouse up as a a rare rare pleasure kernesrequire extraordinary Extraordinary claims claims require require extraordinary bullout there is a part of it turnsREMEMBER it turns out of the future full

github上的node-freestyle[]

47. 节点马尔科夫

Node-markov 为聊天机器人和自由式说唱比赛生成马尔可夫链。

github 上的 node-markov[]

48.说唱对战

Rap-battle 是一款说唱对战服务器，竞争对手使用 dnode。它接受人们聊天的输入文件并输出说唱。

这是 node.js 的创建者 ryah 和 npm 的创建者 isaacs 之间的说唱大战：

substack : rap-battle $ node watch.js---<isaacs> no scripting its arbitrary any lovecraftian c<ryah> converting then itd and be READMEs worth keeping FLEE---<ryah> standalone way to grab a long as long yeah, but than 2 locks<isaacs> sth is missing what php i ala get sugar a syntactic FLOCKS---<ryah> its was >64kb, that were shared utility functions are a cheaper<isaacs> scripting I arbitrary call allowing DEEPER

github 上的 rap-battle[]

49. 节点韵

Node-rhyme 找到押韵。例子：var rhyme = require(rhyme);rhyme(function (r) {console.log(r.rhyme(bed).join( ));});

输出：

$ node examples/bed.jsBLED BREAD BRED DEAD DREAD DRED DREDD ED FED FLED FREAD FRED FREDA GED HEADJED LEAD LED MED NED NEDD PLED READ READE RED REDD SAID SCHWED SFFED SHEADSHED SHEDD SHRED SLED SLEDD SPED SPREAD STEAD SWED SZWED TED THREAD TREADWED WEDD WEHDE ZED

github上的节点韵[]

50. 节点甲板

Node-deck 进行统一和加权的洗牌和采样。

统一洗牌：

> var deck = require(deck);> var xs = deck.shuffle([ 1, 2, 3, 4 ]);> console.log(xs);[ 1, 4, 2, 3 ]

统一样本：

> var deck = require(deck);> var x = deck.pick([ 1, 2, 3, 4 ]);> console.log(x);2</per>Weighted shuffle:<pre>> var deck = require(deck);> var xs = deck.shuffle({a : 10,b : 8,c : 2,d : 1,e : 1,});> console.log(xs);[ b, a, c, d, e ]

加权样本：

> var deck = require(deck);> var x = deck.pick({a : 10,b : 8,c : 2,d : 1,e : 1,});> console.log(x);a

github 上的节点甲板[]

51. 节点缓冲区列表

BufferList 提供了一个接口来将缓冲区的链接列表视为单个流。这对于产生许多小缓冲区的事件很有用，例如网络流。

该模块已弃用。Node-binary 和 node-buffers 以类似但更好的方式提供了 bufferlist 的功能。

这是它过去的样子：

var sys = require(sys);var Buffer = require(buffer).Buffer;var BufferList = require(bufferlist).BufferList;var b = new BufferList;[abcde,xyz,11358].forEach(function (s) {var buf = new Buffer(s.length);buf.write(s);b.push(buf);});sys.puts(b.take(10)); // abcdexyz11

github 上的节点缓冲区列表[]

52. node-permafrost

Permafrost 使用 JavaScript/EcmaScript 协调代理来递归地捕获对数据结构的更新，并将更改的结构自动存储到磁盘，并且对编程模型透明。

想想 ORM，但有一个疯狂的低阻抗失配。

这东西还是蛮坑的。我不会将它用于任何重要的事情。

这是一个例子：

var pf = require(permafrost);pf(times.db, { times : 0 }, function (err, obj) {obj.times ++;console.log(obj.times + times);});

然后运行它：

$ node times.js1 times$ node times.js2 times$ node times.js3 times

github 上的节点永久冻土[]

53. 节点放置

Node-put 将多字节二进制值打包到具有特定字节顺序的缓冲区中。

例子：

var Put = require(put);var buf = Put().word16be(1337).word8(1).pad(5).put(new Buffer(pow, ascii)).word32le(9000).buffer();

buf 现在包含编码为 16 位大端序的 1337，然后是 1，用 5 个 nuls 填充，然后是 ascii 中的 pow，然后是编码为 32 位小端序的 9000。

节点放在 github[]

54. 节点键x

用于公钥加密密钥交换的算法、解析器和文件格式。

这是一个生成密钥对并输出公钥的示例：

var keyx = require(keyx);var keypair = keyx.generate(dss);console.log(keypair.key(public).format(ssh2));

输出：

github 上的 node-keyx[]

55. 节点-SSH-服务器

Node-ssh-server 试图在 node.js 中编写一个 ssh 服务器。它没有成功，但有人可能会发现那里的代码很有用。

github 上的 node-ssh-server[-server]

56.节点AP

在 JavaScript 中进行柯里化。this 如果您只想在传递参数时对参数进行柯里化，那么Function.prototype.bind 设置非常烦人。

相反，您可以这样做：

var ap = require(ap);var z = ap([3], function (x, y) {return this.z * (x * 2 + y);}).call({ z : 10 }, 4);console.log(z);

输出：

1100

github 上的 node-ap[]

57. 节点源

Node-source 查找包的所有源文件。

这是一个玉石[]的例子：

var source = require(source)console.dir(Object.keys(source.modules(jade)));

输出：

[ jade,jade/package.json,jade/lib/jade.js,jade/lib/compiler.js,jade/lib/utils.js,jade/lib/self-closing.js,jade/lib/index.js,jade/lib/._parser.js,jade/lib/lexer.js,jade/lib/parser.js,jade/lib/._doctypes.js,jade/lib/._self-closing.js,jade/lib/doctypes.js,jade/lib/filters.js,jade/lib/nodes/tag.js,jade/lib/nodes/filter.js,jade/lib/nodes/doctype.js,jade/lib/nodes/code.js,jade/lib/nodes/._each.js,jade/lib/nodes/block.js,jade/lib/nodes/index.js,jade/lib/nodes/._block.js,jade/lib/nodes/._code.js,jade/lib/nodes/._text.js,jade/lib/nodes/comment.js,jade/lib/nodes/text.js,jade/lib/nodes/each.js,jade/lib/nodes/node.js,jade/lib/._filters.js,jade/lib/._jade.js,jade/._index ]

github上的节点源[]

58. 节点侦察

无论如何，Node-recon 都能让你的网络连接在 node.js 中保持活跃。Recon 看起来像一个常规的 tcp 连接，但它会侦听断开连接事件并尝试在幕后重新建立连接。当连接断开时， write() 返回 false 并且数据被缓冲。当连接恢复时，recon 会发出一个 drain 事件。

这是一个例子。在 node.js 中运行这个程序：

var recon = require(recon);var conn = recon(4321);conn.on(data, function (buf) {var msg = buf.toString().trim()console.log(msg);});

localhost:4321 无论如何，它都会尝试保持连接开放。

要尝试一下，您可以 4321 使用 netcat 监听端口，输入一些内容，杀死 netcat，然后再次启动它以输入更多内容。

github 上的节点侦察[]

59.npmdep

Npmdep 为 npm 包构建依赖关系图。

git hub上的 npmdep[]

60. 节点等候名单

Node-waitlist 管理排队等待资源的消费者。

github 上的节点候补名单[]

61. dnode堆栈

Dnode-stack 为 dnode socket.io 连接处理您的网络服务器中间件。

github 上的 dnode-stack[-stack]

62. 节点代理

Node-prox 是 node.js 中一个可挂钩的 socks5 代理客户端和服务器。

例子。这是 socks5 服务器，它在端口 7890 上创建一个 socks5 代理：

var socks5 = require(prox).socks5;socks5.createServer(function (req, res) {res.write(Requested + req.host + : + req.port);}).listen(7890)

这是连接到 socks5 服务器然后通过它连接到 substack.net 的客户端：

var socks5 = require(prox).socks5;var stream = socks5.createConnection(localhost, 7890).connect(substack.net, 1337);stream.on(data, function (buf) {console.log(buf.toString());});

github 上的节点代理[]

63. dnode-ruby

Dnode-ruby 在 Ruby 中实现了 dnode 协议。

github 上的 dnode-ruby[-ruby]

64. 节点-dmesh

管理履行特定角色的 DNode 服务池。（未完成）。

github上的node-dmesh[]

65. 行位

Rowbit 是我们在 Browserling 中用于通知的 IRC 机器人。它使用 dnode 作为其插件系统，因此模块只是连接到 rowbit 服务器的进程。

我们在 IRC 频道中收到这样的警报：

< rowbit> /!\ ATTENTION: (default-local) Somebody in the developer group is waiting in the queue! /!\

< rowbit> /!\ ATTENTION: (default-local) Somebody clicked the payment link! /!\

github上的rowbit[]

66.节点-rdesktop

Node-rdesktop 实现了 Windows 用于远程桌面的 RDP 协议的客户端。（还没完。）

github 上的 node-rdesktop[]

67. 电幕

Telescreen 用于管理跨多个服务器运行的进程。我们不再使用它了。

github上的电幕[]

68. 节点-iptables

Node-iptables 允许通过 iptables.

例如，要允许 TCP 端口 34567 来自 10.1.1.5 do：

var iptables = require(iptables);iptables.allow({protocol : tcp,src : 10.1.1.5,dport : 34567,sudo : true});

我们将其用于 Browserling 隧道来控制对隧道端口的访问。

github 上的节点 iptables[]

69. 节点密码

Node-passwd 允许您控制 UNIX 用户。它派生 passwd 实用程序来完成所有工作。

例如，要创建新的 UNIX 用户，请执行以下操作：

passwd.add(pkrumins,password,{ createHome : true },function (status) {if (status == 0) {console.log(great success! pkrumins added!);}else {console.log(not so great success! pkrumins not added! useradd command returned: + status);}});

我们将它用于 Browserling 隧道来控制 ssh 用户访问。

github 上的 node-passwd[]

70. 节点-jpeg

Node-jpeg 是一个 C++ 模块，可将 RGB 或 RGBA 缓冲区转换为内存中的 JPEG 图像。它具有同步和异步接口。

github 上的 node-jpeg[]

71. nodejs-代理

Nodejs-proxy 是一个带有 IP 和 URL 访问控制的哑 HTTP 代理。一年前我在我的博客——nodejs http 代理上写过它。

github 上的 nodejs-proxy[]

72. 节点-base64

Node-base64 是一个用于在 node.js 中进行 base64 编码的模块。它是在 node.js 内置 base64 编码之前编写的。

下面是它的工作原理：

var base64_encode = require(base64).encode;var buf = new Buffer(hello world);console.log(base64_encode(buf)); /* Output: aGVsbG8gd29ybGQ= */

github 上的 node-base64[]

73.节点-gif

Node-gif 是一个 C++ nodejs 模块，用于从 RGB 或 RGBA 缓冲区创建 GIF 图像和动画 GIF。

github上的node-gif[]

74. 节点超市

Node-supermarket 是基于 node.js 的 sqlite 的键/值存储。

这是一个例子：

github上的节点超市[]

75. 节点-des

Node-des 是一个 C++ node.js 模块，它进行 DES 加密并且实际工作（节点的加密模块不起作用。）

我们将它与 node-rfb 一起使用来进行 VNC 身份验证。

github上的node-des[]

76.节点-png

Node-png 是一个 C++ 模块，可将 RGB 或 RGBA 缓冲区转换为内存中的 PNG 图像。

github上的node-png[]

77. 节点浏览器

Node-browser 提供了一个浏览器，用于从 node.js 轻松浏览网页（尚未完成。）

完成后，它将像这样工作：

var Browser = require(browser);var browser = new Browser;browser.get(http://www.reddit.com).post( + data.username,{op : login-main,user : data.username,passwd : data.password,id : #login_login-main,renderstyle : html}).get( + data.subreddit).get( + data.subreddit + /submit).post(http://www.reddit.com/api/submit,{uh : todo,kind : link,sr : data.subreddit,url : data.url,title : data.title,id : #newlink,r : data.subreddit,renderstyle : html})

这会登录 reddit 并发布一个故事。

github 上的节点浏览器[]

78. 超市购物车

Supermarket-cart 是一个使用 node-supermarket 的连接[] 会话存储。

github 上的超市购物车[]

79.节点视频

Node-video 是一个 C++ 模块，用于从 RGB 或 RGBA 缓冲区记录 Theora/ogg 视频。

github上的节点视频[]

80. 节点图像

node-image 统一了 node-png、node-jpeg 和 node-gif。

这是一个示例用法：

var Image = require(image);var png = new Image(png).encodeSync(buffer, width, height);var gif = new Image(gif).encodeSync(buffer, widht, height);var jpeg = new Image(jpeg).encodeSync(buffer, width, height);

github上的节点图像[]

81.节点-万用表

万用表控制终端上的多个 ANSI 进度条。

这是控制台的屏幕截图：

我们正在使用这个模块进行测试！

github上的节点万用表[]

82.节点魅力

Node-charm 使用 VT100 ansi 终端字符来写入颜色和光标位置。节点万用表使用它来输出进度条。

github 上的节点魅力[]

83.节点游标

Node-cursory 从发出 ansi 事件的流中计算相对光标位置。

github上的节点游标[]

84. rfb-协议

RFB-protocols 是一个 node.js 模块，用于将各种 RFB 编码（RRE、Hextile、Tight 等）转换为 RGB 缓冲区。不过，目前它只实现了 hextile，我们并没有真正使用它。

rfb 协议在 github[]

85. 节点异步

Node-async 是一个示例 C++ 模块，它展示了如何异步地将两个数字相乘。

github 上的节点异步[]

86.节点缓冲

Node-bufferdiff 是一个用于 node.js 的 C++ 模块，用于快速测试两个缓冲区是否相等。

github 上的 node-bufferdiff[]

87. 节点-jsmin

Node-jsmin 是最初移植到 node.js 的 Doug Crockford 的 JavaScript 最小化器。

github 上的 node-jsmin[]

88. dnode-协议

该模块以可重用的形式实现 dnode 协议，目前用于服务器端和浏览器端的 dnode 代码。

github 上的 dnode 协议[-protocol]

89.python.js

这是在 JavaScript 中的 Python 实现。对于 lulz。

github 上的 python.js[]

90.节点时间

我忘记了 JavaScript 有 Date 对象，所以我把 node-time 写成一个 C++ 模块来获取一些时间信息。

github上的节点时间[]