Node.js 如何实现文件的复制与移动

Node.js 基础知识回顾

在深入探讨文件复制与移动之前，先来简单回顾一下Node.js的一些基础知识。Node.js是一个基于Chrome V8引擎的JavaScript运行时，它让JavaScript能够在服务器端运行。Node.js采用事件驱动、非阻塞I/O模型，使其非常适合构建高并发、高性能的网络应用。

Node.js有一个丰富的标准库，其中fs（文件系统）模块是我们操作文件的核心。fs模块提供了一系列方法来处理文件和目录，包括读取、写入、复制、移动等操作。这个模块既有同步操作方法，也有异步操作方法。同步方法会阻塞程序的执行，直到操作完成，而异步方法则不会阻塞，它们通过回调函数或者Promise来处理操作的结果。

文件复制

使用 `fs.createReadStream` 和 `fs.createWriteStream`

在Node.js中，实现文件复制最常见的方式是使用fs.createReadStream和fs.createWriteStream。这两个方法分别用于创建可读流和可写流。

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

const sourceFilePath = path.join(__dirname, 'original.txt');
const destinationFilePath = path.join(__dirname, 'copy.txt');

const readStream = fs.createReadStream(sourceFilePath);
const writeStream = fs.createWriteStream(destinationFilePath);

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');
});

在上述代码中：

首先引入了fs和path模块。path模块用于处理文件路径，以确保代码在不同操作系统上都能正确运行。
定义了源文件路径sourceFilePath和目标文件路径destinationFilePath。
使用fs.createReadStream创建了一个可读流readStream，用于读取源文件。
使用fs.createWriteStream创建了一个可写流writeStream，用于写入目标文件。
通过pipe方法将可读流和可写流连接起来。pipe方法会自动处理数据的流动，将可读流中的数据读取并写入到可写流中。
为readStream和writeStream添加了error事件监听器，以便在读取或写入过程中出现错误时能够捕获并处理错误。
为writeStream添加了finish事件监听器，当写入操作完成时，会触发该事件并打印出“File copied successfully”。

处理大文件

上述方法对于大文件的复制非常高效，因为流是逐块处理数据的，而不是一次性将整个文件读入内存。这大大减少了内存的使用，避免了因大文件导致的内存溢出问题。

同步复制

除了异步方式，fs模块也提供了同步的文件复制方法。虽然同步方法会阻塞程序执行，但在某些场景下，比如需要确保文件复制完成后再继续执行后续代码时，同步方法会很有用。

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

const sourceFilePath = path.join(__dirname, 'original.txt');
const destinationFilePath = path.join(__dirname, 'copy.txt');

try {
  fs.copyFileSync(sourceFilePath, destinationFilePath);
  console.log('File copied successfully');
} catch (err) {
  console.error('Error copying file:', err);
}

在这段代码中，使用fs.copyFileSync方法进行文件的同步复制。try - catch块用于捕获可能发生的错误。如果复制成功，会打印“File copied successfully”；如果出现错误，会打印错误信息。

文件移动

简单文件移动（重命名）

在Node.js中，文件移动可以通过重命名文件来实现。fs.rename方法可以用于重命名文件或移动文件到另一个目录。

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

const sourceFilePath = path.join(__dirname, 'original.txt');
const destinationFilePath = path.join(__dirname, 'newLocation', 'original.txt');

fs.rename(sourceFilePath, destinationFilePath, (err) => {
  if (err) {
    console.error('Error moving file:', err);
  } else {
    console.log('File moved successfully');
  }
});

在上述代码中：

同样引入了fs和path模块。
定义了源文件路径sourceFilePath和目标文件路径destinationFilePath。目标路径指定了一个新的目录newLocation，这实际上就是将文件移动到了新的位置。
使用fs.rename方法进行文件移动。该方法是异步的，通过回调函数来处理操作结果。如果移动过程中出现错误，会在控制台打印错误信息；如果移动成功，会打印“File moved successfully”。

同步文件移动（重命名）

类似于文件复制，fs模块也提供了同步的文件移动（重命名）方法。

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

const sourceFilePath = path.join(__dirname, 'original.txt');
const destinationFilePath = path.join(__dirname, 'newLocation', 'original.txt');

try {
  fs.renameSync(sourceFilePath, destinationFilePath);
  console.log('File moved successfully');
} catch (err) {
  console.error('Error moving file:', err);
}

这里使用fs.renameSync方法进行同步的文件移动。try - catch块用于捕获可能发生的错误。如果移动成功，会打印“File moved successfully”；如果出现错误，会打印错误信息。

跨设备移动文件

当需要跨设备（比如从一个硬盘移动到另一个硬盘）移动文件时，简单的重命名方法就不再适用。这时需要先复制文件，然后删除源文件。

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

const sourceFilePath = path.join(__dirname, 'original.txt');
const destinationFilePath = path.join('/anotherDrive/newLocation', 'original.txt');

function copyAndDelete() {
  const readStream = fs.createReadStream(sourceFilePath);
  const writeStream = fs.createWriteStream(destinationFilePath);

  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', () => {
    fs.unlink(sourceFilePath, (err) => {
      if (err) {
        console.error('Error deleting source file:', err);
      } else {
        console.log('File moved successfully (across devices)');
      }
    });
  });
}

copyAndDelete();

在这段代码中：

首先通过fs.createReadStream和fs.createWriteStream将源文件复制到目标位置。
当复制完成（writeStream触发finish事件）后，使用fs.unlink方法删除源文件。fs.unlink方法用于删除文件，同样有异步和同步版本，这里使用的是异步版本。如果删除过程中出现错误，会打印错误信息；如果成功删除，会打印“File moved successfully (across devices)”。

错误处理

在文件复制和移动操作中，错误处理非常重要。以下是一些常见的错误情况及其处理方式：

文件不存在

无论是复制还是移动文件，如果源文件不存在，相关操作会失败。在异步操作中，错误会通过回调函数传递；在同步操作中，会抛出异常。

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

const nonExistentSourceFilePath = path.join(__dirname, 'nonExistent.txt');
const destinationFilePath = path.join(__dirname, 'copy.txt');

fs.copyFile(nonExistentSourceFilePath, destinationFilePath, (err) => {
  if (err && err.code === 'ENOENT') {
    console.error('Source file does not exist');
  } else {
    console.error('Other error:', err);
  }
});

在上述代码中，通过检查err.code是否为ENOENT来判断源文件是否不存在。如果是，打印“Source file does not exist”；否则，打印其他错误信息。

权限问题

如果没有足够的权限来读取、写入或删除文件，操作也会失败。在异步操作中，错误会通过回调函数传递；在同步操作中，会抛出异常。

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

const sourceFilePath = path.join(__dirname, 'original.txt');
const destinationFilePath = path.join('/protectedFolder', 'copy.txt');

fs.copyFile(sourceFilePath, destinationFilePath, (err) => {
  if (err && err.code === 'EACCES') {
    console.error('Permission denied');
  } else {
    console.error('Other error:', err);
  }
});

这里通过检查err.code是否为EACCES来判断是否是权限问题。如果是，打印“Permission denied”；否则，打印其他错误信息。

高级应用场景

批量文件复制与移动

在实际开发中，经常需要批量处理文件，比如将一个目录下的所有文件复制或移动到另一个目录。

const fs = require('fs');
const path = require('path');
const { promisify } = require('util');

const readdir = promisify(fs.readdir);
const copyFile = promisify(fs.copyFile);
const rename = promisify(fs.rename);

async function batchCopy(sourceDir, destinationDir) {
  try {
    const files = await readdir(sourceDir);
    for (const file of files) {
      const sourceFilePath = path.join(sourceDir, file);
      const destinationFilePath = path.join(destinationDir, file);
      await copyFile(sourceFilePath, destinationFilePath);
    }
    console.log('Batch copy completed');
  } catch (err) {
    console.error('Error in batch copy:', err);
  }
}

async function batchMove(sourceDir, destinationDir) {
  try {
    const files = await readdir(sourceDir);
    for (const file of files) {
      const sourceFilePath = path.join(sourceDir, file);
      const destinationFilePath = path.join(destinationDir, file);
      await rename(sourceFilePath, destinationFilePath);
    }
    console.log('Batch move completed');
  } catch (err) {
    console.error('Error in batch move:', err);
  }
}

const sourceDirectory = path.join(__dirname,'source');
const destinationDirectory = path.join(__dirname, 'destination');

batchCopy(sourceDirectory, destinationDirectory);
batchMove(sourceDirectory, destinationDirectory);

在上述代码中：

使用promisify将fs.readdir、fs.copyFile和fs.rename方法转换为Promise形式，以便在async函数中使用await。
定义了batchCopy和batchMove两个async函数。batchCopy函数先读取源目录中的所有文件，然后逐个将文件复制到目标目录；batchMove函数则是将文件逐个移动到目标目录。
最后调用这两个函数，实现批量复制和移动操作。如果操作过程中出现错误，会在控制台打印错误信息。

按文件类型筛选复制与移动

有时候，我们只需要复制或移动特定类型的文件，比如只复制所有的.txt文件。

const fs = require('fs');
const path = require('path');
const { promisify } = require('util');

const readdir = promisify(fs.readdir);
const copyFile = promisify(fs.copyFile);
const rename = promisify(fs.rename);

async function copyTxtFiles(sourceDir, destinationDir) {
  try {
    const files = await readdir(sourceDir);
    for (const file of files) {
      if (path.extname(file) === '.txt') {
        const sourceFilePath = path.join(sourceDir, file);
        const destinationFilePath = path.join(destinationDir, file);
        await copyFile(sourceFilePath, destinationFilePath);
      }
    }
    console.log('Copy of.txt files completed');
  } catch (err) {
    console.error('Error in copying.txt files:', err);
  }
}

async function moveTxtFiles(sourceDir, destinationDir) {
  try {
    const files = await readdir(sourceDir);
    for (const file of files) {
      if (path.extname(file) === '.txt') {
        const sourceFilePath = path.join(sourceDir, file);
        const destinationFilePath = path.join(destinationDir, file);
        await rename(sourceFilePath, destinationFilePath);
      }
    }
    console.log('Move of.txt files completed');
  } catch (err) {
    console.error('Error in moving.txt files:', err);
  }
}

const sourceDirectory = path.join(__dirname,'source');
const destinationDirectory = path.join(__dirname, 'destination');

copyTxtFiles(sourceDirectory, destinationDirectory);
moveTxtFiles(sourceDirectory, destinationDirectory);

在这段代码中：

同样使用promisify将相关方法转换为Promise形式。
定义了copyTxtFiles和moveTxtFiles两个async函数。在函数内部，通过path.extname方法获取文件扩展名，判断是否为.txt文件。如果是，则进行复制或移动操作。
最后调用这两个函数，实现按文件类型筛选复制和移动操作。如果操作过程中出现错误，会在控制台打印错误信息。

性能优化

缓冲区大小调整

在使用fs.createReadStream和fs.createWriteStream进行文件复制时，可以通过调整缓冲区大小来优化性能。默认情况下，缓冲区大小为64KB。

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

const sourceFilePath = path.join(__dirname, 'largeFile.txt');
const destinationFilePath = path.join(__dirname, 'copyLargeFile.txt');

const readStream = fs.createReadStream(sourceFilePath, { highWaterMark: 1024 * 1024 });
const writeStream = fs.createWriteStream(destinationFilePath, { highWaterMark: 1024 * 1024 });

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');
});

在上述代码中，将highWaterMark设置为1MB（1024 * 1024字节）。较大的缓冲区大小可以减少I/O操作的次数，但也会占用更多的内存。需要根据实际情况，如文件大小、系统内存等，来调整缓冲区大小以获得最佳性能。

并发控制

在批量复制或移动文件时，如果同时处理过多的文件，可能会导致系统资源耗尽。可以通过控制并发数来优化性能。

const fs = require('fs');
const path = require('path');
const { promisify } = require('util');
const Queue = require('p-queue');

const readdir = promisify(fs.readdir);
const copyFile = promisify(fs.copyFile);

const queue = new Queue({ concurrency: 5 });

async function batchCopyWithConcurrency(sourceDir, destinationDir) {
  try {
    const files = await readdir(sourceDir);
    for (const file of files) {
      queue.add(async () => {
        const sourceFilePath = path.join(sourceDir, file);
        const destinationFilePath = path.join(destinationDir, file);
        await copyFile(sourceFilePath, destinationFilePath);
      });
    }
    await queue.onIdle();
    console.log('Batch copy with concurrency completed');
  } catch (err) {
    console.error('Error in batch copy with concurrency:', err);
  }
}

const sourceDirectory = path.join(__dirname,'source');
const destinationDirectory = path.join(__dirname, 'destination');

batchCopyWithConcurrency(sourceDirectory, destinationDirectory);

在这段代码中：

使用了p-queue库来控制并发数。通过Queue构造函数创建了一个队列，并将并发数设置为5，即同时最多处理5个文件的复制操作。
在batchCopyWithConcurrency函数中，将每个文件的复制任务添加到队列中。queue.onIdle()方法用于等待队列中的所有任务完成。
这样可以有效地控制系统资源的使用，避免因过多并发操作导致的性能问题。

与其他技术结合

与 Express 结合

在Web应用开发中，可能需要在服务器端处理文件的复制和移动。Express是一个流行的Node.js Web应用框架，可以很方便地与文件操作结合。

const express = require('express');
const fs = require('fs');
const path = require('path');
const app = express();
const port = 3000;

app.get('/copyFile', (req, res) => {
  const sourceFilePath = path.join(__dirname, 'original.txt');
  const destinationFilePath = path.join(__dirname, 'copy.txt');

  fs.copyFile(sourceFilePath, destinationFilePath, (err) => {
    if (err) {
      res.status(500).send('Error copying file');
    } else {
      res.send('File copied successfully');
    }
  });
});

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

在上述代码中：

创建了一个Express应用，并监听3000端口。
定义了一个/copyFile路由，当客户端访问该路由时，会执行文件复制操作。如果复制成功，返回“File copied successfully”；如果出现错误，返回“Error copying file”并设置状态码为500。

与数据库结合

在一些场景下，文件的复制和移动可能与数据库操作相关联。比如，在上传文件后，将文件的相关信息（如文件名、路径等）存储到数据库中，同时可能需要根据数据库中的记录来移动文件。

假设使用sqlite3数据库：

const sqlite3 = require('sqlite3').verbose();
const fs = require('fs');
const path = require('path');

const db = new sqlite3.Database('file.db');

function moveFileBasedOnDbRecord() {
  db.get('SELECT source_path, destination_path FROM files WHERE id =?', [1], (err, row) => {
    if (err) {
      console.error('Error querying database:', err);
      return;
    }
    const sourceFilePath = path.join(__dirname, row.source_path);
    const destinationFilePath = path.join(__dirname, row.destination_path);

    fs.rename(sourceFilePath, destinationFilePath, (err) => {
      if (err) {
        console.error('Error moving file:', err);
      } else {
        console.log('File moved successfully based on database record');
      }
    });
  });
}

moveFileBasedOnDbRecord();

db.close();

在这段代码中：

首先引入了sqlite3模块并创建了一个数据库实例。
定义了moveFileBasedOnDbRecord函数，该函数从数据库中查询文件的源路径和目标路径，然后根据查询结果移动文件。
调用moveFileBasedOnDbRecord函数执行文件移动操作，并在操作完成后关闭数据库连接。

通过以上详细的介绍和代码示例，相信你对Node.js中文件的复制与移动操作有了全面而深入的理解。无论是简单的单个文件操作，还是复杂的批量处理、性能优化以及与其他技术的结合，Node.js都提供了丰富的工具和方法来满足各种需求。在实际应用中，需要根据具体场景选择合适的方法，并注意错误处理和性能优化，以确保程序的稳定性和高效性。

Node.js 如何实现文件的复制与移动

Node.js 基础知识回顾

文件复制

使用 fs.createReadStream 和 fs.createWriteStream

处理大文件

同步复制

文件移动

简单文件移动（重命名）

同步文件移动（重命名）

跨设备移动文件

错误处理

文件不存在

权限问题

高级应用场景

批量文件复制与移动

按文件类型筛选复制与移动

性能优化

缓冲区大小调整

并发控制

与其他技术结合

与 Express 结合

与数据库结合

使用 `fs.createReadStream` 和 `fs.createWriteStream`