perlre - Online sa Cloud

PROGRAMA:

NAME

perlre - Perl na mga regular na expression

DESCRIPTION

Inilalarawan ng page na ito ang syntax ng mga regular na expression sa Perl.

Kung hindi ka pa nakagamit ng mga regular na expression dati, available ang isang quick-start na panimula sa
perlrequick, at ang isang mas mahabang panimula ng tutorial ay magagamit sa perlretut.

Para sa sanggunian kung paano ginagamit ang mga regular na expression sa pagtutugma ng mga operasyon, kasama ang iba't ibang
mga halimbawa ng pareho, tingnan ang mga talakayan ng "m//", "s///", "qr//" at "??" sa "Regexp Quote-
Tulad ng mga Operator" sa perlop.

Bago sa v5.22, ang "use re 'strict'" ay naglalapat ng mas mahigpit na panuntunan kaysa sa kung hindi man kapag nag-compile
mga pattern ng regular na expression. Makakahanap ito ng mga bagay na, bagama't legal, ay maaaring hindi kung ano sa iyo
nilayon.

Mga Modifier
Pangkalahatang-ideya

Ang mga pagpapatakbo ng pagtutugma ay maaaring magkaroon ng iba't ibang mga modifier. Mga modifier na nauugnay sa
interpretasyon ng regular na expression sa loob ay nakalista sa ibaba. Mga modifier na nagbabago
ang paraan ng paggamit ng isang regular na expression ng Perl ay nakadetalye sa "Regexp Quote-Like Operators"
sa perlop at "Gory na mga detalye ng pag-parse ng mga naka-quote na konstruksyon" sa perlop.

m Tratuhin ang string bilang maraming linya. Iyon ay, baguhin ang "^" at "$" mula sa pagtutugma sa simula
ng unang linya ng string at ang dulo ng huling linya nito upang tumugma sa simula at pagtatapos
ng bawat linya sa loob ng string.

s Tratuhin ang string bilang isang linya. Ibig sabihin, baguhin "." upang tumugma sa anumang karakter kahit ano pa man,
kahit isang bagong linya, na karaniwang hindi ito magkatugma.

Ginagamit nang magkasama, bilang "/ms", hinahayaan nila ang "." tumugma sa anumang karakter kahit ano pa man, habang wala pa
na nagpapahintulot sa "^" at "$" na tumugma, ayon sa pagkakabanggit, pagkatapos lamang at bago ang mga bagong linya
sa loob ng string.

i Gumawa ng case-insensitive na pagtutugma ng pattern.

Kung ang mga panuntunan sa pagtutugma ng lokal ay may bisa, ang mapa ng kaso ay kinuha mula sa kasalukuyang lokal
para sa mga code point na mas mababa sa 255, at mula sa Unicode rules para sa mas malalaking code point.
Gayunpaman, ang mga tugma na lalampas sa hangganan ng mga panuntunan ng Unicode/hindi Unicode na panuntunan (ords
255/256) ay hindi magtatagumpay. Tingnan ang perllocale.

Mayroong ilang mga Unicode na character na tumutugma sa maraming mga character sa ilalim ng "/i".
Halimbawa, dapat tumugma ang "LATIN SMALL LIGATURE FI" sa sequence na "fi". Si Perl ay hindi
kasalukuyang nagagawa ito kapag ang maramihang mga character ay nasa pattern at ay
hatiin sa pagitan ng mga pagpapangkat, o kapag ang isa o higit pa ay binibilang. Sa gayon

"\N{LATIN MALIIT NA LIGATURE FI}" =~ /fi/i; # Mga tugma
"\N{LATIN MALIIT NA LIGATURE FI}" =~ /[fi][fi]/i; # Hindi tugma!
"\N{LATIN MALIIT NA LIGATURE FI}" =~ /fi*/i; # Hindi tugma!

# Ang nasa ibaba ay hindi tumutugma, at hindi malinaw kung ano ang gagawin ng $1 at $2
# maging kahit na!!
"\N{LATIN SMALL LIGATURE FI}" =~ /(f)(i)/i; # Hindi tugma!

Ang Perl ay hindi tumutugma sa maraming character sa isang naka-bracket na klase ng character maliban kung ang
tahasang binanggit ang karakter na namamapa sa kanila, at hindi ito tumutugma sa kanila
kung ang klase ng character ay baligtad, na kung hindi man ay maaaring maging lubhang nakalilito. Tingnan mo
"Mga Klase ng Naka-bracket na Character" sa perlrecharclass, at "Negation" sa perlrecharclass.

x Palawakin ang pagiging madaling mabasa ng iyong pattern sa pamamagitan ng pagpapahintulot sa whitespace at mga komento. Mga detalye sa
"/x"

p Panatilihin ang string na tumugma na ang ${^PREMATCH}, ${^MATCH}, at ${^POSTMATCH} ay
magagamit para magamit pagkatapos ng pagtutugma.

Sa Perl 5.20 at mas mataas ay hindi ito pinansin. Dahil sa bagong mekanismo ng copy-on-write,
Ang ${^PREMATCH}, ${^MATCH}, at ${^POSTMATCH} ay magiging available pagkatapos ng laban
anuman ang modifier.

a, d, l at u
Ang mga modifier na ito, lahat ay bago sa 5.14, ay nakakaapekto kung aling mga panuntunan sa set ng character (Unicode, atbp.) ang
ginamit, gaya ng inilarawan sa ibaba sa "Mga modifier ng character set".

n Pigilan ang pagpapangkat ng mga metacharacter na "()" sa pagkuha. Ang modifier na ito, bago sa 5.22,
pipigilan ang $1, $2, atbp... na mapunan.

"hello" =~ /(hi|hello)/; # $1 ay "hello"
"hello" =~ /(hi|hello)/n; # $1 ay undef

Katumbas ito ng paglalagay ng "?:" sa simula ng bawat grupong kumukuha:

"hello" =~ /(?:hi|hello)/; # $1 ay undef

Ang "/n" ay maaaring balewalain sa bawat pangkat na batayan. Bilang kahalili, ang mga pinangalanang pagkuha ay maaari pa rin
ginagamit.

"hello" =~ /(?-n:(hi|hello))/n; # $1 ay "hello"
"hello" =~ /(? hi|hello)/n; # $1 ay "hello", $+{greet} ay
# "hello"

Iba pang mga Modifier
Mayroong ilang mga flag na makikita sa dulo ng regular na expression
mga konstruksyon na hindi mga flag ng generic na regular na expression, ngunit nalalapat sa operasyon
ginagawa, tulad ng pagtutugma o pagpapalit ("m//" o "s///" ayon sa pagkakabanggit).

Ang mga flag na inilarawan pa sa "Paggamit ng mga regular na expression sa Perl" sa perlretut ay:

c - panatilihin ang kasalukuyang posisyon sa panahon ng paulit-ulit na pagtutugma
g - sa buong mundo ay tumutugma sa pattern nang paulit-ulit sa string

Mga modifier na tukoy sa pagpapalit na inilarawan sa

Ang "s/PATTERN/REPLACEMENT/msixpodualngcer" sa perlop ay:

e - suriin ang kanang bahagi bilang isang expression
ee - suriin ang kanang bahagi bilang isang string pagkatapos ay suriin ang resulta
o - magpanggap na i-optimize ang iyong code, ngunit talagang nagpapakilala ng mga bug
r - magsagawa ng hindi mapanirang pagpapalit at ibalik ang bagong halaga

Ang mga regular na expression modifier ay karaniwang nakasulat sa dokumentasyon bilang hal, "ang "/x"
modifier", kahit na ang tinutukoy na delimiter ay maaaring hindi talaga isang slash. Ang
ang mga modifier na "/imnsxadlup" ay maaari ding i-embed sa loob ng regular na expression na ginagamit mismo
ang "(?...)" construct, tingnan ang "Extended Patterns" sa ibaba.

Detalye on ilan nagbabago

Ang ilan sa mga modifier ay nangangailangan ng higit na paliwanag kaysa sa ibinigay sa "Pangkalahatang-ideya" sa itaas.

/x

Sinasabi ng "/x" sa regular na expression na parser na huwag pansinin ang karamihan sa whitespace na wala
backslashed o sa loob ng isang naka-bracket na klase ng character. Magagamit mo ito para masira ang iyong
regular na pagpapahayag sa (bahagyang) mas nababasang mga bahagi. Gayundin, ang "#" na karakter ay
itinuturing bilang isang metacharacter na nagpapakilala ng komento na umaabot hanggang sa pagsasara ng pattern
delimiter, o sa dulo ng kasalukuyang linya kung ang pattern ay umaabot sa susunod na linya.
Samakatuwid, ito ay halos katulad ng isang ordinaryong komento ng Perl code. (Maaari mong isama ang pagsasara
delimiter sa loob ng komento lamang kung inunahan mo ito ng backslash, kaya mag-ingat!)

Ang paggamit ng "/x" ay nangangahulugan na kung gusto mo ng totoong whitespace o "#" na mga character sa pattern
(sa labas ng isang naka-bracket na klase ng character, na hindi naaapektuhan ng "/x"), pagkatapos ay gagawin mo rin
kailangang takasan sila (gamit ang mga backslashes o "\Q...\E") o i-encode ang mga ito gamit ang octal, hex, o
Ang "\N{}" ay tumakas. Ito ay hindi epektibong subukang ipagpatuloy ang isang komento sa susunod na linya sa pamamagitan ng
pagtakas sa "\n" gamit ang backslash o "\Q".

Maaari mong gamitin ang "(?#text)" upang lumikha ng komento na nagtatapos nang mas maaga kaysa sa katapusan ng kasalukuyang
linya, ngunit ang "text" ay hindi rin maaaring maglaman ng pansarang delimiter maliban kung nakatakas na may backslash.

Kung pinagsama-sama, ang mga tampok na ito ay napupunta sa isang mahabang paraan patungo sa paggawa ng mga regular na expression ni Perl
mas nababasa. Narito ang isang halimbawa:

# Tanggalin (karamihan) C komento.
$program =~ s {
/\* # Itugma ang pambungad na delimiter.
.*? # Itugma ang kaunting bilang ng mga character.
\*/ # Itugma ang pansarang delimiter.
} [] gsx;

Tandaan na ang anumang bagay sa loob ng "\Q...\E" ay nananatiling hindi naaapektuhan ng "/x". At tandaan na "/x"
ay hindi nakakaapekto sa interpretasyon ng espasyo sa loob ng iisang multi-character construct. Para sa
halimbawa sa "\x{...}", anuman ang "/x" modifier, maaaring walang mga puwang. Pareho para sa a
quantifier gaya ng "{3}" o "{5,}". Katulad nito, ang "(?:...)" ay hindi maaaring magkaroon ng puwang sa pagitan ng
"(", "?", at ":". Sa loob ng anumang mga delimiter para sa naturang construct, ang mga pinapayagang puwang ay hindi
apektado ng "/x", at depende sa construct. Halimbawa, ang "\x{...}" ay hindi maaaring magkaroon ng mga puwang
dahil ang mga hexadecimal na numero ay walang mga puwang sa mga ito. Ngunit, maaaring magkaroon ng mga katangian ng Unicode
mga puwang, kaya sa "\p{...}" maaaring mayroong mga puwang na sumusunod sa mga panuntunan ng Unicode, kung saan makikita
"Mga katangiang naa-access sa pamamagitan ng \p{} at \P{}" sa perluniprops.

Ang hanay ng mga character na itinuring na whitespace ay ang mga tinatawag ng Unicode na "Pattern
White Space", ibig sabihin:

U+0009 TABULATION NG CHARACTER
U+000A LINE FEED
U+000B LINE TABULATION
U+000C FORM FEED
U+000D CARRIAGE RETURN
U+0020 SPACE
U+0085 NEXT LINE
U+200E LEFT-To-RIGHT MARK
U+200F KANAN-PAG-LIW NA MARK
U+2028 LINE SEPARATOR
U+2029 PARAGRAPH SEPARATOR

Mga modifier ng character set

Ang "/d", "/u", "/a", at "/l", na available simula sa 5.14, ay tinatawag na character set
mga modifier; nakakaapekto ang mga ito sa mga panuntunan sa set ng character na ginagamit para sa regular na expression.

Ang mga modifier na "/d", "/u", at "/l" ay malamang na hindi gaanong magamit sa iyo, at sa gayon ay
hindi kailangang mag-alala tungkol sa kanila nang labis. Umiiral ang mga ito para sa panloob na paggamit ni Perl, kaya kumplikado iyon
Ang mga istruktura ng data ng regular na expression ay maaaring awtomatikong i-serialize at sa ibang pagkakataon nang eksakto
reconstituted, kasama ang lahat ng kanilang mga nuances. Ngunit, dahil hindi kayang magtago ng sikreto ni Perl, at
maaaring may mga bihirang pagkakataon kung saan kapaki-pakinabang ang mga ito, nakadokumento ang mga ito dito.

Ang "/a" modifier, sa kabilang banda, ay maaaring maging kapaki-pakinabang. Ang layunin nito ay payagan ang code na iyon
upang gumana halos lahat sa ASCII data upang hindi na alalahanin ang sarili sa Unicode.

Sa madaling sabi, itinatakda ng "/l" ang character set sa kung ano man LAng ocale ay may bisa sa panahong iyon
ng execution ng pattern match.

Itinatakda ng "/u" ang set ng character sa Unicode.

Itinatakda din ng "/a" ang set ng character sa Unicode, PERO nagdaragdag ng ilang mga paghihigpit para sa ALigtas sa SCII
pagtutugma

Ang "/d" ay ang luma, may problema, bago ang 5.14 Dhindi nagawang pag-uugali ng set ng character. Ang tanging gamit nito ay upang
pilitin ang lumang ugali.

Sa anumang oras, eksaktong isa sa mga modifier na ito ang may bisa. Ang kanilang pag-iral ay nagpapahintulot
Perl na panatilihin ang orihinal na pinagsama-samang gawi ng isang regular na expression, anuman ang ano
Ang mga patakaran ay may bisa kapag ito ay aktwal na naisakatuparan. At kung ito ay interpolated sa isang mas malaki
regex, ang mga panuntunan ng orihinal ay patuloy na nalalapat dito, at ito lamang.

Ang "/l" at "/u" modifier ay awtomatikong pinipili para sa mga regular na expression na pinagsama-sama
sa loob ng saklaw ng iba't ibang pragma, at inirerekomenda namin na sa pangkalahatan, gamitin mo ang mga iyon
pragmas sa halip na tahasang tukuyin ang mga modifier na ito. Para sa isang bagay, ang mga modifier
makakaapekto lamang sa pagtutugma ng pattern, at hindi umabot sa kahit na anumang kapalit na ginawa, samantalang
ang paggamit ng mga pragma ay nagbibigay ng pare-parehong resulta para sa lahat ng naaangkop na operasyon sa loob ng kanilang
mga saklaw. Halimbawa,

s/foo/\Ubar/il

ay tutugma sa "foo" gamit ang mga panuntunan ng locale para sa case-insensitive na pagtutugma, ngunit ang "/l" ay
hindi nakakaapekto sa kung paano gumagana ang "\U". Malamang na gusto mong pareho silang gumamit ng mga lokal na panuntunan.
Upang gawin ito, sa halip ay i-compile ang regular na expression sa loob ng saklaw ng "use locale". Ito
parehong implicit na idinaragdag ang "/l", at inilalapat ang mga lokal na panuntunan sa "\U". Ang aral ay upang
"gamitin ang lokal", at hindi "/l" nang tahasan.

Katulad nito, mas mabuting gamitin ang "gamitin ang tampok na 'unicode_strings'" sa halip na,

s/foo/\Lbar/iu

upang makakuha ng mga panuntunan sa Unicode, gaya ng gagawin ng "\L" sa una (ngunit hindi naman sa huli).
gumamit din ng mga panuntunan sa Unicode.

Sumusunod ang higit pang detalye sa bawat isa sa mga modifier. Malamang na hindi mo kailangang malaman ito
detalye para sa "/l", "/u", at "/d", at maaaring lumaktaw sa unahan sa /a.

/l

nangangahulugang gamitin ang kasalukuyang mga panuntunan ng lokal (tingnan ang perllocale) kapag tumutugma ang pattern. Para sa
halimbawa, tutugma ang "\w" sa mga character na "salita" ng lokal na iyon, at case-insensitive ang "/i"
tutugma ang pagtutugma ayon sa mga panuntunan sa pag-fold ng case ng lokal. Ang lokal na gagamitin ay
ang may bisa sa oras ng pagpapatupad ng pattern match. Maaaring hindi ito pareho
bilang lokal na oras ng compilation, at maaaring mag-iba mula sa isang tugma patungo sa isa pa kung mayroong isang
intervening na tawag ng setlocale() function.

Ang tanging non-single-byte locale na sinusuportahan ng Perl ay (simula sa v5.20) na UTF-8. Ibig sabihin nito
na ang mga puntos ng code sa itaas ng 255 ay itinuturing bilang Unicode kahit na anong lokal ang may bisa
(dahil ang UTF-8 ay nagpapahiwatig ng Unicode).

Sa ilalim ng mga panuntunan ng Unicode, may ilang case-insensitive na mga tugma na tumatawid sa 255/256
hangganan. Maliban sa mga lokal na UTF-8 sa Perls v5.20 at mas bago, hindi pinapayagan ang mga ito sa ilalim
"/l". Halimbawa, ang 0xFF (sa mga platform ng ASCII) ay hindi basta-basta tumutugma sa karakter sa
0x178, "LATIN CAPITAL LETTER Y WITH DIAERESIS", dahil ang 0xFF ay maaaring hindi "LATIN SMALL
LETTER Y WITH DIAERESIS" sa kasalukuyang lokal, at walang paraan si Perl para malaman kung iyon
ang character ay umiiral pa sa lokal, higit na hindi kung ano ang punto ng code.

Sa isang lokal na UTF-8 sa v5.20 at mas bago, ang tanging nakikitang pagkakaiba sa pagitan ng lokal at hindi
ang lokal sa mga regular na expression ay dapat na nabahiran (tingnan ang perlsec).

Maaaring tukuyin ang modifier na ito bilang default sa pamamagitan ng "gamitin ang lokal", ngunit tingnan ang "Aling character
ang set modifier ay may bisa?".

/u

nangangahulugang gumamit ng mga panuntunan sa Unicode kapag tumutugma ang pattern. Sa mga platform ng ASCII, nangangahulugan ito na ang
ang mga puntos ng code sa pagitan ng 128 at 255 ay gumagamit ng kanilang Latin-1 (ISO-8859-1) na mga kahulugan (na kung saan ay ang
katulad ng sa Unicode). (Kung hindi, itinuturing ni Perl na hindi natukoy ang kanilang mga kahulugan.) Kaya,
sa ilalim ng modifier na ito, epektibong nagiging Unicode platform ang ASCII platform; at samakatuwid,
halimbawa, ang "\w" ay tutugma sa alinman sa higit sa 100_000 na character ng salita sa Unicode.

Hindi tulad ng karamihan sa mga lokal, na partikular sa isang pares ng wika at bansa, inuuri ng Unicode
lahat ng mga character na mga titik sa isang lugar sa mundo bilang "\w". Halimbawa, ang iyong
Maaaring hindi isipin ng locale na ang "LATIN SMALL LETTER ETH" ay isang liham (maliban kung nagkataon
nagsasalita ng Icelandic), ngunit ginagawa ng Unicode. Katulad nito, ang lahat ng mga character na mga decimal na digit
sa isang lugar sa mundo ay tutugma sa "\d"; ito ay daan-daan, hindi 10, posibleng mga tugma. At
ang ilan sa mga digit na iyon ay mukhang ilan sa 10 ASCII digit, ngunit ibig sabihin ay ibang numero,
kaya madaling isipin ng isang tao na ang isang numero ay ibang dami kaysa ito talaga. Para sa
halimbawa, ang "BENGALI DIGIT FOUR" (U+09EA) ay mukhang isang "ASCII DIGIT EIGHT"
(U+0038). At, "\d+", ay maaaring tumugma sa mga string ng mga digit na pinaghalong iba
mga sistema ng pagsulat, na lumilikha ng isyu sa seguridad. "num()" sa Unicode::UCD ay maaaring gamitin upang pagbukud-bukurin
ito palabas. O ang "/a" modifier ay maaaring gamitin upang pilitin ang "\d" na tumugma lamang sa ASCII 0
sa pamamagitan ng 9.

Gayundin, sa ilalim ng modifier na ito, gumagana ang case-insensitive na pagtutugma sa buong hanay ng Unicode
mga karakter. Ang "KELVIN SIGN", halimbawa ay tumutugma sa mga titik na "k" at "K"; at "LATIN
SMALL LIGATURE FF" ay tumutugma sa sequence na "ff", na, kung hindi ka handa, ay maaaring magtagumpay
mukhang hexadecimal constant, na nagpapakita ng isa pang potensyal na isyu sa seguridad. Tingnan mo
<http://unicode.org/reports/tr36> para sa isang detalyadong talakayan ng mga isyu sa seguridad ng Unicode.

Maaaring tukuyin ang modifier na ito bilang default sa pamamagitan ng "use feature 'unicode_strings", "use
locale ':not_characters'", o "use 5.012" (o mas mataas), ngunit tingnan ang "Aling set ng character
may bisa ang modifier?".

/d

Ang modifier na ito ay nangangahulugan na gamitin ang "Default" na mga katutubong panuntunan ng platform maliban kung mayroon
gamitin sa halip ang mga panuntunan ng Unicode, tulad ng sumusunod:

1. ang target na string ay naka-encode sa UTF-8; o

2. ang pattern ay naka-encode sa UTF-8; o

3. tahasang binabanggit ng pattern ang isang code point na nasa itaas ng 255 (sabihin sa pamamagitan ng "\x{100}"); o

4. ang pattern ay gumagamit ng Unicode name ("\N{...}"); o

5. ang pattern ay gumagamit ng isang Unicode property ("\p{...}" o "\P{...}"); o

6. ang pattern ay gumagamit ng Unicode break ("\b{...}" o "\B{...}"); o

7. ang pattern ay gumagamit ng ""(?[ ])""

Ang isa pang mnemonic para sa modifier na ito ay "Depends", dahil nakadepende ang mga panuntunang aktwal na ginamit
iba't ibang bagay, at bilang isang resulta maaari kang makakuha ng mga hindi inaasahang resulta. Tingnan ang "Ang "Unicode Bug""
sa perlunicode. Ang Unicode Bug ay naging medyo kasumpa-sumpa, na humahantong sa isa pa
(napi-print) na pangalan para sa modifier na ito, "Dodgy".

Maliban kung ang pattern o string ay naka-encode sa UTF-8, ASCII character lang ang maaaring tumugma
positibo.

Narito ang ilang halimbawa kung paano iyon gumagana sa isang ASCII platform:

$str = "\xDF"; # $str ay wala sa UTF-8 na format.
$str =~ /^\w/; # Walang tugma, dahil ang $str ay wala sa UTF-8 na format.
$str .= "\x{0e0b}"; # Ngayon ang $str ay nasa UTF-8 na format.
$str =~ /^\w/; # Tugma! Ang $str ay nasa UTF-8 na format na ngayon.
tumaga $str;
$str =~ /^\w/; # May laban pa! Nananatili ang $str sa format na UTF-8.

Awtomatikong pinipili ang modifier na ito bilang default kapag wala pa sa iba, kaya pa
isa pang pangalan para dito ay "Default".

Dahil sa mga hindi inaasahang gawi na nauugnay sa modifier na ito, malamang na dapat mo
gamitin lamang ito upang mapanatili ang mga kakaibang backward compatibility.

/a (at /aa)

Ang modifier na ito ay nangangahulugang ASCII-restrict (o ASCII-safe). Ang modifier na ito, hindi katulad ng
ang iba, ay maaaring doblehin upang madagdagan ang epekto nito.

Kapag ito ay lumabas nang isa-isa, nagiging sanhi ito ng mga sequence na "\d", "\s", "\w", at ang Posix na character
mga klase upang tumugma lamang sa hanay ng ASCII. Kaya bumalik sila sa kanilang pre-5.6, pre-Unicode
mga kahulugan. Sa ilalim ng "/a", "\d" ay palaging nangangahulugang tiyak ang mga digit na "0" hanggang "9"; Ang ibig sabihin ng "\s" ay ang
limang character na "[ \f\n\r\t]", at simula sa Perl v5.18, ang vertical na tab; "\w" ibig sabihin
ang 63 character na "[A-Za-z0-9_]"; at gayundin, lahat ng klase ng Posix tulad ng
Ang "[[:print:]]" ay tumutugma lamang sa mga naaangkop na ASCII-range na character.

Ang modifier na ito ay kapaki-pakinabang para sa mga taong nagkataon lamang na gumagamit ng Unicode, at hindi nagnanais
mabigatan sa mga kumplikado at alalahanin sa seguridad nito.

Sa "/a", maaaring isulat ng isa ang "\d" nang may kumpiyansa na tutugma lamang ito sa mga ASCII na character,
at sakaling magkaroon ng pangangailangan na tumugma sa kabila ng ASCII, maaari mong gamitin ang "\p{Digit}" (o
"\p{Word}" para sa "\w"). May mga katulad na "\p{...}" na mga construct na maaaring tumugma sa kabila ng ASCII
parehong puting espasyo (tingnan ang "Whitespace" sa perlrecharclass), at mga klase ng Posix (tingnan ang "POSIX
Character Classes" sa perlrecharclass). Kaya, ang modifier na ito ay hindi nangangahulugang hindi mo magagamit
Unicode, nangangahulugan ito na upang makakuha ng pagtutugma ng Unicode kailangan mong tahasang gumamit ng isang construct
("\p{}", "\P{}") na nagpapahiwatig ng Unicode.

Tulad ng iyong inaasahan, ang modifier na ito ay nagiging sanhi, halimbawa, ang "\D" ay pareho ang ibig sabihin ng
"[^0-9]"; sa katunayan, lahat ng hindi ASCII na character ay tumutugma sa "\D", "\S", at "\W". "\b" pa rin ang ibig sabihin
upang tumugma sa hangganan sa pagitan ng "\w" at "\W", gamit ang "/a" na mga kahulugan ng mga ito
(katulad para sa "\B").

Kung hindi, ang "/a" ay kumikilos tulad ng "/u" modifier, sa case-insensitive na pagtutugmang mga gamit
Mga panuntunan sa Unicode; halimbawa, ang "k" ay tutugma sa Unicode na "\N{KELVIN SIGN}" sa ilalim ng "/i"
pagtutugma, at mga puntos ng code sa hanay ng Latin1, sa itaas ng ASCII ay magkakaroon ng mga panuntunan sa Unicode kapag ito
pagdating sa case-insensitive na pagtutugma.

Para ipagbawal ang mga tugmang ASCII/hindi ASCII (tulad ng "k" na may "\N{KELVIN SIGN}"), tukuyin ang "a"
dalawang beses, halimbawa "/aai" o "/aia". (Ang unang paglitaw ng "a" ay naghihigpit sa "\d",
atbp., at ang pangalawang pangyayari ay nagdaragdag ng "/i" na mga paghihigpit.) Ngunit, tandaan na ang mga punto ng code
sa labas ng hanay ng ASCII ay gagamit ng mga panuntunan ng Unicode para sa pagtutugma ng "/i", kaya ang modifier ay hindi
talagang paghigpitan ang mga bagay sa ASCII lamang; ipinagbabawal lamang nito ang paghahalo ng ASCII at hindi
ASCII.

Upang buod, nagbibigay ang modifier na ito ng proteksyon para sa mga application na hindi gustong maging
nakalantad sa lahat ng Unicode. Ang pagtukoy nito ng dalawang beses ay nagbibigay ng karagdagang proteksyon.

Maaaring tukuyin ang modifier na ito bilang default sa pamamagitan ng "use re '/a'" o "use re '/aa'". Kung
gagawin mo ito, maaari kang magkaroon ng pagkakataon na gamitin ang "/u" modifier nang tahasan kung mayroon
ilang mga regular na expression kung saan gusto mo ang buong mga panuntunan sa Unicode (ngunit kahit dito, ito ay pinakamahusay
kung ang lahat ay nasa ilalim ng tampok na "unicode_strings", kasama ang "use re '/aa'"). Gayundin
tingnan ang "Aling character set modifier ang may bisa?".

Aling character set modifier ang may bisa?

Alin sa mga modifier na ito ang may bisa sa anumang partikular na punto sa isang regular na expression ay nakasalalay
sa isang medyo kumplikadong hanay ng mga pakikipag-ugnayan. Ang mga ito ay idinisenyo upang sa pangkalahatan ay ikaw
huwag mag-alala tungkol dito, ngunit ang seksyong ito ay nagbibigay ng mga madugong detalye. Gaya ng ipinaliwanag sa ibaba
sa "Mga Extended Pattern" posibleng tahasang tukuyin ang mga modifier na nalalapat lang sa
mga bahagi ng isang regular na expression. Ang pinakaloob ay palaging may priyoridad kaysa sa anumang panlabas,
at ang isa na nag-aaplay sa buong expression ay may priyoridad kaysa sa alinman sa mga default na setting
na inilalarawan sa natitirang bahagi ng seksyong ito.

Ang "use re '/foo'" pragma ay maaaring gamitin upang magtakda ng mga default na modifier (kabilang ang mga ito) para sa
mga regular na expression na pinagsama-sama sa loob ng saklaw nito. Ang pragma na ito ay nangunguna sa iba
pragmas na nakalista sa ibaba na nagbabago rin sa mga default.

Kung hindi, itinatakda ng "use locale" ang default na modifier sa "/l"; at "gamitin ang tampok
'unicode_strings", o "use 5.012" (o mas mataas) itakda ang default sa "/u" kapag wala sa parehong
saklaw bilang alinman sa "use locale" o "use bytes". (Ang "use locale ':not_characters'" ay nagtatakda din
ang default sa "/u", override sa anumang plain "use locale".) Hindi tulad ng mga mekanismong nabanggit
sa itaas, nakakaapekto ang mga ito sa mga operasyon bukod sa pagtutugma ng pattern ng mga regular na expression, at sa gayon ay nagbibigay
mas pare-parehong mga resulta sa iba pang mga operator, kabilang ang paggamit ng "\U", "\l", atbp. sa
pagpapalit ng kapalit.

Kung wala sa mga nabanggit ang nalalapat, para sa mga dahilan ng backwards compatibility, ang "/d" modifier ay ang
isa na may bisa bilang default. Dahil ito ay maaaring humantong sa mga hindi inaasahang resulta, ito ay pinakamahusay na tukuyin
kung aling iba pang hanay ng panuntunan ang dapat gamitin.

Pag-uugali ng character set modifier bago ang Perl 5.14

Bago ang 5.14, walang mga tahasang modifier, ngunit ang "/l" ay ipinahiwatig para sa mga regexe na pinagsama-sama
sa loob ng saklaw ng "use locale", at "/d" ay ipinahiwatig kung hindi man. Gayunpaman, interpolating
babalewalain ng isang regex sa isang mas malaking regex ang orihinal na compilation pabor sa kung ano man iyon
may bisa sa panahon ng ikalawang compilation. Mayroong ilang mga hindi pagkakapare-pareho
(mga bug) gamit ang "/d" modifier, kung saan gagamitin ang mga panuntunan ng Unicode kapag hindi naaangkop, at
vice versa. Ang "\p{}" ay hindi nagpahiwatig ng mga panuntunan sa Unicode, at gayundin ang lahat ng paglitaw ng
"\N{}", hanggang 5.12.

regular expression
Mga Metacharacter

Ang mga pattern na ginamit sa Perl pattern matching ay nagbago mula sa mga ibinigay sa Bersyon 8
regex na gawain. (Ang mga gawain ay hinango (malayo) mula kay Henry Spencer nang malaya
muling maipamahagi na muling pagpapatupad ng mga nakagawiang V8.) Tingnan ang "Mga Regular na Ekspresyon ng Bersyon 8"
para sa mga detalye.

Sa partikular, ang mga sumusunod na metacharacter ay may kanilang pamantayan egrep-ish kahulugan:

\ Sipiin ang susunod na metacharacter
^ Itugma ang simula ng linya
. Itugma ang anumang karakter (maliban sa bagong linya)
$ Itugma ang dulo ng string (o bago ang bagong linya sa dulo
ng string)
| Paghahalili
() Pagpapangkat
[] Naka-bracket na klase ng Character

Bilang default, ang karakter na "^" ay ginagarantiyahan na tumugma lamang sa simula ng string, ang
"$" na character lamang ang dulo (o bago ang bagong linya sa dulo), at tiyak na ginagawa ni Perl
mga pag-optimize na may pag-aakalang ang string ay naglalaman lamang ng isang linya. Naka-embed
ang mga bagong linya ay hindi tutugma sa "^" o "$". Gayunpaman, maaari mong hilingin na ituring ang isang string bilang isang
multi-line buffer, upang ang "^" ay tutugma pagkatapos ng anumang bagong linya sa loob ng string
(maliban kung ang bagong linya ay ang huling character sa string), at ang "$" ay tutugma bago ang anuman
bagong linya. Sa halaga ng kaunti pang overhead, magagawa mo ito sa pamamagitan ng paggamit ng /m modifier
sa operator ng pagtutugma ng pattern. (Ginawa ito ng mas lumang mga programa sa pamamagitan ng pagtatakda ng $*, ngunit ang pagpipiliang ito
ay inalis sa perl 5.10.)

Upang gawing simple ang mga multi-line na pagpapalit, ang "." hindi kailanman tumutugma ang karakter sa isang bagong linya maliban kung ikaw
gamitin ang "/s" modifier, na kung saan ay nagsasabi kay Perl na magpanggap na ang string ay iisa
linya--kahit hindi.

Mga Quantifier

Ang mga sumusunod na karaniwang quantifier ay kinikilala:

* Magtugma ng 0 o higit pang beses
+ Magtugma ng 1 o higit pang beses
? Itugma 1 o 0 beses
{n} Itugma nang eksakto sa n beses
{n,} Magtugma nang hindi bababa sa n beses
{n,m} Itugma ang hindi bababa sa n ngunit hindi hihigit sa m beses

(Kung ang isang kulot na bracket ay nangyayari sa anumang iba pang konteksto at hindi bahagi ng isang backslashed
sequence tulad ng "\x{...}", ito ay itinuturing bilang isang regular na character. Gayunpaman, isang depresyon
itinaas ang babala para sa lahat ng ganoong pangyayari, at sa Perl v5.26, literal na paggamit ng isang kulot
bracket ay kinakailangan na makatakas, sabihin sa pamamagitan ng unahan sa kanila ng isang backslash ("\{") o
nilalagay ang mga ito sa loob ng mga square bracket ("[{]"). Ang pagbabagong ito ay magbibigay-daan para sa hinaharap na syntax
mga extension (tulad ng paggawang opsyonal ang lower bound ng isang quantifier), at mas magandang error
pagsuri ng mga quantifier.)

Ang "*" quantifier ay katumbas ng "{0,}", ang "+" na quantifier sa "{1,}", at ang "?"
quantifier sa "{0,1}". Ang n at m ay limitado sa mga di-negatibong integral na halaga na mas mababa sa a
tinukoy ang preset na limitasyon kapag binuo ang perl. Ito ay karaniwang 32766 sa pinakakaraniwan
mga platform. Ang aktwal na limitasyon ay makikita sa mensahe ng error na nabuo ng code tulad ng
ito:

$_ **= $_ , / {$_} / para sa 2 .. 42;

Bilang default, ang isang quantified subpattern ay "matakaw", ibig sabihin, ito ay tutugma nang kasing dami
posible (ibinigay sa isang partikular na lokasyon ng pagsisimula) habang pinapayagan pa rin ang natitirang bahagi ng
pattern upang tumugma. Kung gusto mong tumugma ito sa pinakamababang bilang ng beses na posible, sundin
ang quantifier na may "?". Tandaan na ang mga kahulugan ay hindi nagbabago, ang "kasakiman" lamang:

*? Magtugma ng 0 o higit pang beses, hindi sakim
+? Magtugma ng 1 o higit pang beses, hindi sakim
?? Tugma 0 o 1 beses, hindi sakim
{n}? Itugma nang eksakto sa n beses, hindi sakim (kalabisan)
{n,}? Itugma kahit n beses, hindi sakim
{n,m}? Itugma ang hindi bababa sa n ngunit hindi hihigit sa m beses, hindi sakim

Karaniwan kapag ang isang quantified subpattern ay hindi pinapayagan ang natitirang bahagi ng pangkalahatang pattern
laban, babalikan ni Perl. Gayunpaman, kung minsan ang pag-uugali na ito ay hindi kanais-nais. Kaya naman si Perl
nagbibigay din ng "possessive" quantifier form.

*+ Magtugma ng 0 o higit pang beses at walang ibabalik
++ Magtugma ng 1 o higit pang beses at walang ibabalik
?+ Magtugma ng 0 o 1 beses at walang ibabalik
{n}+ Itugma nang eksakto n beses at walang ibabalik (redundant)
{n,}+ Magtugma ng kahit n beses at walang ibabalik
{n,m}+ Itugma ang hindi bababa sa n ngunit hindi hihigit sa m beses at walang ibabalik

Halimbawa,

'aaaa' =~ /a++a/

hindi kailanman tutugma, dahil lalamunin ng "a++" ang lahat ng "a" sa string at hindi aalis
anuman para sa natitirang bahagi ng pattern. Ang tampok na ito ay maaaring maging lubhang kapaki-pakinabang na ibigay
Ang perl ay nagpapahiwatig tungkol sa kung saan hindi ito dapat mag-backtrack. Halimbawa, ang tipikal na "tugma sa dobleng-
quoted string" na problema ay maaaring maisagawa nang mas mahusay kapag nakasulat bilang:

/"(?:[^"\\]++|\\.)*+"/

dahil alam natin na kung hindi tumugma ang huling quote, hindi makakatulong ang backtracking. Tingnan ang
independent subexpression ""(?>pattern)"" para sa higit pang mga detalye; possessive quantifiers ay
syntactic sugar lang para sa construct na iyon. Halimbawa ang halimbawa sa itaas ay maaari ding
nakasulat tulad ng sumusunod:

/"(?>(?:(?>[^"\\]+)|\\.)*)"/

Tandaan na hindi maaaring isama ang possessive quantifier modifier sa hindi matakaw
modifier. Ito ay dahil ito ay walang kahulugan. Isaalang-alang ang sumusunod na equivalency table:

Ilegal na Legal
------------ ------
X??+ X{0}
X+?+ X{1}
X{min,max}?+ X{min}

Makatakas pagkakasunud-sunod

Dahil ang mga pattern ay pinoproseso bilang double-quoted na mga string, gumagana din ang sumusunod:

\t tab (HT, TAB)
\n bagong linya (LF, NL)
bumalik (CR)
\f form feed (FF)
\a alarm (kampana) (BEL)
\e pagtakas (isipin ang troff) (ESC)
\cK control char (halimbawa: VT)
\x{}, \x00 character na ang ordinal ay ang ibinigay na hexadecimal na numero
\N{name} na pinangalanang Unicode na character o pagkakasunud-sunod ng character
\N{U+263D} Unicode na character (halimbawa: FIRST QUARTER MOON)
\o{}, \000 character na ang ordinal ay ang ibinigay na octal number
\l maliit na titik sa susunod na char (isipin vi)
\u uppercase next char (isipin vi)
\L lowercase hanggang \E (think vi)
\U uppercase hanggang \E (think vi)
\Q quote (disable) pattern metacharacter hanggang \E
\E tapusin ang alinman sa pagbabago ng kaso o sinipi na seksyon, isipin vi

Ang mga detalye ay nasa "Quote at Quote-like Operators" sa perlop.

Katangian Klase at iba espesyal Escapes

Bilang karagdagan, tinukoy ng Perl ang sumusunod:

Sequence Note Paglalarawan
[...] [1] Itugma ang isang karakter ayon sa mga tuntunin ng
naka-bracket na klase ng character na tinukoy ng "...".
Halimbawa: [az] tumutugma sa "a" o "b" o "c" ... o "z"
[[:...:]] [2] Itugma ang isang character ayon sa mga patakaran ng POSIX
klase ng karakter "..." sa loob ng panlabas na naka-bracket
klase ng karakter. Halimbawa: [[:upper:]] ay tumutugma sa alinman
malaking titik na karakter.
(?[...]) [8] Extended bracketed character class
\w [3] Itugma ang isang "salita" na karakter (alphanumeric plus "_", plus
iba pang connector na bantas na char at Unicode
marka)
\W [3] Itugma ang isang hindi "salita" na karakter
\s [3] Itugma ang isang character na whitespace
\S [3] Itugma ang isang character na hindi whitespace
\d [3] Itugma ang isang decimal na digit na character
\D [3] Itugma ang isang hindi-digit na character
\pP [3] Tugma sa P, pinangalanang ari-arian. Gamitin ang \p{Prop} para sa mas mahahabang pangalan
\PP [3] Itugma ang hindi P
\X [4] Itugma ang Unicode na "eXtended grapheme cluster"
\C Itugma ang isang C-language char (octet) kahit na iyon
bahagi ng mas malaking UTF-8 na character. Kaya ito nasira
mga character sa kanilang UTF-8 byte, kaya maaari kang mapunta
may mga malformed na piraso ng UTF-8. Hindi suportado sa
tumingin sa likod. (Hindi na ginagamit.)
\1 [5] Backreference sa isang partikular na grupo ng pagkuha o buffer.
Ang '1' ay maaaring maging anumang positibong integer.
\g1 [5] Backreference sa isang partikular o nakaraang grupo,
\g{-1} [5] Ang numero ay maaaring negatibo na nagpapahiwatig ng isang kamag-anak
nakaraang pangkat at maaaring opsyonal na i-wrap
mga kulot na bracket para sa mas ligtas na pag-parse.
\g{name} [5] Pinangalanang backreference
\k [5] Pinangalanang backreference
\K [6] Itago ang mga bagay na natitira sa \K, huwag isama ito sa $&
\N [7] Anumang karakter maliban sa \n. Hindi apektado ng /s modifier
\v [3] Patayong whitespace
\V [3] Hindi patayong whitespace
\h [3] Pahalang na whitespace
\H [3] Hindi pahalang na whitespace
\R [4] Linebreak

[1] Tingnan ang "Bracketed Character Classes" sa perlrecharclass para sa mga detalye.

[2] Tingnan ang "POSIX Character Classes" sa perlrecharclass para sa mga detalye.

[3] Tingnan ang "Backslash sequence" sa perlrecharclass para sa mga detalye.

[4] Tingnan ang "Misc" sa perlrebackslash para sa mga detalye.

[5] Tingnan ang "Mga pangkat ng pagkuha" sa ibaba para sa mga detalye.

[6] Tingnan ang "Mga Extended Pattern" sa ibaba para sa mga detalye.

[7] Tandaan na ang "\N" ay may dalawang kahulugan. Kapag sa form na "\N{NAME}", tumutugma ito sa
karakter o pagkakasunud-sunod ng karakter na ang pangalan ay "NAME"; at katulad din kapag sa anyo
"\N{U+hex}", tumutugma ito sa character na ang Unicode code point ay hex. Kung hindi ito
tumutugma sa anumang karakter maliban sa "\n".

[8] Tingnan ang "Extended Bracketed Character Classes" sa perlrecharclass para sa mga detalye.

Mga Pahayag

Tinutukoy ng Perl ang mga sumusunod na zero-width assertion:

\b{} Itugma sa hangganan ng Unicode ng tinukoy na uri
\B{} Itugma kung saan ang katumbas na \b{} ay hindi tumutugma
\b Itugma ang hangganan ng salita
\B Tugma maliban sa hangganan ng salita
\A Tugma lamang sa simula ng string
\Z Itugma lamang sa dulo ng string, o bago ang bagong linya sa dulo
\z Itugma lamang sa dulo ng string
\G Itugma lamang sa pos() (hal. sa end-of-match na posisyon
ng naunang m//g)

Ang hangganan ng Unicode ("\b{}"), na magagamit simula sa v5.22, ay isang lugar sa pagitan ng dalawa
mga character, o bago ang unang character sa string, o pagkatapos ng huling character sa
ang string kung saan natutugunan ang ilang pamantayang tinukoy ng Unicode. Tingnan ang "\b{}, \b, \B{}, \B" sa
perlrebackslash para sa mga detalye.

Ang hangganan ng salita ("\b") ay isang lugar sa pagitan ng dalawang character na may "\w" sa isang gilid nito
at isang "\W" sa kabilang panig nito (sa alinmang pagkakasunud-sunod), binibilang ang mga haka-haka na character
sa simula at dulo ng string bilang tumutugma sa isang "\W". (Sa loob ng mga klase ng character
Ang "\b" ay kumakatawan sa backspace sa halip na isang hangganan ng salita, tulad ng karaniwan nitong ginagawa sa alinman
double-quoted string.) Ang "\A" at "\Z" ay katulad lang ng "^" at "$", maliban na sila
ay hindi tutugma nang maraming beses kapag ginamit ang "/m" modifier, habang ang "^" at "$" ay magtutugma sa
bawat panloob na hangganan ng linya. Upang tumugma sa aktwal na dulo ng string at hindi balewalain ang isang
opsyonal na trailing newline, gamitin ang "\z".

Ang assertion na "\G" ay maaaring gamitin upang i-chain ang mga pandaigdigang tugma (gamit ang "m//g"), tulad ng inilarawan sa
"Regexp Quote-Like Operators" sa perlop. Ito ay kapaki-pakinabang din kapag nagsusulat ng "lex"-like
scanner, kapag mayroon kang ilang mga pattern na gusto mong itugma laban sa kinahinatnan
mga substring ng iyong string; tingnan ang nakaraang sanggunian. Ang aktwal na lokasyon kung saan ang "\G"
will match ay maaari ding maimpluwensyahan sa pamamagitan ng paggamit ng "pos()" bilang isang lvalue: tingnan ang "pos" sa perlfunc.
Tandaan na ang panuntunan para sa zero-length ay tumutugma (tingnan ang "Repeated Patterns Matching a Zero-length
Substring") ay medyo binago, dahil ang mga nilalaman sa kaliwa ng "\G" ay hindi binibilang
kapag tinutukoy ang haba ng laban. Kaya ang mga sumusunod ay hindi magtutugma magpakailanman:

aking $string = 'ABC';
pos($string) = 1;
habang ($string =~ /(.\G)/g) {
i-print ang $1;
}

Ito ay magpi-print ng 'A' at pagkatapos ay magwawakas, dahil itinuturing nitong zero-width ang tugma, at sa gayon
hindi tutugma sa parehong posisyon nang dalawang beses sa isang hilera.

Ito ay nagkakahalaga na tandaan na ang "\G" na hindi wastong ginamit ay maaaring magresulta sa isang walang katapusang loop. Mag-ingat ka
kapag gumagamit ng mga pattern na may kasamang "\G" sa isang kahalili.

Tandaan din na tatanggi ang "s///" na i-overwrite ang bahagi ng isang pagpapalit na mayroon na
pinalitan; kaya halimbawa ito ay titigil pagkatapos ng unang pag-ulit, sa halip na
inuulit ang daan pabalik sa string:

$_ = "123456789";
pos = 6;
s/.(?=.\G)/X/g;
print; # print na 1234X6789, hindi XXXXX6789

Pagbihag grupo

Ang bracketing construct na "( ... )" ay lumilikha ng mga grupo ng pagkuha (tinatawag din bilang capture
buffer). Upang sumangguni sa mga kasalukuyang nilalaman ng isang pangkat sa ibang pagkakataon, sa loob ng parehong pattern,
gamitin ang "\g1" (o "\g{1}") para sa una, "\g2" (o "\g{2}") para sa pangalawa, at iba pa. Ito
ay tinatawag na a backreference.

Walang limitasyon sa bilang ng mga nakunan na substring na maaari mong gamitin. Ang mga grupo ay
may bilang na may pinakakaliwang bukas na panaklong bilang numero 1, atbp. Kung ang isang grupo ay hindi
tugma, hindi rin tutugma ang nauugnay na backreference. (Maaari itong mangyari kung ang grupo ay
opsyonal, o sa ibang sangay ng isang kahalili.) Maaari mong alisin ang "g", at isulat
"\1", atbp, ngunit may ilang mga isyu sa form na ito, na inilarawan sa ibaba.

Maaari ka ring sumangguni sa mga grupong kumukuha nang medyo, sa pamamagitan ng paggamit ng negatibong numero, nang sa gayon
Ang "\g-1" at "\g{-1}" ay parehong tumutukoy sa naunang grupo ng pagkuha, at "\g-2" at
Ang "\g{-2}" ay parehong tumutukoy sa pangkat bago nito. Halimbawa:

/
(Y) # pangkat 1
( # pangkat 2
(X) # pangkat 3
\g{-1} # backref sa pangkat 3
\g{-3} # backref sa pangkat 1
)
/x

ay kapareho ng "/(Y) ( (X) \g3 \g1 )/x". Nagbibigay-daan ito sa iyo na i-interpolate ang mga regex
sa mas malalaking regexes at hindi na kailangang mag-alala tungkol sa mga pangkat ng pagkuha na muling binibilang.

Maaari kang magbigay ng mga numero nang buo at lumikha ng mga pinangalanang pangkat ng pagkuha. Ang notasyon ay
"(?pangalan>...)" upang ipahayag at "\g{pangalan}" sa sanggunian. (Upang maging tugma sa .Net
mga regular na expression, "\g{pangalan}" maaari ding isulat bilang "\k{pangalan}", "\kpangalan>" or
"\k'pangalan'".) pangalan hindi dapat magsimula sa isang numero, o naglalaman ng mga gitling. Kapag iba
ang mga pangkat sa loob ng parehong pattern ay may parehong pangalan, ang anumang pagtukoy sa pangalang iyon ay ipinapalagay ang
pinakakaliwang tinukoy na pangkat. Ang mga pinangalanang pangkat ay binibilang sa absolute at relative numbering, at maaari rin
tinutukoy din ng mga numerong iyon. (Posibleng gumawa ng mga bagay gamit ang pangalang capture
mga pangkat na kung hindi man ay mangangailangan ng "(??{})".)

Ang mga nilalaman ng pangkat ng pagkuha ay dynamic na saklaw at available sa iyo sa labas ng pattern
hanggang sa dulo ng kalakip na bloke o hanggang sa susunod na matagumpay na laban, alinman ang dumating
una. (Tingnan ang "Mga Tambalan na Pahayag" sa perlsyn.) Maaari kang sumangguni sa kanila sa pamamagitan ng ganap na numero
(gamit ang "$1" sa halip na "\g1", atbp); o sa pamamagitan ng pangalan sa pamamagitan ng "%+" hash, gamit ang "$+{pangalan}".

Kinakailangan ang mga brace sa pagtukoy sa mga pinangalanang grupo ng pagkuha, ngunit opsyonal para sa absolute o
mga kamag-anak na may bilang. Ang mga brace ay mas ligtas kapag gumagawa ng regex sa pamamagitan ng pagsasama-sama ng mas maliit
mga string. Halimbawa kung mayroon kang "qr/$a$b/", at ang $a ay naglalaman ng "\g1", at ang $b ay naglalaman
"37", makakakuha ka ng "/\g137/" na malamang na hindi ang iyong nilayon.

Ang mga notasyong "\g" at "\k" ay ipinakilala sa Perl 5.10.0. Bago iyon ay wala
pinangalanan o kamag-anak na may bilang na mga pangkat ng pagkuha. Ang mga pangkat na may ganap na bilang ay tinukoy
gamit ang "\1", "\2", atbp., at tinatanggap pa rin ang notasyong ito (at malamang na palaging ganoon).
Ngunit humahantong ito sa ilang mga ambiguity kung mayroong higit sa 9 na pangkat ng pagkuha, gaya ng magagawa ng "\10".
nangangahulugang alinman sa ikasampung pangkat ng pagkuha, o ang karakter na ang ordinal sa octal ay 010 (a
backspace sa ASCII). Niresolba ng Perl ang kalabuan na ito sa pamamagitan ng pagbibigay-kahulugan sa "\10" bilang a
backreference lamang kung hindi bababa sa 10 kaliwang panaklong ang nakabukas bago nito. Gayundin ang "\11"
ay isang backreference lamang kung hindi bababa sa 11 kaliwang panaklong ang nakabukas bago nito. At iba pa.
Ang "\1" hanggang "\9" ay palaging binibigyang kahulugan bilang mga backreference. Mayroong ilang mga halimbawa
sa ibaba na naglalarawan ng mga panganib na ito. Maiiwasan mo ang kalabuan sa pamamagitan ng palaging paggamit ng "\g{}" o
"\g" kung ang ibig mong sabihin ay pagkuha ng mga grupo; at para sa mga octal constant na palaging gumagamit ng "\o{}", o para sa
"\077" at mas mababa, gamit ang 3 digit na may padded na may mga leading zero, dahil ang leading zero ay nagpapahiwatig
isang octal constant.

Ang "\digit" gumagana rin ang notasyon sa ilang partikular na sitwasyon sa labas ng pattern. Tingnan mo
"Babala sa \1 Sa halip na $1" sa ibaba para sa mga detalye.

Halimbawa:

s/^([^ ]*) *([^ ]*)/$2 $1/; # palitan ang unang dalawang salita

/(.)\g1/ # find first doubled char
at i-print ang "'$1' ay ang unang dobleng karakter\n";

/(? .)\k / # ... ibang paraan
at i-print ang "'$+{char}' ay ang unang dobleng character\n";

/(?'char'.)\g1/ # ... mix and match
at i-print ang "'$1' ay ang unang dobleng karakter\n";

if (/Time: (..):(..):(..)/) { # parse out values
$hours = $1;
$minuto = $2;
$segundo = $3;
}

/(.)(.)(.)(.)(.)(.)(.)(.)(.)\g10/ # \g10 ay isang backreference
/(.)(.)(.)(.)(.)(.)(.)(.)(.)\10/ # \10 ay octal
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\10/ # \10 ay isang backreference
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\010/ # \010 ay octal

$a = '(.)\1'; # Lumilikha ng mga problema kapag pinagsama-sama.
$b = '(.)\g{1}'; # Iniiwasan ang mga problema.
"aa" =~ /${a}/; # Totoo
"aa" =~ /${b}/; # Totoo
"aa0" =~ /${a}0/; # Mali!
"aa0" =~ /${b}0/; # Totoo
"aa\x08" =~ /${a}0/; #Totoo!
"aa\x08" =~ /${b}0/; # Mali

Ang ilang mga espesyal na variable ay sumangguni din sa mga bahagi ng nakaraang tugma. nagbabalik ang $+
anuman ang tugma ng huling bracket. $& ibinabalik ang buong katugmang string. (Sa isa
ginawa rin ng point $0, ngunit ngayon ay ibinabalik nito ang pangalan ng programa.) "$`" ay nagbabalik ng lahat
bago ang katugmang string. Ibinabalik ng "$'" ang lahat pagkatapos ng katugmang string. At $^N
naglalaman ng anumang naitugma ng pinakakamakailang saradong pangkat (submatch). Maaaring maging $^N
ginagamit sa mga pinahabang pattern (tingnan sa ibaba), halimbawa upang magtalaga ng submatch sa isang variable.

Ang mga espesyal na variable na ito, tulad ng "%+" na hash at ang may bilang na mga variable na tumutugma ($1, $2, $3,
atbp.) ay dynamic na saklaw hanggang sa dulo ng kalakip na bloke o hanggang sa susunod
matagumpay na laban, alinman ang mauna. (Tingnan ang "Mga Compound Statement" sa perlsyn.)

NOTA: Ang mga nabigong tugma sa Perl ay hindi nagre-reset ng mga variable ng pagtutugma, na ginagawang mas madali
sumulat ng code na sumusubok para sa isang serye ng mga mas partikular na kaso at naaalala ang pinakamahusay na tugma.

BABALA: Kung ang iyong code ay tatakbo sa Perl 5.16 o mas maaga, mag-ingat na kapag nakita iyon ng Perl
kailangan mo ng isa sa $&, "$`", o "$'" saanman sa programa, kailangan nitong ibigay ang mga ito
bawat pattern ay tugma. Ito ay maaaring lubos na makapagpabagal sa iyong programa.

Gumagamit ang Perl ng parehong mekanismo upang makagawa ng $1, $2, atbp, kaya magbabayad ka rin ng presyo para sa bawat isa
pattern na naglalaman ng pagkuha ng mga panaklong. (Upang maiwasan ang gastos na ito habang pinapanatili ang
pag-uugali ng pagpapangkat, gamitin ang pinahabang regular na expression na "(?: ... )" sa halip.) Ngunit kung ikaw
huwag gumamit ng $&, "$`" o "$'", pagkatapos ay mga pattern wala ang pagkuha ng mga panaklong ay hindi magiging
pinarusahan. Kaya iwasan ang $&, "$'", at "$`" kung kaya mo, ngunit kung hindi mo magagawa (at ilang algorithm
talagang pinahahalagahan ang mga ito), kapag ginamit mo ang mga ito ng isang beses, gamitin ang mga ito sa kalooban, dahil ikaw ay
binayaran na ang presyo.

Ipinakilala ng Perl 5.16 ang isang bahagyang mas mahusay na mekanismo na nagsasaad nang hiwalay kung
bawat isa sa "$`", $&, at "$'" ay nakita, at sa gayon ay maaaring kailanganin lamang na kopyahin ang bahagi ng
string. Ipinakilala ng Perl 5.20 ang isang mas mahusay na mekanismo ng copy-on-write na
inaalis ang anumang pagbagal.

Bilang isa pang solusyon para sa problemang ito, ipinakilala ng Perl 5.10.0 ang "${^PREMATCH}", "${^MATCH}"
at "${^POSTMATCH}", na katumbas ng "$`", $& at "$'", maliban na sila lang
garantisadong matutukoy pagkatapos ng isang matagumpay na tugma na naisakatuparan gamit ang "/p"
(preserba) modifier. Ang paggamit ng mga variable na ito ay hindi nagkakaroon ng global performance penalty,
hindi tulad ng kanilang mga katumbas na bantas na char, gayunpaman sa trade-off na kailangan mong sabihin
perl kapag gusto mong gamitin ang mga ito. Sa Perl 5.20, ang tatlong variable na ito ay katumbas ng
Ang "$`", $& at "$'", at "/p" ay hindi pinapansin.

Pag-quote metacharacter
Ang mga naka-backslash na metacharacter sa Perl ay alphanumeric, gaya ng "\b", "\w", "\n". Unlike
ilang iba pang mga regular na expression na wika, walang mga backslash na simbolo na hindi
alphanumeric. Kaya ang anumang mukhang \\, \(, \), \[, \], \{, o \} ay palaging
binibigyang kahulugan bilang isang literal na karakter, hindi isang metacharacter. Ito ay minsang ginamit sa isang pangkaraniwan
idyoma upang huwag paganahin o banggitin ang mga espesyal na kahulugan ng mga regular na expression na metacharacter sa a
string na gusto mong gamitin para sa isang pattern. Sipiin lang ang lahat ng hindi "salita" na character:

$pattern =~ s/(\W)/\\$1/g;

(Kung nakatakda ang "gumamit ng lokal", depende ito sa kasalukuyang lokal.) Mas marami na ito ngayon
karaniwang ginagamit ang quotemeta() function o ang "\Q" metaquoting escape sequence upang i-disable
lahat ng mga espesyal na kahulugan ng metacharacter tulad nito:

/$unquoted\Q$quoted\E$unquoted/

Mag-ingat na kung maglalagay ka ng mga literal na backslashes (mga wala sa loob ng interpolated variable)
sa pagitan ng "\Q" at "\E", ang double-quotish na backslash interpolation ay maaaring humantong sa pagkalito
resulta. Kung ikaw kailangan para gumamit ng literal na backslashes sa loob ng "\Q...\E", kumonsulta sa "Gory details
ng pag-parse ng mga naka-quote na konstruksyon" sa perlop.

Ang "quotemeta()" at "\Q" ay ganap na inilalarawan sa "quotemeta" sa perlfunc.

Pinahaba Pattern
Tinutukoy din ng Perl ang isang pare-parehong extension syntax para sa mga feature na hindi matatagpuan sa mga karaniwang tool
gaya ng ang awkward at lex. Ang syntax para sa karamihan sa mga ito ay isang pares ng panaklong na may tanong
markahan bilang ang unang bagay sa loob ng panaklong. Ang karakter pagkatapos ng tandang pananong
ay nagpapahiwatig ng extension.

Ang katatagan ng mga extension na ito ay malawak na nag-iiba. Ang ilan ay naging bahagi ng pangunahing wika
sa loob ng maraming taon. Ang iba ay pang-eksperimento at maaaring magbago nang walang babala o ganap
inalis. Suriin ang dokumentasyon sa isang indibidwal na tampok upang i-verify ang kasalukuyang katayuan nito.

Ang isang tandang pananong ay pinili para dito at para sa minimal na pagtutugma ng konstruksyon dahil 1)
bihira ang mga tandang pananong sa mas lumang mga regular na expression, at 2) sa tuwing makakakita ka ng isa, ikaw
dapat huminto at "magtanong" nang eksakto kung ano ang nangyayari. Psychology yan....

"(?#text)"
Isang komento. Hindi pinapansin ang text. Tandaan na isinasara ni Perl ang komento sa sandaling makita nito
a ")", kaya walang paraan na maglagay ng literal na ")" sa komento. Ang pattern ay pagsasara
delimiter ay dapat na makatakas sa pamamagitan ng isang backslash kung ito ay lilitaw sa komento.

Tingnan ang "/x" para sa isa pang paraan upang magkaroon ng mga komento sa mga pattern.

"(?adlupimnsx-imnsx)"
"(?^alupimnsx)"
Isa o higit pang naka-embed na pattern-match modifier, na i-on (o i-off, kung
pinangungunahan ng "-") para sa natitira sa pattern o ang natitira sa kalakip
pangkat ng pattern (kung mayroon man).

Ito ay partikular na kapaki-pakinabang para sa mga dynamic na pattern, tulad ng mga nabasa mula sa a
configuration file, kinuha mula sa isang argumento, o tinukoy sa isang table sa isang lugar.
Isaalang-alang ang kaso kung saan ang ilang mga pattern ay gustong maging case-sensitive at ang ilan ay hindi: Ang
Ang mga case-insensitive ay kailangan lang isama ang "(?i)" sa harap ng pattern. Para sa
halimbawa:

$pattern = "foobar";
kung ( /$pattern/i ) { }

# mas nababaluktot:

$pattern = "(?i)foobar";
kung ( /$pattern/ ) { }

Ibinabalik ang mga modifier na ito sa dulo ng kalakip na grupo. Halimbawa,

( (?i) blah ) \s+ \g1

ay tutugma sa "blah" sa anumang kaso, ilang mga puwang, at isang eksaktong (kabilang ang kaso!)
pag-uulit ng nakaraang salita, sa pag-aakalang ang "/x" modifier, at walang "/i" modifier
labas ng grupong ito.

Ang mga modifier na ito ay hindi dinadala sa mga pinangalanang subpattern na tinatawag sa kalakip
pangkat. Sa madaling salita, hindi binabago ng pattern gaya ng "((?i)(?&NAME))" ang case-
pagiging sensitibo ng pattern na "NAME".

Anuman sa mga modifier na ito ay maaaring itakda na ilapat sa buong mundo sa lahat ng mga regular na expression
pinagsama-sama sa loob ng saklaw ng isang "use re". Tingnan ang "'/flags' mode" sa re.

Simula sa Perl 5.14, isang "^" (caret o circumflex accent) kaagad pagkatapos ng "?" ay
isang shorthand na katumbas ng "d-imnsx". Ang mga flag (maliban sa "d") ay maaaring sundin ang caret sa
i-override ito. Ngunit ang isang minus sign ay hindi legal dito.

Tandaan na ang mga modifier na "a", "d", "l", "p", at "u" ay espesyal na maaari lamang nilang
i-enable, hindi i-disable, at ang mga modifier na "a", "d", "l", at "u" ay magkapareho
eksklusibo: ang pagtukoy ng isa ay hindi tumutukoy sa iba, at isang maximum ng isa (o dalawang "a")
maaaring lumitaw sa konstruksyon. Kaya, halimbawa, "(?-p)" ay babala kapag pinagsama-sama sa ilalim
"gamitin ang mga babala"; "(?-d:...)" at "(?dl:...)" ay nakamamatay na mga error.

Tandaan din na ang "p" modifier ay espesyal sa pagkakaroon nito saanman sa isang pattern
ay may pandaigdigang epekto.

"(?: pattern)"
"(?adluimnsx-imnsx:pattern)"
"(?^aluimnsx:pattern)"
Ito ay para sa clustering, hindi pagkuha; pinapangkat nito ang mga subexpression tulad ng "()", ngunit hindi
gumawa ng mga backreference gaya ng ginagawa ng "()". Kaya

@fields = split(/\b(?:a|b|c)\b/)

ay tulad ng

@fields = split(/\b(a|b|c)\b/)

ngunit hindi naglalabas ng karagdagang mga patlang. Mas mura rin ang hindi kumuha ng mga character kung ikaw
hindi na kailangan.

Anumang mga titik sa pagitan ng "?" at ang ":" ay kumikilos bilang mga flag modifier tulad ng sa "(?adluimnsx-imnsx)".
Halimbawa,

/(?si:more.*than).*million/i

ay katumbas ng mas maraming salita

/(?:(?si)more.*than).*million/i

Tandaan na ang anumang "(...)" na mga construct na nakapaloob sa isang ito ay makukuha pa rin maliban kung
ang "/n" modifier ay may bisa.

Simula sa Perl 5.14, isang "^" (caret o circumflex accent) kaagad pagkatapos ng "?" ay
isang shorthand na katumbas ng "d-imnsx". Anumang mga positibong flag (maliban sa "d") ay maaaring sundin ang
caret, kaya

(?^x:foo)

ay katumbas ng

(?x-imns:foo)

Ang caret ay nagsasabi kay Perl na ang cluster na ito ay hindi nagmamana ng mga flag ng anumang nakapaligid
pattern, ngunit ginagamit ang mga default ng system ("d-imnsx"), na binago ng anumang mga flag na tinukoy.

Ang caret ay nagbibigay-daan para sa mas simpleng stringification ng pinagsama-samang mga regular na expression. Ang mga ito
kamukha

(?^:pattern)

na may anumang hindi default na mga flag na lumilitaw sa pagitan ng caret at colon. Isang pagsubok na
tumitingin sa naturang stringification kaya hindi kailangang magkaroon ng mga default na flag ng system nang husto-
naka-code sa loob nito, ang caret lang. Kung ang mga bagong flag ay idinagdag sa Perl, ang kahulugan ng
Magbabago ang pagpapalawak ng caret upang isama ang default para sa mga flag na iyon, kaya gagawin ng pagsubok
gumagana pa rin, hindi nagbabago.

Ang pagtukoy ng negatibong flag pagkatapos ng caret ay isang error, dahil ang flag ay kalabisan.

Mnemonic para sa "(?^...)": Isang bagong simula dahil ang karaniwang paggamit ng isang caret ay upang tumugma
sa simula.

"(?|pattern)"
Ito ang pattern na "branch reset", na may espesyal na katangian na nakukuha
ang mga grupo ay binibilang mula sa parehong panimulang punto sa bawat alternation branch. Ito ay
magagamit simula sa perl 5.10.0.

Ang mga pangkat ng pagkuha ay binibilang mula kaliwa hanggang kanan, ngunit sa loob nito ay bumuo ng
ang pagnunumero ay na-restart para sa bawat sangay.

Ang pagnunumero sa loob ng bawat sangay ay magiging tulad ng normal, at anumang mga pangkat na sumusunod dito
construct ay mabibilang na parang ang construct ay naglalaman lamang ng isang sangay, iyon
pagiging isa na may pinakamaraming mga grupo ng pagkuha dito.

Ang construct na ito ay kapaki-pakinabang kapag gusto mong makuha ang isa sa ilang alternatibo
tugma

Isaalang-alang ang sumusunod na pattern. Ipinapakita ng mga numero sa ibaba kung saang pangkat ang
ang nakunan na nilalaman ay maiimbak.

# bago ---------------branch-reset----------- pagkatapos
/ ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
# 1 2 2 3 2 3 4

Mag-ingat kapag ginagamit ang pattern ng pag-reset ng sangay kasama ng mga pinangalanang pagkuha.
Ang mga pinangalanang pagkuha ay ipinapatupad bilang mga alias sa mga may bilang na grupo na may hawak ng
mga kinukunan, at nakakasagabal ito sa pagpapatupad ng pattern ng pag-reset ng sangay. Kung
ikaw ay gumagamit ng pinangalanang mga pagkuha sa isang pattern ng pag-reset ng sangay, pinakamahusay na gumamit ng pareho
mga pangalan, sa parehong pagkakasunud-sunod, sa bawat isa sa mga kahalili:

/(?| (? x ) (? y )
| (? z ) (? w )) /x

Ang hindi paggawa nito ay maaaring humantong sa mga sorpresa:

"12" =~ /(?| (? \d+ ) | (? \D+))/x;
sabihin ang $+ {a}; # Mga Print '12'
sabihin ang $+ {b}; # *Gayundin* nagpi-print ng '12'.

Ang problema dito ay ang parehong pangkat na pinangalanang "a" at ang pangkat na pinangalanang "b" ay mga alias
para sa pangkat na kabilang sa $1.

Mga Pahayag sa Palibot
Ang look-around assertion ay zero-width pattern na tumutugma sa isang partikular na pattern na wala
kasama ito sa $&. Ang mga positibong assertion ay tumutugma kapag ang kanilang subpattern ay tumutugma, negatibo
tumutugma ang mga pahayag kapag nabigo ang kanilang subpattern. Look-back matches text hanggang sa
kasalukuyang posisyon ng tugma, ang tingin sa unahan ay tumutugma sa teksto kasunod ng kasalukuyang posisyon ng tugma.

"(?= pattern)"
Isang zero-width positive look-ahead assertion. Halimbawa, ang "/\w+(?=\t)/" ay tumutugma sa a
salita na sinusundan ng tab, nang hindi isinama ang tab sa $&.

"(?! pattern)"
Isang zero-width na negatibong pagtingin sa hinaharap na assertion. Halimbawa "/foo(?!bar)/" mga tugma
anumang paglitaw ng "foo" na hindi sinusundan ng "bar". Gayunpaman, tandaan na ang hitsura-
sa unahan at sa likod ay HINDI pareho. Hindi mo ito magagamit para tingnan-
sa likod.

Kung naghahanap ka ng "bar" na hindi pinangungunahan ng "foo", "/(?!foo)bar/" ay
huwag gawin ang gusto mo. Iyan ay dahil ang "(?!foo)" ay nagsasabi lamang na ang susunod
bagay ay hindi maaaring "foo"--at ito ay hindi, ito ay isang "bar", kaya "foobar" ay tumutugma. Gamitin
sa halip ay tumingin-sa likod (tingnan sa ibaba).

"(?<=pattern)" "\K"
Isang zero-width positive look-behind assertion. Halimbawa, ang "/(?<=\t)\w+/" ay tumutugma
isang salita na sumusunod sa isang tab, nang hindi kasama ang tab sa $&. Gumagana lamang para sa fixed-
lapad tumingin-likod.

Mayroong isang espesyal na anyo ng konstruksyon na ito, na tinatawag na "\K" (magagamit mula noong Perl
5.10.0), na nagiging sanhi ng regex engine na "panatilihin" ang lahat ng naitugma nito noon
sa "\K" at huwag isama ito sa $&. Ito ay epektibong nagbibigay ng variable-length
tingin-likod. Ang paggamit ng "\K" sa loob ng isa pang assertion sa pagtingin sa paligid ay pinapayagan,
ngunit ang pag-uugali ay kasalukuyang hindi mahusay na tinukoy.

Para sa iba't ibang kadahilanan, ang "\K" ay maaaring mas mahusay kaysa sa katumbas
"(?<=...)" construct, at ito ay lalong kapaki-pakinabang sa mga sitwasyon kung saan mo gustong gawin
mahusay na alisin ang isang bagay na sumusunod sa ibang bagay sa isang string. Halimbawa

s/(foo)bar/$1/g;

maaaring muling isulat bilang mas mahusay

s/foo\Kbar//g;

"(?
Isang zero-width na negatibong pagtingin sa likod ng assertion. Halimbawa "/(?
anumang paglitaw ng "foo" na hindi sumusunod sa "bar". Gumagana lamang para sa fixed-width
tingin-likod.

"(?'NAME'pattern)"
"(? pattern)"
Isang pinangalanang pangkat ng pagkuha. Magkapareho sa lahat ng aspeto sa normal na pagkuha ng mga panaklong "()"
ngunit para sa karagdagang katotohanan na ang grupo ay maaaring tukuyin sa pamamagitan ng pangalan sa iba't-ibang
regular na expression constructs (tulad ng "\g{NAME}") at maaaring ma-access sa pamamagitan ng pangalan pagkatapos ng a
matagumpay na tugma sa pamamagitan ng "%+" o "%-". Tingnan ang perlvar para sa higit pang mga detalye sa "%+" at "%-"
mga hash.

Kung maraming magkakaibang pangkat ng pagkuha ang may parehong pangalan, ang $+{NAME} ang tutukuyin
ang pinakakaliwang tinukoy na grupo sa laban.

Ang mga form na "(?'NAME'pattern)" at "(? pattern)" ay katumbas.

TANDAAN: Habang ang notasyon ng construct na ito ay kapareho ng katulad na function sa .NET
regex, ang pag-uugali ay hindi. Sa Perl ang mga pangkat ay binibilang nang sunud-sunod anuman
mapangalanan man o hindi. Kaya sa pattern

/(x)(? y)(z)/

Ang $+{foo} ay magiging kapareho ng $2, at ang $3 ay maglalaman ng 'z' sa halip na ang kabaligtaran na
ay kung ano ang maaaring asahan ng isang .NET regex hacker.

Sa kasalukuyan, ang NAME ay limitado lamang sa mga simpleng identifier. Sa madaling salita, dapat
tumugma sa "/^[_A-Za-z][_A-Za-z0-9]*\z/" o sa extension ng Unicode nito (tingnan ang utf8), kahit na
ay hindi pinalawak ng locale (tingnan ang perllocale).

TANDAAN: Upang gawing mas madali ang mga bagay para sa mga programmer na may karanasan sa Python
o PCRE regex engine, ang pattern na "(?P pattern)" ay maaaring gamitin sa halip na
"(? pattern)"; gayunpaman hindi sinusuportahan ng form na ito ang paggamit ng mga solong panipi bilang a
delimiter para sa pangalan.

"\k "
"\k'NAME'"
Pinangalanang backreference. Katulad ng mga numeric na backreference, maliban na ang grupo ay
itinalaga sa pamamagitan ng pangalan at hindi numero. Kung maraming grupo ang may parehong pangalan kung gayon ito
ay tumutukoy sa pinakakaliwang tinukoy na pangkat sa kasalukuyang tugma.

Ito ay isang error na sumangguni sa isang pangalan na hindi tinukoy ng isang "(? )" kanina sa pattern.

Ang parehong mga form ay katumbas.

TANDAAN: Upang gawing mas madali ang mga bagay para sa mga programmer na may karanasan sa Python
o PCRE regex engine, ang pattern na "(?P=NAME)" ay maaaring gamitin sa halip na "\k ".

"(?{ code })"
BABALA: Ang paggamit ng feature na ito nang ligtas ay nangangailangan na maunawaan mo ang mga limitasyon nito. Code
ang naisakatuparan na may mga side effect ay maaaring hindi gumanap nang magkapareho mula sa bersyon hanggang sa bersyon na dapat bayaran
sa epekto ng mga pag-optimize sa hinaharap sa regex engine. Para sa karagdagang impormasyon sa
ito, tingnan ang "Dalas ng Pagpapatupad ng Naka-embed na Code".

Ang zero-width na assertion na ito ay nagpapatupad ng anumang naka-embed na Perl code. Palagi itong nagtatagumpay, at
nakatakda ang return value nito bilang $^R.

Sa literal na mga pattern, ang code ay na-parse kasabay ng nakapalibot na code.
Habang nasa pattern, pansamantalang ipapasa pabalik sa perl parser ang kontrol, hanggang
ang lohikal na pagbabalanse ng closing brace ay nakatagpo. Ito ay katulad ng paraan na iyon
isang array index expression sa isang literal na string ay hinahawakan, halimbawa

"abc$array[ 1 + f('[') + g()]def"

Sa partikular, ang mga braces ay hindi kailangang balansehin:

s/abc(?{ f('{'); })/def/

Kahit na sa isang pattern na interpolated at pinagsama-sama sa run-time, literal na mga bloke ng code
ay isasama nang isang beses, sa perl compile time; ang mga sumusunod na print na "ABCD":

i-print ang "D";
my $qr = qr/(?{ BEGIN { print "A" } })/;
aking $foo = "foo";
/$foo$qr(?{ BEGIN { print "B" } })/;
BEGIN { print "C" }

Sa mga pattern kung saan ang teksto ng code ay nagmula sa impormasyon ng run-time
kaysa sa literal na paglitaw sa isang source code /pattern/, ang code ay pinagsama-sama sa parehong
oras na ang pattern ay pinagsama-sama, at para sa mga kadahilanan ng seguridad, "gumamit ng muling 'eval'" ay dapat
maging nasa saklaw. Ito ay upang ihinto ang mga pattern na ibinigay ng user na naglalaman ng mga snippet ng code mula sa
pagiging executable.

Sa mga sitwasyon kung saan kailangan mong paganahin ito gamit ang "use re 'eval'", dapat ay mayroon ka rin
pinagana ang pagsusuri ng bahid. Mas mabuti pa, gamitin ang maingat na pinipigilang pagsusuri sa loob ng a
Ligtas na kompartimento. Tingnan ang perlsec para sa mga detalye tungkol sa parehong mekanismong ito.

Mula sa pananaw ng pag-parse, lexical variable na saklaw at pagsasara,

/AAA(?{ BBB })CCC/

kumikilos ng humigit-kumulang tulad ng

/AAA/ && gawin { BBB } && /CCC/

Katulad nito,

qr/AAA(?{ BBB })CCC/

kumikilos ng humigit-kumulang tulad ng

sub { /AAA/ && gawin { BBB } && /CCC/ }

Sa partikular:

{ my $i = 1; $r = qr/(?{ print $i })/ }
aking $i = 2;
/$r/; # prints "1"

Sa loob ng bloke na "(?{...})", ang $_ ay tumutukoy sa string na tumutugma sa regular na expression
laban sa. Maaari mo ring gamitin ang "pos()" para malaman kung ano ang kasalukuyang posisyon ng pagtutugma
sa loob ng string na ito.

Ang code block ay nagpapakilala ng bagong saklaw mula sa pananaw ng lexical variable
mga deklarasyon, ngunit hindi mula sa pananaw ng "lokal" at katulad na lokalisasyon
mga pag-uugali. Kaya sa ibang pagkakataon ang mga bloke ng code sa loob ng parehong pattern ay makikita pa rin ang mga halaga
na naisalokal sa mga naunang bloke. Ang mga naipon na lokalisasyon na ito ay binabawi
alinman sa dulo ng isang matagumpay na laban, o kung ang assertion ay na-backtrack (ihambing
"Backtracking"). Halimbawa,

$_ = 'a' x 8;
m<
(?{ $cnt = 0 }) # Simulan ang $cnt.
(
a
(?{
lokal na $cnt = $cnt + 1; # I-update ang $cnt,
# backtracking-safe.
})
)*
aaaa
(?{ $res = $cnt }) # Sa tagumpay na kopyahin sa
# hindi lokal na lokasyon.
>x;

sa una ay tataas ang $cnt hanggang 8; pagkatapos sa panahon ng backtracking, ang halaga nito ay magiging
unwound pabalik sa 4, na kung saan ay ang halaga na itinalaga sa $res. Sa dulo ng regex
execution, $cnt ay ibabalik sa paunang halaga nito na 0.

Ang assertion na ito ay maaaring gamitin bilang kondisyon sa a

(?(kondisyon)yes-pattern|no-pattern)

lumipat. Kung hindi ginamit sa ganitong paraan, ang resulta ng pagsusuri ng "code" ay inilalagay sa
espesyal na variable $^R. Nangyayari ito kaagad, kaya maaaring gamitin ang $^R mula sa iba pang "(?{
code })" na mga pahayag sa loob ng parehong regular na expression.

Ang pagtatalaga sa $^R sa itaas ay wastong na-localize, kaya ang lumang halaga ng $^R ay naibalik
kung ang assertion ay backtracked; ihambing ang "Backtracking".

Tandaan na ang espesyal na variable na $^N ay partikular na kapaki-pakinabang sa mga bloke ng code na kukunan
ang mga resulta ng mga submatch sa mga variable nang hindi kinakailangang subaybayan ang bilang ng
naka-nest na panaklong. Halimbawa:

$_ = "Ang brown fox ay tumalon sa ibabaw ng tamad na aso";
/ang (\S+)(?{ $color = $^N }) (\S+)(?{ $animal = $^N })/i;
i-print ang "kulay = $kulay, hayop = $hayop\n";

"(??{ code })"
BABALA: Ang paggamit ng feature na ito nang ligtas ay nangangailangan na maunawaan mo ang mga limitasyon nito. Code
ang naisakatuparan na may mga side effect ay maaaring hindi gumanap nang magkapareho mula sa bersyon hanggang sa bersyon na dapat bayaran
sa epekto ng mga pag-optimize sa hinaharap sa regex engine. Para sa karagdagang impormasyon sa
ito, tingnan ang "Dalas ng Pagpapatupad ng Naka-embed na Code".

Ito ay isang regular na subexpression na "na-postpone". Ito ay kumikilos sa tamang-tama sa parehong paraan tulad ng a
"(?{ code })" block ng code gaya ng inilarawan sa itaas, maliban sa halaga ng ibinabalik nito, sa halip na
na itinalaga sa $^R, ay itinuturing bilang isang pattern, pinagsama-sama kung ito ay isang string (o ginamit bilang-
ay kung ito ay isang qr// object), pagkatapos ay itinugma na parang ito ay ipinasok sa halip na ito
bumuo.

Sa panahon ng pagtutugma ng sub-pattern na ito, mayroon itong sariling hanay ng mga pagkuha na kung saan ay
valid sa panahon ng sub-match, ngunit itatapon kapag bumalik ang control sa main
pattern. Halimbawa, ang mga sumusunod na tugma, na may panloob na pattern na kumukuha ng "B" at
tumutugma sa "BB", habang ang panlabas na pattern ay kumukuha ng "A";

aking $inner = '(.)\1';
"ABBA" =~ /^(.)(??{ $inner })\1/;
i-print ang $1; # prints "A";

Tandaan na nangangahulugan ito na walang paraan para sa panloob na pattern na sumangguni sa isang pagkuha
pangkat na tinukoy sa labas. (Ang code block mismo ay maaaring gumamit ng $1, atbp., upang sumangguni sa
kalakip ang mga grupo ng pagkuha ng pattern.) Kaya, bagaman

('a' x 100)=~/(??{'(.)' x 100})/

habilin magkatugma, ito ay hindi itakda ang $1 sa paglabas.

Ang sumusunod na pattern ay tumutugma sa isang nakakulong na pangkat:

$re = qr{
\(
(?:
(?> [^()]+ ) # Non-paren nang walang backtracking
|
(??{ $re }) # Pangkat na may tugmang pare
)*
\)
}x;

Tingnan din ang "(?PARNO)" para sa ibang, mas mahusay na paraan upang magawa ang parehong gawain.

Isinasagawa ang isang ipinagpaliban na regular na expression nang 50 beses nang hindi gumagamit ng anumang input string
ay magreresulta sa isang nakamamatay na pagkakamali. Ang maximum na depth ay pinagsama-sama sa perl, kaya binabago ito
nangangailangan ng custom na build.

"(?PARNO)" "(?-PARNO)" "(?+PARNO)" "(?R)" "(?0)"
Recursive subpattern. Tratuhin ang mga nilalaman ng isang ibinigay na buffer ng pagkuha sa kasalukuyang
pattern bilang isang independiyenteng subpattern at subukang itugma ito sa kasalukuyang posisyon
sa tali. Impormasyon tungkol sa estado ng pagkuha mula sa tumatawag para sa mga bagay tulad ng
ang mga backreference ay magagamit sa subpattern, ngunit ang pagkuha ng mga buffer na itinakda ng
subpattern ay hindi nakikita ng tumatawag.

Katulad ng "(??{ code })" maliban na hindi ito nagsasangkot ng pagpapatupad ng anumang code o
potensyal na pag-compile ng ibinalik na string ng pattern; sa halip ay tinatrato nito ang bahagi ng
kasalukuyang pattern na nilalaman sa loob ng isang tinukoy na pangkat ng pagkuha bilang isang independiyenteng pattern
na dapat tumugma sa kasalukuyang posisyon. Iba rin ang pagtrato sa pagkuha
buffer, hindi katulad ng "(??{ code })" na may access ang mga recursive pattern sa kanilang mga katugmang tumatawag
estado, upang ligtas na magamit ng isa ang mga backreference.

PARNO ay isang sequence ng mga digit (hindi nagsisimula sa 0) na ang halaga ay sumasalamin sa pare-
bilang ng pangkat ng paghuli na uulitin. "(?R)" recurses sa simula ng
buong pattern. Ang "(?0)" ay isang kahaliling syntax para sa "(?R)". Kung PARNO ay naunahan ng a
plus o minus sign pagkatapos ito ay ipinapalagay na kamag-anak, na may mga negatibong numero na nagpapahiwatig
naunang mga grupo ng pagkuha at mga positibong sumusunod. Kaya ang "(?-1)" ay tumutukoy sa pinaka
kamakailang ipinahayag na pangkat, at ang "(?+1)" ay nagpapahiwatig ng susunod na pangkat na idedeklara. Tandaan
na ang pagbibilang para sa kamag-anak na recursion ay naiiba sa mga kamag-anak na backreference,
sa na may recursion unclosed grupo ay kasama.

Ang sumusunod na pattern ay tumutugma sa isang function foo() na maaaring naglalaman ng balanseng panaklong
bilang argumento.

$re = qr{ ( # paren group 1 (full function)
foo
( # paren group 2 (parens)
\(
( # paren group 3 (contents of parens)
(?:
(?> [^()]+ ) # Non-paren nang walang backtracking
|
(?2) # Recurse sa pagsisimula ng paren group 2
)*
)
\)
)
)
}x;

Kung ginamit ang pattern tulad ng sumusunod

'foo(bar(baz)+baz(bop))'=~/$re/
at i-print ang "\$1 = $1\n",
"\$2 = $2\n",
"\$3 = $3\n";

ang output na ginawa ay dapat na ang mga sumusunod:

$1 = foo(bar(baz)+baz(bop))
$2 = (bar(baz)+baz(bop))
$3 = bar(baz)+baz(bop)

Kung walang tinukoy na kaukulang pangkat ng pagkuha, ito ay isang nakamamatay na error.
Magreresulta din ang pag-uulit nang mas malalim sa 50 beses nang hindi gumagamit ng anumang input string
isang nakamamatay na pagkakamali. Ang pinakamataas na lalim ay pinagsama-sama sa perl, kaya ang pagbabago nito ay nangangailangan ng a
pasadyang build.

Ipinapakita ng sumusunod kung paano mapadali ng paggamit ng negatibong pag-index ang pag-embed ng recursive
mga pattern sa loob ng isang "qr//" construct para magamit sa ibang pagkakataon:

my $parens = qr/(\((?:[^()]++|(?-1))*+\))/;
kung (/foo $parens \s+ \+ \s+ bar $parens/x) {
#gawin mo dito...
}

nota na ang pattern na ito ay hindi kumikilos sa parehong paraan tulad ng katumbas na PCRE o Python
konstruksyon ng parehong anyo. Sa Perl maaari kang mag-backtrack sa isang recursed group, sa PCRE
at Python ang recursed sa grupo ay itinuturing bilang atomic. Gayundin, nalutas ang mga modifier
sa oras ng pag-compile, kaya ang mga konstruksyon tulad ng (?i:(?1)) o (?:(?i)(?1)) ay hindi makakaapekto kung paano ang
ipoproseso ang sub-pattern.

"(?&NAME)"
Ulitin sa isang pinangalanang subpattern. Kapareho ng "(?PARNO)" maliban na ang panaklong sa
ang recurse to ay tinutukoy ng pangalan. Kung ang maraming panaklong ay may parehong pangalan, kung gayon ito
umuulit sa pinakakaliwa.

Ito ay isang error na sumangguni sa isang pangalan na hindi ipinahayag sa isang lugar sa pattern.

TANDAAN: Upang gawing mas madali ang mga bagay para sa mga programmer na may karanasan sa Python
o PCRE regex engine ang pattern na "(?P>NAME)" ay maaaring gamitin sa halip na "(?&NAME)".

"(?(kondisyon)yes-pattern|no-pattern)"
"(?(kondisyon)oo-pattern)"
Pagpapahayag ng kondisyon. Tumutugma sa "yes-pattern" kung ang "kondisyon" ay nagbubunga ng totoong halaga,
tumutugma sa "walang pattern" kung hindi man. Palaging tumutugma ang isang nawawalang pattern.

Ang "(kondisyon)" ay dapat isa sa: 1) isang integer sa mga panaklong (na wasto kung ang
katumbas na pares ng panaklong ang tumugma); 2) isang pagtingin sa unahan/pagtingin sa likod/pagsusuri ng zero-
lapad assertion; 3) isang pangalan sa angle bracket o single quotes (na wasto kung a
pangkat na may tugmang pangalan); o 4) ang espesyal na simbolo (R) (totoo kapag sinusuri
sa loob ng recursion o eval). Bilang karagdagan, ang R ay maaaring sundan ng isang numero, (na
ay magiging totoo kapag nasuri kapag umuulit sa loob ng naaangkop na grupo), o sa pamamagitan ng
&NAME, kung saan ito ay magiging totoo lamang kapag nasuri sa panahon ng recursion sa pinangalanan
group.

Narito ang isang buod ng mga posibleng panaguri:

(1) (2) ...
Sinusuri kung may tumugma ang pangkat na kumukuha ng numero.

( ) ('NAME')
Sinusuri kung ang isang pangkat na may ibinigay na pangalan ay tumugma sa isang bagay.

(?=...) (?!...) (?<=...) (?
Sinusuri kung tumutugma ang pattern (o hindi tumutugma, para sa mga variant na '!').

(?{ CODE })
Tinatrato ang return value ng block ng code bilang kundisyon.

(R) Sinusuri kung ang expression ay nasuri sa loob ng recursion.

(R1) (R2) ...
Sinusuri kung ang expression ay nasuri habang direktang isinasagawa sa loob ng
n-th capture group. Ang tseke na ito ay katumbas ng regex ng

kung ((tumatawag(0))[3] eq 'subname') { ... }

Sa madaling salita, hindi nito sinusuri ang buong stack ng recursion.

(R&NAME)
Katulad ng "(R1)", sinusuri ng predicate na ito kung direkta kaming nag-e-execute sa loob
sa pinakakaliwang pangkat na may ibinigay na pangalan (ito ang parehong lohika na ginamit ng "(?&NAME)"
upang i-disambiguate). Hindi nito sinusuri ang buong stack, ngunit ang pangalan lamang ng
pinakaloob na aktibong recursion.

(DEFINE)
Sa kasong ito, ang yes-pattern ay hindi kailanman direktang naisakatuparan, at walang no-pattern ay
pinapayagan. Katulad sa diwa ng "(?{0})" ngunit mas mahusay. Tingnan sa ibaba para sa mga detalye.

Halimbawa:

m{ ( \( )?
[^()]+
(?(1) \) )
}x

tumutugma sa isang tipak ng mga hindi panaklong, posibleng kasama sa mga panaklong mismo.

Ang isang espesyal na anyo ay ang "(DEFINE)" na panaguri, na hindi kailanman naisasagawa ang yes-pattern nito
direkta, at hindi pinapayagan ang walang pattern. Nagbibigay-daan ito sa isa na tukuyin ang mga subpattern na alin
ay isasagawa lamang sa pamamagitan ng mekanismo ng recursion. Sa ganitong paraan, maaari mong tukuyin ang isang set ng
mga panuntunan sa regular na expression na maaaring isama sa anumang pattern na pipiliin mo.

Inirerekomenda na para sa paggamit na ito ay ilagay mo ang DEFINE block sa dulo ng
pattern, at pangalanan mo ang anumang mga subpattern na tinukoy sa loob nito.

Gayundin, ito ay nagkakahalaga ng noting na ang mga pattern na tinukoy sa paraang ito ay malamang na hindi magiging bilang
mahusay, dahil ang optimizer ay hindi masyadong matalino sa paghawak sa kanila.

Ang isang halimbawa kung paano ito maaaring gamitin ay ang mga sumusunod:

/(? (?&NAME_PAT))(? (?&ADDRESS_PAT))
(?(DEFINE)
(? ....)
(? ....)
)/x

Tandaan na ang mga pangkat ng pagkuha na tumugma sa loob ng recursion ay hindi naa-access pagkatapos ng
bumabalik ang recursion, kaya kailangan ang dagdag na layer ng pagkuha ng mga grupo. Sa gayon
Ang $+{NAME_PAT} ay hindi tutukuyin kahit na ang $+{NAME}.

Panghuli, tandaan na ang mga subpattern na ginawa sa loob ng isang DEFINE block count patungo sa
ganap at kamag-anak na bilang ng mga pagkuha, kaya ito:

my @captures = "a" =~ /(.) # Unang pagkuha
(?(DEFINE)
(? 1 ) # Pangalawang pagkuha
)/x;
sabihin scalar @captures;

Maglalabas ng 2, hindi 1. Ito ay partikular na mahalaga kung balak mong i-compile ang
mga kahulugan gamit ang operator na "qr//", at pagkatapos ay i-interpolate ang mga ito sa ibang pattern.

"(?>pattern)"
Isang "independiyenteng" subexpression, isa na tumutugma sa substring na a standalone
Magtutugma ang "pattern" kung nakaangkla sa ibinigay na posisyon, at tumutugma ito wala iba
kaysa ito substring. Ang construct na ito ay kapaki-pakinabang para sa mga pag-optimize ng kung ano ang gagawin
kung hindi man ay "walang hanggan" na mga tugma, dahil hindi ito uurong (tingnan ang "Backtracking").
Maaari rin itong maging kapaki-pakinabang sa mga lugar kung saan ang "grab all you can, at huwag magbigay ng anuman
pabalik" ang semantiko ay kanais-nais.

Halimbawa: "^(?>a*)ab" ay hindi kailanman tutugma, dahil "(?>a*)" (naka-angkla sa simula
ng string, tulad ng nasa itaas) ay tutugma lahat mga character na "a" sa simula ng string, umaalis
walang "a" para sa "ab" na tumutugma. Sa kabaligtaran, ang "a*ab" ay tutugma sa "a+b", dahil ang
Ang tugma ng subgroup na "a*" ay naiimpluwensyahan ng sumusunod na pangkat na "ab" (tingnan
"Backtracking"). Sa partikular, ang "a*" sa loob ng "a*ab" ay tutugma sa mas kaunting mga character kaysa sa a
standalone "a*", dahil ginagawa nitong magkatugma ang buntot.

Hindi ganap na pinapagana ng "(?>pattern)" ang pag-backtrack sa sandaling tumugma na ito. Ito ay
posible pa ring i-backtrack ang construct, ngunit hindi dito. Kaya
Ang "((?>a*)|(?>b*))ar" ay tutugma pa rin sa "bar".

Maaaring makamit ang epektong katulad ng "(?>pattern)" sa pamamagitan ng pagsulat ng "(?=(pattern))\g{-1}".
Ito ay tumutugma sa parehong substring bilang isang standalone na "a+", at ang sumusunod na "\g{-1}" ay kumakain
ang katugmang string; ito samakatuwid ay gumagawa ng isang zero-length assertion sa isang analogue ng
"(?>...)". (Ang pagkakaiba sa pagitan ng dalawang konstruksyon na ito ay ang pangalawa ay gumagamit ng a
pagkuha ng grupo, kaya nagbabago ang mga ordinal ng mga backreference sa natitirang bahagi ng isang regular
pagpapahayag.)

Isaalang-alang ang pattern na ito:

m{ \(
(
[^()]+ # x+
|
\( [^()]* \)
)+
\)
}x

Iyon ay mahusay na tutugma sa isang pangkat na walang laman na may tugmang panaklong dalawang antas ang lalim
o mas kaunti. Gayunpaman, kung walang ganoong grupo, aabutin ito ng halos magpakailanman sa mahabang panahon
string. Iyon ay dahil napakaraming iba't ibang paraan upang hatiin ang isang mahabang string
ilang mga substrings. Ito ang ginagawa ng "(.+)+", at ang "(.+)+" ay katulad ng a
subpattern ng pattern sa itaas. Isaalang-alang kung paano nakikita ng pattern sa itaas ang walang tugma sa
"((()aaaaaaaaaaaaaaaa" sa ilang segundo, ngunit ang bawat karagdagang titik ay doble nito
oras. Ipapakita ng exponential performance na ito na nag-hang ang iyong program.
Gayunpaman, isang maliit na pagbabago sa pattern na ito

m{ \(
(
(?> [^()]+ ) # palitan ang x+ sa itaas ng (?> x+ )
|
\( [^()]* \)
)+
\)
}x

na gumagamit ng "(?>...)" ay eksaktong tumutugma kapag ang nasa itaas ay tumutugma (nagpapatunay na ito mismo
ay isang produktibong ehersisyo), ngunit nagtatapos sa ikaapat na oras kapag ginamit sa a
katulad na string na may 1000000 "a" s. Magkaroon ng kamalayan, gayunpaman, na, kapag ang construct na ito ay
na sinusundan ng isang quantifier, kasalukuyan itong nagpapalitaw ng mensahe ng babala sa ilalim ng "use
babala" pragma o -w switch na nagsasabing ito ay "tumutugma sa null string ng maraming beses sa regex".

Sa mga simpleng grupo, gaya ng pattern na "(?> [^()]+ )", maaaring may maihahambing na epekto
nakakamit sa pamamagitan ng negatibong pagtingin sa unahan, tulad ng sa "[^()]+ (?! [^()] )". Ito ay 4 na beses lamang
mas mabagal sa isang string na may 1000000 "a" s.

Ang semantiko na "grab all you can, and don't give anything back" ay kanais-nais sa marami
mga sitwasyon kung saan sa unang tingin isang simpleng "()*" ang mukhang tamang solusyon.
Ipagpalagay na nag-parse kami ng text na may mga komento na nililimitahan ng "#" na sinusundan ng ilang opsyonal
(pahalang) whitespace. Taliwas sa hitsura nito, "#[ \t]*" is hindi ang tamang
subexpression upang tumugma sa delimiter ng komento, dahil maaari itong "magbigay" ng ilang whitespace
kung ang natitira sa pattern ay maaaring gawin upang tumugma sa ganoong paraan. Ang tamang sagot ay
alinman sa mga ito:

(?>#[ \t]*)
#[ \t]*(?![ \t])

Halimbawa, para makuha ang mga komentong hindi walang laman sa $1, dapat gamitin ng isa ang alinman sa mga ito:

/ (?> \# [ \t]* ) ( .+ ) /x;
/ \# [ \t]* ( [^ \t] .* ) /x;

Alin ang pipiliin mo ay depende sa kung alin sa mga expression na ito ang mas mahusay na sumasalamin sa itaas
detalye ng mga komento.

Sa ilang panitikan ang konstruksyon na ito ay tinatawag na "atomic matching" o "possessive
tugma".

Ang mga possessive quantifier ay katumbas ng paglalagay ng item na inilapat sa kanila sa loob
ng isa sa mga konstruksyon na ito. Nalalapat ang mga sumusunod na katumbas:

Quantifier Form Bracketing Form
--------------- ---------------
PAT*+ (?>PAT*)
PAT++ (?>PAT+)
PAT?+ (?>PAT?)
PAT{min,max}+ (?>PAT{min,max})

"(?[ ])"
Tingnan ang "Extended Bracketed Character Classes" sa perlrecharclass.

espesyal Backtracking Kontrolin Pandiwa
Ang mga espesyal na pattern na ito ay karaniwang nasa anyong "(*VERB:ARG)". Maliban kung iba ang nakasaad
ang argumento ng ARG ay opsyonal; sa ilang mga kaso, ito ay ipinagbabawal.

Anumang pattern na naglalaman ng isang espesyal na backtracking verb na nagbibigay-daan sa isang argumento ay may espesyal
pag-uugali na kapag naisakatuparan ay nagtatakda ito ng kasalukuyang package na $REGERROR at $REGMARK
mga variable. Kapag ginagawa ito, nalalapat ang mga sumusunod na patakaran:

Sa pagkabigo, ang $REGERROR variable ay itatakda sa ARG value ng pattern ng pandiwa, kung
kasangkot ang pandiwa sa kabiguan ng tugma. Kung ang bahagi ng ARG ng pattern ay
tinanggal, pagkatapos ay itatakda ang $REGERROR sa pangalan ng huling pattern na "(*MARK:NAME)"
naisakatuparan, o sa TRUE kung wala. Gayundin, ang $REGMARK variable ay itatakda sa FALSE.

Sa isang matagumpay na laban, ang $REGERROR variable ay itatakda sa FALSE, at ang $REGMARK
itatakda ang variable sa pangalan ng huling pattern na "(*MARK:NAME)" na naisakatuparan. Tingnan ang
paliwanag para sa "(*MARK:NAME)" na pandiwa sa ibaba para sa higit pang mga detalye.

TANDAAN: Ang $REGERROR at $REGMARK ay hindi mga magic variable tulad ng $1 at karamihan sa iba pang nauugnay sa regex
mga variable. Ang mga ito ay hindi lokal sa isang saklaw, o readonly, ngunit sa halip ay pabagu-bago ng isip na pakete
mga variable na katulad ng $AUTOLOAD. Gamitin ang "lokal" upang i-localize ang mga pagbabago sa kanila sa isang partikular
saklaw kung kinakailangan.

Kung ang isang pattern ay hindi naglalaman ng isang espesyal na backtracking na pandiwa na nagbibigay-daan sa isang argumento, kung gayon
Ang $REGERROR at $REGMARK ay hindi ginalaw.

Mga pandiwa na kumukuha ng argumento
"(*PRUNE)" "(*PRUNE:NAME)"
Pinuputol ng pattern na ito ng zero-width ang backtracking tree sa kasalukuyang punto kung kailan
bumalik sa kabiguan. Isaalang-alang ang pattern na "A (*PRUNE) B", kung saan ang A at B ay
kumplikadong mga pattern. Hanggang sa maabot ang "(*PRUNE)" na pandiwa, ang A ay maaaring mag-backtrack bilang
kailangan upang tumugma. Kapag naabot na ito, magpapatuloy ang pagtutugma sa B, na maaari ring
backtrack kung kinakailangan; gayunpaman, dapat hindi tumugma ang B, pagkatapos ay wala nang karagdagang pag-urong
magaganap, at ang pattern ay ganap na mabibigo sa kasalukuyang pagsisimula
posisyon.

Binibilang ng sumusunod na halimbawa ang lahat ng posibleng pagtutugma ng mga string sa isang pattern
(nang hindi talaga tumutugma sa alinman sa mga ito).

'aaab' =~ /a+b?(?{print "$&\n"; $count++})(*FAIL)/;
i-print ang "Count=$count\n";

na gumagawa ng:

aaaand
aaa
aa
a
aab
aa
a
ab
a
Bilang=9

Kung magdaragdag tayo ng "(*PRUNE)" bago ang bilang tulad ng sumusunod

'aaab' =~ /a+b?(*PRUNE)(?{print "$&\n"; $count++})(*FAIL)/;
i-print ang "Count=$count\n";

pinipigilan namin ang pag-backtrack at hinahanap ang bilang ng pinakamahabang pagtutugma ng string sa bawat isa
tumutugma sa panimulang punto tulad nito:

aaaand
aab
ab
Bilang=3

Anumang bilang ng "(*PRUNE)" assertion ay maaaring gamitin sa isang pattern.

Tingnan din ang "(?>pattern)" at possessive quantifier para sa iba pang paraan ng pagkontrol
pag-urong. Sa ilang mga kaso, ang paggamit ng "(*PRUNE)" ay maaaring palitan ng a
"(?>pattern)" na walang pagkakaiba sa pagganap; gayunpaman, maaaring gamitin ang "(*PRUNE)".
pangasiwaan ang mga kaso na hindi maaaring ipahayag gamit ang isang "(?>pattern)" nang mag-isa.

"(*SKIP)" "(*SKIP:NAME)"
Ang pattern na zero-width na ito ay katulad ng "(*PRUNE)", maliban na rin sa pagkabigo
nangangahulugang anumang teksto ang naitugma na humahantong sa pattern na "(*SKIP)".
ang pinapatay ay hindi maaaring maging bahagi ng anumang tugma ng pattern na ito. Ito ay epektibong nangangahulugan
na ang regex engine ay "lumilaklak" pasulong sa posisyong ito sa pagkabigo at sinusubukang gawin
tugma muli, (ipagpalagay na may sapat na puwang upang tumugma).

Ang pangalan ng pattern na "(*SKIP:NAME)" ay may espesyal na kahalagahan. Kung a
"(*MARK:NAME)" ay na-encounter habang tumutugma, pagkatapos ay ang posisyon na iyon
ginamit bilang "skip point". Kung walang na-encounter na "(*MARK)" ng pangalang iyon, ang
Ang operator ng "(*SKIP)" ay walang epekto. Kapag ginamit nang walang pangalan ang "skip point" ay
kung saan ang tugmang punto ay noong isinasagawa ang (*SKIP) pattern.

Ihambing ang sumusunod sa mga halimbawa sa "(*PRUNE)"; tandaan ang string ay dalawang beses bilang
mahaba:

'aaabaaab' =~ /a+b?(*SKIP)(?{print "$&\n"; $count++})(*FAIL)/;
i-print ang "Count=$count\n";

output

aaaand
aaaand
Bilang=2

Kapag ang 'aaab' sa simula ng string ay tumugma, at ang "(*SKIP)" ay naisakatuparan,
ang susunod na panimulang punto ay kung saan ang cursor ay kung kailan ang "(*SKIP)".
pinatay.

"(*MARK:NAME)" "(*:NAME)"
Ang zero-width na pattern na ito ay maaaring gamitin upang markahan ang puntong naabot sa isang string kapag a
ang ilang bahagi ng pattern ay matagumpay na naitugma. Ang markang ito ay maaaring bigyan ng a
pangalan. Ang susunod na "(*SKIP)" na pattern ay lalaktawan pasulong sa puntong iyon kung iurong
sa kabiguan. Ang anumang bilang ng mga pattern na "(*MARK)" ay pinapayagan, at ang bahagi ng NAME
maaaring doblehin.

Bilang karagdagan sa pakikipag-ugnayan sa pattern na "(*SKIP)," maaaring gamitin ang "(*MARK:NAME)"
upang "lagyan ng label" ang isang sangay ng pattern, upang pagkatapos ng pagtutugma, matukoy ng programa
kung aling mga sangay ng pattern ang kasangkot sa tugma.

Kapag matagumpay ang isang laban, ang $REGMARK variable ay itatakda sa pangalan ng
pinakakamakailang naisakatuparan ang "(*MARK:NAME)" na kasama sa laban.

Magagamit ito upang matukoy kung aling sangay ng isang pattern ang naitugma nang hindi gumagamit ng a
hiwalay na pangkat ng pagkuha para sa bawat sangay, na maaaring magresulta sa isang pagganap
pagpapabuti, dahil hindi mai-optimize ng perl ang "/(?:(x)|(y)|(z))/" nang kasinghusay ng
parang "/(?:x(*MARK:x)|y(*MARK:y)|z(*MARK:z))/".

Kapag nabigo ang isang tugma, at maliban kung may ibang pandiwa na nasangkot sa pagkabigo sa
tugma at nagbigay ng sarili nitong pangalan na gagamitin, ang $REGERROR variable ay itatakda sa
ang pangalan ng pinakakamakailang naisakatuparan na "(*MARK:NAME)".

Tingnan ang "(*SKIP)" para sa higit pang mga detalye.

Bilang isang shortcut na "(*MARK:NAME)" ay maaaring isulat na "(*:NAME)".

"(*THEN)" "(*THEN:NAME)"
Ito ay katulad ng operator na "cut group" na "::" mula sa Perl 6. Tulad ng "(*PRUNE)",
ang pandiwa na ito ay palaging tumutugma, at kapag na-backtrack sa pagkabigo, nagiging sanhi ito ng regex
engine upang subukan ang susunod na paghalili sa pinakaloob na nakapaloob na grupo (pagkuha o
kung hindi) na may mga paghahalili. Ang dalawang sangay ng a
"(?(kondisyon)yes-pattern|no-pattern)" ay hindi binibilang bilang isang kahalili, hangga't
"(*THEN)" ay nag-aalala.

Ang pangalan nito ay nagmula sa obserbasyon na ang operasyong ito ay pinagsama sa
alternation operator ("|") ay maaaring gamitin upang lumikha ng kung ano ang mahalagang pattern-
batay sa kung / pagkatapos / iba pang bloke:

( COND (*THEN) FOO | COND2 (*THEN) BAR | COND3 (*THEN) BAZ )

Tandaan na kung ang operator na ito ay ginagamit at HINDI sa loob ng isang kahalili, ito ay kumikilos
eksakto tulad ng "(*PRUNE)" operator.

/ A (*PRUNE) B /

ay pareho

/ A (*TAON) B /

pero

/ ( A (*TAPOS) B | C ) /

ay hindi pareho

/ ( A (*PRUNE) B | C ) /

bilang pagkatapos itugma ang A ngunit nabigo sa B ang "(*THEN)" na pandiwa ay uurong at
subukan ang C; ngunit ang "(*PRUNE)" na pandiwa ay mabibigo lamang.

Mga pandiwa na walang argumento
"(*COMMIT)"
Ito ang Perl 6 "commit pattern" " " o ":::". Isa itong pattern na zero-width
katulad ng "(*SKIP)", maliban na kapag na-backtrack sa pagkabigo ito ay nagiging sanhi ng
tugma para tuluyang mabigo. Walang karagdagang pagtatangka upang makahanap ng wastong tugma sa pamamagitan ng pagsulong sa
magaganap muli ang start pointer. Halimbawa,

'aaabaaab' =~ /a+b?(*COMMIT)(?{print "$&\n"; $count++})(*FAIL)/;
i-print ang "Count=$count\n";

output

aaaand
Bilang=1

Sa madaling salita, kapag ang "(*COMMIT)" ay naipasok na, at kung ang pattern ay hindi
tugma, hindi susubukan ng regex engine ang anumang karagdagang pagtutugma sa iba pang bahagi ng
string.

"(*FAIL)" "(*F)"
Ang pattern na ito ay walang tugma at palaging nabigo. Maaari itong magamit upang pilitin ang makina
upang i-backtrack. Ito ay katumbas ng "(?!)", ngunit mas madaling basahin. Sa katunayan, ang "(?!)" ay nakukuha
na-optimize sa "(*FAIL)" sa loob.

Malamang na ito ay kapaki-pakinabang lamang kapag pinagsama sa "(?{})" o "(??{})".

"(*TANGGAPIN)"
Ang pattern na ito ay walang tumutugma at nagiging sanhi ng pagtatapos ng matagumpay na pagtutugma sa punto
kung saan nakatagpo ang pattern na "(*ACCEPT)", hindi alintana kung mayroon
actually mas to match sa string. Kapag nasa loob ng isang nested pattern, gaya ng
recursion, o sa isang subpattern na dynamic na nabuo sa pamamagitan ng "(??{})", tanging ang
Ang pinakaloob na pattern ay natapos kaagad.

Kung ang "(*ACCEPT)" ay nasa loob ng pagkuha ng mga grupo, ang mga grupo ay mamarkahan bilang
natapos sa punto kung saan na-encounter ang "(*ACCEPT)". Halimbawa:

'AB' =~ /(A (A|B(*TANGGAPIN)|C) D)(E)/x;

ay tutugma, at $1 ay magiging "AB" at $2 ay magiging "B", $3 ay hindi itatakda. Kung iba
itinugma ang sangay sa mga panloob na panaklong, tulad ng sa string na 'ACDE', pagkatapos ay ang
Ang "D" at "E" ay kailangang itugma rin.

Backtracking
TANDAAN: Ang seksyong ito ay nagpapakita ng abstract na pagtatantya ng pag-uugali ng regular na expression. Para sa
isang mas mahigpit (at masalimuot) na pagtingin sa mga panuntunang kasangkot sa pagpili ng tugma sa pagitan
posibleng mga alternatibo, tingnan ang "Pagsasama-sama ng RE Pieces".

Ang isang pangunahing tampok ng regular na pagtutugma ng expression ay kinabibilangan ng paniwala na tinatawag
pag-backtrack, na kasalukuyang ginagamit (kapag kinakailangan) ng lahat ng regular na hindi nagmamay-ari
mga expression quantifier, katulad ng "*", "*?", "+", "+?", "{n,m}", at "{n,m}?". Backtracking
ay madalas na na-optimize sa loob, ngunit ang pangkalahatang prinsipyo na nakabalangkas dito ay wasto.

Para magkatugma ang isang regular na expression, ang buo ang regular na expression ay dapat tumugma, hindi lamang bahagi
nito. Kaya kung ang simula ng isang pattern na naglalaman ng isang quantifier ay magtagumpay sa isang paraan na
nagiging sanhi ng pagbagsak sa mga susunod na bahagi sa pattern, ang katugmang engine ay nagba-back up at muling nagkalkula
ang simulang bahagi--kaya naman tinatawag itong backtracking.

Narito ang isang halimbawa ng backtracking: Sabihin nating gusto mong hanapin ang salitang kasunod ng "foo"
sa string na "Nasa foo table ang pagkain.":

$_ = "Nasa foo table ang pagkain.";
kung ( /\b(foo)\s+(\w+)/i ) {
print "Ang $2 ay sumusunod sa $1.\n";
}

Kapag tumakbo ang laban, ang unang bahagi ng regular na expression ("\b(foo)") ay makakahanap ng posible
tumugma mismo sa simula ng string, at naglo-load ng $1 ng "Foo". Gayunpaman, sa lalong madaling panahon
dahil nakikita ng tumutugmang makina na walang whitespace na sumusunod sa "Foo" na mayroon ito
naka-save sa $1, napagtanto nito ang pagkakamali nito at magsisimulang muli ng isang character pagkatapos kung saan ito
nagkaroon ng pansamantalang laban. Sa pagkakataong ito ay nagpapatuloy ito hanggang sa susunod na paglitaw ng
"foo". Ang kumpletong regular na expression ay tumutugma sa oras na ito, at makukuha mo ang inaasahang output
ng "table follows foo."

Minsan malaki ang maitutulong ng kaunting pagtutugma. Isipin na gusto mong itugma ang lahat sa pagitan
"foo" at "bar". Sa una, sumulat ka ng ganito:

$_ = "Ang pagkain ay nasa ilalim ng bar sa kamalig.";
kung ( /foo(.*)bar/ ) {
i-print ang "nakuha <$1>\n";
}

Na marahil ay hindi inaasahang nagbubunga:

nakuha

Iyon ay dahil ".*" ay matakaw, kaya nakukuha mo ang lahat sa pagitan ng una "foo" at ang huli
"bar". Dito mas epektibong gumamit ng minimal na pagtutugma para matiyak na makukuha mo ang text
sa pagitan ng isang "foo" at ang unang "bar" pagkatapos noon.

if ( /foo(.*?)bar/ ) { print "nakuha <$1>\n" }
nakuha

Narito ang isa pang halimbawa. Sabihin nating gusto mong itugma ang isang numero sa dulo ng isang string, at
gusto mo ring panatilihin ang naunang bahagi ng laban. Kaya isulat mo ito:

$_ = "Mayroon akong 2 numero: 53147";
kung ( /(.*)(\d*)/ ) { # Mali!
print "Ang simula ay <$1>, ang numero ay <$2>.\n";
}

Hindi iyon gagana, dahil ".*" ay matakaw at nilamon ang buong string. Bilang "\d*"
maaaring tumugma sa isang walang laman na string ang kumpletong regular na expression na matagumpay na naitugma.

Ang simula ay , ang numero ay <>.

Narito ang ilang variant, karamihan sa mga ito ay hindi gumagana:

$_ = "Mayroon akong 2 numero: 53147";
@pats = qw{
(.*)(\d*)
(.*)(\d+)
(.*?)(\d*)
(.*?)(\d+)
(.*)(\d+)$
(.*?)(\d+)$
(.*)\b(\d+)$
(.*\D)(\d+)$
};

para kay $pat (@pats) {
printf "%-12s", $pat;
kung ( /$pat/ ) {
i-print ang "<$1> <$2>\n";
} Iba pa {
i-print ang "FAIL\n";
}
}

Iyan ay magpi-print:

(.*)(\d*) <>
(.*)(\d+) <2>
(.*?)(\d*) <> <>
(.*?)(\d+) <2>
(.*)(\d+)$ <2>
(.*?)(\d+)$ <2>
(.*)\b(\d+)$ <2>
(.*\D)(\d+)$ <2>

Tulad ng nakikita mo, ito ay maaaring medyo nakakalito. Mahalagang mapagtanto na ang isang regular na expression
ay isang hanay lamang ng mga pahayag na nagbibigay ng kahulugan ng tagumpay. Maaaring mayroong 0, 1, o
ilang iba't ibang paraan na maaaring magtagumpay ang kahulugan laban sa isang partikular na string. At
kung maraming paraan kung paano ito magtagumpay, kailangan mong maunawaan ang backtracking upang malaman
kung aling iba't ibang tagumpay ang iyong makakamit.

Kapag gumagamit ng mga assertion at negasyon na tumingin sa unahan, maaari itong maging mas nakakalito. Imagine
gusto mong humanap ng sequence ng mga non-digit na hindi sinusundan ng "123". Baka subukan mong magsulat
ganyan

$_ = "ABC123";
kung ( /^\D*(?!123)/ ) { # Mali!
print "Oo, walang 123 sa $_\n";
}

Ngunit hindi iyon magkatugma; at least, hindi sa paraang iyong inaasahan. Sinasabi nito na doon
ay walang 123 sa string. Narito ang isang mas malinaw na larawan kung bakit tumutugma ang pattern na iyon, salungat
sa mga tanyag na inaasahan:

$x = 'ABC123';
$y = 'ABC445';

i-print ang "1: nakakuha ng $1\n" kung $x =~ /^(ABC)(?!123)/;
print "2: nakakuha ng $1\n" kung $y =~ /^(ABC)(?!123)/;

print "3: nakakuha ng $1\n" kung $x =~ /^(\D*)(?!123)/;
print "4: nakakuha ng $1\n" kung $y =~ /^(\D*)(?!123)/;

Ito ay nagpi-print

2: nakakuha ng ABC
3: nakakuha ng AB
4: nakakuha ng ABC

Maaaring inaasahan mong mabibigo ang pagsubok 3 dahil ito ay tila isang mas pangkalahatang layunin na bersyon
ng pagsubok 1. Ang mahalagang pagkakaiba sa pagitan nila ay ang pagsusulit 3 ay naglalaman ng isang quantifier
("\D*") at sa gayon ay maaaring gumamit ng backtracking, samantalang ang pagsubok 1 ay hindi. Ano ba ang nangyayari
nagtanong ka ng "Totoo ba na sa simula ng $x, kasunod ng 0 o higit pang mga hindi digit, mayroon kang
isang bagay na hindi 123?" Kung hinayaan ng pattern matcher na lumawak ang "\D*" sa "ABC", ito
magiging sanhi ng pagkabigo ng buong pattern.

Ang search engine ay unang tutugma sa "\D*" sa "ABC". Pagkatapos ay susubukan nitong tumugma
"(?!123)" na may "123", na nabigo. Ngunit dahil ang isang quantifier ("\D*") ay ginamit sa
regular na expression, maaaring i-backtrack ng search engine at subukang muli ang tugma sa ibang paraan sa
pag-asa na tumugma sa kumpletong regular na expression.

Ang pattern talaga, Talaga gustong magtagumpay, kaya ginagamit nito ang karaniwang pattern na back-off-and-
subukang muli at hayaan ang "\D*" na lumawak sa "AB" lang sa pagkakataong ito. Ngayon ay mayroon na talagang isang bagay
sumusunod sa "AB" na hindi "123". Ito ay "C123", na sapat na.

Maaari nating harapin ito sa pamamagitan ng paggamit ng parehong assertion at isang negation. Sasabihin natin na ang una
bahagi sa $1 ay dapat na sundan ng isang digit at ng isang bagay na hindi "123". Tandaan
na ang mga tingin sa unahan ay mga zero-width na expression--tumingin lamang sila, ngunit hindi gumagamit ng alinman sa
ang tali sa kanilang laban. Kaya ang muling pagsusulat sa paraang ito ay nagbubunga ng kung ano ang iyong inaasahan; ibig sabihin,
ang kaso 5 ay mabibigo, ngunit ang kaso 6 ay nagtagumpay:

print "5: nakakuha ng $1\n" kung $x =~ /^(\D*)(?=\d)(?!123)/;
print "6: nakakuha ng $1\n" kung $y =~ /^(\D*)(?=\d)(?!123)/;

6: nakakuha ng ABC

Sa madaling salita, ang dalawang zero-width na assertion sa tabi ng isa't isa ay gumagana na parang sila
AT magkasama, tulad ng paggamit mo ng anumang mga built-in na assertion: "/^$/" ay tumutugma lang kung ikaw ay
sa simula ng linya AT sa dulo ng linya nang sabay-sabay. Ang mas malalim
ang pinagbabatayan ng katotohanan ay ang pagkakatugma sa mga regular na expression ay palaging nangangahulugang AT, maliban
kapag sumulat ka ng tahasang O gamit ang vertical bar. Ang ibig sabihin ng "/ab/" ay tumutugma sa "a" AT (pagkatapos)
tumugma sa "b", bagama't ang mga sinubukang tugma ay ginawa sa iba't ibang posisyon dahil ang "a" ay
hindi isang zero-width assertion, ngunit isang one-width na assertion.

BABALA: Ang partikular na kumplikadong mga regular na expression ay maaaring tumagal ng exponential na oras upang malutas
dahil sa napakaraming posibleng paraan na magagamit nila ang backtracking upang subukan ang a
tugma. Halimbawa, nang walang mga panloob na pag-optimize na ginagawa ng regular na expression engine,
ito ay aabutin ng isang masakit na mahabang oras upang tumakbo:

'aaaaaaaaaaaa' =~ /((a{0,5}){0,5})*[c]/

At kung ginamit mo ang "*" sa mga panloob na grupo sa halip na limitahan ang mga ito sa 0 hanggang 5
mga tugma, pagkatapos ay magtatagal ito nang walang hanggan--o hanggang sa maubusan ka ng stack space. Bukod dito, ang mga ito
hindi palaging naaangkop ang mga panloob na pag-optimize. Halimbawa, kung "{0,5}" ang ilalagay mo sa halip
ng "*" sa panlabas na pangkat, walang kasalukuyang pag-optimize ang naaangkop, at ang tugma ay tumatagal ng a
matagal bago matapos.

Ang isang makapangyarihang tool para sa pag-optimize ng gayong mga hayop ay ang kilala bilang isang "independiyenteng grupo",
na hindi umuurong (tingnan ang ""(?>pattern)""). Tandaan din na zero-length
hindi mag-uurong ang mga pagtingin sa unahan/tingin-likod para magkatugma ang buntot, dahil sila
ay nasa "lohikal" na konteksto: tanging kung ang mga ito ay tumutugma ay itinuturing na may kaugnayan. Para sa isang halimbawa
kung saan side-effects ng look-ahead maaari naimpluwensyahan ang sumusunod na laban, tingnan
""(?>pattern)"".

bersyon 8 regular expression
Kung sakaling hindi ka pamilyar sa "regular" na Bersyon 8 regex routines, narito ang
mga panuntunan sa pagtutugma ng pattern na hindi inilarawan sa itaas.

Ang anumang solong karakter ay tumutugma sa sarili nito, maliban kung ito ay a metacharacter na may espesyal na kahulugan
inilarawan dito o sa itaas. Maaari kang maging sanhi ng mga character na karaniwang gumagana bilang
metacharacter na literal na bigyang-kahulugan sa pamamagitan ng paglalagay ng prefix sa kanila ng "\" (hal., "\."
tumutugma sa isang ".", hindi sa anumang karakter; Ang "\\" ay tumutugma sa isang "\"). Ang mekanismo ng pagtakas na ito ay din
kinakailangan para sa karakter na ginamit bilang delimiter ng pattern.

Isang serye ng mga character ang tumutugma sa serye ng mga character sa target na string, kaya ang
ang pattern na "blurfl" ay tutugma sa "blurfl" sa target na string.

Maaari kang tumukoy ng klase ng character, sa pamamagitan ng paglalagay ng listahan ng mga character sa "[]", na gagawin
tumugma sa anumang karakter mula sa listahan. Kung ang unang character pagkatapos ng "[" ay "^", ang klase
tumutugma sa anumang karakter na wala sa listahan. Sa loob ng isang listahan, ang karakter na "-" ay tumutukoy sa a
range, upang ang "az" ay kumakatawan sa lahat ng mga character sa pagitan ng "a" at "z", kasama. Kung ikaw
gusto mong maging miyembro ng isang klase ang alinman sa "-" o "]", ilagay ito sa simula ng listahan
(maaaring pagkatapos ng "^"), o takasan ito gamit ang isang backslash. Ang "-" ay literal ding kinuha kapag
ito ay nasa dulo ng listahan, bago ang pagsasara ng "]". (Ang lahat ng sumusunod ay tumutukoy sa
parehong klase ng tatlong character: "[-az]", "[az-]", at "[a\-z]". Lahat ay iba sa
"[az]", na tumutukoy sa isang klase na naglalaman ng dalawampu't anim na character, kahit na sa EBCDIC-based
set ng character.) Gayundin, kung susubukan mong gamitin ang mga klase ng character na "\w", "\W", "\s", "\S",
"\d", o "\D" bilang mga endpoint ng isang range, literal na nauunawaan ang "-".

Tandaan din na ang ideya ng buong hanay ay medyo hindi madadala sa pagitan ng mga set ng character, maliban
para sa apat na sitwasyon na espesyal na pinangangasiwaan ni Perl. Anumang subset ng mga saklaw na "[AZ]",
Ang "[az]", at "[0-9]" ay garantisadong tumutugma sa inaasahang subset ng mga ASCII na character, hindi
mahalaga kung anong set ng character ang pinapatakbo ng platform. Ang ikaapat na portable na paraan upang tukuyin
Ang mga saklaw ay ang paggamit ng "\N{...}" na syntax upang tukuyin ang alinman sa dulong punto ng hanay. Para sa
halimbawa, ang ibig sabihin ng "[\N{U+04}-\N{U+07}]" ay tumugma sa mga punto ng Unicode code na "\N{U+04}",
"\N{U+05}", "\N{U+06}", at "\N{U+07}", anuman ang kanilang mga native na halaga sa
plataporma. Sa ilalim ng paggamit ng 'mahigpit' o sa loob ng ""(?[ ])"", isang babala ang itinaas, kung pinagana,
at ang kabilang dulong punto ng isang hanay na may "\N{...}" na endpoint ay hindi madadala
tinukoy. Halimbawa,

[\N{U+00}-\x06] # Babala sa ilalim ng "use re 'strict'".

Mahirap maunawaan nang hindi hinuhukay kung ano ang eksaktong tumutugma sa mga saklaw maliban sa mga subset ng
"[AZ]", "[az]", at "[0-9]". Ang isang mahusay na prinsipyo ay ang paggamit lamang ng mga hanay na nagsisimula sa
at magtatapos sa alinman sa mga alpabetikong may pantay na titik ([ae], [AE]), o mga digit ([0-9]). Kahit ano
ang iba ay hindi ligtas o hindi malinaw. Kung may pagdududa, baybayin nang buo ang hanay.

Maaaring tukuyin ang mga character gamit ang isang metacharacter syntax na katulad ng ginamit sa C: "\n"
tumutugma sa isang bagong linya, "\t" isang tab, "\r" isang carriage return, "\f" isang form feed, atbp. Higit pa
sa pangkalahatan, \nnn, Kung saan nnn ay isang string ng tatlong octal digit, tumutugma sa character na kung saan
naka-code na halaga ng set ng character ay nnn. Katulad nito, \xnn, Kung saan nn ay mga hexadecimal digit,
tumutugma sa karakter na ang ordinal ay nn. Ang ekspresyong \cx tumutugma sa karakter
kontrol-x. Sa wakas, ang "." tumutugma ang metacharacter sa anumang karakter maliban sa "\n" (maliban kung ikaw
gamitin ang "/s").

Maaari mong tukuyin ang isang serye ng mga alternatibo para sa isang pattern gamit ang "|" para paghiwalayin sila, para
Ang "fee|fie|foe" ay tutugma sa alinman sa "fee", "fie", o "foe" sa target string (gaya ng gagawin
"f(e|i|o)e"). Kasama sa unang alternatibo ang lahat mula sa huling pattern delimiter
("(", "(?:", atbp. o ang simula ng pattern) hanggang sa unang "|", at ang huli
Ang alternatibo ay naglalaman ng lahat mula sa huling "|" sa susunod na closing pattern delimiter.
Iyon ang dahilan kung bakit karaniwang kasanayan na magsama ng mga alternatibo sa panaklong: upang mabawasan
pagkalito tungkol sa kung saan sila magsisimula at magtatapos.

Ang mga alternatibo ay sinubukan mula kaliwa hanggang kanan, kaya ang unang alternatibo ay natagpuan kung saan ang
buong expression na tumutugma, ay ang isa na pinili. Nangangahulugan ito na ang mga alternatibo ay hindi
kinakailangang gahaman. Halimbawa: kapag itinutugma ang "foo|foot" laban sa "barefoot", tanging ang
Magtutugma ang "foo" na bahagi, dahil iyon ang unang alternatibong sinubukan, at matagumpay itong tumutugma
ang target na string. (Maaaring hindi ito mukhang mahalaga, ngunit ito ay mahalaga kapag ikaw ay
pagkuha ng katugmang teksto gamit ang mga panaklong.)

Tandaan din na "|" ay binibigyang-kahulugan bilang literal sa loob ng mga square bracket, kaya kung isusulat mo
"[fee|fie|foe]" kaparehas lang talaga ng "[feio|]".

Sa loob ng isang pattern, maaari kang magtalaga ng mga subpattern para sa sanggunian sa ibang pagkakataon sa pamamagitan ng paglalagay ng mga ito
panaklong, at maaari kang sumangguni pabalik sa nika-subpattern mamaya sa pattern gamit ang
metacharacter \n o \gn. Ang mga subpattern ay binibilang batay sa kaliwa hanggang kanang pagkakasunud-sunod ng
kanilang pambungad na panaklong. Ang isang backreference ay tumutugma sa anumang aktwal na tumugma sa
subpattern sa string na sinusuri, hindi ang mga panuntunan para sa subpattern na iyon. Samakatuwid,
"(0|0x)\d*\s\g1\d*" ay tutugma sa "0x1234 0x4321", ngunit hindi sa "0x1234 01234", dahil subpattern
1 ang tumugma sa "0x", kahit na ang panuntunang "0|0x" ay posibleng tumugma sa nangungunang 0 sa
pangalawang numero.

babala on \1 Sa halip of $1
Ang ilang mga tao ay masyadong nasanay sa pagsusulat ng mga bagay tulad ng:

$pattern =~ s/(\W)/\\\1/g;

Ito ay lolo (para sa \1 hanggang \9) para sa RHS ng isang kahalili upang maiwasang mabigla ang uhaw
mga adik, pero maduming ugali ang pasukin. Iyon ay dahil sa PerlThink, ang kanang kamay
Ang gilid ng isang "s///" ay isang double-quoted na string. "\1" sa karaniwang ibig sabihin ng double-quoted na string
isang kontrol-A. Ang nakagawiang kahulugan ng Unix ng "\1" ay nakalagay sa "s///". Gayunpaman, kung
nakaugalian mong gawin iyon, malalagay ka sa gulo kung saka ka magdadagdag ng
"/e" modifier.

s/(\d+)/ \1 + 1 /hal; # nagiging sanhi ng babala sa ilalim ng -w

O kung susubukan mong gawin

s/(\d+)/\1000/;

Hindi mo maaaring i-disambiguate iyon sa pamamagitan ng pagsasabi ng "\{1}000", samantalang maaari mo itong ayusin gamit ang "${1}000".
Ang operasyon ng interpolation ay hindi dapat malito sa operasyon ng pagtutugma ng a
backreference. Tiyak na dalawang magkaibang bagay ang ibig nilang sabihin sa kaliwa gilid ng "s///".

Paulit-ulit Pattern Pagtutugma a Zero-length Substring
BABALA: Mahirap na materyal (at prosa) sa unahan. Ang seksyong ito ay nangangailangan ng muling pagsulat.

Ang mga regular na expression ay nagbibigay ng isang maikli at malakas na programming language. Tulad ng karamihan sa iba
mga tool sa kapangyarihan, ang kapangyarihan ay kasama ng kakayahang gumawa ng kalituhan.

Ang karaniwang pang-aabuso sa kapangyarihang ito ay nagmumula sa kakayahang gumawa ng walang katapusang mga loop gamit ang regular
mga expression, na may isang bagay na hindi nakapipinsala gaya ng:

'foo' =~ m{ ( o? )* }x;

Ang "o?" tumutugma sa simula ng 'foo', at dahil ang posisyon sa string ay hindi
naantig sa laban, "o?" ay magkatugma nang paulit-ulit dahil sa "*" na quantifier.
Ang isa pang karaniwang paraan upang lumikha ng katulad na cycle ay ang looping modifier na "//g":

@matches = ( 'foo' =~ m{ o? }xg );

or

i-print ang "tugma: <$&>\n" habang 'foo' =~ m{ o? }xg;

o ang loop na ipinahiwatig ng hatiin ().

Gayunpaman, ipinakita ng mahabang karanasan na maraming mga gawain sa programming ang maaaring maging makabuluhan
pinasimple sa pamamagitan ng paggamit ng mga paulit-ulit na subexpression na maaaring tumugma sa zero-length na mga substring. eto
isang simpleng halimbawa ay:

@chars = hati //, $string; # // ay hindi magic sa split
($whitewashed = $string) =~ s/()/ /g; # mga magulang umiiwas sa mahika s// /

Kaya pinahihintulutan ng Perl ang gayong mga konstruksyon, sa pamamagitan ng malakas pagsira ang walang katapusan silo. Ang mga patakaran para sa
iba ito para sa mga loop na mas mababang antas na ibinigay ng mga matakaw na quantifier na "*+{}", at para sa
mas mataas na antas tulad ng "/g" modifier o hatiin () operator

Ang mas mababang antas na mga loop ay nagambala (iyon ay, nasira ang loop) kapag nakita iyon ni Perl
isang paulit-ulit na expression ang tumugma sa isang zero-length na substring. Sa gayon

m{ (?: NON_ZERO_LENGTH | ZERO_LENGTH )* }x;

ay ginawang katumbas ng

m{ (?: NON_ZERO_LENGTH )* (?: ZERO_LENGTH )? }x;

Halimbawa, ang programang ito

#!perl -l
"aaaab" =~ /
(?:
isang # non-zero
| # o
(?{print "hello"}) # print hello tuwing ganito
# branch ang sinubukan
(?=(b)) # zero-width assertion
)* # anumang bilang ng beses
/x;
i-print ang $&;
i-print ang $1;

mga kopya

hoy
aaaaa
b

Pansinin na ang "hello" ay isang beses lang naka-print, gaya nang makita ni Perl na ang ikaanim na pag-ulit ng
ang pinakalabas na "(?:)*" ay tumutugma sa isang zero-length na string, ito ay humihinto sa "*".

Ang mga loop na may mataas na antas ay nagpapanatili ng karagdagang estado sa pagitan ng mga pag-ulit: kung ang huli
zero-length ang laban. Upang masira ang loop, ang sumusunod na tugma pagkatapos ng isang zero-length na tugma
ay ipinagbabawal na magkaroon ng haba na zero. Ang pagbabawal na ito ay nakikipag-ugnayan sa backtracking (tingnan
"Backtracking"), at kaya ang pangalawa pinakamahusay tugma ang pipiliin kung ang pinakamahusay ang tugma ay zero
haba.

Halimbawa:

$_ = 'bar';
s/\w??/<$&>/g;

mga resulta sa "<> <> <> <>". Sa bawat posisyon ng string ang pinakamahusay na tugma na ibinigay ng
hindi matakaw "??" ay ang zero-length na tugma, at ang pangalawa pinakamahusay tugma ay kung ano ang itinutugma ng
"\w". Kaya't ang zero-length na mga tugma ay kahalili ng isang-character-long mga tugma.

Katulad nito, para sa paulit-ulit na "m/()/g" ang pangalawang pinakamahusay na tugma ay ang tugma sa posisyon ng isa
bingaw pa sa string.

Ang karagdagang estado ng pagiging naitugma sa zero-length ay nauugnay sa katugmang
string, at ni-reset ng bawat pagtatalaga sa pos(). Zero-length na mga tugma sa dulo ng
hindi pinapansin ang nakaraang tugma sa panahon ng "split".

Pagsasama RE Piraso
Ang bawat isa sa mga elementarya na piraso ng mga regular na expression na inilarawan dati (tulad ng
Ang "ab" o "\Z") ​​ay maaaring tumugma sa hindi hihigit sa isang substring sa ibinigay na posisyon ng input string.
Gayunpaman, sa isang tipikal na regular na expression ang mga elementong ito ay pinagsama sa higit pa
kumplikadong mga pattern gamit ang pinagsamang mga operator na "ST", "S|T", "S*" atbp. (sa mga halimbawang ito
Ang "S" at "T" ay mga regular na subexpression).

Ang ganitong mga kumbinasyon ay maaaring magsama ng mga alternatibo, na humahantong sa isang problema ng pagpili: kung itugma natin ang a
regular na expression na "a|ab" laban sa "abc", tutugma ba ito sa substring na "a" o "ab"? Isang paraan upang
ilarawan kung aling substring ang aktwal na tumugma ay ang konsepto ng backtracking (tingnan
"Backtracking"). Gayunpaman, ang paglalarawang ito ay masyadong mababa ang antas at ginagawa kang mag-isip sa mga tuntunin
ng isang partikular na pagpapatupad.

Ang isa pang paglalarawan ay nagsisimula sa mga ideya ng "mas mabuti"/"mas malala". Lahat ng mga substring na maaaring
maitugma ng ibinigay na regular na expression ay maaaring pag-uri-uriin mula sa "pinakamahusay" na tugma sa
"pinakamasama" na tugma, at ito ang "pinakamahusay" na tugma na pipiliin. Pinapalitan nito ang tanong
ng "ano ang napili?" sa pamamagitan ng tanong na "aling mga tugma ang mas mahusay, at alin ang mas masahol?".

Muli, para sa mga elementong elementarya ay walang ganoong tanong, dahil hindi hihigit sa isang tugma sa isang naibigay
posisyon ay posible. Inilalarawan ng seksyong ito ang paniwala ng mas mabuti/mas masahol para sa pagsasama-sama
mga operator. Sa paglalarawan sa ibaba ang "S" at "T" ay mga regular na subexpression.

"ST"
Isaalang-alang ang dalawang posibleng tugma, "AB" at "A'B'", "A" at "A'" ay mga substring na maaaring
na itugma sa pamamagitan ng "S", "B" at "B'" ay mga substring na maaaring itugma ng "T".

Kung ang "A" ay mas mahusay na tugma para sa "S" kaysa sa "A'", ang "AB" ay isang mas mahusay na tugma kaysa sa "A'B'".

Kung ang "A" at "A'" ay magkatugma: "AB" ay isang mas mahusay na tugma kaysa "AB'" kung "B" ay isang mas mahusay na tugma
para sa "T" kaysa sa "B'".

"S|T"
Kapag ang "S" ay maaaring tumugma, ito ay isang mas mahusay na tugma kaysa kapag ang "T" lamang ang maaaring tumugma.

Ang pag-order ng dalawang tugma para sa "S" ay kapareho ng para sa "S". Katulad para sa dalawang tugma para sa
"T".

"S{REPEAT_COUNT}"
Tumutugma bilang "SSS...S" (naulit nang maraming beses kung kinakailangan).

"S{min,max}"
Tumutugma bilang "S{max}|S{max-1}|...|S{min+1}|S{min}".

"S{min,max}?"
Tumutugma bilang "S{min}|S{min+1}|...|S{max-1}|S{max}".

"S?", "S*", "S+"
Pareho sa "S{0,1}", "S{0,BIG_NUMBER}", "S{1,BIG_NUMBER}" ayon sa pagkakabanggit.

"S??", "S*?", "S+?"
Pareho sa "S{0,1}?", "S{0,BIG_NUMBER}?", "S{1,BIG_NUMBER}?" ayon sa pagkakabanggit.

"(?>S)"
Tumutugma sa pinakamahusay na tugma para sa "S" at iyon lang.

"(?=S)", "(?<=S)"
Tanging ang pinakamahusay na tugma para sa "S" ang isinasaalang-alang. (Ito ay mahalaga lamang kung ang "S" ay may
ang pagkuha ng mga panaklong, at mga backreference ay ginagamit sa ibang lugar sa buong regular
pagpapahayag.)

"(?! S)", "(?
Para sa operator ng pagpapangkat na ito ay hindi na kailangang ilarawan ang pag-order, dahil lamang
mahalaga man ang "S" o hindi.

"(??{ EXPR })", "(?PARNO)"
Ang pag-order ay kapareho ng para sa regular na expression na resulta ng EXPR, o
ang pattern na nilalaman ng pangkat ng pagkuha PARNO.

"(?(kondisyon)yes-pattern|no-pattern)"
Alalahanin na kung alin sa "yes-pattern" o "no-pattern" ang talagang tumutugma na
determinado. Ang pagkakasunud-sunod ng mga tugma ay kapareho ng para sa napiling subexpression.

Inilalarawan ng mga recipe sa itaas ang pag-order ng mga posporo at a naibigay na posisyon. Isa pang panuntunan ay
kailangan upang maunawaan kung paano tinutukoy ang isang tugma para sa buong regular na expression: isang tugma
sa isang mas naunang posisyon ay palaging mas mahusay kaysa sa isang laban sa isang mas huling posisyon.

Paglikha Pasadya RE Engine
Mula sa Perl 5.10.0, maaaring lumikha ang isa ng mga custom na regular na expression engine. Ito ay hindi para sa
mahina ang loob, dahil kailangan nilang magsaksak sa antas ng C. Tingnan ang perlreapi para sa higit pang mga detalye.

Bilang kahalili, ang mga overload na constant (tingnan ang sobrang karga) ay nagbibigay ng isang simpleng paraan upang mapalawak ang
functionality ng RE engine, sa pamamagitan ng pagpapalit ng isang pattern para sa isa pa.

Ipagpalagay na gusto naming paganahin ang isang bagong RE escape-sequence "\Y|" na tumutugma sa isang hangganan
sa pagitan ng mga character na whitespace at mga character na hindi whitespace. Tandaan na
"(?=\S)(?
"\Y|" sa lugar ng mas kumplikadong bersyon. Maaari tayong lumikha ng isang module na "customre" sa
gawin ito:

package customre;
gumamit ng labis na karga;

sub import {
shift;
mamatay "No argument to customre::import allowed" kung @_;
overload::constant 'qr' => \&convert;
}

sub invalid { mamatay "/$_[0]/: invalid escape '\\$_[1]'"}

# Dapat din nating ingatan na hindi makatakas sa lehitimong \\Y|
# sequence, kaya ang presensya ng '\\' sa mga panuntunan sa conversion.
my %rules = ( '\\' => '\\\\',
'Y|' => qr/(?=\S)(?
sub convert {
aking $re = shift;
$re =~ s{
\\ ( \\ | Y. )
}
{ $rules{$1} o invalid($re,$1) }sgex;
ibalik ang $re;
}

Ngayon ang "use customre" ay nagbibigay-daan sa bagong pagtakas sa mga regular na expression, ibig sabihin, ang mga iyon
nang walang anumang runtime variable interpolations. Gaya ng nakadokumento sa sobrang karga, ang conversion na ito
gagana lamang sa mga literal na bahagi ng mga regular na expression. Para sa "\Y|$re\Y|" ang variable
bahagi ng regular na expression na ito ay kailangang tahasang i-convert (ngunit kung ang espesyal na
kahulugan ng "\Y|" dapat paganahin sa loob ng $re):

gumamit ng customre;
$re = <>;
chomp $re;
$re = customre::convert $re;
/\Y|$re\Y|/;

Naka-embed na kodigo Pagpapatupad dalas
Ang eksaktong mga panuntunan para sa kung gaano kadalas (??{}) at (?{}) ay isinasagawa sa isang pattern ay hindi tinukoy.
Sa kaso ng isang matagumpay na laban maaari mong ipagpalagay na sila ay DWIM at isasagawa sa
kaliwa hanggang kanan mag-order ng naaangkop na bilang ng beses sa pagtanggap ng landas ng pattern
gaya ng iba pang meta-pattern. Paano nakakaapekto ang hindi pagtanggap na mga pathway at mga pagkabigo sa pagtutugma sa
ang bilang ng beses na ang isang pattern ay naisakatuparan ay partikular na hindi natukoy at maaaring mag-iba depende
sa kung anong mga pag-optimize ang maaaring ilapat sa pattern at malamang na magbago mula sa bersyon
sa bersyon.

Halimbawa sa

"aaabcdeeeee"=~/a(?{print "a"})b(?{print "b"})cde/;

ang eksaktong bilang ng beses na "a" o "b" ay na-print out ay hindi tinukoy para sa pagkabigo, ngunit ikaw
maaaring ipagpalagay na ang mga ito ay ipi-print nang hindi bababa sa isang beses sa panahon ng isang matagumpay na laban, bukod pa sa iyo
maaaring ipagpalagay na kung ang "b" ay nakalimbag, ito ay mauunahan ng hindi bababa sa isang "a".

Sa kaso ng mga branching construct tulad ng sumusunod:

/a(b|(?{ print "a" }))c(?{ print "c" })/;

maaari mong ipagpalagay na ang input na "ac" ay maglalabas ng "ac", at ang "abc" ay maglalabas lamang ng "c".

Kapag na-quantified ang naka-embed na code, ang mga matagumpay na tugma ay tatawag sa code nang isang beses para sa bawat isa
katugmang pag-ulit ng quantifier. Halimbawa:

"mabuti" =~ /g(?:o(?{print "o"}))*d/;

maglalabas ng "o" ng dalawang beses.

PCRE/Python Suporta
Mula sa Perl 5.10.0, sinusuportahan ng Perl ang ilang mga extension na partikular sa Python/PCRE sa regex
syntax. Habang ang Perl programmer ay hinihikayat na gamitin ang Perl-specific syntax, ang
tinatanggap din ang mga sumusunod:

"(?P pattern)"
Tukuyin ang isang pinangalanang pangkat ng pagkuha. Katumbas ng "(? pattern)".

"(? P=NAME)"
Backreference sa isang pinangalanang pangkat ng pagkuha. Katumbas ng "\g{NAME}".

"(?P>NAME)"
Subroutine na tawag sa isang pinangalanang pangkat ng pagkuha. Katumbas ng "(?&NAME)".

Gumamit ng perlre online gamit ang mga serbisyo ng onworks.net