Найти файлы по расширению, *.html под папкой в ​​nodejs

Ответ 1

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.indexOf(filter)>=0) {
            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);
});

Ответ 2

мне нравится использовать пакет glob:

const glob = require('glob');

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

Ответ 3

Что, держись?!... Ладно, возможно, это имеет смысл и для кого-то еще.

[nodejs 7 mind you]

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

Сделайте что-нибудь с регулярным выражением, сделайте его аргументом, установленным в функции со значением по умолчанию и т.д.

Ответ 4

Основываясь на коде Lucio, я создал модуль. Он вернет вам все файлы с определенными расширениями под одним. Просто отправьте его здесь, если кому-нибудь это понадобится.

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;

Ответ 5

Вы можете использовать Filehound для этого.

Например: найдите все файлы .html в /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);
});

Для получения дополнительной информации (и примеров), ознакомьтесь с документами: https://github.com/nspragg/filehound

Отказ от ответственности: я автор.

Ответ 6

Я посмотрел на приведенные выше ответы и смешал эту версию, которая работает для меня:

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

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

Этот тест вернет массив имен файлов из файлов, найденных в папке по пути ./testdata. Работа над версией узла 8.11.3.

Ответ 7

Следующий код выполняет рекурсивный поиск внутри./(соответствующим образом меняет его) и возвращает массив абсолютных имен файлов, заканчивающихся на .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);

Ответ 8

Для этого вы можете использовать справочную систему ОС. Вот кросс-платформенное решение:

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

Ответ 9

мои два пенсов, используя карту вместо 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);

Ответ 10

Я просто заметил, что вы используете методы sync fs, которые могут блокировать ваше приложение, здесь используется асинхронный способ с поддержкой async и q, вы можете выполнить он с START =/myfolder FILTER = ". jpg" node myfile.js, предполагая, что вы поместили следующий код в файл 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);
})

Ответ 11

Загляните в файл-регулярное выражение

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

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

Приведенный выше фрагмент кода напечатает все файлы js в текущем каталоге.

Ответ 12

Ваша цель может быть достигнута с помощью этого модуля:

нпм дри

Это позволяет вам иметь объект json или строку, представляющую дерево данного пути. Он также имеет обратный вызов при обнаружении файлов и несколько фильтров и опций.

Это код:

const dree = require('dree');

const files = [];
const fileCb = function(file) {
    files.push(file.name);
}

dree.scan('path', { extensions: ['txt', 'html'] }, fileCb);

console.log(files); //Print all txt and html files found

Ответ 13

Не могу добавить комментарий из-за репутации, но обратите внимание на следующее:

Использование fs.readdir или node-glob для поиска группового набора файлов в папке из 500 000 файлов заняло ~ 2 с. Использование exec с DIR заняло ~ 0,05 с (не рекурсивно) или ~ 0,45 с (рекурсивно). (Я искал ~ 14 файлов, соответствующих моему шаблону в одном каталоге).

До сих пор я не смог найти ни одной реализации nodejs, которая использует подстановочный знак ОС низкого уровня для эффективности. Но приведенный выше код на основе DIR/ls прекрасно работает в Windows с точки зрения эффективности. Однако для больших каталогов linux будет работать очень медленно.

Ответ 14

Старый пост, но ES6 теперь обрабатывает это из коробки с includes в includes метод.

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

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

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