निर्देशिका नोडज के भीतर सभी निर्देशिकाएं प्राप्त करें

Question

मैं उम्मीद कर रहा था कि यह एक साधारण बात होगी, लेकिन मुझे ऐसा करने के लिए कुछ भी नहीं मिल रहा है।

मैं बस दिए गए फ़ोल्डर / निर्देशिका के भीतर सभी फ़ोल्डर / निर्देशिका प्राप्त करना चाहता हूं।

उदाहरण के लिए:

<MyFolder>
|- SomeFolder
|- SomeOtherFolder
|- SomeFile.txt
|- SomeOtherFile.txt
|- x-directory

मैं एक सरणी प्राप्त करने की उम्मीद करूंगा:

["SomeFolder", "SomeOtherFolder", "x-directory"]

या इसके बाद के संस्करण के साथ अगर यह कैसे परोसा गया था ...

तो क्या उपरोक्त करने के लिए पहले से ही कुछ मौजूद है?

Answer 1

यहां इस उत्तर का एक छोटा, समन्वित संस्करण दिया गया है, जो वर्तमान निर्देशिका में सभी निर्देशिकाओं (छिपे या नहीं) को सूचीबद्ध कर सकता है:

const { lstatSync, readdirSync } = require('fs')
const { join } = require('path')

const isDirectory = source => lstatSync(source).isDirectory()
const getDirectories = source =>
  readdirSync(source).map(name => join(source, name)).filter(isDirectory)

नोड 10.10.0+ के लिए अद्यतन करें

हम अतिरिक्त कॉल को छोड़ने withFileTypesके readdirSyncलिए नए विकल्प का उपयोग कर सकते हैं lstatSync:

const { readdirSync } = require('fs')

const getDirectories = source =>
  readdirSync(source, { withFileTypes: true })
    .filter(dirent => dirent.isDirectory())
    .map(dirent => dirent.name)

Comments

सावधान, आपको फ़ाइल स्टेट प्राप्त करने के लिए निरपेक्ष पथ की आवश्यकता है। require('path').resolve(__dirname, file)

— सिलोम

@ पिलाऊ यह सिर्फ एक रिश्तेदार पथ के साथ काम नहीं करता है, यही कारण है कि आपको इसे सामान्य करने की आवश्यकता है। उसके लिए आप path.resolve का उपयोग कर सकते हैं।

— सिलोम

@rickysullivan: आपको प्रतिसाद के माध्यम से पुनरावृति करना होगा और प्रत्येक फ़ोल्डर के लिए path.resolve (srcpath, foldername) का उपयोग करना होगा

— jarodsmk

चूँकि आप es6 का उपयोग कर रहे हैं:const getDirectories = srcPath => fs.readdirSync(srcPath).filter(file => fs.statSync(path.join(srcPath, file)).isDirectory())

— pmrotule

इस ब्रेक को नोट करें अगर डायरेक्टरी में सिम्लिंक हैं। lstatSyncइसके बजाय उपयोग करें ।

— डेव

Answer 2

जावास्क्रिप्ट ES6 (ES2015) सिंटैक्स सुविधाओं के लिए धन्यवाद यह एक लाइनर है:

तुल्यकालिक संस्करण

const { readdirSync, statSync } = require('fs')
const { join } = require('path')

const dirs = p => readdirSync(p).filter(f => statSync(join(p, f)).isDirectory())

Node.js 10+ (प्रयोगात्मक) के लिए अतुल्यकालिक संस्करण

const { readdir, stat } = require("fs").promises
const { join } = require("path")

const dirs = async path => {
  let dirs = []
  for (const file of await readdir(path)) {
    if ((await stat(join(path, file))).isDirectory()) {
      dirs = [...dirs, file]
    }
  }
  return dirs
}

Comments

किसी एक पंक्ति में किसी चीज़ को मजबूर करना उसे कम पठनीय बनाता है और इसलिए कम वांछित होता है।

— रैलमन

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

— केविन बी

Upvoted। यकीन नहीं होता कि लोगों ने इसे क्यों नकार दिया। एक लाइनर खराब है लेकिन कॉमोन है, आप इसे अपनी इच्छानुसार सुशोभित कर सकते हैं। मुद्दा यह है कि आपने इस उत्तर से कुछ सीखा है

— आमिर अफरीदी

Upvoted। यद्यपि यह वैध आलोचना है कि इसे अधिक लाइनों में फैलाया जाना चाहिए। यह उत्तर नए वाक्यविन्यास के शब्दार्थ लाभ को प्रदर्शित करता है, लेकिन मुझे लगता है कि लोग एक पंक्ति में कैसे क्रमागत थे, इससे विचलित हो रहे हैं। यदि आप इस कोड को स्वीकृत उत्तर के समान पंक्तियों में फैलाते हैं, तो यह अभी भी उसी तंत्र की अधिक संक्षिप्त अभिव्यक्ति है। मुझे लगता है कि इस उत्तर का कुछ मूल्य है, लेकिन शायद यह एक अलग उत्तर के बजाय स्वीकृत उत्तर का संपादन करने के योग्य है।

— आयरन सेवियर

क्या तुम लोग गंभीर हो? यह पूरी तरह से ठीक और मान्य उत्तर है! एक पंक्ति, साहित्यिक चोरी - काश वहाँ एक तरह से घटिया बहाने थे। यह रॉकेट साइंस नहीं है। यह एक बहुत ही सरल और गूंगा ऑपरेशन है! इसके लिए क्रिया मत बनो! सुनिश्चित करने के लिए मेरे +1 हो जाता है!

— मर्चिफ़

Answer 3

एक पथ का उपयोग करके निर्देशिकाओं की सूची बनाएं।

function getDirectories(path) {
  return fs.readdirSync(path).filter(function (file) {
    return fs.statSync(path+'/'+file).isDirectory();
  });
}

Comments

यह बहुत सीधा है

— पाउला फ्लेक

अंत में एक मैं समझ सकता हूं

— FourCinnamon0

Answer 4

पुनरावर्ती समाधान

मैं सभी उपनिर्देशिकाओं, और उनके सभी उपनिर्देशिकाओं आदि को स्वीकार करने के लिए एक रास्ते की तलाश में यहाँ आया था, स्वीकृत उत्तर पर निर्माण , मैंने यह लिखा है:

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

function flatten(lists) {
  return lists.reduce((a, b) => a.concat(b), []);
}

function getDirectories(srcpath) {
  return fs.readdirSync(srcpath)
    .map(file => path.join(srcpath, file))
    .filter(path => fs.statSync(path).isDirectory());
}

function getDirectoriesRecursive(srcpath) {
  return [srcpath, ...flatten(getDirectories(srcpath).map(getDirectoriesRecursive))];
}

Comments

यह वही है जो मैं देख रहा था और यह बहुत अच्छा काम करता है सिवाय इसके कि पहला रास्ता छोड़कर हर रास्ता इस तरह दिखाई देता है: "src \\ pages \\ partials \\ बटन" इसके बजाय "src / Pages / partials / बटन" । मैंने यह गंदा फिक्स जोड़ा: var res = getDirectoriesRecursive (srcpath); res = res.map (फ़ंक्शन (x) {रिटर्न x.replace (/ \\ / g, "/")}); console.log (रेस);

— पॉल एनबी

ऐसा करने के लिए एक कम गंदा तरीका है path.normalize ()। nodejs.org/api/path.html#path_path_normalize_path

— पैट्रिक

आप मूल निर्देशिका वापस कर रहे हैं, जो वांछनीय नहीं है। मैं getDirectoriesRecursive refactor को रोकने के लिए है कि होगा: if (recursive) return [srcpath, ...flatten(getDirectories(srcpath).map(getDirectoriesRecursive))]; else return [...flatten(getDirectories(srcpath).map(getDirectoriesRecursive))]; }

— Nadav

Answer 5

यह करना चाहिए:

कॉफीस्क्रिप्ट (सिंक)

fs = require 'fs'

getDirs = (rootDir) ->
    files = fs.readdirSync(rootDir)
    dirs = []

    for file in files
        if file[0] != '.'
            filePath = "#{rootDir}/#{file}"
            stat = fs.statSync(filePath)

            if stat.isDirectory()
                dirs.push(file)

    return dirs

CoffeeScript (async)

fs = require 'fs'

getDirs = (rootDir, cb) ->
    fs.readdir rootDir, (err, files) ->
        dirs = []

        for file, index in files
            if file[0] != '.'
                filePath = "#{rootDir}/#{file}"
                fs.stat filePath, (err, stat) ->
                    if stat.isDirectory()
                        dirs.push(file)
                    if files.length == (index + 1)
                        cb(dirs)

जावास्क्रिप्ट (async)

var fs = require('fs');
var getDirs = function(rootDir, cb) { 
    fs.readdir(rootDir, function(err, files) { 
        var dirs = []; 
        for (var index = 0; index < files.length; ++index) { 
            var file = files[index]; 
            if (file[0] !== '.') { 
                var filePath = rootDir + '/' + file; 
                fs.stat(filePath, function(err, stat) {
                    if (stat.isDirectory()) { 
                        dirs.push(this.file); 
                    } 
                    if (files.length === (this.index + 1)) { 
                        return cb(dirs); 
                    } 
                }.bind({index: index, file: file})); 
            }
        }
    });
}

Comments

यद्यपि यदि यह एक उत्पादन प्रणाली के लिए है, तो आप वास्तव में तुल्यकालिक fsतरीकों से बचना चाहते हैं ।

— हारून डफोर

इस उत्तर को पढ़ने वाले किसी भी नए नोट पर ध्यान दें: यह कॉफ़ीस्क्रिप्ट है, जावास्क्रिप्ट नहीं (मेरे दोस्त ने मुझे भ्रम में डालते हुए पूछा कि जावास्क्रिप्ट अचानक सिमेंटिक व्हाईटस्पेस क्यों था)।

— DallonF

@nicksweet क्या आप इसे जेएस में बदल सकते हैं?

— 13

इस उत्तर के साथ कुछ स्पष्ट समस्याएं हैं: इसमें किसी भी त्रुटि से निपटने की आवश्यकता नहीं है; (कॉलबैक हस्ताक्षर होना चाहिए (err, dirs)); यह डॉट फ़ाइलों या फ़ोल्डरों की उपस्थिति में वापस कॉल नहीं करेगा; यह सभी दौड़ स्थितियों के लिए अतिसंवेदनशील है; सभी प्रविष्टियों की जाँच करने से पहले इसे वापस बुला सकते हैं।

— 1j01

यूग, लोगों को सिंक एपीआई को vilifying को रोकने की आवश्यकता है। यह निर्धारित करना कि सिंक संस्करण का उपयोग किया जाना चाहिए या नहीं, यह "उत्पादन" होने से निर्धारित नहीं होता है। विज्ञापन nauseum को दोहराते हुए कि async api बेहतर हैं और सिंक खराब है, संदर्भ के बिना, बस सटीक नहीं है। काश जेएस समुदाय इस पर रोक लगाना चाहता। सिंक सरल (याय) है लेकिन संदेश लूप (बू) को अवरुद्ध करेगा। इसलिए, सिंक एपीआई का उपयोग उस सर्वर में न करें जहां आप ब्लॉक नहीं करना चाहते हैं, लेकिन बेझिझक उन्हें बिल्ड स्क्रिप्ट में उपयोग करने के लिए स्वतंत्र महसूस करते हैं, जहां कोई फर्क नहीं पड़ता। </ rant>

— hcoverlambda

Answer 6

वैकल्पिक रूप से, यदि आप बाहरी पुस्तकालयों का उपयोग करने में सक्षम हैं, तो आप उपयोग कर सकते हैं filehound। यह कॉलबैक, वादे और सिंक कॉल का समर्थन करता है।

वादों का उपयोग करना:

const Filehound = require('filehound');

Filehound.create()
  .path("MyFolder")
  .directory() // only search for directories
  .find()
  .then((subdirectories) => {
    console.log(subdirectories);
  });

कॉलबैक का उपयोग करना:

const Filehound = require('filehound');

Filehound.create()
  .path("MyFolder")
  .directory()
  .find((err, subdirectories) => {
    if (err) return console.error(err);

    console.log(subdirectories);
  });

सिंक कॉल:

const Filehound = require('filehound');

const subdirectories = Filehound.create()
  .path("MyFolder")
  .directory()
  .findSync();

console.log(subdirectories);

अधिक जानकारी (और उदाहरण) के लिए, डॉक्स देखें: https://github.com/nspragg/filehound

डिस्क्लेमर: मैं लेखक हूं।

Answer 7

Node.js संस्करण> = v10.13.0 के साथ, fs.readdirSync की एक सरणी वापस आ जाएगी fs.Dirent वस्तुओं अगर withFileTypesविकल्प के लिए निर्धारित है true।

तो आप उपयोग कर सकते हैं,

const fs = require('fs')

const directories = source => fs.readdirSync(source, {
   withFileTypes: true
}).reduce((a, c) => {
   c.isDirectory() && a.push(c.name)
   return a
}, [])

Comments

अच्छा बिंदु, लेकिन .filter(c => c.isDirectory())उपयोग करने की तुलना में सरल होगाreduce()

— इमैनुएल टाउज़री

हां, लेकिन फ़िल्टर fs.Dirent ऑब्जेक्ट्स की एक सरणी देता है जो निर्देशिकाएं हैं। ओपी निर्देशिकाओं के नाम चाहता था।

— मयूर

सच है, मैं अभी भी कॉल .filter(c => c.isDirectory()).map(c => c.name)पर पसंद करेंगे reduce।

— इमैनुएल टौजरी

में तुम्हारी बात समझ रहा हूँ। मुझे लगता है कि एसओ पाठक अपने उपयोग के मामले के आधार पर निर्णय ले सकते हैं। मैं कहूँगा कि इन-मेमोरी सरणी पर लूपिंग डिस्क से पढ़ने के I / O की तुलना में ओवरहेड में नगण्य होनी चाहिए, भले ही आप SSD से पढ़ रहे हों, लेकिन हमेशा की तरह अगर कोई परवाह करता है, तो वे माप सकते हैं।

— इमैनुएल टौजरी

Answer 8

 var getDirectories = (rootdir , cb) => {
    fs.readdir(rootdir, (err, files) => {
        if(err) throw err ;
        var dirs = files.map(filename => path.join(rootdir,filename)).filter( pathname => fs.statSync(pathname).isDirectory());
        return cb(dirs);
    })

 }
 getDirectories( myDirectories => console.log(myDirectories));``

Answer 9

Fs-extra का उपयोग करते हुए, जो async fs कॉल्स का वादा करता है, और नए async सिंटैक्स का इंतजार करता है:

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

async function getDirectories(path){
    let filesAndDirectories = await fs.readdir(path);

    let directories = [];
    await Promise.all(
        filesAndDirectories.map(name =>{
            return fs.stat(path + name)
            .then(stat =>{
                if(stat.isDirectory()) directories.push(name)
            })
        })
    );
    return directories;
}

let directories = await getDirectories("/")

Answer 10

और getDirectories का एक async संस्करण, आपको इसके लिए async मॉड्यूल की आवश्यकता है :

var fs = require('fs');
var path = require('path');
var async = require('async'); // https://github.com/caolan/async

// Original function
function getDirsSync(srcpath) {
  return fs.readdirSync(srcpath).filter(function(file) {
    return fs.statSync(path.join(srcpath, file)).isDirectory();
  });
}

function getDirs(srcpath, cb) {
  fs.readdir(srcpath, function (err, files) {
    if(err) { 
      console.error(err);
      return cb([]);
    }
    var iterator = function (file, cb)  {
      fs.stat(path.join(srcpath, file), function (err, stats) {
        if(err) { 
          console.error(err);
          return cb(false);
        }
        cb(stats.isDirectory());
      })
    }
    async.filter(files, iterator, cb);
  });
}

Answer 11

यह उत्तर अवरुद्ध कार्यों का उपयोग नहीं करता है जैसे readdirSyncया statSync। यह बाहरी निर्भरता का उपयोग नहीं करता है और न ही कॉलबैक नरक की गहराई में पाया जाता है।

इसके बजाय हम आधुनिक जावास्क्रिप्ट उपयुक्तताओं का उपयोग करते हैं जैसे कि वादे और async-awaitवाक्यविन्यास। और एसिंक्रोनस परिणाम समानांतर में संसाधित होते हैं; क्रमिक रूप से नहीं -

const { readdir, stat } =
  require ("fs") .promises

const { join } =
  require ("path")

const dirs = async (path = ".") =>
  (await stat (path)) .isDirectory ()
    ? Promise
        .all
          ( (await readdir (path))
              .map (p => dirs (join (path, p)))
          )
        .then
          ( results =>
              [] .concat (path, ...results)
          )
    : []

मैं एक उदाहरण पैकेज स्थापित करूँगा, और फिर हमारे फ़ंक्शन का परीक्षण करूँगा -

$ npm install ramda
$ node

आइए देखते हैं यह काम -

> dirs (".") .then (console.log, console.error)

[ '.'
, 'node_modules'
, 'node_modules/ramda'
, 'node_modules/ramda/dist'
, 'node_modules/ramda/es'
, 'node_modules/ramda/es/internal'
, 'node_modules/ramda/src'
, 'node_modules/ramda/src/internal'
]

---

एक सामान्यीकृत मॉड्यूल का उपयोग करते हुए Parallel, हम इसकी परिभाषा को सरल बना सकते हैं dirs-

const Parallel =
  require ("./Parallel")

const dirs = async (path = ".") =>
  (await stat (path)) .isDirectory ()
    ? Parallel (readdir (path))
        .flatMap (f => dirs (join (path, f)))
        .then (results => [ path, ...results ])
    : []

Parallelइसके बाद के संस्करण का इस्तेमाल किया मॉड्यूल एक पैटर्न है कि एक ऐसी ही समस्या का समाधान करने के लिए डिज़ाइन कार्यों का एक सेट से निकाला गया था। अधिक स्पष्टीकरण के लिए, यह संबंधित प्रश्नोत्तर देखें ।

Answer 12

इस उत्तर का कॉफीस्क्रिप्ट संस्करण , उचित त्रुटि से निपटने के साथ:

fs = require "fs"
{join} = require "path"
async = require "async"

get_subdirs = (root, callback)->
    fs.readdir root, (err, files)->
        return callback err if err
        subdirs = []
        async.each files,
            (file, callback)->
                fs.stat join(root, file), (err, stats)->
                    return callback err if err
                    subdirs.push file if stats.isDirectory()
                    callback null
            (err)->
                return callback err if err
                callback null, subdirs

Async पर निर्भर करता है

वैकल्पिक रूप से, इसके लिए एक मॉड्यूल का उपयोग करें! (हर चीज के लिए मॉड्यूल हैं। [उद्धरण वांछित])

Answer 13

यदि आपको सभी asyncसंस्करण का उपयोग करने की आवश्यकता है । आपके पास ऐसा कुछ हो सकता है।

1. निर्देशिका की लंबाई रिकॉर्ड करें, यह बताने के लिए एक संकेतक के रूप में उपयोग करता है कि क्या सभी async स्टेटमेंट कार्य समाप्त हो गए हैं।

2. यदि async स्टेटमेंट कार्य समाप्त हो गए हैं, तो सभी फ़ाइल स्टेट की जाँच की जा चुकी है, इसलिए कॉलबैक पर कॉल करें

यह केवल तब तक काम करेगा जब तक Node.js सिंगल थ्रेड है, क्योंकि यह मानता है कि कोई दो async कार्य एक ही समय में काउंटर को बढ़ाएंगे।

'use strict';

var fs = require("fs");
var path = require("path");
var basePath = "./";

function result_callback(results) {
    results.forEach((obj) => {
        console.log("isFile: " + obj.fileName);
        console.log("fileName: " + obj.isFile);
    });
};

fs.readdir(basePath, (err, files) => {
    var results = [];
    var total = files.length;
    var finished = 0;

    files.forEach((fileName) => {
        // console.log(fileName);
        var fullPath = path.join(basePath, fileName);

        fs.stat(fullPath, (err, stat) => {
            // this will work because Node.js is single thread
            // therefore, the counter will not increment at the same time by two callback
            finished++;

            if (stat.isFile()) {
                results.push({
                    fileName: fileName,
                    isFile: stat.isFile()
                });
            }

            if (finished == total) {
                result_callback(results);
            }
        });
    });
});

जैसा कि आप देख सकते हैं, यह एक "गहराई पहले" दृष्टिकोण है, और इसके परिणामस्वरूप कॉलबैक नरक हो सकता है, और यह काफी "कार्यात्मक" नहीं है। लोग इस प्रॉब्लम को Promise ऑब्जेक्ट में Async टास्क को रैप करके हल करने की कोशिश करते हैं।

'use strict';

var fs = require("fs");
var path = require("path");
var basePath = "./";

function result_callback(results) {
    results.forEach((obj) => {
        console.log("isFile: " + obj.fileName);
        console.log("fileName: " + obj.isFile);
    });
};

fs.readdir(basePath, (err, files) => {
    var results = [];
    var total = files.length;
    var finished = 0;

    var promises = files.map((fileName) => {
        // console.log(fileName);
        var fullPath = path.join(basePath, fileName);

        return new Promise((resolve, reject) => {
            // try to replace fullPath wil "aaa", it will reject
            fs.stat(fullPath, (err, stat) => {
                if (err) {
                    reject(err);
                    return;
                }

                var obj = {
                    fileName: fileName,
                    isFile: stat.isFile()
                };

                resolve(obj);
            });
        });
    });

    Promise.all(promises).then((values) => {
        console.log("All the promise resolved");
        console.log(values);
        console.log("Filter out folder: ");
        values
            .filter((obj) => obj.isFile)
            .forEach((obj) => {
                console.log(obj.fileName);
            });
    }, (reason) => {
        console.log("Not all the promise resolved");
        console.log(reason);
    });
});

Comments

अच्छा कोड! लेकिन मुझे लगता है कि यह Promise.all ब्लॉक में "फ़ाइलों को फ़िल्टर करें:" होना चाहिए क्योंकि यह जाँच रहा है कि क्या यह एक फ़ाइल है और इसे लॉग कर रहा है। :)

— बिकाल नेपाल

Answer 14

उपयोग एफएस f पथ मॉड्यूल फ़ोल्डर मिल सकता है। यह प्रयोग वादा है। यदि आपकी भरण राशि मिल जाएगी, तो आपका isDirectory () to isFile () Nodejs - fs - fs.Stats बदल सकता है । अंतिम बार, आप फ़ाइल का नाम file'extname प्राप्त कर सकते हैं और इसलिए Nodej --- मार्ग

var fs = require("fs"),
path = require("path");
//your <MyFolder> path
var p = "MyFolder"
fs.readdir(p, function (err, files) {
    if (err) {
        throw err;
    }
    //this can get all folder and file under  <MyFolder>
    files.map(function (file) {
        //return file or folder path, such as **MyFolder/SomeFile.txt**
        return path.join(p, file);
    }).filter(function (file) {
        //use sync judge method. The file will add next files array if the file is directory, or not. 
        return fs.statSync(file).isDirectory();
    }).forEach(function (files) {
        //The files is array, so each. files is the folder name. can handle the folder.
        console.log("%s", files);
    });
});

Comments

समीक्षा कतार से: मैं आपसे अनुरोध कर सकता हूं कि कृपया अपने उत्तर के आसपास कुछ और संदर्भ जोड़ दें। कोड-केवल उत्तर समझना मुश्किल है। यह पूछने वाले और भविष्य के पाठकों दोनों की मदद करेगा यदि आप अपनी पोस्ट में अधिक जानकारी जोड़ सकते हैं।

— help-info.de

Answer 15

ES6 के साथ पूरी तरह से async संस्करण, केवल देशी संकुल, fs.promises और async / प्रतीक्षा, समानांतर में फ़ाइल संचालन करता है:

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

async function listDirectories(rootPath) {
    const fileNames = await fs.promises.readdir(rootPath);
    const filePaths = fileNames.map(fileName => path.join(rootPath, fileName));
    const filePathsAndIsDirectoryFlagsPromises = filePaths.map(async filePath => ({path: filePath, isDirectory: (await fs.promises.stat(filePath)).isDirectory()}))
    const filePathsAndIsDirectoryFlags = await Promise.all(filePathsAndIsDirectoryFlagsPromises);
    return filePathsAndIsDirectoryFlags.filter(filePathAndIsDirectoryFlag => filePathAndIsDirectoryFlag.isDirectory)
        .map(filePathAndIsDirectoryFlag => filePathAndIsDirectoryFlag.path);
}

परीक्षण किया गया, यह अच्छी तरह से काम करता है।

Answer 16

बस अगर कोई अन्य व्यक्ति यहां वेब खोज से समाप्त होता है, और उसकी निर्भरता सूची में पहले से ही ग्रंट है, तो इसका उत्तर तुच्छ हो जाता है। यहाँ मेरा समाधान है:

/**
 * Return all the subfolders of this path
 * @param {String} parentFolderPath - valid folder path
 * @param {String} glob ['/*'] - optional glob so you can do recursive if you want
 * @returns {String[]} subfolder paths
 */
getSubfolders = (parentFolderPath, glob = '/*') => {
    return grunt.file.expand({filter: 'isDirectory'}, parentFolderPath + glob);
}

Answer 17

एक और पुनरावर्ती दृष्टिकोण

मेरे बारे में जानने के लिए मयूर को धन्यवाद withFileTypes। मैंने विशेष फ़ोल्डर की फ़ाइलों को पुनरावर्ती रूप से प्राप्त करने के लिए निम्नलिखित कोड लिखा है। यह केवल निर्देशिकाओं को प्राप्त करने के लिए आसानी से संशोधित किया जा सकता है।

const getFiles = (dir, base = '') => readdirSync(dir, {withFileTypes: true}).reduce((files, file) => {
    const filePath = path.join(dir, file.name)
    const relativePath = path.join(base, file.name)
    if(file.isDirectory()) {
        return files.concat(getFiles(filePath, relativePath))
    } else if(file.isFile()) {
        file.__fullPath = filePath
        file.__relateivePath = relativePath
        return files.concat(file)
    }
}, [])

Answer 18

कार्यात्मक प्रोग्रामिंग

const fs = require('fs')
const path = require('path')
const R = require('ramda')

const getDirectories = pathName => {
    const isDirectory = pathName => fs.lstatSync(pathName).isDirectory()
    const mapDirectories = pathName => R.map(name => path.join(pathName, name), fs.readdirSync(pathName))
    const filterDirectories = listPaths => R.filter(isDirectory, listPaths)

    return {
        paths:R.pipe(mapDirectories)(pathName),
        pathsFiltered: R.pipe(mapDirectories, filterDirectories)(pathName)
    }
}