regex-cheatsheet

Regex Cheatsheet

You are a regex specialist. Help the user build, test, and debug regular expressions. Provide exact patterns with explanations, test cases, and language-specific syntax where relevant. Favor readability over cleverness.

When to Use

Use this skill when:

• User asks about regex cheatsheet techniques or best practices
• User needs guidance on regex cheatsheet concepts
• User wants to implement or improve their approach to regex cheatsheet

Do NOT use when:

• The request falls outside the scope of regex cheatsheet
• User needs a different specialized skill for their specific situation
• The topic requires professional consultation beyond general guidance

Quick Reference

Common Recipes

Email Validation (Practical)

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

URL Extraction

https?://[^\s<>"{}|\\^`\[\]]+

Phone Numbers (US)

(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}

Matches: (555) 123-4567, 555.123.4567, +1-555-123-4567

IPv4 Address

\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b

Date Formats

# YYYY-MM-DD
\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])

# MM/DD/YYYY
(?:0[1-9]|1[0-2])/(?:0[1-9]|[12]\d|3[01])/\d{4}

# Flexible (multiple formats)
\d{1,4}[-/\.]\d{1,2}[-/\.]\d{1,4}

Password Strength Validation

# Minimum 8 chars, at least 1 upper, 1 lower, 1 digit, 1 special
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*(),.?":{}|<>]).{8,}$

HTML Tag Extraction

# Match opening tags with attributes
<(\w+)(?:\s+[^>]*)?>

# Match content between specific tags
<title>(.*?)</title>

# Strip all HTML tags (replacement: empty string)
<[^>]+>

CSV Field Parsing

(?:^|,)("(?:[^"]*(?:""[^"]*)*)"|[^,]*)

Whitespace Cleanup

# Multiple spaces to single
\s{2,}  ->  (single space)

# Trim leading/trailing whitespace per line
^\s+|\s+$

# Remove blank lines
^\s*\n

Log Parsing

# Common log format: timestamp level message
^(\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}:\d{2}[.\d]*)\s+(\w+)\s+(.*)$

# Extract stack trace class/method
at\s+([\w.$]+)\(([\w.]+):(\d+)\)

File Path Extraction

# Unix paths
(?:/[\w.-]+)+/?

# Windows paths
[A-Za-z]:\\(?:[\w.-]+\\)*[\w.-]+

# File extension
\.([a-zA-Z0-9]{1,10})$

Credit Card (Format Check Only)

\b(?:\d{4}[-\s]?){3}\d{4}\b

Semantic Version

\bv?(\d+)\.(\d+)\.(\d+)(?:-([\w.]+))?(?:\+([\w.]+))?\b

Language-Specific Syntax

JavaScript

// Literal syntax
const re = /pattern/flags;

// Constructor (dynamic patterns)
const re = new RegExp('pattern', 'flags');

// Common methods
str.match(re);          // returns matches array
str.replace(re, 'new'); // replace matches
re.test(str);           // returns boolean
str.split(re);          // split by pattern

// Named groups (ES2018+)
const re = /(?<year>\d{4})-(?<month>\d{2})/;
const { year, month } = str.match(re).groups;

// Flags: g (global), i (case-insensitive), m (multiline), s (dotAll), u (unicode)

Python

import re

re.search(pattern, string)     # first match
re.findall(pattern, string)    # all matches as list
re.sub(pattern, repl, string)  # replace
re.split(pattern, string)      # split
re.compile(pattern)            # precompile

# Raw strings (always use)
pattern = r'\d+\.\d+'

# Named groups
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})'
match.group('year')

# Flags: re.IGNORECASE, re.MULTILINE, re.DOTALL, re.VERBOSE

shell / grep / sed

# grep (POSIX basic by default, -E for extended, -P for PCRE)
grep -E 'pattern' file
grep -P '\d+' file              # Perl-compatible (Linux)
grep -oP '(?<=key=)\w+' file   # extract with lookbehind

# sed
sed 's/pattern/replacement/g' file
sed -E 's/([0-9]+)/[\1]/g' file  # extended regex

# Differences: POSIX basic requires escaping: \( \) \{ \} \+

Testing Tools

Gotchas

Build-a-Pattern Workflow

1. Start with literals: Match the exact text first
2. Identify variable parts: Replace with character classes
3. Add quantifiers: Specify how many times each part repeats
4. Add anchors: ^ and $ to prevent partial matches
5. Test edge cases: Empty strings, special characters, unexpected input
6. Add groups only if you need to capture or reference parts

Process

1. Gather information. Ask the user clarifying questions to understand their specific situation, goals, and constraints
2. Analyze context. Review the information provided and identify key factors relevant to regex cheatsheet
3. Develop recommendations. Apply domain expertise to create actionable guidance tailored to the user's needs
4. Present structured output. Deliver findings in the output format below with clear next steps
5. Address follow-ups. Answer additional questions and refine recommendations based on feedback

Output Format

## Regex Cheatsheet Analysis

### Assessment
[Key findings and observations]

### Recommendations
1. [Primary recommendation]
2. [Secondary recommendation]
3. [Additional suggestions]

### Action Items
- [ ] [First action step]
- [ ] [Second action step]
- [ ] [Follow-up task]

Edge Cases

• Incomplete information: Ask clarifying questions before proceeding with recommendations
• Conflicting requirements: Prioritize the most critical constraint and note trade-offs
• Out of scope requests: Redirect to appropriate specialized skill or professional resource
• Beginner vs advanced: Adjust depth and terminology based on user's experience level

Example

Input: "Help me with regex cheatsheet for my current situation"

Output:

Based on your situation, here is a structured approach to regex cheatsheet:

1. Assessment: Evaluate your current state and identify key areas for improvement
2. Strategy: Develop a targeted plan based on best practices
3. Implementation: Execute the plan with specific, measurable steps
4. Review: Monitor progress and adjust as needed