Fatal编程技术网
  • javascript/
  • Javascript 在Node.js中递归复制文件夹

Javascript 在Node.js中递归复制文件夹

javascript node.js

Javascript 在Node.js中递归复制文件夹,javascript,node.js,fs,Javascript,Node.js,Fs,是否有一种更简单的方法可以复制文件夹及其所有内容，而无需手动递归执行一系列的fs.readir，fs.readfile，fs.writefile 我只是想知道我是否缺少一个理想情况下可以这样工作的函数： fs.copy("/path/to/source/folder", "/path/to/destination/folder"); 您可以使用该模块。我想这就是您需要的。有些模块支持复制文件夹及其内容。最受欢迎的是： 另一种选择是： 因为我只是在构建一个

是否有一种更简单的方法可以复制文件夹及其所有内容，而无需手动递归执行一系列的
fs.readir
，
fs.readfile
，
fs.writefile

我只是想知道我是否缺少一个理想情况下可以这样工作的函数：

fs.copy("/path/to/source/folder", "/path/to/destination/folder");
您可以使用该模块。我想这就是您需要的。

有些模块支持复制文件夹及其内容。最受欢迎的是：

另一种选择是：

因为我只是在构建一个简单的Node.js脚本，我不希望脚本的用户需要导入一堆外部模块和依赖项，所以我戴上我的思维帽，从bashshell中搜索正在运行的命令

此Node.js代码段递归地将名为Node-webkit.app的文件夹复制到名为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 {

    }
});
谢谢你让我开始

上面的代码片段仅限于基于Unix的平台，如macOS和Linux，但类似的技术可能适用于Windows。

这里有一个函数，可以递归地将目录及其内容复制到另一个目录：

const fs=require（“fs”）
const path=require（“路径”）
/**
*看，妈，这是cp-R。
*@param{string}src要复制的对象的路径。
*@param{string}删除新副本的路径。
*/
var copyRecursiveSync=函数（src，dest）{
var exists=fs.existsSync（src）；
var stats=exists&&fs.statSync（src）；
var isDirectory=exists&&stats.isDirectory（）；
国际单项体育联合会（isDirectory）{
fs.mkdirSync（dest）；
fs.readdirSync（src.forEach）（函数（childItemName）{
copyRecursiveSync（path.join（src，childItemName），
join（dest，childItemName））；
});
}否则{
fs.copyFileSync（src，dest）；
}
};
这是我解决这个问题的方法，不需要任何额外的模块。只需使用内置的
fs
和
path
模块即可

注意：这确实使用了fs的读/写功能，因此不会复制任何元数据（创建时间等）。从Node.js 8.5开始，有一个
copyFileSync
函数可用，它调用操作系统的复制函数，因此也复制元数据。我还没有测试它们，但它应该可以取代它们。（见附件）

var fs=require（'fs'）；
var path=require（'path'）；
函数copyFileSync（源、目标）{
var targetFile=target；
//如果目标是一个目录，将创建一个同名的新文件
如果（fs.existsSync（目标））{
if（fs.lstatSync（target.isDirectory（））{
targetFile=path.join（目标，path.basename（源））；
}
}
fs.writeFileSync（targetFile，fs.readFileSync（source））；
}
函数copyFolderRecursiveSync（源、目标）{
var文件=[]；
//检查是否需要创建或集成文件夹
var targetFolder=path.join（目标，path.basename（源））；
如果（！fs.existsSync（targetFolder））{
fs.mkdirSync（targetFolder）；
}
//抄袭
if（fs.lstatSync（source.isDirectory（））{
files=fs.readdirSync（源）；
forEach（函数（文件）{
var curSource=path.join（源，文件）；
if（fs.lstatSync（curSource.isDirectory（））{
copyFolderRecursiveSync（curSource，targetFolder）；
}否则{
copyFileSync（curSource，targetFolder）；
}
} );
}
}
这段代码可以很好地工作，递归地将任何文件夹复制到任何位置。但它只是窗户

var child = require("child_process");
function copySync(from, to){
    from = from.replace(/\//gim, "\\");
    to = to.replace(/\//gim, "\\");
    child.exec("xcopy /y /q \"" + from + "\\*\" \"" + to + "\\\"");
}
它非常适合我的基于文本的游戏，用于创建新玩家。

fs extra
在
ncp
和
扳手
不足时对我有效：

我创建了一个小的工作示例，只需几个步骤即可将源文件夹复制到另一个目标文件夹（基于使用ncp）：

步骤1-安装ncp模块：

npm install ncp --save

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.');
});
步骤2-创建copy.js（根据需要修改srcPath和destPath变量）：

npm install ncp --save

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
对于Linux/Unix操作系统，可以使用shell语法

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

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

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

fs额外模块工作起来很有魅力

安装fs extra：

$ npm install fs-extra
以下是将源目录复制到目标目录的程序

// Include the fs-extra package
var fs = require("fs-extra");

var source = 'folderA'
var destination = 'folderB'

// Copy the source folder to the destination
fs.copy(source, destination, function (err) {
    if (err){
        console.log('An error occurred while copying the folder.')
        return console.error(err)
    }
    console.log('Copy completed!')
});
工具书类 财政司司长额外：

示例：-

是，
ncp
是
cool
但是。。。 您可能想要/应该宣传它的功能，使其超酷。当您使用它时，将它添加到
tools
文件中以重用它

下面是一个工作版本，它是
异步的
，使用
承诺

文件index.js 文件tools.js !

fs extra做了这件事，如果您不提供回调，它甚至可以返回一个承诺：）

解决此问题的最简单方法是仅使用“fs”和“Path”模块以及一些逻辑

如果您只想设置版本号，即“var v=‘Your Directory name’”，则根文件夹中的所有文件都将使用新名称进行复制

在文件名前缀中，添加了与文件名一起添加的内容

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

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标志=假；
var directoryPath=[]；
var directoryName=[]；
var directoryFileName=[]；
var文件名；
var目录名称存储器；
var dc=0；
var路径；
如果（！fs.existsSync（v））{
财政司司长(五)；
}
var basePath=path.join（uu dirname，v）；
功能步行（dir）{
fs.readdir（dir，函数（err，items）{
items.forEach（函数（文件）{
file=path.resolve（dir，file）；
fs.stat（文件，函数（err，stat）{
if（stat&&stat.isDirectory（））{
directoryNameStorer=path.basename（文件）；

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;



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 occurred while copying the folder.')
    return console.error(err)
  })



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



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



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



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



let filePath = // Your file path

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)



// Node.js module for Node.js 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;
  }
};



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



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



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




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



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



const fse = require('fs-extra');

const srcDir = `path/to/file`;
const destDir = `path/to/destination/directory`;
                              
// To copy a folder or file  
fse.copySync(srcDir, destDir, function (err) {
  if (err) {                 ^
    console.error(err);      |___{ overwrite: true } // add if you want to replace existing folder or file with same name
  } else {
    console.log("success!");
  }
});



// To copy a folder or file  
fse.moveSync(srcDir, destDir, function (err) {
  if (err) {                 ^
    console.error(err);      |___{ overwrite: true } // add if you want to replace existing folder or file with same name
  } else {
    console.log("success!");
  }
});



const fs = require('fs-extra');
let sourceDir = '/tmp/src_dir';
let destDir = '/tmp/dest_dir';
try {
  fs.copySync(sourceDir, destDir, { recursive: true })
  console.log('success!')
} catch (err) {
  console.error(err)
}




const bash = require('shelljs');
bash.cp("-rf", "/path/to/source/folder", "/path/to/destination/folder");