NodeJS学习笔记(二)

时间:2021-11-06 23:13:02
    对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.jsshaneGirish/bcrypt-nodejsfpirsch/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
-----------------------------------------------------------
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学习笔记(二)NodeJS学习笔记(二)
   这种情况可能极端了一点,但是并不少见,可以看出这些操作是有先后顺序的,用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框架相对来说不是很难,我研究的也不深入,以后有机会再写新的笔记吧。