Zeichenklassen in regulären AusdrückenCharacter Classes in Regular Expressions

Eine Zeichenklasse definiert einen Satz von Zeichen, von denen jedes in einer Eingabezeichenfolge enthalten sein kann, damit eine Übereinstimmung vorliegt.A character class defines a set of characters, any one of which can occur in an input string for a match to succeed. Die Sprache für reguläre Ausdrücke in .NET unterstützt die folgenden Zeichenklassen:The regular expression language in .NET supports the following character classes:

  • Positive Zeichengruppen.Positive character groups. Ein Zeichen in der Eingabezeichenfolge muss mit einem Zeichen in einem angegebenen Zeichensatz übereinstimmen.A character in the input string must match one of a specified set of characters. Weitere Informationen finden Sie unter Positive Zeichengruppe.For more information, see Positive Character Group.

  • Negative Zeichengruppen.Negative character groups. Ein Zeichen in der Eingabezeichenfolge darf nicht mit einem Zeichen in einem angegebenen Zeichensatz übereinstimmen.A character in the input string must not match one of a specified set of characters. Weitere Informationen finden Sie unter Negative Zeichengruppe.For more information, see Negative Character Group.

  • Jedes Zeichen.Any character. Beim .-Zeichen (Punkt) in einem regulären Ausdruck handelt es sich um ein Platzhalterzeichen, das mit Ausnahme von \n mit jedem Zeichen übereinstimmt.The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. Weitere Informationen finden Sie unter Alle Zeichen.For more information, see Any Character.

  • Eine allgemeine Unicode-Kategorie oder ein benannter Block.A general Unicode category or named 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.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. Weitere Informationen finden Sie unter Unicode-Kategorie oder Unicode-Block.For more information, see Unicode Category or Unicode Block.

  • Eine negative allgemeine Unicode-Kategorie oder ein benannter Block.A negative general Unicode category or named 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.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. Weitere Informationen finden Sie unter Negative Unicode-Kategorie oder negativer Unicode-Block.For more information, see Negative Unicode Category or Unicode Block.

  • Ein Wortzeichen.A word character. Ein Zeichen in der Eingabezeichenfolge kann allen Unicode-Kategorien angehören, die für Zeichen in Wörtern geeignet sind.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. Weitere Informationen finden Sie unter Wortzeichen.For more information, see Word Character.

  • Ein Nicht-Wortzeichen.A non-word character. Ein Zeichen in der Eingabezeichenfolge kann jeder Unicode-Kategorie angehören, bei der es sich nicht um ein Wortzeichen handelt.A character in the input string can belong to any Unicode category that is not a word character. Weitere Informationen finden Sie unter Nicht-Wortzeichen.For more information, see Non-Word Character.

  • Ein Leerzeichen.A white-space character. Ein Zeichen in der Eingabezeichenfolge kann sowohl jedes Unicode-Trennzeichen als auch jedes Zeichen aus einer Anzahl von Steuerzeichen sein.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. Weitere Informationen finden Sie unter Leerzeichen.For more information, see White-Space Character.

  • Ein Nicht-Leerzeichen.A non-white-space character. Ein Zeichen in der Eingabezeichenfolge kann jedes Nicht-Leerzeichen sein.A character in the input string can be any character that is not a white-space character. Weitere Informationen finden Sie unter Nicht-Leerzeichen.For more information, see Non-White-Space Character.

  • Eine Dezimalzahl.A decimal digit. Ein Zeichen in der Eingabezeichenfolge kann jedes als Unicode-Dezimalzeichen klassifiziertes Zeichen sein.A character in the input string can be any of a number of characters classified as Unicode decimal digits. Weitere Informationen finden Sie unter Dezimalzeichen.For more information, see Decimal Digit Character.

  • Ein Nicht-Dezimalzeichen.A non-decimal digit. Ein Zeichen in der Eingabezeichenfolge kann mit Ausnahme von Unicode-Dezimalzeichen jedes Zeichen sein.A character in the input string can be anything other than a Unicode decimal digit. Weitere Informationen finden Sie unter Dezimalzeichen.For more information, see Decimal Digit Character.

.NET unterstützt Zeichenklassensubtraktions-Ausdrücke. Hierdurch können Sie einen Zeichensatz definieren, der das Ergebnis des Ausschlusses einer Zeichenklasse von einer anderen darstellt..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. Weitere Informationen finden Sie unter Zeichenklassensubtraktion.For more information, see Character Class Subtraction.

Hinweis

Zeichenklassen, die Zeichen nach Kategorie abgleichen, etwa \w zum Abgleichen von Wortzeichen oder \p{} zum Abgleichen mit einer Unicode-Kategorie, setzen auf der CharUnicodeInfo-Klasse auf, um Informationen zu Zeichenkategorien bereitzustellen.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. Ab .NET Framework 4.6.2.NET Framework 4.6.2 basieren Zeichenkategorien auf dem Unicode Standard, Version 8.0.0.Starting with the .NET Framework 4.6.2.NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. In .NET Framework 4.NET Framework 4 bis .NET Framework 4.6.1.NET Framework 4.6.1 basieren sie auf dem Unicode-Standard, Version 6.3.0.In the .NET Framework 4.NET Framework 4 through the .NET Framework 4.6.1.NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

Positive Zeichengruppe: [ ]Positive Character Group: [ ]

In einer positiven Zeichengruppe wird eine Liste von Zeichen festgelegt. Wenn eine Eingabezeichenfolge eines dieser Zeichen aufweist, liegt eine Übereinstimmung vor.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. Diese Zeichenliste kann einzeln, als Bereich oder beides angegeben werden.This list of characters may be specified individually, as a range, or both.

Die Syntax zum Angeben einer Liste einzelner Zeichen lautet wie folgt:The syntax for specifying a list of individual characters is as follows:

[Zeichen_Gruppe][character_group]

wobei Zeichen_Gruppe eine Liste der einzelnen Zeichen ist, die in der Eingabezeichenfolge vorkommen können, damit eine Übereinstimmung vorliegt.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. Zeichen_Gruppe kann aus einer beliebigen Kombination von mindestens einem Literalzeichen, Escapezeichen oder Zeichenklassen bestehen.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

Die Syntax zum Angeben eines Zeichenbereichs lautet wie folgt:The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]  

wobei firstCharacter das Zeichen ist, mit dem der Bereich beginnt, und lastCharacter das Zeichen, mit dem der Bereich endet.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. 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.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Zwei Zeichen sind zusammenhängend, wenn sie benachbarte Unicode-Codepunkte aufweisen.Two characters are contiguous if they have adjacent Unicode code points.

In der folgenden Tabelle werden einige allgemeine Muster für reguläre Ausdrücke mit positiven Zeichenklassen aufgeführt.Some common regular expression patterns that contain positive character classes are listed in the following table.

MusterPattern Beschreibung Description
[aeiou] Übereinstimmung mit allen Vokalen.Match all vowels.
[\p{P}\d] Übereinstimmung mit allen Interpunktions- und Dezimalzeichen.Match all punctuation and decimal digit characters.
[\s\p{P}] Übereinstimmung mit allen Leerzeichen und Interpunktionszeichen.Match all white space and punctuation.

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.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

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:The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

MusterPattern Beschreibung Description
gr Übereinstimmung mit den Literalzeichen"gr".Match the literal characters "gr".
[ae] Übereinstimmung mit entweder "a" oder "e".Match either an "a" or an "e".
y\s Übereinstimmung mit dem Literalzeichen "y" gefolgt von einem Leerzeichen.Match the literal character "y" followed by a white-space character.
\S+? Übereinstimmung mit mindestens einem, jedoch möglichst wenigen Nicht-Leerzeichen.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] Übereinstimmung mit entweder einem Leerzeichen oder einem Interpunktionszeichen.Match either a white-space character or a punctuation mark.

Im folgenden Beispiel liegen Übereinstimmungen mit Wörtern vor, die mit einem die oft ausgegebene Befehlszeilen Großbuchstaben beginnen.The following example matches words that begin with any capital letter. Der Großbuchstabenbereich von A bis Z wird durch den [A-Z]-Unterausdruck dargestellt.It uses the subexpression [A-Z] to represent the range of capital letters from A to Z.

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:The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

MusterPattern Beschreibung Description
\b An einer Wortgrenze beginnen.Start at a word boundary.
[A-Z] Übereinstimmung mit einem die oft ausgegebene Befehlszeilen Großbuchstaben von A bis Z.Match any uppercase character from A to Z.
\w* Übereinstimmung mit keinem oder mehreren Wortzeichen.Match zero or more word characters.
\b Übereinstimmung mit einer Wortgrenze.Match a word boundary.

Zurück zum AnfangBack to Top

Negative Zeichengruppe: [^]Negative Character Group: [^]

In einer negativen Zeichengruppe wird eine Liste von Zeichen festgelegt. Eine Eingabezeichenfolge darf keines dieser Zeichen aufweisen, damit eine Übereinstimmung vorliegt.A negative character group specifies a list of characters that must not appear in an input string for a match to occur. Die Zeichenliste kann einzeln, als Bereich oder beides angegeben werden.The list of characters may be specified individually, as a range, or both.

Die Syntax zum Angeben einer Liste einzelner Zeichen lautet wie folgt:The syntax for specifying a list of individual characters is as follows:

[^Zeichen_Gruppe][^character_group]

wobei Zeichen_Gruppe eine Liste der einzelnen Zeichen ist, die in der Eingabezeichenfolge nicht vorkommen können, damit eine Übereinstimmung vorliegt.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. Zeichen_Gruppe kann aus einer beliebigen Kombination von mindestens einem Literalzeichen, Escapezeichen oder Zeichenklassen bestehen.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

Die Syntax zum Angeben eines Zeichenbereichs lautet wie folgt:The syntax for specifying a range of characters is as follows:

[^erstesZeichen-letztesZeichen][^firstCharacter-lastCharacter]

wobei erstesZeichen das Zeichen ist, mit dem der Bereich beginnt, und letztesZeichen das Zeichen, mit dem der Bereich endet.where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. 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.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Zwei Zeichen sind zusammenhängend, wenn sie benachbarte Unicode-Codepunkte aufweisen.Two characters are contiguous if they have adjacent Unicode code points.

Mindestens zwei Zeichenbereiche können miteinander verkettet werden.Two or more character ranges can be concatenated. 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].For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [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.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

Wichtig

Bei einer negativen Zeichengruppe in einem größeren Muster eines regulären Ausdrucks handelt es sich nicht um eine Assertion mit einer Breite von Null.A negative character group in a larger regular expression pattern is not a zero-width assertion. Dies bedeutet, dass nach dem Auswerten der negativen Zeichengruppe die Engine für reguläre Ausdrücke in der Eingabezeichenfolge zum nachfolgenden Zeichen übergeht.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

In der folgenden Tabelle werden einige allgemeine Muster für reguläre Ausdrücke mit negativen Zeichengruppen aufgeführt.Some common regular expression patterns that contain negative character groups are listed in the following table.

MusterPattern Beschreibung Description
[^aeiou] Übereinstimmung mit allen Zeichen mit Ausnahme von Vokalen.Match all characters except vowels.
[^\p{P}\d] Übereinstimmung mit allen Zeichen mit Ausnahme von Interpunktions- und Dezimalzeichen.Match all characters except punctuation and decimal digit characters.

Im folgenden Beispiel werden Übereinstimmungen für alle Wörter dargestellt, die mit den Zeichen "th" beginnen, wobei darauf kein "o" folgt.The following example matches any word that begins with the characters "th" and is not followed by an "o".

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:The regular expression \bth[^o]\w+\b is defined as shown in the following table.

MusterPattern Beschreibung Description
\b An einer Wortgrenze beginnen.Start at a word boundary.
th Übereinstimmung mit den Literalzeichen"th".Match the literal characters "th".
[^o] Übereinstimmung mit allen Zeichen außer "o".Match any character that is not an "o".
\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
\b An einer Wortgrenze beenden.End at a word boundary.

Zurück zum AnfangBack to Top

Alle Zeichen: .Any Character: .

Das Punktzeichen (.) stimmt mit Ausnahme von \n (dem Zeichen für einen Zeilenumbruch, "\u000A") mit allen Zeichen überein. Hierfür gelten die folgenden beiden Qualifikationen:The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • 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.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. Weitere Informationen finden Sie unter Optionen für reguläre Ausdrücke.For more information, see Regular Expression Options.

    Im folgenden Beispiel wird das unterschiedliche Verhalten der .-Zeichenklasse in der Standardeinstellung und mit der RegexOptions.Singleline-Option veranschaulicht.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. Der reguläre ^.+-Ausdruck beginnt am Anfang der Zeichenfolge und stimmt mit jedem Zeichen überein.The regular expression ^.+ starts at the beginning of the string and matches every character. Standardmäßig endet die Übereinstimmung am Ende der ersten Zeile. Das Muster für den regulären Ausdruck stimmt mit dem Wagenrücklaufzeichen (\r oder "\u000D"), jedoch nicht mit \n überein.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \n. 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.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \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\.
    

Hinweis

Da für die .-Zeichenklasse mit Ausnahme von \n eine Übereinstimmung mit jedem Zeichen vorliegt, stimmt \r (das Wagenrücklaufzeichen, "\u000D") ebenfalls überein.Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • In einer positiven oder negativen Zeichengruppe wird ein Punkt anstatt einer Zeichenklasse als Literalzeichen behandelt.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. Weitere Informationen finden Sie weiter oben in diesem Thema unter Positive Zeichengruppe und Negative Zeichengruppe.For more information, see Positive Character Group and Negative Character Group earlier in this topic. 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.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. 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.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    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.
    

Hinweis

Aufgrund der Übereinstimmung des .-Sprachelements mit jedem Zeichen wird es häufig mit einem verzögerten Quantifizierer verwendet, wenn von einem Muster für einen regulären Ausdruck mehrere Versuche bezüglich der Übereinstimmung eines bestimmten Zeichens ausgeführt werden.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. Weitere Informationen finden Sie unter Quantifizierer.For more information, see Quantifiers.

Zurück zum AnfangBack to Top

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

Jedem Zeichen wird im Unicode-Standard eine allgemeine Kategorie zugewiesen.The Unicode standard assigns each character a general category. 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.For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Bestimmte Zeichensätze im Unicode-Standard nehmen auch einen bestimmten Bereich oder einen Block aufeinander folgender Codepunkte ein.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Beispielsweise befindet sich der grundlegende lateinische Zeichensatz im Bereich von "\u0000" bis "\u007F", während der arabische Zeichensatz zwischen "\u0600" und "\u06FF" liegt.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

Konstrukt des regulären AusdrucksThe regular expression construct

\p{ Name }\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.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. Eine Liste von Kategorieabkürzungen finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte allgemeine Unicode-Kategorien.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Eine Liste von benannten Blöcken finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte benannte Blöcke.For a list of named blocks, see the Supported Named Blocks section later in this topic.

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.The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

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:The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

MusterPattern Beschreibung Description
\b An einer Wortgrenze beginnen.Start at a word boundary.
\p{IsGreek}+ Übereinstimmung mit mindestens einem griechischen Zeichen.Match one or more Greek characters.
(\s)? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
(\p{IsGreek}+(\s)?)+ Übereinstimmung mit dem Muster mindestens eines griechischen Zeichens, ein- oder mehrmals gefolgt von einer Null oder einem Leerzeichen.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} Übereinstimmung mit einem Interpunktionszeichen oder Bindestrich.Match a Punctuation, Dash character.
\s Entsprechung für ein Leerraumzeichen finden.Match a white-space character.
\p{IsBasicLatin}+ Übereinstimmung mit mindestens einem grundlegenden lateinischen Zeichen.Match one or more basic Latin characters.
(\s)? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
(\p{IsBasicLatin}+(\s)?)+ Übereinstimmung mit dem Muster mindestens eines grundlegenden lateinischen Zeichens, ein- oder mehrmals gefolgt von einer Null oder einem Leerzeichen.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

Zurück zum AnfangBack to Top

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

Jedem Zeichen wird im Unicode-Standard eine allgemeine Kategorie zugewiesen.The Unicode standard assigns each character a general category. 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.For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Bestimmte Zeichensätze im Unicode-Standard nehmen auch einen bestimmten Bereich oder einen Block aufeinander folgender Codepunkte ein.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Beispielsweise befindet sich der grundlegende lateinische Zeichensatz im Bereich von "\u0000" bis "\u007F", während der arabische Zeichensatz zwischen "\u0600" und "\u06FF" liegt.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

Konstrukt des regulären AusdrucksThe regular expression construct

\P{ Name }\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.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. Eine Liste von Kategorieabkürzungen finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte allgemeine Unicode-Kategorien.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Eine Liste von benannten Blöcken finden Sie weiter unten in diesem Thema im Abschnitt Unterstützte benannte Blöcke.For a list of named blocks, see the Supported Named Blocks section later in this topic.

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.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

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.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

Zurück zum AnfangBack to Top

Wortzeichen: \wWord Character: \w

\w entspricht einem beliebigen Wortzeichen.\w matches any word character. Ein Wortzeichen gehört einer der in der folgenden Tabelle aufgeführten Unicode-Kategorien an.A word character is a member of any of the Unicode categories listed in the following table.

KategorieCategory Beschreibung Description
LlLl Letter, Lowercase (Buchstabe, Kleinschreibung)Letter, Lowercase
LuLu Letter, Uppercase (Buchstabe, Großschreibung)Letter, Uppercase
LtLt Letter, Titlecase (Buchstabe, großer Anfangsbuchstabe)Letter, Titlecase
LoLo Letter, Other (Buchstabe, andere)Letter, Other
LmLm Letter, Modifier (Buchstabe, Modifizierer)Letter, Modifier
MnMn Mark, Nonspacing (Satzzeichen, ohne horizontalen Vorschub)Mark, Nonspacing
NdNd Number, Decimal Digit (Zahl, Dezimalzahl)Number, Decimal Digit
PcPc Punctuation, Connector (Interpunktion, Konnektor).Punctuation, Connector. Zu dieser Kategorie gehören zehn Zeichen, von denen das UNTERSTRICH-Zeichen "u+005F" () am häufigsten verwendet wird.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \w dem [a-zA-Z_0-9]-Ausdruck.If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Hinweis

Aufgrund der Übereinstimmung des \w-Sprachelements mit jedem Wortzeichen wird es häufig mit einem verzögerten Quantifizierer verwendet, wenn ein Muster für einen regulären Ausdruck mehrmals versucht, eine Übereinstimmung mit einem beliebigen Wortzeichen, gefolgt von einem bestimmten Wortzeichen, herzustellen.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. Weitere Informationen finden Sie unter Quantifizierer.For more information, see Quantifiers.

Im folgenden Beispiel werden mit dem \w-Sprachelement übereinstimmende doppelte Zeichen innerhalb eines Worts ermittelt.The following example uses the \w language element to match duplicate characters in a word. Im Beispiel wird ein Muster für reguläre Ausdrücke definiert ((\w)\1), das wie folgt interpretiert werden kann.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

ElementElement Beschreibung Description
(\w)(\w) Übereinstimmung mit einem Wortzeichen.Match a word character. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\1\1 Übereinstimmung mit dem Wert der ersten Erfassung.Match the value of the first capture.
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.

Zurück zum AnfangBack to Top

Nicht-Wortzeichen: \WNon-Word Character: \W

\W entspricht einem beliebigen Nichtwortzeichen.\W matches any non-word character. Das \W-Sprachelement entspricht der folgenden Zeichenklasse:The \W language element is equivalent to the following character class:

[^\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.In other words, it matches any character except for those in the Unicode categories listed in the following table.

KategorieCategory Beschreibung Description
LlLl Letter, Lowercase (Buchstabe, Kleinschreibung)Letter, Lowercase
LuLu Letter, Uppercase (Buchstabe, Großschreibung)Letter, Uppercase
LtLt Letter, Titlecase (Buchstabe, großer Anfangsbuchstabe)Letter, Titlecase
LoLo Letter, Other (Buchstabe, andere)Letter, Other
LmLm Letter, Modifier (Buchstabe, Modifizierer)Letter, Modifier
MnMn Mark, Nonspacing (Satzzeichen, ohne horizontalen Vorschub)Mark, Nonspacing
NdNd Number, Decimal Digit (Zahl, Dezimalzahl)Number, Decimal Digit
PcPc Punctuation, Connector (Interpunktion, Konnektor).Punctuation, Connector. Zu dieser Kategorie gehören zehn Zeichen, von denen das UNTERSTRICH-Zeichen "u+005F" () am häufigsten verwendet wird.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \W dem [^a-zA-Z_0-9]-Ausdruck.If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Hinweis

Aufgrund der Übereinstimmung des \W-Sprachelements mit jedem Nichtwortzeichen wird es häufig mit einem verzögerten Quantifizierer verwendet, wenn ein Muster für einen regulären Ausdruck mehrmals versucht, eine Übereinstimmung mit einem beliebigen Nichtwortzeichen, gefolgt von einem bestimmten Nichtwortzeichen, herzustellen.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. Weitere Informationen finden Sie unter Quantifizierer.For more information, see Quantifiers.

Das folgende Beispiel veranschaulicht die \W-Zeichenklasse.The following example illustrates the \W character class. 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.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.The regular expression is interpreted as shown in the following table.

ElementElement Beschreibung Description
\b\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
(\w+)(\w+) Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
(\W){1,2}(\W){1,2} Übereinstimmung mit einem Nicht-Wortzeichen (ein- oder zweimal).Match a non-word character either one or two times. Dies ist die zweite Erfassungsgruppe.This is the second capturing group.
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.Because the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

Zurück zum AnfangBack to Top

Leerzeichen: \sWhite-Space Character: \s

\s stimmt mit jedem Leerzeichen überein.\s matches any white-space character. Dies ist zu den in der folgenden Tabelle aufgeführten Escapesequenzen und Unicode-Kategorien äquivalent.It is equivalent to the escape sequences and Unicode categories listed in the following table.

KategorieCategory Beschreibung Description
\f Seitenvorschubzeichen, "\u000C".The form feed character, \u000C.
\n Zeilenumbruchzeichen, "\u000A".The newline character, \u000A.
\r Wagenrücklaufzeichen, "\u000D".The carriage return character, \u000D.
\t Tabstoppzeichen, "\u0009".The tab character, \u0009.
\v Vertikales Tabstoppzeichen, "\u000B".The vertical tab character, \u000B.
\x85 Auslassungs- oder NÄCHSTE ZEILE (NEL)-Zeichen (…), "\u0085".The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} Übereinstimmung mit jedem Trennzeichen.Matches any separator character.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \s dem [ \f\n\r\t\v]-Ausdruck.If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Das folgende Beispiel veranschaulicht die \s-Zeichenklasse.The following example illustrates the \s character class. 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.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.The regular expression is interpreted as shown in the following table.

ElementElement Beschreibung Description
\b\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
\w+\w+ Übereinstimmung mit mindestens einem Wortzeichen.Match one or more word characters.
(e)?(e)? Übereinstimmung mit "e", entweder null- oder einmal.Match an "e" either zero or one time.
ss Übereinstimmung mit "s".Match an "s".
(\s|$)(\s|$) Übereinstimmung mit entweder einem Leerzeichen oder dem Ende der Eingabezeichenfolge.Match either a white-space character or the end of the input string.
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

Zurück zum AnfangBack to Top

Nicht-Leerzeichen: \SNon-White-Space Character: \S

\S entspricht einem beliebigen Nichtleerraumzeichen.\S matches any non-white-space character. 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.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. Weitere Informationen finden Sie unter Leerzeichen: \s.For more information, see White-Space Character: \s.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \S dem [^ \f\n\r\t\v]-Ausdruck.If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Im folgenden Beispiel wird das \S-Sprachelement veranschaulicht.The following example illustrates the \S language element. Das Muster für den regulären Ausdruck \b(\S+)\s? stimmt mit durch Leerzeichen getrennten Zeichenfolgen überein.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. Das zweite Element im GroupCollection-Objekt der Übereinstimmung enthält die entsprechende Zeichenfolge.The second element in the match's GroupCollection object contains the matched string. Der reguläre Ausdruck kann wie in der folgenden Tabelle dargestellt interpretiert werden.The regular expression can be interpreted as shown in the following table.

ElementElement Beschreibung Description
\b Der Vergleich beginnt an einer Wortgrenze.Begin the match at a word boundary.
(\S+) Übereinstimmung mit mindestens einem Nicht-Leerzeichen.Match one or more non-white-space characters. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\s? Übereinstimmung mit keinem oder einem Leerzeichen.Match zero or one white-space character.
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.

Zurück zum AnfangBack to Top

Dezimalzahl: \dDecimal Digit Character: \d

\d entspricht einer beliebigen Dezimalziffer.\d matches any decimal digit. 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.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \d dem [0-9]-Ausdruck.If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Im folgenden Beispiel wird das \d-Sprachelement veranschaulicht.The following example illustrates the \d language element. Anhand eines Tests soll ermittelt werden, ob eine Eingabezeichenfolge eine gültige Telefonnummer in den USA und Kanada darstellt.It tests whether an input string represents a valid telephone number in the United States and Canada. Das Muster für reguläre Ausdrücke ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ wird entsprechend der folgenden Tabelle definiert:The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

ElementElement Beschreibung Description
^ Beginnt den Vergleich am Anfang der Eingabezeichenfolge.Begin the match at the beginning of the input string.
\(? Übereinstimmung mit null oder einem Literalzeichen ("(").Match zero or one literal "(" character.
\d{3} Entsprechung für drei Dezimalstellen finden.Match three decimal digits.
\)? Übereinstimmung mit null oder einem Literalzeichen (")").Match zero or one literal ")" character.
[\s-] Übereinstimmung mit einem Bindestrich oder Leerzeichen.Match a hyphen or a white-space character.
(\(?\d{3}\)?[\s-])? Übereinstimmung mit einer optionalen öffnenden Klammer gefolgt von drei Dezimalzahlen, einer optionalen schließenden Klammer sowie entweder null- oder einmal von einem Leerzeichen oder Bindestrich.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. Dies ist die erste Erfassungsgruppe.This is the first capturing group.
\d{3}-\d{4} Übereinstimmung mit drei Dezimalzahlen gefolgt von einem Bindestrich und vier zusätzlichen Dezimalzahlen.Match three decimal digits followed by a hyphen and four more decimal digits.
$ Entsprechung für das Ende der Eingabezeichenfolge finden.Match the end of the input string.
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

Zurück zum AnfangBack to Top

Nicht-Zahlen: \DNon-Digit Character: \D

\D stimmt mit jedem Zeichen außer Zahlen überein.\D matches any non-digit character. Dies entspricht dem Muster des regulären Ausdrucks \P{Nd}.It is equivalent to the \P{Nd} regular expression pattern.

Bei Angabe von ECMAScript-kompatiblem Verhalten entspricht \D dem [^0-9]-Ausdruck.If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. Weitere Informationen zu regulären ECMAScript-Ausdrücken finden Sie im Abschnitt „ECMAScript-Vergleichsverhalten“ unter Optionen für reguläre Ausdrücke.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Im folgenden Beispiel wird das "\D"-Sprachelement veranschaulicht.The following example illustrates the \D language element. Anhand eines Tests wird ermittelt, ob eine Zeichenfolge (z. B. eine Teilenummer) aus der gewünschten Kombination von Dezimalzahlen und Nicht-Dezimalzahlen besteht.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. Das Muster für reguläre Ausdrücke ^\D\d{1,5}\D*$ wird entsprechend der folgenden Tabelle definiert:The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

ElementElement Beschreibung Description
^ Beginnt den Vergleich am Anfang der Eingabezeichenfolge.Begin the match at the beginning of the input string.
\D Übereinstimmung mit jedem Zeichen außer Zahlen.Match a non-digit character.
\d{1,5} Übereinstimmung mit einer bis fünf Dezimalzahlen.Match from one to five decimal digits.
\D* Übereinstimmung mit null, einem oder mehreren Nichtdezimalzeichen.Match zero, one, or more non-decimal characters.
$ Entsprechung für das Ende der Eingabezeichenfolge finden.Match the end of the input string.
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:

Zurück zum AnfangBack to Top

Unterstützte allgemeine Unicode-KategorienSupported Unicode General Categories

In der folgenden Tabelle werden die allgemeinen, in Unicode definierten Kategorien aufgeführt.Unicode defines the general categories listed in the following table. Weitere Informationen finden Sie in den Unterthemen „UCD File Format“ (UCD-Dateiformat) und „General Category Values“ (Allgemeine Kategorienwerte) der Unicode Character Database.For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

KategorieCategory Beschreibung Description
Lu Letter, Uppercase (Buchstabe, Großschreibung)Letter, Uppercase
Ll Letter, Lowercase (Buchstabe, Kleinschreibung)Letter, Lowercase
Lt Letter, Titlecase (Buchstabe, großer Anfangsbuchstabe)Letter, Titlecase
Lm Letter, Modifier (Buchstabe, Modifizierer)Letter, Modifier
Lo Letter, Other (Buchstabe, andere)Letter, Other
L Alle Buchstaben.All letter characters. Hierzu zählen die Zeichen Lu, Ll, Lt, Lm und Lo.This includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn Mark, Nonspacing (Satzzeichen, ohne horizontalen Vorschub)Mark, Nonspacing
Mc Mark, Spacing Combining (Satzzeichen, Kombinationszeichen mit Vorschub)Mark, Spacing Combining
Me Mark, Enclosing (Satzzeichen, einschließend)Mark, Enclosing
M Alle diakritischen Zeichen.All diacritic marks. Hierzu zählen die Kategorien Mn, Mc und Me.This includes the Mn, Mc, and Me categories.
Nd Number, Decimal Digit (Zahl, Dezimalzahl)Number, Decimal Digit
Nl Number, Letter (Zahl, Buchstabe)Number, Letter
No Number, Other (Zahl, andere)Number, Other
N Alle Zahlen.All numbers. Hierzu zählen die Kategorien Nd, Nl und No.This includes the Nd, Nl, and No categories.
Pc Punctuation, Connector (Interpunktion, Konnektor)Punctuation, Connector
Pd Punctuation, Dash (Interpunktion, Bindestrich)Punctuation, Dash
Ps Punctuation, Open (Interpunktion, öffnend)Punctuation, Open
Pe Punctuation, Close (Interpunktion, schließend)Punctuation, Close
Pi Punctuation, Initial quote (Interpunktion, öffnendes Anführungszeichen; kann sich je nach Verwendung wie "Ps" oder "Pe" verhalten)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf Punctuation, Final quote (Interpunktion, schließendes Anführungszeichen; kann sich je nach Verwendung wie "Ps" oder "Pe" verhalten)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po Punctuation, Other (Interpunktion, andere)Punctuation, Other
P Alle Interpunktionszeichen.All punctuation characters. Hierzu zählen die Kategorien Pc, Pd, Ps, Pe, Pi, Pf und Po.This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm Symbol, Math (Symbol, Mathematik)Symbol, Math
Sc Symbol, Currency (Symbol, Währung)Symbol, Currency
Sk Symbol, Modifier (Symbol, Modifizierer)Symbol, Modifier
So Symbol, Other (Symbol, andere)Symbol, Other
S Alle Symbole.All symbols. Hierzu zählen die Kategorien Sm, Sc, Sk und So.This includes the Sm, Sc, Sk, and So categories.
Zs Separator, Space (Trennzeichen, Leerzeichen)Separator, Space
Zl Separator, Line (Trennzeichen, Zeile)Separator, Line
Zp Separator, Paragraph (Trennzeichen, Absatz)Separator, Paragraph
Z Alle Trennzeichen.All separator characters. Hierzu zählen die Kategorien Zs, Zl und Zp.This includes the Zs, Zl, and Zp categories.
Cc Other, Control (Andere, Steuerzeichen)Other, Control
Cf Other, Format (Andere, Format)Other, Format
Cs Other, Surrogate (Andere, Ersatzzeichen)Other, Surrogate
Co Other, Private Use (Andere, persönliche Verwendung)Other, Private Use
Cn Other, Not Assigned (Andere, nicht zugewiesen; kein Zeichen weist diese Eigenschaft auf)Other, Not Assigned (no characters have this property)
C Alle Steuerzeichen.All control characters. Hierzu zählen die Kategorien Cc, Cf, Cs, Co und Cn.This includes the Cc, Cf, Cs, Co, and Cn categories.

Sie können die Unicode-Kategorie eines bestimmten Zeichens ermitteln, indem Sie das Zeichen an die GetUnicodeCategory-Methode übergeben.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. Im folgenden Beispiel wird mithilfe der GetUnicodeCategory-Methode die Kategorie jedes Elements in einem Array mit ausgewählten lateinischen Zeichen ermittelt.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

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

Zurück zum AnfangBack to Top

Unterstützte benannte BlöckeSupported Named Blocks

In der folgenden Tabelle werden die von .NET bereitgestellten benannten Blöcke aufgelistet..NET provides the named blocks listed in the following table. Der Satz von unterstützten benannten Blöcke basiert auf Unicode 4.0 und Perl 5.6.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6.

CodepunktbereichCode point range BlocknameBlock name
0000 - 007F0000 - 007F IsBasicLatin
0080 - 00FF0080 - 00FF IsLatin-1Supplement
0100 - 017F0100 - 017F IsLatinExtended-A
0180 - 024F0180 - 024F IsLatinExtended-B
0250 - 02AF0250 - 02AF IsIPAExtensions
02B0 - 02FF02B0 - 02FF IsSpacingModifierLetters
0300 - 036F0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF0370 - 03FF IsGreek

- oder - -or-

IsGreekandCoptic
0400 - 04FF0400 - 04FF IsCyrillic
0500 - 052F0500 - 052F IsCyrillicSupplement
0530 - 058F0530 - 058F IsArmenian
0590 - 05FF0590 - 05FF IsHebrew
0600 - 06FF0600 - 06FF IsArabic
0700 - 074F0700 - 074F IsSyriac
0780 - 07BF0780 - 07BF IsThaana
0900 - 097F0900 - 097F IsDevanagari
0980 - 09FF0980 - 09FF IsBengali
0A00 - 0A7F0A00 - 0A7F IsGurmukhi
0A80 - 0AFF0A80 - 0AFF IsGujarati
0B00 - 0B7F0B00 - 0B7F IsOriya
0B80 - 0BFF0B80 - 0BFF IsTamil
0C00 - 0C7F0C00 - 0C7F IsTelugu
0C80 - 0CFF0C80 - 0CFF IsKannada
0D00 - 0D7F0D00 - 0D7F IsMalayalam
0D80 - 0DFF0D80 - 0DFF IsSinhala
0E00 - 0E7F0E00 - 0E7F IsThai
0E80 - 0EFF0E80 - 0EFF IsLao
0F00 - 0FFF0F00 - 0FFF IsTibetan
1000 - 109F1000 - 109F IsMyanmar
10A0 - 10FF10A0 - 10FF IsGeorgian
1100 - 11FF1100 - 11FF IsHangulJamo
1200 - 137F1200 - 137F IsEthiopic
13A0 - 13FF13A0 - 13FF IsCherokee
1400 - 167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F1680 - 169F IsOgham
16A0 - 16FF16A0 - 16FF IsRunic
1700 - 171F1700 - 171F IsTagalog
1720 - 173F1720 - 173F IsHanunoo
1740 - 175F1740 - 175F IsBuhid
1760 - 177F1760 - 177F IsTagbanwa
1780 - 17FF1780 - 17FF IsKhmer
1800 - 18AF1800 - 18AF IsMongolian
1900 - 194F1900 - 194F IsLimbu
1950 - 197F1950 - 197F IsTaiLe
19E0 - 19FF19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF1F00 - 1FFF IsGreekExtended
2000 - 206F2000 - 206F IsGeneralPunctuation
2070 - 209F2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF20A0 - 20CF IsCurrencySymbols
20D0 - 20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

- oder - -or-

IsCombiningMarksforSymbols
2100 - 214F2100 - 214F IsLetterlikeSymbols
2150 - 218F2150 - 218F IsNumberForms
2190 - 21FF2190 - 21FF IsArrows
2200 - 22FF2200 - 22FF IsMathematicalOperators
2300 - 23FF2300 - 23FF IsMiscellaneousTechnical
2400 - 243F2400 - 243F IsControlPictures
2440 - 245F2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F2500 - 257F IsBoxDrawing
2580 - 259F2580 - 259F IsBlockElements
25A0 - 25FF25A0 - 25FF IsGeometricShapes
2600 - 26FF2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF2700 - 27BF IsDingbats
27C0 - 27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF2800 - 28FF IsBraillePatterns
2900 - 297F2900 - 297F IsSupplementalArrows-B
2980 - 29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F3040 - 309F IsHiragana
30A0 - 30FF30A0 - 30FF IsKatakana
3100 - 312F3100 - 312F IsBopomofo
3130 - 318F3130 - 318F IsHangulCompatibilityJamo
3190 - 319F3190 - 319F IsKanbun
31A0 - 31BF31A0 - 31BF IsBopomofoExtended
31F0 - 31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF3300 - 33FF IsCJKCompatibility
3400 - 4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48FA000 - A48F IsYiSyllables
A490 - A4CFA490 - A4CF IsYiRadicals
AC00 - D7AFAC00 - D7AF IsHangulSyllables
D800 - DB7FD800 - DB7F IsHighSurrogates
DB80 - DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFFDC00 - DFFF IsLowSurrogates
E000 - F8FFE000 - F8FF IsPrivateUse oder IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900 - FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0FFE00 - FE0F IsVariationSelectors
FE20 - FE2FFE20 - FE2F IsCombiningHalfMarks
FE30 - FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6FFE50 - FE6F IsSmallFormVariants
FE70 - FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFFFFF0 - FFFF IsSpecials

Zurück zum AnfangBack to Top

Zeichenklassensubtraktion: [base_group - [excluded_group]]Character Class Subtraction: [base_group - [excluded_group]]

Eine Zeichenklasse definiert einen Satz von Zeichen.A character class defines a set of characters. Durch Zeichenklassensubtraktion erhalten Sie einen Zeichensatz, der das Ergebnis des Ausschlusses der Zeichen einer Zeichenklasse von einer anderen darstellt.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

Ein Zeichenklassensubtraktionsausdruck weist folgende Form auf:A character class subtraction expression has the following form:

[ Basisgruppe -[ ausgeschlossene_Gruppe ]][ base_group -[ excluded_group ]]

Die eckigen Klammern ([]) und der Bindestrich (-) sind obligatorisch.The square brackets ([]) and hyphen (-) are mandatory. Bei der Basisgruppe handelt es sich um eine positive Zeichengruppe oder eine negative Zeichengruppe.The base_group is a positive character group or a negative character group. 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).The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

Beispiel: Angenommen, Sie verfügen über eine Basisgruppe, die aus dem Zeichenbereich von "a" bis "z" besteht.For example, suppose you have a base group that consists of the character range from "a" through "z". Zum Definieren eines Zeichensatzes, der mit Ausnahme des Zeichens "m" aus der Basisgruppe besteht, verwenden Sie [a-z-[m]].To define the set of characters that consists of the base group except for the character "m", use [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]].To define the set of characters that consists of the base group except for the set of characters "d", "j", and "p", use [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]].To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

Betrachten Sie den geschachtelten [a-z-[d-w-[m-o]]]-Zeichenklassensubtraktionsausdruck.Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. Der Ausdruck wird vom innersten Zeichenbereich nach außen ausgewertet.The expression is evaluated from the innermost character range outward. 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.First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". Dieser Satz wird anschließend vom Zeichenbereich "a" bis "z" subtrahiert, sodass sich der Zeichensatz [abcmnoxyz] ergibt.That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

Für die Zeichenklassensubtraktion kann jede Zeichenklasse verwendet werden.You can use any character class with character class subtraction. 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]].To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\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.Choose character classes for a character class subtraction expression that will yield useful results. Vermeiden Sie Ausdrücke, die einen leeren Satz von Zeichen ergeben, mit nichts übereinstimmen oder ein Äquivalent der ursprünglichen Basisgruppe darstellen.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. 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.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. Gleichermaßen ist die ursprüngliche Basisgruppe das Ergebnis des Ausdrucks [a-z-[0-9]].Similarly, the original base group is the result of the expression [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.This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "9".

Im folgenden Beispiel wird ein regulärer Ausdruck definiert (^[0-9-[2468]]+$), der in einer Eingabezeichenfolge Übereinstimmungen für Null und ungerade Zahlen ergibt.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. Der reguläre Ausdruck wird entsprechend der Darstellung in der folgenden Tabelle interpretiert.The regular expression is interpreted as shown in the following table.

ElementElement Beschreibung Description
^ Beginnt am Anfang der Eingabezeichenfolge mit der Übereinstimmung.Begin the match at the start of the input string.
[0-9-[2468]]+ Mindestens eine Übereinstimmung mit einem Zeichen von 0 bis 9 (mit Ausnahme von 2, 4, 6 und 8) liegt vor.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. Anders ausgedrückt: Es liegt mindestens eine Übereinstimmung mit Null oder einer ungeraden Zahl vor.In other words, match one or more occurrences of zero or an odd digit.
$ Ende des Abgleichs am Ende der Eingabezeichenfolge.End the match at the end of the input string.
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 auchSee also