Espressioni regolari .NET.NET Regular Expressions

Le espressioni regolari ("regular expression") garantiscono un metodo efficace e flessibile per elaborare del testo.Regular expressions provide a powerful, flexible, and efficient method for processing text. L'ampia notazione per la formulazione dei criteri di ricerca fornita dalle espressioni regolari consente di analizzare rapidamente grandi quantità di testo per trovare combinazioni di caratteri specifiche, per convalidare il testo verificandone la corrispondenza con un modello predefinito, ad esempio un indirizzo di posta elettronica, per estrarre, modificare, sostituire o eliminare sottostringhe di testo e per aggiungere le stringhe estratte a una raccolta per generare un rapporto.The extensive pattern-matching notation of regular expressions enables you to quickly parse large amounts of text to find specific character patterns; to validate text to ensure that it matches a predefined pattern (such as an email address); to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection in order to generate a report. Per numerose applicazioni che gestiscono stringhe o che analizzano grandi blocchi di testo, le espressioni regolari rappresentano uno strumento indispensabile.For many applications that deal with strings or that parse large blocks of text, regular expressions are an indispensable tool.

Funzionamento delle espressioni regolariHow Regular Expressions Work

Il motore di elaborazione di testo tramite espressioni regolari è rappresentato dall'oggetto System.Text.RegularExpressions.Regex in .NET.The centerpiece of text processing with regular expressions is the regular expression engine, which is represented by the System.Text.RegularExpressions.Regex object in .NET. L'elaborazione di testo tramite espressioni regolari richiede che al motore delle espressioni regolari vengano fornite almeno le due informazioni seguenti:At a minimum, processing text using regular expressions requires that the regular expression engine be provided with the following two items of information:

  • Criterio di espressione regolare da identificare nel testo.The regular expression pattern to identify in the text.

    In .NET i criteri di espressione regolare vengono definiti a un linguaggio o una sintassi speciale, compatibile con le espressioni regolari Perl 5, che offre funzionalità aggiuntive come la corrispondenza da destra verso sinistra.In .NET, regular expression patterns are defined by a special syntax or language, which is compatible with Perl 5 regular expressions and adds some additional features such as right-to-left matching. Per altre informazioni, vedere Linguaggio di espressioni regolari - Riferimento rapido.For more information, see Regular Expression Language - Quick Reference.

  • Testo da analizzare per il criterio di espressione regolare.The text to parse for the regular expression pattern.

I metodi della classe Regex consentono di eseguire le operazioni seguenti:The methods of the Regex class let you perform the following operations:

Per una panoramica del modello a oggetti delle espressioni regolari, vedere Modello a oggetti delle espressioni regolari.For an overview of the regular expression object model, see The Regular Expression Object Model.

Per altre informazioni sul linguaggio delle espressioni regolari, vedere Linguaggio di espressioni regolari - Riferimento rapido o scaricare e stampare una delle brochure seguenti:For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Riferimento rapido in formato Word (DOCX)Quick Reference in Word (.docx) format
Riferimento rapido in formato PDF (PDF)Quick Reference in PDF (.pdf) format

Esempi di espressioni regolariRegular Expression Examples

La classe String include numerosi metodi di ricerca e sostituzione di stringhe che è possibile usare quando si vogliono individuare stringhe letterali in una stringa più grande.The String class includes a number of string search and replacement methods that you can use when you want to locate literal strings in a larger string. Le espressioni regolari sono utili per lo più quando si vuole individuare una di diverse sottostringhe in una stringa più grande o quando si vogliono identificare dei modelli in una stringa, come illustrato negli esempi seguenti.Regular expressions are most useful either when you want to locate one of several substrings in a larger string, or when you want to identify patterns in a string, as the following examples illustrate.

Esempio 1: sostituzione di sottostringheExample 1: Replacing Substrings

Si presupponga che una lista di distribuzione contenga nomi che talvolta includono un titolo (Mr., Mrs., Miss o Ms.) oltre al nome e al cognome.Assume that a mailing list contains names that sometimes include a title (Mr., Mrs., Miss, or Ms.) along with a first and last name. Se non si vogliono includere i titoli quando si generano etichette per le buste dall'elenco, è possibile usare un'espressione regolare per rimuovere i titoli, come illustrato nell'esempio seguente.If you do not want to include the titles when you generate envelope labels from the list, you can use a regular expression to remove the titles, as the following example illustrates.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";
      string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels", 
                         "Abraham Adams", "Ms. Nicole Norris" };
      foreach (string name in names)
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty));
   }
}
// The example displays the following output:
//    Henry Hunt
//    Sara Samuels
//    Abraham Adams
//    Nicole Norris
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
      Dim names() As String = { "Mr. Henry Hunt", "Ms. Sara Samuels", _
                                "Abraham Adams", "Ms. Nicole Norris" }
      For Each name As String In names
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
      Next                                
   End Sub
End Module
' The example displays the following output:
'    Henry Hunt
'    Sara Samuels
'    Abraham Adams
'    Nicole Norris

Il criterio di espressione regolare (Mr\.? |Mrs\.? |Miss |Ms\.? ) trova una corrispondenza di tutte le occorrenze di "Mr", "Mr.", "Mrs", "Mrs.", "Miss", "Ms" o "Ms.".The regular expression pattern(Mr\.? |Mrs\.? |Miss |Ms\.? ) matches any occurrence of "Mr ", "Mr. ", "Mrs ", "Mrs. ", "Miss ", "Ms or "Ms. ". La chiamata al metodo Regex.Replace sostituisce la stringa corrispondente con String.Empty, ovvero la rimuove dalla stringa originale.The call to the Regex.Replace method replaces the matched string with String.Empty; in other words, it removes it from the original string.

Esempio 2: identificazione di parole duplicateExample 2: Identifying Duplicated Words

La duplicazione accidentale delle parole è un errore comune commesso dagli autori.Accidentally duplicating words is a common error that writers make. È possibile usare un'espressione regolare per identificare le parole duplicate, come illustrato nell'esempio seguente.A regular expression can be used to identify duplicated words, as the following example shows.

using System;
using System.Text.RegularExpressions;

public class Class1
{
   public static void Main()
   {
      string pattern = @"\b(\w+?)\s\1\b";
      string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine("{0} (duplicates '{1}') at position {2}", 
                           match.Value, match.Groups[1].Value, match.Index);
   }
}
// The example displays the following output:
//       This this (duplicates 'This') at position 0
//       a a (duplicates 'a') at position 66
Imports System.Text.RegularExpressions

Module modMain
   Public Sub Main()
      Dim pattern As String = "\b(\w+?)\s\1\b"
      Dim input As String = "This this is a nice day. What about this? This tastes good. I saw a a dog."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
                           match.Value, match.Groups(1).Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       This this (duplicates 'This') at position 0
'       a a (duplicates 'a') at position 66

Il criterio di espressione regolare \b(\w+?)\s\1\b può essere interpretato nel modo seguente:The regular expression pattern \b(\w+?)\s\1\b can be interpreted as follows:

\b Inizia dal confine di una parola.Start at a word boundary.
(\w+?)(\w+?) Corrisponde a uno o più caratteri alfanumerici, ma il minor numero di caratteri possibile.Match one or more word characters, but as few characters as possible. I caratteri insieme formano un gruppo a cui è possibile fare riferimento come \1.Together, they form a group that can be referred to as \1.
\s Trova la corrispondenza con uno spazio vuoto.Match a white-space character.
\1 Trova la corrispondenza della sottostringa equivalente al gruppo denominato \1.Match the substring that is equal to the group named \1.
\b Trova la corrispondenza di un confine di parola.Match a word boundary.

Il metodo Regex.Matches viene chiamato con le opzioni relative alle espressioni regolari impostate su RegexOptions.IgnoreCase.The Regex.Matches method is called with regular expression options set to RegexOptions.IgnoreCase. Per l'operazione di corrispondenza non viene quindi fatta distinzione tra maiuscole e minuscole e nell'esempio la sottostringa "This this" viene identificata come duplicato.Therefore, the match operation is case-insensitive, and the example identifies the substring "This this" as a duplication.

Si noti che la stringa di input include la sottostringa "this?Note that the input string includes the substring "this? This".This". Dato che tuttavia tra le due parole è presente un segno di punteggiatura, le parole non vengono identificate come duplicati.However, because of the intervening punctuation mark, it is not identified as a duplication.

Esempio 3: compilazione dinamica di un'espressione regolare dipendente dalle impostazioni culturaExample 3: Dynamically Building a Culture-Sensitive Regular Expression

L'esempio seguente illustra le potenzialità delle espressioni regolari combinate alla flessibilità offerta dalle funzionalità di globalizzazione di .NET.The following example illustrates the power of regular expressions combined with the flexibility offered by .NET's globalization features. Viene usato l'oggetto NumberFormatInfo per determinare il formato dei valori di valuta nelle impostazioni cultura correnti del sistema.It uses the NumberFormatInfo object to determine the format of currency values in the system's current culture. Queste informazioni vengono quindi usate per costruire in modo dinamico un'espressione regolare per l'estrazione dei valori di valuta dal testo.It then uses that information to dynamically construct a regular expression that extracts currency values from the text. Per ogni corrispondenza, viene estratto il sottogruppo che contiene solo la stringa numerica, viene convertito in un valore Decimal e viene calcolato un totale parziale.For each match, it extracts the subgroup that contains the numeric string only, converts it to a Decimal value, and calculates a running total.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Define text to be parsed.
      string input = "Office expenses on 2/13/2008:\n" + 
                     "Paper (500 sheets)                      $3.95\n" + 
                     "Pencils (box of 10)                     $1.00\n" + 
                     "Pens (box of 10)                        $4.49\n" + 
                     "Erasers                                 $2.19\n" + 
                     "Ink jet printer                        $69.95\n\n" + 
                     "Total Expenses                        $ 81.58\n"; 
      
      // Get current culture's NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
      // Assign needed property values to variables.
      string currencySymbol = nfi.CurrencySymbol;
      bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
      string groupSeparator = nfi.CurrencyGroupSeparator;
      string decimalSeparator = nfi.CurrencyDecimalSeparator;

      // Form regular expression pattern.
      string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") + 
                       @"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + 
                       Regex.Escape(decimalSeparator) + "[0-9]+)?)" + 
                       (! symbolPrecedesIfPositive ? currencySymbol : ""); 
      Console.WriteLine( "The regular expression pattern is:");
      Console.WriteLine("   " + pattern);      

      // Get text that matches regular expression pattern.
      MatchCollection matches = Regex.Matches(input, pattern, 
                                              RegexOptions.IgnorePatternWhitespace);               
      Console.WriteLine("Found {0} matches.", matches.Count); 

      // Get numeric string, convert it to a value, and add it to List object.
      List<decimal> expenses = new List<Decimal>();
                     
      foreach (Match match in matches)
         expenses.Add(Decimal.Parse(match.Groups[1].Value));      

      // Determine whether total is present and if present, whether it is correct.
      decimal total = 0;
      foreach (decimal value in expenses)
         total += value;
      
      if (total / 2 == expenses[expenses.Count - 1]) 
         Console.WriteLine("The expenses total {0:C2}.", expenses[expenses.Count - 1]);
      else
         Console.WriteLine("The expenses total {0:C2}.", total);
   }  
}
// The example displays the following output:
//       The regular expression pattern is:
//          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
//       Found 6 matches.
//       The expenses total $81.58.
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Define text to be parsed.
      Dim input As String = "Office expenses on 2/13/2008:" + vbCrLf + _
                            "Paper (500 sheets)                      $3.95" + vbCrLf + _
                            "Pencils (box of 10)                     $1.00" + vbCrLf + _
                            "Pens (box of 10)                        $4.49" + vbCrLf + _
                            "Erasers                                 $2.19" + vbCrLf + _
                            "Ink jet printer                        $69.95" + vbCrLf + vbCrLf + _
                            "Total Expenses                        $ 81.58" + vbCrLf
      ' Get current culture's NumberFormatInfo object.
      Dim nfi As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
      ' Assign needed property values to variables.
      Dim currencySymbol As String = nfi.CurrencySymbol
      Dim symbolPrecedesIfPositive As Boolean = CBool(nfi.CurrencyPositivePattern Mod 2 = 0)
      Dim groupSeparator As String = nfi.CurrencyGroupSeparator
      Dim decimalSeparator As String = nfi.CurrencyDecimalSeparator

      ' Form regular expression pattern.
      Dim pattern As String = Regex.Escape(CStr(IIf(symbolPrecedesIfPositive, currencySymbol, ""))) + _
                              "\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + _
                              Regex.Escape(decimalSeparator) + "[0-9]+)?)" + _
                              CStr(IIf(Not symbolPrecedesIfPositive, currencySymbol, "")) 
      Console.WriteLine("The regular expression pattern is: ")
      Console.WriteLine("   " + pattern)      

      ' Get text that matches regular expression pattern.
      Dim matches As MatchCollection = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)               
      Console.WriteLine("Found {0} matches. ", matches.Count)

      ' Get numeric string, convert it to a value, and add it to List object.
      Dim expenses As New List(Of Decimal)
                     
      For Each match As Match In matches
         expenses.Add(Decimal.Parse(match.Groups.Item(1).Value))      
      Next

      ' Determine whether total is present and if present, whether it is correct.
      Dim total As Decimal
      For Each value As Decimal In expenses
         total += value
      Next
      
      If total / 2 = expenses(expenses.Count - 1) Then
         Console.WriteLine("The expenses total {0:C2}.", expenses(expenses.Count - 1))
      Else
         Console.WriteLine("The expenses total {0:C2}.", total)
      End If   
   End Sub
End Module
' The example displays the following output:
'       The regular expression pattern is:
'          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
'       Found 6 matches.
'       The expenses total $81.58.

In un computer le cui impostazioni cultura correnti sono Inglese - Stati Uniti (en-US), l'esempio compila l'espressione regolare \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) dinamicamente.On a computer whose current culture is English - United States (en-US), the example dynamically builds the regular expression \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). Questo criterio di espressione regolare può essere interpretato nel modo seguente:This regular expression pattern can be interpreted as follows:

\$ Cerca una singola occorrenza del simbolo di dollaro ($) nella stringa di input.Look for a single occurrence of the dollar symbol ($) in the input string. La stringa del criterio di espressione regolare include una barra rovesciata per indicare che il simbolo di dollaro deve essere interpretato letteralmente e non come un ancoraggio dell'espressione regolare.The regular expression pattern string includes a backslash to indicate that the dollar symbol is to be interpreted literally rather than as a regular expression anchor. Il simbolo $ da solo indica che il motore delle espressioni regolari deve cercare di iniziare la ricerca della corrispondenza alla fine di una stringa. Per garantire che il simbolo di valuta delle impostazioni cultura correnti non venga interpretato erroneamente come simbolo dell'espressione regolare, l'esempio chiama il metodo Escape per usare caratteri di escape per il carattere.(The $ symbol alone would indicate that the regular expression engine should try to begin its match at the end of a string.) To ensure that the current culture's currency symbol is not misinterpreted as a regular expression symbol, the example calls the Escape method to escape the character.
\s* Cerca zero o più occorrenze di uno spazio vuoto.Look for zero or more occurrences of a white-space character.
[-+]? Cerca zero o una occorrenza di un segno positivo o negativo.Look for zero or one occurrence of either a positive sign or a negative sign.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) Le parentesi esterne che delimitano questa espressione la definiscono come gruppo di acquisizione o come sottoespressione.The outer parentheses around this expression define it as a capturing group or a subexpression. Se viene trovata una corrispondenza, è possibile recuperare informazioni relative a questa parte della stringa corrispondente dal secondo oggetto Group nell'oggetto GroupCollection restituito dalla proprietà Match.Groups.If a match is found, information about this part of the matching string can be retrieved from the second Group object in the GroupCollection object returned by the Match.Groups property. Il primo elemento della raccolta rappresenta la corrispondenza completa.(The first element in the collection represents the entire match.)
[0-9]{0,3} Cerca da zero a tre occorrenze delle cifre decimali comprese tra 0 e 9.Look for zero to three occurrences of the decimal digits 0 through 9.
(,[0-9]{3})* Cerca zero o più occorrenze di un separatore di gruppi seguito da tre cifre decimali.Look for zero or more occurrences of a group separator followed by three decimal digits.
\. Cerca una singola occorrenza del separatore decimale.Look for a single occurrence of the decimal separator.
[0-9]+ Cerca una o più cifre decimali.Look for one or more decimal digits.
(\.[0-9]+)? Cerca zero o una occorrenza del separatore decimale seguito da almeno una cifra decimale.Look for zero or one occurrence of the decimal separator followed by at least one decimal digit.

Se ognuno di questi modelli secondari viene trovato nella stringa di input, la corrispondenza ha esito positivo e un oggetto Match contenente informazioni sulla corrispondenza viene aggiunto all'oggetto MatchCollection.If each of these subpatterns is found in the input string, the match succeeds, and a Match object that contains information about the match is added to the MatchCollection object.

TitoloTitle DescrizioneDescription
Linguaggio di espressioni regolari - Riferimento rapidoRegular Expression Language - Quick Reference Fornisce informazioni sul set di caratteri, di operatori e di costrutti che è possibile usare per definire le espressioni regolari.Provides information on the set of characters, operators, and constructs that you can use to define regular expressions.
Modello a oggetti delle espressioni regolariThe Regular Expression Object Model Fornisce esempi di codice e informazioni che illustrano l'uso delle classi di espressioni regolari.Provides information and code examples that illustrate how to use the regular expression classes.
Dettagli sul comportamento delle espressioni regolariDetails of Regular Expression Behavior Offre informazioni sulle funzionalità e il funzionamento delle espressioni regolari di .NET.Provides information about the capabilities and behavior of .NET regular expressions.
Esempi di espressioni regolariRegular Expression Examples Fornisce esempi di codice che illustrano gli usi tipici delle espressioni regolari.Provides code examples that illustrate typical uses of regular expressions.

RiferimentiReference

System.Text.RegularExpressions
System.Text.RegularExpressions.Regex
Espressioni regolari - Guida di riferimento rapido (download in formato Word)Regular Expressions - Quick Reference (download in Word format)
Espressioni regolari - Guida di riferimento rapido (download in formato PDF)Regular Expressions - Quick Reference (download in PDF format)