zoukankan      html  css  js  c++  java
  • 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值的不严格等于考察:

    代码:

     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 += "
    ";
    13     result += addPadding("!!" + i);
    14     result += !!vals[i];
    15     result += "
    ";
    16     for (var j in vals)
    17     {
    18         result += addPadding(i + " == " + j);
    19         result += vals[i] == vals[j];
    20         result += "
    ";
    21     }
    22     result += "
    ";
    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 
  • 相关阅读:
    Mac MySql突然不好用了,说权限不够
    关闭Nginx的进程
    Mac 设置域名解析
    Docker的Yml文件
    Docker遇到的异常和注意点
    MySQL 查询时间段内的数据
    golang martini 源码阅读笔记之martini核心
    golang martini 源码阅读笔记之inject
    使用erlang实现简单的二进制通信协议
    使用 erlang OTP 模式编写非阻塞的 tcp 服务器(来自erlang wiki)
  • 原文地址:https://www.cnblogs.com/be-bright/p/share_nodejs_dev_exp.html
Copyright © 2011-2022 走看看