Wie verschiebe ich Dateien in node.js?

Dieses Beispiel stammt aus: Node.js in Aktion

Eine move () - Funktion, die wenn möglich umbenannt oder auf das Kopieren zurückgreift

var fs = require('fs');

module.exports = function move(oldPath, newPath, callback) {

    fs.rename(oldPath, newPath, function (err) {
        if (err) {
            if (err.code === 'EXDEV') {
                copy();
            } else {
                callback(err);
            }
            return;
        }
        callback();
    });

    function copy() {
        var readStream = fs.createReadStream(oldPath);
        var writeStream = fs.createWriteStream(newPath);

        readStream.on('error', callback);
        writeStream.on('error', callback);

        readStream.on('close', function () {
            fs.unlink(oldPath, callback);
        });

        readStream.pipe(writeStream);
    }
}

Verwenden Sie das Modul mv node, das zuerst versucht, einen fs.rename auszuführen, und dann auf das Kopieren und dann die Verknüpfung zurückgreift.

util.pump ist in Knoten 0.10 veraltet und generiert eine Warnmeldung

 util.pump() is deprecated. Use readableStream.pipe() instead

Die Lösung für das Kopieren von Dateien mithilfe von Streams lautet: 

var source = fs.createReadStream('/path/to/source');
var dest = fs.createWriteStream('/path/to/dest');

source.pipe(dest);
source.on('end', function() { /* copied */ });
source.on('error', function(err) { /* error */ });

Node verwenden

var fs = require('fs')

var oldPath = 'old/path/file.txt'
var newPath = 'new/path/file.txt'

fs.rename(oldPath, newPath, function (err) {
  if (err) throw err
  console.log('Successfully renamed - AKA moved!')
})

Verwenden der Umbenennungsfunktion:

fs.rename(getFileName, __dirname + '/new_folder/' + getFileName); 

woher

getFilename = file.extension (old path)
__dirname + '/new_folder/' + getFileName

vorausgesetzt, Sie möchten den Dateinamen unverändert lassen.

Mit dem fs-extra-Modul können Sie dies mit seiner move()-Methode tun. Ich habe es bereits implementiert und es funktioniert gut, wenn Sie eine Datei vollständig von einem Verzeichnis in ein anderes verschieben möchten - dh Entfernen Sie die Datei aus dem Quellverzeichnis. Sollte für die meisten grundlegenden Fälle funktionieren.

var fs = require('fs-extra')

fs.move('/tmp/somefile', '/tmp/does/not/exist/yet/somefile', function (err) {
 if (err) return console.error(err)
 console.log("success!")
})

Hier ein Beispiel mit util.pump aus >> Wie verschiebe ich die Datei a auf eine andere Partition oder ein anderes Gerät in Node.js?

var fs = require('fs'),
    util = require('util');

var is = fs.createReadStream('source_file')
var os = fs.createWriteStream('destination_file');

util.pump(is, os, function() {
    fs.unlinkSync('source_file');
});

Verschiebe file1.htm von 'test /' nach 'test/dir_1 /'

moveFile('./test/file1.htm', './test/dir_1/');

Ich würde alle beteiligten Funktionen (d. H. rename, copy, unlink) voneinander trennen, um Flexibilität zu gewinnen und natürlich alles zu versprechen:

const renameFile = (path, newPath) => 
  new Promise((res, rej) => {
    fs.rename(path, newPath, (err, data) =>
      err
        ? rej(err)
        : res(data));
  });

const copyFile = (path, newPath, flags) =>
  new Promise((res, rej) => {
    const readStream = fs.createReadStream(path),
      writeStream = fs.createWriteStream(newPath, {flags});

    readStream.on("error", rej);
    writeStream.on("error", rej);
    writeStream.on("finish", res);
    readStream.pipe(writeStream);
  });

const unlinkFile = path => 
  new Promise((res, rej) => {
    fs.unlink(path, (err, data) =>
      err
        ? rej(err)
        : res(data));
  });

const moveFile = (path, newPath, flags) =>
  renameFile(path, newPath)
    .catch(e => {
      if (e.code !== "EXDEV")
        throw new e;

      else
        return copyFile(path, newPath, flags)
          .then(() => unlinkFile(path));
    });

moveFile ist nur eine Komfortfunktion und wir können die Funktionen separat anwenden, wenn zum Beispiel eine feinere Ausnahmebehandlung erforderlich ist.

dies ist eine Neuauflage von teoman shipahis Antwort mit einem etwas weniger eindeutigen Namen und folgt dem Design-Prinzip, Code zu definieren, bevor Sie versuchen, ihn aufzurufen. (Während Node es Ihnen erlaubt, etwas anderes zu tun, ist es nicht ratsam, den Wagen vor das Pferd zu stellen.)

function rename_or_copy_and_delete (oldPath, newPath, callback) {

    function copy_and_delete () {
        var readStream = fs.createReadStream(oldPath);
        var writeStream = fs.createWriteStream(newPath);

        readStream.on('error', callback);
        writeStream.on('error', callback);
        readStream.on('close', 
              function () {
                fs.unlink(oldPath, callback);
              }
        );

        readStream.pipe(writeStream);
    }

    fs.rename(oldPath, newPath, 
        function (err) {
          if (err) {
              if (err.code === 'EXDEV') {
                  copy_and_delete();
              } else {
                  callback(err);
              }
              return;// << both cases (err/copy_and_delete)
          }
          callback();
        }
    );
}

Versprechen für Node-Versionen größer als 8.0.0 verwenden:

const {promisify} = require('util');
const fs = require('fs');
const {join} = require('path');
const mv = promisify(fs.rename);

const moveThem = () => {
  // Move file ./bar/foo.js to ./baz/qux.js
  const original = join(__dirname, 'bar/foo.js');
  const target = join(__dirname, 'baz/qux.js'); 
  await mv(original, target);
}

moveThem();

Mithilfe der folgenden URL können Sie Ihre Datei CURRENT Source entweder kopieren oder in Destination Source verschieben

https://coursesweb.net/nodejs/move-copy-file

/*********Moves the $file to $dir2 Start *********/
var moveFile = (file, dir2)=>{
  //include the fs, path modules
  var fs = require('fs');
  var path = require('path');

  //gets file name and adds it to dir2
  var f = path.basename(file);
  var dest = path.resolve(dir2, f);

  fs.rename(file, dest, (err)=>{
    if(err) throw err;
    else console.log('Successfully moved');
  });
};

//move file1.htm from 'test/' to 'test/dir_1/'
moveFile('./test/file1.htm', './test/dir_1/');
/*********Moves the $file to $dir2 END *********/

/*********copy the $file to $dir2 Start *********/
var copyFile = (file, dir2)=>{
  //include the fs, path modules
  var fs = require('fs');
  var path = require('path');

  //gets file name and adds it to dir2
  var f = path.basename(file);
  var source = fs.createReadStream(file);
  var dest = fs.createWriteStream(path.resolve(dir2, f));

  source.pipe(dest);
  source.on('end', function() { console.log('Succesfully copied'); });
  source.on('error', function(err) { console.log(err); });
};

//example, copy file1.htm from 'test/dir_1/' to 'test/'
copyFile('./test/dir_1/file1.htm', './test/');
/*********copy the $file to $dir2 END *********/

Nur meine 2 Cent wie in der answer oben angegeben : Die copy () -Methode sollte nicht ohne Änderungen für das Kopieren von Dateien verwendet werden:

function copy(callback) {
    var readStream = fs.createReadStream(oldPath);
    var writeStream = fs.createWriteStream(newPath);

    readStream.on('error', callback);
    writeStream.on('error', callback);

    // Do not callback() upon "close" event on the readStream
    // readStream.on('close', function () {
    // Do instead upon "close" on the writeStream
    writeStream.on('close', function () {
        callback();
    });

    readStream.pipe(writeStream);
}

Die Kopierfunktion in einem Versprechen verpackt:

function copy(oldPath, newPath) {
  return new Promise((resolve, reject) => {
    const readStream = fs.createReadStream(oldPath);
    const writeStream = fs.createWriteStream(newPath);

    readStream.on('error', err => reject(err));
    writeStream.on('error', err => reject(err));

    writeStream.on('close', function() {
      resolve();
    });

    readStream.pipe(writeStream);
  })

Beachten Sie jedoch, dass das Dateisystem abstürzen kann, wenn der Zielordner nicht vorhanden ist.