node大文件拷贝优化（显示进度）

smallzip2025-06-09 18:14

前言

在electron项目中，拷贝大文件时，如果不考虑显示进度情况， 直接使用 fs.cp 函数通常会有更好的性能，原因如下：

  1. 底层优化 ： fs.cp （Node.js v16.7.0+）是官方提供的高层API，底层实现会根据操作系统自动选择最优的复制方式（如 copy_file_range 、 sendfile 等），通常比手动用 fs.createReadStream 和 fs.createWriteStream 实现的流式复制更快。

  2. 更少的JavaScript开销 ： fs.cp 大部分操作在C++层完成，减少了JavaScript层的数据调度和事件监听的开销。

  3. 简化代码 ： fs.cp 用法简单，出错点更少。

小结： 绝大多数场景下， fs.cp 会比流式复制更快，尤其是大文件或大量小文件时。

但是我们的场景需要显示拷贝的进度，所以只能通过创建可读写、可写流来监听拷贝的进度。

初始版本

Typescript 复制代码 
/**
 * 复制文件并显示进度
 *
 * @param src 源文件路径
 * @param dest 目标文件路径
 * @param callback 进度回调函数，参数为进度百分比（保留两位小数），可选
 * @returns 返回一个Promise，成功时resolve为true，失败时reject为错误对象
 */
export async function copyFileWithProgress(src: string, dest: string, callback?: (progress: number, total: number, loaded: number) => void): Promise<string> {
  const stat = await fs.promises.stat(src);
  const totalSize = stat.size;
  let copiedSize = 0;
  const isShowProgress = !!callback // 是否显示进度

  return new Promise((resolve, reject) => {
    const readStream = fs.createReadStream(src);
    const writeStream = fs.createWriteStream(dest);

    if (isShowProgress) {
      readStream.on('data', (chunk) => {
        copiedSize += chunk.length;
        const progress = (copiedSize / totalSize) * 100;
        callback?.(Math.floor(progress * 100) / 100, totalSize, copiedSize);

        writeStream.write(chunk)

        // 检查是否已经复制完成
        if(copiedSize === totalSize) {
          writeStream.close()
        }
      });
    }

    writeStream.on('close', () => resolve(dest));
    writeStream.on('error', reject);
    readStream.on('error', reject);
  })
}

优点：

  • 计算进度时，只需要累加长度(length),而不是直接存储chunk，减少内存的占用。

不足：

  • writeStream.write(chunk)直接写入会占用极大的内存，特别是拷贝大文件的时候，很容易内存爆表

所以可以对于内存进行优化。

第二版

typescript 复制代码 
/**
 * 复制文件并报告进度
 *
 * @param src 源文件路径
 * @param dest 目标文件路径
 * @param callback 进度回调函数，参数为进度百分比（保留两位小数），可选
 * @returns 返回一个Promise，成功时resolve为true，失败时reject为错误对象
 */
export function copyFileWithProgress(src: string, dest: string, callback?: (progress: string) => void): Promise<boolean> {
	return new Promise((resolve, reject) => {
        const stat = fs.statSync(src);
        const totalSize = stat.size;
        let copiedSize = 0;

        const readStream = fs.createReadStream(src);
        const writeStream = fs.createWriteStream(dest);

        readStream.on('data', (chunk) => {
            copiedSize += chunk.length;
            const progress = (copiedSize / totalSize) * 100;
            callback?.(progress.toFixed(2));
            Logger.log(`复制文件进度: ${progress.toFixed(2)}%`);
        });

        readStream.pipe(writeStream);

        writeStream.on('finish', () => {
            Logger.log('【copyFileWithProgress】File copied successfully.');
        });

        writeStream.on('close', () => {
            resolve(true);
        })

        writeStream.on('error', (err) => {
            reject(err)
            Logger.error('【copyFileWithProgress】Error writing file:', err);
        });

        readStream.on('error', (err) => {
            reject(err)
            Logger.error('【copyFileWithProgress】Error reading file:', err);
        });
    })
}

优化点：

  • 使用到了pipe管道，以流的形式实现一边读一边写，占用内存更小。

不足：

  • pipe管道分片读写时，每次读写内容太小，会导致读写次数太多，造成时间耗费过长。

pipe其实就是将流文件拆分成为一小块一小块流动起来，而无需一次性全部读入。可以看下面图，应该很好理解。

一次性读入：

pipe管道：

最终版

typescript 复制代码 
import Logger from "electron-log";
import fs from "fs";

/**
 * 复制文件并显示进度
 *
 * @param src 源文件路径
 * @param dest 目标文件路径
 * @param callback 进度回调函数，参数为进度百分比（保留两位小数），可选
 * @returns 返回一个Promise，成功时resolve为true，失败时reject为错误对象
 */
export async function copyFileWithProgress(src: string, dest: string, callback?: (progress: number) => void): Promise<string> {
  const stat = await fs.promises.stat(src);
  const totalSize = stat.size;
  let copiedSize = 0;
  const isShowProgress = !!callback // 是否显示进度
  const blockSize = await getHighWaterMarkBlockSize(src)

  return new Promise((resolve, reject) => {
    const readStream = fs.createReadStream(src, { highWaterMark: blockSize });
    const writeStream = fs.createWriteStream(dest);

    const startTime = process.hrtime.bigint();

    let isDone = false;

    const safeResolve = (result: string) => {
      if (!isDone) {
        isDone = true;
        resolve(result);
      }
    };

    const safeReject = (err: Error) => {
      if (!isDone) {
        isDone = true;
        reject(err);
        Logger.error('【copyFileWithProgress】文件拷贝错误:', err);
      }
    };

    // 【性能优化】显示进度时，监听数据事件以计算进度
    if (isShowProgress) {
      readStream.on('data', (chunk) => {
        copiedSize += chunk.length;
        const progress = (copiedSize / totalSize) * 100;
        callback?.(Math.floor(progress * 100) / 100);
        // Logger.log(`复制文件进度: ${progress.toFixed(2)}%`);
      });
    }

    writeStream.on('finish', () => {
      const durationMilliseconds = Number(process.hrtime.bigint() - startTime) / 1e6;
      Logger.info(`【copyFileWithProgress】⌛️文件复制完成！总耗时：${durationMilliseconds.toFixed(3)} 毫秒`);
    });

    writeStream.on('close', () => safeResolve(dest));
    writeStream.on('error', safeReject);
    readStream.on('error', safeReject);

    readStream.pipe(writeStream);
  })
}



/**
 * 获取文件合适的 highWaterMark 块大小
 * @param filePath 文件路径
 * @returns 返回一个 Promise，成功时resolve为true，失败时reject为错误对象
 */
export async function getHighWaterMarkBlockSize(filePath: string): Promise<number> {
	let blockSize = 64 * 1024; // 默认 64 KB

	try {
		if (!filePath || !fs.existsSync(filePath)) {
			Logger.error(`【getHighWaterMarkBlockSize】路径文件不存在：${filePath}`);
			return blockSize
		}

		const stat = await fs.promises.stat(filePath);
		// 自动决定 highWaterMark 块大小（更高性能）
		const sizeMB = stat.size / (1024 * 1024);

		if (sizeMB > 500) {
			blockSize = 2 * 1024 * 1024; // 2 MB
		} else if (sizeMB > 10) {
			blockSize = 512 * 1024; // 512 KB
		}
	} catch (error) {
		Logger.error(`【getHighWaterMarkBlockSize】获取文件大小失败：${error}`);
	}

	return blockSize;
}

优点：

  • createReadStream默认设定highWaterMark是64k，通过动态控制highWaterMark大小减少读写次数。
  • 针对不同文件大小可以按照下面这个规则进行设置
文件大小 建议 highWaterMark 说明
< 10 MB 默认即可（64 KB） 不明显影响性能，避免浪费内存
10MB -- 500MB 512 KB - 1 MB 明显减少系统调用次数，提升吞吐
> 500MB 2 MB 或更大（2048 * 1024） 大幅提升性能，但注意内存占用

测试

针对优化2版本和最终版本使用同一个文件各自进行8次测试。

优化前：

测试1： 文件大小：251M 耗时：423ms
测试2： 文件大小：251M 耗时：401ms
测试3： 文件大小：251M 耗时：543ms
测试4： 文件大小：251M 耗时：489ms
测试5： 文件大小：251M 耗时：411ms
测试6： 文件大小：251M 耗时：457ms
测试7： 文件大小：251M 耗时：477ms
测试8： 文件大小：251M 耗时：533ms

优化后：

测试1： 文件大小：251M 耗时：201ms
测试2： 文件大小：251M 耗时：299ms
测试3： 文件大小：251M 耗时：250ms
测试4： 文件大小：251M 耗时：197ms
测试5： 文件大小：251M 耗时：211ms
测试6： 文件大小：251M 耗时：244ms
测试7： 文件大小：251M 耗时：210ms
测试8： 文件大小：251M 耗时：199ms

对highWaterMark优化之后效果还是挺明显的。

总结

  1. 拷贝不需要考虑进度，则直接使用fs.cp
  2. 拷贝需要显示进度，使用pipe进行读写，动态控制highWaterMark读写每块的大小。
相关推荐
dualven_in_csdn1 小时前
搞了两天的win7批处理脚本问题
java·linux·前端
你的人类朋友1 小时前
✍️【Node.js程序员】的数据库【索引优化】指南
前端·javascript·后端
小超爱编程2 小时前
纯前端做图片压缩
开发语言·前端·javascript
应巅2 小时前
echarts 数据大屏（无UI设计 极简洁版）
前端·ui·echarts
Jimmy3 小时前
CSS 实现描边文字效果
前端·css·html
islandzzzz3 小时前
HMTL+CSS+JS-新手小白循序渐进案例入门
前端·javascript·css·html
Senar3 小时前
网页中如何判断用户是否处于闲置状态
前端·javascript
很甜的西瓜4 小时前
typescript软渲染实现类似canvas的2d矢量图形引擎
前端·javascript·typescript·图形渲染·canvas
百万蹄蹄向前冲4 小时前
不会邮件合并，就用代码KoWord
node.js·产品·trae
Allen Bright4 小时前
【CSS-9】深入理解CSS字体图标：原理、优势与最佳实践
前端·css
热门推荐
01DeepSeek各版本说明与优缺点分析02【图像处理与机器视觉】XJTU期末考点03KGG转MP3工具|非KGM文件|解密音频04海康Visionmaster-常见问题排查方法-启动阶段05从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑06YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】07Trae AI 开发工具使用手册08Coze扣子平台完整体验和实践（附国内和国际版对比）09【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！10零代码入门 | Coze——让大模型接入自己的数据库