Czy istnieje prostszy sposób skopiować folder i całą jego zawartość bez konieczności ręcznego robi sekwencję fs.readir, fs.readfile, fs.writefilerekurencyjnie?

Zastanawiam się tylko, czy brakuje mi funkcji, która idealnie działałaby w ten sposób

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

Możesz użyć modułu ncp . Myślę, że tego potrzebujesz

To jest moje podejście do rozwiązania tego problemu bez żadnych dodatkowych modułów. Po prostu używając wbudowanych fsi pathmodułów.

Uwaga: używa funkcji odczytu / zapisu fs, więc nie kopiuje żadnych metadanych (czas utworzenia itp.). W węźle 8.5 dostępne są copyFileSyncfunkcje, które wywołują funkcje kopiowania systemu operacyjnego, a zatem również kopiują metadane. Nie testowałem ich jeszcze, ale powinno działać po prostu je wymienić. (Zobacz 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 );
            }
        } );
    }
}

Istnieje kilka modułów obsługujących kopiowanie folderów wraz z ich zawartością. Najpopularniejszy byłby klucz

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

Alternatywą byłby 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

Oto funkcja, która rekurencyjnie kopiuje katalog i jego zawartość do innego katalogu:

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-extra pracował dla mnie kiedy ncp iwrench :

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

W przypadku systemu Linux / unix można użyć składni powłoki

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

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

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

Otóż ​​to!

Moduł FS-extra działa jak urok.

Zainstaluj fs-extra

$ npm install fs-extra

Poniżej znajduje się program do kopiowania katalogu źródłowego do katalogu docelowego.

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

Bibliografia

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

Przykład: NodeJS Tutorial - Node.js Kopiuj folder

Tak bym to zrobił osobiście:

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

działa dla folderów i plików

Stworzyłem mały przykład roboczy, który kopiuje folder źródłowy do innego folderu docelowego w zaledwie kilku krokach (w oparciu o odpowiedź @ shift66 przy użyciu ncp):

krok 1 - Zainstaluj moduł ncp:

npm install ncp --save

krok 2 - utwórz copy.js (zmień zmienne srcPath i destPath na cokolwiek potrzebujesz):

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

krok 3 - biegnij

node copy.js

W przypadku węzła 10 jest to całkiem proste.

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

To zakłada, destże nie istnieje.

Znam już tak wiele odpowiedzi, ale nikt nie odpowiedział w prosty sposób. Jeśli chodzi o oficjalną dokumentację fs-exra , możesz to zrobić bardzo łatwo

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')

Ponieważ buduję prosty skrypt węzłowy, nie chciałem, aby użytkownicy skryptu musieli importować kilka zewnętrznych modułów i zależności, więc założyłem swój limit myślenia i szukałem uruchomionych poleceń z basha muszla.

Ten fragment kodu node.js rekurencyjnie kopiuje folder o nazwie node-webkit.app do folderu o nazwie 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 {

        }
    });

Podziękowania dla Lance'a Pollarda z dzone za rozpoczęcie pracy.

Powyższy fragment kodu jest ograniczony do platform opartych na Uniksie, takich jak Mac OS i Linux, ale podobna technika może działać w systemie Windows.

@ mallikarjun-m dziękuję!

fs-extra zrobił to samo i może nawet zwrócić Promise, jeśli nie dostarczysz wywołania zwrotnego! :)

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

Ten z obsługą dowiązań symbolicznych + nie zgłasza, jeśli katalog istnieje.

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

Ten kod będzie działał dobrze, rekurencyjnie kopiując dowolny folder do dowolnej lokalizacji. Tylko 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+"\\\"");
}

Działa idealnie w mojej grze tekstowej do tworzenia nowych graczy.

Próbowałem fs-extra i copy-dir, aby kopiować folder-rekurencyjnie. ale ja to chce

1. działa normalnie (copy-dir generuje nierozpoznany błąd)
2. dostarcza dwa argumenty w filtrze: ścieżka pliku i typ pliku (fs-extra nie mówi typu pliku)
3. ma sprawdzanie dir-to-subdir i dir-to-file

Więc napisałem własne:

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

i podobną funkcję mkdirs, która jest alternatywą dla mkdirp

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

Napisałem tę funkcję zarówno do kopiowania (copyFileSync), jak i przenoszenia (renameSync) plików rekurencyjnie między katalogami:

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

Jeśli jesteś w Linuksie i wydajność nie jest problemem, możesz użyć execfunkcji z child_processmodułu, aby wykonać polecenie bash:

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

W niektórych przypadkach uznałem to rozwiązanie za bardziej przejrzyste niż pobieranie całego modułu lub nawet używanie fsmodułu.

ncp blokuje deskryptor pliku i uruchamia wywołanie zwrotne, gdy nie został jeszcze odblokowany. Zamiast tego polecam użycie modułu rekurencyjno-kopiującego . Obsługuje wydarzenia i możesz być pewien w zakończeniu kopii.

Zachowaj ostrożność podczas odbierania paczki. Niektóre pakiety, takie jak copy-dir, nie obsługują kopiowania dużych plików dłuższych niż 0x1fffffe8 znaków. Pojawi się błąd, taki jak:

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

Doświadczyłem czegoś takiego w jednym z moich projektów. Ostatecznie musiałem zmienić pakiet, z którego korzystałem i dostosować dużo kodu. Powiedziałbym, że nie jest to zbyt przyjemne doświadczenie.

Jeśli potrzebujesz wielu źródeł i wielu kopii docelowych, możesz użyć lepszej kopii i napisać coś takiego:

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

lub nawet :

// 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']);

TAK, ncpjestcool jednak ...

Możesz chcieć / powinieneś obiecać, że jego funkcja będzie super cool. Skoro już to robisz, dodaj go do plikutools pliku, aby użyć go ponownie.

Poniżej znajduje się działająca wersja, która jest Asynci używa 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;

Najłatwiejszym rozwiązaniem tego problemu jest użycie tylko modułu „fs” i „Path” oraz pewnej logiki .....

Wszystkie pliki w folderze głównym są kopiowane z Nową Nazwą, jeśli chcesz, po prostu ustaw numer wersji, tj. ....................... "var v = 'Twój katalog Imię'"

w zawartości przedrostka nazwy pliku V dodanej z nazwą pliku.

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

Oto jak zrobiłem:

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

następnie:

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

Następnie wywołaj metodę:

This.walkSync(filePath, fileList)