Expressions régulières (C++/CLI)
Illustre différentes opérations de chaîne à l’aide de classes d’expressions régulières dans le .NET Framework.
Les rubriques suivantes illustrent l’utilisation de l’espace de noms .NET Framework System.Text.RegularExpressions (et, dans un cas, la System.String.Split méthode) pour rechercher, analyser et modifier des chaînes.
Analyser des chaînes à l’aide d’expressions régulières
L’exemple de code suivant illustre l’analyse de chaîne simple à l’aide de la Regex classe dans l’espace System.Text.RegularExpressions de noms. Une chaîne contenant plusieurs types de déligneurs de mots est construite. La chaîne est ensuite analysée à l’aide de la Regex classe conjointement avec la Match classe. Ensuite, chaque mot de la phrase s’affiche séparément.
Exemple
// 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;
}
Analyser des chaînes à l’aide de la méthode Split
L’exemple de code suivant illustre l’utilisation de la System.String.Split méthode pour extraire chaque mot d’une chaîne. Une chaîne contenant plusieurs types de déligneurs de mots est construite, puis analysée en appelant Split avec une liste des délimiteurs. Ensuite, chaque mot de la phrase s’affiche séparément.
Exemple
// 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;
}
Utiliser des expressions régulières pour la correspondance simple
L’exemple de code suivant utilise des expressions régulières pour rechercher des correspondances exactes de sous-chaîne. La recherche est effectuée par la méthode statique IsMatch , qui prend deux chaînes comme entrée. La première est la chaîne à rechercher, et la seconde est le modèle à rechercher.
Exemple
// 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;
}
Utiliser des expressions régulières pour extraire des champs de données
L’exemple de code suivant illustre l’utilisation d’expressions régulières pour extraire des données d’une chaîne mise en forme. L’exemple de code suivant utilise la Regex classe pour spécifier un modèle qui correspond à une adresse de messagerie. Ce patter inclut des identificateurs de champ qui peuvent être utilisés pour récupérer les parties utilisateur et nom d’hôte de chaque adresse e-mail. La Match classe est utilisée pour effectuer la correspondance réelle du modèle. Si l’adresse de messagerie donnée est valide, le nom d’utilisateur et les noms d’hôte sont extraits et affichés.
Exemple
// 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;
}
Utiliser des expressions régulières pour réorganiser les données
L’exemple de code suivant montre comment la prise en charge des expressions régulières .NET Framework peut être utilisée pour réorganiser ou reformater des données. L’exemple de code suivant utilise les classes et Match les classes pour extraire les Regex prénoms et les noms d’une chaîne, puis afficher ces éléments de nom dans l’ordre inverse.
La Regex classe est utilisée pour construire une expression régulière qui décrit le format actuel des données. Les deux noms sont supposés être séparés par une virgule et peuvent utiliser n’importe quelle quantité d’espace blanc autour de la virgule. La Match méthode est ensuite utilisée pour analyser chaque chaîne. En cas de réussite, les prénoms et les noms sont récupérés à partir de l’objet Match et affichés.
Exemple
// 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;
}
Utiliser des expressions régulières pour rechercher et remplacer
L’exemple de code suivant montre comment la classe Regex d’expression régulière peut être utilisée pour effectuer la recherche et le remplacement. Cette opération est effectuée avec la Replace méthode. La version utilisée prend deux chaînes comme entrée : la chaîne à modifier et la chaîne à insérer à la place des sections (le cas échéant) qui correspondent au modèle donné à l’objet Regex .
Ce code remplace tous les chiffres d’une chaîne par des traits de soulignement (_), puis les remplace par une chaîne vide, les supprimant efficacement. Le même effet peut être accompli en une seule étape, mais deux étapes sont utilisées ici à des fins de démonstration.
Exemple
// 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;
}
Utiliser des expressions régulières pour valider la mise en forme des données
L’exemple de code suivant illustre l’utilisation d’expressions régulières pour vérifier la mise en forme d’une chaîne. Dans l’exemple de code suivant, la chaîne doit contenir un numéro de téléphone valide. L’exemple de code suivant utilise la chaîne « \d{3}-\d-\d-d{3}{4} » pour indiquer que chaque champ représente un numéro de téléphone valide. Le « d » dans la chaîne indique un chiffre et l’argument après chaque « d » indique le nombre de chiffres qui doivent être présents. Dans ce cas, le nombre doit être séparé par des tirets.
Exemple
// 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;
}
Sections connexes
Expressions régulières du .NET Framework