नोड .js में पुनरावर्ती फ़ोल्डर की प्रतिलिपि बनाएँ


154

वहाँ मैन्युअल का एक अनुक्रम कर के बिना एक फ़ोल्डर और उसकी सभी सामग्री कॉपी करने के लिए एक आसान तरीका है fs.readir, fs.readfile, fs.writefileरिकर्सिवली?

अगर मैं एक समारोह याद कर रहा हूँ जो सोच रहा था कि आदर्श रूप से इस तरह काम करेगा

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

3
क्या बिना किसी मॉड्यूल के ऐसा करने का कोई तरीका है? शायद एक पुनरावर्ती कार्य / कोड स्निप-इट?
सुकीमा Su

@ सुकिमा - यहाँ मेरा जवाब देखें ।
jmort253

जवाबों:


121

आप ncp मॉड्यूल का उपयोग कर सकते हैं । मुझे लगता है कि आपको यही चाहिए


2
उत्तम! npm install ncpऔर 30 से कम समय में काम करना। धन्यवाद।
ऐसबसिस

1
रिंच मेरे लिए बेहतर है, क्योंकि यह अधिक विकल्पों का समर्थन करता है। एनसीपी के साथ आप उदाहरण के लिए सहानुभूति को हल नहीं कर सकते।
स्लाव फोमिन II

3
एक अद्भुत बोनस के रूप में, एक क्रॉस प्लेटफॉर्म npm रन स्क्रिप्ट में ncp का उपयोग कर सकता है।
Ciantic

मुझे कुछ सरल मामले मिले जहां एनसीपी मेरे कॉलबैक में नहीं जाता है जहां एफएस-एक्स्ट्रा सही ढंग से होता है।
bumpmann

40
कृपया ध्यान दें कि एनसीपी अस्वाभाविक प्रतीत होता हैfs-extra शायद इसके बजाय सबसे अच्छा विकल्प है।
क्रिस

74

बिना किसी अतिरिक्त मॉड्यूल के इस समस्या को हल करने के लिए यह मेरा दृष्टिकोण है। बिल्ट-इन fsऔर pathमॉड्यूल का उपयोग करना ।

नोट: यह fs के पढ़ने / लिखने के कार्यों का उपयोग करता है इसलिए यह किसी मेटा डेटा (निर्माण का समय आदि) की नकल नहीं करता है। नोड 8.5 के रूप में एक copyFileSyncफ़ंक्शन उपलब्ध है जो ओएस कॉपी फ़ंक्शन को कॉल करता है और इसलिए मेटा डेटा को भी कॉपी करता है। मैंने उन्हें अभी तक परीक्षण नहीं किया है, लेकिन यह सिर्फ उन्हें बदलने के लिए काम करना चाहिए। ( 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 );
            }
        } );
    }
}

अगर उनके नाम में जगह है तो यह फोल्डर की नकल नहीं करता है
31415926

मेरे लिए यह उनके नाम के रिक्त स्थान वाले फ़ोल्डर की प्रतिलिपि बनाता है। शायद यह @victor द्वारा सही किए गए त्रुटि के कारण था। जैसा कि मैं इस फ़ंक्शन का उपयोग नियमित रूप से कर रहा हूं (वर्तमान स्थिति में, जैसा कि मैं बहुत ही सुधार विजेता को अपडेट करना भूल गया), मुझे पूरा यकीन है कि यह सामान्य रूप से काम करता है।
साइमन ज़ीक्स

1
इसके अलावा की जरूरत है:javascript var fs = require('fs'); var path = require('path');
टायलर

2
यह वास्तव में फ़ाइलों की नकल नहीं करता है। यह उन्हें पढ़ता है फिर उन्हें लिखता है। वह नकल नहीं है। प्रतिलिपि बनाने में निर्माण तिथि के साथ-साथ अन्य मेटा डेटा स्ट्रीम भी शामिल हैं जो विंडोज और मैकओएस दोनों का समर्थन करते हैं और इस कोड द्वारा कॉपी नहीं किए जाते हैं। नोड should.५ के रूप में आपको कॉल करना चाहिए fs.copyया fs.copySyncजैसा कि वे वास्तविक रूप से मैकओएस और विंडोज में ओएस स्तर की कॉपी फ़ंक्शन को कॉल करते हैं और इसलिए वास्तव में फ़ाइलों की प्रतिलिपि बनाते हैं।
gman

1
क्षमा fs.copyFileकरें, यदि आप मैक और विंडोज पर नोड स्रोत के माध्यम से अपनी खुदाई करते हैं, तो वे फ़ाइल को कॉपी करने के लिए ओएस विशिष्ट फ़ंक्शन को कॉल करते हैं
gman

52

कुछ मॉड्यूल हैं जो अपनी सामग्री के साथ फ़ोल्डर्स की प्रतिलिपि बनाने का समर्थन करते हैं। सबसे लोकप्रिय रिंच होगा

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

एक नोड नोड-एफएस-अतिरिक्त होगा

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

3
रिंच को विफल करता है यदि निर्देशिका की प्रतिलिपि करने के लिए एक प्रतीकात्मक लिंक होता है
DoubleMalt

2
यह विंडोज पर भी विफल रहता है यदि निर्देशिका पहले से मौजूद है, तो ncp ने बैग से ठीक बाहर काम किया।
ब्लेंड किया

6
नोड- fs-extra ने मेरे लिए काम किया। यह मूल fs विरासत में मिला है और मुझे पसंद आया कि यह प्रक्रिया को संभालने का तरीका है। ऐप में अपडेट करने के लिए कम कोड।
DVDMn

15
कृपया ध्यान दें कि wrenchहटा दिया गया है और इसे node-fs-extra( github.com/jprichardson/node-fs-extra ) से बदल दिया जाना चाहिए
Ambidex

1
रिंच वास्तव में फाइलों की नकल नहीं करता है। यह उन्हें पढ़ता है, फिर उन्हें लिखता है, फिर उनकी तिथि की प्रतिलिपि बनाता है। वह नकल नहीं है। नकल में अन्य मेटा डेटा स्ट्रीम शामिल हैं जो विंडोज और मैकओएस दोनों का समर्थन करते हैं और रिंच द्वारा कॉपी नहीं किए जाते हैं।
gman

38

यहां एक फ़ंक्शन है जो किसी निर्देशिका की पुन: प्रतिलिपि बनाता है और यह किसी अन्य निर्देशिका की सामग्री है:

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

3
यहां तक ​​कि अगर आप एक वास्तविक प्रतिलिपि फ़ंक्शन सम्मिलित करेंगे, तो आपको प्रतीकात्मक लिंक का उपयोग नहीं करना चाहिए ( fs.lstatSyncइसके बजाय उपयोग करें fs.statSync)
साइमन ज़ीएक्स

3
इस भ्रम का कारण क्या हो सकता है कि fs.unlink फ़ाइलों को हटा देता है, लेकिन fs.link लिंक को कॉपी नहीं करता है।
सिमोन ज़ीक्स

3
@SimonSeyock: सही है .. आईटी linkingकॉपी नहीं कर रहा है .. मुद्दा यह है कि जब आप लिंक की गई फ़ाइल की सामग्री को संशोधित करते हैं, तो मूल फ़ाइल भी बदल जाएगी।
अब्देनूर टुमी

30

fs-extraमेरे लिए काम किया जब छोटा ncpऔर wrenchगिर गया:

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


3
इसके अतिरिक्त, wrenchडायरेक्टर्स उपयोगकर्ताओं को fs-extraअपने पुस्तकालय का उपयोग करने के लिए निर्देशित करता है ।
mozillalives

22

लिनक्स / यूनिक्स ओएस के लिए, आप शेल सिंटैक्स का उपयोग कर सकते हैं

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

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

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

बस!


1
आप कर रहे हैं आपका स्वागत है 👋
Abdennour Toumi

1
यह सबसे सरल उपाय है। यूनिक्स उपकरणों को फिर से आविष्कार करने की आवश्यकता नहीं है!
माइकल फ्रांज़ल

11
चूंकि नोडज OSX / linux / windows पर चलता है, यह केवल 2 के लिए ही जवाब नहीं है 3.
mjwrazor

2
यदि आप विंडोज़ सर्वर पर चल रहे हैं तो @AbdennourTOUMI।
mjwrazor

3
इसीलिए मैंने "linux / unix OS के लिए" से उत्तर की शुरुआत की, आप शेल सिंटैक्स का उपयोग कर सकते हैं .. "👍🏼
Abdennour TOUMI

19

fs-extra मॉड्यूल एक आकर्षण की तरह काम करता है।

Fs-extra स्थापित करें

$ npm install fs-extra

स्रोत निर्देशिका को गंतव्य निर्देशिका में कॉपी करने का कार्यक्रम निम्नलिखित है।

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

संदर्भ

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

उदाहरण: NodeJS ट्यूटोरियल - Node.js एक फ़ोल्डर की प्रतिलिपि बनाएँ


क्या यह प्रक्रिया निर्देशिका को प्रतिस्थापित करती है या इसके साथ विलय करती है?
एसएम शाहीनुल इस्लाम

14

इस तरह से मैं इसे व्यक्तिगत रूप से करूंगा:

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

फ़ोल्डर्स और फ़ाइलों के लिए काम करता है


3
यह घोल चटक और सीधा है। यह लगभग ऐसा ही होगा कि मैं इसे कैसे करूंगा, इसलिए मेरे से +1। आपको अपने कोड में टिप्पणियों के साथ अपने उत्तर में सुधार करना चाहिए और वर्णन करना चाहिए कि यह समाधान दूसरों पर क्यों पसंद किया जाता है और इसमें क्या कमियां हो सकती हैं। - यह भी अपडेट करें कि इसके लिए किन मॉड्यूल्स की जरूरत है। ("पथ", "एफएस")
एंड्रयू

जांचें कि क्या फ़ोल्डर शीर्ष पर मौजूद है ... जीवन को बचाएगा;; अगर ((fs.existsSync (से)) fs.mkdirSync (से);
टोबियास

9

मैंने एक छोटा सा काम करने वाला उदाहरण बनाया है जो एक स्रोत फ़ोल्डर को केवल कुछ चरणों में दूसरे गंतव्य फ़ोल्डर में कॉपी करता है (npp का उपयोग करके @ शिफ्ट 66 उत्तर पर आधारित):

चरण 1 - एनसीपी मॉड्यूल स्थापित करें:

npm install ncp --save

चरण 2 - copy.js बनाएँ (srcPath और destPath vars को जो भी आपकी आवश्यकता हो संशोधित करें):

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

चरण 3 - भागो

node copy.js

7

यह नोड 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);
        }
    }
}

यह मानता destनहीं है।


3
हम इस नोड 8.x में का उपयोग करके काम करने के लिए प्राप्त कर सकते हैं require('util').promisifyके साथ fs.mkdirऔर fs.copyFileके बजाय require('fs').promises, जो अभी भी v11.1 पर प्रयोगात्मक है।
सॉन ट्रन-गुयेन

@ सैंसरन 8. क्या withFileTypesविकल्प है? क्योंकि यह आपको एक statकॉल बचाता है
एमपीएन

दुर्भाग्य से, 8.x में withFileTypesविकल्प नहीं है ।
Sễn Trơn-Nguyơn

@ S @nTrần-Nguy 8.n 8.x 31 दिसंबर, 2019 को जीवन के अंत तक पहुंचता है - अपग्रेड करने का समय हो सकता है :-)
एमपीएन

6

मैं यहाँ पहले से ही इतने सारे उत्तर जानता हूँ, लेकिन किसी ने भी इसका सरल उत्तर नहीं दिया। Fs-exra आधिकारिक दस्तावेज के बारे में , आप इसे बहुत आसान कर सकते हैं

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

पुनरावर्ती विकल्प सेट करना सुनिश्चित करें। fs.copySync ('/ tmp / mydir', '/ tmp / mynewdir', {recursive: true})
धीरज कुमार

मुझे आपके द्वारा बताए { recursive: true }गए github doc का विकल्प नहीं मिल रहा है , पता नहीं यह काम है।
फ्रेडी डैनियल

मुझे लगता है कि हम fs-extra की बात कर रहे हैं, लेकिन आपका github लिंक नोड-fs-extra की ओर इशारा करता है। अलग पुस्तकालय हो सकता है?
धीरज कुमार

@DheerajKumar, यह नोड FS-अतिरिक्त GitHub लेकिन में FS-अतिरिक्त में से पता चलता NPM । मैं नहीं जानता कि दोनों समान हैं कृपया npm
फ्रेडी डैनियल

क्या fs-extra प्रतिस्थापित करता है fs?
मैट

4

चूंकि मैं सिर्फ एक सरल नोड स्क्रिप्ट का निर्माण कर रहा हूं, इसलिए मैं नहीं चाहता था कि स्क्रिप्ट के उपयोगकर्ता बाहरी मॉड्यूल और निर्भरता का एक गुच्छा आयात करने की आवश्यकता है, इसलिए मैंने अपनी सोच टोपी पर रखी और बैश से कमांड चलाने के लिए एक खोज की खोल।

यह नोड.जिस कोड स्निपेट बिल्ड- फोल्डर के नाम पर नोड-webkit.app नामक पुनरावर्ती रूप से कॉपी करता है:

   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 {

        }
    });

मुझे शुरू करने के लिए dzone पर लांस पोलार्ड का धन्यवाद ।

उपरोक्त स्निपेट मैक ओएस और लिनक्स जैसे यूनिक्स आधारित प्लेटफार्मों तक सीमित है, लेकिन विंडोज के लिए एक समान तकनीक काम कर सकती है।


4

@ मल्लिकार्जुन-एम शुक्रिया!

fs-extra ने बात की और कॉलबैक प्रदान नहीं करने पर यह वादा भी कर सकता है ! :)

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

2

यदि प्रतीकात्मक लिंक समर्थन + के साथ एक है तो निर्देशिका मौजूद नहीं है।

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

1

यह कोड ठीक काम करेगा, किसी भी फ़ोल्डर को किसी भी स्थान पर पुन: कॉपी करेगा। केवल विंडोज।

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

नए खिलाड़ियों को बनाने के लिए मेरे पाठ-आधारित खेल के लिए पूरी तरह से काम करता है।


1

मैंने fs-extra और copy-dir को कॉपी-फ़ोल्डर-पुनरावर्ती रूप से करने की कोशिश की। मगर मुझे यह चाहिए

  1. सामान्य रूप से काम करता है (कॉपी-डायन अनपेक्षित त्रुटि फेंकता है)
  2. फ़िल्टर में दो तर्क प्रदान करता है: फ़ाइलपथ और फ़ाइलप्राइप (fs-extra filetype नहीं बताता है)
  3. dir-to-subdir चेक और dir-to-file चेक है

इसलिए मैंने अपना लिखा:

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

और एक समान फ़ंक्शन mkdirs, जो 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`);
    }
  }
}

0

मैंने यह फ़ंक्शन कॉपी (copyFileSync) या मूविंग (renameSync) फ़ाइलों को निर्देशिकाओं के बीच पुनरावर्ती: दोनों के लिए लिखा था

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

0

यदि आप लिनक्स में हैं, और प्रदर्शन कोई समस्या नहीं है, तो आप बैश कमांड को निष्पादित करने के लिए मॉड्यूल execसे फ़ंक्शन का उपयोग कर सकते हैं child_process:

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

कुछ मामलों में, मैंने पूरे मॉड्यूल को डाउनलोड करने या यहां तक ​​कि fsमॉड्यूल का उपयोग करने की तुलना में इस समाधान को अधिक साफ पाया ।


0

ncp फ़ाइल डिस्क्रिप्टर को बंद कर देता है और कॉलबैक को निकालता है जब इसे अभी तक अनलॉक नहीं किया गया है। मैं इसके बजाय पुनरावर्ती-प्रतिलिपि मॉड्यूल का उपयोग करने की सलाह देता हूं । यह घटनाओं का समर्थन करता है और आप प्रतिलिपि समाप्त होने में सुनिश्चित हो सकते हैं।


0

अपना पैकेज उठाते समय सावधान रहें। कॉपी-डीआईआर जैसे कुछ पैकेज 0x1fffffe8 वर्ण से अधिक बड़ी फ़ाइल की प्रतिलिपि का समर्थन नहीं करते हैं। यह कुछ त्रुटि की तरह फेंक देगा:

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

मैंने अपने एक प्रोजेक्ट में कुछ ऐसा अनुभव किया है। अंततः, मुझे उस पैकेज को बदलना पड़ा जिसका मैं उपयोग कर रहा था और बहुत सारे कोड समायोजित कर रहा था। मैं कहूंगा कि यह बहुत सुखद अनुभव नहीं है।

यदि कई स्रोत और कई गंतव्य प्रतिलिपि वांछित हैं, तो आप बेहतर प्रतिलिपि का उपयोग कर सकते हैं और कुछ इस तरह लिख सकते हैं :

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

या और भी :

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

-1

हाँ, ncpहै coolहालांकि ...

आप चाहते हैं / बनाने के लिए अपने समारोह का वादा करना चाहिए super cool। चूंकि आप इस पर हैं, इसे toolsपुन: उपयोग करने के लिए फ़ाइल में जोड़ें ।

नीचे एक कार्यशील संस्करण है जो है Asyncऔर उपयोग करता है 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;

-1

इस समस्या के लिए सबसे आसान तरीका केवल 'fs' और 'Path' मॉड्यूल और कुछ तर्क का उपयोग करना है ....।

रूट फ़ोल्डर में सभी फाइलें नए नाम के साथ कॉपी होती हैं यदि आप केवल संस्करण संख्या सेट करना चाहते हैं, तो ....................... "var v '' निर्देशिका नाम ' "

फ़ाइल नाम में उपसर्ग V सामग्री फ़ाइल नाम के साथ जोड़ा गया है।

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

-1

मैंने ऐसा किया है:

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

फिर:

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

फिर मैथोड को कॉल करें:

This.walkSync(filePath, fileList)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.