nanomatch

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)

Table of Contents

• What is nanomatch?
• Getting started
• API
• Features
  • Globbing reference
  • Bash pattern matching
• Benchmarks
  • Running benchmarks
  • Latest results
• History
• About
  • Related projects
  • Contributing
  • Running tests
  • Author
  • License

(TOC generated by verb using markdown-toc)

What is nanomatch?

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

See the features section for more info about features.

How is this different from micromatch?

Nanomatch only provides wildcard matching, which represents only 1 of the 5 matching "types" offered by micromatch. The others are listed in the features section.

Nanomatch will also provide the wildcard matching functionality to micromatch, starting with v3.0.0.

Getting started

var nanomatch = require('nanomatch');

// the main export is a function that takes an array of strings to match
// and one or more patterns to use for matching
nanomatch(list, patterns[, options]);

Params

• list {String|Array}: One or more strings to match against. This is often a list of files.
• patterns {String|Array}: One or more glob paterns to use for matching.
• options {Object}: Visit the API to learn about available options.

Example

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']

Additional detail provided in the API documentation.

API

nanomatch

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

Example

var mm = require('nanomatch');
mm(list, patterns[, options]);

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

Params

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

.match

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

Example

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

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

Params

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

.isMatch

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

Example

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

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

Params

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

.not

Returns a list of strings that DO NOT MATCH any of the given patterns.

Example

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

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

Params

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

.any

Returns true if the given string matches any of the given glob patterns.

Example

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

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

Params

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

.contains

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

Example

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

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

Params

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

.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.

Example

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

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

Params

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

.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.

Example

var mm = require('nanomatch');
mm.matcher(pattern[, options]);

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

Params

• pattern {String}: Glob pattern
• options {Object}: Any options to change how matches are performed.
• returns {Function}: Returns a matcher function.

.makeRe

Create a regular expression from the given glob pattern.

Example

var mm = require('nanomatch');
mm.makeRe(pattern[, options]);

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

Params

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

.create

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

Example

var mm = require('nanomatch');
mm.create(pattern[, options]);

console.log(mm.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 }

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.

.parse

Parse the given str with the given options.

Example

var mm = require('nanomatch');
mm.parse(pattern[, options]);

var ast = mm.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: '' } ] }

Params

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

.compile

Compile the given ast or string with the given options.

Example

var nanomatch = require('nanomatch');
mm.compile(ast[, options]);

var ast = nanomatch.parse('a/{b,c}/d');
console.log(nanomatch.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: [] }

Params

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

Features

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

Globbing reference

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
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 pattern matching

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:

npm i -d && npm benchmark

Latest results

Benchmarking: (6 of 6)
 · globstar-basic
 · large-list-globstar
 · long-list-globstar
 · negation-basic
 · not-glob-basic
 · star-basic

# benchmark/fixtures/match/globstar-basic.js (182 bytes)
  minimatch x 32,012 ops/sec ±0.86% (83 runs sampled)
  multimatch x 29,055 ops/sec ±1.41% (83 runs sampled)
  nanomatch x 479,001 ops/sec ±1.32% (86 runs sampled)

  fastest is nanomatch

# benchmark/fixtures/match/large-list-globstar.js (485686 bytes)
  minimatch x 24.10 ops/sec ±1.28% (42 runs sampled)
  multimatch x 24.33 ops/sec ±0.78% (44 runs sampled)
  nanomatch x 407 ops/sec ±0.86% (83 runs sampled)

  fastest is nanomatch

# benchmark/fixtures/match/long-list-globstar.js (194085 bytes)
  minimatch x 264 ops/sec ±1.13% (82 runs sampled)
  multimatch x 251 ops/sec ±0.96% (82 runs sampled)
  nanomatch x 999 ops/sec ±0.51% (87 runs sampled)

  fastest is nanomatch

# benchmark/fixtures/match/negation-basic.js (132 bytes)
  minimatch x 77,301 ops/sec ±1.68% (85 runs sampled)
  multimatch x 25,492 ops/sec ±1.24% (86 runs sampled)
  nanomatch x 565,552 ops/sec ±1.16% (88 runs sampled)

  fastest is nanomatch

# benchmark/fixtures/match/not-glob-basic.js (93 bytes)
  minimatch x 90,972 ops/sec ±1.02% (86 runs sampled)
  multimatch x 71,725 ops/sec ±1.42% (86 runs sampled)
  nanomatch x 1,446,237 ops/sec ±0.99% (87 runs sampled)

  fastest is nanomatch

# benchmark/fixtures/match/star-basic.js (93 bytes)
  minimatch x 70,011 ops/sec ±1.23% (87 runs sampled)
  multimatch x 53,431 ops/sec ±1.07% (89 runs sampled)
  nanomatch x 650,425 ops/sec ±0.85% (90 runs sampled)

  fastest is nanomatch

History

key

Changelog entries are classified using the following labels (from keep-a-changelog):

• added: for new features
• changed: for changes in existing functionality
• deprecated: for once-stable features removed in upcoming releases
• removed: for deprecated features removed in this release
• fixed: for any bug fixes
• bumped: updated dependencies, only minor or higher will be listed.

[0.1.0] - 2016-10-08

First release.

About

Related projects

• expand-brackets: Expand POSIX bracket expressions (character classes) in glob patterns. | homepage
• extglob: Convert extended globs to regex-compatible strings. Add (almost) the expressive power of regular expressions to… more | homepage
• micromatch: Glob matching for javascript/node.js. A drop-in replacement and faster alternative to minimatch and multimatch. | homepage

Contributing

Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.

Please read the contributing guide for avice on opening issues, pull requests, and coding standards.

Running tests

Install dev dependencies:

$ npm install -d && npm test

Author

Jon Schlinkert

• github/jonschlinkert
• twitter/jonschlinkert

License

Copyright © 2016, Jon Schlinkert. Released under the MIT license.

---

This file was generated by verb-generate-readme, v0.2.0, on October 21, 2016.