3 A minimal matching utility.
5 [![Build Status](https://secure.travis-ci.org/isaacs/minimatch.png)](http://travis-ci.org/isaacs/minimatch)
8 This is the matching library used internally by npm.
10 Eventually, it will replace the C binding in node-glob.
12 It works by converting glob expressions into JavaScript `RegExp`
18 var minimatch = require("minimatch")
20 minimatch("bar.foo", "*.foo") // true!
21 minimatch("bar.foo", "*.bar") // false!
22 minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
27 Supports these glob features:
30 * Extended glob matching
31 * "Globstar" `**` matching
42 Create a minimatch object by instanting the `minimatch.Minimatch` class.
45 var Minimatch = require("minimatch").Minimatch
46 var mm = new Minimatch(pattern, options)
51 * `pattern` The original pattern the minimatch object represents.
52 * `options` The options supplied to the constructor.
53 * `set` A 2-dimensional array of regexp or string expressions.
55 array corresponds to a brace-expanded pattern. Each item in the row
56 corresponds to a single path-part. For example, the pattern
57 `{a,b/c}/d` would expand to a set of patterns like:
62 If a portion of the pattern doesn't have any "magic" in it
63 (that is, it's something like `"foo"` rather than `fo*o?`), then it
64 will be left as a string rather than converted to a regular
67 * `regexp` Created by the `makeRe` method. A single regular expression
68 expressing the entire pattern. This is useful in cases where you wish
69 to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
70 * `negate` True if the pattern is negated.
71 * `comment` True if the pattern is a comment.
72 * `empty` True if the pattern is `""`.
76 * `makeRe` Generate the `regexp` member if necessary, and return it.
77 Will return `false` if the pattern is invalid.
78 * `match(fname)` Return true if the filename matches the pattern, or
80 * `matchOne(fileArray, patternArray, partial)` Take a `/`-split
81 filename, and match it against a single row in the `regExpSet`. This
82 method is mainly for internal use, but is exposed so that it can be
83 used by a glob-walker that needs to avoid excessive filesystem calls.
85 All other methods are internal, and will be called as necessary.
89 The top-level exported function has a `cache` property, which is an LRU
90 cache set to store 100 items. So, calling these methods repeatedly
91 with the same pattern and options will use the same Minimatch object,
92 saving the cost of parsing it multiple times.
94 ### minimatch(path, pattern, options)
96 Main export. Tests a path against the pattern using the options.
99 var isJS = minimatch(file, "*.js", { matchBase: true })
102 ### minimatch.filter(pattern, options)
104 Returns a function that tests its
105 supplied argument, suitable for use with `Array.filter`. Example:
108 var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
111 ### minimatch.match(list, pattern, options)
113 Match against the list of
114 files, in the style of fnmatch or glob. If nothing is matched, and
115 options.nonull is set, then return a list containing the pattern itself.
118 var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
121 ### minimatch.makeRe(pattern, options)
123 Make a regular expression object from the pattern.
127 All options are `false` by default.
131 Dump a ton of stuff to stderr.
135 Do not expand `{a,b}` and `{1..3}` brace sets.
139 Disable `**` matching against multiple folder names.
143 Allow patterns to match filenames starting with a period, even if
144 the pattern does not explicitly have a period in that spot.
146 Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
151 Disable "extglob" style patterns like `+(a|b)`.
155 Perform a case-insensitive match.
159 When a match is not found by `minimatch.match`, return a list containing
160 the pattern itself. When set, an empty list is returned if there are
165 If set, then patterns without slashes will be matched
166 against the basename of the path if it contains slashes. For example,
167 `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
171 Suppress the behavior of treating `#` at the start of a pattern as a
176 Suppress the behavior of treating a leading `!` character as negation.
180 Returns from negate expressions the same as if they were not negated.
181 (Ie, true on a hit, false on a miss.)
184 ## Comparisons to other fnmatch/glob implementations
186 While strict compliance with the existing standards is a worthwhile
187 goal, some discrepancies exist between minimatch and other
188 implementations, and are intentional.
190 If the pattern starts with a `!` character, then it is negated. Set the
191 `nonegate` flag to suppress this behavior, and treat leading `!`
192 characters normally. This is perhaps relevant if you wish to start the
193 pattern with a negative extglob pattern like `!(a|B)`. Multiple `!`
194 characters at the start of a pattern will negate the pattern multiple
197 If a pattern starts with `#`, then it is treated as a comment, and
198 will not match anything. Use `\#` to match a literal `#` at the
199 start of a line, or set the `nocomment` flag to suppress this behavior.
201 The double-star character `**` is supported by default, unless the
202 `noglobstar` flag is set. This is supported in the manner of bsdglob
203 and bash 4.1, where `**` only has special significance if it is the only
204 thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but
207 If an escaped pattern has no matches, and the `nonull` flag is set,
208 then minimatch.match returns the pattern as-provided, rather than
209 interpreting the character escapes. For example,
210 `minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
211 `"*a?"`. This is akin to setting the `nullglob` option in bash, except
212 that it does not resolve escaped pattern characters.
214 If brace expansion is not disabled, then it is performed before any
215 other interpretation of the glob pattern. Thus, a pattern like
216 `+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
217 **first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
218 checked for validity. Since those two are valid, matching proceeds.