fast-glob vs glob vs micromatch vs node-glob
File Pattern Matching and Traversal in Node.js
Search packages..
fast-globglobmicromatchnode-globSimilar Packages:

File Pattern Matching and Traversal in Node.js

fast-glob, glob, micromatch, and node-glob are utilities used to match file paths against wildcard patterns (globs) in JavaScript and Node.js environments. glob and fast-glob are primarily designed to traverse the file system and return lists of files that match a given pattern. micromatch focuses on high-performance string matching against glob patterns without necessarily traversing the file system itself, often serving as the engine for other tools. node-glob is historically associated with the glob package (often the repository name), but as a distinct npm package, it is generally considered legacy or a wrapper around glob. These tools are essential for build systems, task runners, and file manipulation scripts where selecting specific files based on naming conventions is required.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
fast-glob02,80498.4 kB41a year agoMIT
glob08,7231.61 MB4a month agoBlueOak-1.0.0
micromatch03,02156.6 kB442 years agoMIT
node-glob02-110 years agoBSD-3-Clause

File Pattern Matching and Traversal: fast-glob vs glob vs micromatch vs node-glob

When building Node.js tools, build scripts, or file processors, you inevitably need to find files based on patterns like src/**/*.js. The ecosystem offers several options, but they solve slightly different problems. fast-glob and glob traverse the file system to find files. micromatch matches strings against patterns. node-glob is a legacy reference often confused with glob. Let's break down how they differ in practice.

🗂️ Core Function: Traversal vs Matching

The most important distinction is whether the library walks the file system or just matches strings.

fast-glob traverses the file system asynchronously by default. It reads directories and returns file paths that match.

import fg from 'fast-glob';

// Traverses disk, returns array of file paths
const files = await fg(['src/**/*.js'], { absolute: true });
console.log(files); // ['/project/src/index.js', ...]

glob also traverses the file system. It is the historical standard for this operation in Node.js.

import { glob } from 'glob';

// Traverses disk, returns array of file paths
const files = await glob(['src/**/*.js'], { absolute: true });
console.log(files); // ['/project/src/index.js', ...]

micromatch does not traverse the file system. It matches an array of strings you provide against a pattern. You must get the file list first (e.g., via fs.readdir or another tool).

import mm from 'micromatch';

// Matches strings in memory, returns filtered array
const files = ['src/index.js', 'src/test.ts', 'dist/bundle.js'];
const matched = mm(files, ['src/**/*.js']);
console.log(matched); // ['src/index.js']

node-glob functions like glob (traversal), but as a package, it is often a wrapper or outdated alias. In modern contexts, it behaves similarly to glob but lacks active feature development.

import glob from 'node-glob';

// Traverses disk (legacy API style)
glob('src/**/*.js', (err, files) => {
  console.log(files); // ['/project/src/index.js', ...]
});

⚡ Performance and Concurrency

Speed matters when scanning thousands of files. fast-glob is engineered for concurrency, while glob prioritizes consistency.

fast-glob uses multiple workers to read directories in parallel. It is significantly faster on large projects.

import fg from 'fast-glob';

// Optimized for speed with concurrent directory reading
const entries = await fg(['**/*.ts'], {
  concurrency: 4, // Control parallelism
  deep: 5         // Limit recursion depth
});

glob traditionally processes directories sequentially, though newer versions have improved. It is generally slower than fast-glob on deep trees.

import { glob } from 'glob';

// Standard traversal, generally single-threaded execution
const entries = await glob(['**/*.ts'], {
  ignore: ['node_modules/**']
});

micromatch is extremely fast because it only does string comparison, no disk I/O. It is often used inside faster tools to filter results.

import mm from 'micromatch';

// Instant string matching, no I/O overhead
const isMatch = mm.isMatch('src/components/Button.tsx', ['**/*.tsx']);
console.log(isMatch); // true

node-glob inherits the performance characteristics of the older glob implementations. It does not offer the concurrency optimizations found in fast-glob.

import glob from 'node-glob';

// Legacy callback-based async, no concurrency options
glob('**/*.ts', { ignore: 'node_modules/**' }, (err, matches) => {
  // Process matches
});

🛠️ API Design: Promises vs Callbacks

Modern development favors async/await. The libraries differ in how they expose asynchronous operations.

fast-glob is Promise-first. It returns Promises by default but also offers Sync and Stream APIs.

import fg from 'fast-glob';

// Async/Await support out of the box
async function getFiles() {
  const files = await fg('*.json');
  return files;
}

glob (v9+) has moved to a Promise-based API as the default export, aligning with modern standards.

import { glob } from 'glob';

// Modern Promise-based API
async function getFiles() {
  const files = await glob('*.json');
  return files;
}

micromatch is synchronous. Since it only matches strings, it returns results immediately without needing Promises.

import mm from 'micromatch';

// Synchronous return
const matches = mm(['a.js', 'b.ts'], ['*.js']);
// Returns immediately

node-glob relies heavily on the older callback pattern, though some versions support Promises via util.promisify. It feels dated in modern codebases.

import glob from 'node-glob';

// Callback pattern required by default
glob('*.json', (err, files) => {
  if (err) throw err;
  console.log(files);
});

🚫 Handling Negation and Ignoring Files

Excluding files (like node_modules) is a common requirement. All packages support this, but syntax varies slightly.

fast-glob supports negation patterns directly in the pattern array.

import fg from 'fast-glob';

// Negate patterns with '!' prefix
const files = await fg(['**/*.js', '!**/vendor/**']);

glob uses an ignore option or negation patterns.

import { glob } from 'glob';

// Using the ignore option
const files = await glob(['**/*.js'], {
  ignore: ['**/vendor/**']
});

micromatch supports negation in the pattern array, similar to fast-glob.

import mm from 'micromatch';

// Negate patterns in the list
const files = mm(['src/a.js', 'vendor/b.js'], ['**/*.js', '!**/vendor/**']);

node-glob uses the ignore option, consistent with the original glob spec.

import glob from 'node-glob';

// Using ignore option
const options = { ignore: ['**/vendor/**'] };
glob('**/*.js', options, (err, files) => {
  // Handle result
});

🌐 Real-World Scenarios

Scenario 1: Build Tool File Discovery

You are writing a bundler that needs to find all source files quickly.

  • ✅ Best choice: fast-glob
  • Why? You need speed and async support to avoid blocking the build process.
import fg from 'fast-glob';
const sources = await fg(['src/**/*.{ts,tsx}']);

Scenario 2: Filtering a Known File List

You already have a list of files from a Git hook and need to check which ones match a linting pattern.

  • ✅ Best choice: micromatch
  • Why? No disk I/O needed, just pure string matching.
import mm from 'micromatch';
const toLint = mm(gitChangedFiles, ['**/*.js']);

Scenario 3: Legacy Script Maintenance

You are maintaining an old Node.js script that uses callbacks everywhere.

  • ✅ Best choice: node-glob or glob (older versions)
  • Why? Fits the existing control flow without refactoring to Promises.
import glob from 'node-glob';
glob('**/*.md', (err, files) => { /* ... */ });

Scenario 4: Standard CLI Tool

You are building a CLI that needs to be robust and standard-compliant across many environments.

  • ✅ Best choice: glob
  • Why? It is the reference implementation with the widest compatibility.
import { glob } from 'glob';
const files = await glob('**/*.md');

📊 Summary Table

Featurefast-globglobmicromatchnode-glob
File System Traversal✅ Yes✅ Yes❌ No (String only)✅ Yes
Default API StylePromise / AsyncPromise / AsyncSynchronousCallback
Performance🚀 High (Parallel)🐢 Moderate⚡ Very High (In-memory)🐢 Moderate
Negation Support✅ Pattern (!)✅ Option / Pattern✅ Pattern (!)✅ Option
Maintenance Status🟢 Active🟢 Active🟢 Active🟡 Legacy
TypeScript Support🟢 Built-in🟢 Built-in🟢 Built-in🟡 Community

💡 Final Recommendation

Think about where your data lives and how you handle async.

  • Need to scan the disk? → Use fast-glob for speed or glob for stability.
  • Need to match strings in memory? → Use micromatch.
  • Maintaining old code? → node-glob works, but plan to migrate.

For most modern frontend architectures, fast-glob is the default choice for file discovery due to its speed and modern API. micromatch is essential to keep in your toolkit for filtering logic where disk access is not required. Avoid node-glob for new work, as glob provides the same functionality with better long-term support.

How to Choose: fast-glob vs glob vs micromatch vs node-glob

  • fast-glob:

    Choose fast-glob for modern Node.js projects where performance is critical, especially when dealing with large directory structures. It supports async, sync, and stream operations out of the box and offers a more modern API with better TypeScript support. It is the preferred choice for new tooling and build pipelines that need speed and flexibility without sacrificing features.

  • glob:

    Choose glob if you need the reference implementation that has been the standard for over a decade. It is highly stable and widely compatible with older Node.js versions. It is ideal for projects that prioritize long-term stability and strict adherence to standard glob behavior over raw speed, or when working in environments where fast-glob dependencies might be an issue.

  • micromatch:

    Choose micromatch when you need to match patterns against strings in memory rather than traversing the file system. It is perfect for filtering lists of files you already have, or for building custom tools that need a high-performance matching engine. It is often used internally by bundlers and linters to evaluate path patterns quickly.

  • node-glob:

    Avoid using node-glob in new projects as it is largely considered legacy or redundant compared to the glob package. The functionality is effectively covered by glob, which is the actively maintained canonical package. If you encounter node-glob in older codebases, plan to migrate to glob or fast-glob for better long-term support and performance.

Similar Npm Packages to fast-glob

fast-glob is a high-performance file matching library for Node.js that allows developers to efficiently search for files and directories using glob patterns. It is designed to be faster and more efficient than traditional glob libraries, making it an excellent choice for applications that require quick file system operations. Fast-glob supports various features such as streaming, caching, and asynchronous operations, which enhance its performance and usability.

While fast-glob is a robust option for file matching, there are several alternatives in the Node.js ecosystem that also provide globbing capabilities. Here are a few notable alternatives:

  • glob is one of the most widely used globbing libraries in the Node.js community. It provides a simple API for matching files using glob patterns and supports various options for customization. While it is reliable and widely adopted, it may not match the performance of fast-glob, especially when dealing with large file sets or complex directory structures. Glob is a solid choice for projects that require basic file matching without the need for advanced performance optimizations.

  • micromatch is a powerful and flexible library for matching strings using glob patterns. It is designed to be more feature-rich than traditional glob libraries, offering advanced matching capabilities, such as support for complex patterns and performance optimizations. Micromatch is particularly useful when you need to match file paths or strings with intricate patterns. If your project requires advanced matching features beyond basic globbing, micromatch is an excellent alternative.

  • node-glob is another popular globbing library for Node.js that provides similar functionality to glob. It allows for file matching using glob patterns and supports various options for customization. While it is a reliable choice, it may not offer the same level of performance as fast-glob, particularly in scenarios involving a large number of files. Node-glob is suitable for projects that require straightforward globbing capabilities without the need for the highest performance.

To see how fast-glob compares with glob, micromatch, and node-glob, check out the comparison: Comparing fast-glob vs glob vs micromatch vs node-glob.

Similar Npm Packages to glob

glob is a popular npm package used for matching files and directories using glob patterns. It allows developers to specify patterns for file paths, making it easy to find files that match certain criteria. This is particularly useful in build processes, file manipulation tasks, and when working with file systems in Node.js applications. While glob is widely used, there are several alternatives that offer similar functionality with different features or performance characteristics. Here are a few notable alternatives:

  • fast-glob is an alternative to glob that focuses on performance. It is designed to be faster than the traditional glob package, especially when dealing with a large number of files. Fast-glob uses asynchronous file system operations, making it suitable for applications that require high performance and efficiency. If speed is a priority in your file-matching tasks, fast-glob is an excellent choice.
  • globby is a wrapper around glob that simplifies the process of matching files. It allows you to use multiple glob patterns and provides a more user-friendly API. Globby is particularly useful when you want to combine multiple glob patterns or when you need to work with file paths in a more flexible way. If you are looking for a more convenient way to handle file matching with glob patterns, globby is worth considering.
  • micromatch is another alternative that offers advanced pattern matching capabilities. It supports a wide range of matching patterns, including glob, regex, and other custom patterns. Micromatch is particularly useful when you need more control over how files are matched and when you want to leverage advanced features like negation or custom matching logic. If your file-matching requirements go beyond basic glob patterns, micromatch provides the flexibility you need.

To see how glob compares with fast-glob, globby, and micromatch, check out the comparison: Comparing fast-glob vs glob vs globby vs micromatch.

Similar Npm Packages to micromatch

micromatch is a powerful and flexible pattern matching library for JavaScript, primarily used for matching file paths and strings against glob patterns. It is designed to be fast and efficient, making it a popular choice for developers who need to perform complex matching operations in their applications. Micromatch supports a wide range of globbing features, including braces, extglob, and more, allowing for sophisticated pattern matching.

While micromatch is a great option, there are several alternatives in the ecosystem that also provide similar functionality. Here are a few noteworthy alternatives:

  • fast-glob is a highly efficient library for matching file paths using glob patterns. It is designed to be faster than traditional glob libraries, making it suitable for applications that require high performance when dealing with large sets of files. Fast-glob supports various features, including negation patterns and the ability to read from streams, making it a versatile choice for file searching and matching tasks.

  • glob is one of the original libraries for matching file paths using glob patterns in Node.js. It provides a straightforward API for matching files and directories based on specified patterns. While it is widely used and well-documented, it may not be as performant as some newer libraries like fast-glob. However, glob remains a solid choice for many projects, especially those that do not require the advanced features offered by more modern alternatives.

  • minimatch is a minimalistic pattern matching library that focuses on matching strings against glob patterns. It is lightweight and easy to use, making it a good option for simple matching tasks. Minimatch is particularly useful when you need to match strings without the overhead of a more complex library. However, it may lack some of the advanced features found in micromatch or fast-glob.

To see how micromatch compares with fast-glob, glob, and minimatch, check out the comparison: Comparing fast-glob vs glob vs micromatch vs minimatch.

Similar Npm Packages to node-glob

node-glob is a popular package for matching files and directories using glob patterns in Node.js applications. It allows developers to easily find files based on specific patterns, making it a useful tool for tasks such as file manipulation, build processes, and more. While node-glob is widely used, there are several alternatives that offer similar functionality with different features and performance characteristics. Here are a few noteworthy alternatives:

  • fast-glob is an alternative to node-glob that focuses on performance. It is designed to be faster and more efficient, especially when dealing with a large number of files. Fast-glob supports all the same glob patterns as node-glob but optimizes the file searching process, making it a great choice for projects where speed is a critical factor. If you need a high-performance globbing solution, fast-glob is worth considering.

  • glob is the original globbing library for Node.js, and it serves as the foundation for many other globbing libraries, including node-glob. It provides a simple API for matching files and directories using glob patterns. While it may not have the performance optimizations of fast-glob, it is still a reliable choice for basic globbing needs. If you are looking for a straightforward solution without additional complexity, glob is a solid option.

  • glob-all extends the functionality of the glob library by allowing users to match files across multiple glob patterns. This can be particularly useful when you need to gather files from different directories or when you want to include or exclude specific files based on various patterns. If your project requires more complex file matching scenarios, glob-all can help simplify the process.

  • globby is another alternative that builds on the capabilities of glob while providing a more user-friendly interface. It supports multiple glob patterns and offers additional features such as filtering and ignoring files. Globby is particularly useful for developers who want a simple and elegant way to work with file patterns in their Node.js applications.

To see how these packages compare, check out the comparison: Comparing fast-glob vs glob vs glob-all vs globby vs node-glob.

README for fast-glob

fast-glob

It's a very fast and efficient glob library for Node.js.

This package provides methods for traversing the file system and returning pathnames that matched a defined set of a specified pattern according to the rules used by the Unix Bash shell with some simplifications, meanwhile results are returned in arbitrary order. Quick, simple, effective.

Table of Contents

Details

Highlights

  • Fast. Probably the fastest.
  • Supports multiple and negative patterns.
  • Synchronous, Promise and Stream API.
  • Object mode. Can return more than just strings.
  • Error-tolerant.

Old and modern mode

This package works in two modes, depending on the environment in which it is used.

  • Old mode. Node.js below 10.10 or when the stats option is enabled.
  • Modern mode. Node.js 10.10+ and the stats option is disabled.

The modern mode is faster. Learn more about the internal mechanism.

Pattern syntax

:warning: Always use forward-slashes in glob expressions (patterns and ignore option). Use backslashes for escaping characters.

There is more than one form of syntax: basic and advanced. Below is a brief overview of the supported features. Also pay attention to our FAQ.

:book: This package uses micromatch as a library for pattern matching.

Basic syntax

  • An asterisk (*) — matches everything except slashes (path separators), hidden files (names starting with .).
  • A double star or globstar (**) — matches zero or more directories.
  • Question mark (?) – matches any single character except slashes (path separators).
  • Sequence ([seq]) — matches any character in sequence.

:book: A few additional words about the basic matching behavior.

Some examples:

  • src/**/*.js — matches all files in the src directory (any level of nesting) that have the .js extension.
  • src/*.?? — matches all files in the src directory (only first level of nesting) that have a two-character extension.
  • file-[01].js — matches files: file-0.js, file-1.js.

Advanced syntax

:book: A few additional words about the advanced matching behavior.

Some examples:

  • src/**/*.{css,scss} — matches all files in the src directory (any level of nesting) that have the .css or .scss extension.
  • file-[[:digit:]].js — matches files: file-0.js, file-1.js, …, file-9.js.
  • file-{1..3}.js — matches files: file-1.js, file-2.js, file-3.js.
  • file-(1|2) — matches files: file-1.js, file-2.js.

Installation

npm install fast-glob

API

Asynchronous

fg(patterns, [options])
fg.async(patterns, [options])
fg.glob(patterns, [options])

Returns a Promise with an array of matching entries.

const fg = require('fast-glob');

const entries = await fg(['.editorconfig', '**/index.js'], { dot: true });

// ['.editorconfig', 'services/index.js']

Synchronous

fg.sync(patterns, [options])
fg.globSync(patterns, [options])

Returns an array of matching entries.

const fg = require('fast-glob');

const entries = fg.sync(['.editorconfig', '**/index.js'], { dot: true });

// ['.editorconfig', 'services/index.js']

Stream

fg.stream(patterns, [options])
fg.globStream(patterns, [options])

Returns a ReadableStream when the data event will be emitted with matching entry.

const fg = require('fast-glob');

const stream = fg.stream(['.editorconfig', '**/index.js'], { dot: true });

for await (const entry of stream) {
	// .editorconfig
	// services/index.js
}

patterns

  • Required: true
  • Type: string | string[]

Any correct pattern(s).

:1234: Pattern syntax

:warning: This package does not respect the order of patterns. First, all the negative patterns are applied, and only then the positive patterns. If you want to get a certain order of records, use sorting or split calls.

[options]

See Options section.

Helpers

generateTasks(patterns, [options])

Returns the internal representation of patterns (Task is a combining patterns by base directory).

fg.generateTasks('*');

[{
    base: '.', // Parent directory for all patterns inside this task
    dynamic: true, // Dynamic or static patterns are in this task
    patterns: ['*'],
    positive: ['*'],
    negative: []
}]
patterns
  • Required: true
  • Type: string | string[]

Any correct pattern(s).

[options]

See Options section.

isDynamicPattern(pattern, [options])

Returns true if the passed pattern is a dynamic pattern.

:1234: What is a static or dynamic pattern?

fg.isDynamicPattern('*'); // true
fg.isDynamicPattern('abc'); // false
pattern
  • Required: true
  • Type: string

Any correct pattern.

[options]

See Options section.

escapePath(path)

Returns the path with escaped special characters depending on the platform.

  • Posix:
    • *?|(){}[];
    • ! at the beginning of line;
    • @+! before the opening parenthesis;
    • \\ before non-special characters;
  • Windows:
    • (){}[]
    • ! at the beginning of line;
    • @+! before the opening parenthesis;
    • Characters like *?| cannot be used in the path (windows_naming_conventions), so they will not be escaped;
fg.escapePath('!abc');
// \\!abc
fg.escapePath('[OpenSource] mrmlnc – fast-glob (Deluxe Edition) 2014') + '/*.flac'
// \\[OpenSource\\] mrmlnc – fast-glob \\(Deluxe Edition\\) 2014/*.flac

fg.posix.escapePath('C:\\Program Files (x86)\\**\\*');
// C:\\\\Program Files \\(x86\\)\\*\\*\\*
fg.win32.escapePath('C:\\Program Files (x86)\\**\\*');
// Windows: C:\\Program Files \\(x86\\)\\**\\*

convertPathToPattern(path)

Converts a path to a pattern depending on the platform, including special character escaping.

  • Posix. Works similarly to the fg.posix.escapePath method.
  • Windows. Works similarly to the fg.win32.escapePath method, additionally converting backslashes to forward slashes in cases where they are not escape characters (!()+@{}[]).
fg.convertPathToPattern('[OpenSource] mrmlnc – fast-glob (Deluxe Edition) 2014') + '/*.flac';
// \\[OpenSource\\] mrmlnc – fast-glob \\(Deluxe Edition\\) 2014/*.flac

fg.convertPathToPattern('C:/Program Files (x86)/**/*');
// Posix: C:/Program Files \\(x86\\)/\\*\\*/\\*
// Windows: C:/Program Files \\(x86\\)/**/*

fg.convertPathToPattern('C:\\Program Files (x86)\\**\\*');
// Posix: C:\\\\Program Files \\(x86\\)\\*\\*\\*
// Windows: C:/Program Files \\(x86\\)/**/*

fg.posix.convertPathToPattern('\\\\?\\c:\\Program Files (x86)') + '/**/*';
// Posix: \\\\\\?\\\\c:\\\\Program Files \\(x86\\)/**/* (broken pattern)
fg.win32.convertPathToPattern('\\\\?\\c:\\Program Files (x86)') + '/**/*';
// Windows: //?/c:/Program Files \\(x86\\)/**/*

Options

Common options

concurrency

  • Type: number
  • Default: os.cpus().length

Specifies the maximum number of concurrent requests from a reader to read directories.

:book: The higher the number, the higher the performance and load on the file system. If you want to read in quiet mode, set the value to a comfortable number or 1.

More details

In Node, there are two types of threads: Event Loop (code) and a Thread Pool (fs, dns, …). The thread pool size controlled by the UV_THREADPOOL_SIZE environment variable. Its default size is 4 (documentation). The pool is one for all tasks within a single Node process.

Any code can make 4 real concurrent accesses to the file system. The rest of the FS requests will wait in the queue.

:book: Each new instance of FG in the same Node process will use the same Thread pool.

But this package also has the concurrency option. This option allows you to control the number of concurrent accesses to the FS at the package level. By default, this package has a value equal to the number of cores available for the current Node process. This allows you to set a value smaller than the pool size (concurrency: 1) or, conversely, to prepare tasks for the pool queue more quickly (concurrency: Number.POSITIVE_INFINITY).

So, in fact, this package can only make 4 concurrent requests to the FS. You can increase this value by using an environment variable (UV_THREADPOOL_SIZE), but in practice this does not give a multiple advantage.

cwd

  • Type: string
  • Default: process.cwd()

The current working directory in which to search.

deep

  • Type: number
  • Default: Infinity

Specifies the maximum depth of a read directory relative to the start directory.

For example, you have the following tree:

dir/
└── one/            // 1
    └── two/        // 2
        └── file.js // 3

// With base directory
fg.sync('dir/**', { onlyFiles: false, deep: 1 }); // ['dir/one']
fg.sync('dir/**', { onlyFiles: false, deep: 2 }); // ['dir/one', 'dir/one/two']

// With cwd option
fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 1 }); // ['one']
fg.sync('**', { onlyFiles: false, cwd: 'dir', deep: 2 }); // ['one', 'one/two']

:book: If you specify a pattern with some base directory, this directory will not participate in the calculation of the depth of the found directories. Think of it as a cwd option.

followSymbolicLinks

  • Type: boolean
  • Default: true

Indicates whether to traverse descendants of symbolic link directories when expanding ** patterns.

:book: Note that this option does not affect the base directory of the pattern. For example, if ./a is a symlink to directory ./b and you specified ['./a**', './b/**'] patterns, then directory ./a will still be read.

:book: If the stats option is specified, the information about the symbolic link (fs.lstat) will be replaced with information about the entry (fs.stat) behind it.

fs

  • Type: FileSystemAdapter
  • Default: fs.*

Custom implementation of methods for working with the file system. Supports objects with enumerable properties only.

export interface FileSystemAdapter {
    lstat?: typeof fs.lstat;
    stat?: typeof fs.stat;
    lstatSync?: typeof fs.lstatSync;
    statSync?: typeof fs.statSync;
    readdir?: typeof fs.readdir;
    readdirSync?: typeof fs.readdirSync;
}

ignore

  • Type: string[]
  • Default: []

An array of glob patterns to exclude matches. This is an alternative way to use negative patterns.

dir/
├── package-lock.json
└── package.json

fg.sync(['*.json', '!package-lock.json']);            // ['package.json']
fg.sync('*.json', { ignore: ['package-lock.json'] }); // ['package.json']

suppressErrors

  • Type: boolean
  • Default: false

By default this package suppress only ENOENT errors. Set to true to suppress any error.

:book: Can be useful when the directory has entries with a special level of access.

throwErrorOnBrokenSymbolicLink

  • Type: boolean
  • Default: false

Throw an error when symbolic link is broken if true or safely return lstat call if false.

:book: This option has no effect on errors when reading the symbolic link directory.

Output control

absolute

  • Type: boolean
  • Default: false

Return the absolute path for entries.

fg.sync('*.js', { absolute: false }); // ['index.js']
fg.sync('*.js', { absolute: true });  // ['/home/user/index.js']

:book: This option is required if you want to use negative patterns with absolute path, for example, !${__dirname}/*.js.

markDirectories

  • Type: boolean
  • Default: false

Mark the directory path with the final slash.

fg.sync('*', { onlyFiles: false, markDirectories: false }); // ['index.js', 'controllers']
fg.sync('*', { onlyFiles: false, markDirectories: true });  // ['index.js', 'controllers/']

objectMode

  • Type: boolean
  • Default: false

Returns objects (instead of strings) describing entries.

fg.sync('*', { objectMode: false }); // ['src/index.js']
fg.sync('*', { objectMode: true });  // [{ name: 'index.js', path: 'src/index.js', dirent: <fs.Dirent> }]

The object has the following fields:

  • name (string) — the last part of the path (basename)
  • path (string) — full path relative to the pattern base directory
  • dirent (fs.Dirent) — instance of fs.Dirent

:book: An object is an internal representation of entry, so getting it does not affect performance.

onlyDirectories

  • Type: boolean
  • Default: false

Return only directories.

fg.sync('*', { onlyDirectories: false }); // ['index.js', 'src']
fg.sync('*', { onlyDirectories: true });  // ['src']

:book: If true, the onlyFiles option is automatically false.

onlyFiles

  • Type: boolean
  • Default: true

Return only files.

fg.sync('*', { onlyFiles: false }); // ['index.js', 'src']
fg.sync('*', { onlyFiles: true });  // ['index.js']

stats

  • Type: boolean
  • Default: false

Enables an object mode with an additional field:

  • stats (fs.Stats) — instance of fs.Stats
fg.sync('*', { stats: false }); // ['src/index.js']
fg.sync('*', { stats: true });  // [{ name: 'index.js', path: 'src/index.js', dirent: <fs.Dirent>, stats: <fs.Stats> }]

:book: Returns fs.stat instead of fs.lstat for symbolic links when the followSymbolicLinks option is specified.

:warning: Unlike object mode this mode requires additional calls to the file system. On average, this mode is slower at least twice. See old and modern mode for more details.

unique

  • Type: boolean
  • Default: true

Ensures that the returned entries are unique.

fg.sync(['*.json', 'package.json'], { unique: false }); // ['package.json', 'package.json']
fg.sync(['*.json', 'package.json'], { unique: true });  // ['package.json']

If true and similar entries are found, the result is the first found.

Matching control

braceExpansion

  • Type: boolean
  • Default: true

Enables Bash-like brace expansion.

:1234: Syntax description or more detailed description.

dir/
├── abd
├── acd
└── a{b,c}d

fg.sync('a{b,c}d', { braceExpansion: false }); // ['a{b,c}d']
fg.sync('a{b,c}d', { braceExpansion: true });  // ['abd', 'acd']

caseSensitiveMatch

  • Type: boolean
  • Default: true

Enables a case-sensitive mode for matching files.

dir/
├── file.txt
└── File.txt

fg.sync('file.txt', { caseSensitiveMatch: false }); // ['file.txt', 'File.txt']
fg.sync('file.txt', { caseSensitiveMatch: true });  // ['file.txt']

dot

  • Type: boolean
  • Default: false

Allow patterns to match entries that begin with a period (.).

:book: Note that an explicit dot in a portion of the pattern will always match dot files.

dir/
├── .editorconfig
└── package.json

fg.sync('*', { dot: false }); // ['package.json']
fg.sync('*', { dot: true });  // ['.editorconfig', 'package.json']

extglob

  • Type: boolean
  • Default: true

Enables Bash-like extglob functionality.

:1234: Syntax description.

dir/
├── README.md
└── package.json

fg.sync('*.+(json|md)', { extglob: false }); // []
fg.sync('*.+(json|md)', { extglob: true });  // ['README.md', 'package.json']

globstar

  • Type: boolean
  • Default: true

Enables recursively repeats a pattern containing **. If false, ** behaves exactly like *.

dir/
└── a
    └── b

fg.sync('**', { onlyFiles: false, globstar: false }); // ['a']
fg.sync('**', { onlyFiles: false, globstar: true });  // ['a', 'a/b']

baseNameMatch

  • Type: boolean
  • Default: false

If set to true, then patterns without slashes will be matched against the basename of the path if it contains slashes.

dir/
└── one/
    └── file.md

fg.sync('*.md', { baseNameMatch: false }); // []
fg.sync('*.md', { baseNameMatch: true });  // ['one/file.md']

FAQ

What is a static or dynamic pattern?

All patterns can be divided into two types:

  • static. A pattern is considered static if it can be used to get an entry on the file system without using matching mechanisms. For example, the file.js pattern is a static pattern because we can just verify that it exists on the file system.
  • dynamic. A pattern is considered dynamic if it cannot be used directly to find occurrences without using a matching mechanisms. For example, the * pattern is a dynamic pattern because we cannot use this pattern directly.

A pattern is considered dynamic if it contains the following characters (… — any characters or their absence) or options:

  • The caseSensitiveMatch option is disabled
  • \\ (the escape character)
  • *, ?, ! (at the beginning of line)
  • […]
  • (…|…)
  • @(…), !(…), *(…), ?(…), +(…) (respects the extglob option)
  • {…,…}, {…..…} (respects the braceExpansion option)

How to write patterns on Windows?

Always use forward-slashes in glob expressions (patterns and ignore option). Use backslashes for escaping characters. With the cwd option use a convenient format.

Bad

[
	'directory\\*',
	path.join(process.cwd(), '**')
]

Good

[
	'directory/*',
	fg.convertPathToPattern(process.cwd()) + '/**'
]

:book: Use the .convertPathToPattern package to convert Windows-style path to a Unix-style path.

Read more about matching with backslashes.

Why are parentheses match wrong?

dir/
└── (special-*file).txt

fg.sync(['(special-*file).txt']) // []

Refers to Bash. You need to escape special characters:

fg.sync(['\\(special-*file\\).txt']) // ['(special-*file).txt']

Read more about matching special characters as literals. Or use the .escapePath.

How to exclude directory from reading?

You can use a negative pattern like this: !**/node_modules or !**/node_modules/**. Also you can use ignore option. Just look at the example below.

first/
├── file.md
└── second/
    └── file.txt

If you don't want to read the second directory, you must write the following pattern: !**/second or !**/second/**.

fg.sync(['**/*.md', '!**/second']);                 // ['first/file.md']
fg.sync(['**/*.md'], { ignore: ['**/second/**'] }); // ['first/file.md']

:warning: When you write !**/second/**/* it means that the directory will be read, but all the entries will not be included in the results.

You have to understand that if you write the pattern to exclude directories, then the directory will not be read under any circumstances.

How to use UNC path?

You cannot use Uniform Naming Convention (UNC) paths as patterns (due to syntax) directly, but you can use them as cwd directory or use the fg.convertPathToPattern method.

// cwd
fg.sync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
fg.sync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });

// .convertPathToPattern
fg.sync(fg.convertPathToPattern('\\\\?\\c:\\Python27') + '/*');

Compatible with node-glob?

node-globfast-glob
cwdcwd
root–
dotdot
nomount–
markmarkDirectories
nosort–
nouniqueunique
nobracebraceExpansion
noglobstarglobstar
noextextglob
nocasecaseSensitiveMatch
matchBasebaseNameMatch
nodironlyFiles
ignoreignore
followfollowSymbolicLinks
realpath–
absoluteabsolute

Benchmarks

You can see results here for every commit into the main branch.

  • Product benchmark – comparison with the main competitors.
  • Regress benchmark – regression between the current version and the version from the npm registry.

Changelog

See the Releases section of our GitHub project for changelog for each release version.

License

This software is released under the terms of the MIT license.

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.