A reguláris kifejezésobjektum-modell
Ez a témakör a .NET reguláris kifejezések használatakor használt objektummodellt ismerteti. A következő szakaszokat tartalmazza:
A reguláris kifejezésmotor
A .NET-ben a reguláris kifejezésmotort az Regex osztály jelöli. A reguláris kifejezésmotor feladata egy reguláris kifejezés elemzése és összeállítása, valamint olyan műveletek végrehajtása, amelyek megfelelnek a reguláris kifejezés mintájának egy bemeneti sztringgel. A motor a .NET reguláris kifejezésobjektum-modell központi összetevője.
A reguláris kifejezésmotort kétféleképpen használhatja:
Az osztály statikus metódusainak Regex meghívásával. A metódusparaméterek közé tartozik a bemeneti sztring és a reguláris kifejezésminta. A reguláris kifejezésmotor gyorsítótárazza a statikus metódushívásokban használt reguláris kifejezéseket, így az azonos reguláris kifejezéseket használó statikus reguláris kifejezésmetódusok ismételt hívásai viszonylag jó teljesítményt nyújtanak.
Egy objektum példányosításával Regex egy reguláris kifejezést ad át az osztálykonstruktornak. Ebben az esetben az Regex objektum nem módosítható (írásvédett), és egy reguláris kifejezésmotort jelöl, amely szorosan kapcsolódik egyetlen reguláris kifejezéshez. Mivel a példányok által Regex használt reguláris kifejezések nem gyorsítótárazva vannak, nem szabad többször példányosítani egy Regex objektumot ugyanazzal a reguláris kifejezéssel.
Az osztály metódusait a Regex következő műveletek végrehajtásához hívhatja meg:
Annak meghatározása, hogy egy sztring megfelel-e egy reguláris kifejezésmintának.
Egyetlen egyezés vagy az első egyezés kinyerése.
Bontsa ki az összes egyezést.
Egy megfeleltethető részstring cseréje.
Egyetlen sztring felosztása sztringek tömbjeire.
Ezeket a műveleteket a következő szakaszok ismertetik.
Normál kifejezésminta egyeztetése
A Regex.IsMatch metódus akkor ad true vissza, ha a sztring megegyezik a mintával, vagy false ha nem. A IsMatch metódust gyakran használják a sztringbemenet ellenőrzésére. A következő kód például biztosítja, hogy egy sztring megfeleljen a Egyesült Államok érvényes társadalombiztosítási számának.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] values = { "111-22-3333", "111-2-3333"};
string pattern = @"^\d{3}-\d{2}-\d{4}$";
foreach (string value in values) {
if (Regex.IsMatch(value, pattern))
Console.WriteLine("{0} is a valid SSN.", value);
else
Console.WriteLine("{0}: Invalid", value);
}
}
}
// The example displays the following output:
// 111-22-3333 is a valid SSN.
// 111-2-3333: Invalid
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim values() As String = {"111-22-3333", "111-2-3333"}
Dim pattern As String = "^\d{3}-\d{2}-\d{4}$"
For Each value As String In values
If Regex.IsMatch(value, pattern) Then
Console.WriteLine("{0} is a valid SSN.", value)
Else
Console.WriteLine("{0}: Invalid", value)
End If
Next
End Sub
End Module
' The example displays the following output:
' 111-22-3333 is a valid SSN.
' 111-2-3333: Invalid
A rendszer a reguláris kifejezésmintát ^\d{3}-\d{2}-\d{4}$ az alábbi táblázatban látható módon értelmezi.
| Minta | Leírás |
|---|---|
^ |
Egyezzen a bemeneti sztring elejére. |
\d{3} |
Három tizedesjegy egyeztetése. |
- |
Egyezik egy kötőjelel. |
\d{2} |
Két tizedesjegy egyeztetése. |
- |
Egyezik egy kötőjelel. |
\d{4} |
Négy tizedesjegy egyeztetése. |
$ |
Egyezzen a bemeneti sztring végére. |
Egyetlen egyezés vagy az első egyezés kinyerése
A Regex.Match metódus egy Match olyan objektumot ad vissza, amely egy reguláris kifejezésmintával egyező első részszúrással kapcsolatos információkat tartalmaz. Ha a Match.Success tulajdonság egyezést jelző tulajdonságot ad vissza true, a metódus meghívásával információkat kaphat a Match.NextMatch későbbi egyezésekről. Ezek a metódushívások mindaddig folytatódhatnak, amíg a Match.Success tulajdonság vissza nem tér false. Az alábbi kód például a Regex.Match(String, String) metódussal keresi meg egy duplikált szó első előfordulását egy sztringben. Ezután meghívja a metódust Match.NextMatch , hogy megtalálja a további előfordulásokat. A példa az egyes metódushívások után megvizsgálja a Match.Success tulajdonságot annak megállapításához, hogy az aktuális egyezés sikeres volt-e, és hogy a metódus hívásának követnie kell-e.Match.NextMatch
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is a a farm that that raises dairy cattle.";
string pattern = @"\b(\w+)\W+(\1)\b";
Match match = Regex.Match(input, pattern);
while (match.Success)
{
Console.WriteLine("Duplicate '{0}' found at position {1}.",
match.Groups[1].Value, match.Groups[2].Index);
match = match.NextMatch();
}
}
}
// The example displays the following output:
// Duplicate 'a' found at position 10.
// Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is a a farm that that raises dairy cattle."
Dim pattern As String = "\b(\w+)\W+(\1)\b"
Dim match As Match = Regex.Match(input, pattern)
Do While match.Success
Console.WriteLine("Duplicate '{0}' found at position {1}.", _
match.Groups(1).Value, match.Groups(2).Index)
match = match.NextMatch()
Loop
End Sub
End Module
' The example displays the following output:
' Duplicate 'a' found at position 10.
' Duplicate 'that' found at position 22.
A rendszer a reguláris kifejezésmintát \b(\w+)\W+(\1)\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. Ez az első rögzítési csoport. |
\W+ |
Egy vagy több szó nélküli karakter egyeztetése. |
(\1) |
Egyezzen az első rögzített sztringgel. Ez a második rögzítési csoport. |
\b |
Egy szóhatáron fejezd be az egyezést. |
Az összes egyezés kinyerése
A Regex.Matches metódus egy MatchCollection olyan objektumot ad vissza, amely információkat tartalmaz a bemeneti sztringben található reguláris kifejezésmotor által talált összes egyezésről. Az előző példa például átírható úgy, hogy a Matches metódust hívja meg ahelyett, hogy a metódust és NextMatch a Match metódusokat használná.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "This is a a farm that that raises dairy cattle.";
string pattern = @"\b(\w+)\W+(\1)\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine("Duplicate '{0}' found at position {1}.",
match.Groups[1].Value, match.Groups[2].Index);
}
}
// The example displays the following output:
// Duplicate 'a' found at position 10.
// Duplicate 'that' found at position 22.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "This is a a farm that that raises dairy cattle."
Dim pattern As String = "\b(\w+)\W+(\1)\b"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("Duplicate '{0}' found at position {1}.", _
match.Groups(1).Value, match.Groups(2).Index)
Next
End Sub
End Module
' The example displays the following output:
' Duplicate 'a' found at position 10.
' Duplicate 'that' found at position 22.
Egyeztetett részszűrés cseréje
A Regex.Replace metódus lecseréli az összes olyan részsztringet, amely megfelel a reguláris kifejezés mintájának egy megadott sztringre vagy reguláris kifejezésmintára, és a teljes bemeneti sztringet lecseréli. Az alábbi kód például egy amerikai pénznemszimbólumot ad hozzá egy sztringben lévő tizedesszám elé.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\d+\.\d{2}\b";
string replacement = "$$$&";
string input = "Total Cost: 103.64";
Console.WriteLine(Regex.Replace(input, pattern, replacement));
}
}
// The example displays the following output:
// Total Cost: $103.64
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\d+\.\d{2}\b"
Dim replacement As String = "$$$&"
Dim input As String = "Total Cost: 103.64"
Console.WriteLine(Regex.Replace(input, pattern, replacement))
End Sub
End Module
' The example displays the following output:
' Total Cost: $103.64
A rendszer a reguláris kifejezésmintát \b\d+\.\d{2}\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. |
\d+ |
Egy vagy több tizedesjegy egyeztetése. |
\. |
Pont egyeztetése. |
\d{2} |
Két tizedesjegy egyeztetése. |
\b |
Egy szóhatáron fejezd be az egyezést. |
A csereminta $$$& értelmezése az alábbi táblázatban látható módon történik.
| Minta | Helyettesítő sztring |
|---|---|
$$ |
A dollárjel ($) karakter. |
$& |
Az egész egyező részsztring. |
Egyetlen sztring felosztása sztringek tömbjeire
A Regex.Split metódus felosztja a bemeneti sztringet egy reguláris kifejezésegyezés által meghatározott pozíciókra. Az alábbi kód például egy számozott listában lévő elemeket egy sztringtömbbe helyezi.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea";
string pattern = @"\b\d{1,2}\.\s";
foreach (string item in Regex.Split(input, pattern))
{
if (! String.IsNullOrEmpty(item))
Console.WriteLine(item);
}
}
}
// The example displays the following output:
// Eggs
// Bread
// Milk
// Coffee
// Tea
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "1. Eggs 2. Bread 3. Milk 4. Coffee 5. Tea"
Dim pattern As String = "\b\d{1,2}\.\s"
For Each item As String In Regex.Split(input, pattern)
If Not String.IsNullOrEmpty(item) Then
Console.WriteLine(item)
End If
Next
End Sub
End Module
' The example displays the following output:
' Eggs
' Bread
' Milk
' Coffee
' Tea
A rendszer a reguláris kifejezésmintát \b\d{1,2}\.\s 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. |
\d{1,2} |
Egy vagy két tizedesjegy egyeztetése. |
\. |
Pont egyeztetése. |
\s |
Egyezik egy szóköz karakterrel. |
A MatchCollection és az Egyező objektumok
A Regex metódusok két objektumot adnak vissza, amelyek a reguláris kifejezési objektummodell részét képezik: az MatchCollection objektumot és az Match objektumot.
A gyűjtemény egyeztetése
A Regex.Matches metódus egy MatchCollection objektumot ad vissza, amely olyan objektumokat tartalmaz Match , amelyek a normál kifejezésmotor által talált összes egyezést képviselik a bemeneti sztringben való előfordulásuk sorrendjében. Ha nincsenek egyezések, a metódus egy MatchCollection tag nélküli objektumot ad vissza. A MatchCollection.Item[] tulajdonsággal index alapján érheti el a gyűjtemény egyes tagjait, nullától a tulajdonság értékénél MatchCollection.Count egy kisebbig. Item[] A gyűjtemény indexelője (C#-ban) és alapértelmezett tulajdonsága (a Visual Basicben).
Alapértelmezés szerint a metódus hívása Regex.Matches lusta kiértékeléssel tölti fel az MatchCollection objektumot. Az olyan tulajdonságokhoz való hozzáférés, amelyek teljes mértékben kitöltött gyűjteményt igényelnek, például a tulajdonságok és MatchCollection.Item[] a MatchCollection.Count tulajdonságok, teljesítménybeli büntetést vonhatnak maguk után. Ennek eredményeképpen azt javasoljuk, hogy a metódus által visszaadott objektummal férhessen hozzá a IEnumerator gyűjteményhez MatchCollection.GetEnumerator . Az egyes nyelvek olyan szerkezeteket biztosítanak, például For Each a Visual Basicben és foreach a C#-ban, amelyek a gyűjtemény felületét burkolják IEnumerator .
Az alábbi példa a Regex.Matches(String) metódus használatával tölt fel egy MatchCollection objektumot a bemeneti sztringben található összes egyezéssel. A példa számba veszi a gyűjteményt, sztringtömbbe másolja az egyezéseket, és egy egész számtömb karakterpozícióit rögzíti.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
MatchCollection matches;
List<string> results = new List<string>();
List<int> matchposition = new List<int>();
// Create a new Regex object and define the regular expression.
Regex r = new Regex("abc");
// Use the Matches method to find all matches in the input string.
matches = r.Matches("123abc4abcd");
// Enumerate the collection to retrieve all matches and positions.
foreach (Match match in matches)
{
// Add the match string to the string array.
results.Add(match.Value);
// Record the character position where the match was found.
matchposition.Add(match.Index);
}
// List the results.
for (int ctr = 0; ctr < results.Count; ctr++)
Console.WriteLine("'{0}' found at position {1}.",
results[ctr], matchposition[ctr]);
}
}
// The example displays the following output:
// 'abc' found at position 3.
// 'abc' found at position 7.
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim matches As MatchCollection
Dim results As New List(Of String)
Dim matchposition As New List(Of Integer)
' Create a new Regex object and define the regular expression.
Dim r As New Regex("abc")
' Use the Matches method to find all matches in the input string.
matches = r.Matches("123abc4abcd")
' Enumerate the collection to retrieve all matches and positions.
For Each match As Match In matches
' Add the match string to the string array.
results.Add(match.Value)
' Record the character position where the match was found.
matchposition.Add(match.Index)
Next
' List the results.
For ctr As Integer = 0 To results.Count - 1
Console.WriteLine("'{0}' found at position {1}.", _
results(ctr), matchposition(ctr))
Next
End Sub
End Module
' The example displays the following output:
' 'abc' found at position 3.
' 'abc' found at position 7.
Az egyezés
Az Match osztály egyetlen reguláris kifejezésegyezés eredményét jelöli. Az objektumok kétféleképpen érhetők el Match :
A metódus által visszaadott objektumból MatchCollection való lekérésével Regex.Matches . Az egyes Match objektumok lekéréséhez iterálja a gyűjteményt egy
foreach(C#-ban) vagyFor Each...Next(Visual Basicben) szerkezettel, vagy használja a MatchCollection.Item[] tulajdonságot egy adott Match objektum index vagy név alapján történő lekéréséhez. Az egyes Match objektumokat úgy is lekérheti a gyűjteményből, hogy index szerint iterálja a gyűjteményt, nulláról eggyel kevesebbre, mint a gyűjteményben lévő objektumok száma. Ez a módszer azonban nem használja ki a lusta kiértékelés előnyeit, mert hozzáfér a tulajdonsághoz MatchCollection.Count .Az alábbi példa a gyűjtemény vagy a ...
Nextszerkezettel történő iterálásával kér le egyes Match objektumokat egyFor EachMatchCollectionforeachobjektumból. A reguláris kifejezés egyszerűen megfelel az "abc" sztringnek a bemeneti sztringben.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "abc"; string input = "abc123abc456abc789"; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine("{0} found at position {1}.", match.Value, match.Index); } } // The example displays the following output: // abc found at position 0. // abc found at position 6. // abc found at position 12.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "abc" Dim input As String = "abc123abc456abc789" For Each match As Match In Regex.Matches(input, pattern) Console.WriteLine("{0} found at position {1}.", _ match.Value, match.Index) Next End Sub End Module ' The example displays the following output: ' abc found at position 0. ' abc found at position 6. ' abc found at position 12.A metódus meghívásával Regex.Match egy olyan objektumot ad Match vissza, amely egy sztring első egyezését vagy egy sztring egy részét jelöli. A tulajdonság értékének
Match.Successbeolvasásával megállapíthatja, hogy az egyezés megtalálható-e. A következő egyezéseket képviselő objektumok lekéréséhez Match hívja meg többször a Match.NextMatch metódust, amíg aSuccessvisszaadott Match objektum tulajdonsága nem leszfalse.Az alábbi példa az "abc Regex.Match(String, String) " sztringnek megfelelő metódusokat és Match.NextMatch metódusokat használja a bemeneti sztringben.
using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "abc"; string input = "abc123abc456abc789"; Match match = Regex.Match(input, pattern); while (match.Success) { Console.WriteLine("{0} found at position {1}.", match.Value, match.Index); match = match.NextMatch(); } } } // The example displays the following output: // abc found at position 0. // abc found at position 6. // abc found at position 12.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "abc" Dim input As String = "abc123abc456abc789" Dim match As Match = Regex.Match(input, pattern) Do While match.Success Console.WriteLine("{0} found at position {1}.", _ match.Value, match.Index) match = match.NextMatch() Loop End Sub End Module ' The example displays the following output: ' abc found at position 0. ' abc found at position 6. ' abc found at position 12.
Az osztály két tulajdonsága visszaadja a Match gyűjteményobjektumokat:
A Match.Groups tulajdonság egy GroupCollection olyan objektumot ad vissza, amely a reguláris kifejezésmintában szereplő rögzítési csoportokkal egyező részsztringekről tartalmaz információkat.
A
Match.Capturestulajdonság korlátozott CaptureCollection használatú objektumot ad vissza. A gyűjtemény nem töltődik fel olyan Match objektumhoz, amelynekSuccessa tulajdonsága .falseEllenkező esetben egyetlen Capture objektumot tartalmaz, amely ugyanazokkal az információkkal rendelkezik, mint az Match objektum.
Az objektumokkal kapcsolatos további információkért tekintse meg a jelen témakör későbbi, Csoportgyűjtemény és a Gyűjtemény rögzítése című szakaszát.
Az osztály két további tulajdonsága adja meg az Match egyezés adatait. A Match.Value tulajdonság a bemeneti sztringben lévő részsztringet adja vissza, amely megfelel a reguláris kifejezésmintának. A Match.Index tulajdonság a bemeneti sztringben lévő egyező sztring nullaalapú kezdőpozícióját adja vissza.
Az Match osztály két mintaegyeztetési metódust is használ:
A Match.NextMatch metódus megkeresi az egyezést az aktuális Match objektum által képviselt egyezés után, és visszaad egy Match , az adott egyezést képviselő objektumot.
A Match.Result metódus egy megadott csereműveletet hajt végre a megfeleltetett sztringen, és visszaadja az eredményt.
Az alábbi példa egy $ szimbólum és egy szóköz előtűnésére használja a Match.Result metódust minden olyan szám előtt, amely két törtjegyet tartalmaz.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\d+(,\d{3})*\.\d{2}\b";
string input = "16.32\n194.03\n1,903,672.08";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Result("$$ $&"));
}
}
// The example displays the following output:
// $ 16.32
// $ 194.03
// $ 1,903,672.08
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\d+(,\d{3})*\.\d{2}\b"
Dim input As String = "16.32" + vbCrLf + "194.03" + vbCrLf + "1,903,672.08"
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Result("$$ $&"))
Next
End Sub
End Module
' The example displays the following output:
' $ 16.32
' $ 194.03
' $ 1,903,672.08
A reguláris kifejezésminta \b\d+(,\d{3})*\.\d{2}\b 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. |
\d+ |
Egy vagy több tizedesjegy egyeztetése. |
(,\d{3})* |
Egy vessző nulla vagy több előfordulásának egyezése, amelyet három tizedesjegy követ. |
\. |
Egyezzen a tizedesvessző karakterével. |
\d{2} |
Két tizedesjegy egyeztetése. |
\b |
Egy szóhatáron fejezd be az egyezést. |
A csereminta $$ $& azt jelzi, hogy a megfeleltetett részszúrást egy dollárjel ($) szimbólum (a $$ minta), egy szóköz és az egyezés értéke (a $& minta) váltja fel.
A csoportgyűjtemény
A Match.Groups tulajdonság egy GroupCollection objektumot ad vissza, amely egyetlen egyezésben rögzített csoportokat ábrázoló objektumokat tartalmaz Group . A gyűjtemény első Group objektuma (a 0. indexnél) a teljes egyezést jelöli. Az alábbi objektumok egyetlen rögzítési csoport eredményeit jelölik.
A tulajdonság használatával GroupCollection.Item[] lekérheti a gyűjtemény egyes Group objektumait. A névtelen csoportokat lekérheti a gyűjteményben lévő sorrendi pozíciójuk alapján, és név vagy sorszám szerint is lekérheti az elnevezett csoportokat. A névtelen rögzítések először a gyűjteményben jelennek meg, és a rendszer balról jobbra indexeli őket abban a sorrendben, amelyben a reguláris kifejezési mintában jelennek meg. A névvel ellátott rögzítéseket a rendszer a névtelen rögzítések után indexeli, balról jobbra abban a sorrendben, amelyben azok megjelennek a reguláris kifejezési mintában. Ha meg szeretné állapítani, hogy mely számozott csoportok érhetők el egy adott reguláris kifejezésmegfeleltetési metódushoz visszaadott gyűjteményben, meghívhatja a példánymetódust Regex.GetGroupNumbers . A gyűjteményben elérhető elnevezett csoportok meghatározásához meghívhatja a példánymetódust Regex.GetGroupNames . Mindkét módszer különösen hasznos az olyan általános célú rutinokban, amelyek bármely reguláris kifejezés által talált egyezéseket elemzik.
A GroupCollection.Item[] tulajdonság a gyűjtemény indexelője c# nyelven, a gyűjteményobjektum alapértelmezett tulajdonsága pedig a Visual Basicben. Ez azt jelenti, hogy az egyes Group objektumok az alábbiak szerint érhetők el index (vagy név alapján, nevesített csoportok esetén):
Group group = match.Groups[ctr];
Dim group As Group = match.Groups(ctr)
Az alábbi példa egy reguláris kifejezést határoz meg, amely csoportosítási szerkezetekkel rögzíti a dátum hónapját, napját és évét.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(\w+)\s(\d{1,2}),\s(\d{4})\b";
string input = "Born: July 28, 1989";
Match match = Regex.Match(input, pattern);
if (match.Success)
for (int ctr = 0; ctr < match.Groups.Count; ctr++)
Console.WriteLine("Group {0}: {1}", ctr, match.Groups[ctr].Value);
}
}
// The example displays the following output:
// Group 0: July 28, 1989
// Group 1: July
// Group 2: 28
// Group 3: 1989
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(\w+)\s(\d{1,2}),\s(\d{4})\b"
Dim input As String = "Born: July 28, 1989"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
For ctr As Integer = 0 To match.Groups.Count - 1
Console.WriteLine("Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End If
End Sub
End Module
' The example displays the following output:
' Group 0: July 28, 1989
' Group 1: July
' Group 2: 28
' Group 3: 1989
A reguláris kifejezésminta \b(\w+)\s(\d{1,2}),\s(\d{4})\b 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. Ez az első rögzítési csoport. |
\s |
Egyezik egy szóköz karakterrel. |
(\d{1,2}) |
Egy vagy két tizedesjegy egyeztetése. Ez a második rögzítési csoport. |
, |
Egyezik egy vesszővel. |
\s |
Egyezik egy szóköz karakterrel. |
(\d{4}) |
Négy tizedesjegy egyeztetése. Ez a harmadik rögzítési csoport. |
\b |
Egy szóhatáron fejezd be az egyezést. |
A rögzített csoport
Az Group osztály egyetlen rögzítési csoport eredményét jelöli. A normál kifejezésben definiált rögzítési csoportokat képviselő csoportobjektumokat a Item[]GroupCollection tulajdonság által Match.Groups visszaadott objektum tulajdonsága adja vissza. A Item[] tulajdonság az indexelő (C#-ban) és az osztály alapértelmezett tulajdonsága Group (a Visual Basicben). Az egyes tagokat úgy is lekérheti, hogy a gyűjteményt a szerkezettel vagy For Each a foreach szerkezettel iterálja. Például lásd az előző szakaszt.
Az alábbi példa beágyazott csoportosítási szerkezeteket használ az alsztringek csoportokba való rögzítéséhez. A reguláris kifejezésminta (a(b))c megegyezik az "abc" sztringgel. Az "ab" részsztringet az első rögzítési csoporthoz, a "b" alsztringet pedig a második rögzítési csoporthoz rendeli.
var matchposition = new List<int>();
var results = new List<string>();
// Define substrings abc, ab, b.
var r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
// Add groups to string array.
results.Add(m.Groups[i].Value);
// Record character position.
matchposition.Add(m.Groups[i].Index);
}
// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
Console.WriteLine("{0} at position {1}",
results[ctr], matchposition[ctr]);
// The example displays the following output:
// abc at position 3
// ab at position 3
// b at position 4
Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
' Add groups to string array.
results.Add(m.Groups(i).Value)
' Record character position.
matchposition.Add(m.Groups(i).Index)
i += 1
End While
' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
Console.WriteLine("{0} at position {1}", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' abc at position 3
' ab at position 3
' b at position 4
Az alábbi példa nevesített csoportosítási szerkezeteket használ a "DATANAME:VALUE" formátumú adatokat tartalmazó sztring részsztringjeinek rögzítésére, amelyeket a reguláris kifejezés a kettőspontnál (:)) oszt meg.
var r = new Regex(@"^(?<name>\w+):(?<value>\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
// Section1
// 119900
Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
' Section1
' 119900
A reguláris kifejezésminta ^(?<name>\w+):(?<value>\w+) az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
^ |
Kezdje el az egyezést a bemeneti sztring elején. |
(?<name>\w+) |
Egy vagy több szó karakterének egyeztetése. Ennek a rögzítési csoportnak a neve .name |
: |
Egyeztessen egy kettőspontot. |
(?<value>\w+) |
Egy vagy több szó karakterének egyeztetése. Ennek a rögzítési csoportnak a neve .value |
Az osztály tulajdonságai Group információt nyújtanak a rögzített csoportról: A Group.Value tulajdonság tartalmazza a rögzített részstringet, a Group.Index tulajdonság a rögzített csoport kezdőpozícióját jelzi a bemeneti szövegben, a Group.Length tulajdonság a rögzített szöveg hosszát, a Group.Success tulajdonság pedig azt jelzi, hogy egy részszúrás megfelelt-e a rögzítési csoport által meghatározott mintának.
Ha kvantitátorokat alkalmaz egy csoportra (további információkért lásd : Kvantitátorok) a rögzítési csoportonkénti egy rögzítés kapcsolatát kétféleképpen módosítja:
Ha a
*(nulla vagy*?több egyezést meghatározó) kvantálót egy csoportra alkalmazza a rendszer, előfordulhat, hogy a rögzítési csoportnak nincs egyezése a bemeneti sztringben. Ha nincs rögzített szöveg, az objektum tulajdonságai az Group alábbi táblázatban látható módon vannak beállítva.Csoporttulajdonság Érték SuccessfalseValueString.Empty Length0 Az alábbi példa egy illusztrációt tartalmaz. A reguláris kifejezésmintában
aaa(bbb)*cccaz első rögzítési csoport (a "bbb" részsztring) nullával vagy többször is megfeleltethető. Mivel az "aaaccc" bemeneti sztring megegyezik a mintával, a rögzítési csoportnak nincs egyezése.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "aaa(bbb)*ccc"; string input = "aaaccc"; Match match = Regex.Match(input, pattern); Console.WriteLine("Match value: {0}", match.Value); if (match.Groups[1].Success) Console.WriteLine("Group 1 value: {0}", match.Groups[1].Value); else Console.WriteLine("The first capturing group has no match."); } } // The example displays the following output: // Match value: aaaccc // The first capturing group has no match.Imports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "aaa(bbb)*ccc" Dim input As String = "aaaccc" Dim match As Match = Regex.Match(input, pattern) Console.WriteLine("Match value: {0}", match.Value) If match.Groups(1).Success Then Console.WriteLine("Group 1 value: {0}", match.Groups(1).Value) Else Console.WriteLine("The first capturing group has no match.") End If End Sub End Module ' The example displays the following output: ' Match value: aaaccc ' The first capturing group has no match.A kvantátorok egy rögzítési csoport által definiált minta több előfordulását is meg tudják egyezni. Ebben az esetben egy
ValueGroup objektum tulajdonságai ésLengthtulajdonságai csak az utolsó rögzített részszűréssel kapcsolatos információkat tartalmazzák. Az alábbi reguláris kifejezés például egy pontban végződő mondatot egyezik meg. Két csoportosítási szerkezetet használ: Az első az egyes szavakat rögzíti egy szóköz karakterrel együtt; a második az egyes szavakat rögzíti. Ahogy a példa kimenete is mutatja, bár a reguláris kifejezésnek sikerül egy teljes mondatot rögzítenie, a második rögzítési csoport csak az utolsó szót rögzíti.using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b((\w+)\s?)+\."; string input = "This is a sentence. This is another sentence."; Match match = Regex.Match(input, pattern); if (match.Success) { Console.WriteLine("Match: " + match.Value); Console.WriteLine("Group 2: " + match.Groups[2].Value); } } } // The example displays the following output: // Match: This is a sentence. // Group 2: sentenceImports System.Text.RegularExpressions Module Example Public Sub Main() Dim pattern As String = "\b((\w+)\s?)+\." Dim input As String = "This is a sentence. This is another sentence." Dim match As Match = Regex.Match(input, pattern) If match.Success Then Console.WriteLine("Match: " + match.Value) Console.WriteLine("Group 2: " + match.Groups(2).Value) End If End Sub End Module ' The example displays the following output: ' Match: This is a sentence. ' Group 2: sentence
A rögzítési gyűjtemény
Az Group objektum csak az utolsó rögzítésről tartalmaz információkat. A rögzítési csoport által készített rögzítések teljes készlete azonban továbbra is elérhető a CaptureCollection tulajdonság által Group.Captures visszaadott objektumból. A gyűjtemény minden tagja egy Capture objektum, amely az adott rögzítési csoport által készített rögzítést jelöli a rögzítés sorrendjében (és ezért abban a sorrendben, amelyben a rögzített sztringek balról jobbra illeszkednek a bemeneti sztringben). Az egyes Capture objektumok kétféleképpen kérhetők le a gyűjteményből:
A gyűjteményen keresztüli iterálással olyan szerkezetet használjon, mint
foreacha (C#) vagyFor Eacha (Visual Basicben).A tulajdonság használatával CaptureCollection.Item[] lekérhet egy adott objektumot index alapján. A Item[] tulajdonság az CaptureCollection objektum alapértelmezett tulajdonsága (a Visual Basicben) vagy az indexelő (C#-ban).
Ha egy kvantáló nem alkalmaz rögzítési csoportra, az CaptureCollection objektum egyetlen Capture , kevésbé érdekes objektumot tartalmaz, mivel az az objektummal Group azonos egyezésről ad információt. Ha egy rögzítőcsoportra kvantátort alkalmaz, az CaptureCollection objektum tartalmazza a rögzítési csoport által készített összes rögzítést, és a gyűjtemény utolsó tagja ugyanazt a rögzítést jelöli, mint az Group objektum.
Ha például a reguláris kifejezésmintát ((a(b))c)+ használja (ahol a + kvantáló egy vagy több egyezést ad meg) az "abcabcabc" sztring egyezéseinek rögzítéséhez, az CaptureCollection egyes Group objektumok objektuma három tagot tartalmaz.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "((a(b))c)+";
string input = "abcabcabc";
Match match = Regex.Match(input, pattern);
if (match.Success)
{
Console.WriteLine("Match: '{0}' at position {1}",
match.Value, match.Index);
GroupCollection groups = match.Groups;
for (int ctr = 0; ctr < groups.Count; ctr++) {
Console.WriteLine(" Group {0}: '{1}' at position {2}",
ctr, groups[ctr].Value, groups[ctr].Index);
CaptureCollection captures = groups[ctr].Captures;
for (int ctr2 = 0; ctr2 < captures.Count; ctr2++) {
Console.WriteLine(" Capture {0}: '{1}' at position {2}",
ctr2, captures[ctr2].Value, captures[ctr2].Index);
}
}
}
}
}
// The example displays the following output:
// Match: 'abcabcabc' at position 0
// Group 0: 'abcabcabc' at position 0
// Capture 0: 'abcabcabc' at position 0
// Group 1: 'abc' at position 6
// Capture 0: 'abc' at position 0
// Capture 1: 'abc' at position 3
// Capture 2: 'abc' at position 6
// Group 2: 'ab' at position 6
// Capture 0: 'ab' at position 0
// Capture 1: 'ab' at position 3
// Capture 2: 'ab' at position 6
// Group 3: 'b' at position 7
// Capture 0: 'b' at position 1
// Capture 1: 'b' at position 4
// Capture 2: 'b' at position 7
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "((a(b))c)+"
Dim input As STring = "abcabcabc"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("Match: '{0}' at position {1}", _
match.Value, match.Index)
Dim groups As GroupCollection = match.Groups
For ctr As Integer = 0 To groups.Count - 1
Console.WriteLine(" Group {0}: '{1}' at position {2}", _
ctr, groups(ctr).Value, groups(ctr).Index)
Dim captures As CaptureCollection = groups(ctr).Captures
For ctr2 As Integer = 0 To captures.Count - 1
Console.WriteLine(" Capture {0}: '{1}' at position {2}", _
ctr2, captures(ctr2).Value, captures(ctr2).Index)
Next
Next
End If
End Sub
End Module
' The example displays the following output:
' Match: 'abcabcabc' at position 0
' Group 0: 'abcabcabc' at position 0
' Capture 0: 'abcabcabc' at position 0
' Group 1: 'abc' at position 6
' Capture 0: 'abc' at position 0
' Capture 1: 'abc' at position 3
' Capture 2: 'abc' at position 6
' Group 2: 'ab' at position 6
' Capture 0: 'ab' at position 0
' Capture 1: 'ab' at position 3
' Capture 2: 'ab' at position 6
' Group 3: 'b' at position 7
' Capture 0: 'b' at position 1
' Capture 1: 'b' at position 4
' Capture 2: 'b' at position 7
Az alábbi példa a reguláris kifejezéssel (Abc)+ keresi meg az "Abc" sztring egy vagy több egymást követő futását az "XYZAbcAbcAbcAbcAbcAbcXYZAbcAb" sztringben. A példa azt szemlélteti, hogy a Group.Captures tulajdonság több rögzített részstringcsoportot ad vissza.
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
// Look for groupings of "Abc".
var r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;
// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());
// Loop through each group.
for (int i = 0; i < gc.Count; i++)
{
cc = gc[i].Captures;
counter = cc.Count;
// Display the number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in the group.
for (int ii = 0; ii < counter; ii++)
{
// Display the capture and its position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
// The example displays the following output:
// Captured groups = 2
// Captures count = 1
// AbcAbcAbc Starts at character 3
// Captures count = 3
// Abc Starts at character 3
// Abc Starts at character 6
// Abc Starts at character 9
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection
' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups
' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())
' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
cc = gc(i).Captures
counter = cc.Count
' Display the number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in the group.
For ii = 0 To counter - 1
' Display the capture and its position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
' The example displays the following output:
' Captured groups = 2
' Captures count = 1
' AbcAbcAbc Starts at character 3
' Captures count = 3
' Abc Starts at character 3
' Abc Starts at character 6
' Abc Starts at character 9
Az egyéni rögzítés
Az Capture osztály egyetlen szubexpressziós rögzítés eredményeit tartalmazza. A Capture.Value tulajdonság tartalmazza a megfeleltetett szöveget, a Capture.Index tulajdonság pedig azt a nulla alapú pozíciót jelzi a bemeneti sztringben, ahol a megfeleltetett részsztring kezdődik.
Az alábbi példa egy bemeneti sztringet elemez a kiválasztott városok hőmérsékletéhez. A városok és a hőmérséklet elválasztására vessző (";") szolgál, pontosvesszővel (";") pedig az egyes városok adatainak elválasztására. A teljes bemeneti sztring egyetlen egyezést jelöl. A sztring elemzéséhez használt reguláris kifejezési mintában ((\w+(\s\w+)*),(\d+);)+a városnév a második rögzítési csoporthoz van rendelve, a hőmérséklet pedig a negyedik rögzítési csoporthoz van rendelve.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;";
string pattern = @"((\w+(\s\w+)*),(\d+);)+";
Match match = Regex.Match(input, pattern);
if (match.Success)
{
Console.WriteLine("Current temperatures:");
for (int ctr = 0; ctr < match.Groups[2].Captures.Count; ctr++)
Console.WriteLine("{0,-20} {1,3}", match.Groups[2].Captures[ctr].Value,
match.Groups[4].Captures[ctr].Value);
}
}
}
// The example displays the following output:
// Current temperatures:
// Miami 78
// Chicago 62
// New York 67
// San Francisco 59
// Seattle 58
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "Miami,78;Chicago,62;New York,67;San Francisco,59;Seattle,58;"
Dim pattern As String = "((\w+(\s\w+)*),(\d+);)+"
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("Current temperatures:")
For ctr As Integer = 0 To match.Groups(2).Captures.Count - 1
Console.WriteLine("{0,-20} {1,3}", match.Groups(2).Captures(ctr).Value, _
match.Groups(4).Captures(ctr).Value)
Next
End If
End Sub
End Module
' The example displays the following output:
' Current temperatures:
' Miami 78
' Chicago 62
' New York 67
' San Francisco 59
' Seattle 58
A reguláris kifejezés az alábbi táblázatban látható módon van definiálva.
| Minta | Leírás |
|---|---|
\w+ |
Egy vagy több szó karakterének egyeztetése. |
(\s\w+)* |
Egy üres szóköz karakter nulla vagy több előfordulásának egyezése, amelyet egy vagy több szókarakter követ. Ez a minta egyezik a többszavas városnevekkel. Ez a harmadik rögzítési csoport. |
(\w+(\s\w+)*) |
Egy vagy több szó karakterének egyezése, majd egy szóköz karakter nulla vagy több előfordulása és egy vagy több szókarakter. Ez a második rögzítési csoport. |
, |
Egyezik egy vesszővel. |
(\d+) |
Egy vagy több számjegy egyeztetése. Ez a negyedik rögzítési csoport. |
; |
Pontosvesszővel egyező. |
((\w+(\s\w+)*),(\d+);)+ |
Egyezik a szó mintájával, majd a további szavakkal, majd egy vesszővel, egy vagy több számjegytel és pontosvesszővel, egy vagy több alkalommal. Ez az első rögzítési csoport. |
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: