Apakah ada cara yang lebih mudah untuk menyalin folder dan seluruh isinya tanpa manual melakukan urutan fs.readir, fs.readfile, fs.writefilerekursif?

Hanya ingin tahu apakah saya kehilangan fungsi yang idealnya bekerja seperti ini

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

Anda dapat menggunakan modul ncp . Saya pikir inilah yang Anda butuhkan

Ini adalah pendekatan saya untuk menyelesaikan masalah ini tanpa modul tambahan. Hanya menggunakan modul fsdan built-in path.

Catatan: Ini tidak menggunakan fungsi baca / tulis dari fs sehingga tidak menyalin data meta (waktu pembuatan dll.). Pada node 8.5 ada copyFileSyncfungsi yang tersedia yang memanggil fungsi copy OS dan karena itu juga menyalin meta data. Saya belum mengujinya, tetapi seharusnya hanya menggantikan mereka. (Lihat 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 );
            }
        } );
    }
}

Ada beberapa modul yang mendukung penyalinan folder dengan kontennya. Yang paling populer adalah kunci pas

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

Alternatifnya adalah 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

Berikut adalah fungsi yang secara rekursif menyalin direktori dan isinya ke direktori lain:

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-extrabekerja untuk saya kapan ncpdan wrenchgagal:

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

Untuk linux / unix OS, Anda dapat menggunakan sintaks shell

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

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

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

Itu dia!

Modul fs-extra bekerja seperti pesona.

Instal fs-extra

$ npm install fs-extra

Berikut ini adalah program untuk menyalin direktori sumber ke direktori tujuan.

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

Referensi

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

Contoh: Tutorial NodeJS - Node.js Menyalin Folder

Inilah yang akan saya lakukan secara pribadi:

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

berfungsi untuk folder dan file

Saya membuat contoh kecil yang berfungsi menyalin folder sumber ke folder tujuan lain hanya dalam beberapa langkah (berdasarkan jawaban @ shift66 menggunakan ncp):

langkah 1 - Instal modul ncp:

npm install ncp --save

langkah 2 - buat copy.js (modifikasi srcPath dan destPath vars untuk apa pun yang Anda butuhkan):

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

langkah 3 - jalankan

node copy.js

Ini cukup mudah dengan simpul 10.

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

Ini mengasumsikan desttidak ada.

Saya tahu begitu banyak jawaban di sini tetapi tidak ada yang menjawabnya dengan cara sederhana. Mengenai dokumentasi resmi fs-exra , Anda dapat melakukannya dengan sangat mudah

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

Karena saya hanya membuat skrip simpul sederhana, saya tidak ingin para pengguna skrip perlu mengimpor banyak modul eksternal dan dependensi, jadi saya memakai topi berpikir saya dan melakukan pencarian untuk menjalankan perintah dari bash kulit.

Cuplikan kode node.js ini secara rekursif menyalin folder bernama node-webkit.app ke folder bernama 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 {

        }
    });

Terima kasih kepada Lance Pollard di dzone untuk memulai saya.

Cuplikan di atas terbatas pada platform berbasis Unix seperti Mac OS dan Linux, tetapi teknik yang sama dapat bekerja untuk Windows.

@ mallikarjun-m terima kasih!

fs-extra melakukan hal itu dan bahkan dapat mengembalikan Janji jika Anda tidak memberikan panggilan balik! :)

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

Yang dengan dukungan tautan simbolis + tidak melempar jika direktori ada.

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

Kode ini akan berfungsi dengan baik, menyalin folder apa pun secara rekursif ke lokasi mana pun. Hanya untuk 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+"\\\"");
}

Berfungsi sempurna untuk game Berbasis Teks saya untuk membuat pemain baru.

Saya mencoba fs-extra dan menyalin-dir untuk menyalin-folder-secara rekursif. tapi aku menginginkannya

1. bekerja secara normal (copy-dir melempar kesalahan yang tidak dapat diperbaiki)
2. memberikan dua argumen dalam filter: filepath dan filetype (fs-extra does not tell filetype)
3. memiliki pemeriksaan dir-to-subdir dan pemeriksaan dir-to-file

Jadi saya menulis sendiri:

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

dan fungsi serupa mkdirs, yang merupakan alternatif untuk 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`);
    }
  }
}

Saya menulis fungsi ini untuk menyalin file (copyFileSync) atau memindahkan (renameSync) file secara rekursif antara direktori:

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

Jika Anda berada di Linux, dan kinerja tidak menjadi masalah, Anda dapat menggunakan execfungsi dari child_processmodul, untuk menjalankan perintah bash:

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

Dalam beberapa kasus, saya menemukan solusi ini lebih bersih daripada mengunduh seluruh modul atau bahkan menggunakan fsmodul.

ncp mengunci deskriptor file dan mengaktifkan panggilan balik saat belum dibuka. Saya merekomendasikan untuk menggunakan modul salin rekursif sebagai gantinya. Ini mendukung acara dan Anda dapat yakin pada akhir salinan.

Hati-hati saat memilih paket Anda. Beberapa paket seperti copy-dir tidak mendukung copy file berukuran besar lebih dari 0x1fffffe8 karakter. Ini akan menimbulkan beberapa kesalahan seperti:

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

Saya pernah mengalami hal seperti ini di salah satu proyek saya. Pada akhirnya, saya harus mengubah paket yang saya gunakan dan menyesuaikan banyak kode. Saya akan mengatakan bahwa ini bukan pengalaman yang sangat menyenangkan.

Jika beberapa sumber dan beberapa tujuan salinan diinginkan, Anda dapat menggunakan lebih baik menyalin dan menulis sesuatu seperti ini:

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

atau bahkan :

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

Ya, ncpapakah cool...

Anda mungkin ingin / harus menjanjikan fungsinya untuk membuatnya super cool. Karena Anda melakukannya, tambahkan ke toolsfile untuk menggunakannya kembali.

Di bawah ini adalah versi yang berfungsi Asyncdan sedang digunakan 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;

Pendekatan termudah untuk masalah ini adalah hanya menggunakan modul 'fs' dan 'Path' dan beberapa logika .....

Semua file dalam folder root salin dengan Nama Baru jika Anda Hanya ingin mengatur nomor versi yaitu ....................... "var v = 'Direktori Anda Nama'"

dalam awalan nama File V konten ditambahkan dengan Nama file.

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

Inilah yang saya lakukan:

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

kemudian:

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

Kemudian panggil metode:

This.walkSync(filePath, fileList)