Regex (Regular Expressions) Cheat Sheet - WittyWriter

Regex (Regular Expressions) Cheat Sheet

📘 Key Concepts and Definitions

Regular Expression (Regex): A sequence of characters that specifies a search pattern in text.
Literal Character: Any character that is not a metacharacter and matches itself (e.g., a, 5, !).
Metacharacter: A character with a special meaning that defines the search rules (e.g., ., *, ^).
Pattern: The combination of literal characters and metacharacters that forms the regex.
Capture Group: A part of a pattern enclosed in parentheses () used to capture a substring for later use or back-referencing.
Flags: Modifiers placed at the end of a regex pattern that change its behavior (e.g., case-insensitivity, global search).

🧮 Pattern Structure & Flags

In many languages (like JavaScript), regex patterns are defined between slashes, followed by flags.

/pattern/flags

Common Flags

g: Global search. Finds all matches in the string, not just the first one.
i: Case-insensitive. Matches both uppercase and lowercase letters.
m: Multiline mode. Allows anchors (^, $) to match the start/end of lines, not just the whole string.

Example: /hello/gi would find all occurrences of "hello", "Hello", "HELLO", etc., in a string.

🛠️ Core Syntax & Metacharacters

Anchors & Boundaries

Character	Description	Example
`^`	Asserts position at the start of the string (or line in multiline mode).	`^A` matches "A" in "Apple"
`$`	Asserts position at the end of the string (or line in multiline mode).	`e$` matches "e" in "Apple"
`\b`	Word boundary. Matches a position between a word and a non-word character.	`\bcat\b` matches "cat" in "The cat sat." but not in "caterpillar".

Character Classes

Character	Description
`.`	Matches any single character except newline.
`\d`	Matches any digit (0-9). Equivalent to `[0-9]`.
`\D`	Matches any non-digit.
`\w`	Matches any word character (alphanumeric + underscore). Equivalent to `[A-Za-z0-9_]`.
`\W`	Matches any non-word character.
`\s`	Matches any whitespace character (space, tab, newline).
`\S`	Matches any non-whitespace character.
`[...]`	Character set. Matches any one of the characters inside the brackets (e.g., `[aeiou]`).
`[^...]`	Negated character set. Matches any character not inside the brackets.

Quantifiers

Quantifier	Description
`*`	Matches the preceding item 0 or more times.
`+`	Matches the preceding item 1 or more times.
`?`	Matches the preceding item 0 or 1 time. (Makes it optional).
`{n}`	Matches the preceding item exactly `n` times.
`{n,}`	Matches the preceding item `n` or more times.
`{n,m}`	Matches the preceding item between `n` and `m` times.

Groups & Alternation

Syntax	Description
`(...)`	Grouping. Groups multiple tokens together and creates a capture group.
`(?:...)`	Non-capturing group. Groups tokens but does not create a capture group.
`\|`	Alternation (OR). Matches either the expression before or after the pipe.

🧭 Workflow for Building a Regex

Define the Target: Be very clear about what you want to match and what you want to exclude. Find sample strings.
Start with Literals: Begin by matching the parts of the string that are always the same.
Generalize with Classes: Replace specific characters with character classes (e.g., replace 5 with \d).
Add Quantifiers: Specify how many times characters or groups should repeat (e.g., use \d+ for one or more digits).
Set Boundaries: Use anchors (^, $) and word boundaries (\b) to prevent partial matches.
Test and Refine: Use an online tool like Regex101 to test your pattern against various inputs and refine it.

⌨️ Productivity Tips

Use an Online Tester: Tools like Regex101 and RegExr are invaluable. They provide real-time matching, explanations of your pattern, and a reference guide.
Make Quantifiers Lazy: By default, quantifiers are "greedy" (they match as much as possible). Add a ? to make them "lazy" (match as little as possible). For example, to match an HTML tag: <.*?> is often better than <.*>.
Comment Your Regex: In languages that support it (like Python with the `re.VERBOSE` flag), you can add comments to complex patterns to explain what each part does.

📊 Quick Reference Table

This table summarizes the most common tokens.

Token	Meaning	Token	Meaning
`.`	Any character	`\d`	Digit
`\w`	Word character	`\s`	Whitespace
`[...]`	Character set	`^`	Start of string
`$`	End of string	`*`	0 or more
`+`	1 or more	`?`	0 or 1
`(...)`	Capture group	`\|`	OR

🧪 Common Use Case Examples

Validate a Simple Email Address

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

^: Start of the string.
[^\s@]+: One or more characters that are not whitespace or '@'.
@: A literal '@' symbol.
[^\s@]+\.: The domain name, followed by a literal dot . (escaped with a backslash).
[^\s@]+: The top-level domain.
$: End of the string.

Match a US Phone Number

/^\(?(\d{3})\)?[-\s]?(\d{3})[-\s]?(\d{4})$/

This pattern matches formats like (123) 456-7890, 123-456-7890, and 123 456 7890.

Extract a URL from Text

/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)/gi

A more complex example that finds http and https URLs.

🧹 Troubleshooting Common Issues

Problem: The pattern matches too much (Greediness).
- Fix: Your quantifier (* or +) is "greedy". Make it "lazy" by adding a ? after it (e.g., *?). This tells the engine to match the shortest possible string.
Problem: Special characters are being treated as literals (or vice versa).
- Fix: You need to escape metacharacters if you want to match them literally. To match a period, use \.. To match a backslash, use \\.
Problem: Catastrophic Backtracking (Regex is very slow).
- Fix: This happens with complex patterns involving nested quantifiers and alternation. Simplify your pattern. Avoid nested groups with quantifiers like (a*)*. Make your pattern more specific.

📚 References and Further Reading

Regex101: The best tool for building, testing, and debugging regular expressions.
MDN Web Docs: JavaScript Regular Expressions Guide.
Regular-Expressions.info: An in-depth, comprehensive website covering every aspect of regex.