Regular Expressions
Regex-modificaties (vlaggen)

Invoering

Opmerkingen

DOTALL modifier

Een regexpatroon waarbij een DOTALL-modificator (in de meeste regex-smaken uitgedrukt met s ) het gedrag van verandert . waardoor het overeenkomt met een newline (LF) symbool:

/cat (.*?) dog/s

Deze regex in Perl-stijl komt overeen met een string als "cat fled from\na dog" gevangen "fled from\na" in groep 1.

Een inline-versie: (?s) (bijv. (?s)cat (.*?) dog )

Opmerking : In Ruby is het equivalent van de DOTALL-modificatie m , Regexp::MULTILINE modificator (bijvoorbeeld /a.*b/m ).

Opmerking : JavaScript biedt geen DOTALL-modifier, dus een . mag nooit overeenkomen met een nieuweteken. Om hetzelfde effect te bereiken, is een oplossing nodig, bijvoorbeeld het vervangen van alle . s met een allesomvattende karakterklasse zoals [\S\s] , of een niet-niets karakterklasse [^] (deze constructie wordt echter door alle andere motoren als een fout behandeld en is dus niet draagbaar).

MULTILINE modifier

Een ander voorbeeld is een MULTILINE-modifier (meestal uitgedrukt met de vlag m (niet in Oniguruma (bijv. Ruby) die m gebruikt om een DOTALL-modifier aan te duiden)) waardoor ^ en $ ankers overeenkomen met het begin / einde van een regel , niet het begin / einde van de hele string.

/^My Line \d+$/gm

vindt alle regels die beginnen met My Line en bevatten vervolgens een spatie en 1+ cijfers tot aan het regeleinde.

Een inline-versie: (?m) (bijv. (?m)^My Line \d+$ )

Opmerking: In Oniguruma (bv Ruby) en ook vrijwel alle tekstverwerkers ondersteunen regexps de ^ en $ ankers duiden regel start / eindstanden standaard. U moet \A gebruiken om het hele document / tekenreeksstart te definiëren en \z om het document / tekenreekseinde aan te duiden. Het verschil tussen de \Z en \z is dat de eerste kan matchen voor het laatste newline (LF) symbool aan het einde van de string (bijv. /\Astring\Z/ vindt een match in "string\n" ) (behalve Python, waarbij \Z gedrag gelijk is aan \z en \z anker niet wordt ondersteund).

IGNORE CASE modifier

De algemene modificator om een case te negeren is i :

/fog/i

komt overeen met Fog , foG , etc.

De inline-versie van de modifier ziet eruit als (?i) .

Opmerkingen:

In Java wordt in hoofdletterongevoelige overeenkomsten standaard verondersteld dat alleen tekens in het US-ASCII-tekenset worden vergeleken. Unicode-bewust hoofdletterongevoelig matchen kan worden ingeschakeld door de vlag UNICODE_CASE op te geven in combinatie met deze vlag ( CASE_INSENSITIVE ) . (bijv. Pattern p = Pattern.compile("YOUR_REGEX", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); ). Meer hierover is te vinden op Case-Insensitive Matching in Java RegEx . Ook kan UNICODE_CHARACTER_CLASS worden gebruikt om overeenkomende Unicode bewust te maken.

VERBOSE / COMMENT / IgnorePatternWhitespace modifier

De modifier die het mogelijk maakt om in sommige delen van het patroon witruimte te gebruiken om het op te maken voor een betere leesbaarheid en om opmerkingen toe te staan die beginnen met # :

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

Voorbeeld van een string: #word1here . Merk op dat het # -symbool ontsnapt is om een letterlijk # aan te geven dat deel uitmaakt van een patroon.

Niet-gevormde witte ruimte in het reguliere expressiepatroon wordt genegeerd. Ontsnap eraan om er een deel van te maken.

Gewoonlijk wordt de witruimte in tekenklassen ( [...] ) behandeld als een letterlijke witruimte, behalve in Java.

Het is ook vermeldenswaard dat in PCRE, .NET, Python, Ruby Oniguruma, ICU, Boost regex-smaken opmerkingen (?#:...) in het regex-patroon kunnen worden gebruikt.

Modifier voor expliciete opname

Dit is een .NET regex-specifieke modifier uitgedrukt met n . Wanneer gebruikt, worden niet-benoemde groepen (zoals (\d+) ) niet vastgelegd. Alleen geldige vastleggingen hebben expliciet benoemde groepen (bijv. (?<name> subexpression) ).

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

komt overeen met de hele 123-1_abc-00098 , maar (\d+) en (\w+) maken geen groepen in het resulterende 123-1_abc-00098 . De enige groep is ${id} . Zie demo .

UNICODE-modificator

De modificator UNICODE, meestal uitgedrukt als u (PHP, Python) of U (Java), zorgt ervoor dat de regex-engine het patroon en de invoertekenreeks behandelt als Unicode-tekenreeksen en patronen, waardoor het patroon steno-klassen maakt zoals \w , \d , \s , etc. Unicode-bewust.

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

is een PHP-regex die overeenkomt met tekenreeksen die bestaan uit 1 of meer Unicode-letters. Bekijk de regex-demo .

Merk op dat in / PHP de modificator /u de PCRE-engine in staat stelt om strings als UTF8-strings te behandelen (door PCRE_UTF8 werkwoord in te PCRE_UTF8 ) en de verkorte PCRE_UTF8 in het patroon Unicode bewust te maken (door PCRE_UCP werkwoord in te schakelen , zie meer op pcre.org ) .

Patroon- en onderwerpstrings worden behandeld als UTF-8. Deze modifier is beschikbaar vanaf PHP 4.1.0 of hoger op Unix en vanaf PHP 4.2.3 op win32. UTF-8-geldigheid van het patroon en het onderwerp wordt gecontroleerd sinds PHP 4.3.5. Een ongeldig onderwerp zorgt ervoor dat de preg_ * -functie niets overeenkomt; een ongeldig patroon veroorzaakt een fout van niveau E_WARNING. UTF-8-sequenties van vijf en zes octetten worden als ongeldig beschouwd sinds PHP 5.3.4 (resp. PCRE 7.3 2007-08-28); voorheen werden die als geldige UTF-8 beschouwd.

In Python 2.x is de re.UNICODE alleen van invloed op het patroon zelf: maak \w , \W , \b , \B , \d , \D , \s en \S afhankelijk van de database met eigenschappen van Unicode-tekens.

Een inline-versie: (?u) in Python, (?U) in Java. Bijvoorbeeld:

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 modifier

De PCRE-compatibele PCRE_DOLLAR_ENDONLY modifier die de $ anchor-match aan het einde van de string maakt (exclusief de positie voor de laatste nieuwe regel in de string).

/^\d+$/D

is gelijk aan

/^\d+\z/

en komt overeen met een hele reeks die bestaat uit 1 of meer cijfers en komt niet overeen met "123\n" , maar wel met "123" .

PCRE_ANCHORED modifier

Nog een PCRE-compatibele modifier uitgedrukt met /A modifier. Als deze modificator is ingesteld, wordt het patroon gedwongen "verankerd" te zijn, dat wil zeggen, het is beperkt om alleen overeen te komen aan het begin van de string waarnaar wordt gezocht (de "subject string"). Dit effect kan ook worden bereikt door geschikte constructies in het patroon zelf, wat de enige manier is om het in Perl te doen.

/man/A

is hetzelfde als

/^man/

PCRE_UNGREEDY modifier

De PCRE-compatibele PCRE_UNGREEDY vlag uitgedrukt met /U Het verandert hebzucht in een patroon: /a.*?b/U = /a.*b/ en vice versa.

PCRE_INFO_JCHANGED modifier

Nog een PCRE-modifier die het gebruik van dubbele benoemde groepen mogelijk maakt.

OPMERKING : alleen inline- versie wordt ondersteund - (?J) en moet aan het begin van het patroon worden geplaatst.

Als je gebruikt

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

de "val" groepswaarden zullen nooit leeg zijn (zullen altijd worden ingesteld). Een soortgelijk effect kan echter worden bereikt met een reset van de vertakking.

PCRE_EXTRA modifier

Een PCRE-modifier die een fout veroorzaakt als een backslash in een patroon wordt gevolgd door een letter die geen speciale betekenis heeft. Standaard wordt een backslash gevolgd door een letter zonder speciale betekenis als letterlijk beschouwd.

Eg

/big\y/

komt overeen met bigy , maar

/big\y/X

zal een uitzondering veroorzaken.

Inline-versie: (?X)