Freigeben über

Quantifizierer

  • Artikel

Quantifizierer geben an, wie viele Instanzen eines Zeichens, einer Gruppe oder einer Zeichenklasse in der Eingabe vorhanden sein müssen, damit eine Übereinstimmung festgestellt wird. In der folgenden Tabelle sind die Quantifizierer aufgeführt, die von .NET Framework unterstützt werden.

Gieriger Quantifizierer

Träge (lazy) Quantifizierer

Beschreibungen

*

*?

Entsprechung (nullmal oder mehrere Male).

+

+?

Mindestens einmalige Entsprechung.

?

??

Entsprechung (null- oder einmal).

{}n

{}?n

Entspricht genau n‑mal dem Zeichen.

{,}n

{,}?n

Entspricht mindestens n‑mal dem Zeichen.

{n,m}

{n,m}?

Entsprechung zwischen n- und m-mal.

Der Mengen n und m sind ganzzahlige Konstanten. Gewöhnlich sind Quantifizierer gierig; durch sie ordnet das Modul für reguläre Ausdrücke so viele Vorkommen bestimmter Muster wie möglich zu. Das Anhängen des ?-Zeichens an einen Quantifizierer macht es träge; es bewirkt, dass das Modul für reguläre Ausdrücke so wenige Vorkommen wie möglich findet. Eine vollständige Beschreibung des Unterschieds zwischen "gierigen" und "trägen" Quantifizierern finden Sie im Abschnitt Gierige und träge Quantifizierer später in diesem Thema.

Wichtiger HinweisWichtig

Das Schachteln von Quantifizierern (z. B. wie durch das Muster eines regulären Ausdrucks (a*)*) kann die Anzahl von Vergleichen, die das Modul für reguläre Ausdrücke ausführen muss, als Exponentialfunktion der Anzahl von Zeichen in der Eingabezeichenfolge erhöhen.Weitere Informationen zu diesem Verhalten und zu Problemumgehungen finden Sie unter Backtracking.

Reguläre Ausdrucksquantifizierer

In der folgenden Abschnittsliste sind die Quantifizierer aufgeführt, die von regulären .NET Framework-Ausdrücken unterstützt werden.

HinweisHinweis

Wenn die Zeichen *, +?, {, und } im Muster eines regulären Ausdrucks enthalten sind, interpretiert das Modul für reguläre Ausdrücke sie als Quantifizierer oder als Teil von Quantifiziererkonstrukten, sofern sie nicht in einer Zeichenklasse enthalten sind.Um diese außerhalb einer Zeichenklasse als Literalzeichen zu interpretieren, müssen Sie sie mit Escapezeichen versehen, indem Sie ihnen einen umgekehrten Schrägstrich voranstellen.Die Zeichenfolge \* in einem Muster eines regulären Ausdrucks wird z. B. als literales Sternchenzeichen ("*") interpretiert.

Entspricht dem Zeichen nullmal oder mehrere Male: *

Der *-Quantifizierer gleicht das vorausgehende Element nullmal oder häufiger ab. Sie entspricht dem {0,}-Quantifizierer. * ist ein gieriger Quantifizierer, dessen träge Entsprechung *? ist.

Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht. Von den neun Ziffern in der Eingabezeichenfolge stimmen fünf mit dem Muster überein und vier nicht (95, 929, 9129 und 9919).

Dim pattern As String = "\b91*9*\b"   
Dim input As String = "99 95 919 929 9119 9219 999 9919 91119"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next     
' The example displays the following output:   
'       '99' found at position 0.
'       '919' found at position 6.
'       '9119' found at position 14.
'       '999' found at position 24.
'       '91119' found at position 33.

string pattern = @"\b91*9*\b";   
string input = "99 95 919 929 9119 9219 999 9919 91119";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

// The example displays the following output:   
//       '99' found at position 0.
//       '919' found at position 6.
//       '9119' found at position 14.
//       '999' found at position 24.
//       '91119' found at position 33.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

91*

Entspricht "9" gefolgt von null oder mehr "1"-Zeichen.

9*

Entspricht null oder mehr "9"-Zeichen.

\b

An einer Wortgrenze beenden.

Mindestens einmalige Entsprechung: +

Der +-Quantifizierer gleicht das vorausgehende Element mindestens einmal ab. Ist äquivalent zu {1,}. + ist ein gieriger Quantifizierer, dessen träge Entsprechung +? ist.

Der reguläre Ausdruck \ban+\w*?\b sucht beispielsweise nach ganzen Wörtern, die mit dem Buchstaben a beginnen, auf den mindestens eine Instanz des Buchstaben n folgt. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht. Der reguläre Ausdruck liefert die Wörter an, annual, announcement und antique als Ergebnis und erkennt erwartungsgemäß keine Übereinstimmung bei den Wörtern autumn und all.

Dim pattern As String = "\ban+\w*?\b"

Dim input As String = "Autumn is a great time for an annual announcement to all antique collectors."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next   
' The example displays the following output:   
'       'an' found at position 27.
'       'annual' found at position 30.
'       'announcement' found at position 37.
'       'antique' found at position 57.      

string pattern = @"\ban+\w*?\b";

string input = "Autumn is a great time for an annual announcement to all antique collectors.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

// The example displays the following output:   
//       'an' found at position 27.
//       'annual' found at position 30.
//       'announcement' found at position 37.
//       'antique' found at position 57.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

an+

Entspricht "a" gefolgt von mindestens einem "n"-Zeichen.

\w*?

Entspricht einem Wortzeichen nullmal oder mehrere Male, doch so wenig wie möglich.

\b

An einer Wortgrenze beenden.

Entspricht dem Zeichen null- oder einmal: ?

Der ?-Quantifizierer gleicht das vorausgehende Element nullmal oder einmal ab. Ist äquivalent zu {0,1}. ? ist ein gieriger Quantifizierer, dessen träge Entsprechung ?? ist.

Der reguläre Ausdruck \ban?\b sucht beispielsweise nach ganzen Wörtern, die mit dem Buchstaben a beginnen, auf den keine oder eine Instanz des Buchstaben n folgt. Er sucht also nach den Wörtern a und an. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht.

Dim pattern As String = "\ban?\b"
Dim input As String = "An amiable animal with a large snount and an animated nose."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next  
' The example displays the following output:   
'       'An' found at position 0.
'       'a' found at position 23.
'       'an' found at position 42.

string pattern = @"\ban?\b";
string input = "An amiable animal with a large snount and an animated nose.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

// The example displays the following output:   
//        'An' found at position 0.
//        'a' found at position 23.
//        'an' found at position 42.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

an?

Entspricht "a" gefolgt von null oder einem "n"-Zeichen.

\b

An einer Wortgrenze beenden.

Entspricht genau n-mal dem Zeichen: {n}

Der {}-Quantifizierer entspricht dem vorangehenden Element genau n-mal, wobei n eine beliebige ganze Zahl ist. {n} ist ein gieriger Quantifizierer, dessen träge Entsprechung {n}? ist.

Der reguläre Ausdruck \b\d+\,\d{3}\b sucht beispielsweise nach Übereinstimmungen einer Wortgrenze, auf die mindestens eine Dezimalziffer, drei Dezimalziffern und eine weitere Wortgrenze folgen. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht.

Dim pattern As String = "\b\d+\,\d{3}\b"
Dim input As String = "Sales totaled 103,524 million in January, " + _
                      "106,971 million in February, but only " + _
                      "943 million in March."
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next     
' The example displays the following output:   
'       '103,524' found at position 14.
'       '106,971' found at position 45.

string pattern = @"\b\d+\,\d{3}\b";
string input = "Sales totaled 103,524 million in January, " + 
                      "106,971 million in February, but only " + 
                      "943 million in March.";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:   
//        '103,524' found at position 14.
//        '106,971' found at position 45.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

\d+

Entsprechung für mindestens eine Dezimalstelle finden.

\,

Entspricht einem Kommazeichen.

\d{3}

Entsprechung für drei Dezimalstellen finden.

\b

An einer Wortgrenze beenden.

Entspricht mindestens n‑mal dem Zeichen: {n,}

Der {n,}-Quantifizierer entspricht dem vorangehenden Element mindestens n-mal, wobei n eine beliebige ganze Zahl ist. {n,} ist ein gieriger Quantifizierer, dessen träge Entsprechung {n}? ist.

Der reguläre Ausdruck \b\d{2,}\b\D+ sucht beispielsweise nach Übereinstimmungen einer Wortgrenze, auf die mindestens zwei Ziffern, eine Wortgrenze und ein weiteres Zeichen folgen, bei dem es sich nicht um eine Ziffer handelt. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht. Der reguläre Ausdruck liefert kein Ergebnis für den Ausdruck "7 days", da dieser nur eine Dezimalziffer enthält, er erkennt jedoch erfolgreich Übereinstimmungen mit den Ausdrücken "10 weeks and 300 years".

 Dim pattern As String = "\b\d{2,}\b\D+"  
 Dim input As String = "7 days, 10 weeks, 300 years"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       '10 weeks, ' found at position 8.
'       '300 years' found at position 18.

string pattern = @"\b\d{2,}\b\D+";   
string input = "7 days, 10 weeks, 300 years";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        '10 weeks, ' found at position 8.
//        '300 years' found at position 18.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

\d{2,}

Entspricht mindestens zwei Dezimalstellen.

\b

Entsprechung für eine Wortgrenze finden.

\D+

Entspricht mindestens einer nicht dezimalen Stelle.

Entspricht dem Zeichen zwischen n- und m-mal: {n,m}?

Der {n,m}-Quantifizierer entspricht dem vorangehenden Element mindestens n-mal und maximal m-mal, wobei n und m ganze Zahlen sind. {n,m} ist ein gieriger Quantifizierer, dessen träge Entsprechung {n,m}? ist.

Im folgenden Beispiel sucht der reguläre Ausdruck (00\s){2,4} beispielsweise nach zwei bis vier Vorkommen zweier 0-Ziffern, auf die ein Leerzeichen folgt. Beachten Sie, dass der letzte Abschnitt der Eingabezeichenfolge dieses Muster fünf Mal und nicht maximal vier Mal enthält. Nur der Anfangsabschnitt dieser Teilzeichenfolge (bis zum Leerzeichen und dem fünften Nullenpaar) stimmt mit dem regulären Ausdrucksmuster jedoch überein.

Dim pattern As String = "(00\s){2,4}"
Dim input As String = "0x00 FF 00 00 18 17 FF 00 00 00 21 00 00 00 00 00"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       '00 00 ' found at position 8.
'       '00 00 00 ' found at position 23.
'       '00 00 00 00 ' found at position 35.

string pattern = @"(00\s){2,4}";
string input = "0x00 FF 00 00 18 17 FF 00 00 00 21 00 00 00 00 00";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        '00 00 ' found at position 8.
//        '00 00 00 ' found at position 23.
//        '00 00 00 00 ' found at position 35.

Entspricht dem Zeichen nullmal oder mehrere Male (träge Übereinstimmung): *?

Der *?-Quantifizierer sucht für das vorangehende Element keine oder mehrere Übereinstimmungen, jedoch so wenige wie möglich. Es handelt sich um das träge Gegenstück des gierigen Quantifizierers *.

Im folgenden Beispiel entspricht der reguläre Ausdruck \b\w*?oo\w*?\b allen Wörtern, die die Zeichenfolge oo enthalten.

 Dim pattern As String = "\b\w*?oo\w*?\b"
 Dim input As String = "woof root root rob oof woo woe"
 For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
 Next 
 ' The example displays the following output:
'       'woof' found at position 0.
'       'root' found at position 5.
'       'root' found at position 10.
'       'oof' found at position 19.
'       'woo' found at position 23.

 string pattern = @"\b\w*?oo\w*?\b";
 string input = "woof root root rob oof woo woe";
 foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
    Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

 //  The example displays the following output:
//        'woof' found at position 0.
//        'root' found at position 5.
//        'root' found at position 10.
//        'oof' found at position 19.
//        'woo' found at position 23.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

\w*?

Entspricht null oder mehreren Wortzeichen, aber so wenigen Zeichen wie möglich.

oo

Entspricht der Zeichenfolge "oo".

\w*?

Entspricht null oder mehreren Wortzeichen, aber so wenigen Zeichen wie möglich.

\b

An einer Wortgrenze beenden.

Mindestens einmalige Entsprechung (träge Übereinstimmung): +?

Der +?-Quantifizierer sucht für das vorangehende Element eine oder mehrere Übereinstimmungen, jedoch so wenige wie möglich. Es handelt sich um das träge Gegenstück des gierigen Quantifizierers +.

Der reguläre Ausdruck \b\w+?\b sucht beispielsweise ein oder mehrere durch Wortgrenzen getrennte Zeichen. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht.

 Dim pattern As String = "\b\w+?\b"
 Dim input As String = "Aa Bb Cc Dd Ee Ff"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       'Aa' found at position 0.
'       'Bb' found at position 3.
'       'Cc' found at position 6.
'       'Dd' found at position 9.
'       'Ee' found at position 12.
'       'Ff' found at position 15.

string pattern = @"\b\w+?\b";
string input = "Aa Bb Cc Dd Ee Ff";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'Aa' found at position 0.
//        'Bb' found at position 3.
//        'Cc' found at position 6.
//        'Dd' found at position 9.
//        'Ee' found at position 12.
//        'Ff' found at position 15.

Entspricht dem Zeichen null- oder einmal (träge Übereinstimmung): ??

Der ??-Quantifizierer sucht für das vorangehende Element keine oder eine Übereinstimmungen, jedoch so wenige wie möglich. Es handelt sich um das träge Gegenstück des gierigen Quantifizierers ?.

Zum Beispiel versucht der reguläre Ausdruck ^\s*(System.)??Console.Write(Line)??\(??, die Zeichenfolgen "Console.Write" oder "Console.WriteLine" zuzuordnen. Die Zeichenfolge kann auch "System." vor "Console" enthalten und vor einer öffnenden Klammer stehen. Die Zeichenfolge muss am Anfang einer Zeile stehen, ihr kann jedoch ein Leerzeichen vorangehen. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht.

Dim pattern As String = "^\s*(System.)??Console.Write(Line)??\(??"
Dim input As String = "System.Console.WriteLine(""Hello!"")" + vbCrLf + _
                      "Console.Write(""Hello!"")" + vbCrLf + _
                      "Console.WriteLine(""Hello!"")" + vbCrLf + _
                      "Console.ReadLine()" + vbCrLf + _
                      "   Console.WriteLine"
For Each match As Match In Regex.Matches(input, pattern, _
                                         RegexOptions.IgnorePatternWhitespace Or RegexOptions.IgnoreCase Or RegexOptions.MultiLine)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       'System.Console.Write' found at position 0.
'       'Console.Write' found at position 36.
'       'Console.Write' found at position 61.
'       '   Console.Write' found at position 110.

string pattern = @"^\s*(System.)??Console.Write(Line)??\(??";
string input = "System.Console.WriteLine(\"Hello!\")\n" + 
                      "Console.Write(\"Hello!\")\n" + 
                      "Console.WriteLine(\"Hello!\")\n" + 
                      "Console.ReadLine()\n" + 
                      "   Console.WriteLine";
foreach (Match match in Regex.Matches(input, pattern, 
                                      RegexOptions.IgnorePatternWhitespace | 
                                      RegexOptions.IgnoreCase | 
                                      RegexOptions.Multiline))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'System.Console.Write' found at position 0.
//        'Console.Write' found at position 36.
//        'Console.Write' found at position 61.
//        '   Console.Write' found at position 110.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

^

Entspricht dem Anfang des Eingabestreams.

\s*

Sucht nach 0 (null) oder mehr Leerzeichen.

(System.)??

Entspricht null oder einem Vorkommen der Zeichenfolge "System.".

Console.Write

Übereinstimmung mit der Zeichenfolge "Console.Write".

(Line)??

Übereinstimmung mit 0 (null) oder einem Vorkommen der Zeichenfolge "Line".

\(??

Entspricht null oder einem Vorkommen der öffnenden Klammer.

Entspricht genau n-mal dem Zeichen (träge Übereinstimmung): {n}?

Der {n}?-Quantifizierer entspricht dem vorangehenden Element genau n-mal, wobei n eine beliebige ganze Zahl ist. Es handelt sich um das träge Gegenstück des gierigen Quantifizierers {n}+.

Im folgenden Beispiel wird der reguläre Ausdruck \b(\w{3,}?\.){2}?\w{3,}?\b verwendet, um eine Website-Adresse zu identifizieren. Es entspricht "www.microsoft.com" und "msdn.microsoft.com", jedoch nicht "mywebsite" oder "mycompany.com".

 Dim pattern As String = "\b(\w{3,}?\.){2}?\w{3,}?\b"
 Dim input As String = "www.microsoft.com msdn.microsoft.com mywebsite mycompany.com"
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next     
' The example displays the following output:
'       'www.microsoft.com' found at position 0.
'       'msdn.microsoft.com' found at position 18.

string pattern = @"\b(\w{3,}?\.){2}?\w{3,}?\b";
string input = "www.microsoft.com msdn.microsoft.com mywebsite mycompany.com";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'www.microsoft.com' found at position 0.
//        'msdn.microsoft.com' found at position 18.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

(\w{3,}? \.)

Entspricht mindestens drei Wortzeichen, doch möglichst wenigen Zeichen, gefolgt von einem Punktzeichen. Dies ist die erste Erfassungsgruppe.

(\w{3,}? \.){2}?

Entspricht dem Muster in der ersten zweimal, doch so wenige Male wie möglich.

\b

Beendet den Vergleich an einer Wortgrenze.

Entspricht mindestens n-mal dem Zeichen (träge Übereinstimmung): {n,}?

Der {n,}?-Quantifizierer entspricht dem vorangehenden Element mindestens n-mal (wobei n eine beliebige ganze Zahl ist), aber so wenige Male wie möglich. Es handelt sich um das träge Gegenstück des gierigen Quantifizierers {n,}.

Eine Darstellung finden Sie im Beispiel für den {n}?-Quantifizierer im vorherigen Abschnitt. Der reguläre Ausdruck in diesem Beispiel verwendet den {n,}-Quantifizierer, um nach einer Zeichenfolge zu suchen, die mindestens drei Zeichen enthält, auf die ein Punkt folgt.

Entspricht dem Zeichen zwischen n- und m-mal (träge Übereinstimmung): {n,m}?

Der {n,m}?-Quantifizierer entspricht dem vorangehenden Element zwischen n- und m-mal (wobei n und m ganze Zahlen sind), jedoch so wenige Male wie möglich. Es handelt sich um das träge Gegenstück des gierigen Quantifizierers {n,m}.

Im folgenden Beispiel führt der reguläre Ausdruck \b[A-Z](\w*\s+){1,10}?[.!?] zu Übereinstimmungen mit Sätzen, die zwischen einem und zehn Wörtern enthalten. Er liefert alle Sätze der Eingabezeichenfolge als Ergebnis mit Ausnahme eines Satzes, der 18 Wörter enthält.

Dim pattern As String = "\b[A-Z](\w*\s?){1,10}?[.!?]"
Dim input As String = "Hi. I am writing a short note. Its purpose is " + _
                      "to test a regular expression that attempts to find " + _
                      "sentences with ten or fewer words. Most sentences " + _
                      "in this note are short."
For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
Next 
' The example displays the following output:
'       'Hi.' found at position 0.
'       'I am writing a short note.' found at position 4.
'       'Most sentences in this note are short.' found at position 132.

string pattern = @"\b[A-Z](\w*?\s*?){1,10}[.!?]";
string input = "Hi. I am writing a short note. Its purpose is " + 
                      "to test a regular expression that attempts to find " + 
                      "sentences with ten or fewer words. Most sentences " + 
                      "in this note are short.";
foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);

//  The example displays the following output:
//        'Hi.' found at position 0.
//        'I am writing a short note.' found at position 4.
//        'Most sentences in this note are short.' found at position 132.

Das Muster für reguläre Ausdrücke ist wie in der folgenden Tabelle gezeigt definiert.

Muster

Beschreibungen

\b

An einer Wortgrenze beginnen.

[A-Z]

Entspricht einem Großbuchstaben von A bis Z.

(\w*\s+)

Entspricht null oder mehreren Wortzeichen gefolgt von mindestens einem Leerzeichen. Dies ist die erste Erfassungsgruppe.

{1,10}?

Entspricht dem vorangehenden Muster zwischen ein- und zehnmal, jedoch so wenige Male wie möglich.

[.!?]

Entspricht einem der Interpunktionszeichen ".","! " oder"?".

Gierige und träge Quantifizierer

Einige Quantifizierer kommen in zwei Versionen vor:

  • Eine gierige Version.

    Ein gieriger Quantifizierer sucht nach so vielen Übereinstimmungen mit dem Element wie möglich.

  • Eine nicht gierige bzw. träge Version.

    Ein nicht gieriger Quantifizierer sucht nach so wenigen Übereinstimmungen mit dem Element wie möglich. Sie können einen gierigen Quantifizierer in einen faulen Quantifizierer umwandeln, indem Sie ? hinzufügen.

Betrachten Sie z. B. einen sehr einfachen regulären Ausdruck, der die letzten vier Ziffern einer Zahlenfolge, wie z. B. einer Kreditkartennummer, extrahieren soll. Die Version des regulären Ausdrucks, der den gierigen Quantifizierer * verwendet, lautet \b.*([0-9]{4})\b. Wenn eine Zeichenfolge jedoch zwei Zahlen enthält, entspricht der reguläre Ausdruck nur den letzten vier Ziffern der zweiten Zahl (siehe folgendes Beispiel).

Dim greedyPattern As String = "\b.*([0-9]{4})\b"
Dim input1 As String = "1112223333 3992991999"
For Each match As Match In Regex.Matches(input1, greedypattern)
   Console.WriteLine("Account ending in ******{0}.", match.Groups(1).Value)
Next
' The example displays the following output:
'       Account ending in ******1999.

string greedyPattern = @"\b.*([0-9]{4})\b";
string input1 = "1112223333 3992991999";
foreach (Match match in Regex.Matches(input1, greedyPattern))
   Console.WriteLine("Account ending in ******{0}.", match.Groups[1].Value);

// The example displays the following output:
//       Account ending in ******1999.

Der reguläre Ausdruck liefert kein Ergebnis für die erste Zahl, da der *-Quantifizierer in der gesamten Zeichenfolge nach so vielen Überereinstimmungen des vorangehenden Elements wie möglich sucht, und daher eine Entsprechung am Ende der Zeichenfolge feststellt.

Dies ist nicht das gewünschte Verhalten. Stattdessen können Sie mit dem trägen Quantifizierer *? Ziffern aus beiden Zahlen extrahieren (siehe folgendes Beispiel).

Dim lazyPattern As String = "\b.*?([0-9]{4})\b"
Dim input2 As String = "1112223333 3992991999"
For Each match As Match In Regex.Matches(input2, lazypattern)
   Console.WriteLine("Account ending in ******{0}.", match.Groups(1).Value)
Next     
' The example displays the following output:
'       Account ending in ******3333.
'       Account ending in ******1999.

string lazyPattern = @"\b.*?([0-9]{4})\b";
string input2 = "1112223333 3992991999";
foreach (Match match in Regex.Matches(input2, lazyPattern))
   Console.WriteLine("Account ending in ******{0}.", match.Groups[1].Value);

// The example displays the following output:
//       Account ending in ******3333.
//       Account ending in ******1999.

In den meisten Fällen geben reguläre Ausdrücke mit gierigen und trägen Quantifizierern die gleichen Übereinstimmungen zurück. Normalerweise geben sie unterschiedliche Ergebnisse zurück, wenn sie mit dem Platzhaltermetazeichen (.) verwendet werden, das einem beliebigen Zeichen entspricht.

Quantifizierer und leere Übereinstimmungen

Die Quantifizierer *, + und {n,m} und ihre trägen Gegenstücke werden nie nach einer leeren Übereinstimmung wiederholt, wenn die Mindestanzahl der Erfassungen gefunden wurde. Diese Regel verhindert, dass Quantifizierer in Endlosschleifen für leere Übereinstimmungen mit Teilausdrücken eintreten, wenn die maximale Anzahl möglicher Gruppenaufzeichnungen unbegrenzt oder beinahe unbegrenzt ist.

Beispielsweise zeigt der folgende Code das Ergebnis eines Aufrufs der Regex.Match-Methode mit dem Muster eines regulären Ausdrucks (a?)* an, das mit keinem oder einem Zeichen "a" keinmal oder mehrmals übereinstimmt. Beachten Sie, dass die einzelne Erfassungsgruppe jedes "a" sowie String.Empty erfasst, aber keine zweite leere Übereinstimmung vorhanden ist, da der Quantifizierer nach der ersten leeren Übereinstimmung die Wiederholung beendet.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(a?)*"
      Dim input As String = "aaabbb"
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: '{0}' at index {1}", 
                        match.Value, match.Index)
      If match.Groups.Count > 1 Then
         Dim groups As GroupCollection = match.Groups
         For grpCtr As Integer = 1 To groups.Count - 1
            Console.WriteLine("   Group {0}: '{1}' at index {2}", 
                              grpCtr, 
                              groups(grpCtr).Value,
                              groups(grpCtr).Index)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In groups(grpCtr).Captures
               captureCtr += 1
               Console.WriteLine("      Capture {0}: '{1}' at index {2}", 
                                 captureCtr, capture.Value, capture.Index)
            Next
         Next 
      End If   
   End Sub
End Module
' The example displays the following output:
'       Match: 'aaa' at index 0
'          Group 1: '' at index 3
'             Capture 1: 'a' at index 0
'             Capture 2: 'a' at index 1
'             Capture 3: 'a' at index 2
'             Capture 4: '' at index 3

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(a?)*";
      string input = "aaabbb";
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}' at index {1}", 
                        match.Value, match.Index);
      if (match.Groups.Count > 1) {
         GroupCollection groups = match.Groups;
         for (int grpCtr = 1; grpCtr <= groups.Count - 1; grpCtr++) {
            Console.WriteLine("   Group {0}: '{1}' at index {2}", 
                              grpCtr, 
                              groups[grpCtr].Value,
                              groups[grpCtr].Index);
            int captureCtr = 0;
            foreach (Capture capture in groups[grpCtr].Captures) {
               captureCtr++;
               Console.WriteLine("      Capture {0}: '{1}' at index {2}", 
                                 captureCtr, capture.Value, capture.Index);
            }
         } 
      }   
   }
}
// The example displays the following output:
//       Match: 'aaa' at index 0
//          Group 1: '' at index 3
//             Capture 1: 'a' at index 0
//             Capture 2: 'a' at index 1
//             Capture 3: 'a' at index 2
//             Capture 4: '' at index 3

Um den praktischen Unterschied zwischen einer Erfassungsgruppe, die eine minimale und maximale Anzahl von Erfassungen definiert, und einer Erfassungsgruppe anzuzeigen, die eine feste Anzahl von Erfassungen definiert, sollten Sie die Muster eines regulären Ausdrucks (a\1|(?(1)\1)){0,2} und (a\1|(?(1)\1)){2} berücksichtigen. Beide reguläre Ausdrücke bestehen aus einer einzelnen Erfassungsgruppe, die entsprechend der folgenden Tabelle definiert ist.

Muster

Beschreibungen

(a\1

Entweder Übereinstimmung mit "a" zusammen mit dem Wert der ersten Erfassungsgruppe…

|(?(1)

… oder Test, ob die erste Erfassungsgruppe definiert wurde. (Beachten Sie, dass das (?(1)-Konstrukt keine Erfassungsgruppe definiert.)

\1))

Wenn die erste Erfassungsgruppe vorhanden ist, entspricht sie dem Wert. Falls die Gruppe nicht vorhanden ist, entspricht die Gruppe String.Empty.

Der erste reguläre Ausdruck versucht, dieses Muster zwischen null und zweimal abzugleichen, der zweite genau zwei Mal. Da das erste Muster die Mindestanzahl von Erfassungen mit der ersten Erfassung von String.Empty erreicht, wiederholt es keine Versuche, a\1 zu entsprechen. Der {0,2}-Quantifizierer gestattet nur leere Übereinstimmungen in der letzten Iteration. Im Gegensatz dazu entspricht der zweite reguläre Ausdruck "a", da er a\1 ein zweites Mal auswertet. Die minimale Anzahl von Iterationen (2) erzwingt eine Wiederholung des Moduls nach einer leeren Übereinstimmung.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern, input As String

      pattern = "(a\1|(?(1)\1)){0,2}"
      input = "aaabbb" 

      Console.WriteLine("Regex pattern: {0}", pattern)
      Dim match As Match = Regex.Match(input, pattern)
      Console.WriteLine("Match: '{0}' at position {1}.", 
                        match.Value, match.Index)
      If match.Groups.Count > 1 Then
         For groupCtr As Integer = 1 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               captureCtr += 1
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index)
            Next   
         Next
      End If
      Console.WriteLine()

      pattern = "(a\1|(?(1)\1)){2}"
      Console.WriteLine("Regex pattern: {0}", pattern)
      match = Regex.Match(input, pattern)
         Console.WriteLine("Matched '{0}' at position {1}.", 
                           match.Value, match.Index)
      If match.Groups.Count > 1 Then
         For groupCtr As Integer = 1 To match.Groups.Count - 1
            Dim group As Group = match.Groups(groupCtr)         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index)
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               captureCtr += 1
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index)
            Next   
         Next
      End If
   End Sub
End Module
' The example displays the following output:
'       Regex pattern: (a\1|(?(1)\1)){0,2}
'       Match: '' at position 0.
'          Group: 1: '' at position 0.
'             Capture: 1: '' at position 0.
'       
'       Regex pattern: (a\1|(?(1)\1)){2}
'       Matched 'a' at position 0.
'          Group: 1: 'a' at position 0.
'             Capture: 1: '' at position 0.
'             Capture: 2: 'a' at position 0.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern, input;

      pattern = @"(a\1|(?(1)\1)){0,2}";
      input = "aaabbb"; 

      Console.WriteLine("Regex pattern: {0}", pattern);
      Match match = Regex.Match(input, pattern);
      Console.WriteLine("Match: '{0}' at position {1}.", 
                        match.Value, match.Index);
      if (match.Groups.Count > 1) {
         for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
         {
            Group group = match.Groups[groupCtr];         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index);
            int captureCtr = 0;
            foreach (Capture capture in group.Captures) {
               captureCtr++;
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index);
            }   
         }
      }
      Console.WriteLine();

      pattern = @"(a\1|(?(1)\1)){2}";
      Console.WriteLine("Regex pattern: {0}", pattern);
      match = Regex.Match(input, pattern);
         Console.WriteLine("Matched '{0}' at position {1}.", 
                           match.Value, match.Index);
      if (match.Groups.Count > 1) {
         for (int groupCtr = 1; groupCtr <= match.Groups.Count - 1; groupCtr++)
         {
            Group group = match.Groups[groupCtr];         
            Console.WriteLine("   Group: {0}: '{1}' at position {2}.", 
                              groupCtr, group.Value, group.Index);
            int captureCtr = 0;
            foreach (Capture capture in group.Captures) {
               captureCtr++;
               Console.WriteLine("      Capture: {0}: '{1}' at position {2}.", 
                                 captureCtr, capture.Value, capture.Index);
            }   
         }
      }
   }
}
// The example displays the following output:
//       Regex pattern: (a\1|(?(1)\1)){0,2}
//       Match: '' at position 0.
//          Group: 1: '' at position 0.
//             Capture: 1: '' at position 0.
//       
//       Regex pattern: (a\1|(?(1)\1)){2}
//       Matched 'a' at position 0.
//          Group: 1: 'a' at position 0.
//             Capture: 1: '' at position 0.
//             Capture: 2: 'a' at position 0.

Siehe auch

Konzepte

Sprachelemente für reguläre Ausdrücke

Backtracking

Änderungsprotokoll

Datum

Versionsgeschichte

Grund

Oktober 2010

Der Abschnitt "Quantifizierer und leere Übereinstimmungen" wurde hinzugefügt.

Informationsergänzung.