Quantifizierer

  • Artikel

Aktualisiert: Juli 2008

Quantifizierer geben an, wie viele Instanzen des vorherigen Elements (bei dem es sich um ein Zeichen, eine Gruppe oder eine Zeichenklasse handeln kann) in der Eingabe vorhanden sein müssen, damit eine Übereinstimmung festgestellt wird.

Quantifizierer in regulären .NET Framework-Ausdrücken

In der folgenden Tabelle sind die Quantifizierer aufgeführt, die von regulären .NET Framework-Ausdrücken unterstützt werden. Der Mengen n und m sind ganzzahlige Konstanten. Eine Beschreibung des Unterschieds zwischen "gierigen" und "trägen" Quantifizierern finden Sie im Abschnitt "Gierige und träge Quantifizierer" im Anschluss an diese Tabelle.

Quantifizierer

Beschreibung

*

Stimmt mit dem vorangehenden Element nicht oder mehrmals überein. Ist äquivalent zu {0,}. * ist ein gieriger Quantifizierer, dessen nicht gieriges Äquivalent *? ist.

Der reguläre Ausdruck \b91*9*\b sucht beispielsweise nach Entsprechungen der Ziffer 9, die auf eine Wortgrenze folgen. Auf die 9 können keine oder mehrere Instanzen der Ziffer 1 folgen, auf die ihrerseits keine oder mehrere Instanzen der Ziffer 9 folgen können. 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.

+

Stimmt mit dem vorangehenden Element mindestens einmal überein. Ist äquivalent zu {1,}. + ist ein gieriger Quantifizierer, dessen nicht gieriges Äquivalent +? ist.

Der reguläre Ausdruck \ba(n)+\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 = "\ba(n)+\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 = @"\ba(n)+\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.

?

Stimmt mit dem vorangehenden Element nicht oder einmal überein. Ist äquivalent zu {0,1}. ? ist ein gieriger Quantifizierer, dessen nicht gieriges Äquivalent ?? 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.

{n}

Stimmt mit dem vorangehenden Element genau n-mal überein. {n} ist ein gieriger Quantifizierer, dessen nicht gieriges Äquivalent {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.

{n,}

Stimmt mit dem vorangehenden Element mindestens n-mal überein. {n,} ist ein gieriger Quantifizierer, dessen nicht gieriges Äquivalent {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 und 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.

{n,m}

Stimmt mit dem vorangehenden Element mindestens n-mal, jedoch nicht mehr als m-mal überein. {n,m} ist ein gieriger Quantifizierer, dessen nicht gieriges Äquivalent {n,m}? ist.

Der reguläre Ausdruck (00\s){2,4} sucht beispielsweise nach zwei bis vier Vorkommen zweier 0-Ziffern, auf die ein Leerzeichen folgt. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht. Beachten Sie, dass der letzte Abschnitt der Eingabezeichenfolge dieses Muster fünf Mal und nicht maximal vier Mal enthält. 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.

*?

Stimmt mit dem vorangehenden Element nicht oder mehrmals, jedoch so wenige Male wie möglich überein. Dies ist ein träger Quantifizierer, der das Gegenstück zum gierigen Quantifizierer * darstellt.

Der reguläre Ausdruck \b\w*?oo\w*?\b sucht beispielsweise alle Wörter, die die Zeichenfolge oo enthalten. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht.

 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.

+?

Stimmt mit dem vorangehenden Element einmal oder mehrmals, jedoch so wenige Male wie möglich überein. Dies ist ein träger Quantifizierer, der das Gegenstück zum gierigen Quantifizierer + darstellt.

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.

??

Stimmt mit dem vorangehenden Element nicht oder mehrmals, jedoch so wenige Male wie möglich überein. Dies ist ein träger Quantifizierer, der das Gegenstück zum gierigen Quantifizierer ? darstellt.

Beispielsweise sucht der reguläre Ausdruck ^(\s)*(System.)??Console.Write(Line)??\(?? nach Übereinstimmungen mit den Zeichenfolgen Console.Write oder Console.WriteLine. Die Zeichenfolge kann auch System. vor Console enthalten, und eine öffnende Klammer kann auf sie folgen. 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.

{n}?

Stimmt genau n-mal mit dem vorangehenden Element überein. Dies ist ein träger Quantifizierer, der das Gegenstück zum gierigen Quantifizierer {n}+ darstellt.

Der reguläre Ausdruck \b(\w{3,}?\.){2}?\w{3,}?\b sucht beispielsweise nach genau zwei Sätzen von Zeichen, auf die ein Punkt an einer Wortgrenze folgt. Auf diesen folgt dann ein weiterer Satz von Zeichen und eine Wortgrenze. Dieser reguläre Ausdruck soll eine Websiteadresse identifizieren. Im folgenden Beispiel wird der reguläre Ausdruck veranschaulicht. Beachten Sie, dass Übereinstimmungen mit www.microsoft.com und mdsn.microsoft.com erkannt werden, jedoch nicht mit 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.

{n,}?

Stimmt mit dem vorangehenden Element mindestens n-mal, jedoch so wenige Male wie möglich überein. Dies ist ein träger Quantifizierer, der das Gegenstück zum gierigen Quantifizierer {n,} darstellt.

Beachten Sie zur Veranschaulichung das Beispiel für den {n}?-Quantifizierer. 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.

{n,m}?

Stimmt mit dem vorangehenden Element n-mal bis m-mal, jedoch so wenige Male wie möglich, überein. Dies ist ein träger Quantifizierer, der das Gegenstück zum gierigen Quantifizierer {n,m} darstellt.

Der reguläre Ausdruck \b[A-Z](\w*?\s*?){1,10}[.!?] sucht beispielsweise nach Sätzen, die zwischen einem und zehn Wörtern enthalten. Er sucht nach einer Wortgrenze gefolgt von einem Großbuchstaben, auf den ein bis zehn Wiederholungen von keinen oder mehreren Wortzeichen und optional ein Leerzeichen folgen. Die Übereinstimmung wird dann von einem Punkt, einem Ausrufezeichen oder einem Fragezeichen beendet. Im folgenden Beispiel wird dieser reguläre Ausdruck veranschaulicht. Er liefert alle Sätze der Eingabezeichenfolge als Ergebnis mit Ausnahme eines einzigen 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.

Gierige und träge Quantifizierer

Einige Quantifizierer kommen in zwei Versionen vor:

  • Eine gierige Version.

    Ein gieriger Quantifizierer sucht nach Übereinstimmungen mit dem Element, für das er so oft wie möglich gilt.

  • Eine nicht gierige bzw. träge Version.

    Ein nicht gieriger Quantifizierer sucht nach Übereinstimmungen mit dem Element, für das er so wenige Male wie möglich gilt.

Um den Unterschied zu veranschaulichen, 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. Bei einer gegebenen Zeichenfolge, die zwei Zahlen enthält, werden von ihm jedoch nur die letzten vier Ziffern der zweiten Zahl angezeigt, wie im folgenden Beispiel veranschaulicht.

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.

Dies ist nicht das gewünschte Verhalten. 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.

Der entsprechende reguläre Ausdruck, der den trägen Quantifizierer *? verwendet, liefert das erwartete Verhalten, wie im folgenden Beispiel veranschaulicht.

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 Punktmetazeichen (.) verwendet werden, das einem beliebigen Zeichen entspricht.

Siehe auch

Weitere Ressourcen

Sprachelemente für reguläre Ausdrücke

Änderungsprotokoll

Date

Versionsgeschichte

Grund

Juli 2008

Gründlich überarbeitet.

Korrektur inhaltlicher Fehler.