NodeJS学习笔记（二）

浏览数：73 / 时间：2015年06月09日

对NodeJS的基本配置了解之后，现在需要解决一些显示问题，大致有以下问题

1、与PHP框架Laravel的密码验证系统相适应

2、异步调用的常见编程问题：Promise和EventEmitter

3、Sails框架简述

下面是详细的内容：

1、与Laravel系统的加密系统相适应

Laravel是比较流行的PHP系统，其密码加密有以下特点：（参考文章：http://www.tuicool.com/articles/zQnqyi）

1）密码每次加密结果都是不同的

2）加密结果长度为60位

3）加密结果是元数据

根据文档介绍，加密采取了bcrypt函数和Blowfish算法，这是一种加盐算法，用Laravel实际运行一下代码，

Route::get(‘/‘, function(){

$str = "";

for($i=0;$i<10;$i++){

$str .= Hash::make(‘stone-fly‘)."<br>";

}

return $str;

});

结果类似如下：

$2y$10$2XweYEnSPjBBNy/EsLEVouXfE3Stq.NKIl.kNM6TB.kRokpu7hRCy

$2y$10$yK45wyX0PxWIfxhZCkxkhecTBvR/2delG9vK0XT2CE3GAWxVHZgzS

$2y$10$sSqbrX71sdUdUPcrpepcUeg5QxJ1Ow7iq7YiGrXYS7QYIRuyOoZni

$2y$10$6asY8EhViIAHk1cg6onvUO5Gc8/NDV.qyH6tObyQ5WqK5jYz89LTq

$2y$10$kpcEnWOcMvVDbGw6PqN07eL5gZholdxqatnENuD.TczAMDF1FWjpG

$2y$10$JW7fPgmebGlO1wivDmus6OeCxUGb2wefFxlGjhK5UGX0exMtIcLgO

$2y$10$yzgApGe227Yhkf6H87P7yu48KDVd0tVf0Tkv9J6KP5cEjhfU8HxGi

$2y$10$6I4yhAUpU0bBpiP6323S2e4aTtq1psI39A91fh2SDgMvJCRkEUzwC

$2y$10$EUxfsWCgbqfbQcvO0lGk8O605o2ACXe34/BqcGfeeCBNi5t4XTZdi

$2y$10$I.dA/8bdSmXWeo6BtfJB/u2pqOUVqDOv6U1ByOSypohK7B7ZpUJP.

可以看出加密了10次，各不相同，加密结果是一种元数据，原因如下：

1）头四位是加盐前缀，一般为“$2y$”、"$2a$"、"$2x$"，较老的是"$2a$"，最新的是"$2y$"，Laravel生成的是"$2y$"，或者说php5.3.7之前是"$2a$"，之后是"$2y$"，前者有些bug，但也可以使用，根据https://github.com/fpirsch/twin-bcrypt的说法，2a是可能正确也可能错误，2x有bug，2y肯定正确。

2）5-6位是cost值

3）7位是$，之后是22位随机生成的盐值，范围为“./0-9A-Za-z”.”

4）之后为密码

这里需要注意的是，既然每次都不同，就必须使用提供提供的api来判断密码是否正确，而不是将用户提交的密码加密然后和数据库保存的比较，这是错误的，Laravel提供了Auth::attempt()方法来做密码验证。

根据上面的描述，需要去nodejs中寻找相应的模块，在github.com上搜索"node bcrypt"，按照星级排序，我尝试了前3种加密模块，分别为ncb000gt/node.bcrypt.js、shaneGirish/bcrypt-nodejs、fpirsch/twin-bcrypt，它们的使用方法都差不多，大致的区别如下

ncb000gt/node.bcrypt.js是用c++实现的，后两者都是用js实现的
除fpirsch/twin-bcrypt外，加密前缀都是"$2a$",fpirsch/twin-bcrypt支持3种前缀的比较，生成的密码前缀为"$2y$"，当然这个并不难解决，只要替换前四个字母为"$2a$"，其他两个模块就可以正常比较了

它们都提供了异步和同步操作，下面以 ncb000gt/node.bcrypt.js 为例说明一下用法：

在package.json的dependencie中加入"bcrypt":"*"，然后运行npm install，或者直接运行npm install bcrypt，需要系统安装微软的编译环境，我的电脑上是visual studio 2013。

使用bcrypt也非常简单，简单示例如下

var bcrypt = require(‘bcrypt‘);

var salt = "";

var hash = "";

for (var i = 0; i < 10; i++) {

salt = bcrypt.genSaltSync(10);

hash = bcrypt.hashSync(‘stone-fly‘, salt);

console.log(hash+‘--‘+i);

}

console.log("-----------------------------------------------------------");

for (var i = 0; i < 10; i++) {

console.log(i);

bcrypt.genSalt(10, function (err,salt) {

bcrypt.hash(‘stone-fly‘, salt, function(err, hash){

console.log(hash+‘--‘+i);

});

}

运行结果如下

$2a$10$FwQQeqgAsB3mY53JG01xnOhQXW4jkfC/UYYVr2n0Evoc7kwxe8HXS--0

$2a$10$FYNn/8MEHfc3pRo99D2hfu0BJYHMySuRinGeGeoRjZi07w/jUW6YG--1

$2a$10$bb0f9z2LveAJnOAF.T5sRuqK7olcB6KlvcjwLQJY6MOmTv6Ys11t.--2

$2a$10$kSoUp7D3l0n4PTmTfFk/nOVVnA3jKoqjyP3mZ/hMpZ0k7dbZ4vphS--3

$2a$10$uQdp3O6toqnbmK1FNN9JH.8ck4TS13glkSr60Y6KllVnesA3Ll7i.--4

$2a$10$jjBYt8sIHo.BMOzvgoidaeyVFm4MKtnD86X3Vtn0ZkzYts0I3biVK--5

$2a$10$/Iuc1K00T6DuWvOm5oSSZuwSTgAiyyU9wMBAP.ccr9/V2yREaCQwy--6

$2a$10$JvjAdWLSc1.eLLs.E4ROsO4ztPY37FNPk8qbjv3ItntiEys0TjSzm--7

$2a$10$txYGWGYItNo4jjWkl6JPVeTO1l8tHSC3biYHsDPhCQOnVJG75DKFW--8

$2a$10$ZqvA4Jrib3z8ipP2ORELi.9Q1HvJN0x8ihMYr0uFk1DDEImoSAUge--9

-----------------------------------------------------------

$2a$10$iqLtJTN4lWwXqs7BynPDFeoeToNlAKX14aolSW85U00KOKb9zdRHy--10

$2a$10$7xRvfdsdDwT/P0EUB48lM.hCWK8UWmxbfvXE2dkZHb8093jhm3Oey--10

$2a$10$btnfDhIR00pVJyu/yEvjYO3qlB56MTNXwgfwCPeU4mkxitURqxWLW--10

$2a$10$pyLoJKmb6.FUVrd7eu9PfuvhYVnA1zheZmHJGZHJ9a5akOEL2Q46a--10

$2a$10$M/M/.CVPt2SNvtch9Yh1quhDbguuvrfPc7Je0U62O/9eM52dqDtdm--10

$2a$10$sjmoBqzAOXb2mWS9YDpwKuZqDLlN64zn5VY13xbrBoMvZV5A6MqeS--10

$2a$10$xu4sBhDh0H87PzFcZXbCGezn8qn3mnn3dIiPY4MZKcez7BzmTPvQy--10

$2a$10$TqzCq3qAVXxj5sBD4UKAKO4IK0oB4QXQpzZeC80eGIB6q3llDgx3K--10

$2a$10$tueNpGrtiH6p0NfRUfEPyOyrqHSCuxnUlfMGtsGWx5LZ/UsZX7Gp.--10

$2a$10$./m5HGNLPLjbV8fCbWaMl.3TNLK848r8eUiT2bYbzdWNvUHEeGDg6--10

研究一下上面的结果，可以看出：

使用异步加密时，所有的i都是10，说明加密确实是异步进行。
同步加密没什么特别的
加密前缀确实是"$2a$"，加盐cost是10

需要注意的是，当产生密码的时候，对应的循环值i早已经变化了，可以看出，nodejs对于批处理不适合，比如要批量插入用户信息，还要对密码进行加密，就比较麻烦，因为很难在回掉函数中调用正确的变量，因为回调函数的格式是固定的，不包含你需要的标识信息，所以异步操作不要太多，逻辑不要太复杂，否则会出现难以理解的错误。

密码比对程序如下

var bcrypt = require(‘bcrypt‘);

//laravel生成的stone-fly的加密结果

var laravel_hash = "$2y$10$2XweYEnSPjBBNy/EsLEVouXfE3Stq.NKIl.kNM6TB.kRokpu7hRCy";

//node生成的stone-fly的加密结果

var node_hash = "$2a$10$FwQQeqgAsB3mY53JG01xnOhQXW4jkfC/UYYVr2n0Evoc7kwxe8HXS";

//laravel生成的stone-fly的加密结果，将$2y$改为$2a$

var laravel_ca_hash = "$2a$10$2XweYEnSPjBBNy/EsLEVouXfE3Stq.NKIl.kNM6TB.kRokpu7hRCy";

bcrypt.compare(‘stone-fly‘,laravel_hash,function(err,result){

console.log(result);

});

bcrypt.compare(‘stone-fly‘,node_hash,function(err,result){

console.log(result);

});

bcrypt.compare(‘stone-fly‘,laravel_ca_hash,function(err,result){

console.log(result);

});

结果为

false

true

可以知道，密码校验只需要将laravel的加盐前缀修改为"$2a$"就可以进行正常比对了，需要注意在laravel比对时，将前缀修改为"$2y$"，node校验修改为"$2a$"就可以了。

为谨慎起见，将数据库中的加密密码更新为nodejs加密的密文，然后输入用户名，密码为stone-fly，可以正常登陆，说明laravel或者说php是向下兼容的，前缀不造成影响。只需要注意nodejs的比对就可以了。

2、异步调用问题

对于nodejs来说，其优势是通过回调函数进行异步编程，可以提高前端的处理io的能力，并可以迅速释放CPU，这样可以提交性能，但是这会产生一个比较麻烦的问题，就是函数嵌套问题，即在函数执行需要前后顺序的时候，因为必须等待前面的函数执行之后才能执行后面的函数，所以不可避免的需要在回调函数中编写逻辑，如果事件过多，就会出现很难看的代码，并且也不容易编写。

设想一种场景，用户注册，大致的执行流程如下：

这种情况可能极端了一点，但是并不少见，可以看出这些操作是有先后顺序的，用nodejs实现，就会出现大量的函数嵌套，在每个函数的回调函数中调用下一个函数，看起来让人很不舒服，而且如果逻辑复杂，必须把实现封装为函数，否则就会过于复杂，很难看懂和修改。

解决这个问题方法有3种（这里主要参考朴灵的《深入浅出NodeJS》），一种是EventEmitter，一种是Promise，还有一种就是一些流程控制库，我觉得async好像更好一些，下面简单的做个说明：

1）EventEmitter：它使用nodejs的事件机制，可以处理任何异步问题，但是也有它的缺点，它本质来说相当于goto，如果代码过于复杂，也会出现很难看懂的现象

以加密为例

var bcrypt = require(‘bcrypt‘);

var EventEmitter = require(‘events‘).EventEmitter;

var emitter = new EventEmitter();

var salt = "";

var hash = "";

bcrypt.genSalt(10, function (err, salt) {

bcrypt.hash(‘stone-fly‘, salt, function (err, hash) {

emitter.emit(‘hash‘, hash);

});

});

console.log("hash=" + hash);

emitter.on(‘hash‘, function (hash) {

console.log("hash=" + hash);

});

输出为

hash=

hash=$2a$10$l9OHdYdjcaeynhnDdSL/j.2Ig1Egawc3tfx0DFJ9ouQOXZtE4b9Dq

从这里可以看出，在异步操作可以通过事件来触发，只不过上面这个例子非常简单，用函数嵌套看起来更好，也不复杂，这里只不过做个例子。如果是多个事件按顺序执行，就非常麻烦，相当于一堆的goto语句，逻辑不清晰，容易出错误。

2）Promise/Deferred

Promise/Deferred是一种规范，最简单的是Promises/A ，其实现也简单，其函数有三种结果：执行中、成功、失败，还有极端的实现，只有两种状态：成功和失败，其实现方式有多种，一种是使用EventEmitter封装，可以参考一下这篇文章：http://www.aspku.com/kaifa/javascript/44687.html，一种是用队列来处理，如Q模块，但对外展现的API是一样的，如下

var promise = doSomethingAync()

promise.then(onFulfilled, onRejected, onProgress).then(onFulfilled1, onRejected1,onProgress1)...

这里可以看出，要使用Promise需要将函数进行Promise模式的封装，保证其返回值是promise，想要链式处理，就需要封装更多的函数，这里就要使用队列了。不过对某些模块封装并不难，而且也可以到github.com上面搜索，基本可以满足需要。

Q模块还提供了一些专门的封装方法，可以参考现成的模块，最简单的方法如下：（来源于q-io/fs）

exports.remove = function (path) {

path = String(path);

var done = Q.defer();

FS.unlink(path, function (error) {

if (error) {

error.message = "Can‘t remove " + JSON.stringify(path) + ": " + error.message;

done.reject(error);

} else {

done.resolve();

}

});

return done.promise;

};

只要在回调函数中根据状态，调用Q.defer().reject(error)或者Q.defer().resolve()就可以了。这两个函数本质来说，就是修改内部的队列状态，promise根据状态决定调用哪个函数，再看一下promise.then()方法的源码：（来源于Q）

Promise.prototype.then = function (fulfilled, rejected, progressed) {

var self = this;

var deferred = defer();

var done = false; // ensure the untrusted promise makes at most a

// single call to one of the callbacks

function _fulfilled(value) {

try {

return typeof fulfilled === "function" ? fulfilled(value) : value;

} catch (exception) {

return reject(exception);

}

function _rejected(exception) {

if (typeof rejected === "function") {

makeStackTraceLong(exception, self);

try {

return rejected(exception);

} catch (newException) {

return reject(newException);

}

return reject(exception);

}

function _progressed(value) {

return typeof progressed === "function" ? progressed(value) : value;

}

//去掉了一部分

//....

return deferred.promise;

};

因此，可以知道，用promise方式封装api并不难，基本是模式化的。只不过大部分情况下，可以在github.com上找到合适的。

3）流程控制库

常见的流程控制库async，step，相对来说，async更流行一些，在github.com上星级很高，它提供了20多个函数，不过我们要解决异步流程控制的问题，常见的有以下几种：

//串行执行

async.series([function(c){},function(c){},function(c){}],function(err,result){});

//异步执行

async.parallel([function(c){},function(c){},function(c){}],function(err,result){});

//串行且参数执行，前一个函数的输出结果，是后一个函数的第一个参数

async.waterfall([function(c){},function(arg1,c){},function(arg2,c){}],function(err,result){});

//自动判断依赖执行

async.auto([function(c){},function(c){},function(c){}],function(err,result){});

这里需要注意一点，回调函数c是必须的，而且必须位于每个子函数的回调函数的最后，因为async用回调函数c来判断函数是否结束了，如果位置不合适，就不会有串行的效果，如果没有回调函数，则只会执行第一个函数，因为async会认为出现了错误。我写了一个简单的例子，如下：

var async = require(‘async‘);

var fs = require(‘fs‘);

async.parallel([

function (c) {

fs.readFile(‘b.txt‘, function (err, data) {

fs.writeFile(‘a.txt‘, data, function (err) {

console.log("读取b.txt完成");

console.log("写a.txt完成");

c(null,1);

});

console.log(‘test‘);

function (c) {

setTimeout(function () {

console.log("Hello World");

c(null,2);

}, 1000);

function (c) {

fs.readFile(‘a.txt‘, function (err, buf) {

console.log(‘a.txt: ‘+buf.toLocaleString());

c(null,3);

});

}

],function(err, results) {

console.log("results="+results);

});

console.log(‘最后‘);

这里用async.parallel包装了3个函数，第一个函数读取b.txt的内容，写入a.txt，第二个函数等待1秒打印"Hello World"，第三个读取a.txt的内容并打印。

a.txt内容为

这是a.txt的内容

b.txt的内容为

这是b.txt的内容

D:\work\nodejs\nodeStudy\study>node async3

test

最后

a.txt: 这是a.txt的内容

读取b.txt完成

写a.txt完成

Hello World

results=1,2,3

可以看出第一个函数的test最先打印出啦，之后是最后一行的"最后"打印出来，然后第三个函数执行，打印出a.txt的内容，然后读取b.txt的内容，写入到a.txt中，最后执行函数二，停顿一秒钟打印出"Hello World"，最后是回调函数，回调函数在async中所有的函数都调用了之后，才会执行，当然如果遇到了错误，会停止执行函数循环，直接执行回调函数。回调函数的result是之前回调函数的第二个参数的组成的一个数组。

现在手工修改一下a.txt为原来的内容，当然不修改一个可以，修改上面的aysnc为串行，即修改parallel为series，再次执行如下：