Manuel bir dizi yapmadan bir klasör ve tüm içeriğini kopyalamak için daha kolay bir yolu var mı fs.readir, fs.readfile, fs.writefileyinelemeli?

İdeal olarak böyle çalışacak bir işlevi kaçırıp kaçırmadığımı merak ediyorum

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

Ncp modülünü kullanabilirsiniz . Bence ihtiyacın olan şey bu

Ekstra modüller olmadan bu sorunu çözme yaklaşımım budur. Sadece yerleşik fsve pathmodülleri kullanarak .

Not: Bu, fs'nin okuma / yazma işlevlerini kullanır, böylece meta verileri (oluşturma zamanı vb.) Kopyalamaz. 8.5 düğümünden copyFileSyncitibaren işletim sistemi kopyalama işlevlerini çağıran ve dolayısıyla meta verileri kopyalayan bir işlev vardır. Henüz test etmedim, ama sadece onları değiştirmek için çalışmak gerekir. (Bkz. 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 );
            }
        } );
    }
}

İçerikleriyle klasör kopyalamayı destekleyen bazı modüller vardır. En popüler anahtar olurdu

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

Alternatif olarak node-fs-extra olurdu

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

Bir dizini ve içeriğini başka bir dizine özyineli olarak kopyalayan bir işlev şunlardır:

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-extrane zaman benim için çalıştı ncpve wrenchdüştü:

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

Linux / unix OS için kabuk sözdizimini kullanabilirsiniz

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

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

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

Bu kadar!

fs-extra modülü cazibe gibi çalışır.

Fs-extra yükle

$ npm install fs-extra

Kaynak dizini hedef dizine kopyalamak için program aşağıdadır.

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

Referanslar

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

Örnek: NodeJS Eğitimi - Node.js Klasörü Kopyala

Şahsen ben böyle yapardım:

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

klasörler ve dosyalar için çalışır

Bir kaynak klasörü sadece birkaç adımda başka bir hedef klasöre kopyalayan küçük bir çalışma örneği oluşturdum (ncp kullanarak @ shift66 yanıtına dayanarak):

adım 1 - ncp modülünü takın:

npm install ncp --save

2. adım - copy.js oluşturun (srcPath ve destPath'i ihtiyacınız olana göre değiştirin):

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. adım - çalıştırın

node copy.js

Bu, düğüm 10 ile oldukça kolaydır.

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

Bu destvar olmadığı varsayılmaktadır .

Zaten burada çok fazla cevap biliyorum ama kimse bunu basit bir şekilde cevaplamadı Fs-exra resmi belgeleri ile ilgili olarak , bunu çok kolay yapabilirsiniz

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

Sadece basit bir düğüm komut dosyası oluşturduğum için, komut dosyası kullanıcılarının bir dizi harici modül ve bağımlılığı içe aktarmalarını istemedim, bu yüzden düşünme başlığımı koydum ve bash'den komutları çalıştırmak için bir arama yaptım kabuk.

Bu node.js kod snippet'i node-webkit.app adlı klasörü yinelemeli olarak build adlı bir klasöre kopyalar:

   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 {

        }
    });

Başladığım için dzone'daki Lance Pollard'a teşekkürler .

Yukarıdaki snippet, Mac OS ve Linux gibi Unix tabanlı platformlarla sınırlıdır, ancak benzer bir teknik Windows için işe yarayabilir.

@ mallikarjun-m teşekkür ederim!

fs-extra bir şey yaptı ve geri arama sağlamazsanız bile Promise dönebilir ! :)

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

İle bir sembolik bağlantı desteği dizin varsa + atmak değil.

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

Bu kod, herhangi bir klasörü herhangi bir konuma tekrar tekrar kopyalayarak gayet iyi çalışacaktır. Yalnızca 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+"\\\"");
}

Yeni oyuncular oluşturmak için Metin Tabanlı oyunum için mükemmel çalışıyor.

Ben fs-extra ve kopya-klasör-özyinelemeli-copy-dir denedim. ama ben istiyorum

1. normal çalışıyor (copy-dir yanıt verilemez bir hata veriyor)
2. filtrede iki bağımsız değişken sağlar: dosyayolu ve dosya tipi (fs-extra dosya türünü söylemez)
3. dir-to-subdir denetimi ve dir-to-file denetimi var

Bu yüzden kendim yazdım:

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

ve mkdirp'e alternatif olan mkdirs işlevine benzer

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

Bu işlevi hem kopyalama (copyFileSync) hem de dizinler arasında yinelemeli olarak taşıma (renameSync) için yazdım:

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

Linux'taysanız ve performans bir sorun değilse , bir bash komutu yürütmek için modülden execişlevi kullanabilirsiniz child_process:

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

Bazı durumlarda, bu çözümü tüm bir modülü indirmekten, hatta fsmodülü kullanmaktan daha temiz buldum .

ncp dosya tanımlayıcıyı kilitler ve henüz kilidi açılmadığında geri aramayı başlatır. Bunun yerine özyinelemeli kopya modülünü kullanmanızı öneririm . Olayları destekler ve kopya sonunda emin olabilirsiniz.

Paketinizi seçerken dikkatli olun. Copy-dir gibi bazı paketler, 0x1fffffe8 karakter uzunluğunda büyük dosyaları kopyalamayı desteklemez. Aşağıdaki gibi bir hata atar:

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

Projelerimden birinde böyle bir şey yaşadım. Sonuçta, kullandığım paketi değiştirmek ve çok fazla kod ayarlamak zorunda kaldım. Bunun çok hoş bir deneyim olmadığını söyleyebilirim.

Birden çok kaynak ve birden çok hedef kopya isteniyorsa, daha iyi kopya kullanabilir ve şöyle bir şey yazabilirsiniz:

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

ya da :

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

EVET, ncpöyle cool...

İsteyebilirsiniz / işlevini yapmak için söz veriyorum super cool. İçinde bulunduğunuzdan, toolsyeniden kullanmak için bir dosyaya ekleyin .

Aşağıda çalışan Asyncve kullanılan çalışan bir sürüm bulunmaktadır 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;

Bu sorun için en kolay yaklaşım sadece 'fs' ve 'Path' modülünü ve bazı mantığı kullanmaktır .....

Kök klasördeki tüm dosyalar Yeni Ad ile kopyalanır, örneğin sürüm numarasını ayarlayın ....................... "var v = 'Dizininiz Adı '"

Dosya adı öneki V dosya adıyla eklenen içerik.

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

Ben böyle yaptım:

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

sonra:

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

Ardından yöntemi çağırın:

This.walkSync(filePath, fileList)