Wie kann ich Dateien (wie die mv-Befehlsshell) auf node.js verschieben? Gibt es dafür eine Methode oder sollte ich eine Datei lesen, in eine neue Datei schreiben und ältere Dateien entfernen?

Laut seppo0010-Kommentar habe ich dazu die Umbenennungsfunktion verwendet.

http://nodejs.org/docs/latest/api/fs.html#fs_fs_rename_oldpath_newpath_callback

fs.rename (oldPath, newPath, Rückruf)

Hinzugefügt in: v0.0.2

oldPath <String> | <Buffer>
newPath <String> | <Buffer>
callback <Function>

Asynchrone Umbenennung (2). Für den Abschlussrückruf werden keine anderen Argumente als eine mögliche Ausnahme angegeben.

Dieses Beispiel stammt aus: Node.js in Aktion

Eine move () - Funktion, die nach Möglichkeit umbenennt 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);
    }
}

Nodejs nativ 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!')
})

(HINWEIS: "Dies funktioniert nicht, wenn Sie Partitionen kreuzen oder ein virtuelles Dateisystem verwenden, das das Verschieben von Dateien nicht unterstützt. [...]" - Flavien Volken 2. September 15 um 12:50 ")

Verwenden Sie das MV- Knotenmodul, das zuerst versucht, ein fs.renameKopieren durchzuführen und dann die Verknüpfung aufzuheben.

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

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

Die Lösung zum Kopieren von Dateien mithilfe von Streams lautet also:

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

Verwenden der Umbenennungsfunktion:

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

wo

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

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

Das fs-extraModul ermöglicht es Ihnen, dies mit seiner move()Methode zu 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 der 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 ist ein Beispiel mit util.pump von >> Wie verschiebe ich 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');
});

Verwenden von Versprechungen für Knotenversionen größer als 8.0.0:

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

const moveThem = async () => {
  // 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();

Nur meine 2 Cent, wie in der obigen Antwort angegeben : Die copy () -Methode sollte nicht unverändert zum Kopieren von Dateien ohne geringfügige Anpassung 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:

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 möglicherweise abstürzt, wenn der Zielordner nicht vorhanden ist.

Ich würde alle beteiligten Funktionen trennen (dh rename, copy, unlink) voneinander Flexibilität und promisify alles zu gewinnen, natürlich:

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 wir beispielsweise eine feinkörnigere Ausnahmebehandlung benötigen.

Shelljs ist eine sehr praktische Lösung.

Befehl: mv ([Optionen,] Quelle, Ziel)

Verfügbare Optionen:

-f: force (Standardverhalten)

-n: um ein Überschreiben zu verhindern

const shell = require('shelljs');
const status = shell.mv('README.md', '/home/my-dir');
if(status.stderr)  console.log(status.stderr);
else console.log('File moved!');

Dies ist eine Wiederholung der Antwort von Teoman Shipahi mit einem etwas weniger mehrdeutigen Namen und folgt dem Entwurfsprinzip, Code zu definieren, bevor Sie versuchen, ihn aufzurufen. (Während der Knoten es Ihnen erlaubt, etwas anderes zu tun, ist es keine gute Praxis, 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();
        }
    );
}

Mithilfe der folgenden URL können Sie Ihre Datei CURRENT Source entweder kopieren oder in die Zielquelle 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 *********/

Wenn Sie versuchen, eine Quelldatei von node.js zu verschieben oder umzubenennen, versuchen Sie dies https://github.com/viruschidai/node-mv . Die Verweise auf diese Datei werden in allen anderen Dateien aktualisiert.

Du kannst den ... benutzen move-file npm-Paket verwenden:

Installieren Sie zuerst das Paket:

$ npm install move-file

Verwendung:

const moveFile = require('move-file');

// moveFile Returns a Promise that resolves when the file has been moved
moveFile('source/unicorn.png', 'destination/unicorn.png')
  .then(() => {/* Handle success */})
  .catch((err) => {/* Handle failure */});

// Or use async/await
(async () => {
    try {
      await moveFile('source/unicorn.png', 'destination/unicorn.png');
      console.log('The file has been moved');
    } catch (err) {
      // Handle failure
      console.error(err);
    }
})();