Tôi muốn tìm tất cả các tệp * .html trong thư mục src và tất cả các thư mục con của nó bằng cách sử dụng nodejs. Cách tốt nhất để làm điều đó là gì?

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

Tôi nghĩ rằng nhiều nhà phát triển nên có giải pháp tuyệt vời và đã được thử nghiệm và tốt hơn là sử dụng nó hơn là tự viết một giải pháp.

node.js, hàm đơn giản đệ quy:

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.indexOf(filter)>=0) {
            console.log('-- found: ',filename);
        };
    };
};

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

thêm RegExp nếu bạn muốn trở nên lạ mắt và gọi lại để làm cho nó chung chung.

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

tôi thích sử dụng gói cầu :

const glob = require('glob');

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

Cái gì, chờ đã ?! ... Được rồi, có lẽ điều này cũng có ý nghĩa hơn đối với một số người khác.

[ nodejs 7 nhớ bạn]

fs = import('fs');
let dirCont = fs.readdirSync( dir );
let files = dirCont.filter( function( elm ) {return elm.match(/.*\.(htm?html)/ig);});

Làm bất cứ điều gì với regex khiến nó trở thành đối số bạn đặt trong hàm với mặc định, v.v.

Dựa trên mã của Lucio, tôi đã tạo một mô-đun. Nó sẽ trả lại tất cả các tệp có phần mở rộng cụ thể bên dưới. Chỉ cần đăng nó ở đây trong trường hợp bất kỳ ai cần nó.

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;

Bạn có thể sử dụng Filehound để làm điều này.

Ví dụ: tìm tất cả các tệp .html trong / tmp:

const Filehound = require('filehound');

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

    console.log(htmlFiles);
});

Để biết thêm thông tin (và ví dụ), hãy xem tài liệu: https://github.com/nspragg/filehound

Disclaimer : Tôi là tác giả.

Tôi đã xem xét các câu trả lời ở trên và đã kết hợp với nhau phiên bản này phù hợp với tôi:

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

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

Kiểm tra này sẽ trả về một mảng tên tệp từ các tệp được tìm thấy trong thư mục ở đường dẫn ./testdata. Làm việc trên phiên bản nút 8.11.3.

Bạn có thể sử dụng trợ giúp của hệ điều hành cho việc này. Đây là một giải pháp đa nền tảng:

1. Hàm dưới đây sử dụng lsvà dirkhông tìm kiếm đệ quy nhưng nó có các đường dẫn tương đối

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. Hàm dưới đây sử dụng findvà dirtìm kiếm đệ quy nhưng trên windows nó có đường dẫn tuyệt đối

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

Đoạn mã sau thực hiện tìm kiếm đệ quy bên trong ./ (thay đổi nó một cách thích hợp) và trả về một mảng tên tệp tuyệt đối kết thúc bằng .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);

Không thể thêm nhận xét vì danh tiếng, nhưng hãy lưu ý những điều sau:

Sử dụng fs.readdir hoặc node-global để tìm một tập hợp ký tự đại diện của các tệp trong một thư mục 500.000 tệp mất khoảng 2 giây. Sử dụng thực thi với DIR mất ~ 0,05 giây (không đệ quy) hoặc ~ 0,45 giây (đệ quy). (Tôi đang tìm kiếm ~ 14 tệp phù hợp với mẫu của tôi trong một thư mục).

Cho đến nay, tôi đã không tìm thấy bất kỳ triển khai nodejs nào sử dụng tìm kiếm ký tự đại diện hệ điều hành cấp thấp để có hiệu quả. Nhưng mã dựa trên DIR / ls ở trên hoạt động tuyệt vời trong windows về mặt hiệu quả. Tuy nhiên, tìm kiếm linux có thể sẽ rất chậm đối với các thư mục lớn.

hai pence của tôi, sử dụng bản đồ thay cho vòng lặp

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

Hãy xem xét tệp-regex

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

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

Đoạn mã trên sẽ in tất cả các jstệp trong thư mục hiện tại.

Tôi chỉ nhận thấy rằng, bạn đang sử dụng các phương thức fs đồng bộ, có thể chặn ứng dụng của bạn, đây là cách không đồng bộ dựa trên lời hứa sử dụng async và q , bạn có thể thực thi nó với nút START = / myfolder FILTER = ". Jpg" myfile.js, giả sử bạn đặt mã sau vào tệp có tên 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);
})

Tải về

bạn có thể cài đặt walk-sync gói này bằng cách

yarn add walk-sync

Sử dụng

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

Bài cũ nhưng ES6 hiện xử lý điều này ra khỏi hộp bằng includesphương pháp này.

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

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

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