perlreref - Online sa Cloud

PROGRAMA:

NAME

perlreref - Perl Regular Expressions Reference

DESCRIPTION

Ito ay isang mabilis na sanggunian sa mga regular na expression ni Perl. Para sa buong impormasyon tingnan ang perlre
at perlop, pati na rin ang seksyong "TINGNAN DIN" sa dokumentong ito.

OPERATOR
Tinutukoy ng "=~" kung aling variable ang inilalapat ng regex. Sa kawalan nito, $_ ang ginagamit.

$var =~ /foo/;

Tinutukoy ng "!~" kung aling variable ang regex ay inilapat, at tinatanggihan ang resulta ng
tugma; ito ay nagbabalik ng mali kung ang laban ay magtagumpay, at totoo kung ito ay nabigo.

$var !~ /foo/;

Ang "m/pattern/msixpogcdualn" ay naghahanap ng isang string para sa isang pattern na tugma, na inilalapat ang ibinigay
mga pagpipilian.

m Multiline mode - ^ at $ ay tumutugma sa mga panloob na linya
s tugma bilang Isang linya - . mga tugma \n
ako case-Insensitive
x Pinahabang pagiging madaling mabasa - libreng whitespace at mga komento
p Panatilihin ang isang kopya ng katugmang string -
${^PREMATCH}, ${^MATCH}, ${^POSTMATCH} ay tutukuyin.
o mag-compile ng pattern Minsan
g Global - lahat ng mga pangyayari
c huwag i-reset ang pos sa mga nabigong tugma kapag gumagamit ng /g
isang paghihigpit sa \d, \s, \w at [:posix:] upang tumugma lamang sa ASCII
aa (two a's) din ang /i na mga tugma ay hindi kasama ang ASCII/non-ASCII
l tumutugma ayon sa kasalukuyang lokal
tumutugma ka ayon sa mga patakaran ng Unicode
d tumugma ayon sa mga katutubong tuntunin maliban kung may nagsasaad
Unicode
n Non-capture mode. Huwag hayaang () punan ang $1, $2, atbp...

Kung ang 'pattern' ay isang walang laman na string, ang huli matagumpay ginagamit ang katugmang regex. Mga delimiter
maliban sa '/' ay maaaring gamitin para sa operator na ito at sa mga sumusunod. Ang nangungunang "m"
maaaring tanggalin kung ang delimiter ay '/'.

Hinahayaan ka ng "qr/pattern/msixpodualn" na mag-imbak ng regex sa isang variable, o magpasa ng isa sa paligid.
Ang mga modifier para sa "m//", at iniimbak sa loob ng regex.

Pinapalitan ng "s/pattern/replacement/msixpogcedual" ang mga tugma ng 'pattern' ng 'replacement'.
Mga modifier para sa "m//", na may dalawang karagdagan:

e Suriin ang 'kapalit' bilang isang expression
r Ibalik ang pagpapalit at iwanan ang orihinal na string na hindi nagalaw.

Maaaring tukuyin ang 'e' nang maraming beses. Ang 'kapalit' ay binibigyang kahulugan bilang dobleng sinipi
string maliban kung ang isang solong-quote ("'") ay ang delimiter.

"? pattern?" ay parang "m/pattern/" ngunit isang beses lang tumugma. Walang maaaring maging kahaliling mga delimiter
ginamit. Dapat i-reset sa i-reset().

SINTAX
\ Tinatakasan ang karakter kaagad na sumusunod dito
. Tumutugma sa anumang solong karakter maliban sa isang bagong linya (maliban kung ang /s ay
ginamit)
^ Mga tugma sa simula ng string (o linya, kung ginagamit ang /m)
$ Mga tugma sa dulo ng string (o linya, kung ginagamit ang /m)
* Tumutugma sa naunang elemento ng 0 o higit pang beses
+ Tumutugma sa naunang elemento ng 1 o higit pang beses
? Tumutugma sa naunang elemento 0 o 1 beses
{...} Tinutukoy ang isang hanay ng mga paglitaw para sa elementong nauuna rito
[...] Tumutugma sa alinman sa mga character na nasa loob ng mga bracket
(...) Mga subexpression ng pangkat para sa pagkuha sa $1, $2...
(?:...) Nagpangkat ng mga subexpression nang hindi kumukuha (cluster)
| Tumutugma sa alinman sa subexpression na nauuna o kasunod nito
\g1 o \g{1}, \g2 ... Tumutugma sa teksto mula sa Nth na pangkat
\1, \2, \3 ... Tumutugma sa teksto mula sa Nth na pangkat
\g-1 o \g{-1}, \g-2 ... Tumutugma sa teksto mula sa Nth nakaraang pangkat
\g{name} Pinangalanang backreference
\k Pinangalanang backreference
\k'name' Pinangalanang backreference
(?P=name) Pinangalanang backreference (python syntax)

Escape MGA PAGSUNOD
Gumagana ang mga ito tulad ng sa mga normal na string.

\a Alarm (beep)
\e Makatakas
\f Formfeed
\n Bagong linya
\r Pagbabalik ng karwahe
\t Tab
\037 Char na ang ordinal ay ang 3 octal na digit, max \777
\o{2307} Char na ang ordinal ay ang octal number, hindi pinaghihigpitan
\x7f Char na ang ordinal ay ang 2 hex digit, max \xFF
\x{263a} Char na ang ordinal ay ang hex na numero, hindi pinaghihigpitan
\cx Control-x
\N{name} Isang pinangalanang Unicode na character o pagkakasunud-sunod ng character
\N{U+263D} Isang Unicode na character sa pamamagitan ng hex ordinal

\l Maliit na titik ang susunod na character
\u Titlecase sa susunod na character
\L Maliit na titik hanggang \E
\Uppercase hanggang \E
\F Foldcase hanggang \E
\Q Huwag paganahin ang mga pattern na metacharacter hanggang \E
\E Tapusin ang pagbabago

Para sa Titlecase, tingnan ang "Titlecase".

Ang isang ito ay gumagana nang iba mula sa normal na mga string:

\b Isang assertion, hindi backspace, maliban sa isang klase ng character

CHARACTER KLASE
[amy] Itugma ang 'a', 'm' o 'y'
[fj] Tinukoy ng Dash ang "range"
[fj-] Ang Dash escaped o sa simula o dulo ay nangangahulugang 'dash'
[^fj] Isinasaad ng Caret ang "match any character _except_ these"

Ang mga sumusunod na sequence (maliban sa "\N") ay gumagana sa loob o walang klase ng character. Ang una
anim ang locale aware, lahat ay Unicode aware. Tingnan ang perllocale at perlunicode para sa mga detalye.

\d Isang digit
\DA walang digit
\w Isang character na salita
\WA na hindi salita na character
\s Isang character na whitespace
\SA non-whitespace na character
\h Isang pahalang na whitespace
\HA hindi pahalang na whitespace
\NA hindi bagong linya (kapag hindi sinundan ng '{NAME}';;
hindi wasto sa isang klase ng character; katumbas ng [^\n]; ito ay
gaya ng '.' walang /s modifier)
\v Isang patayong whitespace
\VA hindi patayong whitespace
\RA generic newline (?>\v|\x0D\x0A)

\C Itugma ang isang byte (sa Unicode, '.' ay tumutugma sa isang character)
(Hindi na ginagamit.)
\pP Itugma ang P-named (Unicode) property
\p{...} Itugma ang Unicode property na may pangalan na mas mahaba sa 1 character
\PP Match non-P
\P{...} Itugma ang kakulangan ng Unicode property na may pangalan na mas mahaba sa 1 char
\X Match Unicode extended grapheme cluster

POSIX character classes at ang kanilang Unicode at Perl na katumbas:

ASCII- Buong-
POSIX range range backslash
[[:...:]] \p{...} \p{...} pagkakasunod-sunod Paglalarawan

-------------------------------------------------- ---------------------
alnum PosixAlnum XPosixAlnum Alpha plus Digit
alpha PosixAlpha XPosixAlpha Alpabetikong mga character
ascii ASCII Anumang karakter ng ASCII
blangko PosixBlank XPosixBlank \h Pahalang na whitespace;
full-range din
nakasulat bilang
\p{HorizSpace} (GNU
extension)
cntrl PosixCntrl XPosixCntrl Control na mga character
digit na PosixDigit XPosixDigit \d Mga desimal na digit
graph PosixGraph XPosixGraph Alnum plus Punct
lower PosixLower XPosixLower Lowercase na mga character
i-print ang PosixPrint XPosixPrint Graph plus Print, ngunit
hindi anumang Cntrls
punct PosixPunct XPosixPunct Punctuation at Simbolo
sa ASCII-range; basta
punt sa labas nito
space PosixSpace XPosixSpace [\s\cK]
PerlSpace XPerlSpace \s Perl's whitespace def'n
upper PosixUpper XPosixUpper Uppercase na mga character
salita PosixWord XPosixWord \w Alnum + Unicode marks +
mga konektor, tulad ng '_'
(Perl extension)
xdigit ASCII_Hex_Digit XPosixDigit Hexadecimal digit,
ASCII-range ay
[0-9A-Fa-f]

Gayundin, iba't ibang kasingkahulugan tulad ng "\p{Alpha}" para sa "\p{XPosixAlpha}"; lahat ay nakalista sa "Properties
naa-access sa pamamagitan ng \p{} at \P{}" sa perluniprops

Sa loob ng klase ng character:

POSIX tradisyonal na Unicode
[:digit:] \d \p{Digit}
[:^digit:] \D \P{Digit}

MGA ANCHOR
Lahat ay zero-width assertions.

^ Pagsisimula ng string ng pagtutugma (o linya, kung ginagamit ang /m)
$ Itugma ang dulo ng string (o linya, kung ginamit ang /m) o bago ang bagong linya
\b{} Itugma ang hangganan ng uri na tinukoy sa loob ng mga brace
\B{} Itugma saanman ang \b{} ay hindi tumutugma
\b Itugma ang hangganan ng salita (sa pagitan ng \w at \W)
\B Tugma maliban sa hangganan ng salita (sa pagitan ng \w at \w o \W at \W)
\A Match string start (anuman ang /m)
\Z Itugma ang dulo ng string (bago ang opsyonal na bagong linya)
\z Itugma ang ganap na dulo ng string
\G Itugma kung saan tumigil ang nakaraang m//g
\K Itago ang mga bagay na natitira sa \K, huwag isama ito sa $&

quantifiers
Ang mga quantifier ay matakaw bilang default at tumutugma sa pinakamahabang pinakakaliwa.

Maximal Minimal Possessive Allowed range
------- ------- ---------- -------------
{n,m} {n,m}? {n,m}+ Dapat mangyari nang hindi bababa sa n beses
ngunit hindi hihigit sa m beses
{n,} {n,}? {n,}+ Dapat mangyari nang hindi bababa sa n beses
{n} {n}? {n}+ Dapat mangyari nang eksaktong n beses
**? *+ 0 o higit pang beses (katulad ng {0,})
+ +? ++ 1 o higit pang beses (katulad ng {1,})
? ?? ?+ 0 o 1 beses (katulad ng {0,1})

Ang mga possessive form (bago sa Perl 5.10) ay pumipigil sa pag-backtrack: kung ano ang itinutugma ng isang
Ang pattern na may possessive na quantifier ay hindi iuurong, kahit na iyon ang sanhi ng
mabibigo ang buong laban.

Walang quantifier na "{,n}". Iyan ay binibigyang kahulugan bilang isang literal na string.

LALAKI CONSTRUCTS
(?#text) Isang komento
(?:...) Nagpangkat ng mga subexpression nang hindi kumukuha (cluster)
(?pimsx-imsx:...) I-enable/disable ang opsyon (ayon sa m// modifier)
(?=...) Zero-width positive lookahead assertion
(?!...) Zero-width negative lookahead assertion
(?<=...) Zero-width positive lookbehind assertion
(?
(?>...) Kunin ang aming makakaya, ipagbawal ang pag-backtrack
(?|...) Pag-reset ng sangay
(? ...) Pinangalanang kuha
(?'name'...) Pinangalanang capture
(?P ...) Pinangalanang capture (python syntax)
(?[...]) Extended na bracket na klase ng character
(?{ code }) Naka-embed na code, nagiging $^R ang return value
(??{ code }) Dynamic na regex, return value na ginamit bilang regex
(?N) Ulitin sa subpattern number N
(?-N), (?+N) Ulitin sa Nth nakaraan/susunod na subpattern
(?R), (?0) Recurse sa simula ng buong pattern
(?&pangalan) Ulitin sa isang pinangalanang subpattern
(?P>name) Recurse sa isang pinangalanang subpattern (python syntax)
(?(cond)oo|hindi)
(?(cond)yes) Conditional expression, kung saan ang "cond" ay maaaring:
(?=pat) tumingin-harap
(?!pat) negatibong tingin sa unahan
(?<=pat) tingin-likod
(?
(N) subpattern N ay tumugma sa isang bagay
( ) pinangalanang subpattern ay tumugma sa isang bagay
('pangalan') pinangalanang subpattern ay tumugma sa isang bagay
(?{code}) kundisyon ng code
(R) true kung umuulit
(RN) true kung umuulit sa Nth subpattern
(R&name) true kung umuulit sa pinangalanang subpattern
(DEFINE) palaging mali, walang pattern na pinapayagan

MGA VARIABLE
$_ Default na variable para magamit ng mga operator

$` Lahat bago ang katugmang string
$& Buong katugmang string
$' Lahat pagkatapos ay tumugma sa string

${^PREMATCH} Lahat bago ang tugmang string
${^MATCH} Buong katugmang string
${^POSTMATCH} Lahat pagkatapos ay tumugma sa string

Paalala sa mga gumagamit pa rin ng Perl 5.18 o mas maaga: Ang paggamit ng "$`", $& o "$'" ay bumagal
lahat paggamit ng regex sa loob ng iyong programa. Kumonsulta sa perlvar para sa "@-" upang makita ang mga katumbas na expression
hindi iyon magdudulot ng pagbagal. Tingnan din ang Devel::SawAmpersand. Simula sa Perl 5.10, ikaw
maaari ding gumamit ng mga katumbas na variable na "${^PREMATCH}", "${^MATCH}" at "${^POSTMATCH}", ngunit
para matukoy ang mga ito, kailangan mong tukuyin ang "/p" (preserve) modifier sa iyong regular
pagpapahayag. Sa Perl 5.20, ang paggamit ng "$`", $& at "$'" ay walang pagkakaiba sa bilis.

$1, $2 ... hold ang Xth captured expr
$+ Huling nakakulong na tugma ng pattern
$^N Hinahawakan ang pinakakamakailang saradong pagkuha
$^R Hinahawakan ang resulta ng huling (?{...}) expr
@- Mga offset ng pagsisimula ng mga grupo. Hawak ng $-[0] ang simula ng buong laban
@+ Mga offset ng mga dulo ng mga pangkat. Hawak ng $+[0] ang pagtatapos ng buong laban
%+ Pinangalanang mga pangkat ng pagkuha
%- Pinangalanan ang mga pangkat ng pagkuha, bilang mga array ref

Ang mga nakuhang grupo ay binibilang ayon sa kanilang pagbubukas pare.

Mga function
lc Maliit ang isang string
lcfirst Lowercase unang char ng isang string
uc Malaking titik ang isang string
ucfirst Titlecase unang char ng isang string
fc I-foldcase ang isang string

pos Ibalik o itakda ang kasalukuyang posisyon ng tugma
quotemeta Quote metacharacter
i-reset I-reset ang ?pattern? katayuan
pag-aralan ang Analyze string para sa pag-optimize ng pagtutugma

split Gumamit ng regex para hatiin ang isang string sa mga bahagi

Ang unang lima sa mga ito ay tulad ng mga escape sequence na "\L", "\l", "\U", "\u", at "\F".
Para sa Titlecase, tingnan ang "Titlecase"; Para sa Foldcase, tingnan ang "Foldcase".

TERMINOLOHIYA
Titlecase

Ang konsepto ng Unicode na kadalasan ay katumbas ng uppercase, ngunit para sa ilang partikular na character tulad ng
ang German "sharp s" ay may pagkakaiba.

Foldcase

Unicode form na kapaki-pakinabang kapag naghahambing ng mga string anuman ang kaso, bilang tiyak
ang mga character ay may kumplikadong isa-sa-maraming case mapping. Pangunahing variant ng lowercase.

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