Regex Cheatsheet & Tester

Regular expressions (regex) are powerful pattern-matching tools used across virtually every programming language and text processing tool. A regex is a sequence of characters that defines a search pattern, enabling complex text operations like validation, extraction, replacement, and parsing with concise syntax.

Regex originated in the 1950s from formal language theory and became widely available in Unix tools like grep, sed, and awk in the 1970s. Today, regex is built into JavaScript, Python, Java, Go, Ruby, PHP, and nearly every modern language, making it an essential skill for developers. Understanding regex transforms hours of string manipulation into single-line operations.

When to Use Regular Expressions

Data Validation: Verify user input matches expected formats (email addresses, phone numbers, URLs, credit cards). Regex provides precise pattern definitions that simple string operations can't match. For example, validating email format requires checking for username@domain.extension structure with specific character constraints.

Text Extraction: Pull specific data from unstructured text like log files, API responses, or scraped web content. Extract all URLs from HTML, find all phone numbers in a document, or parse timestamps from log entries. Regex excels at finding patterns in noisy data.

Find & Replace: Perform sophisticated text transformations using capturing groups and backreferences. Reformat dates from MM/DD/YYYY to YYYY-MM-DD, convert camelCase to snake_case, or sanitize user input by removing dangerous characters. Single regex operations replace complex loops and conditionals.

Code Search: Find patterns in codebases - locate all function definitions, identify TODO comments, or find hardcoded API keys. IDEs and tools like grep use regex for advanced search capabilities beyond simple string matching.

Regex Syntax Basics

Character Classes: Match specific character types. \d matches any digit (0-9), \w matches word characters (a-z, A-Z, 0-9, _), \s matches whitespace (space, tab, newline). Negated versions (\D, \W, \S) match opposite characters. Use [abc] to match any of a, b, or c, or [^abc] to match anything except those characters.

Quantifiers: Control how many times a pattern should match. * means zero or more, + means one or more, ? means zero or one (optional), {n} means exactly n times, {n,m} means between n and m times. For example, \d{3} matches exactly three digits, while \w+ matches one or more word characters.

Anchors: Define position requirements. ^ matches start of string/line, $ matches end of string/line, \b matches word boundaries (transition between \w and \W). These prevent partial matches - /^\d{3}$/ matches strings that are exactly three digits, while /\d{3}/ matches any string containing three consecutive digits.

Groups: Parentheses create capturing groups that extract matched substrings. /(\d{3})-(\d{2})-(\d{4})/ matches Social Security Numbers and captures area code, group number, and serial number separately as $1, $2, $3. Non-capturing groups (?:...) match without creating references.

JavaScript Regex Flavor

This tester uses JavaScript regex engine, which follows ECMAScript specification. Key features:

Lookaheads/Lookbehinds: Match patterns based on what comes before/after without including it in the match. Positive lookahead (?=...) ensures pattern is followed by something, negative lookahead (?!...) ensures it's not followed. Example: \d+(?= dollars) matches numbers followed by " dollars" but doesn't include "dollars" in the match.

Unicode Support: The 'u' flag enables full Unicode matching, treating emoji and non-ASCII characters correctly. Without 'u', some emoji and extended Unicode characters may be treated as two characters. Always use 'u' flag when working with internationalized text.

Named Capture Groups: (?<name>...) creates named captures for more readable code. Instead of referencing $1, $2, use descriptive names: (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) creates $<year>, $<month>, $<day>.

Common Regex Pitfalls

Greedy vs Lazy Matching: By default, quantifiers are greedy - they match as much as possible. In "test", /<.>/ matches the entire string (from first < to last >), not individual tags. Use lazy quantifiers (?, +?, ??) to match as little as possible: /<.*?>/ matches each tag individually.

Catastrophic Backtracking: Poorly constructed patterns can cause exponential time complexity, hanging your application. Patterns like /(a+)+b/ against "aaaaaaaaaaaaaaaaac" cause catastrophic backtracking as the engine tries all possible ways to divide the 'a' characters between groups. Avoid nested quantifiers on overlapping patterns.

Character Escaping: Special characters (. * + ? ^ $ [ ] { } ( ) | ) must be escaped with backslash to match literally. To match a literal period, use ., not .. Common mistake: using . to mean "any character" when you meant literal period.

Multiline Confusion: Without 'm' flag, ^ and $ match only start/end of entire string. With 'm' flag, they match start/end of each line. Choose based on whether you're processing single strings or multi-line text like log files.

Regex Performance Considerations

Regex operations can be slow on large text or complex patterns. Performance tips:

Anchor Patterns When Possible: Anchored patterns (^pattern$ or \bword\b) execute faster than unanchored ones because the engine knows where to start matching. If validating format, always anchor.

Avoid Unbounded Quantifiers: Patterns like .text. can scan entire documents. Be specific about what you're matching. Instead of .*, use more targeted patterns like \w+ or [^\s]+.

Compile Once, Use Many: In JavaScript, create RegExp objects outside loops and reuse them. Creating new regex instances repeatedly wastes CPU. let pattern = /\d+/g; for (let line of lines) { pattern.test(line); }

Consider Alternatives: For simple operations, string methods (includes(), startsWith(), split()) are faster than regex. Reserve regex for complex patterns that truly require its power.

Testing & Debugging Regex

Building complex regex requires iterative refinement. Start simple and add complexity incrementally:

1. Start with basics: Match the simplest case first (e.g., \d+ for any number)
2. Add constraints: Refine to specific requirements (\d{3}-\d{4} for phone numbers)
3. Handle variations: Add optional parts or alternation (\d{3}-?\d{4} allows optional dash)
4. Test edge cases: Empty strings, maximum lengths, special characters
5. Validate with diverse data: Real-world examples often reveal issues missed in synthetic tests

Use tools like this tester to visualize matches, experiment with flags, and understand why patterns behave unexpectedly. The ability to see matches highlighted in context dramatically speeds debugging.

Regex Across Languages

While regex syntax is largely standardized, different languages have nuances:

JavaScript: Supports lookaheads and (recently) lookbehinds. No \A or \Z anchors (use ^ and $ with appropriate flags). Named groups added in ES2018.

Python: Supports verbose mode for commented patterns: re.compile(r"\d{3} # area code", re.VERBOSE). Has \A and \Z for absolute string start/end (vs ^ and $ which may match line boundaries).

Java: Requires double escaping in string literals: "\d+" for digit matching (first backslash escapes second backslash). Pattern and Matcher classes for regex operations.

Go: Regex package (regexp) uses RE2 syntax, which guarantees linear time complexity by omitting some features (no backreferences, no lookaheads). Prevents catastrophic backtracking but limits some advanced patterns.

Test patterns in your target language's environment when possible, but JavaScript regex is representative of most flavors.

Beyond Basic Pattern Matching

Text Normalization: Use regex to standardize inconsistent data. Convert various phone formats ((555) 123-4567, 555-123-4567, 555.123.4567) to unified format using capturing groups: phone.replace(/(\d{3})[.-()]?(\d{3})[.-]?(\d{4})/, "$1-$2-$3").

Markdown Parsing: Extract links text, code blocks code, or headers from Markdown using patterns like /[([^]]+)](([^)]+))/ for links.

Log Analysis: Parse structured logs with patterns like /^[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})] (\w+): (.+)$/ to extract timestamp, level, and message from [2024-02-01 10:30:00] INFO: Server started.

Data Sanitization: Remove HTML tags with /<[^>]+>/g, strip script tags with /<script\b[^<](?:(?!</script>)<[^<])*</script>/gi, or sanitize SQL inputs by blocking dangerous patterns.

Regex is a powerful tool that rewards study. Master the basics (character classes, quantifiers, anchors) then progressively learn advanced features (lookarounds, backreferences, non-greedy matching) as needs arise.