Le moyen le plus rapide de copier un fichier dans node.js

Le projet sur lequel je travaille (node.js) implique de nombreuses opérations avec le système de fichiers (copie / lecture / écriture, etc.). Je voudrais savoir quelles méthodes sont les plus rapides et je serais heureux de recevoir un conseil. Merci.

C'est un bon moyen de copier un fichier sur une seule ligne de code à l'aide de flux:

var fs = require('fs');

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

Dans le nœud v8.5.0, copyFile a été ajouté

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

Même mécanisme, mais cela ajoute la gestion des erreurs:

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

Je n'ai pas pu faire fonctionner la createReadStream/createWriteStreamméthode pour une raison quelconque, mais en utilisant le fs-extramodule npm, cela a fonctionné tout de suite. Je ne suis pas sûr de la différence de performances.

fs-extra

npm install --save fs-extra

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

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

Depuis Node.js 8.5.0, nous avons de nouvelles méthodes fs.copyFile et fs.copyFileSync .

Exemple d'utilisation:

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

Rapide à écrire et pratique à utiliser, avec gestion des promesses et des erreurs.

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

Idem avec la syntaxe async / wait:

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

Eh bien, il est généralement préférable d'éviter les opérations de fichiers asynchrones. Voici l'exemple de synchronisation courte (c'est-à-dire sans gestion d'erreur):

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

Solution de Mike Schilling avec gestion des erreurs avec un raccourci pour le gestionnaire d'événements d'erreur.

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

Si vous ne vous souciez pas que ce soit asynchrone, et que vous ne copiez pas de fichiers de taille gigaoctet, et préférez ne pas ajouter une autre dépendance juste pour une seule fonction:

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

C'est ce que j'utilise personnellement pour copier un fichier et remplacer un autre fichier en utilisant node.js :)

Pour des copies rapides, vous devez utiliser le fs.constants.COPYFILE_FICLONEdrapeau. Il permet (pour les systèmes de fichiers qui le prennent en charge) de ne pas réellement copier le contenu du fichier. Seule une nouvelle entrée de fichier est créée, mais elle pointe vers un «clone» de copie sur écriture du fichier source.

Ne rien faire / moins est le moyen le plus rapide de faire quelque chose;)

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

Utiliser des promesses à la place:

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

La solution de benweet vérifiant la visibilité du fichier avant la copie:

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

Pourquoi ne pas utiliser la fonction de copie intégrée de nodejs?

Il fournit une version asynchrone et sync:

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

La solution de Mike , mais avec des promesses:

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

Amélioration d'une autre réponse.

Fonctionnalités:

• Si les dossiers dst n'existent pas, il les créera automatiquement. L'autre réponse ne générera que des erreurs.
• Il renvoie un promise, ce qui le rend plus facile à utiliser dans un projet plus important.
• Il vous permet de copier plusieurs fichiers, et la promesse sera faite lorsque tous seront copiés.

Usage:

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

toutes les solutions ci-dessus qui ne vérifient pas l'existence d'un fichier source sont dangereuses ... par exemple

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

sinon, il y a un risque dans un scénario au cas où la source et la cible sont remplacées par une erreur, vos données seront définitivement perdues sans remarquer aucune erreur.