quantificatori in espressioni regolariQuantifiers in Regular Expressions

I quantificatori specificano il numero di istanze di un carattere, un gruppo o una classe di caratteri che deve essere presente nell'input affinché venga trovata una corrispondenza.Quantifiers specify how many instances of a character, group, or character class must be present in the input for a match to be found. Nella tabella seguente vengono elencati i quantificatori supportati da .NET.The following table lists the quantifiers supported by .NET.

Quantificatore greedyGreedy quantifier Quantificatore lazyLazy quantifier DescrizioneDescription
* *? Trova la corrispondenza zero o più volte.Match zero or more times.
+ +? Trova la corrispondenza una o più volte.Match one or more times.
? ?? Trova la corrispondenza zero o una volta.Match zero or one time.
{n}{ n } {n}?{ n }? Trova la corrispondenza esatta n volte.Match exactly n times.
{n,}{ n ,} {n,}?{ n ,}? Trova la corrispondenza almeno n volte.Match at least n times.
{n , m}{ n , m } {n , m}?{ n , m }? Trova la corrispondenza da n a m volte.Match from n to m times.

Le quantità n e m sono costanti integer.The quantities n and m are integer constants. In genere, i quantificatori sono greedy: il motore delle espressioni regolari trova la corrispondenza con il maggior numero possibile di determinati criteri.Ordinarily, quantifiers are greedy; they cause the regular expression engine to match as many occurrences of particular patterns as possible. L'aggiunta del carattere ? rende un quantificatore lazy: il motore delle espressioni regolari trova la corrispondenza con il minor numero possibile di occorrenze.Appending the ? character to a quantifier makes it lazy; it causes the regular expression engine to match as few occurrences as possible. Per una descrizione completa della differenza tra quantificatori greedy e lazy, vedere la sezione Quantificatori greedy e lazy più avanti in questo argomento.For a complete description of the difference between greedy and lazy quantifiers, see the section Greedy and Lazy Quantifiers later in this topic.

Importante

Annidare i quantificatori, come nel caso del criterio di espressione regolare (a*)*, può aumentare il numero dei confronti che deve eseguire il motore delle espressioni regolari, come una funzione esponenziale del numero di caratteri nella stringa di input.Nesting quantifiers (for example, as the regular expression pattern (a*)* does) can increase the number of comparisons that the regular expression engine must perform, as an exponential function of the number of characters in the input string. Per altre informazioni su questo comportamento e sulle relative soluzioni alternative, vedere Backtracking.For more information about this behavior and its workarounds, see Backtracking.

Quantificatori delle espressioni regolariRegular Expression Quantifiers

Nelle sezioni seguenti sono riportati i quantificatori supportati dalle espressioni regolari in .NET.The following sections list the quantifiers supported by .NET regular expressions.

Nota

Se vengono rilevati i caratteri *, +,?, { e} in un criterio di espressione regolare, il motore delle espressioni regolari li interpreta come quantificatori o parte di costrutti di quantificatori a meno che non siano inclusi in una classe di caratteri.If the *, +, ?, {, and } characters are encountered in a regular expression pattern, the regular expression engine interprets them as quantifiers or part of quantifier constructs unless they are included in a character class. Per interpretarli come caratteri letterali all'esterno di una classe di caratteri, è necessaria una sequenza di escape con i caratteri preceduti da una barra rovesciata.To interpret these as literal characters outside a character class, you must escape them by preceding them with a backslash. Ad esempio, la stringa \* in un'espressione regolare viene interpretata come carattere letterale asterisco ("*").For example, the string \* in a regular expression pattern is interpreted as a literal asterisk ("*") character.

Trova la corrispondenza zero o più volte: *Match Zero or More Times: *

Il quantificatore * trova la corrispondenza con l'elemento precedente zero o più volte.The * quantifier matches the preceding element zero or more times. È equivalente al quantificatore {0,}.It is equivalent to the {0,} quantifier. * è un quantificatore greedy il cui equivalente lazy è *?.* is a greedy quantifier whose lazy equivalent is *?.

L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression. Dei gruppi di nove cifre nella stringa di input, cinque corrispondono al criterio e quattro ( 95 , 929 , 9219 e 9919 ) non lo sono.Of the nine digit groups in the input string, five match the pattern and four (95, 929, 9219, and 9919) do not.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
91* Trova un "9" seguito da zero o più caratteri "1".Match a "9" followed by zero or more "1" characters.
9* Trova la corrispondenza con zero o più caratteri "9".Match zero or more "9" characters.
\b Terminare al confine di una parola.End at a word boundary.

Trova la corrispondenza una o più volte: +Match One or More Times: +

Il quantificatore + trova la corrispondenza con l'elemento precedente una o più volte.The + quantifier matches the preceding element one or more times. Equivale a {1,}.It is equivalent to {1,}. + è un quantificatore greedy il cui equivalente lazy è +?.+ is a greedy quantifier whose lazy equivalent is +?.

Ad esempio, l'espressione regolare \ban+\w*?\b tenta di trovare la corrispondenza con intere parole che iniziano con la lettera a seguita da una o più istanze della lettera n.For example, the regular expression \ban+\w*?\b tries to match entire words that begin with the letter a followed by one or more instances of the letter n. L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression. L'espressione regolare trova le parole an, annual, announcement, antique e, correttamente, non riesce a trovare autumn e all.The regular expression matches the words an, annual, announcement, and antique, and correctly fails to match autumn and all.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
an+ Trova una "a" seguita da uno o più caratteri "n".Match an "a" followed by one or more "n" characters.
\w*? Trova la corrispondenza con un carattere alfanumerico o più volte, ma il minor numero di volte possibile.Match a word character zero or more times, but as few times as possible.
\b Terminare al confine di una parola.End at a word boundary.

Trova la corrispondenza zero o una volta: ?Match Zero or One Time: ?

? trova la corrispondenza con l'elemento precedente zero o una volta.The ? quantifier matches the preceding element zero or one time. Equivale a {0,1}.It is equivalent to {0,1}. ? è un quantificatore greedy il cui equivalente lazy è ??.? is a greedy quantifier whose lazy equivalent is ??.

Ad esempio, l'espressione regolare \ban?\b tenta di trovare la corrispondenza con intere parole che iniziano con la lettera a seguita da zero o una istanza della lettera n.For example, the regular expression \ban?\b tries to match entire words that begin with the letter a followed by zero or one instances of the letter n. In altre parole, tenta di trovare la corrispondenza con le parole a e an.In other words, it tries to match the words a and an. L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
an? Trova una "a" seguita da zero o un carattere "n".Match an "a" followed by zero or one "n" character.
\b Terminare al confine di una parola.End at a word boundary.

Trova la corrispondenza esatta n volte: {n}Match Exactly n Times: {n}

Il { } quantificatore n trova la corrispondenza con l'elemento precedente esattamente n volte, dove n è qualsiasi numero intero.The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n } è un quantificatore greedy il cui equivalente lazy è { n }? .{n} is a greedy quantifier whose lazy equivalent is {n}?.

Ad esempio, l'espressione regolare \b\d+\,\d{3}\b tenta di trovare la corrispondenza con il confine di una parola seguito da una o più cifre decimali seguite da tre cifre decimali seguite dal confine di una parola.For example, the regular expression \b\d+\,\d{3}\b tries to match a word boundary followed by one or more decimal digits followed by three decimal digits followed by a word boundary. L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
\d+ Trova la corrispondenza con una o più cifre decimali.Match one or more decimal digits.
\, Trova la corrispondenza con un carattere virgola.Match a comma character.
\d{3} Trova la corrispondenza con tre cifre decimali.Match three decimal digits.
\b Terminare al confine di una parola.End at a word boundary.

Trova la corrispondenza almeno n volte: {n,}Match at Least n Times: {n,}

Il { ,} quantificatore n trova la corrispondenza con l'elemento precedente almeno n volte, dove n è qualsiasi numero intero.The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n ,} è un quantificatore greedy il cui equivalente lazy è { n ,}? .{n,} is a greedy quantifier whose lazy equivalent is {n,}?.

Ad esempio, l'espressione regolare \b\d{2,}\b\D+ tenta di trovare la corrispondenza con il confine di una parola seguito da almeno due cifre seguite dal confine di una parola e un carattere non numerico.For example, the regular expression \b\d{2,}\b\D+ tries to match a word boundary followed by at least two digits followed by a word boundary and a non-digit character. L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression. L'espressione regolare non riesce a trovare la frase "7 days" perché contiene solo una cifra decimale, ma trova la corrispondenza con le frasi "10 weeks and 300 years".The regular expression fails to match the phrase "7 days" because it contains just one decimal digit, but it successfully matches the phrases "10 weeks and 300 years".

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
\d{2,} Trova la corrispondenza con almeno due cifre decimali.Match at least two decimal digits.
\b Trova la corrispondenza di un confine di parola.Match a word boundary.
\D+ Trova la corrispondenza con almeno una cifra non decimale.Match at least one non-decimal digit.

Trova la corrispondenza tra n e m volte: {n,m}Match Between n and m Times: {n,m}

Il { , } quantificatore n m trova la corrispondenza con l'elemento precedente almeno n volte, ma non più di m volte, dove n e m sono numeri interi.The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n , m } è un quantificatore greedy il cui equivalente lazy è { n , m }? .{n,m} is a greedy quantifier whose lazy equivalent is {n,m}?.

Nell'esempio seguente, l'espressione regolare (00\s){2,4} tenta di trovare una corrispondenza tra due e quattro occorrenze di due cifre zero seguite da uno spazio.In the following example, the regular expression (00\s){2,4} tries to match between two and four occurrences of two zero digits followed by a space. Si noti che la parte finale della stringa di input include questo criterio cinque volte anziché il numero massimo di quattro.Note that the final portion of the input string includes this pattern five times rather than the maximum of four. Tuttavia, solo la parte iniziale della sottostringa (fino allo spazio e alla quinta coppia di zeri) corrisponde al criterio dell'espressione regolare.However, only the initial portion of this substring (up to the space and the fifth pair of zeros) matches the regular expression pattern.

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

Trova la corrispondenza zero o più volte (corrispondenza lazy): *?Match Zero or More Times (Lazy Match): *?

Il quantificatore *? trova la corrispondenza con l'elemento precedente zero o più volte, ma il minor numero di volte possibile.The *? quantifier matches the preceding element zero or more times, but as few times as possible. Si tratta della controparte lazy del quantificatore greedy *.It is the lazy counterpart of the greedy quantifier *.

Nell'esempio seguente l'espressione regolare \b\w*?oo\w*?\b corrisponde a tutte le parole contenenti la stringa oo.In the following example, the regular expression \b\w*?oo\w*?\b matches all words that contain the string oo.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
\w*? Trova la corrispondenza con zero o più caratteri alfanumerici, ma il minor numero di caratteri possibile.Match zero or more word characters, but as few characters as possible.
oo Trova la corrispondenza con la stringa "oo".Match the string "oo".
\w*? Trova la corrispondenza con zero o più caratteri alfanumerici, ma il minor numero di caratteri possibile.Match zero or more word characters, but as few characters as possible.
\b Termina al confine di una parola.End on a word boundary.

Trova la corrispondenza una o più volte (corrispondenza lazy): +?Match One or More Times (Lazy Match): +?

Il quantificatore +? trova la corrispondenza con l'elemento precedente una o più volte, ma il minor numero di volte possibile.The +? quantifier matches the preceding element one or more times, but as few times as possible. Si tratta della controparte lazy del quantificatore greedy +.It is the lazy counterpart of the greedy quantifier +.

Ad esempio, l'espressione regolare \b\w+?\b trova la corrispondenza con uno o più caratteri separati confini di parole.For example, the regular expression \b\w+?\b matches one or more characters separated by word boundaries. L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression.

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

Trova la corrispondenza zero o una volta (corrispondenza lazy): ??Match Zero or One Time (Lazy Match): ??

Il quantificatore ?? trova la corrispondenza con l'elemento precedente zero o una volta, ma il minor numero di volte possibile.The ?? quantifier matches the preceding element zero or one time, but as few times as possible. Si tratta della controparte lazy del quantificatore greedy ?.It is the lazy counterpart of the greedy quantifier ?.

Ad esempio, l'espressione regolare ^\s*(System.)??Console.Write(Line)??\(?? tenta di trovare la corrispondenza con le stringhe "Console.Write" o "Console.WriteLine".For example, the regular expression ^\s*(System.)??Console.Write(Line)??\(?? attempts to match the strings "Console.Write" or "Console.WriteLine". La stringa può anche includere "System."The string can also include "System." prima di "Console" e può essere seguita da una parentesi di apertura.before "Console", and it can be followed by an opening parenthesis. La stringa deve essere all'inizio di una riga, anche se può essere preceduta da uno spazio vuoto.The string must be at the beginning of a line, although it can be preceded by white space. L'esempio seguente illustra questa espressione regolare.The following example illustrates this regular expression.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
^ Trova la corrispondenza con l'inizio del flusso di input.Match the start of the input stream.
\s* Trovare la corrispondenza di zero o più spazi vuoti.Match zero or more white-space characters.
(System.)?? Trova la corrispondenza con zero o una occorrenza della stringa "System.".Match zero or one occurrence of the string "System.".
Console.Write Trova la corrispondenza con la stringa "Console.Write".Match the string "Console.Write".
(Line)?? Trova la corrispondenza con zero o una occorrenza della stringa "Line".Match zero or one occurrence of the string "Line".
\(?? Trova la corrispondenza con zero o una occorrenza della parentesi di apertura.Match zero or one occurrence of the opening parenthesis.

Trova la corrispondenza esatta n volte (corrispondenza lazy): {n}?Match Exactly n Times (Lazy Match): {n}?

Il { }? quantificatore n trova la corrispondenza con l'elemento precedente esattamente n volte, dove n è qualsiasi numero intero.The {n}? quantifier matches the preceding element exactly n times, where n is any integer. Si tratta della controparte Lazy del quantificatore greedy { n } .It is the lazy counterpart of the greedy quantifier {n}.

Nell'esempio seguente viene usata l'espressione regolare \b(\w{3,}?\.){2}?\w{3,}?\b per identificare un indirizzo di sito Web.In the following example, the regular expression \b(\w{3,}?\.){2}?\w{3,}?\b is used to identify a Web site address. Si noti che corrisponde a "www.microsoft.com" e "msdn.microsoft.com", ma non a "mywebsite" o "mycompany.com".Note that it matches "www.microsoft.com" and "msdn.microsoft.com", but does not match "mywebsite" or "mycompany.com".

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
(\w{3,}?\.) Trova la corrispondenza con almeno 3 caratteri alfanumerici, ma il minor numero di caratteri possibile, seguiti da un carattere punto.Match at least 3 word characters, but as few characters as possible, followed by a dot or period character. Equivale al primo gruppo di acquisizione.This is the first capturing group.
(\w{3,}?\.){2}? Corrisponde al criterio nel primo gruppo due volte, ma il minor numero di volte possibile.Match the pattern in the first group two times, but as few times as possible.
\b Termina la corrispondenza sul confine di parola.End the match on a word boundary.

Trova la corrispondenza almeno n volte (corrispondenza lazy): {n,}?Match at Least n Times (Lazy Match): {n,}?

Il { ,}? quantificatore n trova la corrispondenza con l'elemento precedente almeno n volte, dove n è qualsiasi numero intero, ma il minor numero di volte possibile.The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. Si tratta della controparte Lazy del quantificatore greedy { n ,} .It is the lazy counterpart of the greedy quantifier {n,}.

Vedere l'esempio per il { }? quantificatore n nella sezione precedente per un'illustrazione.See the example for the {n}? quantifier in the previous section for an illustration. L'espressione regolare in tale esempio usa il { ,} quantificatore n per trovare la corrispondenza con una stringa che contiene almeno tre caratteri seguiti da un punto.The regular expression in that example uses the {n,} quantifier to match a string that has at least three characters followed by a period.

Trova la corrispondenza tra n e m volte (corrispondenza lazy): {n,m}?Match Between n and m Times (Lazy Match): {n,m}?

Il { , }? quantificatore n m trova la corrispondenza con l'elemento precedente tra n e m Times, dove n e m sono numeri interi, ma il minor numero di volte possibile.The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. Si tratta della controparte Lazy del quantificatore greedy { n , m } .It is the lazy counterpart of the greedy quantifier {n,m}.

Nell'esempio seguente l'espressione regolare \b[A-Z](\w*?\s*?){1,10}[.!?] corrisponde alle frasi che contengono da una a dieci parole.In the following example, the regular expression \b[A-Z](\w*?\s*?){1,10}[.!?] matches sentences that contain between one and ten words. Trova la corrispondenza con tutte le frasi nella stringa di input, ad eccezione di una frase che contiene 18 parole.It matches all the sentences in the input string except for one sentence that contains 18 words.

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

Il criterio di ricerca di espressioni regolari è definito nel modo illustrato nella tabella seguente.The regular expression pattern is defined as shown in the following table.

ModelloPattern DescrizioneDescription
\b Inizia dal confine di una parola.Start at a word boundary.
[A-Z] Trova la corrispondenza con un carattere maiuscolo da A a Z.Match an uppercase character from A to Z.
(\w*?\s*?) Trova la corrispondenza con uno o più caratteri alfanumerici seguiti da uno o più caratteri spazio vuoto, ma il minor numero di volte possibile.Match zero or more word characters, followed by one or more white-space characters, but as few times as possible. Equivale al primo gruppo di acquisizione.This is the first capture group.
{1,10} Trova la corrispondenza con il criterio precedente da 1 a 10 volte.Match the previous pattern between 1 and 10 times.
[.!?] Trova la corrispondenza con uno dei caratteri di punteggiatura ".", "!" o "?".Match any one of the punctuation characters ".", "!", or "?".

Quantificatori greedy e lazyGreedy and Lazy Quantifiers

Alcuni quantificatori hanno due versioni:A number of the quantifiers have two versions:

  • Una versione greedy.A greedy version.

    Un quantificatore greedy tenta di trovare la corrispondenza con un elemento il maggior numero di volte possibile.A greedy quantifier tries to match an element as many times as possible.

  • Una versione non greedy (o lazy).A non-greedy (or lazy) version.

    Un quantificatore non greedy tenta di trovare la corrispondenza con un elemento il minor numero di volte possibile.A non-greedy quantifier tries to match an element as few times as possible. È possibile trasformare un quantificatore greedy in un quantificatore lazy aggiungendo semplicemente un ?.You can turn a greedy quantifier into a lazy quantifier by simply adding a ?.

Si consideri un'espressione regolare semplice progettata per estrarre le ultime quattro cifre da una stringa di numeri, ad esempio un numero di carta di credito.Consider a simple regular expression that is intended to extract the last four digits from a string of numbers such as a credit card number. La versione dell'espressione regolare che usa il quantificatore greedy * è \b.*([0-9]{4})\b.The version of the regular expression that uses the * greedy quantifier is \b.*([0-9]{4})\b. Se tuttavia una stringa contiene due numeri, come illustrato nell'esempio seguente, l'espressione regolare trova la corrispondenza solo con le ultime quattro cifre secondo numero.However, if a string contains two numbers, this regular expression matches the last four digits of the second number only, as the following example shows.

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

L'espressione regolare non è in grado di trovare il primo numero perché il quantificatore * tenta di trovare la corrispondenza con l'elemento precedente il maggior numero di volte possibile nell'intera stringa, quindi trova la corrispondenza alla fine della stringa.The regular expression fails to match the first number because the * quantifier tries to match the previous element as many times as possible in the entire string, and so it finds its match at the end of the string.

Questo non è il comportamento desiderato.This is not the desired behavior. È invece possibile usare il quantificatore lazy *? per estrarre cifre da entrambi i numeri, come illustra l'esempio seguente.Instead, you can use the *?lazy quantifier to extract digits from both numbers, as the following example shows.

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

Nella maggior parte dei casi le espressioni regolari con quantificatori greedy e lazy restituiscono le stesse corrispondenze.In most cases, regular expressions with greedy and lazy quantifiers return the same matches. In genere restituiscono risultati diversi quando vengono usate con il metacarattere jolly (.), che corrisponde a qualsiasi carattere.They most commonly return different results when they are used with the wildcard (.) metacharacter, which matches any character.

Quantificatori e corrispondenze vuoteQuantifiers and Empty Matches

I quantificatori * , + e { n , m } e le relative controparti lazy non si ripetono mai dopo una corrispondenza vuota quando è stato trovato il numero minimo di acquisizioni.The quantifiers *, +, and {n,m} and their lazy counterparts never repeat after an empty match when the minimum number of captures has been found. Questa regola impedisce ai quantificatori di avviare cicli infiniti su corrispondenze di sottoespressioni vuote quando il numero massimo di acquisizioni possibili per il gruppo possibili è infinito o quasi infinito.This rule prevents quantifiers from entering infinite loops on empty subexpression matches when the maximum number of possible group captures is infinite or near infinite.

Ad esempio, il codice seguente presenta il risultato di una chiamata al metodo Regex.Match con il criterio di espressione regolare (a?)* che trova la corrispondenza con uno o nessun carattere "a" zero o più volte.For example, the following code shows the result of a call to the Regex.Match method with the regular expression pattern (a?)*, which matches zero or one "a" character zero or more times. Si noti che il singolo gruppo di acquisizione acquisisce ogni "a" nonché String.Empty, ma che non esiste una seconda corrispondenza vuota, perché la prima corrispondenza vuota induce il quantificatore a interrompere la ripetizione.Note that the single capturing group captures each "a" as well as String.Empty, but that there is no second empty match, because the first empty match causes the quantifier to stop repeating.

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

Per vedere in pratica la differenza tra un gruppo di acquisizione che definisce un numero minimo e massimo di acquisizioni e uno che definisce un numero fisso di acquisizioni, considerare i criteri di espressione regolare (a\1|(?(1)\1)){0,2} e (a\1|(?(1)\1)){2}.To see the practical difference between a capturing group that defines a minimum and a maximum number of captures and one that defines a fixed number of captures, consider the regular expression patterns (a\1|(?(1)\1)){0,2} and (a\1|(?(1)\1)){2}. Entrambe le espressioni regolari sono costituite da un singolo gruppo di acquisizione, definito come illustrato nella tabella seguente.Both regular expressions consist of a single capturing group, which is defined as shown in the following table.

ModelloPattern DescrizioneDescription
(a\1 Trova la corrispondenza con "a" insieme al valore del primo gruppo acquisito...Either match "a" along with the value of the first captured group …
|(?(1) o verifica se è stato definito il primo gruppo acquisito.or test whether the first captured group has been defined. Si noti che il costrutto (?(1) non definisce un gruppo di acquisizione.(Note that the (?(1) construct does not define a capturing group.)
\1)) Se il primo gruppo acquisito esiste, trovare la corrispondenza con il relativo valore.If the first captured group exists, match its value. Se non esiste, il gruppo corrisponderà a String.Empty.If the group does not exist, the group will match String.Empty.

La prima espressione regolare tenta di trovare la corrispondenza con questo criterio da zero a due volte, la seconda esattamente due volte.The first regular expression tries to match this pattern between zero and two times; the second, exactly two times. Poiché il primo criterio raggiunge il numero minimo di acquisizioni con la prima acquisizione di String.Empty, non ripete mai il tentativo di trovare una corrispondenza con a\1 e il quantificatore {0,2} consente solo corrispondenze vuote nell'ultima iterazione.Because the first pattern reaches its minimum number of captures with its first capture of String.Empty, it never repeats to try to match a\1; the {0,2} quantifier allows only empty matches in the last iteration. Al contrario, la seconda espressione regolare trova la corrispondenza con "a" perché restituisce a\1 una seconda volta. Il numero minimo di iterazioni, 2, impone al motore la ripetizione dopo una corrispondenza vuota.In contrast, the second regular expression does match "a" because it evaluates a\1 a second time; the minimum number of iterations, 2, forces the engine to repeat after an empty match.

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

Vedere ancheSee also