Node js fs readdir recursive directory search

Question

Any ideas on an async directory search using fs readdir  I realize that we could introduce recursion and call the read directory function with the next directory to read  but I m a little worried about it not being async    Any ideas  I ve looked at node-walk which is great  but doesn t give me just the files in an array  like readdir does  Although Looking for output like      file1 txt    file2 txt    dir file3 txt

User · Answer

Another simple and helpful one  function walkDir root        const stat   fs statSync root        if  stat isDirectory              const dirs   fs readdirSync root  filter item   gt   item startsWith                let results   dirs map sub   gt  walkDir    root    sub              return    concat    results         else           return root

User · Answer

Using bluebird promise coroutine   let promise   require  bluebird        PC   promise coroutine      fs   promise promisifyAll require  fs     let getFiles   PC function  dir       let files           let contents   yield fs readdirAsync dir       for  let i   0  l   contents length  i  lt  l  i                 to remove dot hidden  files on MAC         if          test contents i    contents splice i  1             for  let i   0  l   contents length  i  lt  l  i               let content   path resolve dir  contents i            let contentStat   yield fs statAsync content           if  contentStat  amp  amp  contentStat isDirectory                  let subFiles   yield getFiles content               files   files concat subFiles             else               files push content                       return files        how to use   easy error handling in one place getFiles your dir  then console log  catch err   gt  console log err

User · Answer

Here s a recursive method of getting all files including subdirectories   const FileSystem   require  fs    const Path   require  path            function getFiles directory        directory   Path normalize directory       let files   FileSystem readdirSync directory  map  file    gt  directory   Path sep   file        files forEach  file  index    gt            if  FileSystem statSync file  isDirectory                  Array prototype splice apply files   index  1  concat getFiles file                            return files

User · Answer

Promise based recursive solution in TypeScript using Array flat   for handling nested returns   import   resolve   from  path  import   Dirent   from  fs  import   as fs from  fs   function getFiles root  string   Promise lt string   gt     return fs promises     readdir root    withFileTypes  true        then dirents   gt          const mapToPath    r  string    gt   dirent  Dirent   string   gt  resolve r  dirent name        const directoryPaths   dirents filter a   gt  a isDirectory    map mapToPath root         const filePaths   dirents filter a   gt  a isFile    map mapToPath root         return Promise all lt string gt              directoryPaths map a   gt  getFiles a  include   flat              filePaths map a   gt  Promise resolve a           then a   gt  a flat

User · Answer

Another nice npm package is glob   npm install glob  It is very powerful and should cover all your recursing needs   Edit   I actually wasn t perfectly happy with glob  so I created readdirp   I m very confident that its API makes finding files and directories recursively and applying specific filters very easy   Read through its documentation to get a better idea of what it does and install via   npm install readdirp

User · Answer

Use node-dir to produce exactly the output you like  var dir   require  node-dir     dir files   dirname  function err  files      if  err  throw err    console log files       we have an array of files now  so now we can iterate that array   files forEach function path        action null  path

User · Answer

Check out the final-fs library  It provides a readdirRecursive function   ffs readdirRecursive dirPath  true   my initial path        then function  files               in the  files  variable you ve got all the files             otherwise function  err               something went wrong

User · Answer

For Node 10 3   here is a for-await solution      usr bin env node  const FS   require  fs    const Util   require  util    const readDir   Util promisify FS readdir   const Path   require  path     async function  readDirR path        const entries   await readDir path  withFileTypes true        for let entry of entries            const fullPath   Path join path entry name           if entry isDirectory                  yield  readDirR fullPath             else               yield fullPath                     async function main         const start   process hrtime bigint        for await const file of readDirR   mnt home media Unsorted              console log file             console log  process hrtime bigint  -start  1000000n      main   catch err   gt        console error err         The benefit of this solution is that you can start processing the results immediately  e g  it takes 12 seconds to read all the files in my media directory  but if I do it this way I can get the first result within a few milliseconds

User · Answer

Whoever wants a synchronous alternative to the accepted answer  I know I did    var fs   require  fs    var path   require  path    var walk   function dir        let results       err   null  list      try           list   fs readdirSync dir        catch e            err   e toString              if  err  return err      var i   0      return  function next             var file   list i              if  file  return results          file   path resolve dir  file           let stat   fs statSync file           if  stat  amp  amp  stat isDirectory                let res   walk file             results   results concat res             return next              else             results push file              return next                              console log      walk

User · Answer

A library called Filehound is another option  It will recursively search a given directory  working directory by default   It supports various filters  callbacks  promises and sync searches     For example  search the current working directory for all files  using callbacks    const Filehound   require  filehound     Filehound create    find  err  files    gt        if  err            return console error  error    err               console log files      array of files       Or promises and specifying a specific directory   const Filehound   require  filehound     Filehound create    paths   tmp    find    each console log     Consult the docs for further use cases and examples of usage  https   github com nspragg filehound  Disclaimer  I m the author

User · Answer

I recommend using node-glob to accomplish that task   var glob   require   glob        glob   dirname      js   function  err  files       console log  files

User · Answer

The recursive-readdir module has this functionality

User · Answer

Using Promises  Q  to solve this in a Functional style   var fs   require  fs        fsPath   require  path        Q   require  q     var walk   function  dir      return Q ninvoke fs   readdir   dir  then function  files         return Q all files map function  file           file   fsPath join dir  file         return Q ninvoke fs   lstat   file  then function  stat             if  stat isDirectory                return walk file             else             return  file                                     then function  files        return files reduce function  pre  cur          return pre concat cur                      It returns a promise of an array  so you can use it as   walk   home mypath   then function  files    console log files

User · Answer

Simple  Async Promise Based  const fs   require  fs promises    const getDirRecursive   async  dir    gt        try           const items   await fs readdir dir           let files               for  const item of items                if   await fs lstat    dir    item     isDirectory    files       files      await getDirRecursive    dir    item                   else files push  file  item  path     dir    item    parents  dir split  quot   quot                        return files        catch  e            return e           Usage  await getDirRecursive  quot   public quot

User · Answer

This one uses the maximum amount of new  buzzwordy features available in node 8  including Promises  util promisify  destructuring  async-await  map reduce and more  making your co-workers scratch their heads as they try to figure out what is going on  Node 8  No external dependencies  const   promisify     require  util    const   resolve     require  path    const fs   require  fs    const readdir   promisify fs readdir   const stat   promisify fs stat    async function getFiles dir      const subdirs   await readdir dir     const files   await Promise all subdirs map async  subdir    gt        const res   resolve dir  subdir       return  await stat res   isDirectory     getFiles res    res           return files reduce  a  f    gt  a concat f           Usage getFiles   dirname     then files   gt  console log files      catch e   gt  console error e     Node 10 10  Updated for node 10  with even more whizbang  const   resolve     require  path    const   readdir     require  fs   promises   async function getFiles dir      const dirents   await readdir dir    withFileTypes  true       const files   await Promise all dirents map  dirent    gt        const res   resolve dir  dirent name       return dirent isDirectory     getFiles res    res           return Array prototype concat    files      Note that starting with node 11 15 0 you can use files flat   instead of Array prototype concat    files  to flatten the files array  Node 11  If you want to blow everybody s head up completely  you can use the following version using async iterators  In addition to being really cool  it also allows consumers to pull results one-at-a-time  making it better suited for really large directories  const   resolve     require  path    const   readdir     require  fs   promises   async function  getFiles dir      const dirents   await readdir dir    withFileTypes  true       for  const dirent of dirents        const res   resolve dir  dirent name       if  dirent isDirectory            yield  getFiles res         else         yield res               Usage has changed because the return type is now an async iterator instead of a promise   async      gt      for await  const f of getFiles             console log f             In case somebody is interested  I ve written more about async iterators here  https   qwtel com posts software async-generators-in-the-wild

User · Answer

I modified Trevor Senior s Promise based answer to work with Bluebird  var fs   require  fs        path   require  path        Promise   require  bluebird     var readdirAsync   Promise promisify fs readdir   var statAsync   Promise promisify fs stat   function walkFiles  directory        var results           return readdirAsync directory  map function file            file   path join directory  file           return statAsync file  then function stat                if  stat isFile                      return results push file                             return walkFiles file  then function filesInDir                    results   results concat filesInDir                                      then function             return results               use walkDir   dirname  then function files        console log files      catch function e        console error e

User · Answer

qwtel s answer variant  in TypeScript import   resolve   from  path   import   readdir   from  fs promises    async function  getFiles dir  string   AsyncGenerator lt string gt        const entries   await readdir dir    withFileTypes  true         for  const entry of entries            const res   resolve dir  entry name           if  entry isDirectory                  yield  getFiles res             else               yield res

User · Answer

Using async await  this should work   const FS   require  fs    const readDir   promisify FS readdir   const fileStat   promisify FS stat    async function getFiles dir        let files   await readDir dir        let result   files map file   gt            let path   Path join dir file           return fileStat path  then stat   gt  stat isDirectory     getFiles path    path                return flatten await Promise all result       function flatten arr        return Array prototype concat    arr       You can use bluebird Promisify or this          Returns a function that will wrap the given  nodeFunction   Instead of taking a callback  the returned function will return a promise whose fate is decided by the callback behavior of the given node function  The node function should conform to node js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument         param  Function  nodeFunction     returns  Function      module exports   function promisify nodeFunction        return function    args            return new Promise  resolve  reject    gt                nodeFunction call this     args   err  data    gt                    if err                        reject err                     else                       resolve data                                                               Node 8  has Promisify built-in   See my other answer for a generator approach that can give results even faster

User · Answer

I ve coded this recently  and thought it would make sense to share this here  The code makes use of the async library   var fs   require  fs    var async   require  async     var scan   function dir  suffix  callback      fs readdir dir  function err  files        var returnFiles           async each files  function file  next          var filePath   dir         file        fs stat filePath  function err  stat            if  err              return next err                     if  stat isDirectory                scan filePath  suffix  function err  results                if  err                  return next err                             returnFiles   returnFiles concat results               next                                   else if  stat isFile                if  file indexOf suffix  file length - suffix length      -1                returnFiles push filePath                         next                               function err          callback err  returnFiles                      You can use it like this   scan   some dir     ext   function err  files         Do something with files that ends in   ext     console log files

User · Answer

There is a new module called cup-readdir that recursively searches directories very fast  It uses asynchronous promises and outperforms many popular modules when dealing with deep directory structures  It can return all files in an array and sort them by their properties  but lacks features like file filtering and entering symlinked directories  This could be useful for large projects where you simply want to get every file from a directory  Here is a link to their project homepage

User · Answer

Yet another answer  but this time using TypeScript    x000D   x000D      x000D     Recursively walk a directory asynchronously and obtain all file names  with full path   x000D     x000D      param dir Folder name you want to recursively process x000D      param done Callback function  returns all files with full path  x000D      param filter Optional filter to specify which files to include   x000D       e g  for json files   f  string    gt    json   test f  x000D      x000D  const walk     x000D    dir  string  x000D    done   err  Error   null  results     string      gt  void  x000D    filter      f  string    gt  boolean x000D      gt    x000D    let results  string         x000D    fs readdir dir   err  Error  list  string      gt    x000D      if  err    x000D        return done err   x000D        x000D      let pending   list length  x000D      if   pending    x000D        return done null  results   x000D        x000D      list forEach  file  string    gt    x000D        file   path resolve dir  file   x000D        fs stat file   err2  stat    gt    x000D          if  stat  amp  amp  stat isDirectory      x000D            walk file   err3  res    gt    x000D              if  res    x000D                results   results concat res   x000D                x000D              if   --pending    x000D                done null  results   x000D                x000D               filter   x000D            else   x000D            if  typeof filter      undefined      filter  amp  amp  filter file      x000D              results push file   x000D              x000D            if   --pending    x000D              done null  results   x000D              x000D            x000D            x000D          x000D        x000D     x000D   x000D   x000D

User · Answer

Just in case anyone finds it useful  I also put together a synchronous version   var walk   function dir        var results           var list   fs readdirSync dir       list forEach function file            file   dir         file          var stat   fs statSync file           if  stat  amp  amp  stat isDirectory                      Recurse into a subdirectory                results   results concat walk file              else                   Is a file                results push file                         return results      Tip  To use less resources when filtering  Filter within this function itself  E g  Replace results push file   with below code  Adjust as required       file type   file split      pop        file name   file split          g  pop        if  file type     json   results push file

User · Answer

This is my answer  Hope it can help somebody    My focus is to make the searching routine can stop at anywhere  and for a file found  tells the relative depth to the original path   var  fs   require  fs    var  path   require  path    var  defer   process nextTick      next   will pop the first element from an array and return it  together with    the recursive depth and the container array of the element  i e  If the first    element is an array  it ll be dug into recursively  But if the first element is    an empty array  it ll be simply popped and ignored     e g  If the original array is  1  2  3   next   will return  1 0   2  3    and    the array becomes   2  3   If the array is       1 2  3  4   next   will return     1 2  2    and the array becomes    2  3  4      There is an infinity loop  while true          because I optimized the code to    make it a non-recursive version  var next   function c        var a   c      var n   0      while  true            if  a length    0  return null          var x   a 0           if  x constructor    Array                if  x length  gt  0                    a   x                    n                else                   a shift                    a   c                  n   0                          else               a shift                return  x  n  a                         cb is the callback function  it have four arguments        1  an error object if any exception happens        2  a path name  may be a directory or a file        3  a flag   true  means directory  and  false  means file        4  a zero-based number indicates the depth relative to the original path     cb should return a state value to tell whether the searching routine should    continue   true  means it should continue   false  means it should stop here     but for a directory  there is a third state  null   means it should do not    dig into the directory and continue searching the next file  var ls   function path  cb           use   path resolve    to correctly handle     and           var c      path resolve path         var f   function             var p   next c           p  amp  amp  s p              var s   function p             fs stat p 0   function err  ss                if  err                       use   defer    to turn a recursive call into a non-recursive call                  cb err  p 0   null  p 1    amp  amp   defer f                 else if  ss isDirectory                      var y   cb null  p 0   true  p 1                    if  y  r p                   else if  y    null   defer f                 else                   cb null  p 0   false  p 1    amp  amp   defer f                                        var r   function p             fs readdir p 0   function err  files                if  err                    cb err  p 0   true  p 1    amp  amp   defer f                 else                      not use  Array prototype map    because we can make each change on site                  for  var i   0  i  lt  files length  i                          files i     path join p 0   files i                                      p 2  unshift files                    defer f                                        defer f       var printfile   function err  file  isdir  n        if  err            console log  -- gt               n           file          err           return true        else           console log                 n            isdir    D     F           file           return true            var path   process argv 2   ls path  printfile

User · Answer

With Recursion  var fs   require  fs   var path   process cwd   var files       var getFiles   function path  files       fs readdirSync path  forEach function file           var subpath   path         file          if fs lstatSync subpath  isDirectory                 getFiles subpath  files             else               files push path         file                              Calling  getFiles path  files  console log files     will log all files in directory

User · Answer

klaw and klaw-sync are worth considering for this sort of thing  These were part of node-fs-extra

User · Answer

A  Have a look at the file module  It has a function called walk      file walk start  callback       Navigates a file tree  calling callback for each directory  passing in    null  dirPath  dirs  files     This may be for you  And yes  it is async  However  I think you would have to aggregate the full path s yourself  if you needed them   B  An alternative  and even one of my favourites  use the unix find for that  Why do something again  that has already been programmed  Maybe not exactly what you need  but still worth checking out   var execFile   require  child process   execFile  execFile  find      somepath      function err  stdout  stderr      var file list   stdout split   n         now you ve got a list with full path file names          Find has a nice build-in caching mechanism that makes subsequent searches very fast  as long as only few folder have changed

User · Answer

Because everyone should write his own  I made one   walk dir  cb  endCb  cb file  endCb err   null   DIRTY  module exports   walk   function walk dir  cb  endCb      var fs   require  fs      var path   require  path       fs readdir dir  function err  files        if  err          return endCb err              var pending   files length      if  pending     0          endCb null             files forEach function file          fs stat path join dir  file   function err  stats            if  err              return endCb err                     if  stats isDirectory                walk path join dir  file   cb  function                 pending--              if  pending     0                  endCb null                                         else             cb path join dir  file              pending--            if  pending     0                endCb null

User · Answer

If you want to use an npm package  wrench is pretty good   var wrench   require  wrench     var files   wrench readdirSyncRecursive  directory     wrench readdirRecursive  directory   function  error  files           live your dreams       EDIT  2018   Anyone reading through in recent time  The author deprecated this package in 2015      wrench js is deprecated  and hasn t been updated in quite some time  I heavily recommend using fs-extra to do any extra filesystem operations

User · Answer

Async  const fs   require  fs   const path   require  path    const readdir    p  done  a       i   0    gt  fs readdir p   e  d         gt    d map f   gt  readdir a a push path join p  f   - 1        gt        i    d length  amp  amp  done a   a   length    done a    readdir   dirname  console log    Sync  const fs   require  fs   const path   require  path    const readdirSync    p  a         gt      if  fs statSync p  isDirectory        fs readdirSync p  map f   gt  readdirSync a a push path join p  f   - 1   a     return a    console log readdirSync   dirname     Async readable  function readdir  currentPath  done  allFiles       i   0      fs readdir currentPath  function  e  directoryFiles             if   directoryFiles length        return done allFiles      directoryFiles map function  file          var joinedPath   path join currentPath  file        allFiles push joinedPath        readdir joinedPath  function              i   i   1         if  i    directoryFiles length            done allFiles           allFiles                 readdir   dirname  console log    Note  both versions will follow symlinks  same as the original fs readdir

User · Answer

I loved the answer from chjj above and would not have been able to create my version of the parallel loop without that start   var fs   require  fs     var tree   function dir  done      var results              path   dir           children                 fs readdir dir  function err  list        if  err    return done err         var pending   list length      if   pending    return done null  results         list forEach function file          fs stat dir         file  function err  stat            if  stat  amp  amp  stat isDirectory                tree dir         file  function err  res                results children push res               if   --pending   done null  results                             else             results children push   path   dir         file              if   --pending    done null  results                                           module exports   tree    I created a Gist as well  Comments welcome  I am still starting out in the NodeJS realm so that is one way I hope to learn more

User · Answer

here is the complete working code  As per your requirement  you can get all files and folders recursively   var recur   function dir                fs readdir dir function err list                   list forEach function file                       var file2   path resolve dir  file                       fs stat file2 function err stats                           if stats isDirectory                                  recur file2                                                     else                               console log file2                                                                                                          recur path     in path give your directory path in which you want to search like  c  test

User · Answer

Here is a simple synchronous recursive solution const fs   require  fs    const getFiles   path   gt        const files          for  const file of fs readdirSync path             const fullPath   path         file         if fs lstatSync fullPath  isDirectory                getFiles fullPath  forEach x   gt  files push file         x           else files push file            return files    Usage  const files   getFiles process cwd     console log files   You could write it asynchronously  but there is no need  Just make sure that the input directory exists and is accessible

User · Answer

Here s yet another implementation   None of the above solutions have any limiters  and so if your directory structure is large  they re all going to thrash and eventually run out of resources   var async   require  async    var fs   require  fs    var resolve   require  path   resolve   var scan   function path  concurrency  callback        var list            var walker   async queue function path  callback            fs stat path  function err  stats                if  err                    return callback err                 else                   if  stats isDirectory                          fs readdir path  function err  files                            if  err                                callback err                             else                               for  var i   0  i  lt  files length  i                                      walker push resolve path  files i                                                               callback                                                                        else                       list push path                       callback                                                       concurrency        walker push path        walker drain   function             callback list              Using a concurrency of 50 works pretty well  and is almost as fast as simpler implementations for small directory structures

User · Answer

check out loaddir https   npmjs org package loaddir  npm install loaddir    loaddir   require  loaddir      allJavascripts        loaddir       path    dirname     public javascripts       callback  function     allJavascripts push this relativePath   this baseName            You can use fileName instead of baseName if you need the extension as well     An added bonus is that it will watch the files as well and call the callback again   There are tons of configuration options to make it extremely flexible   I just remade the guard gem from ruby using loaddir in a short while

User · Answer

For fun  here is a flow based version that works with highland js streams library   It was co-authored by Victor Vu         directory  gt ---m------ gt  dirFilesStream  gt ---------o---- gt  out                                                                                                                          -------- lt  returnPipe  lt -----------     legend   m erge   o bserve     directory         has the initial file    dirListStream     does a directory listing    out               prints out the full path of the file    returnPipe        runs stat and filters on directories           require  highland   fs   require  fs   fsPath   require  path    directory       someDirectory    mergePoint       dirFilesStream   mergePoint merge   flatMap  parentPath  - gt      wrapCallback fs readdir  parentPath  sequence   map  path  - gt      fsPath join parentPath  path   out   dirFilesStream   Create the return pipe returnPipe   dirFilesStream observe   flatFilter  path  - gt      wrapCallback fs stat  path  map  v  - gt      v isDirectory       Connect up the merge point now that we have all of our streams  mergePoint write directory mergePoint write returnPipe mergePoint end     Release backpressure   This will print files as they are discovered out each H log   Another way would be to queue them all up and then print them all out at once    out toArray  files - gt  console log files

User · Answer

I must add the Promise-based sander library to the list    var sander   require  sander     sander lsr directory  then  filenames   gt    console log filenames

User · Answer

just a simple walk  let pending    baseFolderPath  function walk          pending shift           do stuffs width pending 0  and change pending items     if  pending 0   walk pending 0     walk pending 0

User · Answer

This is how I use the nodejs fs readdir function to recursively search a directory   const fs   require  fs    const mime   require  mime-types    const readdirRecursivePromise   path   gt        return new Promise  resolve  reject    gt            fs readdir path   err  directoriesPaths    gt                if  err                    reject err                 else                   if  directoriesPaths indexOf   DS Store      -1                        directoriesPaths splice directoriesPaths indexOf   DS Store    1                                     directoriesPaths forEach  e  i    gt                        directoriesPaths i    statPromise    path    e                                         Promise all directoriesPaths  then out   gt                        resolve out                      catch err   gt                        reject err                                                            const statPromise   path   gt        return new Promise  resolve  reject    gt            fs stat path   err  stats    gt                if  err                    reject err                 else                   if  stats isDirectory                          readdirRecursivePromise path  then out   gt                            resolve out                          catch err   gt                            reject err                                             else if  stats isFile                          resolve                            path   path                           type   mime lookup path                                            else                       reject  Error parsing path    path                                                            const flatten    arr  result         gt        for  let i   0  length   arr length  i  lt  length  i              const value   arr i           if  Array isArray value                 flatten value  result             else               result push value                       return result       Let s say you have a path called   database  in your node projects root  Once this promise is resolved  it should spit out an array of every file under   database    readdirRecursivePromise  database   then out   gt        console log flatten out       catch err   gt        console log err

User · Answer

There are basically two ways of accomplishing this  In an async environment you ll notice that there are two kinds of loops  serial and parallel  A serial loop waits for one iteration to complete before it moves onto the next iteration - this guarantees that every iteration of the loop completes in order  In a parallel loop  all the iterations are started at the same time  and one may complete before another  however  it is much faster than a serial loop  So in this case  it s probably better to use a parallel loop because it doesn t matter what order the walk completes in  just as long as it completes and returns the results  unless you want them in order    A parallel loop would look like this   var fs   require  fs    var path   require  path    var walk   function dir  done      var results         fs readdir dir  function err  list        if  err  return done err       var pending   list length      if   pending  return done null  results       list forEach function file          file   path resolve dir  file         fs stat file  function err  stat            if  stat  amp  amp  stat isDirectory                walk file  function err  res                results   results concat res               if   --pending  done null  results                           else             results push file             if   --pending  done null  results                                          A serial loop would look like this   var fs   require  fs    var path   require  path    var walk   function dir  done      var results         fs readdir dir  function err  list        if  err  return done err       var i   0       function next           var file   list i           if   file  return done null  results         file   path resolve dir  file         fs stat file  function err  stat            if  stat  amp  amp  stat isDirectory                walk file  function err  res                results   results concat res               next                            else             results push file             next                                             And to test it out on your home directory  WARNING  the results list will be huge if you have a lot of stuff in your home directory    walk process env HOME  function err  results      if  err  throw err    console log results         EDIT  Improved examples

User · Answer

Standalone promise implementation  I am using the when js promise library in this example   var fs   require  fs     path   require  path     when   require  when     nodefn   require  when node function     function walk  directory  includeDir        var results           return when map nodefn call fs readdir  directory   function file            file   path join directory  file           return nodefn call fs stat  file  then function stat                if  stat isFile      return results push file                 if  includeDir    results push file   path sep                 return walk file  includeDir  then function filesInDir                    results   results concat filesInDir                                      then function             return results              walk   dirname  then function files        console log files      otherwise function error        console error error stack    error         I ve included an optional parameter includeDir which will include directories in the file listing if set to true

[node.js] Node.js fs.readdir recursive directory search

Examples related to node.js

Examples related to readdir