《Node.js开发指南》读书笔记

继续学学node.js。翻开书首先被惊到=。=：作者BYVoid是清华大学2010级本科……同样是2010级本科，我真是无语凝噎，大学浪费了好多时间。不过过去的已经过去了，接下来好好努力提高才好，加油。

在这之前，我已经看了一些其他的资料，对Node.js有了一些基本的了解。写了一篇博客 ，之后看了一本只有42页的入门书《Node入门》，这本书虽然很短，但是却是一本很不错的书。

接下来开始看这本《Node.js开发指南》，准备之后再看看《深入浅出Node.js》逐步来学习node。

下面开始笔记：

第一章 Node.js简介

npm：node package manager

异步I/O

事件驱动

Node.js进程在同一时刻智慧处理一个事件，完成后立即进入事件循环检查并处理后面的事件。

第二章 安装和配置Node.js

Microsoft Windows系统上安装Node.js：官网下载安装即可。这样安装的node.js还自带npm，可以直接使用。

第三章 Node.js快速入门

1.运行node.js程序的基本方法就是执行

node script.js

其中script.js是脚本的文件名。

2.还可以使用

node -e"要执行的js代码"

来执行js。

3.运行无参数的node将会启动一个JavaScript的交互式shell

4.使用node.js的http模块可以轻松创建服务器

小技巧——使用supervisor

开发时会发现，修改node.js文件后，必须重启node.js服务器才生效。这是因为node.js只有在第一次引用某部分时才会去解析脚本文件，以后都会直接访问内存，避免重复载入。node.js这种设计有利于提高性能，却不利于开发调试。

supervisor可以帮助时实现这个功能，它会见识你对代码的改动并自动重启node.js。使用方法很简单：首先

npm install -g supervisor

安装；接下来使用supervisor命令启动文件，例如：

supervisor index.js

。

这样就可以用supervisor这个小工具解决开发中的调试问题。

异步式I/O（非阻塞I/O）与事件式编程

为了处理异步 I/O，线程必须有事件循环，不断地检查有没有未处理的事件，依次予

以处理。

回调函数

//readfile.js

var fs = require('fs');
fs.readFile('file.text','UTF-8',function(err,data){
if(err){
console.error(err);
}else{
console.log(data);
}
});
console.log('end');

运行结果如下：

end

Content of the file.text.

由于是异步所以先输出end，当读取到文件之后触发匿名回调函数，再输出data

如果不用匿名函数，也可以将其定义在外边，例如：

//readfilecallback.js
functon readFileCallBack(err,data){
if(err){
console.error(err);
}else{
console.log(data);
}
}

var fs = require('fs');
fs.readFile('file.txt','utf-8',readFileCallBack);
console.log('end');

Node.js也提供了同步文件的API：

//readFilesync.js

var fs = require('fs');
var data = fa.readFileSync('file.text','utf-8');
console.log(data);
console.log('end');

运行结果：

Content of the file.

end

这次是同步方式读取文件，所以按顺序输出了data和end

事件

Node.js所有的异步I/O操作在完成时候、都会发送一个事件到事件队列。在开发者看来，事件由EventEmitter对象提供。下例来说明该对象的用法：

//event.js

var EventEmitter = require('events').EventEmitter;
var event = new EventEmitter();

event.on('some_event',function(){
console.log('some_event occured.');
});

setTimeout(function(){
event.emit('some_event');
},1000);

运行上例，1秒后输出some_event occured。原理是event对象注册了事件some_event 的第一个监听器，然后我们在1000毫秒后向event对象发送事件some_event，此时会调用some_event的监听器。

Node.js程序在执行时会不断检查是否有活动的、可供检测了事件监听器，值到检测不到时才退出事件循环，进程结束。Node.js的时间循环对开发者不可见。

模块和包

模块（Module）和包（Package）是Node.js最重要的支柱。我们经常把 Node.js 的模块和包相提并论，因为模块和包是没有本质区别的，两个概念也时常混用。如果要辨析，那么可以把包理解成是实现了某个功能模块的集合，用于发布和维护。对使用者来说，模块和包的区别是透明的，因此经常不作区分。

模块是 Node.js 应用程序的基本组成部分，文件和模块是一一对应的。换言之，一个Node.js 文件就是一个模块，这个文件可能是 JavaScript 代码、JSON 或者编译过的C/C++ 扩展。

Node.js 提供了 exports 和 require 两个对象，其中 exports 是模块公开的接口，require 用于从外部获取一个模块的接口，即所获取模块的 exports 对象。

例子：

module.js文件：

//module.js

var name;
//设置导出对象的方法
exports.setName = function(thyName){
name = thyName;
};

exports.sayHello = function(){
console.log('Hello' + name);
}

/*
当你想要直接导出sayHello对象的时候，也可以这样：
module.exports = Hello;
这样的话，使用var a = require('./module');得到的就是Hello对象了。
否则要使用：var a = require('./module').sayHello;

*/

getmodule.js文件:

//getmodule.js

var myModule = require('./module');

//设置名字为Creabine
myModule.setName('Creabine');
//设置名字为Creabine_1
myModule.setName('Creabine_1');

myModule.sayHello();

运行node getmodule.je，结果是：

Hello Creabine_1

这里要注意，输出的是Creabine_1。因为require不会重复加载模块，只会加载一次，所以设置两次名字的时候，Creabine_1会覆盖掉之前的Creabine。最终输出的是最后设置的名字

事实上，exports本身仅仅是一个普通的空对象，即{ }，它专门用来声明接口，本质上是通过它为模块闭包的内部建立了一个有限的访问接口。因为它没有任何特殊的地方，所以可以用其他东西来代替。可以使用:module.exports来覆盖exports。

不可以通过对 exports 直接赋值代替对 module.exports 赋值。exports 实际上只是一个和 module.exports 指向同一个对象的变量，它本身会在模块执行结束后释放，但 module 不会，因此只能通过指定module.exports 来改变访问接口。

Node.js 的包是一个目录，其中包含一个 JSON 格式的包说明文件 package.json。

Node.js 在调用某个包时，会首先检查包中 package.json 文件的 main 字段，将其作为包的接口模块，如果 package.json 或 main 字段不存在，会尝试寻找 index.js 或 index.node作为包的接口。

package.json文件包含的内容：

name：包的名称

description：包的简要描述

version：版本号

keywords：关键字数组

maintainers：维护者数组

contributors：贡献者数组

bugs：提交bug地址

licenses：许可证数组

repositories：仓库托管地址数组

dependencies：包的依赖。

main：包的接口模块，如果没有则默认是index.js或index.node

npm

使用npm安装包的命令： npm [install/i] [package_name]

安装一个模块的时候还会自动解析其依赖的模块并安装。

在使用 npm 安装包的时候，有两种模式：本地模式和全局模式。默认情况下我们使用 npm

install命令就是采用本地模式，即把包安装到当前目录的 node_modules 子目录下Node.js的 require 在加载模块时会尝试搜寻 node_modules 子目录，因此使用 npm 本地模式安装

的包可以直接被引用。

npm 还有另一种不同的安装模式被成为全局模式，使用方法为：npm [install/i] -g [package_name]



使用 npm init 命令初始化一个包，生成一个符合规范的package.json。

可以使用npm adduser添加用户，输入账号密码邮箱，即可创建账号。完成后可以使用npm whoami检测是否已经取得了账号。接下来在package.json所在目录下运行npm publish，就可以发布自己制作的包了。可以在http://search.npmjs.org/ 找到自己发布的包，并且在其他计算机上使用npm install [package_name] 来安装他。如果要更新包，只要修改package.json文件中的version字段，然后再npm publish即可。还可以使用npm unpublish来取消发布。

调试

命令行调试

远程调试

在命令行下使用：

//使用这两个语句之一，可以打开调试服务器。默认端口是5858
node --debug[=port] script.js
node --debug-brk[=port] script.js

Eclipse调试Node.js

详见书P57

使用node-inspector调试Node.js

大部分基于 Node.js 的应用都是运行在浏览器中的，例如强大的调试工具 node-inspector。node-inspector 是一个完全基于 Node.js 的开源在线调试工具，提供了强大的调试功能和友好的用户界面，它的使用方法十分简便。

首先，使用 npm install -g node-inspector 命令安装 node-inspector，然后在终

端中通过 node –debug-brk=5858 debug.js 命令连接你要除错的脚本的调试服务器，

启动 node-inspector：

第四章 Node.js核心模块

全局对象

JavaScript 中有一个特殊的对象，称为全局对象（Global Object），它及其所有属性都可

以在程序的任何地方访问，即全局变量。在浏览器 JavaScript 中，通常 window 是全局对象，而 Node.js 中的全局对象是 global，所有全局变量（除了 global 本身以外）都是 global对象的属性。

我们在 Node.js 中能够直接访问到对象通常都是 global 的属性，如 console、process

等，下面逐一介绍。

global 最根本的作用是作为全局变量的宿主。

process

console

常用工具util

事件驱动events

events 是 Node.js 最重要的模块，没有“之一”，原因是 Node.js 本身架构就是事件式

的，而它提供了唯一的接口，所以堪称 Node.js 事件编程的基石。events 模块不仅用于用户代码与 Node.js 下层事件循环的交互，还几乎被所有的模块依赖。

events 模块只提供了一个对象： events.EventEmitter。EventEmitter 的核心就是事件发射与事件监听器功能的封装。EventEmitter 的每个事件由一个事件名和若干个参数组成，事件名是一个字符串，通常表达一定的语义。对于每个事件，EventEmitter 支持若干个事件监听器。当事件发射时，注册到这个事件的事件监听器被依次调用，事件参数作为回调函数参数传递。

例子：

//引入events模块
var events  = require('events');
//发射器对象
var emitter = new events.EventEmitter();
//emitter为someEvent事件注册了两个事件监听器。
emitter.on('someEvent',function(arg1,arg2){
console.log('listener1',arg1,arg2);
});
emitter.on('someEvent',function(arg1,arg2){
console.log('listener2',arg1,arg2);
});
//发射一个sonmeEvent事件
emitter.emit('someEvent','Creabine',1991);

运行结果是如下。运行结果中可以看到两个事件监听器回调函数被先后调用。

listener1 Creabine 1991

listener2 Creabine 1991

以上是EventEmitter最简单的用法，接下来介绍一下它的常用API：

EventEmitter.on(event,listener) 为指定事件注册一个监听器，接受一个字符串event和一个回调函数listener

EventEmitter.once(event,listener) 为指定事件注册一个单次监听器，即监听器最多只会触发一次，出发后立即解除该监听器。

EventEmitter.removeListener(event,listener) 移除指定事件的某个监听器，listener必须是该事件已经注册过的监听器。

EventEmitter.removeAllListener([event]) 移除所有事件的所有监听器。如果指定event，则移除指定事件的所有监听器。

error事件

EventEmitter 定义了一个特殊的事件 error，它包含了“错误”的语义，我们在遇到异常的时候通常会发射 error 事件。当 error 被发射时，EventEmitter 规定如果没有响应的监听器，Node.js 会把它当作异常，退出程序并打印调用栈。我们一般要为会发射 error事件的对象设置监听器，避免遇到错误后整个程序崩溃。

集成EventEmitter

大多数时候我们不会直接使用 EventEmitter，而是在对象中继承它。包括 fs、net、http 在内的，只要是支持事件响应的核心模块都是 EventEmitter 的子类。

为什么要这样做呢？原因有两点。首先，具有某个实体功能的对象实现事件符合语义，事件的监听和发射应该是一个对象的方法。其次 JavaScript 的对象机制是基于原型的，支持部分多重继承，继承 EventEmitter 不会打乱对象原有的继承关系。

文件系统fs

fs 模块是文件操作的封装，它提供了文件的读取、写入、更名、删除、遍历目录、链接等 POSIX 文件系统操作。与其他模块不同的是，fs 模块中所有的操作都提供了异步的和同步的两个版本， 例如读取文件内容的函数有异步的 fs.readFile() 和同步的fs.readFileSync()。

fs.readFile(filename,[encoding],[callback(err,data)])

fs.readFile是最简单的读取文件的函数。它接受一个必选参数 filename，表示要读取的文件名。第二个参数 encoding是可选的，表示文件的字符编码。callback 是回调函数，用于接收文件的内容。如果不指定 encoding，则 callback 就是第二个参数。回调函数提供两个参数 err 和 data，err 表示有没有错误发生，data 是文件内容。

如果指定了 encoding，data 是一个解析后的字符串，否则 data 将会是以 Buffer 形式表示的二进制数据。

当读取文件出现错误时，err 将会是 Error 对象。

fs.readFileSync(filename,[encoding])

fs.readFileSync(filename, [encoding])是 fs.readFile 同步的版本。它接受的参数和 fs.readFile 相同，而读取到的文件内容会以函数返回值的形式返回。如果有错误发生，fs 将会抛出异常，你需要使用 try 和 catch 捕捉并处理异常。

与同步 I/O 函数不同，Node.js 中异步函数大多没有返回值。

fs.open(path,flags,[mode],[callback(err,fd)])

path是文件路径，flags的值为：

 r ：以读取模式打开文件。

 r+ ：以读写模式打开文件。

 w ：以写入模式打开文件，如果文件不存在则创建。

 w+ ：以读写模式打开文件，如果文件不存在则创建。

 a ：以追加模式打开文件，如果文件不存在则创建。

 a+ ：以读取追加模式打开文件，如果文件不存在则创建。

mode 参数用于创建文件时给文件指定权限，默认是 0666①。回调函数将会传递一个文

件描述符 fd。

此外fs还有许多其他函数。

HTTP服务器与客户端

Node.js 标准库提供了 http 模块，其中封装了一个高效的 HTTP 服务器和一个简易的HTTP 客户端。http.Server 是一个基于事件的 HTTP 服务器，它的核心由 Node.js 下层 C++部分实现，而接口由 JavaScript 封装，兼顾了高性能与简易性。http.request 则是一个HTTP 客户端工具，用于向 HTTP 服务器发起请求，例如实现 Pingback①或者内容抓取。

HTTP服务器

http.Server 是 http 模块中的 HTTP 服务器对象，用 Node.js 做的所有基于 HTTP 协议的系统，如网站、社交应用甚至代理服务器，都是基于 http.Server 实现的。它提供了一套封装级别很低的 API，仅仅是流控制和简单的消息解析，所有的高层功能都要通过它的接口来实现。

简单的http服务器例如：

//app.js

var http = require('http');

http.createServer(function(req,res){
//响应代码200（表示请求成功），制定相应头为'Content-Type':'text/html'
res.write(200,'Content-Type':'text/html');
//写入响应体
res.write('<h1>Node.js</h1>');
//结束并发送
res.end('<p>Hello World</p>');
//调用listen函数，启动服务器并监听3000端口
}).listen(3000);

console.log('HTTP Server is listening at 3000');

http.server的事件

http.Server 是一个基于事件的 HTTP 服务器，所有的请求都被封装为独立的事件，开发者只需要对它的事件编写响应函数即可实现 HTTP 服务器的所有功能。它继承自EventEmitter，提供了以下几个事件。

request：当客户端请求到来时，该事件被触发。提供两个参数req和res,res，分别是http.ServerRequest 和 http.ServerResponse 的实例，表示请求和响应信息。

connection：当TCP连接建时，该事件被触发，提供一个参数socket，为net.Socket 的实例。connection 事件的粒度要大于 request，因为客户端在Keep-Alive 模式下可能会在同一个连接内发送多次请求。

close：当服务器关闭时，该事件被触发。注意不是在用户连接断开时。

除此之外还有 checkContinue、upgrade、clientError 事件，通常我们不需要关心，只有在实现复杂的 HTTP 服务器的时候才会用到。

在这些事件中， 最常用的就是 request 了， 因此 http 提供了一个捷径：http.createServer([requestListener]) ， 功能是创建一个 HTTP 服务器并将requestListener 作为 request 事件的监听函数，这也是我们前面例子中使用的方法。事实上它显式的实现方法是：

//httpserver.js

var http = require('http');

var server = new http.Server();
server.on('request', function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<h1>Node.js</h1>');
res.end('<p>Hello World</p>');
});
server.listen(3000);

console.log("HTTP server is listening at port 3000.");

http.ServerRequest

http.ServerRequest 是 HTTP 请求的信息，是后端开发者最关注的内容。它一般由http.Server 的 request 事件发送，作为第一个参数传递，通常简称 request 或 req。

HTTP 请求一般可以分为两部分：请求头（Request Header）和请求体（Requset Body）。以上内容由于长度较短都可以在请求头解析完成后立即读取。而请求体可能相对较长，需要一定的时间传输，因此 http.ServerRequest 提供了以下3个事件用于控制请求体传输:

data:当请求体数据到来时，该事件被触发。该事件提供一个参数 chunk，表示接收到的数据。如果该事件没有被监听，那么请求体将会被抛弃。该事件可能会被调用多次。

end:当请求体数据传输完成时，该事件被触发，此后将不会再有数据到来。

close:用户当前请求结束时，该事件被触发。不同于 end，如果用户强制终止了传输，也还是调用close。

http.ServerResponse

http.ServerResponse 是返回给客户端的信息，决定了用户最终能看到的结果。它也是由 http.Server 的 request 事件发送的，作为第二个参数传递，一般简称为response 或 res。

http.ServerResponse 有三个重要的成员函数，用于返回响应头、响应内容以及结束请求。

response.writeHead(statusCode, [headers])：向请求的客户端发送响应头。statusCode 是 HTTP 状态码，如 200 （请求成功）、404 （未找到）等。headers是一个类似关联数组的对象，表示响应头的每个属性。该函数在一个请求内最多只能调用一次，如果不调用，则会自动生成一个响应头。

response.write(data, [encoding])：向请求的客户端发送响应内容。data 是一个 Buffer 或字符串，表示要发送的内容。如果 data 是字符串，那么需要指定encoding 来说明它的编码方式，默认是 utf-8。在 response.end 调用之前，response.write 可以被多次调用。

response.end([data], [encoding])：结束响应，告知客户端所有发送已经完成。当所有要返回的内容发送完毕的时候，该函数 必须 被调用一次。它接受两个可选参数，意义和 response.write 相同。如果不调用该函数，客户端将永远处于等待状态。

82-84

第五章 使用Node.js进行Web开发

Node.js实现网站，目的是实现动态网页，也就是说由服务器动态生成HTML页面。之所以要这么做，是因为静态HTML的可扩展性非常有限，无法与用户有效交互。同时如果有大量相似内容，例如产品介绍页面，那么1000个产品就要1000个静态的HTML页面，维护它们简直是灾难，隐刺动态生成HTML页面的技术应运而生。

MVC（Model-View-Controller，模型-视图-控制器）是一种软件设计模式，把一个复杂的工程分解为三个层面：模型，视图和控制器。其中：

模型是对象及其数据结构的实现，通常包含数据库操作。

视图表示用户界面，在网站中通常就是HTML的组织结构。

控制器用于处理用户请求和数组刘，复杂模型，将输出传递给视图。

Node.js的好处是它内置了http模块，本身就可以作为服务器，性能可靠，可以直接应用到生产环境。

Node.js的http模块提供的是底层接口，比起PHP这种封装好的高级接口，使用起来复杂很多，所以我们使用node官方推荐的Express框架。

首先安装Express：本身只要局部安装即可，但是我们需要使用快速开始工具，所以我们全局安装：

npm install express -g
//安装完之后发现执行express --help无效，这是因为express在4.0版本后需要安装the executable（执行器express-generator）才能执行express命令，所以再：
npm install express-generator -g

接下来的部分估计有点老了，我按照书中的操作，但是生成的文件内容并不一致。这本书就先看到这里，找找别的练习做一做。