Regex Tester & Cheatsheet

A regular expression (regex, or regexp) is a compact syntax for describing patterns in text. Instead of searching for one exact string, a regex describes a shape: "a digit followed by three letters," "anything between two quotes," or "a word repeated twice in a row." The regex engine then finds every piece of text that matches that shape. It's built into nearly every programming language, text editor, and command-line tool, which is why the same core syntax (with small dialect differences) shows up everywhere from JavaScript to grep to your IDE's find-and-replace.

Developers reach for regex because it turns pattern matching from a manual, error-prone loop of string checks into a single declarative expression. A pattern is built from literal characters (which match themselves), character classes like \d or [a-z] (which match a category of characters), quantifiers like + or {2,4} (which control how many times something repeats), and structural pieces like groups and alternation that let you combine smaller patterns into bigger ones. The regex engine scans the input text and reports every position where the pattern's rules are satisfied.

In day-to-day work, regex shows up in form validation (does this look like a phone number?), log and data parsing (pull every IP address out of this file), search-and-replace across a codebase, URL routing, extracting structured fields from unstructured text, and cleaning up messy data before it goes into a pipeline. It's not always the right tool (see regex vs. string methods below), but for genuine pattern matching, nothing else is as concise.

Character classes match a category of characters at one position: \d for digits, \w for word characters, \s for whitespace, or a custom set like [aeiou].

Quantifiers control repetition: * (zero or more), + (one or more), ? (optional), and {n,m} (a specific range) all attach to the token immediately before them.

Anchors match a position rather than a character. ^ and $ pin a match to the start or end of the string (or line, with the m flag), and \b matches a word boundary.

Groups like (abc) capture matched text for later use, (?:abc) groups without capturing, and (?<name>abc) captures with a readable name instead of a number. Alternation (a|b) matches either side of the pipe.

Lookarounds, (?=...), (?!...), (?<=...), and (?<!...), assert that something does or doesn't appear before or after the current position, without including it in the match itself. All four are supported in modern JavaScript engines.

Flags change how the whole pattern behaves: g finds all matches, i ignores case, m makes ^/$ match per line, s lets . match newlines, u switches to Unicode-aware mode, and y matches only at the exact current position.

Regex is powerful, but it's not always the clearest or fastest option. When the check is simple, plain string methods are usually more readable and often faster to run:

• includes(): checking whether a fixed substring appears anywhere, e.g. url.includes("https://"), instead of a regex just to test for a literal string.
• startsWith() / endsWith() : checking a fixed prefix or suffix, e.g. a filename ending in .pdf, is clearer than /\.pdf$/.
• split(): breaking text on a fixed, simple delimiter like a comma doesn't need regex at all (though split() does also accept one for variable-width delimiters).
• replace(): replacing one fixed substring is simpler without regex; reach for a regex replacement once the thing you're replacing varies (whitespace runs, digits, optional parts).

As a rule of thumb: if you can describe the check in one sentence without the word "pattern," a string method probably expresses it more clearly. Reach for regex once you're matching variable text, multiple alternatives, repetition, or need to extract pieces of a larger string.