Share via

Diverse konstruktioner i reguljära uttryck

  • Artikel

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 .

Se även