Szerkezetek csoportosítása reguláris kifejezésekben
A csoportosítási szerkezetek egy reguláris kifejezés alkifejezéseit rendezik, és rögzítik a bemeneti sztringek részsztringeit. A csoportosítási szerkezetekkel a következőket teheti:
- Egyezik a bemeneti sztringben ismétlődő alexpresszióval.
- Kvantáló alkalmazása olyan alexpresszióra, amely több reguláris kifejezésnyelvi elemmel rendelkezik. A kvantátorokról további információt a Quantifiers című témakörben talál.
- Adjon meg egy alkifejezést a sztringben, amelyet a Regex.Replace metódusok adnak Match.Result vissza.
- Kérje le az egyes alkifejezéseket a Match.Groups tulajdonságból, és dolgozza fel őket külön a megfeleltetett szöveg egészétől.
Az alábbi táblázat a .NET reguláris kifejezésmotor által támogatott csoportosítási szerkezeteket sorolja fel, és jelzi, hogy rögzítenek vagy nem foglalnak-e le.
| Csoportosítási szerkezet | Rögzítés vagy le nem foglalás |
|---|---|
| Megfeleltethető alkifejezések | Elfog |
| Elnevezett egyező alkifejezések | Elfog |
| Csoportdefiníciók kiegyensúlyozása | Elfog |
| Nem foglalható csoportok | Le nem foglalható |
| Csoportbeállítások | Le nem foglalható |
| Nulla szélességű pozitív lookahead-állítások | Le nem foglalható |
| Nullaszélességű negatív lookahead-állítások | Le nem foglalható |
| Nulla szélességű pozitív lookbehind-állítások | Le nem foglalható |
| Nulla szélességű negatív lookbehind-állítások | Le nem foglalható |
| Atomi csoportok | Le nem foglalható |
A csoportokról és a reguláris kifejezésobjektum-modellről további információt a Csoportosítási szerkezetek és a reguláris kifejezésobjektumok című témakörben talál.
Megfeleltethető alkifejezések
A következő csoportosítási szerkezet egy egyeztetett alexpressziót rögzít:
(subexpression)
Itt az alexpresszió bármely érvényes reguláris kifejezési minta. A zárójeleket használó rögzítéseket a rendszer automatikusan megszámozza balról jobbra a reguláris kifejezés nyitó zárójeleinek sorrendje alapján, 1-től kezdve. A névvel ellátott rögzítési csoportok azonban mindig az utolsó sorrendben vannak rendezve, a nem elnevezett rögzítési csoportok után. A 0 számozott rögzítés a teljes reguláris kifejezésmintával egyező szöveg.
Feljegyzés
Alapértelmezés szerint a (szubexpressziós) nyelvi elem rögzíti a megfeleltetett alexpressziót. Ha azonban egy RegexOptions reguláris kifejezésminta-egyeztetési módszer paramétere tartalmazza a RegexOptions.ExplicitCapture jelölőt, vagy ha a n beállítás erre az alkifejezésre van alkalmazva (lásd a cikk későbbi, csoportbeállításait ), a rendszer nem rögzíti a megfeleltetett alkifejezést.
A rögzített csoportokat négy módon érheti el:
Használja a háttérszerkezetet a reguláris kifejezésen belül. A megfeleltetett alexpresszióra ugyanabban a reguláris kifejezésben hivatkozik a szintaxis
\számával, ahol a szám a rögzített alexpresszió sorszáma.A névvel ellátott háttérszerkezettel a reguláris kifejezésen belül. A megfeleltetett alkifejezésre ugyanabban a reguláris kifejezésben hivatkozik a szintaxis
\k<nevével>, ahol a név egy rögzítési csoport neve, vagy\k<szám>, ahol a szám egy rögzítési csoport sorszáma. A rögzítési csoport alapértelmezett neve megegyezik a sorszámával. További információ: Elnevezett egyeztetésű alkifejezések a jelen témakör későbbi részében.Ha a
$számcserét egy vagy Match.Result több Regex.Replace metódushívásban használja, ahol a szám a rögzített részexpresszió sorszáma.Programozott módon, a GroupCollection tulajdonság által Match.Groups visszaadott objektum használatával. A gyűjtemény nulla pozíciójában lévő tag a teljes reguláris kifejezésegyezést jelöli. Minden további tag egy megfeleltetett alexpressziót jelöl. További információ: Csoportosítási szerkezetek és reguláris kifejezésobjektumok szakasz.
Az alábbi példa egy olyan reguláris kifejezést mutat be, amely ismétlődő szavakat azonosít a szövegben. A reguláris kifejezésminta két rögzítési csoportja a duplikált szó két példányát jelöli. A második példány a bemeneti sztring kezdőpozíciójának jelentéséhez lesz rögzítve.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\w+)\s(\1)\W";
string input = "He said that that was the the correct answer.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.",
match.Groups[1].Value, match.Groups[1].Index, match.Groups[2].Index);
}
}
// The example displays the following output:
// Duplicate 'that' found at positions 8 and 13.
// Duplicate 'the' found at positions 22 and 26.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\w+)\s(\1)\W"
Dim input As String = "He said that that was the the correct answer."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
Next
End Sub
End Module
' The example displays the following output:
' Duplicate 'that' found at positions 8 and 13.
' Duplicate 'the' found at positions 22 and 26.
A reguláris kifejezésminta a következő:
(\w+)\s(\1)\W
Az alábbi táblázat bemutatja, hogyan értelmezi a reguláris kifejezésmintát.
| Minta | Leírás |
|---|---|
(\w+) |
Egy vagy több szó karakterének egyeztetése. Ez az első rögzítési csoport. |
\s |
Egyezik egy szóköz karakterrel. |
(\1) |
Egyezzen az első rögzített csoportban lévő sztringgel. Ez a második rögzítési csoport. A példa egy rögzített csoporthoz rendeli, hogy az ismétlődő szó kezdőpozíciója lekérhető legyen a Match.Index tulajdonságból. |
\W |
Egyezik egy nem szóból álló karakterrel, beleértve a szóközt és az írásjelet. Ez megakadályozza, hogy a reguláris kifejezésminta egyezik az első rögzített csoportból származó szóval kezdődő szavakkal. |
Elnevezett egyező alkifejezések
A következő csoportosítási szerkezet rögzíti a megfeleltethető alexpressziót, és lehetővé teszi a név vagy szám szerinti hozzáférést:
(?<name>subexpression)
vagy:
(?'name'subexpression)
Itt a név egy érvényes csoportnév, a részexpresszió pedig bármely érvényes reguláris kifejezési minta. a név nem tartalmazhat írásjeleket, és nem kezdődhet számmal.
Feljegyzés
Ha egy RegexOptions reguláris kifejezésminta-egyeztetési módszer paramétere tartalmazza a RegexOptions.ExplicitCapture jelölőt, vagy ha a n beállítás erre az alkifejezésre van alkalmazva (lásd a témakör későbbi részében a Csoportbeállításokat ), az alkifejezések rögzítésének egyetlen módja a csoportok explicit elnevezése.
Az elnevezett rögzített csoportokat a következő módokon érheti el:
A névvel ellátott háttérszerkezettel a reguláris kifejezésen belül. A megfeleltetett alexpresszióra ugyanabban a reguláris kifejezésben hivatkozik a szintaxis
\k<nevével>, ahol a név a rögzített alkifejezés neve.Használja a háttérszerkezetet a reguláris kifejezésen belül. A megfeleltetett alexpresszióra ugyanabban a reguláris kifejezésben hivatkozik a szintaxis
\számával, ahol a szám a rögzített alexpresszió sorszáma. Az elnevezett egyező alexpressziókat a rendszer egymás után, balról jobbra számozza.Ha a
${névhelyettesítő}sorozatot használja egy vagy Match.Result egy Regex.Replace metódushívásban, ahol a név a rögzített alkifejezés neve.Ha a
$számcserét egy vagy Match.Result több Regex.Replace metódushívásban használja, ahol a szám a rögzített részexpresszió sorszáma.Programozott módon, a GroupCollection tulajdonság által Match.Groups visszaadott objektum használatával. A gyűjtemény nulla pozíciójában lévő tag a teljes reguláris kifejezésegyezést jelöli. Minden további tag egy megfeleltetett alexpressziót jelöl. Az elnevezett rögzített csoportok a számozott rögzített csoportok után tárolódnak a gyűjteményben.
Programozott módon az objektum indexelőjének (C#-ban) vagy tulajdonságának Item[] (a Visual Basicben) adja meg a GroupCollection szubexpresszió nevét.
Egy egyszerű reguláris kifejezésminta bemutatja, hogy a számozott (névtelen) és az elnevezett csoportok hogyan hivatkozhatók programozott módon vagy normál kifejezésnyelvi szintaxissal. A reguláris kifejezés ((?<One>abc)\d+)?(?<Two>xyz)(.*) a következő rögzítési csoportokat hozza létre szám és név szerint. Az első rögzítési csoport (0- szám) mindig a teljes mintára vonatkozik. (A névvel ellátott csoportok mindig utoljára vannak rendezve.)
| Szám | Név | Minta |
|---|---|---|
| 0 | 0 (alapértelmezett név) | ((?<One>abc)\d+)?(?<Two>xyz)(.*) |
| 0 | 1 (alapértelmezett név) | ((?<One>abc)\d+) |
| 2 | 2 (alapértelmezett név) | (.*) |
| 3 | Eggyel | (?<One>abc) |
| 4 | Kettővel | (?<Two>xyz) |
Az alábbi példa egy olyan reguláris kifejezést mutat be, amely azonosítja a duplikált szavakat, és azt a szót, amely azonnal követi az egyes duplikált szavakat. A reguláris kifejezésminta két elnevezett alkifejezést határoz meg: duplicateWorda duplikált szót, a nextWordduplikált szót pedig az ismétlődő szót követő szót.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
string input = "He said that that was the the correct answer.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.",
match.Groups["duplicateWord"].Value, match.Groups["duplicateWord"].Index,
match.Groups["nextWord"].Value);
}
}
// The example displays the following output:
// A duplicate 'that' at position 8 is followed by 'was'.
// A duplicate 'the' at position 22 is followed by 'correct'.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
Dim input As String = "He said that that was the the correct answer."
Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
match.Groups("nextWord").Value)
Next
End Sub
End Module
' The example displays the following output:
' A duplicate 'that' at position 8 is followed by 'was'.
' A duplicate 'the' at position 22 is followed by 'correct'.
A reguláris kifejezésminta a következő:
(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)
Az alábbi táblázat a reguláris kifejezés értelmezését mutatja be.
| Minta | Leírás |
|---|---|
(?<duplicateWord>\w+) |
Egy vagy több szó karakterének egyeztetése. Nevezze el ezt a rögzítési csoportot duplicateWord. |
\s |
Egyezik egy szóköz karakterrel. |
\k<duplicateWord> |
Egyezzen a rögzített csoport által elnevezett sztringgel duplicateWord. |
\W |
Egyezik egy nem szóból álló karakterrel, beleértve a szóközt és az írásjelet. Ez megakadályozza, hogy a reguláris kifejezésminta egyezik az első rögzített csoportból származó szóval kezdődő szavakkal. |
(?<nextWord>\w+) |
Egy vagy több szó karakterének egyeztetése. Nevezze el ezt a rögzítési csoportot nextWord. |
A csoportnevek egy reguláris kifejezésben megismételhetők. Előfordulhat például, hogy egynél több csoportot is elneveznek digit, ahogy az alábbi példa is mutatja. Ismétlődő nevek esetén az objektum értékét a Group bemeneti sztring utolsó sikeres rögzítése határozza meg. Emellett a rendszer az CaptureCollection egyes rögzítésekkel kapcsolatos információkat is feltölti, ahogyan az is lenne, ha a csoport neve nem duplikálva lenne.
Az alábbi példában a reguláris kifejezés \D+(?<digit>\d+)\D+(?<digit>\d+)? egy nevű digitcsoport két előfordulását tartalmazza. Az első digit elnevezett csoport egy vagy több számjegy karaktert rögzít. A második digit elnevezett csoport egy vagy több számjegy karakterének nulla vagy egy előfordulását rögzíti. Ahogy a példa kimenete is mutatja, ha a második rögzítési csoport sikeresen megfelel a szövegnek, a szöveg értéke határozza meg az Group objektum értékét. Ha a második rögzítési csoport nem egyezik a bemeneti sztringgel, az utolsó sikeres egyezés értéke határozza meg az Group objektum értékét.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
String pattern = @"\D+(?<digit>\d+)\D+(?<digit>\d+)?";
String[] inputs = { "abc123def456", "abc123def" };
foreach (var input in inputs) {
Match m = Regex.Match(input, pattern);
if (m.Success) {
Console.WriteLine("Match: {0}", m.Value);
for (int grpCtr = 1; grpCtr < m.Groups.Count; grpCtr++) {
Group grp = m.Groups[grpCtr];
Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value);
for (int capCtr = 0; capCtr < grp.Captures.Count; capCtr++)
Console.WriteLine(" Capture {0}: {1}", capCtr,
grp.Captures[capCtr].Value);
}
}
else {
Console.WriteLine("The match failed.");
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// Match: abc123def456
// Group 1: 456
// Capture 0: 123
// Capture 1: 456
//
// Match: abc123def
// Group 1: 123
// Capture 0: 123
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\D+(?<digit>\d+)\D+(?<digit>\d+)?"
Dim inputs() As String = {"abc123def456", "abc123def"}
For Each input As String In inputs
Dim m As Match = Regex.Match(input, pattern)
If m.Success Then
Console.WriteLine("Match: {0}", m.Value)
For grpCtr As Integer = 1 to m.Groups.Count - 1
Dim grp As Group = m.Groups(grpCtr)
Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value)
For capCtr As Integer = 0 To grp.Captures.Count - 1
Console.WriteLine(" Capture {0}: {1}", capCtr,
grp.Captures(capCtr).Value)
Next
Next
Else
Console.WriteLine("The match failed.")
End If
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Match: abc123def456
' Group 1: 456
' Capture 0: 123
' Capture 1: 456
'
' Match: abc123def
' Group 1: 123
' Capture 0: 123
Az alábbi táblázat a reguláris kifejezés értelmezését mutatja be.
| Minta | Leírás |
|---|---|
\D+ |
Egy vagy több nem tizedesjegy karakterének egyeztetése. |
(?<digit>\d+) |
Egy vagy több tizedesjegy karakterének egyeztetése. Rendelje hozzá az egyezést a digit névvel ellátott csoporthoz. |
\D+ |
Egy vagy több nem tizedesjegy karakterének egyeztetése. |
(?<digit>\d+)? |
Egy vagy több tizedesjegy karakterének nullával vagy egy előfordulásával egyezik. Rendelje hozzá az egyezést a digit névvel ellátott csoporthoz. |
Csoportdefiníciók kiegyensúlyozása
A kiegyensúlyozó csoport definíciója törli egy korábban definiált csoport definícióját, és az aktuális csoportban tárolja a korábban definiált csoport és az aktuális csoport közötti intervallumot. A csoportosítási szerkezet formátuma a következő:
(?<name1-name2>subexpression)
vagy:
(?'name1-name2' subexpression)
Itt a név1 az aktuális csoport (nem kötelező), a name2 egy korábban definiált csoport, a subexpression pedig bármely érvényes reguláris kifejezési minta. A kiegyensúlyozó csoport definíciója törli a név2 definícióját, és a név2 és a név1 közötti intervallumot a név1 névben tárolja. Ha nincs definiálva név2 csoport, akkor a visszakövetések egyeznek. Mivel a név2 utolsó definíciójának törlése felfedi a név2 előző definícióját, ez a szerkezet lehetővé teszi, hogy a csoportnév2 rögzítési halomját számlálóként használja a beágyazott szerkezetek, például zárójelek vagy nyitó és záró zárójelek nyomon követéséhez.
A kiegyensúlyozási csoport definíciója a név2 nevet használja veremként. Az egyes beágyazott szerkezetek kezdő karaktere a csoportba és a gyűjteménybe Group.Captures kerül. A záró karakter egyeztetésekor a megfelelő nyitó karakter el lesz távolítva a csoportból, és a Captures gyűjtemény egyel csökken. A beágyazott szerkezetek nyitó és záró karaktereinek egyeztetése után a 2 . név üres.
Feljegyzés
Miután módosította a reguláris kifejezést a következő példában egy beágyazott szerkezet megfelelő nyitó és záró karakterének használatára, a legtöbb beágyazott szerkezetet, például matematikai kifejezéseket vagy több beágyazott metódushívást tartalmazó programkódsorok kezelésére használhatja.
Az alábbi példa egy kiegyensúlyozó csoportdefiníciót használ a bemeneti sztring bal és jobb szögletes zárójeleinek (<>) egyeztetéséhez. A példa két elnevezett csoportot határoz meg, Open amelyeket Closeveremként használnak a szögletes zárójelek egyező párjainak nyomon követéséhez. A rendszer minden rögzített bal szögletes zárójelet a csoport rögzítési gyűjteményébe Open küld, és minden rögzített derékszögű szögletes zárójel a csoport rögzítési gyűjteményébe Close kerül. A kiegyensúlyozási csoport definíciója biztosítja, hogy az egyes bal szögletes zárójelekhez megfelelő szögletes zárójel legyen. Ha nincs, a végső alpatter csak akkor lesz kiértékelve, (?(Open)(?!))ha a Open csoport nem üres (és ezért ha az összes beágyazott szerkezet nem lett bezárva). Ha a végső allap kiértékelése történik, az egyezés meghiúsul, mert az (?!) alpattern egy nulla szélességű negatív lookahead-állítás, amely mindig meghiúsul.
using System;
using System.Text.RegularExpressions;
class Example
{
public static void Main()
{
string pattern = "^[^<>]*" +
"(" +
"((?'Open'<)[^<>]*)+" +
"((?'Close-Open'>)[^<>]*)+" +
")*" +
"(?(Open)(?!))$";
string input = "<abc><mno<xyz>>";
Match m = Regex.Match(input, pattern);
if (m.Success == true)
{
Console.WriteLine("Input: \"{0}\" \nMatch: \"{1}\"", input, m);
int grpCtr = 0;
foreach (Group grp in m.Groups)
{
Console.WriteLine(" Group {0}: {1}", grpCtr, grp.Value);
grpCtr++;
int capCtr = 0;
foreach (Capture cap in grp.Captures)
{
Console.WriteLine(" Capture {0}: {1}", capCtr, cap.Value);
capCtr++;
}
}
}
else
{
Console.WriteLine("Match failed.");
}
}
}
// The example displays the following output:
// Input: "<abc><mno<xyz>>"
// Match: "<abc><mno<xyz>>"
// Group 0: <abc><mno<xyz>>
// Capture 0: <abc><mno<xyz>>
// Group 1: <mno<xyz>>
// Capture 0: <abc>
// Capture 1: <mno<xyz>>
// Group 2: <xyz
// Capture 0: <abc
// Capture 1: <mno
// Capture 2: <xyz
// Group 3: >
// Capture 0: >
// Capture 1: >
// Capture 2: >
// Group 4:
// Group 5: mno<xyz>
// Capture 0: abc
// Capture 1: xyz
// Capture 2: mno<xyz>
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^[^<>]*" & _
"(" + "((?'Open'<)[^<>]*)+" & _
"((?'Close-Open'>)[^<>]*)+" + ")*" & _
"(?(Open)(?!))$"
Dim input As String = "<abc><mno<xyz>>"
Dim rgx AS New Regex(pattern) '
Dim m As Match = Regex.Match(input, pattern)
If m.Success Then
Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
input, m)
Dim grpCtr As Integer = 0
For Each grp As Group In m.Groups
Console.WriteLine(" Group {0}: {1}", grpCtr, grp.Value)
grpCtr += 1
Dim capCtr As Integer = 0
For Each cap As Capture In grp.Captures
Console.WriteLine(" Capture {0}: {1}", capCtr, cap.Value)
capCtr += 1
Next
Next
Else
Console.WriteLine("Match failed.")
End If
End Sub
End Module
' The example displays the following output:
' Input: "<abc><mno<xyz>>"
' Match: "<abc><mno<xyz>>"
' Group 0: <abc><mno<xyz>>
' Capture 0: <abc><mno<xyz>>
' Group 1: <mno<xyz>>
' Capture 0: <abc>
' Capture 1: <mno<xyz>>
' Group 2: <xyz
' Capture 0: <abc
' Capture 1: <mno
' Capture 2: <xyz
' Group 3: >
' Capture 0: >
' Capture 1: >
' Capture 2: >
' Group 4:
' Group 5: mno<xyz>
' Capture 0: abc
' Capture 1: xyz
' Capture 2: mno<xyz>
A reguláris kifejezésminta a következő:
^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$
A reguláris kifejezés értelmezése a következő:
| Minta | Leírás |
|---|---|
^ |
Kezdje a sztring elején. |
[^<>]* |
Nulla vagy több, nem bal vagy jobb szögben szögletes zárójelben szereplő karakternek felel meg. |
(?'Open'<) |
Egy bal oldali szögletes zárójel egyeztetése és hozzárendelése egy nevű Opencsoporthoz. |
[^<>]* |
Nulla vagy több, nem bal vagy jobb szögben szögletes zárójelben szereplő karakternek felel meg. |
((?'Open'<)[^<>]*)+ |
Egy bal oldali szögletes zárójel egy vagy több előfordulásának egyezése, amelyet nulla vagy több olyan karakter követ, amely nem bal vagy jobb szögletes zárójel. Ez a második rögzítési csoport. |
(?'Close-Open'>) |
Egyezzen egy szögletes zárójelben, rendelje hozzá a Open csoport és az aktuális csoport közötti részszúrást a Close csoporthoz, és törölje a Open csoport definícióját. |
[^<>]* |
Egyezik a bal és a derékszögű szögletes zárójelet nem tartalmazó karakterek nullával vagy több előfordulásával. |
((?'Close-Open'>)[^<>]*)+ |
Egy szögletes zárójel egy vagy több előfordulásának egyezése, amelyet egy vagy több olyan karakter nulla vagy több előfordulása követ, amely nem bal vagy jobb szögletes zárójel. A szögletes zárójel egyeztetésekor rendelje hozzá a csoport és az aktuális csoport közötti Open részszúrást a Close csoporthoz, és törölje a Open csoport definícióját. Ez a harmadik rögzítési csoport. |
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* |
A következő minta nulla vagy több előfordulásának egyezése: egy bal szögletes zárójel egy vagy több előfordulása, amelyet nulla vagy több nem szögletes zárójel karakter követ, majd egy vagy több előfordulása a szögletes zárójelben, majd a nem szögletes zárójelek nulla vagy több előfordulása. A szögletes zárójel megfeleltetésekor törölje a Open csoport definícióját, és rendelje hozzá a csoport és az aktuális csoport közötti Open részszűrést a Close csoporthoz. Ez az első rögzítési csoport. |
(?(Open)(?!)) |
Ha a Open csoport létezik, hagyja abba az egyezést, ha egy üres sztring megfeleltethető, de ne lépje túl a normál kifejezésmotor pozícióját a sztringben. Ez egy nullaszélességű negatív lookahead-állítás. Mivel egy üres sztring mindig implicit módon jelen van egy bemeneti sztringben, ez az egyezés mindig meghiúsul. Ennek az egyezésnek a hibája azt jelzi, hogy a szögletes zárójelek nem kiegyensúlyozottak. |
$ |
Egyezzen a bemeneti sztring végére. |
Az utolsó alexpresszió azt jelzi, (?(Open)(?!))hogy a bemeneti sztringben lévő beágyazási szerkezetek megfelelően vannak-e kiegyensúlyozottak (például azt, hogy az egyes bal szögletes zárójelek egy-egy szögletes zárójelben vannak-e megfeleltetve). Feltételes egyeztetést használ egy érvényes rögzített csoport alapján; további információ: Alternation Constructs. Ha a Open csoport definiálva van, a reguláris kifejezésmotor megkísérli egyezni a bemeneti sztringben lévő alexpresszióval (?!) . A Open csoportot csak akkor szabad definiálni, ha a beágyazott szerkezetek kiegyensúlyozatlanok. Ezért a bemeneti sztringben egyeztetendő mintának olyannak kell lennie, amely mindig az egyezés meghiúsulását okozza. Ebben az esetben (?!) egy nullaszélességű negatív lookahead-állítás, amely mindig meghiúsul, mivel egy üres sztring mindig implicit módon jelen van a bemeneti sztring következő helyén.
A példában a reguláris kifejezésmotor kiértékeli az "<abc><mno<xyz>>" bemeneti sztringet az alábbi táblázatban látható módon.
| Lépés | Minta | Eredmény |
|---|---|---|
| 0 | ^ |
Az egyezés indítása a bemeneti sztring elején |
| 2 | [^<>]* |
Nem szögletes zárójel karaktereket keres a bal oldali szögletes zárójel előtt; nem talál egyezést. |
| 3 | (((?'Open'<) |
Egyezik az "<abc>" bal oldali szögletes zárójelével, és hozzárendeli a Open csoporthoz. |
| 4 | [^<>]* |
Egyezik az "abc"-vel. |
| 5 | )+ |
Az "<abc" a második rögzített csoport értéke. A bemeneti sztring következő karaktere nem bal szögletes zárójel, így a reguláris kifejezésmotor nem hurkol vissza az (?'Open'<)[^<>]*) allapra. |
| 6 | ((?'Close-Open'>) |
Egyezik az "<abc>" szögletes zárójelével, hozzárendeli az "abc"-t, amely a csoport és a derékszögű szögletes zárójel közötti Open részszúrás a csoporthozClose, és törli a Open csoport aktuális értékét ("<") üresen hagyva. |
| 7 | [^<>]* |
Nem szögletes zárójel karaktereket keres a szögletes zárójel után; nem talál egyezést. |
| 8 | )+ |
A harmadik rögzített csoport értéke ">". A bemeneti sztring következő karaktere nem szögletes zárójel, így a normál kifejezésmotor nem hurkol vissza az ((?'Close-Open'>)[^<>]*) allapra. |
| 9 | )* |
Az első rögzített csoport értéke az "<abc>". A bemeneti sztring következő karaktere egy bal oldali szögletes zárójel, így a reguláris kifejezésmotor visszacsukódik az (((?'Open'<) allapra. |
| 10 | (((?'Open'<) |
Egyezik az "<mno" bal szögletes zárójelével, és hozzárendeli a Open csoporthoz. Gyűjteményének Group.Captures most egyetlen értéke van: "<". |
| 11 | [^<>]* |
Egyezik az "mno"-ra. |
| 12 | )+ |
Az "<mno" a második rögzített csoport értéke. A bemeneti sztring következő karaktere egy bal oldali szögletes zárójel, így a reguláris kifejezésmotor visszalép az (?'Open'<)[^<>]*) alhálózatra. |
| 13 | (((?'Open'<) |
Egyezik a bal oldali szögletes zárójelmel a "<xyz>" fájlban, és hozzárendeli a Open csoporthoz. A Group.Captures csoport gyűjteménye Open most két rögzítést tartalmaz: a bal szögletes zárójelet az "<mno"-ból, a bal szögletes zárójelet pedig a "<xyz>"-ből. |
| 14 | [^<>]* |
Egyezik a "xyz" értékkel. |
| 15 | )+ |
A "<xyz" a második rögzített csoport értéke. A bemeneti sztring következő karaktere nem bal szögletes zárójel, így a reguláris kifejezésmotor nem hurkol vissza az (?'Open'<)[^<>]*) allapra. |
| 16 | ((?'Close-Open'>) |
Megfelel a "xyz>" szögletes zárójelének<. "xyz", hozzárendeli a csoport és a derékszögű szögletes zárójel közötti Open részsztringet a Close csoporthoz, és törli a Open csoport aktuális értékét. Az előző rögzítés értéke (az "<mno" bal szögletes zárójele) lesz a Open csoport aktuális értéke. A Captures csoport gyűjteménye Open mostantól egyetlen rögzítést tartalmaz, a bal oldali szögletes zárójelet a "<xyz>"-ből. |
| 17 | [^<>]* |
Nem szögletes zárójel karaktereket keres; nem talál egyezést. |
| 18 | )+ |
A harmadik rögzített csoport értéke ">". A bemeneti sztring következő karaktere egy derékszögű szögletes zárójel, így a reguláris kifejezésmotor visszalép az ((?'Close-Open'>)[^<>]*) alhálózatra. |
| 19 | ((?'Close-Open'>) |
Megfelel a "xyz>>" utolsó szögletes zárójelének, hozzárendeli az "mno<xyz>" (a csoport és a szögletes zárójel közötti Open részszúrást) a Close csoporthoz, és törli a Open csoport aktuális értékét. A Open csoport most már üres. |
| 20 | [^<>]* |
Nem szögletes zárójel karaktereket keres; nem talál egyezést. |
| 21 | )+ |
A harmadik rögzített csoport értéke ">". A bemeneti sztring következő karaktere nem szögletes zárójel, így a normál kifejezésmotor nem hurkol vissza az ((?'Close-Open'>)[^<>]*) allapra. |
| 22 | )* |
Az első rögzített csoport értéke az "<mno<xyz>>". A bemeneti sztring következő karaktere nem bal szögletes zárójel, így a reguláris kifejezésmotor nem hurkol vissza az (((?'Open'<) allapra. |
| 23 | (?(Open)(?!)) |
A Open csoport nincs definiálva, ezért a rendszer nem kísérel meg egyezést. |
| 24 | $ |
Megfelel a bemeneti sztring végének. |
Nem foglalható csoportok
A következő csoportosítási szerkezet nem rögzíti a szubexpresszióval egyeztetett részszűrést:
(?:subexpression)
Itt az alexpresszió bármely érvényes reguláris kifejezési minta. A nem cselekvő csoportszerkezetet általában akkor használják, ha egy kvantitálót alkalmaz egy csoportra, de a csoport által rögzített részszűrések nem érdeklik.
Feljegyzés
Ha egy reguláris kifejezés beágyazott csoportosítási szerkezeteket tartalmaz, a külső, nem összefoglalt csoportszerkezetek nem vonatkoznak a belső beágyazott csoportszerkezetekre.
Az alábbi példa egy olyan reguláris kifejezést mutat be, amely nem foglalt csoportokat tartalmaz. Vegye figyelembe, hogy a kimenet nem tartalmaz rögzített csoportokat.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(?:\b(?:\w+)\W*)+\.";
string input = "This is a short sentence.";
Match match = Regex.Match(input, pattern);
Console.WriteLine("Match: {0}", match.Value);
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
Console.WriteLine(" Group {0}: {1}", ctr, match.Groups[ctr].Value);
}
}
// The example displays the following output:
// Match: This is a short sentence.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
Dim input As String = "This is a short sentence."
Dim match As Match = Regex.Match(input, pattern)
Console.WriteLine("Match: {0}", match.Value)
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End Sub
End Module
' The example displays the following output:
' Match: This is a short sentence.
A reguláris kifejezés (?:\b(?:\w+)\W*)+\. egy ponttal végződő mondattal egyezik. Mivel a reguláris kifejezés a mondatokra összpontosít, és nem az egyes szavakra, a csoportosítási szerkezetek kizárólag kvantitátorokként használhatók. A rendszer a reguláris kifejezésmintát az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
(?:\w+) |
Egy vagy több szó karakterének egyeztetése. Ne rendelje hozzá a egyeztetett szöveget rögzített csoporthoz. |
\W* |
Nulla vagy több nem szó karakter egyezése. |
(?:\b(?:\w+)\W*)+ |
Egy vagy több szókarakterek mintájának felel meg egy szóhatártól kezdődően, amelyet nulla vagy több nem szóból álló karakter követ egy vagy több alkalommal. Ne rendelje hozzá a egyeztetett szöveget rögzített csoporthoz. |
\. |
Pont egyeztetése. |
Csoportbeállítások
A következő csoportosítási szerkezet a megadott beállításokat alkalmazza vagy tiltja le egy alkifejezésen belül:
(?imnsx-imnsx:subexpression)
Itt az alexpresszió bármely érvényes reguláris kifejezési minta. Bekapcsolhatja például a kis- és nagybetűk érzéketlenségét, (?i-s:) és letiltja az egysoros módot. A megadható beágyazott beállításokról további információt a Reguláris kifejezés beállításai című témakörben talál.
Feljegyzés
Osztálykonstruktor vagy statikus metódus használatával System.Text.RegularExpressions.Regex megadhatja azokat a beállításokat, amelyek egy teljes reguláris kifejezésre vonatkoznak, nem pedig alkifejezésre. A nyelvi szerkezettel (?imnsx-imnsx) megadhatja azokat a beágyazott beállításokat is, amelyek egy reguláris kifejezés egy adott pontja után érvényesek.
A csoportbeállítások konstrukciója nem rögzítési csoport. Vagyis bár a sztringnek az alexpresszióval rögzített bármely része szerepel a találatban, nem szerepel a rögzített csoportban, és nem használja az GroupCollection objektum feltöltésére.
A következő példában szereplő reguláris kifejezés \b(?ix: d \w+)\s például beágyazott beállításokat használ egy csoportosítási szerkezetben, hogy lehetővé tegye a kis- és nagybetűk megkülönböztetését, és figyelmen kívül hagyja a minta üres területét a "d" betűvel kezdődő összes szó azonosításában. A reguláris kifejezés az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
(?ix: d \w+) |
A kis- és nagybetűk megkülönböztetése és a fehér terület figyelmen kívül hagyása ebben a mintában egyezik egy "d" karakterrel, amelyet egy vagy több szókarakter követ. |
\s |
Egyezik egy szóköz karakterrel. |
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
// 'Dogs // found at index 0.
// 'decidedly // found at index 9.
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
' 'Dogs ' found at index 0.
' 'decidedly ' found at index 9.
Nulla szélességű pozitív lookahead-állítások
A következő csoportosítási szerkezet nullaszélességű pozitív keresésifej-állítást határoz meg:
(?=subexpression)
Itt a szubexpresszió bármilyen reguláris kifejezési minta. Ahhoz, hogy egy egyezés sikeres legyen, a bemeneti sztringnek meg kell egyeznie a subexpression reguláris kifejezésmintájával, bár a megfeleltetett részsztring nem szerepel az egyezés eredményében. A nullaszélességű pozitív lookahead-állítás nem von vissza.
A normál kifejezésminta végén általában nullaszélességű pozitív lookahead-állítás található. Egy olyan részsztringet határoz meg, amelyet egy sztring végén kell megtalálni ahhoz, hogy egy egyezés létrejönjön, de ezt nem szabad belefoglalni az egyezésbe. A túlzott visszakövetés megelőzésére is hasznos. Nulla szélességű pozitív lookahead-állítással biztosíthatja, hogy egy adott rögzített csoport olyan szöveggel kezdődjön, amely megfelel az adott rögzített csoporthoz definiált minta egy részhalmazának. Ha például egy rögzítési csoport egyezik az egymást követő szókarakterekkel, nulla szélességű pozitív keresőfej-állítással megkövetelheti, hogy az első karakter betűrendes nagybetű legyen.
Az alábbi példa egy nullaszélességű pozitív keresőfej-állítással egyezik a bemeneti sztringben az "is" igét megelőző szóhoz.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\w+(?=\sis\b)";
string[] inputs = { "The dog is a Malamute.",
"The island has beautiful birds.",
"The pitch missed home plate.",
"Sunday is a weekend day." };
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine("'{0}' precedes 'is'.", match.Value);
else
Console.WriteLine("'{0}' does not match the pattern.", input);
}
}
}
// The example displays the following output:
// 'dog' precedes 'is'.
// 'The island has beautiful birds.' does not match the pattern.
// 'The pitch missed home plate.' does not match the pattern.
// 'Sunday' precedes 'is'.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\w+(?=\sis\b)"
Dim inputs() As String = {"The dog is a Malamute.", _
"The island has beautiful birds.", _
"The pitch missed home plate.", _
"Sunday is a weekend day."}
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("'{0}' precedes 'is'.", match.Value)
Else
Console.WriteLine("'{0}' does not match the pattern.", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' 'dog' precedes 'is'.
' 'The island has beautiful birds.' does not match the pattern.
' 'The pitch missed home plate.' does not match the pattern.
' 'Sunday' precedes 'is'.
A rendszer a reguláris kifejezést \b\w+(?=\sis\b) az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
\w+ |
Egy vagy több szó karakterének egyeztetése. |
(?=\sis\b) |
Állapítsa meg, hogy a szó karaktereit fehér szóköz és "is" sztring követi-e, amely egy szóhatáron végződik. Ha igen, az egyezés sikeres lesz. |
Nullaszélességű negatív lookahead-állítások
A következő csoportosítási szerkezet nullaszélességű negatív lookahead-állítást határoz meg:
(?!subexpression)
Itt a szubexpresszió bármilyen reguláris kifejezési minta. Ahhoz, hogy az egyezés sikeres legyen, a bemeneti sztring nem egyezhet meg a subexpression reguláris kifejezésmintájával, bár a megfelelt sztring nem szerepel az egyezés eredményében.
A nullaszélességű negatív lookahead-állítást általában egy reguláris kifejezés elején vagy végén használják. A reguláris kifejezés elején meghatározhat egy olyan mintát, amelyet nem szabad egyeztetni, amikor a reguláris kifejezés kezdete egy hasonló, de általánosabb, egyeztetendő mintát határoz meg. Ebben az esetben gyakran használják a visszakövetés korlátozására. A reguláris kifejezés végén definiálhat egy olyan alkifejezést, amely nem fordulhat elő egyezés végén.
Az alábbi példa egy olyan reguláris kifejezést határoz meg, amely a normál kifejezés elején nulla szélességű keresőfej-állítást használ a nem "un" kezdetű szavakkal való egyeztetéshez.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(?!un)\w+\b";
string input = "unite one unethical ethics use untie ultimate";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// one
// ethics
// use
// ultimate
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(?!un)\w+\b"
Dim input As String = "unite one unethical ethics use untie ultimate"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' one
' ethics
' use
' ultimate
A rendszer a reguláris kifejezést \b(?!un)\w+\b az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
(?!un) |
Határozza meg, hogy a következő két karakter "un" legyen-e. Ha nem, egyezés lehetséges. |
\w+ |
Egy vagy több szó karakterének egyeztetése. |
\b |
Egy szóhatáron fejezd be az egyezést. |
Az alábbi példa egy olyan reguláris kifejezést határoz meg, amely nulla szélességű keresőfej-állítást használ a reguláris kifejezés végén az írásjellel nem végződő szavak egyeztetéséhez.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\w+\b(?!\p{P})";
string input = "Disconnected, disjointed thoughts in a sentence fragment.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// disjointed
// thoughts
// in
// a
// sentence
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\w+\b(?!\p{P})"
Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' disjointed
' thoughts
' in
' a
' sentence
A rendszer a reguláris kifejezést \b\w+\b(?!\p{P}) az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
\w+ |
Egy vagy több szó karakterének egyeztetése. |
\b |
Egy szóhatáron fejezd be az egyezést. |
\p{P}) |
Ha a következő karakter nem írásjel (például pont vagy vessző), az egyezés sikeres lesz. |
Nulla szélességű pozitív lookbehind-állítások
A következő csoportosítási szerkezet nullaszélességű pozitív lookbehind-állítást határoz meg:
(?<=subexpression)
Itt a szubexpresszió bármilyen reguláris kifejezési minta. Ahhoz, hogy egy egyezés sikeres legyen, a részexpressziónak az aktuális pozíciótól balra lévő bemeneti sztringnél kell történnie, bár subexpression ez nem szerepel a találat eredményében. A nullaszélességű pozitív lookbehind-állítás nem von vissza.
A nullaszélességű pozitív lookbehind-állításokat általában a normál kifejezések elején használják. Az általuk definiált minta egy egyezés előfeltétele, bár nem része az egyezés eredményének.
Az alábbi példa például az év utolsó két számjegyét egyezteti meg a huszonegyedik században (vagyis a "20" számjegynek meg kell előznie a megfeleltethető sztringet).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "2010 1999 1861 2140 2009";
string pattern = @"(?<=\b20)\d{2}\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// 10
// 09
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "2010 1999 1861 2140 2009"
Dim pattern As String = "(?<=\b20)\d{2}\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' 10
' 09
A rendszer a reguláris kifejezésmintát (?<=\b20)\d{2}\b az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
\d{2} |
Két tizedesjegy egyeztetése. |
(?<=\b20) |
Folytassa az egyezést, ha a két tizedesjegyet a "20" tizedesjegy előzi meg egy szóhatáron. |
\b |
Egy szóhatáron fejezd be az egyezést. |
A nulla szélességű pozitív lookbehind-állítások a visszakövetés korlátozására is szolgálnak, ha a rögzített csoport utolsó karakterének vagy karaktereinek az adott csoport normál kifejezésmintájának megfelelő karakterek részhalmazának kell lenniük. Ha például egy csoport az összes egymást követő szót rögzíti, nullaszélességű pozitív lookbehind állítással megkövetelheti, hogy az utolsó karakter betűrendbe legyen állítva.
Nulla szélességű negatív lookbehind-állítások
A következő csoportosítási szerkezet nullaszélességű negatív lookbehind-állítást határoz meg:
(?<!subexpression)
Itt a szubexpresszió bármilyen reguláris kifejezési minta. Ahhoz, hogy egy egyezés sikeres legyen, a szubexpresszió nem történhet az aktuális pozíciótól balra lévő bemeneti sztringnél. A nem egyező subexpression részstringek azonban nem szerepelnek az egyezés eredményében.
A nullaszélességű negatív lookbehind-állításokat általában a normál kifejezések elején használják. Az általuk definiált minta kizárja a következő sztring egyezését. Arra is használhatók, hogy korlátozzák a visszakövetést, ha egy rögzített csoport utolsó karaktere vagy karaktere nem lehet egy vagy több olyan karakter, amely megfelel az adott csoport reguláris kifejezésmintájának. Ha például egy csoport az összes egymást követő szót rögzíti, nulla szélességű pozitív lookbehind állítással megkövetelheti, hogy az utolsó karakter ne legyen aláhúzásjel (_).
Az alábbi példa egyezik a hét bármely olyan napjának dátumával, amely nem hétvége (vagyis nem szombat vagy vasárnap).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] dates = { "Monday February 1, 2010",
"Wednesday February 3, 2010",
"Saturday February 6, 2010",
"Sunday February 7, 2010",
"Monday, February 8, 2010" };
string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";
foreach (string dateValue in dates)
{
Match match = Regex.Match(dateValue, pattern);
if (match.Success)
Console.WriteLine(match.Value);
}
}
}
// The example displays the following output:
// February 1, 2010
// February 3, 2010
// February 8, 2010
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim dates() As String = {"Monday February 1, 2010", _
"Wednesday February 3, 2010", _
"Saturday February 6, 2010", _
"Sunday February 7, 2010", _
"Monday, February 8, 2010"}
Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"
For Each dateValue As String In dates
Dim match As Match = Regex.Match(dateValue, pattern)
If match.Success Then
Console.WriteLine(match.Value)
End If
Next
End Sub
End Module
' The example displays the following output:
' February 1, 2010
' February 3, 2010
' February 8, 2010
A rendszer a reguláris kifejezésmintát (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
\w+ |
Egy vagy több szó karakterének egyezése, majd egy szóköz karakter. |
\d{1,2}, |
Egy vagy két tizedesjegyet, majd egy szóköz karaktert és egy vesszőt kell megadni. |
\d{4}\b |
Egyezzen négy tizedesjegyet, és fejezzen be egy egyezést egy szóhatáron. |
(?<!(Saturday|Sunday) ) |
Ha a mérkőzést a "Szombat" vagy a "Vasárnap" sztringen kívül egy szóköz előzi meg, a találat sikeres lesz. |
Atomi csoportok
A következő csoportosítási szerkezet egy atomcsoportot jelöl (más reguláris kifejezésmotorokban nem visszalépő alexpresszióként, atomi alexpresszióként vagy egyszeres alexpresszióként ismert):
(?>subexpression)
Itt a szubexpresszió bármilyen reguláris kifejezési minta.
Általában, ha egy reguláris kifejezés opcionális vagy alternatív egyeztetési mintát tartalmaz, és az egyezés nem sikerül, a reguláris kifejezésmotor több irányban elágazhat, hogy egy bemeneti sztringet mintával egyezzen. Ha nem található egyezés az első ág felvételekor, a reguláris kifejezésmotor biztonsági másolatot készíthet vagy visszaléptethet arra a pontra, ahol az első egyezést alkalmazta, és a második ág használatával próbálja meg az egyezést. Ez a folyamat az összes ág kipróbálásáig folytatódhat.
A (?>szubexpressziós) nyelvi szerkezet letiltja a visszakövetést. A normál kifejezésmotor annyi karaktert fog egyezni a bemeneti sztringben, amennyit csak tud. Ha nincs lehetőség további egyezésre, nem kísérel meg alternatív mintaegyezéseket kísérelni. (Ez azt jelenti, hogy a szubexpresszió csak azokat a sztringeket egyezteti meg, amelyeket a szubexpresszió önmagában is megfeleltetne; nem próbálja meg egyezni a sztringet az alexpresszió és az azt követő alexpressziók alapján.)
Ez a beállítás akkor ajánlott, ha tudja, hogy a visszakövetés nem fog sikerülni. A normál kifejezésmotor szükségtelen keresésének megakadályozása javítja a teljesítményt.
Az alábbi példa bemutatja, hogyan módosítja egy atomcsoport egy mintaegyezés eredményét. A visszakövetési reguláris kifejezés sikeresen megfelel az ismétlődő karakterek sorozatának, majd egy újabb előfordulása ugyanazon karakternek egy szóhatáron, de a vissza nem térő reguláris kifejezés nem.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "cccd.", "aaad", "aaaa" };
string back = @"(\w)\1+.\b";
string noback = @"(?>(\w)\1+).\b";
foreach (string input in inputs)
{
Match match1 = Regex.Match(input, back);
Match match2 = Regex.Match(input, noback);
Console.WriteLine("{0}: ", input);
Console.Write(" Backtracking : ");
if (match1.Success)
Console.WriteLine(match1.Value);
else
Console.WriteLine("No match");
Console.Write(" Nonbacktracking: ");
if (match2.Success)
Console.WriteLine(match2.Value);
else
Console.WriteLine("No match");
}
}
}
// The example displays the following output:
// cccd.:
// Backtracking : cccd
// Nonbacktracking: cccd
// aaad:
// Backtracking : aaad
// Nonbacktracking: aaad
// aaaa:
// Backtracking : aaaa
// Nonbacktracking: No match
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = {"cccd.", "aaad", "aaaa"}
Dim back As String = "(\w)\1+.\b"
Dim noback As String = "(?>(\w)\1+).\b"
For Each input As String In inputs
Dim match1 As Match = Regex.Match(input, back)
Dim match2 As Match = Regex.Match(input, noback)
Console.WriteLine("{0}: ", input)
Console.Write(" Backtracking : ")
If match1.Success Then
Console.WriteLine(match1.Value)
Else
Console.WriteLine("No match")
End If
Console.Write(" Nonbacktracking: ")
If match2.Success Then
Console.WriteLine(match2.Value)
Else
Console.WriteLine("No match")
End If
Next
End Sub
End Module
' The example displays the following output:
' cccd.:
' Backtracking : cccd
' Nonbacktracking: cccd
' aaad:
' Backtracking : aaad
' Nonbacktracking: aaad
' aaaa:
' Backtracking : aaaa
' Nonbacktracking: No match
A vissza nem vont reguláris kifejezés (?>(\w)\1+).\b az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
(\w) |
Egyezik egy szó karakterrel, és rendelje hozzá az első rögzítési csoporthoz. |
\1+ |
Egyezik az első rögzített részszúrás értékével egy vagy több alkalommal. |
. |
Bármely karakternek megfelelő. |
\b |
Egy szóhatáron fejezd be az egyezést. |
(?>(\w)\1+) |
Egy duplikált szó karakter egy vagy több előfordulásának egyezése, de ne térjen vissza az utolsó karakterhez egy szóhatáron. |
Szerkezetek és reguláris kifejezésobjektumok csoportosítása
A reguláris kifejezésrögzítési csoporttal egyeztetett részszúrásokat objektumok jelölik System.Text.RegularExpressions.Group , amelyek a System.Text.RegularExpressions.GroupCollection tulajdonság által Match.Groups visszaadott objektumból kérhetők le. Az GroupCollection objektum a következőképpen lesz feltöltve:
- A gyűjtemény első Group objektuma (a nulla indexnél lévő objektum) a teljes egyezést jelöli.
- A következő objektumkészlet névtelen (számozott) rögzítési Group csoportokat jelöl. A reguláris kifejezésben definiált sorrendben jelennek meg balról jobbra. Ezeknek a csoportoknak az indexértékei 1 és a gyűjtemény névtelen rögzítési csoportjainak száma között mozognak. (Egy adott csoport indexe egyenértékű a számozott háttérrendszerével. További információ a háttérrendszerekről: Backreference Constructs.)
- Az utolsó objektumkészlet nevesített rögzítési Group csoportokat jelöl. A reguláris kifejezésben definiált sorrendben jelennek meg balról jobbra. Az első elnevezett rögzítési csoport indexértéke nagyobb, mint az utolsó névtelen rögzítési csoport indexe. Ha a reguláris kifejezésben nincsenek meg nem nevezett rögzítési csoportok, az első elnevezett rögzítési csoport indexértéke egy.
Ha kvantálót alkalmaz egy rögzítési csoportra, a megfelelő Group objektum Capture.Valueés Capture.IndexCapture.Length tulajdonságok a rögzítési csoport által rögzített utolsó részszűrést tükrözik. A tulajdonság által visszaadott objektumból CaptureCollection kvantitátorokkal rendelkező csoportok által rögzített részszűrések teljes készletét Group.Captures lekérheti.
Az alábbi példa tisztázza az objektumok és Capture az Group objektumok közötti kapcsolatot.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\b(\w+)\W+)+";
string input = "This is a short sentence.";
Match match = Regex.Match(input, pattern);
Console.WriteLine("Match: '{0}'", match.Value);
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
{
Console.WriteLine(" Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
int capCtr = 0;
foreach (Capture capture in match.Groups[ctr].Captures)
{
Console.WriteLine(" Capture {0}: '{1}'", capCtr, capture.Value);
capCtr++;
}
}
}
}
// The example displays the following output:
// Match: 'This is a short sentence.'
// Group 1: 'sentence.'
// Capture 0: 'This '
// Capture 1: 'is '
// Capture 2: 'a '
// Capture 3: 'short '
// Capture 4: 'sentence.'
// Group 2: 'sentence'
// Capture 0: 'This'
// Capture 1: 'is'
// Capture 2: 'a'
// Capture 3: 'short'
// Capture 4: 'sentence'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\b(\w+)\W+)+"
Dim input As String = "This is a short sentence."
Dim match As Match = Regex.Match(input, pattern)
Console.WriteLine("Match: '{0}'", match.Value)
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
Dim capCtr As Integer = 0
For Each capture As Capture In match.Groups(ctr).Captures
Console.WriteLine(" Capture {0}: '{1}'", capCtr, capture.Value)
capCtr += 1
Next
Next
End Sub
End Module
' The example displays the following output:
' Match: 'This is a short sentence.'
' Group 1: 'sentence.'
' Capture 0: 'This '
' Capture 1: 'is '
' Capture 2: 'a '
' Capture 3: 'short '
' Capture 4: 'sentence.'
' Group 2: 'sentence'
' Capture 0: 'This'
' Capture 1: 'is'
' Capture 2: 'a'
' Capture 3: 'short'
' Capture 4: 'sentence'
A reguláris kifejezésminta (\b(\w+)\W+)+ egy sztringből nyeri ki az egyes szavakat. Az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\b |
Kezdje el az egyezést egy szóhatáron. |
(\w+) |
Egy vagy több szó karakterének egyeztetése. Ezek a karakterek együtt alkotnak egy szót. Ez a második rögzítési csoport. |
\W+ |
Egy vagy több szó nélküli karakter egyeztetése. |
(\b(\w+)\W+) |
Egy vagy több szókarakterek mintájának egy vagy több nem szóból álló karakterből álló mintája. Ez az első rögzítési csoport. |
A második rögzítési csoport megegyezik a mondat minden egyes szavával. Az első rögzítési csoport megegyezik az egyes szavakkal, valamint az írásjellel és a szót követő szóközzel. Az Group az objektum, amelynek indexe 2, információt nyújt a második rögzítési csoport által egyeztetett szövegről. A rögzítési csoport által rögzített szavak teljes készlete elérhető a CaptureCollection tulajdonság által Group.Captures visszaadott objektumból.
Lásd még
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: