Gibt es einen einfacheren Weg , um einen Ordner und seinen Inhalt , ohne manuell zu tun eine Folge von kopieren fs.readir, fs.readfile, fs.writefilerekursiv?

Ich frage mich nur, ob mir eine Funktion fehlt, die idealerweise so funktioniert

fs.copy("/path/to/source/folder","/path/to/destination/folder");

Sie können das ncp- Modul verwenden. Ich denke, das ist was du brauchst

Dies ist mein Ansatz, um dieses Problem ohne zusätzliche Module zu lösen. Nur mit den eingebauten fsund pathModulen.

Hinweis: Hierbei werden die Lese- / Schreibfunktionen von fs verwendet, sodass keine Metadaten (Erstellungszeitpunkt usw.) kopiert werden. Ab Knoten 8.5 copyFileSyncstehen Funktionen zur Verfügung, die die OS-Kopierfunktionen aufrufen und damit auch Metadaten kopieren. Ich habe sie noch nicht getestet, aber es sollte funktionieren, sie einfach zu ersetzen. (Siehe https://nodejs.org/api/fs.html#fs_fs_copyfilesync_src_dest_flags )

var fs = require('fs');
var path = require('path');

function copyFileSync( source, target ) {

    var targetFile = target;

    //if target is a directory a new file with the same name will be created
    if ( fs.existsSync( target ) ) {
        if ( fs.lstatSync( target ).isDirectory() ) {
            targetFile = path.join( target, path.basename( source ) );
        }
    }

    fs.writeFileSync(targetFile, fs.readFileSync(source));
}

function copyFolderRecursiveSync( source, target ) {
    var files = [];

    //check if folder needs to be created or integrated
    var targetFolder = path.join( target, path.basename( source ) );
    if ( !fs.existsSync( targetFolder ) ) {
        fs.mkdirSync( targetFolder );
    }

    //copy
    if ( fs.lstatSync( source ).isDirectory() ) {
        files = fs.readdirSync( source );
        files.forEach( function ( file ) {
            var curSource = path.join( source, file );
            if ( fs.lstatSync( curSource ).isDirectory() ) {
                copyFolderRecursiveSync( curSource, targetFolder );
            } else {
                copyFileSync( curSource, targetFolder );
            }
        } );
    }
}

Es gibt einige Module, die das Kopieren von Ordnern mit ihrem Inhalt unterstützen. Am beliebtesten wäre der Schraubenschlüssel

// Deep-copy an existing directory
wrench.copyDirSyncRecursive('directory_to_copy', 'location_where_copy_should_end_up');

Eine Alternative wäre Node-Fs-Extra

fs.copy('/tmp/mydir', '/tmp/mynewdir', function (err) {
  if (err) {
    console.error(err);
  } else {
    console.log("success!");
  }
}); //copies directory, even if it has subdirectories or files

Hier ist eine Funktion, die ein Verzeichnis und seinen Inhalt rekursiv in ein anderes Verzeichnis kopiert:

const fs = require("fs")
const path = require("path")

/**
 * Look ma, it's cp -R.
 * @param {string} src The path to the thing to copy.
 * @param {string} dest The path to the new copy.
 */
var copyRecursiveSync = function(src, dest) {
  var exists = fs.existsSync(src);
  var stats = exists && fs.statSync(src);
  var isDirectory = exists && stats.isDirectory();
  if (isDirectory) {
    fs.mkdirSync(dest);
    fs.readdirSync(src).forEach(function(childItemName) {
      copyRecursiveSync(path.join(src, childItemName),
                        path.join(dest, childItemName));
    });
  } else {
    fs.copyFileSync(src, dest);
  }
};

fs-extraarbeitete für mich wann ncpund wrenchfiel zu kurz:

https://www.npmjs.com/package/fs-extra

Für Linux / Unix-Betriebssysteme können Sie die Shell-Syntax verwenden

const shell = require('child_process').execSync ; 

const src= `/path/src`;
const dist= `/path/dist`;

shell(`mkdir -p ${dist}`);
shell(`cp -r ${src}/* ${dist}`);

Das ist es!

Das fs-extra Modul funktioniert wie ein Zauber.

Installieren Sie fs-extra

$ npm install fs-extra

Das folgende Programm kopiert das Quellverzeichnis in das Zielverzeichnis.

// include fs-extra package
var fs = require("fs-extra");

var source = 'folderA'
var destination = 'folderB'

// copy source folder to destination
fs.copy(source, destination, function (err) {
    if (err){
        console.log('An error occured while copying the folder.')
        return console.error(err)
    }
    console.log('Copy completed!')
});

Verweise

fs-extra: https://www.npmjs.com/package/fs-extra

Beispiel: NodeJS Tutorial - Node.js Kopieren Sie einen Ordner

So würde ich es persönlich machen:

function copyFolderSync(from, to) {
    fs.mkdirSync(to);
    fs.readdirSync(from).forEach(element => {
        if (fs.lstatSync(path.join(from, element)).isFile()) {
            fs.copyFileSync(path.join(from, element), path.join(to, element));
        } else {
            copyFolderSync(path.join(from, element), path.join(to, element));
        }
    });
}

funktioniert für Ordner und Dateien

Ich habe ein kleines Arbeitsbeispiel erstellt, das einen Quellordner in nur wenigen Schritten in einen anderen Zielordner kopiert (basierend auf der @ shift66-Antwort mit ncp):

Schritt 1 - Installieren Sie das NCP-Modul:

npm install ncp --save

Schritt 2 - Erstellen Sie copy.js (ändern Sie die Variablen srcPath und destPath nach Ihren Wünschen):

var path = require('path');
var ncp = require('ncp').ncp;

ncp.limit = 16;

var srcPath = path.dirname(require.main.filename); //current folder
var destPath = '/path/to/destination/folder'; //Any destination folder

console.log('Copying files...');
ncp(srcPath, destPath, function (err) {
  if (err) {
    return console.error(err);
  }
  console.log('Copying files complete.');
});

Schritt 3 - ausführen

node copy.js

Dies ist mit Knoten 10 ziemlich einfach.

const FSP = require('fs').promises;

async function copyDir(src,dest) {
    const entries = await FSP.readdir(src,{withFileTypes:true});
    await FSP.mkdir(dest);
    for(let entry of entries) {
        const srcPath = Path.join(src,entry.name);
        const destPath = Path.join(dest,entry.name);
        if(entry.isDirectory()) {
            await copyDir(srcPath,destPath);
        } else {
            await FSP.copyFile(srcPath,destPath);
        }
    }
}

Dies setzt voraus, dass destes nicht existiert.

Ich kenne hier schon so viele Antworten, aber niemand hat es auf einfache Weise beantwortet. In Bezug auf die offizielle Dokumentation von fs-exra können Sie dies sehr einfach tun

const fs = require('fs-extra')

// copy file
fs.copySync('/tmp/myfile', '/tmp/mynewfile')

// copy directory, even if it has subdirectories or files
fs.copySync('/tmp/mydir', '/tmp/mynewdir')

Da ich nur ein einfaches Knotenskript erstelle, wollte ich nicht, dass die Benutzer des Skripts eine Reihe externer Module und Abhängigkeiten importieren müssen. Deshalb setzte ich meine Denkkapsel auf und suchte nach ausgeführten Befehlen aus der Bash Schale.

Dieses Code-Snippet von node.js kopiert rekursiv einen Ordner namens node-webkit.app in einen Ordner namens build:

   child = exec("cp -r node-webkit.app build", function(error, stdout, stderr) {
        sys.print("stdout: " + stdout);
        sys.print("stderr: " + stderr);
        if(error !== null) {
            console.log("exec error: " + error);
        } else {

        }
    });

Vielen Dank an Lance Pollard von dzone für den Einstieg.

Das obige Snippet ist auf Unix-basierte Plattformen wie Mac OS und Linux beschränkt, aber eine ähnliche Technik kann für Windows funktionieren.

@ mallikarjun-m danke!

fs-extra hat das Ding gemacht und es kann sogar Promise zurückgeben, wenn Sie keinen Rückruf geben! :) :)

const path = require('path')
const fs = require('fs-extra')

let source = path.resolve( __dirname, 'folderA')
let destination = path.resolve( __dirname, 'folderB')

fs.copy(source, destination)
  .then(() => console.log('Copy completed!'))
  .catch( err => {
    console.log('An error occured while copying the folder.')
    return console.error(err)
  })

Der mit Unterstützung für symbolische Links + wirft nicht, wenn ein Verzeichnis vorhanden ist.

function copyFolderSync(from, to) {
  try {
    fs.mkdirSync(to);
  } catch(e) {}

  fs.readdirSync(from).forEach((element) => {
    const stat = fs.lstatSync(path.join(from, element));
    if (stat.isFile()) {
      fs.copyFileSync(path.join(from, element), path.join(to, element));
    } else if (stat.isSymbolicLink()) {
      fs.symlinkSync(fs.readlinkSync(path.join(from, element)), path.join(to, element));
    } else if (stat.isDirectory()) {
      copyFolderSync(path.join(from, element), path.join(to, element));
    }
  });
}

Dieser Code funktioniert einwandfrei und kopiert rekursiv jeden Ordner an einen beliebigen Speicherort. Nur Windows.

var child=require("child_process");
function copySync(from,to){
    from=from.replace(/\//gim,"\\");
    to=to.replace(/\//gim,"\\");
    child.exec("xcopy /y /q \""+from+"\\*\" \""+to+"\\\"");
}

Funktioniert perfekt für mein textbasiertes Spiel zum Erstellen neuer Spieler.

Ich habe versucht, fs-extra und copy-dir rekursiv in den Ordner zu kopieren. aber ich will es

1. funktioniert normal (Kopierverzeichnis löst nicht resonablen Fehler aus)
2. bietet zwei Argumente im Filter: Dateipfad und Dateityp (fs-extra teilt den Dateityp nicht mit)
3. hat dir-to-subdir-Prüfung und dir-to-file-Prüfung

Also schrieb ich meine eigenen:

//node module for node 8.6+
var path=require("path");
var fs=require("fs");

function copyDirSync(src,dest,options){
  var srcPath=path.resolve(src);
  var destPath=path.resolve(dest);
  if(path.relative(srcPath,destPath).charAt(0)!=".")
    throw new Error("dest path must be out of src path");
  var settings=Object.assign(Object.create(copyDirSync.options),options);
  copyDirSync0(srcPath,destPath,settings);
  function copyDirSync0(srcPath,destPath,settings){
    var files=fs.readdirSync(srcPath);
    if (!fs.existsSync(destPath)) {
      fs.mkdirSync(destPath);
    }else if(!fs.lstatSync(destPath).isDirectory()){
      if(settings.overwrite)
        throw new Error(`Cannot overwrite non-directory '${destPath}' with directory '${srcPath}'.`);
      return;
    }
    files.forEach(function(filename){
      var childSrcPath=path.join(srcPath,filename);
      var childDestPath=path.join(destPath,filename);
      var type=fs.lstatSync(childSrcPath).isDirectory()?"directory":"file";
      if(!settings.filter(childSrcPath,type))
        return;
      if (type=="directory") {
        copyDirSync0(childSrcPath,childDestPath,settings);
      } else {
        fs.copyFileSync(childSrcPath, childDestPath, settings.overwrite?0:fs.constants.COPYFILE_EXCL);
        if(!settings.preserveFileDate)
          fs.futimesSync(childDestPath,Date.now(),Date.now());
      }
    });
  }
}
copyDirSync.options={
  overwrite: true,
  preserveFileDate: true,
  filter: function(filepath,type){return true;}
};

und eine ähnliche Funktion mkdirs, die eine Alternative zu mkdirp ist

function mkdirsSync(dest) {
  var destPath=path.resolve(dest);
  mkdirsSync0(destPath);
  function mkdirsSync0(destPath){
    var parentPath=path.dirname(destPath);
    if(parentPath==destPath)
      throw new Error(`cannot mkdir ${destPath}, invalid root`);
    if (!fs.existsSync(destPath)) {
      mkdirsSync0(parentPath);
      fs.mkdirSync(destPath);
    }else if(!fs.lstatSync(destPath).isDirectory()){
      throw new Error(`cannot mkdir ${destPath}, a file already exists there`);
    }
  }
}

Ich habe diese Funktion sowohl zum Kopieren (copyFileSync) als auch zum rekursiven Verschieben (renameSync) von Dateien zwischen Verzeichnissen geschrieben:

//copy files
copyDirectoryRecursiveSync(sourceDir, targetDir);
//move files
copyDirectoryRecursiveSync(sourceDir, targetDir, true);


function copyDirectoryRecursiveSync(source, target, move) {
if (!fs.lstatSync(source).isDirectory()) return;

var operation = move ? fs.renameSync : fs.copyFileSync;
fs.readdirSync(source).forEach(function (itemName) {
    var sourcePath = path.join(source, itemName);
    var targetPath = path.join(target, itemName);

    if (fs.lstatSync(sourcePath).isDirectory()) {
        fs.mkdirSync(targetPath);
        copyDirectoryRecursiveSync(sourcePath, targetDir);
    }
    else {
        operation(sourcePath, targetPath);
    }
});}

Wenn Sie unter Linux arbeiten und die Leistung kein Problem darstellt, können Sie die execFunktion from child_processmodule verwenden, um einen Bash-Befehl auszuführen:

const { exec } = require('child_process');
exec('cp -r source dest', (error, stdout, stderr) => {...});

In einigen Fällen fand ich diese Lösung sauberer als das Herunterladen eines gesamten Moduls oder sogar die Verwendung eines fsModuls.

ncp sperrt den Dateideskriptor und löst einen Rückruf aus, wenn er noch nicht entsperrt wurde. Ich empfehle stattdessen das Modul für rekursives Kopieren . Es unterstützt Ereignisse und Sie können sicher sein, dass die Kopie endet.

Seien Sie vorsichtig bei der Auswahl Ihres Pakets. Einige Pakete wie copy-dir unterstützen das Kopieren großer Dateien mit einer Länge von mehr als 0x1fffffe8 nicht. Es wird ein Fehler wie:

buffer.js:630 Uncaught Error: Cannot create a string longer than 0x1fffffe8 characters 

Ich habe so etwas in einem meiner Projekte erlebt. Letztendlich musste ich das verwendete Paket ändern und viel Code anpassen. Ich würde sagen, dass dies keine sehr angenehme Erfahrung ist.

Wenn mehrere Quell- und mehrere Zielkopien gewünscht werden, können Sie eine bessere Kopie verwenden und Folgendes schreiben:

// copy from multiple source into a directory
bCopy(['/path/to/your/folder1', '/path/to/some/file.txt'], '/path/to/destination/folder');

oder auch :

// copy from multiple source into multiple destination
bCopy(['/path/to/your/folder1', '/path/to/some/file.txt'], ['/path/to/destination/folder', '/path/to/another/folder']);

JA, ncpist coolaber ...

Vielleicht möchten / sollten Sie versprechen, seine Funktion zu machen super cool. Wenn Sie schon dabei sind, fügen Sie es einer toolsDatei hinzu, um es wiederzuverwenden.

Unten ist eine Arbeitsversion, die ist Asyncund verwendet Promises.

index.js

const {copyFolder} = require('./tools/');

return copyFolder(
    yourSourcePath,
    yourDestinationPath
)
.then(() => {
    console.log('-> Backup completed.')
}) .catch((err) => {
    console.log("-> [ERR] Could not copy the folder: ", err);
})

tools.js

const ncp = require("ncp");

/**
 * Promise Version of ncp.ncp()
 * 
 * This function promisifies ncp.ncp().
 * We take the asynchronous function ncp.ncp() with 
 * callback semantics and derive from it a new function with
 * promise semantics.
 */
ncp.ncpAsync = function (sourcePath, destinationPath) {
  return new Promise(function (resolve, reject) {
      try {
          ncp.ncp(sourcePath, destinationPath, function(err){
              if (err) reject(err); else resolve();
          });
      } catch (err) {
          reject(err);
      }
  });
};

/**
 * Utility function to copy folders asynchronously using
 * the Promise returned by ncp.ncp(). 
 */
const copyFolder = (sourcePath, destinationPath) => {
    return ncp.ncpAsync(sourcePath, destinationPath, function (err) {
        if (err) {
            return console.error(err);
        }
    });
}
module.exports.copyFolder = copyFolder;

Der einfachste Ansatz für dieses Problem besteht darin, nur die Module 'fs' und 'Path' sowie eine Logik zu verwenden.

Alle Dateien im Stammordner werden mit dem neuen Namen kopiert, wenn Sie nur die Versionsnummer festlegen möchten, dh ....................... "var v = 'Ihr Verzeichnis Name'"

in Dateiname Präfix V Inhalt mit dem Dateinamen hinzugefügt.

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

var c = 0;
var i =0 ;
var v = "1.0.2";
var copyCounter = 0;
var directoryCounter = 0; 
var directoryMakerCounter = 0;
var recursionCounter = -1;
var Flag = false;
var directoryPath = [] ;
var directoryName = [] ;
var directoryFileName = [];
var fileName;
var directoryNameStorer;
var dc = 0;
var route ;



if (!fs.existsSync(v)){
   fs.mkdirSync(v);
}

var basePath = path.join(__dirname, v);


function walk(dir){

  fs.readdir(dir, function(err, items) {

    items.forEach(function(file){

        file = path.resolve(dir, file);

        fs.stat(file, function(err, stat){
            if(stat && stat.isDirectory()){

                directoryNameStorer = path.basename(file);
                route = file;
                route = route.replace("gd",v);

                directoryFileName[directoryCounter] = route;
                directoryPath[directoryCounter] = file;
                directoryName[directoryCounter] = directoryNameStorer;

                directoryCounter++;
                dc++;

                if (!fs.existsSync(basePath+"/"+directoryName[directoryMakerCounter])){
                    fs.mkdirSync(directoryFileName[directoryMakerCounter]);
                    directoryMakerCounter++;
                }

            }else{

                    fileName = path.basename(file);
                    if(recursionCounter >= 0){
                        fs.copyFileSync(file, directoryFileName[recursionCounter]+"/"+v+"_"+fileName, err => {
                            if(err) return console.error(err);
                        });
                        copyCounter++;
                    }else{
                        fs.copyFileSync(file, v+"/"+v+"_"+fileName, err => {
                            if(err) return console.error(err);
                        });
                        copyCounter++;    
                    }

                }
                if(copyCounter + dc == items.length && directoryCounter > 0 && recursionCounter < directoryMakerCounter-1){
                    console.log("COPY COUNTER :             "+copyCounter);
                    console.log("DC COUNTER :               "+dc);                        
                    recursionCounter++;
                    dc = 0;
                    copyCounter = 0;
                    console.log("ITEM DOT LENGTH :          "+items.length);
                    console.log("RECURSION COUNTER :        "+recursionCounter);
                    console.log("DIRECOTRY MAKER COUNTER :  "+directoryMakerCounter);
                    console.log(": START RECURSION :        "+directoryPath[recursionCounter]);
                    walk(directoryPath[recursionCounter]); //recursive call to copy sub-folder

                }

        })
    })
 });

}
 walk('./gd', function(err, data){ //Just Pass The Root Directory Which You Want to Copy
 if(err) throw err;
 console.log("done");
})

So habe ich es gemacht:

let fs = require('fs');
let path = require('path');

dann:

let filePath = //your FilePath

let fileList = []
        var walkSync = function(filePath, filelist) 
        {
          let files = fs.readdirSync(filePath);
          filelist = filelist || [];
          files.forEach(function(file) 
          {
            if (fs.statSync(path.join(filePath, file)).isDirectory()) 
            {
              filelist = walkSync(path.join(filePath, file), filelist);
            }
            else 
            {
              filelist.push(path.join(filePath, file));
            }
          });

          // Ignore hidden files
          filelist = filelist.filter(item => !(/(^|\/)\.[^\/\.]/g).test(item));

          return filelist;
        };

Rufen Sie dann die Methode auf:

This.walkSync(filePath, fileList)