web-dev-qa-db-fra.com

Comment déplacer des fichiers dans node.js?

Comment puis-je déplacer des fichiers (comme mv command Shell) sur node.js? Existe-t-il une méthode pour cela ou dois-je lire un fichier, écrire dans un nouveau fichier et supprimer l'ancien fichier?

filenode.jsexpress
103
rizidoro

Selon le commentaire seppo0010, j'ai utilisé la fonction renommer pour le faire.

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

fs.rename (oldPath, newPath, callback)

Ajouté dans: v0.0.2

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

Renommer asynchrone (2). Aucun argument autre qu'une exception possible sont donnés au rappel d'achèvement.

115
rizidoro

Cet exemple tiré de: Node.js in Action

Une fonction move () qui renomme, si possible, ou retourne à la copie

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

Utilisez le module mv node qui essaiera d’abord de faire un fs.rename, puis retombera sur la copie puis sur la dissociation.

23
andrewrk

util.pump est obsolète dans le nœud 0.10 et génère un message d'avertissement

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

Donc, la solution pour copier des fichiers en utilisant des flux est: 

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

Utilisation native de nodejs

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

En utilisant la fonction renommer:

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

où

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

en supposant que vous souhaitiez conserver le nom du fichier inchangé.

8
iulia

Le module fs-extra vous permet de faire cela avec sa méthode move(). Je l'ai déjà implémenté et cela fonctionne bien si vous voulez déplacer complètement un fichier d'un répertoire à un autre - c'est à dire supprimer le fichier du répertoire source. Devrait fonctionner pour la plupart des cas de base.

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

Voici un exemple utilisant util.pump, from >> Comment déplacer le fichier a vers une autre partition ou un autre périphérique dans 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

Déplacez file1.htm de 'test /' à 'test/dir_1 /'

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

Je séparerais toutes les fonctions impliquées (c'est-à-dire rename, copy, unlink) les unes des autres pour gagner en souplesse et tout promettre, bien sûr:

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 est simplement une fonction pratique et nous pouvons appliquer les fonctions séparément, lorsque, par exemple, nous avons besoin d'une gestion plus fine des exceptions.

1
user10675354

c'est une répétition de la réponse de teoman shipahi avec un nom légèrement moins ambigu et suivant le principe de la définition du code avant d'essayer de l'appeler. (Si node vous permet de faire autrement, ce n'est pas une bonne pratique de mettre la charrue avant les boeufs.)

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

Utilisation de promesses pour les versions de nœud supérieures à 8.0.0:

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

À l’aide de l’URL ci-dessous, vous pouvez copier ou déplacer votre fichier CURRENT Source vers Destination Source.

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
Abdullah Pariyani

Juste mes 2 cents comme indiqué dans la réponse ci-dessus : La méthode copy () ne doit pas être utilisée telle quelle pour copier des fichiers sans un léger ajustement:

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

La fonction de copie enveloppée dans une promesse:

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

Cependant, gardez à l'esprit que le système de fichiers peut tomber en panne si le dossier cible n'existe pas.

0
Jem