Eexpresiones regulares (C++/CLI)
Muestra varias operaciones de cadena usando clases de expresiones regulares en .NET Framework.
En los temas siguientes, se muestra el uso del espacio de nombres System.Text.RegularExpressions de .NET Framework (y en un caso el método System.String.Split) para buscar, analizar y modificar cadenas.
Uso de expresiones regulares para el análisis de cadenas
En el siguiente ejemplo de código se muestra el análisis de una cadena sencilla mediante la clase Regex del espacio de nombres System.Text.RegularExpressions. Se crea una cadena que contiene varios tipos de descriptores de palabras. A continuación, se analiza la cadena mediante las clases Regex y 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;
}
Uso del método Split para el análisis de cadenas
En el ejemplo de código siguiente se muestra cómo utilizar el método System.String.Split para extraer todas las palabras de una cadena. Se construye una cadena que contiene varios tipos de perfiladores de palabras y, a continuación, se analiza llamando a Split con una lista de los perfiladores. 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;
}
Uso de expresiones regulares para la búsqueda de coincidencias simples
En el ejemplo de código siguiente, se usan expresiones regulares para buscar coincidencias de subcadena exactas. La búsqueda se realiza con el método estático IsMatch, que toma dos cadenas como entrada. La primera es la cadena donde se busca y la segunda es el patrón que se busca.
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;
}
Uso de 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 utiliza 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 del nombre de host y usuario de cada dirección de correo electrónico. La clase Match se usa para la búsqueda de coincidencia del patrón. Si la dirección de correo electrónico especificada es válida, se extraen y se muestran los nombres de usuario y de 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;
}
Uso de expresiones regulares para reorganizar datos
En el ejemplo de código siguiente, se muestra cómo se puede usar la compatibilidad de .NET Framework 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 el nombre y el apellido de una cadena y mostrarlos en el 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. Después, se usa el método Match para analizar cada cadena. Si se ejecuta correctamente, se recuperan el nombre y el apellido 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;
}
Uso de expresiones regulares para buscar y reemplazar elementos
En el ejemplo de código siguiente, se muestra cómo se puede usar la clase Regex de expresión regular para buscar y reemplazar elementos. Para esto se utiliza 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 el lugar de las secciones (si las hay) que coinciden con el patrón que se proporciona 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, lo que los quita totalmente. El mismo efecto se puede realizar en un solo paso, pero aquí se usan dos pasos como 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;
}
Uso de expresiones regulares para validar el formato de los 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{3}-\d{4}" para indicar que cada campo representa un número de teléfono válido. La "d" de la cadena indica un dígito y el argumento que aparece 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
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de