What Is a Regular Expression? Regex Explained with Examples

If you have ever written code that checks whether an email address looks valid, extracted all phone numbers from a document, or replaced every occurrence of a word in a file — you were doing what regex does, just manually. A regular expression lets you write that logic as a compact pattern that the language engine executes for you.

Regex is built into JavaScript, Python, Java, Ruby, Go, Rust, SQL, and virtually every other general-purpose language. Once you understand the syntax, you carry that skill across every tool and language you use.

What Is a Regular Expression?

A regular expression is a sequence of characters that forms a search pattern. The pattern can be used to:

• Test — does this string match the pattern?
• Search — find all substrings matching the pattern
• Extract — pull out specific parts of a match (capture groups)
• Replace — substitute matching text with something else
• Split — break a string wherever the pattern matches

In most languages, a regex is written between two forward slashes: /pattern/flags. In Python you pass a raw string to re functions: re.search(r"pattern", text).

Regex Syntax: Quick-Reference Cheat Sheet

These are the building blocks of every regex pattern. Learn these and you can read or write the vast majority of regular expressions you will encounter.

Regex Flags

Flags modify how the engine interprets the pattern. They go after the closing slash in JavaScript (/pattern/gi) or as a second argument in Python (re.findall(pattern, text, re.I)).

8 Commonly Used Regex Patterns

These patterns cover the validation tasks developers reach for most often. Copy any pattern into the regex tester to see live matches and explanations.

Code Examples in JavaScript, Python, and TypeScript

The regex syntax is nearly identical across languages. The main differences are in how you call the function — not the pattern itself.

// Test if a string matches a pattern
const email = "user@example.com";
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
console.log(emailRegex.test(email)); // true

// Extract all matches
const text = "Call 555-1234 or 555-5678 for support";
const phones = text.match(/\d{3}-\d{4}/g);
console.log(phones); // ["555-1234", "555-5678"]

// Replace with a function
const result = "2026-05-05".replace(
  /(\d{4})-(\d{2})-(\d{2})/,
  (_, y, m, d) => `${d}/${m}/${y}`
);
console.log(result); // "05/05/2026"

import re

# Search for a pattern
text = "Order placed on 2026-05-05 at 14:30"
match = re.search(r"\d{4}-\d{2}-\d{2}", text)
if match:
    print(match.group())  # "2026-05-05"

# Find all matches
emails = re.findall(r"[^\s@]+@[^\s@]+\.[^\s@]+", text)

# Replace using regex
clean = re.sub(r"\s+", " ", "too   many    spaces")
print(clean)  # "too many spaces"

# Compile for reuse (faster when used many times)
pattern = re.compile(r"\d{3}-\d{4}")
print(pattern.findall("555-1234 and 555-5678"))

// Named capture groups (ES2018+)
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = "2026-05-05".match(dateRegex);

if (match?.groups) {
  const { year, month, day } = match.groups;
  console.log(year, month, day); // "2026" "05" "05"
}

// Validate input before processing
function isValidSlug(s: string): boolean {
  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(s);
}

4 Common Regex Pitfalls

Most regex bugs fall into a small number of categories. Knowing these saves hours of debugging.

// Dangerous: (a+)+ on "aaaaaaaaaaaab"
// Safe alternative: use non-backtracking possessive quantifier or atomic group

// Wrong: /image.png/  — the dot matches ANY character
// Correct: /image\.png/

// Wrong: /\d{4}/.test("abc1234xyz") // true — found 4 digits inside
// Correct: /^\d{4}$/.test("1234")     // true — entire string is 4 digits

// JS supports lookbehind in modern engines: /(?<=@)\w+/
// But older JS engines don't — check compatibility

When to Use Regex (and When Not To)

Regex Flavors: Language Differences

Most regex patterns are portable across languages, but there are dialect differences worth knowing: