Mastering Regular Expressions: Essential Rules and Advanced Techniques

What Is a Regular Expression

A regular expression uses a string pattern to describe a characteristic and then tests whether another string matches that characteristic, such as

s.match("a")

. It can validate strings, search within text, and perform flexible replacements.

Basic Rules

Literal Characters

Letters, digits, Chinese characters, underscores, and punctuation that have no special meaning match themselves; e.g., the pattern

a

matches the first "a" in "abcde".

Escape Characters

Special characters are escaped with a backslash, e.g.,

\r

(carriage return),

\n

(newline),

\t

(tab),

\\

(a literal backslash). Other symbols like

\^

,

\$

,

\.

also need escaping.

Character Classes

\d

: any digit (0‑9)

\w

: any word character (letters, digits, underscore)

\s

: any whitespace character

.

: any character except a newline

Custom classes can be defined with brackets, e.g.,

[123]

matches "1", "2" or "3";

[^abc]

matches any character except "a", "b", or "c".

Quantifiers

{n}

: exactly n repetitions

{m,n}

: between m and n repetitions

{m,}

: at least m repetitions

?

: 0 or 1 time

+

: 1 or more times

*

: 0 or more times

Special Symbols

^

: start of a string (or line in multiline mode)

$

: end of a string (or line in multiline mode)

\b

: word boundary

|

: alternation (OR)

( )

: grouping, also captures matched substrings

Advanced Rules

Greedy vs. Lazy Matching

Quantifiers are greedy by default, matching as much as possible. Adding

?

after a quantifier makes it lazy, matching as little as needed.

Backreferences

Parenthesized sub‑expressions are stored and can be referenced later with

\1

,

\2

, etc., enabling patterns like

(['"]).*?\1

to match quoted strings.

Lookahead and Lookbehind

Positive lookahead

(?=pattern)

asserts that

pattern

follows without consuming characters; negative lookahead

(?!pattern)

asserts that it does not. Similarly,

(?<=pattern)

and

(?<!pattern)

are lookbehind assertions.

Tips

Use

^

and

$

to anchor a pattern to the whole string.

Use

\b

to match whole words.

Avoid patterns that can match an empty string to prevent infinite loops.

Ensure alternation operators

|

are placed so only one side can match a given character.

Choose greedy or lazy quantifiers appropriately for the desired match.

Source: Backend Technology Talk, author: 飒然Hang