Node.js复习合集曙光博客-随笔小窝曙光博客

Node.js 的 fs 模块用于与文件系统进行交互。通过 fs 模块，您可以对文件进行读取、写入、删除、重命名等操作。以下是 fs 模块的一些主要功能和示例代码。

1. 引入 `fs` 模块

在使用 fs 模块之前，需要先将其引入：

const fs = require('fs');

2. 读取文件

fs 模块提供了同步和异步两种方式来读取文件。

异步读取文件

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});

在这个例子中，fs.readFile 异步读取文件 example.txt。回调函数中，如果读取成功，data 参数将包含文件内容。

同步读取文件

try {
  const data = fs.readFileSync('example.txt', 'utf8');
  console.log(data);
} catch (err) {
  console.error(err);
}

fs.readFileSync 同步读取文件，读取结果会立即返回，如果发生错误，会抛出异常，需要通过 try...catch 捕获。

3. 写入文件

fs 模块也提供了异步和同步两种方式来写入文件。

异步写入文件

const content = 'This is some content to write to the file.';
fs.writeFile('example.txt', content, err => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('File has been written');
});

fs.writeFile 异步写入文件 example.txt，如果文件不存在会创建新文件。

同步写入文件

const content = 'This is some content to write to the file.';
try {
  fs.writeFileSync('example.txt', content);
  console.log('File has been written');
} catch (err) {
  console.error(err);
}

fs.writeFileSync 同步写入文件，会立即写入并返回，发生错误时抛出异常。

4. 追加内容到文件

有时我们需要在文件末尾追加内容，fs 提供了 appendFile 和 appendFileSync 方法。

异步追加内容

const additionalContent = '\nThis content will be appended to the file.';
fs.appendFile('example.txt', additionalContent, err => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('Content has been appended');
});

同步追加内容

const additionalContent = '\nThis content will be appended to the file.';
try {
  fs.appendFileSync('example.txt', additionalContent);
  console.log('Content has been appended');
} catch (err) {
  console.error(err);
}

5. 删除文件

删除文件可以使用 unlink 和 unlinkSync 方法。

异步删除文件

fs.unlink('example.txt', err => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('File has been deleted');
});

同步删除文件

try {
  fs.unlinkSync('example.txt');
  console.log('File has been deleted');
} catch (err) {
  console.error(err);
}

6. 创建目录

fs 模块提供了 mkdir 和 mkdirSync 方法来创建目录。

异步创建目录

fs.mkdir('exampleDir', { recursive: true }, err => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('Directory has been created');
});

在这个例子中，{ recursive: true } 选项表示如果父目录不存在会自动创建。

同步创建目录

try {
  fs.mkdirSync('exampleDir', { recursive: true });
  console.log('Directory has been created');
} catch (err) {
  console.error(err);
}

7. 读取目录内容

读取目录内容可以使用 readdir 和 readdirSync 方法。

异步读取目录内容

fs.readdir('exampleDir', (err, files) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(files);
});

同步读取目录内容

try {
  const files = fs.readdirSync('exampleDir');
  console.log(files);
} catch (err) {
  console.error(err);
}

8. 重命名文件或目录

fs 模块提供了 rename 和 renameSync 方法来重命名文件或目录。

异步重命名

fs.rename('oldName.txt', 'newName.txt', err => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('File has been renamed');
});

同步重命名

try {
  fs.renameSync('oldName.txt', 'newName.txt');
  console.log('File has been renamed');
} catch (err) {
  console.error(err);
}

总结

Node.js 的 fs 模块提供了丰富的文件系统操作功能，包括文件和目录的读取、写入、追加、删除、重命名等操作。无论是异步操作还是同步操作，都可以满足不同的使用需求。通过学习和实践这些方法，可以高效地进行文件系统操作。

Node.js 的 path 模块提供了一系列实用工具，用于处理和转换文件路径。path 模块是 Node.js 核心模块之一，不需要额外安装。

引入 `path` 模块

在使用 path 模块之前，需要先将其引入：

const path = require('path');

1. `path.basename(path, [ext])`

path.basename 方法返回路径的最后一部分，可以选择去掉文件扩展名。

const filePath = '/home/user/dir/file.txt';

// 获取文件名（带扩展名）
const baseNameWithExt = path.basename(filePath);
console.log(baseNameWithExt); // 输出: 'file.txt'

// 获取文件名（不带扩展名）
const baseNameWithoutExt = path.basename(filePath, '.txt');
console.log(baseNameWithoutExt); // 输出: 'file'

2. `path.dirname(path)`

path.dirname 方法返回路径的目录部分。

const filePath = '/home/user/dir/file.txt';
const dirName = path.dirname(filePath);
console.log(dirName); // 输出: '/home/user/dir'

3. `path.extname(path)`

path.extname 方法返回路径中文件的扩展名。

const filePath = '/home/user/dir/file.txt';
const extName = path.extname(filePath);
console.log(extName); // 输出: '.txt'

4. `path.join([...paths])`

path.join 方法将多个路径片段拼接成一个完整的路径。

const joinedPath = path.join('/home', 'user', 'dir', 'file.txt');
console.log(joinedPath); // 输出: '/home/user/dir/file.txt'

它也会规范化路径，去除多余的斜杠。

const joinedPath = path.join('/home//user/', 'dir', 'file.txt');
console.log(joinedPath); // 输出: '/home/user/dir/file.txt'

5. `path.resolve([...paths])`

path.resolve 方法将路径或路径片段解析为绝对路径。

const absolutePath = path.resolve('dir/file.txt');
console.log(absolutePath); // 输出: '/当前工作目录/dir/file.txt'

如果传入的路径片段中包含绝对路径，则之前的路径片段会被忽略。

const absolutePath = path.resolve('/home/user', 'dir', 'file.txt');
console.log(absolutePath); // 输出: '/home/user/dir/file.txt'

6. `path.normalize(path)`

path.normalize 方法规范化给定的路径，处理诸如 .. 和 . 的片段。

const normalizedPath = path.normalize('/home//user/../dir/file.txt');
console.log(normalizedPath); // 输出: '/home/dir/file.txt'

7. `path.isAbsolute(path)`

path.isAbsolute 方法判断给定的路径是否为绝对路径。

console.log(path.isAbsolute('/home/user/dir/file.txt')); // 输出: true
console.log(path.isAbsolute('home/user/dir/file.txt'));  // 输出: false

8. `path.relative(from, to)`

path.relative 方法根据当前目录的路径，返回从一个路径到另一个路径的相对路径。

const fromPath = '/home/user/dir';
const toPath = '/home/user/dir/subdir/file.txt';
const relativePath = path.relative(fromPath, toPath);
console.log(relativePath); // 输出: 'subdir/file.txt'

9. `path.parse(path)`

path.parse 方法返回一个对象，包含路径的各个部分。

const filePath = '/home/user/dir/file.txt';
const parsedPath = path.parse(filePath);
console.log(parsedPath);
/* 输出:
{
  root: '/',
  dir: '/home/user/dir',
  base: 'file.txt',
  ext: '.txt',
  name: 'file'
}
*/

10. `path.format(pathObject)`

path.format 方法与 path.parse 相反，接受一个对象格式的路径，返回一个字符串路径。

const pathObject = {
  root: '/',
  dir: '/home/user/dir',
  base: 'file.txt',
  ext: '.txt',
  name: 'file'
};
const formattedPath = path.format(pathObject);
console.log(formattedPath); // 输出: '/home/user/dir/file.txt'

11. `path.sep`

path.sep 属性提供平台特定的路径片段分隔符：

POSIX (Linux/macOS): /
Windows: \\

console.log(path.sep); // 在 POSIX 系统上输出: '/'，在 Windows 上输出: '\\'

12. `path.delimiter`

path.delimiter 属性提供平台特定的路径分隔符：

POSIX (Linux/macOS): :
Windows: ;

console.log(path.delimiter); // 在 POSIX 系统上输出: ':'，在 Windows 上输出: ';'

综合示例

以下示例综合使用了多个 path 模块的方法，展示如何构建和解析路径。

const path = require('path');

// 构建路径
const dirPath = path.join(__dirname, 'src', 'modules');
const filePath = path.join(dirPath, 'app.js');
console.log('Directory Path:', dirPath);
console.log('File Path:', filePath);

// 解析路径
const parsedPath = path.parse(filePath);
console.log('Parsed Path:', parsedPath);

// 判断路径是否为绝对路径
console.log('Is Absolute:', path.isAbsolute(filePath));

// 获取路径的目录名、基础名和扩展名
console.log('Directory Name:', path.dirname(filePath));
console.log('Base Name:', path.basename(filePath));
console.log('Extension Name:', path.extname(filePath));

// 规范化路径
const messyPath = '/home//user/../dir/file.txt';
const normalizedPath = path.normalize(messyPath);
console.log('Normalized Path:', normalizedPath);

// 获取相对路径
const relativePath = path.relative('/home/user/dir', '/home/user/dir/subdir/file.txt');
console.log('Relative Path:', relativePath);

// 构建路径字符串
const pathObject = {
  root: '/',
  dir: '/home/user/dir',
  base: 'file.txt',
  ext: '.txt',
  name: 'file'
};
const formattedPath = path.format(pathObject);
console.log('Formatted Path:', formattedPath);

// 获取路径分隔符
console.log('Path Separator:', path.sep);

// 获取路径分隔符
console.log('Path Delimiter:', path.delimiter);

通过上述示例和解释，您可以全面了解 Node.js path 模块的功能和用法。该模块在处理文件路径时非常有用，可以帮助您编写更健壮和跨平台的代码。

Node.js 的 http 模块是构建 Web 服务器和处理 HTTP 请求与响应的核心模块。它提供了创建 HTTP 服务器和客户端的功能。以下是对 http 模块的详细介绍和代码示例。

1. 引入 `http` 模块

在使用 http 模块之前，需要先将其引入：

const http = require('http');

2. 创建 HTTP 服务器

创建一个基本的 HTTP 服务器：

const http = require('http');

// 创建服务器
const server = http.createServer((req, res) => {
  // 设置响应头
  res.writeHead(200, {'Content-Type': 'text/plain'});
  // 发送响应内容
  res.end('Hello, World!\n');
});

// 服务器监听端口
server.listen(3000, '127.0.0.1', () => {
  console.log('Server running at http://127.0.0.1:3000/');
});

上述代码创建了一个简单的 HTTP 服务器，监听 127.0.0.1 上的 3000 端口。当访问此服务器时，它会返回 “Hello, World!”。

3. 处理 HTTP 请求

HTTP 服务器可以处理不同的请求方法和 URL：

const http = require('http');

// 创建服务器
const server = http.createServer((req, res) => {
  if (req.method === 'GET' && req.url === '/') {
    // 处理 GET 请求到根路径
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Welcome to the Home Page!\n');
  } else if (req.method === 'GET' && req.url === '/about') {
    // 处理 GET 请求到 /about 路径
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Welcome to the About Page!\n');
  } else {
    // 处理未定义的请求
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.end('Page Not Found\n');
  }
});

// 服务器监听端口
server.listen(3000, '127.0.0.1', () => {
  console.log('Server running at http://127.0.0.1:3000/');
});

这个服务器根据不同的 URL 处理不同的请求，并返回相应的响应。

4. 处理 POST 请求

处理 POST 请求时，我们需要从请求主体中读取数据：

const http = require('http');

// 创建服务器
const server = http.createServer((req, res) => {
  if (req.method === 'POST' && req.url === '/submit') {
    let body = '';

    // 监听 data 事件获取数据
    req.on('data', chunk => {
      body += chunk.toString();
    });

    // 监听 end 事件处理完成的请求
    req.on('end', () => {
      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end(`Received data: ${body}\n`);
    });
  } else {
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.end('Page Not Found\n');
  }
});

// 服务器监听端口
server.listen(3000, '127.0.0.1', () => {
  console.log('Server running at http://127.0.0.1:3000/');
});

这个服务器会在 /submit 路径上处理 POST 请求，并将接收到的数据返回给客户端。

5. 创建 HTTP 客户端

Node.js 的 http 模块还可以用来发起 HTTP 请求，充当客户端。

const http = require('http');

// 选项参数
const options = {
  hostname: 'www.example.com',
  port: 80,
  path: '/',
  method: 'GET'
};

// 创建请求
const req = http.request(options, res => {
  console.log(`STATUS: ${res.statusCode}`);
  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);

  // 设置编码
  res.setEncoding('utf8');

  // 监听 data 事件获取响应数据
  res.on('data', chunk => {
    console.log(`BODY: ${chunk}`);
  });

  // 监听 end 事件
  res.on('end', () => {
    console.log('No more data in response.');
  });
});

// 监听 error 事件
req.on('error', e => {
  console.error(`Problem with request: ${e.message}`);
});

// 结束请求
req.end();

这个客户端代码发起一个 GET 请求到 www.example.com，并打印响应状态、头信息和主体内容。

6. 使用 `http` 模块的高级特性

http 模块还提供了许多高级特性，比如使用 http.Agent 管理 HTTP 连接池。

使用 HTTP 代理

const http = require('http');

// 创建代理服务器
const proxy = http.createServer((req, res) => {
  const options = {
    hostname: 'www.example.com',
    port: 80,
    path: req.url,
    method: req.method,
    headers: req.headers
  };

  // 发起代理请求
  const proxyReq = http.request(options, proxyRes => {
    res.writeHead(proxyRes.statusCode, proxyRes.headers);
    proxyRes.pipe(res, {
      end: true
    });
  });

  req.pipe(proxyReq, {
    end: true
  });
});

// 代理服务器监听端口
proxy.listen(3000, '127.0.0.1', () => {
  console.log('Proxy server running at http://127.0.0.1:3000/');
});

这个代理服务器将所有请求转发到 www.example.com，并返回响应。

总结

Node.js 的 http 模块功能强大，可以用来构建各种 Web 服务器和客户端。以下是 http 模块的一些主要功能和示例代码：

创建 HTTP 服务器
处理 HTTP 请求方法和 URL
处理 POST 请求
创建 HTTP 客户端
使用高级特性如代理服务器

通过学习和实践这些示例，可以熟练掌握 Node.js http 模块的基本和高级用法。

文章版权声明 1、本网站名称：曙光博客
2、本站永久网址：pqblog.com
3、本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长QQ86512进行删除处理。
4、本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5、本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6、本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

THE END