반응형
node.js에서 폴더를 재귀 적으로 복사
수동의 순서를하지 않고 폴더와 모든 콘텐츠를 복사 할 수있는 쉬운 방법이 있습니까 fs.readir, fs.readfile, fs.writefile재귀는?
이상적으로 이와 같이 작동하는 기능이 누락되어 있는지 궁금합니다.
fs.copy("/path/to/source/folder","/path/to/destination/folder");
ncp 모듈을 사용할 수 있습니다 . 나는 이것이 당신이 필요로 생각합니다
이것은 추가 모듈 없이이 문제를 해결하는 나의 접근 방식입니다. 내장 fs및 path모듈 만 사용하십시오 .
참고 : 이것은 fs의 읽기 / 쓰기 기능을 사용하므로 메타 데이터 (생성 시간 등)를 복사하지 않습니다. 노드 8.5부터는 copyFileSyncOS 복사 기능을 호출하여 메타 데이터를 복사 하는 기능이 있습니다. 아직 테스트하지는 않았지만 교체하는 것이 좋습니다. ( 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 );
}
} );
}
}
내용과 함께 폴더 복사를 지원하는 일부 모듈이 있습니다. 가장 인기있는 것은 렌치입니다
// 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
fs-extra때 나를 위해 일한 ncp및 wrench하회 :
https://www.npmjs.com/package/fs-extra
/**
* 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 (exists && isDirectory) {
fs.mkdirSync(dest);
fs.readdirSync(src).forEach(function(childItemName) {
copyRecursiveSync(path.join(src, childItemName),
path.join(dest, childItemName));
});
} else {
fs.copyFile(src, dest); // UPDATE FROM: fs.linkSync(src, dest);
}
};
Linux / unix OS의 경우 쉘 구문을 사용할 수 있습니다
const shell = require('child_process').execSync ;
const src= `/path/src`;
const dist= `/path/dist`;
shell(`mkdir -p ${dist}`);
shell(`cp -r ${src}/* ${dist}`);
그게 다야!
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를 복사
몇 단계 만 거치면 소스 폴더를 다른 대상 폴더로 복사하는 작은 실제 예제를 만들었습니다 (ncp를 사용한 @ shift66 응답 기반).
1 단계-ncp 모듈 설치 :
npm install ncp --save
2 단계-copy.js 작성 (srcPath 및 destPath 변수를 필요한대로 수정) :
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
이것이 내가 개인적으로하는 방법입니다.
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));
}
});
}
폴더 및 파일에 사용
간단한 노드 스크립트를 작성하고 있기 때문에 스크립트 사용자가 많은 외부 모듈과 종속성을 가져 오기를 원하지 않기 때문에 사고 뚜껑을 쓰고 bash에서 명령 실행을 검색했습니다. 껍질.
이 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 {
}
});
dzone의 Lance Pollard 에게 감사의 말을 전 합니다.
위의 스 니펫은 Mac OS 및 Linux와 같은 Unix 기반 플랫폼으로 제한되지만 Windows에서도 유사한 기술이 작동 할 수 있습니다.
@ mallikarjun-m 감사합니다!
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)
})
이것은 노드 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존재하지 않는 것으로 가정 합니다.
이 코드는 모든 폴더를 모든 위치에 재귀 적으로 복사하여 정상적으로 작동합니다. 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+"\\\"");
}
새로운 플레이어를 만들기 위해 내 텍스트 기반 게임에 완벽하게 작동합니다.
fs-extra 및 copy-dir을 복사 폴더로 재귀 적으로 시도했습니다. 그러나 나는 그것을 원한다
- 정상적으로 작동합니다 (copy-dir에서 부적합한 오류가 발생 함)
- 필터에서 filepath와 filetype의 두 가지 인수를 제공합니다 (fs-extra가 파일 형식을 알려주지 않음).
- 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;}
};
mkdirp의 대안 인 유사한 함수 mkdirs
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`);
}
}
}
디렉토리간에 파일을 재귀 적으로 복사 (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);
}
});}
나는 이미 많은 답변을 알고 있지만 아무도 간단한 방법으로 대답하지 않았습니다. 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')
YES, 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;
이 문제에 대한 가장 쉬운 방법은 '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");
})
이것이 내가 한 방법입니다.
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)
참고 URL : https://stackoverflow.com/questions/13786160/copy-folder-recursively-in-node-js
반응형
'IT story' 카테고리의 다른 글
| jest 테스트에서 localStorage를 어떻게 처리합니까? (0) | 2020.07.11 |
|---|---|
| Capybara 2.0으로 업그레이드 한 후 항목 목록에서 첫 번째 링크를 클릭하는 방법은 무엇입니까? (0) | 2020.07.11 |
| 픽셀을 포인트로 변환 (0) | 2020.07.11 |
| CSS 끝없는 회전 애니메이션 (0) | 2020.07.11 |
| React + ES6 + 웹팩을 사용하여 컴포넌트를 가져오고 내보내는 방법은 무엇입니까? (0) | 2020.07.11 |