Node.js 工具模块

在 Node.js 模块库中有很多好用的模块。接下来我们为大家介绍几种常用模块的使用：

OS 模块

os 模块提供了一些基本的系统操作函数。我们可以通过以下方式引入该模块：

os 模块提供了一些基本属性

var os = require("os")
console.log('endianness : ' + os.endianness()) // CPU 的字节序
console.log('type : ' + os.type())             // 操作系统名
console.log('platform : ' + os.platform())     // 操作系统名
console.log('total memory : ' + os.totalmem() + " bytes.") // 系统内存总量
console.log('free memory : ' + os.freemem() + " bytes.")   // 操作系统空闲内存量
console.log(os.cpus())   // 操作系统空闲内存量
/*
endianness : LE
type : Darwin
platform : darwin
total memory : 8589934592 bytes.
free memory : 26660864 bytes.
[
  {
    model: 'Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz',
    speed: 1800,
    times: { user: 238620, nice: 0, sys: 149150, idle: 689960, irq: 0 }
  },
  {
    model: 'Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz',
    speed: 1800,
    times: { user: 48830, nice: 0, sys: 22970, idle: 1004680, irq: 0 }
  },
  ...
]
*/

Path 模块

path 模块提供了一些用于处理文件路径的小工具，我们可以通过以下方式引入该模块：

var path = require("path")

方法

序号	方法 & 描述
1	path.normalize(p) 规范化路径，注意’..’ 和 ‘.’。
2	path.join([path1][, path2][, …]) 用于连接路径。该方法的主要用途在于，会正确使用当前系统的路径分隔符，Unix系统是”/“，Windows系统是”\“。
3	path.resolve([from …], to) 将 to 参数解析为绝对路径，给定的路径的序列是从右往左被处理的，后面每个 path 被依次解析，直到构造完成一个绝对路径。 例如，给定的路径片段的序列为：/foo、/bar、baz，则调用 path.resolve(‘/foo’, ‘/bar’, ‘baz’) 会返回 /bar/baz。
4	path.isAbsolute(path) 判断参数 path 是否是绝对路径。
5	path.relative(from, to) 用于将绝对路径转为相对路径，返回从 from 到 to 的相对路径（基于当前工作目录）。
6	path.dirname(p) 返回路径中代表文件夹的部分，同 Unix 的dirname 命令类似。
7	path.basename(p[, ext]) 返回路径中的最后一部分。同 Unix 命令 bashname 类似。
8	path.extname(p) 返回路径中文件的后缀名，即路径中最后一个’.’之后的部分。如果一个路径中并不包含’.’或该路径只包含一个’.’ 且这个’.’为路径的第一个字符，则此命令返回空字符串。
9	path.parse(pathString) 返回路径字符串的对象。
10	path.format(pathObject) 从对象中返回路径字符串，和 path.parse 相反。

属性

创建 main.js 文件，代码如下所示：

var path = require("path")
console.log('normalization : ' + path.normalize('/test/test1//2slashes/1slash/tab/..')) // 格式化路径
console.log('joint path : ' + path.join('/test', 'test1', '2slashes/1slash', 'tab', '..')) // 连接路径
console.log('resolve : ' + path.resolve('main.js')) // 转换为绝对路径
console.log('resolve : ' + path.resolve(__dirname, "..", 'main.js')) // 转换为绝对路径
console.log('resolve : ' + path.resolve(__dirname, 'main.js')) // 转换为绝对路径
console.log('ext name : ' + path.extname('main.js')) // 路径中文件的后缀名
/*
normalization : /test/test1/2slashes/1slash
joint path : /test/test1/2slashes/1slash
resolve : /Users/ken/yx-taro/main.js
resolve : /Users/ken/yx-taro/main.js
resolve : /Users/ken/yx-taro/config/main.js
ext name : .js
*/

path.join()和path.resolve()区别

// path.join()和path.resolve()区别 就是两个路径的拼接的API
// 示例在 E: \web\test\abc.js 里面写：
let path = require("path")
let join1 = path.join(__dirname, '/static/js')  // 输出 E: \web\test\static\js
let join2 = path.join(__dirname, './static/js') // 输出 E: \web\test\static\js
let join3 = path.join('/file', 'static')        // 输出 file\static
// path.resolve() 中的 / 会被解析为根目录
let resolve1 = path.resolve('/test', '/static/js') // 输出 E: \static\js
let resolve2 = path.resolve('/test', './static/js')  //输出 E: \test\static\js

Net 模块

Net 模块提供了一些用于底层的网络通信的小工具，包含了创建服务器/客户端的方法，我们可以通过以下方式引入该模块：

var net = require("net")

方法

net.Server

net.Server通常用于创建一个 TCP 或本地服务器。

事件

net.Socket

net.Socket 对象是 TCP 或 UNIX Socket 的抽象。net.Socket 实例实现了一个双工流接口。 他们可以在用户创建客户端(使用 connect())时使用, 或者由 Node 创建它们，并通过 connection 服务器事件传递给用户。

net.Socket 事件有：

net.Socket 提供了很多有用的属性，便于控制 socket 交互：

方法

实例

创建 server.js 文件，代码如下所示：

var net = require('net')
var server = net.createServer(function (connection) {
  console.log('client connected')
  connection.on('end', function () {
    console.log('客户端关闭连接')
  })
  connection.on('data', function (data) {
    console.log(data.toString())
    //  server.close()
    //异步获取服务器当前活跃连接的数量
    server.getConnections(function (err, count) {
      console.log(`异步获取服务器当前活跃连接的数量: ${count}`);
    })
  })
  connection.write('Hello World!\r\n')
  // connection.pipe(connection)
  console.log(connection.address())
})
server.listen(8080, function () {
  console.log('server is listening')
})

新开一个窗口，创建 client.js 文件，代码如下所示：

var net = require('net')
var client = net.connect({ port: 8080 }, function () {
  console.log('连接到服务器！')
})
client.on('data', function (data) {
  console.log(data.toString())
})
client.write("客户端给你发送消息")
// client.end()
client.on('end', function () {
  console.log('断开与服务器的连接')
})

执行以上服务端的代码：

server is listening
client connected
客户端关闭连接

执行以上客户端的代码：

连接到服务器！
Hello World!
断开与服务器的连接

DNS 模块

DNS 模块用于解析域名。引入 DNS 模块语法格式如下

var dns = require("dns")

rrtypes

以下列出了 dns.resolve() 方法中有效的 rrtypes值:

• ‘A’ IPV4 地址, 默认
• ‘AAAA’ IPV6 地址
• ‘MX’ 邮件交换记录
• ‘TXT’ text 记录
• ‘SRV’ SRV 记录
• ‘PTR’ 用来反向 IP 查找
• ‘NS’ 域名服务器记录
• ‘CNAME’ 别名记录
• ‘SOA’ 授权记录的初始值

错误码

每次 DNS 查询都可能返回以下错误码：

• dns.NODATA: 无数据响应。
• dns.FORMERR: 查询格式错误。
• dns.SERVFAIL: 常规失败。
• dns.NOTFOUND: 没有找到域名。
• dns.NOTIMP: 未实现请求的操作。
• dns.REFUSED: 拒绝查询。
• dns.BADQUERY: 查询格式错误。
• dns.BADNAME: 域名格式错误。
• dns.BADFAMILY: 地址协议不支持。
• dns.BADRESP: 回复格式错误。
• dns.CONNREFUSED: 无法连接到 DNS 服务器。
• dns.TIMEOUT: 连接 DNS 服务器超时。
• dns.EOF: 文件末端。
• dns.FILE: 读文件错误。
• dns.NOMEM: 内存溢出。
• dns.DESTRUCTION: 通道被摧毁。
• dns.BADSTR: 字符串格式错误。
• dns.BADFLAGS: 非法标识符。
• dns.NONAME: 所给主机不是数字。
• dns.BADHINTS: 非法HINTS标识符。
• dns.NOTINITIALIZED: c c-ares 库尚未初始化。
• dns.LOADIPHLPAPI: 加载 iphlpapi.dll 出错。
• dns.ADDRGETNETWORKPARAMS: 无法找到 GetNetworkParams 函数。
• dns.CANCELLED: 取消 DNS 查询。

实例

创建 main.js 文件，代码如下所示：

var dns = require('dns')
dns.lookup('www.github.com', function onLookup(err, address, family) {
  if (err) { console.log(err.stack) }
  console.log('ip 地址:', address)
  dns.reverse(address, function (err, hostnames) {
    console.log('反向解析 ' + address + ': ' + JSON.stringify(hostnames))
  })
})
dns.resolve("www.github.com", "A", function (err, address, aa) {
  console.log(address);
})
/*
ip 地址: 20.205.243.166
[ '20.205.243.166' ]
反向解析 20.205.243.166: ["www.github.com"]
*/

Domain 模块

Domain(域) 简化异步代码的异常处理，可以捕捉处理try catch无法捕捉的异常。引入 Domain 模块 语法格式如下：

var domain = require("domain")

domain模块，把处理多个不同的IO的操作作为一个组。注册事件和回调到domain，当发生一个错误事件或抛出一个错误时，domain对象会被通知，不会丢失上下文环境，也不导致程序错误立即退出，与process.on(‘uncaughtException’)不同。
Domain 模块可分为隐式绑定和显式绑定：

• 隐式绑定: 把在domain上下文中定义的变量，自动绑定到domain对象
• 显式绑定: 把不是在domain上下文中定义的变量，以代码的方式绑定到domain对象

方法

属性

创建 main.js 文件，代码如下所示：

var EventEmitter = require("events").EventEmitter
var domain = require("domain")
var emitter1 = new EventEmitter()
var domain1 = domain.create() // 创建域
domain1.add(emitter1) // 显式绑定
domain1.on('error', function (err) {
  console.log("domain1 处理这个错误 => (" + err.message + ")")
})
emitter1.on('error', function (err) {
  console.log("监听器处理此错误 => (" + err.message + ")")
})
emitter1.emit('error', new Error('通过监听器来处理'))
emitter1.removeAllListeners('error')
emitter1.emit('error', new Error('通过 domain1 处理'))
/* 
domain1.remove(emitter1)
emitter1.emit('error', new Error('转换为异常，系统将崩溃!'))
events.js:72
        throw er; // Unhandled 'error' event
              ^
Error: 转换为异常，系统将崩溃!
    at Object.<anonymous> (/www/node/main.js:40:24)
    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 
*/
var domain2 = domain.create()
domain2.on('error', function (err) {
  console.log("domain2 处理这个错误 => (" + err.message + ")")
})
// 隐式绑定
domain2.run(function () {
  var emitter2 = new EventEmitter()
  emitter2.emit('error', new Error('通过 domain2 处理'))
})
/*
监听器处理此错误 => (通过监听器来处理)
domain1 处理这个错误 => (通过 domain1 处理)
domain2 处理这个错误 => (通过 domain2 处理)
*/