Regex módosítók – bekapcsolásuk

Ez egy referenciaoldal – ne érezd úgy, hogy muszáj elolvasnod, mivel meglehetősen szűkszavú. Más részek szükség esetén hivatkoznak rá.
A regex módosítók ezen az oldalon minden sarkon felbukkannak. Ahelyett, hogy ismételten elmagyaráznám, hogy mit csinálnak, és hogy milyen sokféleképpen lehet őket bekapcsolni minden regex-ízben, úgy döntöttem, hogy a négy leggyakoribbat (i, s, m és x) összegyűjtöm egy helyre. Az utolsó szakasz röviden áttekinti az egyéb módosítókat, amelyek általában nyelvspecifikusak.
Ugráspontok
A könnyebb navigáció érdekében itt van néhány ugráspont az oldal különböző részeihez:
✽ Case Insensitivity: i
✽ DOTALL (Dot Matches Line Breaks): s (kivéve Ruby és JavaScript)
✽ Multiline (^ és $ Match on Every Line):
✽ Free-Spacing: x (kivéve JavaScript)
✽ Egyéb módosítók
✽ PCRE’s Special Start-of-Pattern Modifiers
(direct link)

Case Insensitivity: i

By default, all major regex engines match in case-sensitive mode. Ha olyan mintákat szeretne, mint például Name: +, akkor ezt a funkciót be kell kapcsolnunk.
Igen, de…
Mit jelent valójában a nagy- és kisbetű-érzékenység?
Ha ragaszkodunk az angol ábécé 26 betűjéhez, a kis- és nagybetű definíciója egyszerű. Ha elágazunk a tipográfiai finomságok vagy más nyelvek és írásmódok felé, a dolgok nem mindig ilyen egyszerűek. Íme néhány kérdés, amibe belefuthatsz.
✽ A fl (egy karakter, azaz a fl ligatúra) megfelel az FL-nek?
✽ Az à (egy karakter) megfelel az À-nak?
✽ Az à (két karakter, azaz az a betű és az ékezet) megfelel az À-nak? Úgy tűnik, ezt minden motor helyesen kezeli.
✽ A ß megfelel az ss-nek? Úgy tűnik, ezt egyetlen motor sem teszi meg.
✽ Megfelel-e az i az İ-nek (török nagy i), valamint az I-nek?
Ezek a kérdések csak a jéghegy csúcsa. Még ha tudnám is az összes választ, lehetetlen lenne az összeset beilleszteni ebbe a szakaszba: ha egy adott szkriptet használsz, utána kell nézned, hogy az adott motor hogyan kezeli az adott szkriptben az eset-érzéketlenséget.
Több mint egy mód
Több motor esetében megjegyzendő, hogy az eset-érzéketlenséget kétféleképpen lehet bekapcsolni: inline módosítóként (?i) vagy a regex metódus vagy függvény opciójaként.
Inline módosító (?i)
A .NET, PCRE (C, PHP, R…), Perl, Python, Java és Ruby (de nem JavaScript) esetében használható az inline módosító (?i), például a (?i)cat. Lásd az inline módosítókról szóló részt, ahol három további (Pythonban nem elérhető) funkcióról olvashatsz szaftos részleteket: bekapcsolhatod a karakterlánc közepén, kikapcsolhatod a (?-i) kapcsolóval, vagy csak egy nem fogadó csoport tartalmára alkalmazhatod a (?i:foo)

.NET
A (?i) inline módosítón kívül a .NET nyelvek rendelkeznek az IgnoreCase opcióval. A C# nyelvben például:
var catRegex = new Regex("cat", RegexOptions.IgnoreCase);
Perl
A (?i) inline módosító mellett a Perl lehetővé teszi, hogy a minta záró elválasztója után hozzáadjuk az i zászlót. Például használhatod a következőt:
if ($the_subject =~ m/cat/i) { … }
PCRE (C, PHP, R…)
Megjegyzendő, hogy a PCRE-ben a nagy- és kisbetű-független megfeleltetés használatához a nem angol betűkkel, amelyek nem részei a nyelvterületének, be kell kapcsolnia az Unicode módot – például a (*UTF8) speciális mintaindító módosítóval.
A (?i) inline módosító mellett a PCRE lehetővé teszi a PCRE_CASELESS mód beállítását a pcre_compile() (vagy hasonló) függvény hívásakor:

cat_regex = pcre_compile( "cat", PCRE_CASELESS, &error, &erroroffset, NULL ); 

PHP-ben a PCRE_CASELESS opciót az i jelzővel adjuk át, amelyet a záró elválasztójel után adhatunk a regex karakterláncba. Például használhatja a következőt:
$cat_regex = '~cat~i';
Az R-ben a PCRE_CASELESS opciót az ignore.case=TRUE opcióval adjuk át. Használhatja például:
grep("cat", subject, perl=TRUE, value=TRUE, ignore.case=TRUE);
Python
A Pythonban a (?i) inline módosító mellett az IGNORECASE opció is rendelkezésre áll. Például használhatja:
cat_regex = re.compile("cat", re.IGNORECASE)
Java
A (?i) inline módosító mellett a Java rendelkezik a CASE_INSENSITIVE opcióval. Használhatja például:

Pattern catRegex = Pattern.compile( "cat", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE );

Az itt hozzáadott UNICODE_CASE opció biztosítja, hogy a case-insensivity funkció Unicode-tudatos legyen. Ha csak ASCII-vel dolgozol, nem kell használnod.
JavaScript
JavaScriptben az egyetlen lehetőséged, hogy a mintád záró elválasztójelzője után hozzáadod az i jelzőt. Például használhatod a következőt:
var catRegex = /cat/i;
Ruby
A (?i) inline módosító mellett a Ruby lehetővé teszi, hogy a minta záró elválasztójelzője után hozzáadja az i zászlót. Például használhatja a következőket:
cat_regex = /cat/i
(közvetlen hivatkozás)

DOTALL (Dot Matches Line Breaks): s (kivételekkel)

A dot . alapértelmezés szerint nem illeszkedik a sortörő karakterekhez, például a sortovábbításhoz és a kocsivégzéshez. Ha olyan mintákat szeretnénk, mint a BEGIN .*? END sorokon átívelő egyezéseket, akkor ezt a funkciót be kell kapcsolnunk.
Ezt a módot néha egysorosnak is nevezik (innen az s), mivel a pont az egész karakterláncot egyetlen nagy sornak tekinti – a.* az első karaktertől az utolsóig egyezik, függetlenül attól, hogy hány sortörés van közte.

A módot a PCRE-ben, a Pythonban és a Java-ban is DOTALL-nak nevezik (pontosabban a PCRE dokumentáció a PCRE_DOTALL-t használja). Számomra a DOTALL elnevezés értelmes módja ennek a módnak. A harmadik opció dot-matches-line-breaks leíró jellegű, de kissé szájbarágós.
Néhány motor esetében vegye figyelembe, hogy kétféleképpen lehet bekapcsolni: inline módosítóként vagy opcióként a regex metódusban vagy függvényben.
JavaScript
A JavaScript nem támogatja az egysoros módot. A JavaScript bármely karakterének megfeleltetéséhez, beleértve a sortöréseket is, használjon egy olyan konstrukciót, mint a . Ez a karakterosztály egy olyan karakterrel egyezik meg, amely vagy egy nem számjegy \D, vagy egy számjegy \d. Ezért bármilyen karakterrel megegyezik.
Egy másik JavaScript megoldás az XRegExp regex könyvtár használata. Ha végtelen időd van, megpróbálhatod a PCRE-t átültetni JavaScriptre az Emscripten segítségével, ahogy Firas is tette a regex 101-en.
Inline módosító (?s)
A .NET, PCRE (C, PHP, R…), Perl, Python és Java (de nem Ruby) esetében használhatod az inline módosítót (?s), például a (?s)BEGIN .*? END. Az inline módosítókról szóló fejezetben három további (Pythonban nem elérhető) szaftos részletet találsz: bekapcsolhatod a karakterlánc közepén, kikapcsolhatod a (?-s) kapcsolóval, vagy a (?s:foo)
.NET
A (?s) inline módosító mellett a .NET nyelvek rendelkeznek a Singleline opcióval. A C# nyelvben például:

var blockRegex = new Regex( "BEGIN .*? END", RegexOptions.IgnoreCase | RegexOptions.Singleline );

Perl
A (?s) inline módosító mellett a Perl lehetővé teszi, hogy a minta záró elválasztója után hozzáadjuk az s zászlót. Például használhatod a következőt:
if ($the_subject =~ m/BEGIN .*? END/s) { … }
PCRE (C, PHP, R…)
A (?s) inline módosító mellett a PCRE lehetővé teszi a PCRE_DOTALL mód beállítását a pcre_compile() (vagy hasonló) függvény hívásakor:

block_regex = pcre_compile( "BEGIN .*? END", PCRE_DOTALL, &error, &erroroffset, NULL ); 

A PHP-ben a PCRE_DOTALL opciót az s zászlóval adjuk át, amelyet a regex karakterláncunkban a záró elválasztó után adhatunk hozzá. Például használhatja a következőt:
$block_regex = '~BEGIN .*? END~s';
Python
A (?s) inline módosító mellett a Pythonban is van DOTALL opció. Például használhatja:
block_regex = re.compile("BEGIN .*? END", re.IGNORECASE | re.DOTALL)
Java
A (?s) inline módosító mellett a Java rendelkezik a DOTALL opcióval. Például használhatja:

Pattern blockRegex = Pattern.compile( "BEGIN .*? END", Pattern.CASE_INSENSITIVE | Pattern.DOTALL ); 

Ruby: (A Rubyban használhatjuk az inline módosítót (?m), például a (?m)BEGIN .*? END. Ez egy furcsa Ruby furcsaság, mivel más motorok a (?m)-t a “^ és $ minden sorban egyezik” módra használják.
Az inline módosítókról szóló fejezetben három további szaftos részletet találsz: bekapcsolhatod a karakterlánc közepén, kikapcsolhatod a (?-m)-vel, vagy csak egy nem elfogott csoport tartalmára alkalmazhatod a (?m:foo)
A Ruby lehetővé teszi azt is, hogy az m flag-et a regex karakterlánc végére helyezd. Például használhatjuk:
block_regex = /BEGIN .*? END/m
(közvetlen hivatkozás)
A DOTALL eredete
Az egysoros módot gyakran DOTALL-nak is nevezik (ami a “dot matches all” rövidítése), mivel a PCRE-ben a PCRE_DOTALL, a Pythonban a re.DOTALL, a Java-ban pedig a Pattern.DOTALL opciót használjuk.
Már többször hallottam azt állítani, hogy “a DOTALL egy Python dolog”, de úgy tűnt, hogy ez olyan emberektől származik, akik nem hallottak a PCRE és a Java megfelelő opcióiról. Ez mégis elgondolkodtatott: hol jelent meg először a DOTALL? A PCRE változásnaplóját és a régi Python dokumentációt átnézve úgy tűnik, hogy a PCRE-ben a 0.96-os verzióval (1997. október), a Pythonban az 1.5-ös verzióval (1998. február), majd a Java 1.4-ben (2002. február) jelent meg. A PCRE és a Python bevezetése közötti különbség nem volt meggyőző – a szó lehet, hogy már korábbi bétaverziókban, vagy akár más eszközökben is forgalomban volt -, ezért megkérdeztem Philip Hazelt (a PCRE atyját) erről. Ő így válaszolt:

Azt hiszem, én találtam ki – biztosan nem láttam máshol, amikor megpróbáltam kitalálni egy nevet a PCRE opciónak, amely megfelel a Perl /s opciójának. (“S” ott a “single-line”-t jelenti (…), ezért akartam egy jobb nevet.)

Szóval ott. Azok, akik szeretik a történelmet, élvezhetik ezt az ínycsiklandó rögöt.
(közvetlen link)

Multiline (^ és $ Match on Every Line): m (kivéve Ruby)

Alapértelmezés szerint a Ruby kivételével minden nagyobb motorban a ^ és $ horgonyok csak a karakterlánc elején és végén illeszkednek (illetve).
A Rubyban minden sor elején és végén illeszkednek, és ezt a funkciót nem lehet kikapcsolni. Ez tulajdonképpen egy ésszerű módja a dolgoknak, amivel a Ruby részben megváltja magát azért, hogy m-t használ a DOTALL módra, amikor más motorok s-t használnak.
Más motorokban, ha azt akarjuk, hogy az olyan minták, mint a ^Define és >>>>$ minden sor elején és végén egyezzenek (illetve), akkor ezt a funkciót be kell kapcsolnunk.
Ezt a funkciót általában többsorosnak nevezik (innen az m), mert a ^ és $ horgonyok több soron is működnek.

Más motoroknál figyeljük meg, hogy kétféleképpen kapcsolhatjuk be: soron belüli módosítóként (?m) vagy a regex módszer vagy függvény opciójaként.
Ruby
A Rubyban a ^ és $ horgonyok mindig minden sorban egyeznek. Nincs mód ennek az opciónak a kikapcsolására. Ez tulajdonképpen elég jó megoldás, mivel a legtöbb ízben külön horgonyok vannak a karakterláncok elejére és végére: \A, \Z és \z.
Másrészt sajnálhatjuk, hogy a Ruby nem szabványos módon használja az m jelzőt és a módosítót (lásd DOTALL).
Inline módosító (?m)
A .NET, PCRE (C, PHP, R…), Perl, Python, Java és Ruby (de nem JavaScript) esetében használhatjuk az inline módosítót (?m), például a (?m)^cat-ben. Az inline módosítókról szóló fejezetben három további (Pythonban nem elérhető) szaftos részletet találsz: bekapcsolhatod a karakterlánc közepén, kikapcsolhatod (?-m) segítségével, vagy csak egy nem fogadó csoport tartalmára alkalmazhatod (?m:foo)
.NET
A (?m) inline módosítón kívül a .NET nyelvek rendelkeznek a Multiline opcióval. A C# nyelvben például:

var catRegex = new Regex("^cat", RegexOptions.IgnoreCase | RegexOptions.Multiline); 

Perl
A (?m) inline módosító mellett a Perl lehetővé teszi, hogy az m jelzőt a minta záró elválasztója után adjuk hozzá. Például használhatod a következőt:
if ($the_subject =~ m/^cat/m) { … }
PCRE (C, PHP, R…)
A (?m) inline módosító mellett a PCRE lehetővé teszi a PCRE_MULTILINE üzemmód beállítását a pcre_compile() (vagy hasonló) függvény hívásakor:

cat_regex = pcre_compile( "^cat", PCRE_CASELESS | PCRE_MULTILINE, &error, &erroroffset, NULL ); 

A PHP-ben a PCRE_MULTILINE opciót az m flag segítségével adjuk át, amelyet a regex karakterláncunkban a záró elválasztó után adhatunk hozzá. Például használhatja a következőt:
$cat_regex = '~^cat~m';
Python
A (?m) inline módosító mellett a Pythonban is van MULTILINE opció. Például használhatja:
cat_regex = re.compile("^cat", re.IGNORECASE | re.MULTILINE)
Java
A (?m) inline módosító mellett a Java rendelkezik a MULTILINE opcióval. Például használhatod:

Pattern catRegex = Pattern.compile( "^cat", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE ); 

JavaScript
A JavaScriptben az egyetlen lehetőséged az m jelző hozzáadása a minta záró elválasztója után. Például használhatja a következőket:
var catRegex = /^cat/m;
(közvetlen hivatkozás)

Free-Spacing: x (kivéve JavaScript)

Egy regex karakterláncban alapértelmezés szerint minden szóköz egy illesztendő karaktert jelöl. Azokon a nyelveken, ahol a regex karakterláncok több sorba írhatók, a sortörések is megadják az illesztendő szó szerinti karaktereket. Mivel nem lehet szóközöket beilleszteni a különböző jelentéssel bíró csoportok elválasztására (ahogyan angolul írva a mondatok és pragrafák közé), a regex nehezen olvashatóvá válhat, mint például a Meaning of Life regex a regex humor oldalról:

^(?=(?!(.))()(?-1)(?<!\d(?<=(?!)\d))).$
Szerencsére sok motor támogatja a szabad szóközöket tartalmazó módot, amely lehetővé teszi a regex szellőztetését. Például szóközöket adhatsz a tokenek közé. PHP-ben ezt írhatnád – figyeld meg az x zászlót a végső elválasztó ~ után:
$word_with_digit_and_cap_regex = '~ ^ (?=\D*\d) \w*\w* $ ~x';
De miért maradnál egy sorban? A regexet annyi sorra oszthatod szét, ahány sorra csak akarod – elzárással és megjegyzésekkel -, amelyeket egy # vezet be. C# nyelven például valami ilyesmit tehetsz:

var wordWithDigitAndCapRegex = new Regex(@"(?x) # Free-spacing mode ^ # Assert that position = beginning of string ######### Lookahead ########## (?= # Start lookahead \D* # Match any non-digits \d # Match one digit ) # End lookahead ######## Matching Section ######## \w* # Match any word chars # Match one upper-case letter \w* # Match any word chars $ # Assert that position = end of string");

Ezt a módot nevezzük szabad szóközös módnak. Találkozhatsz vele whitespace mode, comment mode vagy verbose mode néven is.
Ez túlzás lehet egy olyan egyszerű regexben, mint a fenti (bár bár bárki, akinek karbantartania kell a kódodat, hálás lesz érte). De ha egy komoly regexmintát építesz, mint amilyen a trükkben látható, hogy számokat egyeztess egyszerű angol nyelven… Hacsak nem vagy mazochista, nincs más választásod.
Megjegyezzük, hogy egy karakterosztályon belül a szóköz karakter és a # (ami egyébként megjegyzéseket vezet be) még mindig tiszteletben van tartva – kivéve a Java-ban, ahol mindkettőt el kell kerülni, ha ezekkel a karakterekkel akarsz egyezni.
Néhány motor esetében kétféleképpen lehet bekapcsolni a szabad szóköz módot: inline módosítóként vagy a regex metódus vagy függvény opciójaként.
A szabad szóköz mód csodálatos, de van néhány kisebb veszély, amivel érdemes tisztában lenni, mivel ezek miatt előfordulhat, hogy a fejünket vakargatva csodálkozunk, hogy egy minta miért nem úgy működik, ahogy vártuk.
Botlásveszély #1: A szóköz jelentése
Először is, már nem használhatod a Számot: \d+ egy olyan karakterláncra, mint a Number: 24. Ennek oka, hogy a szóköz a : \d már nem felel meg a szóköznek. Szabad szóköz üzemmódban vagyunk, emlékszel? Ez az egésznek a lényege.
A szóköz karakterrel való egyezéshez meg kell adnod a szóközt. Ennek két fő módja, hogy egy karakterosztályon belül helyezzük el, vagy backslash-szel szüntetjük meg. Bármelyik működne: A Number:\d+ vagy Number:\ \ \d+
Természetesen a Number:\s\d+ is megfelel, de ne feledjük, hogy az \s sokkal többre illik, mint a szóköz karakter. Például megfelelhet egy tabulátornak vagy egy sortörésnek is. Lehet, hogy nem ezt szeretné.

Trip Hazard #2: Late Start
Második lehetőség, hogy túlságosan bízik a szabad szóköz erejében, és valami ilyesmivel próbálkozik, hogy a regex önállóan álljon:

var wordWithDigitAndCapRegex = new Regex(@" (?x) # Free-spacing mode ^ # Beginning of string etc # Match the literal chars e,t,c");

A probléma ezzel az, hogy bár úgy tűnik, mintha a szabad szóköz módosító (?x) az első dolog a regexedben, ez nem így van.
A nyitó dupla idézőjel ” után van egy sortörés és több szóköz. A motor megpróbál ezeknek megfelelni, mert ebben a szakaszban még nem vagyunk szabad térben. Ez az üzemmód csak akkor kapcsol be, amikor találkozunk (?x). Ez a regex soha nem fog megfelelni a string stb. és még többre, mert mire találkozunk a string horgonyzó ^ elejével, már a sortörést és a szóköz karaktereket kellene megfeleltetnünk!
Ez az oka annak, hogy ha megnézed az első példát, látni fogod, hogy a szabad szóköz módosító (?x) a legelső dolog a nyitó idézőjel karakter után.
A szóközöket nem egyszerűen kivágjuk a mintából
Még ha a szóközöket figyelmen kívül is hagyjuk, a szóköz pozíciója még mindig elválasztja az előző és a következő tokent. Például
✽ (A)\1 2 nem azonos az (A)\12-vel. Az előbbi megfelel AA2-nek, az utóbbi megfelel A\n-nek .NET-ben, PCRE-ben, Perl-ben és Ruby-ban (a 12 a sorvégi karakter oktális kódja)
✽ \p{Nd} érvényes, de \p{N d} nem – kivéve Perl-ben és Ruby-ban
JavaScript
JavaScript nem támogatja a szabad szóköz módot. JavaScriptben bármely karakterhez, beleértve a sortörést is, egy olyan konstrukciót kell használni, mint a . Ez a karakterosztály egy olyan karakterrel egyezik meg, amely vagy egy nem számjegy \D, vagy egy számjegy \d. Ezért bármilyen karakterrel megegyezik.
Egy másik JavaScript megoldás az XRegExp regex könyvtár használata. Ha végtelen időd van, megpróbálhatod a PCRE-t átültetni JavaScriptre az Emscripten segítségével, ahogy Firas is tette a regex 101-en.
Inline módosító (?s)
A .NET, PCRE (C, PHP, R…), Perl, Python, Java és Ruby (de nem JavaScript) esetében használhatod az inline módosítót (?x), ez például egy légiesített regex az ismétlődő szavakra:
(?x) (\w+) + \bLásd még az inline módosítókról szóló részt.
.NET
A (?x) inline módosító mellett a .NET nyelvek rendelkeznek az IgnorePatternWhitespace opcióval. A C# nyelvben például használhatjuk:

var repeatedWordRegex = new Regex(@" (\w+) + \b", RegexOptions.IgnorePatternWhitespace );

Perl
A (?x) inline módosító mellett a Perl lehetővé teszi, hogy a minta záró elválasztója után hozzáadjuk az x zászlót. Például használhatod a következőt:

if ($the_subject =~ m/(\w+) + \b/x) { … }
PCRE (C, PHP, R…)
A (?x) inline módosító mellett a PCRE lehetővé teszi a PCRE_EXTENDED üzemmód beállítását a pcre_compile() (vagy hasonló) függvény hívásakor:

repeated_word_regex = pcre_compile( "(\w+) + \b", PCRE_EXTENDED, &error, &erroroffset, NULL ); 

A PHP-ben a PCRE_EXTENDED opciót az x flag segítségével adjuk át, amelyet a regex karakterláncunkban a záró elválasztó után adhatunk hozzá. Például használhatja a következőt:
$repeated_word_regex = '~(\w+) + \b~x';
Python
A (?x) inline módosító mellett a Python rendelkezik a VERBOSE opcióval. Például használhatod:
repeated_word_regex = re.compile(r"(\w+) + \b", re.VERBOSE)
Java
A többi motorral ellentétben a Java karakteres osztályon belül a hash-okat bevezető kommentek és szóközök figyelmen kívül maradnak, ezért ezeket ki kell kerülnöd, ha ezeket a karaktereket egy osztályban akarod használni, például +
A (?x) inline módosító mellett a Java rendelkezik a COMMENTS opcióval. Például használhatod:

Pattern repeatedWordRegex = Pattern.compile( "(\w+) + \1\b", Pattern.COMMENTS );

Ruby
A (?x) inline módosító mellett a Ruby lehetővé teszi, hogy a regex karakterláncod végére x jelzőt adj. Például használhatod a következőket:
repeated_word_regex = /(\w+) + \b/x
(közvetlen hivatkozás)

Más módosítók

Egyes motorok támogatják az i, s, m és x módosítókon és zászlókon kívül az i, s, m és x módosítókat. tervezem, hogy az ezeknek az ízeknek szentelt oldalakon foglalkozom velük.
A
✽ .NET például rendelkezik a (?n) módosítóval (az ExplicitCapture opcióval is elérhető). Ez minden (zárójeles) csoportot nem befogadó csoportokká alakít. A rögzítéshez megnevezett csoportokat kell használni.
✽ A Java rendelkezik a (?d) módosítóval (amely a UNIX_LINES opcióval is elérhető). Ha ez be van kapcsolva, akkor a sortovábbítási karakter \n az egyetlen, ami befolyásolja a pont . (amely nem illeszkedik a sortörésekhez, kivéve, ha a DOTALL be van kapcsolva) és a ^ és $ horgonyokat (amelyek többsoros üzemmódban a sor elejére és végére illeszkednek.)
✽ A Perlnek több más jelzője is van. Lásd a dokumentáció módosító szakaszát.
✽ A PCRE rendelkezik a (?J) módosítóval (kódban is elérhető a PCRE_DUPNAMES opcióval). Ha be van állítva, a különböző elfogási csoportok ugyanazt a nevet használhatják – bár különböző számokat kapnak.
(közvetlen link)
✽ A PCRE rendelkezik a (?U) módosítóval (a kódban is elérhető a PCRE_UNGREEDY opcióval). Ha be van állítva, a kvantifikátorok alapértelmezés szerint nem mohóak. Egy ? hozzáadása mohóvá teszi őket.

(közvetlen link)
✽ A PCRE rendelkezik a (?X) módosítóval (a kódban a PCRE_EXTRA opcióval is elérhető). Történelmileg ezt a módot a fejlesztés során új funkciók engedélyezésére használták. Jelenleg hibát vált ki, ha olyan tokeneket használnak, mint a \B egy karakterosztályon belül (ahol általában a B nagybetűvel egyezik meg, ellentétben a karakterosztályon kívül, ahol ez egy nem szóhatár-kijelentés).
✽ A PCRE-nek számos speciális módosítója van, amelyeket a minta elején lehet beállítani (ezek alább láthatóak). Ezen kívül számos opciót el lehet küldeni a pcre_compile() függvénycsaládnak, ha van hozzáférésünk hozzájuk. Ezekkel kapcsolatos részletekért a pcre_compile.html fájlt a doc mappából a PCRE letöltésével szerezze be.
(közvetlen link)

PCRE speciális mintaindító módosítók

A PCRE számos “speciális módosítóval” rendelkezik, amelyeket a minta elején állíthat be. A soron belüli módosítók standard (?z) szintaxisa helyett a speciális módosítók szintaxisa így néz ki: (*MYMODIFIER). Ezek a módosítók különösen hasznosak olyan kontextusokban, ahol a PCRE egy eszközbe vagy nyelvbe van integrálva – mivel számos olyan opciót helyettesítenek, amelyet a pcre_compile() parancsnak küldenél.
UTF karakterláncok
Feltéve, hogy a PCRE-t a megfelelő opciókkal fordítottuk le, utasíthatjuk a motort, hogy a tárgy karakterláncot különböző típusú UTF karakterláncokként kezelje.
✽ (*UTF) egy általános módja annak, hogy a tárgyat UTF karakterláncként kezeljük – megállapítva, hogy UTF-8, UTF-16 vagy UTF-32 karakterláncként kell-e kezelni.
✽ (*UTF8), (*UTF16) és (*UTF32) a karakterláncot három konkrét UTF-kódolás egyikeként kezeli.
Unicode Properties for \d and \w
Az \d alapértelmezés szerint csak ASCII számjegyekkel, míg az \w csak ASCII számjegyekkel, betűkkel és aláhúzásokkal egyezik meg.
A (*UCP) módosító (ami a Unicode Character Properties (Unicode karaktertulajdonságok) rövidítése) lehetővé teszi, hogy ezek a tokenek Unicode számjegyekkel és szó karakterekkel is egyezzenek.
Például a (*UCP)\d+ :: \w+ megfelel az 1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ
(Lásd a demót).
A (*UCP) mellett szükség lehet a (*UTF) módosítók egyikének használatára is. Hogy lássuk, hogyan működik ez, tekintsük meg ennek a programnak a kimenetét egy szabványos Xampp PHP-vel:

$string = '1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ';$utfregex = "~\d+ :: \w+~";$utfregex = "~(*UCP)\d+ :: \w+~";$utfregex = "~(*UTF)(*UCP)\d+ :: \w+~";$utfregex = "~(*UTF)\d+ :: \w+~";$utfregex = "~\d+ :: \w+~u";foreach (range(0, 4) as $i) { echo "$i: ".preg_match($utfregex,$string)."<br />"; }// Output:// 0: 0// 1: 0// 2: 1 => (*UTF)(*UCP)// 3: 0// 4: 1 => The u flag produces the same result as (*UTF)(*UCP)

Sorszakadás módosítók
A PCRE fordításakor alapértelmezés szerint megmondjuk neki, hogy mit tekintsen sorszakadásnak, amikor egy . karakterrel találkozik (mivel a pont nem illeszkedik a sorszakadáshoz, kivéve, ha dotall módban van), valamint a ^ és $ horgonyok viselkedését többsoros módban. Ezt az alapértelmezést a következő módosítókkal felülbírálhatja:
✽ (*CR) Csak a kocsivisszatérés számít sortörésnek
✽ (*LF) Csak a sortovábbítás számít sortörésnek (mint Unixon)
✽ (*CRLF) Csak a kocsivisszatérés, amelyet sortovábbítás követ. (mint Windowson)
✽ (*ANYCRLF) A fenti három közül bármelyik sortörésnek minősül
✽ (*ANY) Bármelyik Unicode újsor szekvencia sortörésnek minősül
Például, (*CR)\w+.A \w+ megfelel a Line1\nLine2 sornak, mivel a pont képes megfeleltetni az \n-t, ami nem tekinthető sortörésnek. Lásd a demót.
Az \R szabályozása
Alapértelmezés szerint az \R metajel bármely Unicode újsorozatra illeszkedik. Ha az UTF-8 mód ki van kapcsolva, ezek az újsor szekvenciák az \r\n pár, valamint a carriage return, a line feed, a függőleges tabulátor, a form feed vagy a következő sor karakterek. UTF-8 módban a token a sort elválasztó és a bekezdést elválasztó karakterrel is egyezik.
Két mintakezdés-módosító segítségével megváltoztathatja az \R viselkedését:
✽ A (*BSR_ANYCRLF) használatával az \R csak az \r\n szekvenciával, az \r vagy az \n karakterrel egyezik. Ez a PCRE fordításakor vagy a PCRE_BSR_ANYCRLF opcióval
✽ With (*BSR_UNICODE), \R bármely Unicode újsorozatra illeszkedik (felülbírálva a PCRE_BSR_ANYCRLF opciót, ha az be van állítva). Ez a PCRE fordításakor is beállítható, vagy a PCRE_BSR_UNICODE opcióval kérhető
Futó minták ellenőrzése
A PCRE match() függvény meghívásainak számának korlátozásához használjuk a (*LIMIT_MATCH=x) módosítót, x-et a kívánt számra állítva.
A rekurzió korlátozásához használjuk a (*LIMIT_RECURSION=d) módosítót, d-t a legmélyebb megengedett rekurziós szintre állítva.
Optimalizálás kikapcsolása
(közvetlen hivatkozás)
Alapértelmezés szerint a PCRE tanulmányozza a mintát, és automatikusan atomizál egy kvantált tokent, ha a következő token nem kompatibilis – például az A+X-ből A++X lesz. A (*NO_AUTO_POSSESS) módosító kikapcsolja ezt az optimalizálást. Ezt akkor használja, ha a pcretest segítségével két mintát akar összehasonlítani, és jól érzi magát, hogy az automatikus pozesszifikációval mennyi ciklust takarít meg.
A PCRE alapértelmezés szerint több optimalizálást is végrehajt, hogy gyorsabban kiderüljön, hogy egy egyezés nem fog-e sikertelenül végződni. A (*NO_START_OPT) módosító kikapcsolja ezeket az optimalizálásokat.
Az üres találatok kikapcsolása
A PCRE2-ben a (*NOTEMPTY) azt mondja a motornak, hogy ne adjon vissza üres találatokat. Hasonlóképpen, a (*NOTEMPTY_ATSTART) azt mondja a motornak, hogy ne adja vissza a tárgy elején talált üres találatokat.
Az automatikus lehorgonyzás optimalizálás kikapcsolása
A PCRE2-ben a PCRE2_NO_DOTSTAR_ANCHOR azt mondja a motornak, hogy ne horgonyozza le automatikusan a .*
Erről a jelzőről bővebben a PCRE2 API oldalán olvashat (keresse a PCRE2_NO_DOTSTAR_ANCHOR szót).

A Regex használatának 1001 módja
.