Modyfikatory regex – włączanie ich

To jest strona referencyjna – nie czuj, że musisz ją przeczytać, ponieważ jest raczej zwięzła. Inne sekcje odsyłają do niej w razie potrzeby.
Modyfikatory Regex pojawiają się na każdym kroku na tej stronie. Zamiast wielokrotnie wyjaśniać, co one robią i na ile sposobów można je włączyć w każdym smaku regex, zdecydowałem się zebrać cztery wspólne (i, s, m i x) w jednym miejscu. Ostatnia sekcja krótko omawia inne modyfikatory, które są zwykle specyficzne dla danego języka.
Punkty przeskoku
Dla ułatwienia nawigacji, oto kilka punktów przeskoku do różnych sekcji strony:
✽ Niewrażliwość na wielkość liter: i
✽ DOTALL (Kropka pasuje do przerw w linii): s (z wyjątkiem Ruby i JavaScript)
✽ Wielowierszowy (^ i $ pasują w każdej linii): m (oprócz Ruby)
✽ Free-Spacing: x (oprócz JavaScript)
✽ Other Modifiers
✽ PCRE’s Special Start-of-Pattern Modifiers
(bezpośredni link)

Case Insensitivity: i

Domyślnie, wszystkie główne silniki regex dopasowują w trybie rozróżniania wielkości liter. Jeśli chcesz, aby wzorce takie jak Nazwa: +, aby dopasowywały się w sposób niewrażliwy na wielkość liter, musimy włączyć tę funkcję.
Tak, ale…
Co tak naprawdę oznacza niewrażliwość na wielkość liter?
Dopóki trzymasz się 26 liter alfabetu angielskiego, definicja wielkich i małych liter jest prosta. Kiedy wchodzisz w typograficzne niuanse lub inne języki i skrypty, sprawy nie zawsze są takie proste. Oto kilka pytań, na które możesz się natknąć.
✽ Czy fl (jeden znak, tj. ligatura fl) będzie pasować do FL?
✽ Czy à (jeden znak) będzie pasować do À?
✽ Czy à (dwa znaki, tj. litera a i akcent grobowy) będzie pasować do À? Wszystkie silniki wydają się obsługiwać to poprawnie.
✽ Czy ß będzie pasować do ss? Żaden silnik nie wydaje się to robić.
✽ Czy i będzie pasować do İ (turecka wielka litera i), jak również I?
Te pytania są tylko wierzchołkiem góry lodowej. Nawet gdybym znał wszystkie odpowiedzi, niemożliwe byłoby zawarcie ich wszystkich w tej sekcji: jeśli używasz konkretnego skryptu, będziesz musiał sprawdzić, jak twój konkretny silnik radzi sobie z rozróżnianiem wielkości liter w tym skrypcie.
Więcej niż jeden sposób
W przypadku kilku silników, zauważ, że istnieją dwa sposoby włączania rozróżniania wielkości liter: jako modyfikator inline (?i) lub jako opcja w metodzie lub funkcji regex.
Modyfikator inline (?i)
W .NET, PCRE (C, PHP, R…), Perlu, Pythonie, Javie i Ruby (ale nie JavaScript), możesz użyć modyfikatora inline (?i), na przykład w (?i)cat. Zobacz sekcję o modyfikatorach inline dla soczystych szczegółów o trzech dodatkowych funkcjach (niedostępnych w Pythonie): włączanie go w połowie łańcucha, wyłączanie za pomocą (?-i), lub stosowanie go tylko do zawartości grupy nie przechwytującej za pomocą (?i:foo)

.NET
Oprócz modyfikatora inline (?i), języki .NET mają opcję IgnoreCase. Na przykład w C# można użyć:
var catRegex = new Regex("cat", RegexOptions.IgnoreCase);
Perl
Oprócz modyfikatora (?i) inline, Perl pozwala na dodanie flagi i po delimiterze zamykającym wzorzec. Na przykład, możesz użyć:
if ($the_subject =~ m/cat/i) { … }
PCRE (C, PHP, R…)
Zauważ, że w PCRE, aby użyć dopasowania niewrażliwego na wielkość liter z literami innymi niż angielskie, które nie są częścią twojego locale, będziesz musiał włączyć tryb Unicode – na przykład za pomocą (*UTF8) specjalnego modyfikatora start-of-pattern.
Oprócz (?i), PCRE pozwala ci ustawić tryb PCRE_CASELESS podczas wywoływania funkcji pcre_compile() (lub podobnej):

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

W PHP, opcja PCRE_CASELESS jest przekazywana przez flagę i, którą możesz dodać do swojego łańcucha regex po zamykającym delimiterze. Na przykład, możesz użyć:
$cat_regex = '~cat~i';
W R, opcja PCRE_CASELESS jest przekazywana przez opcję ignore.case=TRUE. Na przykład, można użyć:
grep("cat", subject, perl=TRUE, value=TRUE, ignore.case=TRUE);
Python
Oprócz modyfikatora (?i) inline, Python posiada opcję IGNORECASE. Na przykład, możesz użyć:
cat_regex = re.compile("cat", re.IGNORECASE)
Java
Oprócz modyfikatora (?i) inline, Java ma opcję CASE_INSENSITIVE. Na przykład, możesz użyć:

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

Opcja UNICODE_CASE dodana tutaj zapewnia, że funkcja niewrażliwości na wielkość liter jest świadoma Unicode. Jeśli pracujesz tylko z ASCII, nie musisz jej używać.
JavaScript
W JavaScript, twoją jedyną opcją jest dodanie flagi i po delimiterze zamykającym twojego wzorca. Na przykład, możesz użyć:
var catRegex = /cat/i;
Ruby
Oprócz modyfikatora (?i) inline, Ruby pozwala na dodanie flagi i po delimiterze zamykającym twój wzorzec. Na przykład, możesz użyć:
cat_regex = /cat/i
(link bezpośredni)

DOTALL (Dot dopasowuje znaki łamania linii): s (z wyjątkami)

Domyślnie, kropka . nie dopasowuje znaków łamania linii, takich jak line feeds i carriage returns. Jeśli chcemy, by wzorce takie jak BEGIN .*? END, aby pasowały do wszystkich linii, musimy włączyć tę właściwość.
Tryb ten jest czasami nazywany jednowierszowym (stąd s), ponieważ jeśli chodzi o kropkę, to zamienia ona cały łańcuch w jedną wielką linię -.* będzie pasować od pierwszego znaku do ostatniego, bez względu na to, ile przerw między wierszami się znajduje.
Tryb ten jest również nazywany DOTALL w PCRE, Pythonie i Javie (aby być bardziej precyzyjnym, dokumentacja PCRE używa PCRE_DOTALL). Według mnie, nazwa DOTALL jest sensownym sposobem na nazwanie tego trybu. Trzecia opcja dot-matches-line-breaks jest opisowa, ale trochę usterkowa.

W przypadku kilku silników, zauważ, że istnieją dwa sposoby jej włączenia: jako modyfikator inline lub jako opcja w metodzie lub funkcji regex.
JavaScript
JavaScript nie obsługuje trybu jednoliniowego. Aby dopasować dowolny znak w JavaScript, łącznie z przerwami w linii, należy użyć konstrukcji takiej jak . Ta klasa znaków pasuje do jednego znaku, który jest albo nie-cyfrą albo cyfrą. Dlatego pasuje do dowolnego znaku.
Innym rozwiązaniem JavaScript jest użycie biblioteki XRegExp regex. Jeśli masz nieskończoną ilość czasu, możesz również spróbować przeportować PCRE na JavaScript używając Emscripten, tak jak Firas zdaje się zrobił to w regex 101.
Modyfikator inline (?s)
W .NET, PCRE (C, PHP, R…), Perlu, Pythonie i Javie (ale nie Ruby), możesz użyć modyfikatora inline (?s), na przykład w (?s)BEGIN .*? END. Zobacz sekcję o modyfikatorach inline dla soczystych szczegółów o trzech dodatkowych funkcjach (niedostępnych w Pythonie): włączanie go w połowie łańcucha, wyłączanie za pomocą (?-s), lub stosowanie go tylko do zawartości grupy nie przechwytującej za pomocą (?s:foo)
.NET
Oprócz modyfikatora inline (?s), języki .NET mają opcję Singleline. Na przykład, w C# można użyć:

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

Perl
Oprócz modyfikatora (?s) inline, Perl pozwala na dodanie flagi s po ograniczniku zamykającym wzorzec. Na przykład, możesz użyć:
if ($the_subject =~ m/BEGIN .*? END/s) { … }
PCRE (C, PHP, R…)
Oprócz modyfikatora (?s) inline, PCRE pozwala na ustawienie trybu PCRE_DOTALL podczas wywoływania funkcji pcre_compile() (lub podobnej):

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

W PHP, opcja PCRE_DOTALL jest przekazywana poprzez flagę s, którą możesz dodać do swojego łańcucha regex po delimiterze zamykającym. Na przykład, możesz użyć:
$block_regex = '~BEGIN .*? END~s';
Python
Oprócz modyfikatora (?s) inline, Python posiada opcję DOTALL. Na przykład, można użyć:
block_regex = re.compile("BEGIN .*? END", re.IGNORECASE | re.DOTALL)
Java
Oprócz modyfikatora (?s) inline, Java ma opcję DOTALL. Na przykład, możesz użyć:

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

Ruby: (?m) modyfikator i flaga m
W Ruby możesz użyć modyfikatora inline (?m), na przykład w (?m)BEGIN .*? END. Jest to dziwne dziwactwo Rubiego, ponieważ inne silniki używają (?m) dla trybu „^ i $ match on every line”.
Zobacz sekcję o modyfikatorach inline, aby dowiedzieć się więcej o trzech dodatkowych funkcjach: włączaniu modyfikatora w połowie łańcucha, wyłączaniu go za pomocą (?-m), lub stosowaniu go tylko do zawartości grupy nie przechwytującej za pomocą (?m:foo)

Ruby pozwala także na dodanie flagi m na końcu łańcucha regex. Na przykład, możesz użyć:
block_regex = /BEGIN .*? END/m
(link bezpośredni)
Origins of DOTALL
Tryb jednowierszowy jest również często nazywany DOTALL (co oznacza „dot matches all”) z powodu opcji PCRE_DOTALL w PCRE, opcji re.DOTALL w Pythonie i opcji Pattern.DOTALL w Javie.
Słyszałem kilka razy, że „DOTALL jest rzeczą Pythona”, ale wydawało się, że pochodzi to od ludzi, którzy nie słyszeli o równoważnych opcjach w PCRE i Javie. Mimo to zacząłem się zastanawiać: gdzie DOTALL pojawił się po raz pierwszy? Patrząc na dziennik zmian PCRE i starą dokumentację Pythona, wygląda na to, że pojawił się w PCRE w wersji 0.96 (październik 1997), w Pythonie w wersji 1.5 (luty 1998), a następnie w Javie 1.4 (luty 2002). Luka pomiędzy wprowadzeniem do PCRE i Pythona nie była rozstrzygająca – słowo mogło być w obiegu we wcześniejszych wersjach beta, a nawet w innych narzędziach – dlatego zapytałem o to Philipa Hazela (ojca PCRE). Odpowiedział:

Sądzę, że to ja je wymyśliłem – z pewnością nie widziałem go gdzie indziej, gdy próbowałem wymyślić nazwę dla opcji PCRE, która odpowiadałaby opcji /s Perla. („S” oznacza tam „pojedynczą linię” (…), więc chciałem mieć lepszą nazwę.)

Tak więc jest. Ci którzy lubią trochę historii mogą cieszyć się tym smakowitym samorodkiem.
(bezpośredni link)

Multiline (^ i $ Match on Every Line): m (z wyjątkiem Rubiego)

Domyślnie, we wszystkich głównych silnikach z wyjątkiem Rubiego, kotwice ^ i $ pasują (odpowiednio) tylko na początku i na końcu łańcucha.
W Rubim, pasują na początku i na końcu każdej linii, i nie ma sposobu na wyłączenie tej funkcji. Jest to rozsądny sposób działania, dzięki któremu Ruby częściowo zrehabilitował się za używanie m dla trybu DOTALL, gdy inne silniki używają s.
W innych silnikach, jeśli chcemy aby wzorce takie jak ^Define i >>>$ pasowały (odpowiednio) na początku i na końcu każdej linii, musimy włączyć tę właściwość.
Ta właściwość jest zwykle nazywana multi-line (stąd m), ponieważ kotwice ^ i $ działają na wielu liniach.
W przypadku kilku silników, zauważ, że istnieją dwa sposoby jej włączenia: jako modyfikator inline (?m) lub jako opcja w metodzie lub funkcji regex.
Ruby
W Ruby, kotwice ^ i $ zawsze pasują we wszystkich liniach. Nie ma sposobu na wyłączenie tej opcji. Jest to całkiem fajny sposób, ponieważ, jak w większości smaków, istnieją osobne kotwice dla początku i końca łańcucha: \A, Z i Z.
Z drugiej strony, można żałować, że Ruby zdecydowało się używać flagi m i modyfikatora w niestandardowy sposób (patrz DOTALL).

Modyfikator inline (?m)
W .NET, PCRE (C, PHP, R…), Perlu, Pythonie, Javie i Ruby (ale nie JavaScript), można używać modyfikatora inline (?m), na przykład w (?m)^cat. Zobacz sekcję o modyfikatorach inline dla soczystych szczegółów o trzech dodatkowych funkcjach (niedostępnych w Pythonie): włączanie go w połowie łańcucha, wyłączanie go za pomocą (?-m), lub stosowanie go tylko do zawartości grupy nie przechwytującej za pomocą (?m:foo)
.NET
Oprócz modyfikatora inline (?m), języki .NET mają opcję Multiline. Na przykład, w C# można użyć:

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

Perl
Oprócz modyfikatora (?m) inline, Perl pozwala na dodanie flagi m po ograniczniku zamykającym wzorzec. Na przykład, możesz użyć:
if ($the_subject =~ m/^cat/m) { … }
PCRE (C, PHP, R…)
Oprócz modyfikatora (?m) inline, PCRE pozwala na ustawienie trybu PCRE_MULTILINE podczas wywoływania funkcji pcre_compile() (lub podobnej):

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

W PHP, opcja PCRE_MULTILINE jest przekazywana poprzez flagę m, którą możesz dodać do swojego łańcucha regex po delimiterze zamykającym. Na przykład, możesz użyć:
$cat_regex = '~^cat~m';
Python
Oprócz modyfikatora (?m) inline, Python posiada opcję MULTILINE. Na przykład, można użyć:
cat_regex = re.compile("^cat", re.IGNORECASE | re.MULTILINE)
Java
Oprócz modyfikatora (?m) inline, Java ma opcję MULTILINE. Na przykład, możesz użyć:

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

JavaScript
W JavaScript, twoją jedyną opcją jest dodanie flagi m po delimiterze zamykającym twojego wzorca. Na przykład, możesz użyć:
var catRegex = /^cat/m;
(link bezpośredni)

Free-Spacing: x (oprócz JavaScript)

Domyślnie, każda spacja w łańcuchu regex określa znak, który ma być dopasowany. W językach, w których można pisać łańcuchy regex w wielu liniach, podziały linii również określają dosłowne znaki, które mają być dopasowane. Ponieważ nie można wstawiać spacji, aby oddzielić grupy, które mają różne znaczenia (jak to się robi między frazami i pragramami, gdy piszemy po angielsku), regex może stać się trudny do odczytania, jak na przykład regex Meaning of Life ze strony humorystycznej regex:
^(?=(?!(.))()(?-1)(?<!\d(?<=(?!)\d))).$
Na szczęście, wiele silników obsługuje tryb wolnych spacji, który pozwala na przyspieszenie regexu. Na przykład, możesz dodać spacje pomiędzy tokenami. W PHP, mógłbyś napisać tak – zauważ flagę x po końcowym delimiterze ~:

$word_with_digit_and_cap_regex = '~ ^ (?=\D*\d) \w*\w* $ ~x';
Ale dlaczego pozostawać w jednej linii? Możesz rozłożyć swój regex na tyle linii, ile tylko zechcesz – wciskając tiret i dodając komentarze, które są wprowadzane przez znak #. Na przykład, w C# możesz zrobić coś takiego:

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");

Ten tryb nazywany jest trybem wolnych odstępów. Można go również nazwać trybem białych spacji, trybem komentarzy lub trybem dosłownym.
To może być overkill w prostym regexie, takim jak ten powyżej (chociaż każdy, kto będzie musiał utrzymać twój kod, podziękuje ci za to). Ale jeśli budujesz poważny wzorzec regex, taki jak ten w sztuczce, aby dopasować liczby w czystym angielskim… O ile nie jesteś masochistą, nie masz wyboru.
Zauważ, że wewnątrz klasy znaków, znak spacji i znak # (który w przeciwnym razie wprowadza komentarze) są nadal honorowane – z wyjątkiem Javy, gdzie oba muszą być uciec, jeśli masz na myśli dopasowanie tych znaków.
W kilku silnikach istnieją dwa sposoby włączania trybu wolnych odstępów: jako modyfikator inline lub jako opcja w metodzie lub funkcji regex.
Tryb wolnych odstępów jest wspaniały, ale istnieje kilka drobnych zagrożeń, których powinieneś być świadomy, ponieważ mogą one sprawić, że będziesz drapał się po głowie, zastanawiając się, dlaczego wzorzec nie działa tak, jak tego oczekujesz.
Zagrożenie #1: Znaczenie spacji
Po pierwsze, nie możesz już używać Number: \, aby dopasować ciąg znaków, taki jak Liczba: 24. Powodem jest to, że spacja w : \nie pasuje już do spacji. Jesteśmy w trybie wolnych odstępów, pamiętasz? To jest cały punkt.
Aby dopasować znak spacji, musisz go określić. Dwa główne sposoby, by to zrobić, to umieszczenie jej wewnątrz klasy znaków lub ucieczka przed nią za pomocą odwrotnego ukośnika. Każdy z tych sposobów może zadziałać: Number:\d+ lub Number:\d+
Oczywiście Number:\d+ również by pasowało, ale pamiętaj, że \s pasuje do znacznie więcej niż znak spacji. Na przykład, może dopasować tabulator lub przerwę w linii. To może nie być to, czego chcesz.
Zagrożenie podróży #2: Późny początek
Po drugie, możesz stać się zbyt pewny mocy wolnych odstępów i spróbować czegoś takiego, aby pozwolić regexowi stać na własną rękę:

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

Problem z tym jest taki, że chociaż może to wyglądać tak, jakby modyfikator wolnych odstępów (?x) jest pierwszą rzeczą w twoim regexie, to tak nie jest.
Po otwierającym podwójnym cudzysłowie „, mamy przerwę w linii i kilka spacji. Silnik stara się je dopasować, ponieważ na tym etapie nie jesteśmy jeszcze w trybie swobodnych odstępów. Tryb ten jest włączany dopiero gdy napotkamy (?x). Ten regex nigdy nie będzie pasował do łańcucha etc i więcej, ponieważ do czasu napotkania początku łańcucha kotwicy ^, mamy już dopasować przerwę w linii i znaki spacji!
To dlatego, jeśli spojrzysz na pierwszy przykład, zobaczysz, że modyfikator wolnych odstępów (?x) jest pierwszą rzeczą po otwierającym znaku cudzysłowu.
Whitespace nie jest po prostu usuwany z wzorca
Nawet jeśli whitespace jest ignorowany, pozycja whitespace wciąż oddziela poprzedni token od następnego. Na przykład,
✽ (A)\1 2 nie jest tym samym co (A)\12. Pierwszy pasuje do AA2, drugi do A w .NET, PCRE, Perlu i Ruby (12 jest kodem ósemkowym dla znaku końca linii)
✽ \Np{Nd} jest poprawne, ale \N d} nie jest – z wyjątkiem Perla i Ruby
JavaScript
JavaScript nie obsługuje trybu wolnych odstępów. W JavaScript, aby dopasować dowolny znak, włączając w to łamanie linii, użyj konstrukcji takiej jak . Ta klasa znaków pasuje do jednego znaku, który jest albo nie-cyfrą albo cyfrą. Dlatego pasuje do dowolnego znaku.
Innym rozwiązaniem w JavaScript jest użycie biblioteki XRegExp regex. Jeśli masz nieskończoną ilość czasu, możesz również spróbować przeportować PCRE na JavaScript używając Emscripten, jak Firas zdaje się zrobił na regex 101.
Inline Modifier (?s)
W .NET, PCRE (C, PHP, R…), Perl, Python, Java i Ruby (ale nie JavaScript), możesz użyć modyfikatora inline (?x), na przykład, jest to napowietrzony regex do dopasowania powtarzających się słów:
(?x) (\w+) + \bZobacz też sekcję o modyfikatorach inline.
.NET
Oprócz modyfikatora inline (?x), języki .NET mają opcję IgnorePatternWhitespace. Na przykład, w C# można użyć:

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

Perl
Oprócz modyfikatora (?x) inline, Perl pozwala na dodanie flagi x po ograniczniku zamykającym wzorzec. Na przykład, możesz użyć:
if ($the_subject =~ m/(\w+) + \b/x) { … }
PCRE (C, PHP, R…)
Oprócz modyfikatora (?x) inline, PCRE pozwala ustawić tryb PCRE_EXTENDED podczas wywoływania funkcji pcre_compile() (lub podobnej):

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

W PHP, opcja PCRE_EXTENDED jest przekazywana poprzez flagę x, którą możesz dodać w swoim łańcuchu regex po delimiterze zamykającym. Na przykład, możesz użyć:
$repeated_word_regex = '~(\w+) + \b~x';
Python
Oprócz modyfikatora (?x) inline, Python posiada opcję VERBOSE. Na przykład, możesz użyć:
repeated_word_regex = re.compile(r"(\w+) + \b", re.VERBOSE)
Java
W przeciwieństwie do innych silników, wewnątrz klasy znaków Java hashe wprowadzają komentarze i spacje, które są ignorowane, więc musisz je uciec, jeśli chcesz użyć tych znaków w klasie, np. Na przykład, możesz użyć:

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

Ruby
Oprócz modyfikatora (?x) inline, Ruby pozwala na dodanie flagi x na końcu ciągu regex. Na przykład, możesz użyć:
repeated_word_regex = /(\w+) + \b/x
(link bezpośredni)

Inne modyfikatory

Niektóre silniki obsługują modyfikatory i flagi oprócz i, s, m oraz x. Planuję omówić je na stronach poświęconych tym smakom.
Na przykład,
✽ .NET posiada modyfikator (?n) (dostępny również poprzez opcję ExplicitCapture). Zmienia to wszystkie (nawiasy) w grupy nie przechwytujące. Aby przechwycić, musisz użyć nazwanych grup.
✽ Java ma modyfikator (?d) (dostępny także przez opcję UNIX_LINES). Gdy jest on włączony, znak podawania linii jest jedynym, który wpływa na kropkę . (która nie pasuje do podziałów wiersza, chyba że DOTALL jest włączony) i kotwice ^ i $ (które pasują do początków i końców wierszy w trybie wielowierszowym.)
✽ Perl ma kilka innych flag. Zobacz sekcję modyfikatorów w dokumentacji.
✽ PCRE ma modyfikator (?J) (dostępny także w kodzie przez opcję PCRE_DUPNAMES). Gdy jest ustawiony, różne grupy przechwytywania mogą używać tej samej nazwy – choć będą im przypisane różne numery.
(link bezpośredni)
✽ PCRE ma modyfikator (?U) (dostępny także w kodzie przez opcję PCRE_UNGREEDY). Gdy jest ustawiony, kwantyfikatory są domyślnie niezachłanne. Dodanie ? czyni je zachłannymi.
(link bezpośredni)
✽ PCRE posiada modyfikator (?X) (dostępny również w kodzie poprzez opcję PCRE_EXTRA). Historycznie, tryb ten był używany do włączania nowych funkcji w rozwoju. Obecnie wyzwala on błędy, jeśli tokeny takie jak \B są używane w klasie znaków (gdzie normalnie pasuje do dużej litery B, w przeciwieństwie do poza klasą znaków, gdzie jest to zapewnienie not-a-word-boundary).
✽ PCRE ma wiele specjalnych modyfikatorów, które można ustawić na początku wzorca (są one pokazane poniżej). Dodatkowo, wiele opcji może być wysłanych do rodziny funkcji pcre_compile(), jeśli masz do nich dostęp. Aby uzyskać szczegóły na ich temat, pobierz pcre_compile.html z folderu doc, ściągając PCRE.

(bezpośredni link)

Specjalne modyfikatory początku wzorca w PCRE

PCRE posiada pewną liczbę „specjalnych modyfikatorów”, które możesz ustawić na początku wzorca. Zamiast standardowej składni (?z) dla modyfikatorów inline, składnia modyfikatorów specjalnych wygląda jak (*MYMODIFIER). Modyfikatory te są szczególnie użyteczne w kontekstach, gdzie PCRE jest zintegrowane z narzędziem lub językiem – ponieważ zastępują one wiele opcji, które można by wysłać do pcre_compile().
Łańcuchy UTF
Zakładając, że PCRE jest skompilowane z odpowiednimi opcjami, możesz poinstruować silnik, aby traktował łańcuch tematu jako różnego rodzaju łańcuchy UTF.
✽ (*UTF) jest ogólnym sposobem traktowania tematu jako łańcucha UTF – wykrywa czy powinien on być traktowany jako UTF-8, UTF-16 czy UTF-32.
✽ (*UTF8), (*UTF16) i (*UTF32) traktują łańcuch jako jedno z trzech określonych kodowań UTF.
Właściwości Unicode dla \d i \w
Domyślnie, \d dopasowuje tylko cyfry ASCII, podczas gdy \w dopasowuje tylko cyfry ASCII, litery i podkreślenia.
Modyfikator (*UCP) (który jest skrótem od Unicode Character Properties) pozwala tym tokenom dopasowywać cyfry i znaki słowne Unicode.
Na przykład, (*UCP)\d+ :: \w+ pasuje do 1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ
(Zobacz demo).
W połączeniu z (*UCP), może być również konieczne użycie jednego z modyfikatorów (*UTF). Aby zobaczyć jak to działa, rozważ wyjście tego programu ze standardowym Xampp PHP:

$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)

Modyfikatory przerwania linii
Domyślnie, gdy PCRE jest kompilowane, mówisz mu co ma uważać za przerwanie linii przy napotkaniu . (jako kropka nie pasuje do przerwania linii, chyba że w trybie dotall), jak również zachowanie kotwic ^ i $ w trybie wielowierszowym. Można zastąpić to domyślne zachowanie następującymi modyfikatorami:
✽ (*CR) Tylko powrót karetki jest uważany za przerwanie wiersza
✽ (*LF) Tylko podawanie wiersza jest uważane za przerwanie wiersza (jak w Uniksie)
✽ (*CRLF) Tylko powrót karetki, po którym następuje podawanie wiersza, jest (*ANYCRLF) Każda z powyższych trzech jest uważana za przerwę w linii
✽ (*ANY) Każda sekwencja nowej linii Unicode jest uważana za przerwę w linii
Na przykład, (*CR)\w+.\W+ pasuje do Line1Line2, ponieważ kropka jest w stanie dopasować się do n, który nie jest uważany za przerwę w linii. Zobacz demo.
Kontrolowanie R
Domyślnie, metaznak R pasuje do każdej sekwencji nowej linii Unicode. Gdy tryb UTF-8 jest wyłączony, takimi sekwencjami nowych linii jest para ∗, jak również znaki powrotu karetki, podawania wiersza, tabulacji pionowej, podawania kształtu lub następnego wiersza. W trybie UTF-8, token pasuje również do separatora linii i separatora akapitu.
Dwa modyfikatory początku wzorca pozwalają zmienić zachowanie R:
✽ Z (*BSR_ANYCRLF), R pasuje tylko do sekwencji \r\n, \r lub \n. Może to być także ustawione, gdy PCRE jest kompilowane lub żądane przez opcję PCRE_BSR_ANYCRLF
✽ Z (*BSR_UNICODE), \R pasuje do dowolnej sekwencji nowej linii Unicode (nadpisując opcję PCRE_BSR_ANYCRLF, jeśli jest ustawiona). Może to być również ustawione podczas kompilacji PCRE lub wymagane przez opcję PCRE_BSR_UNICODE
Kontrola uciekających wzorców
Aby ograniczyć liczbę wywołań funkcji match() przez PCRE, użyj modyfikatora (*LIMIT_MATCH=x), ustawiając x na żądaną liczbę.
Aby ograniczyć rekurencję, użyj (*LIMIT_RECURSION=d), ustawiając d na najgłębszy dozwolony poziom rekurencji.
Wyłączanie optymalizacji
(link bezpośredni)
Domyślnie, PCRE bada wzorzec i automatycznie czyni kwantyfikowany token atomowym, gdy następujący po nim token jest niekompatybilny – na przykład zamieniając A+X na A++X. Modyfikator (*NO_AUTO_POSSESS) wyłącza tę optymalizację. Użyj tego, gdy chcesz użyć pcretest do porównania dwóch wzorców i poczuć się dobrze z powodu wszystkich cykli, które oszczędza ci auto-possessification.
Domyślnie, PCRE wykonuje kilka optymalizacji, aby szybciej dowiedzieć się, czy dopasowanie się nie powiedzie. Modyfikator (*NO_START_OPT) wyłącza te optymalizacje.
Dezaktywacja pustych dopasowań
W PCRE2, (*NOTEMPTY) mówi silnikowi by nie zwracał pustych dopasowań. Podobnie, (*NOTEMPTY_ATSTART) mówi silnikowi, aby nie zwracał pustych dopasowań znalezionych na początku tematu.
Wyłączenie optymalizacji automatycznego zakotwiczenia
W PCRE2, PCRE2_NO_DOTSTAR_ANCHOR mówi silnikowi, aby nie zakotwiczał automatycznie wzorców zaczynających się od .*
Więcej o tej fladze można przeczytać na stronie PCRE2 API (szukaj PCRE2_NO_DOTSTAR_ANCHOR).

Sześćset jeden sposobów użycia Regex
.