RegExp Tester

The RegExp Tester tool provides an interactive environment for testing regular expressions against sample text. It supports all JavaScript regex flags, displays match positions, and extracts capture groups for detailed pattern analysis.

Features

Full JavaScript regex syntax support
All standard flags (g, i, m, s, u, y)
Match highlighting with positions
Capture group extraction
Match count and indexing
Real-time error reporting

Use Cases

Pattern Development

Test and refine regex patterns before using them in production code

Data Validation

Validate input patterns like emails, phone numbers, and URLs

Text Extraction

Extract specific data patterns from unstructured text

Log Parsing

Build patterns to parse and extract information from log files

Regex Flags

Select flags by changing the action:

Flag	Name	Description
`g`	Global	Find all matches (not just first)
`i`	Ignore Case	Case-insensitive matching
`m`	Multiline	`^` and `$` match line boundaries
`s`	DotAll	`.` matches newlines
`u`	Unicode	Enable full Unicode support
`y`	Sticky	Match from lastIndex position

Common Flag Combinations

Default: gm (global, multiline)
Case-insensitive search: gi
Single match: i (no global flag)
Unicode text: gu

Input Format

Pattern (Main Input)

Enter the regular expression pattern without delimiters:

\d{3}-\d{3}-\d{4}

Do not include / delimiters. Enter only the pattern. Flags are set via the action parameter.

Test String (Second Input)

The text to test against:

Call me at 555-123-4567 or 555-987-6543

Output Format

Matches are displayed with:

Match number - Sequential index
Matched text - The captured string
Position - Character offset in the input
Capture groups - Named groups labeled as g1, g2, etc.

#1 "555-123-4567" @ 11
#2 "555-987-6543" @ 28

Examples

Phone Numbers
Email Extraction
Capture Groups
Case-Insensitive
Multiline Matching

Extract US phone numbers.Pattern:

\d{3}-\d{3}-\d{4}

Test String:

Contact: 555-123-4567 (office) or 555-987-6543 (mobile)

Output:

#1 "555-123-4567" @ 9
#2 "555-987-6543" @ 35

Find email addresses.Pattern:

[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

Test String:

Email [email protected] or [email protected]

Output:

#1 "[email protected]" @ 6
#2 "[email protected]" @ 27

Flags: g (global)

Extract parts of a match using capture groups.Pattern:

(\w+)@(\w+\.\w+)

Test String:

Contact: [email protected]

Output:

#1 "[email protected]" @ 9 (g1=support, g2=example.com)

Groups:

g1: Username (support)
g2: Domain (example.com)

Match regardless of case.Pattern:

error|warning|critical

Test String:

ERROR: disk full
Warning: low memory
CRITICAL: system shutdown

Flags: gi (global, ignore case)Output:

#1 "ERROR" @ 0
#2 "Warning" @ 18
#3 "CRITICAL" @ 37

Match across multiple lines.Pattern:

^\d+\.

Test String:

First item
Second item
Third item

Flags: gm (global, multiline)Output:

#1 "1." @ 0
#2 "2." @ 15
#3 "3." @ 31

Without the m flag, ^ only matches the start of the entire string, not line starts.

Implementation Details

From lib/tools/engine.ts:438-453:

case 'regexp-tester': {
  const validFlags = /^[gimsuy]*$/.test(action) ? action : 'gm';
  const flags = action === 'default' ? 'gm' : validFlags;
  
  let regex: RegExp;
  try {
    regex = new RegExp(input, flags);
  } catch (e) {
    return { output: `Invalid regular expression: ${e.message}` };
  }
  
  const test = options.secondInput ?? '';
  const matches = [...test.matchAll(regex)].map((m, i) => {
    const groups = m.slice(1)
      .map((g, idx) => `g${idx + 1}=${g ?? ''}`)
      .join(', ');
    return `#${i + 1} "${m[0]}" @ ${m.index ?? 0}${
      groups ? ` (${groups})` : ''
    }`;
  });
  
  return { output: matches.length ? matches.join('\n') : 'No matches' };
}

Common Patterns

URL Matching

https?://[^\s]+

Hex Colors

#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}

IP Addresses

\b(?:\d{1,3}\.){3}\d{1,3}\b

Date (YYYY-MM-DD)

\d{4}-\d{2}-\d{2}

HTML Tags

<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)

Credit Card (Simple)

\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}

Character Classes

Pattern	Matches
`\d`	Any digit (0-9)
`\D`	Any non-digit
`\w`	Word character (a-z, A-Z, 0-9, _)
`\W`	Non-word character
`\s`	Whitespace (space, tab, newline)
`\S`	Non-whitespace
`.`	Any character (except newline)
`[abc]`	Any of a, b, or c
`[^abc]`	Anything except a, b, or c
`[a-z]`	Lowercase letters

Quantifiers

Pattern	Matches
`*`	0 or more
`+`	1 or more
`?`	0 or 1 (optional)
`{n}`	Exactly n times
`{n,}`	n or more times
`{n,m}`	Between n and m times

Anchors

Pattern	Matches
`^`	Start of string/line
`$`	End of string/line
`\b`	Word boundary
`\B`	Non-word boundary

Common Mistakes

Escaping Special Characters: Remember to escape special regex characters like ., *, +, ?, [, ], {, }, (, ), |, \, ^, $Example: Use \. to match a literal period

Greedy vs Non-Greedy

<.*>     # Greedy: matches <b>test</b> more</b> as one match
<.*?>    # Non-greedy: matches <b>, </b>, </b> separately

Case Sensitivity

By default, regex is case-sensitive. Use the i flag for case-insensitive matching:

test     # Matches: test
test (i) # Matches: test, Test, TEST, TeSt

Testing Strategy

Start simple - Test basic patterns before adding complexity
Test edge cases - Empty strings, special characters, very long inputs
Use capture groups - Extract specific parts of matches
Check performance - Avoid catastrophic backtracking with complex patterns
Validate thoroughly - Test with both valid and invalid inputs

String Inspector - Analyze text characteristics
Text Separator - Split text with custom delimiters
URL Parser - Parse URL components

Encoding & Encryption

Escaping & Entities

Preview & Comparison

Format Converters

Code Beautifiers

Generators

Data Transformers

Features

Use Cases

Pattern Development

Data Validation

Text Extraction

Log Parsing

Regex Flags

Common Flag Combinations

Input Format

Pattern (Main Input)

Test String (Second Input)

Output Format

Examples

Implementation Details

Common Patterns

URL Matching

Hex Colors

IP Addresses

Date (YYYY-MM-DD)

HTML Tags

Credit Card (Simple)

Character Classes

Quantifiers

Anchors

Common Mistakes

Greedy vs Non-Greedy

Case Sensitivity

Testing Strategy

Build docs developers (and LLMs) love

Encoding & Encryption

Escaping & Entities

Preview & Comparison

Format Converters

Code Beautifiers

Generators

Data Transformers

​Features

​Use Cases

Pattern Development

Data Validation

Text Extraction

Log Parsing

​Regex Flags

​Common Flag Combinations

​Input Format

​Pattern (Main Input)

​Test String (Second Input)

​Output Format

​Examples

​Implementation Details

​Common Patterns

​URL Matching

​Hex Colors

​IP Addresses

​Date (YYYY-MM-DD)

​HTML Tags

​Credit Card (Simple)

​Character Classes

​Quantifiers

​Anchors

​Common Mistakes

​Greedy vs Non-Greedy

​Case Sensitivity

​Testing Strategy

​Related Tools

Build docs developers (and LLMs) love

Features

Use Cases

Regex Flags

Common Flag Combinations

Input Format

Pattern (Main Input)

Test String (Second Input)

Output Format

Examples

Implementation Details

Common Patterns

URL Matching

Hex Colors

IP Addresses

Date (YYYY-MM-DD)

HTML Tags

Credit Card (Simple)

Character Classes

Quantifiers

Anchors

Common Mistakes

Greedy vs Non-Greedy

Case Sensitivity

Testing Strategy

Related Tools