Regex Cheat Sheet: Riferimento completo per le espressioni regolari

Regular expressions (regex) are one of the most powerful tools in a developer's arsenal. Whether you are validating user input, parsing log files, or performing complex search-and-replace operations, regex gives you unmatched precision. This complete regex cheat sheet covers every major concept: anchors, character classes, quantifiers, groups, lookarounds, flags, and cross-language usage. Bookmark this page and refer to it whenever you need a quick refresher.

Try every pattern live in our Regex Tester ->

Basic Syntax: Anchors & Character Classes

Anchors and character classes form the foundation of every regex pattern. Anchors specify where in the string a match should occur. Character classes define what characters to match.

Anchors

Anchors do not match characters themselves; they match positions within the string.

Character Classes

Character classes let you match a set of characters in a single position.

Special Characters (Metacharacters)

These characters have special meaning in regex. To match them literally, escape them with a backslash.

Special characters that need escaping:
.  ^  $  *  +  ?  {  }  [  ]  \  |  (  )

To match a literal dot:   \.
To match a literal star:  \*
To match a literal pipe:  \|
To match a backslash:     \\

Quantifiers: How Many Times to Match

Quantifiers control how many times a preceding element must appear for a match. By default, quantifiers are greedy -- they match as much as possible. Appending ? makes them lazy (match as little as possible).

Greedy vs. Lazy Quantifiers

Consider the string <b>bold</b> and <i>italic</i>. A greedy pattern <.*> matches the entire string from the first < to the last >. The lazy version <.*?> matches only <b>, stopping at the first >.

// Input string:
const str = '<b>bold</b> and <i>italic</i>';

// Greedy: matches from first < to LAST >
str.match(/<.*>/);
// Result: '<b>bold</b> and <i>italic</i>'

// Lazy: matches from first < to FIRST >
str.match(/<.*?>/);
// Result: '<b>'

Groups & Capturing

Groups let you treat multiple characters as a single unit, apply quantifiers to sub-expressions, and extract matched portions.

Capturing Groups

Wrap a sub-expression in parentheses (...) to capture its match. You can reference captured groups with backreferences like \1, \2, etc.

// Capturing group example
const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
const match = '2026-02-10'.match(dateRegex);
// match[0] = '2026-02-10'  (full match)
// match[1] = '2026'        (year)
// match[2] = '02'          (month)
// match[3] = '10'          (day)

// Backreference: match repeated words
const repeated = /\b(\w+)\s+\1\b/;
repeated.test('the the');  // true
repeated.test('the cat');  // false

Named Groups

Named groups improve readability. In JavaScript and Python, use (?<name>...) syntax.

// Named groups in JavaScript
const dateRegex = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/;
const match = '2026-02-10'.match(dateRegex);
// match.groups.year  = '2026'
// match.groups.month = '02'
// match.groups.day   = '10'

# Named groups in Python
import re
pattern = r'^(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})$'
m = re.match(pattern, '2026-02-10')
# m.group('year')  = '2026'
# m.group('month') = '02'
# m.group('day')   = '10'

Non-Capturing Groups

Use (?:...) when you need grouping but do not need to capture the match. This is more efficient for complex patterns.

// Non-capturing group
const regex = /(?:https?|ftp):\/\/[^\s]+/;
// Groups the protocol options without capturing them
// Only the full URL is in match[0]

Alternation (OR)

Use the pipe | inside a group to match one of several alternatives.

// Alternation examples
/cat|dog/           // Match "cat" or "dog"
/(red|blue) car/    // Match "red car" or "blue car"
/^(GET|POST|PUT|DELETE)\s/  // Match HTTP methods

Lookahead & Lookbehind (Zero-Width Assertions)

Lookarounds assert that a certain pattern exists (or does not exist) ahead of or behind the current position, without consuming characters. This makes them incredibly powerful for complex matching conditions.

Positive Lookahead (?=...)

Matches a position that is followed by the specified pattern.

// Match a number followed by "px"
/\d+(?=px)/
// "20px 30em 40px" → matches "20" and "40" (not "30")

// Password: must contain at least one digit
/^(?=.*\d).{8,}$/

Negative Lookahead (?!...)

Matches a position that is not followed by the specified pattern.

// Match "cat" NOT followed by "fish"
/cat(?!fish)/
// "catfish catdog" → matches "cat" in "catdog" only

// Match numbers NOT followed by a unit
/\d+(?!\s*(px|em|rem|%))/

Positive Lookbehind (?<=...)

Matches a position that is preceded by the specified pattern.

// Match a number preceded by "$"
/(?<=\$)\d+(\.\d{2})?/
// "$49.99 and €29.99" → matches "49.99" only

// Extract value after "price:"
/(?<=price:\s*)\d+/

Negative Lookbehind (?<!...)

Matches a position that is not preceded by the specified pattern.

// Match "cat" NOT preceded by "wild"
/(?<!wild)cat/
// "wildcat housecat" → matches "cat" in "housecat" only

// Match digits not preceded by a minus sign
/(?<!-)\b\d+\b/

Note: Lookbehinds have limited support in some regex engines. JavaScript (ES2018+) supports them, but older engines may not. Python and Go support lookbehinds with fixed-length patterns.

Regex Flags (Modifiers)

Flags modify how the regex engine interprets the pattern. They are placed after the closing delimiter (e.g., /pattern/gi in JavaScript) or passed as arguments in functions.

// Combining flags
const regex = /^hello world$/gim;

// In Python, flags are constants:
import re
pattern = re.compile(r'^hello world$', re.IGNORECASE | re.MULTILINE)

// In Go, use inline flags:
// (?i) for case-insensitive, (?m) for multiline, (?s) for dotall
regexp.MustCompile("(?im)^hello world$")

Common Patterns Quick Reference

Here are the most frequently needed regex patterns. Test any of them in our regex tester tool.

Test all these patterns live with our Regex Tester ->

Regex in Different Programming Languages

While regex syntax is largely universal, each language has its own API for creating, testing, and applying patterns. Here are the key differences.

JavaScript

// Creating regex in JavaScript
const regex1 = /^\d+$/;             // Literal syntax
const regex2 = new RegExp('^\\d+$'); // Constructor (needs double-escape)

// Testing
regex1.test('12345');                // true

// Matching
'hello world'.match(/\w+/g);        // ['hello', 'world']

// Replacing
'2026-02-10'.replace(
  /^(\d{4})-(\d{2})-(\d{2})$/,
  '$2/$3/$1'
);  // '02/10/2026'

// matchAll (ES2020) - get all matches with groups
const text = 'Price: $10, Tax: $2';
for (const m of text.matchAll(/\$(\d+)/g)) {
  console.log(m[0], m[1]);
  // '$10' '10', then '$2' '2'
}

// Named groups (ES2018+)
const { groups } = '2026-02-10'.match(
  /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
);
console.log(groups.year);  // '2026'

Python

import re

# Compile for reuse (recommended)
pattern = re.compile(r'^\d+$')

# Test if the entire string matches
pattern.match('12345')      # Match object (truthy)
pattern.match('abc')        # None (falsy)

# Search anywhere in the string
re.search(r'\d+', 'abc 123 def')  # Finds '123'

# Find all matches
re.findall(r'\w+', 'hello world')  # ['hello', 'world']

# Replace
re.sub(
    r'^(\d{4})-(\d{2})-(\d{2})$',
    r'\2/\3/\1',
    '2026-02-10'
)  # '02/10/2026'

# Named groups
m = re.match(
    r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
    '2026-02-10'
)
m.group('year')   # '2026'
m.group('month')  # '02'

# Flags
re.findall(r'^start', text, re.MULTILINE | re.IGNORECASE)

# Split by pattern
re.split(r'[,;\s]+', 'a, b; c  d')  # ['a', 'b', 'c', 'd']

Go (Golang)

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // Compile (panics on invalid pattern)
    re := regexp.MustCompile(`^\d+$`)

    // Test
    fmt.Println(re.MatchString("12345"))  // true
    fmt.Println(re.MatchString("abc"))    // false

    // Find first match
    re2 := regexp.MustCompile(`\d+`)
    fmt.Println(re2.FindString("abc 123 def"))  // "123"

    // Find all matches
    fmt.Println(re2.FindAllString("10 cats and 20 dogs", -1))
    // ["10", "20"]

    // Replace
    re3 := regexp.MustCompile(`(\d{4})-(\d{2})-(\d{2})`)
    result := re3.ReplaceAllString("2026-02-10", "$2/$3/$1")
    fmt.Println(result)  // "02/10/2026"

    // Named groups
    re4 := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
    match := re4.FindStringSubmatch("2026-02-10")
    for i, name := range re4.SubexpNames() {
        if name != "" {
            fmt.Printf("%s: %s\n", name, match[i])
        }
    }
    // year: 2026, month: 02, day: 10

    // Inline flags: (?i) case-insensitive, (?m) multiline, (?s) dotall
    re5 := regexp.MustCompile(`(?i)hello`)
    fmt.Println(re5.MatchString("HELLO"))  // true
}

Go uses the RE2 engine, which does not support lookaheads, lookbehinds, or backreferences. This is a deliberate design decision for guaranteed linear-time matching.

Performance Tips & Best Practices

Be specific: Use [a-zA-Z] instead of . when you know what characters to expect. Specific patterns are faster and less error-prone.

Avoid catastrophic backtracking: Nested quantifiers like (a+)+ can cause exponential time complexity. Use atomic groups or possessive quantifiers where available.

// BAD: Catastrophic backtracking risk
const bad = /^(a+)+$/;
bad.test('aaaaaaaaaaaaaaaaaaaaa!');  // Extremely slow!

// GOOD: Flatten nested quantifiers
const good = /^a+$/;
good.test('aaaaaaaaaaaaaaaaaaaaa!'); // Instant: false

Use non-capturing groups: When you do not need to extract matched text, use (?:...) instead of (...) to improve performance.

Compile once, use many: In languages like Python and Go, compile your regex once and reuse the compiled object for better performance.

# Python: compile once, reuse many times
import re
email_re = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')

# Fast: uses pre-compiled pattern
for addr in addresses:
    if email_re.match(addr):
        print(f"Valid: {addr}")

Test incrementally: Build complex patterns step by step. Test each part individually before combining them.

Try every pattern live in our Regex Tester ->