Zeichenklassen

Eine Zeichenklasse definiert einen Satz von Zeichen, von denen alle in einer Eingabezeichenfolge auftreten können, damit die Übereinstimmung erfolgreich ist. Die Sprache des regulären Ausdrucks in .NET Framework unterstützt die folgenden Zeichenklassen:

• Positive Zeichengruppen. Ein Zeichen aus der angegebenen Eingabezeichenfolge muss mit einem der angegebenen Sätze von Zeichen übereinstimmen. Weitere Informationen finden Sie im Abschnitt Positive Zeichengruppe.

• Negative Zeichengruppen. Ein Zeichen aus der angegebenen Eingabezeichenfolge darf nicht mit einem der angegebenen Sätze von Zeichen übereinstimmen. Weitere Informationen finden Sie im Abschnitt Negative Zeichengruppe.

• Beliebiges Zeichen. Das .-Zeichen (Punkt) in einem regulären Ausdruck ist ein Platzhalterzeichen, das jedem Zeichen mit Ausnahme von \n entspricht. Weitere Informationen finden Sie im Abschnitt Beliebiges Zeichen.

• Eine allgemeine Kategorie für Unicode oder ein benannter Block. Ein Zeichen in der Eingabezeichenfolge muss ein Mitglied einer bestimmten Kategorie von Unicode sein oder innerhalb eines zusammenhängenden Bereichs von Unicode-Zeichen fallen, damit eine Übereinstimmung erfolgreich ist. Weitere Informationen finden Sie im Abschnitt zu Unicode-Kategorien oder Unicode-Blöcken.

• Eine negative allgemeine Kategorie für Unicode oder ein benannter Block. Ein Zeichen in der Eingabezeichenfolge darf nicht ein Mitglied einer bestimmten Kategorie von Unicode sein oder innerhalb eines zusammenhängenden Bereichs von Unicode-Zeichen fallen, damit eine Übereinstimmung erfolgreich ist. Weitere Informationen finden Sie im Abschnitt zu negativen Unicode-Kategorien oder Unicode-Blöcken.

• Ein Wortzeichen. Ein Zeichen in der Eingabezeichenfolge kann zu irgendeiner der Unicode-Kategorien gehören, die für Zeichen in Wörtern geeignet sind. Weitere Informationen finden Sie im Abschnitt Wortzeichen.

• Ein Nichtwortzeichen. Ein Zeichen in der Eingabezeichenfolge kann zu jeder Unicode-Kategorie gehören, die kein Wortzeichen ist. Weitere Informationen finden Sie im Abschnitt zu Nichtwortzeichen .

• Ein Leerraumzeichen. Ein Zeichen in der Eingabezeichenfolge kann irgendein Unicode-Trennzeichen und auch eine Anzahl von Steuerzeichen sein. Weitere Informationen finden Sie unter Nicht-Leerstellenzeichen: \s.

• Ein Nichtleerraumzeichen. Ein Zeichen in der Eingabezeichenfolge kann jedes Zeichen sein, das kein Leerstellenzeichen ist. Weitere Informationen finden Sie unter Nicht-Leerstellenzeichen.

• Eine Dezimalstelle. Ein Zeichen in der Eingabezeichenfolge kann irgendeine Anzahl von Zeichen sein, die als Unicode-Dezimalstellen klassifizierten sind. Weitere Informationen finden Sie im Abschnitt Dezimalstellenzeichen.

• Eine Nichtdezimalstelle. Ein Zeichen in der Eingabezeichenfolge kann etwas anderes als eine Unicode-Dezimalstelle sein. Weitere Informationen finden Sie im Abschnitt Dezimalstellenzeichen.

.NET Framework unterstützt Zeichenklassensubtraktionsausdrücke. Hierdurch können Sie einen Zeichensatz definieren, der aus dem Ausschluss einer Zeichenklasse aus einer anderen Zeichenklasse resultiert. Weitere Informationen finden Sie unter Zeichenklassensubtraktion.

Positive Zeichengruppe: [ ]

Eine positive Zeichengruppe gibt eine Liste von Zeichen an, von denen alle in einer Eingabezeichenfolge erscheinen können, damit eine Übereinstimmung auftritt. Diese Zeichenliste kann einzeln, als Bereich oder sowohl einzeln als auch als Bereich angegeben werden.

Die Syntax zum Angeben einer Liste einzelner Zeichen sieht folgendermaßen aus:

[character_group]

wobei character_group eine Liste der einzelnen Zeichen ist, die in der Eingabezeichenfolge erscheinen können, damit eine Übereinstimmung erfolgreich ist. character_group kann aus einer beliebigen Kombination von einem oder mehr Literalzeichen, Escapezeichen oder Zeichenklassen bestehen.

Die Syntax zum Angeben eines Zeichenbereichs sieht folgendermaßen aus:

[firstCharacter-lastCharacter]

wobei firstCharacter das Zeichen ist, das den Anfang des Bereichs markiert, und lastCharacter das Zeichen ist, das das Ende des Bereichs darstellt. Ein Zeichenbereich ist eine Folge zusammenhängender Zeichen, die definiert wird, indem das erste Zeichen in der Folge, ein Bindestrich (-), und das letzte Zeichen in der Folge angegeben werden. Zwei Zeichen sind zusammenhängend, wenn sie benachbarte Unicode-Codepunkte haben.

Einige allgemeine Muster eines regulären Ausdrucks, die positive Zeichenklassen enthalten, sind in der folgenden Tabelle aufgeführt.

Muster	Beschreibungen
[aeiou]	Entspricht allen Vokalen.
[\p{P}\d]	Entspricht allen Interpunktions- und Dezimalstellenzeichen.
[\s\p{P}]	Entspricht allen Leerstellen und Interpunktionszeichen.

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

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.

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.

Der reguläre Ausdruck gr[ae]y\s\S+?[\s|\p{P}] wird folgendermaßen definiert:

Muster	Beschreibungen
gr	Entspricht den Literalzeichen"gr".
[ae]	Entspricht entweder "a" oder "e".
y\s	Entspricht dem Literalzeichen "y" gefolgt von einem Leerstellenzeichen.
\S+?	Entspricht mindestens einem Nichtleerzeichen, aber so wenigen Zeichen wie möglich.
[\s|\p{P}]	Entspricht entweder einem Leerzeichen oder einem Satzzeichen.

Im folgenden Beispiel werden Entsprechungen für Wörter angezeigt, die mit einem beliebigen Großbuchstaben beginnen. Mit dem Teilausdruck [A-Z] wird der Bereich der Großbuchstaben von A-Z dargestellt.

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

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

Der reguläre Ausdruck \b[A-Z]\w*\b ist wie in der folgenden Tabelle gezeigt definiert.

Muster	Beschreibungen
\b	An einer Wortgrenze beginnen.
[A-Z]	Entspricht einem beliebigen Großbuchstaben von A bis Z.
\w*	Suchen Sie nach einer Übereinstimmung mit null oder mehr Wortzeichen.
\b	Entsprechung für eine Wortgrenze finden.

Nach oben

Negative Zeichengruppe: [^]

Eine negative Zeichengruppe gibt eine Liste von Zeichen an, die nicht in einer Eingabezeichenfolge erscheinen müssen, damit eine Übereinstimmung auftritt. Die Zeichenliste kann einzeln, als Bereich oder sowohl einzeln als auch als Bereich angegeben werden.

Die Syntax zum Angeben einer Liste einzelner Zeichen sieht folgendermaßen aus:

[^character_group]

wobei character_group eine Liste der einzelnen Zeichen ist, die nicht in der Eingabezeichenfolge erscheinen können, damit eine Übereinstimmung erfolgreich ist. character_group kann aus einer beliebigen Kombination von einem oder mehr Literalzeichen, Escapezeichen oder Zeichenklassen bestehen.

Die Syntax zum Angeben eines Zeichenbereichs sieht folgendermaßen aus:

[^firstCharacter-lastCharacter]

wobei firstCharacter das Zeichen ist, das den Anfang des Bereichs markiert, und lastCharacter das Zeichen ist, das das Ende des Bereichs darstellt. Ein Zeichenbereich ist eine Folge zusammenhängender Zeichen, die definiert wird, indem das erste Zeichen in der Folge, ein Bindestrich (-), und das letzte Zeichen in der Folge angegeben werden. Zwei Zeichen sind zusammenhängend, wenn sie benachbarte Unicode-Codepunkte haben.

Es können zwei oder mehr Zeichenbereiche miteinander verkettet werden. Wenn Sie beispielsweise den Bereich der Dezimalziffern von "0" bis "9", den Bereich der Kleinbuchstaben von "a" bis "f" und den Bereich der Großbuchstaben von "A" bis "F" angeben möchten, verwenden Sie [0-9a-fA-F].

Das führende Zirkumflexzeichen (^) in einer negativen Zeichengruppe ist obligatorisch und gibt an, dass es sich bei der Zeichengruppe um eine negative und nicht um eine positive Zeichengruppe handelt.

Wichtig
Eine negative Zeichengruppe in einem größeren Muster eines regulären Ausdrucks ist keine Assertion mit einer Breite von null.Das heißt, dass nach dem Auswerten der negativen Zeichengruppe das Modul für reguläre Ausdrücke in der Eingabezeichenfolge ein Zeichen weiter nach vorne verschoben wird.

Einige allgemeine Muster eines regulären Ausdrucks, die negative Zeichengruppen enthalten, sind in der folgenden Tabelle aufgeführt.

Muster	Beschreibungen
[^aeiou]	Entspricht allen Zeichen mit Ausnahme von Vokalen.
[^\p{P}\d]	Entspricht allen Zeichen mit Ausnahme von Interpunktions- und Dezimalstellenzeichen.

Im folgenden Beispiel werden Entsprechungen für ein beliebiges Wort angezeigt, das mit den Zeichen "th" beginnt, wobei darauf kein "o" folgt.

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

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

Der reguläre Ausdruck \bth[^o]\w+\b ist wie in der folgenden Tabelle gezeigt definiert.

Muster	Beschreibungen
\b	An einer Wortgrenze beginnen.
th	Entspricht den Literalzeichen"th".
[^o]	Entspricht jedem Zeichen, bei dem es sich nicht um "o" handelt.
\w+	Entsprechung für eines oder mehrere Wortzeichen finden.
\b	An einer Wortgrenze beenden.

Nach oben

Beliebiges Zeichen: .

Der Punkt (.) entspricht einem beliebigen Zeichen mit Ausnahme von \n (das Zeichen für einen Zeilenumbruch, \u000A) mit den folgenden beiden Qualifikationen:

• Wenn das Muster eines regulären Ausdrucks von der RegexOptions.Singleline-Option geändert wird, oder wenn der Teil des Musters, das die .-Zeichenklasse enthält, von der s-Option geändert wird, entspricht . jedem beliebigen Zeichen. Weitere Informationen finden Sie unter Optionen für reguläre Ausdrücke.

  Im folgenden Beispiel wird das unterschiedliche Verhalten der .-Zeichenklasse standardmäßig 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 eines regulären Ausdrucks findet eine Entsprechung für das Wagenrücklaufzeichen, \r oder \u000D, aber es findet keine \n. Da die RegexOptions.Singleline-Option die ganze Eingabezeichenfolge als einzelne Zeile interpretiert, findet es für jedes Zeichen in der Eingabezeichenfolge, einschließlich \n, eine Entsprechung.

  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\.
  

  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\.
  

Hinweis
Da es außer \n eine Entsprechung für alle Zeichen findet, findet die .-Zeichenklasse auch ein Entsprechung für \r (das Wagenrücklaufzeichen, \u000D).

• In einer positiven oder negativen Zeichengruppe wird ein Punkt als Literalzeichen und nicht als Zeichenklasse behandelt. Weitere Informationen finden Sie unter Positive Zeichengruppe und Negative Zeichengruppe früher in diesem Thema. Im folgenden Beispiel wird eine Abbildung gezeigt, indem ein regulärer Ausdruck definiert wird, der das Punktzeichen (.) sowohl als Zeichenklasse als auch als Mitglied einer positiven Zeichengruppe einschließt. Der reguläre Ausdruck \b.*[.?!;:](\s|\z) beginnt an einer Wortgrenze, gleicht jedes beliebige Zeichen ab, bis eines von vier Satzzeichen gefunden wird (einschließlich eines Punkts), und gleicht dann entweder ein Leerzeichen oder das Ende der Zeichenfolge ab.

  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.
  

  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.
  

Hinweis
Da es eine Entsprechung für alle Zeichen findet, wird das .-Sprachelement oft mit einem trägen Quantifizierer verwendet, wenn ein Muster eines regulären Ausdrucks versucht, mehrmals eine Entsprechung für irgendein Zeichen zu finden.Weitere Informationen finden Sie unter Quantifizierer.

Nach oben

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

Der Unicode-Standard weist jedem Zeichen eine allgemeine Kategorie zu. Ein bestimmtes Zeichen kann z. B. ein Großbuchstabe (von der Kategorie Lu dargestellt), eine Dezimalstelle (die Kategorie Nd), ein mathematisches Symbol (die Kategorie Sm ) oder ein Absatztrennzeichen sein (die Kategorie Zl). Bestimmte Zeichensätze im Unicode-Standard nehmen auch einen bestimmten Bereich oder einen Block aufeinander folgender Codepunkte ein. Der grundlegende lateinische Zeichensatz wird z. B. von \u0000 bis \u007F gefunden, während der arabische Zeichensatz von \u0600 bis \u06FF gefunden wird.

Das Konstrukt des regulären Ausdrucks

\p{name}

entspricht einem beliebigen Zeichen, das einer allgemeinen Unicode-Kategorie oder einem benannten Block angehört, wobei name die Abkürzung der Kategorie oder der Name des benannten Blocks ist. 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 dient das \p{name}-Konstrukt zum Abgleich einer allgemeinen Unicode-Kategorie (in diesem Fall die Pd-, oder Punctuation,Dash-Kategorie) und eines benannten Blocks (die benannten Blöcke IsGreek und IsBasicLatin).

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

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.
   }
}

Der reguläre Ausdruck \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ ist wie in der folgenden Tabelle gezeigt definiert.

Muster	Beschreibungen
\b	An einer Wortgrenze beginnen.
\p{IsGreek}+	Entspricht mindestens einem griechischen Zeichen.
(\s)?	0 (null) oder ein Leerzeichen sollen überstimmen.
(\p{IsGreek}+(\s)?)+	Entspricht dem Muster von mindestens einem griechischen Basiszeichen gefolgt von null oder einem Leerzeichen (ein- oder zweimal).
\p{Pd}	Entspricht einem Interpunktions- bzw. einem Gedankenstrichzeichen.
\s	Entsprechung für ein Leerraumzeichen finden.
\p{IsBasicLatin}+	Entspricht mindestens einem lateinischen Basiszeichen.
(\s)?	0 (null) oder ein Leerzeichen sollen überstimmen.
(\p{IsBasicLatin}+(\s)?)+	Entspricht dem Muster von mindestens einem lateinischen Basiszeichen gefolgt von null oder einem Leerzeichen (ein- oder zweimal).

Nach oben

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

Der Unicode-Standard weist jedem Zeichen eine allgemeine Kategorie zu. Ein bestimmtes Zeichen kann z. B. ein Großbuchstabe (von der Kategorie Lu dargestellt), eine Dezimalstelle (die Kategorie Nd), ein mathematisches Symbol (die Kategorie Sm ) oder ein Absatztrennzeichen sein (die Kategorie Zl). Bestimmte Zeichensätze im Unicode-Standard nehmen auch einen bestimmten Bereich oder einen Block aufeinander folgender Codepunkte ein. Der grundlegende lateinische Zeichensatz wird z. B. von \u0000 bis \u007F gefunden, während der arabische Zeichensatz von \u0600 bis \u06FF gefunden wird.

Das Konstrukt des regulären Ausdrucks

\P{name}

entspricht einem beliebigen Zeichen, das nicht einer allgemeinen Unicode-Kategorie oder einem benannten Block angehört, wobei name die Abkürzung der Kategorie oder der Name des benannten Blocks ist. 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.

Das folgende Beispiel entfernt beliebige Währungssymbole (in diesem Fall die Sc- bzw. Symbol-, Währungskategorie) mithilfe des \P{name}-Konstrukts aus numerischen Zeichenfolgen.

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

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

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

Nach oben

Wortzeichen: \w

\w entspricht einem beliebigen Wortzeichen. Ein Wortzeichen ist ein Mitglied von irgendeiner in der folgenden Tabelle aufgeführten Unicode-Kategorien.

Kategorie	Beschreibungen
Ll	Letter, Lowercase (Buchstabe, Kleinschreibung)
Lu	Letter, Uppercase
Lt	Letter, Titlecase (Buchstabe, großer Anfangsbuchstabe)
Lo	Letter, Other (Buchstabe, andere)
Lm	Letter, Modifier (Buchstabe, Modifizierer)
Nd	Number, Decimal Digit (Zahl, Dezimalziffer)
Pc	Interpunktion, Verbinder. Diese Kategorie schließt zehn Zeichen ein, von denen das am häufigsten verwendete das UNTERSTRICH-Zeichen (_), u+005F, ist.

Wenn ECMAScript-kompatibles Verhalten angegeben wird, entspricht \w [a-zA-Z_0-9]. Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt "ECMAScript-Vergleichsverhalten" in Optionen für reguläre Ausdrücke.

Hinweis
Da es eine Entsprechung für alle Wortzeichen findet, wird das \w-Sprachelement oft mit einem trägen Quantifizierer verwendet, wenn ein Muster eines regulären Ausdrucks versucht, mehrmals eine Entsprechung für irgendein Wortzeichen zu finden, gefolgt von einem speziellen Wortzeichen.Weitere Informationen finden Sie unter Quantifizierer.

Im folgenden Beispiel werden mit dem \w-Sprachelement doppelte Zeichen in einem Wort abgeglichen. Im Beispiel wird ein Muster für reguläre Ausdrücke definiert ((\w)\1), das folgendermaßen interpretiert werden kann.

Element	Beschreibungen
(\w)	Entspricht einem Wortzeichen. Dies ist die erste Erfassungsgruppe.
\1	Entspricht dem Wert der ersten Erfassung.

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.

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.

Nach oben

Ein Nichtwortzeichen: \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 liegt eine Übereinstimmung mit jedem Zeichen mit Ausnahme der in der folgenden Tabellen aufgeführten Zeichen vor.

Kategorie	Beschreibungen
Ll	Letter, Lowercase (Buchstabe, Kleinschreibung)
Lu	Letter, Uppercase
Lt	Letter, Titlecase (Buchstabe, großer Anfangsbuchstabe)
Lo	Letter, Other (Buchstabe, andere)
Lm	Letter, Modifier (Buchstabe, Modifizierer)
Nd	Number, Decimal Digit (Zahl, Dezimalziffer)
Pc	Interpunktion, Verbinder. Diese Kategorie schließt zehn Zeichen ein, von denen das am häufigsten verwendete das UNTERSTRICH-Zeichen (_), u+005F, ist.

Wenn ECMAScript-kompatibles Verhalten angegeben wird, entspricht \W [^a-zA-Z_0-9]. Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt "ECMAScript-Vergleichsverhalten" in Optionen für reguläre Ausdrücke.

Hinweis
Da es eine Entsprechung für alle Nichtwortzeichen findet, wird das \W-Sprachelement oft mit einem trägen Quantifizierer verwendet, wenn ein Muster eines regulären Ausdrucks versucht, mehrmals eine Entsprechung für irgendein Nichtwortzeichen zu finden, gefolgt von einem speziellen Nichtwortzeichen.Weitere Informationen finden Sie unter Quantifizierer.

Das folgende Beispiel veranschaulicht die \w-Zeichenklasse: Ein Muster eines regulären Ausdrucks wird definiert (\b(\w+)(\W){1,2}), das einem Wort entspricht, auf das mindestens ein Nichtwortzeichen (z. B. Leerstellen oder Interpunktion) folgt. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Element	Beschreibungen
\b	Der Vergleich beginnt an einer Wortgrenze.
(\w+)	Entsprechung für eines oder mehrere Wortzeichen finden. Dies ist die erste Erfassungsgruppe.
(\w){1,2}	Entspricht einem Nichtwortzeichen (ein- oder zweimal). Dies ist die zweite Erfassungsgruppe.

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)

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)

Da das Group-Objekt für die zweite Erfassungsgruppe nur ein einzelnes aufgezeichnetes Nichtwortzeichen enthält, werden im Beispiel alle aufgezeichneten Nichtwortzeichen aus dem CaptureCollection-Objekt abgerufen, das von der Group.Captures-Eigenschaft zurückgegeben wird.

Nach oben

Leerraumzeichen: \s

\s entspricht einem beliebigen Leerraumzeichen. Dies entspricht den Escapesequenzen und Unicode-Kategorien, die in der folgenden Tabelle aufgeführt sind.

Kategorie	Beschreibungen
\f	Das Seitenvorschubzeichen, \u000C.
\n	Das Zeilenumbruchzeichen, \u000A.
\r	Das Wagenrücklaufzeichen, \u000D.
\t	Das Tabstoppzeichen, \u0009.
\v	Das vertikale Tabulatorzeichen, \u000B.
\x85	Das Ellipsen- oder NÄCHSTE ZEILE (NEL)-Zeichen (…), \u0085.
\p{Z}	Entspricht einem beliebigen Trennzeichen.

Wenn ECMAScript-kompatibles Verhalten angegeben wird, entspricht \s [\f\n\r\t\v]. Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt "ECMAScript-Vergleichsverhalten" in Optionen für reguläre Ausdrücke.

Das folgende Beispiel veranschaulicht die \s-Zeichenklasse: Ein Muster für reguläre Ausdrücke wird definiert (\b\w+(e)*s(\s|$)), das einem Wort entspricht, das entweder auf "s" oder "es" endet und auf das entweder ein Leerstellenzeichen oder das Ende der Eingabezeichenfolge folgt. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Element	Beschreibungen
\b	Der Vergleich beginnt an einer Wortgrenze.
\w+	Entsprechung für eines oder mehrere Wortzeichen finden.
(e)*	Entspricht "e" entweder null- oder einmal.
s	Entspricht "s".
(\s|$)	Entspricht entweder einem Leerzeichen oder dem Ende der Eingabezeichenfolge.

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

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

Nach oben

Nichtleerraumzeichen: \S

\S entspricht einem anderen Zeichen als einem Leerraumzeichen. Dies entspricht dem [^\f\n\r\t\v\x85\p{Z}]-Muster eines regulären Ausdrucks oder dem Gegenteil des Musters eines regulären Ausdrucks, das \s entspricht (steht für Leerstellenzeichen). Weitere Informationen finden Sie unter Nicht-Leerstellenzeichen: \s.

Wenn ECMAScript-kompatibles Verhalten angegeben wird, entspricht \S [^ \f\n\r\t\v]. Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt "ECMAScript-Vergleichsverhalten" in Optionen für reguläre Ausdrücke.

Das folgende Beispiel veranschaulicht das \S-Sprachelement. Das Muster eines regulären Ausdrucks (\b(\S+)-\s*) entspricht Zeichenfolgen, die durch Leerstellenzeichen getrennt werden. Das zweite Element im GroupCollection-Objekt der Übereinstimmung enthält die entsprechende Zeichenfolge. Der reguläre Ausdruck kann entsprechend der Darstellung in der folgenden Tabelle interpretiert werden.

Element	Beschreibungen
\b	Der Vergleich beginnt an einer Wortgrenze.
(\S+)	Entspricht mindestens einem Zeichen, das kein Leerzeichen ist. Dies ist die erste Erfassungsgruppe.
\s*	0 (null) oder ein Leerzeichen sollen überstimmen.

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.

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.

Nach oben

Dezimalstellenzeichen: \d

\d entspricht einer beliebigen Dezimalziffer. Dies entspricht dem \p{Nd}-Muster eines regulären Ausdrucks, das die Standarddezimalstellen 0-9 sowie die Dezimalstellen einer Zahl anderer Zeichensätze einschließt.

Wenn ECMAScript-kompatibles Verhalten angegeben wird, entspricht \d [0-9]. Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt "ECMAScript-Vergleichsverhalten" in Optionen für reguläre Ausdrücke.

Das folgende Beispiel veranschaulicht das \d-Sprachelement. Es wird getestet, 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:

Element	Beschreibungen
^	Beginnt den Vergleich am Anfang der Eingabezeichenfolge.
\(*	Entspricht null oder einem Literalzeichen ("(").
\d{3}	Entsprechung für drei Dezimalstellen finden.
\)*	Entspricht null oder einem Literalzeichen ("(").
[\s-]	Entspricht einem Bindestrich oder Leerzeichen.
(\(*\d{3}\)*[\s-])*	Entspricht einer optionalen öffnenden Klammer gefolgt von drei Dezimalstellen, einer optionalen schließenden Klammer und null- oder einmal entweder einem Leerzeichen oder einem Bindestrich. Dies ist die erste Erfassungsgruppe.
\d{3}=\d{4}	Entspricht drei Dezimalstellen gefolgt von einem Bindestrich und vier weiteren Dezimalstellen.
$	Entsprechung für das Ende der Eingabezeichenfolge finden.

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

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

Nach oben

Nichtzifferzeichen: \D

\D entspricht einem beliebigen anderen Zeichen. Dies entspricht dem \p{Nd}-Muster eines regulären Ausdrucks.

Wenn ECMAScript-kompatibles Verhalten angegeben wird, entspricht \D [^0-9]. Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt "ECMAScript-Vergleichsverhalten" in Optionen für reguläre Ausdrücke.

Im folgenden Beispiel wird das \D-Sprachelement veranschaulicht. Es wird getestet, ob eine Zeichenfolge wie z. B. eine Teilenummer aus der entsprechenden Kombination dezimaler und nicht dezimaler Zeichen besteht. Das Muster für reguläre Ausdrücke ^\D\d{1,5}\D*$ wird entsprechend der folgenden Tabelle definiert:

Element	Beschreibungen
^	Beginnt den Vergleich am Anfang der Eingabezeichenfolge.
\D	Entspricht einem anderen Zeichen als einer Ziffer.
\d{1,5}	Entsprechung von einer bis fünf Dezimalstellen.
\D*	Entspricht null oder einem Nichtdezimalzeichen.
$	Entsprechung für das Ende der Eingabezeichenfolge finden.

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:

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

Nach oben

Unterstützte allgemeine Unicode-Kategorien

Unicode definiert die in der folgenden Tabelle aufgelisteten allgemeinen Kategorien. Weitere Informationen finden Sie in der Unicode-Zeichendatenbank (auf Englisch) in den untergeordneten Themen "UCD-Dateiformat" (auf Englisch) und "Werte der allgemeinen Kategorie" (auf Englisch).

Kategorie	Beschreibungen
Lu	Letter, Uppercase
Ll	Letter, Lowercase (Buchstabe, Kleinschreibung)
Lt	Letter, Titlecase (Buchstabe, großer Anfangsbuchstabe)
Lm	Letter, Modifier (Buchstabe, Modifizierer)
Lo	Letter, Other (Buchstabe, andere)
L	Alle Buchstabenzeichen. Dazu zählen auch die Zeichen Lu, Ll, Lt, Lm und Lo.
Mn	Mark, Nonspacing (Satzzeichen, ohne horizontalen Vorschub)
Mc	Mark, Spacing Combining (Satzzeichen, Kombinationszeichen mit Vorschub)
Me	Mark, Enclosing (Satzzeichen, einschließend)
M	Alle diakritischen Zeichen. Dazu zählen auch die Kategorien Mn, Mc und Me.
Nd	Number, Decimal Digit (Zahl, Dezimalziffer)
Nl	Number, Letter (Zahl, Buchstabe)
No	Number, Other (Zahl, andere)
N	Alle Zahlen. Dazu zählen auch die Kategorien Nd, Nl und No.
Pc	Punctuation, Connector (Interpunktion, Verbindung)
Pd	Punctuation, Dash (Interpunktion, Bindestrich)
Ps	Punctuation, Open (Interpunktion, öffnend)
Pe	Punctuation, Close (Interpunktion, schließend)
Pi	Punctuation, Initial quote (Interpunktion, öffnendes Anführungszeichen; verhält sich je nach Verwendung möglicherweise wie Ps oder Pe)
Pf	Punctuation, Final quote (Interpunktion, schließendes Anführungszeichen; verhält sich je nach Verwendung möglicherweise wie Ps oder Pe)
Po	Interpunktion, Other (Interpunktion, andere)
P	Alle Interpunktionszeichen. Dazu zählen auch die Kategorien Pc, Pd, Ps, Pe, Pi, Pf und Po.
Sm	Symbol, Math (Symbol, Mathematik)
Sc	Symbol, Currency (Symbol, Währung)
Sk	Symbol, Modifier (Symbol, Modifizierer)
So	Symbol, Other (Symbol, andere)
S	Alle Symbole. Dazu zählen auch die Kategorien Sm, Sc, Sk und So.
Zs	Separator, Space (Trennzeichen, Leerzeichen)
Zl	Separator, Line (Trennzeichen, Zeile)
Zp	Separator, Paragraph (Trennzeichen, Absatz)
Z	Alle Trennzeichen. Dazu zählen auch die Kategorien Zs, Zl und Zp.
Cc	Other, Control (Andere, Steuerzeichen)
Cf	Other, Format (Andere, Format)
Cs	Other, Surrogate (Andere, Ersatzzeichen)
Co	Other, Private Use (Andere, persönliche Verwendung)
Cn	Other, Not Assigned (Andere, nicht zugeordnet; keine Zeichen besitzen diese Eigenschaft)
C	Alle Steuerzeichen. Dazu zählen auch die Kategorien Cc, Cf, Cs, Co und Cn.

Sie können die Unicode-Kategorie eines bestimmten Zeichens bestimmen, indem Sie das Zeichen an die GetUnicodeCategory-Methode übergeben. Das folgende Beispiel bestimmt die Kategorie jedes Elements in einem Array, das ausgewählte lateinische Zeichen enthält, mithilfe der GetUnicodeCategory-Methode.

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

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

Nach oben

Unterstützte benannte Blöcke

.NET Framework stellt die in der folgenden Tabelle aufgelisteten benannten Blöcke bereit. Der Satz von unterstützten benannten Blöcken basiert auf Unicode 4.0 und Perl 5.6.

Codepunktbereich	Blockname
0000 - 007F	IsBasicLatin
0080 - 00FF	IsLatin-1Supplement
0100 - 017F	IsLatinExtended-A
0180 - 024F	IsLatinExtended-B
0250 - 02AF	IsIPAExtensions
02B0 - 02FF	IsSpacingModifierLetters
0300 - 036F	IsCombiningDiacriticalMarks
0370 - 03FF	IsGreek – oder – IsGreekandCoptic
0400 - 04FF	IsCyrillic
0500 - 052F	IsCyrillicSupplement
0530 - 058F	IsArmenian
0590 - 05FF	IsHebrew
0600 - 06FF	IsArabic
0700 - 074F	IsSyriac
0780 - 07BF	IsThaana
0900 - 097F	IsDevanagari
0980 - 09FF	IsBengali
0A00 - 0A7F	IsGurmukhi
0A80 - 0AFF	IsGujarati
0B00 - 0B7F	IsOriya
0B80 - 0BFF	IsTamil
0C00 - 0C7F	IsTelugu
0C80 - 0CFF	IsKannada
0D00 - 0D7F	IsMalayalam
0D80 - 0DFF	IsSinhala
0E00 - 0E7F	IsThai
0E80 - 0EFF	IsLao
0F00 - 0FFF	IsTibetan
1000 - 109F	IsMyanmar
10A0 - 10FF	IsGeorgian
1100 - 11FF	IsHangulJamo
1200 - 137F	IsEthiopic
13A0 - 13FF	IsCherokee
1400 - 167F	IsUnifiedCanadianAboriginalSyllabics
1680 - 169F	IsOgham
16A0 - 16FF	IsRunic
1700 - 171F	IsTagalog
1720 - 173F	IsHanunoo
1740 - 175F	IsBuhid
1760 - 177F	IsTagbanwa
1780 - 17FF	IsKhmer
1800 - 18AF	IsMongolian
1900 - 194F	IsLimbu
1950 - 197F	IsTaiLe
19E0 - 19FF	IsKhmerSymbols
1D00 - 1D7F	IsPhoneticExtensions
1E00 - 1EFF	IsLatinExtendedAdditional
1F00 - 1FFF	IsGreekExtended
2000 - 206F	IsGeneralPunctuation
2070 - 209F	IsSuperscriptsandSubscripts
20A0 - 20CF	IsCurrencySymbols
20D0 - 20FF	IsCombiningDiacriticalMarksforSymbols – oder – IsCombiningMarksforSymbols
2100 - 214F	IsLetterlikeSymbols
2150 - 218F	IsNumberForms
2190 - 21FF	IsArrows
2200 - 22FF	IsMathematicalOperators
2300 - 23FF	IsMiscellaneousTechnical
2400 - 243F	IsControlPictures
2440 - 245F	IsOpticalCharacterRecognition
2460 - 24FF	IsEnclosedAlphanumerics
2500 - 257F	IsBoxDrawing
2580 - 259F	IsBlockElements
25A0 - 25FF	IsGeometricShapes
2600 - 26FF	IsMiscellaneousSymbols
2700 - 27BF	IsDingbats
27C0 - 27EF	IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF	IsSupplementalArrows-A
2800 - 28FF	IsBraillePatterns
2900 - 297F	IsSupplementalArrows-B
2980 - 29FF	IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF	IsSupplementalMathematicalOperators
2B00 - 2BFF	IsMiscellaneousSymbolsandArrows
2E80 - 2EFF	IsCJKRadicalsSupplement
2F00 - 2FDF	IsKangxiRadicals
2FF0 - 2FFF	IsIdeographicDescriptionCharacters
3000 - 303F	IsCJKSymbolsandPunctuation
3040 - 309F	IsHiragana
30A0 - 30FF	IsKatakana
3100 - 312F	IsBopomofo
3130 - 318F	IsHangulCompatibilityJamo
3190 - 319F	IsKanbun
31A0 - 31BF	IsBopomofoExtended
31F0 - 31FF	IsKatakanaPhoneticExtensions
3200 - 32FF	IsEnclosedCJKLettersandMonths
3300 - 33FF	IsCJKCompatibility
3400 - 4DBF	IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF	IsYijingHexagramSymbols
4E00 - 9FFF	IsCJKUnifiedIdeographs
A000 - A48F	IsYiSyllables
A490 - A4CF	IsYiRadicals
AC00 - D7AF	IsHangulSyllables
D800 - DB7F	IsHighSurrogates
DB80 - DBFF	IsHighPrivateUseSurrogates
DC00 - DFFF	IsLowSurrogates
E000 - F8FF	IsPrivateUse oder IsPrivateUseArea
F900 - FAFF	IsCJKCompatibilityIdeographs
FB00 - FB4F	IsAlphabeticPresentationForms
FB50 - FDFF	IsArabicPresentationForms-A
FE00 - FE0F	IsVariationSelectors
FE20 - FE2F	IsCombiningHalfMarks
FE30 - FE4F	IsCJKCompatibilityForms
FE50 - FE6F	IsSmallFormVariants
FE70 - FEFF	IsArabicPresentationForms-B
FF00 - FFEF	IsHalfwidthandFullwidthForms
FFF0 - FFFF	IsSpecials

Nach oben

Zeichenklassensubtraktion

Eine Zeichenklasse definiert einen Satz von Zeichen. Durch Zeichenklassensubtraktion erhalten Sie einen Zeichensatz, der aus dem Ausschluss der Zeichen in einer Zeichenklasse aus einer anderen Zeichenklasse resultiert.

Ein Zeichenklassensubtraktionsausdruck hat folgende Form:

[base_group-[excluded_group]]

Die eckigen Klammern ([]) und der Bindestrich (-- sind obligatorisch. base_group ist eine positive oder negative Zeichengruppe, wie in der Tabelle Zeichenklassensyntax beschrieben. Die excluded_group-Komponente ist eine andere positive oder negative Zeichengruppe bzw. ein anderer Zeichenklassensubtraktionsausdruck (d. h. Sie können Zeichenklassensubtraktionsausdrücke schachteln).

Angenommen, Sie haben eine Basisgruppe, die aus dem Zeichenbereich von "a" bis "z" besteht. Wenn Sie einen Zeichensatz definieren möchten, der aus der Basisgruppe mit Ausnahme des Zeichens "m" besteht, verwenden Sie [a-z-[m]]. Möchten Sie einen Zeichensatz definieren, der aus der Basisgruppe mit Ausnahme der Zeichen "d", "j" und "p" besteht, verwenden Sie [a-z-[djp]]. Um einen Zeichensatz zu definieren, der aus der Basisgruppe mit Ausnahme der Zeichen "m" bis "p" besteht, verwenden Sie [a-z-[m-p]].

Betrachten Sie den geschachtelten Zeichenklassensubtraktionsausdruck [a-z-[d-w-[m-o]]]. Der Ausdruck wird vom innersten Zeichenbereich nach außen ausgewertet. Zuerst wird der Zeichenbereich "m" bis "o" vom Zeichenbereich "d" bis "w" subtrahiert. Ergebnis ist der Zeichensatz "d" bis "l" und "p" bis "w". Dieser Satz wird dann vom Zeichenbereich "a" bis "z" subtrahiert. Ergebnis ist der Zeichensatz [abcmnoxyz].

Sie können bei der Zeichenklassensubtraktion jede beliebige Zeichenklasse verwenden. Wenn Sie einen Zeichensatz definieren möchten, der aus allen Unicode-Zeichen von \u0000 bis \uFFFF mit Ausnahme von Leerzeichen (\s), den Zeichen in der allgemeinen Interpunktionskategorie (\p{P}), den Zeichen im benannten Block IsGreek (\p{IsGreek}) und dem Unicode-Steuerzeichen 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 Sie nützliche Ergebnisse erhalten. Vermeiden Sie Ausdrücke, die einen leeren Satz von Zeichen ergeben, die nichts entsprechen können, bzw. Ausdrücke, die der ursprünglichen Basisgruppe entsprechen. Ein leerer Zeichensatz ist z. B. das Ergebnis des Ausdrucks [\p{IsBasicLatin}-[\x00-\x7F]], mit dem alle Zeichen im IsBasicLatin-Zeichenbereich aus der allgemeinen Kategorie IsBasicLatin subtrahiert werden. Ähnlich ist die ursprüngliche Basisgruppe das Ergebnis des Ausdrucks [a-z-[0-9]]. Der Grund dafür ist, dass die Basisgruppe (der Zeichenbereich der Buchstaben von "a" bis "z") keine der Zeichen in der ausgeschlossenen Gruppe (dem Zeichenbereich der Dezimalziffern von "0" bis "9") enthält.

Im folgenden Beispiel wird ein regulärer Ausdruck definiert (^[0-9-[2468]]+$), der in einer Eingabezeichenfolge 0 (null) und ungeraden Zahlen entspricht. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.

Element	Beschreibungen
^	Starten Sie den Abgleich am Beginn der Eingabenzeichenfolge.
[0-9-[2468]]+	Entspricht mindestens einem Vorkommen eines beliebigen Zeichens von 0 bis 9 mit Ausnahme von 2, 4, 6 und 8. Anders ausgedrückt muss für mindestens ein Vorkommen von null oder einer ungeraden Zahl eine Übereinstimmung vorliegen.
$	Vergleich am Ende der Eingabezeichenfolge beenden.

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

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

Nach oben

Siehe auch

Referenz

GetUnicodeCategory

Optionen für reguläre Ausdrücke

Konzepte

Sprachelemente für reguläre Ausdrücke