fs-extra vs memfs vs memory-fs vs mock-fs
File System Abstraction and Testing Utilities for Node.js
Search packages..
fs-extramemfsmemory-fsmock-fsSimilar Packages:

File System Abstraction and Testing Utilities for Node.js

fs-extra extends the built-in Node.js fs module with additional methods like ensureDir and promise support. memfs and memory-fs implement a virtual file system in memory, useful for testing or isolated environments. mock-fs intercepts calls to the real fs module to simulate files and directories without touching the disk. Together, these tools cover production file operations, in-memory isolation, and test mocking scenarios.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
fs-extra09,61058.1 kB15a month agoMIT
memfs02,06864.8 kB535 days agoApache-2.0
memory-fs0878-307 years agoMIT
mock-fs0918107 kB74a year agoMIT

File System Utilities for Node.js Development and Testing

When building Node.js applications, handling files safely and efficiently is critical. The packages fs-extra, memfs, memory-fs, and mock-fs all address file system interactions, but they serve different purposes. Some enhance the real file system, while others simulate it entirely. Let's compare how they handle common tasks.

📝 Basic File Operations: Reading and Writing

fs-extra works directly with the real disk but adds convenience methods.

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

// Reads from actual disk
const data = await fs.readFile('/path/to/file.txt', 'utf8');

memfs creates a virtual file system instance that lives in RAM.

const { fs } = require('memfs');

// Reads from memory volume
const data = fs.readFileSync('/path/to/file.txt', 'utf8');

memory-fs also uses RAM but is legacy technology.

const MemoryFileSystem = require('memory-fs');
const fs = new MemoryFileSystem();

// Reads from legacy memory volume
const data = fs.readFileSync('/path/to/file.txt', 'utf8');

mock-fs tricks the native fs module into reading from a fake structure.

const mock = require('mock-fs');
const fs = require('fs');

mock({ '/path/to/file.txt': 'content' });

// Reads from mocked structure
const data = fs.readFileSync('/path/to/file.txt', 'utf8');

📁 Directory Management: Creating Folders Safely

Creating directories often fails if parent folders do not exist. These packages handle that differently.

fs-extra provides ensureDir, which creates all missing parents automatically.

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

// Creates /tmp/new/dir even if /tmp/new is missing
await fs.ensureDir('/tmp/new/dir');

memfs relies on the standard recursive option available in modern Node.js.

const { fs } = require('memfs');

// Creates directory tree in memory
fs.mkdirSync('/tmp/new/dir', { recursive: true });

memory-fs uses a specific helper method mkdirp.

const MemoryFileSystem = require('memory-fs');
const fs = new MemoryFileSystem();

// Creates directory tree in legacy memory
fs.mkdirpSync('/tmp/new/dir');

mock-fs defines the entire structure upfront in the mock config.

const mock = require('mock-fs');

// Define structure before test runs
mock({
  '/tmp/new/dir': {}
});

🧪 Testing Strategy: Isolation and Cleanup

When writing tests, you want to avoid leaving files on your computer after the test runs.

fs-extra requires manual cleanup since it touches the real disk.

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

await fs.writeFile('/tmp/test.txt', 'data');
// You must manually delete this later
await fs.remove('/tmp/test.txt');

memfs isolates data in memory, so cleanup is instant when the process ends.

const { fs, vol } = require('memfs');

vol.fromJSON({ '/test.txt': 'data' });
// No disk cleanup needed

memory-fs also isolates in memory but lacks modern features.

const MemoryFileSystem = require('memory-fs');
const fs = new MemoryFileSystem();

fs.writeFileSync('/test.txt', 'data');
// Isolated but deprecated

mock-fs swaps the real module and restores it after tests.

const mock = require('mock-fs');

mock({ '/test.txt': 'data' });
// Run tests
mock.restore(); // Returns to real fs

⚠️ Maintenance Status: Active vs Deprecated

This is the most critical factor for long-term projects.

fs-extra is actively maintained and stable.

// Safe for production use
const fs = require('fs-extra');

memfs is actively maintained and recommended for in-memory needs.

// Safe for modern projects
const { fs } = require('memfs');

memory-fs is deprecated and should not be used.

// DO NOT USE - Deprecated
const MemoryFileSystem = require('memory-fs');

mock-fs is maintained for testing purposes.

// Safe for testing
const mock = require('mock-fs');

📊 Summary: Key Differences

Featurefs-extramemfsmemory-fsmock-fs
Storage🖥️ Real Disk💾 Memory💾 Memory🎭 Mocked Disk
Status✅ Active✅ Active❌ Deprecated✅ Active
Best ForProduction IOVirtual FSLegacy CodeUnit Tests
SetupDrop-in ReplaceNew InstanceNew InstanceGlobal Swap
CleanupManualAuto (RAM)Auto (RAM)Manual Restore

💡 The Big Picture

fs-extra is the standard choice for real file operations — it makes working with the actual disk safer and easier. Use it for build scripts, server uploads, or any task that needs persistent storage.

memfs is the modern standard for in-memory file systems — it is fast and isolated. Use it for testing tools, bundlers, or scenarios where disk I/O is too slow or undesirable.

mock-fs is the specialist for testing — it lets you fake the file system without changing your code. Use it when you need to test how your app handles missing files or specific directory structures.

memory-fs should be avoided — it is deprecated and replaced by memfs. Only interact with it if you are maintaining older webpack configurations.

Final Thought: For new projects, combine fs-extra for real disk tasks and memfs or mock-fs for testing. Avoid memory-fs entirely to ensure your stack remains supported.

How to Choose: fs-extra vs memfs vs memory-fs vs mock-fs

  • fs-extra:

    Choose fs-extra for production applications that need reliable file operations beyond the standard library. It is ideal when you require methods like ensureDir or move that simplify common tasks. This package is stable and widely adopted for server-side Node.js development.

  • memfs:

    Choose memfs when you need a modern, actively maintained in-memory file system implementation. It is suitable for testing environments or tools that require fast, isolated file operations without disk I/O. This package is the recommended successor to older in-memory solutions.

  • memory-fs:

    Do not choose memory-fs for new projects as it is officially deprecated and no longer maintained. It was previously used by webpack but has been replaced by memfs. You should only encounter this in legacy codebases that have not yet migrated.

  • mock-fs:

    Choose mock-fs when you need to mock the native fs module during testing without changing your application code. It allows you to define a fake file structure that your tests can interact with safely. This is best for unit tests that require file system isolation.

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 memfs

memfs is a memory file system implementation for Node.js that allows developers to create and manipulate files in memory rather than on disk. This can be particularly useful for testing, prototyping, or scenarios where you want to avoid the overhead of file I/O. With memfs, you can perform typical file system operations like reading, writing, and deleting files, all while keeping everything in memory for speed and efficiency.

While memfs provides a robust solution for in-memory file operations, there are several alternatives that developers might consider:

  • fs-extra is an extension of the built-in Node.js fs module that adds extra methods and functionality. It allows for easier file manipulation with additional features like recursive directory creation, file copying, and more. While fs-extra operates on the actual file system rather than in memory, it is a great choice for developers looking for a more feature-rich alternative to the standard fs module.
  • memory-fs is another in-memory file system for Node.js, similar to memfs. It is often used in scenarios like Webpack where a virtual file system is needed to handle files during the build process. Memory-fs allows for efficient file operations in memory, making it suitable for applications that require fast access to file data without the need for persistent storage.
  • mock-fs is a library designed for testing purposes that allows you to mock the file system in your tests. It enables developers to simulate file system operations without affecting the actual file system, making it easy to test code that interacts with files. Mock-fs is particularly useful in unit tests where you want to isolate file system interactions and ensure that your tests are not dependent on the actual file system state.

To explore how memfs compares with fs-extra, memory-fs, and mock-fs, check out the comparison: Comparing fs-extra vs memfs vs memory-fs vs mock-fs.

Similar Npm Packages to memory-fs

memory-fs is a Node.js package that provides an in-memory file system. It allows developers to create, read, and manipulate files in memory, which can be particularly useful for testing, bundling, or any scenario where you need a temporary file system without writing to disk. This can enhance performance and speed up operations since accessing memory is significantly faster than disk I/O. memory-fs is often used in conjunction with build tools like Webpack, enabling developers to handle file operations seamlessly during the build process.

An alternative to memory-fs is memfs. Memfs is another in-memory file system implementation for Node.js, but it offers a more comprehensive API and additional features. It is designed to be a drop-in replacement for the native Node.js fs module, providing a familiar interface for developers. With memfs, you can perform file operations like reading, writing, and deleting files, all in memory, making it a versatile choice for various applications, including testing and development environments.

To see how memory-fs compares with memfs, check out the comparison: Comparing memory-fs vs memfs.

Similar Npm Packages to mock-fs

mock-fs is a Node.js package that allows developers to create a mock file system for testing purposes. It simulates a file system environment, enabling you to test file operations without affecting the actual file system. This is particularly useful for unit tests where you want to isolate file system interactions and avoid side effects. With mock-fs, you can create a virtual file system, define files and directories, and control the behavior of file operations, making it easier to write reliable and repeatable tests.

An alternative to mock-fs is memfs. Memfs is a memory-based file system that provides a similar functionality but is designed to work seamlessly with the Node.js fs module. It allows you to create an in-memory file system that can be used for testing or other purposes where you need a temporary file system without writing to disk. memfs is particularly useful when you want to maintain compatibility with existing code that uses the fs module, as it can be easily swapped in for testing without significant changes to your codebase.

For a detailed comparison of these two packages, check out the following link: Comparing memfs vs mock-fs.

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')

NOTE: The deprecated constants fs.F_OK, fs.R_OK, fs.W_OK, & fs.X_OK are not exported on Node.js v24.0.0+; please use their fs.constants equivalents.

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:

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-2024 JP Richardson

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.