之前经常由于不注重，习习用写PHP或许Java的体式格局来写nodejs，发作了了一些缺点，这里总结一些小小的trick，以便于展现nodejs的差别，和日常平凡须要注重的处所。
变量提拔
var variable = 'global';
console.log(variable);
function fn () {
console.log(variable);
var variable = 'local';
console.log(variable);
}
fn();
你能够以为这段代码实行结果为：
global
global
local但实际上结果是
global
undefined
local缘由就是函数作用域致使部分变量在全部函数体内部可见，所以实行起来就成了：
function fn () {
var variable
console.log(variable);
variable = 'local';
console.log(variable);
}函数内部的console.log出于就近准绳读取的是内部variable，亦即部分variable覆蓋了全局variable，然后部分variable是全部函数体内可见，所以相当于提拔了变量声明，亦即变量声明放在了函数开首，然则变量初始化照样在本来的位置，所以就是上面展现的递次。
写Java的时刻我们倾向于在最最先运用一个部分变量之前声明它，如许帮我们清楚它的作用域以及生命周期；然则JavaScript没有块级作用域，所以部分变量最好写在函数最先，如许才更清楚的展现它的作用域（全部函数内部）和生命周期，防止发作误解。
有点须要注重的是:声明写var与不写var是有辨别的：
console.log(a);
a = 1;会报错，而下面这个：
console.log(a);
var a = 1;结果是 undefined ，也就是没有var的声明不会提拔。
函数提拔
js中建立函数有两种体式格局：函数声明式和函数字面量式。只需函数声明才存在函数提拔:
console.log(f1);
console.log(f2);
function f1() {}
var f2 = function() {}结果：
[Function: f1]
undefined就是函数提拔致使递次变成：
function f1() {}
console.log(f1);
console.log(f2);
var f2 = function() {}
原型继续中的坑
JavaScript 没有 供应对象继续的言语级别特征，而是经由过程原型复制来完成的。
var util = require('util')
function Superclass(){
this.a = 'a';
}
Superclass.prototype.d = 'd';
function Subclass(){
this.b = 'b';
}
util.inherits(Subclass, Superclass);
var superC = new Superclass();
var subC = new Subclass();
console.log(superC.a);
console.log(subC.a);
subC.a = 'suba';
console.log(superC.a);
console.log(subC.a);
subC.cc = 'cc';
console.log(superC.cc);
console.log(subC.cc);
console.log(superC.d);
console.log(subC.d);
结果：
a
undefined
a
suba
undefined
cc
d
d
Superclass { a: 'a' }subC仅仅继续了superC在prototype中定义的属性d，而组织函数内部制造的a属性没有被subC继续。同时，在原型中定义的属性不会被console.log作为对象的属性输出。在subC中修正属性a并不会修正superC的属性a，然则能猎取superC的属性d，而且设置了一个属性cc也不会影响superC。所以关于set操纵并不会修正原型链，只需get操纵才会体会到原型链（继续）的存在。
var util = require('util')
function Superclass(){
this.a = 'a';
}
Superclass.prototype.d = 'd';
function Subclass(){
this.b = 'b';
}
util.inherits(Subclass, Superclass);
var superC = new Superclass();
var subC = new Subclass();
for(x in subC){
console.log(x);
}
结果是
b
d
也就是说 in 关键字能检测到自有属性和继续熟性，这个能够用 !==来替代
for(x in subC){
if(subC[x] !== undefined)
console.log(x);
}结果一致， 然则in能够辨别属性不存在 和 属性存在且为undefined 两种状况，而!==不能辨别。
再看下面的：
for(x in subC){
if(subC.hasOwnProperty(x))
console.log(x);
}
结果是
b也就是说hasOwnProperty能检测到自身属性，不包括继续属性。总结一下：
superC.hasOwnProperty(); //自有属性为真
superC.propertyIsEnumerable(superC); //可罗列属性为真
Object.keys(superC); //一切可罗列自有属性
Object.getOwnPropertyNames(superC); //一切自有属性
for x in superC //自有及其其原型链上继续到的可罗列属性
依然是作用域
看看这段代码：
for(var i = 0; i < 5; i++){
setTimeout(function(){
console.log(i);
},100*i)
}你能够会以为结果是
0 1 2 3 4
然则结果是
5 5 5 5 5
缘由就是 settimeout的回调函数实行时，for轮回已实行终了。i变成了5，而回调函数近来的原型作用域上的i（此处也就是全局作用域）就是5，天然就是5了。要到达想要的结果准确的做法是：
for(var i = 0; i < 5; i++){
(function(i){setTimeout(function(){
console.log(i);
},100*i)})(i)
}
即用 (function(i){})(i);来发作一个马上作用域，保证settimeout回调函数实行的时刻近来的原型作用域的i就是当时轮回的i。
说到这个就得谈谈闭包：所谓“闭包”，指的是一个具有很多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。用大白话：闭包的作用就是在一个函数实行完并返回后，并不接纳该函数所占用的资本，由于该函数的内部函数（或属性）的实行须要依靠该函数中的属性。
function outF() {
var count = 0;
return function inF(){
count++;
console.log(count);
}
}
var inF= outF();
inF(); // 1
inF(); // 2
可见outF实行事后，其属性count并未接纳。回到上面谁人缺点的轮回，for建立了若干个闭包，每一个闭包同享上下文环境 i。由于for（很大能够）会先跑完，所以运转回调函数的时刻 i 已变成了5。而准确的轮回中，也经由过程匿名函数建立了闭包，这个匿名函数作为外部函数，经由过程马上挪用，使得settimeout不须要同享轮回中的i，而是独享每一次轮回差别的i。
作用域真的能够说是JavaScript的一个题目，var 声明是具有全部函数内部的可见性，而js1.7以后的let的涌现算是弥补了这个缺点（至于是不是是缺点就见仁见智了），let 声明的变量只属于就近的花括号内部，看下面的代码
for(let i = 0; i < 5; i++){
setTimeout(function(){
console.log(i);
},100*i)
}
结果就是
0 1 2 3 4
辨别就在于运用了 var 和 let 来生明变量i，let 使得每次顺序进入花括号就发作了一个块级作用域，也就是说settimeout的回调函数作用域链中近来的i不再是全局的i，而是块级作用域的i，也就是每一次差别的0,1,2,3,4而不是全局i末了是5。let发作了和上面马上作用域雷同的结果。
对象范例
异常新鲜，在Javascript中没有异常简朴的猎取一个对象的种别的要领，instanceof 是要搜检原型链的，类似于isPropertypeOf，所以没法一步到位取得最准确地的对象范例，平常用下面这个 classof能够取得最准确的范例
var a = new Date();
function classof(o){
if(o===null) return "Null";
if(o===undefined) return "Undefined";
return Object.prototype.toString.call(o).slice(8,-1);
}
console.log(classof(a));//Date
之所以不直接用Object.prototype.toString，是由于很多范例重写了这个要领，不能保证它输出是
[object class],所以运用Function.call要领。
万恶的分号 ;
nodejs中分号; 是可选的，这个有肯定水平的方便，但是在我看来它更多的是造成了杂沓，js会在必要的时刻协助我们增加分号，它有自身的增加划定规矩（我们天然都懒得去记）。
var a
a
=
3
console.log(a)这个会剖析成
var a; a = 3;console.log(a);没啥缺点。
但是
var equa = function(a,b){
if(a===b){
return
true;
}
return false;
}
console.log(equa(5,5));//undefined
就没有按预期实行，由于它剖析成了 return;true;返回的天然是undefined。
所以防止杂沓最简朴的做法就是老老实实的给每一句都加上 ;
数组相干
a = [];a[1000]=5; //a.length=1001，虽然a只需一个元素
a1 = [,,,]; // [undefined,undefined,undefined]
a2 = new Array(3); //数组基本没有元素
0 in a1;// true ，如上所说，in 能够辨别元素不存在和元素值存在且为undefined的状况
0 in a2;// false
高等数组要领
filter()：“过滤”功用，数组中的每一项运转给定函数，返回满足过滤前提构成的数组。
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
return index % 3 === 0 || x >= 8;
});
console.log(arr2); //[1, 4, 7, 8, 9, 10]
every()：推断数组中每一项都是不是满足前提，只需一切项都满足前提，才会返回true。
var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
});
console.log(arr2); //true
var arr3 = arr.every(function(x) {
return x < 3;
});
console.log(arr3); // false
some()：推断数组中是不是存在满足前提的项，只需有一项满足前提，就会返回true。
reduce() 和 reduceRight()，这两个要领都邑完成迭代数组的一切项，然后构建一个终究返回的值。reduce()要领从数组的第一项最先，逐一遍历到末了。而 reduceRight()则从数组的末了一项最先，向前遍历到第一项。
这两个要领都吸收两个参数：一个在每一项上挪用的函数和（可选的）作为合并基本的初始值。
传给 reduce()和 reduceRight()的函数吸收 4 个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都邑作为第一个参数自动传给下一项。第一次迭代发作在数组的第二项上，因而第一个参数是数组的第一项，第二个参数就是数组的第二项。
下面代码用reduce()完成数组求。
var values = [1,2,3,4,5];
var sum = values.reduceRight(function(prev, cur, index, array){
return prev + cur;
},0);
console.log(sum); //15
挪用函数之 this
挪用函数有4种体式格局，差别之处就在于挪用上下文，也就是关键字（不是变量，不是属性名）this的值
- 函数挪用 ，亦即直接挪用一个函数，在非严厉形式下this指向全局对象，严厉形式下指向undefined。须要注重的是嵌套函数的this并不指向外层函数的上下文，而是也遵循这个划定规矩。
- 要领挪用 ，亦即作为一个类的要领挪用一个函数，this指向这个类的对象
- 组织器挪用 ，亦即运用 new 关键字，this指向新建的对象自身
- call,apply挪用 ，this指向该函数绑定的对象
参考
JavaScript 威望指南 第六版；
JavaScript 言语精炼；
深入浅出 nodejs；
http://blog.csdn.net/u0146071…
https://developer.mozilla.org…
