|
2 years ago | |
---|---|---|
.. | ||
out | 2 years ago | |
LICENSE | 2 years ago | |
README.md | 2 years ago | |
package.json | 2 years ago |
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.
Do you like this project? Support it by donating, creating an issue or pull request.
This package works in two modes, depending on the environment in which it is used.
stats
option is enabled.stats
option is disabled.The modern mode is faster. Learn more about the internal mechanism.
: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 a
micromatch
as a library for pattern matching.
*
) — matches everything except slashes (path separators), hidden files (names starting with .
).**
) — matches zero or more directories.?
) – matches any single character except slashes (path separators).[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
.\\
) — matching special characters ($^*+?()[]
) as literals.[[:digit:]]
).?(pattern-list)
).{}
).[1-5]
).(a|b)
).: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
.npm install fast-glob
fg(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']
fg.sync(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']
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.stream(['.editorconfig', '**/index.js'], { dot: true });
for await (const entry of stream) {
// .editorconfig
// services/index.js
}
true
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.
false
Options
See Options section.
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: []
}]
true
string | string[]
Any correct pattern(s).
false
Options
See Options section.
isDynamicPattern(pattern, [options])
Returns true
if the passed pattern is a dynamic pattern.
fg.isDynamicPattern('*'); // true
fg.isDynamicPattern('abc'); // false
true
string
Any correct pattern.
false
Options
See Options section.
escapePath(pattern)
Returns a path with escaped special characters (*?|(){}[]
, !
at the beginning of line, @+!
before the opening parenthesis).
fg.escapePath('!abc'); // \\!abc
fg.escapePath('C:/Program Files (x86)'); // C:/Program Files \\(x86\\)
true
string
Any string, for example, a path to a file.
number
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
.
string
process.cwd()
The current working directory in which to search.
number
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.
boolean
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.
FileSystemAdapter
fs.*
Custom implementation of methods for working with the file system.
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;
}
string[]
[]
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']
boolean
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.
boolean
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.
boolean
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
.
boolean
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/']
boolean
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:
string
) — the last part of the path (basename)string
) — full path relative to the pattern base directoryfs.Dirent
) — instance of fs.Direct
:book: An object is an internal representation of entry, so getting it does not affect performance.
boolean
false
Return only directories.
fg.sync('*', { onlyDirectories: false }); // ['index.js', 'src']
fg.sync('*', { onlyDirectories: true }); // ['src']
:book: If
true
, theonlyFiles
option is automaticallyfalse
.
boolean
true
Return only files.
fg.sync('*', { onlyFiles: false }); // ['index.js', 'src']
fg.sync('*', { onlyFiles: true }); // ['index.js']
boolean
false
Enables an object mode with an additional field:
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 offs.lstat
for symbolic links when thefollowSymbolicLinks
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.
boolean
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.
boolean
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']
boolean
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']
boolean
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']
boolean
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']
boolean
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']
boolean
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']
All patterns can be divided into two types:
file.js
pattern is a static pattern because we can just verify that it exists on the file system.*
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:
caseSensitiveMatch
option is disabled\\
(the escape character)*
, ?
, !
(at the beginning of line)[…]
(…|…)
@(…)
, !(…)
, *(…)
, ?(…)
, +(…)
(respects the extglob
option){…,…}
, {…..…}
(respects the braceExpansion
option)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/*',
path.join(process.cwd(), '**').replace(/\\/g, '/')
]
:book: Use the
normalize-path
or theunixify
package to convert Windows-style path to a Unix-style path.
Read more about matching with backslashes.
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.
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.
You cannot use Uniform Naming Convention (UNC) paths as patterns (due to syntax), but you can use them as cwd
directory.
fg.sync('*', { cwd: '\\\\?\\C:\\Python27' /* or //?/C:/Python27 */ });
fg.sync('Python27/*', { cwd: '\\\\?\\C:\\' /* or //?/C:/ */ });
node-glob
?node-glob | fast-glob |
---|---|
cwd |
cwd |
root |
– |
dot |
dot |
nomount |
– |
mark |
markDirectories |
nosort |
– |
nounique |
unique |
nobrace |
braceExpansion |
noglobstar |
globstar |
noext |
extglob |
nocase |
caseSensitiveMatch |
matchBase |
baseNameMatch |
nodir |
onlyFiles |
ignore |
ignore |
follow |
followSymbolicLinks |
realpath |
– |
absolute |
absolute |
Link: Vultr Bare Metal
You can see results here for latest release.
Link: Zotac bi323
You can see results here for latest release.
See the Releases section of our GitHub project for changelog for each release version.
This software is released under the terms of the MIT license.