perlre - Dalam talian di Awan

JADUAL:

NAMA

perlre - ungkapan biasa Perl

DESCRIPTION

Halaman ini menerangkan sintaks ungkapan biasa dalam Perl.

Jika anda tidak pernah menggunakan ungkapan biasa sebelum ini, pengenalan permulaan pantas tersedia dalam
perlrequick, dan pengenalan tutorial yang lebih panjang tersedia dalam perlretut.

Untuk rujukan tentang cara ungkapan biasa digunakan dalam operasi pemadanan, serta pelbagai
contoh yang sama, lihat perbincangan tentang "m//", "s///", "qr//" dan "??" dalam "Petikan Regexp-
Seperti Operator" dalam perlop.

Baharu dalam v5.22, "use re 'strict'" menggunakan peraturan yang lebih ketat berbanding sebaliknya semasa menyusun
corak ekspresi biasa. Ia boleh menemui perkara yang, walaupun sah, mungkin bukan perkara yang anda
yang dimaksudkan.

Pengubah
Pengenalan

Operasi pemadanan boleh mempunyai pelbagai pengubah suai. Pengubah suai yang berkaitan dengan
tafsiran ungkapan biasa di dalam disenaraikan di bawah. Pengubah suai yang mengubah
cara ungkapan biasa digunakan oleh Perl diperincikan dalam "Pengendali Seperti Petikan Regexp"
dalam perlop dan "Butiran menghuraikan binaan yang dipetik" dalam perlop.

m Anggap rentetan sebagai berbilang baris. Iaitu, tukar "^" dan "$" daripada sepadan dengan permulaan
daripada baris pertama rentetan dan penghujung baris terakhirnya untuk memadankan permulaan dan akhir
setiap baris dalam rentetan.

s Anggap rentetan sebagai satu baris. Iaitu, tukar "." untuk memadankan watak apa pun,
walaupun baris baru, yang biasanya tidak sepadan.

Digunakan bersama, sebagai "/ms", mereka membiarkan "." padankan mana-mana watak sekalipun, sementara masih
membenarkan "^" dan "$" sepadan, masing-masing, selepas dan sebelum baris baharu
dalam rentetan.

i Lakukan padanan corak tidak sensitif huruf besar-besaran.

Jika peraturan padanan tempat berkuat kuasa, peta kes diambil daripada tempat semasa
untuk mata kod kurang daripada 255, dan daripada peraturan Unicode untuk mata kod yang lebih besar.
Walau bagaimanapun, padanan yang akan melintasi sempadan peraturan Unicode/bukan Unicode (ords
255/256) tidak akan berjaya. Lihat perllocale.

Terdapat beberapa aksara Unicode yang sepadan dengan berbilang aksara di bawah "/i".
Contohnya, "FI LIGATUR KECIL LATIN" hendaklah sepadan dengan jujukan "fi". Perl tidak
pada masa ini boleh melakukan ini apabila berbilang aksara berada dalam corak dan sedang
berpecah antara kumpulan, atau apabila satu atau lebih dikira. Justeru

"\N{LIGATUR KECIL LATIN FI}" =~ /fi/i; # Perlawanan
"\N{LIGATUR KECIL LATIN FI}" =~ /[fi][fi]/i; # Tidak padan!
"\N{LIGATUR KECIL LATIN FI}" =~ /fi*/i; # Tidak padan!

# Di bawah tidak sepadan, dan tidak jelas apa yang akan dilakukan oleh $1 dan $2
# jadilah walaupun begitu!!
"\N{LIGATUR KECIL LATIN FI}" =~ /(f)(i)/i; # Tidak padan!

Perl tidak sepadan dengan berbilang aksara dalam kelas aksara kurungan melainkan
watak yang dipetakan kepada mereka disebut secara eksplisit dan ia tidak sepadan dengan mereka sama sekali
jika kelas aksara diterbalikkan, yang sebaliknya boleh menjadi sangat mengelirukan. Lihat
"Kelas Watak Berkurung" dalam perlrecharclass, dan "Negation" dalam perlrecharclass.

x Panjangkan kebolehbacaan corak anda dengan membenarkan ruang kosong dan ulasan. Butiran dalam
"/x"

p Kekalkan rentetan dipadankan supaya ${^PREMATCH}, ${^MATCH} dan ${^POSTMATCH} adalah
tersedia untuk digunakan selepas dipadankan.

Dalam Perl 5.20 dan lebih tinggi ini diabaikan. Disebabkan mekanisme salin atas tulis baharu,
${^PREMATCH}, ${^MATCH} dan ${^POSTMATCH} akan tersedia selepas perlawanan
tanpa mengira pengubahsuai.

a, d, l dan u
Pengubah suai ini, semuanya baharu dalam 5.14, mempengaruhi peraturan set aksara (Unicode, dll.) yang
digunakan, seperti yang diterangkan di bawah dalam "Pengubah suai set aksara".

n Halang aksara meta kumpulan "()" daripada ditangkap. Pengubah suai ini, baharu dalam 5.22,
akan menghentikan $1, $2, dsb... daripada diisi.

"hello" =~ /(hai|hello)/; # $1 ialah "hello"
"hello" =~ /(hai|hello)/n; # $1 tidak ditetapkan

Ini bersamaan dengan meletakkan "?:" pada permulaan setiap kumpulan penangkap:

"hello" =~ /(?:hi|hello)/; # $1 tidak ditetapkan

"/n" boleh dinafikan berdasarkan setiap kumpulan. Sebagai alternatif, tangkapan bernama mungkin masih ada
terpakai.

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

Pengubah suai lain
Terdapat beberapa bendera yang boleh ditemui pada akhir ungkapan biasa
binaan yang tidak bendera ungkapan biasa generik, tetapi digunakan pada operasi
sedang dilakukan, seperti padanan atau penggantian ("m//" atau "s///" masing-masing).

Bendera yang diterangkan lebih lanjut dalam "Menggunakan ungkapan biasa dalam Perl" dalam perlretut ialah:

c - kekalkan kedudukan semasa semasa padanan berulang
g - memadankan corak secara global berulang kali dalam rentetan

Pengubah suai khusus penggantian diterangkan dalam

"s/PATTERN/REPLACEMENT/msixpodualngcer" dalam perlop ialah:

e - nilai sebelah kanan sebagai ungkapan
ee - nilai bahagian kanan sebagai rentetan kemudian nilai hasilnya
o - berpura-pura mengoptimumkan kod anda, tetapi sebenarnya memperkenalkan pepijat
r - lakukan penggantian tanpa musnah dan kembalikan nilai baharu

Pengubah suai ungkapan biasa biasanya ditulis dalam dokumentasi sebagai contoh, ""/x"
pengubah suai", walaupun pembatas yang dimaksudkan mungkin bukan garis miring. The
pengubah suai "/imnsxadlup" juga boleh dibenamkan dalam ungkapan biasa itu sendiri menggunakan
binaan "(?...)", lihat "Corak Lanjutan" di bawah.

Butiran on beberapa pengubah

Sesetengah pengubah suai memerlukan lebih banyak penjelasan daripada yang diberikan dalam "Ikhtisar" di atas.

/x

"/x" memberitahu penghurai ungkapan biasa untuk mengabaikan kebanyakan ruang putih yang bukan kedua-duanya
bergaris ke belakang mahupun dalam kelas aksara yang dikurung. Anda boleh menggunakan ini untuk memecahkan anda
ungkapan biasa kepada (sedikit) bahagian yang lebih mudah dibaca. Juga, watak "#" ialah
dianggap sebagai metacharacter yang memperkenalkan ulasan yang berjalan sehingga penutupan corak
pembatas, atau ke penghujung baris semasa jika corak memanjang ke baris seterusnya.
Oleh itu, ini sangat mirip dengan ulasan kod Perl biasa. (Anda boleh memasukkan penutup
pembatas dalam ulasan hanya jika anda mendahuluinya dengan garis serong ke belakang, jadi berhati-hati!)

Penggunaan "/x" bermakna jika anda mahukan ruang kosong sebenar atau aksara "#" dalam corak
(di luar kelas aksara kurungan, yang tidak terjejas oleh "/x"), maka anda akan sama ada
perlu melepaskannya (menggunakan garis miring ke belakang atau "\Q...\E") atau mengekodnya menggunakan oktal, hex atau
"\N{}" terlepas. Ia tidak berkesan untuk cuba meneruskan ulasan ke baris seterusnya
melepaskan "\n" dengan garis miring ke belakang atau "\Q".

Anda boleh menggunakan "(?#text)" untuk membuat ulasan yang berakhir lebih awal daripada penghujung semasa
baris, tetapi "teks" juga tidak boleh mengandungi pembatas penutup melainkan dilepaskan dengan garis miring ke belakang.

Jika digabungkan, ciri-ciri ini sangat membantu dalam membuat ungkapan biasa Perl
lebih mudah dibaca. Berikut adalah contoh:

# Padam (kebanyakan) komen C.
$program =~ s {
/\* # Padankan pembatas pembukaan.
.*? # Padankan bilangan minimum aksara.
\*/ # Padankan pembatas penutup.
} []gsx;

Ambil perhatian bahawa apa-apa sahaja di dalam "\Q...\E" kekal tidak terjejas oleh "/x". Dan ambil perhatian bahawa "/x"
tidak menjejaskan tafsiran ruang dalam satu binaan berbilang aksara. Untuk
contoh dalam "\x{...}", tanpa mengira pengubah suai "/x", tidak boleh ada ruang. Sama untuk a
pengkuantiti seperti "{3}" atau "{5,}". Begitu juga, "(?:...)" tidak boleh mempunyai ruang antara
"(", "?", dan ":". Dalam mana-mana pembatas untuk binaan sedemikian, ruang yang dibenarkan tidak
dipengaruhi oleh "/x", dan bergantung pada konstruk. Contohnya, "\x{...}" tidak boleh mempunyai ruang
kerana nombor heksadesimal tidak mempunyai ruang di dalamnya. Tetapi, sifat Unicode boleh ada
spaces, jadi dalam "\p{...}" mungkin terdapat ruang yang mengikut peraturan Unicode, yang boleh dilihat
"Sifat boleh diakses melalui \p{} dan \P{}" dalam perluniprops.

Set aksara yang dianggap ruang putih ialah aksara yang Unicode panggil "Corak
Ruang Putih", iaitu:

U+0009 TABULASI WATAK
U+000A LINE FEED
PENJADUALIAN BARIS U+000B
U+000C SUAPAN BORANG
U+000D PENGHANTARAN PEMULANGAN
RUANG U+0020
U+0085 BARISAN SETERUSNYA
U+200E TANDA KIRI-KANAN
U+200F TANDA KANAN-KE-KIRI
PEMISAH BARIS U+2028
PEMISAH PERENGGAN U+2029

Pengubah suai set aksara

"/d", "/u", "/a", dan "/l", tersedia bermula pada 5.14, dipanggil set aksara
pengubahsuai; ia mempengaruhi peraturan set aksara yang digunakan untuk ungkapan biasa.

Pengubah suai "/d", "/u", dan "/l" mungkin tidak begitu berguna kepada anda, jadi anda
tidak perlu risau sangat tentang mereka. Mereka wujud untuk kegunaan dalaman Perl, jadi kompleks itu
struktur data ungkapan biasa boleh bersiri secara automatik dan kemudian tepat
disusun semula, termasuk semua nuansa mereka. Tetapi, kerana Perl tidak boleh menyimpan rahsia, dan
mungkin terdapat kejadian yang jarang berlaku di mana ia berguna, ia didokumenkan di sini.

Pengubah suai "/a", sebaliknya, mungkin berguna. Tujuannya adalah untuk membenarkan kod itu
untuk bekerja kebanyakannya pada data ASCII untuk tidak perlu mengambil berat tentang Unicode.

Secara ringkas, "/l" menetapkan set aksara kepada apa sahaja Locale berkuat kuasa pada masa itu
daripada pelaksanaan padanan corak.

"/u" menetapkan set aksara kepada Unicode.

"/a" juga menetapkan set aksara kepada Unicode, TETAPI menambah beberapa sekatan untuk ASCII-selamat
sepadan.

"/d" ialah yang lama, bermasalah, pra-5.14 Dtingkah laku set watak yang salah. Kegunaannya hanya untuk
paksa perangai lama tu.

Pada bila-bila masa, betul-betul salah satu pengubah ini sedang berkuat kuasa. Kewujudan mereka membolehkan
Perl untuk mengekalkan gelagat asal yang disusun bagi ungkapan biasa, tanpa mengira apa
peraturan berkuat kuasa apabila ia benar-benar dilaksanakan. Dan jika ia diinterpolasi menjadi lebih besar
regex, peraturan asal terus digunakan padanya, dan hanya peraturan itu sahaja.

Pengubah suai "/l" dan "/u" dipilih secara automatik untuk ungkapan biasa yang disusun
dalam skop pelbagai pragma, dan kami mengesyorkan bahawa secara umum, anda menggunakannya
pragmas dan bukannya menyatakan pengubahsuai ini secara eksplisit. Untuk satu perkara, pengubahsuai
mempengaruhi padanan corak sahaja, dan tidak dilanjutkan kepada sebarang penggantian yang dilakukan, sedangkan
menggunakan pragma memberikan hasil yang konsisten untuk semua operasi yang sesuai dalam mereka
skop. Sebagai contoh,

s/foo/\Ubar/il

akan memadankan "foo" menggunakan peraturan setempat untuk pemadanan tidak sensitif huruf besar-besaran, tetapi "/l" tidak
tidak menjejaskan cara "\U" beroperasi. Kemungkinan besar anda mahu kedua-duanya menggunakan peraturan setempat.
Untuk melakukan ini, sebaliknya kumpulkan ungkapan biasa dalam skop "gunakan setempat". ini
kedua-duanya secara tersirat menambah "/l", dan menggunakan peraturan setempat pada "\U". Pengajarannya ialah
"gunakan tempatan", dan bukan "/l" secara eksplisit.

Begitu juga, adalah lebih baik untuk menggunakan "gunakan ciri 'unicode_strings'" dan bukannya,

s/foo/\Lbar/iu

untuk mendapatkan peraturan Unicode, seperti "\L" dalam yang pertama (tetapi tidak semestinya yang terakhir).
juga menggunakan peraturan Unicode.

Lebih terperinci mengenai setiap pengubah suai berikut. Kemungkinan besar anda tidak perlu tahu ini
butiran untuk "/l", "/u", dan "/d", dan boleh melangkau ke hadapan ke /a.

/l

bermaksud menggunakan peraturan setempat semasa (lihat perlocale) apabila padanan corak. Untuk
contoh, "\w" akan sepadan dengan aksara "perkataan" tempat itu dan "/i" tidak peka huruf besar-besaran
pemadanan akan dipadankan mengikut peraturan lipatan kes setempat. Tempatan yang digunakan ialah
yang berkuat kuasa pada masa pelaksanaan padanan corak. Ini mungkin tidak sama
sebagai tempat kompilasi-masa, dan boleh berbeza dari satu perlawanan ke yang lain jika ada
panggilan campur tangan daripada setlocale() fungsi.

Satu-satunya tempat bukan bait tunggal Perl menyokong ialah (bermula pada v5.20) UTF-8. Ini bermaksud
titik kod di atas 255 dianggap sebagai Unicode tidak kira tempat mana yang berkuat kuasa
(memandangkan UTF-8 membayangkan Unicode).

Di bawah peraturan Unicode, terdapat beberapa padanan tidak sensitif huruf besar yang melintasi 255/256
sempadan. Kecuali untuk tempat UTF-8 dalam Perls v5.20 dan lebih baru, ini tidak dibenarkan di bawah
"/l". Contohnya, 0xFF (pada platform ASCII) tidak sepadan dengan aksara di
0x178, "HURUF BESAR LATIN Y DENGAN DIAERESIS", kerana 0xFF mungkin bukan "LATIN KECIL
HURUF Y DENGAN DIAERESIS" dalam tempat semasa, dan Perl tidak mempunyai cara untuk mengetahui sama ada itu
watak malah wujud dalam tempat, apalagi titik kod itu.

Dalam tempat UTF-8 dalam v5.20 dan kemudian, satu-satunya perbezaan yang boleh dilihat antara tempat dan bukan
locale dalam ungkapan biasa harus tercemar (lihat perlsec).

Pengubah suai ini mungkin ditetapkan sebagai lalai oleh "gunakan setempat", tetapi lihat "Aksara yang mana
set pengubah berkuat kuasa?".

/u

bermaksud menggunakan peraturan Unicode apabila padanan corak. Pada platform ASCII, ini bermakna bahawa
titik kod antara 128 dan 255 mengambil makna Latin-1 (ISO-8859-1) mereka (iaitu
sama seperti Unicode). (Jika tidak, Perl menganggap maknanya tidak dapat ditentukan.) Oleh itu,
di bawah pengubah suai ini, platform ASCII secara berkesan menjadi platform Unicode; dan oleh itu,
contohnya, "\w" akan memadankan mana-mana lebih daripada 100_000 aksara perkataan dalam Unicode.

Tidak seperti kebanyakan tempat, yang khusus untuk pasangan bahasa dan negara, Unicode mengelaskan
semua watak iaitu huruf tempat di dunia sebagai "\w". Sebagai contoh, anda
locale mungkin tidak menyangka bahawa "HURUF KECIL LATIN ETH" ialah huruf (melainkan anda kebetulan
bercakap bahasa Iceland), tetapi Unicode melakukannya. Begitu juga, semua aksara yang merupakan digit perpuluhan
suatu tempat di dunia akan sepadan dengan "\d"; ini adalah ratusan, bukan 10, kemungkinan perlawanan. Dan
sesetengah digit tersebut kelihatan seperti beberapa daripada 10 digit ASCII, tetapi bermaksud nombor yang berbeza,
jadi manusia boleh dengan mudah menganggap nombor adalah kuantiti yang berbeza daripada yang sebenarnya. Untuk
contoh, "BENGALI DIGIT FOUR" (U+09EA) kelihatan sangat mirip dengan "ASCII DIGIT LAPAN"
(U+0038). Dan, "\d+", mungkin sepadan dengan rentetan digit yang merupakan campuran daripada berbeza
sistem penulisan, mewujudkan isu keselamatan. "num()" dalam Unicode::UCD boleh digunakan untuk mengisih
ini keluar. Atau pengubah suai "/a" boleh digunakan untuk memaksa "\d" untuk memadankan hanya ASCII 0
melalui 9.

Selain itu, di bawah pengubah suai ini, padanan tidak peka huruf besar-besaran berfungsi pada set lengkap Unicode
watak. "TANDA KELVIN", contohnya sepadan dengan huruf "k" dan "K"; dan "LATIN
SMALL LIGATURE FF" sepadan dengan urutan "ff", yang, jika anda tidak bersedia, mungkin berjaya
kelihatan seperti pemalar heksadesimal, mengemukakan satu lagi isu keselamatan yang berpotensi. Lihat
<http://unicode.org/reports/tr36> untuk perbincangan terperinci tentang isu keselamatan Unicode.

Pengubah suai ini mungkin ditetapkan sebagai lalai oleh "use feature 'unicode_strings", "use
locale ':not_characters'", atau "guna 5.012" (atau lebih tinggi), tetapi lihat "Set aksara yang mana
pengubah suai berkuat kuasa?".

/d

Pengubah suai ini bermaksud menggunakan peraturan asli "Lalai" platform kecuali apabila ada
menyebabkan untuk menggunakan peraturan Unicode sebaliknya, seperti berikut:

1. rentetan sasaran dikodkan dalam UTF-8; atau

2. corak dikodkan dalam UTF-8; atau

3. corak secara eksplisit menyebut titik kod yang melebihi 255 (katakan dengan "\x{100}"); atau

4. corak menggunakan nama Unikod ("\N{...}"); atau

5. corak menggunakan sifat Unicode ("\p{...}" atau "\P{...}"); atau

6. corak menggunakan pemecahan Unikod ("\b{...}" atau "\B{...}"); atau

7. corak menggunakan ""(?[ ])""

Satu lagi mnemonik untuk pengubah suai ini ialah "Bergantung", kerana peraturan yang sebenarnya digunakan bergantung pada
pelbagai perkara, dan akibatnya anda boleh mendapat hasil yang tidak dijangka. Lihat "Pepijat Unicode""
dalam perlunicode. Pepijat Unicode telah menjadi agak terkenal, membawa kepada yang lain
nama (boleh dicetak) untuk pengubah suai ini, "Dodgy".

Melainkan corak atau rentetan dikodkan dalam UTF-8, hanya aksara ASCII boleh dipadankan
positif.

Berikut ialah beberapa contoh cara ia berfungsi pada platform ASCII:

$str = "\xDF"; # $str bukan dalam format UTF-8.
$str =~ /^\w/; # Tiada padanan, kerana $str bukan dalam format UTF-8.
$str .= "\x{0e0b}"; # Kini $str berada dalam format UTF-8.
$str =~ /^\w/; # Padan! $str kini dalam format UTF-8.
potong $str;
$str =~ /^\w/; # Masih perlawanan! $str kekal dalam format UTF-8.

Pengubah suai ini dipilih secara automatik secara lalai apabila tiada yang lain, jadi belum
nama lain untuknya ialah "Lalai".

Kerana tingkah laku yang tidak dijangka yang dikaitkan dengan pengubah suai ini, anda mungkin perlu melakukannya
hanya gunakannya untuk mengekalkan keserasian ke belakang yang pelik.

/a (dan /aa)

Pengubah suai ini bermaksud ASCII-restrict (atau ASCII-safe). Pengubah suai ini, tidak seperti
yang lain, mungkin digandakan untuk meningkatkan kesannya.

Apabila ia muncul secara tunggal, ia menyebabkan urutan "\d", "\s", "\w", dan aksara Posix
kelas untuk dipadankan hanya dalam julat ASCII. Oleh itu, mereka kembali kepada pra-5.6 mereka, pra-Unicode
makna. Di bawah "/a", "\d" sentiasa bermaksud dengan tepat digit "0" hingga "9"; "\s" bermaksud
lima aksara "[ \f\n\r\t]", dan bermula dalam Perl v5.18, tab menegak; "\w" bermaksud
63 aksara "[A-Za-z0-9_]"; dan begitu juga, semua kelas Posix seperti
"[[:print:]]" hanya sepadan dengan aksara julat ASCII yang sesuai.

Pengubah suai ini berguna untuk orang yang hanya menggunakan Unicode secara kebetulan dan yang tidak mahu
dibebani dengan kerumitan dan kebimbangan keselamatannya.

Dengan "/a", seseorang boleh menulis "\d" dengan yakin bahawa ia hanya akan sepadan dengan aksara ASCII,
dan sekiranya timbul keperluan untuk memadankan melebihi ASCII, sebaliknya anda boleh menggunakan "\p{Digit}" (atau
"\p{Word}" untuk "\w"). Terdapat binaan "\p{...}" serupa yang boleh dipadankan di luar ASCII
kedua-dua ruang putih (lihat "Ruang Putih" dalam perlrecharclass), dan kelas Posix (lihat "POSIX
Kelas Aksara" dalam perlrecharclass). Oleh itu, pengubah suai ini tidak bermakna anda tidak boleh menggunakan
Unicode, ini bermakna untuk mendapatkan padanan Unicode anda mesti menggunakan binaan secara eksplisit
("\p{}", "\P{}") yang menandakan Unicode.

Seperti yang anda jangkakan, pengubah suai ini menyebabkan, sebagai contoh, "\D" bermaksud perkara yang sama seperti
"[^0-9]"; sebenarnya, semua aksara bukan ASCII sepadan dengan "\D", "\S", dan "\W". "\b" masih bermakna
untuk memadankan di sempadan antara "\w" dan "\W", menggunakan takrifan "/a" bagi mereka
(begitu juga untuk "\B").

Jika tidak, "/a" berkelakuan seperti pengubah suai "/u", dalam penggunaan padanan yang tidak sensitif huruf besar itu
Peraturan Unicode; contohnya, "k" akan sepadan dengan Unicode "\N{KELVIN SIGN}" di bawah "/i"
padanan, dan titik kod dalam julat Latin1, di atas ASCII akan mempunyai peraturan Unicode apabila ia
datang kepada padanan tidak peka huruf besar-besaran.

Untuk melarang padanan ASCII/bukan ASCII (seperti "k" dengan "\N{KELVIN SIGN}"), nyatakan "a"
dua kali, contohnya "/aai" atau "/aia". (Kejadian pertama "a" menyekat "\d",
dsb., dan kejadian kedua menambah sekatan "/i".) Tetapi, ambil perhatian bahawa kod itu menunjukkan
di luar julat ASCII akan menggunakan peraturan Unicode untuk pemadanan "/i", jadi pengubah suai tidak
benar-benar mengehadkan perkara kepada ASCII sahaja; ia hanya melarang percampuran ASCII dan bukan-
ASCII.

Untuk meringkaskan, pengubah suai ini menyediakan perlindungan untuk aplikasi yang tidak mahu
terdedah kepada semua Unicode. Menentukannya dua kali memberikan perlindungan tambahan.

Pengubah suai ini mungkin ditetapkan sebagai lalai dengan "use re '/a'" atau "use re '/aa'". Jika
anda berbuat demikian, anda sebenarnya mungkin mempunyai kesempatan untuk menggunakan pengubah suai "/u" secara eksplisit jika ada
beberapa ungkapan biasa yang anda mahukan peraturan Unicode penuh (tetapi di sini, ia adalah yang terbaik
jika semuanya berada di bawah ciri "unicode_strings", bersama-sama dengan "use re '/aa'"). Juga
lihat "Pengubah suai set aksara yang manakah berkuat kuasa?".

Pengubah suai set aksara yang manakah berkuat kuasa?

Manakah antara pengubah suai ini berkuat kuasa pada mana-mana titik tertentu dalam ungkapan biasa bergantung
pada set interaksi yang agak kompleks. Ini telah direka supaya secara amnya anda
tidak perlu risau, tetapi bahagian ini memberikan butiran yang mengerikan. Seperti yang dijelaskan di bawah
dalam "Corak Lanjutan" adalah mungkin untuk menentukan secara eksplisit pengubah suai yang digunakan hanya untuk
bahagian ungkapan biasa. Yang paling dalam sentiasa mempunyai keutamaan daripada mana-mana yang luar,
dan satu yang memohon pada keseluruhan ungkapan mempunyai keutamaan berbanding mana-mana tetapan lalai
yang diterangkan dalam baki bahagian ini.

Pragma "use re '/foo'" boleh digunakan untuk menetapkan pengubah suai lalai (termasuk ini) untuk
ungkapan biasa yang disusun dalam skopnya. Pragma ini mempunyai keutamaan berbanding yang lain
pragmas yang disenaraikan di bawah yang turut menukar lalai.

Jika tidak, "use locale" menetapkan pengubah suai lalai kepada "/l"; dan "gunakan ciri
'unicode_strings", atau "use 5.012" (atau lebih tinggi) tetapkan lalai kepada "/u" apabila tidak sama
skop sama ada "guna tempat" atau "guna bait". ("gunakan locale ':not_characters'" juga ditetapkan
lalai kepada "/u", mengatasi mana-mana "use locale" biasa.) Tidak seperti mekanisme yang disebutkan
di atas, ini mempengaruhi operasi selain padanan corak ungkapan biasa, dan seterusnya memberi
hasil yang lebih konsisten dengan pengendali lain, termasuk menggunakan "\U", "\l", dsb. dalam
penggantian penggantian.

Jika tiada satu pun perkara di atas digunakan, atas sebab keserasian ke belakang, pengubah suai "/d" ialah
satu berkuat kuasa secara lalai. Memandangkan ini boleh membawa kepada hasil yang tidak dijangka, sebaiknya nyatakan
set peraturan lain yang manakah harus digunakan.

Tingkah laku pengubah set aksara sebelum Perl 5.14

Sebelum 5.14, tiada pengubah suai yang jelas, tetapi "/l" tersirat untuk regeks yang disusun
dalam skop "use locale", dan "/d" tersirat sebaliknya. Walau bagaimanapun, interpolasi
regex menjadi regex yang lebih besar akan mengabaikan kompilasi asal yang memihak kepada apa sahaja
berkuat kuasa pada masa kompilasi kedua. Terdapat beberapa ketidakkonsistenan
(pepijat) dengan pengubah suai "/d", di mana peraturan Unicode akan digunakan apabila tidak sesuai, dan
sebaliknya. "\p{}" tidak membayangkan peraturan Unicode dan begitu juga dengan semua kejadian
"\N{}", sehingga 5.12.

Biasa Ungkapan
Metakarakter

Corak yang digunakan dalam padanan corak Perl berkembang daripada yang dibekalkan dalam Versi 8
rutin regex. (Rutin diperolehi (jauh) daripada Henry Spencer secara bebas
pelaksanaan semula boleh diagihkan semula rutin V8.) Lihat "Ekspresi Biasa Versi 8"
untuk maklumat lanjut.

Khususnya metakarakter berikut mempunyai standardnya egrep-maksud ish:

\ Petik metakarakter seterusnya
^ Padankan permulaan baris
. Padankan mana-mana aksara (kecuali baris baharu)
$ Padankan hujung rentetan (atau sebelum baris baharu pada penghujung
daripada rentetan)
| Bergantian
() Pengelompokan
[] Kelas Watak Berkurung

Secara lalai, aksara "^" dijamin hanya sepadan dengan permulaan rentetan, iaitu
aksara "$" hanya pada penghujung (atau sebelum baris baharu pada penghujung), dan Perl melakukan yang tertentu
pengoptimuman dengan andaian bahawa rentetan mengandungi hanya satu baris. Terbenam
baris baharu tidak akan dipadankan dengan "^" atau "$". Walau bagaimanapun, anda mungkin ingin menganggap rentetan sebagai a
penimbal berbilang baris, supaya "^" akan sepadan selepas mana-mana baris baharu dalam rentetan
(kecuali jika baris baharu ialah aksara terakhir dalam rentetan), dan "$" akan sepadan sebelum mana-mana
baris baru. Dengan kos overhed yang lebih sedikit, anda boleh melakukan ini dengan menggunakan pengubah suai /m
pada pengendali padanan corak. (Program lama melakukan ini dengan menetapkan $*, tetapi pilihan ini
telah dialih keluar dalam perl 5.10.)

Untuk memudahkan penggantian berbilang baris, "." watak tidak pernah sepadan dengan baris baharu melainkan anda
gunakan pengubah suai "/s", yang sebenarnya memberitahu Perl untuk berpura-pura rentetan itu adalah satu
baris--walaupun tidak.

Pembilang

Pengukur standard berikut diiktiraf:

* Padankan 0 atau lebih kali
+ Padankan 1 atau lebih kali
? Padankan 1 atau 0 kali
{n} Padankan tepat n kali
{n,} Padankan sekurang-kurangnya n kali
{n,m} Padankan sekurang-kurangnya n tetapi tidak lebih daripada m kali

(Jika kurungan kerinting berlaku dalam mana-mana konteks lain dan tidak menjadi sebahagian daripada garis serong ke belakang
jujukan seperti "\x{...}", ia dianggap sebagai aksara biasa. Walau bagaimanapun, penolakan
amaran dinaikkan untuk semua kejadian sedemikian, dan dalam Perl v5.26, penggunaan literal kerinting
kurungan akan diperlukan untuk dilepaskan, katakan dengan mendahuluinya dengan garis serong ke belakang ("\{") atau
melampirkannya dalam kurungan segi empat sama ("[{]"). Perubahan ini akan membolehkan sintaks masa hadapan
sambungan (seperti menjadikan sempadan bawah pengkuantiti sebagai pilihan), dan ralat yang lebih baik
menyemak pengkuantiti.)

Pengkuantiti "*" bersamaan dengan "{0,}", pengkuantiti "+" kepada "{1,}", dan "?"
pengkuantiti kepada "{0,1}". n dan m adalah terhad kepada nilai kamiran bukan negatif kurang daripada a
had pratetap ditakrifkan apabila perl dibina. Ini biasanya 32766 pada yang paling biasa
platform. Had sebenar boleh dilihat dalam mesej ralat yang dihasilkan oleh kod seperti
ini:

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

Secara lalai, subcorak yang dikira adalah "tamak", iaitu, ia akan sepadan seberapa banyak kali
mungkin (diberikan lokasi permulaan tertentu) sementara masih membenarkan selebihnya
corak untuk dipadankan. Jika anda mahu ia sepadan dengan bilangan kali minimum yang mungkin, ikuti
pengkuantiti dengan "?". Ambil perhatian bahawa makna tidak berubah, hanya "ketamakan":

*? Padankan 0 atau lebih kali, tidak tamak
+? Padankan 1 kali atau lebih, bukan tamak
?? Padankan 0 atau 1 kali, bukan tamak
{n}? Padankan tepat n kali, tidak tamak (berlebihan)
{n,}? Padankan sekurang-kurangnya n kali, tidak tamak
{n,m}? Padankan sekurang-kurangnya n tetapi tidak lebih daripada m kali, tidak tamak

Biasanya apabila subcorak yang dikira tidak membenarkan seluruh corak keseluruhan
perlawanan, Perl akan mundur. Walau bagaimanapun, tingkah laku ini kadangkala tidak diingini. Oleh itu Perl
menyediakan borang pengkuantiti "posesif" juga.

*+ Padankan 0 atau lebih kali dan tidak membalas apa-apa
++ Padankan 1 kali atau lebih dan tidak memberikan apa-apa kembali
?+ Padankan 0 atau 1 kali dan tidak membalas apa-apa
{n}+ Padankan dengan tepat n kali dan tidak memberikan apa-apa balasan (berlebihan)
{n,}+ Padankan sekurang-kurangnya n kali dan tidak membalas apa-apa
{n,m}+ Padankan sekurang-kurangnya n tetapi tidak lebih daripada m kali dan tidak membalas apa-apa

Sebagai contoh,

'aaaa' =~ /a++a/

tidak akan sepadan, kerana "a++" akan memakan semua "a" dalam rentetan dan tidak akan pergi
mana-mana untuk bahagian corak yang tinggal. Ciri ini boleh menjadi sangat berguna untuk diberikan
perl memberi petunjuk tentang di mana ia tidak sepatutnya berundur. Sebagai contoh, tipikal "padanan dua-
rentetan petikan" masalah boleh dilakukan dengan paling cekap apabila ditulis sebagai:

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

seperti yang kita tahu bahawa jika petikan akhir tidak sepadan, backtracking tidak akan membantu. Lihat
subungkapan bebas ""(?>corak)"" untuk butiran lanjut; pengkuantiti posesif ialah
hanya gula sintaksis untuk binaan itu. Sebagai contoh contoh di atas juga boleh
ditulis seperti berikut:

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

Ambil perhatian bahawa pengubah pengkuantiti milikan tidak boleh digabungkan dengan yang tidak tamak
pengubahsuai. Ini kerana ia tidak masuk akal. Pertimbangkan jadual kesetaraan berikut:

Undang-undang Haram
------------ ------
X??+ X{0}
X+?+ X{1}
X{min,maks}?+ X{min}

Melarikan diri urutan

Oleh kerana corak diproses sebagai rentetan petikan dua kali, yang berikut juga berfungsi:

tab \t (HT, TAB)
\n baris baharu (LF, NL)
\r pulangan (CR)
\f suapan borang (FF)
\penggera (loceng) (BEL)
\e melarikan diri (fikir troff) (ESC)
\cK kawalan char (contoh: VT)
\x{}, \x00 aksara yang ordinalnya ialah nombor perenambelasan yang diberikan
\N{name} menamakan aksara Unikod atau jujukan aksara
\N{U+263D} Aksara Unikod (contoh: BULAN SUKU PERTAMA)
\o{}, \000 aksara yang ordinalnya ialah nombor perlapanan yang diberikan
\l huruf kecil aksara seterusnya (fikir vi)
\u huruf besar aksara seterusnya (fikir vi)
\L huruf kecil sehingga \E (fikir vi)
\U huruf besar sehingga \E (fikir vi)
\Q petikan (lumpuhkan) corak metakarakter sehingga \E
\E tamatkan sama ada pengubahsuaian kes atau bahagian petikan, fikir vi

Butiran ada dalam "Pengendali Sebut Harga dan Seperti Sebut Harga" dalam perlop.

Watak kelas and lain khas Escapes

Di samping itu, Perl mentakrifkan perkara berikut:

Huraian Nota Urutan
[...] [1] Padankan watak mengikut peraturan
kelas aksara kurungan ditakrifkan oleh "...".
Contoh: [az] sepadan dengan "a" atau "b" atau "c" ... atau "z"
[[:...:]] [2] Padankan watak mengikut peraturan POSIX
kelas aksara "..." dalam kurungan luar
kelas watak. Contoh: [[:atas:]] sepadan dengan mana-mana
huruf besar.
(?[...]) [8] Kelas aksara kurungan lanjutan
\w [3] Padankan aksara "perkataan" (abjad angka tambah "_", tambah
aksara tanda baca penyambung lain serta Unicode
markah)
\W [3] Padankan aksara bukan "perkataan".
\s [3] Padankan aksara ruang putih
\S [3] Padankan aksara bukan ruang putih
\d [3] Padankan aksara digit perpuluhan
\D [3] Padankan aksara bukan digit
\pP [3] Padankan P, dinamakan harta. Gunakan \p{Prop} untuk nama yang lebih panjang
\PP [3] Padankan bukan P
\X [4] Padankan Unicode "kluster grafem yang dipanjangkan"
\C Padankan satu aksara bahasa C (oktet) walaupun begitu
sebahagian daripada aksara UTF-8 yang lebih besar. Oleh itu ia pecah
aksara ke dalam UTF-8 bait mereka, jadi anda mungkin berakhir
dengan kepingan UTF-8 yang cacat. Tidak disokong dalam
pandang belakang. (Ditamatkan.)
\1 [5] Rujukan balik kepada kumpulan tangkapan atau penimbal tertentu.
'1' sebenarnya boleh menjadi sebarang integer positif.
\g1 [5] Rujukan balik kepada kumpulan tertentu atau sebelumnya,
\g{-1} [5] Nombor itu mungkin negatif yang menunjukkan saudara
kumpulan sebelumnya dan boleh dibungkus secara pilihan
kurungan kerinting untuk penghuraian yang lebih selamat.
\g{nama} [5] Rujukan belakang dinamakan
\k [5] Rujukan belakang dinamakan
\K [6] Simpan barang yang tinggal di \K, jangan masukkannya dalam $&
\N [7] Mana-mana watak kecuali \n. Tidak terjejas oleh pengubah suai /s
\v [3] Ruang putih menegak
\V [3] Bukan ruang putih menegak
\h [3] Ruang putih mendatar
\H [3] Bukan ruang putih mendatar
\R [4] Linebreak

[1] Lihat "Kelas Watak Berkurung" dalam perlrecharclass untuk mendapatkan butiran.

[2] Lihat "Kelas Aksara POSIX" dalam perlrecharclass untuk mendapatkan butiran.

[3] Lihat "Jujukan pukulan belakang" dalam perlrecharclass untuk mendapatkan butiran.

[4] Lihat "Lain-lain" dalam perlrebackslash untuk butiran.

[5] Lihat "Tangkap kumpulan" di bawah untuk mendapatkan butiran.

[6] Lihat "Corak Lanjutan" di bawah untuk mendapatkan butiran.

[7] Ambil perhatian bahawa "\N" mempunyai dua makna. Apabila borang "\N{NAME}", ia sepadan dengan
aksara atau urutan aksara yang namanya "NAMA"; dan begitu juga apabila borang
"\N{U+hex}", ia sepadan dengan watak yang mempunyai titik kod Unikod heks. Jika tidak ia
sepadan dengan mana-mana aksara kecuali "\n".

[8] Lihat "Kelas Aksara Kurung Lanjutan" dalam perlrecharclass untuk mendapatkan butiran.

Ketegasan

Perl mentakrifkan pernyataan lebar sifar berikut:

\b{} Padankan pada sempadan Unicode jenis yang ditentukan
\B{} Padankan di mana yang sepadan \b{} tidak sepadan
\b Padankan sempadan perkataan
\B Padankan kecuali pada sempadan perkataan
\A Padankan hanya pada permulaan rentetan
\Z Padankan hanya pada penghujung rentetan, atau sebelum baris baharu pada penghujung
\z Padankan hanya pada hujung rentetan
\G Padankan hanya di pos() (cth pada kedudukan akhir perlawanan
daripada m//g sebelumnya)

Sempadan Unicode ("\b{}"), tersedia bermula dalam v5.22, ialah titik antara dua
aksara, atau sebelum aksara pertama dalam rentetan, atau selepas aksara akhir dalam
rentetan di mana kriteria tertentu yang ditakrifkan oleh Unicode dipenuhi. Lihat "\b{}, \b, \B{}, \B" dalam
perlrebackslash untuk butiran.

Sempadan perkataan ("\b") ialah titik antara dua aksara yang mempunyai "\w" pada satu sisinya
dan "\W" di sebelahnya (dalam mana-mana tertib), mengira aksara khayalan
di luar permulaan dan penghujung rentetan sebagai sepadan dengan "\W". (Dalam kelas watak
"\b" mewakili ruang belakang dan bukannya sempadan perkataan, seperti yang biasa berlaku dalam mana-mana
rentetan petikan dua kali.) "\A" dan "\Z" adalah seperti "^" dan "$", kecuali mereka
tidak akan sepadan beberapa kali apabila pengubah suai "/m" digunakan, manakala "^" dan "$" akan sepadan pada
setiap sempadan garisan dalaman. Untuk memadankan hujung sebenar rentetan dan tidak mengabaikan a
baris baharu mengekor pilihan, gunakan "\z".

Penegasan "\G" boleh digunakan untuk merantai padanan global (menggunakan "m//g"), seperti yang diterangkan dalam
"Pengendali Seperti Sebut Harga Regexp" dalam perlop. Ia juga berguna apabila menulis "lex"-like
pengimbas, apabila anda mempunyai beberapa corak yang anda mahu padankan dengan akibatnya
subrentetan rentetan anda; lihat rujukan sebelum ini. Lokasi sebenar di mana "\G"
akan padanan juga boleh dipengaruhi dengan menggunakan "pos()" sebagai lvalue: lihat "pos" dalam perlfunc.
Ambil perhatian bahawa peraturan untuk padanan panjang sifar (lihat "Corak Berulang Padanan dengan panjang Sifar
Subrentetan") agak diubah suai, kerana kandungan di sebelah kiri "\G" tidak dikira
semasa menentukan tempoh perlawanan. Oleh itu yang berikut tidak akan sepadan selama-lamanya:

$string saya = 'ABC';
pos($string) = 1;
manakala ($rentetan =~ /(.\G)/g) {
cetak $1;
}

Ia akan mencetak 'A' dan kemudian ditamatkan, kerana ia menganggap padanan sebagai lebar sifar, dan dengan itu
tidak akan sepadan pada kedudukan yang sama dua kali berturut-turut.

Perlu diingat bahawa "\G" digunakan secara tidak betul boleh mengakibatkan gelung tak terhingga. Jaga diri
apabila menggunakan corak yang menyertakan "\G" dalam seli.

Ambil perhatian juga bahawa "s///" akan menolak untuk menulis ganti sebahagian daripada penggantian yang sudah ada
telah diganti; jadi sebagai contoh ini akan berhenti selepas lelaran pertama, bukannya
mengulangi jalannya ke belakang melalui rentetan:

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

Tangkap kumpulan

Konstruk kurungan "( ... )" mencipta kumpulan tangkapan (juga dirujuk sebagai tangkapan
penampan). Untuk merujuk kepada kandungan semasa kumpulan kemudian hari, dalam corak yang sama,
gunakan "\g1" (atau "\g{1}") untuk yang pertama, "\g2" (atau "\g{2}") untuk yang kedua, dan seterusnya. ini
dipanggil a pilihan balik.

Tiada had kepada bilangan subrentetan yang ditangkap yang boleh anda gunakan. Kumpulan adalah
bernombor dengan kurungan paling kiri terbuka ialah nombor 1, dsb. Jika kumpulan tidak
sepadan, rujukan belakang yang berkaitan juga tidak akan sepadan. (Ini boleh berlaku jika kumpulan itu
pilihan, atau dalam cabang lain bagi selang-seli.) Anda boleh meninggalkan "g", dan menulis
"\1", dsb, tetapi terdapat beberapa isu dengan borang ini, diterangkan di bawah.

Anda juga boleh merujuk kepada kumpulan tangkapan secara relatif, dengan menggunakan nombor negatif, supaya
"\g-1" dan "\g{-1}" kedua-duanya merujuk kepada kumpulan tangkapan sebelum ini dan "\g-2" dan
"\g{-2}" kedua-duanya merujuk kepada kumpulan sebelum itu. Sebagai contoh:

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

akan sepadan dengan sama seperti "/(Y) ( (X) \g3 \g1 )/x". Ini membolehkan anda menginterpolasi regex
ke dalam regex yang lebih besar dan tidak perlu risau tentang kumpulan tangkapan dinomborkan semula.

Anda boleh mengetepikan nombor sama sekali dan membuat kumpulan tangkapan bernama. Notasinya ialah
"(?nama>...)" untuk mengisytiharkan dan "\g{nama}" untuk rujukan. (Untuk serasi dengan .Net
ungkapan biasa, "\g{nama}" juga boleh ditulis sebagai "\k{nama}", "\knama>" or
"\k'nama'".) nama tidak boleh bermula dengan nombor, atau mengandungi tanda sempang. Apabila berbeza
kumpulan dalam corak yang sama mempunyai nama yang sama, sebarang rujukan kepada nama itu menganggap
kumpulan paling kiri ditakrifkan. Kumpulan bernama dikira dalam penomboran mutlak dan relatif, dan boleh juga
juga dirujuk oleh nombor tersebut. (Adalah mungkin untuk melakukan sesuatu dengan tangkapan bernama
kumpulan yang sebaliknya memerlukan "(??{})".)

Kandungan kumpulan tangkap diskop secara dinamik dan tersedia untuk anda di luar corak
sehingga akhir blok penutup atau sehingga perlawanan seterusnya berjaya, yang mana datang
pertama. (Lihat "Pernyataan Kompaun" dalam perlsyn.) Anda boleh merujuknya dengan nombor mutlak
(menggunakan "$1" bukannya "\g1", dll); atau dengan nama melalui cincangan "%+", menggunakan "$+{nama}".

Pendakap diperlukan dalam merujuk kepada kumpulan tangkap yang dinamakan, tetapi adalah pilihan untuk mutlak atau
yang bernombor relatif. Pendakap adalah lebih selamat apabila mencipta regex dengan menggabungkan lebih kecil
rentetan. Contohnya jika anda mempunyai "qr/$a$b/", dan $a mengandungi "\g1", dan $b mengandungi
"37", anda akan mendapat "/\g137/" yang mungkin bukan yang anda maksudkan.

Notasi "\g" dan "\k" telah diperkenalkan dalam Perl 5.10.0. Sebelum itu tidak ada
kumpulan tangkapan yang dinamakan mahupun relatif. Kumpulan bernombor mutlak telah dirujuk
menggunakan "\1", "\2", dsb., dan tatatanda ini masih diterima (dan berkemungkinan akan begitu).
Tetapi ia membawa kepada beberapa kesamaran jika terdapat lebih daripada 9 kumpulan tangkapan, seperti yang boleh dilakukan oleh "\10".
bermaksud sama ada kumpulan tangkap kesepuluh, atau watak yang ordinalnya dalam oktal ialah 010 (a
ruang belakang dalam ASCII). Perl menyelesaikan kekaburan ini dengan mentafsir "\10" sebagai a
rujukan belakang hanya jika sekurang-kurangnya 10 kurungan kiri telah dibuka sebelum itu. Begitu juga "\11"
adalah rujukan belakang hanya jika sekurang-kurangnya 11 kurungan kiri telah dibuka sebelum itu. Dan sebagainya.
"\1" hingga "\9" sentiasa ditafsirkan sebagai rujukan belakang. Terdapat beberapa contoh
di bawah yang menggambarkan bahaya ini. Anda boleh mengelakkan kekaburan dengan sentiasa menggunakan "\g{}" atau
"\g" jika anda maksudkan menangkap kumpulan; dan untuk pemalar oktal sentiasa menggunakan "\o{}", atau untuk
"\077" dan ke bawah, menggunakan 3 digit berlapik dengan sifar pendahuluan, kerana sifar pendahuluan membayangkan
pemalar oktal.

"\digit" tatatanda juga berfungsi dalam keadaan tertentu di luar corak. Lihat
"Amaran pada \1 Daripada $1" di bawah untuk mendapatkan butiran.

Contoh:

s/^([^ ]*) *([^ ]*)/$2 $1/; # tukar dua perkataan pertama

/(.)\g1/ # cari aksara berganda pertama
dan cetak "'$1' ialah aksara berganda pertama\n";

/(? .)\k / # ... cara yang berbeza
dan cetak "'$+{char}' ialah aksara berganda pertama\n";

/(?'char'.)\g1/ # ... gaul dan padankan
dan cetak "'$1' ialah aksara berganda pertama\n";

jika (/Masa: (..):(..):(..)/) { # menghuraikan nilai
$jam = $1;
$minit = $2;
$saat = $3;
}

/(.)(.)(.)(.)(.)(.)(.)(.)(.)\g10/ # \g10 ialah rujukan belakang
/(.)(.)(.)(.)(.)(.)(.)(.)(.)\10/ # \10 ialah perlapanan
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\10/ # \10 ialah rujukan belakang
/((.)(.)(.)(.)(.)(.)(.)(.)(.))\010/ # \010 ialah perlapanan

$a = '(.)\1'; # Mencipta masalah apabila digabungkan.
$b = '(.)\g{1}'; # Mengelakkan masalah.
"aa" =~ /${a}/; # Benar
"aa" =~ /${b}/; # Benar
"aa0" =~ /${a}0/; # Salah!
"aa0" =~ /${b}0/; # Benar
"aa\x08" =~ /${a}0/; # Betul!
"aa\x08" =~ /${b}0/; # Salah

Beberapa pembolehubah khas juga merujuk kembali kepada bahagian perlawanan sebelumnya. $+ pulangan
apa sahaja perlawanan kurungan terakhir yang sepadan. $& mengembalikan keseluruhan rentetan yang dipadankan. (Pada satu
titik $0 juga, tetapi kini ia mengembalikan nama program.) "$`" mengembalikan segala-galanya
sebelum rentetan yang dipadankan. "$'" mengembalikan segala-galanya selepas rentetan yang dipadankan. Dan $^N
mengandungi apa sahaja yang dipadankan oleh kumpulan yang paling baru ditutup (subpadanan). $^N boleh
digunakan dalam corak lanjutan (lihat di bawah), contohnya untuk menetapkan subpadanan kepada pembolehubah.

Pembolehubah khas ini, seperti cincang "%+" dan pembolehubah sepadan bernombor ($1, $2, $3,
dsb.) diskop secara dinamik sehingga hujung blok penutup atau sehingga seterusnya
perlawanan yang berjaya, yang mana dahulu. (Lihat "Pernyataan Kompaun" dalam perlsyn.)

NOTA: Padanan yang gagal dalam Perl tidak menetapkan semula pembolehubah padanan, yang memudahkannya
tulis kod yang menguji siri kes yang lebih khusus dan mengingati padanan terbaik.

BERKHATAN :: Jika kod anda ingin dijalankan pada Perl 5.16 atau lebih awal, berhati-hati apabila Perl melihatnya
anda memerlukan salah satu daripada $&, "$`", atau "$'" di mana-mana sahaja dalam program, ia perlu menyediakannya
setiap corak padan. Ini mungkin melambatkan program anda dengan ketara.

Perl menggunakan mekanisme yang sama untuk menghasilkan $1, $2, dll, jadi anda juga membayar harga untuk setiap satu
corak yang mengandungi kurungan menangkap. (Untuk mengelakkan kos ini sambil mengekalkan
gelagat pengelompokan, gunakan ungkapan biasa lanjutan "(?: ... )" sebaliknya.) Tetapi jika anda
jangan sekali-kali menggunakan $&, "$`" atau "$'", kemudian corak tanpa menangkap kurungan tidak akan
dihukum. Jadi elakkan $&, "$'", dan "$`" jika anda boleh, tetapi jika anda tidak boleh (dan beberapa algoritma
sangat menghargai mereka), sebaik sahaja anda menggunakannya sekali, gunakannya sesuka hati, kerana anda telah
sudah bayar harganya.

Perl 5.16 memperkenalkan mekanisme yang lebih cekap sedikit yang menyatakan secara berasingan sama ada
setiap "$`", $&, dan "$'" telah dilihat, dan oleh itu mungkin hanya perlu menyalin sebahagian daripada
tali. Perl 5.20 memperkenalkan mekanisme salin atas tulis yang lebih cekap
menghapuskan sebarang kelembapan.

Sebagai penyelesaian lain untuk masalah ini, Perl 5.10.0 memperkenalkan "${^PREMATCH}", "${^MATCH}"
dan "${^POSTMATCH}", yang bersamaan dengan "$`", $& dan "$'", kecuali bahawa mereka sahaja
dijamin untuk ditakrifkan selepas perlawanan yang berjaya yang telah dilaksanakan dengan "/p"
(memelihara) pengubahsuai. Penggunaan pembolehubah ini tidak dikenakan penalti prestasi global,
tidak seperti tanda baca yang setara, namun pada pertukaran yang anda perlu beritahu
perl apabila anda mahu menggunakannya. Sehingga Perl 5.20, ketiga-tiga pembolehubah ini bersamaan dengan
"$`", $& dan "$'", dan "/p" diabaikan.

Memetik metakarakter
Metakarakter bergaris ke belakang dalam Perl ialah abjad angka, seperti "\b", "\w", "\n". Tidak seperti
beberapa bahasa ungkapan biasa yang lain, tiada simbol garis miring ke belakang yang tidak
abjad angka. Jadi apa-apa sahaja yang kelihatan seperti \\, \(, \), \[, \], \{, atau \} adalah sentiasa
ditafsirkan sebagai watak literal, bukan watak meta. Ini pernah digunakan secara umum
simpulan bahasa untuk melumpuhkan atau memetik makna khas metakarakter ungkapan biasa dalam a
rentetan yang anda ingin gunakan untuk corak. Hanya petik semua aksara bukan "perkataan":

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

(Jika "gunakan tempattempat" ditetapkan, maka ini bergantung pada tempattempat semasa.) Hari ini lebih banyak lagi
biasa digunakan quotemeta() fungsi atau urutan pelarian metaquoting "\Q" untuk dilumpuhkan
semua makna khas metacharacter seperti ini:

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

Berhati-hati jika anda meletakkan garis miring ke belakang literal (yang tidak berada di dalam pembolehubah interpolasi)
antara "\Q" dan "\E", interpolasi sengkang terbalik dua tanda kutip boleh menyebabkan mengelirukan
keputusan. Jika awak perlu untuk menggunakan garis miring ke belakang literal dalam "\Q...\E", rujuk "Butiran Gory
menghurai binaan yang dipetik" dalam perlop.

"quotemeta()" dan "\Q" diterangkan sepenuhnya dalam "quotemeta" dalam perlfunc.

Extended Corak
Perl juga mentakrifkan sintaks sambungan yang konsisten untuk ciri yang tidak ditemui dalam alat standard
seperti awk and lex. Sintaks untuk kebanyakan ini ialah sepasang kurungan dengan soalan
tandakan sebagai perkara pertama dalam kurungan. Watak selepas tanda soal
menunjukkan sambungan.

Kestabilan sambungan ini berbeza-beza secara meluas. Beberapa telah menjadi sebahagian daripada bahasa teras
selama bertahun-tahun. Yang lain adalah percubaan dan mungkin berubah tanpa amaran atau sepenuhnya
dikeluarkan. Semak dokumentasi pada ciri individu untuk mengesahkan status semasanya.

Tanda soal telah dipilih untuk ini dan untuk konstruk padanan minimum kerana 1)
tanda soal jarang berlaku dalam ungkapan biasa yang lebih lama, dan 2) setiap kali anda melihatnya, anda
harus berhenti dan "menyoal" dengan tepat apa yang sedang berlaku. itu psikologi....

"(? #teks)"
Satu komen. Teks diabaikan. Ambil perhatian bahawa Perl menutup ulasan sebaik sahaja ia melihat
a ")", jadi tiada cara untuk meletakkan ")" literal dalam ulasan. Corak ditutup
pembatas mesti dilepaskan dengan garis miring ke belakang jika ia muncul dalam ulasan.

Lihat "/x" untuk mendapatkan cara lain untuk mempunyai ulasan dalam corak.

"(?adlupimnsx-imnsx)"
"(?^alupimnsx)"
Satu atau lebih pengubah suai padanan corak terbenam, untuk dihidupkan (atau dimatikan, jika
didahului dengan "-") untuk baki corak atau baki lampiran
kumpulan pola (jika ada).

Ini amat berguna untuk corak dinamik, seperti yang dibaca dari a
fail konfigurasi, diambil daripada hujah, atau dinyatakan dalam jadual di suatu tempat.
Pertimbangkan kes di mana sesetengah corak mahu menjadi sensitif huruf besar dan sesetengahnya tidak: The
yang tidak peka huruf besar-besaran hanya perlu memasukkan "(?i)" di hadapan corak. Untuk
contoh:

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

# lebih fleksibel:

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

Pengubah suai ini dipulihkan pada penghujung kumpulan yang disertakan. Sebagai contoh,

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

akan memadankan "bla" dalam apa jua keadaan, beberapa ruang dan tepat (termasuk yang kes!)
pengulangan perkataan sebelumnya, dengan mengandaikan pengubah "/x", dan tiada pengubah "/i".
di luar kumpulan ini.

Pengubah suai ini tidak dibawa ke dalam subcorak bernama yang dipanggil dalam lampiran
kumpulan. Dalam erti kata lain, corak seperti "((?i)(?&NAME))" tidak mengubah kes-
sensitiviti corak "NAME".

Mana-mana pengubah suai ini boleh ditetapkan untuk digunakan secara global pada semua ungkapan biasa
disusun dalam skop "use re". Lihat "mod '/bendera'" dalam semula.

Bermula dalam Perl 5.14, "^" (aksen karet atau sirkumfleks) sejurus selepas "?" ialah
singkatan yang setara dengan "d-imnsx". Bendera (kecuali "d") boleh mengikut karet ke
mengatasinya. Tetapi tanda tolak tidak sah dengannya.

Ambil perhatian bahawa pengubah suai "a", "d", "l", "p", dan "u" adalah istimewa kerana ia hanya boleh
didayakan, bukan dilumpuhkan dan pengubah suai "a", "d", "l" dan "u" adalah saling
eksklusif: menyatakan satu menyahspesifikasikan yang lain, dan maksimum satu (atau dua "a")
mungkin muncul dalam konstruk. Oleh itu, sebagai contoh, "(?-p)" akan memberi amaran apabila disusun di bawah
"gunakan amaran"; "(?-d:...)" dan "(?dl:...)" ialah ralat yang membawa maut.

Perhatikan juga bahawa pengubah suai "p" adalah istimewa kerana kehadirannya di mana-mana dalam corak
mempunyai kesan global.

"(?:corak)"
"(?adluimnsx-imnsx:corak)"
"(?^aluimnsx:corak)"
Ini adalah untuk pengelompokan, bukan menangkap; ia mengumpulkan subungkapan seperti "()", tetapi tidak
buat rujukan belakang seperti yang dilakukan oleh "()". Jadi

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

adalah seperti

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

tetapi tidak meludahkan medan tambahan. Ia juga lebih murah untuk tidak menangkap watak jika anda
tidak perlu.

Sebarang huruf antara "?" dan ":" bertindak sebagai pengubah suai bendera seperti dengan "(?adluimnsx-imnsx)".
Sebagai contoh,

/(?si:lebih.*daripada).*juta/i

adalah bersamaan dengan yang lebih bertele-tele

/(?:(?si)lebih.*daripada).*juta/i

Ambil perhatian bahawa mana-mana binaan "(...)" yang disertakan dalam binaan ini masih akan ditangkap melainkan
pengubah suai "/n" sedang berkuat kuasa.

Bermula dalam Perl 5.14, "^" (aksen karet atau sirkumfleks) sejurus selepas "?" ialah
singkatan yang setara dengan "d-imnsx". Sebarang bendera positif (kecuali "d") boleh mengikut
karet, jadi

(?^x:foo)

adalah bersamaan dengan

(?x-imns:foo)

Karet memberitahu Perl bahawa kelompok ini tidak mewarisi bendera mana-mana sekeliling
corak, tetapi menggunakan lalai sistem ("d-imnsx"), diubah suai oleh mana-mana bendera yang ditentukan.

Karet membolehkan rentetan yang lebih mudah bagi ungkapan biasa yang disusun. Ini
seperti

(?^:corak)

dengan mana-mana bendera bukan lalai muncul di antara karet dan kolon. Ujian yang
melihat pada penetapan sedemikian oleh itu tidak perlu mempunyai bendera lalai sistem keras-
berkod di dalamnya, hanya karet. Jika bendera baharu ditambahkan pada Perl, maksudnya
pengembangan caret akan berubah untuk memasukkan lalai untuk bendera tersebut, jadi ujian akan berlaku
masih berfungsi, tidak berubah.

Menentukan bendera negatif selepas karet adalah ralat, kerana bendera itu berlebihan.

Mnemonik untuk "(?^...)": Permulaan yang baru kerana penggunaan biasa karet adalah padanan
pada permulaan.

"(?|corak)"
Ini ialah corak "set semula cawangan", yang mempunyai sifat istimewa yang ditangkap
kumpulan dinomborkan dari titik permulaan yang sama dalam setiap cabang silih berganti. Ia adalah
tersedia bermula dari perl 5.10.0.

Kumpulan tangkapan dinomborkan dari kiri ke kanan, tetapi di dalam ini membina
penomboran dimulakan semula untuk setiap cawangan.

Penomboran dalam setiap cawangan adalah seperti biasa, dan mana-mana kumpulan mengikuti ini
konstruk akan dinomborkan seolah-olah konstruk mengandungi hanya satu cabang, iaitu
menjadi kumpulan yang paling banyak menangkap di dalamnya.

Pembinaan ini berguna apabila anda ingin menangkap salah satu daripada beberapa alternatif
perlawanan.

Pertimbangkan pola berikut. Nombor di bawah menunjukkan kumpulan yang mana
kandungan yang ditangkap akan disimpan.

# sebelum --------------semula cawangan----------- selepas
/ ( a ) (?| x ( y ) z | (p (q) r) | (t) u (v) ) ( z ) /x
# 1 2 2 3 2 3 4

Berhati-hati apabila menggunakan corak tetapan semula cawangan dalam kombinasi dengan tangkapan bernama.
Tangkapan bernama dilaksanakan sebagai alias kepada kumpulan bernombor yang memegang
menangkap, dan itu mengganggu pelaksanaan corak tetapan semula cawangan. Jika
anda menggunakan tangkapan bernama dalam corak tetapan semula cawangan, sebaiknya gunakan yang sama
nama, dalam susunan yang sama, dalam setiap selang-seli:

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

Tidak berbuat demikian boleh membawa kepada kejutan:

"12" =~ /(?| (? \d+ ) | (? \D+))/x;
sebut $+ {a}; # Cetakan '12'
sebut $+ {b}; # *Juga* mencetak '12'.

Masalahnya di sini ialah kedua-dua kumpulan bernama "a" dan kumpulan bernama "b" adalah alias
untuk kumpulan kepunyaan $1.

Pernyataan Lihat-Sekeliling
Penegasan lihat sekeliling ialah corak lebar sifar yang sepadan dengan corak tertentu tanpa
termasuk dalam $&. Penegasan positif sepadan apabila subpolanya sepadan, negatif
pernyataan sepadan apabila subcorak mereka gagal. Pandangan belakang padanan teks sehingga ke
kedudukan perlawanan semasa, pandangan ke hadapan sepadan dengan teks mengikut kedudukan perlawanan semasa.

"(?=corak)"
Penegasan pandangan hadapan positif lebar sifar. Contohnya, "/\w+(?=\t)/" sepadan dengan a
perkataan diikuti dengan tab, tanpa memasukkan tab dalam $&.

"(?!corak)"
Pernyataan pandangan ke hadapan negatif lebar sifar. Contohnya padanan "/foo(?!bar)/".
sebarang kejadian "foo" yang tidak diikuti oleh "bar". Walau bagaimanapun, perhatikan bahawa rupa-
hadapan dan pandang belakang BUKAN perkara yang sama. Anda tidak boleh menggunakan ini untuk melihat-
belakang.

Jika anda mencari "bar" yang tidak didahului dengan "foo", "/(?!foo)bar/" akan
tidak melakukan apa yang anda mahu. Itu kerana "(?! foo)" hanya mengatakan bahawa seterusnya
benda tidak boleh "foo"--dan bukan, ia adalah "bar", jadi "foobar" akan sepadan. guna
lihat ke belakang (lihat di bawah).

"(?<=corak)" "\K"
Penegasan pandangan belakang positif lebar sifar. Contohnya, "/(?<=\t)\w+/" sepadan
perkataan yang mengikuti tab, tanpa memasukkan tab dalam $&. Berfungsi hanya untuk tetap-
lebar melihat-belakang.

Terdapat bentuk khas binaan ini, dipanggil "\K" (tersedia sejak Perl
5.10.0), yang menyebabkan enjin regex "menyimpan" semua yang telah dipadankan sebelumnya
kepada "\K" dan tidak memasukkannya dalam $&. Ini secara berkesan menyediakan panjang berubah-ubah
pandang belakang. Penggunaan "\K" di dalam pernyataan lihat sekeliling yang lain dibenarkan,
tetapi tingkah laku pada masa ini tidak ditakrifkan dengan baik.

Atas pelbagai sebab "\K" mungkin jauh lebih cekap daripada yang setara
"(?<=...)" bina, dan ia amat berguna dalam situasi yang anda mahu
dengan cekap mengalih keluar sesuatu mengikut sesuatu yang lain dalam rentetan. Contohnya

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

boleh ditulis semula sebagai yang lebih cekap

s/foo\Kbar//g;

"(?
Penegasan pandangan belakang negatif lebar sifar. Sebagai contoh "/(?
sebarang kejadian "foo" yang tidak mengikut "bar". Berfungsi hanya untuk lebar tetap
pandang belakang.

"(? Corak 'NAME')"
"(? corak)"
Kumpulan penangkap bernama. Sama dalam setiap aspek dengan penangkapan kurungan biasa "()"
tetapi untuk fakta tambahan bahawa kumpulan itu boleh dirujuk dengan nama dalam pelbagai
binaan ungkapan biasa (seperti "\g{NAME}") dan boleh diakses mengikut nama selepas a
perlawanan berjaya melalui "%+" atau "%-". Lihat perlvar untuk mendapatkan butiran lanjut tentang "%+" dan "%-"
cincang.

Jika berbilang kumpulan tangkapan berbeza mempunyai nama yang sama maka $+{NAME} akan merujuk kepada
kumpulan paling kiri dalam perlawanan itu.

Borang "(?'NAME'corak)" dan "(? corak)" adalah setara.

PERHATIAN: Manakala tatatanda binaan ini adalah sama dengan fungsi yang serupa dalam .NET
regex, kelakuannya tidak. Dalam Perl kumpulan dinomborkan mengikut urutan tanpa mengira
dinamakan atau tidak. Oleh itu dalam corak

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

$+{foo} akan sama dengan $2 dan $3 akan mengandungi 'z' dan bukannya sebaliknya yang
adalah apa yang mungkin dijangkakan oleh penggodam regex .NET.

Pada masa ini NAME terhad kepada pengecam mudah sahaja. Dalam erti kata lain, ia mesti
padankan "/^[_A-Za-z][_A-Za-z0-9]*\z/" atau sambungan Unicodenya (lihat utf8), walaupun ia
tidak dilanjutkan oleh tempat (lihat perlocale).

PERHATIAN: Untuk memudahkan pengaturcara yang berpengalaman dengan Python
atau enjin regex PCRE, corak "(?P corak)" boleh digunakan sebagai ganti
"(? pattern)"; namun borang ini tidak menyokong penggunaan petikan tunggal sebagai a
pembatas untuk nama.

"\k "
"\k'NAME'"
Dinamakan rujukan belakang. Serupa dengan rujukan belakang berangka, kecuali kumpulan itu
ditetapkan dengan nama dan bukan nombor. Jika berbilang kumpulan mempunyai nama yang sama maka ia
merujuk kepada kumpulan paling kiri ditakrifkan dalam perlawanan semasa.

Ia adalah ralat untuk merujuk kepada nama yang tidak ditakrifkan oleh "(? )" awal dalam corak.

Kedua-dua bentuk adalah setara.

PERHATIAN: Untuk memudahkan pengaturcara yang berpengalaman dengan Python
atau enjin regex PCRE, corak "(?P=NAME)" boleh digunakan dan bukannya "\k ".

"(?{ kod })"
BERKHATAN :: Menggunakan ciri ini dengan selamat memerlukan anda memahami batasannya. Kod
dilaksanakan yang mempunyai kesan sampingan mungkin tidak menunjukkan prestasi yang sama dari versi ke versi yang sepatutnya
kepada kesan pengoptimuman masa hadapan dalam enjin regex. Untuk maklumat lanjut tentang
ini, lihat "Kekerapan Pelaksanaan Kod Terbenam".

Penegasan lebar sifar ini melaksanakan sebarang kod Perl terbenam. Ia sentiasa berjaya, dan
nilai pulangannya ditetapkan sebagai $^R.

Dalam corak literal, kod dihuraikan pada masa yang sama dengan kod sekeliling.
Semasa dalam corak, kawalan dihantar semula sementara ke parser perl, sehingga
pendakap penutup yang mengimbangi secara logik ditemui. Ini serupa dengan cara itu
ungkapan indeks tatasusunan dalam rentetan literal dikendalikan, sebagai contoh

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

Khususnya, pendakap tidak perlu seimbang:

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

Walaupun dalam corak yang diinterpolasi dan disusun pada masa jalan, blok kod literal
akan disusun sekali, pada masa penyusunan perl; cetakan "ABCD" berikut:

cetak "D";
my $qr = qr/(?{ BEGIN { print "A" } })/;
$foo saya = "foo";
/$foo$qr(?{ BEGIN { print "B" } })/;
MULAI { cetak "C" }

Dalam corak di mana teks kod diperoleh daripada maklumat masa larian
daripada muncul secara literal dalam kod sumber /corak/, kod tersebut disusun pada masa yang sama
masa corak itu disusun, dan atas sebab keselamatan, "gunakan semula 'eval'" mesti
berada dalam skop. Ini adalah untuk menghentikan corak yang dibekalkan pengguna yang mengandungi coretan kod daripada
boleh dilaksanakan.

Dalam situasi di mana anda perlu mendayakan ini dengan "use re 'eval'", anda juga harus mempunyai
pemeriksaan kotoran didayakan. Lebih baik lagi, gunakan penilaian yang dikekang dengan teliti dalam a
Petak selamat. Lihat perlsec untuk butiran tentang kedua-dua mekanisme ini.

Dari sudut pandangan penghuraian, skop pembolehubah leksikal dan penutupan,

/AAA(?{ BBB })CCC/

berkelakuan lebih kurang seperti

/AAA/ && lakukan { BBB } && /CCC/

Begitu juga,

qr/AAA(?{ BBB })CCC/

berkelakuan lebih kurang seperti

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

Khususnya:

{ $i saya = 1; $r = qr/(?{ cetak $i })/ }
$i saya = 2;
/$r/; # cetakan "1"

Di dalam blok "(?{...})", $_ merujuk kepada rentetan ungkapan biasa yang dipadankan
terhadap. Anda juga boleh menggunakan "pos()" untuk mengetahui kedudukan semasa padanan
dalam rentetan ini.

Blok kod memperkenalkan skop baharu dari perspektif pembolehubah leksikal
pengisytiharan, tetapi tidak dari perspektif penyetempatan "tempatan" dan serupa
tingkah laku. Jadi blok kod kemudian dalam corak yang sama masih akan melihat nilai
yang telah disetempatkan di blok terdahulu. Penyetempatan terkumpul ini dibuat asal
sama ada pada penghujung perlawanan yang berjaya, atau jika penegasan itu diundur (bandingkan
"Menjejak ke belakang"). Sebagai contoh,

$_ = 'a' x 8;
m<
(?{ $cnt = 0 }) # Mulakan $cnt.
(
a
(?{
$cnt tempatan = $cnt + 1; # Kemas kini $cnt,
# backtracking-selamat.
})
)*
aaaa
(?{ $res = $cnt }) # Pada kejayaan salin ke
# lokasi bukan setempat.
>x;

pada mulanya akan menambah $cnt sehingga 8; maka semasa backtracking, nilainya akan menjadi
unwound kembali kepada 4, iaitu nilai yang diberikan kepada $res. Pada penghujung regex
pelaksanaan, $cnt akan dikembalikan kepada nilai awalnya 0.

Penegasan ini boleh digunakan sebagai syarat dalam a

(?(syarat)ya-corak|tiada-corak)

beralih. Sekiranya tidak digunakan dengan cara ini, hasil penilaian "kod" dimasukkan ke dalam
pembolehubah khas $^R. Ini berlaku serta-merta, jadi $^R boleh digunakan daripada "(?{) yang lain
kod })" pernyataan dalam ungkapan biasa yang sama.

Tugasan kepada $^R di atas disetempatkan dengan betul, jadi nilai lama $^R dipulihkan
jika dakwaan itu diundur; bandingkan "Menjejak Belakang".

Ambil perhatian bahawa pembolehubah khas $^N amat berguna dengan blok kod untuk ditangkap
keputusan subpadanan dalam pembolehubah tanpa perlu menjejaki bilangan
kurungan bersarang. Sebagai contoh:

$_ = "Musang coklat melompat ke atas anjing malas";
/the (\S+)(?{ $color = $^N }) (\S+)(?{ $haiwan = $^N })/i;
cetak "warna = $warna, haiwan = $haiwan\n";

"(??{ kod })"
BERKHATAN :: Menggunakan ciri ini dengan selamat memerlukan anda memahami batasannya. Kod
dilaksanakan yang mempunyai kesan sampingan mungkin tidak menunjukkan prestasi yang sama dari versi ke versi yang sepatutnya
kepada kesan pengoptimuman masa hadapan dalam enjin regex. Untuk maklumat lanjut tentang
ini, lihat "Kekerapan Pelaksanaan Kod Terbenam".

Ini ialah subungkapan biasa "ditunda". Ia berkelakuan dalam sebenarnya cara yang sama seperti a
"(?{ code })" blok kod seperti yang diterangkan di atas, kecuali nilai pulangannya, bukannya
diberikan kepada $^R, dianggap sebagai corak, disusun jika ia adalah rentetan (atau digunakan sebagai-
adalah jika ia adalah objek qr //), kemudian dipadankan seolah-olah ia dimasukkan dan bukannya ini
membina.

Semasa pemadanan sub-corak ini, ia mempunyai set tangkapan sendiri iaitu
sah semasa sub-perlawanan, tetapi dibuang sebaik sahaja kawalan kembali ke utama
corak. Contohnya, padanan berikut, dengan corak dalaman menangkap "B" dan
memadankan "BB", manakala corak luar menangkap "A";

$inner saya = '(.)\1';
"ABBA" =~ /^(.)(??{ $dalaman })\1/;
cetak $1; # cetakan "A";

Ambil perhatian bahawa ini bermakna bahawa tiada cara untuk corak dalam merujuk kepada tangkapan
kumpulan yang ditakrifkan di luar. (Blok kod itu sendiri boleh menggunakan $1, dsb., untuk merujuk kepada
melampirkan kumpulan tangkap corak.) Oleh itu, walaupun

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

akan sepadan, ia akan tidak tetapkan $1 semasa keluar.

Corak berikut sepadan dengan kumpulan dalam kurungan:

$re = qr{
\(
(?:
(?> [^()]+ ) # Bukan induk tanpa berundur
|
(??{ $re }) # Kumpulan dengan induk yang sepadan
)*
\)
}x;

Lihat juga "(?PARNO)" untuk cara yang berbeza dan lebih cekap untuk menyelesaikan tugas yang sama.

Melaksanakan ungkapan biasa yang ditangguhkan 50 kali tanpa menggunakan sebarang rentetan input
akan mengakibatkan kesilapan yang membawa maut. Kedalaman maksimum disusun menjadi perl, jadi mengubahnya
memerlukan binaan tersuai.

"(?PARNO)" "(?-PARNO)" "(?+PARNO)" "(?R)" "(?0)"
Subcorak rekursif. Rawat kandungan penimbal tangkapan yang diberikan dalam arus
corak sebagai subcorak bebas dan cuba memadankannya pada kedudukan semasa
dalam rentetan. Maklumat tentang keadaan tangkapan daripada pemanggil untuk perkara seperti
rujukan belakang tersedia untuk subcorak, tetapi penampan penangkapan yang ditetapkan oleh
subcorak tidak kelihatan kepada pemanggil.

Serupa dengan "(??{ kod })" kecuali ia tidak melibatkan pelaksanaan sebarang kod atau
berpotensi menyusun rentetan corak yang dikembalikan; sebaliknya ia merawat bahagian
corak semasa yang terkandung dalam kumpulan tangkapan tertentu sebagai corak bebas
yang mesti sepadan dengan kedudukan semasa. Juga berbeza adalah perlakuan tangkapan
penampan, tidak seperti "(??{ kod })" corak rekursif mempunyai akses kepada padanan pemanggilnya
nyatakan, supaya seseorang boleh menggunakan rujukan belakang dengan selamat.

PARNO ialah jujukan digit (bukan bermula dengan 0) yang nilainya mencerminkan induk-
nombor kumpulan tangkapan untuk diulang. "(?R)" berulang ke permulaan
keseluruhan corak. "(?0)" ialah sintaks alternatif untuk "(?R)". Jika PARNO didahului oleh a
tanda tambah atau tolak maka ia dianggap sebagai relatif, dengan nombor negatif menunjukkan
kumpulan tangkapan sebelum dan yang positif berikut. Oleh itu "(?-1)" merujuk kepada yang paling banyak
kumpulan yang diisytiharkan baru-baru ini dan "(?+1)" menunjukkan kumpulan seterusnya yang akan diisytiharkan. Catatan
bahawa pengiraan untuk rekursi relatif berbeza daripada pengiraan rujukan belakang relatif,
dalam itu dengan rekursi kumpulan tidak tertutup adalah dimasukkan.

Corak berikut sepadan dengan fungsi foo() yang mungkin mengandungi kurungan yang seimbang
sebagai hujah.

$re = qr{ ( # kumpulan paren 1 (fungsi penuh)
foo
( # kumpulan paren 2 (paren)
\(
( # kumpulan paren 3 (kandungan induk)
(?:
(?> [^()]+ ) # Bukan induk tanpa berundur
|
(?2) # Berulang untuk memulakan kumpulan paren 2
)*
)
\)
)
)
}x;

Jika corak digunakan seperti berikut

'foo(bar(baz)+baz(bop))'=~/$re/
dan cetak "\$1 = $1\n",
"\$2 = $2\n",
"\$3 = $3\n";

output yang dihasilkan hendaklah seperti berikut:

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

Jika tiada kumpulan tangkapan sepadan yang ditentukan, maka ia adalah ralat yang membawa maut.
Mengulang lebih dalam daripada 50 kali tanpa menggunakan sebarang rentetan input juga akan mengakibatkan
kesilapan yang membawa maut. Kedalaman maksimum disusun menjadi perl, jadi mengubahnya memerlukan a
binaan tersuai.

Berikut menunjukkan cara menggunakan pengindeksan negatif boleh memudahkan untuk membenamkan rekursif
corak di dalam binaan "qr//" untuk kegunaan kemudian:

$paren saya = qr/(\((?:[^()]++|(?-1))*+\))/;
jika (/foo $paren \s+ \+ \s+ bar $parens/x) {
# buat sesuatu di sini...
}

Nota bahawa corak ini tidak berkelakuan dengan cara yang sama seperti PCRE atau Python yang setara
binaan dalam bentuk yang sama. Dalam Perl anda boleh menjejak kembali ke kumpulan berulang, dalam PCRE
dan Python yang diulang ke dalam kumpulan dianggap sebagai atom. Juga, pengubah suai diselesaikan
pada masa penyusunan, jadi binaan seperti (?i:(?1)) atau (?:(?i)(?1)) tidak menjejaskan bagaimana
sub-corak akan diproses.

"(?&NAMA)"
Berulang kepada subcorak bernama. Sama dengan "(?PARNO)" kecuali bahawa kurungan ke
recurse to ditentukan oleh nama. Jika berbilang kurungan mempunyai nama yang sama, maka ia
berulang ke paling kiri.

Ia adalah ralat untuk merujuk kepada nama yang tidak diisytiharkan di suatu tempat dalam corak.

PERHATIAN: Untuk memudahkan pengaturcara yang berpengalaman dengan Python
atau enjin regex PCRE corak "(?P>NAME)" boleh digunakan dan bukannya "(?&NAME)".

"(?(syarat)ya-corak|tiada-corak)"
"(? (syarat) ya-corak)"
Ungkapan bersyarat. Memadankan "pola ya" jika "keadaan" menghasilkan nilai sebenar,
sepadan dengan "tiada corak" sebaliknya. Corak yang hilang sentiasa sepadan.

"(syarat)" hendaklah salah satu daripada: 1) integer dalam kurungan (yang sah jika
pasangan kurungan sepadan dipadankan); 2) pandangan ke hadapan/pandang-belakang/nilai sifar-
penegasan lebar; 3) nama dalam kurungan sudut atau petikan tunggal (yang sah jika a
kumpulan dengan nama yang diberikan sepadan); atau 4) simbol khas (R) (benar apabila dinilai
dalam rekursi atau eval). Selain itu R boleh diikuti dengan nombor, (yang
akan menjadi benar apabila dinilai apabila berulang di dalam kumpulan yang sesuai), atau oleh
&NAME, dalam hal ini ia akan benar hanya apabila dinilai semasa rekursi dalam nama
kumpulan.

Berikut ialah ringkasan predikat yang mungkin:

(1) (2) ...
Menyemak sama ada kumpulan penangkap bernombor telah sepadan dengan sesuatu.

( ) ('NAMA')
Menyemak sama ada kumpulan dengan nama yang diberikan telah memadankan sesuatu.

(?=...) (?!...) (?<=...) (?
Menyemak sama ada corak sepadan (atau tidak sepadan, untuk varian '!').

(?{ KOD })
Menganggap nilai pulangan blok kod sebagai syarat.

(R) Semak sama ada ungkapan telah dinilai di dalam rekursi.

(R1) (R2) ...
Semak sama ada ungkapan telah dinilai semasa melaksanakan secara langsung di dalam
kumpulan tangkap ke-n. Semakan ini adalah setara dengan regex

jika ((pemanggil(0))[3] eq 'subname') { ... }

Dalam erti kata lain, ia tidak menyemak timbunan rekursi penuh.

(R&NAME)
Sama seperti "(R1)", predikat ini menyemak untuk melihat sama ada kita melaksanakan secara langsung di dalam
kumpulan paling kiri dengan nama yang diberikan (ini adalah logik yang sama digunakan oleh "(?&NAME)"
untuk menyahkekaburan). Ia tidak menyemak timbunan penuh, tetapi hanya nama
rekursi aktif paling dalam.

(DEFINE)
Dalam kes ini, corak ya tidak pernah dilaksanakan secara langsung, dan tiada corak tidak dilaksanakan
dibenarkan. Semangat serupa dengan "(?{0})" tetapi lebih cekap. Lihat di bawah untuk butiran.

Sebagai contoh:

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

sepadan dengan sebahagian daripada bukan kurungan, mungkin termasuk dalam kurungan itu sendiri.

Bentuk khas ialah predikat "(DEFINE)", yang tidak pernah melaksanakan corak yanya
secara langsung, dan tidak membenarkan tanpa corak. Ini membolehkan seseorang mentakrifkan subcorak yang
hanya akan dilaksanakan oleh mekanisme rekursi. Dengan cara ini, anda boleh menentukan satu set
peraturan ungkapan biasa yang boleh digabungkan ke dalam mana-mana corak yang anda pilih.

Adalah disyorkan bahawa untuk penggunaan ini anda meletakkan blok DEFINE di hujung
corak, dan anda menamakan mana-mana subcorak yang ditakrifkan di dalamnya.

Juga, perlu diperhatikan bahawa corak yang ditakrifkan dengan cara ini mungkin tidak akan seperti
cekap, kerana pengoptimum tidak begitu bijak mengendalikannya.

Contoh bagaimana ini boleh digunakan adalah seperti berikut:

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

Ambil perhatian bahawa kumpulan tangkapan yang dipadankan di dalam rekursi tidak boleh diakses selepas
rekursi kembali, jadi lapisan tambahan kumpulan penangkapan diperlukan. Justeru
$+{NAME_PAT} tidak akan ditakrifkan walaupun $+{NAME} akan ditakrifkan.

Akhir sekali, perlu diingat bahawa subcorak yang dibuat di dalam kiraan blok DEFINE terhadap
bilangan tangkapan mutlak dan relatif, jadi ini:

my @captures = "a" =~ /(.) # Tangkapan pertama
(?(DEFINE)
(? 1 ) # Tangkapan kedua
)/x;
katakan skalar @captures;

Akan mengeluarkan 2, bukan 1. Ini amat penting jika anda berhasrat untuk menyusun
takrifan dengan pengendali "qr//", dan kemudian interpolasikannya dalam corak lain.

"(?>corak)"
Subungkapan "bebas", yang sepadan dengan subrentetan yang a mandiri
"corak" akan sepadan jika berlabuh pada kedudukan yang diberikan, dan ia sepadan apa-apa lain
daripada ini subrentetan. Pembinaan ini berguna untuk pengoptimuman perkara yang akan dilakukan
sebaliknya menjadi perlawanan "kekal", kerana ia tidak akan berundur (lihat "Menjejak Belakang").
Ia juga mungkin berguna di tempat di mana "rebut semua yang anda boleh, dan jangan berikan apa-apa
kembali" semantik adalah wajar.

Contohnya: "^(?>a*)ab" tidak akan sepadan, sejak "(?>a*)" (dilabuhkan pada permulaan
rentetan, seperti di atas) akan sepadan semua aksara "a" pada permulaan rentetan, meninggalkan
tiada "a" untuk "ab" untuk dipadankan. Sebaliknya, "a*ab" akan sepadan dengan "a+b", kerana
padanan subkumpulan "a*" dipengaruhi oleh kumpulan "ab" berikut (lihat
"Menjejak ke belakang"). Khususnya, "a*" di dalam "a*ab" akan sepadan dengan lebih sedikit aksara daripada a
"a*" tersendiri, kerana ini menjadikan ekor sepadan.

"(?>corak)" tidak melumpuhkan pengesanan belakang sama sekali setelah ia sepadan. Ia adalah
masih boleh diundur melepasi binaan, tetapi tidak ke dalamnya. Jadi
"((?>a*)|(?>b*))ar" masih akan sepadan dengan "bar".

Kesan yang serupa dengan "(?>corak)" boleh dicapai dengan menulis "(?=(corak))\g{-1}".
Ini sepadan dengan subrentetan yang sama seperti "a+" yang berdiri sendiri dan "\g{-1}" berikut makan
rentetan yang dipadankan; oleh itu ia membuat penegasan panjang sifar menjadi analog bagi
"(?>...)". (Perbezaan antara kedua-dua konstruk ini ialah yang kedua menggunakan a
menangkap kumpulan, sekali gus mengalihkan ordinal rujukan belakang dalam baki biasa
ungkapan.)

Pertimbangkan corak ini:

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

Itu akan memadankan kumpulan yang tidak kosong secara cekap dengan padanan kurungan dua tahap dalam
atau kurang. Walau bagaimanapun, jika tiada kumpulan sedemikian, ia akan mengambil masa hampir selama-lamanya
tali. Itu kerana terdapat banyak cara yang berbeza untuk memisahkan rentetan panjang
beberapa subrentetan. Inilah yang "(.+)+" lakukan dan "(.+)+" adalah serupa dengan a
subcorak pola di atas. Pertimbangkan cara corak di atas mengesan tiada padanan dihidupkan
"((()aaaaaaaaaaaaaaaa" dalam beberapa saat, tetapi setiap huruf tambahan menggandakan ini
masa. Prestasi eksponen ini akan menunjukkan bahawa program anda telah digantung.
Walau bagaimanapun, perubahan kecil kepada corak ini

m{ \(
(
(?> [^()]+ ) # tukar x+ di atas kepada (?> x+ )
|
\( [^()]* \)
)+
\)
}x

yang menggunakan "(?>...)" sepadan dengan tepat apabila yang di atas melakukannya (mengesahkan ini sendiri
akan menjadi latihan yang produktif), tetapi selesai dalam masa keempat apabila digunakan pada a
rentetan serupa dengan 1000000 "a" s. Sedar, bagaimanapun, bahawa, apabila binaan ini
diikuti dengan pengkuantiti, pada masa ini ia mencetuskan mesej amaran di bawah "use
amaran" pragma atau -w suis mengatakan ia "padanan rentetan null berkali-kali dalam regex".

Pada kumpulan mudah, seperti corak "(?> [^()]+ )", kesan yang setanding mungkin
dicapai dengan pandangan negatif ke hadapan, seperti dalam "[^()]+ (?! [^()] )". Ini hanya 4 kali
lebih perlahan pada rentetan dengan 1000000 "a" s.

Semantik "rebut semua yang anda boleh, dan jangan berikan apa-apa kembali" adalah diingini dalam kebanyakan orang
situasi di mana pada pandangan pertama "()*" mudah kelihatan seperti penyelesaian yang betul.
Katakan kita menghuraikan teks dengan ulasan yang dibatasi oleh "#" diikuti dengan beberapa pilihan
(mendatar) ruang putih. Bertentangan dengan penampilannya, "#[ \t]*" is tidak yang betul
subungkapan untuk memadankan pembatas ulasan, kerana ia mungkin "menyerah" beberapa ruang kosong
jika baki corak boleh dibuat untuk dipadankan dengan cara itu. Jawapan yang betul ialah
salah satu daripada ini:

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

Sebagai contoh, untuk mendapatkan ulasan tidak kosong menjadi $1, seseorang harus menggunakan salah satu daripada ini:

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

Mana satu yang anda pilih bergantung pada ungkapan mana yang lebih menggambarkan perkara di atas
spesifikasi ulasan.

Dalam sesetengah literatur, binaan ini dipanggil "padanan atom" atau "posesif
sepadan".

Pengkuantiti posesif adalah bersamaan dengan meletakkan item yang digunakan di dalamnya
daripada salah satu binaan ini. Persamaan berikut digunakan:

Borang Pengkuantiti Borang Kurungan
--------------- ---------------
PAT*+ (?>PAT*)
PAT++ (?>PAT+)
PAT?+ (?>PAT?)
PAT{min,maks}+ (?>PAT{min,maks})

"(?[ ])"
Lihat "Kelas Aksara Kurung Lanjutan" dalam perlrecharclass.

khas Backtracking Mengawal Kata Kerja
Corak khas ini biasanya dalam bentuk "(*KATA KERJA:ARG)". Melainkan dinyatakan sebaliknya
hujah ARG adalah pilihan; dalam beberapa kes, ia dilarang.

Mana-mana corak yang mengandungi kata kerja menjejak ke belakang khas yang membenarkan hujah mempunyai khas
tingkah laku yang apabila dilaksanakan ia menetapkan $REGERROR dan $REGMARK pakej semasa
pembolehubah. Apabila berbuat demikian peraturan berikut terpakai:

Apabila gagal, pembolehubah $REGERROR akan ditetapkan kepada nilai ARG pola kata kerja, jika
kata kerja itu terlibat dalam kegagalan perlawanan. Jika bahagian ARG pada corak itu ialah
ditinggalkan, maka $REGERROR akan ditetapkan kepada nama corak "(*MARK:NAME)" terakhir
dilaksanakan, atau menjadi BENAR jika tiada. Selain itu, pembolehubah $REGMARK akan ditetapkan kepada FALSE.

Pada perlawanan yang berjaya, pembolehubah $REGERROR akan ditetapkan kepada FALSE dan $REGMARK
pembolehubah akan ditetapkan kepada nama corak "(*MARK:NAME)" yang terakhir dilaksanakan. Lihat
penjelasan untuk kata kerja "(*MARK:NAME)" di bawah untuk butiran lanjut.

PERHATIAN: $REGERROR dan $REGMARK bukanlah pembolehubah ajaib seperti $1 dan kebanyakan berkaitan regex yang lain
pembolehubah. Mereka bukan setempat untuk skop, atau baca sahaja, sebaliknya adalah pakej yang tidak menentu
pembolehubah serupa dengan $AUTOLOAD. Gunakan "tempatan" untuk menyetempatkan perubahan kepada mereka kepada yang khusus
skop jika perlu.

Jika corak tidak mengandungi kata kerja backtracking khas yang membenarkan hujah, maka
$REGERROR dan $REGMARK tidak disentuh sama sekali.

Kata kerja yang mengambil hujah
"(*PRUNE)" "(*PRUNE:NAME)"
Corak lebar sifar ini memangkas pokok menjejak ke belakang pada titik semasa apabila
mundur ke atas kegagalan. Pertimbangkan corak "A (*PRUNE) B", di mana A dan B adalah
corak kompleks. Sehingga kata kerja "(*PRUNE)" dicapai, A boleh berundur sebagai
perlu dipadankan. Setelah ia dicapai, pemadanan diteruskan dalam B, yang mungkin juga
mundur apabila perlu; walau bagaimanapun, sekiranya B tidak sepadan, maka tidak perlu berundur lagi
akan berlaku, dan corak akan gagal secara langsung pada permulaan semasa
kedudukan.

Contoh berikut mengira semua kemungkinan rentetan padanan dalam corak
(tanpa benar-benar sepadan dengan mana-mana daripada mereka).

'aaab' =~ /a+b?(?{print "$&\n"; $count++})(*GAGAL)/;
cetak "Count=$count\n";

yang menghasilkan:

aaab
aaa
aa
a
aab
aa
a
ab
a
Kira=9

Jika kita menambah "(*PRUNE)" sebelum kiraan seperti berikut

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

kami menghalang pengunduran dan mencari kiraan rentetan padanan terpanjang pada setiap satu
memadankan titik permulaan seperti:

aaab
aab
ab
Kira=3

Sebarang bilangan pernyataan "(*PRUNE)" boleh digunakan dalam corak.

Lihat juga "(?>corak)" dan pengkuantiti posesif untuk cara lain untuk mengawal
berundur. Dalam sesetengah kes, penggunaan "(*PRUNE)" boleh digantikan dengan a
"(?>corak)" tanpa perbezaan fungsi; walau bagaimanapun, "(*PRUNE)" boleh digunakan untuk
mengendalikan kes yang tidak boleh dinyatakan menggunakan "(?>corak)" sahaja.

"(*LANGKAH)" "(*LANGKAH:NAMA)"
Corak lebar sifar ini adalah serupa dengan "(*PRUNE)", kecuali jika ia gagal juga
menandakan bahawa apa-apa sahaja teks yang dipadankan yang membawa kepada corak "(*SKIP)".
dilaksanakan tidak boleh menjadi sebahagian daripada mana-mana padanan corak ini. Ini bermakna
bahawa enjin regex "melangkau" ke hadapan ke kedudukan ini apabila gagal dan cuba melakukannya
padankan lagi, (dengan mengandaikan bahawa terdapat ruang yang mencukupi untuk dipadankan).

Nama corak "(*LANGKAH:NAMA)" mempunyai kepentingan yang istimewa. Sekiranya
"(*MARK:NAME)" ditemui semasa memadankan, maka kedudukan itu ialah
digunakan sebagai "titik langkau". Jika tiada "(*MARK)" nama itu ditemui, maka
Pengendali "(*SKIP)" tidak mempunyai kesan. Apabila digunakan tanpa nama "titik langkau" adalah
di mana titik padanan adalah semasa melaksanakan corak (*SKIP).

Bandingkan yang berikut dengan contoh dalam "(*PRUNE)"; ambil perhatian bahawa rentetan adalah dua kali ganda
panjang:

'aaabaaab' =~ /a+b?(*SKIP)(?{cetak "$&\n"; $count++})(*GAGAL)/;
cetak "Count=$count\n";

output

aaab
aaab
Kira=2

Setelah 'aaab' pada permulaan rentetan telah dipadankan, dan "(*SKIP)" dilaksanakan,
titik permulaan seterusnya ialah di mana kursor berada semasa "(*SKIP)" berada
dilaksanakan.

"(*TANDA:NAMA)" "(*:NAMA)"
Corak lebar sifar ini boleh digunakan untuk menandakan titik yang dicapai dalam rentetan apabila a
bahagian tertentu corak telah berjaya dipadankan. Markah ini boleh diberikan a
nama. Corak "(*SKIP)" kemudian akan melangkau ke hadapan ke titik itu jika diundur
ke atas kegagalan. Sebarang bilangan corak "(*MARK)" dibenarkan dan bahagian NAME
boleh ditiru.

Selain berinteraksi dengan corak "(*SKIP)", "(*MARK:NAME)" boleh digunakan
untuk "melabel" cawangan corak, supaya selepas padanan, program boleh menentukan
cabang corak manakah yang terlibat dalam perlawanan itu.

Apabila perlawanan berjaya, pembolehubah $REGMARK akan ditetapkan kepada nama
terbaharu melaksanakan "(*MARK:NAME)" yang terlibat dalam perlawanan itu.

Ini boleh digunakan untuk menentukan cabang corak mana yang dipadankan tanpa menggunakan a
kumpulan tangkapan berasingan untuk setiap cawangan, yang seterusnya boleh menghasilkan prestasi
penambahbaikan, kerana perl tidak dapat mengoptimumkan "/(?:(x)|(y)|(z))/" secekap
sesuatu seperti "/(?:x(*MARK:x)|y(*MARK:y)|z(*MARK:z))/".

Apabila perlawanan telah gagal, dan melainkan kata kerja lain telah terlibat dalam kegagalan
sepadan dan telah memberikan namanya sendiri untuk digunakan, pembolehubah $REGERROR akan ditetapkan kepada
nama "(*MARK:NAME)" yang paling baru dilaksanakan.

Lihat "(*SKIP)" untuk butiran lanjut.

Sebagai pintasan "(*MARK:NAME)" boleh ditulis "(*:NAME)".

"(*KEMUDIAN)" "(*KEMUDIAN:NAMA)"
Ini serupa dengan pengendali "kumpulan potong" "::" daripada Perl 6. Seperti "(*PRUNE)",
kata kerja ini sentiasa sepadan, dan apabila berundur ke kegagalan, ia menyebabkan regex
enjin untuk mencuba seli seterusnya dalam kumpulan tertutup paling dalam (menangkap atau
sebaliknya) yang mempunyai selang-seli. Dua cabang a
"(?(syarat)ya-corak|tiada-corak)" tidak dikira sebagai selang-seli, setakat
"(*KEMUDIAN)" prihatin.

Namanya berasal dari pemerhatian bahawa operasi ini digabungkan dengan
pengendali gantian ("|") boleh digunakan untuk mencipta apa yang pada asasnya merupakan corak-
berdasarkan jika/kemudian/else blok:

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

Ambil perhatian bahawa jika pengendali ini digunakan dan BUKAN di dalam selang-seli maka ia bertindak
betul-betul seperti pengendali "(*PRUNE)".

/ A (*PRUNE) B /

adalah sama seperti

/ A (*KEMUDIAN) B /

tetapi

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

tidak sama dengan

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

kerana selepas memadankan A tetapi gagal pada B kata kerja "(*KEMUDIAN)" akan berundur dan
cuba C; tetapi kata kerja "(*PRUNE)" akan gagal.

Kata kerja tanpa hujah
"(*KOMIT)"
Ini ialah "corak komitmen" " Perl 6 " atau ":::". Ia ialah corak lebar sifar
serupa dengan "(*SKIP)", kecuali apabila diundur ke dalam kegagalan ia menyebabkan
perlawanan untuk gagal secara langsung. Tiada lagi percubaan untuk mencari perlawanan yang sah dengan memajukan
penunjuk mula akan berlaku lagi. Sebagai contoh,

'aaabaaab' =~ /a+b?(*KOMIT)(?{cetak "$&\n"; $count++})(*GAGAL)/;
cetak "Count=$count\n";

output

aaab
Kira=1

Dalam erti kata lain, sebaik sahaja "(*COMMIT)" telah dimasukkan, dan jika corak tidak
padanan, enjin regex tidak akan mencuba apa-apa padanan lanjut pada bahagian lain
tali.

"(*GAGAL)" "(*F)"
Corak ini tidak sepadan dan sentiasa gagal. Ia boleh digunakan untuk memaksa enjin
untuk berundur. Ia bersamaan dengan "(?!)", tetapi lebih mudah dibaca. Malah, "(?!)" mendapat
dioptimumkan menjadi "(*FAIL)" secara dalaman.

Ia mungkin berguna hanya apabila digabungkan dengan "(?{})" atau "(??{})".

"(*TERIMA)"
Corak ini tidak sepadan dan menyebabkan pemadanan yang berjaya pada titik itu berakhir
di mana corak "(*TERIMA)" ditemui, tidak kira sama ada terdapat
sebenarnya lebih kepada dipadankan dalam rentetan. Apabila berada di dalam corak bersarang, seperti
rekursi, atau dalam subcorak yang dijana secara dinamik melalui "(??{})", hanya
corak paling dalam ditamatkan serta-merta.

Jika "(*TERIMA)" berada di dalam kumpulan penangkapan maka kumpulan itu ditandakan sebagai
berakhir pada titik di mana "(*TERIMA)" ditemui. Sebagai contoh:

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

akan sepadan, dan $1 akan menjadi "AB" dan $2 akan menjadi "B", $3 tidak akan ditetapkan. Jika lain
cawangan dalam kurungan dalam telah dipadankan, seperti dalam rentetan 'ACDE', kemudian
"D" dan "E" perlu dipadankan juga.

Backtracking
NOTA: Bahagian ini membentangkan anggaran abstrak bagi tingkah laku ungkapan biasa. Untuk
pandangan yang lebih ketat (dan rumit) tentang peraturan yang terlibat dalam memilih padanan antara
alternatif yang mungkin, lihat "Menggabungkan Kepingan RE".

Ciri asas padanan ungkapan biasa melibatkan tanggapan yang dipanggil
mengundur, yang pada masa ini digunakan (apabila diperlukan) oleh semua biasa bukan milik
pengkuantiti ungkapan, iaitu "*", "*?", "+", "+?", "{n,m}", dan "{n,m}?". Menjejak ke belakang
selalunya dioptimumkan secara dalaman, tetapi prinsip umum yang digariskan di sini adalah sah.

Untuk memadankan ungkapan biasa, keseluruhan ungkapan biasa mesti sepadan, bukan hanya sebahagian
daripadanya. Jadi jika permulaan corak yang mengandungi pengkuantiti berjaya dengan cara itu
menyebabkan bahagian kemudian dalam corak gagal, enjin yang sepadan menyandar dan mengira semula
bahagian permulaan--itu sebabnya ia dipanggil mundur.

Berikut ialah contoh menjejak ke belakang: Katakan anda ingin mencari perkataan berikut "foo"
dalam rentetan "Makanan ada di atas meja foo.":

$_ = "Makanan ada di atas meja foo.";
jika ( /\b(foo)\s+(\w+)/i ) {
cetak "$2 mengikuti $1.\n";
}

Apabila perlawanan berjalan, bahagian pertama ungkapan biasa ("\b(foo)") mencari kemungkinan
padan betul-betul pada permulaan rentetan dan memuatkan $1 dengan "Foo". Namun begitu
kerana enjin yang sepadan melihat bahawa tiada ruang kosong mengikuti "Foo" yang dimilikinya
disimpan dalam $1, ia menyedari kesilapannya dan memulakan semula satu aksara selepas di mana ia
mempunyai perlawanan tentatif. Kali ini ia berterusan sehingga kejadian seterusnya
"foo". Ungkapan biasa yang lengkap sepadan dengan kali ini, dan anda mendapat output yang diharapkan
daripada "jadual mengikut foo."

Kadang-kadang padanan minimum boleh banyak membantu. Bayangkan anda ingin memadankan segala-galanya antara
"foo" dan "bar". Pada mulanya, anda menulis sesuatu seperti ini:

$_ = "Makanan berada di bawah bar di kandang.";
jika ( /foo(.*)bar/ ) {
cetak "mendapat <$1>\n";
}

Yang mungkin tanpa diduga menghasilkan:

mendapat

Itu kerana ".*" adalah tamak, jadi anda mendapat segala-galanya antara pertama "foo" dan lepas
"bar". Di sini adalah lebih berkesan untuk menggunakan padanan minimum untuk memastikan anda mendapat teks
antara "foo" dan "bar" pertama selepas itu.

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

Ini satu lagi contoh. Katakan anda ingin memadankan nombor pada penghujung rentetan dan
anda juga mahu mengekalkan bahagian sebelum perlawanan. Jadi anda tulis ini:

$_ = "Saya ada 2 nombor: 53147";
jika ( /(.*)(\d*)/ ) { # Salah!
cetak "Permulaan ialah <$1>, nombor ialah <$2>.\n";
}

Itu tidak akan berfungsi sama sekali, kerana ".*" tamak dan memakan keseluruhan rentetan. Sebagai "\d*"
boleh memadankan pada rentetan kosong ungkapan biasa yang lengkap dipadankan dengan jayanya.

Permulaan ialah , nombor ialah <>.

Berikut ialah beberapa varian, kebanyakannya tidak berfungsi:

$_ = "Saya ada 2 nombor: 53147";
@tepuk = qw{
(.*)(\d*)
(.*)(\d+)
(.*?)(\d*)
(.*?)(\d+)
(.*)(\d+)$
(.*?)(\d+)$
(.*)\b(\d+)$
(.*\D)(\d+)$
};

untuk $pat (@pats) {
printf "%-12s", $pat;
jika ( /$pat/ ) {
cetak "<$1> <$2>\n";
} Lain {
cetak "GAGAL\n";
}
}

Itu akan mencetak:

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

Seperti yang anda lihat, ini boleh menjadi agak rumit. Adalah penting untuk menyedari bahawa ungkapan biasa
hanyalah satu set pernyataan yang memberikan definisi kejayaan. Mungkin ada 0, 1, atau
beberapa cara berbeza yang definisi mungkin berjaya terhadap rentetan tertentu. Dan
jika terdapat pelbagai cara ia mungkin berjaya, anda perlu memahami menjejak ke belakang untuk mengetahui
yang pelbagai kejayaan yang akan anda capai.

Apabila menggunakan penegasan dan penolakan pandangan ke hadapan, ini semua boleh menjadi lebih rumit. Bayangkan
anda ingin mencari jujukan bukan digit yang tidak diikuti dengan "123". Anda mungkin cuba menulis
bahawa sebagai

$_ = "ABC123";
jika ( /^\D*(?!123)/ ) { # Salah!
cetak "Ya, tiada 123 dalam $_\n";
}

Tetapi itu tidak akan sepadan; sekurang-kurangnya, bukan seperti yang anda harapkan. Ia mendakwa bahawa ada
ialah no 123 dalam rentetan. Berikut ialah gambaran yang lebih jelas tentang sebab corak itu sepadan, sebaliknya
kepada jangkaan popular:

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

cetak "1: mendapat $1\n" jika $x =~ /^(ABC)(?!123)/;
cetak "2: mendapat $1\n" jika $y =~ /^(ABC)(?!123)/;

cetak "3: mendapat $1\n" jika $x =~ /^(\D*)(?!123)/;
cetak "4: mendapat $1\n" jika $y =~ /^(\D*)(?!123)/;

Ini mencetak

2: mendapat ABC
3: mendapat AB
4: mendapat ABC

Anda mungkin menjangkakan ujian 3 akan gagal kerana ia kelihatan seperti versi tujuan yang lebih umum
daripada ujian 1. Perbezaan penting antara mereka ialah ujian 3 mengandungi pengkuantiti
("\D*") dan seterusnya boleh menggunakan penjejakan ke belakang, manakala ujian 1 tidak akan. Apa yang berlaku ialah itu
anda telah bertanya "Adakah benar bahawa pada permulaan $x, mengikuti 0 atau lebih bukan digit, anda telah
sesuatu yang bukan 123?" Jika penjodoh corak telah membiarkan "\D*" berkembang kepada "ABC", ini
akan menyebabkan keseluruhan corak gagal.

Enjin carian pada mulanya akan memadankan "\D*" dengan "ABC". Kemudian ia akan cuba dipadankan
"(?!123)" dengan "123", yang gagal. Tetapi kerana pengkuantiti ("\D*") telah digunakan dalam
ungkapan biasa, enjin carian boleh mengundur dan mencuba semula padanan secara berbeza dalam
harapan untuk memadankan ungkapan biasa yang lengkap.

Coraknya sungguh, benar-benar mahu berjaya, jadi ia menggunakan corak standard back-off-and-
cuba semula dan biarkan "\D*" berkembang kepada hanya "AB" kali ini. Sekarang memang ada sesuatu
mengikuti "AB" yang bukan "123". Ia adalah "C123", yang memadai.

Kita boleh menangani perkara ini dengan menggunakan kedua-dua penegasan dan penafian. Kami akan mengatakan bahawa yang pertama
bahagian dalam $1 mesti diikuti oleh kedua-dua digit dan dengan sesuatu yang bukan "123". Ingat
bahawa pandangan ke hadapan adalah ungkapan lebar sifar--ia hanya melihat, tetapi tidak menggunakan mana-mana
rentetan dalam perlawanan mereka. Jadi menulis semula dengan cara ini menghasilkan apa yang anda harapkan; itu dia,
kes 5 akan gagal, tetapi kes 6 berjaya:

cetak "5: mendapat $1\n" jika $x =~ /^(\D*)(?=\d)(?!123)/;
cetak "6: mendapat $1\n" jika $y =~ /^(\D*)(?=\d)(?!123)/;

6: mendapat ABC

Dalam erti kata lain, kedua-dua penegasan lebar sifar bersebelahan antara satu sama lain berfungsi seolah-olah benar
DAN disatukan, sama seperti anda akan menggunakan sebarang pernyataan terbina dalam: "/^$/" padanan hanya jika anda
pada permulaan baris DAN penghujung baris serentak. Semakin dalam
kebenaran asas ialah penjajaran dalam ungkapan biasa sentiasa bermaksud DAN, kecuali
apabila anda menulis ATAU eksplisit menggunakan bar menegak. "/ab/" bermaksud padankan "a" DAN (kemudian)
padankan "b", walaupun padanan percubaan dibuat pada kedudukan yang berbeza kerana "a" adalah
bukan penegasan lebar sifar, tetapi penegasan satu lebar.

BERKHATAN :: Ungkapan biasa yang sangat rumit boleh mengambil masa eksponen untuk diselesaikan
kerana banyaknya kemungkinan cara yang mereka boleh gunakan menjejak ke belakang untuk mencuba a
perlawanan. Contohnya, tanpa pengoptimuman dalaman yang dilakukan oleh enjin ekspresi biasa,
ini akan mengambil masa yang sangat lama untuk dijalankan:

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

Dan jika anda menggunakan "*" dalam kumpulan dalaman dan bukannya mengehadkannya kepada 0 hingga 5
padanan, maka ia akan mengambil masa selama-lamanya--atau sehingga anda kehabisan ruang tindanan. Lebih-lebih lagi, ini
pengoptimuman dalaman tidak selalu boleh digunakan. Contohnya, jika anda meletakkan "{0,5}" sebaliknya
daripada "*" pada kumpulan luar, tiada pengoptimuman semasa boleh digunakan dan padanan mengambil masa a
lama nak habis.

Alat yang berkuasa untuk mengoptimumkan binatang tersebut ialah apa yang dikenali sebagai "kumpulan bebas",
yang tidak berundur (lihat ""(?>corak)""). Perhatikan juga bahawa panjang sifar
kenyataan pandang ke hadapan/pandang belakang tidak akan berundur untuk membuat ekor sepadan, kerana mereka
berada dalam konteks "logik": hanya sama ada ia sepadan dianggap relevan. Sebagai contoh
di mana kesan sampingan pandangan ke hadapan kekuatan telah mempengaruhi perlawanan berikut, lihat
""(?>corak)"".

versi 8 Biasa Ungkapan
Sekiranya anda tidak biasa dengan rutin regex Versi 8 "biasa", berikut ialah
peraturan padanan corak yang tidak diterangkan di atas.

Mana-mana watak tunggal sepadan dengan dirinya sendiri, melainkan ia adalah a metacharacter dengan makna yang istimewa
diterangkan di sini atau di atas. Anda boleh menyebabkan aksara yang biasanya berfungsi sebagai
metakarakter untuk ditafsirkan secara literal dengan memberi awalan dengan "\" (cth, "\."
sepadan dengan ".", bukan sebarang watak; "\\" sepadan dengan "\"). Mekanisme melarikan diri ini juga
diperlukan untuk watak yang digunakan sebagai pembatas corak.

Satu siri aksara sepadan dengan siri aksara dalam rentetan sasaran, jadi
corak "blurfl" akan sepadan dengan "blurfl" dalam rentetan sasaran.

Anda boleh menentukan kelas aksara, dengan melampirkan senarai aksara dalam "[]", yang akan
padankan mana-mana watak daripada senarai. Jika aksara pertama selepas "[" ialah "^", kelas itu
sepadan dengan mana-mana watak yang tiada dalam senarai. Dalam senarai, aksara "-" menentukan a
julat, supaya "az" mewakili semua aksara antara "a" dan "z", inklusif. Jika awak
mahu "-" atau "]" sendiri menjadi ahli kelas, letakkannya di permulaan senarai
(mungkin selepas "^"), atau elakkannya dengan garis miring ke belakang. "-" juga diambil secara literal apabila
ia berada di penghujung senarai, sejurus sebelum penutup "]". (Semua yang berikut menyatakan
kelas tiga aksara yang sama: "[-az]", "[az-]", dan "[a\-z]". Semua berbeza daripada
"[az]", yang menentukan kelas yang mengandungi dua puluh enam aksara, walaupun pada berasaskan EBCDIC
set aksara.) Juga, jika anda cuba menggunakan kelas aksara "\w", "\W", "\s", "\S",
"\d", atau "\D" sebagai titik akhir julat, "-" difahami secara literal.

Perhatikan juga bahawa keseluruhan julat idea agak tidak boleh dialih antara set aksara, kecuali
untuk empat situasi yang dikendalikan khas oleh Perl. Mana-mana subset julat "[AZ]",
"[az]", dan "[0-9]" dijamin sepadan dengan subset jangkaan aksara ASCII, tidak
tidak kira set watak apa yang platform sedang berjalan. Cara mudah alih keempat untuk menentukan
julat adalah menggunakan sintaks "\N{...}" untuk menentukan sama ada titik akhir julat. Untuk
contoh, "[\N{U+04}-\N{U+07}]" bermaksud memadankan titik kod Unikod "\N{U+04}",
"\N{U+05}", "\N{U+06}", dan "\N{U+07}", walau apa pun nilai aslinya pada
platform. Di bawah penggunaan semula 'ketat' atau dalam ""(?[ ])"", amaran dibangkitkan, jika didayakan,
dan satu lagi titik akhir julat yang mempunyai titik akhir "\N{...}" tidak mudah alih
ditentukan. Sebagai contoh,

[\N{U+00}-\x06] # Amaran di bawah "gunakan semula 'ketat'".

Sukar untuk difahami tanpa menggali apa sebenarnya yang sepadan dengan julat selain daripada subset
"[AZ]", "[az]", dan "[0-9]". Prinsip yang baik ialah menggunakan hanya julat yang bermula dari
dan berakhir sama ada abjad huruf besar yang sama ([ae], [AE]), atau digit ([0-9]). apa-apa sahaja
yang lain tidak selamat atau tidak jelas. Jika ragu-ragu, nyatakan julat sepenuhnya.

Aksara boleh ditentukan menggunakan sintaks metacharacter sama seperti yang digunakan dalam C: "\n"
sepadan dengan baris baharu, "\t" tab, "\r" pemulangan pengangkutan, "\f" suapan borang, dsb. Lagi
secara amnya, \nnn, Di mana nnn ialah rentetan tiga digit perlapanan, sepadan dengan aksara yang
nilai set aksara berkod ialah nnn. Begitu juga, \xnn, Di mana nn ialah digit heksadesimal,
sepadan dengan watak yang ordinalnya nn. Ungkapan \cx sepadan dengan watak
kawalan-x. Akhirnya, "." metacharacter sepadan dengan mana-mana aksara kecuali "\n" (melainkan anda
gunakan "/s").

Anda boleh menentukan satu siri alternatif untuk corak menggunakan "|" untuk memisahkan mereka, supaya
"fee|fie|foe" akan sepadan dengan mana-mana "fee", "fie", atau "foe" dalam rentetan sasaran (seperti
"f(e|i|o)e"). Alternatif pertama merangkumi segala-galanya daripada pembatas corak terakhir
("(", "(?:", dsb. atau permulaan corak) sehingga "|", dan yang terakhir
alternatif mengandungi segala-galanya daripada "|" terakhir ke pembatas corak penutup seterusnya.
Itulah sebabnya menjadi amalan biasa untuk memasukkan alternatif dalam kurungan: untuk meminimumkan
kekeliruan tentang di mana mereka bermula dan berakhir.

Alternatif dicuba dari kiri ke kanan, jadi alternatif pertama dijumpai yang
padanan keseluruhan ekspresi, adalah yang dipilih. Ini bermakna bahawa alternatif tidak
semestinya tamak. Contohnya: apabila memadankan "foo|foot" dengan "berkaki ayam", hanya
Bahagian "foo" akan sepadan, kerana itu adalah alternatif pertama yang dicuba, dan ia berjaya dipadankan
rentetan sasaran. (Ini mungkin kelihatan tidak penting, tetapi ia penting apabila anda berada
menangkap teks yang dipadankan menggunakan kurungan.)

Juga ingat bahawa "|" ditafsirkan sebagai literal dalam kurungan segi empat sama, jadi jika anda menulis
"[fee|fie|foe]" anda benar-benar hanya sepadan dengan "[feio|]".

Dalam corak, anda boleh menetapkan subcorak untuk rujukan kemudian dengan melampirkannya
kurungan, dan anda boleh merujuk kembali kepada nsubcorak ke kemudian dalam corak menggunakan
metacharacter \n atau \gn. Subcorak dinomborkan berdasarkan susunan kiri ke kanan
kurungan pembukaan mereka. Rujukan belakang sepadan dengan apa sahaja yang sebenarnya sepadan dengan
subcorak dalam rentetan yang sedang diperiksa, bukan peraturan untuk subcorak itu. Oleh itu,
"(0|0x)\d*\s\g1\d*" akan sepadan dengan "0x1234 0x4321", tetapi bukan "0x1234 01234", kerana subcorak
1 sepadan dengan "0x", walaupun peraturan "0|0x" berpotensi memadankan 0 terkemuka dalam
nombor kedua.

Amaran on \1 Sebaliknya of $1
Sesetengah orang terlalu biasa menulis perkara seperti:

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

Ini adalah datuk (untuk \1 hingga \9) untuk RHS pengganti untuk mengelakkan kejutan sed
penagih, tetapi ia adalah tabiat kotor untuk masuk ke dalam. Itu kerana dalam PerlThink, sebelah kanan
sisi "s///" ialah rentetan petikan dua kali. "\1" dalam rentetan petikan dua biasa bermaksud
kawalan-A. Makna Unix biasa "\1" dimasukkan ke dalam untuk "s///". Namun, jika
anda membiasakan diri untuk melakukan itu, anda mendapat masalah jika anda kemudian menambah
"/e" pengubah suai.

s/(\d+)/ \1 + 1 /cth; # menyebabkan amaran di bawah -w

Atau jika anda cuba lakukan

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

Anda tidak boleh menyahkekaburannya dengan menyebut "\{1}000", manakala anda boleh membetulkannya dengan "${1}000".
Operasi interpolasi tidak boleh dikelirukan dengan operasi padanan a
rujukan belakang. Sudah tentu mereka bermaksud dua perkara yang berbeza pada kiri sebelah "s///".

Berulang Corak Pemadanan a Panjang sifar Subrentetan
BERKHATAN :: Bahan yang sukar (dan prosa) di hadapan. Bahagian ini memerlukan penulisan semula.

Ungkapan biasa menyediakan bahasa pengaturcaraan yang ringkas dan berkuasa. Seperti kebanyakan yang lain
alat kuasa, kuasa datang bersama-sama dengan keupayaan untuk mendatangkan malapetaka.

Penyalahgunaan biasa kuasa ini berpunca daripada keupayaan untuk membuat gelung tak terhingga menggunakan biasa
ungkapan, dengan sesuatu yang tidak berbahaya seperti:

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

"o?" padanan pada permulaan 'foo', dan kerana kedudukan dalam rentetan tidak
terharu dengan perlawanan itu, "o?" akan sepadan lagi dan lagi kerana pengkuantiti "*".
Satu lagi cara biasa untuk mencipta kitaran yang serupa ialah dengan pengubah suai gelung "//g":

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

or

cetak "padanan: <$&>\n" manakala 'foo' =~ m{ o? }xg;

atau gelung yang tersirat oleh berpecah ().

Walau bagaimanapun, pengalaman yang panjang telah menunjukkan bahawa banyak tugas pengaturcaraan mungkin ketara
dipermudahkan dengan menggunakan subungkapan berulang yang mungkin sepadan dengan subrentetan panjang sifar. Ini
contoh mudah ialah:

@chars = split //, $string; # // bukan sihir dalam perpecahan
($dicuci putih = $rentetan) =~ s/()/ /g; # ibu bapa mengelakkan sihir s// /

Oleh itu Perl membenarkan binaan sedemikian, oleh secara paksa memecahkan yang tak terhingga gelung. Peraturan untuk
ini berbeza untuk gelung peringkat rendah yang diberikan oleh pengkuantiti tamak "*+{}", dan untuk
peringkat lebih tinggi seperti pengubah "/g" atau berpecah () pengendali.

Gelung peringkat bawah ialah terganggu (iaitu, gelung rosak) apabila Perl mengesannya
ungkapan berulang sepadan dengan subrentetan panjang sifar. Justeru

m{ (?: BUKAN_SIF_LENGTH | SIFAR_LENGTH )* }x;

dibuat bersamaan dengan

m{ (?: BUKAN_SIF_LENGTH )* (?: SIFAR_LENGTH )? }x;

Sebagai contoh, program ini

#!perl -l
"aaaab" =~ /
(?:
# bukan sifar
| # atau
(?{print "hello"}) # print hello bila-bila masa ini
# cawangan dicuba
(?=(b)) # penegasan lebar sifar
)* # berapa kali
/x;
cetak $&;
cetak $1;

cetakan

hello
aaaaa
b

Perhatikan bahawa "hello" hanya dicetak sekali, seperti apabila Perl melihat bahawa lelaran keenam
"(?:)*" paling luar sepadan dengan rentetan panjang sifar, ia menghentikan "*".

Gelung peringkat lebih tinggi mengekalkan keadaan tambahan antara lelaran: sama ada yang terakhir
perlawanan adalah sifar panjang. Untuk memecahkan gelung, padanan berikut selepas padanan panjang sifar
adalah dilarang mempunyai panjang sifar. Larangan ini berinteraksi dengan mundur (lihat
"Menjejak ke belakang"), dan sebagainya kedua terbaik perlawanan dipilih jika terbaik perlawanan adalah sifar
panjang.

Sebagai contoh:

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

hasil dalam "<> <> <> <>". Pada setiap kedudukan rentetan padanan terbaik diberikan oleh
tidak tamak "??" ialah padanan panjang sifar, dan kedua terbaik padan adalah apa yang dipadankan oleh
"\w". Oleh itu padanan panjang sifar silih berganti dengan padanan panjang satu aksara.

Begitu juga, untuk "m/()/g" berulang, padanan kedua terbaik ialah perlawanan di kedudukan satu
takuk lebih jauh dalam rentetan.

Keadaan tambahan dipadankan bersama panjang sifar dikaitkan dengan yang dipadankan
rentetan, dan ditetapkan semula oleh setiap tugasan kepada pos(). Perlawanan panjang sifar pada penghujung perlawanan
perlawanan sebelumnya diabaikan semasa "berpecah".

Menggabungkan RE Pieces
Setiap bahagian asas ungkapan biasa yang diterangkan sebelum ini (seperti
"ab" atau "\Z") ​​boleh memadankan paling banyak satu subrentetan pada kedudukan rentetan input yang diberikan.
Walau bagaimanapun, dalam ungkapan biasa biasa kepingan asas ini digabungkan menjadi lebih banyak
corak rumit menggunakan gabungan operator "ST", "S|T", "S*" dsb. (dalam contoh ini
"S" dan "T" ialah subungkapan biasa).

Gabungan sedemikian boleh termasuk alternatif, yang membawa kepada masalah pilihan: jika kita memadankan a
ungkapan biasa "a|ab" melawan "abc", adakah ia sepadan dengan subrentetan "a" atau "ab"? Satu cara untuk
terangkan subrentetan mana yang sebenarnya dipadankan ialah konsep menjejak ke belakang (lihat
"Menjejak ke belakang"). Walau bagaimanapun, huraian ini terlalu tahap rendah dan membuatkan anda berfikir mengikut istilah
daripada pelaksanaan tertentu.

Penerangan lain bermula dengan tanggapan "lebih baik"/"lebih teruk". Semua subrentetan yang mungkin
dipadankan dengan ungkapan biasa yang diberikan boleh diisih daripada padanan "terbaik" kepada
perlawanan "terburuk", dan ia adalah perlawanan "terbaik" yang dipilih. Ini menggantikan soalan
daripada "apa yang dipilih?" dengan soalan "perlawanan mana yang lebih baik, dan yang mana lebih buruk?".

Sekali lagi, untuk bahagian asas tidak ada soalan sedemikian, kerana paling banyak satu padanan pada sesuatu
kedudukan adalah mungkin. Bahagian ini menerangkan tanggapan lebih baik/buruk untuk digabungkan
pengendali. Dalam huraian di bawah "S" dan "T" ialah subungkapan biasa.

"ST"
Pertimbangkan dua kemungkinan padanan, "AB" dan "A'B'", "A" dan "A'" ialah subrentetan yang boleh
dipadankan dengan "S", "B" dan "B'" adalah subrentetan yang boleh dipadankan dengan "T".

Jika "A" adalah padanan yang lebih baik untuk "S" daripada "A'", "AB" ialah padanan yang lebih baik daripada "A'B'".

Jika "A" dan "A'" bertepatan: "AB" adalah padanan yang lebih baik daripada "AB'" jika "B" adalah padanan yang lebih baik
untuk "T" daripada "B'".

"S|T"
Apabila "S" boleh sepadan, ia adalah padanan yang lebih baik daripada apabila hanya "T" boleh sepadan.

Pesanan dua perlawanan untuk "S" adalah sama seperti untuk "S". Serupa untuk dua perlawanan untuk
"T".

"S{REPEAT_COUNT}"
Padankan sebagai "SSS...S" (diulang seberapa banyak yang perlu).

"S{min,maks}"
Padan sebagai "S{maks}|S{maks-1}|...|S{min+1}|S{min}".

"S{min,maks}?"
Padan sebagai "S{min}|S{min+1}|...|S{maks-1}|S{maks}".

"S?", "S*", "S+"
Sama seperti "S{0,1}", "S{0,BIG_NUMBER}", "S{1,BIG_NUMBER}" masing-masing.

"S??", "S*?", "S+?"
Sama seperti "S{0,1}?", "S{0,BIG_NUMBER}?", "S{1,BIG_NUMBER}?" masing-masing.

"(?>S)"
Padanan padanan terbaik untuk "S" dan hanya itu.

"(?=S)", "(?<=S)"
Hanya padanan terbaik untuk "S" dipertimbangkan. (Ini penting hanya jika "S" mempunyai
menangkap kurungan, dan rujukan belakang digunakan di tempat lain dalam keseluruhan biasa
ungkapan.)

"(?!S)", "(?
Untuk pengendali pengelompokan ini tidak perlu menerangkan pesanan, kerana hanya
sama ada "S" boleh dipadankan atau tidak adalah penting.

"(??{ EXPR })", "(?PARNO)"
Susunan adalah sama seperti ungkapan biasa yang merupakan hasil EXPR, atau
corak yang terkandung oleh kumpulan tangkapan PARNO.

"(?(syarat)ya-corak|tiada-corak)"
Ingat bahawa "pola ya" atau "corak tidak" yang mana sebenarnya sudah sepadan
ditentukan. Susunan padanan adalah sama seperti subungkapan yang dipilih.

Resipi di atas menerangkan susunan mancis at a diberikan kedudukan. Satu lagi peraturan ialah
diperlukan untuk memahami cara perlawanan ditentukan untuk keseluruhan ungkapan biasa: padanan
pada kedudukan yang lebih awal adalah sentiasa lebih baik daripada perlawanan di kedudukan yang kemudian.

mewujudkan Adat RE Enjin
Mulai Perl 5.10.0, seseorang boleh mencipta enjin ekspresi biasa tersuai. Ini bukan untuk
pengsan, kerana mereka perlu memasangkan pada tahap C. Lihat perlreapi untuk butiran lanjut.

Sebagai alternatif, pemalar terlampau beban (lihat lebihan beban) menyediakan cara mudah untuk melanjutkan
kefungsian enjin RE, dengan menggantikan satu corak dengan yang lain.

Katakan bahawa kita ingin mendayakan urutan pelarian RE baharu "\Y|" yang sepadan dengan sempadan
antara aksara ruang putih dan aksara bukan ruang putih. Perhatikan bahawa
"(?=\S)(?
"\Y|" di tempat versi yang lebih rumit. Kita boleh mencipta modul "customre" untuk
melakukan ini:

pakej customre;
menggunakan lebihan beban;

sub import {
syif;
mati "Tiada hujah untuk customre::import dibenarkan" jika @_;
terlebih beban::constant 'qr' => \&convert;
}

sub tidak sah { mati "/$_[0]/: melarikan diri tidak sah '\\$_[1]'"}

# Kita juga mesti menjaga agar tidak terlepas daripada \\Y| yang sah
# jujukan, oleh itu kehadiran '\\' dalam peraturan penukaran.
%rules saya = ( '\\' => '\\\\',
'Y|' => qr/(?=\S)(?
sub convert {
my $re = shift;
$re =~ s{
\\ ( \\ | Y. )
}
{ $rules{$1} atau tidak sah($re,$1) }sgex;
pulangkan $re;
}

Sekarang "use customre" membolehkan pelarian baharu dalam ungkapan biasa yang berterusan, iaitu, mereka
tanpa sebarang interpolasi pembolehubah masa jalan. Seperti yang didokumenkan dalam beban berlebihan, penukaran ini
hanya akan berfungsi pada bahagian literal ungkapan biasa. Untuk "\Y|$re\Y|" pembolehubah
sebahagian daripada ungkapan biasa ini perlu ditukar secara eksplisit (tetapi hanya jika special
maksud "\Y|" harus didayakan di dalam $re):

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

Terbenam Kod Pelaksanaan Kekerapan
Peraturan tepat untuk kekerapan (??{}) dan (?{}) dilaksanakan dalam corak tidak ditentukan.
Dalam kes perlawanan yang berjaya, anda boleh menganggap bahawa mereka DWIM dan akan dilaksanakan
kiri ke kanan susun bilangan kali yang sesuai dalam laluan penerimaan corak
seperti mana-mana corak meta yang lain. Bagaimana laluan tidak menerima dan kegagalan padanan mempengaruhi
bilangan kali corak dilaksanakan secara khusus tidak ditentukan dan mungkin berbeza-beza bergantung
mengenai pengoptimuman yang boleh digunakan pada corak dan berkemungkinan berubah daripada versi
kepada versi.

Contohnya dalam

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

bilangan tepat "a" atau "b" dicetak tidak ditentukan untuk kegagalan, tetapi anda
mungkin menganggap ia akan dicetak sekurang-kurangnya sekali semasa perlawanan yang berjaya, tambahan pula anda
mungkin menganggap bahawa jika "b" dicetak, ia akan didahului oleh sekurang-kurangnya satu "a".

Dalam kes binaan bercabang seperti berikut:

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

anda boleh menganggap bahawa input "ac" akan mengeluarkan "ac", dan bahawa "abc" akan mengeluarkan hanya "c".

Apabila kod terbenam dikira, padanan yang berjaya akan memanggil kod sekali untuk setiap satu
lelaran yang dipadankan bagi pengkuantiti. Sebagai contoh:

"baik" =~ /g(?:o(?{cetak "o"}))*d/;

akan mengeluarkan "o" dua kali.

PCRE/Python Khidmat Bantuan
Mulai Perl 5.10.0, Perl menyokong beberapa sambungan khusus Python/PCRE kepada regex
sintaks. Walaupun pengaturcara Perl digalakkan untuk menggunakan sintaks khusus Perl, the
berikut juga diterima:

"(?P corak)"
Tentukan kumpulan tangkap bernama. Bersamaan dengan "(? corak)".

"(? P=NAME)"
Rujukan belakang kepada kumpulan tangkap bernama. Bersamaan dengan "\g{NAME}".

"(?P>NAME)"
Panggilan subrutin kepada kumpulan tangkap bernama. Bersamaan dengan "(?&NAME)".

Gunakan perlre dalam talian menggunakan perkhidmatan onworks.net