Có một cách dễ dàng hơn để sao chép một thư mục và tất cả các nội dung của nó không bằng tay làm một chuỗi các fs.readir, fs.readfile,fs.writefile đệ quy?

Chỉ tự hỏi nếu tôi thiếu một chức năng lý tưởng sẽ làm việc như thế này

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

Bạn có thể sử dụng mô-đun ncp . Tôi nghĩ rằng đây là những gì bạn cần

Đây là cách tiếp cận của tôi để giải quyết vấn đề này mà không cần thêm bất kỳ mô-đun nào. Chỉ cần sử dụng tích hợp fsvà pathmô-đun.

Lưu ý: Điều này không sử dụng các chức năng đọc / ghi của fs để nó không sao chép bất kỳ dữ liệu meta nào (thời gian tạo, v.v.). Kể từ nút 8.5, có một copyFileSyncchức năng có sẵn để gọi các chức năng sao chép hệ điều hành và do đó cũng sao chép dữ liệu meta. Tôi chưa kiểm tra chúng, nhưng nó chỉ hoạt động để thay thế chúng. (Xem 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 );
            }
        } );
    }
}

Có một số mô-đun hỗ trợ sao chép các thư mục với nội dung của chúng. Phổ biến nhất sẽ là cờ lê

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

Một thay thế sẽ là nút-fs-thêm

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

Đây là một chức năng sao chép đệ quy một thư mục và nội dung của nó sang một thư mục khác:

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-extralàm việc cho tôi khi nào ncpvà wrenchgiảm xuống:

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

Đối với hệ điều hành linux / unix, bạn có thể sử dụng cú pháp shell

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

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

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

Đó là nó!

mô-đun fs-Extra hoạt động như một nét duyên dáng.

Cài đặt thêm fs

$ npm install fs-extra

Sau đây là chương trình sao chép thư mục nguồn vào thư mục đích.

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

Người giới thiệu

fs-thêm: https://www.npmjs.com/package/fs-extra

Ví dụ: Hướng dẫn NodeJS - Node.js Sao chép thư mục

Đây là cách tôi sẽ làm điều đó cá nhân:

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

hoạt động cho các thư mục và tập tin

Tôi đã tạo một ví dụ hoạt động nhỏ sao chép thư mục nguồn sang thư mục đích khác chỉ trong vài bước (dựa trên câu trả lời @ shift66 bằng ncp):

Bước 1 - Cài đặt mô-đun ncp:

npm install ncp --save

bước 2 - tạo copy.js (sửa đổi srcPath và DestPath vars thành bất cứ thứ gì bạn cần):

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

bước 3 - chạy

node copy.js

Điều này khá dễ dàng với nút 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);
        }
    }
}

Giả định destnày không tồn tại.

Tôi biết rất nhiều câu trả lời đã có ở đây nhưng không ai trả lời nó một cách đơn giản. Về tài liệu chính thức của fs-exra , bạn có thể làm điều đó rất dễ dàng

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

Vì tôi chỉ đang xây dựng một tập lệnh nút đơn giản, tôi không muốn người dùng tập lệnh cần nhập một loạt các mô-đun và phụ thuộc bên ngoài, vì vậy tôi đã đặt trên nắp suy nghĩ của mình và thực hiện tìm kiếm để chạy các lệnh từ bash vỏ.

Đoạn mã node.js này sao chép đệ quy một thư mục có tên là node-webkit.app vào một thư mục có tên là 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 {

        }
    });

Cảm ơn Lance Pollard tại dzone đã giúp tôi bắt đầu.

Đoạn mã trên được giới hạn trong các nền tảng dựa trên Unix như Mac OS và Linux, nhưng một kỹ thuật tương tự có thể hoạt động cho Windows.

@ mallikarjun-m cảm ơn bạn!

fs-Extra đã làm điều đó và nó thậm chí có thể trả lại Promise nếu bạn không cung cấp cuộc gọi lại! :)

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

Cái có hỗ trợ liên kết tượng trưng + không ném nếu thư mục tồn tại.

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

Mã này sẽ hoạt động tốt, sao chép đệ quy bất kỳ thư mục nào vào bất kỳ vị trí nào. Chỉ có 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+"\\\"");
}

Hoạt động hoàn hảo cho trò chơi Dựa trên văn bản của tôi để tạo người chơi mới.

Tôi đã thử fs-Extra và copy-dir để sao chép thư mục-đệ quy. nhưng tôi muốn điều đó

1. hoạt động bình thường (copy-dir ném lỗi không thể khắc phục)
2. cung cấp hai đối số trong bộ lọc: filepath và filetype (fs-Extra không cho filetype)
3. có kiểm tra dir-to-subir và kiểm tra dir-to-file

Vì vậy, tôi đã viết của riêng tôi:

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

và một mkdirs chức năng tương tự, là một thay thế cho 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`);
    }
  }
}

Tôi đã viết hàm này cho cả hai tệp sao chép (copyFileSync) hoặc di chuyển (renameSync) đệ quy giữa các thư mục:

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

Nếu bạn đang ở trong Linux và hiệu suất không phải là vấn đề, bạn có thể sử dụng execchức năng từ child_processmô-đun để thực hiện lệnh bash:

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

Trong một số trường hợp, tôi thấy giải pháp này sạch hơn so với tải xuống toàn bộ mô-đun hoặc thậm chí sử dụng fsmô-đun.

ncp khóa bộ mô tả tập tin và thực hiện gọi lại khi nó chưa được mở khóa. Tôi khuyên bạn nên sử dụng mô-đun sao chép đệ quy thay thế. Nó hỗ trợ các sự kiện và bạn có thể chắc chắn trong bản sao kết thúc.

Hãy cẩn thận khi chọn gói của bạn. Một số gói như copy-dir không hỗ trợ sao chép tệp lớn hơn 0x1fffffe8 ký tự. Nó sẽ đưa ra một số lỗi như:

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

Tôi đã trải nghiệm một cái gì đó như thế này trong một trong các dự án của tôi. Cuối cùng, tôi đã phải thay đổi gói tôi đang sử dụng và điều chỉnh rất nhiều mã. Tôi sẽ nói rằng đây không phải là một kinh nghiệm rất dễ chịu.

Nếu muốn có nhiều nguồn và nhiều bản sao đích, bạn có thể sử dụng bản sao tốt hơn và viết một cái gì đó như thế này:

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

hoặc thậm chí:

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

CÓ, ncplà coolmặc dù ...

Bạn có thể muốn / nên quảng bá chức năng của nó để thực hiện super cool. Vì bạn đang ở đó, hãy thêm nó vào một toolstệp để sử dụng lại.

Dưới đây là một phiên bản làm việc được Asyncvà sử dụng 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;

Cách tiếp cận dễ nhất cho vấn đề này là chỉ sử dụng mô đun 'fs' và 'Path' và một số logic .....

Tất cả các tệp trong thư mục gốc sao chép với Tên mới nếu bạn chỉ muốn đặt số phiên bản tức là ....................... "var v = 'Thư mục của bạn Tên'"

trong tên tệp Tiền tố nội dung V được thêm vào với tên tệp.

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

Đây là cách tôi đã làm:

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

sau đó:

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

Sau đó gọi methode:

This.walkSync(filePath, fileList)