File System Utilities for Node.js Comparison
fs-extra vs rimraf vs mkdirp vs graceful-fs vs node-fs
Search packages..
1 Year
fs-extrarimrafmkdirpgraceful-fsnode-fsSimilar Packages:
What's File System Utilities for Node.js?

These npm packages provide various utilities for file system operations in Node.js, enhancing the built-in 'fs' module with additional features, improved performance, and better error handling. They are essential for developers looking to simplify file manipulation tasks such as reading, writing, and deleting files or directories. Each package has its unique strengths, catering to different use cases and preferences in file system management.

NPM Package Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
fs-extra89,639,1779,49354.9 kB16a year agoMIT
rimraf82,493,4325,687281 kB115 months agoISC
mkdirp73,707,983187107 kB12 years agoMIT
graceful-fs53,280,8691,27632.5 kB492 years agoISC
node-fs99,07568-011 years ago-
Feature Comparison: fs-extra vs rimraf vs mkdirp vs graceful-fs vs node-fs

Extended Functionality

  • fs-extra:

    fs-extra adds several useful methods to the native fs module, such as 'copy', 'move', 'remove', and 'ensureDir', allowing for more complex file operations with ease.

  • rimraf:

    rimraf is specifically designed for recursive directory removal, making it a reliable choice for deleting directories and their contents, handling deep structures effortlessly.

  • mkdirp:

    mkdirp provides a simple way to create directories recursively, allowing you to create a directory and any necessary parent directories in a single function call, which is not available in the native fs module.

  • graceful-fs:

    graceful-fs primarily enhances the existing fs module by improving its behavior under heavy load, ensuring that file operations do not fail due to too many open file descriptors.

  • node-fs:

    node-fs offers a minimalistic approach to file system operations, providing basic methods for reading and writing files without the additional features found in other packages.

Error Handling

  • fs-extra:

    fs-extra includes built-in error handling that provides clear messages and prevents common pitfalls associated with file operations, making it easier to debug issues.

  • rimraf:

    rimraf provides clear error messages when directory deletion fails, helping developers understand issues related to permissions or non-existent paths.

  • mkdirp:

    mkdirp handles errors gracefully, ensuring that if a directory already exists, it does not throw an error, thus simplifying the directory creation process.

  • graceful-fs:

    graceful-fs mitigates errors related to file system limits by queuing requests, which helps prevent crashes and improves stability during high-load operations.

  • node-fs:

    node-fs offers basic error handling, but it may not provide as much detail or robustness as other packages, making it less suitable for complex applications.

Performance

  • fs-extra:

    fs-extra is optimized for performance, particularly in bulk file operations, making it suitable for applications that require efficient file handling.

  • rimraf:

    rimraf is designed for performance in directory deletion, ensuring that it can handle large directory trees without significant slowdowns.

  • mkdirp:

    mkdirp is efficient in creating directories, as it only creates directories that do not already exist, minimizing unnecessary operations.

  • graceful-fs:

    graceful-fs improves performance by managing the number of concurrent file system operations, reducing the likelihood of hitting system limits.

  • node-fs:

    node-fs is lightweight and performs well for basic file operations, but may not be as optimized for larger tasks compared to fs-extra or graceful-fs.

Ease of Use

  • fs-extra:

    fs-extra is user-friendly, with a clear API that simplifies complex file operations, making it accessible for developers of all skill levels.

  • rimraf:

    rimraf's API is simple and mirrors the Unix command line, making it easy to use for developers familiar with shell commands.

  • mkdirp:

    mkdirp has a straightforward API that allows for quick directory creation, making it easy to integrate into existing projects.

  • graceful-fs:

    graceful-fs maintains a familiar API while enhancing the native fs module, making it easy to adopt without a steep learning curve.

  • node-fs:

    node-fs offers a simple and intuitive API, making it easy for developers to perform basic file operations without additional complexity.

Community and Support

  • fs-extra:

    fs-extra has a large community and extensive documentation, providing ample resources for troubleshooting and learning.

  • rimraf:

    rimraf is widely adopted and has strong community support, making it easy to find solutions and examples for common use cases.

  • mkdirp:

    mkdirp is popular among developers for its simplicity, and it has a supportive community that contributes to its ongoing development.

  • graceful-fs:

    graceful-fs is well-maintained and widely used, ensuring that developers can find support and examples easily.

  • node-fs:

    node-fs has a smaller community compared to others, which may limit available resources and support.

How to Choose: fs-extra vs rimraf vs mkdirp vs graceful-fs vs node-fs
  • fs-extra:

    Choose fs-extra if you need a comprehensive solution that extends the native fs module with additional methods like copy, remove, and ensureFile, making it ideal for complex file operations.

  • rimraf:

    Choose rimraf for robust directory deletion, especially when dealing with deep directory structures or when you need to ensure that directories are removed recursively, similar to the Unix command 'rm -rf'.

  • mkdirp:

    Select mkdirp when you need to create nested directories easily. It allows you to create a directory and all its parent directories in a single call, simplifying directory creation in your applications.

  • graceful-fs:

    Opt for graceful-fs if you want to improve the reliability of file system operations in Node.js, especially in high-load scenarios, as it gracefully handles the limitations of the native fs module by queuing requests.

  • node-fs:

    Use node-fs if you prefer a lightweight alternative to the native fs module with a more straightforward API, focusing on basic file operations without additional features.

Similar Npm Packages to fs-extra

fs-extra is a popular Node.js package that extends the built-in fs (file system) module with additional methods and functionalities. It provides a more convenient and powerful API for file and directory manipulation, making it easier to handle common tasks like copying, moving, and removing files. With fs-extra, developers can work with promises or callbacks, enabling a more flexible approach to file operations.

While fs-extra is a robust choice for file system operations, there are alternatives available that may better suit specific needs:

  • fs is the built-in Node.js file system module. It provides a comprehensive set of methods for interacting with the file system, including reading and writing files, creating directories, and more. However, it lacks some of the convenience methods found in fs-extra, such as recursive directory creation or file copying with additional options. If you only need basic file system operations and prefer to stick with the core Node.js modules, using fs might be sufficient for your needs.
  • fs-extra-promise is a variant of fs-extra that focuses on providing promise-based methods for file system operations. This package allows developers to work with promises instead of callbacks, making it easier to manage asynchronous operations. If you prefer using promises for handling file system tasks and want to leverage the additional features of fs-extra, fs-extra-promise is a great option.

To see how fs-extra compares with fs and fs-extra-promise, check out the comparison: Comparing fs vs fs-extra vs fs-extra-promise.

Similar Npm Packages to rimraf

rimraf is a popular npm package used for deleting files and directories in Node.js applications. It is particularly useful for removing directories that may contain files and subdirectories, as it recursively deletes everything within the specified path. This functionality is similar to the Unix command rm -rf, making it a go-to choice for developers looking for a reliable way to clean up their file system during build processes or other tasks.

While rimraf is widely used, there are several alternatives that offer similar functionality. Here are a few noteworthy options:

  • del is a powerful package that provides a simple and flexible way to delete files and directories. It supports glob patterns, allowing users to specify which files or directories to delete with ease. Additionally, del can return a promise, making it easy to integrate into asynchronous workflows. If you need more control over the deletion process or want to use glob patterns, del is a great alternative to rimraf.

  • fs-extra is an extension of the built-in Node.js fs module that adds extra methods for file and directory manipulation. Among its many features, fs-extra includes a remove function that behaves similarly to rimraf, allowing for the deletion of files and directories. If you are already using fs-extra for other file operations, leveraging its remove method can simplify your code and reduce dependencies.

  • remove is another package designed for deleting files and directories. It offers a straightforward API and supports asynchronous operations, making it easy to use in modern JavaScript applications. If you are looking for a lightweight alternative that focuses solely on file and directory removal, remove is worth considering.

To compare these packages and see how they stack up against each other, check out the following link: Comparing del vs fs-extra vs remove vs rimraf.

Similar Npm Packages to mkdirp

mkdirp is a popular npm package that allows developers to create directories recursively in Node.js applications. It simplifies the process of ensuring that a directory structure exists, making it particularly useful for applications that need to create nested directories without having to check for their existence manually. While mkdirp is a reliable choice for directory creation, there are several alternatives that offer similar functionality. Here are a few noteworthy options:

  • fs-extra is an extension of the built-in Node.js fs module that adds additional file system methods and functionality. Among its many features, fs-extra includes the ability to create directories recursively, similar to mkdirp. It also provides a wide range of other file system operations, making it a versatile choice for developers who need more than just directory creation. If you are looking for a comprehensive file system utility that includes directory creation along with many other useful methods, fs-extra is an excellent option.
  • make-dir is a lightweight alternative to mkdirp that focuses solely on creating directories. It supports creating directories recursively and is designed to be simple and efficient. If you prefer a minimalistic approach and only need a straightforward solution for making directories, make-dir is a great choice. Its simplicity makes it easy to integrate into any project without adding unnecessary complexity.
  • mkdirp-promise is a promise-based version of mkdirp, allowing for asynchronous directory creation. This package is particularly useful for developers who prefer to work with promises or async/await syntax in their Node.js applications. If you need the functionality of mkdirp but want to leverage modern JavaScript features for asynchronous operations, mkdirp-promise is a suitable alternative.

To explore how mkdirp compares with fs-extra, make-dir, and mkdirp-promise, check out the comparison link: Comparing fs-extra vs make-dir vs mkdirp vs mkdirp-promise.

Similar Npm Packages to graceful-fs

graceful-fs is a Node.js module that enhances the built-in fs (file system) module by providing a more resilient and robust way to handle file system operations. It addresses issues related to the default fs module, such as handling too many open file descriptors and providing better error handling. By using graceful-fs, developers can ensure that their applications are less likely to crash due to file system-related errors, making it a reliable choice for file operations in Node.js applications. However, there are several alternatives available that also provide file system utilities. Here are a few:

  • fs-extra is an extension of the built-in fs module that adds extra methods and functionality. It includes methods for copying, removing, and moving files and directories, as well as methods for ensuring that directories exist. fs-extra is a great choice for developers who need additional file system features while still relying on the familiar fs API. Its simplicity and added functionality make it a popular choice for many Node.js projects.
  • mkdirp is a small utility that allows you to create directories recursively. If you need to create a directory and all its parent directories if they do not exist, mkdirp is the go-to solution. It is lightweight and straightforward, making it an excellent choice for projects that require directory creation without the overhead of a larger library.
  • node-fs is another alternative that provides a more modern approach to file system operations in Node.js. It offers a promise-based API, making it easier to work with asynchronous file operations. If you prefer using promises over callbacks for file system tasks, node-fs can be a suitable option.
  • rimraf is a utility for removing files and directories, similar to the Unix command rm -rf. It is particularly useful for cleaning up temporary files or directories in a Node.js application. If you need a reliable way to delete files and directories recursively, rimraf is a straightforward and effective solution.

To compare these packages, check out the following link: Comparing fs-extra vs graceful-fs vs mkdirp vs node-fs vs rimraf.

README for fs-extra

Node.js: fs-extra

fs-extra adds file system methods that aren't included in the native fs module and adds promise support to the fs methods. It also uses graceful-fs to prevent EMFILE errors. It should be a drop in replacement for fs.

npm Package License build status downloads per month JavaScript Style Guide

Why?

I got tired of including mkdirp, rimraf, and ncp in most of my projects.

Installation

npm install fs-extra

Usage

CommonJS

fs-extra is a drop in replacement for native fs. All methods in fs are attached to fs-extra. All fs methods return promises if the callback isn't passed.

You don't ever need to include the original fs module again:

const fs = require('fs') // this is no longer necessary

you can now do this:

const fs = require('fs-extra')

or if you prefer to make it clear that you're using fs-extra and not fs, you may want to name your fs variable fse like so:

const fse = require('fs-extra')

you can also keep both, but it's redundant:

const fs = require('fs')
const fse = require('fs-extra')

ESM

There is also an fs-extra/esm import, that supports both default and named exports. However, note that fs methods are not included in fs-extra/esm; you still need to import fs and/or fs/promises seperately:

import { readFileSync } from 'fs'
import { readFile } from 'fs/promises'
import { outputFile, outputFileSync } from 'fs-extra/esm'

Default exports are supported:

import fs from 'fs'
import fse from 'fs-extra/esm'
// fse.readFileSync is not a function; must use fs.readFileSync

but you probably want to just use regular fs-extra instead of fs-extra/esm for default exports:

import fs from 'fs-extra'
// both fs and fs-extra methods are defined

Sync vs Async vs Async/Await

Most methods are async by default. All async methods will return a promise if the callback isn't passed.

Sync methods on the other hand will throw if an error occurs.

Also Async/Await will throw an error if one occurs.

Example:

const fs = require('fs-extra')

// Async with promises:
fs.copy('/tmp/myfile', '/tmp/mynewfile')
  .then(() => console.log('success!'))
  .catch(err => console.error(err))

// Async with callbacks:
fs.copy('/tmp/myfile', '/tmp/mynewfile', err => {
  if (err) return console.error(err)
  console.log('success!')
})

// Sync:
try {
  fs.copySync('/tmp/myfile', '/tmp/mynewfile')
  console.log('success!')
} catch (err) {
  console.error(err)
}

// Async/Await:
async function copyFiles () {
  try {
    await fs.copy('/tmp/myfile', '/tmp/mynewfile')
    console.log('success!')
  } catch (err) {
    console.error(err)
  }
}

copyFiles()

Methods

Async

Sync

NOTE: You can still use the native Node.js methods. They are promisified and copied over to fs-extra. See notes on fs.read(), fs.write(), & fs.writev()

What happened to walk() and walkSync()?

They were removed from fs-extra in v2.0.0. If you need the functionality, walk and walkSync are available as separate packages, klaw and klaw-sync.

Third Party

CLI

fse-cli allows you to run fs-extra from a console or from npm scripts.

TypeScript

If you like TypeScript, you can use fs-extra with it: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/fs-extra

File / Directory Watching

If you want to watch for changes to files or directories, then you should use chokidar.

Obtain Filesystem (Devices, Partitions) Information

fs-filesystem allows you to read the state of the filesystem of the host on which it is run. It returns information about both the devices and the partitions (volumes) of the system.

Misc.

Hacking on fs-extra

Wanna hack on fs-extra? Great! Your help is needed! fs-extra is one of the most depended upon Node.js packages. This project uses JavaScript Standard Style - if the name or style choices bother you, you're gonna have to get over it :) If standard is good enough for npm, it's good enough for fs-extra.

js-standard-style

What's needed?

  • First, take a look at existing issues. Those are probably going to be where the priority lies.
  • More tests for edge cases. Specifically on different platforms. There can never be enough tests.
  • Improve test coverage.

Note: If you make any big changes, you should definitely file an issue for discussion first.

Running the Test Suite

fs-extra contains hundreds of tests.

  • npm run lint: runs the linter (standard)
  • npm run unit: runs the unit tests
  • npm run unit-esm: runs tests for fs-extra/esm exports
  • npm test: runs the linter and all tests

When running unit tests, set the environment variable CROSS_DEVICE_PATH to the absolute path of an empty directory on another device (like a thumb drive) to enable cross-device move tests.

Windows

If you run the tests on the Windows and receive a lot of symbolic link EPERM permission errors, it's because on Windows you need elevated privilege to create symbolic links. You can add this to your Windows's account by following the instructions here: http://superuser.com/questions/104845/permission-to-make-symbolic-links-in-windows-7 However, I didn't have much luck doing this.

Since I develop on Mac OS X, I use VMWare Fusion for Windows testing. I create a shared folder that I map to a drive on Windows. I open the Node.js command prompt and run as Administrator. I then map the network drive running the following command:

net use z: "\\vmware-host\Shared Folders"

I can then navigate to my fs-extra directory and run the tests.

Naming

I put a lot of thought into the naming of these functions. Inspired by @coolaj86's request. So he deserves much of the credit for raising the issue. See discussion(s) here:

  • https://github.com/jprichardson/node-fs-extra/issues/2
  • https://github.com/flatiron/utile/issues/11
  • https://github.com/ryanmcgrath/wrench-js/issues/29
  • https://github.com/substack/node-mkdirp/issues/17

First, I believe that in as many cases as possible, the Node.js naming schemes should be chosen. However, there are problems with the Node.js own naming schemes.

For example, fs.readFile() and fs.readdir(): the F is capitalized in File and the d is not capitalized in dir. Perhaps a bit pedantic, but they should still be consistent. Also, Node.js has chosen a lot of POSIX naming schemes, which I believe is great. See: fs.mkdir(), fs.rmdir(), fs.chown(), etc.

We have a dilemma though. How do you consistently name methods that perform the following POSIX commands: cp, cp -r, mkdir -p, and rm -rf?

My perspective: when in doubt, err on the side of simplicity. A directory is just a hierarchical grouping of directories and files. Consider that for a moment. So when you want to copy it or remove it, in most cases you'll want to copy or remove all of its contents. When you want to create a directory, if the directory that it's suppose to be contained in does not exist, then in most cases you'll want to create that too.

So, if you want to remove a file or a directory regardless of whether it has contents, just call fs.remove(path). If you want to copy a file or a directory whether it has contents, just call fs.copy(source, destination). If you want to create a directory regardless of whether its parent directories exist, just call fs.mkdirs(path) or fs.mkdirp(path).

Credit

fs-extra wouldn't be possible without using the modules from the following authors:

License

Licensed under MIT

Copyright (c) 2011-2017 JP Richardson

Terms & PrivacyProduct HuntJSON to TypeScriptCopilotChat for Web Dev