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. for (var key in obs) {}，这里的key一定是字符串，有时为了保证逻辑正确，可能要转成其它类型。
13. 对象字面量，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。
14. 对于array，var a = []; a[0]=1;和a["0"]=1;效果一样。
15. 如果想让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]就好。
16. for of的性能很差，for in也好一点，但也不太好，如数据量少，尽量使用array，for i来遍历。
17. object的查找性能比array好很多，不过遍历性却差很多很多，如果数据变化少、查找也少，但遍历多，考虑用array。
18. array的forEach、find的性能都不如for i快，就是更方便而已，indexOf的话，速度快不少，但只能直接匹配、不能某字段匹配，不过性能还是不如object[key]。
19. 对于类类型，o.constructor === Class比 o instanceof Class慢，对于基本类型o.constructor === Class比 typeof(o) === "string"慢。
20. 数字、字符串、布尔 instanceof Number/String/Boolean为false，那得用typeof(o) === "number"、typeof(o) === "string"、typeof(o) === "boolean"。
21. ES6的三点运算（...）效率比较低。
22. js有个比较恶心的地方：[] == false，但![] == false也是，"0" == false，但!"0" == false也是。
23. var o = {a:1,b:2}，如果o[a]，很快，如果o[c]，一个不存在的key，慢一点，如果o[undefined]或o[null]，很慢很慢很慢，千万不要这样用，可以考虑用o[key || ""]。
24. 一般===的性能高于==，有时甚至是远高于，也就是说，如果不是故意允许类型不一致地相等，尽量用===。v == null或v == undefined可以写成v === null || v === undefined，不过比较麻烦了。
25. 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];}。
26. 获取时间戳，使用Date.now()，new Date().getTime()会慢一倍。
27. 以下两个代码，哪个快？

    for(var i=0;i<o.arr.length;++i)
    {
        s+=o.arr[i].a+o.arr[i].b+o.arr[i].c;
    }

    for(var i=0,len=o.arr.length;i<len;++i)
    {
        var item = o.arr[i];
        s+=item.a+item.b+item.c;
    }

    本来我们可能觉得后者快，因为o.arr.length会有额外运算，o.arr[i]也会有额外运算，但实际上测试发现，前者比后者快，这个现象在使用v8 js引擎的node.js上是这样的，其它js引擎有可能后者快，可能v8 js引擎会对多余、重复的运算做优化。

28. 自定义的类如果想跟Number值做计算，跟String做自定义的连接，转成合理的JSON字符串，可以重载valueOf()、toString()、toJSON()方法。

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

代码：

 var vals = {"undefined":undefined,"null":null,"{}":{},"[]":[],"false":false,"0":0,"\"0\"":"0","\"\"":"","NaN":NaN,"Infinity":Infinity}
 var result = "";
 var alignLen = 50;
 function addPadding(str)
 {
     str += new Array(alignLen - str.length).join(" ");
     return str;
 }
 for (var i in vals)
 {
     result += addPadding("类型" + i);
     result += "\r\n";
     result += addPadding("!!" + i);
     result += !!vals[i];
     result += "\r\n";
     for (var j in vals)
     {
         result += addPadding(i + " == " + j);
         result += vals[i] == vals[j];
         result += "\r\n";
     }
     result += "\r\n";
 }
 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