node.js使用经验记录

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了node.js使用经验记录相关的知识,希望对你有一定的参考价值。

MongoDB使用经验:

  1. 有时不知道MongoDB的错误码代表什么,那有这个链接:

    https://github.com/mongodb/mongo/blob/master/src/mongo/base/error_codes.err

  2. 关于MongoDB连接字符串,有两个经验:
    • 对于node.js驱动,如果要保证一个用户的数据写入到数据库是按调用的顺序来的,请在连接字符串里设置poolSize=1或maxPoolSize=1。
    • w=majority会导致性能很差,用w=1吧。

Node.js本身使用经验:

  1. os.hostname()很慢,不要实时用。
  2. send完网络数据后,不要马上去修改这个被发送的数据Buffer,不然可能会导致发送的是被修改后的。
  3. domain不能捕获Promise.coroutine的错误,只能自己在coroutine里try catch,或者使用.catch(function(err){});调用。
  4. bluebird的创建coroutine很慢很慢很慢,每次启用要消耗快0.1ms,所以除非调用很不频繁,比如程序启动、结束时才调用,否则得先创建,保存到变量,再调用。不过new Promise就比较快了,但这个用法是把非promise转为promise。
  5. require后面的路径名注意大小写一致,不然会得到不一样的模块。

Javascript使用经验(基于ES6标准):

  1. var v = a || 0;,当a为null、undefined时,可以获取默认值(0),但a等价false的情况很多,比如可能a==="",这时需要这个值,但还是得到0,这就不是我们要的。
  2. 对于js,var定义的变量是function内都可见,而es6标签有let,在{}内才可见。
  3. 对于js,由于可以有函数内的内部函数,内部函数的this引用的不是外层的this,如果要访问外部的this,可以var self = this,然后在内部函数里使用self来访问外层的this。
  4. 如果number转number,parseFloat奇慢,parseInt快多了,不过Math.floor、>>0、>>>0(转为无符号数)更快,但移位计算仅对int32范围的数有效,慎用。如果字符串转整数,都差不多了,都慢。
  5. parseInt(n, 10)带上进率,效率会更好。
  6. double能保存最大的整数是2^53,54位,如果要从二进制Buffer里读取int64,如果不考虑精度,可以如下做:
    var high = buffer.readInt32BE(readPos);
    var low = buffer.readUInt32BE(readPos + 4);
    high * 0x100000000 + low;
  7. 类名.prototype.函数名.call很慢,如果为了效率,别用它。比如常见的Array.prototype.slice.call、Object.prototype.toString.call。
  8. 如果没有必要,不要使用eval,new Function。
  9. 移位时,移位数>=32时,会减到32以内,比如 1 << 32其实就是 1 << 0。
  10. 对于array,如果没有必要,不要使用arr.splice(0, arr.length)来清空,而是用arr = [],这样效率更好,如果这个arr对象被别处引用了,那就可能不得不用splice。
  11. object的key一定是字符串,如果不是字符串会转为字符串,而ES6的Map的key可以是任意类型且采用===比较法(如果是对象,引用同一个对象才是相等)。
  12. 对象字面量,var o = {a:1,b:2,1:1,2:2,"a.b":3},这里的a、b、1、2虽然没引号,但也当字符串处理,如果key是一个表达式的值,那就可以:var o = {[1+2]:3}或o[1+2]=3。
  13. 对于array,var a = []; a[0]=1;和a["0"]=1;效果一样。
  14. 如果想让key允许任意值,那就得使用Map、Set。但Map、Set的性能不如object[key]。如果接受key只能为string,那就尽量使用object。而且Map、Set的for of遍历性能不如object的for in和array的for var i,所以尽量使用object、array。无论object、Map、Set,为了性能,尽量不要拼接key字符串,也就是o[a+b]这样,性能不好,直接o[k]就好。
  15. for of的性能很差,for in也好一点,但也不太好,如数据量少,尽量使用array,for i来遍历。
  16. object的查找性能比array好很多,不过遍历性却差很多很多,如果数据变化少、查找也少,但遍历多,考虑用array。
  17. array的forEach、find的性能都不如for i快,就是更方便而已,indexOf的话,速度快不少,但只能直接匹配、不能某字段匹配,不过性能还是不如object[key]。
  18. 对于类类型,o.constructor === Class比 o instanceof Class慢,对于基本类型o.constructor === Class比 typeof(o) === "string"慢。
  19. 数字、字符串、布尔 instanceof Number/String/Boolean为false,那得用typeof(o) === "number"、typeof(o) === "string"、typeof(o) === "boolean"。
  20. ES6的三点运算(...)效率比较低。
  21. js有个比较恶心的地方:[] == false,但![] == false也是,"0" == false,但!"0" == false也是。
  22. var o = {a:1,b:2},如果o[a],很快,如果o[c],一个不存在的key,慢一点,如果o[undefined]或o[null],很慢很慢很慢,千万不要这样用,可以考虑用o[key || ""]。
  23. 一般===的性能高于==,有时甚至是远高于,也就是说,如果不是故意允许类型不一致地相等,尽量用===。v == null或v == undefined可以写成v === null || v === undefined,不过比较麻烦了。
  24. Object.getOwnPropertyNames、Object.keys、for in都是获取对象的属性,不过相比Object.keys,for in 会遍历到原型链上的可枚举属性(不包括自身、原型链上的不可枚举属性),相比Object.keys,Object.getOwnPropertyNames会获取自身的不可枚举的属性(不包括原型链上的可枚举、不可枚举属性)。速度:Object.keys + for i > Object.getOwnPropertyNames + for i > for in。for i 就是指for (var i = 0, len = keys.length; i  < len; ++i){var k = keys[i];}。
  25. 获取时间戳,使用Date.now(),new Date().getTime()会慢一倍

JS里false值的不严格等于考察:

代码:

 1 var vals = {"undefined":undefined,"null":null,"{}":{},"[]":[],"false":false,"0":0,"\"0\"":"0","\"\"":"","NaN":NaN,"Infinity":Infinity}
 2 var result = "";
 3 var alignLen = 50;
 4 function addPadding(str)
 5 {
 6     str += new Array(alignLen - str.length).join(" ");
 7     return str;
 8 }
 9 for (var i in vals)
10 {
11     result += addPadding("类型" + i);
12     result += "\r\n";
13     result += addPadding("!!" + i);
14     result += !!vals[i];
15     result += "\r\n";
16     for (var j in vals)
17     {
18         result += addPadding(i + " == " + j);
19         result += vals[i] == vals[j];
20         result += "\r\n";
21     }
22     result += "\r\n";
23 }
24 console.log(result);

结果:

类型0                                              
!!0                                              false
0 == 0                                           true
0 == undefined                                   false
0 == null                                        false
0 == {}                                          false
0 == []                                          true
0 == false                                       true
0 == "0"                                         true
0 == ""                                          true
0 == NaN                                         false
0 == Infinity                                    false
 
类型undefined                                      
!!undefined                                      false
undefined == 0                                   false
undefined == undefined                           true
undefined == null                                true
undefined == {}                                  false
undefined == []                                  false
undefined == false                               false
undefined == "0"                                 false
undefined == ""                                  false
undefined == NaN                                 false
undefined == Infinity                            false
 
类型null                                           
!!null                                           false
null == 0                                        false
null == undefined                                true
null == null                                     true
null == {}                                       false
null == []                                       false
null == false                                    false
null == "0"                                      false
null == ""                                       false
null == NaN                                      false
null == Infinity                                 false
 
类型{}                                             
!!{}                                             true
{} == 0                                          false
{} == undefined                                  false
{} == null                                       false
{} == {}                                         true
{} == []                                         false
{} == false                                      false
{} == "0"                                        false
{} == ""                                         false
{} == NaN                                        false
{} == Infinity                                   false
 
类型[]                                             
!![]                                             true
[] == 0                                          true
[] == undefined                                  false
[] == null                                       false
[] == {}                                         false
[] == []                                         true
[] == false                                      true
[] == "0"                                        false
[] == ""                                         true
[] == NaN                                        false
[] == Infinity                                   false
 
类型false                                          
!!false                                          false
false == 0                                       true
false == undefined                               false
false == null                                    false
false == {}                                      false
false == []                                      true
false == false                                   true
false == "0"                                     true
false == ""                                      true
false == NaN                                     false
false == Infinity                                false
 
类型"0"                                            
!!"0"                                            true
"0" == 0                                         true
"0" == undefined                                 false
"0" == null                                      false
"0" == {}                                        false
"0" == []                                        false
"0" == false                                     true
"0" == "0"                                       true
"0" == ""                                        false
"0" == NaN                                       false
"0" == Infinity                                  false
 
类型""                                             
!!""                                             false
"" == 0                                          true
"" == undefined                                  false
"" == null                                       false
"" == {}                                         false
"" == []                                         true
"" == false                                      true
"" == "0"                                        false
"" == ""                                         true
"" == NaN                                        false
"" == Infinity                                   false
 
类型NaN                                            
!!NaN                                            false
NaN == 0                                         false
NaN == undefined                                 false
NaN == null                                      false
NaN == {}                                        false
NaN == []                                        false
NaN == false                                     false
NaN == "0"                                       false
NaN == ""                                        false
NaN == NaN                                       false
NaN == Infinity                                  false
 
类型Infinity                                       
!!Infinity                                       true
Infinity == 0                                    false
Infinity == undefined                            false
Infinity == null                                 false
Infinity == {}                                   false
Infinity == []                                   false
Infinity == false                                false
Infinity == "0"                                  false
Infinity == ""                                   false
Infinity == NaN                                  false
Infinity == Infinity                             true 

 

以上是关于node.js使用经验记录的主要内容,如果未能解决你的问题,请参考以下文章

使用electron构建跨平台Node.js桌面应用经验分享

node+express框架中连接使用mysql经验总结

node.js 经验总结

使用适用于 Node JS 的 mongodb 本机驱动程序记录所有查询

Python语言环境中MongoDB聚合经验一则——分组取最近一次记录集

实战ES6 + Node.js 4.x + Express4.x经验分享