Diverse konstruktioner i reguljära uttryck
Reguljära uttryck i .NET innehåller tre olika språkkonstruktioner. Med den ena kan du aktivera eller inaktivera specifika matchningsalternativ mitt i ett mönster för reguljära uttryck. Med de återstående två kan du inkludera kommentarer i ett reguljärt uttryck.
Infogade alternativ
Du kan ange eller inaktivera specifika mönstermatchningsalternativ för en del av ett reguljärt uttryck med hjälp av syntaxen
(?imnsx-imnsx)
Du listar de alternativ som du vill aktivera efter frågetecknet och de alternativ som du vill inaktivera efter minustecknet. I följande tabell beskrivs varje alternativ. Mer information om varje alternativ finns i Alternativ för reguljära uttryck.
| Alternativ | Description |
|---|---|
i |
Skiftlägesokänslig matchning. |
m |
Flerradsläge. |
n |
Endast explicita avbildningar. (Parenteser fungerar inte som insamlingsgrupper.) |
s |
Enkelradsläge. |
x |
Ignorera ej inkapslade blanksteg och tillåt kommentarer i x-läge. |
Alla ändringar i reguljära uttrycksalternativ som definierats av konstruktionen (?imnsx-imnsx) gäller till slutet av den omslutande gruppen.
Kommentar
Konstruktionen (?imnsx-imnsx:för underuttrycksgruppering) ger identiska funktioner för en underuttryck. Mer information finns i Grupperingskonstruktioner.
I följande exempel används ialternativen , noch x för att aktivera skiftlägeskänslighet och explicita avbildningar, och för att ignorera blanksteg i mönstret för reguljära uttryck mitt i ett reguljärt uttryck.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern;
string input = "double dare double Double a Drooling dog The Dreaded Deep";
pattern = @"\b(D\w+)\s(d\w+)\b";
// Match pattern using default options.
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine(match.Value);
if (match.Groups.Count > 1)
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
Console.WriteLine(" Group {0}: {1}", ctr, match.Groups[ctr].Value);
}
Console.WriteLine();
// Change regular expression pattern to include options.
pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
// Match new pattern with options.
foreach (Match match in Regex.Matches(input, pattern))
{
Console.WriteLine(match.Value);
if (match.Groups.Count > 1)
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:
// Drooling dog
// Group 1: Drooling
// Group 2: dog
//
// Drooling dog
// Group 1: 'Drooling'
// Dreaded Deep
// Group 1: 'Dreaded'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String
Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"
pattern = "\b(D\w+)\s(d\w+)\b"
' Match pattern using default options.
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
If match.Groups.Count > 1 Then
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End If
Next
Console.WriteLine()
' Change regular expression pattern to include options.
pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
' Match new pattern with options.
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine(match.Value)
If match.Groups.Count > 1 Then
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
Next
End If
Next
End Sub
End Module
' The example displays the following output:
' Drooling dog
' Group 1: Drooling
' Group 2: dog
'
' Drooling dog
' Group 1: 'Drooling'
' Dreaded Deep
' Group 1: 'Dreaded'
Exemplet definierar två reguljära uttryck. Den första, \b(D\w+)\s(d\w+)\b, matchar två ord i följd som börjar med ett versalt "D" och ett gemener "d". Det andra reguljära uttrycket, \b(D\w+)(?ixn) \s (d\w+) \b, använder infogade alternativ för att ändra det här mönstret enligt beskrivningen i följande tabell. En jämförelse av resultaten bekräftar effekten av konstruktionen (?ixn) .
| Mönster | beskrivning |
|---|---|
\b |
Börja vid en ordgräns. |
(D\w+) |
Matcha versalt "D" följt av ett eller flera ordtecken. Det här är den första insamlingsgruppen. |
(?ixn) |
Från och med nu gör du jämförelser skiftlägesokänsliga, gör endast explicita avbildningar och ignorerar blanksteg i mönstret för reguljära uttryck. |
\s |
Matcha ett blankstegstecken. |
(d\w+) |
Matcha ett versalt eller gemener "d" följt av ett eller flera ordtecken. Den här gruppen samlas inte in eftersom n alternativet (explicit avbildning) har aktiverats. |
\b |
Matcha en ordgräns. |
Infogad kommentar
Med kommentarskonstruktionen (?#)kan du inkludera en infogad kommentar i ett reguljärt uttryck. Motorn för reguljära uttryck använder inte någon del av kommentaren i mönstermatchning, även om kommentaren ingår i strängen som returneras av Regex.ToString metoden. Kommentaren slutar vid den första avslutande parentesen.
I följande exempel upprepas det första reguljära uttrycksmönstret från exemplet i föregående avsnitt. Den lägger till två infogade kommentarer i det reguljära uttrycket för att ange om jämförelsen är skiftlägeskänslig. Mönster för reguljära uttryck, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, definieras på följande sätt.
| Mönster | beskrivning |
|---|---|
\b |
Börja vid en ordgräns. |
(?# case-sensitive comparison) |
En kommentar. Det påverkar inte mönstermatchningsbeteendet. |
(D\w+) |
Matcha versalt "D" följt av ett eller flera ordtecken. Det här är den första insamlingsgruppen. |
\s |
Matcha ett blankstegstecken. |
(?ixn) |
Från och med nu gör du jämförelser skiftlägesokänsliga, gör endast explicita avbildningar och ignorerar blanksteg i mönstret för reguljära uttryck. |
(?#case-insensitive comparison) |
En kommentar. Det påverkar inte mönstermatchningsbeteendet. |
(d\w+) |
Matcha ett versalt eller gemener "d" följt av ett eller flera ordtecken. Det här är den andra insamlingsgruppen. |
\b |
Matcha en ordgräns. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b";
Regex rgx = new Regex(pattern);
string input = "double dare double Double a Drooling dog The Dreaded Deep";
Console.WriteLine("Pattern: " + pattern.ToString());
// Match pattern using default options.
foreach (Match match in rgx.Matches(input))
{
Console.WriteLine(match.Value);
if (match.Groups.Count > 1)
{
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:
// Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
// arison)d\w+)\b
// Drooling dog
// Group 1: Drooling
// Dreaded Deep
// Group 1: Dreaded
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b"
Dim rgx As New Regex(pattern)
Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"
Console.WriteLine("Pattern: " + pattern.ToString())
' Match pattern using default options.
For Each match As Match In rgx.Matches(input)
Console.WriteLine(match.Value)
If match.Groups.Count > 1 Then
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End If
Next
End Sub
End Module
' The example displays the following output:
' Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
' arison)d\w+)\b
' Drooling dog
' Group 1: Drooling
' Dreaded Deep
' Group 1: Dreaded
Kommentar från slutet av rad
Ett taltecken (#) markerar en kommentar i x-läge som börjar med tecknet unescaped # i slutet av mönstret för reguljära uttryck och fortsätter till slutet av raden. Om du vill använda den här konstruktionen x måste du antingen aktivera alternativet (via infogade alternativ) eller ange RegexOptions.IgnorePatternWhitespace värdet till parametern option när du instansierar Regex objektet eller anropar en statisk Regex metod.
I följande exempel visas kommentarskonstruktionen i slutet av raden. Den avgör om en sträng är en sammansatt formatsträng som innehåller minst ett formatobjekt. I följande tabell beskrivs konstruktionerna i det reguljära uttrycksmönstret:
\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.
| Mönster | beskrivning |
|---|---|
\{ |
Matcha en inledande klammerparentes. |
\d+ |
Matcha en eller flera decimaler. |
(,-*\d+)* |
Matcha noll eller en förekomst av ett kommatecken följt av ett valfritt minustecken följt av en eller flera decimaler. |
(\:\w{1,4}?)* |
Matcha noll eller en förekomst av ett kolon följt av ett till fyra, men så få som möjligt, blankstegstecken. |
\} |
Matcha en avslutande klammerparentes. |
(?x) |
Aktivera alternativet ignorera mönstret tomt utrymme så att kommentaren i slutet av raden identifieras. |
# Looks for a composite format item. |
En kommentar från slutet av raden. |
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
string input = "{0,-3:F}";
Console.WriteLine("'{0}':", input);
if (Regex.IsMatch(input, pattern))
Console.WriteLine(" contains a composite format item.");
else
Console.WriteLine(" does not contain a composite format item.");
}
}
// The example displays the following output:
// '{0,-3:F}':
// contains a composite format item.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
Dim input As String = "{0,-3:F}"
Console.WriteLine("'{0}':", input)
If Regex.IsMatch(input, pattern) Then
Console.WriteLine(" contains a composite format item.")
Else
Console.WriteLine(" does not contain a composite format item.")
End If
End Sub
End Module
' The example displays the following output:
' '{0,-3:F}':
' contains a composite format item.
Observera att kommentaren i stället för att tillhandahålla konstruktionen (?x) i det reguljära uttrycket också kunde ha identifierats genom att anropa Regex.IsMatch(String, String, RegexOptions) metoden och skicka uppräkningsvärdet RegexOptions.IgnorePatternWhitespace .
