Cara tercepat untuk menyalin file di node.js

Proyek yang sedang saya kerjakan (node.js) menyiratkan banyak operasi dengan sistem file (menyalin / membaca / menulis dll). Saya ingin tahu metode mana yang paling cepat, dan saya senang mendapatkan saran. Terima kasih.

Ini adalah cara yang baik untuk menyalin file dalam satu baris kode menggunakan stream:

var fs = require('fs');

fs.createReadStream('test.log').pipe(fs.createWriteStream('newLog.log'));

Dalam simpul v8.5.0, copyFile ditambahkan

const fs = require('fs');

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

Mekanisme yang sama, tetapi ini menambahkan penanganan kesalahan:

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

Saya tidak bisa mendapatkan createReadStream/createWriteStreammetode ini bekerja karena alasan tertentu, tetapi menggunakan fs-extramodul npm itu berhasil segera. Saya tidak yakin dengan perbedaan kinerja.

fs-extra

npm install --save fs-extra

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

fs.copySync(path.resolve(__dirname,'./init/xxx.json'), 'xxx.json');

Sejak Node.js 8.5.0 kami memiliki fs.copyFile baru dan fs.copyFileSync metode.

Contoh Penggunaan:

var fs = require('fs');

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

Cepat untuk menulis dan nyaman digunakan, dengan manajemen janji dan kesalahan.

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

Sama dengan sintaks 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;
  }
}

Yah, biasanya ada baiknya menghindari operasi file yang tidak sinkron. Berikut adalah contoh sinkronisasi pendek (mis. Tidak ada penanganan kesalahan):

var fs = require('fs');
fs.writeFileSync(targetFile, fs.readFileSync(sourceFile));

Solusi Mike Schilling dengan penanganan kesalahan dengan jalan pintas untuk penangan peristiwa kesalahan.

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

Jika Anda tidak peduli itu async, dan tidak menyalin file berukuran gigabyte, dan lebih suka tidak menambahkan ketergantungan lain hanya untuk satu fungsi:

function copySync(src, dest) {
  var data = fs.readFileSync(src);
  fs.writeFileSync(dest, data);
}

   const fs = require("fs");
   fs.copyFileSync("filepath1", "filepath2"); //fs.copyFileSync("file1.txt", "file2.txt");

Inilah yang saya pribadi gunakan untuk menyalin file dan mengganti file lain menggunakan node.js :)

Untuk salinan cepat Anda harus menggunakan fs.constants.COPYFILE_FICLONEbendera. Ini memungkinkan (untuk sistem file yang mendukung ini) untuk tidak benar-benar menyalin konten file. Hanya entri file baru yang dibuat, tetapi itu menunjuk ke Copy-on-Write "klon" dari file sumber.

Untuk tidak melakukan apa-apa / kurang adalah cara tercepat untuk melakukan sesuatu;)

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

Sebaliknya, menggunakan janji:

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"));

solusi benweet memeriksa visibilitas file sebelum menyalin:

function copy(from, to) {
    return new Promise(function (resolve, reject) {
        fs.access(from, fs.F_OK, function (error) {
            if (error) {
                reject(error);
            } else {
                var inputStream = fs.createReadStream(from);
                var outputStream = fs.createWriteStream(to);

                function rejectCleanup(error) {
                    inputStream.destroy();
                    outputStream.end();
                    reject(error);
                }

                inputStream.on('error', rejectCleanup);
                outputStream.on('error', rejectCleanup);

                outputStream.on('finish', resolve);

                inputStream.pipe(outputStream);
            }
        });
    });
}

Mengapa tidak menggunakan nodejs built in fungsi salin?

Ini memberikan versi async dan sinkronisasi:

const fs = require('fs');

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

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

Solusi Mike , tetapi dengan janji:

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

Perbaikan satu jawaban lainnya.

Fitur:

• Jika folder dst tidak ada, itu akan secara otomatis membuatnya. Jawaban lainnya hanya akan melempar kesalahan.
• Ini mengembalikan a promise, yang membuatnya lebih mudah digunakan dalam proyek yang lebih besar.
• Ini memungkinkan Anda untuk menyalin beberapa file, dan janji itu akan dilakukan ketika semuanya disalin.

Pemakaian:

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

Kode:

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

semua solusi di atas yang tidak memeriksa keberadaan file sumber berbahaya ... mis

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

jika tidak ada risiko dalam skenario jika sumber dan target diganti secara tidak sengaja, data Anda akan hilang secara permanen tanpa memperhatikan adanya kesalahan.