Regex en C#: cómo utilizar expresiones regulares

En el día a día, siempre que es posible, buscamos establecer patrones que faciliten la comprensión y organización de la información, algo que hacemos naturalmente, después de todo, siempre estamos buscando formas de optimizar nuestra rutina.

Dentro del campo de la programación también existe esta preocupación por mejorar y optimizar la información, como se ve en los estándares de programación, estructuras de datos y algoritmos. Sin embargo, en la rutina de un programador, en algún momento te encontrarás con la necesidad de trabajar con cadenas de caracteres y buscar identificar patrones para extraer información o validar algún tipo de dato.

En este contexto, hoy tenemos las llamadas expresiones regulares, o el término abreviado en inglés, regex. Pero, ¿qué son? ¿Dónde viven? ¿De qué se alimentan? ¿Se pueden usar con .NET? En este artículo vamos a hablar un poco sobre ellas. ¡Vamos a la lectura!

¿Qué es una expresión regular?

Veamos algunas definiciones:

Según Alfredo Lotar, autor del libro "Cómo programar con ASP.NET y C#", una expresión regular define combinaciones de caracteres que podemos usar para representar partes de una cadena.

Y según Cláudio Ralha, autor del libro "Productividad con C#" de Casa do Código:

“Las expresiones regulares son herramientas para realizar tareas complejas con poco código, como localizar y eliminar varias ocurrencias de secuencias de caracteres dentro del texto, validar datos proporcionados por los usuarios que tienen un formato específico.”

Entonces, podemos concluir que una regex va a definir una forma de identificar patrones en cadenas de caracteres (strings) y que podemos usarla para validar datos.

Un poco de historia

La historia de las expresiones regulares está estrechamente ligada a la teoría de la computación, ya que forma parte de la teoría de autómatas y lenguajes formales. Las regex fueron desarrolladas en los estudios del matemático estadounidense Stephen Cole Kleene, quien inicialmente la llamó álgebra de conjuntos regulares.

Los trabajos de Kleene fueron la base para la creación de algoritmos de búsqueda utilizados en la informática. Hoy en día, aplicamos las regex en editores de texto, en funciones de búsqueda y reemplazo, y en lenguajes de programación como una forma de validar formatos de texto. Por ejemplo: cuando necesitamos validar el formato del campo de correo electrónico en un formulario, podemos usar: /^[a-z0-9.]+@[a-z0-9]+.[a-z]+.([a-z]+)?$/i;.

Entonces, en resumen, las regex se pueden aplicar en situaciones de:

• Mecanismos de validación de datos de formularios;
• Encontrar un texto específico en una cadena;
• Representación de patrones. Por ejemplo: los números de un DNI.

Bueno, ¿pero cómo funcionan las regex?

Cuando usamos regex, la búsqueda de caracteres, cadenas o patrones de texto se realiza de izquierda a derecha, de la misma manera en que leemos un texto (al menos según la lectura occidental). Esta búsqueda se puede realizar en una sola línea o en varias, además de poder diferenciar entre mayúsculas y minúsculas e incluso ignorar espacios en blanco.

Veamos un ejemplo de regex para validar un DNI:

/^[0-9]{3}.?[0-9]{3}.?[0-9]{3}-?[0-9]{2}/

En la definición de una regex podemos utilizar dos tipos de caracteres: los literales, que normalmente se usan en las cadenas, y los metacaracteres, que permiten a la regex procesar y manipular información. Hemos recopilado algunos metacaracteres en la siguiente tabla:

Además de estos, las regex también te permiten trabajar con agrupaciones, lo que puede ayudarnos a crear subexpresiones. Para definir grupos, podemos utilizar (). A continuación, enumeramos algunos ejemplos:

Vale la pena destacar que crear una sentencia regex utilizando los símbolos y metacaracteres disponibles puede ser bastante laborioso. Dividir una expresión en partes puede ser de gran ayuda, al mejor estilo de "dividir y conquistar".

Por ejemplo, si queremos seleccionar todas las letras y números de un texto, podemos escribir una expresión que elija los números [0-9], luego escribir la que seleccione las letras [a-zA-Z]. Finalmente, combinamos las partes de la expresión como [0-9][a-zA-Z].

Hasta aquí hemos visto que entre las ventajas de utilizar regex se encuentran la flexibilidad, el rendimiento y la facilidad de uso. Pero después de comprender la teoría, ¿cómo podemos utilizar regex con C#? Para esto, necesitamos utilizar una clase Regex, ¡y eso es lo que conoceremos en el próximo tema!

La clase Regex

En .NET, la clase principal para trabajar con regex tiene el mismo nombre, Regex, y se encuentra en el espacio de nombres System.Text.RegularExpressions. Esta clase cuenta con una serie de métodos estáticos que nos permiten trabajar con expresiones regulares. Por ejemplo, si queremos validar que el valor proporcionado por un usuario esté compuesto únicamente por números, podemos hacer lo siguiente:

using System.Text.RegularExpressions; 

Console.Write("Introduzca un valor: "); 
var caracteres = Console.ReadLine(); 

bool ok = Regex.IsMatch(caracteres, "^[0-9]+$"); 
if (!ok) 
{ 
    Console.WriteLine("El valor indicado no es un número válido.");
} 
else 
{ 
    Console.WriteLine("El valor informado es válido.");
}

Al ejecutar el código anterior e ingresar 14589AC, obtenemos como salida lo que se muestra en la siguiente imagen:

También podemos crear un objeto del tipo Regex que reciba en su constructor un carácter o una expresión compuesta por metacaracteres. También es posible proporcionar un segundo parámetro para definir cómo realizar la búsqueda.

Imagina que necesitas validar el número de identificación de una persona, en este caso vamos a usar DNI. En lugar de crear todo un algoritmo, ¿por qué no usar una regex? Observa cómo podría implementarse:

Console.Write("Introduzca un DNI para la validación: ");
var dni = Console.ReadLine(); 

Regex regex = new Regex(@"([0-9]{4}[-]?[0-9]{2})|([0-9]{3}[\.]?[0-9]{3}[\.]?[0-9]{3}[-]?[0-9]{2})",RegexOptions.IgnoreCase); 
var haCombinado = regex.Match(dni); 
if (combinou.Success) 
{ 
    Console.WriteLine("DNI en formato válido.");
} 
else 
{ 
    Console.WriteLine("DNI inválido.");
}

Al ejecutar el código anterior, el usuario ingresa un número de identificación personal (en este caso, DNI) que contiene solo números o que tiene una máscara con puntos. Se crea un objeto de la clase Regex que recibe como parámetros una expresión para el DNI y una enumeración con el valor IgnoreCase, que diferencia entre mayúsculas y minúsculas.

Al ejecutar el método .Match() del objeto, validamos el DNI con la expresión regular definida en la creación del objeto. Para esto, es importante manejar el resultado creando un objeto del tipo Match.

Si queremos validar, por ejemplo, 000.869.630-66, al ejecutarlo obtendremos la siguiente salida en la terminal:

Pero, ¿y si el DNI a validar no tiene la máscara de DNI? Por ejemplo, 99156503024. ¿Qué sucede?

A continuación, presentamos algunas opciones de la enumeración RegexOptions que podemos usar para crear nuestros objetos de expresiones regulares:

Usando .IsMatch()

Con .IsMatch() podemos validar si un valor dado coincide con la expresión regular definida. El método devuelve un valor booleano y recibe una cadena como parámetro. Usando el mismo ejemplo del DNI:

Console.Write("Introduzca un dni para validación: "); 
var dni = Console.ReadLine(); 
Regex regex = new Regex(@"([0-9]{4}[-]?[0-9]{2})|([0-9]{3}[\.]?[0-9]{3}[\.]?[0-9]{3}[-]?[0-9]{2})", RegexOptions.IgnorePatternWhitespace); 
if (regex.IsMatch(dni))
{ 
    Console.WriteLine("DNI válido."); 
} 
else 
{ 
    Console.WriteLine("DNI inválido.");
}

Usando o .Match()

Este método puede ser usado para buscar una cadena o expresión regex definida en la clase. Por ejemplo:

var busqueda = "Sumergirse en tecnología con Alura."; 
Regex regex = new Regex("Alura",RegexOptions.IgnoreCase); 
Match match = regex.Match(busca); 
if (match.Success)
{ 
    Console.WriteLine("string encontrada en el texto.");
} 
else 
{ 
    Console.WriteLine("string no encontrada.");
}

A través de estos ejemplos, ¡podemos ver el poder que tenemos al utilizar expresiones regulares! Y en .NET, ¡usar la clase Regex lo hace aún más fácil!

Conclusión

En este artículo, nuestro objetivo fue presentar qué son las expresiones regulares, desde su definición hasta su aplicabilidad en la programación. Entendemos que aplicar expresiones regulares para crear expresiones que validen el formato de caracteres, lo que permite buscar contenido específico, puede ser una herramienta valiosa para los desarrolladores, independientemente del lenguaje.

Los diferentes lenguajes tienen sus propias bibliotecas para trabajar con este recurso, ¡y en .NET no es diferente! Por eso conocimos la clase Regex, que encapsula funcionalidades que permiten trabajar con expresiones regulares en el código de C#.

También observamos que, a pesar de la facilidad que ofrece la plataforma a la hora de utilizar expresiones regulares, escribirlas puede ser un desafío, ya que debemos resumir gran parte de la información en una sola expresión.

Para obtener más información sobre expresiones regulares, también puedes ver:

• JavaScript replace: manipulando Strings y regex
• Regex en Java: Validando datos con expresiones regulares
• Documentación Regex Clase
• Curso Regex: Expresiones regulares

André Bessa

Soy programador e instructor de programación usando C# y .NET. Licenciado en Sistemas de Información. Ya he programado usando Java, PHP, C#, PostgreSQL y MySQL, además de haber trabajado con soporte también. Siempre buscando aprender más sobre tecnologías, sus aficiones son los cómics y las series.

Este artículo fue traducido para Alura Latam por Brenda Souza