567

我正在处理的项目（Node.js）意味着对文件系统的大量操作（复制、读取、写入等）。

哪些方法最快？

4

17 回答 17

853

使用标准的内置方式fs.copyFile：

const fs = require('fs');

// File destination.txt will be created or overwritten by default.
fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) throw err;
  console.log('source.txt was copied to destination.txt');
});

如果您必须支持 Node.js 的旧版本 - 以下是您在不支持的版本中执行此操作的方法fs.copyFile：

const fs = require('fs');
fs.createReadStream('test.log').pipe(fs.createWriteStream('newLog.log'));
于 2012-07-02T13:52:46.980 回答
297

相同的机制，但这增加了错误处理：

function copyFile(source, target, cb) {
  var cbCalled = false;

  var rd = fs.createReadStream(source);
  rd.on("error", function(err) {
    done(err);
  });
  var wr = fs.createWriteStream(target);
  wr.on("error", function(err) {
    done(err);
  });
  wr.on("close", function(ex) {
    done();
  });
  rd.pipe(wr);

  function done(err) {
    if (!cbCalled) {
      cb(err);
      cbCalled = true;
    }
  }
}
于 2013-01-17T20:45:13.053 回答
148

createReadStream/createWriteStream由于某种原因，我无法使该方法正常工作，但使用fs-extra npm 模块它立即工作。我不确定性能差异。

npm install --save fs-extra

var fs = require('fs-extra');

fs.copySync(path.resolve(__dirname, './init/xxx.json'), 'xxx.json');
于 2014-08-20T15:17:25.357 回答
146

从 Node.js 8.5.0 开始，我们有了新的fs.copyFile和fs.copyFileSync方法。

使用示例：

var fs = require('fs');

// File "destination.txt" will be created or overwritten by default.
fs.copyFile('source.txt', 'destination.txt', (err) => {
    if (err) 
        throw err;
    console.log('source.txt was copied to destination.txt');
});
于 2017-09-16T12:06:05.527 回答
76

快速编写和方便使用，具有承诺和错误管理：

function copyFile(source, target) {
  var rd = fs.createReadStream(source);
  var wr = fs.createWriteStream(target);
  return new Promise(function(resolve, reject) {
    rd.on('error', reject);
    wr.on('error', reject);
    wr.on('finish', resolve);
    rd.pipe(wr);
  }).catch(function(error) {
    rd.destroy();
    wr.end();
    throw error;
  });
}

与 async/await 语法相同：

async function copyFile(source, target) {
  var rd = fs.createReadStream(source);
  var wr = fs.createWriteStream(target);
  try {
    return await new Promise(function(resolve, reject) {
      rd.on('error', reject);
      wr.on('error', reject);
      wr.on('finish', resolve);
      rd.pipe(wr);
    });
  } catch (error) {
    rd.destroy();
    wr.end();
    throw error;
  }
}
于 2015-05-22T20:07:23.597 回答
45

好吧，通常最好避免异步文件操作。这是简短的（即没有错误处理）同步示例：

var fs = require('fs');
fs.writeFileSync(targetFile, fs.readFileSync(sourceFile));
于 2014-02-22T21:15:26.077 回答
19

如果您不关心它是异步的，并且不复制千兆字节大小的文件，并且宁愿不为单个函数添加另一个依赖项：

function copySync(src, dest) {
  var data = fs.readFileSync(src);
  fs.writeFileSync(dest, data);
}
于 2017-01-07T02:58:25.773 回答
18

Mike Schilling 的错误处理解决方案，带有错误事件处理程序的快捷方式。

function copyFile(source, target, cb) {
  var cbCalled = false;

  var rd = fs.createReadStream(source);
  rd.on("error", done);

  var wr = fs.createWriteStream(target);
  wr.on("error", done);
  wr.on("close", function(ex) {
    done();
  });
  rd.pipe(wr);

  function done(err) {
    if (!cbCalled) {
      cb(err);
      cbCalled = true;
    }
  }
}
于 2014-02-24T18:23:40.193 回答
5 
   const fs = require("fs");
   fs.copyFileSync("filepath1", "filepath2"); //fs.copyFileSync("file1.txt", "file2.txt");

这是我个人用来复制文件并使用 Node.js 替换另一个文件的方法 :)

于 2019-08-10T13:20:03.720 回答
5

您可能想要使用 async/await，因为node v10.0.0它可以使用内置的fs Promises API.

例子：

const fs = require('fs')

const copyFile = async (src, dest) => {
  await fs.promises.copyFile(src, dest)
}

笔记：

截至node v11.14.0, v10.17.0API 不再是实验性的。

更多信息：

承诺 API

承诺复制文件

于 2020-12-17T15:20:37.817 回答
1

使用 Node.js 内置的复制功能

它提供异步和同步版本：

const fs = require('fs');

// File "destination.txt" will be created or overwritten by default.
fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) 
      throw err;
  console.log('source.txt was copied to destination.txt');
});

fs.copyFileSync(src, dest[, mode])

于 2018-05-17T11:20:33.307 回答
1

对于快速副本，您应该使用fs.constants.COPYFILE_FICLONE标志。它允许（对于支持此功能的文件系统）实际上不复制文件的内容。只创建了一个新文件条目，但它指向源文件的“写入时复制”“克隆”。

什么都不做/少做是做某事的最快方式；）

https://nodejs.org/api/fs.html#fs_fs_copyfile_src_dest_flags_callback

let fs = require("fs");

fs.copyFile(
  "source.txt",
  "destination.txt",
  fs.constants.COPYFILE_FICLONE,
  (err) => {
    if (err) {
      // TODO: handle error
      console.log("error");
    }
    console.log("success");
  }
);

改为使用承诺：

let fs = require("fs");
let util = require("util");
let copyFile = util.promisify(fs.copyFile);


copyFile(
  "source.txt",
  "destination.txt",
  fs.constants.COPYFILE_FICLONE
)
  .catch(() => console.log("error"))
  .then(() => console.log("success"));
于 2019-02-25T11:07:24.947 回答
0

你可以fs-extra很容易地使用该模块来做到这一点：

const fse = require('fs-extra');

let srcDir = 'path/to/file';
let destDir = 'pat/to/destination/directory';

fse.moveSync(srcDir, destDir, function (err) {

    // To move a file permanently from a directory
    if (err) {
        console.error(err);
    } else {
        console.log("success!");
    }
});

或者

fse.copySync(srcDir, destDir, function (err) {

     // To copy a file from a directory
     if (err) {
         console.error(err);
     } else {
         console.log("success!");
     }
});
于 2020-10-23T10:02:51.983 回答
0

我写了一个小工具来测试不同的方法：

https://www.npmjs.com/package/copy-speed-test

运行它

npx copy-speed-test --source someFile.zip --destination someNonExistentFolder

它使用 child_process.exec() 进行本机复制，使用 fs.copyFile 进行复制文件，并使用具有各种不同缓冲区大小的 createReadStream（您可以通过在命令行上传递它们来更改缓冲区大小。运行 npx copy-speed-测试 -h 了解更多信息）。

于 2021-04-11T10:29:25.830 回答
-1

迈克的解决方案，但承诺：

const FileSystem = require('fs');

exports.copyFile = function copyFile(source, target) {
    return new Promise((resolve,reject) => {
        const rd = FileSystem.createReadStream(source);
        rd.on('error', err => reject(err));
        const wr = FileSystem.createWriteStream(target);
        wr.on('error', err => reject(err));
        wr.on('close', () => resolve());
        rd.pipe(wr);
    });
};
于 2017-05-30T06:17:50.467 回答
-1

改进另一个答案。

特征：

  • 如果 dst 文件夹不存在，它会自动创建它。另一个答案只会抛出错误。
  • 它返回 a promise，这使得它更容易在更大的项目中使用。
  • 它允许您复制多个文件，并且当所有文件都被复制时，承诺将完成。

用法：

var onePromise = copyFilePromise("src.txt", "dst.txt");
var anotherPromise = copyMultiFilePromise(new Array(new Array("src1.txt", "dst1.txt"), new Array("src2.txt", "dst2.txt")));

代码：

function copyFile(source, target, cb) {
    console.log("CopyFile", source, target);

    var ensureDirectoryExistence = function (filePath) {
        var dirname = path.dirname(filePath);
        if (fs.existsSync(dirname)) {
            return true;
        }
        ensureDirectoryExistence(dirname);
        fs.mkdirSync(dirname);
    }
    ensureDirectoryExistence(target);

    var cbCalled = false;
    var rd = fs.createReadStream(source);
    rd.on("error", function (err) {
        done(err);
    });
    var wr = fs.createWriteStream(target);
    wr.on("error", function (err) {
        done(err);
    });
    wr.on("close", function (ex) {
        done();
    });
    rd.pipe(wr);
    function done(err) {
        if (!cbCalled) {
            cb(err);
            cbCalled = true;
        }
    }
}

function copyFilePromise(source, target) {
    return new Promise(function (accept, reject) {
        copyFile(source, target, function (data) {
            if (data === undefined) {
                accept();
            } else {
                reject(data);
            }
        });
    });
}

function copyMultiFilePromise(srcTgtPairArr) {
    var copyFilePromiseArr = new Array();
    srcTgtPairArr.forEach(function (srcTgtPair) {
        copyFilePromiseArr.push(copyFilePromise(srcTgtPair[0], srcTgtPair[1]));
    });
    return Promise.all(copyFilePromiseArr);
}
于 2017-07-15T03:12:39.173 回答
-2

以前所有不检查源文件是否存在的解决方案都是危险的......例如，

fs.stat(source, function(err,stat) { if (err) { reject(err) }

否则，如果源和目标被错误地替换，您的数据将永久丢失，而不会注意到任何错误。

于 2017-08-10T16:06:29.147 回答