Der schnellste Weg, um eine Datei in node.js zu kopieren

Das Projekt, an dem ich arbeite (node.js), impliziert viele Operationen mit dem Dateisystem (Kopieren / Lesen / Schreiben usw.). Ich würde gerne wissen, welche Methoden am schnellsten sind, und würde mich über einen Rat freuen. Vielen Dank.

Dies ist eine gute Möglichkeit, eine Datei mithilfe von Streams in eine Codezeile zu kopieren:

var fs = require('fs');

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

In Knoten v8.5.0 wurde copyFile hinzugefügt

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

Gleicher Mechanismus, aber dies fügt eine Fehlerbehandlung hinzu:

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

Ich konnte die createReadStream/createWriteStreamMethode aus irgendeinem Grund nicht zum fs-extraLaufen bringen , aber mit dem npm-Modul funktionierte es sofort. Ich bin mir jedoch nicht sicher über den Leistungsunterschied.

fs-extra

npm install --save fs-extra

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

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

Seit Node.js 8.5.0 haben wir neue Methoden fs.copyFile und fs.copyFileSync .

Anwendungsbeispiel:

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

Schnell zu schreiben und bequem zu bedienen, mit Versprechen und Fehlermanagement.

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

Gleiches gilt für die asynchrone / warten-Syntax:

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

Normalerweise ist es gut, asynchrone Dateivorgänge zu vermeiden. Hier ist das kurze Synchronisierungsbeispiel (dh keine Fehlerbehandlung):

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

Mike Schillings Lösung mit Fehlerbehandlung mit einer Verknüpfung für den Fehlerereignishandler.

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

Wenn Sie sich nicht darum kümmern, dass es asynchron ist, und keine Dateien in Gigabyte-Größe kopieren und lieber keine weitere Abhängigkeit nur für eine einzelne Funktion hinzufügen möchten:

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

Dies ist, was ich persönlich benutze, um eine Datei zu kopieren und eine andere Datei mit node.js zu ersetzen :)

Für schnelle Kopien sollten Sie die fs.constants.COPYFILE_FICLONEFlagge verwenden. Es ermöglicht (für Dateisysteme, die dies unterstützen), den Inhalt der Datei nicht tatsächlich zu kopieren. Es wird nur ein neuer Dateieintrag erstellt, der jedoch auf einen Copy-on-Write- "Klon" der Quelldatei verweist .

Nichts / weniger zu tun ist der schnellste Weg, etwas zu tun;)

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

Verwenden Sie stattdessen Versprechen:

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

Die Lösung von benweet überprüft die Sichtbarkeit der Datei vor dem Kopieren:

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

Warum nicht NodeJs verwenden, die in die Kopierfunktion integriert sind?

Es bietet sowohl eine asynchrone als auch eine synchronisierte Version:

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

Mikes Lösung , aber mit Versprechungen:

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

Verbesserung einer anderen Antwort.

Eigenschaften:

• Wenn die dst-Ordner nicht vorhanden sind, wird sie automatisch erstellt. Die andere Antwort wirft nur Fehler.
• Es gibt a zurück promise, was die Verwendung in einem größeren Projekt erleichtert.
• Sie können mehrere Dateien kopieren , und das Versprechen wird erfüllt, wenn alle kopiert wurden.

Verwendungszweck:

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

Code:

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

Alle oben genannten Lösungen, die das Vorhandensein einer Quelldatei nicht überprüfen, sind gefährlich ... z

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

Andernfalls besteht in einem Szenario das Risiko, dass Ihre Daten dauerhaft verloren gehen, ohne dass ein Fehler bemerkt wird, wenn Quelle und Ziel versehentlich ersetzt werden.