Zeichenklassen in regulären Ausdrücken

Eine Zeichenklasse definiert einen Satz von Zeichen, von denen jedes in einer Eingabezeichenfolge enthalten sein kann, damit eine Übereinstimmung vorliegt. Die Sprache für reguläre Ausdrücke in .NET unterstützt die folgenden Zeichenklassen:

• Positive Zeichengruppen. Ein Zeichen in der Eingabezeichenfolge muss mit einem Zeichen in einem angegebenen Zeichensatz übereinstimmen. Weitere Informationen finden Sie unter Positive Zeichengruppe.

• Negative Zeichengruppen. Ein Zeichen in der Eingabezeichenfolge darf nicht mit einem Zeichen in einem angegebenen Zeichensatz übereinstimmen. Weitere Informationen finden Sie unter Negative Zeichengruppe.

• Jedes Zeichen. Beim .-Zeichen (Punkt) in einem regulären Ausdruck handelt es sich um ein Platzhalterzeichen, das mit Ausnahme von \n mit jedem Zeichen übereinstimmt. Weitere Informationen finden Sie unter Alle Zeichen.

• Eine allgemeine Unicode-Kategorie oder ein benannter Block. Ein Zeichen in der Eingabezeichenfolge muss einer bestimmten Unicode-Kategorie oder einem zusammenhängenden Bereich von Unicode-Zeichen angehören, damit eine Übereinstimmung vorliegt. Weitere Informationen finden Sie unter Unicode-Kategorie oder Unicode-Block.

• Eine negative allgemeine Unicode-Kategorie oder ein benannter Block. Ein Zeichen in der Eingabezeichenfolge darf weder einer bestimmten Unicode-Kategorie noch einem zusammenhängenden Bereich von Unicode-Zeichen angehören, damit eine Übereinstimmung vorliegt. Weitere Informationen finden Sie unter Negative Unicode-Kategorie oder negativer Unicode-Block.

• Ein Wortzeichen. Ein Zeichen in der Eingabezeichenfolge kann allen Unicode-Kategorien angehören, die für Zeichen in Wörtern geeignet sind. Weitere Informationen finden Sie unter Wortzeichen.

• Ein Nicht-Wortzeichen. Ein Zeichen in der Eingabezeichenfolge kann jeder Unicode-Kategorie angehören, bei der es sich nicht um ein Wortzeichen handelt. Weitere Informationen finden Sie unter Nicht-Wortzeichen.

• Ein Leerzeichen. Ein Zeichen in der Eingabezeichenfolge kann sowohl jedes Unicode-Trennzeichen als auch jedes Zeichen aus einer Anzahl von Steuerzeichen sein. Weitere Informationen finden Sie unter Leerzeichen.

• Ein Nicht-Leerzeichen. Ein Zeichen in der Eingabezeichenfolge kann jedes Nicht-Leerzeichen sein. Weitere Informationen finden Sie unter Nicht-Leerzeichen.

• Eine Dezimalzahl. Ein Zeichen in der Eingabezeichenfolge kann jedes als Unicode-Dezimalzeichen klassifiziertes Zeichen sein. Weitere Informationen finden Sie unter Dezimalzeichen.

• Ein Nicht-Dezimalzeichen. Ein Zeichen in der Eingabezeichenfolge kann mit Ausnahme von Unicode-Dezimalzeichen jedes Zeichen sein. Weitere Informationen finden Sie unter Dezimalzeichen.

.NET unterstützt Zeichenklassensubtraktions-Ausdrücke. Hierdurch können Sie einen Zeichensatz definieren, der das Ergebnis des Ausschlusses einer Zeichenklasse von einer anderen darstellt. Weitere Informationen finden Sie unter Zeichenklassensubtraktion.

Positive Zeichengruppe: [ ]

In einer positiven Zeichengruppe wird eine Liste von Zeichen festgelegt. Wenn eine Eingabezeichenfolge eines dieser Zeichen aufweist, liegt eine Übereinstimmung vor. Diese Zeichenliste kann einzeln, als Bereich oder beides angegeben werden.

Die Syntax zum Angeben einer Liste einzelner Zeichen lautet wie folgt:

[*character_group*]

wobei Zeichen_Gruppe eine Liste der einzelnen Zeichen ist, die in der Eingabezeichenfolge vorkommen können, damit eine Übereinstimmung vorliegt. Zeichen_Gruppe kann aus einer beliebigen Kombination von mindestens einem Literalzeichen, Escapezeichen oder Zeichenklassen bestehen.

Die Syntax zum Angeben eines Zeichenbereichs lautet wie folgt:

[firstCharacter-lastCharacter]

wobei firstCharacter das Zeichen ist, mit dem der Bereich beginnt, und lastCharacter das Zeichen, mit dem der Bereich endet. Ein Zeichenbereich besteht aus einer Reihe zusammenhängender Zeichen, der durch Angabe des ersten Zeichens der Reihe, eines Bindestrichs (-) und des letzten Zeichens in der Reihe definiert wird. Zwei Zeichen sind zusammenhängend, wenn sie benachbarte Unicode-Codepunkte aufweisen. firstCharacter muss das Zeichen mit dem niedrigeren Codepunkt sein, lastCharacter muss das Zeichen mit dem höheren Codepunkt sein.

Um einen Bindestrich als nichtperipheres Mitglied einer Zeichengruppe einzuschließen, escapeen Sie ihn. Um z. B. eine Zeichengruppe für das Zeichen a und die Zeichen von - bis zu /erstellen, lautet [a\--/]die richtige Syntax.

In der folgenden Tabelle werden einige allgemeine Muster für reguläre Ausdrücke mit positiven Zeichenklassen aufgeführt.

Im folgenden Beispiel wird eine positive Zeichengruppe mit den Zeichen "a" und "e" definiert. Die Eingabezeichenfolge muss daher die Wörter "grey" oder "gray" (zwei gültige Schreibweisen für die englische Form von "grau") gefolgt von einem anderen Wort aufweisen, damit eine Übereinstimmung vorliegt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
        Dim input As String = "The gray wolf jumped over the grey wall."
        Dim matches As MatchCollection = Regex.Matches(input, pattern)
        For Each match As Match In matches
            Console.WriteLine($"'{match.Value}'")
        Next
    End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

Der reguläre Ausdruck gr[ae]y\s\S+?[\s|\p{P}] ist wie folgt definiert:

Im folgenden Beispiel liegen Übereinstimmungen mit Wörtern vor, die mit einem die oft ausgegebene Befehlszeilen Großbuchstaben beginnen. Der Großbuchstabenbereich von A bis Z wird durch den [A-Z]-Unterausdruck dargestellt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b[A-Z]\w*\b"
        Dim input As String = "A city Albany Zulu maritime Marseilles"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module

Der reguläre Ausdruck \b[A-Z]\w*\b wird entsprechend der Darstellung in der folgenden Tabelle definiert:

Negative Zeichengruppe: [^]

In einer negativen Zeichengruppe wird eine Liste von Zeichen festgelegt. Eine Eingabezeichenfolge darf keines dieser Zeichen aufweisen, damit eine Übereinstimmung vorliegt. Die Zeichenliste kann einzeln, als Bereich oder beides angegeben werden.

Die Syntax zum Angeben einer Liste einzelner Zeichen lautet wie folgt:

[*^character_group*]

wobei Zeichen_Gruppe eine Liste der einzelnen Zeichen ist, die in der Eingabezeichenfolge nicht vorkommen können, damit eine Übereinstimmung vorliegt. Zeichen_Gruppe kann aus einer beliebigen Kombination von mindestens einem Literalzeichen, Escapezeichen oder Zeichenklassen bestehen.

Die Syntax zum Angeben eines Zeichenbereichs lautet wie folgt:

[^*firstCharacter*-*lastCharacter*]

wobei firstCharacter das Zeichen ist, mit dem der Bereich beginnt, und lastCharacter das Zeichen, mit dem der Bereich endet. Ein Zeichenbereich besteht aus einer Reihe zusammenhängender Zeichen, der durch Angabe des ersten Zeichens der Reihe, eines Bindestrichs (-) und des letzten Zeichens in der Reihe definiert wird. Zwei Zeichen sind zusammenhängend, wenn sie benachbarte Unicode-Codepunkte aufweisen. firstCharacter muss das Zeichen mit dem niedrigeren Codepunkt sein, lastCharacter muss das Zeichen mit dem höheren Codepunkt sein.

Mindestens zwei Zeichenbereiche können miteinander verkettet werden. Beispiel: Verwenden Sie zum Angeben des Dezimalzeichenbereichs von "0" bis "9", des Kleinbuchstabenbereichs von "a" bis "f" und des Großbuchstabenbereichs von "A" bis "F" den Ausdruck [0-9a-fA-F].

Das Zirkumflexzeichen (^) am Anfang einer negativen Zeichengruppe ist obligatorisch und gibt an, dass es sich um eine negative anstelle einer positiven Zeichengruppe handelt.

In der folgenden Tabelle werden einige allgemeine Muster für reguläre Ausdrücke mit negativen Zeichengruppen aufgeführt.

Im folgenden Beispiel werden Übereinstimmungen für alle Wörter dargestellt, die mit den Zeichen "th" beginnen, wobei darauf kein "o" folgt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bth[^o]\w+\b"
        Dim input As String = "thought thing though them through thus " + _
                              "thorough this"
        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:
'       thing
'       them
'       through
'       thus
'       this

Der reguläre Ausdruck \bth[^o]\w+\b wird entsprechend der Darstellung in der folgenden Tabelle definiert:

Alle Zeichen: .

Das Punktzeichen (.) stimmt mit Ausnahme von \n (dem Zeichen für einen Zeilenumbruch) mit allen Zeichen überein. Hierfür gelten die folgenden beiden Qualifikationen:

• Wenn ein Muster für reguläre Ausdrücke durch die RegexOptions.Singleline-Option oder der Teil des Musters mit der .-Zeichenklasse durch die s-Option geändert wird, stimmt . mit allen Zeichen überein. Weitere Informationen finden Sie unter Optionen für reguläre Ausdrücke.

  Im folgenden Beispiel wird das unterschiedliche Verhalten der .-Zeichenklasse in der Standardeinstellung und mit der RegexOptions.Singleline-Option veranschaulicht. Der reguläre ^.+-Ausdruck beginnt am Anfang der Zeichenfolge und stimmt mit jedem Zeichen überein. Standardmäßig endet die Übereinstimmung am Ende der ersten Zeile. Das Muster für den regulären Ausdruck stimmt mit dem Wagenrücklaufzeichen (\r), jedoch nicht mit \n überein. Da die gesamte Eingabezeichenfolge von der RegexOptions.Singleline-Option als einzelne Zeile interpretiert wird, liegt für jedes enthaltene Zeichen eine Übereinstimmung vor, einschließlich \n.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = "^.+";
        string input = "This is one line and" + Environment.NewLine + "this is the second.";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(Regex.Escape(match.Value));
  
        Console.WriteLine();
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
           Console.WriteLine(Regex.Escape(match.Value));
     }
  }
  // The example displays the following output:
  //       This\ is\ one\ line\ and\r
  //
  //       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As String = "^.+"
          Dim input As String = "This is one line and" + vbCrLf + "this is the second."
          For Each match As Match In Regex.Matches(input, pattern)
              Console.WriteLine(Regex.Escape(match.Value))
          Next
          Console.WriteLine()
          For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
              Console.WriteLine(Regex.Escape(match.Value))
          Next
      End Sub
  End Module
  ' The example displays the following output:
  '       This\ is\ one\ line\ and\r
  '       
  '       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.
  

• In einer positiven oder negativen Zeichengruppe wird ein Punkt anstatt einer Zeichenklasse als Literalzeichen behandelt. Weitere Informationen finden Sie weiter oben in diesem Thema unter Positive Zeichengruppe und Negative Zeichengruppe. Im folgenden Beispiel wird zur Veranschaulichung ein regulärer Ausdruck definiert, der das Punktzeichen (.) sowohl als Zeichenklasse als auch als Mitglied einer positiven Zeichengruppe aufweist. Der reguläre Ausdruck \b.*[.?!;:](\s|\z) beginnt an einer Wortgrenze und stimmt bis zum Erreichen eines von fünf Interpunktionszeichen (einschließlich eines Punkts) mit jedem Zeichen überein. Anschließend liegt entweder eine Übereinstimmung mit einem Leerzeichen oder dem Ende der Zeichenfolge vor.

  using System;
  using System.Text.RegularExpressions;
  
  public class Example
  {
     public static void Main()
     {
        string pattern = @"\b.*[.?!;:](\s|\z)";
        string input = "this. what: is? go, thing.";
        foreach (Match match in Regex.Matches(input, pattern))
           Console.WriteLine(match.Value);
     }
  }
  // The example displays the following output:
  //       this. what: is? go, thing.
  

  Imports System.Text.RegularExpressions
  
  Module Example
      Public Sub Main()
          Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
          Dim input As String = "this. what: is? go, thing."
          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:
  '       this. what: is? go, thing.
  

Unicode-Kategorie oder Unicode-Block: \p{}

Jedem Zeichen wird im Unicode-Standard eine allgemeine Kategorie zugewiesen. Beispiel: Bei einem bestimmten Zeichen kann es sich um einen Großbuchstaben (dargestellt durch die Lu-Kategorie), ein Dezimalzeichen (die Nd-Kategorie), ein mathematisches Symbol (die Sm-Kategorie) oder einen Absatzseparator (die Zl-Kategorie) handeln. Bestimmte Zeichensätze im Unicode-Standard nehmen auch einen bestimmten Bereich oder einen Block aufeinander folgender Codepunkte ein. Beispielsweise befindet sich der grundlegende lateinische Zeichensatz im Bereich von "\u0000" bis "\u007F", während der arabische Zeichensatz zwischen "\u0600" und "\u06FF" liegt.

Konstrukt des regulären Ausdrucks

\p{ name }

Übereinstimmung mit jedem Zeichen, das einer allgemeinen Unicode-Kategorie oder einem benannten Block angehört, wobei Name für die Abkürzung der Kategorie bzw. den Namen des benannten Blocks steht. Eine Liste von Kategorieabkürzungen finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte allgemeine Unicode-Kategorien. Eine Liste von benannten Blöcken finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte benannte Blöcke.

Im folgenden Beispiel wird das \p{Name}-Konstrukt für eine Übereinstimmung mit sowohl einer allgemeinen Unicode-Kategorie (in diesem Fall die Pd-Kategorie, oder Interpunktionszeichen und Bindestriche) als auch mit einem benannten Block (IsGreek und IsBasicLatin) verwendet.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
        Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

        Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
    End Sub
End Module

Der reguläre Ausdruck \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ wird entsprechend der Darstellung in der folgenden Tabelle definiert:

Negative Unicode-Kategorie oder negativer Unicode-Block: \P{}

Jedem Zeichen wird im Unicode-Standard eine allgemeine Kategorie zugewiesen. Beispiel: Bei einem bestimmten Zeichen kann es sich um einen Großbuchstaben (dargestellt durch die Lu-Kategorie), ein Dezimalzeichen (die Nd-Kategorie), ein mathematisches Symbol (die Sm-Kategorie) oder einen Absatzseparator (die Zl-Kategorie) handeln. Bestimmte Zeichensätze im Unicode-Standard nehmen auch einen bestimmten Bereich oder einen Block aufeinander folgender Codepunkte ein. Beispielsweise befindet sich der grundlegende lateinische Zeichensatz im Bereich von "\u0000" bis "\u007F", während der arabische Zeichensatz zwischen "\u0600" und "\u06FF" liegt.

Konstrukt des regulären Ausdrucks

\P{ name }

Übereinstimmung mit jedem Zeichen, das weder einer allgemeinen Unicode-Kategorie noch einem benannten Block angehört, wobei Name für die Abkürzung der Kategorie bzw. den Namen des benannten Blocks steht. Eine Liste von Kategorieabkürzungen finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte allgemeine Unicode-Kategorien. Eine Liste von benannten Blöcken finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte benannte Blöcke.

Im folgenden Beispiel wird das \P{Name}-Konstrukt zum Entfernen aller Währungssymbole (in diesem Fall die Sc-Kategorie oder Symbole und Währungen) aus numerischen Zeichenfolgen verwendet.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\P{Sc})+"

        Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
        For Each value As String In values
            Console.WriteLine(Regex.Match(value, pattern).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

Das Muster für den regulären (\P{Sc})+-Ausdruck stimmt mit mindestens einem Zeichen überein, bei dem es sich nicht um ein Währungssymbol handelt. Tatsächlich werden alle Währungssymbole aus der Ergebniszeichenfolge entfernt.

Wortzeichen: \w

\w entspricht einem beliebigen Wortzeichen. Ein Wortzeichen gehört einer der in der folgenden Tabelle aufgeführten Unicode-Kategorien an.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \w dem [a-zA-Z_0-9]-Ausdruck. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.

Im folgenden Beispiel werden mit dem \w-Sprachelement übereinstimmende doppelte Zeichen innerhalb eines Worts ermittelt. Im Beispiel wird ein Muster für reguläre Ausdrücke definiert ((\w)\1), das wie folgt interpretiert werden kann.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer",
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.",
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\w)\1"
        Dim words() As String = {"trellis", "seer", "latter", "summer", _
                                  "hoarse", "lesser", "aardvark", "stunned"}
        For Each word As String In words
            Dim match As Match = Regex.Match(word, pattern)
            If match.Success Then
                Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                                  match.Value, word, match.Index)
            Else
                Console.WriteLine("No double characters in '{0}'.", word)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Nicht-Wortzeichen: \W

\W entspricht einem beliebigen Nichtwortzeichen. Das \W-Sprachelement entspricht der folgenden Zeichenklasse:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

Anders ausgedrückt: Mit Ausnahme der Zeichen, die in den Unicode-Kategorien enthalten sind, die in der folgenden Tabelle aufgelistet werden, liegt eine Übereinstimmung mit jedem Zeichen vor.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \W dem [^a-zA-Z_0-9]-Ausdruck. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.

Das folgende Beispiel veranschaulicht die \W-Zeichenklasse. Hierfür wird ein Muster für einen regulären Ausdruck definiert (\b(\w+)(\W){1,2}), das mit einem von einem oder zwei Nichtwortzeichen (z. B. Leer- oder Interpunktionszeichen) gefolgten Wort übereinstimmt. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)(\W){1,2}"
        Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            Console.Write("   Non-word character(s):")
            Dim captures As CaptureCollection = match.Groups(2).Captures
            For ctr As Integer = 0 To captures.Count - 1
                Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                              Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                              If(ctr < captures.Count - 1, ", ", ""))
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Da das Group-Objekt für die zweite Erfassungsgruppe nur ein einzelnes erfasstes Nicht-Wortzeichen aufweist, werden im Beispiel alle erfassten Nicht-Wortzeichen aus dem von der CaptureCollection-Eigenschaft zurückgegebenen Group.Captures-Objekt abgerufen.

Leerraumzeichen: \s

\s entspricht einem beliebigen Zeichen für Leerraum. Dies ist zu den in der folgenden Tabelle aufgeführten Escapesequenzen und Unicode-Kategorien äquivalent.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \s dem [ \f\n\r\t\v]-Ausdruck. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.

Das folgende Beispiel veranschaulicht die \s-Zeichenklasse. Hierfür wird ein Muster für einen regulären Ausdruck definiert (\b\w+(e)?s(\s|$)), das mit einem entweder auf "s" oder "es" endenden Wort übereinstimmt. Auf dieses Wort muss ein Leerzeichen oder das Ende der Eingabezeichenfolge folgen. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+(e)?s(\s|$)"
        Dim input As String = "matches stores stops leave leaves"
        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:
'       matches
'       stores
'       stops
'       leaves

Nicht-Leerraumzeichen: \S

\S entspricht einem beliebigen Nichtleerraumzeichen. Dies ist äquivalent zum Muster für den regulären [^\f\n\r\t\v\x85\p{Z}]-Ausdruck bzw. das Gegenteil des Musters für den regulären Ausdruck, der \s entspricht und daher mit Leerzeichen übereinstimmt. Weitere Informationen finden Sie unter Leerzeichen: \s.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \S dem [^ \f\n\r\t\v]-Ausdruck. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.

Im folgenden Beispiel wird das \S-Sprachelement veranschaulicht. Das Muster für den regulären Ausdruck \b(\S+)\s? stimmt mit durch Leerzeichen getrennten Zeichenfolgen überein. Das zweite Element im GroupCollection-Objekt der Übereinstimmung enthält die entsprechende Zeichenfolge. Der reguläre Ausdruck kann wie in der folgenden Tabelle dargestellt interpretiert werden.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " +
                            "This is the second sentence.\n" +
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\S+)\s?"
        Dim input As String = "This is the first sentence of the first paragraph. " + _
                              "This is the second sentence." + vbCrLf + _
                              "This is the only sentence of the second paragraph."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Groups(1))
        Next
    End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Dezimalzahl: \d

\d entspricht einer beliebigen Dezimalziffer. Dies entspricht dem Muster des regulären \p{Nd}-Ausdrucks, das neben den Standarddezimalzahlen 0 bis 9 auch die Dezimalzahlen einer Anzahl anderer Zeichensätze einschließt.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \d dem [0-9]-Ausdruck. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.

Im folgenden Beispiel wird das \d-Sprachelement veranschaulicht. Anhand eines Tests soll ermittelt werden, ob eine Eingabezeichenfolge eine gültige Telefonnummer in den USA und Kanada darstellt. Das Muster für reguläre Ausdrücke ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ wird entsprechend der folgenden Tabelle definiert:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
                          "(212) 111-1111", "111-AB1-1111",
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
        Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
                                   "(212) 111-1111", "111-AB1-1111", _
                                   "212-111-1111", "01 999-9999"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Nicht-Zahlen: \D

\D stimmt mit jedem Zeichen außer Zahlen überein. Dies entspricht dem Muster des regulären Ausdrucks \P{Nd}.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \D dem [^0-9]-Ausdruck. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.

Im folgenden Beispiel wird das "\D"-Sprachelement veranschaulicht. Anhand eines Tests wird ermittelt, ob eine Zeichenfolge (z. B. eine Teilenummer) aus der gewünschten Kombination von Dezimalzahlen und Nicht-Dezimalzahlen besteht. Das Muster für reguläre Ausdrücke ^\D\d{1,5}\D*$ wird entsprechend der folgenden Tabelle definiert:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$";
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^\D\d{1,5}\D*$"
        Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:

Unterstützte allgemeine Unicode-Kategorien

In der folgenden Tabelle werden die allgemeinen, in Unicode definierten Kategorien aufgeführt. Weitere Informationen finden Sie in den Unterthemen „UCD File Format“ (UCD-Dateiformat) und „General Category Values“ (Allgemeine Kategorienwerte) der Unicode Character Database, Abschnitt 5.7.1, Tabelle 12.

Sie können die Unicode-Kategorie eines bestimmten Zeichens ermitteln, indem Sie das Zeichen an die GetUnicodeCategory-Methode übergeben. Im folgenden Beispiel wird mithilfe der GetUnicodeCategory-Methode die Kategorie jedes Elements in einem Array mit ausgewählten lateinischen Zeichen ermittelt.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };

      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()),
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}

        For Each ch As Char In chars
            Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                              Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Unterstützte benannte Blöcke

In der folgenden Tabelle werden die von .NET bereitgestellten benannten Blöcke aufgelistet. Der Satz von unterstützten benannten Blöcke basiert auf Unicode 4.0 und Perl 5.6. Einen regulären Ausdruck, der benannte Blöcke verwendet, finden Sie im Abschnitt Unicode-Kategorie oder Unicode-Block: \p{}.

Zeichenklassensubtraktion: [base_group - [excluded_group]]

Eine Zeichenklasse definiert einen Satz von Zeichen. Durch Zeichenklassensubtraktion erhalten Sie einen Zeichensatz, der das Ergebnis des Ausschlusses der Zeichen einer Zeichenklasse von einer anderen darstellt.

Ein Zeichenklassensubtraktionsausdruck weist folgende Form auf:

[ base_group -[ excluded_group ]]

Die eckigen Klammern ([]) und der Bindestrich (-) sind obligatorisch. Bei der Basisgruppe handelt es sich um eine positive Zeichengruppe oder eine negative Zeichengruppe. Die Komponente ausgeschlossene_Gruppe stellt eine andere positive oder negative Zeichengruppe bzw. einen anderen Zeichenklassensubtraktions-Ausdruck dar (d.h. Sie können Zeichenklassensubtraktions-Ausdrücke schachteln).

Beispiel: Angenommen, Sie verfügen über eine Basisgruppe, die aus dem Zeichenbereich von "a" bis "z" besteht. Zum Definieren eines Zeichensatzes, der mit Ausnahme des Zeichens "m" aus der Basisgruppe besteht, verwenden Sie [a-z-[m]]. Zum Definieren eines Zeichensatzes, der mit Ausnahme der Zeichen "d", "j" und "p" aus der Basisgruppe besteht, verwenden Sie [a-z-[djp]]. Zum Definieren eines Zeichensatzes, der mit Ausnahme des Zeichenbereichs von "m" bis "p" aus der Basisgruppe besteht, verwenden Sie [a-z-[m-p]].

Betrachten Sie den geschachtelten [a-z-[d-w-[m-o]]]-Zeichenklassensubtraktionsausdruck. Der Ausdruck wird vom innersten Zeichenbereich nach außen ausgewertet. Zuerst wird der Zeichenbereich von "m" bis "o" vom Zeichenbereich "d" bis "w" subtrahiert. Das Ergebnis stellt einen Satz von Zeichen von "d" bis "l" und von "p" bis "w" dar. Dieser Satz wird anschließend vom Zeichenbereich "a" bis "z" subtrahiert, sodass sich der Zeichensatz [abcmnoxyz] ergibt.

Für die Zeichenklassensubtraktion kann jede Zeichenklasse verwendet werden. Zum Definieren eines Zeichensatzes, der aus allen Unicode-Zeichen von "\u0000" bis "\uFFFF" mit Ausnahme von Leerzeichen (\s), der Zeichen in der allgemeinen Interpunktionskategorie (\p{P}), der Zeichen im benannten Block IsGreek (\p{IsGreek}) und des Unicode-Steuerzeichens NEXT LINE (\x85) besteht, verwenden Sie [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Wählen Sie für einen Zeichenklassensubtraktionsausdruck Zeichenklassen aus, mit denen nützliche Ergebnisse erzielt werden können. Vermeiden Sie Ausdrücke, die einen leeren Satz von Zeichen ergeben, mit nichts übereinstimmen oder ein Äquivalent der ursprünglichen Basisgruppe darstellen. Beispielsweise ergibt der Ausdruck [\p{IsBasicLatin}-[\x00-\x7F]], durch den alle Zeichen des Zeichenbereichs IsBasicLatin von der allgemeinen Kategorie IsBasicLatin subtrahiert werden, einen leeren Zeichensatz. Gleichermaßen ist die ursprüngliche Basisgruppe das Ergebnis des Ausdrucks [a-z-[0-9]]. Der Grund hierfür ist, dass die Basisgruppe (der Zeichenbereich der Buchstaben von "a" bis "z") keine Zeichen aus der ausgeschlossenen Gruppe (dem Zeichenbereich der Dezimalzahlen von "0" bis "9") aufweist.

Im folgenden Beispiel wird ein regulärer Ausdruck definiert (^[0-9-[2468]]+$), der in einer Eingabezeichenfolge Übereinstimmungen für Null und ungerade Zahlen ergibt. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }
   }
}
// The example displays the following output:
//       13579753
//       335599901

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
        Dim pattern As String = "^[0-9-[2468]]+$"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

Siehe auch

• GetUnicodeCategory
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht
• Optionen für reguläre Ausdrücke