NodeJS on Dapeng Zhang

Nodejs终于看到一个靠谱的招聘了

Tue, 15 Jul 2025 10:29:19 +0000

Nodejs终于看到一个靠谱的招聘了

找Nodejs工作的快进去看看，我都多久不玩Nodejs了

https://zhuanlan.zhihu.com/p/598748057

Nodejs - 安全版本发布

Mon, 14 Jul 2025 14:50:57 +0000

Nodejs于2020年9月15日安全版本发布

主要的几个版本包括

可以下载安装下试试

npm install v10.22.1

npm install v12.18.4

npm install v14.11.0

具体详情请点击这里查看

by Michael Dawson, 2020-09-15

Nodejs小知识之event（错误事件和仅处理事件一次）三

Fri, 11 Jul 2025 11:16:00 +0000

event - 错误事件和仅处理事件一次

当使用 eventEmitter.on() 注册监听器时，监听器会在每次触发命名事件时被调用。

const EventEmitter = require("events");

const emitter = new EventEmitter();

emitter.on("event", function () {
 console.log("event emitter");
});

emitter.emit("event");
emitter.emit("event");

运行后得到的结果如下

$ node main.js
event emitter
event emitter

使用 eventEmitter.once() 可以注册最多可调用一次的监听器。当事件被触发时，监听器会被注销，然后再调用。

const EventEmitter = require("events");

const emitter = new EventEmitter();

emitter.once("event", function () {
 console.log("event emitter");
});

emitter.emit("event");
emitter.emit("event");

运行后得到的结果如下

$ node main.js
event emitter

（错误事件）Error events

const EventEmitter = require("events");

const emitter = new EventEmitter();

emitter.emit("error", new Error("i am a error"));

运行结果如下

$ node main.js
events.js:174
 throw er; // Unhandled 'error' event
 ^

Error: i am a error
 at Object.<anonymous> (/Users/durban/nodejs/main.js:45:23)
 at Module._compile (internal/modules/cjs/loader.js:778:30)
 at Object.Module._extensions..js (internal/modules/cjs/loader.js:789:10)
 at Module.load (internal/modules/cjs/loader.js:653:32)
 at tryModuleLoad (internal/modules/cjs/loader.js:593:12)
 at Function.Module._load (internal/modules/cjs/loader.js:585:3)
 at Function.Module.runMain (internal/modules/cjs/loader.js:831:12)
 at startup (internal/bootstrap/node.js:283:19)
 at bootstrapNodeJSCore (internal/bootstrap/node.js:623:3)
Emitted 'error' event at:
 at Object.<anonymous> (/Users/durban/nodejs/main.js:45:9)
 at Module._compile (internal/modules/cjs/loader.js:778:30)
 [... lines matching original stack trace ...]
 at bootstrapNodeJSCore (internal/bootstrap/node.js:623:3)

再看下面实例

const EventEmitter = require("events");

const emitter = new EventEmitter();

emitter.on("error", function (error) {
 console.log("i am catch a error");
 console.log(error);
});

emitter.emit("error", new Error("i am a error"));

运行后结果如下

$ node main.js
i am catch a error
Error: i am a error
 at Object.<anonymous> (/Users/durban/nodejs/main.js:77:23)
 at Module._compile (internal/modules/cjs/loader.js:778:30)
 at Object.Module._extensions..js (internal/modules/cjs/loader.js:789:10)
 at Module.load (internal/modules/cjs/loader.js:653:32)
 at tryModuleLoad (internal/modules/cjs/loader.js:593:12)
 at Function.Module._load (internal/modules/cjs/loader.js:585:3)
 at Function.Module.runMain (internal/modules/cjs/loader.js:831:12)
 at startup (internal/bootstrap/node.js:283:19)
 at bootstrapNodeJSCore (internal/bootstrap/node.js:623:3)

event（事件）的简单使用记录再次

Nodejs小知识之event（了解事件的异步和同步）二

Fri, 11 Jul 2025 11:15:45 +0000

现看个简单的关于事件使用的代码

const Emitter = require("events");

const emitter = new Emitter();

emitter.on("event_1", function (name, age) {
 setImmediate(function () {
 console.log("event_1 immediate");
 });

 console.log(`event_1 ${name} age is ${age}`);
});

emitter.on("event_2", function (name, age) {
 setImmediate(function () {
 console.log("event_2 immediate");
 });
 console.log(`event_2 ${name} age is ${age}`);
});

emitter.on("event_3", function (name, age) {
 process.nextTick(function () {
 console.log("event_3 nextTick");
 });

 console.log(`event_3 ${name} age is ${age}`);
});

emitter.emit("event_1", "xiaowang", 20);
emitter.emit("event_2", "xiaoli", 30);
emitter.emit("event_1", "xiaowang2", 20);
emitter.emit("event_2", "xiaoli2", 30);
emitter.emit("event_3", "xiaowei", 29);
emitter.emit("event_3", "xiaowei2", 29);

输出的结果如下

event_1 xiaowang age is 20
event_2 xiaoli age is 30
event_1 xiaowang2 age is 20
event_2 xiaoli2 age is 30
event_3 xiaowei age is 29
event_3 xiaowei2 age is 29
event_3 nextTick
event_3 nextTick
event_1 immediate
event_2 immediate
event_1 immediate
event_2 immediate

从上面的输出结果可以看出，emit触发事件的时候，事件的执行顺序是按照顺序从上到下依次执行（应该可以看作是事件的同步）

event_1 xiaowang age is 20
event_2 xiaoli age is 30
event_1 xiaowang2 age is 20
event_2 xiaoli2 age is 30
event_3 xiaowei age is 29
event_3 xiaowei2 age is 29

再看下这里的输出结果，会发现，无论执行多少次这个顺序是不会变的（应该可以看作是事件的异步）

event_3 nextTick
event_3 nextTick
event_1 immediate
event_2 immediate
event_1 immediate
event_2 immediate

process.nextTick和setImmediate，作为异步处理的函数，居然process.nextTick会比setImmediate的调用更先一步执行

具体的原因可以参考官方的文章《Node.js 事件循环，定时器和 process.nextTick()》

从官方的文章中也得出结果，setImmediate应该多用，process.nextTick应该少用，虽然这需要一个漫长的过程

Nodejs小知识之event（事件）一

Fri, 11 Jul 2025 11:15:41 +0000

大多数 Node.js 核心 API 构建于惯用的异步事件驱动架构，其中某些类型的对象（又称触发器，Emitter）会触发命名事件来调用函数（又称监听器，Listener）。

先看下event（事件）如何使用

const Emitter = require("events");

const emitter = new Emitter();

emitter.on("event", function () {
 console.log("an event occur");
});

emitter.on("event1", function () {
 console.log("an event1 occur");
});

emitter.emit("event");
emitter.emit("event1");

上面我们绑定了两个事件分别为event和event1，然后通过emit分别触发了这两个事件

运行结果如下

an event occur
an event1 occur

事件触发了，那么如何能在触发事件的时候传递参数，看下面的代码

const Emitter = require("events");

const emitter = new Emitter();

emitter.on("run", function (name, distance) {
 console.log(`【${name}】跑了${distance}米`);

 console.log(this);
 console.log(this === emitter);
});

emitter.emit("run", "xiaowang", 20);

输出结果如下

【xiaowang】跑了20米
EventEmitter {
 _events: [Object: null prototype] { run: [Function] },
 _eventsCount: 1,
 _maxListeners: undefined }
true

在这里不建议使用 ES6 Arrow Functions

const Emitter = require("events");

const emitter = new Emitter();

emitter.on("run", (name, distance) => {
 console.log(`【${name}】跑了${distance}米`);

 console.log(this);
 console.log(this === emitter);
});

emitter.emit("run", "xiaowang", 20);

运行结果如下

【xiaowang】跑了20米
{}
false

Node v12.18.3 (LTS) 版本发布

Fri, 11 Jul 2025 10:40:42 +0000

Node v12.18.3 (LTS) 版本发布

发布时间：by Shelley Vohr, 2020-07-22

Notable Changes

deps:
- upgrade npm to 6.14.6 (claudiahdz) #34246
- update node-inspect to v2.0.0 (Jan Krems) #33447
- uvwasi: cherry-pick 9e75217 (Colin Ihrig) #33521

Node v10.22.0 (LTS) 版本发布

Fri, 11 Jul 2025 10:40:33 +0000

Node v10.22.0 (LTS) 版本发布

发布时间：by Bethany Nicolle Griggs, 2020-07-21

This release was prepared by Richard Lau (@richardlau) and promoted by Beth Griggs (@BethGriggs).

Notable changes

deps:
- upgrade npm to 6.14.6 (claudiahdz) #34246
- upgrade openssl sources to 1.1.1g (Hassaan Pasha) #32982
n-api:
- add napi_detach_arraybuffer (legendecas) #29768

原文地址：https://nodejs.org/en/blog/release/v10.22.0/

Node v14.6.0 版本发布

Fri, 11 Jul 2025 10:40:30 +0000

发布时间：by Myles Borins, 2020-07-21

Notable Changes

deps:
- upgrade to libuv 1.38.1 (Colin Ihrig) #34187
- upgrade npm to 6.14.6 (claudiahdz) #34246
- (SEMVER-MINOR) update V8 to 8.4.371.19 (Michaël Zasso) #33579
module:
- (SEMVER-MINOR) doc only deprecation of module.parent (Antoine du HAMEL) #32217
- (SEMVER-MINOR) package “imports” field (Guy Bedford) #34117
src:
- (SEMVER-MINOR) allow embedders to disable esm loader (Shelley Vohr) #34060
tls:
- (SEMVER-MINOR) make ‘createSecureContext’ honor more options (Mateusz Krawczuk) #33974
vm:
- (SEMVER-MINOR) add run-after-evaluate microtask mode (Anna Henningsen) #34023
worker:
- (SEMVER-MINOR) add option to track unmanaged file descriptors (Anna Henningsen) #34303
New Collaborators:
- add danielleadams to collaborators (Danielle Adams) #34360
- add ruyadorno to collaborators (Ruy Adorno) #34297
- add sxa as collaborator (Stewart X Addison) #34338

原文地址：https://nodejs.org/en/blog/release/v14.6.0/

NodeJS命令行下调试运行代码初体验

Fri, 11 Jul 2025 10:40:27 +0000

今天发现一个我很久不知道的功能，虽然我用了很久nodejs，但是这个命令行的功能还是第一次发现，记录下

$ node -v
v10.17.0

简单的测试如下

$ node
> .help
.break Sometimes you get stuck, this gets you out
.clear Alias for .break
.editor Enter editor mode
.exit Exit the repl
.help Print this help message
.load Load JS from a file into the REPL session
.save Save all evaluated commands in this REPL session to a file
> .editor
// Entering editor mode (^D to finish, ^C to cancel)
let a = 2
b = a
console.log(b)

2
undefined
> .editor
// Entering editor mode (^D to finish, ^C to cancel)
'use strict';
let a = 2
b = a
console.log(b)

Thrown:
SyntaxError: Identifier 'a' has already been declared
> b = a
2
> .editor
// Entering editor mode (^D to finish, ^C to cancel)
'use strict'

let m = 2
n = m
console.log(n)

Thrown:
ReferenceError: n is not defined
>

如果你使用v12.18.1或者更高的版本应该体验会更好一些，不知道v10.17.0 - v12.18.1之间的版本有没有区别，这个没有测试过试下v12.18.1版本的

$ node
Welcome to Node.js v12.18.1.
Type ".help" for more information.
> process.version
'v12.18.1'
> os.type()
'Darwin'
> os.arch()
'x64'
>
(To exit, press ^C again or ^D or type .exit)
>

很明显的是进入命令行之后，多了

Welcome to Node.js v12.18.1.
Type ".help" for more information.

是不是nodejs变的很友好

$ node
Welcome to Node.js v12.18.1.
Type ".help" for more information.
> .help
.break Sometimes you get stuck, this gets you out
.clear Alias for .break
.editor Enter editor mode
.exit Exit the repl
.help Print this help message
.load Load JS from a file into the REPL session
.save Save all evaluated commands in this REPL session to a file

Press ^C to abort current expression, ^D to exit the repl
> .editor
// Entering editor mode (^D to finish, ^C to cancel)
let a = 1;
let b = a;
console.log(b);

1
undefined
> .exit

.load这个命令感觉很有意思，尝试下

文件代码如下

let hash = "83108adff87ba432cd03d15f9f82db16";
function enHash(key) {
 key = key instanceof Buffer ? key : new Buffer(key);
 var p = 16777619; // 32
 var hash = 0x811C9DC5;

 for (var i = 0; i < key.length; i++) {
 console.log(hash * p + '======' + key[i]);
 console.log((hash * p) ^ key[i]);
 hash = (hash * p) ^ key[i];
 }

 hash += hash << 13;
 hash ^= hash >> 7;
 hash += hash << 3;
 hash ^= hash >> 17;
 hash += hash << 5;

 return hash;
}

let enHashStr = enHash(hash);
console.log('enHashStr =',enHashStr);

启动加载下试试

$ node
Welcome to Node.js v12.18.1.
Type ".help" for more information.
> .load
Failed to load:
> .load /Users/durban/nodejs/test.js
let hash = "83108adff87ba432cd03d15f9f82db16";
function enHash(key) {
 key = key instanceof Buffer ? key : new Buffer(key);
 var p = 16777619; // 32
 var hash = 0x811C9DC5;

 for (var i = 0; i < key.length; i++) {
 console.log(hash * p + '======' + key[i]);
 console.log((hash * p) ^ key[i]);
 hash = (hash * p) ^ key[i];
 }

 hash += hash << 13;
 hash ^= hash >> 7;
 hash += hash << 3;
 hash ^= hash >> 17;
 hash += hash << 5;

 return hash;
 }

 let enHashStr = enHash(hash);
 console.log('enHashStr =',enHashStr);
36342608889142560======56
84696344
1421002990324936======51
175541499
2945168388910881======49
1939861264
32546253200250416======48
348476928
5846613128274432======56
-1297718728
-21772630387548630======97
1944886857
32630570684853484======100
-964875128
-16188307280160232======102
-15918466
-267073957612454======102
-6245316
-104781532382604======56
-1510229428
-25338053945571932======55
-1757002349
-29478315993627030======98
-1231059446
-20654246351339070======97
-2027945567
-34024098075864972======52
1482854464
24878767229441216======51
1663636723
27911863092902536======50
212597434
3566878748029646======99
-1396985171
-23438084947687850======100
-1736817092
-29139655442263948======48
1149014084
19277720526985996======51
337058623
5655041157358637======100
-547363767
-9183460737130772======49
-319529251
-5360940032633369======53
-508471854
-8530947038635626======102
472521200
7927780663022800======57
1179047145
19781603781847756======102
-1971246422
-33072821423429216======56
-1286198888
-21579354901087670======50
-391939462
-6575810964500978======100
-1285960086
-21575348372115230======98
-1067454334
-17909342115750746======49
1493671063
25060244006338996======54
-1107590782
enHashStr = 389970291
undefined
> (node:37594) [DEP0005] DeprecationWarning: Buffer() is deprecated due to security and usability issues. Please use the Buffer.alloc(), Buffer.allocUnsafe(), or Buffer.from() methods instead.

>
>

有点像Python了，OMG。

TypeScript 3 + Koajs + Node.js

Wed, 09 Jul 2025 10:42:24 +0000

自NodeJS早期以来，Express一直是NodeJS开发人员事实上的标准Web框架。
但是，JavaScript在过去几年中已经走过了漫长的道路，像promises和async函数这样的功能使得构建更小，更强大的Web框架成为可能。

Koa就是这样一个框架。
它由Express背后的团队构建，以利用最新的JavaScript和NodeJS功能，特别是异步功能。

与Express和其他node框架（如Hapi）不同，Koa不需要使用回调。
这消除了难以跟踪的错误的巨大潜在来源，并使框架非常容易为新开发人员选择。

在本文中，我将向您介绍如何使用Koa和TypeScript来开发新的Web应用程序项目

第一步、安装和配置

Koa需要一个具有异步功能支持的Node版本，因此在开始之前确保安装了Node 8.x（或更高版本）。
Node 8将于2017年10月成为新的长期支持版本，因此它是启动新项目的绝佳选择。

我们现在将创建一个安装了以下内容的新node项目：

Koa
Koa Router
TypeScript
TS-Node 和 Nodemon(用于在开发期间自动构建和重启)

为项目创建一个新文件夹，然后执行以下命令：

npm init # and follow the resulting prompts to set up the project
npm i koa koa-router
npm i --save-dev typescript ts-node nodemon
npm i --save-dev @types/koa @types/koa-router

现在，在项目的根目录中，创建一个新的tsconfig.json文件并添加以下内容：

{
 "compilerOptions": {
 "module": "commonjs",
 "target": "es2017",
 "noImplicitAny": true,
 "outDir": "./dist",
 "sourceMap": true
 },
 "include": [
 "./src/***/*",
 ]
}

请注意，我们将TypeScript配置为转换为ES2017 - 这可确保我们利用Node的本机async/await功能。

第二步、创建服务器

由于Koa的核心是微框架，因此启动和运行它非常简单。在项目目录中，创建一个src文件夹，在其中创建一个新文件：server.ts，其中包含以下内容：

import * as Koa from 'koa';
import * as Router from "koa-router";

const app = new Koa();
const router = new Router();

router.get('/*', async (ctx) => {
 ctx.body = "Hi TS";
})

app.use(router.routes());

app.listen(8080);

console.log("Server running on port 8080");

第三步、使用Nodemon和TS-Node运行服务器

在开发过程中，每次进行更改时都要记住重新启动服务器会很麻烦，所以我想设置我的服务器端项目以自动重新启动代码更改。

为此，我们将向我们的项目添加watch-server npm脚本。
为此，请将以下内容添加到package.json的"scripts"部分：

"watch-server": "nodemon --watch 'src/***/*' -e ts,tsx --exec 'ts-node' ./src/server.ts"

现在开始新的TypeScript Koa项目，只需执行以下操作即可

npm run watch-server

您应该看到以下输出：

> xx@xx watch-server /Users/durban/nodejs/ts_node_koa_blog
> nodemon --watch 'src/***/*' -e ts,tsx --exec 'ts-node' ./src/server.ts

[nodemon] 1.18.4
[nodemon] to restart at any time, enter `rs`
[nodemon] watching: src/***/*
[nodemon] starting `ts-node ./src/server.ts`
Server running on port 8080

现在您应该能够在浏览器中访问http//localhost:8080/ :)

第四步、构建应用程序 - 添加中间件

主要的Koa库只包含基本的HTTP功能。
要构建完整的Web应用程序，我们需要添加适当的中间件，例如Logging, Error Handling, CSRF Protection等。在Koa中，中间件本质上是一堆函数，通过app.use()创建。
收到Web请求后，它将传递给堆栈中的第一个函数。
该函数可以处理请求，然后可选地将其传递给下一个中间件函数。
让我们将上面的示例扩展为包含一个中间件函数，该函数将每个Web请求的URL记录到控制台：

import * as Koa from 'koa';
import * as Router from "koa-router";

const app = new Koa();

app.use(async (ctx, next) => {
 // Log the request to the console
 console.log("Url: ", ctx.url);

 // Pass the request to the next middleware function
 await next();
})

const router = new Router();

router.get('/*', async (ctx) => {
 ctx.body = "Hi TS";
})

app.use(router.routes());

app.listen(8080);

console.log("Server running on port 8080");

在上面的示例中，我们现在定义两个中间件函数：

第一个中间件函数从请求上下文(ctx.url)获取Url，并使用console.log()将其输出到控制台
然后该函数await next()，告诉Koa将请求传递给堆栈中的下一个中间件函数
第二个中间件函数来自koa-router - 它使用请求的url来匹配我们通过router.get()配置的路由现在，当您在浏览器中访问http://localhost:8080/时，您应该看到类似于以下内容的输出：

> xx@xx watch-server /Users/durban/nodejs/ts_node_koa_blog
> nodemon --watch 'src/***/*' -e ts,tsx --exec 'ts-node' ./src/server.ts

[nodemon] 1.18.4
[nodemon] to restart at any time, enter `rs`
[nodemon] watching: src/***/*
[nodemon] starting `ts-node ./src/server.ts`
Server running on port 8080
Url: /
Url: /
Url: /blog
Url: /blog

第五步、标准中间件

显然，你真的不想为你的网络应用重新发明轮子。
根据您要创建的应用程序类型，以下中间件可能很有用：

Koa路由器
https://github.com/alexmingoia/koa-router

Koa Body Parser（用于JSON和Form Data支持）
https://github.com/dlau/koa-body

Koa Cross-Site-Request-Forgery（CSRF）预防
https://github.com/koajs/csrf

Koa Examples（许多有用的东西，包括错误处理）
https://github.com/koajs/examples

我已经创建了一个基本的TypeScript和Koa项目。可以进行后面自己感兴趣的开发了。

TypeScript 3 + Express + Node.js

Wed, 09 Jul 2025 10:42:21 +0000

第一步、安装需要的配置

首先，我们将使用node包管理器（npm）来为我们的应用程序安装依赖项。
Npm与Node.js一起安装。
如果您还没有安装Node.js，可以通过homebrew程序完成。

安装Homebrew并更新它：

$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
$ brew update
$ brew doctor

然后使用brew install命令安装node

brew install node

第二步、创建项目

接下来，让我们使用npm init命令创建一个新项目。

$ mkdir ts_node_blog
$ cd ts_node_blog
$ npm init

在回答提示后，您将在项目文件夹中有一个新的package.json文件。
我们也添加一些自定义脚本。

首先，添加开发脚本。
这将使用nodemon模块来监视对快速Web应用程序的源文件的任何更改。
如果文件更改，那么我们将重新启动服务器。
接下来，添加grunt脚本。
这只是调用grunt任务运行器。
我们将在本教程后面安装它。
最后，添加启动脚本。
这将使用node来执行bin/www文件。
如果您使用的是Linux或Mac，则package.json文件应如下所示：

{
 "name": "ts_node_blog",
 "version": "1.0.0",
 "description": "The blog of typescript + nodejs + express",
 "main": "app.js",
 "scripts": {
 "dev": "NODE_ENV=development nodemon ./bin/www",
 "grunt": "grunt",
 "start": "node ./bin/www",
 "test": "echo \"Error: no test specified\" && exit 1"
 },
 "keywords": [
 "typescript",
 "noejs",
 "blog"
 ],
 "author": "durban.zhang <[email protected]>",
 "license": "MIT"
}

如果您使用的是Windows，则package.json文件应如下所示：

{
 "name": "ts_node_blog",
 "version": "1.0.0",
 "description": "The blog of typescript + nodejs + express",
 "main": "app.js",
 "scripts": {
 "dev": "SET NODE_ENV=development nodemon ./bin/www",
 "grunt": "grunt",
 "start": "node ./bin/www",
 "test": "echo \"Error: no test specified\" && exit 1"
 },
 "keywords": [
 "typescript",
 "noejs",
 "blog"
 ],
 "author": "durban.zhang <[email protected]>",
 "license": "MIT"
}

请注意Windows用户对dev脚本的微小更改。

第三步、安装Express

下一步是安装Express依赖项。
我在我的npm install命令中包含了–save标志，以便将依赖项保存在package.json文件中。

$ npm install express --save
$ npm install @types/express --save-dev

请注意，这还会在项目中生成新的node_modules文件夹。
如果您使用Git，则应将此文件夹添加到.gitignore文件中。

第四步、启动脚本的配置

接下来我们需要创建我们的启动脚本。
如果您还记得，我们在package.json文件的scripts配置中指定了一个start属性。
我将其值设置为：“node ./bin/www”。
所以，让我们在：bin/www创建一个空文件

$ mkdir bin
$ cd bin
$ touch www

以下是www文件的完整内容：

#!/usr/bin/env node
"use strict";

const server = require("../dist/server");
const debug = require("debug")("express:server");
const http = require("http");

const httpPort = normalizePort(process.env.Port || 8080);
const app = server.Server.bootstrap().app;
app.set("port", httpPort);
const httpServer = http.createServer(app);

httpServer.listen(httpPort);

httpServer.on("error", onError);

httpServer.on("listening", onListening);

function normalizePort(val) {
 const port = parseInt(val, 10);

 if (isNaN(port)) {
 return val;
 }

 if (port >= 0) {
 return port;
 }

 return false;
}

function onError(error) {
 if (error.syscall !== "listen") {
 throw error;
 }

 const bind = typeof httpPort === 'string'
 ? "Pipe " + httpPort
 : "Port " + httpPort;

 switch(error.code) {
 case "EACCES":
 console.error(bind + " requires elevated privileges");
 process.exit(1);
 break;
 case "EADDRINUSE":
 console.error(bind + " alreay is use");
 process.exit(1);
 break;
 default:
 throw error;
 }
}

function onListening() {
 const addr = httpServer.address();
 const bind = typeof httpPort === 'string'
 ? "Pipe " + httpPort
 : "Port " + httpPort;
 debug("Listening on " + bind);
}

这有点长。所以，让我打破这一点并解释每个部分。

#!/usr/bin/env node
"use strict";

const server = require("../dist/server");
const debug = require("debug")("express:server");
const http = require("http");

首先，我们有node shebang来执行这个脚本。如果您使用的是Windows，只需将此文件重命名为www.js，node将根据文件扩展名执行此操作。

然后我们通过“use strict”命令启用严格模式。

然后我需要一些依赖。首先，我将在：dist/server.js中有一个模块（文件）。我们还没有创建这个，所以不要担心。然后我们需要express和http模块。

const httpPort = normalizePort(process.env.Port || 8080);
const app = server.Server.bootstrap().app;
app.set("port", httpPort);
const httpServer = http.createServer(app);

首先，我确定将http服务器绑定到的端口，并监听。这将首先检查PORT环境变量，然后默认为8080。

我还使用了由Google Cloud Platform团队提供的normalizePort()函数。我从他们的示例应用程序中借用了这些。

接下来，我将使用bootstrap()老启动我的应用程序。在创建Server类之后，这将更有意义。

然后我为HTTP服务器设置端口。

最后我们创建了http服务器，传入我们的express app。

httpServer.listen(httpPort);

httpServer.on("error", onError);

httpServer.on("listening", onListening);

在这部分中，我将指定我们的http服务器将侦听的端口，然后我附加一些事件处理程序。
我正在听error和listening事件。
在创建应用程序期间发生错误时将触发错误事件。
当http服务器启动并正在侦听指定端口时，将触发侦听事件。

第五步、安装TypeScript 和 Grunt

接下来，使用npm install命令安装TypeScript：

$ npm install typescript --save-dev

我将使用Grunt任务运行器来编译TypeScript源代码。
使用npm安装grunt：

$ npm install grunt --save-dev

现在我们安装了grunt，让我们安装一些任务运行器：

$ npm install grunt-contrib-copy --save-dev
$ npm install grunt-ts --save-dev
$ npm install grunt-contrib-watch --save-dev

grunt-contrib-copy任务运行器将./public和./views目录中的文件复制到./dist目录中
我们将使用grunt-ts任务来编译TypeScript源代码。
我们将使用grunt-contrib-watch来监视对TypeScript源文件的任何更改。
当一个文件更新（或保存）文件后，我想重新编译我的应用程序。
结合我们之前在package.json文件中创建的dev脚本，我们将能够轻松地对TypeScript源进行更改，然后立即在浏览器中查看更改。

第六步、创建gruntfile.js

下一步是配置Grunt来编译我们的TypeScript源代码。
首先，在应用程序根目录中创建gruntfile.js文件。

$ touch gruntfile.js

在您喜欢的编辑器中打开gruntfile.js文件。我使用Visual Studio Code。gruntfile.js文件内容如下

module.exports = function(grunt) {
 "use strict";

 grunt.initConfig({
 copy: {
 build: {
 files: [
 {
 expand: true,
 cwd: './public',
 src: ["**"],
 dest: "./dist/public",
 },
 {
 expand: true,
 cwd: './views',
 src: ["**"],
 dest: "./dist/views",
 },
 ]
 }
 },
 ts: {
 app: {
 files: [
 {
 src: ["src/\*\*/\*.ts", "!src/.baseDir.ts"],
 dest: "./dist",
 }
 ],
 options: {
 module: "commonjs",
 target: "es6",
 sourceMap: false,
 rootDir: "src",
 }
 }
 },
 watch: {
 ts: {
 files: ["src/\*\*/\*.ts"],
 tasks: ["ts"],
 },
 views: {
 files: ["views/\*\*/\*.pug"],
 tasks: ["copy"],
 }
 }
 });

 grunt.loadNpmTasks("grunt-contrib-copy");
 grunt.loadNpmTasks("grunt-contrib-watch");
 grunt.loadNpmTasks("grunt-ts");

 grunt.registerTask("default", [
 "copy",
 "ts",
 ]);
};

以下是gruntfile.js的说明：

使用exports对象，我们将导出一个将由grunt任务运行器调用的函数。这是非常标准的。它有一个名为grunt的参数。
遵循最佳实践我正在启用严格模式。
然后我们调用grunt.initConfig()方法并传入我们的配置对象。
在我们的配置对象中，我们指定每个任务
第一项任务是复制。此任务将复制./public和./views目录中的文件。
接下来的任务是ts。此任务将TypeScript源代码编译为可由Node.js执行的JavaScript。已编译的JavaScript代码将输出到./dist目录。
第三项任务是观察。此任务将监视对TypeScript源文件（*.ts）以及视图模板文件（*.pug）的任何更改。

如果一切正常，您应该能够执行grunt命令

$ npm run grunt

你应该看到这样的事情：

> [email protected] grunt /Users/durban/nodejs/ts_node_blog
> grunt

Running "copy:build" (copy) task

Running "ts:app" (ts) task
No files to compile

Done.

第七步、安装中间件

在我们创建server.ts模块之前，我们需要安装一些更多的依赖项。
我在此示例Express应用程序中使用以下中间件：

body-parser[https://github.com/expressjs/body-parser]
cookie-parser[https://github.com/expressjs/cookie-parser]
morgan[https://github.com/expressjs/morgan]
errorhandler[https://github.com/expressjs/errorhandler]
method-override[https://github.com/expressjs/method-override]

您可以使用上面的链接阅读有关这些内容的更多信息。让我们继续，通过npm安装这些：

$ npm install body-parser --save
$ npm install cookie-parser --save
$ npm install morgan --save
$ npm install errorhandler --save
$ npm install method-override --save

我们还需要为这些模块安装TypeScript声明文件。
在TypeScript 3之前，您必须使用名为Typings的开源项目。
现在不再是这种情况，因为TypeScript 3极大地改进了对第三方模块声明（或头文件）的支持。

让我们使用npmjs.org上的@ types/repository安装TypeScript声明文件：

$ npm install @types/cookie-parser --save-dev
$ npm install @types/morgan --save-dev
$ npm install @types/errorhandler --save-dev
$ npm install @types/method-override --save-dev

第八步、创建Server类

首先，为TypeScript代码创建一个src目录，然后创建一个新的server.ts文件。

我们准备好在Node.js上使用Express启动我们的新HTTP服务器。
在我们这样做之前，我们需要创建我们的Server类。
这个类将配置我们的express Web application，会涉及到REST API和routes的类。下面是定义我们的Server类的server.ts文件的开头：

import * as bodyParser from "body-parser";
import * as cookieParser from "cookie-parser";
import * as express from "express";
import * as logger from "morgan";
import * as path from "path";
import errorHandler = require("errorhandler");
import merhodOverride = require("method-override");

/**
 * The Server 
 * 
 * @class Server
 */
export class Server {
 public app: express.Application;

 /**
 * Bootstrap the application
 * 
 * @class Server
 * @method bootstrap
 * @static
 * @return Returns the newly created injector for this app. Returns the newly created injector for this app.
 */
 public static bootstrap(): Server {
 return new Server();
 }

 /**
 * Constructor
 * 
 * @class Server
 * @method constructor
 */
 constructor() {
 // create express application
 this.app = express();

 // configure application
 this.config();

 // add routes
 this.routes();

 // add api
 this.api();
 }

 /**
 * Create REST Api routes
 * 
 * @class Server
 * @method api
 */
 public api() {

 }

 /**
 * Configure application
 * 
 * @class Server
 * @method config
 */
 public config() {

 }

 /**
 * Create router
 * 
 * @class Server
 * @method router
 */
 public routes() {

 }
}

让我们深入研究Server.ts模块（文件）中的Server类。

导入

import * as bodyParser from "body-parser";
import * as cookieParser from "cookie-parser";
import * as express from "express";
import * as logger from "morgan";
import * as path from "path";
import errorHandler = require("errorhandler");
import merhodOverride = require("method-override");

首先，我们导入我们以前安装的中间件和必要的模块。
body-parser中间件将JSON有效负载数据解析为可在我们的express应用程序中使用的req.body对象。
cookie-parser中间件类似于body-parser，因为它解析用户的cookie数据并在req.cookies对象中使用它。
然后我们导入express模块。这是express框架。
我正在使用morgan HTTP logger 中间件。这应该只在开发期间使用。
然后我导入path模块。我将使用它来为config()方法中的public和views目录设置路径目录。
errorhandler 中间件将在开发期间处理错误。同样，这不应该用于生产。相反，您需要记录错误，然后向用户显示错误指示。
最后，我使用method-override中间件。您可能不需要这个，但在REST API配置中使用"PUT"和"DELETE"HTTP谓词时需要这样做。

Server类

/**
 * The Server 
 * 
 * @class Server
 */
export class Server {
 public app: express.Application;

 /**
 * Bootstrap the application
 * 
 * @class Server
 * @method bootstrap
 * @static
 * @return Returns the newly created injector for this app. Returns the newly created injector for this app.
 */
 public static bootstrap(): Server {
 return new Server();
 }
}

接下来，我们创建一个名为Server的新类。
我们的类有一个名为app的公共变量。
请注意，我们的应用程序是express.Application类型。
在Server类中，我有一个名为bootstrap()的静态方法。
这在我们的www启动脚本中调用。
它只是创建Server类的新实例并返回它。

constructor函数

/**
 * Constructor
 * 
 * @class Server
 * @method constructor
 */
constructor() {
 // create express application
 this.app = express();

 // configure application
 this.config();

 // add routes
 this.routes();

 // add api
 this.api();
}

在constructor()函数中，我通过创建一个新的express应用程序来设置app属性的值。
然后我调用Server类中定义的一些方法来配置我的应用程序并创建我的应用程序的REST API和HTTP路由。
现在这些都是空的。

此时您可能想要测试一下。
虽然我们还没有配置HTTP服务器，但我们应该能够使用grunt编译我们的TypeScript：

$ npm run grunt

您应该看到编译成功完成的指示：

$ npm run grunt

> [email protected] grunt /Users/durban/nodejs/ts_node_blog
> grunt

Running "copy:build" (copy) task

Running "ts:app" (ts) task
Compiling...
Using tsc v3.0.3

TypeScript compilation complete: 2.65s for 1 TypeScript files.

Done.

第九步、配置Server

下一步是在我们的Server类中实现config()方法：

public config() {
 // add static paths
 this.app.use(express.static(path.join(__dirname, 'public')));

 this.app.set('trust proxy', true);
 // configure pug
 this.app.set('views', path.join(__dirname, "views"));
 this.app.set("view engine", "pug");

 // use logger middleware
 this.app.use(logger("dev"));

 // use json form parse middleware
 this.app.use(bodyParser.json());

 // use query string parser middleware
 this.app.use(bodyParser.urlencoded({
 extended: true,
 }));

 // use cookie parser middleware
 this.app.use(cookieParser("SECRET_TS_NODE_BLOG"));

 // use override middleware
 this.app.use(methodOverride());

 // catch 404 and forward to error handler
 this.app.use(function(err: any, req: express.Request, res: express.Response, next: express.NextFunction) {
 err.status = 404;
 next(err);
 });

 // use handling
 this.app.use(errorHandler());
}

关于config()方法的一些注意事项：

首先，我在/public设置静态路径。位于./public文件夹中的任何文件都可以公开访问（duh）。
接下来，我配置了pug模板引擎。我们将在一分钟内完成安装。我们所有的pug模板文件都位于./views目录中。
然后我们添加morgan logger中间件。
然后我们添加了body-parser中间件来解析JSON以及查询字符串。
然后我们添加cookie-parser中间件。
然后我们添加方法覆盖中间件。
最后，我们添加一些代码来捕获404错误以及任何应用程序异常。

如上所述，我们正在使用pug(哈巴狗)模板引擎。
但是，在我们使用它之前，我们需要通过npm安装它：

$ npm install pug --save

我们还应该创建public和views目录：

$ mkdir public
$ mkdir views

这是我们的目录结构应该是这样的：

.
├── bin
│ └── www
├── dist
│ └── server.js
├── gruntfile.js
├── package-lock.json
├── package.json
├── public
├── src
│ └── server.ts
└── views

现在我们的服务器已配置，我们应该能够编译我们的TypeScript源代码并启动node HTTP服务器：

$ npm run grunt
$ npm start

然后，您应该看到该node正在运行：

> [email protected] start /Users/durban/nodejs/ts_node_blog
> node ./bin/www

现在启动浏览器并转到http//localhost:8080。
如果一切正常，您应该在浏览器中看到以下消息：

这是因为我们还没有定义任何route。
让我们继续。

第十步、创建BaseRoute类

现在我们的服务器已配置并运行，我们已准备好开始构建我们的Web应用程序的路由。
但是，你可能会问自己route是什么。
好吧，根据Express文档：

Routing refers to determining how an application responds to a client request to a particular endpoint, which is a URI (or path) and a specific HTTP request method (GET, POST, and so on).

首先，让我们创建一个带有两个新文件的./src/routes目录：route.ts和index.ts。

$ cd ./src
$ mkdir routes
$ cd routes
$ touch route.ts
$ touch index.ts

route.ts模块将导出BaseRoute类。
所有路由类都将扩展BaseRoute。
让我们来看看route.ts的内容。

import { NextFunction, Request, Response } from "express";

/**
 * BaseRoute
 * 
 * @class BaseRoute
 */
export class BaseRoute {
 protected title: string;

 private scripts: string[];

 /**
 * Constructor
 * 
 * @class BaseRoute
 * @method constructor
 */
 constructor() {
 this.title = "TS Blog";
 this.scripts = [];
 }

 /**
 * Add a JS external file to the request
 * 
 * @class BaseRoute
 * @method addScript
 * @param src {string} The src to the external JS file
 * @return {BaseRoute} The self for chaining
 */
 public addScript(src: string): BaseRoute {
 this.scripts.push(src);
 return this;
 }

 public render(req: Request, res: Response, view: string, options?: Object) {
 // add constants
 res.locals.BASE_URL = "/";

 // add scripts 
 res.locals.scripts = this.scripts;

 // add title
 res.locals.title = this.title;

 res.render(view, options);
 }
}

BaseRoute目前相当薄。但是，这将作为一种在我的应用程序中实现身份验证的方法，以及所有路由可能需要的许多其他功能。

我有一个标题字符串变量，它将保存路径的标题。

作为示例，BaseRoute当前存储特定路由所必需的脚本数组。可能还希望在BaseRoute中定义所有路径都需要的脚本。这只是一部分特性在BaseRoute中实现的一个示例，该功能将可用于所有路由。

此外，BaseRoute类有一个render()方法。这将在我们的扩展类中的每个路由方法中调用。这为我们提供了一种方法来渲染视图，并定义了常见的本地模板变量。

在此示例中，我将BASE_URL，脚本和标题设置到每个视图中。

第十一步、创建IndexRoute类

路由定义通过以下方式定义：

app.METHOD(PATH, HANDLER)

METHOD是适当的HTTP动词，例如get或post。该方法应为小写。PATH是请求的URI路径。并且，HANDLER是在路线匹配时执行的功能。index.ts模块将导出IndexRoute类。
我们来看看index.ts的内容。

import { NextFunction, Request, Response, Router } from "express";
import { BaseRoute } from "./route";

/**
 * IndexRoute
 * 
 * @class IndexRoute
 */
export class IndexRoute extends BaseRoute {
 /**
 * Constructor
 * 
 * @class IndexRoute
 * @method constructor
 */
 constructor() {
 super();
 }

 /**
 * Create the router
 * 
 * @class IndexRoute
 * @method create
 * @static
 * @param router 
 */
 public static create(router: Router) {
 console.log("[IndexRoute::create] Creating index route");

 // add home page route
 router.get("/", (req: Request, res: Response, next: NextFunction) => {
 new IndexRoute().index(req, res, next);
 })
 }

 /**
 * The home page route
 * 
 * @class IndexRoute
 * @method index
 * @param req {Request} The express Request Object.
 * @param res {Response} The express Response Object.
 * @param next {NextFunction} Execute the next method.
 */
 public index(req: Request, res: Response, next: NextFunction) {
 // set custom title
 this.title = "Home | TS Blog";

 let options: Object = {
 "message": "Welcome to the TS Blog",
 };

 // render template
 this.render(req, res, "index", options);
 }
}

我们来看看IndexRoute类：

首先，我们从express模块导入NextFunction，Request，Response和Router类。
我还从routes模块导入BaseRoute类。
create()静态方法创建所有将在类中定义的路由。在这个例子中，我只定义了一个路由。但是，您可能会为应用程序的部分定义多个路由。例如，UsersRoute类可能具有/users/signin/users/signup等的路由。
constructor()函数只是调用BaseRoute的构造函数。
index()函数将呈现我们的模板。在我们渲染模板之前，我们设置一个自定义标题，并定义一个名为options的对象，其中包含将在我们的模板中可用的属性和值。在这个例子中，我设置一个名为message的本地模板变量，其中包含一个简单的字符串。我将在index.pug模板中输出。

第十二步、定义routes

现在我们已经创建了第一个路由的shell，我们需要在Server类中定义它。
但是，在我们定义路由之前，让我们首先通过以下方式在server.ts模块中导入我们的IndexRoute类：

import { IndexRoute } from "./routes/index";

然后，让我们在server.ts模块中实现routes()方法：

/**
 * Create router
 * 
 * @class Server
 * @method router
 */
public routes() {
 let router: express.Router;
 router = express.Router();

 // IndexRoute
 IndexRoute.create(router);

 // use router middleware
 this.app.use(router);
}

在routes()方法中，我们创建了express.Router()实例。
然后，我们调用静态IndexRoute.create()方法并传入路由器实例。
最后，我们将路由器中间件添加到我们的应用程序中。

第十三步、创建Template

现在我们已经创建并定义了路由，我们需要创建必要的模板。
在这个例子中，我将在views目录中创建一个index.pug文件。

$ cd ./views
$ touch index.pug

这是我的示例index.pug文件的样子：

html
 head
 title= title
 body
 h1= message

第十四步、启动服务

我们完成了。我们为使用TypeScript源代码中的Express开发应用程序奠定了坚实的基础。下一步是编译并启动服务器。

$ npm run grunt
$ npm start

现在启动浏览器并转到http://localhost:8080。
如果一切正常，您应该在浏览器中看到以下消息：

第十五步、安装nodemon

如果你想启动我的node服务器来监视源代码的任何变化（在开发中），那么我建议你使用nodemon

$ npm install nodemon --save-dev

然后我们可以运行我们在package.json中定义的自定义开发脚本来启动我们的应用程序使用nodemon：

$ npm run dev

参考资料

https://brianflove.com/2016/11/11/typescript-2-express-mongoose-mocha-chai/

Nodejs新版本8.9.0和9.2.0更新啦

Fri, 04 Jul 2025 11:47:55 +0000

这个11月，Nodejs新版本更新了，欢呼雀跃呀。

记得大概从2014年刚开始接触，到进入新公司后正式使用Nodejs已经有大概会3年了，大概也算是我比较喜欢的语言中的一种。

第一次接触的时候，就基本上只是用来运行js脚本，当时爬取网站的时候，有很多js的调用，需要运行后才有结果，当时自己还只是在用PHP，重写的话有相当的耗时，于是就有了第一次接触，之后断断续续就没有怎么接触了。

第二次接触是在进入奇鸟后，认识了磊哥，于是又开始了Nodejs之旅，这回让我对js有了重新的认识，以往的普通语法认知和视野认知进入到了一个更深的层面。

当时记得做一个逻辑，需要查询数据库，然后需要根据查询的结果做逻辑处理，要是知道，js的特性，那个时候就是一层层的嵌套，后来在使用过程中，了解到了co，async之类的库，就摆脱了一层一层剥洋葱的感觉，也学会了原来，还可以有这样的库能够被使用

比如下面这样一层一层深入

connection.query(sql, function(data, function(err, callback) {
 if (err) {
 return callback();
 }

 if (data) { // 具体的逻辑处理
 connection.query(sql, function(data, function(err, callback) {
 // 具体的逻辑处理 可能还有其他的需求
 });
 }
})

下面试用co跟async的方法

async.waterfall([
 function(callback) {
 if (accessToken) {
 getUidByToken(accessToken, function(err, uid) {
 if (err) {
 return callback(null, 0);
 }
 callback(null, uid);
 })
 } else {
 callback(null, 0);
 }
 },
 function(uid, callback) {
 var sql = `... where user_id = uid`;
 mysql.query({sql: sql}, function(err, row) {
 callback(err, row);
 })
 }
 ], function(err) {
 if (err) {
 return next(err);
 }
 res.json(OKPacket);
});

co(function* () {
 let _isAdmin = yield Promise.resolve(true);
 if (!_isAdmin) {
 throw new Error('Admin only.');
 }
 let sql = ``;
 yield mysql.queyr(sql);
})
.then(val => res.json({suceess: true, data: []}))
.catch(e => next(e));

是不是感觉要比一层一层深入要好很多，虽然是这样，但是依然不能达到自己去深入Nodejs这块的学习。

后来又了解到了koajs，感觉自己时刻跟不上时代的进步，仅仅不到一年的时间，各种新的技术如雨后春笋般，一个一个冒出来。

后来又接触到了Reactjs，ReactNative，Webpack，Gulp，Grunt，Pm2等，短短的时间内感觉自己提升了好几个级别。

但是Nodejs中的各种新的语法也在渐渐的完善。

如今我自己写的代码，大部分是使用了Babel进行了编译后去运行，毕竟使用的版本中很多新的语法还不支持。

比如这个，就是目前我使用了8.9.1这个版本后的.babelrc配置文件

{
 "plugins": [
 'transform-es2015-modules-commonjs',
 ]
}

对比下以前的

{
 "presets": ["es2015"],
 "plugins": [
 'transform-async-to-generator',
 'transform-strict-mode',
 'transform-object-assign',
 'transform-class-properties',
 'transform-export-extensions',
 'transform-runtime',
 'transform-decorators-legacy'
 ]
}

感觉瞬间清爽了许多，应该在开发中，每次写完代码进行编译的速度都快了很多。再过几年import/export被支持的时候，就彻底释放了。

感觉Nodejs这种语言很随意又很严格，随意就是，你可以啥也不管，只能运行就行，可以使用原来的方式。

严格就是，当你对自己严格的时候，你的代码也会严格起来，而且严格的结果就是感觉新的血液不停的在沸腾。

Nodejs 中解决 no-await-in-loop

Thu, 03 Jul 2025 17:37:49 +0000

在使用nodejs中的async/await方法的时候，在map,forEach中使用await的时候，eslint总是提示我no-await-in-loop。对于我比较喜欢正规写代码的人讲，忍受不了这种错误提示。最终还是找到了解决办法。

一般什么情况会有这个错误的呢，如下

async test() {
 const testData = [1, 2, 3];
 testData.forEach((v) => {
 // 这里就会提示 no-await-in-loop
 const res = await getItem(v); // 假设这里的getItem是一个Promise 
 })
}

解决的办法如下,改成如下方式就可以了，针对forEach也一并改为map。

async test() {
 const testData = [1, 2, 3];
 testData.map(async (v) => {
 // 这里就会提示 no-await-in-loop
 const res = await getItem(v); // 假设这里的getItem是一个Promise 
 })
}

Nodejs 通过 fs.createWriteStream 保存文件

Thu, 03 Jul 2025 17:37:21 +0000

工作中难免会遇到处理大文件的时候，有这种stream的处理方式，就不需要一次处理太大的文件，从而导致内存不够用，或者内存占用太多。

fs.createWriteStream 似乎不会自己创建不存在的文件夹，所以在使用之前需要注意，保存文件的文件夹一定要提前创建。

const path = '/xxxxxx/ddd/';

if (!fs.existsSync(path)) {
 fs.mkdirSync(path);
}

创建完文件夹，我们就可以进行文件添加操作了。我们希望在使用文件添加操作的时候是通过saveFile(filePath, fileData);这样的方式来调用。

这里我采用了Promise的方式，个人比较喜欢这样的方式

 /**
 * [saveFileWithStream description]
 * @param {String} filePath [文件路径]
 * @param {Buffer} readData [Buffer 数据]
 */
 static saveFile(filePath, fileData) {
 return new Promise((resolve, reject) => {
 // 块方式写入文件
 const wstream = fs.createWriteStream(filePath);

 wstream.on('open', () => {
 const blockSize = 128;
 const nbBlocks = Math.ceil(fileData.length / (blockSize));
 for (let i = 0; i < nbBlocks; i += 1) {
 const currentBlock = fileData.slice(
 blockSize * i,
 Math.min(blockSize * (i + 1), fileData.length),
 );
 wstream.write(currentBlock);
 }

 wstream.end();
 });
 wstream.on('error', (err) => { reject(err); });
 wstream.on('finish', () => { resolve(true); });
 });
 }

实际调用的时候，如下

try {
 await saveFileWithStream(filePath, fileData); // 这里的fileData是Buffer类型
} catch (err) {
 console.log(err.stack);
}

NodeJs 版本8.5 体验experimental-modules

Thu, 03 Jul 2025 17:37:10 +0000

最近NodeJs 版本 8.5 已经支持了 ESM module，感觉之前的babel编译可以放弃不用了，不过这个只是一个实验性的，具体稳定与否，是否可以上生产环境，还是需要测试一段时间的。

体验环境搭建：

NodeJs: v8.5.0

依赖包：

"dependencies": {
 "axios": "^0.16.2",
 "koa": "^2.3.0",
 "koa-router": "^7.2.1",
 "koa-views": "^6.1.0",
 "twig": "^1.10.5"
}

这里使用的是koajs，大家可以使用下express

模块引入不在需要require了，哈哈，感觉不一样的体验

import koa from 'koa';
import koaRouter from 'koa-router';
import axios from 'axios';
import views from 'koa-views';
import path from 'path';

像这样是不是感觉，瓦萨，还不错

继续看下面的配置

app.use(views(path.resolve() + '/views', {
 map: {
 html: 'twig',
 },
 extension: 'twig',
}));

对于web开发，推荐koa-views,可以支持很多模板，想用哪个就用哪个

const viewsTest = async (ctx, next) => {
 ctx.state = {
 title: 'viewsTest',
 };

 await ctx.render('views_test', {
 title: 'viewsTest',
 });
 return next();
};

router.get('/views', viewsTest);

app
 .use(router.routes())
 .use(router.allowedMethods());

app.listen(8888);

好了，我的index.mjs创建完成，注意这里的index文件是以mjs结尾的，不然稍后运行的话是不会执行的。

view_test.twig模板其实很简单，为了测试简单加下就好了。

<!DOCTYPE html>
<html>
<head>
 <meta charset="utf-8">
 <title>{{ title }}</title>
</head>

<body>
{{ title }}
</body>

</html>

目录结果也给大家演示下

|-index.mjs

|-node_modules

|-package.json

|-package-lock.json

|-views

|-views_test.twig

运行我们的程序

node --experimental-modules index.mjs

出现下面的提示就是运行起来了

$ node --experimental-modules index.mjs
(node:6999) ExperimentalWarning: The ESM module loader is experimental.

感觉开发代码又便捷了很多呀。

Nodejs 之 Koa2 添加travis ci 持续集成工具

Thu, 03 Jul 2025 16:50:05 +0000

最近使用koa2做项目测试开发，想整合下travis ci,网上资料也比较少，于是自己就整了个，做个记录。

先来看下travis.yml的配置

language: node_js
node_js:
 - "6"
before_script:
 - ./node_modules/.bin/knex migrate:latest --knexfile='./app/knexfile.js'
script:
 - npm run test

因为是接口测试，所以首先需要做表创建等操作。

测试的命令：

NODE_ENV=production NODE_CONFIG_DIR='./app/config/' ./node_modules/.bin/mocha --require 'babel-polyfill' --compilers js:babel-register ./app/test/**/*.js

主要是测试这里，使用了supertest，大概看下是如何调用的。

const request = require('supertest');
const should = require('should');
const index = require('../../index');

let app = request(index.listen());

describe('/api/persons', function() {
 let personId;

 it('POST /api/persons - create person success and respond with 200', function(done) {
 app.post('/api/persons')
 .send({
 'firstName': 'Jennifer',
 'lastName': 'Lawrence',
 'age': 24
 })
 .expect(200)
 .expect(function(res) {
 (res.body.id > 0).should.be.true;
 })
 .end(function(err, res) {
 if (err) {
 return done(err);
 }

 let resJson = JSON.parse(res.text);
 personId = resJson.id;

 done();
 })
 });

 it('GET /api/persons - fetch persons item', function(done) {
 app.get('/api/persons')
 .expect(200)
 .expect(function(res) {
 (res.body.length > 0).should.be.true;
 })
 .end(function(err, res) {
 if (err) {
 return done(err);
 }

 done();
 })
 });

 it('GET /api/persons/:id - fetch a person', function(done) {
 app.get(`/api/persons/${personId}`)
 .expect(200)
 .expect(function(res) {
 (res.body.id == personId).should.be.true;
 })
 .end(function(err, res) {
 if (err) {
 return done(err);
 }

 done();
 })
 });

 it('DELETE /api/persons/:id - delete a person', function(done) {
 app.delete(`/api/persons/${personId}`)
 .expect(200)
 .end(function(err, res) {
 if (err) {
 return done(err);
 }

 done();
 })
 });

 it('GET /api/persons/:id - fetch a person should 404', function(done) {
 app.get(`/api/persons/${personId}`)
 .expect(404)
 .end(function(err, res) {
 if (err) {
 return done(err);
 }

 done();
 })
 });

});

这里主要注意的是

const index = require('../../index');

需要将koa实例暴漏出来，不然在做travis ci的集成后，启动了项目，测试的时候依然找不到具体访问地址。

来看下我的index.js

import Knex from 'knex';
import {
 Model
} from 'objection';
import knexConfig from './knexfile';
import config from 'config';
import Koa from 'koa';
import koaLogger from 'koa-logger';
import bodyParser from 'koa-bodyparser';
import render from 'koa-ejs';
import co from 'co';
import koaStatic from "koa2-static"
import router from './router';

const path = require('path');

// initial knex
const knex = Knex(knexConfig.development);
Model.knex(knex);

// initial app
const app = new Koa();

// initial render
render(app, {
 root: path.join(__dirname + '/view'),
 layout: 'template',
 viewExt: 'ejs',
 cache: true,
 debug: true
});
app.context.render = co.wrap(app.context.render);

// initial static

app.use(koaLogger())
 .use(bodyParser())
 .use(router.routes())
 .use(koaStatic({
 path: '/web',
 root: __dirname + "/../static"
 }));

module.exports = app;

需要注意的是这里的

module.exports = app;

暴漏出来，再supertest中才可以独立启动server测试。好的不明白的加群聊聊吧。

Nodejs 应用性能分析

Thu, 03 Jul 2025 16:50:02 +0000

node.js 从 4.4.0 版本开始内置了 profiler， --prof 命令选项运行应用会在当前目录生成性能日志文件。

简单记录下使用方法

运行的时候加上 –prof 参数

node app.js --prof

运行后会在当前目录生成一个类似：isolate-0x1d1e1b0-v8-10041.log这样的文件

执行如下命令来分析程序的性能

node --prof-process isolate-0x1d1e1b0-v8-10041.log

具体解析分析的结果请看参考文章

参考：

诊断 node.js 应用 CPU 占用过高的问题

Easy profiling for Node.js Applications | Node.js

Nodejs 之 __dirname 的使用

Thu, 03 Jul 2025 16:49:55 +0000

新建个文件

app.js

里面的内容如下：

console.log(__dirname + '/example.db');
console.log('example.db');

如果将app.js放在一个根目录下面

执行node app.js

分别输出如下内容：

/Users/durban/nodejs/koa-mysql-orm-model/example.db
example.db

我们建立一个文件夹app,app下建立一个app.js

里面的内容如下：

console.log(__dirname + '/example.db');
console.log('example.db');

执行node app.js

分别输出如下内容：

/Users/durban/nodejs/koa-mysql-orm-model/app/example.db
example.db

可见，__dirname追加了自身的目录路径，一般这样做的好处是，可以避免文件的混乱调用。

Nodejs 数据加密传输

Thu, 03 Jul 2025 11:59:52 +0000

数据加密传输，这个目前我接触的几个方式，一个是密文传输，一个明文传输

密文传输，就是用密钥对数据加密，使用公钥对数据解密，传输的通道可以是https的也可以是http的。

明文传输，前提是建立一个安全的传输通道，这里使用证书对通道的安全做了防护，然后传输数据，使用的是明文。

比较专业的可以后面慢慢分享，不过这里我就介绍下明文传输，如果是用nodejs建立安全通道

使用两个库，分别是urllib和request，这里的证书只介绍使用pfx文件

urllib库的方式

const urllibRequest = (url, method, data, pfx, pass) => {
 return new Promise(function(resolve, reject) {
 let options = {
 data: data,
 method: method,
 pfx: pfx,
 passphrase: pass,
 rejectUnauthorized: false
 }
 urllib.request(url, options, function(err, data, res) {
 if (err) {
 return reject(err);
 }
 return resolve(data.toString());
 });
 });
}

request库的方法

const httpRequest = (url, method, data, pfx, pass) => {
 return new Promise((resolve, reject) => {
 let options = {
 url: url,
 method: method,
 form: data,
 headers: {
 'Content-type': 'application/x-www-form-urlencoded'
 },
 agentOptions: {
 pfx: pfx,
 passphrase: pass,
 rejectUnauthorized: false
 }
 };
 request(options, function(err, httpResponse, data) {
 if (err) {
 return reject(err);
 }
 return resolve(data);
 })
 });
}

Nodejs - 通过身份证号验证年龄，出生日期和性别

Thu, 03 Jul 2025 11:58:22 +0000

想要知道自己的年龄，出生日期和性别，或者是别人的，给我个身份证号，我就可以知道，看下面代码。

static validateIdNumberToAgeYear(str){
 let date = new Date();
 let currentYear = date.getFullYear();
 let currentMonth = date.getMonth() + 1;
 let currentDate = date.getDate();
 
 let idxSexStart = str.length == 18 ? 16 : 14;
 let birthYearSpan = str.length == 18 ? 4 : 2;

 let year;
 let month;
 let day;
 let sex;
 let birthday;
 let age;

 //性别
 let idxSex = 1 - str.substr(idxSexStart, 1) % 2; 
 sex = idxSex == '1' ? '女' : '男'; 
 //生日
 year = (birthYearSpan == 2 ? '19' : '') + str.substr(6, birthYearSpan); 
 month = str.substr(6 + birthYearSpan, 2); 
 day = str.substr(8 + birthYearSpan, 2); 
 birthday = year + '-' + month + '-' + day; 
 //年龄
 let monthFloor = (currentMonth < parseInt(month,10) || (currentMonth == parseInt(month,10) && currentDate < parseInt(day,10))) ? 1 : 0;
 age = currentYear - parseInt(year,10) - monthFloor; 

 // console.log("我的出生日期是"+year+"年"+month+"月"+day+"日"+",今年"+age+"岁了"+",性别是"+sex);

 if(age >= 18){
 return true; 
 }
 
 return false;
}

我这里只是做了一个年龄的判断。

Nodejs 之分享加密算法

Thu, 03 Jul 2025 11:08:24 +0000

这里分享一个node实现的加解密算法，对接了至少三家的接口但是没加的算法都不一样。看着做为程序员的辛苦，我这里分享了。

/**
 * @author zhandapeng <xx@xx>
 * @date 7/12/2016
 *
 * openssl pkcs12 -in 9f_KDJZ_private.pfx -out 9f_KDJZ_private.pem -nodes 
 * openssl x509 -in 9fwlc_public.crt -outform der -out 9fwlc_public.der
 * openssl x509 -in 9fwlc_public.crt -inform der -outform pem -out 9fwlc_public.pem
 *
 * 玖富加密解密
 */
'use strict';

const crypto = require('crypto');
const constants = require('constants');
const _padding = constants.RSA_PKCS1_PADDING;
const _encoding = 'base64';
const _signatureAlgorithm = 'RSA-SHA1';


class XxxxRSA {
 constructor(options) {
 this.options = Object.assign({}, options);
 }

 /**
 * 签名
 * @param {String} data [加密的数据]
 * @return {String} [签名的数据]
 */
 _sign(data) {
 const sign = crypto.createSign(_signatureAlgorithm);
 sign.update(data, 'utf8');
 return sign.sign(this.options.privateKey, _encoding);
 }

 /**
 * 验签
 * @param {String} sign [签名数据]
 * @param {String} data [加密数据]
 * @return {Boolean} [description]
 */
 _verify(sign, data) {
 const verifier = crypto.createVerify(_signatureAlgorithm);
 verifier.update(new Buffer(data, _encoding), 'utf8');
 return verifier.verify(this.options.publicKey, new Buffer(sign, _encoding));
 }

 /**
 * 加密
 * @param {String} msg [要加密的数据]
 * @return {Object} [签名的数据和加密的数据]
 */
 encrypt(msg) {
 const blockSize = 128;
 const padding = 11;

 let buffer = new Buffer(msg);

 const chunkSize = blockSize - padding;
 const nbBlocks = Math.ceil(buffer.length / (chunkSize));

 let outputBuffer = new Buffer(nbBlocks * blockSize);
 for (let i = 0; i < nbBlocks; i++) {
 let currentBlock = buffer.slice(chunkSize * i, chunkSize * (i + 1));
 let encryptedChunk = crypto.publicEncrypt({
 key: this.options.publicKey,
 padding: _padding
 }, currentBlock);

 encryptedChunk.copy(outputBuffer, i * blockSize);
 }

 return {
 data: outputBuffer.toString(_encoding),
 sign: this._sign(outputBuffer)
 };
 };

 /**
 * 解密
 * @param {Object} obj [签名数据和加密数据]
 * @return {String} [解密的数据]
 */
 decrypt(obj) {
 if (!this._verify(obj.sign, obj.data)) {
 throw new Error('Sign verify field.');
 }

 const blockSize = 128;
 let buffer = new Buffer(obj.data, _encoding);
 const nbBlocks = Math.ceil(buffer.length / (blockSize));
 let outputBuffer = new Buffer(nbBlocks * blockSize);

 let totalLength = 0;
 for (var i = 0; i < nbBlocks; i++) {
 let currentBlock = buffer.slice(blockSize * i, Math.min(blockSize * (i + 1), buffer.length));
 let decryptedBuf = crypto.privateDecrypt({
 key: this.options.privateKey,
 padding: _padding
 }, currentBlock);

 decryptedBuf.copy(outputBuffer, totalLength);
 totalLength += decryptedBuf.length;
 }

 let data = outputBuffer.slice(0, totalLength);

 return data.toString();
 };
}

export default XxxxRSA;

事实上简单的不得了，只是我不会而已，对不起献丑了。

这里针对java和php版本做个参考。主要是是说encrypt和decrypt部分。

encrypt->java实现

public static String encrypt(Key key, String dataStr)
 throws RuntimeException {
 try {
 byte[] data = dataStr.getBytes("UTF-8");
 Cipher cipher = Cipher.getInstance(transformation);
 cipher.init(Cipher.ENCRYPT_MODE, key);

 int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小
 int leavedSize = data.length % MAX_ENCRYPT_BLOCK;
 int blocksSize = leavedSize != 0 ? data.length / MAX_ENCRYPT_BLOCK
 + 1 : data.length / MAX_ENCRYPT_BLOCK;
 byte[] raw = new byte[outputSize * blocksSize];
 int i = 0;
 while (data.length - i * MAX_ENCRYPT_BLOCK > 0) {
 if (data.length - i * MAX_ENCRYPT_BLOCK > MAX_ENCRYPT_BLOCK)
 cipher.doFinal(data, i * MAX_ENCRYPT_BLOCK,
 MAX_ENCRYPT_BLOCK, raw, i * outputSize);
 else
 cipher.doFinal(data, i * MAX_ENCRYPT_BLOCK, data.length - i
 * MAX_ENCRYPT_BLOCK, raw, i * outputSize);
 i++;
 }
 return Base64.encodeBase64String(raw);

 } catch (NoSuchAlgorithmException e) {
 throw new RuntimeException(e);
 } catch (NoSuchPaddingException e) {
 throw new RuntimeException(e);
 } catch (IllegalBlockSizeException e) {
 throw new RuntimeException(e);
 } catch (BadPaddingException e) {
 throw new RuntimeException(e);
 } catch (InvalidKeyException e) {
 throw new RuntimeException(e);
 } catch (ShortBufferException e) {
 e.printStackTrace();
 } catch (UnsupportedEncodingException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 return null;
}

decrypt->java实现

public static String decrypt(Key key, String dataStr)
 throws RuntimeException {
 try {
 byte[] data = Base64.decodeBase64(dataStr);
 Cipher cipher = Cipher.getInstance(transformation);
 cipher.init(Cipher.DECRYPT_MODE, key);
 ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
 int j = 0;

 while (data.length - j * MAX_DECRYPT_BLOCK > 0) {
 bout.write(cipher.doFinal(data, j * MAX_DECRYPT_BLOCK,
 MAX_DECRYPT_BLOCK));
 j++;
 }
 return new String(bout.toByteArray(), "UTF-8");
 } catch (NoSuchAlgorithmException e) {
 throw new RuntimeException(e);
 } catch (NoSuchPaddingException e) {
 throw new RuntimeException(e);
 } catch (InvalidKeyException e) {
 throw new RuntimeException(e);
 } catch (IllegalBlockSizeException e) {
 throw new RuntimeException(e);
 } catch (BadPaddingException e) {
 throw new RuntimeException(e);
 } catch (IOException e) {
 e.printStackTrace();
 }
 return null;
}

encrypt->php实现

public function encrypt($content, $public_key) {
 $priKey = file_get_contents($public_key);
 $res = openssl_get_publickey($priKey);
 //把需要加密的内容，按128位拆开加密
 $result = '';
 for($i = 0; $i < ((strlen($content) - strlen($content)%117)/117+1); $i++ ) {
 $data = mb_strcut($content, $i*117, 117, 'utf-8');
 openssl_public_encrypt($data, $encrypted, $res);
 $result .= $encrypted;
 }
 openssl_free_key($res);
 //用base64将二进制编码
 $result = base64_encode($result);
 return $result;
}

decrypt->php实现

public function rsaDecrypt($content, $private_key) {
 $priKey = file_get_contents($private_key);
 $res = openssl_get_privatekey($priKey);
 // var_dump($priKey);
 // var_dump($res);exit();
 //用base64将内容还原成二进制
 $content = base64_decode($content);
 //把需要解密的内容，按128位拆开解密
 $result = '';
 for($i = 0; $i < strlen($content)/128; $i++ ) {
 $data = substr($content, $i * 128, 128);
 openssl_private_decrypt($data, $decrypt, $res);
 $result .= $decrypt;
 }
 openssl_free_key($res);
 return $result;
}

Nodejs 中pfx后缀文件的处理

Thu, 03 Jul 2025 11:08:16 +0000

nodejs中，在做加密解密的时候，会得到第三方的各种各样的加密文件，其后缀也就那么几种吧，.key/.pem/.pfx等，是不是可以自定义，反正就是一个文件。

但是今天我看了很多的nodejs库好像也没有找到与java keytool这样的工具，因为在java里面，完全是可以读取pfx,然户进行在进行处理的，如果在nodejs中要如何操作，目前不知道，使用openssl做个转换处理先。

第一个命令是:

openssl pkcs12 -in xxxx.pfx -nocerts -nodes -out domain_encrypted.key

第二个命令是:

openssl rsa -in domain_encrypted.key -out private.key

哪位大神知道的，可以告知下，谢谢了。

==================补充=================

google上有个办法可以解析出两种格式的文件

第一种格式文件的方式

extract private key from .pfx file

# openssl pkcs12 -in myfile.pfx -nocerts -out private_key.pem -nodes
Enter Import Password:
MAC verified OK

第二种格式文件的方式

extract certificate from .pfx file

# openssl pkcs12 -in myfile.pfx -nokeys -out certificate_file.crt 
Enter Import Password:
MAC verified OK

详细的可到这里：http://tecadmin.net/extract-private-key-and-certificate-files-from-pfx-file/

==========================================

==========================================强烈补充

多日奋战，终于解决了这个问题，因为一直是一个私钥解密的问题

openssl pkcs12 -in xxxx_private.pfx -out xxxx_private.pem -nodes
openssl x509 -in xxxx_public.crt -inform der -outform pem -out xxxx_public.pem

这里主要是针对具体情况具体描述，可以变通取处理

因为对方给过来的是一个在window环境下，使用工具生成的pfx和crt文件。

经过对方给过来的生成工具的描述，这个crt文件还是一个cer后缀文件自己修改的cer->crt。可见这里如果对文件内容不了解，光从后缀来看会坑了很多人。

先来看第一行的命令语句.

经过文档的查询pfx文件是一个带有私钥跟证书的合体文件，通过上面的命令就可以得到一个文件就是private.pem，里面是一个含有证书和私钥的。

不知道的我这里举例。

私钥是以

-----BEGIN RSA PRIVATE KEY-----

开头的。

证书是以

-----BEGIN CERTIFICATE-----

开头的。对不起不方便把所有内容同时贴出来。很容易辨别的。

然后对方还会给你一个crt文件，这个事实上就是一个x509对应的证书，需要解出来，但是对于是java的应该就不需要了，不过是php的或这是node的就需要了。

当然是证书的话，就必须是以

-----BEGIN CERTIFICATE-----

开头的。

好了，如果你跟别人对接接口，遇到私钥公钥的问题，但是对方给了你pfx和crt文件的话，就按照这个命令去操作的吧，我已经在php和node环境下试过了。不过具体的算法还是要针对具体的情况来实施。

================2016-11-11补充================

REM export the ssl cert (normal cases)
openssl pkcs12 -in aa.pfx -out aa.pem -nokeys -clcerts

REM export the ssl cert (Crescendo load balancers)

openssl pkcs12 -in aa.pfx -out aa_tmp_cn.pem -nodes
openssl x509 -in aa_tmp_cn.pem -out aa_cn.pem -text

Nodejs 接口之解析淘宝客短链

Thu, 03 Jul 2025 11:07:37 +0000

给你一个淘宝客的短链，如果获取他跳转后的地址，这是我最近在做个一个程序，使用node开发总体来说还是挺简答的。

大概说下流程

第一步：解析出这个短链最终的真实地址

我的第一个想法是，是不是需要啥啥接口才可以哇。但是我又想，这也太麻烦了，如果我访问了这个链接是不是就可以得到真实的链接了。好，到网上找到了一个request库，还是有实例哦，简单的不要不要的，赶紧弄了下，果然是有结果的。

var r = request(url, function(err, res, body) {
 var uri = res.request.uri.href;
 console.log(uri);
}

可以了。地址拿到了，用浏览器打开试试，结果还是有问题，这个地址不是产品的真实地址，还是要做一个跳转的，好吧。

我又想，这个页面究竟是个啥，打开一看，其实里面就是个js函数，执行了就简单了，这个对于node来说真实小菜一碟哇。

突然让我想起来urllib这个库，嗯，不错很好用的。

开始用的时候，直接请求就以为能得到结果了，结果不是的，还需要在请求中加上referer，哈哈，也许是个漏洞吧，这样我就能解析出真实的地址了。

那先解决第一个问题就是node如何营造一个dom的环境，玩过dom的人肯定知道jsdom啦，然后在进行urllib请求根据302跳转获取到。

jsdom.env(uri, function(err, window) {
 //都有window了，想干嘛就干嘛吧
}

之后就是获取最终headers里面的location

var urlRes = urllib.request(real_jump_address, {
 method: 'GET',
 headers: {
 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36',
 'Upgrade-Insecure-Requests': 1,
 'Host': 's.click.taobao.com',
 'Referer': uri
 }
}, function(err, data, res) {
 if (err) {
 throw err; // you need to handle error
 }
 // console.log(res.statusCode);
 console.log(res.headers.location);
 // data is Buffer instance
 // console.log('body ', data.toString());
});

在express中使用co

Wed, 02 Jul 2025 15:40:47 +0000

以下支持的Nodejs版本是 >=4.2.1

在express中我们都知道，我们可以在文件中定义一个方法，如下，然后可以在router中调用这个方法进行相应的处理。但是我们不想一直去写一些回调的方法，

希望对于异步的处理能像写顺序编程那样一直按照逻辑顺序去执行，co就帮了我们一个大忙，试试如下这种方式吧。【前提是要安装下co】

module.exports.addBackground = function (req, res, next) {
 let title = req.body.title || '';
 let theme = req.body.theme || '';
 let theorder = req.body.theorder || 0;
 let big_url = req.body.big_url || '';
 let thumb_url = req.body.thumb_url || '';
 let mtime = parseInt(new Date().valueOf() / 1000);
 if (!title || !theme || !big_url || !thumb_url) {
 throw new Error('Arguments is Error.');
 }
 co(function *() {
 let _isAdmin = yield User.isAdmin(req.user.id);
 if (!_isAdmin) {
 throw new Error('Admin only.');
 }
 let e_sql = 'SELECT * FROM xxxxx.app_dft_background where title = ' + mysql.escape(title);
 let e_res = yield mysql.thunkQuery(e_sql);
 if (e_res.length > 0) {
 return false;
 }
 let sql = sqlBuilder.makeInsertSql('xxxxx.app_dft_background', {
 title: title,
 theme: theme,
 theorder: theorder,
 big_url: big_url,
 thumb_url: thumb_url,
 mtime: mtime
 });
 let res = yield mysql.thunkQuery(sql);
 return res;
 }).then((data) => {
 if (!data) {
 res.json({'success': false, 'message': '名称已存在'});
 } else {
 res.json({'success': true, 'data': data});
 }
 }).catch((err) => {
 next(err);
 });
};

如果还是没有理解清楚可以去看下co和Promise。很容易理解的

Nodejs开发部署环节整理

Wed, 02 Jul 2025 15:40:44 +0000

做web网站开发一般都会分为三个环节:开发阶段【开发模式】、调试阶段【调试模式】、部署阶段【部署模式】

在Node的环境中：

开发阶段我们希望能够即使响应我们的开发速度，node启动的方式大家都知道 node app.js ,如果中间有修改的话，就不能即使响应了，需要我们自己再去重新启动。

所以我们的开发阶段最好是安装一下supervisor

安装

npm install --save-dev supervisor

启动

supervisor app.js or supervisor www/bin

【此种方法启动，需要作为一个全局去安装supervisor】

我的实践是把package.json里的start

"scripts": {
 "d": "node-debug app.js",
 "start": "./node_modules/.bin/supervisor app.js"
}

然后

npm start

调试阶段，我们肯定是希望监测每个请求的响应结果，一旦出现问题可以直接更加友好的展示给我们：

推荐node-inspector

安装

npm install --save node-inspector

启动

node-inspector app.js or node-debug www/bin

【此种方法启动，需要作为一个全局去安装supervisor】

我的实践是把package.json里的d里

"scripts": {
 "d": "./node_modules/.bin/node-debug app.js",
 "start": "./node_modules/.bin/supervisor app.js"
}

然后执行

npm run d

部署阶段就是我们通常所说的生产环境或者是产品上线

推荐使用pm2

pm2是非常优秀工具，它提供对基于node.js的项目运行托管服务。它基于命令行界面，提供很多特性：

内置的负载均衡器（使用nodecluster module）

以守护进程运行

0s(不间断)重启

为ubuntu/ CentOS 提供启动脚本

关闭不稳定的进程（避免无限死循环）

基于控制台监控

HTTP API

远程控制以及实时监控接口

pm2使用nodecluster构建一个内置的负载均衡器。部署多个app的实例来达到分流的目的以减轻单app处理的压力。

安装pm2

npm install -g pm2

查看基本帮助文档

Basic Examples:

Start an app using all CPUs available + set a name :

$ pm2 start app.js -i 0 --name "api"

Restart the previous app launched, by name :

$ pm2 restart api

Stop the app :

$ pm2 stop api

Restart the app that is stopped :

$ pm2 restart api

Remove the app from the process list :

$ pm2 delete api

Kill daemon pm2 :

$ pm2 kill

Update pm2 :

$ npm install pm2@latest -g ; pm2 updatePM2

More examples in https://github.com/Unitech/pm2#usagefeatures

Deployment help:

$ pm2 deploy help

上面基本是我们比较常用的

我们也可以把启动信息写入到json配置文件中->ecosystem.json

{
 "apps": [
 {
 "name": "web.0",
 "max_memory_restart": "1024M",
 "log_date_format": "YYYY-MM-DD HH:mm:ss SSS",
 "script": "/var/www/web/bundle/main.js",
 "out_file": "/var/log/web/app.0.log",
 "error_file": "/var/log/web/err.0.log",
 "port": "8080",
 "env": {
 "CDN_PREFIX": "//dbde4sd21oahf.cloudfront.net",
 "MONGO_URL": "mongodb://localhost:27017/web",
 "MONGO_OPLOG_URL": "mongodb://localhost:27017/local",
 "ROOT_URL": "http://web.com",
 "PORT": "8080"
 }
 },
 {
 "name": "web.1",
 "max_memory_restart": "1024M",
 "log_date_format": "YYYY-MM-DD HH:mm:ss SSS",
 "script": "/var/www/web/bundle/main.js",
 "out_file": "/var/log/web/app.1.log",
 "error_file": "/var/log/web/err.1.log",
 "port": "8081",
 "env": {
 "CDN_PREFIX": "//dbde4sd21oahf.cloudfront.net",
 "MONGO_URL": "mongodb://localhost:27017/web",
 "MONGO_OPLOG_URL": "mongodb://localhost:27017/local",
 "ROOT_URL": "http://web.com",
 "PORT": "8081"
 }
 },
 {
 "name": "web.2",
 "max_memory_restart": "1024M",
 "log_date_format": "YYYY-MM-DD HH:mm:ss SSS",
 "script": "/var/www/web/bundle/main.js",
 "out_file": "/var/log/web/app.2.log",
 "error_file": "/var/log/web/err.2.log",
 "port": "8082",
 "env": {
 "CDN_PREFIX": "//dbde4sd21oahf.cloudfront.net",
 "MONGO_URL": "mongodb://localhost:27017/web",
 "MONGO_OPLOG_URL": "mongodb://localhost:27017/local",
 "ROOT_URL": "http://web.com",
 "PORT": "8082"
 }
 },
 {
 "name": "web.3",
 "max_memory_restart": "1024M",
 "log_date_format": "YYYY-MM-DD HH:mm:ss SSS",
 "script": "/var/www/web/bundle/main.js",
 "out_file": "/var/log/web/app.3.log",
 "error_file": "/var/log/web/err.3.log",
 "port": "8083",
 "env": {
 "CDN_PREFIX": "//dbde4sd21oahf.cloudfront.net",
 "MONGO_URL": "mongodb://localhost:27017/web",
 "MONGO_OPLOG_URL": "mongodb://localhost:27017/local",
 "ROOT_URL": "http://web.com",
 "PORT": "8083"
 }
 }
 ]
}

pm2的当然还有一些其他的用法：

1、pm2远程部署

pm2 deploy ecosystem.json production setup

2、pm2 cluster启动

pm2 start app.js -i 0 --name "apps"

3、pm2 重启实例

pm2 reload <name>

4、pm2 命令行监测

pm2 monit

5、pm2 查看实例日志

pm2 logs 或 pm2 logs <name> 或 pm2 flush

6、pm2 开机启动

pm2 startup <ubuntu|centos|gentoo|systemd>

7、pm2 web方式监测

pm2 web

之后要考虑的就是服务器的监测以及如果给node做反向代理

比如：

nginx或haproxy的部署，也可以使用nginx+passenger进行部署

mongodb的部署

mysql的部署

redis的部署

还要对服务器进行压测

apache ab

wrk

以及性能调优和监控

罗列一下提高效率的Nodejs模块

Tue, 01 Jul 2025 11:54:35 +0000

罗列一下提高效率的Nodejs模块，分享之。

Cheerio

Fast, flexible, and lean implementation of core jQuery designed specifically for the server.

Cheerio，说它是服务器端的jQuery一点也不为过，在github上也是大受欢迎，star数达4500有余，至目前为止，已经有923次commit。它兼容jQuery绝大部分的库，以至于你只需要一句$ = require(‘cheerio’).load(YOUR_HTML_CONTENT);，便可以像在前端用jQuery一样的舒畅，愉快。

By the way，和Cheerio类似的框架还有：jsdom，一个受欢迎程度略低于Cheerio，但是它有2,147多的commit，可见维护者之诚意。

Waterline

An adapter-based ORM for Node.js with support for mysql, mongo, postgres, redis, and more

Waterline是从Sails框架衍生出来的Nodejs平台下的ORM，除了支持常见的mysql、mongodb，还支持PostgreSQL、Redis、Memory、Disk等等

Bookshelf

A Node.js ORM for PostgreSQL, MySQL and SQLite3 in the style of Backbone.js

与Waterline类似，但作为同类产品且被Ghost选择标配之一的Bookshelf必然有它的特别之处，仍待君细细品来。

Node-Soap

A SOAP client and server for node.js.

对于REST，大家必然熟悉，就算不熟悉，也是久仰其大名，或者是略有耳闻。REST简单而直观，把HTTP协议利用到了极限，在这种思想指导下，它甚至用HTTP请求的头信息来指明资源的表示形式，用HTTP的错误机制来返回访问资源的错误。但在R.T. Fielding博士在他的论文里提出REST之前，又是谁来承担Web Service这份差使呢？

SOAP (Simple Object Access Protocol) 顾名思义，是一个严格定义的信息交换协议，用于在Web Service中把远程调用和返回封装成机器可读的格式化数据。它基于 XML 格式，在绝大多数情况下，使用HTTP协议传输WSDL请求。

而node-soap模块，则允许在node环境中，接入其他程序语言 (诸如 ASP.net、Java 等) 开发的WebService。也能够在node中开发基于SOAP的WebService供其他程序调用。

当然，在大多数情况下，过去SOAP能做的事，REST也是能做到的，且REST更加优雅，简单。以我的水平，我也是想不清楚SOAP依然存在的必然性，但是有那么一句话：「存在，就是合理的」。既然，它存在，也有人用到，那么在合作开发中和SOAP相遇也是有可能性的，相信那是我们的缘分。

如果你有兴趣，听一下我和SOAP邂逅的故事：SOAP，Web service的枢纽

Passport

Simple, unobtrusive authentication for Node.js.

如果你的站点想快速建立passport-user结构的用户系统，且能够简单的接入流行的第三方登录，用passport就没错了。它不但提供了本站登录的解决方案，还有一大堆第三方登录的策略，见:Strategies

如果你用Sails的话，这里还有一个承接Sails和passport的模块：sails-generate-auth

Bluebird

Bluebird is a full featured promise library with unmatched performance.

Javascript 的世界有一种痛叫「callback hell」，中文翻译过来叫「回调地狱」，如果能承受得了她带来的痛楚，且继续爱着她，这是「真爱」。Promise的概念，能够让你与javascript好好爱的深沉。

实现Promise的库有很多，我知道的有：

Q

when

bluebird

jQuery的deferred

javascript自带的Promise（一些高级浏览器内置的Promise对象）

其中，我用的比较顺手的当属bluebird，它也是时下最优秀博客系统Ghost的标配之一。

如果你想深入了解Promise的概念，可以点这里：Promises: The Sync Problem

如果你想珍惜时间，珍惜生命，这里有中文版：深入理解Promise五部曲

Lodash

A JavaScript utility library delivering consistency, modularity, performance, & extras.

我想称它为Javascript的瑞士军刀，或者是一个蓝色工具箱。lodash提供了一系列相当不错的跟函数式编程相关的方法。函数式编程就像搭积木一样，像.identity、.partial、_.compose、splat、unsplat等都是职责单一的函数。别看它们简单，把它们当作积木看待，它们释放的是无尽的活力。越是简单的东西，蕴藏的越是更为无限的可能性。

Node.bcrypt.js

bcrypt for NodeJs

bcrypt，是一个跨平台的文件加密工具。由它加密的文件可在所有支持的操作系统和处理器上进行转移。它的口令必须是8至56个字符，并将在内部被转化为448位的密钥。然而，所提供的所有字符都具有十分重要的意义。密码越强大，您的数据就越安全。而node.bcrypt.js则是披上Nodejs斗篷的bcrypt，它的62.2%是C++代码，而Javascript代码只有30.3%。

Moment

Parse, validate, manipulate, and display dates in javascript.

Moment是一个轻量级用于处理日期的工具，除了对日期进行格式化以外，你还能够对日期进行操作，验证，解析。其在github的star数有1.9W+，比众所周知的Express(github star是1.7w+)还多一点。这么优秀的框架实在是相见恨晚。

Skipper

Streaming multi-uploads for Sails/Express - supports disk, S3, gridfs, and custom file adapters

Skipper是一款Sails衍生的处理多文件上传的组件，支持上传文件到本地或者远端服务器，如果默认adapter没有你需要的服务，你还能够自定义一套adapter满足你的需求。就像我为了把文件上传到又拍云而定制了的adapter： skipper-upyun

Node-fs-extra

Node.js: extra methods for the fs object.

Node-fs-extra提供了一些额外的fs没有的函数，如果Nodejs自带的fs模块，还不能满足你在进行文件操作的使用，或者用着不顺心。不妨来node-fs-extra找一下有没有你想要的解决方案。

Mocha

mocha - simple, flexible, fun javascript test framework for node.js & the browser. (BDD, TDD, QUnit styles via interfaces)

Nodejs单元测试哪家强？

mocha，mocha，似魔鬼的步伐~~yo!

Should

BDD style assertions for node.js – test framework agnostic

BDD风格的断言模块，旨在让编程像说白话（至少在测试断言上）。

Supertest

Super-agent driven library for testing node.js HTTP servers using a fluent API

如果测试的时候，需要HTTP请求呢？找Supertest吧，和Should同一个作者，TJ大神，你值得信赖。

PM2

Production process manager for Node.JS applications. Perfectly designed for microservice architecture.

Nodejs单线程的特性，意味着，如果你的某一行代码阻塞了，你的整个程序都会崩溃。人非圣贤，孰能无过，没有人能保证自己的写的代码永无BUG（难道要在文件头加上无BUG神兽？）。在生产环境下，如果程序挂了怎么办？让它自动重启呗。

PM2就是一款解决这种问题的工具，当然，作为一个进程管理器，它的作用不仅仅如此。

Markdown-js

A Markdown parser for javascript

Markdown时下越来越受欢迎了，实质上markdown最终是转换成HTML格式才能显示于网页的。而markdown-js则是把markdown格式的文本转化成HTML格式的工具。但是，如果从HTML格式的文本转化成Markdown格式的文本呢？markdown-js好像不支持，那就用to-markdown吧。

Nodejs iconv-lite 使用过程中需要注意的几个环节

Tue, 01 Jul 2025 11:52:51 +0000

最近在使用Nodejs的一个库Iconv-lite，有时候会报出这样一个提示

Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding

已经给出了对应的Refer。

具体详情见：https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding 其实看完之后，很简单就是如果有一个Buffer数据的话，你进行了toString()后，就已经进行了一层默认的decode操作，一般默认的是utf-8，所以如果你在进行iconv.decode()的时候，就会出现一个提示，这个在最新版本会出现这个问题，其他的版本我就不知道了，如果你在使用的过程中，decode之后，没有效果的话，可以试试，在decode之前先不要任何操作，直接将Buffer数据进行 decode，进过测试，直接decode(Bufffer)数据会效果比较好，谁用谁知道。

Nodejs 破解不规范json字符串的处理方法

Tue, 01 Jul 2025 11:35:53 +0000

Json字符串如果不是很规范的话,使用nodejs的JSON方法是无法进行parse的,比如说下面这段代码:

{'code':'S_OK','result':[0,0,0,0,0],'sessionCount':85,'var':[
{
'mid':'3a010000d4eede56800000b5',
'fid':1,'mailSession':149,
'size':15074,
'sendDate':1433473712,
'receiveDate':1433473712,
'modifyDate':1434356744,
'taskDate':0,
'securityLevel':0,
'meetingFlag':0,
'priority':3,
'color':0,
'antivirusStatus':0,
'rcptFlag':1,
'attachmentNum':0,
'mailNum':1,
'keepDay':0,
'sendId':0,
'sendTotalNum':0,
'sendNewNum':0,
'mailFlag':5,'starType':0,'logoType':68,'denyForward':0, 'auditStatus':0, 'billType':0,'billFlag':0,'subscriptionFlag':0,'secureEncrypt':0,'secureSigned':0,
'flags':{'successed':1,'selfdestruct':1},
'label':[],
'from':'中国移动139邮箱<xx@xx.com>',
'to':'xx@xx.com',
'subject':'邮箱积分新用途？一起积分初体验',
'summary':'邮箱积分新用途知道自己的邮箱积分吗？ 其实你已拥有诸多财富！想了解积分的用途吗？很多人早把积分'},
....... //这里省略了上下类似的代码
{
'mid':'1d0b257e9c2ec6b800000001',
'fid':1,
'mailSession':123,
'size':25633,
'sendDate':1424588244,
'receiveDate':1424588244,
'modifyDate':1433248644,
'taskDate':0,
'securityLevel':0,
'meetingFlag':0,
'priority':3,
'color':0,
'antivirusStatus':0,
'rcptFlag':1,
'attachmentNum':0,
'mailNum':1,
'keepDay':0,
'sendId':0,
'sendTotalNum':0,
'sendNewNum':0,
'mailFlag':5,'starType':0,'logoType':1,'denyForward':0, 'auditStatus':0, 'billType':0,'billFlag':0,'subscriptionFlag':0,'secureEncrypt':0,'secureSigned':0,
'flags':{'successed':1,'selfdestruct':1},
'label':[],
'from':'中国移动<xx@xx>',
'to':'xx@xx',
'subject':'尊敬的客户，您截至2月15日的积分账单已到，请查阅：巧用积分兑换好礼',
'summary':'用户号码：15000711265，尊敬的动感地带（M-Zone）客户：\r截止2月15日您的可兑换积分为：1074\r特别说明：\r1.'}
]
}

你可以将此n字符串放到文件内,多复制几个,然后通过JSON的方法试试.

首先肯定要进行读取文件

fs.readFile

然后将u读进来的Buffer字节码解析为字符串

buf.toString()

下面得到的就是字符串了,试试吧

JSON.stringify()

JSON.parse()

这两个方法随便搭配.最终还是无解,解析出来的仍然不是你要的对象.

…………………..

好吧,如果到了这里,我就只能说,别啥了,获得字符串之后,直接eval吧,哎,笨

json_obj = eval("(" + json_string + ")");

可以打印debug(json_obj),试试吧,应该可以不让你那么郁闷了.

Nodejs简易聊天室socket.io

Mon, 30 Jun 2025 15:15:52 +0000

初步的了解了一下Socket.io这个感觉还是很好用的，

几步简单的connect，以前觉得聊天室是一个很复杂而又很复杂的东西今天，就一天的时间，不，是一个下午的时间，就出来一个聊天室。

感觉这个可以批量生产了，so happy，借此分享给大家享受一下。

代码放到git上了，给个简单的安装使用步骤：

下载后在项目目录下执行：

npm install

执行完之后，执行如下的命令：

npm start

然后试着打开浏览器，访问http://127.0.0.1:3000

Nodejs通过POP3获取邮件，便于数据存储

Mon, 30 Jun 2025 15:15:36 +0000

经过几天的努力,使用Nodejs实现了POP3协议获取邮件

其实是参考了一个叫yapople的pop3插件库，只是稍微修改了一下，便于debug了。

此处使用了mocha插件进行测试。

代码可以去git上自己行下载并运行尝试。代码参考如下。

https://gitee.com/zhangdapeng89/Node_POP3

QQ邮箱这里有破解，Nodejs实现

Mon, 30 Jun 2025 14:31:32 +0000

QQ邮箱这里有破解了，只是有几个参数，需要你们自己去寻找了，反正我是找好了，就看你们了。

co(function *(){

 var username = '';
 var password = '';
 var _user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.76 Safari/537.36';
 var ptlogin_url = 'https://xui.ptlogin2.qq.com/cgi-bin/xlogin?appid=522005705&daid=4&s_url=https://mail.qq.com/cgi-bin/login?vt=passport%26vm=wpt%26ft=loginpage%26target=&style=25&low_login=1&proxy_url=https://mail.qq.com/proxy.html&need_qr=0&hide_border=1&border_radius=0&self_regurl=http://zc.qq.com/chs/index.html?type=1&app_id=11005?t=regist&';
 var _verifycode = '!IDB';
 var _pt_verifysession_v1 = '5351f6252b2eb7cd2025d8cef4025f3df8514932545b755fdd2bdb5b10d7008ef6b8f42d5f05e44679d09b4515c1d08f682e0330446f702a';
 var _salt = '\x00\x00\x00\x00\x35\x6d\x62\x13';
 try{
 var _p = Encryption.getEncryption(password, _salt, _verifycode, false);
 }catch(err){
 console.log(err.stack);
 } 
 var _login_sig = 'k1j0ogiCLp94MhQuiqFe0aONqYTewoEAWOVK0yRhXiYZ76YjWOLCwCq1AbgbZlz7';

 //登录提交
 var login_url = 'https://ssl.ptlogin2.qq.com/login';
 var login_data = {
 'u':username,
 'verifycode':_verifycode,
 'pt_vcode_v1':0,
 'pt_verifysession_v1':_pt_verifysession_v1,
 'p':_p,
 'pt_randsalt':0,
 'u1':'https://mail.qq.com/cgi-bin/login?vt=passport&vm=wpt&ft=loginpage&target=&account='+username,
 'ptredirect':1,
 'h':1,
 't':1,
 'g':1,
 'from_ui':1,
 'ptlang':'2052',
 'action':'2-3-1432202218068',
 'js_ver':10123,
 'js_type':1,
 'login_sig':_login_sig,
 'pt_uistyle':25,
 'aid':'522005705',
 'daid':4
 };
 login_url = [login_url,queryString.encode(login_data)].join('?');

 try{
 var res = yield request(login_url,{
 method:'GET',
 headers:{
 'Cookie':'dm_login_weixin_rem=; supertoken=3636424164; ptnick_896360979=e68891e79a84e79b8ae8bebe; u_896360979=@EcEWDEtFk:1432212547:1432212547:e68891e79a84e79b8ae8bebe:1; ptcz=6a74b6275a1dbd3a69b6c3ec83088687dcba3c9669af0b6f6bb658ab3b9b151f; pt2gguin=o0896360979; verifysession=h02OBge6wAzGGePYJ7IwDe7G4vsez16cqYqz0LB0w10HLt2JHNAnoqc-ebhwuZSPznSe7GvKEeJztuJhdD1EPPw9rpFU4Q_j7PS; ptui_loginuin=896360979; ETK=j4KdeJfjqM6ytLCbmoD9MUXVRZSffwLcVz8mvfIpmYxfl-514g-Arqm-RDDO-b92avzT*JKE7AQibxTRZGDl*g__; ptisp=ctc; confirmuin=0; ptvfsession='+_pt_verifysession_v1+'; pt_login_sig='+_login_sig+'; pt_clientip=29587f0000012d41; pt_serverip=b6a20abf06626dff; pt_local_token=176655876; uikey=bc5ce4f96fa16f2d0e69733d6a4128b2de3662b28623eb39db9f65dde69b75bd',
 'Referer':ptlogin_url,
 'Host':'ssl.ptlogin2.qq.com',
 'User-Agent':_user_agent
 }
 });
 console.log(res[0].toString());
 }catch(err){
 console.log(err.stack);
 }
});

对了，这里是用来co，是JavaScript的一个新特性，我还是很喜欢的，更喜欢yield，node执行的时候别忘记加–harmony，不然你会说我的，说执行不了。

Nodejs 实现简单数据抓取

Mon, 30 Jun 2025 14:31:16 +0000

近期使用Nodejs，突然想起来以前做过数据抓取，于是为了练手，就开始了数据抓取的旅程，结果在网上搜索，已经有人在做了，于是就抄袭了一下，修改了一下，结果就出来自己的东西了，顺便加上了数据库的数据存储，这里使用的是mysql，为了使得能与自己的服务器想兼容，就没有去折腾其他的数据库了。在这里重点说一下定时任务，Nodejs有自己的Crontab哦，测试了一下，目前还没有发现什么问题。想要使用的可以直接执行安装命令

sudo cnpm install cron

代码我放在了git.oschina.net。懒得在写代码了，喜欢的可以去代码查看，我认为那里看代码更方便一点。代码如下：

Nodejs 实现通过POP3协议进行邮件的收取【指定日期范围】

Mon, 30 Jun 2025 14:31:10 +0000

最近在使用Nodejs通过POP3去获取用户的邮件，但是搜索了很多的Nodejs库，包括pop3、yapople等等，感觉yapople还比较好上手，但是在使用过程中发现，tls的这一块不是很完善，于是自己就补充了一下，新创建了一个文件，并在pop3里面实现了几个简单的方法，用来获取邮件的内容，并借用了分页的模式，可以获取海量的邮箱，存储的话，可以在此基础上进行修改的。

代码的话我这里借用了git的一个插件，我做了公开，大家可以去借用下，有不完善的地方可以一起探讨。

Nodejs 正则获取银行账单

Mon, 30 Jun 2025 14:31:06 +0000

Nodejs正则获取银行账单的消费记录，其实就这么简单：

'use strict';
var _ = require('lodash');
var moment = require('moment');
module.exports.execute = function (str) {
 /**
 * 清理数组
 * @param {[type]} arr [description]
 * @param {[type]} value [description]
 * @return {[type]} [description]
 */
 var clean = function(arr,value) { 
 for (var i = 0; i < arr.length; i++) { 
 if (arr[i] == value) { 
 arr.splice(i, 1);//返回指定的元素 
 i--; 
 } 
 } 
 return arr; 
 }; 

 var result = {};
 var parts = str.match(/<tbody>(.+?)<\/tbody>/g);

 parts = parts.map(function (p) {
 var t = p.replace(/ /g,'')//去掉全部中文字符间的空格
 .replace(/<[^>]*>/g, ' ')//去掉全部html标签
 .replace(/&nbsp;/g,' ')//将&nbsp;替换为一个空格
 .replace(/ +/g, ' ');//将多个空格替换为一个空格
 return t.split(' ').length > 13 ? t : '';
 });

 
 parts = clean(parts,'');
 var parts1 = parts[3].split(' ');
 parts1 = parts1.slice(13,parts.length - 1);
 var records1 = _.chunk(parts1,7);

 var parts2 = parts[4].split(' ');
 parts2 = parts2.slice(13,parts2.length - 1);
 var records2 = _.chunk(parts2,7);
 
 result.records = [];
 _.forEach([records1,records2], function (t) {
 _.forEach(t,function(r){
 var record = new Record();

 record.rtime = moment([r[1], '00:00:00'].join(' '), 'YYYY/MM/DD HH:mm:ss').unix();
 record.money = r[4];
 record.content = r[2].replace(/&nbsp;/g,'');
 result.records.push(record);
 })
 });

 return result;
};

推荐使用mocha进行测试一下。

Nodejs 实现通过 POP3 协议获取邮件列表【yapople】

Mon, 30 Jun 2025 14:30:58 +0000

让我们使用yapople获取一下，你的邮件列表吧

代码如下：

var Client = require('yapople').Client;
var _ = require('lodash');
var async = require('async');
var iconv = require('iconv-lite');

var Fetcher = module.exports = function(options){
 this.options = _.assign(options,{port:995,tls:true,mailparser:true})
 this.client = new Client(this.options)
 this.mails = []
}

Fetcher.prototype.count = function(cb){
 var self = this
 self.client.connect(function(){
 self.client.count(cb);
 self.client.quit();
 });
}

Fetcher.prototype.fetch = function(nums,cb){
 var self = this;
 self.client.connect(function(){
 self.client.retrieve(nums,function(err,messages){
 cb(err,messages);
 self.client.quit();
 })
 });
}

Fetcher.prototype.list = function(number,cb){
 var self = this;
 self.client.connect(function(){
 self.client.list(number,function(err,info){
 cb(err,info);
 self.client.quit();
 })
 });
}

Fetcher.prototype.getContent = function(date,cb){
 var self = this;
 self.client.connect(function(){
 async.waterfall([
 function(done){
 self.client.count(function(err,count){
 done(err,count);
 });
 },
 function(count,done){
 var nums = [];
 var tmp = [];
 for(var i=0;i<count;i++){
 nums.push(i+1);
 }

 self.client.retrieve(nums,function(err,res){
 console.log('res length',res.length);
 done(err,tmp);
 // done(err,res);
 });
 }
 ],function(err,results){
 // console.log('results:',results);
 cb(err,results);
 self.client.quit();
 });
 });
}

Fetcher.prototype._connect = function(cb){
 var self = this;
 self.client.connect(function(){
 self.client.retrieve([2],function(err,messages){
 cb(err,messages);
 self.client.quit();
 })
 })
}

测试一下：

var should = require('should');
var moment = require('moment');
var POP3 = require(__dirname + '/../lib/mail_fetcher/pop3');
var iconv = require('iconv-lite');

var conf = {
 hostname: 'pop.126.com',
 username: 'xxx@xxx.com',
 password: 'mmmmmm'
};

describe('pop3 test', function(){
 it('should get mailbox count', function(done){
 var pop3 = new POP3(conf);
 pop3.count(function(err,count){
 console.log('count:',count);
 return done();
 })
 });
 it('should fetch nums messages',function(done){
 var pop3 = new POP3(conf);
 pop3.fetch([1,2,3],function(err,messages){
 messages.forEach(function(i){
 // console.log('ALL:',i);
 console.log('SUBJECT:',i.subject);
 })
 return done();
 });
 });
 // it('should return date condition messages',function(done){
 // var pop3 = new POP3(conf);
 // pop3.getContent('2015-01-03',function(err,messages){
 // console.log('MESSAGES:',messages);
 // return done();
 // })
 // });
 // it('pop3 list',function(done){
 // var pop3 = new POP3(conf);
 // pop3.list(function(err,info){
 // // console.log('list info:',info);
 // return done();
 // })
 // })
});

password和username换成你自己的。

Nodejs 在Nginx服务器上部署

Mon, 30 Jun 2025 14:09:19 +0000

nginx配置如下：

upstream nodejs_upstream {
 server 127.0.0.1:3030;
 keepalive 64;
}


server {
 listen 80; ## listen for ipv4; this line is default and implied
 #listen [::]:80 default ipv6only=on; ## listen for ipv6

 server_name node.blog.gowhich.dev;

 location / {
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_set_header Host $http_host; 
 proxy_set_header X-NginX-Proxy true;
 proxy_set_header Connection "";
 proxy_http_version 1.1;
 proxy_pass http://nodejs_upstream;
 }
}

使用pm2启动nodejs项目，方便管理项目;

此处的3030是跟你nodejs项目启动的端口号是一致的。

使用Nodejs 实现 Scraping

Mon, 30 Jun 2025 14:09:15 +0000

这里是使用Cheerio

第一个测试代码如下：

var cheerio = require('cheerio'),
 $ = cheerio.load('<h2 class = "title">Hello world</h2>');

$('h2.title').text('Hello there!');
$('h2').addClass('welcome');

$.html();
//=> <h2 class = "title welcome">Hello there!</h2>

如果你的代码是放在本地文件的话，可以使用如下代码

var $ = require('cheerio')
var fs = require('fs')

var htmlString = fs.readFileSync('index.html').toString()
var parsedHTML = $.load(htmlString)

// query for all elements with class 'foo' and loop over them
parsedHTML('.foo').map(function(i, foo) {
 // the foo html element into a cheerio object (same pattern as jQuery)
 foo = $(foo)
 console.log(foo.text())
})

同样的，你也可以使用request模块获取远程的html页面

var $ = require('cheerio')
var request = require('request')

function gotHTML(err, resp, html) {
 if (err) return console.error(err)
 var parsedHTML = $.load(html)
 // get all img tags and loop over them
 var imageURLs = []
 parsedHTML('a').map(function(i, link) {
 var href = $(link).attr('href')
 if (!href.match('.png')) return
 imageURLs.push(domain + href)
 })
}

var domain = 'http://substack.net/images/'
request(domain, gotHTML)

最后一个例子是获取页面的img二进制文件，然后使用picture-tube和Stream API把他渲染出来

var pictureTube = require('picture-tube')

var randomIndex = Math.floor(Math.random() * imageURLs.length)
var randomImage = imageURLs[randomIndex]
request(randomImage).pipe(pictureTube()).pipe(process.stdout)

Nodejs+Mailparser+imap获取QQ邮件的内容

Mon, 30 Jun 2025 14:09:13 +0000

Nodejs 通过imap获取QQ email邮箱的内容：代码实现过程如下

var UTIL = require("util");
var HTTP = require("http");
var HTTPS = require("https");
var URL = require("url");
var HTMLPARSER = require("htmlparser2");
var FORMDATA = require("form-data");
var IMAP = require('imap');
var INSPECT = require('util').inspect;
var MAILPARSER = require('mailparser').MailParser;
var fs = require('fs'), fileStream;


var imap = new IMAP({
	user:'xx@xx',
	password:'password',
	host:'imap.qq.com',
	port:'993',
	tls:true
});

function openInbox(cb){
	imap.openBox('INBOX',true,cb);
}

imap.once('ready', function() {
 openInbox(function(err, box) {
 //邮件搜索
 imap.search([ 'SEEN', ['BEFORE', '2015-05-10'] ], function(err, results) {
 console.log(results);
 if (err) throw err;
 
 var f = imap.fetch(results, { 
 bodies: '',
 struct: true
 });
 
 f.on('message', function(msg, seqno) {
 console.log('Message #%d', seqno);
 var prefix = '(#' + seqno + ') ';
 msg.on('body', function(stream, info) {
 console.log('INFO WHICH:',info.which);
 if (info.which === 'TEXT'){
 console.log(prefix + 'Body [%s] found, %d total bytes', INSPECT(info.which), info.size);
 }
 
 var mailparser = new MAILPARSER();
 stream.pipe(mailparser);
 mailparser.on("end",function( mail ){
 fs.writeFile('msg-' + seqno + '-body.html', mail.text, function (err) {
 if (err) throw err;
 console.log(prefix + 'saved!');
 });
 });
 });
 
 msg.once('attributes', function(attrs) {
 console.log(prefix + 'Attributes: %s', INSPECT(attrs, false, 8));
 });
 msg.once('end', function() {
 console.log(prefix + 'Finished');
 });
 });

 f.once('error', function(err) {
 console.log('Fetch error: ' + err);
 });

 f.once('end', function() {
 console.log('Done fetching all messages!');
 imap.end();
 });
 });
 });
});
 
imap.once('error', function(err) {
 console.log(err);
});
 
imap.once('end', function() {
 console.log('Connection ended');
});
 
imap.connect();

执行

node app.js

即可在根目录下看到一个html的文件，打开就可以看到内容

这里使用的是mail.text，可以替换成mail.html就可以获取到有图文的html页面

Nodejs Async的使用实例

Mon, 30 Jun 2025 12:01:09 +0000

最近在玩nodejs，里面使用了mysql，但是如果你用过php的话，就知道过你想得到一个结果，操作的办法是从上一个sql语句中得到某个需要的值，然后再进行下一个语句使用到，使用nodejs的话，里面设计到了异步，为了达到我们需要的效果，认识了下async这个工具包。看下实例吧

module.exports.index = function(req,res){
 var id = req.query.id;
 var result;
 
 var sql = "select * from ?? order by id DESC";
 var options = ['user'];
 sql = mysql.format(sql,options);
 
 async.waterfall([
 function(done){
 var sql = "select * from ?? order by id DESC";
 var options = ['user'];
 sql = mysql.format(sql,options);
 
 
 DB.select(sql,function(error,result){
 if(!result){
 result = '';
 }
 var templates_data = new Object();
 templates_data['title'] = 'Qeeniao Admin';
 templates_data['result'] = result;
 
 done(null,result);
 });
 },
 function(list1,done){
 var sql = "select * from ?? order by id DESC";
 var options = ['user'];
 sql = mysql.format(sql,options);
 
 var tmp = [];
 if(list1.length > 0){
 list1.map(function(item){
 tmp.push(item);
 });
 }
 
 DB.select(sql,function(error,result){
 if(!result){
 result = [];
 }
 var templates_data = new Object();
 templates_data['title'] = 'Qeeniao Admin';
 templates_data['result'] = result;
 
 if(result.length > 0){
 result.map(function(item){
 tmp.push(item);
 });
 }
 done(null,tmp);
 });
 }
 ],function(error,result){
 if(!result){
 result = '';
 }
 var templates_data = new Object();
 templates_data['title'] = 'Qeeniao Admin';
 templates_data['result'] = result;
 
 res.render('admin/index',templates_data);
 });
};

参考文章:http://yijiebuyi.com/blog/be234394cd350de16479c583f6f6bcb6.html

Node超级简单实现聊天服务器

Fri, 27 Jun 2025 14:14:22 +0000

Node超级简单实现聊天服务器

使用Nodejs是如此简单的实现了一个简单的聊天服务器

实现代码如下：

var net = require('net');

var chatServer = net.createServer(),clientList = [];

chatServer.on("connection",function(client){
 client.name = client.remoteAddress + ":" + client.remotePort;
 client.write("Hi! "+client.name+" \n");
 clientList.push(client);

 client.on("data",function(data){
 //数据发送给客户端
 broadcast(data,client);
 // clientList[i].write(data);
 });

 client.on("end",function(){
 clientList.splice(clientList.indexOf(client),1);
 });

 client.on("error",function(e){
 console.log(e)
 });
});
chatServer.listen(9000)

function broadcast(message,client){
 var cleanup = [];
 for(var i=0;i<clientList.length;i++){
 if(client != clientList[i]){
 if(clientList[i].writable){
 clientList[i].write(client.name = "says:"+message);
 }else{
 cleanup.push[clientList[i]];
 clientList[i].destory();
 }
 }
 }
}

使用过程就是：

启动js

node chat.js

连接方式：telnet

telnet 127.0.0.1 9000

nodejs中express的“Error: Cannot find module 'jade'”错误

Tue, 17 Jun 2025 17:01:09 +0000

安装express之后访问http://localhost:8080 。

会出现500 Error: Cannot find module ‘jade’错误

解决方案：
确定package.json里有添加相应的jade依赖配置

使用npm install -d 可以自动配置package.json，并安装所有需要依赖的包

命令行下执行：

npm install -d

Nodejs安装及Express框架简介-简单的nodejs网站搭建

Tue, 17 Jun 2025 16:45:20 +0000

用node.js建博客(一) - node.js安装及Express框架简介

技术准备:

node.js 写本文的时候我采用的版本是0.4.5, Win用户需要自行编译node.exe
npm 类似Ruby中的RubyGems, node.js包依赖管理工具
express 类似Ruby中的Sinatra, 一个简单的Web框架
markdown.js node.js中的markdown解析器，什么是markdown?? 用过GitHub的朋友应该知道，readme.md文件
prettify.js google-code-prettify, 提供在线的语法高亮支持，支持语法包括C-like, Java, Python, shell等大多数语言。

安装Nodejs

可以参考我的这篇文章：http://www.gowhich.com/blog/40

安装 npm

1）. Unix/Linux:

$ curl http://npmjs.org/install.sh | sh

安装完成后

$ npm -v

看看是否安装成功

2）. Windows:

待补充

Nodejs的express框架

如果你用过Ruby的Sinatra.rb, 会觉得Express非常熟悉。Express作者是参考sinatra, 写了一个基于node.js的实现。

安装

由于这个有点特殊，需要为npm添加-g参数，刚开始安装的时候没有加，导致不能使用epress 命令行参数

$ npm install -g express
$ epxress -v #看看是否安装成功

创建一个express项目看看

$ express nodeblog
$ cd nodeblog

Express 目录结构

目录/文件 说明
./ 根目录，我们的node.js代码都会方这个目录
package.json npm依赖配置文件， 类似ruby中的Gemfile, java Maven中的pom.xml文件.
 一会需要在这里添加 markdownjs-js 项目依赖
app.js 项目的入口文件
public/
 javascript/
 stylesheets/
 images/ 存放静态资源文件, jquery/prettify.js等静态库会方这里，当然自己编写的前端代码也可以放这里
views/ 模板文件, express默认采用jade, 当然，你也可以使用自己喜欢的haml,JES, coffeeKup,
 jQueryTemplate等模板引擎
node_modules/ 存放npm安装到本地依赖包，依赖包在package.json文件中声明，使用npm install指令安装

运行程序看看

$ npm install
$ node app.js

访问http://localhost:3000/

我们看看app.js文件:

var express = require('express'); 
var app = module.exports = express.createServer(); 
 
// Express 程序配置 
app.configure(function(){ 
 app.set('views', __dirname + '/views'); 
 app.set('view engine', 'jade'); 
 app.use(express.bodyParser()); 
 app.use(express.methodOverride()); 
 app.use(app.router); 
 app.use(express.static(__dirname + '/public')); 
}); 
 
// url路由 
app.get('/', function(req, res){ 
 res.render('index', { 
 title: 'Express' 
 }); 
}); 
 
app.listen(3000);

下面代码将url渲染到 index.jade文件, 并且传递title参数:

app.get('/', function(req, res){ 
 res.render('index', { 
 title: 'Express' 
 }); 
});

其中传递变量title, 在views/layout.jade文件中有定义, 我们这里将title改成"Node Blog":

app.get('/', function(req, res){ 
 res.render('index', { 
 title: 'Node Blog' 
 }); 
});

修改后效果如下所示:

到这里， Express 入门介绍就到这里，进一步内容需要看参考资料中的相关文档

参考资料:

jade GitHub仓库: https://github.com/visionmedia/jade

《Express中文入门手册》

《markdown语法说明》

《google-code-prettify使用说明》

《使用node.js, markdownjs, prettify.js打造个人写作平台》

《将node.js应用上传到vmc平台》, 这是我前两天写的一篇，关于如何将应用上传到vmc服务器，后面篇幅不会再做介绍。

http://witcheryne.iteye.com/blog/1165067

Nodejs上HTML分析利器node-jquery

Tue, 17 Jun 2025 15:51:25 +0000

Node.js解析HTML DOM的当然是htmlpaser，jsdom。然而个人更喜欢jQuery的风格，与web jQuery的统一API,所以选择了node-jquery.其代码部署在Github的https://github.com/coolaj86/node-jquery.

借助某人之手搞了个示例，代码如下：

var $ = require('jquery');
String.format = function() {

	var s = arguments[0];

	for (var i = 0; i < arguments.length - 1; i++) {

		var reg = new RegExp("\\{" + i + "\\}", "gm");

		s = s.replace(reg, arguments[i + 1]);

	}

	return s;

};

$.get("https://github.com/popular/forked",function(html){

	var $doc = $(html);

	console.log("No. name language star forks ")

	$doc.find("ul.repolist li.source").each(function(i,project){

		var $project = $(project);

		var name = $project.find("h3").text().trim();

		var language = $project.find("li:eq(0)").text().trim();

		var star = $project.find("li.stargazers").text().trim();

		var forks = $project.find("li.forks").text().trim();

		var row =String.format("{4} {0} {1} {2} {3}",name, language,star,forks,i + 1 );

		console.log(row);

	});

});

参考：http://www.cnblogs.com/whitewolf/archive/2013/02/27/2935618.html

Nodejs的加载html页面和远程获取页面进行匹配操作

Tue, 17 Jun 2025 15:51:17 +0000

1，nodejs 的加载html页面

function detail(response, query_param){
	fs.readFile('./sina_weibo.html','utf-8',function(err, data) {//读取内容
 if(err) throw err;
 response.setHeader('content-type', 'text/html;charset=utf-8');
		response.writeHead(200, {"Content-Type": "text/plain"});
		response.write(data);
		response.end();
 });
	
}

2，远程获取页面并进行匹配的操作

function blog(response, query_param){
 // fs.readFile('./sina_weibo.html','utf-8',function(err, data) {//读取内容
 // if(err) throw err;
 // return data;
 // });

	response.setHeader('content-type', 'text/html;charset=utf-8');
	response.writeHead(200, {"Content-Type": "text/plain"});
 var options = { 
 host: '10.211.55.5', 
 port: 8006, 
 path: '/detail'
 };
 
 var html = '追加变量的变量 ';
 http.get(options, function(res) { 
 res.on('data', function(data) { 
 console.log("data here = " + data);
 // collect the data chunks to the variable named "html" 
 html += data; 
 html += "这里在获取数据";
 }).on('end', function() { 
 // the whole of webpage data has been collected. parsing time! 
 var title = $(html).find('div h3 span').each(function($this){ 
 var a = $(this).children('a').attr('href'); 
 var b = $(this).children('a').text();
 console.log(b + ":" + options.host + a); 
 html += b + ":" + options.host + a;
 response.write(html);
 });
 html += "这里在循环数据";
 });
 html += '结束';
 });
	response.end();
}

执行上面的方法，在nodejs里面需要加入几个模块

var querystring = require("querystring");
var fs = require("fs");
var http = require('http');
var $ = require('jquery');

如果没有安装jquery的话，执行下面的命令

npm install jquery

如果没有安装npm 的话，建议去google一下吧

Nodejs搭建web服务器

Tue, 10 Jun 2025 10:40:46 +0000

nodejs的安装其实是很简单的，官方文档是有直接安装的文件的，之后linux下的稍微麻烦一点，不过只要解压一下，然后直接安装，也是比较简单的。

如果不懂的可以参考我的这篇文章nodejs的安装，测试，hello world

下面演示我的web服务器

第一个是引导文件：

直接看代码好了

index.js

var server = require('./server');
var router = require('./router');
var requestHandlers = require('./requestHandlers');
var handle = {};
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
handle["/weibo"] = requestHandlers.weibo;
handle["/baiduindex"] = requestHandlers.baiduindex;
server.start(router.route,handle);

看到上面的代码中，require了三个文件，下面我分别给出这三个文件

server.js

var http = require('http');
var url = require('url');
var querystring = require("querystring");
function start(route,handle){
 function onRequest(request,response){
 var url_array = url.parse(request.url,true);
 var pathname = url_array.pathname;
 var query_param = url_array.query;
 
 route(handle, pathname, response, query_param);
 }
 http.createServer(onRequest).listen(8006);
 console.log("Server has started. listen:8006");
}
exports.start = start;

router.js

function route(handle,pathname, response, query_param){
// console.log("About to route a request for "+pathname);
 if(typeof handle[pathname] === "function"){
 return handle[pathname](response, query_param);
 }else{
// console.log("No request handler found for " + pathname);
 response.writeHead(404, {"Content-Type": "text/plain"});
 response.write("404 Not found");
 response.end();
 }
}
exports.route = route;

requestHandlers.js

var querystring = require("querystring");
var sinaweibo = require("./sinaWeibo");
var baidu = require("./baiduIndex");

function start(response, query_param){
// console.log("Request handler 'start' was called.");
 return "Hello Start";
}

function upload(response, query_param){
// console.log("Request handler 'upload' was called.");
 response.writeHead(200, {"Content-Type": "text/plain"});
 response.write("You've sent: " + postData +" " + querystring.parse(postData).text);
 response.end();
}

function weibo(response, query_param){
 var content = sinaweibo.GetRSA(query_param.servertime,query_param.nonce,query_param.password);
 response.writeHead(200, {"Content-Type": "text/plain"});
 response.write(content);
 response.end();
}
function baiduindex(response, query_param){
 var content = baidu.execEval(query_param.input,query_param.key);
 response.writeHead(200, {"Content-Type": "text/plain"});
 response.write(content);
 response.end();
}
exports.start = start;
exports.upload = upload;
exports.weibo = weibo;
exports.baiduindex = baiduindex;

在requestHandlers.js文件中，又引入了两个文件，分别是关于sinaWeibo和baiduIndex

在这两个文件中分别是关于对应的一个操作，如果你要针对于自己的操作，也可以自己加入到里面来。

sinaWeibo.js

var sinaSSOEncoder = sinaSSOEncoder || {};
(function(){
 var hexcase = 0;
 var chrsz = 8; 
 this.hex_sha1 = function(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}; 
 var core_sha1 = function(x, len) { 
 x[len >> 5] |= 0x80 << (24 - len % 32); 
 x[((len + 64 >> 9) << 4) + 15] = len; 
 var w = Array(80); 
 var a = 1732584193; 
 var b = -271733879; 
 var c = -1732584194; 
 var d = 271733878; 
 var e = -1009589776; 

 for(var i = 0; i < x.length; i += 16) { 
 var olda = a; 
 var oldb = b; 
 var oldc = c; 
 var oldd = d; 
 var olde = e; 

 for(var j = 0; j < 80; j++) { 
 if(j < 16) w[j] = x[i + j]; 
 else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1); 
 var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), 
 safe_add(safe_add(e, w[j]), sha1_kt(j))); 
 e = d; 
 d = c; 
 c = rol(b, 30); 
 b = a; 
 a = t; 
 } 

 a = safe_add(a, olda); 
 b = safe_add(b, oldb); 
 c = safe_add(c, oldc); 
 d = safe_add(d, oldd); 
 e = safe_add(e, olde); 
 } 
 return Array(a, b, c, d, e); 

 };
 /* 
 * Perform the appropriate triplet combination function for the current 
 * iteration 
 */ 
 var sha1_ft = function(t, b, c, d) { 
 if(t < 20) return (b & c) | ((~b) & d); 
 if(t < 40) return b ^ c ^ d; 
 if(t < 60) return (b & c) | (b & d) | (c & d); 
 return b ^ c ^ d; 
 }; 

 /* 
 * Determine the appropriate additive constant for the current iteration 
 */ 
 var sha1_kt = function(t) { 
 return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : 
 (t < 60) ? -1894007588 : -899497514; 
 }; 
 /* 
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally 
 * to work around bugs in some JS interpreters. 
 */ 
 var safe_add = function(x, y) { 
 var lsw = (x & 0xFFFF) + (y & 0xFFFF); 
 var msw = (x >> 16) + (y >> 16) + (lsw >> 16); 
 return (msw << 16) | (lsw & 0xFFFF); 
 }; 

 /* 
 * Bitwise rotate a 32-bit number to the left. 
 */ 
 var rol = function(num, cnt) { 
 return (num << cnt) | (num >>> (32 - cnt)); 
 }; 

 var str2binb = function(str) { 
 var bin = Array(); 
 var mask = (1 << chrsz) - 1;
 for(var i = 0; i < str.length * chrsz; i += chrsz)
 bin[i>>5] |= (str.charCodeAt(i /chrsz) & mask) << (24 - i%32);
 return bin; 
 };
 var binb2hex = function(binarray) { 
 var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef"; 
 var str = ""; 
 for(var i = 0; i < binarray.length * 4; i++){ 
 str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) + 
 hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8 )) & 0xF); 
 } 
 return str; 
 };

 this.base64 = {
 encode:function(input) {
 input = "" + input; // Convert to string for encode
 if (input == "") return ""; 
 
 var output = '';
 var chr1, chr2, chr3 = '';
 var enc1, enc2, enc3, enc4 = '';
 var i = 0;
 do {
 chr1 = input.charCodeAt(i++);
 chr2 = input.charCodeAt(i++);
 chr3 = input.charCodeAt(i++);
 enc1 = chr1 >> 2;
 enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
 enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
 enc4 = chr3 & 63;
 if (isNaN(chr2)){
 enc3 = enc4 = 64;
 } else if (isNaN(chr3)){
 enc4 = 64;
 }
 output = output+this._keys.charAt(enc1)+this._keys.charAt(enc2)+this._keys.charAt(enc3)+this._keys.charAt(enc4);
 chr1 = chr2 = chr3 = '';
 enc1 = enc2 = enc3 = enc4 = '';
 } while (i < input.length);
 return output;
 },
 
 _keys: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='

 };
}).call(sinaSSOEncoder);

//RSA
;(function(){ 
 /********************* jsbn.js start ************************/

 // Copyright (c) 2005 Tom Wu
 // All Rights Reserved.
 // See "LICENSE" for details.
 
 // Basic JavaScript BN library - subset useful for RSA encryption.
 
 // Bits per digit
 var dbits;
 
 // JavaScript engine analysis
 var canary = 0xdeadbeefcafe;
 var j_lm = ((canary&0xffffff)==0xefcafe);
 
 // (public) Constructor
 function BigInteger(a,b,c) {
 if(a != null)
 if("number" == typeof a) this.fromNumber(a,b,c);
 else if(b == null && "string" != typeof a) this.fromString(a,256);
 else this.fromString(a,b);
 }
 
 // return new, unset BigInteger
 function nbi() { return new BigInteger(null); }
 
 // am: Compute w_j += (x*this_i), propagate carries,
 // c is initial carry, returns final carry.
 // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
 // We need to select the fastest one that works in this environment.
 
 // am1: use a single mult and divide to get the high bits,
 // max digit bits should be 26 because
 // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
 function am1(i,x,w,j,c,n) {
 while(--n >= 0) {
 var v = x*this[i++]+w[j]+c;
 c = Math.floor(v/0x4000000);
 w[j++] = v&0x3ffffff;
 }
 return c;
 }
 // am2 avoids a big mult-and-extract completely.
 // Max digit bits should be <= 30 because we do bitwise ops
 // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
 function am2(i,x,w,j,c,n) {
 var xl = x&0x7fff, xh = x>>15;
 while(--n >= 0) {
 var l = this[i]&0x7fff;
 var h = this[i++]>>15;
 var m = xh*l+h*xl;
 l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);
 c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
 w[j++] = l&0x3fffffff;
 }
 return c;
 }
 // Alternately, set max digit bits to 28 since some
 // browsers slow down when dealing with 32-bit numbers.
 function am3(i,x,w,j,c,n) {
 var xl = x&0x3fff, xh = x>>14;
 while(--n >= 0) {
 var l = this[i]&0x3fff;
 var h = this[i++]>>14;
 var m = xh*l+h*xl;
 l = xl*l+((m&0x3fff)<<14)+w[j]+c;
 c = (l>>28)+(m>>14)+xh*h;
 w[j++] = l&0xfffffff;
 }
 return c;
 }
 // Mozilla/Netscape seems to prefer am3
 BigInteger.prototype.am = am3;
 dbits = 28;
 
 
 BigInteger.prototype.DB = dbits;
 BigInteger.prototype.DM = ((1<<dbits)-1);
 BigInteger.prototype.DV = (1<<dbits);
 
 var BI_FP = 52;
 BigInteger.prototype.FV = Math.pow(2,BI_FP);
 BigInteger.prototype.F1 = BI_FP-dbits;
 BigInteger.prototype.F2 = 2*dbits-BI_FP;
 
 // Digit conversions
 var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
 var BI_RC = new Array();
 var rr,vv;
 rr = "0".charCodeAt(0);
 for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
 rr = "a".charCodeAt(0);
 for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
 rr = "A".charCodeAt(0);
 for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
 
 function int2char(n) { return BI_RM.charAt(n); }
 function intAt(s,i) {
 var c = BI_RC[s.charCodeAt(i)];
 return (c==null)?-1:c;
 }
 
 // (protected) copy this to r
 function bnpCopyTo(r) {
 for(var i = this.t-1; i >= 0; --i) r[i] = this[i];
 r.t = this.t;
 r.s = this.s;
 }
 
 // (protected) set from integer value x, -DV <= x < DV
 function bnpFromInt(x) {
 this.t = 1;
 this.s = (x<0)?-1:0;
 if(x > 0) this[0] = x;
 else if(x < -1) this[0] = x+DV;
 else this.t = 0;
 }
 
 // return bigint initialized to value
 function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
 
 // (protected) set from string and radix
 function bnpFromString(s,b) {
 var k;
 if(b == 16) k = 4;
 else if(b == 8) k = 3;
 else if(b == 256) k = 8; // byte array
 else if(b == 2) k = 1;
 else if(b == 32) k = 5;
 else if(b == 4) k = 2;
 else { this.fromRadix(s,b); return; }
 this.t = 0;
 this.s = 0;
 var i = s.length, mi = false, sh = 0;
 while(--i >= 0) {
 var x = (k==8)?s[i]&0xff:intAt(s,i);
 if(x < 0) {
 if(s.charAt(i) == "-") mi = true;
 continue;
 }
 mi = false;
 if(sh == 0)
 this[this.t++] = x;
 else if(sh+k > this.DB) {
 this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;
 this[this.t++] = (x>>(this.DB-sh));
 }
 else
 this[this.t-1] |= x<<sh;
 sh += k;
 if(sh >= this.DB) sh -= this.DB;
 }
 if(k == 8 && (s[0]&0x80) != 0) {
 this.s = -1;
 if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
 }
 this.clamp();
 if(mi) BigInteger.ZERO.subTo(this,this);
 }
 
 // (protected) clamp off excess high words
 function bnpClamp() {
 var c = this.s&this.DM;
 while(this.t > 0 && this[this.t-1] == c) --this.t;
 }
 
 // (public) return string representation in given radix
 function bnToString(b) {
 if(this.s < 0) return "-"+this.negate().toString(b);
 var k;
 if(b == 16) k = 4;
 else if(b == 8) k = 3;
 else if(b == 2) k = 1;
 else if(b == 32) k = 5;
 else if(b == 4) k = 2;
 else return this.toRadix(b);
 var km = (1<<k)-1, d, m = false, r = "", i = this.t;
 var p = this.DB-(i*this.DB)%k;
 if(i-- > 0) {
 if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }
 while(i >= 0) {
 if(p < k) {
 d = (this[i]&((1<<p)-1))<<(k-p);
 d |= this[--i]>>(p+=this.DB-k);
 }
 else {
 d = (this[i]>>(p-=k))&km;
 if(p <= 0) { p += this.DB; --i; }
 }
 if(d > 0) m = true;
 if(m) r += int2char(d);
 }
 }
 return m?r:"0";
 }
 
 // (public) -this
 function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
 
 // (public) |this|
 function bnAbs() { return (this.s<0)?this.negate():this; }
 
 // (public) return + if this > a, - if this < a, 0 if equal
 function bnCompareTo(a) {
 var r = this.s-a.s;
 if(r != 0) return r;
 var i = this.t;
 r = i-a.t;
 if(r != 0) return r;
 while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
 return 0;
 }
 
 // returns bit length of the integer x
 function nbits(x) {
 var r = 1, t;
 if((t=x>>>16) != 0) { x = t; r += 16; }
 if((t=x>>8) != 0) { x = t; r += 8; }
 if((t=x>>4) != 0) { x = t; r += 4; }
 if((t=x>>2) != 0) { x = t; r += 2; }
 if((t=x>>1) != 0) { x = t; r += 1; }
 return r;
 }
 
 // (public) return the number of bits in "this"
 function bnBitLength() {
 if(this.t <= 0) return 0;
 return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
 }
 
 // (protected) r = this << n*DB
 function bnpDLShiftTo(n,r) {
 var i;
 for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
 for(i = n-1; i >= 0; --i) r[i] = 0;
 r.t = this.t+n;
 r.s = this.s;
 }
 
 // (protected) r = this >> n*DB
 function bnpDRShiftTo(n,r) {
 for(var i = n; i < this.t; ++i) r[i-n] = this[i];
 r.t = Math.max(this.t-n,0);
 r.s = this.s;
 }
 
 // (protected) r = this << n
 function bnpLShiftTo(n,r) {
 var bs = n%this.DB;
 var cbs = this.DB-bs;
 var bm = (1<<cbs)-1;
 var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;
 for(i = this.t-1; i >= 0; --i) {
 r[i+ds+1] = (this[i]>>cbs)|c;
 c = (this[i]&bm)<<bs;
 }
 for(i = ds-1; i >= 0; --i) r[i] = 0;
 r[ds] = c;
 r.t = this.t+ds+1;
 r.s = this.s;
 r.clamp();
 }
 
 // (protected) r = this >> n
 function bnpRShiftTo(n,r) {
 r.s = this.s;
 var ds = Math.floor(n/this.DB);
 if(ds >= this.t) { r.t = 0; return; }
 var bs = n%this.DB;
 var cbs = this.DB-bs;
 var bm = (1<<bs)-1;
 r[0] = this[ds]>>bs;
 for(var i = ds+1; i < this.t; ++i) {
 r[i-ds-1] |= (this[i]&bm)<<cbs;
 r[i-ds] = this[i]>>bs;
 }
 if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;
 r.t = this.t-ds;
 r.clamp();
 }
 
 // (protected) r = this - a
 function bnpSubTo(a,r) {
 var i = 0, c = 0, m = Math.min(a.t,this.t);
 while(i < m) {
 c += this[i]-a[i];
 r[i++] = c&this.DM;
 c >>= this.DB;
 }
 if(a.t < this.t) {
 c -= a.s;
 while(i < this.t) {
 c += this[i];
 r[i++] = c&this.DM;
 c >>= this.DB;
 }
 c += this.s;
 }
 else {
 c += this.s;
 while(i < a.t) {
 c -= a[i];
 r[i++] = c&this.DM;
 c >>= this.DB;
 }
 c -= a.s;
 }
 r.s = (c<0)?-1:0;
 if(c < -1) r[i++] = this.DV+c;
 else if(c > 0) r[i++] = c;
 r.t = i;
 r.clamp();
 }
 
 // (protected) r = this * a, r != this,a (HAC 14.12)
 // "this" should be the larger one if appropriate.
 function bnpMultiplyTo(a,r) {
 var x = this.abs(), y = a.abs();
 var i = x.t;
 r.t = i+y.t;
 while(--i >= 0) r[i] = 0;
 for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
 r.s = 0;
 r.clamp();
 if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
 }
 
 // (protected) r = this^2, r != this (HAC 14.16)
 function bnpSquareTo(r) {
 var x = this.abs();
 var i = r.t = 2*x.t;
 while(--i >= 0) r[i] = 0;
 for(i = 0; i < x.t-1; ++i) {
 var c = x.am(i,x[i],r,2*i,0,1);
 if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
 r[i+x.t] -= x.DV;
 r[i+x.t+1] = 1;
 }
 }
 if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
 r.s = 0;
 r.clamp();
 }
 
 // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
 // r != q, this != m. q or r may be null.
 function bnpDivRemTo(m,q,r) {
 var pm = m.abs();
 if(pm.t <= 0) return;
 var pt = this.abs();
 if(pt.t < pm.t) {
 if(q != null) q.fromInt(0);
 if(r != null) this.copyTo(r);
 return;
 }
 if(r == null) r = nbi();
 var y = nbi(), ts = this.s, ms = m.s;
 var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus
 if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
 else { pm.copyTo(y); pt.copyTo(r); }
 var ys = y.t;
 var y0 = y[ys-1];
 if(y0 == 0) return;
 var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);
 var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;
 var i = r.t, j = i-ys, t = (q==null)?nbi():q;
 y.dlShiftTo(j,t);
 if(r.compareTo(t) >= 0) {
 r[r.t++] = 1;
 r.subTo(t,r);
 }
 BigInteger.ONE.dlShiftTo(ys,t);
 t.subTo(y,y); // "negative" y so we can replace sub with am later
 while(y.t < ys) y[y.t++] = 0;
 while(--j >= 0) {
 // Estimate quotient digit
 var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
 if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out
 y.dlShiftTo(j,t);
 r.subTo(t,r);
 while(r[i] < --qd) r.subTo(t,r);
 }
 }
 if(q != null) {
 r.drShiftTo(ys,q);
 if(ts != ms) BigInteger.ZERO.subTo(q,q);
 }
 r.t = ys;
 r.clamp();
 if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
 if(ts < 0) BigInteger.ZERO.subTo(r,r);
 }
 
 // (public) this mod a
 function bnMod(a) {
 var r = nbi();
 this.abs().divRemTo(a,null,r);
 if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
 return r;
 }
 
 // Modular reduction using "classic" algorithm
 function Classic(m) { this.m = m; }
 function cConvert(x) {
 if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
 else return x;
 }
 function cRevert(x) { return x; }
 function cReduce(x) { x.divRemTo(this.m,null,x); }
 function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
 function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
 
 Classic.prototype.convert = cConvert;
 Classic.prototype.revert = cRevert;
 Classic.prototype.reduce = cReduce;
 Classic.prototype.mulTo = cMulTo;
 Classic.prototype.sqrTo = cSqrTo;
 
 // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
 // justification:
 // xy == 1 (mod m)
 // xy = 1+km
 // xy(2-xy) = (1+km)(1-km)
 // x[y(2-xy)] = 1-k^2m^2
 // x[y(2-xy)] == 1 (mod m^2)
 // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
 // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
 // JS multiply "overflows" differently from C/C++, so care is needed here.
 function bnpInvDigit() {
 if(this.t < 1) return 0;
 var x = this[0];
 if((x&1) == 0) return 0;
 var y = x&3; // y == 1/x mod 2^2
 y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
 y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8
 y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16
 // last step - calculate inverse mod DV directly;
 // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
 y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits
 // we really want the negative inverse, and -DV < y < DV
 return (y>0)?this.DV-y:-y;
 }
 
 // Montgomery reduction
 function Montgomery(m) {
 this.m = m;
 this.mp = m.invDigit();
 this.mpl = this.mp&0x7fff;
 this.mph = this.mp>>15;
 this.um = (1<<(m.DB-15))-1;
 this.mt2 = 2*m.t;
 }
 
 // xR mod m
 function montConvert(x) {
 var r = nbi();
 x.abs().dlShiftTo(this.m.t,r);
 r.divRemTo(this.m,null,r);
 if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
 return r;
 }
 
 // x/R mod m
 function montRevert(x) {
 var r = nbi();
 x.copyTo(r);
 this.reduce(r);
 return r;
 }
 
 // x = x/R mod m (HAC 14.32)
 function montReduce(x) {
 while(x.t <= this.mt2) // pad x so am has enough room later
 x[x.t++] = 0;
 for(var i = 0; i < this.m.t; ++i) {
 // faster way of calculating u0 = x[i]*mp mod DV
 var j = x[i]&0x7fff;
 var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
 // use am to combine the multiply-shift-add into one call
 j = i+this.m.t;
 x[j] += this.m.am(0,u0,x,i,0,this.m.t);
 // propagate carry
 while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
 }
 x.clamp();
 x.drShiftTo(this.m.t,x);
 if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
 }
 
 // r = "x^2/R mod m"; x != r
 function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
 
 // r = "xy/R mod m"; x,y != r
 function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
 
 Montgomery.prototype.convert = montConvert;
 Montgomery.prototype.revert = montRevert;
 Montgomery.prototype.reduce = montReduce;
 Montgomery.prototype.mulTo = montMulTo;
 Montgomery.prototype.sqrTo = montSqrTo;
 
 // (protected) true iff this is even
 function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
 
 // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
 function bnpExp(e,z) {
 if(e > 0xffffffff || e < 1) return BigInteger.ONE;
 var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
 g.copyTo(r);
 while(--i >= 0) {
 z.sqrTo(r,r2);
 if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
 else { var t = r; r = r2; r2 = t; }
 }
 return z.revert(r);
 }
 
 // (public) this^e % m, 0 <= e < 2^32
 function bnModPowInt(e,m) {
 var z;
 if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
 return this.exp(e,z);
 }
 
 // protected
 BigInteger.prototype.copyTo = bnpCopyTo;
 BigInteger.prototype.fromInt = bnpFromInt;
 BigInteger.prototype.fromString = bnpFromString;
 BigInteger.prototype.clamp = bnpClamp;
 BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
 BigInteger.prototype.drShiftTo = bnpDRShiftTo;
 BigInteger.prototype.lShiftTo = bnpLShiftTo;
 BigInteger.prototype.rShiftTo = bnpRShiftTo;
 BigInteger.prototype.subTo = bnpSubTo;
 BigInteger.prototype.multiplyTo = bnpMultiplyTo;
 BigInteger.prototype.squareTo = bnpSquareTo;
 BigInteger.prototype.divRemTo = bnpDivRemTo;
 BigInteger.prototype.invDigit = bnpInvDigit;
 BigInteger.prototype.isEven = bnpIsEven;
 BigInteger.prototype.exp = bnpExp;
 
 // public
 BigInteger.prototype.toString = bnToString;
 BigInteger.prototype.negate = bnNegate;
 BigInteger.prototype.abs = bnAbs;
 BigInteger.prototype.compareTo = bnCompareTo;
 BigInteger.prototype.bitLength = bnBitLength;
 BigInteger.prototype.mod = bnMod;
 BigInteger.prototype.modPowInt = bnModPowInt;
 
 // "constants"
 BigInteger.ZERO = nbv(0);
 BigInteger.ONE = nbv(1);

/********************* jsbn.js end ************************/

/********************* prng4.js start ************************/

 // prng4.js - uses Arcfour as a PRNG

 function Arcfour() {
 this.i = 0;
 this.j = 0;
 this.S = new Array();
 }
 
 // Initialize arcfour context from key, an array of ints, each from [0..255]
 function ARC4init(key) {
 var i, j, t;
 for(i = 0; i < 256; ++i)
 this.S[i] = i;
 j = 0;
 for(i = 0; i < 256; ++i) {
 j = (j + this.S[i] + key[i % key.length]) & 255;
 t = this.S[i];
 this.S[i] = this.S[j];
 this.S[j] = t;
 }
 this.i = 0;
 this.j = 0;
 }
 
 function ARC4next() {
 var t;
 this.i = (this.i + 1) & 255;
 this.j = (this.j + this.S[this.i]) & 255;
 t = this.S[this.i];
 this.S[this.i] = this.S[this.j];
 this.S[this.j] = t;
 return this.S[(t + this.S[this.i]) & 255];
 }
 
 Arcfour.prototype.init = ARC4init;
 Arcfour.prototype.next = ARC4next;
 
 // Plug in your RNG constructor here
 function prng_newstate() {
 return new Arcfour();
 }
 
 // Pool size must be a multiple of 4 and greater than 32.
 // An array of bytes the size of the pool will be passed to init()
 var rng_psize = 256;

/********************* prng4.js end ************************/

/********************* rng.js start ************************/

 // Random number generator - requires a PRNG backend, e.g. prng4.js
 
 // For best results, put code like
 // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>
 // in your main HTML document.
 
 var rng_state;
 var rng_pool;
 var rng_pptr;
 
 // Mix in a 32-bit integer into the pool
 function rng_seed_int(x) {
 rng_pool[rng_pptr++] ^= x & 255;
 rng_pool[rng_pptr++] ^= (x >> 8) & 255;
 rng_pool[rng_pptr++] ^= (x >> 16) & 255;
 rng_pool[rng_pptr++] ^= (x >> 24) & 255;
 if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;
 }
 
 // Mix in the current time (w/milliseconds) into the pool
 function rng_seed_time() {
 rng_seed_int(new Date().getTime());
 }
 
 // Initialize the pool with junk if needed.
 if(rng_pool == null) {
 rng_pool = new Array();
 rng_pptr = 0;
 var t;
 
 while(rng_pptr < rng_psize) { // extract some randomness from Math.random()
 t = Math.floor(65536 * Math.random());
 rng_pool[rng_pptr++] = t >>> 8;
 rng_pool[rng_pptr++] = t & 255;
 }
 rng_pptr = 0;
 rng_seed_time();
 //rng_seed_int(window.screenX);
 //rng_seed_int(window.screenY);
 }
 
 function rng_get_byte() {
 if(rng_state == null) {
 rng_seed_time();
 rng_state = prng_newstate();
 rng_state.init(rng_pool);
 for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
 rng_pool[rng_pptr] = 0;
 rng_pptr = 0;
 //rng_pool = null;
 }
 // TODO: allow reseeding after first request
 return rng_state.next();
 }
 
 function rng_get_bytes(ba) {
 var i;
 for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();
 }
 
 function SecureRandom() {}
 
 SecureRandom.prototype.nextBytes = rng_get_bytes;
 
/********************* rng.js end ************************/

/********************* rsa.js start ************************/

 // Depends on jsbn.js and rng.js
 
 // Version 1.1: support utf-8 encoding in pkcs1pad2
 
 // convert a (hex) string to a bignum object
 function parseBigInt(str,r) {
 return new BigInteger(str,r);
 }
 
 function linebrk(s,n) {
 var ret = "";
 var i = 0;
 while(i + n < s.length) {
 ret += s.substring(i,i+n) + "\n";
 i += n;
 }
 return ret + s.substring(i,s.length);
 }
 
 function byte2Hex(b) {
 if(b < 0x10)
 return "0" + b.toString(16);
 else
 return b.toString(16);
 }
 
 // PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
 function pkcs1pad2(s,n) {
 if(n < s.length + 11) { // TODO: fix for utf-8
 alert("Message too long for RSA");
 return null;
 }
 var ba = new Array();
 var i = s.length - 1;
 while(i >= 0 && n > 0) {
 var c = s.charCodeAt(i--);
 if(c < 128) { // encode using utf-8
 ba[--n] = c;
 }
 else if((c > 127) && (c < 2048)) {
 ba[--n] = (c & 63) | 128;
 ba[--n] = (c >> 6) | 192;
 }
 else {
 ba[--n] = (c & 63) | 128;
 ba[--n] = ((c >> 6) & 63) | 128;
 ba[--n] = (c >> 12) | 224;
 }
 }
 ba[--n] = 0;
 var rng = new SecureRandom();
 var x = new Array();
 while(n > 2) { // random non-zero pad
 x[0] = 0;
 while(x[0] == 0) rng.nextBytes(x);
 ba[--n] = x[0];
 }
 ba[--n] = 2;
 ba[--n] = 0;
 return new BigInteger(ba);
 }
 
 // "empty" RSA key constructor
 function RSAKey() {
 this.n = null;
 this.e = 0;
 this.d = null;
 this.p = null;
 this.q = null;
 this.dmp1 = null;
 this.dmq1 = null;
 this.coeff = null;
 }
 
 // Set the public key fields N and e from hex strings
 function RSASetPublic(N,E) {
 if(N != null && E != null && N.length > 0 && E.length > 0) {
 this.n = parseBigInt(N,16);
 this.e = parseInt(E,16);
 }
 else
 alert("Invalid RSA public key");
 }
 
 // Perform raw public operation on "x": return x^e (mod n)
 function RSADoPublic(x) {
 return x.modPowInt(this.e, this.n);
 }
 
 // Return the PKCS#1 RSA encryption of "text" as an even-length hex string
 function RSAEncrypt(text) {
 var m = pkcs1pad2(text,(this.n.bitLength()+7)>>3);
 if(m == null) return null;
 var c = this.doPublic(m);
 if(c == null) return null;
 var h = c.toString(16);
 if((h.length & 1) == 0) return h; else return "0" + h;
 }
 
 // Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
 //function RSAEncryptB64(text) {
 // var h = this.encrypt(text);
 // if(h) return hex2b64(h); else return null;
 //}
 
 // protected
 RSAKey.prototype.doPublic = RSADoPublic;
 
 // public
 RSAKey.prototype.setPublic = RSASetPublic;
 RSAKey.prototype.encrypt = RSAEncrypt;
 //RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
 
 //暴露RSAKey
 this.RSAKey = RSAKey;

//example:
// var rsa = new RSAKey();
// rsa.setPublic(encode_key, key_plus);
// password = rsa.encrypt(password);

}).call(sinaSSOEncoder);
// function getpass(pwd,servicetime,nonce,rsaPubkey){
// var RSAKey=new sinaSSOEncoder.RSAKey();
// RSAKey.setPublic(rsaPubkey,'10001');
// var password=RSAKey.encrypt([servicetime,nonce].join('\t')+'\n'+pwd);
// return password;
// }

function GetRSA(servertime,nonce,password){
 var key="EB2A38568661887FA180BDDB5CABD5F21C7BFD59C090CB2D245A87AC253062882729293E5506350508E7F9AA3BB77F4333231490F915F6D63C55FE2F08A49B353F444AD3993CACC02DB784ABBB8E42A9B1BBFFFB38BE18D78E87A0E41B9B8F73A928EE0CCEE1F6739884B9777E4FE9E88A1BBE495927AC4A799B3181D6442443";
 var RSAKey = new sinaSSOEncoder.RSAKey();
 RSAKey.setPublic(key, '10001');
 return(RSAKey.encrypt([servertime,nonce].join("\t") + "\n" + password));
}

exports.GetRSA = GetRSA;

baiduIndex.js

function Dec(input, key)
{
 input = escape(input);
 var int_key = "";
 for(var I=0;I<key.length;I++)
 {
 int_key += key.charCodeAt(I).toString();
 }

 var app = input.substr(input.length - 13,input.length);
 var app1 = app;

 app = app ^ 99998999;

 var str = input.substr(0,input.length - 13);
 input = str;

 int_key = int_key + app1;
 var ret = "";

 for(var I=0;I<input.length;I+=2)
 {
 var sig = input.substr(I,2);
 sig = parseInt(sig,16);

 var i = (I/2) % int_key.length;
 var xor_key = int_key.substr(i,1);
 sig = sig ^ xor_key;

 ret += String.fromCharCode(sig);
 }
 return unescape(ret);
}

function execEval(input, key){
 return Dec(input,key);
}
exports.execEval = execEval;

大家认真看的话，除了index.js文件，会发现每个文件最后都会有个exports的调用，这个按照我自己的理解是，使用exports可以使得引用他的文件直接调用里面的方法。

到这里我的web服务就基本上搭建完毕了。

在index.js文件中的

handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
handle["/weibo"] = requestHandlers.weibo;
handle["/baiduindex"] = requestHandlers.baiduindex;

这里其实就是给出了，url的访问地址

比如我如果要访问的话，我会这样写

http://10.211.55.5:8006/start,

http://10.211.55.5:8006/upload,

http://10.211.55.5:8006/weibo,

http://10.211.55.5:8006/baiduindex。

后面也是可以加上参数的，然后对应的处理文件上，加上自己的处理函数，来接受不同的参数，进行自己的一些逻辑操作。

下面可以测试一下了。

在根目录下，执行

node ./index.js

然后再浏览器上输入url地址，就可以访问了

Nodejs的安装、测试及hello world

Mon, 09 Jun 2025 16:19:55 +0000

安装：

现在地址：http://www.nodejs.org/download/

可以根据自己的系统类型，选择对应的安装文件，进行安装

测试

写一个简单的hello world

var http = require('http');
http.createServer(function (request, response) {
 response.writeHead(200, {'Content-Type': 'text/plain'});
 response.end('Hello World\n');
}).listen(8124);
console.log('Server running at http://127.0.0.1:8124/');

使用浏览器，输入url地址http://127.0.0.1:8124/，可以看到输出Hello World字符串，如果没有说明出现问题了。

NodeJS on Dapeng Zhang

Nodejs终于看到一个靠谱的招聘了

Nodejs - 安全版本发布

Nodejs小知识之event（错误事件和仅处理事件一次）三

Nodejs小知识之event（了解事件的异步和同步）二

Nodejs小知识之event（事件）一

Node v12.18.3 (LTS) 版本发布

发布时间：by Shelley Vohr, 2020-07-22

Notable Changes

Node v10.22.0 (LTS) 版本发布

Notable changes

Node v14.6.0 版本发布

发布时间：by Myles Borins, 2020-07-21

Notable Changes

NodeJS命令行下调试运行代码初体验

TypeScript 3 + Koajs + Node.js

第一步、安装和配置

第二步、创建服务器

第三步、使用Nodemon和TS-Node运行服务器

第四步、构建应用程序 - 添加中间件

第五步、标准中间件

TypeScript 3 + Express + Node.js

第一步、安装需要的配置

第二步、创建项目

第三步、安装Express

第四步、启动脚本的配置

第五步、安装TypeScript 和 Grunt

第六步、创建gruntfile.js

第七步、安装中间件

第八步、创建Server类

导入

Server类

constructor函数

第九步、配置Server

第十步、创建BaseRoute类

第十一步、创建IndexRoute类

第十二步、定义routes

第十三步、创建Template

第十四步、启动服务

第十五步、安装nodemon

Nodejs新版本8.9.0和9.2.0更新啦

Nodejs 中解决 no-await-in-loop

Nodejs 通过 fs.createWriteStream 保存文件

NodeJs 版本8.5 体验experimental-modules

Nodejs 之 Koa2 添加travis ci 持续集成工具

Nodejs 应用性能分析

Nodejs 之 __dirname 的使用

Nodejs 数据加密传输

Nodejs - 通过身份证号验证年龄，出生日期和性别

Nodejs 之 分享加密算法

Nodejs 中pfx后缀文件的处理

Nodejs 接口之 解析淘宝客短链

在express中使用co

Nodejs开发部署环节整理

罗列一下提高效率的Nodejs模块

Nodejs iconv-lite 使用过程中需要注意的几个环节

Nodejs 破解 不规范json字符串的处理方法

Nodejs简易聊天室socket.io

Nodejs通过POP3获取邮件，便于数据存储

QQ邮箱这里有破解，Nodejs实现

Nodejs 实现简单数据抓取

Nodejs 实现 通过POP3协议进行邮件的收取【指定日期范围】

Nodejs 正则获取银行账单

Nodejs 实现 通过 POP3 协议获取邮件列表【yapople】

Nodejs 在Nginx服务器上部署

使用Nodejs 实现 Scraping

Nodejs+Mailparser+imap获取QQ邮件的内容

Nodejs Async的使用实例

Node超级简单实现聊天服务器

nodejs中express的“Error: Cannot find module 'jade'”错误

Nodejs安装及Express框架简介-简单的nodejs网站搭建

技术准备:

安装Nodejs

安装 npm

Nodejs的express框架

参考资料:

Nodejs上HTML分析利器node-jquery

Nodejs的加载html页面和远程获取页面进行匹配操作

Nodejs搭建web服务器

Nodejs的安装、测试及hello world

Nodejs 之分享加密算法

Nodejs 接口之解析淘宝客短链

Nodejs 破解不规范json字符串的处理方法

Nodejs 实现通过POP3协议进行邮件的收取【指定日期范围】

Nodejs 实现通过 POP3 协议获取邮件列表【yapople】