Node.js में एक निर्देशिका में मौजूद सभी फ़ाइलों के नामों की सूची कैसे प्राप्त करें?


979

मैं Node.js. का उपयोग करके एक निर्देशिका में मौजूद सभी फाइलों के नामों की एक सूची प्राप्त करने की कोशिश कर रहा हूँ मैं उत्पादन कि filenames की एक सरणी चाहता हूँ। मैं यह कैसे कर सकता हूँ?


9
fs.readdirकाम करता है, लेकिन फ़ाइल नाम ग्लोब पैटर्न का उपयोग नहीं कर सकता ls /tmp/*core*। की जाँच करें github.com/isaacs/node-glob । ग्लोब भी उप-निर्देशिकाओं में खोज कर सकते हैं।
जेस

चेकआउट एनपीएम के readdir-recursiveमॉड्यूल हालांकि अगर आप उपनिर्देशिकाओं में फ़ाइलों के नाम भी देख रहे हैं
एथन डेविस


1
fs.readdir एक सरल async समाधान है - यहाँ
drorw

फिर भी एक पुनरावृत्ति का उपयोग कर जवाब नहीं? मेरे पास स्कैन करने के लिए 2.5 मिलियन फाइलें हैं ... मैं 10 मिनट के बाद 2.5m पथ की सूची प्राप्त नहीं करना चाहता।
फ्लाविएन वोलेन

जवाबों:


1342

आप fs.readdirया fs.readdirSyncविधियों का उपयोग कर सकते हैं ।

fs.readdir

const testFolder = './tests/';
const fs = require('fs');

fs.readdir(testFolder, (err, files) => {
  files.forEach(file => {
    console.log(file);
  });
});

fs.readdirSync

const testFolder = './tests/';
const fs = require('fs');

fs.readdirSync(testFolder).forEach(file => {
  console.log(file);
});

दो विधियों के बीच का अंतर यह है कि पहला एक अतुल्यकालिक है, इसलिए आपको एक कॉलबैक फ़ंक्शन प्रदान करना होगा जो कि पढ़ने की प्रक्रिया समाप्त होने पर निष्पादित किया जाएगा।

दूसरा सिंक्रोनस है, यह फ़ाइल नाम सरणी को लौटा देगा, लेकिन यह आपके कोड के किसी भी आगे के निष्पादन को रोक देगा जब तक कि रीड प्रक्रिया समाप्त नहीं हो जाती।


204
नोट: निर्देशिका नामों कोreaddir भी दिखाता है । इन्हें फ़िल्टर करने के लिए, का उपयोग करें और । fs.stat(path, callback(err, stats))stats.isDirectory()
रोब डब्ल्यू

3
मुझे यह जोड़ना चाहिए कि शायद आपको रेडीयर के साथ जाना चाहिए क्योंकि आप IO को नोड में ब्लॉक नहीं करना चाहते हैं।
DragonKnight

5
@ user3705055 जब तक आप स्रोत आदेश निर्भर फ़ाइलों की एक निर्देशिका में पढ़ने के लिए और उन्हें एक एकल निष्पादन योग्य में संकलन करने के लिए gulp का उपयोग नहीं कर रहे हैं।
r3wt


2
@Sancarn आप के उत्पादन पार्स करने की कोशिश करना चाहते हैं ls? बस प्रतीक्षा करें जब तक कोई एम्बेडेड स्पेस और newlines के साथ कुछ फ़ाइलनाम बनाता है ...
रैडॉन रोज़बोरो

199

IMO इस तरह के कार्यों को करने का सबसे ठोस तरीका है कि एक ग्लोब टूल का उपयोग किया जाए । यहाँ नोड के लिए एक glob पैकेज है। js. के साथ स्थापित करें

npm install glob

फिर फ़ाइल नाम से मेल खाने के लिए वाइल्ड कार्ड का उपयोग करें (उदाहरण पैकेज की वेबसाइट से लिया गया)

var glob = require("glob")

// options is optional
glob("**/*.js", options, function (er, files) {
  // files is an array of filenames.
  // If the `nonull` option is set, and nothing
  // was found, then files is ["**/*.js"]
  // er is an error object or null.
})

5
यह मेरे लिए सबसे अच्छा समाधान था क्योंकि मैं स्ट्रिंग तुलना की तुलना में फिलाटाइप को आसान बनाना चाहता था। धन्यवाद।
पोग्रिंडिस

मुझे यह बहुत पसंद है क्योंकि ग्लोबिंग नोड में लगभग एक मौलिक कौशल है। यदि आप केवल फ़ाइल नाम वापस प्राप्त करना चाहते हैं, cwdतो विकल्प ऑब्जेक्ट में पास करें।
जकुल्लम

1
globस्वयं के बाहर के परिणाम कैसे प्राप्त कर सकते हैं ? उदाहरण के लिए। मैं console.logपरिणामों को चाहता हूं , लेकिन अंदर नहीं glob()?
लंती

13
@ लैंटी: glob.sync(pattern, [options])विधि का उपयोग करना आसान हो सकता है क्योंकि यह कॉलबैक का उपयोग करने के बजाय केवल फ़ाइल नामों की एक सरणी देता है। यहाँ अधिक जानकारी: github.com/isaacs/node-glob
ग्लेन लॉरेंस

1
मेरे जैसे लोगों के लिए प्रोमिस का उपयोग करके एक ग्लोब कार्यान्वयन की तलाश में, सिंद्सरसोरस द्वारा ग्लोब को देखें: github.com/sindresorhus/globby
Nacho Coloma

180

ऊपर दिया गया उत्तर हालांकि निर्देशिका में पुनरावर्ती खोज नहीं करता है। यहाँ मैंने एक पुनरावर्ती खोज ( नोड-वॉक का उपयोग करके npm install walk) के लिए किया है :

var walk    = require('walk');
var files   = [];

// Walker options
var walker  = walk.walk('./test', { followLinks: false });

walker.on('file', function(root, stat, next) {
    // Add this file to the list of files
    files.push(root + '/' + stat.name);
    next();
});

walker.on('end', function() {
    console.log(files);
});

4
fs.readdirSync बेहतर है, इसके लिए विशेष रूप से बनाया गया देशी विकल्प।
एरादेन

37
fs.readdirSync उप-निर्देशिकाओं में दुर्भाग्य से नहीं चलता है, जब तक कि आप अपनी दिनचर्या को लिखने के लिए तैयार नहीं होते हैं, जो कि आपने नहीं दिया है कि इस समस्या को हल करने के लिए पहले से ही npm मॉड्यूल हैं।
तान

6
यहाँ पर चलने के लिए एक लिंक है github repo + docs: github.com/coolaj86/node-walk
santiagoIT

ओपी ने यह नहीं पूछा कि कौन सा एपीआई एक पुनरावर्ती पढ़ता है। किसी भी मामले में, स्वीकृत उत्तर प्रदान करता है जो पुनरावर्ती पढ़ने के लिए आधार के रूप में भी काम कर सकता है।
इग्वे कालू

यह एक शानदार समारोह है। त्वरित प्रश्न: कुछ डायरियों को अनदेखा करने का एक त्वरित तरीका है? मैं निर्देशिका को अनदेखा करना चाहता हूं.git
j_d

91

सभी उपखंडों में फाइलें प्राप्त करें

function getFiles (dir, files_){
    files_ = files_ || [];
    var files = fs.readdirSync(dir);
    for (var i in files){
        var name = dir + '/' + files[i];
        if (fs.statSync(name).isDirectory()){
            getFiles(name, files_);
        } else {
            files_.push(name);
        }
    }
    return files_;
}

console.log(getFiles('path/to/dir'))

4
क्यों if (typeof files_ === 'undefined') files_=[];? आपको var files_ = files_ || [];इसके बजाय केवल करने की आवश्यकता है files_ = files_ || [];
jkutianski

4
आप var fs = require('fs');शुरुआत में जोड़ना भूल गए getFiles
GFoley83

यह एक पुनरावर्ती विधि है। यह बहुत गहरी फ़ोल्डर संरचनाओं का समर्थन नहीं करता है, जिसके परिणामस्वरूप स्टैक ओवरफ्लो होगा।
मथियास लिकेगार्ड लोरेंजेन

63

यहां केवल मूल fsऔर pathमॉड्यूल का उपयोग करके एक सरल समाधान है :

// sync version
function walkSync(currentDirPath, callback) {
    var fs = require('fs'),
        path = require('path');
    fs.readdirSync(currentDirPath).forEach(function (name) {
        var filePath = path.join(currentDirPath, name);
        var stat = fs.statSync(filePath);
        if (stat.isFile()) {
            callback(filePath, stat);
        } else if (stat.isDirectory()) {
            walkSync(filePath, callback);
        }
    });
}

या async संस्करण ( fs.readdirइसके बजाय उपयोग करता है ):

// async version with basic error handling
function walk(currentDirPath, callback) {
    var fs = require('fs'),
        path = require('path');
    fs.readdir(currentDirPath, function (err, files) {
        if (err) {
            throw new Error(err);
        }
        files.forEach(function (name) {
            var filePath = path.join(currentDirPath, name);
            var stat = fs.statSync(filePath);
            if (stat.isFile()) {
                callback(filePath, stat);
            } else if (stat.isDirectory()) {
                walk(filePath, callback);
            }
        });
    });
}

फिर आप बस कॉल करें (सिंक संस्करण के लिए):

walkSync('path/to/root/dir', function(filePath, stat) {
    // do something with "filePath"...
});

या async संस्करण:

walk('path/to/root/dir', function(filePath, stat) {
    // do something with "filePath"...
});

अंतर यह है कि आईओ प्रदर्शन करते समय नोड कैसे ब्लॉक करता है। यह देखते हुए कि ऊपर दी गई एपीआई समान है, आप अधिकतम प्रदर्शन सुनिश्चित करने के लिए एसिंक्स संस्करण का उपयोग कर सकते हैं।

हालाँकि तुल्यकालिक संस्करण का उपयोग करने का एक फायदा है। वॉक करते ही कुछ कोड निष्पादित करना आसान हो जाता है, जैसे कि वॉक के बाद अगले स्टेटमेंट में। Async संस्करण के साथ, आपको यह जानने के कुछ अतिरिक्त तरीके की आवश्यकता होगी कि आप कब किए गए हैं। शायद पहले सभी रास्तों का नक्शा बनाना, फिर उन्हें एन्यूमरेट करना। सरल बिल्ड / उपयोग स्क्रिप्ट (बनाम उच्च प्रदर्शन वेब सर्वर) के लिए आप बिना किसी नुकसान के सिंक संस्करण का उपयोग कर सकते हैं।


1
में लाइन बदलना चाहिए walkSyncसे walk(filePath, callback);करने के लिएwalkSync(filePath, callback);
MIDE11

3
लेकिन आप अभी भी fs.statSync का उपयोग कर रहे हैं, जो async संस्करण में ब्लॉक करता है। आप इसके बजाय fs.stat का उपयोग नहीं किया जाना चाहिए?
माइंडलेसरेंजर

यह वास्तव में सहायक है, और यह विधि पुनरावर्ती है। धन्यवाद!
छोटी खुशियाँ

35

नोड v10.10.0 के रूप में, यह नई उपयोग करना संभव है withFileTypesके लिए विकल्प fs.readdirऔर fs.readdirSyncके साथ संयोजन में dirent.isDirectory()समारोह एक निर्देशिका में फ़ाइल नामों के लिए फिल्टर करने के लिए। यह इस तरह दिखता है:

fs.readdirSync('./dirpath', {withFileTypes: true})
.filter(item => !item.isDirectory())
.map(item => item.name)

लौटाया गया सरणी फॉर्म में है:

['file1.txt', 'file2.txt', 'file3.txt']

Fs.Dirent वर्ग के लिए दस्तावेज़


7
अब तक कि सबसे अच्छा जवाब यहाँ है!
एलेक्स इवासेवु

2
यह वही है जो लोग 2020 में खोज रहे हैं - "
पिनड

1
सबसे अच्छा जवाब 2020!
यवेस लैंग

26

ES7 के साथ वादे का उपयोग करना

Mz / fs के साथ अतुल्यकालिक उपयोग

mzमॉड्यूल कोर नोड पुस्तकालय की promisified संस्करण प्रदान करता है। उनका उपयोग करना सरल है। पहले पुस्तकालय स्थापित करें ...

npm install mz

फिर...

const fs = require('mz/fs');
fs.readdir('./myDir').then(listing => console.log(listing))
  .catch(err => console.error(err));

वैकल्पिक रूप से आप उन्हें ES7 में अतुल्यकालिक कार्यों में लिख सकते हैं:

async function myReaddir () {
  try {
    const file = await fs.readdir('./myDir/');
  }
  catch (err) { console.error( err ) }
};

पुनरावर्ती सूची के लिए अद्यतन

कुछ उपयोगकर्ताओं ने एक पुनरावर्ती सूची (हालांकि सवाल में नहीं) को देखने की इच्छा निर्दिष्ट की है ... उपयोग करें fs-promise। यह एक पतला आवरण है mz

npm install fs-promise;

फिर...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));

5
fswalk को fs-वादे से हटा दिया जाता है क्योंकि यह fs ( github.com/kevinbeaty/fs-promise/issues/28 ) द्वारा समर्थित नहीं है
adnan

20

निर्भरता।

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

परिभाषा।

// String -> [String]
function fileList(dir) {
  return fs.readdirSync(dir).reduce(function(list, file) {
    var name = path.join(dir, file);
    var isDir = fs.statSync(name).isDirectory();
    return list.concat(isDir ? fileList(name) : [name]);
  }, []);
}

उपयोग।

var DIR = '/usr/local/bin';

// 1. List all files in DIR
fileList(DIR);
// => ['/usr/local/bin/babel', '/usr/local/bin/bower', ...]

// 2. List all file names in DIR
fileList(DIR).map((file) => file.split(path.sep).slice(-1)[0]);
// => ['babel', 'bower', ...]

कृपया ध्यान दें कि fileListरास्ता बहुत आशावादी है। किसी भी गंभीर चीज के लिए, कुछ त्रुटि हैंडलिंग जोड़ें।


1
मैंने एक excludeDirsसरणी तर्क भी जोड़ा । यह इसे इतना बदल देता है कि शायद आपको इसके बजाय इसे संपादित करना चाहिए (यदि आप इसे चाहते हैं)। अन्यथा मैं इसे एक अलग उत्तर में जोड़ दूंगा। gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AT

1
@ अच्छा लगा! आपको अपना जवाब पोस्ट करना चाहिए, क्योंकि यह एक उपयोगी एक्सटेंशन है। आइये इसे एक फीचर रहित रखें।
हुनान रोस्तोमैन १४'१६ को

19

गैर-पुनरावर्ती संस्करण

आप यह नहीं कहते हैं कि आप इसे पुनरावर्ती रूप से करना चाहते हैं, इसलिए मुझे लगता है कि आपको केवल निर्देशिका के प्रत्यक्ष बच्चों की आवश्यकता है।

नमूना कोड:

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

fs.readdirSync('your-directory-path')
  .filter((file) => fs.lstatSync(path.join(folder, file)).isFile());

10

लोड fs:

const fs = require('fs');

फ़ाइलें async पढ़ें :

fs.readdir('./dir', function (err, files) {
    // "files" is an Array with files names
});

पढ़ें फ़ाइलें सिंक :

var files = fs.readdirSync('./dir');

10

अगर कोई अभी भी इसके लिए खोज करता है, तो मैं यह करता हूं:

import fs from 'fs';
import path from 'path';

const getAllFiles = dir =>
    fs.readdirSync(dir).reduce((files, file) => {
        const name = path.join(dir, file);
        const isDirectory = fs.statSync(name).isDirectory();
        return isDirectory ? [...files, ...getAllFiles(name)] : [...files, name];
    }, []);

और इसका काम मेरे लिए बहुत अच्छा है


मेरे लिए बहुत अच्छा काम किया और यह पुनरावर्ती है। बस याद रखें कि आयात वाक्यविन्यास अभी भी नोड में एक ध्वज के पीछे है, आपको पुराने तरीके से जाना पड़ सकता है: const fs = आवश्यकता ('fs');
mjsarfatti

@ जोश यह आकर्षण की तरह काम करता है। हालांकि, यह समझने में थोड़ी कठिनाई हो रही है कि कैसे [...files, ...getAllFiles(name)]या [...files, name]काम करता है। स्पष्टीकरण का एक बहुत उपयोगी होगा :)
एमडी मजदुल इस्लाम खान

1
@MdMazedulIslamKhan यहां ...उपयोग किया जाता है जिसे एक फैल सिंटैक्स कहा जाता है। यह मूल रूप से क्या करता है सभी वस्तुओं को सरणी के अंदर ले जाता है और इसे नए सरणी में 'स्प्रेड' करता है। इस स्थिति में, filesपुनरावर्ती कॉल से लौटाए गए सभी मानों के साथ सरणी के अंदर सभी प्रविष्टियाँ रिटर्न में जोड़ी जाती हैं। YOu यहां प्रसारित वाक्यविन्यास को संदर्भित कर सकता है: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90

8

sortedफ़ाइल नाम प्राप्त करें । आप किसी विशिष्ट के आधार पर परिणामों को फ़िल्टर कर सकते हैं extensionजैसे कि '.txt', '.jpg'और इसी तरह।

import * as fs from 'fs';
import * as Path from 'path';

function getFilenames(path, extension) {
    return fs
        .readdirSync(path)
        .filter(
            item =>
                fs.statSync(Path.join(path, item)).isFile() &&
                (extension === undefined || Path.extname(item) === extension)
        )
        .sort();
}

6

मैं आपके प्रश्न से यह मान रहा हूं कि आप निर्देशिका के नाम, सिर्फ फाइलें नहीं चाहते हैं।

उदाहरण:

animals
├── all.jpg
├── mammals
   └── cat.jpg
   └── dog.jpg
└── insects
    └── bee.jpg

यदि आप फ़ाइलों के पथ का सिर्फ एक सरणी का उपयोग करना चाहते हैं return_object: false:

const fs = require('fs').promises;
const path = require('path');

async function walk(dir) {
    let files = await fs.readdir(dir);
    files = await Promise.all(files.map(async file => {
        const filePath = path.join(dir, file);
        const stats = await fs.stat(filePath);
        if (stats.isDirectory()) return walk(filePath);
        else if(stats.isFile()) return filePath;
    }));

    return files.reduce((all, folderContents) => all.concat(folderContents), []);
}

console.log(walk('animals'))

रिटर्न:

[
  "/animals/all.jpg",
  "/animals/mammals/cat.jpg",
  "/animals/mammals/dog.jpg",
  "/animals/insects/bee.jpg"
];

क्रेडिट्स https://gist.github.com/lovasoa/8691344#gistcomment-2927279 पर जाएं


5

यहाँ एक अतुल्यकालिक पुनरावर्ती संस्करण है।

    function ( path, callback){
     // the callback gets ( err, files) where files is an array of file names
     if( typeof callback !== 'function' ) return
     var
      result = []
      , files = [ path.replace( /\/\s*$/, '' ) ]
     function traverseFiles (){
      if( files.length ) {
       var name = files.shift()
       fs.stat(name, function( err, stats){
        if( err ){
         if( err.errno == 34 ) traverseFiles()
    // in case there's broken symbolic links or a bad path
    // skip file instead of sending error
         else callback(err)
        }
        else if ( stats.isDirectory() ) fs.readdir( name, function( err, files2 ){
         if( err ) callback(err)
         else {
          files = files2
           .map( function( file ){ return name + '/' + file } )
           .concat( files )
          traverseFiles()
         }
        })
        else{
         result.push(name)
         traverseFiles()
        }
       })
      }
      else callback( null, result )
     }
     traverseFiles()
    }

4
अपने बयानों के अंत में अर्धविराम जोड़ने की आदत डालें। आप अन्यथा कोड को छोटा नहीं कर सकते। फिर भी, बहुत आवश्यक async योगदान के लिए धन्यवाद।
user2867288

2
HAHAHAHA यह कल्पना का हिस्सा नहीं है, बस कुछ यादृच्छिक व्यक्ति अपनी पसंदीदा लाइनिंग शैली को "मानकज" कहते हैं। कोड स्पष्टता बनाए रखने के लिए विशेष रूप से जावास्क्रिप्ट में अर्धविराम अच्छे अभ्यास हैं। अन्यथा आपको और आपकी टीम को स्वचालित अर्धविराम सम्मिलन के नियमों को याद रखना चाहिए , और मैं कम से कम औसत जेएस डेवलपर को जानता हूं जहां मैं काम करता हूं वह मेहनती नहीं है।
user2867288

@ user2867288 लेकिन जब से एएसआई मौजूद है, हम इसका इस्तेमाल कर सकते हैं, नहीं? मैं अपने कोड को नियमित रूप से सहेजने के लिए एस्लिंट और प्रीटीयर का उपयोग करता हूं और अर्धविराम प्रविष्टि एक गैर-मुद्दा है।
दाउरा

5

@ हुनान-रोस्तोमैन के सामान्य दृष्टिकोण को लिया, इसने एक मुकदमे को और अधिक संक्षिप्त कर दिया और excludeDirsतर्क जोड़ दिया । यह includeDirsकेवल एक ही पैटर्न का पालन करने के लिए तुच्छ होगा ;

import * as fs from 'fs';
import * as path from 'path';

function fileList(dir, excludeDirs?) {
    return fs.readdirSync(dir).reduce(function (list, file) {
        const name = path.join(dir, file);
        if (fs.statSync(name).isDirectory()) {
            if (excludeDirs && excludeDirs.length) {
                excludeDirs = excludeDirs.map(d => path.normalize(d));
                const idx = name.indexOf(path.sep);
                const directory = name.slice(0, idx === -1 ? name.length : idx);
                if (excludeDirs.indexOf(directory) !== -1)
                    return list;
            }
            return list.concat(fileList(name, excludeDirs));
        }
        return list.concat([name]);
    }, []);
}

उदाहरण उपयोग:

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));

मेरे पास एक मुख्य फ़ोल्डर है: scss, और इसके अंदर अन्य फ़ोल्डर: थीम, लेकिन अंतिम सूची मुझे सभी निर्देशिकाएं देती है, न केवल डायरेक्टरी के बिना निर्देशिकाएं, क्या होती हैं?
सलाअद्दीन

केवल 'के साथ ठीक काम करता है। फ़ोल्डर निर्देशिका, बाकी निर्देशिकाओं के साथ काम नहीं करता है।
सलाअदीन

5

अलग सोच

यदि आप निर्देशिका संरचना के साथ कोई वस्तु चाहते हैं, तो मैं आपको निर्देशिका-ट्री की जांच करने के लिए अत्यधिक प्रतिसाद देता हूं ।

कहते हैं कि आपके पास यह संरचना है:

photos
   june
   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg
const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

वापस होगा:

{
  path: "photos",
  name: "photos",
  size: 600,
  type: "directory",
  children: [
    {
      path: "photos/june",
      name: "june",
      size: 400,
      type: "directory",
      children: [
        {
          path: "photos/june/windsurf.jpg",
          name: "windsurf.jpg",
          size: 400,
          type: "file",
          extension: ".jpg"
        }
      ]
    },
    {
      path: "photos/january",
      name: "january",
      size: 200,
      type: "directory",
      children: [
        {
          path: "photos/january/ski.png",
          name: "ski.png",
          size: 100,
          type: "file",
          extension: ".png"
        },
        {
          path: "photos/january/snowboard.jpg",
          name: "snowboard.jpg",
          size: 100,
          type: "file",
          extension: ".jpg"
        }
      ]
    }
  ]
}

कस्टम वस्तु

अन्यथा यदि आप अपनी कस्टम सेटिंग्स के साथ डायरेक्टरी ट्री ऑब्जेक्ट बनाना चाहते हैं तो निम्नलिखित स्निपेट पर एक नज़र डालें। इस कोडैंडबॉक्स पर एक लाइव उदाहरण दिखाई देता है ।

// my-script.js
const fs = require("fs");
const path = require("path");

const isDirectory = filePath => fs.statSync(filePath).isDirectory();
const isFile = filePath => fs.statSync(filePath).isFile();

const getDirectoryDetails = filePath => {
  const dirs = fs.readdirSync(filePath);
  return {
    dirs: dirs.filter(name => isDirectory(path.join(filePath, name))),
    files: dirs.filter(name => isFile(path.join(filePath, name)))
  };
};

const getFilesRecursively = (parentPath, currentFolder) => {
  const currentFolderPath = path.join(parentPath, currentFolder);
  let currentDirectoryDetails = getDirectoryDetails(currentFolderPath);

  const final = {
    current_dir: currentFolder,
    dirs: currentDirectoryDetails.dirs.map(dir =>
      getFilesRecursively(currentFolderPath, dir)
    ),
    files: currentDirectoryDetails.files
  };

  return final;
};

const getAllFiles = relativePath => {
  const fullPath = path.join(__dirname, relativePath);
  const parentDirectoryPath = path.dirname(fullPath);
  const leafDirectory = path.basename(fullPath);

  const allFiles = getFilesRecursively(parentDirectoryPath, leafDirectory);
  return allFiles;
};

module.exports = { getAllFiles };

तो आप बस कर सकते हैं:

// another-file.js 

const { getAllFiles } = require("path/to/my-script");

const allFiles = getAllFiles("/path/to/my-directory");

3

यह एक टाइपस्क्रिप्ट, वैकल्पिक रूप से पुनरावर्ती, वैकल्पिक रूप से त्रुटि लॉगिंग और एसिंक्रोनस समाधान है। आप उन फ़ाइल नामों के लिए एक नियमित अभिव्यक्ति निर्दिष्ट कर सकते हैं जिन्हें आप खोजना चाहते हैं।

मैंने इस्तेमाल किया fs-extra, क्योंकि इसका एक आसान सुपर सेट सुधार था fs

import * as FsExtra from 'fs-extra'

/**
 * Finds files in the folder that match filePattern, optionally passing back errors .
 * If folderDepth isn't specified, only the first level is searched. Otherwise anything up
 * to Infinity is supported.
 *
 * @static
 * @param {string} folder The folder to start in.
 * @param {string} [filePattern='.*'] A regular expression of the files you want to find.
 * @param {(Error[] | undefined)} [errors=undefined]
 * @param {number} [folderDepth=0]
 * @returns {Promise<string[]>}
 * @memberof FileHelper
 */
public static async findFiles(
    folder: string,
    filePattern: string = '.*',
    errors: Error[] | undefined = undefined,
    folderDepth: number = 0
): Promise<string[]> {
    const results: string[] = []

    // Get all files from the folder
    let items = await FsExtra.readdir(folder).catch(error => {
        if (errors) {
            errors.push(error) // Save errors if we wish (e.g. folder perms issues)
        }

        return results
    })

    // Go through to the required depth and no further
    folderDepth = folderDepth - 1

    // Loop through the results, possibly recurse
    for (const item of items) {
        try {
            const fullPath = Path.join(folder, item)

            if (
                FsExtra.statSync(fullPath).isDirectory() &&
                folderDepth > -1)
            ) {
                // Its a folder, recursively get the child folders' files
                results.push(
                    ...(await FileHelper.findFiles(fullPath, filePattern, errors, folderDepth))
                )
            } else {
                // Filter by the file name pattern, if there is one
                if (filePattern === '.*' || item.search(new RegExp(filePattern, 'i')) > -1) {
                    results.push(fullPath)
                }
            }
        } catch (error) {
            if (errors) {
                errors.push(error) // Save errors if we wish
            }
        }
    }

    return results
}

1

यह काम करेगा और परिणाम को test.txt फ़ाइल में संग्रहीत करेगा जो उसी निर्देशिका में मौजूद होगा

  fs.readdirSync(__dirname).forEach(file => {
    fs.appendFileSync("test.txt", file+"\n", function(err){
    })
})

1

मैंने हाल ही में इसके लिए एक उपकरण बनाया है जो सिर्फ यही करता है ... यह एक निर्देशिका को अतुल्य रूप से प्राप्त करता है और मदों की एक सूची देता है। आप या तो निर्देशिकाएं, फ़ाइलें या दोनों प्राप्त कर सकते हैं, पहले फ़ोल्डर्स के साथ। आप उस स्थिति में डेटा को भी रोक सकते हैं जहाँ आप संपूर्ण फ़ोल्डर नहीं लाना चाहते हैं।

https://www.npmjs.com/package/fs-browser

यह लिंक है, आशा है कि यह किसी की मदद करता है!


0

बस एक सिर: यदि आप एक निर्देशिका में प्रत्येक फ़ाइल पर संचालन करने की योजना बना रहे हैं, तो विनाइल-एफएस (जो कि गुलप द्वारा उपयोग किया जाता है , स्ट्रीमिंग बिल्ड सिस्टम) का प्रयास करें।


0

मैंने इस कार्य को स्वचालित करने के लिए एक नोड मॉड्यूल बनाया: mddir

प्रयोग

नोड mddir "../relative/path/"

स्थापित करने के लिए: npm स्थापित mddir -g

वर्तमान निर्देशिका के लिए मार्कडाउन उत्पन्न करने के लिए: mddir

किसी भी निरपेक्ष पथ के लिए उत्पन्न करने के लिए: mddir / निरपेक्ष / पथ

एक रिश्तेदार पथ के लिए उत्पन्न करने के लिए: mddir ~ / दस्तावेज / जो भी हो।

Md फाइल आपके वर्किंग डायरेक्टरी में जेनरेट होती है।

वर्तमान में नोड_मॉडल, और .गित फ़ोल्डर को अनदेखा करता है।

समस्या निवारण

यदि आपको 'नोड \ r: ऐसी कोई फ़ाइल या निर्देशिका' प्राप्त नहीं होती है, तो समस्या यह है कि आपका ऑपरेटिंग सिस्टम अलग-अलग लाइन एंडिंग का उपयोग करता है और mddir आपको यूनिक्स को लाइन एंडिंग स्टाइल को स्पष्ट रूप से सेट किए बिना पार्स नहीं कर सकता है। यह आमतौर पर विंडोज को प्रभावित करता है, लेकिन लिनक्स के कुछ संस्करण भी। यूनिक्स शैली के लिए लाइन एंडिंग सेट करना mddir npm वैश्विक बिन फ़ोल्डर में किया जाना चाहिए।

लाइन अंत तय

के साथ npm बिन फ़ोल्डर पथ प्राप्त करें:

npm config get prefix

उस फ़ोल्डर में सीडी

काढ़ा स्थापित करें dos2unix

dos2unix lib / node_modules / mddir / src / mddir.js

यह डॉस के बजाय यूनिक्स के लिए लाइन एंडिंग को परिवर्तित करता है

फिर साथ में चलाएं: नोड mddir "../relative/path/"।

उदाहरण जनरेट किया गया मार्कडाउन फाइल स्ट्रक्चर 'डाइरेक्टरी लिस्ट.md'

    |-- .bowerrc
    |-- .jshintrc
    |-- .jshintrc2
    |-- Gruntfile.js
    |-- README.md
    |-- bower.json
    |-- karma.conf.js
    |-- package.json
    |-- app
        |-- app.js
        |-- db.js
        |-- directoryList.md
        |-- index.html
        |-- mddir.js
        |-- routing.js
        |-- server.js
        |-- _api
            |-- api.groups.js
            |-- api.posts.js
            |-- api.users.js
            |-- api.widgets.js
        |-- _components
            |-- directives
                |-- directives.module.js
                |-- vendor
                    |-- directive.draganddrop.js
            |-- helpers
                |-- helpers.module.js
                |-- proprietary
                    |-- factory.actionDispatcher.js
            |-- services
                |-- services.cardTemplates.js
                |-- services.cards.js
                |-- services.groups.js
                |-- services.posts.js
                |-- services.users.js
                |-- services.widgets.js
        |-- _mocks
            |-- mocks.groups.js
            |-- mocks.posts.js
            |-- mocks.users.js
            |-- mocks.widgets.js

0

npm सूची-सामग्री मॉड्यूल का उपयोग करें । यह दी गई निर्देशिका की सामग्री और उप-सामग्री को पढ़ता है और फाइलों और फ़ोल्डरों के पथ की सूची देता है।

const list = require('list-contents');

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});

-1
function getFilesRecursiveSync(dir, fileList, optionalFilterFunction) {
    if (!fileList) {
        grunt.log.error("Variable 'fileList' is undefined or NULL.");
        return;
    }
    var files = fs.readdirSync(dir);
    for (var i in files) {
        if (!files.hasOwnProperty(i)) continue;
        var name = dir + '/' + files[i];
        if (fs.statSync(name).isDirectory()) {
            getFilesRecursiveSync(name, fileList, optionalFilterFunction);
        } else {
            if (optionalFilterFunction && optionalFilterFunction(name) !== true)
                continue;
            fileList.push(name);
        }
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.