Src klasöründeki tüm * .html dosyalarını ve nodejs kullanarak tüm alt klasörlerini bulmak istiyorum. Bunu yapmanın en iyi yolu ne?

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

Bir çok geliştiricinin harika ve test edilmiş bir çözüme sahip olması gerektiğini düşünüyorum ve bunu kendim yazmaktansa kullanmak daha iyidir.

node.js, özyinelemeli basit işlev:

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

Süslü olmak istiyorsanız RegExp'i ve onu genel hale getirmek için bir geri arama ekleyin.

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 paketini kullanmayı seviyorum :

const glob = require('glob');

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

Ne, bekle ?! ... Tamam ya, belki bu başkaları için de daha mantıklı geliyor.

[ nodejs 7 size dikkat edin]

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

Normal ifadeyle ne yaparsanız yapın, işlevde ayarladığınız bir bağımsız değişken yapın, varsayılan vb.

Lucio'nun koduna göre bir modül yaptım. Birinin altında belirli uzantılara sahip tüm dosyalar ile bir geri dönecektir. Birinin ihtiyacı olursa diye buraya postalayı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;

Bunu yapmak için Filehound'u kullanabilirsiniz .

Örneğin: tüm .html dosyalarını / tmp içinde bulun:

const Filehound = require('filehound');

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

    console.log(htmlFiles);
});

Daha fazla bilgi (ve örnekler) için dokümanlara bakın: https://github.com/nspragg/filehound

Feragatname : Yazar benim.

Yukarıdaki cevaplara baktım ve benim için çalışan bu versiyonu karıştırdım:

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

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

Bu test, yoldaki klasörde bulunan dosyalardan bir dizi dosya adı döndürecektir ./testdata. Düğüm sürümü 8.11.3 üzerinde çalışıyor.

Bunun için OS yardımını kullanabilirsiniz. İşte çapraz platform çözümü:

1. Aşağıdaki işlevi kullanır lsve diryinelemeli olarak arama yapmaz, ancak göreceli yolları vardır

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. Aşağıdaki işlev, findve kullanır dir, yinelemeli olarak arar, ancak pencerelerde mutlak yollara sahiptir

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

Aşağıdaki kod ./ içinde özyinelemeli bir arama yapar (uygun şekilde değiştirin) ve .html ile biten mutlak dosya adları dizisi döndürür.

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

Dosya normal ifadesine bir göz atın

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

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

Yukarıdaki kod parçası js, geçerli dizindeki tüm dosyaları yazdırır .

İtibar nedeniyle yorum eklenemiyor, ancak aşağıdakilere dikkat edin:

Fs.readdir veya node-glob dosyalarının 500.000 dosyalık bir klasördeki joker karakter kümesini bulmak için kullanılması yaklaşık 2 saniye sürdü. DIR ile exec kullanmak ~ 0,05s (özyinelemesiz) veya ~ 0,45s (özyinelemeli) aldı. (Tek bir dizinde kalıbımla eşleşen ~ 14 dosya arıyordum).

Şimdiye kadar, verimlilik için arama yapan düşük seviyeli işletim sistemi jokerini kullanan herhangi bir nodejs uygulaması bulamadım. Ancak yukarıdaki DIR / ls tabanlı kod, verimlilik açısından pencerelerde harika çalışıyor. ancak linux bulma, büyük dizinler için muhtemelen çok yavaş olacaktır .

iki pensim, for döngüsü yerine harita kullanıyorum

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

Az önce fark ettim ki, uygulamanızı engelleyebilecek sync fs yöntemlerini kullanıyorsunuz, işte async ve q kullanarak söze dayalı eşzamansız bir yol , START = / myfolder FILTER = ". Jpg" node myfile.js ile çalıştırabilirsiniz, Aşağıdaki kodu myfile.js adlı bir dosyaya koyduğunuzu varsayarsak:

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

Yüklemek

bu paketi kurabilirsin walk-sync'i :

yarn add walk-sync

Kullanım

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

Eski gönderi ancak ES6 artık bunu includesyöntemle kutudan çıkarıyor .

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

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

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