How can I loop through the folder that has subfolder and retrieve all files with extension '.element.ts' ?

       const fs = require('fs'); 
       const filesDir = fs.readdirSync('packages/web-components/src');

       // the json result that will be generated
       let content = []; 

       files.forEach(file => {
         if (fileName === '???') 
           content.push(file);
       });
                

CodePudding user response：

Easy way: use glob package.

const glob = require("glob");
const pattern = "packages/web-components/src/*.element.ts"
const elementTsFilenames = glob.sync(pattern);

Manual way:

const dir = "packages/web-components/src";
const extension = ".element.ts";
const elementTsFilenames = fs.readdirSync(dir).filter(fn => fn.endsWith(extension));

This is easy enough that the manual way is as easy or easier; if you have more complex requirements (e.g. recursively searching subdirectories), a library approach is nice.

CodePudding user response：

const fs=require('fs');

function getAllFiles (dir, allFilesList = []){
    const files = fs.readdirSync(dir);
    files.map(file => {
      const name = dir   '/'   file;
      if (fs.statSync(name).isDirectory()) { // check if subdirectory is present
        getAllFiles(name, allFilesList);     // do recursive execution for subdirectory
      } else {
          allFilesList.push(name);           // push filename into the array
      }
    })
    
    return allFilesList;
}

const allFiles = getAllFiles('./testfolder');
const fileEndsWith = allFiles.filter(file => file.endsWith('.element.ts'))

console.log(fileEndsWith);

CodePudding user response：

I'll show you how to recursively get all the files in a directory (even those located in a subdirectory).

To do this, we need to create a recursive function that can call itself when dealing with sub-directories. And we also need the function to go through each of the sub-directories and add any new files it encounters. Then we also need to check if the filename contains a specific string. When the function is finished , it should return an array with all the files it encountered.

Here's what the recursive function looks like:

const fs = require("fs")
const path = require("path")

const getAllFiles = function(dirPath, extension, arrayOfFiles) {
  files = fs.readdirSync(dirPath);

  arrayOfFiles = arrayOfFiles || [];

  files.forEach(function(file) {
    if (fs.statSync(dirPath   "/"   file).isDirectory()) {
      arrayOfFiles = getAllFiles(dirPath   "/"   file, arrayOfFiles);
    } else if (file.endsWith(extension)){
      arrayOfFiles.push(path.join(__dirname, dirPath, "/", file));
    }
  });

  return arrayOfFiles;
}

First, we require() the Node.js path module. Since this is included with Node.js, you don't need to install anything for it to work. This module will help us easily create full file paths for our files.

The getAllFiles variable holds the recursive function that will go through each subdirectory and return an array of filenames. It takes a directory file path, a specified character and an optional arrayOfFiles as arguments.

Inside the getAllFiles function, we first use the readdirSync() function to get all of the files and directories inside the given dirPath supplied to the function.

Then, we create an arrayOfFiles that will hold all the filenames that will be returned when the function is done running.

Next, we loop over each item (file or directory) found by the readdirSync() function. If the item is a directory, we have the function recursively call itself to get all of the files and sub-directories inside the given directory.

And if the item is a file, we simply append the file path to the arrayOfFiles array. (When the end of the file name is confirmed to contain characters)

When the forEach loop has finished, we return the arrayOfFiles array.

Here is how you use the function in your code:

const result = getAllFiles("packages/web-components/src", ".element.ts");

CodePudding user response：

I don't think you need an npm package for this: It's not too hard to walk the file system using an async iterator and filter the results based on something like a regular expression.

Another bonus of an async technique is that it doesn't block your thread while it iterates the files (other work can be done in between each result while it's searching), especially if you have a lot of sub-directories/files to search through.

If you want to reduce your project's dependencies, you can do something like this:

example.mjs:

import * as path from 'node:path';
import {readdir} from 'node:fs/promises';

/** Search all subdirectories, yielding matching file entries */
export async function* findFiles (dir, regexpFilter) {
  for (const entry of await readdir(dir, {withFileTypes: true})) {
    const fPath = path.resolve(dir, entry.name);
    if (entry.isDirectory()) {
      yield* findFiles(fPath, regexpFilter);
      continue;
    }
    if (regexpFilter && !regexpFilter.test(entry.name)) continue;
    yield Object.assign(entry, {path: fPath});
  }
}

async function main () {
  const dir = 'packages/web-components/src';
  
  // Regular expression which means: ends with '.element.ts'
  const filter = /\.element\.ts$/;

  for await (const entry of findFiles(dir, filter)) {
    //                                     ^^^^^^
    // If you don't include a filter argument, then all files will be iterated

    console.log(entry.name); // just the file name
    console.log(entry.path); // the full file path
  }
}

main();