Regular Expressions
Regex-modifierare (flaggor)

Introduktion

Anmärkningar

DOTALL-modifierare

Ett regex-mönster där en DOTALL-modifierare (i de flesta regex-smaker uttryckt med s ) ändrar beteendet hos . så att den matchar en ny linje (LF) symbol:

/cat (.*?) dog/s

Denna regex i Perl-stil matchar en sträng som "cat fled from\na dog" fångar "fled from\na" till grupp 1.

En inlineversion: (?s) (t.ex. (?s)cat (.*?) dog )

Obs : I Ruby är ekvivalent DOTALL-modifieraren m , Regexp::MULTILINE modifierare (t.ex. /a.*b/m ).

Obs! JavaScript tillhandahåller inte en DOTALL-modifierare, så a . kan aldrig tillåtas matcha en ny linje-karaktär. För att uppnå samma effekt är en lösning nödvändig, t.ex. att ersätta alla . s med en catch-all-karaktärsklass som [\S\s] , eller en inte-inget karaktärsklass [^] (men denna konstruktion kommer att behandlas som ett fel av alla andra motorer, och är därför inte bärbar).

MULTILINE-modifierare

Ett annat exempel är en MULTILINE-modifierare (vanligtvis uttryckt med m flagga (inte i Oniguruma (t.ex. Ruby) som använder m att beteckna en DOTALL-modifierare)) som gör att ^ och $ -ankare matchar början / slutet på en linje , inte start / slut av hela strängen.

/^My Line \d+$/gm

hittar alla rader som börjar med My Line och innehåller sedan ett mellanslag och 1+ siffror upp till linjen.

En inlineversion: (?m) (t.ex. (?m)^My Line \d+$ )

OBS! I Oniguruma (t.ex. i Ruby), och även i nästan alla textredigerare som stöder regexps, de ^ och $ ankare betecknar linje start / ändlägen som standard. Du måste använda \A att definiera hela dokument / strängstart och \z att beteckna dokumentet / strängen. Skillnaden mellan \Z och \z är att den förstnämnda kan matcha före den sista nylinjesymbolen (LF) i slutet av strängen (t.ex. /\Astring\Z/ hittar en matchning i "string\n" ) (utom Python, där \Z beteendet är lika med \z och \z ankaret inte stöds).

IGNORE CASE-modifierare

Den vanliga modifieraren för att ignorera fall är i :

/fog/i

kommer att matcha Fog , foG , etc.

Inlineversionen av modifieraren ser ut (?i) .

Anmärkningar:

I Java antar som standard okänslig matchning att endast tecken i US-ASCII-charset matchas. Unicode-medvetna fall-okänslig matchning kan aktiveras genom att ange UNICODE_CASE flaggan i samband med denna ( CASE_INSENSITIVE ) flagga . (t.ex. Pattern p = Pattern.compile("YOUR_REGEX", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); ). Några mer om detta finns på Case-Insensitive Matching i Java RegEx . UNICODE_CHARACTER_CLASS kan också användas för att göra matchande Unicode medveten.

VERBOSE / COMMENT / IgnorePatternWhitespace-modifierare

Modifieraren som gör det möjligt att använda vitrummet i vissa delar av mönstret för att formatera det för bättre läsbarhet och för att tillåta kommentarer som börjar med # :

/(?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
/

Exempel på en sträng: #word1here . Observera att symbolen # undgår att beteckna en bokstavlig # som är en del av ett mönster.

Oöverskådligt vitt utrymme i det vanliga uttrycksmönstret ignoreras, undgå det för att göra det till en del av mönstret.

Vanligtvis behandlas vitrummet inuti karaktärsklasser ( [...] ) som ett bokstavligt vitrum, utom i Java.

Det är också värt att nämna att i PCRE, .NET, Python, Ruby Oniguruma, ICU, Boost regex-smaker kan man använda (?#:...) kommentarer i regex-mönstret.

Explicit Capture modifier

Detta är en .NET regex-specifik modifierare uttryckt med n . Vid användning fångas inte namngivna grupper (som (\d+) ). Endast giltiga fångar är uttryckligen namngivna grupper (t.ex. (?<name> subexpression) ).

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

matchar hela 123-1_abc-00098 , men (\d+) och (\w+) skapar inte grupper i det resulterande matchningsobjektet. Den enda gruppen är ${id} . Se demo .

UNICODE-modifierare

UNICODE-modifieraren, vanligtvis uttryckt som u (PHP, Python) eller U (Java), gör att regex-motorn behandlar mönstret och ingångssträngen som Unicode-strängar och mönster, gör mönstret korta klasser som \w , \d , \s osv. Unicode-medveten.

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

är ett PHP-regex för att matcha strängar som består av 1 eller flera Unicode-bokstäver. Se regex demo .

Observera att /u modifieraren i PHP gör det möjligt för PCRE-motorn att hantera strängar som UTF8-strängar (genom att slå på PCRE_UTF8 verb) och göra korta teckenklasser i mönstret Unicode medvetna (genom att aktivera PCRE_UCP verb, se mer på pcre.org ) .

Mönster- och ämnessträngar behandlas som UTF-8. Denna modifierare är tillgänglig från PHP 4.1.0 eller senare på Unix och från PHP 4.2.3 på win32. UTF-8-giltighet för mönstret och motivet kontrolleras sedan PHP 4.3.5. Ett ogiltigt ämne får preg_ * -funktionen att matcha ingenting; ett ogiltigt mönster utlöser ett fel på nivå E_WARNING. Fem och sex oktett UTF-8-sekvenser betraktas som ogiltiga sedan PHP 5.3.4 (resp. PCRE 7.3 2007-08-28); tidigare har de betraktats som giltiga UTF-8.

I Python 2.x påverkar re.UNICODE endast själva mönstret: Gör \w , \W , \b , \B , \d , \D , \s och \S beroende på Unicode-karaktärsegenskapens databas.

En inlineversion: (?u) i Python, (?U) i Java. Till exempel:

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

PCRE_DOLLAR_ENDONLY modifierare

Den PCRE-kompatibla PCRE_DOLLAR_ENDONLY- modifieraren som gör att $ ankaret matchar i slutet av strängen (exklusive positionen före den sista nylinjen i strängen).

/^\d+$/D

är lika med

/^\d+\z/

och matchar en hel sträng som består av 1 eller fler siffror och inte kommer att matcha "123\n" , men kommer att matcha "123" .

PCRE_ANCHORED modifierare

En annan PCRE-kompatibel modifierare uttryckt med /A modifierare. Om denna modifierare är inställd tvingas mönstret att "förankras", det vill säga det är begränsat att matcha bara i början av strängen som söks ("ämnessträngen"). Denna effekt kan också uppnås genom lämpliga konstruktioner i själva mönstret, vilket är det enda sättet att göra det i Perl.

/man/A

är det samma som

/^man/

PCRE_UNGREEDY modifierare

Den PCRE-kompatibla PCRE_UNGREEDY-flaggan uttryckt med /U Det växlar girighet i ett mönster: /a.*?b/U = /a.*b/ och vice versa.

PCRE_INFO_JCHANGED modifierare

Ytterligare en PCRE-modifierare som tillåter användning av duplicerade namngivna grupper.

OBS : endast inlineversion stöds - (?J) och måste placeras i början av mönstret.

Om du använder

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

gruppvärdena "val" kommer aldrig att vara tomma (kommer alltid att ställas in). En liknande effekt kan dock uppnås med återställning av gren.

PCRE_EXTRA-modifierare

En PCRE-modifierare som orsakar ett fel om något bakslag i ett mönster följs av en bokstav som inte har någon speciell betydelse. Som standard behandlas ett motstreck följt av en bokstav som inte har någon speciell betydelse som en bokstavlig.

T.ex

/big\y/

kommer att matcha bigy , men

/big\y/X

kommer att kasta ett undantag.

Inline version: (?X)