Condividi tramite

Quantificatori

  • Articolo

Aggiornamento: Luglio 2008

I quantificatori specificano il numero di istanze dell'elemento precedente, che può essere un carattere, un gruppo o una classe di caratteri, che devono essere presenti nell'input affinché venga trovata una corrispondenza.

Quantificatori nelle espressioni regolari di .NET Framework

Nella tabella seguente vengono elencati i quantificatore supportati dalle espressioni regolari di .NET Framework. Le quantità n e m sono costanti integer. Per una descrizione della differenza tra quantificatore greedy e lazy, vedere la sezione corrispondente dopo la tabella.

Quantificatore

Descrizione

*

Corrisponde all'elemento precedente zero o più volte. È equivalente a \{0,}. * è un quantificatore greedy il cui equivalente non-greedy è *?.

Ad esempio, l'espressione regolare \b91*9*\b tenta di trovare una corrispondenza con la cifra 9 che segue un limite di parole. 9 può essere seguita da zero o più istanze della cifra 1, che a sua volta può essere seguita da zero o più istanze della cifra 9. Questa espressione regolare viene illustrata nell'esempio seguente. Delle nove cifre della stringa di input, cinque corrispondono al modello e quattro (95, 929, 9129 e 9919) no.

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.

+

Corrisponde all'elemento precedente una o più volte. È equivalente a {1,}. + è un quantificatore greedy il cui equivalente non-greedy è +?.

Ad esempio, l'espressione regolare \ba(n)+\w*?\b tenta di trovare una corrispondenza con intere parole che iniziano con la lettera a seguita da una o più istanze della lettera n. Questa espressione regolare viene illustrata nell'esempio seguente. L'espressione regolare trova una corrispondenza con le parole an, annual, announcement e antique, mentre correttamente non la trova con autumn e 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.

?

Corrisponde all'elemento precedente zero o una volta. È equivalente a {0,1}. ? è un quantificatore greedy il cui equivalente non-greedy è ??.

Ad esempio, l'espressione regolare \ban?\b tenta di trovare una corrispondenza con intere parole che iniziano con la lettera a seguita da zero o più istanze della lettera n. In altri termini, tenta di trovare una corrispondenza con le parole a e an. Questa espressione regolare viene illustrata nell'esempio seguente.

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}

Corrisponde all'elemento precedente esattamente n volte. {n} è un quantificatore greedy il cui equivalente non-greedy è {n}?.

Ad esempio, l'espressione regolare \b\d+\,\d{3}\b tenta di trovare una corrispondenza con un limite di parola seguito da una o più cifre decimali seguite da tre cifre decimali seguite da un limite di parola. Questa espressione regolare viene illustrata nell'esempio seguente.

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

Corrisponde all'elemento precedente almeno n volte. {n,} è un quantificatore greedy il cui equivalente non-greedy è {n}?.

Ad esempio, l'espressione regolare \b\d{2,}\b\D+ tenta di trovare una corrispondenza con un limite di parola seguito da almeno due cifre seguite da un limite di parola e da un carattere non numerico. Questa espressione regolare viene illustrata nell'esempio seguente. L'espressione regolare non trova una corrispondenza con la frase 7 days perché contiene solo uno cifra decimale, ma trova una corrispondenza con le frasi 10 weeks e 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}

Corrisponde all'elemento precedente almeno n volte, ma non più di m volte. {n,m} è un quantificatore greedy il cui equivalente non-greedy è {n,m}?.

Ad esempio, l'espressione regolare (00\s){2,4} tenta di trovare una corrispondenza tra due e quattro occorrenze di cifre zero seguite da uno spazio. Questa espressione regolare viene illustrata nell'esempio seguente. Si noti che la parte finale della stringa di input include il modello cinque volte anziché il massimo di quattro. Tuttavia, la parte iniziale della sottostringa (fino allo spazio e alla quinta coppia di zero) corrisponde al modello dell'espressione regolare.

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.

*?

Corrisponde all'elemento precedente zero o più volte, ma il numero minimo di volte possibile. Si tratta di un quantificatore lazy omologo del quantificatore greedy *.

Ad esempio, l'espressione regolare \b\w*?oo\w*?\b corrisponde a tutte le parole che contengono la stringa oo. Questa espressione regolare viene illustrata nell'esempio seguente.

 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.

+?

Corrisponde all'elemento precedente una o più volte, ma il numero minimo di volte possibile. Si tratta di un quantificatore lazy omologo del quantificatore greedy +.

Ad esempio, l'espressione regolare \b\w+?\b corrisponde a uno o più caratteri separati da limiti di parola. Questa espressione regolare viene illustrata nell'esempio seguente.

 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.

??

Corrisponde all'elemento precedente zero o una volta, ma il numero minimo di volte possibile. Si tratta di un quantificatore lazy omologo del quantificatore greedy ?.

Ad esempio, l'espressione regolare ^(\s)*(System.)??Console.Write(Line)??\(?? tenta di trovare una corrispondenza con le stringhe Console.Write o Console.WriteLine. La stringa può includere anche System. prima di Console e può essere seguita da una parentesi aperta. La stringa deve trovarsi all'inizio di una riga, anche se può essere preceduta da uno spazio vuoto. Questa espressione regolare viene illustrata nell'esempio seguente.

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

Corrisponde all'elemento precedente esattamente n volte. Si tratta di un quantificatore lazy omologo del quantificatore greedy {n}+.

Ad esempio, l'espressione regolare \b(\w{3,}?\.){2}?\w{3,}?\b corrisponde esattamente a due insiemi di caratteri seguiti da un punto in un limite di parola. Quest'ultimo è seguito da un altro insieme di caratteri e da un limte di parola. Questa espressione regolare dovrebbe identificare un indirizzo di sito Web. Questa espressione regolare viene illustrata nell'esempio seguente. Si noti che corrisponde a www.microsoft.com e mdsn.microsoft.com, ma non corrisponde a mywebsite o 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,}?

Corrisponde all'elemento precedente almeno n volte, ma il numero minimo di volte possibile. Si tratta di un quantificatore lazy omologo del quantificatore greedy {n,}.

Per un'illustrazione, vedere l'esempio relativo al quantificatore {n}?. L'espressione regolare in tale esempio utilizza il quantificatore {n,} per trovare una corrispondenza con una stringa che contiene almeno tre caratteri seguiti da un punto.

{n,m}?

Corrisponde all'elemento precedente tra n e m volte, ma il numero minimo di volte possibile. Si tratta di un quantificatore lazy omologo del quantificatore greedy {n,m}.

Ad esempio, l'espressione regolare \b[A-Z](\w*?\s*?){1,10}[.!?] corrisponde alle frasci che contengono da una a dieci parole. Corrisponde a un limite di parola seguito da una lettera maiuscola seguita da un numero compreso tra uno e dieci di ripetizioni di zero o più lettere e facoltativamente uno spazio. La corrispondenza termina quindi con un punto, un punto esclamativo o un punto interrogativo. Questa espressione regolare viene illustrata nell'esempio seguente. Corrisponde a tutte le frasi nella stringa di input ad eccezione della singola frase che contiene 18 parole.

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.

Quantificatore greedy e lazy

Diversi quantificatori sono disponibili in due versioni:

  • Una versione greedy.

    Un quantificatore greedy tenta di trovare una corrispondenza con l'elemento cui si applica il numero massimo di volte possibile.

  • Una versione non-greedy (o lazy).

    Un quantificatore non-greedy tenta di trovare una corrispondenza con l'elemento cui si applica il numero minimo di volte possibile.

Per illustrare la differenza, considerare un'espressione regolare semplice progettata per estrarre le ultime quattro cifre da una stringa di numeri, ad esempio il numero di una carta di credito. La versione dell'espressione regolare che utilizza il quantificatore greedy * è \b.*([0-9]{4})\b. Tuttavia, data una stringa che contiene due numeri, riesce a visualizzare solo le ultime quattro cifre del secondo numero, come illustrato nell'esempio seguente.

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.

Non si tratta del comportamento previsto. L'espressione regolare non riesce a trovare una corrispondenza con il primo numero perché il quantificatore * tenta di trovare una corrispondenza con l'elemento precedente il numero massimo di volte possibile nell'intera stringa, quindi trova la corrispondenza alla fine della stringa.

Un'espressione regolare equivalente che utilizza il quantificatore lazy *? produce invece il comportamento previsto, come illustrato nell'esempio seguente.

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.

Nella maggior parte dei casi, le espressioni regolari con quantificatori greedy e lazy restituiscono le stesse corrispondenze. In genere restituiscono risultati diversi se utilizzate con il punto (metacarattere . )), che corrisponde a qualsiasi carattere.

Vedere anche

Altre risorse

Elementi del linguaggio di espressioni regolari

Cronologia delle modifiche

Data

Cronologia

Motivo

Luglio 2008

Rivisto in modo esteso.

Correzione di errori nel contenuto.