Home

Awesome

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> <summary><strong>Details</strong></summary> </details>

Highlights

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

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

Some examples:

Advanced syntax

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

Some examples:

Installation

npm install fast-glob

API

Asynchronous

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

Returns a Promise with an array of matching entries.

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

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

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

Synchronous

fg.globSync(patterns, [options])

Returns an array of matching entries.

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

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

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

Stream

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

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

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

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

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

patterns

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

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

Any correct pattern.

[options]

See Options section.

escapePath(path)

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

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.

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

cwd

The current working directory in which to search.

deep

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.globSync('dir/**', { onlyFiles: false, deep: 1 }); // ['dir/one']
fg.globSync('dir/**', { onlyFiles: false, deep: 2 }); // ['dir/one', 'dir/one/two']

// With cwd option
fg.globSync('**', { onlyFiles: false, cwd: 'dir', deep: 1 }); // ['one']
fg.globSync('**', { 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

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

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

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

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

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

suppressErrors

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

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

Return the absolute path for entries.

fg.globSync('*.js', { absolute: false }); // ['index.js']
fg.globSync('*.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

Mark the directory path with the final slash.

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

objectMode

Returns objects (instead of strings) describing entries.

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

The object has the following fields:

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

onlyDirectories

Return only directories.

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

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

onlyFiles

Return only files.

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

stats

Enables an object mode with an additional field:

fg.globSync('*', { stats: false }); // ['src/index.js']
fg.globSync('*', { 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.

unique

Ensures that the returned entries are unique.

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

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

Matching control

braceExpansion

Enables Bash-like brace expansion.

:1234: Syntax description or more detailed description.

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

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

caseSensitiveMatch

Enables a case-sensitive mode for matching files.

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

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

dot

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.globSync('*', { dot: false }); // ['package.json']
fg.globSync('*', { dot: true });  // ['.editorconfig', 'package.json']

extglob

Enables Bash-like extglob functionality.

:1234: Syntax description.

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

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

globstar

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

dir/
└── a
    └── b

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

baseNameMatch

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.globSync('*.md', { baseNameMatch: false }); // []
fg.globSync('*.md', { baseNameMatch: true });  // ['one/file.md']

FAQ

What is a static or dynamic pattern?

All patterns can be divided into two types:

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

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.globSync(['(special-*file).txt']) // []

Refers to Bash. You need to escape special characters:

fg.globSync(['\\(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.globSync(['**/*.md', '!**/second']);                 // ['first/file.md']
fg.globSync(['**/*.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.globSync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
fg.globSync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });

// .convertPathToPattern
fg.globSync(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.

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.