Regulární výrazy (C++/CLI)
Demonstruje různé řetězcové operace pomocí tříd regulárních výrazů v rozhraní .NET Framework.
Následující témata ukazují použití oboru názvů rozhraní .NET Framework System.Text.RegularExpressions (a v jednom případě System.String.Split metody) k vyhledávání, analýze a úpravě řetězců.
Analýza řetězců pomocí regulárních výrazů
Následující příklad kódu ukazuje jednoduchou analýzu řetězců pomocí Regex třídy v System.Text.RegularExpressions oboru názvů. Řetězec obsahující více typů slov delineátorů je vytvořen. Řetězec se pak analyzuje pomocí Regex třídy ve spojení s Match třídou. Potom se každé slovo ve větě zobrazí samostatně.
Příklad
// 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;
}
Parsování řetězců pomocí metody Split
Následující příklad kódu ukazuje použití System.String.Split metody k extrahování každého slova z řetězce. Řetězec obsahující více typů delineátorů slova se vytvoří a pak parsuje voláním Split se seznamem delineátorů. Potom se každé slovo ve větě zobrazí samostatně.
Příklad
// 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;
}
Použití regulárních výrazů pro jednoduché porovnávání
Následující příklad kódu používá regulární výrazy k vyhledání přesných shod podřetěžců. Vyhledávání provádí statická IsMatch metoda, která jako vstup přebírá dva řetězce. První je řetězec, který se má prohledávat, a druhý je vzor, který se má vyhledat.
Příklad
// 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;
}
Extrakce datových polí pomocí regulárních výrazů
Následující příklad kódu ukazuje použití regulárních výrazů k extrakci dat z formátovaného řetězce. Následující příklad kódu používá Regex třídu k určení vzoru, který odpovídá e-mailové adrese. Tento patter obsahuje identifikátory polí, které lze použít k načtení částí uživatelského jména a názvu hostitele každé e-mailové adresy. Třída Match se používá k provedení skutečné porovnávání vzorů. Pokud je daná e-mailová adresa platná, uživatelské jméno a názvy hostitelů se extrahují a zobrazí.
Příklad
// 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;
}
Změna uspořádání dat pomocí regulárních výrazů
Následující příklad kódu ukazuje, jak lze podporu regulárních výrazů rozhraní .NET Framework použít ke změně uspořádání nebo přeformátování dat. Následující příklad kódu používá Regex a Match třídy k extrakci křestní jména a příjmení z řetězce a následné zobrazení těchto prvků názvů v obráceném pořadí.
Třída Regex se používá k vytvoření regulárního výrazu, který popisuje aktuální formát dat. U těchto dvou názvů se předpokládá, že jsou oddělené čárkou a mohou kolem čárky používat libovolné prázdné znaky. Metoda Match se pak použije k analýze jednotlivých řetězců. V případě úspěchu se z objektu Match načtou křestní jména a příjmení a zobrazí se.
Příklad
// 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;
}
Použití regulárních výrazů k hledání a nahrazení
Následující příklad kódu ukazuje, jak lze třídu regulárních výrazů Regex použít k provádění vyhledávání a nahrazení. To se provádí metodou Replace . Použitá verze má jako vstup dva řetězce: řetězec, který se má upravit, a řetězec, který se má vložit místo oddílů (pokud existuje), které odpovídají vzoru zadanému objektu Regex .
Tento kód nahradí všechny číslice v řetězci podtržítky (_) a nahradí je prázdným řetězcem a efektivně je odebere. Stejný účinek lze provést v jednom kroku, ale dva kroky se zde používají pro demonstrační účely.
Příklad
// 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;
}
Ověření formátování dat pomocí regulárních výrazů
Následující příklad kódu ukazuje použití regulárních výrazů k ověření formátování řetězce. V následujícím příkladu kódu by řetězec měl obsahovat platné telefonní číslo. Následující příklad kódu používá řetězec "\d{3}-\d{3}-\d{4}", který označuje, že každé pole představuje platné telefonní číslo. "d" v řetězci označuje číslici a argument za každým znakem "d" označuje počet číslic, které musí být přítomny. V tomto případě je nutné číslo oddělit pomlčkami.
Příklad
// 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;
}
Související oddíly
Regulární výrazy rozhraní .NET Framework
Viz také
Váš názor
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu: https://aka.ms/ContentUserFeedback.
Odeslat a zobrazit názory pro