JavaScript Regular Expressions

What You’ll Learn

Regular expressions power search, validation, and text cleanup across JavaScript apps. This hub links to 44 RegExp tutorials — from exec() and test() through character classes, quantifiers, anchors, and flags.

Introduction

A regular expression (regex) is a compact language for describing text patterns. In JavaScript, patterns live in RegExp objects. You use them to validate emails, extract numbers, strip HTML tags, or find every word in a paragraph.

What Are Regular Expressions?

Regex combines literal characters (match exactly) with special tokens like \d (digit), + (one or more), and [a-z] (character range). The engine scans a string left to right and reports whether — and where — the pattern matched.

Two Ways to Create a RegExp

• Literal — /pattern/flags when the pattern is fixed in source code.
• Constructor — new RegExp("pattern", "flags") when the pattern comes from user input or variables.
• String methods — str.match(), str.replace(), and str.search() accept regex too.

Pattern Building Blocks

• Character classes — [0-9], [a-z], [^abc] (negated).
• Metacharacters — \d, \w, \s, . (wildcard).
• Quantifiers — ?, +, *, {2,5} control repetition.
• Groups — (abc) capture parts; (a|b) alternation.
• Flags — g global, i ignore case, m multiline.

📝 Syntax

Create a regex and test a string:

const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
const ok = email.test("ada@example.com");

const digits = /\d+/g;
const found = "Order 42 and 7".match(digits); // ["42", "7"]

Common RegExp methods

When to Use Regular Expressions

• Form validation — emails, phone numbers, postal codes (combine with anchors).
• Search & replace — normalize whitespace, strip tags, redact tokens.
• Parsing logs — extract timestamps, IDs, and status codes from lines.
• Tokenizing — split on delimiters with str.split(/[,;]+/).
• When not to use regex — HTML/XML parsing, full email RFC compliance, or nested structures — reach for dedicated parsers instead.

Examples Gallery

Open DevTools Console (F12) and paste each snippet to see regex in action.

const greeting = "Hello World";
const regex = /hello/i;

console.log(regex.test(greeting)); // true

true

const pin = "482910";
const onlyDigits = /^\d+$/;

console.log(onlyDigits.test(pin));      // true
console.log(onlyDigits.test("48a2"));   // false

true
false

const line = "Contact: ada@example.com today";
const email = /(\w+)@([\w.]+)/;
const m = email.exec(line);

console.log(m[0]); // full match
console.log(m[1]); // ada
console.log(m[2]); // example.com

ada@example.com
ada
example.com

const card = "4111-2222-3333-4444";
const masked = card.replace(/\d/g, "*");

console.log(masked);

****-****-****-****

const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

console.log(emailPattern.test("user@mail.com"));  // true
console.log(emailPattern.test("not-an-email"));   // false

true
false

💬 Usage Tips

• Anchor whole fields — use ^ and $ in validation so abc123 does not pass a digits-only rule.
• Prefer literals for fixed patterns — /\d+/ is clearer than new RegExp("\\d+").
• Escape user input — when building new RegExp from variables, escape metacharacters first.
• Reset lastIndex — global regexes remember position; set regex.lastIndex = 0 before reusing.
• Search this index — jump to any of 44 tutorials above.

⚠️ Common Pitfalls

• Greedy quantifiers — .* may swallow too much; use non-greedy .*? when needed.
• Missing anchors — /\d+/ matches a substring; /^\d+$/ validates the whole value.
• Global flag side effects — test() and exec() advance lastIndex on /g regexes.
• Overly complex patterns — split into named steps or use a parser for nested data (JSON, HTML).
• Octal escapes — \123 can be ambiguous; prefer \xHH or \uXXXX.

💡 Best Practices