What is a regular expression (regex)?

A regular expression is a compact syntax for describing patterns in text. You use it to search, validate, extract, and replace substrings. Common tokens include character classes like d for digits, quantifiers like + for "one or more", and anchors like ^ and $ for start and end of a string.

What regex flavor does this cheat sheet cover?

The cheat sheet focuses on the syntax shared by most modern engines including JavaScript (ECMAScript), Python (re), PCRE, and Java. Tokens such as named groups, lookbehind, and the s (dotall) flag are supported in current evergreen browsers and recent language versions. Always test your pattern against your target engine if you target legacy runtimes.

How is this different from a regex tester?

A regex tester lets you type a pattern and a test string and see live matches. This cheat sheet is a reference: it explains what each token means and gives an example, so you can quickly look up or learn syntax. Use it together with a tester — copy a token here, then refine and test it in a regex tester.

Does the cheat sheet work offline?

Yes. The entire cheat sheet runs in your browser with no network requests. Once the page is loaded, search, copy, and browse all work fully offline, making it reliable even without an internet connection.

Regex Cheat Sheet

Free interactive regex cheat sheet. Search and copy regular expression syntax including anchors, character classes, quantifiers, groups, lookarounds, flags, and common patterns. Bilingual EN/TH with live examples. 100% client-side and offline.

Loading tool...

What is Regex Cheat Sheet?

The Regex Cheat Sheet is a free, browser-based interactive reference for regular expression syntax. Instead of flipping between documentation pages or memorizing tokens, you get a single searchable page covering anchors, character classes, quantifiers, groups, alternation, lookaround, escaped characters, flags, and common real-world patterns. Each entry explains what a token does in plain language and shows a copy-ready example, so you can learn regex or quickly look up a forgotten symbol. Everything runs locally in your browser with no data sent anywhere.

Key Benefits

All core regex concepts organized into nine clear categories, so you find the right token without context switching
Instant fuzzy search across syntax, descriptions, and examples, faster than scrolling a static reference
One-click copy for every token lets you paste directly into your editor, terminal, or regex tester
Bilingual EN/TH content makes the reference accessible to both native and non-native English developers
Includes curated common patterns such as email, URL, IPv4, ISO date, hex color, and HTML tag pairs

Common Use Cases

•Look up a regex token you forgot while writing a validation, parser, or search feature
•Learn regular expressions from scratch by browsing organized categories with plain-language explanations
•Quickly grab a common pattern such as an email or URL regex instead of reinventing it
•Copy syntax into a regex tester or code snippet without retyping from documentation
•Teach or onboard teammates to regex using a bilingual, scannable reference

How to Use the Regex Cheat Sheet

Search or Browse: Type a keyword in the search box (such as "digit", "anchor", or "+") to filter instantly, or scroll through the nine organized categories to browse all available syntax.
Read the Explanation: Each entry shows a plain-language description of what the regex token does, so you understand the behavior and any flag dependencies (such as m, s, or u) before using it.
Check the Example: Every entry includes a concrete example showing sample input and the expected match, helping you confirm the token is the right fit for your pattern.
Copy the Syntax: Click the Copy button next to any entry to copy the regex token to your clipboard, then paste it straight into your code, editor, or regex tester.

Key Features

Nine organized categories covering anchors, character classes, quantifiers, groups, alternation, lookaround, escapes, flags, and common patterns
Instant fuzzy search across syntax tokens, descriptions, and examples with live filtering as you type
One-click copy for every regex syntax entry so you can paste straight into your editor or regex tester
Bilingual EN/TH explanations and examples, displayed automatically based on your selected locale
Common real-world patterns included such as email, URL, IPv4, ISO date, hex color, and HTML tag pairs
100% client-side and offline with no API calls, no tracking, and no signup required

Frequently Asked Questions

In-depth guide

Regex Cheat Sheet: The Interactive Regular Expression Reference You Will Actually Use

Read the full guide →

Regex Cheat Sheet

Anchors & Boundaries

^abc

Matches "abc" at the start of a string (or line with m flag).

Example: ^Hello → matches in "Hello world"

abc$

Matches "abc" at the end of a string (or line with m flag).

Example: world$ → matches in "Hello world"

\b

Word boundary — position between a word char and a non-word char.

Example: \bcat\b → matches "cat" but not "category"

\B

Non-word boundary — opposite of \b.

Example: \Bcat → matches "cat" in "concatenate"

\A

Matches only at the absolute start of the string (not affected by m flag).

Example: \AStart → matches at the very beginning

\z

Matches only at the absolute end of the string (not affected by m flag).

Example: End\z → matches at the very end

Character Classes

.

Matches any single character except newline (with s flag, also matches newline).

Example: a.c → matches "abc", "a1c", "a c"

\d

Matches any digit (0–9). Equivalent to [0-9].

Example: \d{3} → matches "123" in "Order 12345"

\D

Matches any non-digit character. Equivalent to [^0-9].

Example: \D → matches "a", "!", space

\w

Matches any word character (letters, digits, underscore). Equivalent to [a-zA-Z0-9_].

Example: \w+ → matches "hello_123"

\W

Matches any non-word character. Equivalent to [^a-zA-Z0-9_].

Example: \W → matches "@", "#", space

\s

Matches any whitespace (space, tab, newline, etc.).

Example: \s+ → matches spaces between words

\S

Matches any non-whitespace character.

Example: \S+ → matches "Hello" in " Hello "

[abc]

Character set — matches any one of the listed characters.

Example: [aeiou] → matches any vowel

[^abc]

Negated character set — matches any character NOT listed.

Example: [^0-9] → matches any non-digit

[a-z]

Character range — matches any character in the specified range.

Example: [a-zA-Z] → matches any ASCII letter

Quantifiers

*

Matches the preceding element zero or more times.

Example: ab*c → matches "ac", "abc", "abbbc"

+

Matches the preceding element one or more times.

Example: ab+c → matches "abc", "abbbc" but not "ac"

?

Matches the preceding element zero or one time (optional).

Example: colou?r → matches "color" and "colour"

{n}

Matches the preceding element exactly n times.

Example: \d{4} → matches exactly 4 digits

{n,}

Matches the preceding element n or more times.

Example: \d{2,} → matches 2 or more digits

{n,m}

Matches the preceding element between n and m times.

Example: \d{2,4} → matches 2 to 4 digits

*?

Lazy (non-greedy) quantifier — matches as few as possible.

Example: a.*?b → matches shortest "a...b"

*+

Possessive quantifier — matches as much as possible without backtracking.

Example: a*+ → greedy without giving back

Groups & Backreferences

(abc)

Capturing group — groups and remembers the match for backreferences.

Example: (\d+)-(\d+) → two capture groups

(?:abc)

Non-capturing group — groups without creating a capture.

Example: (?:ab)+ → matches "ab", "abab"

(?<name>abc)

Named capturing group — captures the match under a name.

Example: (?<year>\d{4}) → reference by name

\1

Backreference — matches the same text as the Nth capturing group.

Example: (\w+)\s\1 → matches "the the"

\k<name>

Named backreference — matches the same text as a named group.

Example: (?<x>\w+)\s\k<x> → repeated word

Alternation

a|b

Matches either "a" or "b" (logical OR).

Example: cat|dog → matches "cat" or "dog"

(?:a|b)c

Group alternation — use groups to limit the scope of |.

Example: (?:Mr|Mrs|Ms)\. → titles

Lookaround (Assertions)

a(?=b)

Positive lookahead — matches "a" only if followed by "b".

Example: \d(?=px) → digit before "px"

a(?!b)

Negative lookahead — matches "a" only if NOT followed by "b".

Example: \d(?!px) → digit NOT before "px"

(?<=a)b

Positive lookbehind — matches "b" only if preceded by "a".

Example: (?<=\$)\d → digit after "$"

(?<!a)b

Negative lookbehind — matches "b" only if NOT preceded by "a".

Example: (?<!\$)\d → digit NOT after "$"

Escaped & Special Characters

\.

Escaped dot — matches a literal period (not "any char").

Example: example\.com → literal ".com"

\*

Escaped asterisk — matches a literal * character.

Example: \*\*bold\*\* → literal **bold**

\n

Matches a newline (line feed) character.

Example: \n → line break

\t

Matches a horizontal tab character.

Example: \t → tab character

\r

Matches a carriage return character.

Example: \r\n → Windows line ending

\x41

Matches a character by its hexadecimal code point (41 = "A").

Example: \x41 → matches "A"

\u0041

Matches a Unicode character by 4-digit hex code (0041 = "A").

Example: \u00e9 → matches "é"

Flags

g

Global — find all matches, not just the first.

Example: /cat/g → all "cat" occurrences

i

Case-insensitive — ignores letter case.

Example: /cat/i → matches "Cat", "CAT"

m

Multiline — ^ and $ match at every line, not just string boundaries.

Example: /^cat/m → "cat" at line start

s

Dotall — the dot . matches newline characters too.

Example: /a.b/s → matches "a\nb"

u

Unicode — treat the pattern as Unicode code points.

Example: /\u{1F600}/u → emoji support

y

Sticky — match only at lastIndex (no skipping characters).

Example: /abc/y → exact position match

Common Patterns

[\w.+-]+@[\w-]+\.[\w.]+

Basic email pattern — matches most common email formats.

Example: Matches "[email protected]"

https?://[\w.-]+

Basic URL pattern — matches http and https URLs.

Example: Matches "https://example.com"

\d{1,3}(?:\.\d{1,3}){3}

IPv4 address pattern — matches dotted-quad addresses.

Example: Matches "192.168.1.1"

\b\d{4}-\d{2}-\d{2}\b

ISO date pattern — matches YYYY-MM-DD format.

Example: Matches "2026-08-02"

#?[0-9a-fA-F]{6}

Hex color code — matches 6-digit hex with optional #.

Example: Matches "#FF5733"

<\w+>[^<]*</\1>

Simple HTML tag pair — matches an opening and closing tag.

Example: Matches "<b>text</b>"

About Regex Cheat Sheet

A searchable, interactive reference for regular expression syntax. Browse anchors, character classes, quantifiers, groups, lookarounds, flags, and common patterns — each with a plain-language explanation and a copy-ready example. Whether you are learning regex or need a quick lookup while coding, this cheat sheet keeps every token at your fingertips.

Why Use This Cheat Sheet

•Covers all core regex concepts in one place — anchors, classes, quantifiers, groups, assertions, and flags — so you never have to context-switch between documentation tabs.
•Live search filters syntax, descriptions, and examples instantly, making it faster than scrolling a static reference.
•Every entry includes a copy-to-clipboard button, so you can paste the exact token straight into your editor or regex tester.
•Bilingual explanations (English and Thai) help both native and non-native English developers understand each pattern without translation friction.
•Works fully offline in your browser — no API calls, no tracking, no signup required.

Features

✓Nine organized categories covering anchors, character classes, quantifiers, groups, alternation, lookaround, escapes, flags, and common patterns.
✓Instant fuzzy search across syntax tokens, descriptions, and examples.
✓One-click copy for every regex syntax entry.
✓Bilingual EN/TH content with locale-aware display.
✓100% client-side and offline — your queries never leave the browser.