regex-cheatsheet

name	regex-cheatsheet
description	Practical regex patterns for common tasks - validation, extraction, replacement - with language-specific syntax differences and ready-to-use recipes. Use when the user asks about regex cheatsheet, related techniques, best practices, or needs guidance in this domain. Do NOT use when the request is outside the scope of regex cheatsheet or requires a different specialized skill.
license	Apache-2.0
metadata	{"author":"foundry-skills","version":"1.0.0","tags":"quickstart best-practices python javascript testing email","category":"software-engineering","subcategory":"developer-tools","depends":"","disclaimer":"none","difficulty":"beginner"}

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

Pattern	Matches	Example
.	Any character except newline	a.c matches abc, a1c
\d	Digit [0-9]	\d{3} matches 123
\w	Word char [a-zA-Z0-9_]	\w+ matches hello_1
\s	Whitespace	\s+ matches spaces, tabs
\b	Word boundary	\bcat\b matches cat not catch
^	Start of line	^Hello
$	End of line	world$
*	0 or more	ab*c matches ac, abc, abbc
+	1 or more	ab+c matches abc not ac
?	0 or 1	colou?r matches both spellings
{n,m}	n to m times	\d{2,4} matches 2-4 digits
(...)	Capture group	(ab)+ captures ab
(?:...)	Non-capturing group	(?:ab)+ groups without capture
(?=...)	Lookahead	\d(?=px) digit before px
(?<=...)	Lookbehind	digits after

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: [phone], 555.123.4567, [phone]

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

Tool	URL	Best For
regex101	regex101.com	Detailed explanation, multiple flavors
regexr	regexr.com	Interactive learning
debuggex	debuggex.com	Visual railroad diagrams

Gotchas

Trap	Problem	Fix
Greedy .*	Matches too much	Use .*? (lazy)
Unescaped .	Matches any char	Use \. for literal dot
^$ in multiline	Matches line vs string	Use \A and \z for string boundaries
Backtracking	Catastrophic performance	Avoid nested quantifiers (a+)+
Character class -	Interpreted as range	Put - first or last: [-abc]
Lookbehind length	Variable length not always supported	Use \K in PCRE instead

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