Dette er en referenceside – du skal ikke føle dig tvunget til at læse den, da den er ret kortfattet. Andre afsnit linker til den, når det er nødvendigt.
Regex-modifikatorer dukker op på alle hjørner af dette websted. I stedet for gentagne gange at forklare, hvad de gør, og de mange måder at slå dem til på i hver eneste regex-smag, besluttede jeg mig for at samle de fire almindelige (i, s, m og x) på ét sted. Det sidste afsnit giver en kort oversigt over andre modifikatorer, som normalt er sprogspecifikke.
Springpunkter
For at lette navigationen er her nogle springpunkter til de forskellige afsnit på siden:
✽ Case Insensitivity: i
✽ DOTALL (Dot Matches Line Breaks): s (undtagen Ruby og JavaScript)
✽ Multiline (^ og $ Match on Every Line): m (undtagen Ruby)
✽ Free-spacing: x (undtagen JavaScript)
✽ Andre modifikatorer
✽ PCRE’s specielle start-of-pattern-modifikatorer
(direkte link)
Kasusindstilling: i
Som standard matcher alle større regex-maskiner i kasussensitiv tilstand. Hvis du ønsker mønstre som Name:
Ja, men…
Hvad betyder case-insensitive egentlig?
Så længe du holder dig til de 26 bogstaver i det engelske alfabet, er definitionen af store og små bogstaver ligetil. Når man bevæger sig ud til typografiske finesser eller andre sprog og skrifter, er tingene ikke altid så enkle. Her er nogle spørgsmål, som du kan støde på.
✽ Vil fl (ét tegn, dvs. fl-ligaturen) passe til FL?
✽ Vil à (ét tegn) passe til À?
✽ Vil à (to tegn, dvs. bogstavet a og gravaccenten) passe til À? Alle motorer synes at håndtere det korrekt.
✽ Vil ß passe til ss? Ingen motor ser ud til at gøre det.
✽ Vil i matche İ (tyrkisk stort i) såvel som I?
Disse spørgsmål er blot toppen af isbjerget. Selv hvis jeg kendte alle svarene, ville det være umuligt at medtage dem alle i dette afsnit: Hvis du bruger et bestemt script, skal du undersøge, hvordan din specifikke motor håndterer case-insensitive matching i det pågældende script.
Mere end én måde
For flere motorer skal du bemærke, at der er to måder at slå case-insensitive matching til på: som en inline-modifikator (?i) eller som en indstilling i regex-metoden eller -funktionen.
Inline-modifikator (?i)
I .NET, PCRE (C, PHP, R…), Perl, Python, Java og Ruby (men ikke JavaScript) kan du bruge inline-modifikatoren (?i), f.eks. i (?i)cat. Se afsnittet om inline-modifikatorer for saftige detaljer om tre yderligere funktioner (ikke tilgængelige i Python): at slå det til midt i en streng, slå det fra med (?-i) eller kun anvende det på indholdet af en ikke-fanggruppe med (?i:foo)
.NET
Afhængigt af (?i) inline-modifikatoren har .NET-sprogene indstillingen IgnoreCase. I C# kan du f.eks. bruge:var catRegex = new Regex("cat", RegexOptions.IgnoreCase);
Perl
Selvom (?i) inline-modifikatoren giver Perl dig mulighed for at tilføje i-flaget efter dit mønsters afsluttende afgrænser. Du kan f.eks. bruge:if ($the_subject =~ m/cat/i) { … }
PCRE (C, PHP, R…)
Bemærk, at i PCRE skal du aktivere Unicode-tilstand for at bruge case-insensitive matching med ikke-engelske bogstaver, der ikke er en del af din locale, for eksempel med den særlige start-of-pattern-modifikator (*UTF8).
Afhængig af (?i) inline-modifikator, lader PCRE dig indstille PCRE_CASELESS-tilstanden, når du kalder funktionen pcre_compile() (eller lignende):
cat_regex = pcre_compile( "cat", PCRE_CASELESS, &error, &erroroffset, NULL );
I PHP overføres PCRE_CASELESS-indstillingen via i-flaget, som du kan tilføje i din regex-streng efter den afsluttende afgrænser. Du kan f.eks. bruge:$cat_regex = '~cat~i';
I R overføres PCRE_CASELESS-indstillingen via indstillingen ignore.case=TRUE. Du kan f.eks. bruge:grep("cat", subject, perl=TRUE, value=TRUE, ignore.case=TRUE);
Python
Python har ud over (?i) inline-modifikatoren også indstillingen IGNORECASE. Du kan f.eks. bruge:cat_regex = re.compile("cat", re.IGNORECASE)
Java
Som undtagelse af (?i) inline-modifikatoren har Java indstillingen CASE_INSENSITIVE. Du kan f.eks. bruge:
Pattern catRegex = Pattern.compile( "cat", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE );
Den UNICODE_CASE-indstilling, der er tilføjet her, sikrer, at funktionen til at undgå store og små bogstaver (case-insensitivity) er Unicode-aware. Hvis du kun arbejder med ASCII, behøver du ikke at bruge den.
JavaScript
I JavaScript er din eneste mulighed at tilføje i-flaget efter dit mønsters afsluttende afgrænser. Du kan f.eks. bruge:var catRegex = /cat/i;
Ruby
Selvom (?i) inline-modifikatoren giver Ruby dig mulighed for at tilføje i-flaget efter mønsterets afsluttende afgrænser. Du kan f.eks. bruge: :cat_regex = /cat/i
(direkte link)
DOTALL (Dot Matches Line Breaks): s (with exceptions)
Som standard passer punktet . ikke til linjeskifttegn som f.eks. linjeskift og vognrumsmarkeringer. Hvis du ønsker mønstre som BEGIN .*? END skal matche på tværs af linjer, skal vi slå denne funktion til.
Denne tilstand kaldes nogle gange single-line (deraf s), fordi for så vidt angår punktet, forvandler det hele strengen til én stor linje – .* vil matche fra det første tegn til det sidste, uanset hvor mange linjeskift der er imellem.
Moden kaldes også DOTALL i PCRE, Python og Java (for at være mere præcis, bruger PCRE-dokumentationen PCRE_DOTALL). For mig at se er navnet DOTALL en fornuftig måde at kalde denne tilstand på. Den tredje indstilling dot-matches-line-breaks er beskrivende, men lidt af en mundfuld.
For flere motorer skal du bemærke, at der er to måder at slå den til på: som en inline-modifikator eller som en indstilling i regex-metoden eller -funktionen.
JavaScript
JavaScript understøtter ikke single-line mode. For at matche alle tegn i JavaScript, herunder linjeskift, skal du bruge en konstruktion som . Denne tegnklasse matcher et tegn, der enten er et ikke-ciffer \D eller et ciffer \d. Derfor passer den til ethvert tegn.
En anden JavaScript-løsning er at bruge XRegExp-regex-biblioteket. Hvis du har uendelig meget tid til rådighed, kan du også prøve at portere PCRE til JavaScript ved hjælp af Emscripten, som Firas tilsyneladende har gjort på regex 101.
Inline Modifier (?s)
I .NET, PCRE (C, PHP, R…), Perl, Python og Java (men ikke Ruby) kan du bruge inline-modifikatoren (?s), f.eks. i (?s)BEGIN .*? END. Se afsnittet om inline-modifikatorer for saftige detaljer om tre yderligere funktioner (ikke tilgængelige i Python): at slå det til midt i en streng, slå det fra med (?-s) eller kun anvende det på indholdet af en ikke-fanggruppe med (?s:foo)
.NET
Afhængigt af (?s) inline-modifikatoren har .NET-sprogene indstillingen Singleline. I C# kan du f.eks. bruge:
var blockRegex = new Regex( "BEGIN .*? END", RegexOptions.IgnoreCase | RegexOptions.Singleline );
Perl
Perl
Selvom (?s) inline-modifikatoren giver Perl dig mulighed for at tilføje s-flaget efter dit mønsters afsluttende afgrænser. Du kan f.eks. bruge:if ($the_subject =~ m/BEGIN .*? END/s) { … }
PCRE (C, PHP, R…)
Afhængigt af (?s) inline-modifikatoren kan du med PCRE indstille PCRE_DOTALL-tilstanden, når du kalder funktionen pcre_compile() (eller lignende):
block_regex = pcre_compile( "BEGIN .*? END", PCRE_DOTALL, &error, &erroroffset, NULL );
I PHP overføres PCRE_DOTALL-indstillingen via s-flaget, som du kan tilføje i din regex-streng efter det afsluttende afgrænsningsled. Du kan f.eks. bruge:$block_regex = '~BEGIN .*? END~s';
Python
Python har ud over (?s) inline-modifikatoren også DOTALL-indstillingen. Du kan f.eks. bruge:block_regex = re.compile("BEGIN .*? END", re.IGNORECASE | re.DOTALL)
Java
Som undtagelse af (?s) inline-modifikatoren har Java DOTALL-indstillingen. Du kan f.eks. bruge:
Pattern blockRegex = Pattern.compile( "BEGIN .*? END", Pattern.CASE_INSENSITIVE | Pattern.DOTALL );
Ruby: (?m)-modifikator og m-flag
I Ruby kan du bruge inline-modifikatoren (?m), f.eks. i (?m)BEGIN .*? END. Dette er en mærkelig Ruby-finurlighed, da andre motorer bruger (?m) til tilstanden “^ og $ matcher på hver linje”.
Se afsnittet om inline-modifikatorer for saftige detaljer om tre yderligere funktioner: at slå det til midt i strengen, slå det fra med (?-m) eller kun anvende det på indholdet af en ikke-fanggruppe med (?m:foo)
Ruby giver dig også mulighed for at tilføje m-flaget i slutningen af din regex-streng. Du kan f.eks. bruge:block_regex = /BEGIN .*? END/m
(direkte link)
Oprindelse af DOTALL
Den enstrengede tilstand kaldes også ofte DOTALL (som står for “dot matches all”) på grund af PCRE_DOTALL-indstillingen i PCRE, re.DOTALL-indstillingen i Python og Pattern.DOTALL-indstillingen i Java.
Jeg har flere gange hørt det påstået, at “DOTALL er en Python-ting”, men det syntes at komme fra folk, som ikke havde hørt om de tilsvarende muligheder i PCRE og Java. Alligevel fik det mig til at undre mig: Hvor optrådte DOTALL først? Når man ser på PCRE Change Log og den gamle Python-dokumentation, ser det ud til, at den dukkede op i PCRE med version 0.96 (oktober 1997), i Python med version 1.5 (februar 1998) og derefter i Java 1.4 (februar 2002). Afstanden mellem PCRE- og Python-introduktionerne var ikke entydig – ordet kan have været i omløb i tidligere betaversioner eller endda i andre værktøjer – så jeg spurgte Philip Hazel (PCRE’s fader) om det. Han svarede:
Jeg tror, at jeg opfandt det – jeg havde i hvert fald ikke set det andre steder, da jeg forsøgte at finde på et navn til PCRE-optionen, der svarer til Perls /s-option. (“S” står der for “single-line” (…) så jeg ville have et bedre navn.)
Så der. De, der kan lide lidt historie, vil måske nyde denne lækre guldklump.
(direkte link)
Multilinje (^ og $ matcher på hver linje): m (undtagen Ruby)
Som standard i alle større motorer undtagen Ruby matcher ankerne ^ og $ kun (henholdsvis) i begyndelsen og slutningen af strengen.
I Ruby matcher de i begyndelsen og slutningen af hver linje, og der er ingen måde at slå den funktion fra på. Dette er faktisk en fornuftig måde at gøre tingene på, hvormed Ruby delvist indfrier sig selv for at bruge m til DOTALL-tilstand, når andre motorer bruger s.
I andre motorer skal vi slå denne funktion til, hvis man ønsker, at mønstre som ^Define og >>>>$ skal matche (henholdsvis) i begyndelsen og slutningen af hver linje.
Denne funktion kaldes normalt multi-line (deraf m’et), fordi ankerne ^ og $ fungerer på flere linjer.
For flere motorer skal du bemærke, at der er to måder at slå den til på: som en inline-modifikator (?m) eller som en indstilling i regex-metoden eller -funktionen.
Ruby
I Ruby matcher ankerne ^ og $ altid på alle linjer. Der er ingen måde at slå denne indstilling fra på. Dette er faktisk en ganske fin måde at gøre tingene på, da der, som i de fleste varianter, er separate ankre for begyndelsen og slutningen af strenge: \A, \Z og \z.
På den anden side kan man fortryde Rubys valg om at bruge m-flaget og modifikatoren på en ikke-standardiseret måde (se DOTALL).
Inline Modifier (?m)
I .NET, PCRE (C, PHP, R…), Perl, Python, Java og Ruby (men ikke JavaScript) kan du bruge inline-modifikatoren (?m), f.eks. i (?m)^cat. Se afsnittet om inline-modifikatorer for saftige detaljer om tre yderligere funktioner (ikke tilgængelige i Python): at slå det til midt i en streng, slå det fra med (?-m) eller kun anvende det på indholdet af en ikke-fanggruppe med (?m:foo)
.NET
Afhængigt af (?m) inline-modifikatoren har .NET-sprogene Multiline-indstillingen. I C# kan du f.eks. bruge:
var catRegex = new Regex("^cat", RegexOptions.IgnoreCase | RegexOptions.Multiline);
Perl
Perl
Selvom (?m) inline-modifikatoren giver Perl dig mulighed for at tilføje m-flaget efter dit mønsters afsluttende afgrænser. Du kan f.eks. bruge:if ($the_subject =~ m/^cat/m) { … }
PCRE (C, PHP, R…)
Afhængigt af (?m) inline-modifikatoren giver PCRE dig mulighed for at indstille PCRE_MULTILINE-tilstanden, når du kalder funktionen pcre_compile() (eller lignende):
cat_regex = pcre_compile( "^cat", PCRE_CASELESS | PCRE_MULTILINE, &error, &erroroffset, NULL );
I PHP overføres PCRE_MULTILINE-indstillingen via m-flaget, som du kan tilføje i din regex-streng efter den afsluttende afgrænsningslinje. Du kan f.eks. bruge:$cat_regex = '~^cat~m';
Python
Python har ud over (?m) inline-modifikatoren også MULTILINE-indstillingen. Du kan f.eks. bruge:cat_regex = re.compile("^cat", re.IGNORECASE | re.MULTILINE)
Java
Ud over (?m) inline-modifikatoren har Java MULTILINE-indstillingen. Du kan f.eks. bruge:
Pattern catRegex = Pattern.compile( "^cat", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE );
JavaScript
I JavaScript er din eneste mulighed at tilføje m-flaget efter dit mønsters afsluttende afgrænser. Du kan f.eks. bruge:var catRegex = /^cat/m;
(direkte link)
Free-spacing: x (undtagen JavaScript)
Som standard angiver ethvert mellemrum i en regex-streng et tegn, der skal matches. I sprog, hvor du kan skrive regex-strenge på flere linjer, angiver linjeskiftet også bogstavelige tegn, der skal matches. Da man ikke kan indsætte mellemrum for at adskille grupper, der har forskellige betydninger (som man gør mellem sætninger og pragraffer, når man skriver på engelsk), kan en regex blive svær at læse, som f.eks. regex’en Meaning of Life fra regex-humorsiden:
^(?=(?!(.))()(?-1)(?<!\d(?<=(?!)\d))).$
Glædeligvis understøtter mange motorer en tilstand med frit mellemrum, der giver dig mulighed for at lufte din regex. Du kan f.eks. tilføje mellemrum mellem tokens. I PHP kunne du skrive dette – bemærk x-flaget efter den sidste afgrænser ~:$word_with_digit_and_cap_regex = '~ ^ (?=\D*\d) \w*\w* $ ~x';
Men hvorfor blive på én linje? Du kan sprede dit regex over så mange linjer som du vil – med indrykning og tilføjelse af kommentarer – som indledes med et #. I C# kan du f.eks. gøre noget som dette:
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");
Denne tilstand kaldes free-spacing-tilstand. Du kan også se den blive kaldt whitespace mode, comment mode eller verbose mode.
Det kan være overkill i en simpel regex som den ovenfor (selv om alle, der skal vedligeholde din kode, vil takke dig for det). Men hvis du opbygger et seriøst regex-mønster som det i tricket for at matche tal på almindeligt engelsk… Medmindre du er masochist, har du ikke noget valg.
Bemærk, at inden for en tegnklasse bliver mellemrumstegnet og # (som ellers introducerer kommentarer) stadig respekteret – undtagen i Java, hvor de begge skal escapes, hvis du vil matche disse tegn.
For flere motorer er der to måder at slå free-spacing-tilstand til på: som en inline-modifikator eller som en indstilling i regex-metoden eller -funktionen.
Free-spacing-tilstand er vidunderlig, men der er et par mindre farer, som du bør være opmærksom på, da de kan få dig til at klø dig i hovedet og undre dig over, hvorfor et mønster ikke fungerer, som du forventer.
Trip Hazard #1: Betydningen af Space
Først kan du ikke længere bruge Number: \d+ til at matche en streng som Nummer: 24. Årsagen er, at mellemrummet i : \d ikke længere passer til et mellemrum. Vi er i fri mellemrumstilstand, husker du det? Det er hele pointen.
For at matche et mellemrumskarakter skal du angive det. De to vigtigste måder at gøre det på er at placere det inden for en tegnklasse eller at undslippe det med en backslash. Begge dele ville fungere: Nummer:\d+ eller Nummer:\ \ \d+
Nummer:\s\d+ ville selvfølgelig også passe, men husk, at \s passer til meget mere end et mellemrumstegn. Det kan f.eks. passe til en tabulator eller et linjeskift. Det er måske ikke det, du ønsker.
Trip Hazard #2: Late Start
For det andet kan du blive for sikker på friafstandstegnets magt og prøve noget som dette for at lade regex’en stå alene:
var wordWithDigitAndCapRegex = new Regex(@" (?x) # Free-spacing mode ^ # Beginning of string etc # Match the literal chars e,t,c");
Problemet med dette er, at selv om det kan se ud som om friafstandsmodifikatoren (?x) er den første ting i dit regex, er det ikke tilfældet.
Efter det indledende dobbelte citationstegn ” har vi et linjeskift og en række mellemrum. Motoren forsøger at matche dem, fordi vi på det tidspunkt endnu ikke er i fri afstandstilstand. Denne tilstand er først aktiveret, når vi støder på (?x). Dette regex vil aldrig matche strengen osv. og mere, for når vi støder på begyndelsen af strengen anker ^, skal vi allerede have matchet et linjeskift og mellemrumstegn!
Det er derfor, at hvis du kigger på det første eksempel, vil du se, at free-spacing-modifikatoren (?x) er det allerførste efter det indledende citationstegn.
Hvidrum bliver ikke bare trimmet ud af mønsteret
Selv om der bliver ignoreret hvidt mellemrum, adskiller placeringen af et hvidt mellemrum stadig det foregående token fra det næste. F.eks. er
✽ (A)\1 2 ikke det samme som (A)\12. Førstnævnte passer til AA2, sidstnævnte passer til A\n i .NET, PCRE, Perl og Ruby (12 er oktalkoden for linefeed-tegnet)
✽ \p{Nd} er gyldigt, men \p{N d} er det ikke – undtagen i Perl og Ruby
JavaScript
JavaScript
JavaScript understøtter ikke free-spacing-tilstand. I JavaScript skal du bruge en konstruktion som f.eks. . Denne tegnklasse passer til et tegn, der enten er et ikke-ciffer \D eller et ciffer \d. Derfor passer den til ethvert tegn.
En anden JavaScript-løsning er at bruge XRegExp-regex-biblioteket. Hvis du har uendelig meget tid til rådighed, kan du også prøve at portere PCRE til JavaScript ved hjælp af Emscripten, som Firas tilsyneladende har gjort på regex 101.
Inline Modifier (?s)
I .NET, PCRE (C, PHP, R…), Perl, Python, Java og Ruby (men ikke JavaScript) kan du bruge inline-modifikatoren (?x), f.eks. er dette en luftet regex til at matche gentagne ord:(?x) (\w+) + \bSe også afsnittet om inline-modifikatorer.
.NET
Afhængigt af (?x) inline-modifikatoren har .NET-sprogene indstillingen IgnorePatternWhitespace. I C# kan du f.eks. bruge:
var repeatedWordRegex = new Regex(@" (\w+) + \b", RegexOptions.IgnorePatternWhitespace );
Perl
Perl
Selvom (?x) inline-modifikatoren giver Perl dig mulighed for at tilføje x-flaget efter dit mønsters afsluttende afgrænsningstegn. Du kan f.eks. bruge:
if ($the_subject =~ m/(\w+) + \b/x) { … }
PCRE (C, PHP, R…)
Afhængigt af (?x) inline-modifikatoren lader PCRE dig indstille PCRE_EXTENDED-tilstanden, når du kalder funktionen pcre_compile() (eller lignende):
repeated_word_regex = pcre_compile( "(\w+) + \b", PCRE_EXTENDED, &error, &erroroffset, NULL );
I PHP overføres PCRE_EXTENDED-indstillingen via x-flaget, som du kan tilføje i din regex-streng efter det afsluttende afgrænsningsled. Du kan f.eks. bruge:$repeated_word_regex = '~(\w+) + \b~x';
Python
Afhængigt af (?x) inline-modifikatoren har Python VERBOSE-indstillingen. Du kan f.eks. bruge:repeated_word_regex = re.compile(r"(\w+) + \b", re.VERBOSE)
Java
I modsætning til andre motorer ignoreres hashes i en Java-karakterklasse, der indfører kommentarer og mellemrum, så du skal undslippe dem, hvis du vil bruge disse tegn i en klasse, f.eks. +
Selvom (?x) inline-modifikatoren har Java indstillingen COMMENTS. Du kan f.eks. bruge:
Pattern repeatedWordRegex = Pattern.compile( "(\w+) + \1\b", Pattern.COMMENTS );
Ruby
Afhængigt af (?x) inline-modifikatoren kan du med Ruby tilføje x-flaget i slutningen af din regex-streng. Du kan f.eks. bruge:repeated_word_regex = /(\w+) + \b/x
(direkte link)
Andre modifikatorer
Nogle motorer understøtter modifikatorer og flag ud over i, s, m og x. Jeg planlægger at dække disse på de sider, der er dedikeret til disse varianter.
For eksempel har
✽ .NET modifikatoren (?n) (også tilgængelig via indstillingen ExplicitCapture). Dette forvandler alle (parenteser) til non-capture-grupper. Hvis du vil opsamle, skal du bruge navngivne grupper.
✽ Java har modificatoren (?d) (også tilgængelig via UNIX_LINES-indstillingen). Når denne er aktiveret, er det kun linjefodstegnet \n der påvirker punktet . (som ikke passer til linjeskift, medmindre DOTALL er slået til) og ankeret ^ og $ (som passer til linjebegyndelse og -afslutning i flerlinjemodus.)
✽ Perl har flere andre flag. Se afsnittet om modifikatorer i dokumentationen.
✽ PCRE har modifikatoren (?J) (også tilgængelig i kode via indstillingen PCRE_DUPNAMES). Når den er indstillet, kan forskellige optagelsesgrupper bruge det samme navn – selv om de får tildelt forskellige numre.
(direkte link)
✽ PCRE har modificatoren (?U) (også tilgængelig i koden via indstillingen PCRE_UNGREEDY). Når den er indstillet, er kvantifikatorer som standard ungreedy. Hvis der tilføjes et ?, bliver de grådige.
(direkte link)
✽ PCRE har modificatoren (?X) (også tilgængelig i kode via indstillingen PCRE_EXTRA). Historisk set er denne tilstand blevet brugt til at aktivere nye funktioner under udvikling. I øjeblikket udløser den fejl, hvis tokens som \B bruges i en tegnklasse (hvor det normalt passer til det store bogstav B, i modsætning til uden for en tegnklasse, hvor det er en “not-a-word-boundary assertion”).
✽ PCRE har en række specielle modifikatorer, der kan sættes i starten af mønsteret (disse er vist nedenfor). Desuden kan mange indstillinger sendes til pcre_compile()-funktionsfamilien, hvis du har adgang til dem. Du kan få oplysninger om disse ved at hente pcre_compile.html fra doc-mappen ved at downloade PCRE.
(direkte link)
PCRE’s særlige start-of-Pattern Modifiers
PCRE har en række “særlige modifikatorer”, som du kan indstille ved starten af et mønster. I stedet for standard-syntaksen (?z) for inline-modifikatorer ser den specielle modifikator-syntaks ud som (*MYMODIFIER). Disse modifikatorer er særligt nyttige i sammenhænge, hvor PCRE er integreret i et værktøj eller et sprog – da de erstatter en række af de indstillinger, du ville sende til pcre_compile().
UTF-strenge
Såfremt PCRE er kompileret med de relevante indstillinger, kan du instruere motoren til at behandle emnestrengen som forskellige typer UTF-strenge.
✽ (*UTF) er en generisk måde at behandle emnet som en UTF-streng på – den registrerer, om den skal behandles som UTF-8, UTF-16 eller UTF-32.
✽ (*UTF8), (*UTF16) og (*UTF32) behandler strengen som en af tre specifikke UTF-kodninger.
Unicode-egenskaber for \d og \w
Som standard passer \d kun til ASCII-cifre, mens \w kun passer til ASCII-cifre, bogstaver og understregninger.
Modifikatoren (*UCP) (som står for Unicode Character Properties) gør det muligt for disse tokens at matche Unicode-cifre og ordtegn.
For eksempel (*UCP)\d+ :: \w+ passer til 1۳۲١८৮੪ :: Aれま래도ᚠᚱᚩ
(Se demo).
I kombination med (*UCP) kan det også være nødvendigt at bruge en af (*UTF)-modifikatorerne. For at se, hvordan dette fungerer, kan du se på output af dette program med en standard 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)
Line Break Modifiers
Som standard, når PCRE kompileres, fortæller du den, hvad den skal betragte som et linjeskift, når den støder på et . (som punktum passer den ikke til linjeskift, medmindre den er i dotall-tilstand), samt ^- og $-ankernes opførsel i multiline-tilstand. Du kan tilsidesætte denne standard med følgende modifikatorer:
✽ (*CR) Kun et vognrumsretur betragtes som et linjeskift
✽ (*LF) Kun et linjeskift betragtes som et linjeskift (som på Unix)
✽ (*CRLF) Kun et vognrumsretur efterfulgt af et linjeskift betragtes som et linjeskift
✽ (*LF) Kun et linjeskift betragtes som et linjeskift (som på Unix) betragtes som et linjeskift (som i Windows)
✽ (*ANYCRLF) Enhver af de tre ovenstående betragtes som et linjeskift
✽ (*ANY) Enhver Unicode newline-sekvens betragtes som et linjeskift
For eksempel, (*CR)\w+.\w+ passer til Line1\nLine2, fordi prikken kan passe til \n, som ikke betragtes som et linjeskift. Se demo.
Kontrol af \R
Som standard passer metategnet \R til enhver Unicode newline-sekvens. Når UTF-8-tilstand er slået fra, er disse newline-sekvenser parret \r\n samt vogn retur, linjefod, lodret tabulator, formfeed eller næste linje-tegn. I UTF-8-tilstand passer tokenet også til linjeadskilleren og paragrafadskilleren.
Med to start-of-pattern-modifikatorer kan du ændre \R’s adfærd:
✽ Med (*BSR_ANYCRLF) passer \R kun til \r\n-sekvensen \r\n, \r eller \n. Dette kan også indstilles, når PCRE kompileres eller anmodes om via indstillingen PCRE_BSR_ANYCRLF
✽ Med (*BSR_UNICODE) passer \R til enhver Unicode newline-sekvens (og tilsidesætter indstillingen PCRE_BSR_ANYCRLF, hvis den er indstillet). Dette kan også indstilles, når PCRE kompileres eller anmodes om via indstillingen PCRE_BSR_UNICODE
Kontrol af løbsk mønstre
For at begrænse antallet af gange, PCRE kalder funktionen match(), skal du bruge modificatoren (*LIMIT_MATCH=x) og indstille x til det ønskede antal.
For at begrænse rekursion skal du bruge (*LIMIT_RECURSION=d), idet du indstiller d til det dybeste tilladte rekursionsniveau.
Afbrydelse af optimeringer
(direkte link)
Som standard undersøger PCRE mønstret og gør automatisk et kvantificeret token atomisk, når det følgende token er uforeneligt – for eksempel ved at gøre A+X til A++X. Modifikatoren (*NO_AUTO_POSSESS) deaktiverer denne optimering. Brug dette, når du vil bruge pcretest til at benchmarke to mønstre og få dig selv til at føle dig godt tilpas over alle de cyklusser, som auto-possessificering sparer dig.
Som standard udfører PCRE flere optimeringer for hurtigere at finde ud af, om et match vil mislykkes. Modifikatoren (*NO_START_OPT) deaktiverer disse optimeringer.
Disabling Empty Matches
I PCRE2 fortæller (*NOTEMPTY) motoren, at den ikke skal returnere tomme matches. På samme måde fortæller (*NOTEMPTY_ATSTART) motoren, at den ikke skal returnere tomme match, der findes i starten af emnet.
Disabling Automatic Anchoring Optimization
I PCRE2 fortæller PCRE2_NO_DOTSTAR_ANCHOR motoren, at den ikke automatisk skal forankre mønstre, der starter med .*
Du kan læse mere om dette flag på PCRE2 API-siden (søg efter PCRE2_NO_DOTSTAR_ANCHOR).
og The Best Regex Trick Ever!!!
De 1001 måder at bruge Regex på