node-dir

What is node-dir?

The node-dir package is a utility library for Node.js that provides methods to read directories recursively, read files within directories, and perform other directory and file system related operations. It is useful for applications that need to handle file system operations extensively.

What are node-dir's main functionalities?

Reading all files in a directory recursively

This feature allows you to list all files within a directory and its subdirectories. The function `dir.files` takes a directory path and a callback function that receives an array of file paths.

const dir = require('node-dir');
dir.files('/path/to/dir', function(err, files) {
  if (err) throw err;
  console.log(files);
});

Reading all subdirectories within a directory

This function lists all subdirectories within a specified directory. It is useful for applications that need to analyze or manipulate directory structures.

const dir = require('node-dir');
dir.subdirs('/path/to/dir', function(err, subDirs) {
  if (err) throw err;
  console.log(subDirs);
});

Reading content of files in a directory

This method reads the content of each file in a directory sequentially. It provides the file content to a callback function and proceeds to the next file when the `next` function is called.

const dir = require('node-dir');
dir.readFiles('/path/to/dir', function(err, content, next) {
  if (err) throw err;
  console.log(content);
  next();
});

Other packages similar to node-dir

fs-extra

fs-extra is a package that builds on the native 'fs' module, providing additional methods and simplifying file system operations. It includes methods similar to node-dir but also offers file copying, moving, and more comprehensive error handling. It is generally more robust than node-dir.

glob

glob is a package that allows pattern matching for filenames. It can be used to find files in a directory that match a given pattern, which is somewhat similar to listing files with node-dir but with more flexibility in file selection based on patterns.

recursive-readdir

recursive-readdir is a minimalistic package specifically focused on recursively reading directories. It is similar to the recursive file listing feature of node-dir but is lighter and has fewer features, focusing only on reading directories.

README

node-dir

A small node.js module to provide some convenience methods for asynchronous, non-blocking, recursive directory operations like being able to get an array of all files, subdirectories, or both (with the option to either combine or separate the results), and for sequentially reading and processing the contents all files in a directory recursively, optionally firing a callback when finished.

methods

For the sake of brevity, assume that the following line of code precedes all of the examples.

var dir = require('node-dir');

readFiles( dir, [options], fileCallback, [finishedCallback] )

Sequentially read the content of each file in a directory, passing the contents to a callback, optionally calling a finished callback when complete. The options and finishedCallback arguments are not required.

Valid options are:

• encoding: file encoding (defaults to 'utf8')
• match: a regex pattern to specify filenames to operate on
• exclude: a regex pattern to specify filenames to ignore
• shortName: whether to aggregate only the base filename rather than the full filepath

dir.readFiles(__dirname,
    function(err, content, next) {
        if (err) throw err;
        console.log('content:', content);
        next();
    },
    function(err, files){
        if (err) throw err;
        console.log('finished reading files:',files);
    });

// match only filenames with a .txt extension and that don't start with a `.´
dir.readFiles(__dirname, {
    match: /.txt$/,
    exclude: /^\./
    }, function(err, content, next) {
        if (err) throw err;
        console.log('content:', content);
        next();
    },
    function(err, files){
        if (err) throw err;
        console.log('finished reading files:',files);
    });

// the callback for each file can optionally have a filename argument as its 3rd parameter
// and the finishedCallback argument is optional, e.g.
dir.readFiles(__dirname, function(err, content, filename, next) {
        console.log('processing content of file', filename);
        next();
    });

files( dir, callback )

Asynchronously iterate the files of a directory and its subdirectories and pass an array of file paths to a callback.

dir.files(__dirname, function(err, files) {
    if (err) throw err;
    console.log(files);
});

subdirs( dir, callback )

Asynchronously iterate the subdirectories of a directory and its subdirectories and pass an array of directory paths to a callback.

dir.subdirs(__dirname, function(err, subdirs) {
    if (err) throw err;
    console.log(subdirs);
});

paths(dir, [combine], callback )

Asynchronously iterate the subdirectories of a directory and its subdirectories and pass an array of both file and directory paths to a callback.

Separated into two distinct arrays (paths.files and paths.dirs)

dir.paths(__dirname, function(err, paths) {
    if (err) throw err;
    console.log('files:\n',paths.files);
    console.log('subdirs:\n', paths.dirs);
});

Combined in a single array (convenience method for concatenation of the above)

dir.paths(__dirname, true, function(err, paths) {
    if (err) throw err;
    console.log('paths:\n',paths);
});

contributors

• Nathan Cartwright
• robatron
• nazomikan

License

MIT licensed (See LICENSE.txt)