Eexpresiones regulares (C++/CLI)
Muestra varias operaciones de cadena mediante clases de expresiones regulares en el .NET Framework.
En los temas siguientes se muestra el uso del espacio de nombres .NET Framework System.Text.RegularExpressions (y, en un caso, el método System.String.Split) para buscar, analizar y modificar cadenas.
Analizar cadenas mediante expresiones regulares
En el ejemplo de código siguiente se muestra el análisis de cadenas simple mediante la clase Regex en el espacio de nombres System.Text.RegularExpressions. Se crea una cadena que contiene varios tipos de descriptores de palabras. A continuación, la cadena se analiza mediante la clase Regex junto con la clase Match. Finalmente, se muestran todas las palabras de la frase independientemente.
Ejemplo
// 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;
}
Analizar cadenas mediante el método Split
En el ejemplo de código siguiente se muestra cómo usar el método System.String.Split para extraer cada palabra de una cadena. Se construye una cadena que contiene varios tipos de delineadores de palabras y, a continuación, se analiza mediante una llamada a Split con una lista de los delineadores. Finalmente, se muestran todas las palabras de la frase independientemente.
Ejemplo
// 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;
}
Usar expresiones regulares para la coincidencia simple
En el ejemplo de código siguiente se usan expresiones regulares para buscar coincidencias de subcadena exactas. El método IsMatch estático realiza la búsqueda, que toma dos cadenas como entrada. La primera es la cadena que se va a buscar y la segunda es el patrón que se va a buscar.
Ejemplo
// 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;
}
Usar expresiones regulares para extraer campos de datos
En el ejemplo de código siguiente se muestra el uso de expresiones regulares para extraer datos de una cadena con formato. En el ejemplo de código siguiente se usa la clase Regex para especificar un patrón que corresponde a una dirección de correo electrónico. Este patrón incluye identificadores de campo que se pueden usar para recuperar las partes de nombre de usuario y host de cada dirección de correo electrónico. La clase Match se usa para realizar la coincidencia de patrones real. Si la dirección de correo electrónico dada es válida, se extraen y se muestran los nombres de usuario y host.
Ejemplo
// 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;
}
Usar expresiones regulares para reorganizar datos
En el ejemplo de código siguiente se muestra cómo se .NET Framework compatibilidad con expresiones regulares para reorganizar o volver a formatear los datos. En el ejemplo de código siguiente se usan las clases Regex y Match para extraer los nombres y apellidos de una cadena y, a continuación, mostrar estos elementos de nombre en orden inverso.
La clase Regex se usa para construir una expresión regular que describe el formato actual de los datos. Se supone que los dos nombres están separados por una coma y pueden usar cualquier cantidad de espacio en blanco alrededor de la coma. A continuación, se usa el método Match para analizar cada cadena. Si se realiza correctamente, los nombres y apellidos se recuperan del objeto Match y se muestran.
Ejemplo
// 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;
}
Usar expresiones regulares para buscar y reemplazar
En el ejemplo de código siguiente se muestra cómo se puede usar la clase de expresión regular Regex para realizar búsquedas y reemplazos. Esto se hace con el método Replace. La versión usada toma dos cadenas como entrada: la cadena que se va a modificar y la cadena que se va a insertar en lugar de las secciones (si las hay) que coinciden con el patrón dado al objeto Regex.
Este código reemplaza todos los dígitos de una cadena por caracteres de subrayado (_) y, a continuación, los reemplaza por una cadena vacía, quitándolos de forma eficaz. El mismo efecto se puede lograr en un solo paso, pero aquí se usan dos pasos con fines de demostración.
Ejemplo
// 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;
}
Usar expresiones regulares para validar el formato de datos
En el ejemplo de código siguiente se muestra el uso de expresiones regulares para comprobar el formato de una cadena. En el ejemplo de código siguiente, la cadena debe contener un número de teléfono válido. En el ejemplo de código siguiente se usa la cadena "\d {3} -\d -\d" para indicar que cada campo {3} representa un número de teléfono {4} válido. La "d" de la cadena indica un dígito y el argumento después de cada "d" indica el número de dígitos que deben estar presentes. En este caso, el número debe estar separado por guiones.
Ejemplo
// 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;
}
Secciones relacionadas
Expresiones regulares de .NET Framework