Node.js - 工具模块

在这篇文章中，我们将讨论一些Node.js库提供的工具模块，这是非常常见的，经常使用在整个应用程序中。

Sr.No.	模块的名称和说明
1	Console 用于打印输出和错误信息
2	Process 用于获取当前进程的信息，提供处理相关活动的多个事件
3	OS Module 提供基本的操作系统相关的实用功能
4	Path Module 实用工具提供用于处理和转化文件路径
5	Net Module 提供服务器和客户端的数据流。作为一个网络应用包
6	DNS Module 提供的功能做实际的DNS查找，以及使用底层操作系统的名称解析功能
7	Domain Module 提供一种方式来处理多个不同的I/O操作为一个组

Node.js - 控制台

方法

Sr. No.	方法	描述
1	console.log([data][, ...])	打印及带有换行符到stdout，此函数可将多个参数在printf()类似的方式
2	console.info([data][, ...])	打印及带有换行符到stdout，此函数可将多个参数在printf()类似的方式
3	console.error([data][, ...])	打印及带有换行符到stderr，此函数可将多个参数在printf()类似的方
4	console.warn([data][, ...])	打印及带有换行符到stderr，此函数可将多个参数在printf()类似的方式
5	console.dir(obj[, options])	使用util.inspect在obj和生成的字符串打印到stdout
6	console.time(label)	标记时间
7	console.timeEnd(label)	完成定时，记录输出
8	console.trace(message[, ...])	打印到stderr“Trace :'，其次是格式化的消息和堆栈跟踪到当前位置
9	console.assert(value[, message][, ...])	类似于assert.ok()，但错误信息被格式化为util.format(message...)

示例

创建一个js文件名为test.js 在目录 D:\>yiibai_worksp\nodejs

File: test.js

var counter = 10;

console.log("Counter: %d", counter);

console.time("Getting data");
//make a database call to retrive the data
//getDataFromDataBase();
console.timeEnd('Getting data');

console.info("Program Ended!")

现在运行test.js看到的结果：

D:\yiibai_worksp\nodejs> node test.js

验证输出

Counter: 10
Getting data: 0ms
Program Ended!

Node.js - 进程

process 是一个全局性对象，并用于表示Node进程。

退出码

节点正常退出时带状态0码，在没有更多的异步操作挂起时。其他退出代码描述如下：

Code	名称	描述
1	未捕获致命异常	有一个未捕获的异常，它不是由域或uncaughtException事件处理程序处理
2	未使用	通过对于Bash滥用内置保留
3	内部的JavaScript解析错误	JavaScript源代码，在内部Node引导过程引起了解析错误。这是极为罕见的，一般只是在Node本身的开发过程中才发生的。
4	内部的JavaScript评估计算失败	JavaScript源代码，在内部Node的引导过程未能评估计算时返回一个函数值。这是极为罕见的，一般只是在Node本身的开发过程中发生的。
5	致命错误	在V8中的一个致命不可恢复的错误。通常情况下一个消息将被打印到stderr使用前缀致命错误。
6	非函数内部异常处理程序	有一个未捕获的异常，但内部致命的异常处理函数被莫名其妙地设置为一个非函数，并且不能被调用。
7	内部异常处理程序运行时故障	这里是一个未捕获的异常，并试图处理它内部的致命的异常处理函数本身抛出一个错误。
8	未使用
9	无效的参数	要么未知选项指定，或没有值时需要提供一个值的选项。
10	内部的JavaScript运行时故障	JavaScript源代码，在内部Node引导过程中抛出一个错误，当引导函数被调用。这是极为罕见的，一般Node是在开发过程中发生的。
12	无效的调试参数	--debug和/或--debug-brk选项都设置，但不能选择无效的端口号。
>128	信号退出	如果Node接收到一个致命信号如SIGKILL或SIGHUP，然后它的退出代码是128加上的信号代码的值。这是一个标准Unix，实际上由于退出代码被定义为7位整数，信号退出设置的高序位，包含所述信号的代码值。

事件

Process（进程）是一个eventEmitter，并且它发出下列事件

Sr.No.	Event	描述
1	exit	发射当进程即将退出。没有办法来防止事件循环退出在这一点上， 并且一旦所有的退出监听器运行完成，程序将退出。
2	beforeExit	当Node清空它的事件循环，并没有其他事情安排此事件被发射。通常情况下，当没有预定的工作Node退出，但是一个监听'beforeExit'可进行异步调用，并导致Node继续。
3	uncaughtException	发射当异常冒泡一路回到事件循环。如果一个监听器添加了此异常，则缺省操作（这是打印堆栈跟踪并退出）不会发生。
4	Signal Events	发射当进程接收到信号，例如SIGINT，SIGHUP等

属性

Process（进程）提供了许多有用的特性，以更好地控制系统的相互作用。

Sr.No.	属性	描述
1	stdout	可写流到标准输出
2	stderr	可写流到stderr
3	stdin	可写流标准输入
4	argv	包含命令行参数数组。第一元件将是“节点”，第二个元素是JavaScript文件的名称。接下来元素的内容是额外的命令行参数
5	execPath	这是启动进程的可执行文件的绝对路径
6	execArgv	这是一组Node特定的命令行选项从可执行启动进程
7	env	包含用户环境的对象
8	exitCode	许多可作为进程退出代码优雅地退出，或者是通过process.exit()无需指定代码退出
9	version	编译时属性暴露NODE_VERSION
10	versions	属性用来暴露node及其依赖的版本字符串
11	config	对象包含JavaScript用来表示编译当前Node可执行的配置选项能力。这是类似于“config.gypi”文件，所产生在./configure脚本运行时
12	pid	进程的PID
13	title	getter/setter设置 'ps' 所显示
14	arch	在什么处理器架构上运行： 'arm', 'ia32', 或 'x64'
15	platform	正在运行在什么平台： 'darwin', 'freebsd', 'linux', 'sunos' 或 'win32'
16	mainModule	备选的方法来检索require.main。不同的是，如果主模块改变在运行时，require.main仍可能指的是原来的主模块中被要求的变化发生之前的模块。通常它是安全假设的，这两个指的是相同的模块

方法

Process（进程）提供了许多有用的方法，以更好的控制系统的相互作用。

Sr.No.	方法	描述
1	abort()	这导致node发出中止。node退出并生成一个核心文件
2	chdir(directory)	改变进程的当前工作目录，或如果失败将引发异常
3	cwd()	返回进程的当前工作目录
4	exit([code])	终止使用指定的代码进程。如果省略，退出使用'成功'的代码0
5	getgid()	获取进程组标识，这是数值组ID，而不是组名。此函数仅适用于POSIX平台（即非Windows，Android）。
6	setgid(id)	设置进程组的标识。 (详看setgid(2).) 这要么接受一个数字ID或组名字符串。如果指定了组名，则此方法阻塞在解析到一个数字ID。此函数仅适用于POSIX平台（即非Windows，Android）。
7	getuid()	获取进程的用户身份。这是数字ID，而不是用户名。此函数仅适用于POSIX平台（即非Windows，Android）。
8	setuid(id)	设置进程的用户的身份。（请参阅setgid（2））。这接受一个数字ID或用户名字符串。如果指定一个用户名，这个方法会阻塞，同时解析到一个数字ID。此函数仅适用于POSIX平台（即非Windows，Android）。
9	getgroups()	返回带有补充组ID的数组。POSIX离开未指定是否该有效组ID包函，而Node.js保证它始终是。此函数仅适用于POSIX平台（即非Windows，Android）。
10	setgroups(groups)	设置辅助组标识。这是一个权限操作，这意味着需要以root或具有CAP_SETGID权限。此函数仅适用于POSIX平台（即非Windows，Android）。
11	initgroups(user, extra_group)	读取/etc/group文件并初始化组访问列表，使用所有这些组的用户是其成员。这是一个权限操作，这意味着需要以root或具有CAP_SETGID权力。此函数仅适用于POSIX平台（即非Windows，Android）。
12	kill(pid[, signal])	发送信号给一个进程。pid是进程ID和信号描述发送信号的字符串。信号的名字就像'SIGINT'或'SIGHUP'字符串。如果省略，信号是'SIGTERM'。
13	memoryUsage()	返回描述以字节为单位的Node进程的内存使用量的对象
14	nextTick(callback)	一旦当前事件循环转到运行结束，调用回调函数
15	umask([mask])	设置或读取进程的文件模式创建掩码。子进程继承父进程的掩码。返回老掩码如果掩码参数给出，否则返回当前掩码
16	uptime()	Node已经运行的秒数
17	hrtime()	返回当前高分辨率实时在[seconds, nanoseconds] 元组。它是相对于过去的任意时间。它是不相关的一天中的时间，因此，不会受到时钟偏移。 主要用途是用于测量时间间隔之间的性能。

示例

创建一个js文件名为test.js 在目录 D:\>yiibai_worksp\nodejs

File: test.js

var util = require('util');

//printing to console
process.stdout.write("Hello World!" + "\n");

//reading passed parameter
process.argv.forEach(function(val, index, array) {
   console.log(index + ': ' + val);
});

//executable path
console.log(process.execPath);

//print the current directory
console.log('Current directory: ' + process.cwd());

//print the process version
console.log('Current version: ' + process.version);

//print the memory usage
console.log(util.inspect(process.memoryUsage()));

现在运行test.js看到的结果：

D:\yiibai_worksp\nodejs> node test.js

验证输出：

Hello World!
0: node
1: D:\yiibai_worksp\nodejs\test.js
D:\yiibai_worksp\nodejs\node.exe
Current directory: D:\yiibai_worksp\nodejs
Current version: v0.12.7
{ rss: 16379904, heapTotal: 9751808, heapUsed: 4067896 }

Node.js - OS 模块

os模块用于一些基本的操作系统相关的实用功能。os模块可以使用以下语法导入。

var os = require("os")

方法

Sr. No.	方法	描述
1	os.tmpdir()	返回临时文件操作系统的默认目录
2	os.endianness()	返回CPU的存储方式。可能的值是“BE”或“LE”
3	os.hostname()	返回操作系统的主机名
4	os.type()	返回操作系统名称
5	os.platform()	返回操作系统平台
6	os.arch()	返回操作系统的CPU架构。可能的值是“64”，“arm”和“ia32”
7	os.release()	返回操作系统版本
8	os.uptime()	返回系统正常运行时间（秒）
9	os.loadavg()	返回包含1，5和15分钟的负载量平均值的数组
10	os.totalmem()	返回以字节系统存储器的总量
11	os.freemem()	返回可用系统内存量（字节）
12	os.cpus()	返回一个包含每个已安装的CPU/核心的信息对象的数组：model, speed (in MHz),和时间（含有用在CPU/核心的毫秒数量的对象：user, nice, sys, idle, and irq).
13	os.networkInterfaces()	得到的网络接口的列表

属性

Sr. No.	属性	描述
1	os.EOL	操作系统限定行尾的适当标记的常量

示例

创建一个js文件名为test.js 在 D:\>yiibai_worksp\nodejs

File: test.js

var os = require("os");

//endianness
console.log('endianness : ' + os.endianness());

//type
console.log('type : ' + os.type());

//platform
console.log('platform : ' + os.platform());

//totalmem
console.log('total memory : ' + os.totalmem() + " bytes.");

//freemem
console.log('free memory : ' + os.freemem() + " bytes.");

现在运行test.js看到的结果：

D:\yiibai_worksp\nodejs> node test.js

验证输出：

endianness : LE
type : Windows_NT
platform : win32
total memory : 4201889792 bytes.
free memory : 1233211392 bytes.

Node.js - Path 模块

path 模块用于处理和转换文件路径。path模块可以使用以下语法导入。

var path = require("path")

属性

进程提供了许多有用的特性，以获得更好的控制系统的相互作用。

Sr.No.	属性	描述
1	path.sep	特定于平台的文件分隔符 '\\' 或 '/'.
2	path.delimiter	特定于平台的路径分隔符, ; 或 ':'.
3	path.posix	提供访问路径上述方法，但始终在POSIX兼容的方式进行交互
4	path.win32	提供访问路径上述方法，但总是在Win32兼容的方式进行交互

方法

Sr. No.	方法	描述
1	path.normalize(p)	规范化字符串路径，采用'..'和'.'部分
2	path.join([path1][, path2][, ...])	连接所有参数一起和规范生成的路径
3	path.resolve([from ...], to)	解析到一个绝对路径
4	path.isAbsolute(path)	确定路径是否是一个绝对路径。绝对路径将始终解析到相同的位置，而不考虑工作目录
5	path.relative(from, to)	解决相对路径从from到to
6	path.dirname(p)	返回路径的目录名称，类似于Unix的目录名的命令。
7	path.basename(p[, ext])	返回路径的最后部分，类似于UNIX命令基名。
8	path.extname(p)	返回路径的扩展，从最后一个“.”结束到字符串在路径的最后部分。如果没有'.'在路径最后部分或第一个字符的是“.”，那么它返回一个空字符串。
9	path.parse(pathString)	从路径字符串返回对象
10	path.format(pathObject)	从一个对象返回 path.parse上述相反的路径字符串

示例

创建一个js文件名为test.js 在 D:\>yiibai_worksp\nodejs

File: test.js

var path = require("path");

//normalization
console.log('normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/..'));

//join
console.log('joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..'));

//resolve
console.log('resolve : ' + path.resolve('test.js'));

//extName
console.log('ext name : ' + path.extname('test.js'));

现在运行test.js看到的结果：

D:\yiibai_worksp\nodejs> node test.js

验证输出：

normalization : \test\test1\2slashes\1slash
joint path : \test\test1\2slashes\1slash
resolve : D:\yiibai_worksp\nodejs\test.js
ext name : .js

Node.js - Net模块

net 模块是用来创建服务器和客户端。它提供了一个异步网络包装。 net模块可以使用以下语法导入。

var net = require("net")

方法

Sr. No.	方法	描述
1	net.createServer([options][, connectionListener])	创建一个新的TCP服务器。connectionListener参数自动设置为监听器的'连接'事件
2	net.connect(options[, connectionListener])	工厂方法，它返回一个新的“net.Socket”，并连接到提供的地址和端口
3	net.createConnection(options[, connectionListener])	工厂方法，它返回一个新的“net.Socket”，并连接到提供的地址和端口
4	net.connect(port[, host][, connectListener])	创建于主机的TCP连接端口。如果省略主机，默认使用“localhost”。connectListener参数将作为一个监听器“连接”事件。它返回一个新的“net.Socket”工厂方法
5	net.createConnection(port[, host][, connectListener])	创建于主机的TCP连接端口。如果省略主机，默认是“localhost”。 connectListener参数将作为一个监听器“连接”事件。它返回一个新的“net.Socket”工厂方法
6	net.connect(path[, connectListener])	创建Unix套接字连接路径。connectListener参数将作为一个监听器“连接”事件。工厂方法返回一个新的“net.Socket”
7	net.createConnection(path[, connectListener])	创建Unix套接字连接路径，connectListener参数将作为一个监听器“连接”事件。工厂方法返回一个新的“net.Socket”
8	net.isIP(input)	测试输入是否为IP地址，返回0则是无效的字符串，返回4则是IP版本4的地址， 返回6 则是IP版本6的地址
9	net.isIPv4(input)	返回true，如果输入的是版本4的IP地址，否则返回false
10	net.isIPv6(input)	返回true，如果输入的是版本6的IP地址，否则返回false

Class:net.Server

此类用于创建TCP或本地服务器。

方法

Sr. No.	方法	描述
1	server.listen(port[, host][, backlog][, callback])	开始接受指定的端口和主机上的连接。如果省略主机，服务器将接受针对任何IPv4地址（INADDR_ANY）连接，端口值为0时将分配一个随机端口
2	server.listen(path[, callback])	启动本地socket服务器监听给定的路径上的连接
3	server.listen(handle[, callback])	句柄对象可以被设置为一个服务器或socket（下面_handle构件任何东西），或一个{fd:<n>}对象。这将导致服务器接受指定句柄连接，但可以推测该文件描述符或句柄已被绑定到端口或域套接字。监听文件描述符在Windows上不支持。
4	server.listen(options[, callback])	port，host和backlog选项的属性，以及可选callback 函数，这些做一个调用 server.listen(port, [host], [backlog], [callback]) 。或者，可使用的路径选项指定一个UNIX套接字。
5	server.close([callback])	最终关闭时结束所有连接和服务器发出一个“关闭”事件
6	server.address()	操作系统返回服务器的绑定地址，所述地址族名称和端口。
7	server.unref()	在服务器上调用unref将允许程序退出，如果这是在事件系统中唯一的活动服务器。如果服务器已经unrefd再次调用unref将无任何作用。
8	server.ref()	与unref相反，如果它是仅存的服务器（默认行为）调用ref在unrefd之前服务器不会让程序退出。如果服务器refd调用再次ref不会有任何效果。
9	server.getConnections(callback)	异步获取服务器上的并发连接数量。 当套接字被送往forks。回调函数应该用两个参数 err和count。

事件

Sr. No.	事件	描述
1	listening	发射在服务器绑定调用server.listen后
2	connection	当一个新的连接创建时发射。Socket对象，连接对象提供给事件处理。Socket是net.Socket的一个实例。
3	close	服务器关闭时发出。需要注意的是，如果连接存在，这个事件是不会发射的，直到所有的连接都结束。
4	error	当错误发生时发出。 “关闭”将被直接调用此事件之后。

Class:net.Socket

这个对象是一个TCP或本地套接字的抽象。net.Socket的实例实现全双工流接口。它们可以由用户创建，并用作一个客户端（使用connect()），也可以由Node创建并通过服务器的'连接'事件传递给用户。

事件

net.Socket是一个eventEmitter，它发出下列事件。

Sr.No.	事件	描述
1	lookup	解析主机名之后，但在连接之前发射。不适用于Unix套接字
2	connect	当成功建立一个套接字连接时发射
3	data	当接收数据时发射。参数数据将是一个缓冲或字符串。重新编码的数据是通过socket.setEncoding()设定的
4	end	当套接字的另一端发送一个FIN包发射
5	timeout	如果套接字超闲置时发射。这是唯一的，以通知套接字已经空闲。用户必须手动关闭连接
6	drain	当写缓冲区变空时发射。可用于限制上传
7	error	当错误发生时发射，“关闭”事件将被直接称为继此事件。
8	close	当套接字被完全关闭时发射，参数had_error是一个布尔值，指明如果套接字是由于传输错误关闭。

属性

net.Socket提供了许多有用的特性，以更好的控制套接字的相互作用。

Sr.No.	属性	描述
1	socket.bufferSize	此属性表示要写入当前缓冲的字符数
2	socket.remoteAddress	远程IP地址的字符串表示。例如， '74.125.127.100' 或 '2001:4860:a005::68'
3	socket.remoteFamily	远程IP系列（簇）的字符串表示。 'IPv4' 或 'IPv6'
4	socket.remotePort	远程端口的数字表示。例如，80 或 21
5	socket.localAddress	远程客户端连接到本地的IP地址的字符串表示。例如，如果正在在“0.0.0.0”监听，客户端连接到 '192.168.1.1', 那么它的值就是 '192.168.1.1'
6	socket.localPort	本地端口的数字表示。例如，80 或 21
7	socket.bytesRead	接收的字节数
8	socket.bytesWritten	发送的字节数

方法

Sr. No.	方法	描述
1	new net.Socket([options])	构造一个新的 Socket 对象
2	socket.connect(port[, host][, connectListener])	打开一个给定的套接字连接。如果端口和主机给出，那么套接字就会被打开作为TCP套接字，如果省略主机，将使用localhost。如果路径给定，套接字就会被打开作为一个Unix套接字到该路径
3	socket.connect(path[, connectListener])	打开一个给定的套接字连接。如果端口和主机给出，那么套接字就会被打开作为TCP套接字，如果省略主机，将使用localhost。如果路径给定，套接字就会被打开作为一个Unix套接字到该路径
4	socket.setEncoding([encoding])	套接字为只读流设置编码
5	socket.write(data[, encoding][, callback])	发送套接字上的数据。第二个参数指定的编码是在字符串的情况 - 它默认为UTF8编码。
6	socket.end([data][, encoding])	半关闭套接字，即它发送FIN包。可能服务器仍然会发送一些数据。
7	socket.destroy()	确保没有更多的I/O活动发生在此套接字。只有在错误的情况下（解析错误）有必要。
8	socket.pause()	暂停数据读出。即，“数据”事件将不会被发射。有用的节流回到上载
9	socket.resume()	调用 pause() 后读取暂停
10	socket.setTimeout(timeout[, callback])	设置套接字不活动的套接字在timeout毫秒后超时。默认 net.Socket 不会超时。
11	socket.setNoDelay([noDelay])	禁用Nagle算法。默认情况下TCP连接使用Nagle算法，它们在发送之前关闭缓存数据。noDelay设置true时每次socket.write()被调用将立即释放掉的数据。noDelay 默认值是true.
12	socket.setKeepAlive([enable][, initialDelay])	启用/禁用保持有效功能， 可选设置初始延迟后，第一存活探测被发送在空闲插槽。 enable 默认值是 false.
13	socket.address()	返回绑定地址， 报告操作系统的地址系列名称和套接字的端口。 返回一个对象有三个属性，例如{ port: 12346, family: 'IPv4', address: '127.0.0.1' }.
14	socket.unref()	套接字上调用unref 将允许程序退出，如果这是事件系统中唯一的活动套接字。如果套接字已经unrefd再次调用unref 将不会起作用。
15	socket.ref()	与unref相反，调用ref在unrefd套接字之前不会让程序退出，如果它是唯一剩下的socket（默认行为）。如果套接字refd调用再次ref将没有起任何作用。

示例

创建一个js文件名为server.js 在 D:\>yiibai_worksp\nodejs

File: server.js

var net = require('net');
var server = net.createServer(function(connection) {
   console.log('client connected');
   connection.on('end', function() {
      console.log('client disconnected');
   });
   connection.write('Welcome to Yiibai Yiibai!\r\n');
   connection.pipe(connection);
});
server.listen(8080, function() {
  console.log('server is listening');
});

现在运行server.js看到的结果：

D:\yiibai_worksp\nodejs>node server.js

验证输出。

server is listening

创建一个js文件名为client.js 在 C:\>Nodejs_WorkSpace.

File: client.js

var net = require('net');
var client = net.connect({port: 8080}, function() {
   console.log('connected to server!');
});
client.on('data', function(data) {
   console.log(data.toString());
   client.end();
});
client.on('end', function() {
   console.log('disconnected from server');
});

现在启动另一个命令行窗口，运行 client.js 看到结果：

D:\yiibai_worksp\nodejs>node client.js

验证输出：

connected to server!
Welcome to Yiibai Yiibai!

disconnected from server

验证，其中server.js运行输出在终端上如下：

server is listening
client connected
client disconnected

Node.js - DNS 模块

dns 模块是用来做实际的DNS查找，以及使用底层操作系统的名称解析功能..它提供了一个异步网络包装。dns模块可以使用以下语法导入。

var dns = require("dns")

方法

Sr. No.	方法	描述
1	dns.lookup(hostname[, options], callback)	解析主机名（如“google.com”）进入第一找到A（IPv4）或AAAA（IPv6）纪录。选项可以是对象或整数。如果未提供选项，那么IP v4和v6的地址都是有效的。如果选项是整数，那么它必须是4或6
2	dns.lookupService(address, port, callback)	使用getnameinfo会解析给定的地址和端口成一个主机名和服务
3	dns.resolve(hostname[, rrtype], callback)	解析主机名（如“google.com”）到由rrtype指定的记录类型的数组
4	dns.resolve4(hostname, callback)	与 dns.resolve() 相同, 但仅限于IPv4的查询（A记录）。地址是IPv4地址的数组(如，['74.125.79.104', '74.125.79.105', '74.125.79.106'])
5	dns.resolve6(hostname, callback)	与dns.resolve4()相同，除了IPv6的查询（一个AAAA查询）
6	dns.resolveMx(hostname, callback)	与dns.resolve()相同，但仅限于邮件交换查询（MX记录）
7	dns.resolveTxt(hostname, callback)	与 dns.resolve()相同，但仅限于文本查询（TXT记录）。地址是文本纪录，以供主机的2-D数组 (如, [ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). 每个子阵列包含一个记录的TXT块。根据使用的情况，可以任意连接在一起或分别处理
8	dns.resolveSrv(hostname, callback)	与dns.resolve()相同，但仅用于服务记录（SRV记录）。 地址是一个SRV记录的数组提供主机名。SRV记录属性包括优先级，权重，端口和名称(e.g., [{'priority': 10, 'weight': 5, 'port': 21223, 'name': 'service.example.com'}, ...]).
9	dns.resolveSoa(hostname, callback)	与 dns.resolve() 相同, 但仅限于认证记录查询开始（SOA记录）
10	dns.resolveNs(hostname, callback)	与 dns.resolve() 相同, 但只针对域名服务器记录（NS记录）。地址是可用于主机的名称服务器记录的数组 (如, ['ns1.example.com', 'ns2.example.com']).
11	dns.resolveCname(hostname, callback)	与 dns.resolve()相同, 但仅限于规范名称记录（CNAME记录）。地址是的规范名称记录可用于主机的数组 (如, ['bar.example.com']).
12	dns.reverse(ip, callback)	Reverse resolves an ip address to an array of hostnames.
13	dns.getServers()	Returns an array of IP addresses as strings that are currently being used for resolution.
14	dns.setServers(servers)	Given an array of IP addresses as strings, set them as the servers to use for resolving.

rrtypes

以下是所使用dns.resolve()方法的有效rrtypes的列表

• A - IPV4 地址（默认）

• AAAA - IPV6 地址

• MX - 邮件交换记录

• TXT - 文字记录

• SRV - SRV记录

• PTR - 用于逆向IP查找

• NS - 域名服务器记录

• CNAME - 规范名称记录

• SOA - 规范记录的开始

错误代码

每个DNS查询可以返回下列错误代码之一：

• dns.NODATA - DNS服务器返回回答不含数据

• dns.FORMERR - DNS服务器要求查询是misformatted

• dns.SERVFAIL - DNS服务器返回的一般故障

• dns.NOTFOUND - 域名未找到

• dns.NOTIMP - DNS服务器不执行请求操作

• dns.REFUSED - DNS服务器拒绝查询

• dns.BADQUERY - 非格式化的DNS查询

• dns.BADNAME - 非格式化的主机名

• dns.BADFAMILY - 不支持的地址族

• dns.BADRESP - Misformatted DNS回复

• dns.CONNREFUSED - 无法联系DNS服务器

• dns.TIMEOUT - 超时在联系DNS服务器的时候

• dns.EOF - 文件的结尾

• dns.FILE - 读取文件错误

• dns.NOMEM - 内存不足

• dns.DESTRUCTION - 信道被销毁

• dns.BADSTR - 非法格式化字符串

• dns.BADFLAGS - 非法标志指定

• dns.NONAME - 给定主机名不是数字

• dns.BADHINTS - 非法提示标志指定

• dns.NOTINITIALIZED - c-ares库初始化尚未执行

• dns.LOADIPHLPAPI - 加载 iphlpapi.dll 错误

• dns.ADDRGETNETWORKPARAMS - 找不到GetNetworkParams函数

• dns.CANCELLED - DNS查询取消

示例

创建一个js文件名为test.js 在 D:\>yiibai_worksp\nodejs

File: test.js

var dns = require('dns');

dns.lookup('www.yiibai.com', function onLookup(err, address, family) {
   console.log('address:', address);
   dns.reverse(address, function (err, hostnames) {
   if (err) {
      console.log(err.stack);
   }

   console.log('reverse for ' + address + ': ' + JSON.stringify(hostnames));
});
});

现在运行test.js看到的结果：

D:\yiibai_worksp\nodejs> node test.js

验证输出：

address: 112.124.103.85
Error: getHostByAddr ENOTFOUND 112.124.103.85
    at errnoException (dns.js:44:10)
    at Object.onresolve [as oncomplete] (dns.js:199:19)
reverse for 112.124.103.85: undefined

Node.js - Domain模块

domain 模块是用于拦截未处理的错误。这些未处理的错误可以使用内部绑定或外部绑定来拦截。如果错误都那么不处理，那么Node应用会崩溃。

• 内部绑定 - 错误发生执行代码是在一个域的run方法。

• 外部绑定 - 使用它的add方法将错误发生明确地加入到域。

domain（域）模块可以使用以下语法导入。

var domain = require("domain")

域模块的Domain类是用来提供路由错误以及未捕获异常活动域对象的功能。 这是一个EventEmitter的子类。为了处理它捕获错误，监听它的错误事件。它使用如下的语法创建：

var domain = require("domain");
var domain1 = domain.create();

方法

Sr. No.	方法	描述
1	domain.run(function)	运行所提供的函数在域的上下文中，隐式绑定在这种情况下创建的所有事件发射器，定时器和低级请求，这是使用域的最基本的方法
2	domain.add(emitter)	显式地将一个发射器到域。如果由发射器事件处理程序抛出一个错误，或者，如果发射器发出一个错误事件，它会被路由到该域的错误事件，就如隐式绑定
3	domain.remove(emitter)	与domain.add(emitter)相反。从指定的发射器处理删除域
4	domain.bind(callback)	返回的函数将被围绕包装提供回调函数。当返回的函数被调用时，被抛出的任何错误都将被路由到该域的错误事件
5	domain.intercept(callback)	此方法几乎是domain.bind(callback)相同， 然而，除了捕获抛出错误，它也将截取Error 对象发送作为第一个参数到函数。
6	domain.enter()	输入是一种用于运行，绑定，并拦截方法来设置活动域管道。它设置domain.active和process.domain到域，并隐式地推到域，域管理模块域栈（详见domain.exit()详细信息，域名栈）。调用以进入分隔链开始绑定到域异步调用和I/O操作。
7	domain.exit()	exit方法退出当前域，它弹出关闭域堆栈。任何时间执行将要切换到不同链的异步调用的上下文中，重要的是要确保当前域退出。调用以退出分隔末尾或者中断链绑定到一个域的异步调用和I/O操作。
8	domain.dispose()	一旦处理被调用，该域将不再使用回调绑定到通过运行，绑定或拦截该域。以及一个dispose事件发射

属性

Sr.No.	属性	描述
1	domain.members	定时器和事件发射器数组已明确添加到域

示例

创建一个js文件名为test.js 在 D:\>yiibai_worksp\nodejs

File: test.js

var EventEmitter = require("events").EventEmitter;
var domain = require("domain");

var emitter1 = new EventEmitter();

//Create a domain
var domain1 = domain.create();

domain1.on('error', function(err){
   console.log("domain1 handled this error ("+err.message+")");
});

//explicit binding
domain1.add(emitter1);

emitter1.on('error',function(err){
   console.log("listener handled this error ("+err.message+")");
});

emitter1.emit('error',new Error('To be handled by listener'));

emitter1.removeAllListeners('error');

emitter1.emit('error',new Error('To be handled by domain1'));

var domain2 = domain.create();

domain2.on('error', function(err){
   console.log("domain2 handled this error ("+err.message+")");
});

//implicit binding
domain2.run(function(){
   var emitter2 = new EventEmitter();

   emitter2.emit('error',new Error('To be handled by domain2'));
});

domain1.remove(emitter1);

emitter1.emit('error',new Error('Converted to exception. System will crash!'));

现在运行test.js看到的结果：

D:\yiibai_worksp\nodejs>node test.js

验证输出：

listener handled this error (To be handled by listener)
domain1 handled this error (To be handled by domain1)
domain2 handled this error (To be handled by domain2)

events.js:72
        throw er; // Unhandled 'error' event
              ^
Error: Converted to exception. System will crash!
    at Object.<anonymous> (C:\Nodejs_WorkSpace\test.js:42:23)
    at Module._compile (module.js:456:26)
    at Object.Module._extensions..js (module.js:474:10)
    at Module.load (module.js:356:32)
    at Function.Module._load (module.js:312:12)
    at Function.Module.runMain (module.js:497:10)
    at startup (node.js:119:16)
    at node.js:929:3

Node.js - Web模块

Web服务器简介

Web服务器是用于处理使用HTTP协议请求并返回网页作为响应到客户端的软件应用程序。 Web服务器通常提供HTML文档并伴随着图片，样式表和脚本。大多数Web服务器还支持使用脚本语言作为服务器端脚本，或重定向到从数据库中获取数据的执行特定任务的应用程序服务器，执行复杂的逻辑等，Web服务器然后返回应用服务器到客户端输出。

Apache web服务器是最常见的一个网络服务器。它是一个开源项目。

路径定位过程

Web服务器映射使用URL，统一资源定位符的文件的路径。它可以是一个本地文件系统或一个外部/内部程序。例如：

客户端使用的浏览器发起一个URL请求：http://www.test-example-site.com/website/index.htm.

浏览器发起的一个请求是：

Web服务器将追加路径到根目录。举个例子：根目录是home/www，那么实际路径将被转换为 home/www/website/index.htm.

Web网络架构介绍

Web应用程序的使用分为四层：

• Client - 此层是由Web浏览器，移动浏览器或应用程序，它可以发起HTTP请求到服务器。

• Server - 这一层包括可拦截发出的客户端请求，并将其传递到由Web服务器响应。

• Business - 这一层由应用程序服务器组成，它通过利用Web服务器执行动态任务。这一层交互通过数据库或某些外部程序数据层。

• Data - 此层由数据库或任何来源的数据。

使用Node创建Web服务器

使用http.createServer方法创建HTTP服务器。通过它一个函数带参数请求和响应。编写一个示例实现返回一个请求页面。通过在8081端口上监听。

创建一个js文件名为server.js 在 D:\>yiibai_worksp\nodejs

File: server.js

//http module is required to create a web server
var http = require('http');
//fs module is required to read file from file system
var fs = require('fs');
//url module is required to parse the URL passed to server
var url = require('url');

//create the server
http.createServer(function (request, response) {
   //parse the pathname containing file name
   var pathname = url.parse(request.url).pathname;
   //print the name of the file for which request is made.
   //if url is http://localhost:8081/test.htm then
   //pathname will be /test.html
   console.log("Request for " + pathname + " received.");
   //read the requested file content from file system
   fs.readFile(pathname.substr(1), function (err, data) {
      //if error occured during file read
      //send a error response to client
      //that web page is not found.
      if (err) {
         console.log(err.stack);
         // HTTP Status: 404 : NOT FOUND
         // Content Type: text/plain
         response.writeHead(404, {'Content-Type': 'text/html'});
      }else{
         //Page found
         // HTTP Status: 200 : OK
         // Content Type: text/plain
         response.writeHead(200, {'Content-Type': 'text/html'});
         // write the content of the file to response body
         response.write(data.toString());
      }
      // send the response body
      response.end();
   });
}).listen(8081);
// console will print the message
console.log('Server running at http://127.0.0.1:8081/');

创建一个名为 test.html 的 html 文件在 D:\>yiibai_worksp\nodejs

File: test.html

<html>
<head>
<title>Sample Page</title>
</head>
<body>
    Hello World!
</body>
</html>

现在运行server.js看到的结果：

D:\yiibai_worksp\nodejs>node server.js

验证输出。服务器已经启动

Server running at http://127.0.0.1:8081/

发出请求到Node.js服务器

在任何浏览器中打开以下网址：http://127.0.0.1:8081/test.html，看看下面的结果。

验证服务器端的输出

Server running at http://127.0.0.1:8081/
Request for /test.html received.

使用Node创建Web客户端

Web客户端可以使用http模块来创建。参见下面的例子：

创建一个名为client.js的js文件在 D:\>yiibai_worksp\nodejs

File: client.js

//http module is required to create a web client
var http = require('http');

//options are to be used by request
var options = {
   host: 'localhost',
   port: '8081',
   path: '/test.html'
};

//callback function is used to deal with response
var callback = function(response){
   // Continuously update stream with data
   var body = '';
   response.on('data', function(data) {
      body += data;
   });
   response.on('end', function() {
      // Data received completely.
      console.log(body);
   });
}
//make a request to the server
var req = http.request(options, callback);
req.end();

现在运行client.js在不同的终端命令行，也就是在server.js以外终端上看到的结果：

D:\yiibai_worksp\nodejs>node client.js

验证输出：

<html>
<head>
<title>Sample Page</title>
</head>
<body>
    Hello World!
</body>
</html>

验证服务器端的输出

Server running at http://127.0.0.1:8081/
Request for /test.html received.
Request for /test.html received.

Node.js - Express应用程序

Express 概述

Express JS是用于创建Node JS的Web应用程序非常流行的Web应用程序框架。它提供了一个集成的环境便于快速开发基于Node的Web应用程序。Express框架是基于连接的中间件引擎并使用Jade HTML模板框架来做HTML模板。以下是一些Express 框架的核心功能：

• 允许设立中间件来响应HTTP请求

• 定义了用于执行基于HTTP方法和URL不同作用的路由表

• 允许动态渲染基于参数传递给模板的HTML页面

安装Express

首先，使用NPM安装Express框架到全局，以便它可以使用Node终端来创建Web应用程序。

D:\yiibai_worksp\nodejs> npm install express -g

当npm完成下载，可以通过查看内容来验证，内容在 <user-directory>/npm/node_modules. 或输入以下命令：

D:\yiibai_worksp\nodejs> npm ls -g

将看到以下的输出：

C:\Documents and Settings\Administrator\Application Data\npm
+-- express@4.11.2
  +-- accepts@1.2.3
  | +-- mime-types@2.0.8
  | | +-- mime-db@1.6.1
  | +-- negotiator@0.5.0
  +-- content-disposition@0.5.0
  +-- cookie@0.1.2
  +-- cookie-signature@1.0.5
  +-- debug@2.1.1
  | +-- ms@0.6.2
  +-- depd@1.0.0
  +-- escape-html@1.0.1
  +-- etag@1.5.1
  | +-- crc@3.2.1
  +-- finalhandler@0.3.3
  +-- fresh@0.2.4
  +-- media-typer@0.3.0
  +-- merge-descriptors@0.0.2
  +-- methods@1.1.1
  +-- on-finished@2.2.0
  | +-- ee-first@1.1.0
  +-- parseurl@1.3.0
  +-- path-to-regexp@0.1.3
  +-- proxy-addr@1.0.6
  | +-- forwarded@0.1.0
  | +-- ipaddr.js@0.1.8
  +-- qs@2.3.3
  +-- range-parser@1.0.2
  +-- send@0.11.1
  | +-- destroy@1.0.3
  | +-- mime@1.2.11
  | +-- ms@0.7.0
  +-- serve-static@1.8.1
  +-- type-is@1.5.6
  | +-- mime-types@2.0.8
  |   +-- mime-db@1.6.1
  +-- utils-merge@1.0.0
  +-- vary@1.0.0

Express生成器

现在使用NPM安装express生成器。express生成器用于使用express命令创建应用程序框架。

D:\yiibai_worksp\nodejs> npm install express-generator -g

将看到以下的输出：

D:\yiibai_worksp\nodejs>npm install express-generator -g
C:\Users\Administrator\AppData\Roaming\npm\express -> C:\Users\Administrator\AppData\Roaming\npm\node_modules\express-generator\bin\expressexpress-generator@4.13.1 C:\Users\Administrator\AppData\Roaming\npm\node_modules
\express-generator
+-- sorted-object@1.0.0
+-- commander@2.7.1
+-- mkdirp@0.5.1 (minimist@0.0.8)

Hello world 示例

现在使用下面的命令创建一个示例应用程序 firstApplication：

D:\yiibai_worksp\nodejs> express firstApplication

将看到以下的输出：

   create : firstApplication
   create : firstApplication/package.json
   create : firstApplication/app.js
   create : firstApplication/public
   create : firstApplication/public/javascripts
   create : firstApplication/public/images
   create : firstApplication/public/stylesheets
   create : firstApplication/public/stylesheets/style.css
   create : firstApplication/routes
   create : firstApplication/routes/index.js
   create : firstApplication/routes/users.js
   create : firstApplication/views
   create : firstApplication/views/index.jade
   create : firstApplication/views/layout.jade
   create : firstApplication/views/error.jade
   create : firstApplication/bin
   create : firstApplication/bin/www

   install dependencies:
     $ cd firstApplication && npm install

   run the app:
     $ DEBUG=firstApplication:* ./bin/www

进入 firstApplication 文件夹并使用下面的命令来安装 firstApplication 的依赖关系：

D:\yiibai_worksp\nodejs\firstApplication> npm install

将看到以下的输出：

debug@2.1.2 node_modules\debug
+-- ms@0.7.0

cookie-parser@1.3.4 node_modules\cookie-parser
+-- cookie-signature@1.0.6
+-- cookie@0.1.2

morgan@1.5.1 node_modules\morgan
+-- basic-auth@1.0.0
+-- depd@1.0.0
+-- on-finished@2.2.0 (ee-first@1.1.0)

serve-favicon@2.2.0 node_modules\serve-favicon
+-- ms@0.7.0
+-- fresh@0.2.4
+-- parseurl@1.3.0
+-- etag@1.5.1 (crc@3.2.1)

jade@1.9.2 node_modules\jade
+-- character-parser@1.2.1
+-- void-elements@2.0.1
+-- commander@2.6.0
+-- mkdirp@0.5.0 (minimist@0.0.8)
+-- transformers@2.1.0 (promise@2.0.0, css@1.0.8, uglify-js@2.2.5)
+-- with@4.0.1 (acorn-globals@1.0.2, acorn@0.11.0)
+-- constantinople@3.0.1 (acorn-globals@1.0.2)

express@4.12.2 node_modules\express
+-- merge-descriptors@1.0.0
+-- cookie-signature@1.0.6
+-- methods@1.1.1
+-- cookie@0.1.2
+-- fresh@0.2.4
+-- utils-merge@1.0.0
+-- range-parser@1.0.2
+-- escape-html@1.0.1
+-- parseurl@1.3.0
+-- vary@1.0.0
+-- content-type@1.0.1
+-- finalhandler@0.3.3
+-- serve-static@1.9.1
+-- content-disposition@0.5.0
+-- path-to-regexp@0.1.3
+-- depd@1.0.0
+-- qs@2.3.3
+-- on-finished@2.2.0 (ee-first@1.1.0)
+-- etag@1.5.1 (crc@3.2.1)
+-- proxy-addr@1.0.6 (forwarded@0.1.0, ipaddr.js@0.1.8)
+-- send@0.12.1 (destroy@1.0.3, ms@0.7.0, mime@1.3.4)
+-- accepts@1.2.4 (negotiator@0.5.1, mime-types@2.0.9)
+-- type-is@1.6.0 (media-typer@0.3.0, mime-types@2.0.9)

body-parser@1.12.0 node_modules\body-parser
+-- content-type@1.0.1
+-- bytes@1.0.0
+-- raw-body@1.3.3
+-- depd@1.0.0
+-- qs@2.3.3
+-- iconv-lite@0.4.7
+-- on-finished@2.2.0 (ee-first@1.1.0)
+-- type-is@1.6.0 (media-typer@0.3.0, mime-types@2.0.9)

在这里，express生成器创建了一个完整的应用程序结构，可以验证在 firstApplication 文件夹中（Nodejs_WorkSpace文件夹下面）里创建的文件夹/文件：

.
+-- app.js
+-- bin
|   +-- www
+-- package.json
+-- public
|   +-- images
|   +-- javascripts
|   +-- stylesheets
|       +-- style.css
+-- routes
|   +-- index.js
|   +-- users.js
+-- views
    +-- error.jade
    +-- index.jade
    +-- layout.jade

• package.json 是应用程序描述符文件包含在依赖项列表中，应用程序使用 Node 的其他属性

• app.js 包含了服务器的初始化代码

• bin是用于存储在生产模式下的应用程序

• public用于存储图像，样式表和JavaScript文件

• routes 包含路由处理程序

• views 包含HTML模板来生成Web应用各种视图

第一个应用程序

app.js 是基于 express 的应用核心引擎。让我们更新默认app.js包括端口信息，并使用它来创建一个服务器。添加以下行到app.js ：

//set the server port
app.set('port', process.env.PORT || 3000);

//create the server
http.createServer(app).listen(app.get('port'), function(){
  console.log('Express server listening on port ' + app.get('port'));
});

更新 app.js

以下是app.js文件的全部内容

更新 app.js 文件的内容在 D:\>yiibai_worksp\nodejs\firstApplication.

File: app.js

var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var http = require('http');

var routes = require('./routes/index');
var users = require('./routes/users');

var app = express();

// view engine setup
app.set('port', process.env.PORT || 8891);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);
app.use('/users', users);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
   var err = new Error('Not Found');
   err.status = 404;
   next(err);
});

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
   app.use(function(err, req, res, next) {
      res.status(err.status || 500);
      res.render('error', {
         message: err.message,
         error: err
      });
   });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
   res.status(err.status || 500);
   res.render('error', {
      message: err.message,
      error: {}
   });
});

http.createServer(app).listen(app.get('port'), function(){
  console.log('Express server listening on port ' + app.get('port'));
});

module.exports = app;

现在运行app.js看到的结果：

D:\yiibai_worksp\firstApplication>node app

验证输出，服务器已经启动

Express server listening on port 8891

发出一个请求到firstApplication

在浏览器打开网址：http://localhost:8891/，看看下面的结果：

再次在浏览器打开网址：http://localhost:8891/users，看看下面的结果：

基本的路由

在app.js下面的代码绑定两个Route处理。

var routes = require('./routes/index');
var users = require('./routes/users');
...
app.use('/', routes);
app.use('/users', users);

• routes - 路由(index.js), 路由处理程序处理所有请求，主页发出通过 localhost:8891

• users - users (users.js), 路由处理来处理所有发出的请求 /users 通过 localhost:3000/users

以下是对应折代码：D:\>yiibai_worksp\nodejs\firstApplication\routes\index.js是由express生成器创建。

var express = require('express');
var router = express.Router();

/* GET home page. */
router.get('/', function(req, res, next) {
  res.render('index', { title: 'Express' });
});

module.exports = router;

当Node服务器接收到一个主页的请求，express路由器渲染索引页是使用模板index.jade同时传递参数title的值为'Express'。以下是模板代码内容：D:\>yiibai_worksp\nodejs\firstApplication\views\index.jade

extends layout

block content
  h1= title
  p Welcome to #{title}

Node.js - 加强第一个应用程序

概述

在这篇文章中，我们将加强Express第一个应用程序，创建 Express JS 应用程序：

• 显示所有用户的列表

• 显示一个特定的用户的细节

• 添加新的用户的详细信息

第1步：创建一个基于JSON数据库

首先，让我们创建一个用户示例JSON基础数据库。

创建一个名为 user.json 在一个 JSON 文件于 D:\>yiibai_worksp\nodejs\firstApplication

File: user.json

{
   "user1" : {
      "name" : "mahesh",
	  "password" : "password1",
	  "profession" : "teacher"
   },
   "user2" : {
      "name" : "suresh",
	  "password" : "password2",
	  "profession" : "librarian"
   },
   "user3" : {
      "name" : "newuser",
	  "password" : "password3",
	  "profession" : "clerk"
   }
}

第2步：创建特定的用户Jade视图

在创建一个 user 目录在 D:\>yiibai_worksp\node\firstApplication\views 如下视图：index.jade - 查看显示所有用户的列表。

• new.jade - 视图显示一个表单来添加一个新用户。

• profile.jade - 查看显示的用户的细节

创建一个index.jade在 D:\>yiibai_worksp\nodejs\firstApplication\views\users.

File: index.jade

h1 Users

p
   a(href="/users/new/") Create new user
ul
   - for (var username in users) {
   li
      a(href="/users/" + encodeURIComponent(username))= users[username].name
   - };

创建一个文件 new.jade 在 D:\>yiibai_worksp\nodejs\firstApplication\views\users.

File: new.jade

h1 New User

form(method="POST" action="/Users/addUser")
	P
		label(for="name") Name

		input#name(name="name")
	P
		label(for="password") Password

		input#name(name="password")
	P
		label(for="profession") Profession

		input#name(name="profession")
	P
		input(type="submit", value="Create")

创建一个文件 profile.jade 在 D:\>yiibai_worksp\nodejs\firstApplication\views\users.

File: profile.jade

h1 Name: #{user.name}

h2 Profession: #{user.profession}

第3步：更新用户路由处理 users.js

更新文件 users.js 在 D:\>yiibai_worksp\nodejs\firstApplication\routes.

File: users.js

var express = require('express');
var router = express.Router();

var users = require('../users.json');
/* GET users listing. */
router.get('/', function(req, res) {
   res.render('users/index', { title: 'Users',users:users });
});

/* Get form to add a new user*/
router.get('/new', function(req, res) {
   res.render('users/new', { title: 'New User'});
});

/* Get detail of a new user */
router.get('/:name', function(req, res, next) {
   var user = users[req.params.name]
   if(user){
      res.render('users/profile', { title: 'User Profile', user:user});
   }else{
      next();
   }
});

/* post the form to add new user */
router.post('/addUser', function(req, res, next) {
   if(users[req.body.name]){
      res.send('Conflict', 409);
   }else{
     users[req.body.name] = req.body;
	 res.redirect('/users/');
   }
});

module.exports = router;

现在运行app.js看到的结果：

D:\yiibai_worksp\nodejs\firstApplication>node app

验证输出，服务器已经启动

Express server listening on port 3000

发出请求到firstApplication得到所有用户的列表。在浏览器打开网址：http://localhost:8891/users，看看下面的结果。

点击创建新的用户链接看到表单。

提交表单并查看更新列表。

点击查看用户的详细。

可以检查服务器状态如下：

D:\yiibai_worksp\nodejs\firstApplication>node app
Express server listening on port 3000
GET /users/ 200 809.161 ms - 201
GET /users/new/ 304 101.627 ms - -
GET /users/new/ 304 33.496 ms - -
POST /Users/addUser 302 56.206 ms - 70
GET /users/ 200 43.548 ms - 245
GET /users/naresh 200 12.313 ms - 47

Node.js - Restful API

什么是REST架构？

REST表示代表状态传输。REST是基于Web标准的体系结构并使用HTTP协议。它围绕着资源，其中每一个组件是资源，资源是由一个共同的接口使用HTTP的标准方法获得。REST首先是由Roy Fielding在2000年推出。

在REST架构中，REST服务器只是提供获取资源，REST客户端访问和修改的资源。这里每个资源由URI标识的/全局ID。REST使用不同方式表示资源，如文本，JSON，XML。 JSON是最流行的一种。

HTTP 方法

以下四个HTTP方法通常用在基于的REST架构。

• GET - 提供资源的只读访问

• PUT - 用于创建一个新的资源

• DELETE - 用于删除资源

• POST - 用于更新现有的一个资源或创建新的资源

RESTful Web服务介绍

Web服务是用于交换应用程序或系统之间的数据开放的协议和标准的集合。写在各种编程语言的软件应用， 并在各种平台上运行可以使用Web服务以类似的进程间通信的方式在一台计算机上，通过计算机网络交换数据，如互联网。这种互操作性（如Java和Python，或Windows和Linux应用程序之间），是由于使用了开放标准。

基于REST架构的Web服务称为RESTful Web服务。这些Web服务使用HTTP方法来实现REST架构的概念。RESTful Web服务通常定义的URI，统一资源标识符的服务，提供资源的表示，如JSON，并设置HTTP方法。

为一个库创建RESTful

现在，我们将加强express示例应用程序，以下创建一个Web服务来用户管理：

Sr. No.	URI	HTTP 方法	POST body	结果
1	/users/	GET	empty	显示所有用户的列表
2	/users/addUser	POST	JSON String	添加新的用户的详细信息
3	/users/:id	GET	empty	用户的查看详细

获取所有用户信息

首先，让我们更新用户的样本基于JSON的数据库。

更新JSON文件名为user.json在 D:\>yiibai_worksp\nodejs\firstApplication.

File: user.json

{
   "user1" : {
      "name" : "mahesh",
	  "password" : "password1",
	  "profession" : "teacher",
	  "id": 1
   },
   "user2" : {
      "name" : "suresh",
	  "password" : "password2",
	  "profession" : "librarian",
	  "id": 2
   },
   "user3" : {
      "name" : "ramesh",
	  "password" : "password3",
	  "profession" : "clerk",
	  "id": 3
   }
}

当客户端发送GET请求/用户，服务器应该发送一个包含所有用户的响应。更新用户的路由处理，users.js

更新 users.js 在 D:\>yiibai_worksp\nodejs\firstApplication\routes.

File: users.js

/* GET users listing. */
router.get('/', function(req, res) {
   res.send({ title: 'Users',users:users });
});

添加新的用户的详细信息

当客户端发送一个POST请求 /users/addUser 包含JSON字符串，服务器应该发送一个响应声明状态。更新用户的路由处理users.js

更新 users.js 在 D:\>Nodejs_WorkSpace\firstApplication\routes.

File: users.js

/*add a user*/
router.post('/addUser', function(req, res, next) {
    var body = '';
    req.on('data', function (data) {
        body += data;
    });
    req.on('end', function () {
	   var json = JSON.parse(body);
       users["user"+json.id] = body;
	   res.send({ Message: 'User Added'});
    });
});

显示新用户的详细信息

当客户端发送GET请求到/users并带有id，服务器响应返回包含该用户的详细信息。更新用户的路由处理程序：users.js

更新 users.js 在 D:\>yiibai_worksp\nodejs\firstApplication\routes，如下：

File: users.js

router.get('/:id', function(req, res, next) {
   var user = users["user" + req.params.id]
   if(user){
      res.send({ title: 'User Profile', user:user});
   }else{
      res.send({ Message: 'User not present'});
   }
});

完整的users.js 代码

File: users.js

var express = require('express');
var router = express.Router();

var users = require('../users.json');
/* GET users listing. */
router.get('/', function(req, res) {
   res.send({ title: 'Users',users:users });
});

router.get('/:id', function(req, res, next) {
   console.log(req.params)
   var user = users["user" + req.params.id]
   if(user){
      res.send({ title: 'User Profile', user:user});
   }else{
      res.send({ Message: 'User not present'});
   }
});

router.post('/addUser', function(req, res, next) {
    var body = '';
    req.on('data', function (data) {
        body += data;
    });
    req.on('end', function () {
	   var json = JSON.parse(body);
       users["user"+json.id] = body;
	   res.send({ Message: 'User Added'});
    });
});

module.exports = router;

输出

我们使用一个Chrome浏览器的扫插件：Postman, 来测试我们编写的 webservices，安装Postman需要到以下网址下载（可能需要FQ）：https://chrome.google.com/webstore/detail/postman-interceptor/aicmkgpgakddgnaphhhpliifpcfhicfo 安装好这个插件后，打开后显示如下图：

现在运行app.js看到的结果：

D:\yiibai_worksp\nodejs\firstApplication> node app

验证输出。服务器已经启动

Express server listening on port 8891

提出一个请求到firstApplication获取所有用户的信息列表。把 http://localhost:8891/users 到POSTMAN 地址栏中，并使用GET请求，看到下面的结果。

发出一个请求到 firstApplication 以添加一个新用户。把 http://localhost:8891/users/addUser 放入到POSTMAN中并使用POST方式提交，看看下面的结果。

添加JSON数据格式，并选择POST方法。

{"name":"rakesh","password":"password4","profession":"teacher","id":5}

发出一个请求 firstApplication 获得用户。把 http://localhost:8891/users/1 在POSTMAN中找打开并用GET请求，看看下面的结果。

Node.js - 缩放应用

Node是在单线程模式下运行，它使用事件驱动的模式来处理并发。它还有助于创建子进程来利用并行处理在多核CPU的系统。

子进程始终有三个流child.stdin，child.stdout和child.stderr ，可以与父进程共享标准输入输出流。它们能够通过一个单独的流对象管道输送。

主要有三种方法来创建子进程。

• exec - child_process.exec方法在shell/控制台运行一个命令并缓冲输出。

• spawn - child_process.spawn由给定的命令启动一个新的进程

• fork - child_process.fork方法是spawn() 创建Node进程的一个特例。

exec() 方法

child_process.exec方法在shell运行一个命令并缓冲输出。它签名如下：

child_process.exec(command[, options], callback)

• command String要运行的命令，用空格分隔参数

• options 对象

  • cwd 当前工作目录子进程的字符串

  • env 对象环境键值对

  • encoding 字符串（缺省：'utf8'')

  • shell 字符串Shell来执行（默认命令：在UNIX上在“/bin/sh”，在Windows为cmd.exe“，在shell中应该知道在Windows或UNIX/S/C-c开关。在Windows中，命令行解析应与cmd.exe兼容）

  • timeout 数字（默认值: 0）

  • maxBuffer 数字(默认值: 200*1024)

  • killSignal 字符串(默认值: 'SIGTERM')

  • uid 数字设置进程的用户身份

  • gid 数字设置进程的组标识

• callback 当进程终止函数调用输出

  • error Error

  • stdout Buffer

  • stderr Buffer

• Return:ChildProcess对象

exec() 返回一个缓冲器的最大尺寸，并等待该进程结束，并试图在一次返回所有缓冲的数据

示例

创建两个JS文件名为worker.js和master.js在 D:\>yiibai_worksp\nodejs

File: worker.js

console.log("Child Process "+ process.argv[2] +" executed." );

File: master.js

const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
   var workerProcess = child_process.exec('node worker.js '+i,
      function (error, stdout, stderr) {
         if (error) {
            console.log(error.stack);
            console.log('Error code: '+error.code);
            console.log('Signal received: '+error.signal);
         }
         console.log('stdout: ' + stdout);
         console.log('stderr: ' + stderr);
      });

      workerProcess.on('exit', function (code) {
      console.log('Child process exited with exit code '+code);
   });
}

现在运行master.js看到的结果：

D:\yiibai_worksp\nodejs> node master.js

验证输出。服务器已经启动

Child process exited with exit code 0
stdout: Child Process 1 executed.

stderr:
Child process exited with exit code 0
stdout: Child Process 0 executed.

stderr:
Child process exited with exit code 0
stdout: Child Process 2 executed.

spawn() 方法

child_process.spawn方法由给定的命令启动一个新的进程。它具有以下签名

child_process.spawn(command[, args][, options])

• command 字符串 - 要运行的命令

• args 字符串参数数组列表

• options 对象

  • cwd 当前工作目录子进程的字符串

  • env 对象环境键值对

  • stdio 数组|子字符串的标准输入输出配置

  • customFds Array不推荐文件描述符由子进程使用标准输入输出

  • detached boolean值 - 子进程是一个进程组头进程

  • uid 数字设置进程的用户身份

  • gid Number设置进程的组标识

• Return: ChildProcess对象

spawn() 返回流（标准输出与标准错误），并会使用当该过程返回大数据量。spawn()即开始接收到响应进程开始执行。

示例

创建两个JS文件名为worker.js和master.js在  D:\>yiibai_worksp\nodejs

File: worker.js

console.log("Child Process "+ process.argv[2] +" executed." );

File: master.js

const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
   var workerProcess = child_process.spawn('node', ['worker.js', i]);

   workerProcess.stdout.on('data', function (data) {
      console.log('stdout: ' + data);
   });

   workerProcess.stderr.on('data', function (data) {
      console.log('stderr: ' + data);
   });

   workerProcess.on('close', function (code) {
      console.log('child process exited with code ' + code);
   });
}

现在运行master.js看到的结果：

D:\yiibai_worksp\nodejs> node master.js

验证输出。服务器已经启动

stdout: Child Process 0 executed.

child process exited with code 0
stdout: Child Process 2 executed.

child process exited with code 0
stdout: Child Process 1 executed.

child process exited with code 0

fork 方法

child_process.fork方法是spawn() 的一个特例用来创建Node进程。它具有以下签名

child_process.fork(modulePath[, args][, options])

• modulePath 字符串- 模块运行所在的子进程

• args 字符串参数数组列表

• options 对象

  • cwd 当前工作目录子进程的字符串

  • env 对象环境键值对

  • execPath 字符串可执行用于创建子进程

  • execArgv 传递给程序的可执行字符串参数数组列表（默认值：process.execArgv）

  • silent Boolean如果为true，stdin, stdout, 和 stderr 的标准错误将被输送到父进程，否则它们将继承自父，详情参见“管道”和“继承” 选项spawn()的标准输入输出（默认为false）

  • uid 数字设置进程的用户身份

  • gid 数字设置进程的组标识

• Return: ChildProcess 对象

fork返回对象有内置的通信信道，除了具有正常的ChildProcess实例的所有方法。

示例

创建两个JS文件名为 worker.js 和 master.js 在 D:\>yiibai_worksp\nodejs

File: worker.js

console.log("Child Process "+ process.argv[2] +" executed." );

File: master.js

const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
   var worker_process = child_process.fork("worker.js", [i]);	

   worker_process.on('close', function (code) {
      console.log('child process exited with code ' + code);
   });
}

现在运行master.js看到的结果：

D:\yiibai_worksp> node master.js

验证输出。服务器已经启动

Child Process 0 executed.
Child Process 1 executed.
Child Process 2 executed.
child process exited with code 0
child process exited with code 0
child process exited with code 0