globster.xyz

Start with RegexOne's Lesson 1 and type abc into the exercise field to match the first three lines. That single action captures the core idea: a regular expression is a pattern of characters you write to match a specific sequence in text. This approach works if you learn best by doing short exercises and getting immediate feedback; it assumes no prior regex knowledge and only requires a browser.

What a regular expression actually is

A regular expression (also written regex or regexp) is a pattern you use to find, extract, or validate text such as code, log files, spreadsheets, or documents. RegexOne frames the first principle plainly: everything is essentially a character, and you are writing patterns to match a specific sequence of characters (a string).

Most patterns use normal ASCII — letters, digits, punctuation, and symbols like %#$@! from your keyboard — but Unicode characters can also be used to match international text.

How the interactive lessons work

Each lesson introduces one new syntax or concept, then gives you lines of text to match. As you type into the input field, matching characters are highlighted on each line. To move to the next lesson, your pattern must match all the lines provided. This forces you to generalize rather than hard-code a single answer.

In Exercise 1, the task is to match three lines:

match abcdefg
match abcde
match abc

Typing abc matches all three, because those are the common characters on each line. Solve the task to continue to the next problem.

The lesson sequence

RegexOne orders lessons so each builds on the last. Following this order avoids the common trap of jumping to advanced syntax before the basics are automatic:

Practice with real problems

After the lessons, RegexOne provides practice problems that apply patterns to realistic tasks:

• Matching decimal numbers
• Matching phone numbers
• Matching emails
• Matching HTML
• Matching specific filenames
• Trimming whitespace from the start and end of a line
• Extracting information from a log file
• Parsing and extracting data from a URL

These are the patterns you will actually reuse, so treat them as the test of whether the earlier lessons stuck.

Language-specific guides

Regex syntax varies slightly between languages. RegexOne offers guides for C#, JavaScript, Java, PHP, and Python, so you can check how a pattern you learned applies in the language you write.

A practical way to work through it

1. Do one lesson at a time and type patterns rather than reading solutions.
2. When a pattern fails, change one element at a time to see which character breaks the match.
3. After Lesson 10, attempt the practice problems before moving to groups and conditionals.
4. Revisit any lesson where you had to guess rather than reason.

The site lists PayPal among its payment platforms, but the lesson content described here is presented as an interactive tutorial; check the site directly for what is free versus paid.

Minimatch is a JavaScript library that matches file paths against glob patterns — the same wildcard syntax your shell uses when you type cp *.jpg ./thumbnails. If you need to filter files in a Node.js build script, a linter config, or a .gitignore-style rule, minimatch is one of the standard ways to evaluate those patterns in JavaScript. This article covers the syntax it supports, how to test a pattern before trusting it, and when a different library might fit better.

What minimatch actually does

Globbing is pattern matching for the filesystem. A glob pattern like *.jpg describes a set of filenames, and a matcher decides whether a given path belongs to that set.

Minimatch takes two inputs — a pattern string and a path string — and returns whether they match. It does not walk the filesystem itself; it only evaluates the pattern against paths you hand it. That separation matters: the library answers "does this path match?" while a separate tool decides which paths to check.

The online glob tester at globster.xyz uses minimatch (version 3.0.4) to evaluate patterns typed into its input field, highlighting matched files in blue inside a directory tree. That makes it a practical way to see what a pattern does before you wire it into code.

Core wildcard syntax

Minimatch supports the basic wildcards plus several extended features. The table below summarizes the main tokens.

How globstar behaves

** is the token people most often get wrong. It matches all files and zero or more directories and subdirectories — but only when it stands alone as a path segment. If it is followed by a /, it matches only directories and subdirectories. And it must be the only thing inside its path part: a pattern like /myapp/**.js will not behave as a recursive match, because ** is glued to .js rather than occupying its own segment. Write /myapp/**/*.js instead.

Brace expansion

Braces expand one pattern into several, and the final result is the union of all of them. So **/*.{b,c} expands into **/*.b and **/*.c — a path matches if it satisfies either. Ranges work too: **/{a..c} expands into **/a, **/b, and **/c.

Extended glob matching

The extglob forms (?(...), *(...), +(...), @(...), !(...)) let you express repetition and negation that plain * and ? cannot. They are the minimatch equivalent of regular-expression quantifiers, scoped to a set of alternatives.

Testing and debugging a pattern

Because glob syntax varies by implementation, a pattern that works in your shell may not behave the same in minimatch. Testing first saves guesswork.

1. Write the pattern you intend to use, for example **/*.{js,ts}.
2. Enter it into an online glob tester such as globster.xyz, which evaluates patterns with minimatch 3.0.4.
3. Read the highlighted results — matched files appear in blue in the directory tree.
4. Adjust and re-test if the match set is wider or narrower than expected. Common fixes: split a glued ** into its own segment, or convert a brace list into separate patterns.

The tester is most useful for two situations: debugging a pattern that does not work as intended, and experimenting with the provided examples to learn the syntax. If a pattern matches nothing, check whether ** is isolated in its segment and whether your braces are balanced.

Minimatch vs. other glob implementations

Globbing exists in nearly every language, and the syntax is not identical across them. The main alternatives:

• JavaScript: minimatch, micromatch, extglob
• Python: the glob module
• Linux: shell glob

Minimatch supports basic wildcards (?, *), brace expansion, extended glob matching, and globstar. Micromatch is a related JavaScript option; the glob module is Python's built-in; shell glob is what your terminal applies before a command runs. The right choice depends on your runtime and how much of the extended syntax you need — if you only need * and ?, almost any implementation will do, but brace expansion and extglob are where implementations diverge.

Practical takeaways

• Minimatch evaluates patterns against paths; it does not traverse the filesystem.
• ? is one character, * is any string, ** is recursive — but only as a standalone segment.
• Braces expand into a union of patterns; extglob adds repetition and negation.
• Test patterns in an online tester before relying on them, since syntax differs between implementations.
• Reach for micromatch, Python's glob, or shell glob when your environment or feature needs point that way.

Glob patterns are a compact syntax for matching filenames and paths, not arbitrary text. A pattern like *.jpg matches every file in the current directory ending in .jpg, which is why a shell command such as cp *.jpg ./thumbnails copies all JPEGs into a thumbnails folder. Use globbing when you need to select files by name or path shape; use regular expressions when you need to match or extract text content. The exact syntax depends on the implementation, so a pattern that works in one tool may behave differently in another.

Glob vs. regular expressions

Both use wildcards, but they solve different problems:

If you are selecting files, reach for glob. If you are matching a string inside a file, reach for regex.

Core wildcards

These three symbols cover most everyday patterns:

• ? — matches a single character. file?.txt matches file1.txt and fileA.txt but not file10.txt.
• * — matches any string, typically within a single path segment. *.jpg matches all JPEG files in the current directory.
• / — the path separator. It divides a pattern into segments, and in many implementations * will not cross it.

That last point matters: in most tools * stays inside one directory level, while ** is what lets you reach across directories.

Globstar: **

** matches all files and zero or more directories and subdirectories. It is the feature that makes recursive patterns practical.

• **/*.js matches every .js file at any depth.
• If ** is followed by /, it matches only directories and subdirectories.
• For this behavior to apply, ** must be the only thing inside its path segment. A pattern like /myapp/**.js does not behave the same way, because ** is not alone in its segment.

Brace expansion: {a,b} and {a..c}

Braces expand one pattern into several, and the final result is the union of all of them.

• **/*.{b,c} expands into **/*.b and **/*.c, matching files with either extension.
• **/{a..c} expands into **/a, **/b, and **/c, matching those three names.

This is a shorthand for writing multiple patterns, not a matching operator in its own right.

Extended glob (extglob)

Extended glob matching adds operators that borrow from regular expression quantifiers. Each takes a group in parentheses:

So +(a|b) matches a, b, ab, ba, and longer combinations, while @(a|b) matches only a or b. Extglob is not enabled everywhere by default, so check whether your tool supports it before relying on it.

Where globbing is used

Globbing originated in Unix shells and now appears across many tools:

• Shell commands such as cp, ls, and rm.
• .gitignore files, which use patterns to exclude files and folders from version control.
• Build tools, linters, and test runners that select source files by pattern.
• Programming languages through libraries: minimatch and micromatch in JavaScript, the glob module in Python, and shell globbing on Linux.

Syntax varies by implementation

There is no single glob standard. The same pattern can mean different things depending on the tool evaluating it. For example, the Globster tester uses the JavaScript minimatch library (version 3.0.4), which supports basic wildcards (?, *), brace expansion, extended glob matching, and globstar. Other implementations may support only a subset or add their own extensions.

When a pattern does not work as expected, the fastest way to find out why is to test it against a real file tree and see which files get highlighted. That turns a guess about syntax into a visible result.

Glob pattern matching is the wildcard syntax used to match filesystem paths, and you can test it without installing anything by pasting a pattern into an online glob tester such as globster.xyz. Type your pattern into the input field and every matched file is highlighted in blue in the tree directory structure, which makes it easy to see why a pattern over-matches, under-matches, or fails entirely. This works best when you already have a rough idea of the files you expect to match and want to confirm the syntax before putting it into a .gitignore, a build script, or a shell command.

Glob vs. regular expressions

Glob and regex both do pattern matching, but they solve different problems.

The classic illustration is a shell command like cp *.jpg ./thumbnails, which copies every file with a .jpg extension into the thumbnails folder. Here *.jpg is the glob pattern, and it matches all files in the current working directory ending in .jpg. Think of glob as pattern matching for the filesystem rather than for text.

Globbing originated in Unix and is now used widely — the .gitignore file in Git is one common example, where patterns exclude certain files and folders from version control.

Core wildcard syntax

Syntax depends on the implementation. The tester on globster.xyz evaluates patterns with the minimatch JavaScript library (version 3.0.4), which supports basic wildcards, brace expansion, extended glob matching, and globstar.

Globstar ** and its main limitation

** matches all files plus zero or more directories and subdirectories. If it is followed by a /, it matches only directories and subdirectories.

The catch that trips people up: to behave that way, ** must be the only thing inside the path part. A pattern like /myapp/**.js will not work as a recursive match, because ** is not alone in its path segment.

Brace expansion

An expression inside curly braces expands into multiple patterns. For example, **/*.{b,c} expands into **/*.b and **/*.c, and the final result is the union of checking both patterns. Brace sets with a range work too: **/{a..c} expands into **/a, **/b, and **/c.

Step-by-step: testing a glob pattern

1. Decide what should match. Write down the exact files you expect, for example "all .js files in any subdirectory except node_modules."
2. Enter the pattern into the input field of the glob tester.
3. Read the highlighted results. Matched files appear in blue in the tree directory structure. Compare them against your expected list.
4. Adjust and repeat. If files you expected are not highlighted, the pattern is too narrow; if extra files are highlighted, it is too broad.
5. Copy the verified pattern into your .gitignore, build config, or shell command.

Verification and common sticking points

• Over-matching: * matches any string, including across many characters you did not intend. Narrow it with a more specific prefix or extension.
• Recursion not working: check whether ** is alone in its path segment. /myapp/**.js is a frequent offender.
• Brace expansion surprises: remember the result is a union, so **/*.{b,c} will match both sets, not an intersection.
• Implementation differences: minimatch is not the only glob library. JavaScript also has micromatch and extglob, Python has the glob module, and Linux shells have their own glob. A pattern that works in one may not behave identically in another, so test against the tool that will actually run your pattern.

When to use an online glob tester

Use globster.xyz when you want to debug a glob that is not working, or to experiment and learn from the provided examples without setting up a project. It is a fast feedback loop for syntax questions: type, observe the highlighted matches, and correct. For patterns destined for a specific language or tool, confirm the behavior against that tool's own glob implementation before relying on it in production.

Glob pattern matching is a way to select files by name using wildcards instead of listing them one by one. A pattern like *.jpg matches every file in the current directory ending in .jpg, which is why cp *.jpg ./thumbnails copies all JPEGs at once. You use globbing whenever you need to describe a set of files rather than name them individually — in shell commands, .gitignore rules, and build tool configs. The catch is that syntax varies by implementation, so a pattern that works in bash may behave differently in a JavaScript library.

Glob vs. regular expressions

Globbing and regular expressions both match patterns, but they solve different problems and are not interchangeable.

A glob pattern is not a regex. If you paste *.jpg into a regex engine, it means something else entirely. Keep the two mental models separate.

Core wildcards

The basic building blocks, as documented by minimatch (the library behind globster.xyz) and shell documentation:

• ? — matches a single character.
• * — matches any string.
• / — the path separator. It is not a wildcard; it divides a path into segments.

So file?.txt matches file1.txt and fileA.txt but not file10.txt. And *.txt matches notes.txt and report.txt in the current directory.

Advanced syntax

Beyond the basics, minimatch supports several features that cover most real-world needs.

Globstar **

** matches all files and zero or more directories and subdirectories. If followed by /, it matches only directories and subdirectories.

Important constraint: to behave that way, ** must be the only thing inside its path segment. A pattern like /myapp/**.js will not work as a recursive match — the ** is glued to .js and loses its special meaning.

Brace expansion {a,b}

An expression inside curly braces expands into multiple patterns, and the final result is the union of all of them:

• **/*.{b,c} expands into **/*.b and **/*.c.
• Brace sets like **/{a..c} expand into **/a, **/b, and **/c.

Extended glob matching (extglob)

These operators come from the extended glob feature and give you regex-like control:

• ?(a|b) — matches zero or one occurrence.
• *(a|b) — matches zero or more occurrences.
• +(a|b) — matches one or more occurrences.
• @(a|b) — matches exactly one occurrence.
• !(a|b) — matches anything except the listed alternatives.

Where globbing is used

Globbing started in Unix and is now everywhere:

• Shell commands — cp *.jpg ./thumbnails, rm build/*.log.
• Git — .gitignore patterns exclude files and folders from version control.
• Build and tooling configs — selecting source files, test files, or assets.
• Programming languages — JavaScript (minimatch, micromatch, extglob), Python (glob module), and Linux system globbing all implement their own versions.

Syntax varies by implementation

This is the most common source of confusion. The same pattern can mean different things depending on the engine:

• minimatch / micromatch (JavaScript) — supports ?, *, brace expansion, extglob, and globstar as described above.
• Python glob — supports *, ?, and [] character ranges, but not extglob.
• Shell glob — behavior depends on the shell and its options.

Before trusting a pattern, confirm which library or tool is evaluating it.

Debugging a pattern that doesn't match

When a glob fails, the fastest fix is to test it against a real file tree and see which files light up. globster.xyz is built for exactly this: you type a pattern into the input field and matched files are highlighted in blue in a directory tree, using minimatch 3.0.4 to evaluate the pattern. It also ships with an examples section you can learn from.

A practical workflow:

1. Start with the simplest pattern that should match (*.js).
2. Add one feature at a time (**/*.js, then **/*.{js,ts}).
3. Watch which files highlight after each change.
4. If ** stops working, check whether it is alone in its path segment.

That last point trips up more people than any other glob rule — a recursive match silently degrades into a literal one when ** is combined with other characters in the same segment.