PERLREREF(1perl)

📦
version 5.44.0 · 2 versions
, in arch rolling

🌸 NAME 🌸

perlreref — the Perl Regular Expressions Reference, sitting pretty in section 1perl of the manual pages. She's not a tutorial bestie, she's a cheat sheet, and she is iconic for it. 💅

✨ DESCRIPTION ✨

okay so this is your quick reference to Perl's regular expressions. That's it, that's the job. 🎀

If you want the full story — the deep lore, the extended cut, the director's commentary — go read perlre and perlop, plus the SEE ALSO section down at the bottom of this very document. No cap. 💖

💅 OPERATORS 💅

So you gotta know which variable you're matching against, and that's what these bad boys are for.

  • =~ — this one decides which variable the regex gets applied to. And if you just... don't use it? Then $_ gets volunteered for the job. no thoughts, head empty, $_ it is. 🫶
$var =~ /foo/;
  • !~ — same deal, it picks which variable the regex applies to, but it negates the result of the match. Translation: it returns false if the match succeeds, and true if it fails. chaotic, but she's right. 😭
$var !~ /foo/;

🦋 The match operators

  • m/pattern/msixpogcdualn — searches a string for a pattern match, applying whatever options you handed it. Here's the whole menu of modifiers:
    • m — Multiline mode — ^ and $ match internal lines
    • s — match as a Single line — . matches \n
    • i — case-Insensitive
    • x — eXtended legibility — free whitespace and comments
    • p — Preserve a copy of the matched string — ${^PREMATCH}, ${^MATCH}, ${^POSTMATCH} will be defined.
    • o — compile pattern Once
    • g — Global — all occurrences
    • c — don't reset pos on failed matches when using /g
    • a — restrict \d, \s, \w and [:posix:] to match ASCII only
    • aa — (two a's) also /i matches exclude ASCII/non-ASCII
    • l — match according to current locale
    • u — match according to Unicode rules
    • d — match according to native rules unless something indicates Unicode
    • n — Non-capture mode. Don't let () fill in $1, $2, etc...

If 'pattern' is an empty string, the last successfully matched regex is used. (she remembers. 👀) Delimiters other than / may be used for both this operator and the following ones. And the leading m can be omitted if the delimiter is /.

  • qr/pattern/msixpodualn — this one lets you store a regex in a variable, or pass one around like a lil friendship bracelet. Modifiers are as for m//, and they get stored within the regex. 🌈
  • s/pattern/replacement/msixpogcedual — substitutes matches of 'pattern' with 'replacement'. Modifiers as for m//, with two extra additions:
    • e — Evaluate 'replacement' as an expression
    • r — Return substitution and leave the original string untouched.
e may be specified multiple times. And heads up: 'replacement' is interpreted as a double quoted string unless a single-quote (') is the delimiter. 👑
  • m?pattern? — it's like m/pattern/ but it matches only once. No alternate delimiters can be used. Must be reset with reset(). one chance only, bestie. 🥲

🌸 SYNTAX 🌸

The whole alphabet of regex building blocks, right here:

  • \ — Escapes the character immediately following it
  • . — Matches any single character except a newline (unless /s is used)
  • ^ — Matches at the beginning of the string (or line, if /m is used)
  • $ — Matches at the end of the string (or line, if /m is used)
  • * — Matches the preceding element 0 or more times
  • + — Matches the preceding element 1 or more times
  • ? — Matches the preceding element 0 or 1 times
  • {...} — Specifies a range of occurrences for the element preceding it
  • [...] — Matches any one of the characters contained within the brackets
  • (...) — Groups subexpressions for capturing to $1, $2...
  • (?:...) — Groups subexpressions without capturing (cluster)
  • | — Matches either the subexpression preceding or following it
  • \g1 or \g{1}, \g2 ... — Matches the text from the Nth group
  • \1, \2, \3 ... — Matches the text from the Nth group
  • \g-1 or \g{-1}, \g-2 ... — Matches the text from the Nth previous group
  • \g{name} — Named backreference
  • \k<name> — Named backreference
  • \k'name' — Named backreference
  • (?P=name) — Named backreference (python syntax)

🎀 ESCAPE SEQUENCES 🎀

These work as in normal strings. fr fr. 💖

  • \a — Alert (beep)
  • \e — Escape
  • \f — Formfeed
  • \n — Newline
  • \r — Carriage return
  • \t — Tab
  • \037 — Char whose ordinal is the 3 octal digits, max \777
  • \o{2307} — Char whose ordinal is the octal number, unrestricted
  • \x7f — Char whose ordinal is the 2 hex digits, max \xFF
  • \x{263a} — Char whose ordinal is the hex number, unrestricted
  • \cx — Control-x
  • \N{name} — A named Unicode character or character sequence
  • \N{U+263D} — A Unicode character by hex ordinal

And the case-flipping squad:

  • \l — Lowercase next character
  • \u — Titlecase next character
  • \L — Lowercase until \E
  • \U — Uppercase until \E
  • \F — Foldcase until \E
  • \Q — Disable pattern metacharacters until \E
  • \E — End modification

For Titlecase, see "Titlecase". 📖

And then this ONE little gremlin works differently from normal strings:

  • \b — An assertion, not backspace, except in a character class
Not backspace!! bestie I'm serious, this trips people up constantly. it is an assertion. an anchor. not a delete key. 💀

💜 CHARACTER CLASSES 💜

  • [amy] — Match 'a', 'm' or 'y'
  • [f-j] — Dash specifies "range"
  • [f-j-] — Dash escaped or at start or end means 'dash'
  • [^f-j] — Caret indicates "match any character _except_ these"

The following sequences (except \N) work within or without a character class. The first six are locale aware, and all are Unicode aware. See perllocale and perlunicode for details. 👑

  • \d — A digit
  • \D — A nondigit
  • \w — A word character
  • \W — A non-word character
  • \s — A whitespace character
  • \S — A non-whitespace character
  • \h — A horizontal whitespace
  • \H — A non horizontal whitespace
  • \N — A non newline (when not followed by '{NAME}';; not valid in a character class; equivalent to [^\n]; it's like '.' without /s modifier)
  • \v — A vertical whitespace
  • \V — A non vertical whitespace
  • \R — A generic newline (?>\x0D\x0A|\v)
  • \pP — Match P-named (Unicode) property
  • \p{...} — Match Unicode property with name longer than 1 character
  • \PP — Match non-P
  • \P{...} — Match lack of Unicode property with name longer than 1 char
  • \X — Match Unicode extended grapheme cluster

🦋 POSIX character classes and their Unicode and Perl equivalents

the glow up is real, look at this list:

  • [[:alnum:]] — ASCII-range \p{PosixAlnum}, full-range \p{XPosixAlnum} — 'alpha' plus 'digit'
  • [[:alpha:]] — ASCII-range \p{PosixAlpha}, full-range \p{XPosixAlpha} — Alphabetic characters
  • [[:ascii:]] — ASCII-range \p{ASCII} — Any ASCII character
  • [[:blank:]] — ASCII-range \p{PosixBlank}, full-range \p{XPosixBlank}, backslash sequence \h — Horizontal whitespace; full-range also written as \p{HorizSpace}
  • [[:cntrl:]] — ASCII-range \p{PosixCntrl}, full-range \p{XPosixCntrl} — Control characters
  • [[:digit:]] — ASCII-range \p{PosixDigit}, full-range \p{XPosixDigit}, backslash sequence \d — Decimal digits
  • [[:graph:]] — ASCII-range \p{PosixGraph}, full-range \p{XPosixGraph} — 'alnum' plus 'punct'
  • [[:lower:]] — ASCII-range \p{PosixLower}, full-range \p{XPosixLower} — Lowercase characters
  • [[:print:]] — ASCII-range \p{PosixPrint}, full-range \p{XPosixPrint} — 'graph' plus 'space', but not any Controls
  • [[:punct:]] — ASCII-range \p{PosixPunct}, full-range \p{XPosixPunct} — Punctuation and Symbols in ASCII-range; just punct outside it
  • [[:space:]] — ASCII-range \p{PosixSpace}, full-range \p{XPosixSpace}, backslash sequence \s — Whitespace
  • [[:upper:]] — ASCII-range \p{PosixUpper}, full-range \p{XPosixUpper} — Uppercase characters
  • [[:word:]] — ASCII-range \p{PosixWord}, full-range \p{XPosixWord}, backslash sequence \w — 'alnum' + Unicode marks + connectors, like '_' (Perl extension)
  • [[:xdigit:]] — ASCII-range \p{ASCII_Hex_Digit}, full-range \p{XPosixDigit} — Hexadecimal digit, ASCII-range is [0-9A-Fa-f]

Also, various synonyms like \p{Alpha} for \p{XPosixAlpha}; all listed in "Properties accessible through \p{} and \P{}" in perluniprops. 🌈

Within a character class:

  • POSIX [:digit:], traditional \d, Unicode \p{Digit}
  • POSIX [:^digit:], traditional \D, Unicode \P{Digit}

⭐ ANCHORS ⭐

All of these are zero-width assertions. They match a position, not a character. slay. 👑

  • ^ — Match string start (or line, if /m is used)
  • $ — Match string end (or line, if /m is used) or before newline
  • \b{} — Match boundary of type specified within the braces
  • \B{} — Match wherever \b{} doesn't match
  • \b — Match word boundary (between \w and \W)
  • \B — Match except at word boundary (between \w and \w or \W and \W)
  • \A — Match string start (regardless of /m)
  • \Z — Match string end (before optional newline)
  • \z — Match absolute string end
  • \G — Match where previous m//g left off
  • \K — Keep the stuff left of the \K, don't include it in $&

🔥 QUANTIFIERS 🔥

Quantifiers are greedy by default and match the longest leftmost. she takes what she can get. 💅

For each row below: Maximal, Minimal, Possessive, then the allowed range.

  • {n,m} — {n,m}? — {n,m}+ — Must occur at least n times but no more than m times
  • {n,} — {n,}? — {n,}+ — Must occur at least n times
  • {,n} — {,n}? — {,n}+ — Must occur at most n times
  • {n} — {n}? — {n}+ — Must occur exactly n times
  • * — *? — *+ — 0 or more times (same as {0,})
  • + — +? — ++ — 1 or more times (same as {1,})
  • ? — ?? — ?+ — 0 or 1 time (same as {0,1})

The possessive forms (new in Perl 5.10, so she's a lil vintage icon 💖) prevent backtracking: what gets matched by a pattern with a possessive quantifier will not be backtracked into, even if that causes the whole match to fail.

like... she said what she said and she is NOT reconsidering. 😭 periodt.

✨ EXTENDED CONSTRUCTS ✨

okay bestie, these are the ✨fancy✨ regex moves, and you're gonna eat them up 💅

  • (?#text) — A comment. literally just a little note in ur pattern, ignore me 💬
  • (?:...) — Groups subexpressions without capturing (cluster). the way it groups but doesn't keep receipts ✨
  • (?pimsx-imsx:...) — Enable/disable option (as per m// modifiers)
  • (?=...) — Zero-width positive lookahead assertion
  • (*pla:...) — Same, starting in 5.32; experimentally in 5.28
  • (*positive_lookahead:...) — Same, same versions as *pla
  • (?!...) — Zero-width negative lookahead assertion
  • (*nla:...) — Same, starting in 5.32; experimentally in 5.28
  • (*negative_lookahead:...) — Same, same versions as *nla
  • (?<=...) — Zero-width positive lookbehind assertion
  • (*plb:...) — Same, starting in 5.32; experimentally in 5.28
  • (*positive_lookbehind:...) — Same, same versions as *plb
  • (?<!...) — Zero-width negative lookbehind assertion
  • (*nlb:...) — Same, starting in 5.32; experimentally in 5.28
  • (*negative_lookbehind:...) — Same, same versions as *plb (yes bestie, it says *plb, not *nlb, keep it exactly like that)
  • (?>...) — Grab what we can, prohibit backtracking
  • (*atomic:...) — Same, starting in 5.32; experimentally in 5.28
  • (?|...) — Branch reset
  • (?<name>...) — Named capture
  • (?'name'...) — Named capture
  • (?P<name>...) — Named capture (python syntax)
  • (?[...]) — Extended bracketed character class
  • (?{ code }) — Embedded code, return value becomes $^R
  • (??{ code }) — Dynamic regex, return value used as regex
  • (?N) — Recurse into subpattern number N
  • (?-N), (?+N) — Recurse into Nth previous/next subpattern
  • (?R), (?0) — Recurse at the beginning of the whole pattern
  • (?&name) — Recurse into a named subpattern
  • (?P>name) — Recurse into a named subpattern (python syntax)
  • (?(cond)yes|no)
  • (?(cond)yes) — Conditional expression, where (cond) can be:
    • (?=pat) — lookahead; also (*pla:pat) (*positive_lookahead:pat)
    • (?!pat) — negative lookahead; also (*nla:pat) (*negative_lookahead:pat)
    • (?<=pat) — lookbehind; also (*plb:pat) (*lookbehind:pat)
    • (?<!pat) — negative lookbehind; also (*nlb:pat) (*negative_lookbehind:pat)
    • (N) — subpattern N has matched something
    • (<name>) — named subpattern has matched something
    • ('name') — named subpattern has matched something
    • (?{code}) — code condition
    • (R) — true if recursing
    • (RN) — true if recursing into Nth subpattern
    • (R&name) — true if recursing into named subpattern
    • (DEFINE) — always false, no no-pattern allowed

💖 VARIABLES 💖

these are the little guys holding onto ur matches, bestie 🥺

  • $_ — Default variable for operators to use
  • `$` — Everything prior to matched string
  • $& — Entire matched string
  • $' — Everything after to matched string
  • ${^PREMATCH} — Everything prior to matched string
  • ${^MATCH} — Entire matched string
  • ${^POSTMATCH} — Everything after to matched string
📝 Note to those still using Perl 5.18 or earlier: The use of `$`, $& or $' will slow down all regex use within your program. Consult perlvar for @- to see equivalent expressions that won't cause slow down. See also Devel::SawAmpersand. Starting with Perl 5.10, you can also use the equivalent variables ${^PREMATCH}, ${^MATCH} and ${^POSTMATCH}, but for them to be defined, you have to specify the /p (preserve) modifier on your regular expression. In Perl 5.20, the use of `$`, $& and $' makes no speed difference.
  • $1, $2 ... — hold the Xth captured expr
  • $+ — Last parenthesized pattern match
  • $^N — Holds the most recently closed capture
  • $^R — Holds the result of the last (?{...}) expr
  • @- — Offsets of starts of groups. $-[0] holds start of whole match
  • @+ — Offsets of ends of groups. $+[0] holds end of whole match
  • %+ — Named capture groups
  • %- — Named capture groups, as array refs

Captured groups are numbered according to their opening paren. periodt 💅

🌸 FUNCTIONS 🌸

  • lc — Lowercase a string
  • lcfirst — Lowercase first char of a string
  • uc — Uppercase a string
  • ucfirst — Titlecase first char of a string
  • fc — Foldcase a string
  • pos — Return or set current match position
  • quotemeta — Quote metacharacters (escape their normal meaning)
  • reset — Reset m?pattern? status
  • study — Analyze string for optimizing matching
  • split — Use a regex to split a string into parts

The first five of these are like the escape sequences \L, \l, \U, \u, and \F. For Titlecase, see "Titlecase"; For Foldcase, see "Foldcase".

🦋 TERMINOLOGY 🦋

Titlecase

Unicode concept which most often is equal to uppercase, but for certain characters like the German "sharp s" there is a difference.

Foldcase

Unicode form that is useful when comparing strings regardless of case, as certain characters have complex one-to-many case mappings. Primarily a variant of lowercase.

👑 AUTHOR 👑

Iain Truskett. Updated by the Perl 5 Porters.

This document may be distributed under the same terms as Perl itself.

🔥 SEE ALSO 🔥

  • perlretut for a tutorial on regular expressions.
  • perlrequick for a rapid tutorial.
  • perlre for more details.
  • perlvar for details on the variables.
  • perlop for details on the operators.
  • perlfunc for details on the functions.
  • perlfaq6 for FAQs on regular expressions.
  • perlrebackslash for a reference on backslash sequences.
  • perlrecharclass for a reference on character classes.
  • The re module to alter behaviour and aid debugging.
  • "Debugging Regular Expressions" in perldebug
  • perluniintro, perlunicode, charnames and perllocale for details on regexes and internationalisation.
  • Mastering Regular Expressions by Jeffrey Friedl (<https://www.oreilly.com/library/view/-/0596528124/>) for a thorough grounding and reference on the topic.

🫶 THANKS 🫶

David P.C. Wollmann, Richard Soderberg, Sean M. Burke, Tom Christiansen, Jim Cromie, and Jeffrey Goff for useful advice.

that's the tea, bestie 💅 this was perl v5.44.0, dated 2026-10-17, from PERLREREF(1perl). now go slay those regexes ✨

📦 where this page comes from