node.js fs.readdir récursive recherche dans l'annuaire

Il y a essentiellement deux façons d'y parvenir. Dans un environnement asynchrone, vous remarquerez qu'il y a deux types de boucles: série et parallèle. Une série de boucle attend pour une itération à terminer avant de passer à l'itération suivante - ce qui garantit que chaque itération de la boucle est terminée dans l'ordre. Dans une boucle parallèle, toutes les itérations sont lancés dans le même temps, et on peut se terminer avant qu'une autre, cependant, il est beaucoup plus rapide qu'une boucle série. Donc, dans ce cas, il est probablement préférable d'utiliser une boucle parallèle parce qu'il n'a pas d'importance ce que commande la marche terminée, juste aussi longtemps que il remplit et retourne les résultats (sauf si vous les voulez dans l'ordre).

Une boucle parallèle devrait ressembler à ceci:

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 && 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);
        }
      });
    });
  });
};

Une boucle série devrait ressembler à ceci:

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 && stat.isDirectory()) {
          walk(file, function(err, res) {
            results = results.concat(res);
            next();
          });
        } else {
          results.push(file);
          next();
        }
      });
    })();
  });
};

Et de le tester sur votre répertoire home (AVERTISSEMENT: la liste des résultats sera énorme si vous avez beaucoup de choses dans votre répertoire home):

walk(process.env.HOME, function(err, results) {
  if (err) throw err;
  console.log(results);
});

EDIT: Amélioration des exemples.

Celui-ci utilise le montant maximal de nouveau, buzzwordy fonctionnalités disponibles dans le nœud 8, y compris les Promesses, util/promisify, déstructuration, async-attendent, carte+réduire et plus, ce qui rend votre co-travailleurs gratter la tête comme ils essaient de comprendre ce qui se passe.

Nœud 8+

Sans dépendances externes.

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) => {
    const res = resolve(dir, subdir);
    return (await stat(res)).isDirectory() ? getFiles(res) : res;
  }));
  return files.reduce((a, f) => a.concat(f), []);
}

D'utilisation

getFiles(__dirname)
  .then(files => console.log(files))
  .catch(e => console.error(e));

Nœud 10.10+

Mise à jour pour le nœud 10+ avec encore plus de 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) => {
    const res = resolve(dir, dirent.name);
    return dirent.isDirectory() ? getFiles(res) : res;
  }));
  return Array.prototype.concat(...files);
}

Noter qu'à partir avec nœud 11.15.0 vous pouvez utiliser files.flat() au lieu de Array.prototype.concat(...files) pour aplatir les fichiers de tableau.

Nœud 11+

Si vous voulez sauter tout le monde la tête complètement, vous pouvez utiliser la version suivante à l'aide de async itérateurs. En plus d'être vraiment cool, il permet également aux consommateurs de tirer des résultats de l'un-à-un-temps, rendant le mieux adapté pour les très gros répertoires.

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;
    }
  }
}

Utilisation a changé parce que le type de retour est maintenant un async itérateur au lieu d'une promesse

(async () => {
  for await (const f of getFiles('.')) {
    console.log(f);
  }
})()

Dans le cas où quelqu'un est intéressé, je l'ai écrit plus sur async itérateurs ici: https://qwtel.com/posts/software/async-generators-in-the-wild/

Encore un joli package npm est glob.

npm install glob

Il est très puissant et devrait couvrir tous vos recursing besoins.

Edit:

J'ai fait n'était pas parfaitement heureux avec glob, j'ai donc créé readdirp.

Je suis très confiant que son API permet de trouver des fichiers et des répertoires de manière récursive et application de filtres spécifiques très facilement.

Lire son la documentation pour avoir une meilleure idée de ce qu'il fait et de l'installer via:

npm install readdirp

Si vous souhaitez utiliser un package npm, clé est assez bonne.

var wrench = require("wrench");

var files = wrench.readdirSyncRecursive("directory");

wrench.readdirRecursive("directory", function (error, files) {
    //live your dreams
});

MODIFIER (2018):

- On lire à travers ces derniers temps: L'auteur obsolète de ce forfait en 2015:

wrench.js est obsolète, et n'a pas été mis à jour depuis un certain temps. J'ai fortement vous recommandons d'utiliser fs-extra faire supplémentaire opérations de système de fichiers.

Utilisation nœud-dir pour obtenir exactement le résultat que vous aimez

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);
  })
});

J'ai codé cette récemment, et pense qu'il serait bon de les partager ici. Le code fait usage de la async bibliothèque.

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);
    });
  });
};

Vous pouvez l'utiliser comme ceci:

scan('/some/dir', '.ext', function(err, files) {
  //Do something with files that ends in '.ext'.
  console.log(files);
});

À l'aide async/await, cela devrait fonctionner:

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 => {
        let path = Path.join(dir,file);
        return fileStat(path).then(stat => stat.isDirectory() ? getFiles(path) : path);
    });

    return flatten(await Promise.all(result));
}

function flatten(arr) {
    return Array.prototype.concat(...arr);
}

Vous pouvez utiliser bluebird.Promisify ou ceci:

/**
 * 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) => {
            nodeFunction.call(this, ...args, (err, data) => {
                if(err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            })
        });
    };
};

Nœud 8+ a Promisify intégré

Voir mon autre réponse pour un générateur approche qui peut donner des résultats encore plus rapidement.

Autonome promesse de la mise en œuvre

Je suis en utilisant le when.js promesse de la bibliothèque dans cet exemple.

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);
});

J'ai inclus un paramètre facultatif includeDir qui va inclure des répertoires dans le fichier de liste si true.

Voici encore un autre mise en œuvre. Aucune des solutions ci-dessus ont tout de limiteurs d'effort, et donc, si votre structure de répertoire est vaste, ils vont tous thrash et, finalement, à court de ressources.

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 < files.length; i++) {
                                walker.push(resolve(path, files[i]));
                            }
                            callback();
                        }
                    });
                } else {
                    list.push(path);
                    callback();
                }
            }
        });
    }, concurrency);

    walker.push(path);

    walker.drain = function() {
        callback(list);
    }
};

À l'aide d'une simultanéité de 50 fonctionne assez bien, et est presque aussi rapide que simple implémentations pour les petites structures de répertoire.

J'ai modifié Trevor âgées Promesse de réponse de travailler avec 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); {
});

À l'aide de Promesses (Q) afin de résoudre ce dans un style Fonctionnel:

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);
    });
  });
};

Elle renvoie une promesse d'un tableau, de sorte que vous pouvez l'utiliser comme:

walk('/home/mypath').then(function (files) { console.log(files); });

À l'aide de bluebird promesse.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 < 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 < l; i ++) {
        let content = path.resolve(dir, contents[i]);
        let contentStat = yield fs.statAsync(content);
        if (contentStat && 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 => console.log(err));

Parce que tout le monde devrait écrire son propre, j'en ai fait une.

à pied(dir, cb, endCb)
cb(fichier)
endCb(err | null)

SALE

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);
          }
        }
      })
    });

  });
}

C'est ma réponse. J'espère que ça peut aider quelqu'un.

Mon objectif est de faire de la recherche de routine peut s'arrêter n'importe où, et un fichier trouvé, dit la profondeur par rapport à la trajectoire initiale.

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 > 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 && 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]) && _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]) && _defer(f);
}
});
};
var r = function(p) {
_fs.readdir(p[0], function(err, files) {
if (err) {
cb(err, p[0], true, p[1]) && _defer(f);
} else {
//not use `Array.prototype.map()` because we can make each change on site.
for (var i = 0; i < 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('-->   ' + ('[' + n + '] ') + file + ': ' + err);
return true;
} else {
console.log('... ' + ('[' + n + '] ') + (isdir ? 'D' : 'F') + ' ' + file);
return true;
}
};
var path = process.argv[2];
ls(path, printfile);

Un autre simple et utile

function walkDir(root) {
const stat = fs.statSync(root);
if (stat.isDirectory()) {
const dirs = fs.readdirSync(root).filter(item => !item.startsWith('.'));
let results = dirs.map(sub => walkDir(`${root}/${sub}`));
return [].concat(...results);
} else {
return root;
}
}

Encore une autre réponse, mais cette fois à l'aide de la Machine:

JS:

/**
* Recursively walk a directory asynchronously and obtain all file names (with full path).
*
* @param dir Folder name you want to recursively process
* @param done Callback function, returns all files with full path.
* @param filter Optional filter to specify which files to include, 
*   e.g. for json files: (f: string) => /.json$/.test(f)
*/
const walk = (
dir: string,
done: (err: Error | null, results ? : string[]) => void,
filter ? : (f: string) => boolean
) => {
let results: string[] = [];
fs.readdir(dir, (err: Error, list: string[]) => {
if (err) {
return done(err);
}
let pending = list.length;
if (!pending) {
return done(null, results);
}
list.forEach((file: string) => {
file = path.resolve(dir, file);
fs.stat(file, (err2, stat) => {
if (stat && stat.isDirectory()) {
walk(file, (err3, res) => {
if (res) {
results = results.concat(res);
}
if (!--pending) {
done(null, results);
}
}, filter);
} else {
if (typeof filter === 'undefined' || (filter && filter(file))) {
results.push(file);
}
if (!--pending) {
done(null, results);
}
}
});
});
});
};

Il y a un module NPM pour cela:

mnp dree

Il se promène à travers toute l'arborescence du répertoire de cet objet et la retourne comme une chaîne ou un objet. À l'aide de son fichier de rappel vous permettra d'atteindre votre objectif.

Exemple:

const dree = require('dree');
const options = {
followLinks: true,               //If you want to follow the folders pointed by symbolic links
depth: 5,                        //If you want to stop after 5 directory levels
exclude: /dir_to_exclude/,       //If you want to exclude some pahts with a regexp
extensions: [ 'txt', 'jpg' ]     //If you want only some extensions
};
const paths = [];
const fileCallback = function (file) {
paths.push(file.relativePath);
};
let tree;
//Do it synchronously
tree = dree.scan('./dir', options, fileCallback);
//Do it asynchronously (returns promise)
tree = await dree.scanAsync('./dir', options, fileCallback);
//Now paths contains the paths you want
console.log(paths);
//tree contains an object representing the directory tree (filtered in base of the conditions)

Notez que si vous utilisez attendent, ce code doit être inclus dans une fonction async. Une promesse est retourné, de sorte que vous pouvez utiliser .alors() la méthode.