参考：

一、Node.js中的模块

Node.js使用require引入依赖的模块，因此模块是Node.js中的重要组成部分，这篇博客主要罗列一下常用的Node.js模块，并且在后期会添加在工作中用到的模块参考备用。

二、Node.js EventEmitter

Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。Node.js里面的许多对象都会分发事件，所有这些产生事件的对象都是 events.EventEmitter 的实例。

events 模块只提供了一个对象： events.EventEmitter。EventEmitter 的核心就是事件触发与事件监听器功能的封装。你可以通过require("events");来访问该模块。

// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

//event.js 文件
var events = require('events'); 
var emitter = new events.EventEmitter(); 
emitter.on('someEvent', function(arg1, arg2) { console.log('listener1', arg1, arg2); 
}); 
emitter.on('someEvent', function(arg1, arg2) { console.log('listener2', arg1, arg2); 
}); 
emitter.emit('someEvent', 'arg1 参数', 'arg2 参数'); 

server.on('connection', function (stream) {console.log('someone connected!');
});

server.once('connection', function (stream) {console.log('Ah, we have our first user!');
});

var callback = function(stream) {console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

类方法

事件

var events = require('events'); 
var emitter = new events.EventEmitter();
emitter.emit('error'); 

node.js:201 
throw e; // process.nextTick error, or 'error' event on first tick 
^ 
Error: Uncaught, unspecified 'error' event. 
at EventEmitter.emit (events.js:50:15) 
at Object.<anonymous> (/home/byvoid/error.js:5:9) 
at Module._compile (module.js:441:26) 
at Object..js (module.js:459:10) 
at Module.load (module.js:348:31) 
at Function._load (module.js:308:12) 
at Array.0 (module.js:479:10) 
at EventEmitter._tickCallback (node.js:192:40) 

三、Node.js Buffer

JavaScript 语言自身只有字符串数据类型，没有二进制数据类型。但在处理像TCP流或文件流时，必须使用到二进制数据。因此在 Node.js中，定义了一个 Buffer 类，该类用来创建一个专门存放二进制数据的缓存区。在 Node.js 中，Buffer 类是随 Node 内核一起发布的核心库。Buffer 库为 Node.js 带来了一种存储原始数据的方法，可以让 Node.js 处理二进制数据，每当需要在Node.js 中处理I/O操作中移动的数据时，就有可能使用 Buffer 库。原始数据存储在 Buffer 类的实例中。一个 Buffer 类似于一个整数数组，但它对应于 V8 堆内存之外的一块原始内存。

Buffer 实例一般用于表示编码字符的序列，比如 UTF-8 、 UCS2 、 Base64 、或十六进制编码的数据。 通过使用显式的字符编码，就可以在 Buffer 实例与普通的 JavaScript 字符串之间进行相互转换。Node.js 目前支持的字符编码包括：

1. ascii - 仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的。
2. utf8 - 多字节编码的 Unicode 字符。许多网页和其他文档格式都使用 UTF-8 。
3. utf16le - 2 或 4 个字节，小字节序编码的 Unicode 字符。支持代理对（U+10000 至 U+10FFFF）。
4. ucs2 - utf16le 的别名。
5. base64 - Base64 编码。
6. latin1 - 一种把 Buffer 编码成一字节编码的字符串的方式。
7. binary - latin1 的别名。
8. hex - 将每个字节编码为两个十六进制字符。

Buffer类中的方法如下：

const buf = Buffer.allocUnsafe(6);buf.writeUIntLE(0x1234567890ab, 0, 6);// 输出: <Buffer ab 90 78 56 34 12>
console.log(buf);

const buf = Buffer.allocUnsafe(6);buf.writeUIntBE(0x1234567890ab, 0, 6);// 输出: <Buffer 12 34 56 78 90 ab>
console.log(buf);

四、Node.js Stream

Stream 是一个抽象接口，Node 中有很多对象实现了这个接口。例如，对http 服务器发起请求的request 对象就是一个 Stream，还有stdout（标准输出）。Node.js，Stream 有四种流类型：

1. Readable - 可读操作。
2. Writable - 可写操作。
3. Duplex - 可读可写操作.
4. Transform - 操作被写入数据，然后读出结果。

1. data - 当有数据可读时触发。
2. end - 没有更多的数据可读时触发。
3. error - 在接收和写入过程中发生错误时触发。
4. finish - 所有数据已被写入到底层系统时触发。

如下代码展示了Stream ReadStream的用法：

var fs = require("fs");
var data = '';// 创建可读流
var readerStream = fs.createReadStream('input.txt');// 设置编码为 utf8。
readerStream.setEncoding('UTF8');// 处理流事件 --> data, end, and error
readerStream.on('data', function(chunk) {data += chunk;
});readerStream.on('end',function(){console.log(data);
});readerStream.on('error', function(err){console.log(err.stack);
});console.log("程序执行完毕");

var fs = require("fs");
var data = '菜鸟教程官网地址：www.runoob.com';// 创建一个可以写入的流，写入到文件 output.txt 中
var writerStream = fs.createWriteStream('output.txt');// 使用 utf8 编码写入数据
writerStream.write(data,'UTF8');// 标记文件末尾
writerStream.end();// 处理流事件 --> data, end, and error
writerStream.on('finish', function() {console.log("写入完成。");
});writerStream.on('error', function(err){console.log(err.stack);
});console.log("程序执行完毕");

管道流：

var fs = require("fs");// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);console.log("程序执行完毕");

链式流：

链式是通过连接输出流到另外一个流并创建多个流操作链的机制。链式流一般用于管道操作。

接下来我们就是用管道和链式来压缩和解压文件。创建 compress.js 文件, 代码如下：

var fs = require("fs");
var zlib = require('zlib');// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt').pipe(zlib.createGzip()).pipe(fs.createWriteStream('input.txt.gz'));console.log("文件压缩完成。");

Node.js路由中对HTTP请求的URL的解析需要依赖以下url 和querystring 模块：

                   url.parse(string).query|url.parse(string).pathname      ||                   ||                   |------ -------------------
http://localhost:8888/start?foo=bar&hello=world---       -----|          ||          |querystring.parse(queryString)["foo"]    ||querystring.parse(queryString)["hello"]

var http = require("http");
var url = require("url");function start() {function onRequest(request, response) {var pathname = url.parse(request.url).pathname;console.log("Request for " + pathname + " received.");response.writeHead(200, {"Content-Type": "text/plain"});response.write("Hello World");response.end();}http.createServer(onRequest).listen(8888);console.log("Server has started.");
}exports.start = start;

function route(pathname) {console.log("About to route a request for " + pathname);
}exports.route = route;

var http = require("http");
var url = require("url");function start(route) {function onRequest(request, response) {var pathname = url.parse(request.url).pathname;console.log("Request for " + pathname + " received.");route(pathname);response.writeHead(200, {"Content-Type": "text/plain"});response.write("Hello World");response.end();}http.createServer(onRequest).listen(8888);console.log("Server has started.");
}exports.start = start;

var server = require("./server");
var router = require("./router");server.start(router.route);

五、Node.js 全局变量

JavaScript 中有一个特殊的对象，称为全局对象（Global Object），它及其所有属性都可以在程序的任何地方访问，即全局变量。
在浏览器 JavaScript 中，通常 window 是全局对象， 而 Node.js 中的全局对象是 global，所有全局变量（除了 global 本身以外）都是 global 对象的属性。在 Node.js 我们可以直接访问到 global 的属性，而不需要在应用中包含它。

global 最根本的作用是作为全局变量的宿主。按照 ECMAScript 的定义，满足以下条 件的变量是全局变量：

1. 在最外层定义的变量；
2. 全局对象的属性；
3. 隐式定义的变量（未定义直接赋值的变量）。

1. __filename                    __filename 表示当前正在执行的脚本的文件名。它将输出文件所在位置的绝对路径，且和命令行参数所指定的文件名不一定相同。 如果在模块中，返回的值是模块文件的路径。
2. __dirname                     __dirname 表示当前执行脚本所在的目录。
3. setTimeout(cb, ms)       setTimeout(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。：setTimeout() 只执行一次指定函数。
4. 返回一个代表定时器的句柄值。
5. clearTimeout(t)             clearTimeout( t ) 全局函数用于停止一个之前通过 setTimeout() 创建的定时器。 参数 t 是通过 setTimeout() 函数创建的定时器。
6. setInterval(cb, ms)       setInterval(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。返回一个代表定时器的句柄值。可以使用 clearInterval(t) 函数来清除定时器。setInterval() 方法会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。
7. console                        console 用于提供控制台标准输出，它是由 Internet Explorer 的 JScript 引擎提供的调试工具，后来逐渐成为浏览器的实施标准。Node.js 沿用了这个标准，提供与习惯行为一致的 console 对象，用于向标准输出流（stdout）或标准错误流（stderr）输出字符。

六、Node.js util 工具

util 是一个Node.js 核心模块，提供常用函数的集合，用于弥补核心JavaScript 的功能 过于精简的不足。

util.inherits

var util = require('util'); 
function Base() { this.name = 'base'; this.base = 1991; this.sayHello = function() { console.log('Hello ' + this.name); }; 
} 
Base.prototype.showName = function() { console.log(this.name);
}; 
function Sub() { this.name = 'sub'; 
} 
util.inherits(Sub, Base); 
var objBase = new Base(); 
objBase.showName(); 
objBase.sayHello(); 
console.log(objBase); 
var objSub = new Sub(); 
objSub.showName(); 
//objSub.sayHello(); 
console.log(objSub); 

base 
Hello base 
{ name: 'base', base: 1991, sayHello: [Function] } 
sub 
{ name: 'sub' }

util.inspect

1. showHidden 是一个可选参数，如果值为 true，将会输出更多隐藏信息。
2. depth 表示最大递归的层数，如果对象很复杂，你可以指定层数以控制输出信息的多 少。如果不指定depth，默认会递归2层，指定为 null 表示将不限递归层数完整遍历对象。 如果color 值为 true，输出格式将会以ANSI 颜色编码，通常用于在终端显示更漂亮 的效果。
3. util.inspect  并不会简单地直接把对象转换为字符串，即使该对 象定义了toString 方法也不会调用。
4. util.isArray(object) 如果给定的参数 "object" 是一个数组返回true，否则返回false。
   
5. util.isRegExp(object)  如果给定的参数 "object" 是一个正则表达式返回true，否则返回false。
   
6. util.isDate(object)       如果给定的参数 "object" 是一个日期返回true，否则返回false。
   
7. util.isError(object)       如果给定的参数 "object" 是一个错误对象返回true，否则返回false。
   

七、Node.js 文件系统

var fs = require("fs")

var fs = require("fs");// 异步打开文件
console.log("准备打开文件！");
fs.open('input.txt', 'r+', function(err, fd) {if (err) {return console.error(err);}console.log("文件打开成功！");     
});

var fs = require("fs");// 异步读取
fs.readFile('input.txt', function (err, data) {if (err) {return console.error(err);}console.log("异步读取: " + data.toString());
});// 同步读取
var data = fs.readFileSync('input.txt');
console.log("同步读取: " + data.toString());console.log("程序执行完毕。");

八、Node.js GET/POST请求

由于GET请求直接被嵌入在路径中，URL是完整的请求路径，包括了?后面的部分，因此你可以手动解析后面的内容作为GET请求的参数。node.js 中 url 模块中的 parse 函数提供了这个功能。

var http = require('http');
var url = require('url');
var util = require('util');http.createServer(function(req, res){res.writeHead(200, {'Content-Type': 'text/plain'});// 解析 url 参数var params = url.parse(req.url, true).query;res.write("网站名：" + params.name);res.write("\n");res.write("网站 URL：" + params.url);res.end();}).listen(3000);

var http = require('http');
var querystring = require('querystring');http.createServer(function(req, res){// 定义了一个post变量，用于暂存请求体的信息var post = '';     // 通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中req.on('data', function(chunk){    post += chunk;});// 在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。req.on('end', function(){    post = querystring.parse(post);res.end(util.inspect(post));});
}).listen(3000);

var http = require('http');
var querystring = require('querystring');var postHTML = '<html><head><meta charset="utf-8"><title>Node.js 实例</title></head>' +'<body>' +'<form method="post">' +'网站名： <input name="name"><br>' +'网站 URL： <input name="url"><br>' +'<input type="submit">' +'</form>' +'</body></html>';http.createServer(function (req, res) {var body = "";req.on('data', function (chunk) {body += chunk;});req.on('end', function () {// 解析参数body = querystring.parse(body);// 设置响应头部信息及编码res.writeHead(200, {'Content-Type': 'text/html; charset=utf8'});if(body.name && body.url) { // 输出提交的数据res.write("网站名：" + body.name);res.write("<br>");res.write("网站 URL：" + body.url);} else {  // 输出表单res.write(postHTML);}res.end();});
}).listen(3000);

九、Node.js Web 模块

Node.js 提供了 http 模块，http 模块主要用于搭建 HTTP 服务端和客户端，使用 HTTP 服务器或客户端功能必须调用 http 模块，代码如下：

var http = require('http');

var http = require('http');
var fs = require('fs');
var url = require('url');// 创建服务器
http.createServer( function (request, response) {  // 解析请求，包括文件名var pathname = url.parse(request.url).pathname;// 输出请求的文件名console.log("Request for " + pathname + " received.");// 从文件系统中读取请求的文件内容fs.readFile(pathname.substr(1), function (err, data) {if (err) {console.log(err);// HTTP 状态码: 404 : NOT FOUND// Content Type: text/plainresponse.writeHead(404, {'Content-Type': 'text/html'});}else{             // HTTP 状态码: 200 : OK// Content Type: text/plainresponse.writeHead(200, {'Content-Type': 'text/html'});    // 响应文件内容response.write(data.toString());        }//  发送响应数据response.end();});   
}).listen(8080);// 控制台会输出以下信息
console.log('Server running at http://127.0.0.1:8080/');

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>My First Page</title>
</head>
<body><h1>我的第一个标题</h1><p>我的第一个段落。</p>
</body>
</html>

十、Node.js Express框架

Express 是一个简洁而灵活的 node.js Web应用框架, 提供了一系列强大特性帮助你创建各种 Web 应用，和丰富的 HTTP 工具。
使用 Express 可以快速地搭建一个完整功能的网站。Express 框架核心特性：

1. 可以设置中间件来响应 HTTP 请求。
2. 定义了路由表用于执行不同的 HTTP 请求动作。
3. 可以通过向模板传递参数来动态渲染 HTML 页面。

$ npm install express --save

1. body-parser - node.js 中间件，用于处理 JSON, Raw, Text 和 URL 编码的数据。
2. cookie-parser - 这就是一个解析Cookie的工具。通过req.cookies可以取到传过来的cookie，并把它们转成对象。
3. multer - node.js 中间件，用于处理 enctype="multipart/form-data"（设置表单的MIME编码）的表单数据。

10.1 Request和Response对象

Request 对象 - request 对象表示 HTTP 请求，包含了请求查询字符串，参数，内容，HTTP 头部等属性。常见属性有：

• req.app：当callback为外部文件时，用req.app访问express的实例
• req.baseUrl：获取路由当前安装的URL路径
• req.body / req.cookies：获得「请求主体」/ Cookies
• req.fresh / req.stale：判断请求是否还「新鲜」
• req.hostname / req.ip：获取主机名和IP地址
• req.originalUrl：获取原始请求URL
• req.params：获取路由的parameters
• req.path：获取请求路径
• req.protocol：获取协议类型
• req.query：获取URL的查询参数串
• req.route：获取当前匹配的路由
• req.subdomains：获取子域名
• req.accepts()：检查可接受的请求的文档类型
• req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages：返回指定字符集的第一个可接受字符编码
• req.get()：获取指定的HTTP请求头
• req.is()：判断请求头Content-Type的MIME类型

• res.app：同req.app一样
• res.append()：追加指定HTTP头
• res.set()在res.append()后将重置之前设置的头
• res.cookie(name，value [，option])：设置Cookie
• opition: domain / expires / httpOnly / maxAge / path / secure / signed
• res.clearCookie()：清除Cookie
• res.download()：传送指定路径的文件
• res.get()：返回指定的HTTP头
• res.json()：传送JSON响应
• res.jsonp()：传送JSONP响应
• res.location()：只设置响应的Location HTTP头，不设置状态码或者close response
• res.redirect()：设置响应的Location HTTP头，并且设置状态码302
• res.render(view,[locals],callback)：渲染一个view，同时向callback传递渲染后的字符串，如果在渲染过程中有错误发生next(err)将会被自动调用。callback将会被传入一个可能发生的错误以及渲染后的页面，这样就不会自动输出了。
• res.send()：传送HTTP响应
• res.sendFile(path [，options] [，fn])：传送指定路径的文件 -会自动根据文件extension设定Content-Type
• res.set()：设置HTTP头，传入object可以一次设置多个头
• res.status()：设置HTTP状态码
• res.type()：设置Content-Type的MIME类型

路由

在HTTP请求中，我们可以通过路由提取出请求的URL以及GET/POST参数。接下来我们扩展 Hello World，添加一些功能来处理更多类型的 HTTP 请求。创建 express_demo2.js 文件，代码如下所示：

var express = require('express');
var app = express();//  主页输出 "Hello World"
app.get('/', function (req, res) {console.log("主页 GET 请求");res.send('Hello GET');
})//  POST 请求
app.post('/', function (req, res) {console.log("主页 POST 请求");res.send('Hello POST');
})//  /del_user 页面响应
app.get('/del_user', function (req, res) {console.log("/del_user 响应 DELETE 请求");res.send('删除页面');
})//  /list_user 页面 GET 请求
app.get('/list_user', function (req, res) {console.log("/list_user GET 请求");res.send('用户列表页面');
})// 对页面 abcd, abxcd, ab123cd, 等响应 GET 请求
app.get('/ab*cd', function(req, res) {   console.log("/ab*cd GET 请求");res.send('正则匹配');
})var server = app.listen(8081, function () {var host = server.address().addressvar port = server.address().portconsole.log("应用实例，访问地址为 http://%s:%s", host, port)})

访问不同url获得不同的响应结果。

静态文件

Express 提供了内置的中间件 express.static 来设置静态文件如：图片， CSS, JavaScript 等。你可以使用 express.static 中间件来设置静态文件路径。例如，如果你将图片， CSS, JavaScript 文件放在 public 目录下，你可以这么写：

app.use(express.static('public'));

node_modules
server.js
public/
public/images
public/images/logo.png