Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Espressioni regolari di .NET Framework

 

Le espressioni regolari ("regular expression") garantiscono un metodo efficace e flessibile per elaborare del testo. 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. Per numerose applicazioni che gestiscono stringhe o che analizzano grandi blocchi di testo, le espressioni regolari rappresentano uno strumento indispensabile.

Il motore di elaborazione di testo tramite espressioni regolari è rappresentato dall'oggetto System.Text.RegularExpressions.Regex in .NET Framework. L'elaborazione di testo tramite espressioni regolari richiede che al motore delle espressioni regolari vengano fornite almeno le due informazioni seguenti:

  • Criterio di espressione regolare da identificare nel testo.

    In .NET Framework i criteri di espressione regolare vengono definiti tramite un linguaggio o una sintassi speciale, compatibile con le espressioni regolari Perl 5, che offre funzionalità aggiuntive come la corrispondenza da destra verso sinistra. Per altre informazioni, vedere Linguaggio di espressioni regolari - Riferimento rapido.

  • Testo da analizzare per il criterio di espressione regolare.

I metodi della classe Regex consentono di eseguire le operazioni seguenti:

Per una panoramica del modello a oggetti delle espressioni regolari, vedere Modello a oggetti delle espressioni regolari.

Per altre informazioni sul linguaggio delle espressioni regolari, vedere Linguaggio di espressioni regolari - Riferimento rapido o scaricare e stampare una delle brochure seguenti:

Riferimento rapido in formato Word (.docx)
      Riferimento rapido in formato PDF (.pdf)

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

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

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

Il criterio di espressione regolare (Mr\.? |Mrs\.? |Miss |Ms\.? ) trova una corrispondenza di tutte le occorrenza di "Mr ", "Mr. " , "Mrs ", "Mrs. " , "Miss ", "Ms o "Ms. " . La chiamata al metodo Regex.Replace sostituisce la stringa corrispondente con String.Empty, ovvero la rimuove dalla stringa originale.

La duplicazione accidentale delle parole è un errore comune commesso dagli autori. È possibile usare un'espressione regolare per identificare le parole duplicate, come illustrato nell'esempio seguente.

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

Il criterio di espressione regolare \b(\w+?)\s\1\b può essere interpretato nel modo seguente:

\b

Inizia dal confine di una parola.

(\w+?)

Corrisponde a uno o più caratteri alfanumerici, ma il minor numero di caratteri possibile. I caratteri insieme formano un gruppo a cui è possibile fare riferimento come \1.

\s

Trova la corrispondenza con uno spazio vuoto.

\1

Trova la corrispondenza della sottostringa equivalente al gruppo denominato \1.

\b

Trova la corrispondenza di un confine di parola.

Il metodo Regex.Matches viene chiamato con le opzioni relative alle espressioni regolari impostate su 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.

Si noti che la stringa di input include la sottostringa "this? This". Dato che tuttavia tra le due parole è presente un segno di punteggiatura, le parole non vengono identificate come duplicati.

L'esempio seguente illustra le potenzialità delle espressioni regolari combinate alla flessibilità offerta dalle funzionalità di globalizzazione di .NET Framework. Viene usato l'oggetto NumberFormatInfo per determinare il formato dei valori di valuta nelle impostazioni cultura correnti del sistema. Queste informazioni vengono quindi usate per costruire in modo dinamico un'espressione regolare per l'estrazione dei valori di valuta dal testo. 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.

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.

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. Questo criterio di espressione regolare può essere interpretato nel modo seguente:

\$

Cerca una singola occorrenza del simbolo di dollaro ($) nella stringa di input. 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. 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.

\s*

Cerca zero o più occorrenze di uno spazio vuoto.

[-+]?

Cerca zero o una occorrenza di un segno positivo o negativo.

([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. 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. Il primo elemento della raccolta rappresenta la corrispondenza completa.

[0-9]{0,3}

Cerca da zero a tre occorrenze delle cifre decimali comprese tra 0 e 9.

(,[0-9]{3})*

Cerca zero o più occorrenze di un separatore di gruppi seguito da tre cifre decimali.

\.

Cerca una singola occorrenza del separatore decimale.

[0-9]+

Cerca una o più cifre decimali.

(\.[0-9]+)?

Cerca zero o una occorrenza del separatore decimale seguito da almeno una cifra decimale.

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.

Titolo

Descrizione

Linguaggio di espressioni regolari - Riferimento rapido

Fornisce informazioni sul set di caratteri, di operatori e di costrutti che è possibile usare per definire le espressioni regolari.

Modello a oggetti delle espressioni regolari

Fornisce esempi di codice e informazioni che illustrano l'uso delle classi di espressioni regolari.

Dettagli sul comportamento delle espressioni regolari

Fornisce informazioni sulle funzionalità e il funzionamento delle espressioni regolari di .NET Framework.

Esempi di espressioni regolari

Fornisce esempi di codice che illustrano gli usi tipici delle espressioni regolari.

Mostra: