webentwicklung-frage-antwort-db.com.de

Wie verschiebe ich Dateien in node.js?

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

103
rizidoro

Laut dem Kommentar von seppo0010 habe ich dazu die Umbenennungsfunktion verwendet.

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

fs.rename (oldPath, newPath, Callback)

Hinzugefügt in: v0.0.2

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

Asynchrones Umbenennen (2). Keine anderen Argumente als eine mögliche Ausnahme werden zum Rückruf für die Beendigung gegeben.

115
rizidoro

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);
    }
}
34
Teoman shipahi

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.

23
andrewrk

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

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!')
})
10
Hani

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.

8
iulia

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!")
})
6
mikeym

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

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

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

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.

1
user10675354

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();
        }
    );
}
1
unsynchronized

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();
0
vorillaz

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 *********/
0

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.

0
Jem