《Nodejs开发指南》

<p>Node.js是一个让javascript可以运行在服务器端的平台，是一个为数据密集型（data-intensive），实时Web（Real-time Web）应用开发而诞生的平台，它让java-script成为脚本语言世界的一等公民。传统意义上，javascript由DOM，BOM（浏览器对象模型），ECMAscript组成，而Mozilla则指出javascript由Core javascript和Client javascript组成。可以认为，Node.js中所谓的javascript只是Core javascript。</p>

<p>Node.js最大的特点就是采用异步式I/O和事件驱动的架构。与异步式相对的同步式I/O（即阻塞I/O），同步式I/O在面对I/O操作（磁盘读写，网络通信等的总称）时，一个线程只能处理一项任务，因为同步式I/O采用被称为阻塞的线程调度方式（即面对I/O操作时，操作系统会剥夺该线程对cpu的控制权，在被剥夺控制权的这段时间内，该线程是被“阻塞”的），因而产生了多线程，但同时多线程又带来了频繁的上下文切换。而Node.js采用的是非阻塞I/O（即异步式I/O），不存在同步式I/O存在的问题，也就不需要多线程，但为了处理异步I/O，线程就必须有事件循环。</p>

<p>Node.js中的大多数API都是异步的，虽然有些也提供了同步版本，对我们开发者而言，我们可以这样理解Node.js中的异步API，在执行时，这些API只是将I/O请求（以回调函数的形式）发给操作系统后，继续执行后面的代码，等待代码都执行完后， 再进入事件煦循环监听事件。例：</p>

<pre>var fs = require('fs');

fs.readFile('file.txt', function(er, data){
if(er) {
console.log(er + '3333333333');
} else {
console.log(data);
}
})

console.log(1);

fs.readFile('file.txt', function(er, data){
if(er) {
console.log(er + '4444444444');
} else {
console.log(data);
}
})

console.log(2);</pre>
<p>运行结果如下：</p>
<pre>
1
2
Error: ENOENT, open 'file.txt'3333333333
Error: ENOENT, open 'file.txt'4444444444

</pre>
<h2>javascript高级特性</h2>
<h3>作用域（scope）</h3>
<p>不像c，c++，javascript的作用域不是以花括号包围的块级作用域（block scope），它的作用域是通过函数来定义的。javascript的函数定义是可以嵌套的，每一层是一个作用域，变量搜索顺序是从内到外的。例：</p>
<pre>
var scope = 'global';

function f1() {
console.log(scope);
}

f1();//输出global
</pre>
<pre>
var scope = 'global';

function f1() {
console.log(scope);
var scope = 'f';
}

f1();//输出undefined
</pre>
<p>从上边的例子中我们可以看出，在第二个例子里，在<code>console.log</code>处，程序发现scope变量在函数里有定义，便不在搜索函数外的作用域，但是在<code>console.log</code>处，scope变量并没有初始化，因而结果是<code>undefined</code>。</p>
<p>javascript的作用域是静态作用域（词法作用域），函数作用域的嵌套关系是定义时决定的，即作用域的嵌套关系可以在语法分析时确定，而不必等到运行时决定。例：</p>
<pre>
var scope = 'top';

function f1() {
console.log(scope);
}

f1(); //输出 top;

function f2() {
var scope = 'f2';
f1();
}

f2(); //输出 top;
</pre>
<h3>闭包（closure）</h3>
<p>闭包的严格定义“由函数（环境）及封闭的自由变量组成的集合体。”</p>
<p>所谓闭包的特性，是一个函数返回它内部定义的一个函数时，就产生了一个闭包，闭包不但包括被返回的函数，还包括这个函数定义的环境。例（counter和generatecounter（）的局部变量就是一个闭包）：</p>
<pre>
var generatecounter = function() {
var counter = 0;
var get = function() {
counter ++;
}
return get;
}

var counter1 = generatecounter();
var counter2 = generatecounter();
console.log(counter1());//1
console.log(counter2());//1
console.log(counter1());//2
console.log(counter2());//2
console.log(counter2());//3
</pre>
<p>Node.js中闭包的应用：嵌套的回调函数。</p>
<h3>对象</h3>
<p>javascript中的对象实际上是是一个由属性组成的关联数组，属性由名称和值组成，值的类型可以是任何数据类型，或者函数和其他对象。javascript真的没有类，只有对象，对象就是对象，不是类的实例，javascript的对象是基于原型的。</p>
<h4>创建和访问</h4>
<pre>
//对象的创建
//方法一
var foo = {};
foo.prop_1 = 'bar';
foo.prop_2 = false;
foo.prop_3 = function() {
return 'Hello world!';
}
console.log(foo.prop_3());
//方法2
var foo = {};
foo['prop_1'] = 'bar';
foo['prop_2'] = false;
foo['prop_3'] = function() {
return 'Hello world!';
}
//方法3(用对象的初始化器)
var foo = {
'prop_1' : 'bar',
prop_2 : false, //对象中属性名称是否加引号是可选的，除非名称中有空格或者其他可能造成歧义的字符
//否则没必要加引号。
prop_3 : function() {
return 'Hello world!';
}
};
//方法4（构造函数：与前三中方法相比不是一次性的）
function User(name, uri) {
this.xingming = name;
this.email = uri;
this.display = function () {
console.log('Hello world!');
}
}
var user = new User('wa', 'y@13.com');
console.log(user.xingming);
</pre>
<h4>上下文对象</h4>
<p>在javascript中，上下文对象就是this指针，即被调用函数所处的环境。上下文对象的作用是在一个函数内部引用调用它的对象本身，javascript的任何函数都是被某个对像调用的，包括全局对象，所以this指针是一个非常重要的东西。在使用不同的引用调用同一个函数，this指针永远是这个引用所属的对象。本质上，函数类型的变量是指向这个函数实体的一个引用，在引用之间赋值不会对对象产生复制行为。我们可以通过函数的任何一个引用调用这个函数，不同之处仅仅在于上下文。</p>
<p>apply和call方法：功能是以不同的对象作为上下文来调用某个函数。例：</p>
<pre>
function a(b,c) {
console.log(this.a == 'c');
console.log(this.b == 'b');
console.log(b == 'first');
console.log(c == 'second');
}

a.call({a : 'c'}, 'first', 'second');//true false true true 以参数表来接受被调函数的参数
a.apply({b : 'b'}, ['first', 'second'])//false true true true 以数组来接受被调函数的参数
</pre>
<h3>原型</h3>