Las expresiones regulares, conocidas comúnmente como regex, son patrones que describen conjuntos de cadenas de texto. En Delphi, las expresiones regulares son una herramienta poderosa para validar, buscar, extraer y manipular texto de manera eficiente.
A partir de Delphi XE, se introdujo la clase TRegEx
en la unidad System.RegularExpressions
, proporcionando soporte nativo para trabajar con expresiones regulares utilizando el motor PCRE (Perl-Compatible Regular Expressions).
Las expresiones regulares utilizan una serie de metacaracteres para definir patrones de búsqueda. Algunos de los más utilizados incluyen:
. # Cualquier carácter excepto nueva línea
\d # Dígitos [0-9]
\w # Caracteres de palabra [a-zA-Z0-9_]
\s # Espacios en blanco
^ # Inicio de línea
$ # Fin de línea
* # Cero o más repeticiones
+ # Una o más repeticiones
? # Cero o una repetición
{n} # Exactamente n repeticiones
{n,} # Al menos n repeticiones
{n,m} # Entre n y m repeticiones
| # Alternativa (OR)
() # Agrupación
[] # Conjunto de caracteres
\ # Escapar caracteres especiales
Delphi permite utilizar varios modificadores para ajustar la búsqueda de patrones, tales como:
roIgnoreCase
: Realiza una búsqueda sin distinguir entre mayúsculas y minúsculas.roMultiLine
: Trata el texto como varias líneas, afectando los comportamientos de ^ y $.roSingleLine
: Hace que el metacarácter . incluya caracteres de nueva línea.Uno de los usos más frecuentes de las expresiones regulares es la validación de entradas de usuario. Esto incluye:
Las expresiones regulares permiten buscar y extraer información específica dentro de textos:
Las expresiones regulares facilitan la manipulación de texto mediante reemplazos estructurados:
Ventajas | Desventajas |
---|---|
|
|
Este ejemplo muestra cómo validar si una cadena es un correo electrónico válido utilizando la clase TRegEx
:
uses
System.RegularExpressions;
function ValidarEmail(const Email: string): Boolean;
begin
Result := TRegEx.IsMatch(Email, '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$');
end;
Este ejemplo ilustra cómo extraer todas las URLs presentes en una cadena de texto:
uses
System.RegularExpressions, System.SysUtils;
procedure ExtraerURLs(const Texto: string);
var
Matches: TMatchCollection;
Match: TMatch;
begin
Matches := TRegEx.Matches(Texto, 'https?://[^\s]+');
for Match in Matches do
begin
Writeln(Match.Value);
end;
end;
Reemplaza múltiples espacios en blanco con un solo espacio:
uses
System.RegularExpressions;
function ReemplazarEspacios(const Texto: string): string;
begin
Result := TRegEx.Replace(Texto, '\s+', ' ');
end;
Valida si una cadena corresponde a un formato de número de teléfono específico:
uses
System.RegularExpressions;
function ValidarTelefono(const Telefono: string): Boolean;
begin
Result := TRegEx.IsMatch(Telefono, '^\+?\d{1,3}?[-.\s]?\(?\d{1,4}?\)?[-.\s]?\d{1,4}[-.\s]?\d{1,9}$');
end;
Divide una línea CSV en sus componentes individuales:
uses
System.RegularExpressions, System.SysUtils;
procedure DividirCSV(const Linea: string);
var
Columnas: TArray<string>;
Columna: string;
begin
Columnas := TRegEx.Split(Linea, ',\s*');
for Columna in Columnas do
Writeln(Columna);
end;
Encuentra todos los números en un texto y reemplázalos con un carácter específico:
uses
System.RegularExpressions;
function ReemplazarNumeros(const Texto: string): string;
begin
Result := TRegEx.Replace(Texto, '\d+', '#');
end;
Evita crear patrones extremadamente complejos. En su lugar, divide las expresiones regulares largas en subpatrones más manejables y fáciles de entender.
Emplea herramientas en línea como regex101.com para probar y depurar tus patrones antes de integrarlos en tu código Delphi.
Incluye comentarios explicativos sobre lo que hace cada expresión regular. Esto facilita la comprensión y el mantenimiento del código, tanto para ti como para otros desarrolladores.
Evita patrones que puedan causar un impacto negativo en el rendimiento, especialmente cuando se procesan textos grandes. Asegúrate de que tus expresiones regulares sean lo más eficientes posible.
Implementa manejadores de excepciones para capturar y gestionar errores que puedan surgir al trabajar con expresiones regulares, como patrones inválidos o fallos en la coincidencia.
Define patrones reutilizables como constantes o funciones para evitar la duplicación de código y facilitar modificaciones futuras.
Aunque Delphi a partir de la versión XE incluye soporte nativo para expresiones regulares, existen varias bibliotecas de terceros que ofrecen funcionalidades adicionales:
Biblioteca | Descripción | Ventajas | Desventajas |
---|---|---|---|
TPerlRegEx | Una de las primeras bibliotecas de regex para Delphi, basada en PCRE. | Ampliamente utilizada, buena documentación. | Menos mantenida en versiones recientes de Delphi. |
TRegEx | Clase nativa incluida desde Delphi XE, basada en PCRE. | Integración nativa, alto rendimiento, soporte oficial. | Menos funcionalidades avanzadas comparado con bibliotecas especializadas. |
RegularExpressions | Unidad estándar en Delphi para manejar expresiones regulares. | Fácil de usar, bien integrada en el entorno Delphi. | Puede carecer de algunas características avanzadas presentes en otras bibliotecas. |
Para utilizar las expresiones regulares en Delphi, es necesario importar la unidad correspondiente:
uses
System.RegularExpressions;
La clase TRegEx
ofrece varios métodos que facilitan el trabajo con expresiones regulares:
Verifica si una cadena coincide con el patrón especificado.
var
Matched: Boolean;
begin
Matched := TRegEx.IsMatch('Hola Mundo', '^Hola.*');
if Matched then
ShowMessage('Existe coincidencia');
end;
Obtiene la primera coincidencia del patrón en una cadena.
var
Match: TMatch;
begin
Match := TRegEx.Match('Correo: user@email.com', '\S+@\S+\.\S+');
if Match.Success then
ShowMessage('Correo detectado: ' + Match.Value);
end;
Retorna todas las coincidencias del patrón en una cadena.
var
Matches: TMatchCollection;
Match: TMatch;
begin
Matches := TRegEx.Matches('Visita https://www.example.com y http://www.test.com', 'https?://[^\s]+');
for Match in Matches do
ShowMessage('URL encontrada: ' + Match.Value);
end;
Reemplaza todas las ocurrencias que coinciden con el patrón por un texto especificado.
var
NuevoTexto: string;
begin
NuevoTexto := TRegEx.Replace('Delphi es genial', 'genial', 'increíble');
ShowMessage(NuevoTexto); // "Delphi es increíble"
end;
Divide una cadena en partes según el patrón especificado.
var
Partes: TArray<string>;
i: Integer;
begin
Partes := TRegEx.Split('Uno, Dos, Tres', ',\s*');
for i := 0 to High(Partes) do
ShowMessage(Partes[i]);
end;
Antes de implementar una expresión regular en tu código, prueba y optimiza el patrón utilizando herramientas específicas como regex101.com. Esto te ayudará a identificar posibles mejoras en términos de rendimiento y precisión.
Escribe expresiones regulares claras y bien comentadas. Evita patrones excesivamente complicados que puedan dificultar la comprensión y el mantenimiento del código.
Define patrones comunes como constantes o funciones reutilizables para evitar duplicar código y facilitar futuras modificaciones. Por ejemplo:
const
EmailPattern = '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$';
function EsEmailValido(const Email: string): Boolean;
begin
Result := TRegEx.IsMatch(Email, EmailPattern);
end;
Implementa manejo de excepciones para capturar y gestionar posibles errores al usar expresiones regulares, como patrones inválidos o coincidencias fallidas:
uses
System.RegularExpressions, System.SysUtils;
procedure ValidarPatron(const Texto, Patron: string);
begin
try
if TRegEx.IsMatch(Texto, Patron) then
ShowMessage('Coincidencia encontrada')
else
ShowMessage('No se encontró ninguna coincidencia');
except
on E: ERegularExpression do
ShowMessage('Error en la expresión regular: ' + E.Message);
end;
end;
Evita usar expresiones regulares innecesariamente en bucles o sobre textos muy grandes sin optimizar los patrones, ya que puede afectar el rendimiento de tu aplicación.
Herramienta | Descripción | Características | Enlace |
---|---|---|---|
RegexBuddy | Herramienta avanzada para crear y probar expresiones regulares. | Interfaz gráfica, documentación, compatibilidad con múltiples lenguajes. | Visitar RegexBuddy |
regex101.com | Plataforma en línea para probar y entender expresiones regulares. | Soporte para diferentes motores de regex, explicación detallada de patrones. | Visitar regex101.com |
Delphi IDE | Entorno de desarrollo integrado para Delphi con soporte para expresión regulares. | Depurador integrado, resaltado de sintaxis, asistencia de código. | Visitar Delphi IDE |
Las expresiones regulares son una herramienta indispensable para cualquier desarrollador que trabaja con procesamiento de texto en Delphi. Su capacidad para validar, buscar, extraer y manipular texto de manera eficiente las convierte en una herramienta poderosa que puede mejorar significativamente la calidad y rendimiento de tus aplicaciones.
Sin embargo, es fundamental utilizarlas con cuidado, siguiendo buenas prácticas que aseguren la legibilidad y mantenibilidad del código. Aprovechar las bibliotecas y herramientas disponibles, así como la funcionalidad nativa de Delphi, te permitirá integrar expresiones regulares de manera efectiva en tus proyectos.
Investiga, practica y experimenta con diferentes patrones y casos de uso para dominar el arte de las expresiones regulares en Delphi. Con el conocimiento adecuado, podrás resolver problemas complejos de procesamiento de texto de manera rápida y eficiente.