前端之node.js内置模块

Node.js内置了许多常用的模块，它们可以直接在应用程序中使用，无需额外安装。以下是一些常用的Node.js内置模块的介绍：

1. fs模块：提供了文件系统相关的功能，可以进行文件的读写、复制、删除等操作。

2. path模块：用于处理文件路径的相关操作，例如获取文件名、扩展名，拼接路径等。

3. http模块：用于创建HTTP服务器和客户端，可以处理HTTP请求、响应以及路由等。

4. events模块：用于处理事件的模块，可以实现事件的注册、触发和监听等。

5. os模块：提供了与操作系统相关的功能，可以获取操作系统的信息，如CPU架构、内存等。

6. querystring模块：用于解析和处理URL查询字符串。

7. util模块：提供了一些常用的工具函数，例如格式化字符串、对象继承等。

8. crypto模块：提供了一系列加密和解密的功能，包括哈希算法、对称加密、非对称加密等。

9. child_process模块：用于创建子进程，可以执行外部命令和脚本。

这些内置模块提供了基本的功能，可以帮助我们实现各种应用程序的需求。同时，Node.js还提供了许多其他功能丰富的模块，可以通过npm安装和引入使用。

1-内置模块-http模块-1

在Node.js中，http模块是内置的HTTP服务器和客户端功能模块。以下是一个使用http模块创建一个简单的HTTP服务器的例子：

server.js

// 导入内置的 http 模块
const http = require('http');

// 创建 HTTP 服务器，并提供请求处理函数
const server = http.createServer((req, res) => {
  // 设置响应头部信息
  res.setHeader('Content-Type', 'text/plain');
  
  // 发送响应数据
  res.end('Hello World from Node.js HTTP Server!\n');
});

// 设置服务器监听的端口号
const port = 3000;

// 开始监听指定端口上的连接请求
server.listen(port, () => {
  console.log(`Server running at http://localhost:${port}/`);
});

要运行这个服务器，保存上述代码到名为server.js的文件中，然后在命令行终端执行：

node server.js

此时，你将在控制台看到类似“Server running at http://localhost:3000/”的消息，表示服务器已经启动并在3000端口上等待请求。

当您在浏览器中访问 http://localhost:3000/ 或使用 curl 等工具发送请求时，服务器会返回 “Hello World from Node.js HTTP Server!” 的消息。

2-内置模块-http模块-2

除了创建HTTP服务器，http模块还可以用来发送HTTP请求。以下是一个使用http.request()方法发起GET请求的例子：

client.js

// 导入内置的 http 模块
const http = require('http');

// 定义要访问的URL和HTTP方法
const options = {
  hostname: 'example.com',
  port: 80, // 默认为80端口，可以不写
  path: '/api/data', // 请求路径
  method: 'GET' // 请求方法
};

// 创建并配置HTTP请求选项
const req = http.request(options, (res) => {
  let data = '';

  // 设置数据监听器
  res.on('data', (chunk) => {
    data += chunk;
  });

  // 当响应结束时处理完整数据
  res.on('end', () => {
    console.log(`Response status code: ${res.statusCode}`);
    console.log('Response body:', data);
  });
});

// 处理网络错误
req.on('error', (error) => {
  console.error(`Problem with request: ${error.message}`);
});

// 发送请求（对于GET请求可选，因为请求主体为空）
req.end();

在这个例子中，我们创建了一个HTTP GET请求到example.com/api/data。当接收到响应时，我们通过事件监听器收集所有数据片段，并在响应结束时打印出完整的响应体以及响应状态码。

请注意，实际应用中可能需要对响应头进行解析或处理不同的HTTP方法与内容类型。此外，在生产环境中，通常会使用更高级别的库如axios、node-fetch或request（已废弃）等来简化HTTP客户端操作。

3-内置模块-url模块

在Node.js中，url模块提供了处理和解析URL的功能。以下是一个使用url模块的例子：

解析URL

// 导入内置的 url 模块
const url = require('url');

// 假设有一个URL字符串
const myUrlString = 'http://user:pass@www.example.com:8080/path/to/myfile.html?query=string#hash';

// 使用 url.parse() 方法解析 URL（在 Node.js v10及更高版本中推荐使用 new URL() 构造函数）
const parsedUrl = url.parse(myUrlString);

console.log(parsedUrl);

输出结果将是一个对象，包含如下结构：

{
  protocol: 'http:',
  slashes: true,
  auth: 'user:pass',
  host: 'www.example.com:8080',
  port: '8080',
  hostname: 'www.example.com',
  hash: '#hash',
  search: '?query=string',
  query: 'query=string',
  pathname: '/path/to/myfile.html',
  path: '/path/to/myfile.html?query=string',
  href: 'http://user:pass@www.example.com:8080/path/to/myfile.html?query=string#hash'
}

从Node.js v10开始，官方推荐使用全局的URL构造函数来解析URL：

// 使用新的 URL 构造函数（适用于 Node.js v10 及更高版本）
const { URL } = require('url');
const myUrl = new URL(myUrlString);

console.log(myUrl);

这样可以获得与url.parse()相同的结果，但返回的是一个URL实例，可以直接访问属性而非通过键名。

console.log(myUrl.protocol); // 输出: 'http:'
console.log(myUrl.username); // 输出: 'user'
console.log(myUrl.password); // 输出: 'pass'
console.log(myUrl.host); // 输出: 'www.example.com:8080'
console.log(myUrl.hostname); // 输出: 'www.example.com'
console.log(myUrl.port); // 输出: '8080'
console.log(myUrl.pathname); // 输出: '/path/to/myfile.html'
console.log(myUrl.search); // 输出: '?query=string'
console.log(myUrl.hash); // 输出: '#hash'

4-内置模块-url模块新版用发

在Node.js v10及更高版本中，官方推荐使用全局的URL构造函数来处理和解析URL。以下是新版用法的例子：

// 导入URL类（在Node.js v10+版本中已内置）
const { URL } = require('url');

// 定义一个URL字符串
const myUrlString = 'https://user:pass@www.example.com:8080/path/to/myfile.html?query=string#hash';

// 使用URL构造函数解析URL
const myUrl = new URL(myUrlString);

console.log('Protocol:', myUrl.protocol);
console.log('Username:', myUrl.username);
console.log('Password:', myUrl.password);
console.log('Hostname:', myUrl.hostname);
console.log('Port:', myUrl.port);
console.log('Pathname:', myUrl.pathname);
console.log('Search (query string):', myUrl.search);
console.log('Hash:', myUrl.hash);

// 获取查询参数对象
console.log('Parsed query:', myUrl.searchParams);

// 也可以直接通过searchParams获取或设置查询参数
console.log('Query parameter "query":', myUrl.searchParams.get('query'));
myUrl.searchParams.set('newParam', 'newValue');
console.log('Updated URL:', myUrl.href);

输出结果如下：

Protocol: https:
Username: user
Password: pass
Hostname: www.example.com
Port: 8080
Pathname: /path/to/myfile.html
Search (query string): ?query=string
Hash: #hash
Parsed query: URLSearchParams {}
Query parameter "query": string
Updated URL: https://user:pass@www.example.com:8080/path/to/myfile.html?query=string&newParam=newValue#hash

在这个例子中，URL构造函数创建了一个可以读取和修改URL各个部分的对象，并提供了便捷的方法访问URL的每个组件，如协议、用户名、密码、主机名、端口、路径名、查询字符串以及哈希片段等。同时，还可以通过.searchParams属性获取和操作查询参数。

5-内置模块-querystring模块

在Node.js中，querystring模块用于处理URL查询字符串的解析和格式化。以下是一个使用querystring模块的例子：

解析查询字符串

// 导入querystring模块
const querystring = require('querystring');

// 假设有一个查询字符串
const queryString = 'name=John&age=30&city=New%20York';

// 使用querystring.parse()方法解析查询字符串
const parsedQueryString = querystring.parse(queryString);

console.log(parsedQueryString);

运行上述代码后，输出结果将是：

{
  name: 'John',
  age: '30',
  city: 'New York'
}

构建查询字符串

同时，我们也可以使用querystring.stringify()方法将对象转换为查询字符串：

const user = {
  name: 'John',
  age: 30,
  city: 'New York'
};

// 使用querystring.stringify()方法将对象转换为查询字符串
const stringifiedQueryString = querystring.stringify(user);

console.log(stringifiedQueryString);

运行上述代码后，输出结果将是：

"name=John&age=30&city=New%20York"

通过这种方式，querystring模块帮助我们轻松地处理URL中的查询参数部分。

6-内置模块-http模块-jsonp

Node.js内置的http模块本身并不直接支持JSONP（JSON with Padding）功能，因为JSONP主要用于解决浏览器端跨域请求的问题。然而，在服务器端，我们可以创建一个响应JSONP请求的服务端逻辑。以下是一个使用http模块模拟接收并响应JSONP请求的例子：

// 导入http模块
const http = require('http');

// 创建HTTP服务器
const server = http.createServer((req, res) => {
  // 检查请求查询参数中是否存在回调函数名（一般以 callback= 开头）
  const query = req.url.split('?')[1];
  const params = new URLSearchParams(query);
  const callbackName = params.get('callback'); 

  if (!callbackName) {
    res.writeHead(400, { 'Content-Type': 'text/plain' });
    return res.end('Invalid JSONP request. Callback parameter is missing.');
  }

  // 假设我们有一个数据对象要返回
  const data = { message: 'Hello from JSONP Server!' };

  // 构建JSONP响应字符串
  const jsonpResponse = `${callbackName}(${JSON.stringify(data)})`;

  // 设置响应头和内容类型
  res.setHeader('Content-Type', 'application/javascript');
  
  // 发送响应
  res.end(jsonpResponse);
});

// 启动服务器监听特定端口
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  console.log(`JSONP server is running on http://localhost:${PORT}`);
});

在这个例子中，当客户端发起一个带有callback查询参数的GET请求时，服务器将返回一个符合JSONP格式的JavaScript响应，即在回调函数名后包裹了JSON格式的数据。

请注意，实际应用中的JSONP服务通常会验证和处理错误，并确保安全性和兼容性。同时，现代浏览器推荐使用CORS（Cross-Origin Resource Sharing）来代替JSONP解决跨域问题。

7-内置模块-http模块-cors

Node.js内置的http模块本身并不直接支持CORS（Cross-Origin Resource Sharing）配置，但你可以使用中间件如cors来处理HTTP响应头以启用CORS。在Express框架中，通常会利用第三方中间件实现这个功能，例如 cors 包。

下面是一个使用Express和cors中间件的例子：

首先，确保已安装了cors包：

npm install cors

然后，在你的Express应用中设置cors：

// 导入所需的模块
const express = require('express');
const cors = require('cors');

// 创建Express应用
const app = express();

// 使用cors中间件全局启用CORS
app.use(cors());

// 假设你有一个API端点
app.get('/api/data', (req, res) => {
  res.json({ message: 'Hello from the API with CORS enabled!' });
});

// 启动服务器监听特定端口
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

在这个例子中，cors()函数调用没有传入任何选项，这意味着它将允许来自任何源的所有请求。如果你需要更精细地控制CORS策略，可以在调用中间件时传递配置对象：

app.use(cors({
  origin: ['http://example.com', 'https://other-example.com'], // 允许指定来源访问
  methods: ['GET', 'POST'], // 允许的方法
  allowedHeaders: ['Content-Type'], // 允许的自定义请求头
  credentials: true // 允许跨域携带cookie等凭据
}));

请注意，由于Node.js内置的http模块并未提供中间件机制，上述示例是基于Express框架进行的。如果你想在原生http模块创建的服务端应用中添加CORS支持，你需要手动设置响应头来实现CORS策略。

8-内置模块-http模块-get

在Node.js的内置http模块中，虽然没有直接提供发送HTTP GET请求的方法，但是可以使用http.request()方法配合GET方法来实现。以下是一个简单的例子，展示如何用http模块发送一个HTTP GET请求：

const http = require('http');

// 请求的目标URL和选项
const options = {
  hostname: 'example.com',
  port: 80,
  path: '/api/data',
  method: 'GET'
};

// 创建并配置请求对象
const req = http.request(options, (res) => {
  let data = '';

  // 设置数据监听器
  res.on('data', (chunk) => {
    data += chunk;
  });

  // 当响应结束时处理完整数据
  res.on('end', () => {
    console.log(`Response status code: ${res.statusCode}`);
    console.log('Response body:', data);
  });
});

// 处理网络错误
req.on('error', (error) => {
  console.error(`Problem with request: ${error.message}`);
});

// 发送请求（对于GET请求可选，因为请求主体为空）
req.end();

在这个示例中，我们创建了一个HTTP GET请求到example.com/api/data。当接收到响应时，我们将响应体内容的数据片段拼接起来，并在响应结束后打印出完整的响应体以及响应状态码。

注意：在实际应用中，通常会使用更高级别的库如axios、node-fetch或request（已废弃）等来简化HTTP客户端操作。上述示例仅为了说明如何使用原生http模块发送GET请求。

9-内置模块-http模块-post

在Node.js的内置http模块中，可以使用http.request()方法来发送HTTP POST请求。以下是一个简单的例子：

const http = require('http');
const querystring = require('querystring'); // 用于处理POST数据

// 请求的目标URL和选项
const options = {
  hostname: 'example.com',
  port: 80,
  path: '/api/data',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded'
  }
};

// 准备POST数据
const postData = querystring.stringify({
  key1: 'value1',
  key2: 'value2'
});

// 计算POST数据长度并添加到请求头中
options.headers['Content-Length'] = Buffer.byteLength(postData);

// 创建并配置请求对象
const req = http.request(options, (res) => {
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    console.log(`Response status code: ${res.statusCode}`);
    console.log('Response body:', data);
  });
});

// 处理网络错误
req.on('error', (error) => {
  console.error(`Problem with request: ${error.message}`);
});

// 写入POST数据
req.write(postData);

// 结束请求（对于POST请求是必需的）
req.end();

在这个示例中，我们向example.com/api/data发送了一个HTTP POST请求，并附带了表单编码的数据。注意，在实际应用中，如果需要发送JSON格式的数据，应将Content-Type设置为application/json，并将数据转换成JSON字符串。

另外，请确保服务器端能够正确处理这种类型的POST请求以及对应的Content-Type。同时，在生产环境中，通常会使用更高级别的库如axios、node-fetch或request（已废弃）等简化HTTP客户端操作。上述示例仅为了说明如何使用原生http模块发送POST请求。

10-内置模块-http模块-爬虫

在Node.js的内置http模块中，可以用来编写一个基础的HTTP爬虫。以下是一个简单的爬取网页HTML内容的例子：

const http = require('http');

// 目标URL
const targetUrl = 'http://example.com';

// 发送GET请求
http.get(targetUrl, (res) => {
  // 建立响应体收集器
  let data = '';

  // 设置数据监听器，将接收到的数据片段拼接起来
  res.on('data', (chunk) => {
    data += chunk;
  });

  // 当响应结束时处理完整数据
  res.on('end', () => {
    console.log('Response body:', data);

    // 对于HTML内容，你可能需要使用如cheerio或jsdom这样的库来解析和提取信息
    // 这里仅打印原始HTML响应内容
  });

}).on('error', (err) => {
  console.error(`Problem with request: ${err.message}`);
});

上述代码示例向指定的targetUrl发送了一个HTTP GET请求，并接收并打印了服务器返回的HTML内容。但请注意，这只是一个非常基础的爬虫，它没有对获取到的内容进行任何进一步的处理。

如果要从HTML中提取有用的信息，你需要引入额外的DOM解析库，例如Cheerio（适用于简单的HTML解析）或jsdom（对于更复杂的DOM操作）。以下是一个添加了Cheerio库后提取标题标签（<title>）的例子：

首先，安装Cheerio：

npm install cheerio

然后，在Node.js脚本中使用Cheerio：

const http = require('http');
const cheerio = require('cheerio');

// ... 网页请求部分同上 ...

// 当响应结束时处理完整数据
res.on('end', () => {
  const $ = cheerio.load(data); // 使用Cheerio加载HTML字符串

  // 提取<title>标签的内容
  const title = $('title').text();
  console.log('Page Title:', title);
});

通过这种方式，你可以构建一个基础的HTTP爬虫来抓取网页内容并进行简单分析。然而，在实际开发中，还需要考虑更多的因素，如错误处理、重试机制、延迟限制以避免被目标网站封禁等。同时，对于更复杂的情况，可能需要使用更高级别的爬虫框架如Puppeteer或者axios搭配Cheerio等。

11-内置模块-event模块

在Node.js中，events模块是一个内置的核心模块，它提供了一个简单的事件触发机制。以下是一个使用events模块创建自定义事件和监听器的例子：

const events = require('events');

// 创建一个EventEmitter实例
class MyEmitter extends events.EventEmitter {}

const myEmitter = new MyEmitter();

// 添加事件监听器
myEmitter.on('event', (arg1, arg2) => {
  console.log('An event was emitted:', arg1, arg2);
});

// 触发事件
myEmitter.emit('event', 'First argument', 'Second argument');

// 输出：An event was emitted: First argument Second argument

在这个例子中，我们首先继承了events.EventEmitter类创建了一个名为MyEmitter的自定义事件发射器。然后，我们给这个发射器添加了一个监听名为event的事件的监听器。当通过emit方法触发该事件时，相应的监听器会被调用，并打印出传入的参数。

另外，events模块也提供了其他一些方法，如once用于仅监听一次事件，removeListener用于移除指定的事件监听器等。

12-内置模块-fs文件操作模块-1

在Node.js中，fs模块提供了文件系统操作的功能。以下是一个使用fs模块读取文件内容的例子：

const fs = require('fs');

// 读取文件的异步版本（推荐）
fs.readFile('/path/to/your/file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error(`Error reading file: ${err}`);
    return;
  }
  
  console.log('File content:', data);
});

// 或者同步版本（在某些场景下使用，但不建议用于IO密集型操作，因为它会阻塞程序执行）
try {
  const data = fs.readFileSync('/path/to/your/file.txt', 'utf8');
  console.log('File content:', data);
} catch (err) {
  console.error(`Error reading file: ${err}`);
}

在这个例子中，我们分别演示了如何以异步和同步的方式读取一个文本文件的内容。异步版本通过回调函数处理读取完成后的结果或错误；而同步版本直接返回文件内容，如果出现错误，则抛出异常。

请注意，在实际应用中，通常更推荐使用异步版本，因为它们不会阻塞事件循环，从而允许Node.js应用程序保持非阻塞I/O特性。

13-内置模块-fs文件操作模块-2

除了读取文件，Node.js的内置fs模块还提供了写入文件的功能。以下是一个使用fs模块写入文件内容的例子：

const fs = require('fs');

// 写入文件的异步版本（推荐）
const contentToWrite = 'Hello, World!';
fs.writeFile('/path/to/your/newfile.txt', contentToWrite, 'utf8', (err) => {
  if (err) {
    console.error(`Error writing file: ${err}`);
    return;
  }
  
  console.log('File written successfully!');
});

// 或者同步版本（在某些场景下使用，但不建议用于IO密集型操作，因为它会阻塞程序执行）
try {
  const contentToWrite = 'Hello, World!';
  fs.writeFileSync('/path/to/your/newfile.txt', contentToWrite, 'utf8');
  console.log('File written successfully!');
} catch (err) {
  console.error(`Error writing file: ${err}`);
}

在这个例子中，我们分别演示了如何以异步和同步的方式将文本内容写入一个新的或已存在的文件中。异步版本通过回调函数处理写入完成后的结果或错误；而同步版本直接执行写入操作，并在发生错误时抛出异常。

同样地，在实际应用中，特别是对于长时间运行且需要保持高响应性的服务，更推荐使用异步版本进行文件操作。

14-内置模块-stream流模块

Node.js的内置stream模块提供了一种处理数据流的方式，可以高效地处理大量数据。以下是一个使用fs.createReadStream()和fs.createWriteStream()创建文件读写流的例子：

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

// 创建一个读取文件的可读流（ReadStream）
const readStream = fs.createReadStream(path.join(__dirname, 'input.txt'), 'utf8');

// 创建一个写入文件的可写流（WriteStream）
const writeStream = fs.createWriteStream(path.join(__dirname, 'output.txt'), { flags: 'w' });

// 当读取流的数据可用时，将数据从读取流管道到写入流
readStream.pipe(writeStream);

// 监听错误事件
readStream.on('error', (err) => {
  console.error(`Error reading file: ${err}`);
});

writeStream.on('error', (err) => {
  console.error(`Error writing file: ${err}`);
});

// 当所有数据被成功写入时触发事件
writeStream.on('finish', () => {
  console.log('File copied successfully!');
});

在这个例子中，我们创建了一个从input.txt读取内容的可读流，并将其通过.pipe()方法连接到了一个将内容写入output.txt的可写流。这样，当读取流接收到数据时，会自动传输给写入流，实现文件复制功能。同时，我们也监听了错误和完成事件，以便在发生错误或操作完成后执行相应的处理。

15-内置模块-zlib模块

Node.js的内置zlib模块提供了对数据进行压缩和解压的支持，如gzip、deflate和inflate等。以下是一个使用zlib模块对文本内容进行压缩（gzip）和解压的例子：

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

// 压缩数据
let content = 'Hello, World! This is some sample text to compress.';

// 将字符串转换为Buffer对象
const bufferToCompress = Buffer.from(content);

// 创建一个用于压缩的Gzip流
const gzip = zlib.createGzip();

// 创建一个可读流和一个可写流，用来读取原始数据和接收压缩后的数据
const source = fs.createReadStream(null, { autoClose: false });
const destination = fs.createWriteStream('./compressed.txt.gz', { flags: 'w' });

// 将源数据通过gzip流管道到目标文件
source.pipe(gzip).pipe(destination);

// 从内存中直接将Buffer对象写入源流
source.end(bufferToCompress);

// 等待写入完成
destination.on('finish', () => {
  console.log('Compression complete.');

  // 解压数据
  const gunzip = zlib.createGunzip();
  const decompressedFileStream = fs.createReadStream('./compressed.txt.gz');
  const uncompressedFileStream = fs.createWriteStream('./decompressed.txt');

  decompressedFileStream.pipe(gunzip).pipe(uncompressedFileStream);

  // 等待解压并写入完成
  uncompressedFileStream.on('finish', () => {
    console.log('Decompression complete.');
  });
});

这个例子首先创建了一个Gzip压缩流，并将文本内容压缩至一个.gz文件中。接着，它又创建了一个Gunzip解压流来解压刚才生成的压缩文件，并将解压后的内容写入一个新的文本文件中。

注意，在实际应用中，你可能不需要先写入内存然后再传递给流，而是可以直接从一个文件读取并压缩，或者将压缩流直接输出到响应流中（在HTTP服务端场景）。本例为了演示方便，采用了内存中的Buffer对象。

16-内置模块-crypto模块

Node.js的内置crypto模块提供了加密、解密、哈希生成等密码学功能。以下是一个使用crypto模块生成SHA-256哈希值的例子：

const crypto = require('crypto');

// 需要被哈希化的明文字符串
const dataToHash = 'This is a secret message!';

// 创建一个HMAC实例，使用SHA-256算法和一个密钥
const secretKey = 'my-secret-key';
const hash = crypto.createHmac('sha256', secretKey);

// 更新HMAC实例的数据
hash.update(dataToHash);

// 生成并输出最终的哈希摘要（这里以十六进制形式）
const hashInHex = hash.digest('hex');
console.log(`The SHA-256 HMAC of the message is: ${hashInHex}`);

此外，如果想生成一个纯SHA-256散列（不涉及密钥），可以使用如下代码：

const crypto = require('crypto');

// 要计算哈希的文本
const dataToHash = 'This is another secret message.';

// 创建一个SHA-256 Hash实例
const sha256Hash = crypto.createHash('sha256');

// 将数据更新到Hash实例中
sha256Hash.update(dataToHash);

// 计算哈希摘要并转换为十六进制格式
const hashInHex = sha256Hash.digest('hex');
console.log(`The SHA-256 hash of the message is: ${hashInHex}`);

上述例子展示了如何使用crypto模块创建哈希摘要，一个是使用HMAC（带有密钥的哈希消息认证码），另一个是直接生成数据的SHA-256散列值。
最后求点赞，求分享，求抱抱…