nanomatch

Fast, minimal glob matcher for node.js. Similar to micromatch, minimatch and multimatch, but complete Bash 4.3 wildcard support only (no support for exglobs, posix brackets or braces)

This is a fork of the original nanomatch. It was maded just because required functionality was not merged by repository maintainers, PR is still open. Probably, after the merge – this package will be deprecated, but at this moment we have what we have.

Table of Contents

Install

Install with npm:

1$ npm install --save sharec-nanomatch

What is nanomatch?

Nanomatch is a fast and accurate glob matcher with full support for standard Bash glob features, including the following "metacharacters": *, **, ? and [...].

Learn more

• Getting started: learn how to install and begin using nanomatch
• Features: jump to info about supported patterns, and a glob matching reference
• API documentation: jump to available options and methods
• Unit tests: visit unit tests. there is no better way to learn a code library than spending time the unit tests. Nanomatch has 36,000 unit tests - go become a glob matching ninja!

Getting started

Installing sharec-nanomatch

Install with yarn

1$ yarn add sharec-nanomatch

Install with npm

1$ npm install sharec-nanomatch

Usage

Add nanomatch to your project using node's require() system:

1var nanomatch = require('sharec-nanomatch');
2
3// the main export is a function that takes an array of strings to match
4// and a string or array of patterns to use for matching
5nanomatch(list, patterns[, options]);

Params

• list {String|Array}: List of strings to perform matches against. This is often a list of file paths.
• patterns {String|Array}: One or more glob paterns to use for matching.
• options {Object}: Any supported options may be passed

Examples

1var nm = require('sharec-nanomatch')
2console.log(nm(['a', 'b/b', 'c/c/c'], '*'))
3//=> ['a']
4
5console.log(nm(['a', 'b/b', 'c/c/c'], '*/*'))
6//=> ['b/b']
7
8console.log(nm(['a', 'b/b', 'c/c/c'], '**'))
9//=> ['a', 'b/b', 'c/c/c']

See the API documentation for available methods and options.

Documentation

Escaping

Backslashes and quotes can be used to escape characters, forcing nanomatch to regard those characters as a literal characters.

Backslashes

Use backslashes to escape single characters. For example, the following pattern would match foo/*/bar exactly:

1'foo/\*/bar'
2

The following pattern would match foo/ followed by a literal *, followed by zero or more of any characters besides /, followed by /bar.

1'foo/\**/bar'
2

Quoted strings

Use single or double quotes to escape sequences of characters. For example, the following patterns would match foo/**/bar exactly:

1'foo/"**"/bar'
2'foo/\'**\'/bar'
3"foo/'**'/bar"
4

Matching literal quotes

If you need to match quotes literally, you can escape them as well. For example, the following will match foo/"*"/bar, foo/"a"/bar, foo/"b"/bar, or foo/"c"/bar:

1'foo/\\"*\\"/bar'
2

And the following will match foo/'*'/bar, foo/'a'/bar, foo/'b'/bar, or foo/'c'/bar:

1'foo/\\\'*\\\'/bar'
2

API

nanomatch

The main function takes a list of strings and one or more glob patterns to use for matching.

Params

• list {Array}: A list of strings to match
• patterns {String|Array}: One or more glob patterns to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Array}: Returns an array of matches

Example

1var nm = require('sharec-nanomatch');
2nm(list, patterns[, options]);
3
4console.log(nm(['a.js', 'a.txt'], ['*.js']));
5//=> [ 'a.js' ]

.match

Similar to the main function, but pattern must be a string.

Params

• list {Array}: Array of strings to match
• pattern {String}: Glob pattern to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Array}: Returns an array of matches

Example

1var nm = require('sharec-nanomatch');
2nm.match(list, pattern[, options]);
3
4console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));
5//=> ['a.a', 'a.aa']

.isMatch

Returns true if the specified string matches the given glob pattern.

Params

• string {String}: String to match
• pattern {String}: Glob pattern to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns true if the string matches the glob pattern.

Example

1var nm = require('sharec-nanomatch');
2nm.isMatch(string, pattern[, options]);
3
4console.log(nm.isMatch('a.a', '*.a'));
5//=> true
6console.log(nm.isMatch('a.b', '*.a'));
7//=> false

.some

Returns true if some of the elements in the given list match any of the given glob patterns.

Params

• list {String|Array}: The string or array of strings to test. Returns as soon as the first match is found.
• patterns {String|Array}: One or more glob patterns to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns true if any patterns match str

Example

1var nm = require('sharec-nanomatch');
2nm.some(list, patterns[, options]);
3
4console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
5// true
6console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));
7// false

.every

Returns true if every element in the given list matches at least one of the given glob patterns.

Params

• list {String|Array}: The string or array of strings to test.
• patterns {String|Array}: One or more glob patterns to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns true if any patterns match str

Example

1var nm = require('sharec-nanomatch');
2nm.every(list, patterns[, options]);
3
4console.log(nm.every('foo.js', ['foo.js']));
5// true
6console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));
7// true
8console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
9// false
10console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));
11// false

.any

Returns true if any of the given glob patterns match the specified string.

Params

• str {String|Array}: The string to test.
• patterns {String|Array}: One or more glob patterns to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns true if any patterns match str

Example

1var nm = require('sharec-nanomatch');
2nm.any(string, patterns[, options]);
3
4console.log(nm.any('a.a', ['b.*', '*.a']));
5//=> true
6console.log(nm.any('a.a', 'b.*'));
7//=> false

.all

Returns true if all of the given patterns match the specified string.

Params

• str {String|Array}: The string to test.
• patterns {String|Array}: One or more glob patterns to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns true if any patterns match str

Example

1var nm = require('sharec-nanomatch');
2nm.all(string, patterns[, options]);
3
4console.log(nm.all('foo.js', ['foo.js']));
5// true
6
7console.log(nm.all('foo.js', ['*.js', '!foo.js']));
8// false
9
10console.log(nm.all('foo.js', ['*.js', 'foo.js']));
11// true
12
13console.log(nm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
14// true

.not

Returns a list of strings that do not match any of the given patterns.

Params

• list {Array}: Array of strings to match.
• patterns {String|Array}: One or more glob pattern to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Array}: Returns an array of strings that do not match the given patterns.

Example

1var nm = require('sharec-nanomatch');
2nm.not(list, patterns[, options]);
3
4console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));
5//=> ['b.b', 'c.c']

.contains

Returns true if the given string contains the given pattern. Similar to .isMatch but the pattern can match any part of the string.

Params

• str {String}: The string to match.
• patterns {String|Array}: Glob pattern to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns true if the patter matches any part of str.

Example

1var nm = require('sharec-nanomatch');
2nm.contains(string, pattern[, options]);
3
4console.log(nm.contains('aa/bb/cc', '*b'));
5//=> true
6console.log(nm.contains('aa/bb/cc', '*d'));
7//=> false

.matchKeys

Filter the keys of the given object with the given glob pattern and options. Does not attempt to match nested keys. If you need this feature, use glob-object instead.

Params

• object {Object}: The object with keys to filter.
• patterns {String|Array}: One or more glob patterns to use for matching.
• options {Object}: See available options for changing how matches are performed
• returns {Object}: Returns an object with only keys that match the given patterns.

Example

1var nm = require('sharec-nanomatch');
2nm.matchKeys(object, patterns[, options]);
3
4var obj = { aa: 'a', ab: 'b', ac: 'c' };
5console.log(nm.matchKeys(obj, '*b'));
6//=> { ab: 'b' }

.matcher

Returns a memoized matcher function from the given glob pattern and options. The returned function takes a string to match as its only argument and returns true if the string is a match.

Params

• pattern {String}: Glob pattern
• options {Object}: See available options for changing how matches are performed.
• returns {Function}: Returns a matcher function.

Example

1var nm = require('sharec-nanomatch');
2nm.matcher(pattern[, options]);
3
4var isMatch = nm.matcher('*.!(*a)');
5console.log(isMatch('a.a'));
6//=> false
7console.log(isMatch('a.b'));
8//=> true

.capture

Returns an array of matches captured by pattern in string, ornull` if the pattern did not match.

Params

• pattern {String}: Glob pattern to use for matching.
• string {String}: String to match
• options {Object}: See available options for changing how matches are performed
• returns {Boolean}: Returns an array of captures if the string matches the glob pattern, otherwise null.

Example

1var nm = require('sharec-nanomatch');
2nm.capture(pattern, string[, options]);
3
4console.log(nm.capture('test/*.js', 'test/foo.js'));
5//=> ['foo']
6console.log(nm.capture('test/*.js', 'foo/bar.css'));
7//=> null

.makeRe

Create a regular expression from the given glob pattern.

Params

• pattern {String}: A glob pattern to convert to regex.
• options {Object}: See available options for changing how matches are performed.
• returns {RegExp}: Returns a regex created from the given pattern.

Example

1var nm = require('sharec-nanomatch');
2nm.makeRe(pattern[, options]);
3
4console.log(nm.makeRe('*.js'));
5//=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/

.create

Parses the given glob pattern and returns an object with the compiled output and optional source map.

Params

• pattern {String}: Glob pattern to parse and compile.
• options {Object}: Any options to change how parsing and compiling is performed.
• returns {Object}: Returns an object with the parsed AST, compiled string and optional source map.

Example

1var nm = require('sharec-nanomatch');
2nm.create(pattern[, options]);
3
4console.log(nm.create('abc/*.js'));
5// { options: { source: 'string', sourcemap: true },
6//   state: {},
7//   compilers:
8//    { ... },
9//   output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js',
10//   ast:
11//    { type: 'root',
12//      errors: [],
13//      nodes:
14//       [ ... ],
15//      dot: false,
16//      input: 'abc/*.js' },
17//   parsingErrors: [],
18//   map:
19//    { version: 3,
20//      sources: [ 'string' ],
21//      names: [],
22//      mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE',
23//      sourcesContent: [ 'abc/*.js' ] },
24//   position: { line: 1, column: 28 },
25//   content: {},
26//   files: {},
27//   idx: 6 }

.parse

Parse the given str with the given options.

Params

• str {String}
• options {Object}
• returns {Object}: Returns an AST

Example

1var nm = require('sharec-nanomatch');
2nm.parse(pattern[, options]);
3
4var ast = nm.parse('a/{b,c}/d');
5console.log(ast);
6// { type: 'root',
7//   errors: [],
8//   input: 'a/{b,c}/d',
9//   nodes:
10//    [ { type: 'bos', val: '' },
11//      { type: 'text', val: 'a/' },
12//      { type: 'brace',
13//        nodes:
14//         [ { type: 'brace.open', val: '{' },
15//           { type: 'text', val: 'b,c' },
16//           { type: 'brace.close', val: '}' } ] },
17//      { type: 'text', val: '/d' },
18//      { type: 'eos', val: '' } ] }

.compile

Compile the given ast or string with the given options.

Params

• ast {Object|String}
• options {Object}
• returns {Object}: Returns an object that has an output property with the compiled string.

Example

1var nm = require('sharec-nanomatch');
2nm.compile(ast[, options]);
3
4var ast = nm.parse('a/{b,c}/d');
5console.log(nm.compile(ast));
6// { options: { source: 'string' },
7//   state: {},
8//   compilers:
9//    { eos: [Function],
10//      noop: [Function],
11//      bos: [Function],
12//      brace: [Function],
13//      'brace.open': [Function],
14//      text: [Function],
15//      'brace.close': [Function] },
16//   output: [ 'a/(b|c)/d' ],
17//   ast:
18//    { ... },
19//   parsingErrors: [] }

.clearCache

Clear the regex cache.

Example

1nm.clearCache()

.matchingPatterns

Similar to the main function, but returns matched patterns, instead of matched values Doesn't work with negative lookup, because it the most cases it doesn't have sense

Params

• list {Array}: A list of strings to match
• patterns {String|Array}: One or more glob patterns to use for matching
• options {Object}: See available options for changing how matches are performed
• returns {Array}: Returns an array of metched patterns

Example

1var nm = require('sharec-nanomatch');
2nm.matchingPatterns(list, pattern[, options]);
3
4console.log(nm.matchingPatterns(['a.a', 'a.aa', 'a.b', 'a.c'], ['*.a', '*.d']));
5//=> ['*.a']

Options

1nm(['a/b.js', 'a/c.md'], '*.js')
2//=> []
3
4nm(['a/b.js', 'a/c.md'], '*.js', { matchBase: true })
5//=> ['a/b.js']

1var files = ['abc', 'ajz']
2console.log(nm(files, '[a-c]*'))
3//=> ['abc', 'ajz']
4
5console.log(nm(files, '[a-c]*', { bash: false }))

1nm.match(['a/b/c', 'a/b/c'], '**')
2//=> ['abc']
3
4nm.match(['a/b/c', 'a/b/c'], '**', { nodupes: false })
5//=> ['a/b/c', 'a/b/c']

1nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**')
2//=> ['a/b', 'a/b/c', 'a/b/c/d']
3
4nm(['a/b', 'a/b/c', 'a/b/c/d'], 'a/**', { noglobstar: true })
5//=> ['a/b']

1var nm = require('sharec-nanomatch')
2
3var res = nm.create('abc/*.js', { sourcemap: true })
4console.log(res.map)
5// { version: 3,
6//   sources: [ 'string' ],
7//   names: [],
8//   mappings: 'AAAA,GAAG,EAAC,iBAAC,EAAC,EAAE',
9//   sourcesContent: [ 'abc/*.js' ] }
10
11var ast = nm.parse('abc/**/*.js')
12var res = nm.compile(ast, { sourcemap: true })
13console.log(res.map)
14// { version: 3,
15//   sources: [ 'string' ],
16//   names: [],
17//   mappings: 'AAAA,GAAG,EAAC,2BAAE,EAAC,iBAAC,EAAC,EAAE',
18//   sourcesContent: [ 'abc/**/*.js' ] }

1nm.match(['abc', 'a\\*c'], 'a\\*c')
2//=> ['a\\*c']
3
4nm.match(['abc', 'a\\*c'], 'a\\*c', { unescape: true })
5//=> ['a*c']

1nm.match(['a\\b\\c'], 'a/**')
2//=> ['a/b/c']
3
4nm.match(['a\\b\\c'], { unixify: false })
5//=> ['a\\b\\c']

Features

Nanomatch has full support for standard Bash glob features, including the following "metacharacters": *, **, ? and [...].

Here are some examples of how they work:

| Pattern | Description | | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ | | * | Matches any string except for /, leading ., or /. inside a path | | ** | Matches any string including /, but not a leading . or /. inside a path. More than two stars (e.g. *** is treated the same as one star, and ** loses its special meaning | when it's not the only thing in a path segment, per Bash specifications) | | foo* | Matches any string beginning with foo | | *bar* | Matches any string containing bar (beginning, middle or end) | | *.min.js | Matches any string ending with .min.js | | [abc]*.js | Matches any string beginning with a, b, or c and ending with .js | | abc? | Matches abcd or abcz but not abcde |

The exceptions noted for * apply to all patterns that contain a *.

Not supported

The following extended-globbing features are not supported:

• brace expansion (e.g. {a,b,c})
• extglobs (e.g. @(a|!(c|d)))
• POSIX brackets (e.g. [[:alpha:][:digit:]])

If you need any of these features consider using micromatch instead.

Bash expansion libs

Nanomatch is part of a suite of libraries aimed at bringing the power and expressiveness of Bash's matching and expansion capabilities to JavaScript, and - as you can see by the benchmarks - without sacrificing speed.

| Related library | Matching Type | Example | Description | | ------------------------------------------------------------------- | ----------------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | | nanomatch (you are here) | Wildcards | * | Filename expansion, also referred to as globbing and pathname expansion, allows the use of wildcards for matching. | | expand-tilde | Tildes | ~ | Tilde expansion converts the leading tilde in a file path to the user home directory. | | braces | Braces | {a,b,c} | Brace expansion | | expand-brackets | Brackets | [[:alpha:]] | POSIX character classes (also referred to as POSIX brackets, or POSIX character classes) | | extglob | Parens | !(a\ | b) | Extglobs | | micromatch | All | all | Micromatch is built on top of the other libraries. |

There are many resources available on the web if you want to dive deeper into how these features work in Bash.

Benchmarks

Running benchmarks

Install dev dependencies:

1npm i -d && node benchmark

Nanomatch vs. Minimatch vs. Multimatch

1# globstar-basic (182 bytes)
2  minimatch x 69,512 ops/sec ±1.92% (88 runs sampled)
3  multimatch x 63,376 ops/sec ±1.41% (89 runs sampled)
4  nanomatch x 432,451 ops/sec ±0.92% (88 runs sampled)
5
6  fastest is nanomatch (by 651% avg)
7
8# large-list-globstar (485686 bytes)
9  minimatch x 34.02 ops/sec ±1.42% (59 runs sampled)
10  multimatch x 33.58 ops/sec ±1.97% (58 runs sampled)
11  nanomatch x 483 ops/sec ±1.06% (86 runs sampled)
12
13  fastest is nanomatch (by 1429% avg)
14
15# long-list-globstar (194085 bytes)
16  minimatch x 383 ops/sec ±0.74% (90 runs sampled)
17  multimatch x 378 ops/sec ±0.59% (89 runs sampled)
18  nanomatch x 990 ops/sec ±1.14% (85 runs sampled)
19
20  fastest is nanomatch (by 260% avg)
21
22# negation-basic (132 bytes)
23  minimatch x 242,145 ops/sec ±1.17% (89 runs sampled)
24  multimatch x 76,403 ops/sec ±0.78% (92 runs sampled)
25  nanomatch x 537,253 ops/sec ±1.44% (86 runs sampled)
26
27  fastest is nanomatch (by 337% avg)
28
29# not-glob-basic (93 bytes)
30  minimatch x 252,402 ops/sec ±1.33% (89 runs sampled)
31  multimatch x 209,954 ops/sec ±1.30% (90 runs sampled)
32  nanomatch x 1,716,468 ops/sec ±1.13% (86 runs sampled)
33
34  fastest is nanomatch (by 742% avg)
35
36# star-basic (93 bytes)
37  minimatch x 182,780 ops/sec ±1.41% (91 runs sampled)
38  multimatch x 153,210 ops/sec ±0.72% (89 runs sampled)
39  nanomatch x 599,621 ops/sec ±1.22% (90 runs sampled)
40
41  fastest is nanomatch (by 357% avg)
42

About

1$ npm install && npm test

1$ npm install -g verbose/verb#dev verb-generate-readme && verb

Related projects

You might also be interested in these projects:

• extglob: Extended glob support for JavaScript. Adds (almost) the expressive power of regular expressions to glob… more | homepage
• is-extglob: Returns true if a string has an extglob. | homepage
• is-glob: Returns true if the given string looks like a glob pattern or an extglob pattern… more | homepage
• micromatch: Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | homepage

Contributors

Author

Jon Schlinkert

• linkedin/in/jonschlinkert
• github/jonschlinkert
• twitter/jonschlinkert

License

Copyright © 2018, Jon Schlinkert. Released under the MIT License.

This file was generated by verb-generate-readme, v0.6.0, on February 18, 2018.