Regex Modifiers-Turning them On

Questa è una pagina di riferimento – non sentitevi obbligati a leggerla perché è piuttosto concisa. Altre sezioni sono collegate ad essa quando necessario.
I modificatori Regex compaiono in ogni angolo di questo sito. Piuttosto che spiegare ripetutamente cosa fanno e i molteplici modi di attivarli in ogni tipo di regex, ho deciso di raccogliere i quattro comuni (i, s, m e x) in un unico posto. La sezione finale esamina brevemente altri modificatori, che di solito sono specifici della lingua.
Punti di salto
Per una facile navigazione, ecco alcuni punti di salto alle varie sezioni della pagina:
✽ Insensibilità ai casi: i
✽ DOTALL (Dot Matches Line Breaks): s (eccetto Ruby e JavaScript)
✽ Multilinea (^ e $ corrispondono ad ogni riga): m (eccetto Ruby)
✽ Spaziatura libera: x (eccetto JavaScript)
✽ Altri modificatori
✽ PCRE’s Special Start-of-Pattern Modifiers
(link diretto)

Case Insensitivity: i

Di default, tutti i principali motori regex corrispondono in modalità case-sensitive. Se vuoi che schemi come Name: + corrispondano in modo case-insensitive, dobbiamo attivare questa funzione.
Sì, ma…
Cosa significa veramente case-insensitive?
Finché ci si attiene alle 26 lettere dell’alfabeto inglese, la definizione di maiuscole e minuscole è semplice. Quando ci si addentra in sottigliezze tipografiche o in altre lingue e scritture, le cose non sono sempre così semplici. Ecco alcune domande in cui potresti incorrere.
✽ fl (un carattere, cioè la legatura fl) corrisponderà a FL?
✽ à (un carattere) corrisponderà a À?
✽ à (due caratteri, cioè la lettera a e l’accento grave) corrisponderà a À? Tutti i motori sembrano gestirlo correttamente.
✽ La ß corrisponde a ss? Nessun motore sembra farlo.
✽ La i corrisponde a İ (la i maiuscola turca) così come la I?
Queste domande sono solo la punta dell’iceberg. Anche se conoscessi tutte le risposte, sarebbe impossibile includerle tutte in questa sezione: se usate un particolare script, dovrete cercare come il vostro specifico motore gestisce la corrispondenza maiuscola-indifferente in quello script.
Più di un modo
Per diversi motori, notate che ci sono due modi di attivare la corrispondenza maiuscola-indifferente: come un modificatore in linea (?i) o come opzione nel metodo o nella funzione regex.
Modificatore in linea (?i)
In .NET, PCRE (C, PHP, R…), Perl, Python, Java e Ruby (ma non JavaScript), potete usare il modificatore in linea (?i), per esempio in (?i)cat. Vedi la sezione sui modificatori in linea per i dettagli succosi su tre caratteristiche aggiuntive (non disponibili in Python): attivarlo in mezzo alla stringa, disattivarlo con (?-i), o applicarlo solo al contenuto di un gruppo non catturabile con (?i:foo)

.NET
Oltre al modificatore in linea (?i), i linguaggi .NET hanno l’opzione IgnoreCase. Per esempio, in C# potete usare:
var catRegex = new Regex("cat", RegexOptions.IgnoreCase);
Perl
A parte il modificatore (?i) in linea, Perl vi permette di aggiungere il flag i dopo il delimitatore di chiusura del vostro modello. Per esempio, potete usare:
if ($the_subject =~ m/cat/i) { … }
PCRE (C, PHP, R…)
Nota che in PCRE, per usare la corrispondenza case-insensitive con lettere non inglesi che non fanno parte del tuo locale, dovrai attivare la modalità Unicode-per esempio con il modificatore speciale di inizio pattern (*UTF8).
Oltre al modificatore (?i), PCRE permette di impostare la modalità PCRE_CASELESS quando si chiama la funzione pcre_compile() (o simile):

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

In PHP, l’opzione PCRE_CASELESS viene passata attraverso il flag i, che potete aggiungere nella vostra stringa regex dopo il delimitatore di chiusura. Per esempio, puoi usare:
$cat_regex = '~cat~i';
In R, l’opzione PCRE_CASELESS viene passata tramite l’opzione ignore.case=TRUE. Per esempio, potete usare:
grep("cat", subject, perl=TRUE, value=TRUE, ignore.case=TRUE);
Python
Oltre al modificatore (?i) in linea, Python ha l’opzione IGNORECASE. Per esempio, puoi usare:
cat_regex = re.compile("cat", re.IGNORECASE)
Java
Oltre al modificatore in linea (?i), Java ha l’opzione CASE_INSENSITIVE. Per esempio, puoi usare:

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

L’opzione UNICODE_CASE aggiunta qui assicura che la funzione case-insensitivity sia consapevole di Unicode. Se state lavorando solo con ASCII, non dovete usarla.
JavaScript
In JavaScript, la vostra unica opzione è aggiungere il flag i dopo il delimitatore di chiusura del vostro pattern. Per esempio, puoi usare:
var catRegex = /cat/i;
Ruby
A parte il modificatore (?i) in linea, Ruby ti permette di aggiungere il flag i dopo il delimitatore di chiusura del tuo pattern. Per esempio, potete usare:
cat_regex = /cat/i
(link diretto)

DOTALL (Dot Matches Line Breaks): s (con eccezioni)

Per impostazione predefinita, il punto . non corrisponde ai caratteri di interruzione di riga come i feed di riga e i ritorni a capo. Se volete che schemi come BEGIN .*? END corrispondano attraverso le linee, dobbiamo attivare questa funzione.
Questa modalità è talvolta chiamata a linea singola (da cui la s) perché per quanto riguarda il punto, trasforma l’intera stringa in una grande linea-.* corrisponderà dal primo all’ultimo carattere, non importa quante interruzioni di linea ci siano in mezzo.

La modalità è anche chiamata DOTALL in PCRE, Python e Java (per essere più precisi, la documentazione PCRE usa PCRE_DOTALL). Per me, il nome DOTALL è un modo sensato di chiamare questa modalità. La terza opzione dot-matches-line-breaks è descrittiva, ma è un po’ un boccone.
Per diversi motori, si noti che ci sono due modi per attivarla: come modificatore in linea o come opzione nel metodo o nella funzione regex.
JavaScript
JavaScript non supporta la modalità a linea singola. Per far corrispondere qualsiasi carattere in JavaScript, incluse le interruzioni di riga, usate un costrutto come . Questa classe di caratteri corrisponde a un carattere che è o una non cifra \D o una cifra \d. Quindi corrisponde a qualsiasi carattere.
Un’altra soluzione JavaScript è usare la libreria regex XRegExp. Se avete tempo infinito a disposizione, potete anche provare a portare PCRE in JavaScript usando Emscripten, come sembra aver fatto Firas su regex 101.
Modificatore in linea (?s)
In .NET, PCRE (C, PHP, R…), Perl, Python e Java (ma non Ruby), potete usare il modificatore in linea (?s), per esempio in (?s)BEGIN .*? END. Vedere la sezione sui modificatori in linea per i dettagli succosi su tre caratteristiche aggiuntive (non disponibili in Python): attivarlo in mezzo alla stringa, disattivarlo con (?-s), o applicarlo solo al contenuto di un gruppo non catturabile con (?s:foo)
.NET
Oltre al modificatore in linea (?s), i linguaggi .NET hanno l’opzione Singleline. Per esempio, in C# potete usare:

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

Perl
A parte il modificatore (?s) in linea, Perl vi permette di aggiungere il flag s dopo il delimitatore di chiusura del vostro schema. Per esempio, potete usare:
if ($the_subject =~ m/BEGIN .*? END/s) { … }
PCRE (C, PHP, R…)
Oltre al modificatore (?s) in linea, PCRE vi permette di impostare la modalità PCRE_DOTALL quando chiamate la funzione pcre_compile() (o simile):

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

In PHP, l’opzione PCRE_DOTALL viene passata tramite il flag s, che potete aggiungere nella vostra stringa regex dopo il delimitatore di chiusura. Per esempio, puoi usare:
$block_regex = '~BEGIN .*? END~s';
Python
Oltre al modificatore (?s) in linea, Python ha l’opzione DOTALL. Per esempio, potete usare:
block_regex = re.compile("BEGIN .*? END", re.IGNORECASE | re.DOTALL)
Java
A parte il modificatore in linea (?s), Java ha l’opzione DOTALL. Per esempio, potete usare:

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

Ruby: Modificatore (?m) e bandiera m
In Ruby, potete usare il modificatore in linea (?m), per esempio in (?m)BEGIN .*? END. Questa è una strana stranezza di Ruby, dato che altri motori usano (?m) per la modalità “^ e $ corrispondono su ogni linea”.
Vedi la sezione sui modificatori in linea per i succosi dettagli su tre caratteristiche aggiuntive: attivarlo a metà della stringa, disattivarlo con (?-m), o applicarlo solo al contenuto di un gruppo non catturabile con (?m:foo)
Ruby ti permette anche di aggiungere il flag m alla fine della tua stringa regex. Per esempio, puoi usare:
block_regex = /BEGIN .*? END/m
(link diretto)
Origini di DOTALL
La modalità a linea singola è anche spesso chiamata DOTALL (che sta per “dot matches all”) a causa dell’opzione PCRE_DOTALL in PCRE, l’opzione re.DOTALL in Python e l’opzione Pattern.DOTALL in Java.
Ho sentito dire diverse volte che “DOTALL è una cosa di Python”, ma questo sembrava provenire da persone che non avevano sentito parlare delle opzioni equivalenti in PCRE e Java. Eppure questo mi ha fatto chiedere: dove è apparso DOTALL per la prima volta? Guardando il PCRE Change Log e la vecchia documentazione di Python, sembra che sia apparso in PCRE con la versione 0.96 (ottobre 1997), in Python con la versione 1.5 (febbraio 1998), poi in Java 1.4 (febbraio 2002). Il divario tra le introduzioni di PCRE e Python non era conclusivo – la parola potrebbe essere stata in circolazione in versioni beta precedenti, o anche in altri strumenti – così ho chiesto a Philip Hazel (il padre di PCRE) su di esso. Rispose:

Credo di averla inventata io – certamente non l’avevo vista altrove quando stavo cercando di pensare ad un nome per l’opzione PCRE che corrispondesse all’opzione /s di Perl. (“S” lì sta per “single-line” (…) quindi volevo un nome migliore.)

Così. Quelli a cui piace un po’ di storia potrebbero godersi questa gustosa pepita.
(link diretto)

Multilinea (^ e $ corrispondono ad ogni riga): m (eccetto Ruby)

Per default, in tutti i principali motori eccetto Ruby, le ancore ^ e $ corrispondono (rispettivamente) solo all’inizio e alla fine della stringa.
In Ruby, corrispondono all’inizio e alla fine di ogni riga, e non c’è modo di disattivare questa caratteristica. Questo è in realtà un modo ragionevole di fare le cose, con cui Ruby si riscatta parzialmente per aver usato m per la modalità DOTALL quando altri motori usano s.
In altri motori, se si vuole che pattern come ^Define e >>>$ corrispondano (rispettivamente) all’inizio e alla fine di ogni riga, dobbiamo attivare questa caratteristica.

Questa caratteristica è solitamente chiamata multilinea (da cui la m) perché le ancore ^ e $ operano su più righe.
Per diversi motori, si noti che ci sono due modi per attivarla: come modificatore in linea (?m) o come opzione nel metodo o nella funzione regex.
Ruby
In Ruby, le ancore ^ e $ corrispondono sempre a tutte le righe. Non c’è modo di disattivare questa opzione. Questo è in realtà un bel modo di fare le cose, dato che, come nella maggior parte dei gusti, ci sono ancore separate per l’inizio e la fine delle stringhe: \A, \Z e \z.
D’altra parte, si può rimpiangere la scelta di Ruby di usare il flag m e il modificatore in modo non standard (vedi DOTALL).
Modificatore in linea (?m)
In .NET, PCRE (C, PHP, R…), Perl, Python, Java e Ruby (ma non JavaScript), è possibile usare il modificatore in linea (?m), per esempio in (?m)^cat. Vedi la sezione sui modificatori in linea per i dettagli succosi su tre caratteristiche aggiuntive (non disponibili in Python): attivarlo in mezzo alla stringa, disattivarlo con (?-m), o applicarlo solo al contenuto di un gruppo non catturabile con (?m:foo)
.NET
Oltre al modificatore in linea (?m), i linguaggi .NET hanno l’opzione Multilinea. Per esempio, in C# potete usare:

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

Perl
A parte il modificatore (?m) in linea, Perl vi permette di aggiungere il flag m dopo il delimitatore di chiusura del vostro schema. Per esempio, potete usare:
if ($the_subject =~ m/^cat/m) { … }
PCRE (C, PHP, R…)
Oltre al modificatore (?m) in linea, PCRE vi permette di impostare la modalità PCRE_MULTILINE quando chiamate la funzione pcre_compile() (o simile):

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

In PHP, l’opzione PCRE_MULTILINE viene passata tramite il flag m, che potete aggiungere nella vostra stringa regex dopo il delimitatore di chiusura. Per esempio, puoi usare:
$cat_regex = '~^cat~m';
Python
Oltre al modificatore (?m) in linea, Python ha l’opzione MULTILINE. Per esempio, puoi usare:
cat_regex = re.compile("^cat", re.IGNORECASE | re.MULTILINE)
Java
Oltre al modificatore (?m) in linea, Java ha l’opzione MULTILINE. Per esempio, puoi usare:

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

JavaScript
In JavaScript, la tua unica opzione è aggiungere il flag m dopo il delimitatore di chiusura del tuo schema. Per esempio, puoi usare:
var catRegex = /^cat/m;
(link diretto)

Spaziatura libera: x (eccetto JavaScript)

Di default, ogni spazio in una stringa regex specifica un carattere da abbinare. Nei linguaggi in cui è possibile scrivere stringhe regex su più righe, le interruzioni di riga specificano anche i caratteri letterali da abbinare. Poiché non è possibile inserire spazi per separare gruppi che portano significati diversi (come si fa tra frasi e paragrafi quando si scrive in inglese), una regex può diventare difficile da leggere, come per esempio la regex Meaning of Life dalla pagina regex humor:
^(?=(?!(.))()(?-1)(?<!\d(?<=(?!)\d))).$
Per fortuna, molti motori supportano una modalità di spaziatura libera che permette di aerare la regex. Per esempio, puoi aggiungere spazi tra i token. In PHP, potresti scrivere questo – nota il flag x dopo il delimitatore finale ~:
$word_with_digit_and_cap_regex = '~ ^ (?=\D*\d) \w*\w* $ ~x';
Ma perché rimanere su una sola linea? Puoi distribuire la tua regex su tutte le linee che vuoi, con l’aggiunta di commenti, che sono introdotti da un #. Per esempio, in C# potete fare qualcosa del genere:

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

Questa modalità è chiamata modalità free-spacing. Potete anche vederla chiamata modalità spazio bianco, modalità commento o modalità verbosa.
Può essere eccessivo in una semplice regex come quella sopra (anche se chiunque debba mantenere il vostro codice vi ringrazierà per questo). Ma se state costruendo un modello regex serio come quello nel trucco per far corrispondere i numeri in inglese semplice… A meno che non siate masochisti, non avete scelta.
Nota che all’interno di una classe di caratteri, il carattere spazio e il # (che altrimenti introduce commenti) sono ancora onorati – tranne che in Java, dove entrambi devono essere evasi se intendete far corrispondere questi caratteri.
Per diversi motori, ci sono due modi per attivare la modalità free-spacing: come modificatore in linea o come opzione nel metodo o nella funzione regex.
La modalità free-spacing è meravigliosa, ma ci sono un paio di pericoli minori di cui dovreste essere consapevoli, poiché potrebbero lasciarvi a grattare la testa chiedendovi perché un pattern non funziona come vi aspettavate.
Trip Hazard #1: Il significato dello spazio

Primo, non puoi più usare Number: \d+ per abbinare una stringa come Number: 24. La ragione è che lo spazio in : \d non corrisponde più a uno spazio. Siamo in modalità spazio libero, ricordate? È proprio questo il punto.
Per abbinare un carattere di spazio, dovete specificarlo. I due modi principali per farlo sono di metterlo all’interno di una classe di caratteri o di sfuggirgli con un backslash. Entrambi funzionano: Number:\d+ o Number:\ \d+
Naturalmente anche Number:\s\d+ corrisponderebbe, ma ricorda che \s corrisponde a molto più di uno spazio. Per esempio, potrebbe corrispondere a un tab o a un’interruzione di riga. Questo potrebbe non essere quello che vuoi.
Trip Hazard #2: Late Start
In secondo luogo, potresti essere troppo sicuro del potere della spaziatura libera e provare qualcosa come questo per lasciare che la regex stia in piedi da sola:

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

Il problema con questo è che anche se può sembrare che il modificatore di spaziatura libera (?x) sia la prima cosa nella tua regex, non lo è.
Dopo il doppio apice di apertura “, abbiamo un’interruzione di riga e un certo numero di spazi. Il motore cerca di farli corrispondere, perché in quella fase non siamo ancora in modalità free-spacing. Quella modalità si attiva solo quando incontriamo (?x). Questa regex non corrisponderà mai alla stringa etc e oltre, perché nel momento in cui incontriamo l’inizio dell’ancora di stringa ^, si suppone che abbiamo già abbinato un’interruzione di riga e caratteri di spazio!
Questo è il motivo per cui se guardate il primo esempio, vedrete che il modificatore di spaziatura libera (?x) è la prima cosa dopo il carattere di apertura delle virgolette.
Lo spazio bianco non viene semplicemente tagliato fuori dal modello
Anche se lo spazio bianco viene ignorato, la posizione di uno spazio bianco separa ancora il token precedente da quello successivo. Per esempio,
✽ (A)\1 2 non è lo stesso di (A)\12. Il primo corrisponde a AA2, il secondo corrisponde a A\n in .NET, PCRE, Perl e Ruby (12 è il codice ottale per il carattere linefeed)
✽ \p{Nd} è valido, ma \p{N d} non lo è – tranne che in Perl e Ruby
JavaScript
JavaScript non supporta la modalità free-spacing. In JavaScript, per far corrispondere qualsiasi carattere, incluse le interruzioni di riga, usate un costrutto come . Questa classe di caratteri corrisponde a un carattere che è o una non cifra \D o una cifra \d. Quindi corrisponde a qualsiasi carattere.

Un’altra soluzione JavaScript è usare la libreria regex XRegExp. Se avete tempo infinito a disposizione, potete anche provare a portare PCRE in JavaScript usando Emscripten, come sembra aver fatto Firas su regex 101.
Modificatore in linea (?s)
In .NET, PCRE (C, PHP, R…), Perl, Python, Java e Ruby (ma non JavaScript), potete usare il modificatore in linea (?x), per esempio, questa è una regex aerata per abbinare parole ripetute:
(?x) (\w+) + \bVedi anche la sezione sui modificatori in linea.
.NET
Oltre al modificatore in linea (?x), i linguaggi .NET hanno l’opzione IgnorePatternWhitespace. Per esempio, in C# potete usare:

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

Perl
A parte il modificatore (?x) in linea, Perl vi permette di aggiungere il flag x dopo il delimitatore di chiusura del vostro modello. Per esempio, potete usare:
if ($the_subject =~ m/(\w+) + \b/x) { … }
PCRE (C, PHP, R…)
Oltre al modificatore (?x) in linea, PCRE vi permette di impostare la modalità PCRE_EXTENDED quando chiamate la funzione pcre_compile() (o simile):

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

In PHP, l’opzione PCRE_EXTENDED viene passata tramite il flag x, che potete aggiungere nella vostra stringa regex dopo il delimitatore di chiusura. Per esempio, puoi usare:
$repeated_word_regex = '~(\w+) + \b~x';
Python
Oltre al modificatore (?x) in linea, Python ha l’opzione VERBOSE. Per esempio, potete usare:
repeated_word_regex = re.compile(r"(\w+) + \b", re.VERBOSE)
Java
A differenza di altri motori, all’interno di una classe di caratteri Java gli hashish introducono commenti e spazi e vengono ignorati, quindi dovete fare l’escape se volete usare questi caratteri in una classe, per esempio +
A parte il modificatore (?x) in linea, Java ha l’opzione COMMENTS. Per esempio, puoi usare:

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

Ruby
Oltre al modificatore (?x) in linea, Ruby ti permette di aggiungere il flag x alla fine della tua stringa regex. Per esempio, potete usare:
repeated_word_regex = /(\w+) + \b/x
(link diretto)

Altri modificatori

Alcuni motori supportano modificatori e flag oltre a i, s, m e x. Ho intenzione di coprirli nelle pagine dedicate a questi sapori.
Per esempio,
✽ .NET ha il modificatore (?n) (accessibile anche tramite l’opzione ExplicitCapture). Questo trasforma tutti i gruppi (parentesi) in gruppi non catturabili. Per catturare, dovete usare gruppi con nome.

✽ Java ha il modificatore (?d) (accessibile anche tramite l’opzione UNIX_LINES). Quando questo è attivo, il carattere di avanzamento di riga \n è l’unico che influenza il punto . (che non corrisponde alle interruzioni di riga a meno che DOTALL sia attivo) e le ancore ^ e $ (che corrispondono all’inizio e alla fine della riga in modalità multilinea.)
✽ Perl ha molti altri flag. Vedere la sezione della documentazione sui modificatori.
✽ PCRE ha il modificatore (?J) (disponibile anche nel codice tramite l’opzione PCRE_DUPNAMES). Quando è impostato, diversi gruppi di cattura possono usare lo stesso nome, anche se saranno assegnati numeri diversi.
(link diretto)
✽ PCRE ha il modificatore (?U) (disponibile anche nel codice tramite l’opzione PCRE_UNGREEDY). Quando è impostato, i quantificatori sono non avidi per default. L’aggiunta di un ? li rende avidi.
(link diretto)
✽ PCRE ha il modificatore (?X) (disponibile anche nel codice tramite l’opzione PCRE_EXTRA). Storicamente, questa modalità è stata usata per abilitare nuove funzionalità nello sviluppo. Al momento, innesca errori se token come \B sono usati in una classe di caratteri (dove normalmente corrisponde alla lettera B maiuscola, a differenza dell’esterno di una classe di caratteri, dove è un’asserzione che non confina con una parola).
✽ PCRE ha una serie di modificatori speciali che possono essere impostati all’inizio del pattern (questi sono mostrati sotto). Inoltre, molte opzioni possono essere inviate alla famiglia di funzioni pcre_compile(), se si ha accesso ad esse. Per i dettagli su queste, prendi pcre_compile.html dalla cartella doc scaricando PCRE.
(link diretto)

PCRE’s Special Start-of-Pattern Modifiers

PCRE ha un certo numero di “special modifiers” che puoi impostare all’inizio di un pattern. Invece della sintassi standard (?z) per i modificatori in linea, la sintassi del modificatore speciale è simile a (*MYMODIFIER). Questi modificatori sono particolarmente utili in contesti in cui PCRE è integrato all’interno di uno strumento o di un linguaggio, poiché sostituiscono un certo numero di opzioni che inviereste a pcre_compile().
Stringhe UTF
Assumendo che PCRE sia compilato con le relative opzioni, potete istruire il motore a trattare la stringa oggetto come vari tipi di stringhe UTF.
✽ (*UTF) è un modo generico per trattare l’oggetto come una stringa UTF – rilevando se deve essere trattato come UTF-8, UTF-16 o UTF-32.
✽ (*UTF8), (*UTF16) e (*UTF32) trattano la stringa come una delle tre codifiche UTF specifiche.

Proprietà Unicode per \d e \w
Di default, \d corrisponde solo a cifre ASCII, mentre \w corrisponde solo a cifre ASCII, lettere e underscore.
Il modificatore (*UCP) (che sta per Unicode Character Properties) permette a questi token di abbinare cifre e caratteri di parola Unicode.
Per esempio, (*UCP)\d+ :: \w+ corrisponde a 1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ
(Vedi demo).
In combinazione con (*UCP), potrebbe anche essere necessario usare uno dei modificatori (*UTF). Per vedere come funziona, considera l’output di questo programma con un Xampp PHP standard:

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

Modificatori di interruzione di linea
Di default, quando PCRE viene compilato, gli dici cosa considerare come un’interruzione di linea quando incontra un . (come il punto non corrisponde alle interruzioni di linea a meno che non sia in modalità dotall), così come il comportamento delle ancore ^ e $ in modalità multilinea. Puoi sovrascrivere questo default con i seguenti modificatori:
✽ (*CR) Solo un ritorno a capo è considerato un’interruzione di riga
✽ (*LF) Solo un avanzamento di riga è considerato un’interruzione di riga (come su Unix)
✽ (*CRLF) Solo un ritorno a capo seguito da un avanzamento di riga è considerato un’interruzione di riga (come su Windows)
✽ (*ANYCRLF) Una qualsiasi delle tre precedenti è considerata un’interruzione di riga
✽ (*ANY) Qualsiasi sequenza di newline Unicode è considerata un’interruzione di riga
Per esempio, (*CR)\w+.\w+ corrisponde a Line1\nLine2 perché il punto è in grado di corrispondere alla \n, che non è considerata un’interruzione di riga. Vedi demo.
Controllo di \R
Per impostazione predefinita, il metacarattere \R corrisponde a qualsiasi sequenza di newline Unicode. Quando la modalità UTF-8 è disattivata, queste sequenze di newline sono la coppia \r\n, così come i caratteri di ritorno a capo, avanzamento di riga, tabulazione verticale, avanzamento di forma o riga successiva. In modalità UTF-8, il token corrisponde anche al separatore di riga e al carattere separatore di paragrafo.
Due modificatori di inizio modello permettono di cambiare il comportamento di \R:
✽ Con (*BSR_ANYCRLF), \R corrisponde solo alla sequenza \r\n, \r o \n. Questo può anche essere impostato quando PCRE viene compilato o richiesto tramite l’opzione PCRE_BSR_ANYCRLF
✽ Con (*BSR_UNICODE), \R corrisponde a qualsiasi sequenza newline Unicode (sovrascrivendo l’opzione PCRE_BSR_ANYCRLF se impostata). Questo può anche essere impostato quando PCRE viene compilato o richiesto tramite l’opzione PCRE_BSR_UNICODE
Controllo degli schemi in fuga
Per limitare il numero di volte che PCRE chiama la funzione match(), usare il modificatore (*LIMIT_MATCH=x), impostando x al numero desiderato.
Per limitare la ricorsione, usate (*LIMIT_RECURSION=d), impostando d al livello di ricorsione più profondo consentito.
Turning Off Optimizations
(direct link)
Di default, PCRE studia il pattern e rende automaticamente atomico un token quantificato quando il token seguente è incompatibile – per esempio trasformando A+X in A++X. Il modificatore (*NO_AUTO_POSSESS) disabilita questa ottimizzazione. Usatelo quando volete usare pcretest per confrontare due modelli e sentirvi bene per tutti i cicli che l’auto-possessificazione vi sta facendo risparmiare.
Di default, PCRE esegue diverse ottimizzazioni per scoprire più velocemente se una corrispondenza fallirà. Il modificatore (*NO_START_OPT) disabilita queste ottimizzazioni.
Disabilitare le corrispondenze vuote
In PCRE2, (*NOTEMPTY) dice al motore di non restituire corrispondenze vuote. Allo stesso modo, (*NOTEMPTY_ATSTART) dice al motore di non restituire corrispondenze vuote trovate all’inizio dell’argomento.
Disabilitando l’ottimizzazione dell’ancoraggio automatico
In PCRE2, PCRE2_NO_DOTSTAR_ANCHOR dice al motore di non ancorare automaticamente i pattern che iniziano con .*
Puoi saperne di più su questo flag nella pagina API di PCRE2 (cerca PCRE2_NO_DOTSTAR_ANCHOR).

I 1001 modi di usare Regex