RegEX Commands Cheat Sheet

Cheat

RegEX Basics

Character Classes

[abc]

A single character of: a, b or c

[^abc]

A character except: a, b or c

[a-z]

A character in the range: a-z

[^a-z]

A character not in the range: a-z

[0-9]

A digit in the range: 0-9

[a-zA-Z]

A character in the range: a-z or A-Z

[a-zA-Z0-9]

A character in the range: a-z, A-Z or 0-9

Quantifiers

Zero or one of a

Zero or more of a

One or more of a

[0-9]+

One or more of 0-9

a{3}

Exactly 3 of a

a{3,}

3 or more of a

a{3,6}

Between 3 and 6 of a

Greedy quantifier

a*?

Lazy quantifier

a*+

Possessive quantifier

Meta Sequences

Any single character

Any whitespace character

Any non-whitespace character

Any digit, Same as [0-9]

Any non-digit, Same as [^0-9]

Any word character

Any non-word character

Any Unicode sequences, linebreaks included

Match one data unit

Unicode newlines

Vertical whitespace character

Negation of \v - anything except newlines and vertical tabs

Horizontal whitespace character

Negation of \h

Reset match

Match nth subpattern

\pX

Unicode property X

\p{...}

Unicode property or script category

\PX

Negation of \pX

\P{...}

Negation of \p

\Q...\E

Quote; treat as literals

Match subpattern name

\k'name'

Match subpattern name

\k{name}

Match subpattern name

\gn

Match nth subpattern

\g{n}

Match nth subpattern

Recurse nth capture group

\g'n'

Recurses nth capture group.

\g{-n}

Match nth relative previous subpattern

\g<+n>

Recurse nth relative upcoming subpattern

\g'+n'

Match nth relative upcoming subpattern

\g'letter'

Recurse named capture group letter

\g{letter}

Match previously-named capture group letter

Recurses named capture group letter

\xYY

Hex character YY

\x{YYYY}

Hex character YYYY

\ddd

Octal character ddd

\cY

Control character Y

[\b]

Backspace character

Makes any character literal

Anchors

Start of match

Start of string

End of string

Start of string

End of string

Absolute end of string

A word boundary

Non-word boundary

Substitution

Complete match contents

Contents in capture group 1

${foo}

Contents in capture group foo

\x20

Hexadecimal replacement values

\x{06fa}

Hexadecimal replacement values

Tab

Carriage return

Newline

Form-feed

Uppercase Transformation

Lowercase Transformation

Terminate any Transformation

Group Constructs

(...)

Capture everything enclosed

(a|b)

Match either a or b

(?:...)

Match everything enclosed

(?>...)

Atomic group (non-capturing)

(?|...)

Duplicate subpattern group number

(?#...)

Comment

(?'name'...)

Named Capturing Group

(?...)

Named Capturing Group

(?P...)

Named Capturing Group

(?imsxXU)

Inline modifiers

(?(DEFINE)...)

Pre-define patterns before using them

Assertions

(?(1)yes|no)

Conditional statement

(?(R)yes|no)

Conditional statement

(?(R#)yes|no)

Recursive Conditional statement

(?(R&name)yes|no)

Conditional statement

(?(?=...)yes|no)

Lookahead conditional

(?(?<=...)yes|no)

Lookbehind conditional

Lookarounds

(?=...)

Positive Lookahead

(?!...)

Negative Lookahead

(?<=...)

Positive Lookbehind

(?<!...)

Negative Lookbehind

Lookaround lets you match a group before (lookbehind) or after (lookahead) your main pattern without including it in the result.

Flags/Modifiers

Global

Multiline

Case insensitive

Ignore whitespace

Single line

Unicode

eXtended

Ungreedy

Anchor

Duplicate group names

Recurse

(?R)

Recurse entire pattern

(?1)

Recurse first subpattern

(?+1)

Recurse first relative subpattern

(?&name)

Recurse subpattern name

(?P=name)

Match subpattern name

(?P>name)

Recurse subpattern name

POSIX Character Classes

Character Class

Same as

Meaning

[[:alnum:]]

[0-9A-Za-z]

Letters and digits

[[:alpha:]]

[A-Za-z]

Letters

[[:ascii:]]

[\x00-\x7F]

ASCII codes 0-127

[[:blank:]]

[\t ]

Space or tab only

[[:cntrl:]]

[\x00-\x1F\x7F]

Control characters

[[:digit:]]

[0-9]

Decimal digits

[[:graph:]]

[[:alnum:][:punct:]]

Visible characters (not space)

[[:lower:]]

[a-z]

Lowercase letters

[[:print:]]

[ -~] == [ [:graph:]]

Visible characters

[[:punct:]]

[!"#$%&’()*+,-./:;<=>?@[]^_`{|}~]

Visible punctuation characters

[[:space:]]

[\t\n\v\f\r ]

Whitespace

[[:upper:]]

[A-Z]

Uppercase letters

[[:word:]]

[0-9A-Za-z_]

Word characters

[[:xdigit:]]

[0-9A-Fa-f]

Hexadecimal digits

[[:<:]]

[\b(?=\w)]

Start of word

[[:>:]]

[\b(?<=\w)]

End of word

Windows CMD Cheat Sheet

What is a RegEX Cheat Sheet?

A RegEx, short for Regular Expression, is a sequence of characters that form a search pattern. This search pattern can be used in string searching algorithms, find or find and replace operations, input validations, and more. They are very powerful tools in text processing and are incorporated in many programming languages including Java, JavaScript, Python, Perl, and more.
Here is an outline of the main categories or groupings of Regular Expressions commands:

Metacharacters: Special characters like `.` (any character), `^` (starts with), `$` (ends with), `*` (zero or more), and others that have specific functions.
Special Sequences: Begin with a backslash followed by a character (like `\d` for digits, `\s` for whitespace), having a unique meaning.
Sets: Represent a set of characters inside square brackets, defining a range or a specific set of allowable characters (like `[a-z], [A-Z], [0-9])`.
Quantifiers: Define quantity such as `*` (0 or more), + (1 or more), `?` (0 or 1),` {n}` (exactly n), `{n,}` (n or more), `{n,m}` (between n and m).
Groups and Ranges: Use `()` for groups, `|` for OR, `[]` for character set, - for range, and `[^]` for negation.

Regular Expressions (RegEx) in 100 Seconds

When debugging, novices insert corrective code; experts remove defective code.
Richard Pattis