निर्देशिका में सभी फ़ाइलों को रिकर्सिव रूप से प्राप्त करें NodejS

Question

मुझे अपने फ़ंक्शन के साथ एक छोटी सी समस्या है। मैं कई फाइलों में सभी फाइलें प्राप्त करना चाहता हूं। वर्तमान में, मैं पैरामीटर में पारित फ़ाइल में फ़ाइलों को पुनर्प्राप्त कर सकता हूं। मैं एक पैरामीटर के रूप में पारित फ़ोल्डर में प्रत्येक फ़ोल्डर की एचटीएमएल फाइलों को पुनः प्राप्त करना चाहता हूं। मैं समझाऊंगा कि क्या मैं पैरामीटर "टेस्ट" में डालता हूं, मैं "टेस्ट" में फ़ाइलों को पुनर्प्राप्त करता हूं लेकिन मैं "टेस्ट/1/*। एचटीएमएल", "टेस्ट/2/"/ .html ":

पुनर्प्राप्त करना चाहता हूं

var srcpath2 = path.join('.', 'diapo', result); 
function getDirectories(srcpath2) { 
       return fs.readdirSync(srcpath2).filter(function (file) { 
        return fs.statSync(path.join(srcpath2, file)).isDirectory(); 
       }); 
      } 

परिणाम: [1,2,3]

धन्यवाद!

Answer 1

ऐसा लगता है कि glob npm package आपकी मदद करेगा।

फ़ाइल पदानुक्रम:

test 
├── one.html 
└── test-nested 
    └── two.html 

जे एस कोड:

var getDirectories = function (src, callback) { 
    glob(src + '/**/*', callback); 
}; 
getDirectories('test', function (err, res) { 
    if (err) { 
    console.log('Error', err); 
    } else { 
    console.log(res); 
    } 
}); 

जो प्रदर्शित करता है:

[ 'test/one.html', 
    'test/test-nested', 
    'test/test-nested/two.html' ] 

Answer 2

आप अपना स्वयं का लिख ​​सकते हैं इसका इस्तेमाल करने के लिए का एक उदाहरण है नीचे दिखाए गए अनुसार निर्देशिका को पार करने के लिए नीचे दिए गए कोड:

var fs = require('fs'); 
function traverseDirectory(dirname, callback) { 
    var directory = []; 
    fs.readdir(dirname, function(err, list) { 
    dirname = fs.realpathSync(dirname); 
    if (err) { 
     return callback(err); 
    } 
    var listlength = list.length; 
    list.forEach(function(file) { 
     file = dirname + '\\' + file; 
     fs.stat(file, function(err, stat) { 
     directory.push(file); 
if (stat && stat.isDirectory()) { 
      traverseDirectory(file, function(err, parsed) { 
    directory = directory.concat(parsed); 
    if (!--listlength) { 
     callback(null, directory); 
    } 
    }); 
} else { 
    if (!--listlength) { 
     callback(null, directory); 
    } 
      } 
     }); 
    }); 
    }); 
} 
traverseDirectory(__dirname, function(err, result) { 
    if (err) { 
    console.log(err); 
    } 
    console.log(result); 
}); 

आप यहाँ इसके बारे में अधिक जानकारी की जाँच कर सकते हैं: http://www.codingdefined.com/2014/09/how-to-navigate-through-directories-in.html

Answer 3

मैं तो एक इलेक्ट्रॉन अनुप्रयोग में कुछ इसी तरह, की जरूरत है: टाइपप्रति का उपयोग कर किसी दिए गए आधार फ़ोल्डर में सभी उप-फ़ोल्डर मिलता है, है, और इस के साथ आया था:

import { readdirSync, statSync, existsSync } from "fs"; 
import * as path from "path"; 

// recursive synchronous "walk" through a folder structure, with the given base path 
getAllSubFolders = (baseFolder, folderList = []) => { 

    let folders:string[] = readdirSync(baseFolder).filter(file => statSync(path.join(baseFolder, file)).isDirectory()); 
    folders.forEach(folder => { 
     folderList.push(path.join(baseFolder,folder)); 
     this.getAllSubFolders(path.join(baseFolder,folder), folderList); 
    }); 
} 

Answer 4

यहां मेरा है। सभी अच्छे उत्तरों की तरह यह समझना मुश्किल है:

const isDirectory = path => statSync(path).isDirectory(); 
const getDirectories = path => 
    readdirSync(path).map(name => join(path, name)).filter(isDirectory); 

const isFile = path => statSync(path).isFile(); 
const getFiles = path => 
    readdirSync(path).map(name => join(path, name)).filter(isFile); 

const getFilesRecursively = (path) => { 
    let dirs = getDirectories(path); 
    let files = dirs 
     .map(dir => getFilesRecursively(dir)) // go through each directory 
     .reduce((a,b) => a.concat(b), []); // map returns a 2d array (array of file arrays) so flatten 
    return files.concat(getFiles(path)); 
};