Regular Expressions
Modificatori del Regex (bandiere)

introduzione

Osservazioni

Modificatore DOTALL

Un modello regex in cui un modificatore DOTALL (nella maggior parte delle espressioni regex espresso con s ) modifica il comportamento di . abilitandolo per abbinare un simbolo di nuova riga (LF):

/cat (.*?) dog/s

Questa espressione regolare in stile Perl corrisponderà a una stringa come "cat fled from\na dog" catturata "fled from\na" nel Gruppo 1.

Una versione in linea: (?s) (es. (?s)cat (.*?) dog )

Nota : in Ruby, l'equivalente del modificatore DOTALL è m , Regexp::MULTILINE modificatore Regexp::MULTILINE (es. /a.*b/m ).

Nota : JavaScript non fornisce un modificatore DOTALL, quindi a . non può mai permettersi di abbinare un carattere di nuova riga. Per ottenere lo stesso effetto, è necessaria una soluzione alternativa, ad esempio la sostituzione di tutto il . s con una classe di caratteri catch-all come [\S\s] , o una classe di caratteri non nulla [^] (tuttavia, questo costrutto sarà trattato come un errore da tutti gli altri motori, e quindi non è portatile).

Modificatore MULTILINE

Un altro esempio è un modificatore MULTILINE (solitamente espresso con m flag (non in Oniguruma (es. Ruby) che usa m per denotare un modificatore DOTALL)) che rende ^ e $ anchor corrispondenti all'inizio / fine di una riga , non all'inizio / fine dell'intera stringa.

/^My Line \d+$/gm

troverà tutte le linee che iniziano con My Line , quindi contengono uno spazio e 1 o più cifre fino alla fine della riga.

Una versione inline: (?m) (es. (?m)^My Line \d+$ )

NOTA : In Oniguruma (ad esempio in Ruby), e anche in quasi tutti gli editor di testo che supportano le espressioni regolari, le ancore ^ e $ indicano le posizioni iniziali / finali della linea per impostazione predefinita . È necessario utilizzare \A per definire l'intero documento / inizio stringa e \z per indicare il fine documento / stringa. La differenza tra \Z e \z è che il primo può corrispondere prima del simbolo finale di fine riga (LF) alla fine della stringa (ad esempio /\Astring\Z/ troverà una corrispondenza in "string\n" ) (eccetto Python, dove il comportamento di \Z è uguale a \z e \z ancora non è supportato).

Modificatore IGNORE CASE

Il modificatore comune per ignorare il caso è i :

/fog/i

foG Fog , foG , ecc.

La versione in linea del modificatore appare come (?i) .

Gli appunti:

In Java, per impostazione predefinita, la corrispondenza senza distinzione tra maiuscole e minuscole presuppone che vengano confrontati solo i caratteri nel set di caratteri US-ASCII. La corrispondenza senza distinzione tra maiuscole e minuscole di Unicode può essere abilitata specificando il flag UNICODE_CASE in combinazione con questo flag ( CASE_INSENSITIVE ) . (ad es. Pattern p = Pattern.compile("YOUR_REGEX", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); ). Altre informazioni su questo argomento sono disponibili in corrispondenza di Case-Insensitive Matching in Java RegEx . Inoltre, UNICODE_CHARACTER_CLASS può essere utilizzato per rendere compatibile Unicode corrispondente.

Modificatore VERBOSE / COMMENT / IgnorePatternWhitespace

Il modificatore che consente di utilizzare gli spazi bianchi all'interno di alcune parti del pattern per formattarlo per una migliore leggibilità e per consentire commenti che iniziano con # :

/(?x)^          # start of string
  (?=\D*\d)     # the string should contain at least 1 digit 
  (?!\d+$)      # the string cannot consist of digits only
  \#            # the string starts with a hash symbol
  [a-zA-Z0-9]+ # the string should have 1 or more alphanumeric symbols
  $             # end of string
/

Esempio di una stringa: #word1here . Nota: il simbolo # viene fatto scorrere per indicare un # letterale che fa parte di un modello.

Lo spazio bianco senza escape nel pattern di espressione regolare viene ignorato, sfuggirlo per renderlo parte del pattern.

Di solito, lo spazio bianco all'interno delle classi di caratteri ( [...] ) viene trattato come uno spazio bianco letterale, tranne in Java.

Inoltre, vale la pena ricordare che in PCRE, .NET, Python, Ruby Oniguruma, ICU, Boost regex flavor si possono usare (?#:...) commenti all'interno del pattern regex.

Modificatore di cattura esplicita

Questo è un modificatore specifico regex .NET espresso con n . Quando vengono utilizzati, i gruppi senza nome (come (\d+) ) non vengono catturati. Solo le catture valide sono gruppi con nome esplicito (ad es. (?<name> subexpression) ).

(?n)(\d+)-(\w+)-(?<id>\w+)

corrisponderà all'intero 123-1_abc-00098 , ma (\d+) e (\w+) non creeranno gruppi nell'oggetto match risultante. L'unico gruppo sarà ${id} . Guarda la demo .

Modificatore UNICODE

Il modificatore UNICODE, solitamente espresso come u (PHP, Python) o U (Java), rende il motore regex che tratta il pattern e la stringa di input come stringhe e pattern Unicode, crea le classi stenografiche del pattern come \w , \d , \s , ecc. A conoscenza di Unicode.

/\A\p{L}+\z/u

è un'espressione regolare di PHP per far corrispondere le stringhe costituite da 1 o più lettere Unicode. Guarda la demo regex .

Nota che in PHP , il modificatore /u consente al motore PCRE di gestire le stringhe come stringhe UTF8 ( PCRE_UTF8 verbo PCRE_UTF8 ) e rendere le classi di caratteri abbreviati nel pattern Unicode consapevole (abilitando il verbo PCRE_UCP , vedere più su pcre.org ) .

Le stringhe di soggetto e modello sono considerate UTF-8. Questo modificatore è disponibile da PHP 4.1.0 o versioni successive su Unix e da PHP 4.2.3 su Win32. La validità del pattern UTF-8 e il soggetto sono controllati da PHP 4.3.5. Un oggetto non valido farà sì che la funzione preg_ * non corrisponda a nulla; un pattern non valido attiverà un errore di livello E_WARNING. Le sequenze UTF-8 di cinque e sei ottetti sono considerate non valide da PHP 5.3.4 (PCRE 7.3 2007-08-28); in precedenza quelli erano considerati UTF-8 validi.

In Python 2.x, re.UNICODE influenza solo il pattern stesso: re.UNICODE \w , \W , \b , \B , \d , \D , \s e \S dipendenti dal database delle proprietà dei caratteri Unicode.

Una versione inline: (?u) in Python, (?U) in Java. Per esempio:

print(re.findall(ur"(?u)\w+", u"Dąb")) # [u'D\u0105b']
print(re.findall(r"\w+", u"Dąb"))      # [u'D', u'b']

System.out.println("Dąb".matches("(?U)\\w+")); // true
System.out.println("Dąb".matches("\\w+"));     // false

Modificatore PCRE_DOLLAR_ENDONLY

Il modificatore PCRE_DOLLAR_ENDONLY compatibile PCRE che rende l'ancora $ match alla fine della stringa (esclusa la posizione prima della riga finale finale nella stringa).

/^\d+$/D

è uguale a

/^\d+\z/

e corrisponde a un'intera stringa composta da 1 o più cifre e non corrisponde a "123\n" , ma corrisponde a "123" .

Modificatore PCRE_ANCHORED

Un altro modificatore compatibile con PCRE espresso con il modificatore /A Se questo modificatore è impostato, il pattern è forzato ad essere "ancorato", cioè, è costretto a corrispondere solo all'inizio della stringa che viene cercata (la "stringa soggetto"). Questo effetto può anche essere ottenuto mediante costrutti appropriati nel pattern stesso, che è l'unico modo per farlo in Perl.

/man/A

equivale a

/^man/

Modificatore PCRE_UNGREEDY

La bandiera PCRE_UNGREEDY conforme a PCRE espressa con /U /a.*?b/U avidità all'interno di un pattern: /a.*?b/U = /a.*b/ e viceversa.

Modificatore PCRE_INFO_JCHANGED

Un altro modificatore PCRE che consente l'utilizzo di gruppi duplicati denominati.

NOTA : è supportata solo la versione inline - (?J) e deve essere posizionata all'inizio del pattern.

Se usi

/(?J)\w+-(?:new-(?<val>\w+)|\d+-empty-(?<val>[^-]+)-collection)/

i valori del gruppo "val" non saranno mai vuoti (sarà sempre impostato). Un effetto simile può essere ottenuto con il reset del ramo.

Modificatore PCRE_EXTRA

Un modificatore PCRE che causa un errore se una barra rovesciata in un pattern è seguita da una lettera che non ha un significato speciale. Per impostazione predefinita, una barra rovesciata seguita da una lettera senza significato speciale viene considerata letterale.

Per esempio

/big\y/

corrisponderà bigy , ma

/big\y/X

genererà un'eccezione.

Versione in linea: (?X)