Gruppera konstruktioner i reguljära uttryck
Grupperingskonstruktioner beskriver underuttrycken för ett reguljärt uttryck och avbildar delsträngarna i en indatasträng. Du kan använda grupperingskonstruktioner för att göra följande:
- Matcha en underuttryck som upprepas i indatasträngen.
- Tillämpa en kvantifierare på en underuttryck som har flera språkelement för reguljära uttryck. Mer information om kvantifierare finns i Kvantifierare.
- Inkludera en underuttryck i strängen som returneras av Regex.Replace metoderna och Match.Result .
- Hämta enskilda underuttryck från Match.Groups egenskapen och bearbeta dem separat från den matchade texten som helhet.
I följande tabell visas de grupperingskonstruktioner som stöds av motorn för reguljära .NET-uttryck och anger om de avbildas eller inte.
| Grupperingskonstruktion | Samla in eller ta inte in |
|---|---|
| Matchade underuttryck | Fånga |
| Namngivna matchade underuttryck | Fånga |
| Balansera gruppdefinitioner | Fånga |
| Icke-kapslingsgrupper | Inkapsling |
| Gruppalternativ | Inkapsling |
| Positiva lookahead-försäkran med noll bredd | Inkapsling |
| Negativa lookahead-försäkran med noll bredd | Inkapsling |
| Positiva utseenden med noll bredd finns bakom försäkran | Inkapsling |
| Negativa lookbehind-försäkran med noll bredd | Inkapsling |
| Atomiska grupper | Inkapsling |
Information om grupper och objektmodellen för reguljära uttryck finns i Grupperingskonstruktioner och reguljära uttrycksobjekt.
Matchade underuttryck
Följande grupperingskonstruktion avbildar en matchad underuttryck:
(subexpression)
Här är underuttryck ett giltigt mönster för reguljära uttryck. Avbildningar som använder parenteser numreras automatiskt från vänster till höger baserat på ordningen på de inledande parenteserna i det reguljära uttrycket från och med 1. Namngivna avbildningsgrupper sorteras dock alltid sist, efter icke-namngivna avbildningsgrupper. Avbildningen som är numrerad 0 är texten som matchas av hela mönster för reguljära uttryck.
Kommentar
Som standard (avbildar underuttrycksspråkelementet) den matchade underuttrycket. Men om parametern RegexOptions för en mönstermatchningsmetod för reguljära uttryck innehåller RegexOptions.ExplicitCapture flaggan, eller om n alternativet tillämpas på denna underuttryck (se Gruppalternativ senare i den här artikeln), fångas inte den matchade underuttryckningen.
Du kan komma åt insamlade grupper på fyra sätt:
Genom att använda backreference-konstruktionen i det reguljära uttrycket. Den matchade underuttrycket refereras i samma reguljära uttryck med hjälp av syntaxnumret
\, där talet är ordningstalet för den insamlade underuttrycket.Genom att använda den namngivna backreference-konstruktionen i det reguljära uttrycket. Den matchade underuttrycket refereras i samma reguljära uttryck med hjälp av syntaxnamnet
\k<>, där namnet är namnet på en insamlingsgrupp eller\k<ett nummer>, där talet är ordningstalet för en insamlingsgrupp. En insamlingsgrupp har ett standardnamn som är identiskt med dess ordningstal. Mer information finns i Namngivna matchade underuttryck senare i det här avsnittet.Genom att använda
$nummerersättningssekvensen i ett Regex.Replace - eller Match.Result -metodanrop, där talet är ordningstalet för den insamlade underuttrycket.Programmatiskt med hjälp av objektet GroupCollection som returneras av egenskapen Match.Groups . Medlemmen vid position noll i samlingen representerar hela matchningen av reguljära uttryck. Varje efterföljande medlem representerar en matchad underuttryck. Mer information finns i avsnittet Grupperingskonstruktioner och Objekt för reguljära uttryck.
I följande exempel visas ett reguljärt uttryck som identifierar duplicerade ord i text. Det reguljära uttrycksmönstrets två grupper representerar de två instanserna av det duplicerade ordet. Den andra instansen registreras för att rapportera sin startposition i indatasträngen.
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.
Mönster för reguljära uttryck är följande:
(\w+)\s(\1)\W
I följande tabell visas hur mönstret för reguljära uttryck tolkas.
| Mönster | beskrivning |
|---|---|
(\w+) |
Matcha ett eller flera ordtecken. Det här är den första insamlingsgruppen. |
\s |
Matcha ett blankstegstecken. |
(\1) |
Matcha strängen i den första insamlade gruppen. Det här är den andra insamlingsgruppen. Exemplet tilldelar den till en grupperad grupp så att startpositionen för det duplicerade ordet kan hämtas från Match.Index egenskapen. |
\W |
Matcha ett tecken som inte är ord, inklusive blanksteg och skiljetecken. Detta förhindrar att mönster för reguljära uttryck matchar ett ord som börjar med ordet från den första insamlade gruppen. |
Namngivna matchade underuttryck
Följande grupperingskonstruktion samlar in en matchad underuttryck och gör att du kan komma åt den efter namn eller nummer:
(?<name>subexpression)
eller:
(?'name'subexpression)
Här är namnet ett giltigt gruppnamn och underuttryck är ett giltigt mönster för reguljära uttryck. namnet får inte innehålla några skiljetecken och kan inte börja med ett tal.
Kommentar
Om parametern RegexOptions för en mönstermatchningsmetod för reguljära uttryck innehåller RegexOptions.ExplicitCapture flaggan, eller om n alternativet tillämpas på denna underuttryck (se Gruppalternativ senare i det här avsnittet), är det enda sättet att avbilda en underuttryck att uttryckligen namnge grupper som samlar in grupper.
Du kan komma åt namngivna insamlade grupper på följande sätt:
Genom att använda den namngivna backreference-konstruktionen i det reguljära uttrycket. Den matchade underuttrycket refereras till i samma reguljära uttryck med hjälp av syntaxnamnet
\k<>, där namnet är namnet på den insamlade underuttrycket.Genom att använda backreference-konstruktionen i det reguljära uttrycket. Den matchade underuttrycket refereras i samma reguljära uttryck med hjälp av syntaxnumret
\, där talet är ordningstalet för den insamlade underuttrycket. Namngivna matchade underuttryck numreras i följd från vänster till höger efter matchade underuttryck.Genom att använda namnbytessekvensen
${}i ett Regex.Replace - eller Match.Result -metodanrop, där namnet är namnet på den insamlade underuttrycket.Genom att använda
$nummerersättningssekvensen i ett Regex.Replace - eller Match.Result -metodanrop, där talet är ordningstalet för den insamlade underuttrycket.Programmatiskt med hjälp av objektet GroupCollection som returneras av egenskapen Match.Groups . Medlemmen vid position noll i samlingen representerar hela matchningen av reguljära uttryck. Varje efterföljande medlem representerar en matchad underuttryck. Namngivna insamlade grupper lagras i samlingen efter numrerade insamlade grupper.
Programmatiskt genom att ange underuttrycksnamnet till GroupCollection objektets indexerare (i C#) eller dess Item[] egenskap (i Visual Basic).
Ett enkelt mönster för reguljära uttryck visar hur numrerade (namnlösa) och namngivna grupper kan refereras antingen programmatiskt eller med hjälp av syntax för reguljärt uttrycksspråk. Det reguljära uttrycket ((?<One>abc)\d+)?(?<Two>xyz)(.*) genererar följande grupper efter nummer och efter namn. Den första insamlingsgruppen (nummer 0) refererar alltid till hela mönstret. (Namngivna grupper sorteras alltid sist.)
| Antal | Name | Mönster |
|---|---|---|
| 0 | 0 (standardnamn) | ((?<One>abc)\d+)?(?<Two>xyz)(.*) |
| 1 | 1 (standardnamn) | ((?<One>abc)\d+) |
| 2 | 2 (standardnamn) | (.*) |
| 3 | En | (?<One>abc) |
| 4 | Två | (?<Two>xyz) |
I följande exempel visas ett reguljärt uttryck som identifierar duplicerade ord och ordet som omedelbart följer varje duplicerat ord. Mönstret för reguljära uttryck definierar två namngivna underuttryck: duplicateWord, som representerar det duplicerade ordet och nextWord, som representerar ordet som följer det duplicerade ordet.
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'.
Mönster för reguljära uttryck är följande:
(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)
Följande tabell visar hur det reguljära uttrycket tolkas.
| Mönster | beskrivning |
|---|---|
(?<duplicateWord>\w+) |
Matcha ett eller flera ordtecken. Ge den här insamlingsgruppen duplicateWordnamnet . |
\s |
Matcha ett blankstegstecken. |
\k<duplicateWord> |
Matcha strängen från den insamlade gruppen med namnet duplicateWord. |
\W |
Matcha ett tecken som inte är ord, inklusive blanksteg och skiljetecken. Detta förhindrar att mönster för reguljära uttryck matchar ett ord som börjar med ordet från den första insamlade gruppen. |
(?<nextWord>\w+) |
Matcha ett eller flera ordtecken. Ge den här insamlingsgruppen nextWordnamnet . |
Ett gruppnamn kan upprepas i ett reguljärt uttryck. Det är till exempel möjligt att fler än en grupp får namnet digit, vilket visas i följande exempel. När det gäller dubbletter av namn bestäms objektets Group värde av den senaste lyckade avbildningen i indatasträngen. Dessutom fylls den CaptureCollection med information om varje avbildning precis som om gruppnamnet inte duplicerades.
I följande exempel innehåller det reguljära uttrycket \D+(?<digit>\d+)\D+(?<digit>\d+)? två förekomster av en grupp med namnet digit. Den första digit namngivna gruppen samlar in ett eller flera tecken. Den andra digit namngivna gruppen fångar antingen noll eller en förekomst av ett eller flera tecken. Som utdata från exemplet visar, om den andra insamlingsgruppen matchar text, definierar värdet för den texten objektets Group värde. Om den andra insamlingsgruppen inte matchar indatasträngen definierar värdet för den senaste lyckade matchningen objektets Group värde.
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
Följande tabell visar hur det reguljära uttrycket tolkas.
| Mönster | beskrivning |
|---|---|
\D+ |
Matcha ett eller flera tecken som inte är decimaltecken. |
(?<digit>\d+) |
Matcha ett eller flera decimaltecken. Tilldela matchningen till den namngivna digit gruppen. |
\D+ |
Matcha ett eller flera tecken som inte är decimaltecken. |
(?<digit>\d+)? |
Matcha noll eller en förekomst av ett eller flera decimaltecken. Tilldela matchningen till den namngivna digit gruppen. |
Balansera gruppdefinitioner
En definition för balanseringsgrupp tar bort definitionen av en tidigare definierad grupp och lagrar intervallet mellan den tidigare definierade gruppen och den aktuella gruppen i den aktuella gruppen. Den här grupperingskonstruktionen har följande format:
(?<name1-name2>subexpression)
eller:
(?'name1-name2' subexpression)
Här är name1 den aktuella gruppen (valfritt), name2 är en tidigare definierad grupp och underuttryck är ett giltigt mönster för reguljära uttryck. Definitionen för balanserande grupp tar bort definitionen av name2 och lagrar intervallet mellan name2 och name1 i namn1. Om ingen namn 2-grupp har definierats går matchningen bakåt. Eftersom borttagningen av den sista definitionen av name2 visar den tidigare definitionen av name2 kan du använda stacken med avbildningar för gruppnamn2 som en räknare för att hålla reda på kapslade konstruktioner som parenteser eller inledande och avslutande hakparenteser.
Definitionen för balanserande grupp använder name2 som en stack. Starttecknet för varje kapslad konstruktion placeras i gruppen och i dess Group.Captures samling. När det avslutande tecknet matchas tas motsvarande öppningstecken bort från gruppen och Captures samlingen minskas med ett. När de inledande och avslutande tecknen i alla kapslade konstruktioner har matchats är namn 2 tomt.
Kommentar
När du har modifierat det reguljära uttrycket i följande exempel för att använda lämpligt inledande och avslutande tecken för en kapslad konstruktion kan du använda det för att hantera de flesta kapslade konstruktioner, till exempel matematiska uttryck eller rader med programkod som innehåller flera kapslade metodanrop.
I följande exempel används en balansgruppsdefinition för att matcha hakparenteser för vänster och höger vinkel (<>) i en indatasträng. Exemplet definierar två namngivna grupper och OpenClose, som används som en stack för att spåra matchande par med vinkelpar. Varje infångad vänster vinkelparentes skjuts in i insamlingssamlingen Open för gruppen, och varje infångad höger vinkelparentes skjuts in i samlingen av Close gruppen. Balanseringsgruppens definition säkerställer att det finns en matchande höger vinkelparentes för varje vänster vinkelparentes. Om det inte finns utvärderas den sista underordnad, (?(Open)(?!)), endast om Open gruppen inte är tom (och därför om alla kapslade konstruktioner inte har stängts). Om det slutliga undermönstret utvärderas misslyckas matchningen eftersom (?!) undermönstret är ett negativt lookahead-intyg med noll bredd som alltid misslyckas.
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>
Mönster för reguljära uttryck är:
^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$
Det reguljära uttrycket tolkas på följande sätt:
| Mönster | beskrivning |
|---|---|
^ |
Börja i början av strängen. |
[^<>]* |
Matcha noll eller fler tecken som inte är vänster- eller högervinkelparenteser. |
(?'Open'<) |
Matcha en vänster vinkelparentes och tilldela den till en grupp med namnet Open. |
[^<>]* |
Matcha noll eller fler tecken som inte är vänster- eller högervinkelparenteser. |
((?'Open'<)[^<>]*)+ |
Matcha en eller flera förekomster av en vänster vinkelparentes följt av noll eller fler tecken som inte är vänster- eller högervinkelparenteser. Det här är den andra insamlingsgruppen. |
(?'Close-Open'>) |
Matcha en höger vinkelparentes, tilldela delsträngen Open mellan gruppen och den aktuella gruppen till Close gruppen och ta bort definitionen för Open gruppen. |
[^<>]* |
Matcha noll eller fler förekomster av något tecken som varken är vänster eller höger vinkelparentes. |
((?'Close-Open'>)[^<>]*)+ |
Matcha en eller flera förekomster av en höger vinkelparentes, följt av noll eller flera förekomster av något tecken som varken är vänster eller höger vinkelparentes. När du matchar den högra vinkelparentesen tilldelar du delsträngen Open mellan gruppen och den aktuella gruppen till Close gruppen och tar bort definitionen för Open gruppen. Det här är den tredje insamlingsgruppen. |
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* |
Matcha noll eller flera förekomster av följande mönster: en eller flera förekomster av en vänster vinkelparentes följt av noll eller flera icke-vinkelparentestecken, följt av en eller flera förekomster av en höger vinkelparentes, följt av noll eller flera förekomster av icke-vinkelparenteser. När du matchar den högra vinkelparentesen Open tar du bort definitionen för gruppen och tilldelar delsträngen Open mellan gruppen och den aktuella gruppen till Close gruppen. Det här är den första insamlingsgruppen. |
(?(Open)(?!)) |
Om gruppen Open finns överger du matchningen om en tom sträng kan matchas, men flytta inte fram positionen för motorn för reguljära uttryck i strängen. Det här är en negativ lookahead-försäkran med noll bredd. Eftersom en tom sträng alltid finns implicit i en indatasträng misslyckas alltid den här matchning. Fel i den här matchningen indikerar att vinkelparenteserna inte är balanserade. |
$ |
Matcha slutet av indatasträngen. |
Den sista underuttryckningen, (?(Open)(?!)), anger om kapslingskonstruktionerna i indatasträngen är korrekt balanserade (till exempel om varje vänster vinkelparentes matchas av en höger vinkelparentes). Den använder villkorsstyrd matchning baserat på en giltig infångad grupp. Mer information finns i Alternationskonstruktioner. Om gruppen Open har definierats försöker motorn för reguljära uttryck matcha underuttrycket (?!) i indatasträngen. Gruppen Open bör endast definieras om kapslingskonstruktionerna är obalanserade. Därför bör mönstret som ska matchas i indatasträngen vara ett mönster som alltid gör att matchningen misslyckas. I det här fallet (?!) är en negativ lookahead-försäkran med noll bredd som alltid misslyckas, eftersom en tom sträng alltid implicit finns vid nästa position i indatasträngen.
I exemplet utvärderar motorn för reguljära uttryck indatasträngen "<abc><mno<xyz>>" enligt följande tabell.
| Steg | Mönster | Resultat |
|---|---|---|
| 1 | ^ |
Startar matchningen i början av indatasträngen |
| 2 | [^<>]* |
Söker efter icke-vinkelparentestecken före vänster vinkelparentes; hittar inga matchningar. |
| 3 | (((?'Open'<) |
Matchar den vänstra vinkelparentesen i "<abc>" och tilldelar den Open till gruppen. |
| 4 | [^<>]* |
Matchar "abc". |
| 5 | )+ |
"<abc" är värdet för den andra insamlade gruppen. Nästa tecken i indatasträngen är inte en vänster vinkelparentes, så motorn för reguljära uttryck loopar inte tillbaka till (?'Open'<)[^<>]*) undermönstret. |
| 6 | ((?'Close-Open'>) |
Matchar den högra vinkelparentesen i "<abc>", tilldelar "abc", vilket är delsträngen Open mellan gruppen och den högra vinkelparentesen Close , till gruppen och tar bort gruppens aktuella värde ("<") Open och lämnar den tom. |
| 7 | [^<>]* |
Söker efter icke-vinkelparentestecken efter den högra vinkelparentesen; hittar inga matchningar. |
| 8 | )+ |
Värdet för den tredje insamlade gruppen är ">". Nästa tecken i indatasträngen är inte en höger vinkelparentes, så motorn för reguljära uttryck loopar inte tillbaka till ((?'Close-Open'>)[^<>]*) undermönstret. |
| 9 | )* |
Värdet för den första insamlade gruppen är "<abc>". Nästa tecken i indatasträngen är en vänster vinkelparentes, så motorn för reguljära uttryck loopar tillbaka till (((?'Open'<) undermönstret. |
| 10 | (((?'Open'<) |
Matchar den vänstra vinkelparentesen i "<mno" och tilldelar den Open till gruppen. Samlingen Group.Captures har nu ett enda värde, "<". |
| 11 | [^<>]* |
Matchar "mno". |
| 12 | )+ |
"<mno" är värdet för den andra insamlade gruppen. Nästa tecken i indatasträngen är en vänster vinkelparentes, så motorn för reguljära uttryck loopar tillbaka till (?'Open'<)[^<>]*) undermönstret. |
| 13 | (((?'Open'<) |
Matchar den vänstra vinkelparentesen i "<xyz>" och tilldelar den Open till gruppen. Samlingen Group.Captures av Open gruppen innehåller nu två avbildningar: den vänstra vinkelparentesen från "<mno" och den vänstra vinkelparentesen från "<xyz>". |
| 14 | [^<>]* |
Matchar "xyz". |
| 15 | )+ |
"<xyz" är värdet för den andra insamlade gruppen. Nästa tecken i indatasträngen är inte en vänster vinkelparentes, så motorn för reguljära uttryck loopar inte tillbaka till (?'Open'<)[^<>]*) undermönstret. |
| 16 | ((?'Close-Open'>) |
Matchar den högra vinkelparentesen i "<xyz>". "xyz", tilldelar delsträngen Open mellan gruppen och den högra vinkelparentesen Close till gruppen och tar bort gruppens aktuella värde Open . Värdet för den tidigare avbildningen (den vänstra vinkelparentesen i "<mno") blir gruppens aktuella värde Open . Samlingen Captures av Open gruppen innehåller nu en enda avbildning, den vänstra vinkelparentesen från "<xyz>". |
| 17 | [^<>]* |
Söker efter icke-vinkelparentestecken; hittar inga matchningar. |
| 18 | )+ |
Värdet för den tredje insamlade gruppen är ">". Nästa tecken i indatasträngen är en höger vinkelparentes, så motorn för reguljära uttryck loopar tillbaka till ((?'Close-Open'>)[^<>]*) undermönstret. |
| 19 | ((?'Close-Open'>) |
Matchar den sista högra vinkelparentesen i "xyz>>", tilldelar "mno<xyz>" (delsträngen Open mellan gruppen och den högra vinkelparentesen Close ) till gruppen och tar bort gruppens aktuella värde Open . Gruppen Open är nu tom. |
| 20 | [^<>]* |
Söker efter icke-vinkelparentestecken; hittar inga matchningar. |
| 21 | )+ |
Värdet för den tredje insamlade gruppen är ">". Nästa tecken i indatasträngen är inte en höger vinkelparentes, så motorn för reguljära uttryck loopar inte tillbaka till ((?'Close-Open'>)[^<>]*) undermönstret. |
| 22 | )* |
Värdet för den första insamlade gruppen är "<mno<xyz>>". Nästa tecken i indatasträngen är inte en vänster vinkelparentes, så motorn för reguljära uttryck loopar inte tillbaka till (((?'Open'<) undermönstret. |
| 23 | (?(Open)(?!)) |
Gruppen Open har inte definierats, så ingen matchning görs. |
| 24 | $ |
Matchar slutet av indatasträngen. |
Icke-kapslingsgrupper
Följande grupperingskonstruktion avbildar inte den delsträng som matchas av en underuttryck:
(?:subexpression)
Här är underuttryck ett giltigt mönster för reguljära uttryck. Den icke-kapslande gruppkonstruktionen används vanligtvis när en kvantifierare tillämpas på en grupp, men de delsträngar som samlas in av gruppen är inte intressanta.
Kommentar
Om ett reguljärt uttryck innehåller kapslade grupperingskonstruktioner gäller inte en yttre icke-kapslad gruppkonstruktion för de inre kapslade gruppkonstruktionerna.
I följande exempel visas ett reguljärt uttryck som innehåller grupper som inte kapslar in. Observera att utdata inte innehåller några insamlade grupper.
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.
Det reguljära uttrycket (?:\b(?:\w+)\W*)+\. matchar en mening som avslutas med en punkt. Eftersom det reguljära uttrycket fokuserar på meningar och inte på enskilda ord används grupperingskonstruktioner uteslutande som kvantifierare. Mönster för reguljära uttryck tolkas enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
(?:\w+) |
Matcha ett eller flera ordtecken. Tilldela inte den matchade texten till en grupperad grupp. |
\W* |
Matcha noll eller fler tecken som inte är ord. |
(?:\b(?:\w+)\W*)+ |
Matcha mönstret för ett eller flera ordtecken som börjar vid en ordgräns, följt av noll eller fler tecken som inte är ord, en eller flera gånger. Tilldela inte den matchade texten till en grupperad grupp. |
\. |
Matcha en punkt. |
Gruppalternativ
Följande grupperingskonstruktion tillämpar eller inaktiverar de angivna alternativen i en underuttryck:
(?imnsx-imnsx:subexpression)
Här är underuttryck ett giltigt mönster för reguljära uttryck. Aktiverar till exempel (?i-s:) skiftlägeskänslighet och inaktiverar enkelradsläge. Mer information om de infogade alternativ som du kan ange finns i Alternativ för reguljära uttryck.
Kommentar
Du kan ange alternativ som gäller för ett helt reguljärt uttryck i stället för en underuttryck med hjälp av en System.Text.RegularExpressions.Regex klasskonstruktor eller en statisk metod. Du kan också ange infogade alternativ som gäller efter en viss punkt i ett reguljärt uttryck med hjälp av språkkonstruktionen (?imnsx-imnsx) .
Gruppalternativskonstruktionen är inte en samlande grupp. Det vill: även om någon del av en sträng som fångas upp av underuttryck ingår i matchningen, ingår den inte i en grupperad grupp eller används för att fylla i GroupCollection objektet.
Till exempel använder det reguljära uttrycket \b(?ix: d \w+)\s i följande exempel infogade alternativ i en grupperingskonstruktion för att aktivera skiftlägesokänslig matchning och ignorera tomt mönsterutrymme för att identifiera alla ord som börjar med bokstaven "d". Det reguljära uttrycket definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
(?ix: d \w+) |
Om du använder skiftlägeskänslig matchning och ignorerar blanksteg i det här mönstret matchar du ett "d" följt av ett eller flera ordtecken. |
\s |
Matcha ett blankstegstecken. |
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.
Positiva lookahead-försäkran med noll bredd
Följande grupperingskonstruktion definierar en positiv lookahead-försäkran med noll bredd:
(?=subexpression)
Här är underuttryck valfritt mönster för reguljära uttryck. För att en matchning ska lyckas måste indatasträngen matcha mönster för reguljära uttryck i underuttryck, även om den matchade delsträngen inte ingår i matchningsresultatet. En positiv lookahead-försäkran med noll bredd backar inte.
Normalt hittas en positiv lookahead-försäkran med noll bredd i slutet av ett reguljärt uttrycksmönster. Den definierar en delsträng som måste hittas i slutet av en sträng för att en matchning ska ske, men som inte ska ingå i matchningen. Det är också användbart för att förhindra överdriven backtracking. Du kan använda en positiv lookahead-försäkran med noll bredd för att säkerställa att en viss infångad grupp börjar med text som matchar en delmängd av mönstret som definierats för den insamlade gruppen. Om en samlande grupp till exempel matchar ordtecken i följd kan du använda en positiv lookahead-försäkran med noll bredd för att kräva att det första tecknet är ett alfabetiskt versalt tecken.
I följande exempel används en positiv lookahead-försäkran med noll bredd för att matcha ordet som föregår verbet "är" i indatasträngen.
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'.
Det reguljära uttrycket \b\w+(?=\sis\b) tolkas som det visas i följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
\w+ |
Matcha ett eller flera ordtecken. |
(?=\sis\b) |
Avgör om ordet tecken följs av ett blankstegstecken och strängen "är", som slutar på en ordgräns. I så fall lyckas matchningen. |
Negativa lookahead-försäkran med noll bredd
Följande grupperingskonstruktion definierar en negativ lookahead-försäkran med noll bredd:
(?!subexpression)
Här är underuttryck valfritt mönster för reguljära uttryck. För att matchningen ska lyckas får indatasträngen inte matcha mönstret för reguljära uttryck i underuttryck, även om den matchade strängen inte ingår i matchningsresultatet.
En negativ lookahead-försäkran med noll bredd används vanligtvis i början eller i slutet av ett reguljärt uttryck. I början av ett reguljärt uttryck kan det definiera ett specifikt mönster som inte ska matchas när början av det reguljära uttrycket definierar ett liknande men mer allmänt mönster som ska matchas. I det här fallet används det ofta för att begränsa backtracking. I slutet av ett reguljärt uttryck kan det definiera en underuttryck som inte kan inträffa i slutet av en matchning.
I följande exempel definieras ett reguljärt uttryck som använder en lookahead-försäkran med noll bredd i början av det reguljära uttrycket för att matcha ord som inte börjar med "un".
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
Det reguljära uttrycket \b(?!un)\w+\b tolkas som det visas i följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
(?!un) |
Ta reda på om de följande två tecknen är "un". Om de inte är det är en matchning möjlig. |
\w+ |
Matcha ett eller flera ordtecken. |
\b |
Avsluta matchningen vid en ordgräns. |
I följande exempel definieras ett reguljärt uttryck som använder en lookahead-försäkran med noll bredd i slutet av det reguljära uttrycket för att matcha ord som inte slutar med ett skiljetecken.
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
Det reguljära uttrycket \b\w+\b(?!\p{P}) tolkas som det visas i följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
\w+ |
Matcha ett eller flera ordtecken. |
\b |
Avsluta matchningen vid en ordgräns. |
\p{P}) |
Om nästa tecken inte är en skiljeteckensymbol (till exempel en punkt eller ett kommatecken) lyckas matchningen. |
Positiva utseenden med noll bredd finns bakom försäkran
Följande grupperingskonstruktion definierar en positiv lookbehind-försäkran med noll bredd:
(?<=subexpression)
Här är underuttryck valfritt mönster för reguljära uttryck. För att en matchning ska lyckas måste underuttryck ske vid indatasträngen till vänster om den aktuella positionen, även om subexpression den inte ingår i matchningsresultatet. En positiv lookhind-försäkran med noll bredd backar inte.
Positiva lookbehind-försäkran med noll bredd används vanligtvis i början av reguljära uttryck. Det mönster som de definierar är en förutsättning för en matchning, även om det inte är en del av matchningsresultatet.
Följande exempel matchar till exempel årets två sista siffror för 2000-talet (det vill säga att siffrorna "20" föregår den matchade strängen).
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
Mönster för (?<=\b20)\d{2}\b reguljära uttryck tolkas enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\d{2} |
Matcha två decimalsiffror. |
(?<=\b20) |
Fortsätt matchningen om de två decimaltalen föregås av decimaltalen "20" på en ordgräns. |
\b |
Avsluta matchningen vid en ordgräns. |
Positiva utseenden med noll bredd används också för att begränsa bakåtspårningen när det sista tecknet eller tecknen i en samlad grupp måste vara en delmängd av de tecken som matchar gruppens mönster för reguljära uttryck. Om en grupp till exempel samlar in alla ordtecken i följd kan du använda en positiv lookbehind-försäkran med noll bredd för att kräva att det sista tecknet är alfabetiskt.
Negativa lookbehind-försäkran med noll bredd
Följande grupperingskonstruktion definierar en negativ lookbehind-försäkran med noll bredd:
(?<!subexpression)
Här är underuttryck valfritt mönster för reguljära uttryck. För att en matchning ska lyckas får underuttryck inte ske vid indatasträngen till vänster om den aktuella positionen. Alla delsträngar som inte matchar subexpression ingår dock inte i matchningsresultatet.
Negativa lookbehind-kontroller med noll bredd används vanligtvis i början av reguljära uttryck. Mönstret som de definierar utesluter en matchning i strängen som följer. De används också för att begränsa backtracking när det sista tecknet eller tecknen i en samlad grupp inte får vara ett eller flera av de tecken som matchar gruppens reguljära uttrycksmönster. Om en grupp till exempel samlar in alla ordtecken i följd kan du använda en positiv lookbehind-försäkran med noll bredd för att kräva att det sista tecknet inte är ett understreck (_).
Följande exempel matchar datumet för en veckodag som inte är en helg (det vill säga det vill säga varken lördag eller söndag).
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
Mönster för (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b reguljära uttryck tolkas enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
\w+ |
Matcha ett eller flera ordtecken följt av ett blankstegstecken. |
\d{1,2}, |
Matcha antingen en eller två decimalsiffror följt av ett blankstegstecken och ett kommatecken. |
\d{4}\b |
Matcha fyra decimaler och avsluta matchningen vid en ordgräns. |
(?<!(Saturday|Sunday) ) |
Om matchen föregås av något annat än strängarna "Lördag" eller "Söndag" följt av ett blanksteg, lyckas matchen. |
Atomiska grupper
Följande grupperingskonstruktion representerar en atomisk grupp (känd i vissa andra reguljära uttrycksmotorer som en subexpression som inte bakåtspårar, en atomisk underuttryck eller en underuttryck endast en gång):
(?>subexpression)
Här är underuttryck valfritt mönster för reguljära uttryck.
Vanligtvis, om ett reguljärt uttryck innehåller ett valfritt eller alternativt matchningsmönster och en matchning inte lyckas, kan motorn för reguljära uttryck förgrenas i flera riktningar för att matcha en indatasträng med ett mönster. Om en matchning inte hittas när den tar den första grenen kan motorn för reguljära uttryck säkerhetskopiera eller backa tillbaka till den punkt där den tog den första matchningen och försöka matcha med hjälp av den andra grenen. Den här processen kan fortsätta tills alla grenar har provats.
Språkkonstruktionen (?>underuttryck) inaktiverar backtracking. Motorn för reguljära uttryck matchar så många tecken som möjligt i indatasträngen. När ingen ytterligare matchning är möjlig backar den inte för att försöka med alternativa mönstermatchningar. (Det innebär att subexpressionen endast matchar strängar som skulle matchas enbart av underuttrycket. Den försöker inte matcha en sträng baserat på underuttryck och eventuella underuttryck som följer den.)
Det här alternativet rekommenderas om du vet att backtracking inte lyckas. Om du förhindrar att motorn för reguljära uttryck utför onödig sökning förbättras prestandan.
I följande exempel visas hur en atomisk grupp ändrar resultatet av en mönstermatchning. Det bakåtspårande reguljära uttrycket matchar en serie upprepade tecken följt av ytterligare en förekomst av samma tecken på en ordgräns, men det icke-bakåtspårande reguljära uttrycket gör det inte.
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
Reguljärt uttryck (?>(\w)\1+).\b som inte spåras definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
(\w) |
Matcha ett enstaka ordtecken och tilldela det till den första insamlingsgruppen. |
\1+ |
Matcha värdet för den första insamlade delsträngen en eller flera gånger. |
. |
Matcha alla tecken. |
\b |
Avsluta matchningen på en ordgräns. |
(?>(\w)\1+) |
Matcha en eller flera förekomster av ett duplicerat ordtecken, men backa inte för att matcha det sista tecknet på en ordgräns. |
Grupperingskonstruktioner och reguljära uttrycksobjekt
Delsträngar som matchas av en gruppering av reguljära uttryck representeras av System.Text.RegularExpressions.Group objekt som kan hämtas från objektet System.Text.RegularExpressions.GroupCollection som returneras av Match.Groups egenskapen. Objektet GroupCollection fylls i på följande sätt:
- Det första Group objektet i samlingen (objektet vid index noll) representerar hela matchningen.
- Nästa uppsättning Group objekt representerar icke namngivna (numrerade) insamlingsgrupper. De visas i den ordning de definieras i det reguljära uttrycket, från vänster till höger. Indexvärdena för dessa grupper sträcker sig från 1 till antalet icke namngivna insamlingsgrupper i samlingen. (Indexet för en viss grupp motsvarar dess numrerade backreference. Mer information om backreferences finns i Backreference Constructs.)
- Den sista uppsättningen objekt representerar namngivna insamlingsgrupper Group . De visas i den ordning de definieras i det reguljära uttrycket, från vänster till höger. Indexvärdet för den första namngivna insamlingsgruppen är ett större än indexet för den senaste icke namngivna insamlingsgruppen. Om det inte finns några icke namngivna grupper i reguljära uttryck är indexvärdet för den första namngivna insamlingsgruppen ett.
Om du tillämpar en kvantifierare på en insamlingsgrupp återspeglar motsvarande Group objekts Capture.Valueegenskaper , Capture.Indexoch Capture.Length den sista delsträngen som fångas av en insamlingsgrupp. Du kan hämta en fullständig uppsättning delsträngar som samlas in av grupper som har kvantifierare från objektet CaptureCollection som returneras av Group.Captures egenskapen.
I följande exempel klargörs relationen mellan objekten Group och Capture .
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'
Mönster för (\b(\w+)\W+)+ reguljära uttryck extraherar enskilda ord från en sträng. Den definieras enligt följande tabell.
| Mönster | beskrivning |
|---|---|
\b |
Starta matchningen vid en ordgräns. |
(\w+) |
Matcha ett eller flera ordtecken. Tillsammans bildar dessa tecken ett ord. Det här är den andra insamlingsgruppen. |
\W+ |
Matcha ett eller flera tecken som inte är ord. |
(\b(\w+)\W+) |
Matcha mönstret för ett eller flera ordtecken följt av ett eller flera icke-ordtecken en eller flera gånger. Det här är den första insamlingsgruppen. |
Den andra insamlingsgruppen matchar varje ord i meningen. Den första insamlingsgruppen matchar varje ord tillsammans med skiljetecken och blanksteg som följer ordet. Objektet Group vars index är 2 innehåller information om texten som matchas av den andra insamlingsgruppen. Den fullständiga uppsättningen ord som samlas in av insamlingsgruppen är tillgängliga från objektet CaptureCollection som returneras av Group.Captures egenskapen.
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för