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)

Please consider following this project's author, Jon Schlinkert, and consider starring the project to show your :heart: and support.

Table of Contents

Install

Install with npm:

``sh
$ npm install --save 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

$3

Install with yarn

`sh
$ yarn add nanomatch
`

Install with npm

`sh
$ npm install nanomatch
`

$3

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

`js
var nanomatch = require('nanomatch');

// the main export is a function that takes an array of strings to match
// and a string or array of patterns to use for matching
nanomatch(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

`js
var nm = require('nanomatch');
console.log(nm(['a', 'b/b', 'c/c/c'], '*'));
//=> ['a']

console.log(nm(['a', 'b/b', 'c/c/c'], '/'));
//=> ['b/b']

console.log(nm(['a', 'b/b', 'c/c/c'], '**'));
//=> ['a', 'b/b', 'c/c/c']
`

See the API documentation for available methods and options.

Documentation

$3

_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:

`js
'foo/\*/bar'
`

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

`js
'foo/\**/bar'
`

Quoted strings

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

`js
'foo/"**"/bar'
'foo/\'**\'/bar'
"foo/'**'/bar"
`

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:

`js
'foo/\\"*\\"/bar'
`

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

`js
'foo/\\\'*\\\'/bar'
`

API

$3

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

`js
var nm = require('nanomatch');
nm(list, patterns[, options]);

console.log(nm(['a.js', 'a.txt'], ['*.js']));
//=> [ 'a.js' ]
`

$3

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

`js
var nm = require('nanomatch');
nm.match(list, pattern[, options]);

console.log(nm.match(['a.a', 'a.aa', 'a.b', 'a.c'], '*.a'));
//=> ['a.a', 'a.aa']
`

$3

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

`js
var nm = require('nanomatch');
nm.isMatch(string, pattern[, options]);

console.log(nm.isMatch('a.a', '*.a'));
//=> true
console.log(nm.isMatch('a.b', '*.a'));
//=> false
`

$3

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

`js
var nm = require('nanomatch');
nm.some(list, patterns[, options]);

console.log(nm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
// true
console.log(nm.some(['foo.js'], ['*.js', '!foo.js']));
// false
`

$3

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

`js
var nm = require('nanomatch');
nm.every(list, patterns[, options]);

console.log(nm.every('foo.js', ['foo.js']));
// true
console.log(nm.every(['foo.js', 'bar.js'], ['*.js']));
// true
console.log(nm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
// false
console.log(nm.every(['foo.js'], ['*.js', '!foo.js']));
// false
`

$3

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

`js
var nm = require('nanomatch');
nm.any(string, patterns[, options]);

console.log(nm.any('a.a', ['b.', '.a']));
//=> true
console.log(nm.any('a.a', 'b.*'));
//=> false
`

$3

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

`js
var nm = require('nanomatch');
nm.all(string, patterns[, options]);

console.log(nm.all('foo.js', ['foo.js']));
// true

console.log(nm.all('foo.js', ['*.js', '!foo.js']));
// false

console.log(nm.all('foo.js', ['*.js', 'foo.js']));
// true

console.log(nm.all('foo.js', ['.js', 'f', 'o', '*o.js']));
// true
`

$3

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

`js
var nm = require('nanomatch');
nm.not(list, patterns[, options]);

console.log(nm.not(['a.a', 'b.b', 'c.c'], '*.a'));
//=> ['b.b', 'c.c']
`

$3

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

`js
var nm = require('nanomatch');
nm.contains(string, pattern[, options]);

console.log(nm.contains('aa/bb/cc', '*b'));
//=> true
console.log(nm.contains('aa/bb/cc', '*d'));
//=> false
`

$3

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

`js
var nm = require('nanomatch');
nm.matchKeys(object, patterns[, options]);

var obj = { aa: 'a', ab: 'b', ac: 'c' };
console.log(nm.matchKeys(obj, '*b'));
//=> { ab: 'b' }
`

$3

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

`js
var nm = require('nanomatch');
nm.matcher(pattern[, options]);

var isMatch = nm.matcher('.!(a)');
console.log(isMatch('a.a'));
//=> false
console.log(isMatch('a.b'));
//=> true
`

$3

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

``js
var nm = require('nanomatch');
nm.capture(pattern, string[, options]);

console.log(nm.capture('test/*.js', 'test/foo.js'));
//=> ['foo']
console.log(nm.capture('test/*.js', 'foo/bar.css'));
//=> null
`

$3

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

`js
var nm = require('nanomatch');
nm.makeRe(pattern[, options]);

console.log(nm.makeRe('*.js'));
//=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
`

$3

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

`js
var nm = require('nanomatch');
nm.create(pattern[, options]);

console.log(nm.create('abc/*.js'));
// { options: { source: 'string', sourcemap: true },
// state: {},
// compilers:
// { ... },
// output: '(\\.[\\\\\\/])?abc\\/(?!\\.)(?=.)[^\\/]*?\\.js',
// ast:
// { type: 'root',
// errors: [],
// nodes:
// [ ... ],
// dot: false,
// input: 'abc/*.js' },
// parsingErrors: [],
// map:
// { version: 3,
// sources: [ 'string' ],
// names: [],
// mappings: 'AAAA,GAAG,EAAC,kBAAC,EAAC,EAAE',
// sourcesContent: [ 'abc/*.js' ] },
// position: { line: 1, column: 28 },
// content: {},
// files: {},
// idx: 6 }
`

$3

Parse the given str with the given options.

Params

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

Example

`js
var nm = require('nanomatch');
nm.parse(pattern[, options]);

var ast = nm.parse('a/{b,c}/d');
console.log(ast);
// { type: 'root',
// errors: [],
// input: 'a/{b,c}/d',
// nodes:
// [ { type: 'bos', val: '' },
// { type: 'text', val: 'a/' },
// { type: 'brace',
// nodes:
// [ { type: 'brace.open', val: '{' },
// { type: 'text', val: 'b,c' },
// { type: 'brace.close', val: '}' } ] },
// { type: 'text', val: '/d' },
// { type: 'eos', val: '' } ] }
`

$3

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

`js
var nm = require('nanomatch');
nm.compile(ast[, options]);

var ast = nm.parse('a/{b,c}/d');
console.log(nm.compile(ast));
// { options: { source: 'string' },
// state: {},
// compilers:
// { eos: [Function],
// noop: [Function],
// bos: [Function],
// brace: [Function],
// 'brace.open': [Function],
// text: [Function],
// 'brace.close': [Function] },
// output: [ 'a/(b|c)/d' ],
// ast:
// { ... },
// parsingErrors: [] }
`

$3

Clear the regex cache.

Example

`js
nm.clearCache();
`

Options

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

$3

Install dev dependencies:

`bash
npm i -d && node benchmark
`

$3

`bash


globstar-basic (182 bytes)

`

About

$3

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 the expressive power of regular expressions to glob patterns.")
* 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 | true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a bet"" class="text-primary hover:underline" target="_blank" rel="noopener noreferrer">homepage
* micromatch: Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | homepage

$3

| Commits | Contributor |
| --- | --- |
| 164 | jonschlinkert |
| 1 | devongovett |

$3

Jon Schlinkert

* linkedin/in/jonschlinkert
* github/jonschlinkert
* twitter/jonschlinkert

$3

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

*

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