对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
-----------------------------------------------------------
0
1
2
3
4
5
6
7
8
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
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，再次执行如下：
D:\work\nodejs\nodeStudy\study>node async3
test
最后
读取b.txt完成
写a.txt完成
Hello World
a.txt: 这是b.txt的内容
results=1,2,3
可以看到头两行仍然不变，之后依次执行函数1、2、3，到函数3时a.txt的内容已经改了。
这里面需要注意的是test仍然最先打印出来，这在函数1的末尾，但是并没有执行函数2，因为async是通过回调函数来判断函数是否执行完毕，所以如果修改回调函数的位置，就会出现特别奇怪和有趣的效果。增加几个回调函数，修改内容如下
var async = require(‘async‘);
var fs = require(‘fs‘);
async.series([
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);
});
});
c(null,11);
console.log(‘test‘);
},
function (c) {
setTimeout(function () {
console.log("Hello World");
c(null,2);
}, 1000);
c(null,21);
},
function (c) {
fs.readFile(‘a.txt‘, function (err, buf) {
console.log(‘a.txt: ‘+buf.toLocaleString());
c(null,3);
});
c(null,31);
}
],function(err, results) {
console.log("results="+results);
});
console.log(‘最后‘);
D:\work\nodejs\nodeStudy\study>node async3
results=11,21,31
test
最后
a.txt: 这是b.txt的内容
results=11,21,3
读取b.txt完成
写a.txt完成
results=1,21,3
Hello World
results=1,2,3
可以看出，最后的回调函数执行了4次，第一次，三个函数还没来得及输出，第二次，执行了第一次执行的回调函数最近的输出，第三次，第四次依次类推，这些可以通过返回值看出来。
上面的结果虽然有趣，但是实际用起来就不舒服了，总体来说，不要使用多个async的回调函数，如果是条件跳转，可以采用多个回调函数，将返回值设为不同值，这样既保证了每个函数只执行一次async的回调函数，也能通过返回值result知道到底执行了哪个跳转。
sails框架相对来说不是很难，我研究的也不深入，以后有机会再写新的笔记吧。