Espressioni regolari (C++/CLI)
Illustra varie operazioni di stringa usando classi di espressioni regolari in .NET Framework.
Negli argomenti seguenti viene illustrato l'uso dello spazio dei nomi .NET Framework System.Text.RegularExpressions (e in un caso il System.String.Split metodo ) per cercare, analizzare e modificare le stringhe.
Analizzare stringhe usando espressioni regolari
Nell'esempio di codice seguente viene illustrata l'analisi di stringhe semplici usando la Regex classe nello spazio dei System.Text.RegularExpressions nomi . Viene costruita una stringa contenente più tipi di delimitatori di parole. La stringa viene quindi analizzata usando la Regex classe insieme alla Match classe . Quindi, ogni parola nella frase viene visualizzata separatamente.
Esempio
// regex_parse.cpp
// compile with: /clr
#using <system.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
int main( )
{
int words = 0;
String^ pattern = "[a-zA-Z]*";
Console::WriteLine( "pattern : '{0}'", pattern );
Regex^ regex = gcnew Regex( pattern );
String^ line = "one\ttwo three:four,five six seven";
Console::WriteLine( "text : '{0}'", line );
for( Match^ match = regex->Match( line );
match->Success; match = match->NextMatch( ) )
{
if( match->Value->Length > 0 )
{
words++;
Console::WriteLine( "{0}", match->Value );
}
}
Console::WriteLine( "Number of Words : {0}", words );
return 0;
}
Analizzare stringhe usando il metodo Split
Nell'esempio di codice seguente viene illustrato l'utilizzo del System.String.Split metodo per estrarre ogni parola da una stringa. Una stringa contenente più tipi di delineatori di parole viene costruita e quindi analizzata chiamando Split con un elenco dei delineatori. Quindi, ogni parola nella frase viene visualizzata separatamente.
Esempio
// regex_split.cpp
// compile with: /clr
using namespace System;
int main()
{
String^ delimStr = " ,.:\t";
Console::WriteLine( "delimiter : '{0}'", delimStr );
array<Char>^ delimiter = delimStr->ToCharArray( );
array<String^>^ words;
String^ line = "one\ttwo three:four,five six seven";
Console::WriteLine( "text : '{0}'", line );
words = line->Split( delimiter );
Console::WriteLine( "Number of Words : {0}", words->Length );
for (int word=0; word<words->Length; word++)
Console::WriteLine( "{0}", words[word] );
return 0;
}
Usare espressioni regolari per la corrispondenza semplice
Nell'esempio di codice seguente vengono usate espressioni regolari per cercare corrispondenze di sottostringa esatte. La ricerca viene eseguita dal metodo statico IsMatch , che accetta due stringhe come input. La prima è la stringa da cercare e la seconda è il modello da cercare.
Esempio
// regex_simple.cpp
// compile with: /clr
#using <System.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
array<String^>^ sentence =
{
"cow over the moon",
"Betsy the Cow",
"cowering in the corner",
"no match here"
};
String^ matchStr = "cow";
for (int i=0; i<sentence->Length; i++)
{
Console::Write( "{0,24}", sentence[i] );
if ( Regex::IsMatch( sentence[i], matchStr,
RegexOptions::IgnoreCase ) )
Console::WriteLine(" (match for '{0}' found)", matchStr);
else
Console::WriteLine("");
}
return 0;
}
Usare espressioni regolari per estrarre campi dati
Nell'esempio di codice seguente viene illustrato l'uso di espressioni regolari per estrarre dati da una stringa formattata. Nell'esempio di codice seguente viene utilizzata la Regex classe per specificare un modello che corrisponde a un indirizzo di posta elettronica. Questo patter include identificatori di campo che possono essere utilizzati per recuperare le parti utente e nome host di ogni indirizzo di posta elettronica. La Match classe viene usata per eseguire i criteri di ricerca effettivi. Se l'indirizzo di posta elettronica specificato è valido, vengono estratti e visualizzati il nome utente e i nomi host.
Esempio
// Regex_extract.cpp
// compile with: /clr
#using <System.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
array<String^>^ address=
{
"jay@southridgevideo.com",
"barry@adatum.com",
"treyresearch.net",
"karen@proseware.com"
};
Regex^ emailregex = gcnew Regex("(?<user>[^@]+)@(?<host>.+)");
for (int i=0; i<address->Length; i++)
{
Match^ m = emailregex->Match( address[i] );
Console::Write("\n{0,25}", address[i]);
if ( m->Success )
{
Console::Write(" User='{0}'",
m->Groups["user"]->Value);
Console::Write(" Host='{0}'",
m->Groups["host"]->Value);
}
else
Console::Write(" (invalid email address)");
}
Console::WriteLine("");
return 0;
}
Usare espressioni regolari per riorganizzare i dati
Nell'esempio di codice seguente viene illustrato come usare il supporto delle espressioni regolari di .NET Framework per riorganizzare o riformattare i dati. Nell'esempio di codice seguente vengono utilizzate le Regex classi e Match per estrarre nomi e cognome da una stringa e quindi visualizzare questi elementi del nome in ordine inverso.
La Regex classe viene utilizzata per costruire un'espressione regolare che descrive il formato corrente dei dati. I due nomi vengono considerati separati da una virgola e possono usare qualsiasi quantità di spazio vuoto intorno alla virgola. Il Match metodo viene quindi usato per analizzare ogni stringa. In caso di esito positivo, il nome e il cognome vengono recuperati dall'oggetto Match e visualizzati.
Esempio
// regex_reorder.cpp
// compile with: /clr
#using <System.dll>
using namespace System;
using namespace Text::RegularExpressions;
int main()
{
array<String^>^ name =
{
"Abolrous, Sam",
"Berg,Matt",
"Berry , Jo",
"www.contoso.com"
};
Regex^ reg = gcnew Regex("(?<last>\\w*)\\s*,\\s*(?<first>\\w*)");
for ( int i=0; i < name->Length; i++ )
{
Console::Write( "{0,-20}", name[i] );
Match^ m = reg->Match( name[i] );
if ( m->Success )
{
String^ first = m->Groups["first"]->Value;
String^ last = m->Groups["last"]->Value;
Console::WriteLine("{0} {1}", first, last);
}
else
Console::WriteLine("(invalid)");
}
return 0;
}
Usare espressioni regolari per cercare e sostituire
Nell'esempio di codice seguente viene illustrato come usare la classe Regex di espressioni regolari per eseguire ricerche e sostituire. Questa operazione viene eseguita con il Replace metodo . La versione usata accetta due stringhe come input: la stringa da modificare e la stringa da inserire al posto delle sezioni (se presenti) che corrispondono al criterio specificato all'oggetto Regex .
Questo codice sostituisce tutte le cifre in una stringa con caratteri di sottolineatura (_) e quindi li sostituisce con una stringa vuota, rimuovendoli in modo efficace. Lo stesso effetto può essere eseguito in un unico passaggio, ma per scopi dimostrativi vengono usati due passaggi.
Esempio
// regex_replace.cpp
// compile with: /clr
#using <System.dll>
using namespace System::Text::RegularExpressions;
using namespace System;
int main()
{
String^ before = "The q43uick bro254wn f0ox ju4mped";
Console::WriteLine("original : {0}", before);
Regex^ digitRegex = gcnew Regex("(?<digit>[0-9])");
String^ after = digitRegex->Replace(before, "_");
Console::WriteLine("1st regex : {0}", after);
Regex^ underbarRegex = gcnew Regex("_");
String^ after2 = underbarRegex->Replace(after, "");
Console::WriteLine("2nd regex : {0}", after2);
return 0;
}
Usare espressioni regolari per convalidare la formattazione dei dati
Nell'esempio di codice seguente viene illustrato l'uso di espressioni regolari per verificare la formattazione di una stringa. Nell'esempio di codice seguente la stringa deve contenere un numero di telefono valido. Nell'esempio di codice seguente viene usata la stringa "\d-\d{3}{3}-\d{4}" per indicare che ogni campo rappresenta un numero di telefono valido. "d" nella stringa indica una cifra e l'argomento dopo ogni "d" indica il numero di cifre che devono essere presenti. In questo caso, il numero deve essere separato da trattini.
Esempio
// regex_validate.cpp
// compile with: /clr
#using <System.dll>
using namespace System;
using namespace Text::RegularExpressions;
int main()
{
array<String^>^ number =
{
"123-456-7890",
"444-234-22450",
"690-203-6578",
"146-893-232",
"146-839-2322",
"4007-295-1111",
"407-295-1111",
"407-2-5555",
};
String^ regStr = "^\\d{3}-\\d{3}-\\d{4}$";
for ( int i = 0; i < number->Length; i++ )
{
Console::Write( "{0,14}", number[i] );
if ( Regex::IsMatch( number[i], regStr ) )
Console::WriteLine(" - valid");
else
Console::WriteLine(" - invalid");
}
return 0;
}
Sezioni correlate
Espressioni regolari di .NET Framework
Vedi anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per