nodejs의 폴더 아래에 있는 *. html 확장명으로 파일 찾기

nodejs의 폴더 아래에 있는 *. html 확장명으로 파일 찾기

src 폴더의 모든 *.html 파일과 nodejs를 사용하는 모든 하위 폴더를 찾고 싶습니다.그것을 하는 가장 좋은 방법은 무엇입니까?

var folder = '/project1/src';
var extension = 'html';
var cb = function(err, results) {
   // results is an array of the files with path relative to the folder
   console.log(results);

}
// This function is what I am looking for. It has to recursively traverse all sub folders. 
findFiles(folder, extension, cb);

많은 개발자들이 훌륭하고 검증된 솔루션을 가져야 하고 직접 작성하는 것보다 그것을 사용하는 것이 더 낫다고 생각합니다.

node.js, 재귀적 단순 함수:

var path = require('path'),
fs = require('fs');

function fromDir(startPath, filter) {

    //console.log('Starting from dir '+startPath+'/');

    if (!fs.existsSync(startPath)) {
        console.log("no dir ", startPath);
        return;
    }

    var files = fs.readdirSync(startPath);
    for (var i = 0; i < files.length; i++) {
        var filename = path.join(startPath, files[i]);
        var stat = fs.lstatSync(filename);
        if (stat.isDirectory()) {
            fromDir(filename, filter); //recurse
        } else if (filename.endsWith(filter)) {
            console.log('-- found: ', filename);
        };
    };
};

fromDir('../LiteScript', '.html');

화려해지고 싶다면 RegExp를 추가하고, 일반적인 것으로 만들기 위해 콜백을 추가합니다.

var path = require('path'),
fs = require('fs');

function fromDir(startPath, filter, callback) {

    //console.log('Starting from dir '+startPath+'/');

    if (!fs.existsSync(startPath)) {
        console.log("no dir ", startPath);
        return;
    }

    var files = fs.readdirSync(startPath);
    for (var i = 0; i < files.length; i++) {
        var filename = path.join(startPath, files[i]);
        var stat = fs.lstatSync(filename);
        if (stat.isDirectory()) {
            fromDir(filename, filter, callback); //recurse
        } else if (filter.test(filename)) callback(filename);
    };
};

fromDir('../LiteScript', /\.html$/, function(filename) {
    console.log('-- found: ', filename);
});

나는 glob 패키지를 사용하는 것을 좋아합니다.

const glob = require('glob');

glob(__dirname + '/**/*.html', {}, (err, files)=>{
  console.log(files)
})

뭐, 잠깐만!좋아요, 다른 사람들에게도 이게 더 말이 되나 봐요.

[nodejs 7 mind you]

const fs = import('fs');
const dirCont = fs.readdirSync( dir );
const files = dirCont.filter( ( elm ) => elm.match(/.*\.(html?)/ig));

regex로 무엇을 하든지 기본값 등과 함께 함수에서 설정한 인수로 만듭니다.

루시오의 코드를 바탕으로 모듈을 만들었습니다.특정 확장명을 가진 모든 파일이 하나 아래에 있는 어웨이를 반환합니다.필요한 사람이 있으면 여기에 올려주세요.

var path = require('path'), 
    fs   = require('fs');


/**
 * Find all files recursively in specific folder with specific extension, e.g:
 * findFilesInDir('./project/src', '.html') ==> ['./project/src/a.html','./project/src/build/index.html']
 * @param  {String} startPath    Path relative to this file or other file which requires this files
 * @param  {String} filter       Extension name, e.g: '.html'
 * @return {Array}               Result files with path string in an array
 */
function findFilesInDir(startPath,filter){

    var results = [];

    if (!fs.existsSync(startPath)){
        console.log("no dir ",startPath);
        return;
    }

    var files=fs.readdirSync(startPath);
    for(var i=0;i<files.length;i++){
        var filename=path.join(startPath,files[i]);
        var stat = fs.lstatSync(filename);
        if (stat.isDirectory()){
            results = results.concat(findFilesInDir(filename,filter)); //recurse
        }
        else if (filename.indexOf(filter)>=0) {
            console.log('-- found: ',filename);
            results.push(filename);
        }
    }
    return results;
}

module.exports = findFilesInDir;

파일하운드를 사용하여 이 작업을 수행할 수 있습니다.

예를 들어, /tmp에서 모든 .html 파일을 찾습니다.

const Filehound = require('filehound');

Filehound.create()
  .ext('html')
  .paths("/tmp")
  .find((err, htmlFiles) => {
    if (err) return console.error("handle err", err);

    console.log(htmlFiles);
});

자세한 정보(및 예)는 문서: https://github.com/nspragg/filehound 를 참조하십시오.

면책 사항:제가 작가입니다.

위의 답변들을 살펴보았고, 저에게 적합한 이 버전을 조합했습니다.

function getFilesFromPath(path, extension) {
    let files = fs.readdirSync( path );
    return files.filter( file => file.match(new RegExp(`.*\.(${extension})`, 'ig')));
}

console.log(getFilesFromPath("./testdata", ".txt"));

이 테스트는 경로의 폴더에 있는 파일에서 파일 이름 배열을 반환합니다../testdata 중 노드 버전 8.11.3에서 작업 중입니다.

다음 코드는 ./(적절하게 변경) 내부에서 재귀적 검색을 수행하고 .html로 끝나는 절대 파일 이름 배열을 반환합니다.

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

var searchRecursive = function(dir, pattern) {
  // This is where we store pattern matches of all files inside the directory
  var results = [];

  // Read contents of directory
  fs.readdirSync(dir).forEach(function (dirInner) {
    // Obtain absolute path
    dirInner = path.resolve(dir, dirInner);

    // Get stats to determine if path is a directory or a file
    var stat = fs.statSync(dirInner);

    // If path is a directory, scan it and combine results
    if (stat.isDirectory()) {
      results = results.concat(searchRecursive(dirInner, pattern));
    }

    // If path is a file and ends with pattern then push it onto results
    if (stat.isFile() && dirInner.endsWith(pattern)) {
      results.push(dirInner);
    }
  });

  return results;
};

var files = searchRecursive('./', '.html'); // replace dir and pattern
                                                // as you seem fit

console.log(files);

OS 도움말을 이용하시면 됩니다.크로스 플랫폼 솔루션은 다음과 같습니다.

1. 벨로우 기능은 다음을 사용합니다.ls그리고.dir그리고 재귀적으로 검색하지는 않지만 상대적인 경로를 가지고 있습니다.

var exec = require('child_process').exec;
function findFiles(folder,extension,cb){
    var command = "";
    if(/^win/.test(process.platform)){
        command = "dir /B "+folder+"\\*."+extension;
    }else{
        command = "ls -1 "+folder+"/*."+extension;
    }
    exec(command,function(err,stdout,stderr){
        if(err)
            return cb(err,null);
        //get rid of \r from windows
        stdout = stdout.replace(/\r/g,"");
        var files = stdout.split("\n");
        //remove last entry because it is empty
        files.splice(-1,1);
        cb(err,files);
    });
}

findFiles("folderName","html",function(err,files){
    console.log("files:",files);
})

2. 벨로우 기능은 다음을 사용합니다.find그리고.dir, 검색은 재귀적이지만 윈도우에는 절대 경로가 있습니다.

var exec = require('child_process').exec;
function findFiles(folder,extension,cb){
    var command = "";
    if(/^win/.test(process.platform)){
        command = "dir /B /s "+folder+"\\*."+extension;
    }else{
        command = 'find '+folder+' -name "*.'+extension+'"'
    }
    exec(command,function(err,stdout,stderr){
        if(err)
            return cb(err,null);
        //get rid of \r from windows
        stdout = stdout.replace(/\r/g,"");
        var files = stdout.split("\n");
        //remove last entry because it is empty
        files.splice(-1,1);
        cb(err,files);
    });
}

findFiles("folder","html",function(err,files){
    console.log("files:",files);
})

평판 때문에 코멘트를 추가할 수는 없지만, 다음 사항에 유의하십시오.

fs.readdir 또는 node-glob을 사용하여 500,000개의 파일로 구성된 폴더에서 와일드카드 파일 집합을 찾으려면 ~2초가 걸렸습니다.DIR과 함께 exec을 사용하면 ~0.05초(재귀적이 아님) 또는 ~0.45초(재귀적)가 소요됩니다.(단일 디렉토리에서 패턴과 일치하는 ~14개의 파일을 찾고 있었습니다.)

지금까지 저는 효율성을 위해 낮은 수준의 OS 와일드카드 검색을 사용하는 nodejs 구현을 찾지 못했습니다.그러나 위의 DIR/ls 기반 코드는 효율성 측면에서 윈도우에서 훌륭하게 작동합니다.그러나 linux find는 큰 디렉토리에 대해 매우 느릴 것입니다.

file-regex를 살펴봅니다.

let findFiles = require('file-regex')
let pattern = '\.js'

findFiles(__dirname, pattern, (err, files) => {  
   console.log(files);
})

위의 이 토막글은 모든 것을 인쇄할 것입니다.js현재 디렉터리에 있는 파일을(를)

설치하다

당신은 이 패키지 워크싱크를 설치할 수 있습니다.

yarn add walk-sync

사용.

const walkSync = require("walk-sync");
const paths = walkSync("./project1/src", {globs: ["**/*.html"]});
console.log(paths);   //all html file path array

나의 2펜스, for-loop 대신에 지도를 사용하는 것.

var path = require('path'), fs = require('fs');

var findFiles = function(folder, pattern = /.*/, callback) {
  var flist = [];

  fs.readdirSync(folder).map(function(e){ 
    var fname = path.join(folder, e);
    var fstat = fs.lstatSync(fname);
    if (fstat.isDirectory()) {
      // don't want to produce a new array with concat
      Array.prototype.push.apply(flist, findFiles(fname, pattern, callback)); 
    } else {
      if (pattern.test(fname)) {
        flist.push(fname);
        if (callback) {
          callback(fname);
        }
      }
    }
  });
  return flist;
};

// HTML files   
var html_files = findFiles(myPath, /\.html$/, function(o) { console.log('look what we have found : ' + o} );

// All files
var all_files = findFiles(myPath);

수많은 가능한 솔루션에 빌드 스크립트 목적에 적합한 fs-jetpack 라이브러리를 추가할 수도 있습니다.

const jetpack = require("fs-jetpack");

// the sync way
const files = jetpack.find("my_project", { matching: "*.html" });
console.log(files);

// or the async way
jetpack.findAsync("my_project", { matching: "*.html" }).then(files => {
  console.log(files);
});

방금 알게 되었는데, 당신은 syncfs 메서드를 사용하고 있어서 응용 프로그램을 차단할 수 있습니다. 여기 비동기와 q를 사용하는 약속 기반 비동기 방식이 있습니다. 다음 코드를 myfile.js라는 파일에 넣었다고 가정하면 START=/myfolder FILTER=".jpg" 노드 myfile.js로 실행할 수 있습니다.

Q = require("q")
async = require("async")
path = require("path")
fs = require("fs")

function findFiles(startPath, filter, files){
    var deferred;
    deferred = Q.defer(); //main deferred

    //read directory
    Q.nfcall(fs.readdir, startPath).then(function(list) {
        var ideferred = Q.defer(); //inner deferred for resolve of async each
        //async crawling through dir
        async.each(list, function(item, done) {

            //stat current item in dirlist
            return Q.nfcall(fs.stat, path.join(startPath, item))
                .then(function(stat) {
                    //check if item is a directory
                    if (stat.isDirectory()) {
                        //recursive!! find files in subdirectory
                        return findFiles(path.join(startPath, item), filter, files)
                            .catch(function(error){
                                console.log("could not read path: " + error.toString());
                            })
                            .finally(function() {
                                //resolve async job after promise of subprocess of finding files has been resolved
                                return done();
                             });
                    //check if item is a file, that matches the filter and add it to files array
                    } else if (item.indexOf(filter) >= 0) {
                        files.push(path.join(startPath, item));
                        return done();
                    //file is no directory and does not match the filefilter -> don't do anything
                    } else {
                        return done();
                    }
                })
                .catch(function(error){
                    ideferred.reject("Could not stat: " + error.toString());
                });
        }, function() {
            return ideferred.resolve(); //async each has finished, so resolve inner deferred
        });
        return ideferred.promise;
    }).then(function() {
        //here you could do anything with the files of this recursion step (otherwise you would only need ONE deferred)
        return deferred.resolve(files); //resolve main deferred
    }).catch(function(error) {
        deferred.reject("Could not read dir: " + error.toString());
        return
    });
    return deferred.promise;
}


findFiles(process.env.START, process.env.FILTER, [])
    .then(function(files){
        console.log(files);
    })
    .catch(function(error){
        console.log("Problem finding files: " + error);
})

이 코드를 원하는 작업에 맞게 편집할 수 있습니다.노드가 다음 줄의 코드를 계속 실행하기 전에 결과가 반환되도록 nodejs IO 작업에 동기화 버전을 사용했습니다.

const fs = require('fs');
const path = require('path');
    
// Path to the directory(folder) to look into
const dirPath = path.resolve(`${__dirname}../../../../../tests_output`);
        
// Read all files with .html extension in the specified folder above
const filesList = fs.readdirSync(dirPath, (err, files) => files.filter((e) => path.extname(e).toLowerCase() === '.html'));
        
// Read the content of the first file with .txt extension in the folder
const data = fs.readFileSync(path.resolve(`${__dirname}../../../../../tests_output/${filesList[0]}`), 'utf8');

res.writeHead(200, { 'Content-Type': 'text/html' });
res.write(data);
return res.end();

도서관의 재귀적 판독기를 사용하는 것을 추천합니다.

---

html 파일 뿐만 아니라 다른 파일 형식을 검색할 수 있는 기능도 있습니다.

당신은 여기서 도멘테온을 읽을 수 있습니다.

오래된 게시물이지만 ES6는 이제 이것을 즉시 처리합니다.includes방법.

let files = ['file.json', 'other.js'];

let jsonFiles = files.filter(file => file.includes('.json'));

console.log("Files: ", jsonFiles) ==> //file.json

언급URL : https://stackoverflow.com/questions/25460574/find-files-by-extension-html-under-a-folder-in-nodejs