Cadenas de texto y manipulación — parte 2

Expresiones regulares y patrones

Las expresiones regulares son herramientas utiles para realizar búsquedas y manipulaciones de texto basadas en patrones específicos. En PHP, las expresiones regulares permiten validar, buscar, reemplazar y dividir cadenas de forma eficiente.

PHP ofrece dos tipos de funciones para manejar expresiones regulares: las basadas en POSIX y las basadas en PCRE (Perl Compatible Regular Expressions). Actualmente, se recomienda utilizar las funciones PCRE, ya que son más utiles y flexibles.

Uso de funciones PCRE

Las funciones PCRE en PHP comienzan con el prefijo preg_. Entre las más utilizadas se encuentran:

• preg_match()
• preg_match_all()
• preg_replace()
• preg_split()

preg_match()

La función preg_match() se utiliza para buscar patrones en una cadena y determina si existe al menos una coincidencia. Retorna 1 si encuentra una coincidencia, 0 en caso contrario.

$patron = "/^A[0-9]+$/";
$cadena = "A12345";

if (preg_match($patron, $cadena)) {
    echo "La cadena coincide con el patrón.";
} else {
    echo "La cadena no coincide con el patrón.";
}
// Salida: La cadena coincide con el patrón.

En este ejemplo, el patrón ^A[0-9]+$ indica cadenas que comienzan con 'A' seguida de uno o más dígitos y nada más.

preg_match_all()

La función preg_match_all() busca todas las coincidencias del patrón en la cadena y puede almacenar los resultados en un array.

$patron = "/[a-z]+/";
$texto = "PHP es un lenguaje de scripting ampliamente utilizado.";

preg_match_all($patron, $texto, $coincidencias);
print_r($coincidencias[0]);
/*
Salida:
Array
(
    [0] => es
    [1] => un
    [2] => lenguaje
    [3] => de
    [4] => scripting
    [5] => ampliamente
    [6] => utilizado
)
*/

Aquí, el patrón [a-z]+ busca secuencias de letras minúsculas, y preg_match_all() recopila todas las coincidencias encontradas.

preg_replace()

La función preg_replace() permite buscar y reemplazar patrones en una cadena.

$patron = "/[0-9]/";
$reemplazo = "*";
$cadena = "Contraseña123";

$nuevaCadena = preg_replace($patron, $reemplazo, $cadena);
echo $nuevaCadena; // Salida: Contraseña***

En este caso, todos los dígitos en la cadena original son reemplazados por asteriscos.

preg_split()

Con preg_split(), es posible dividir una cadena utilizando un patrón como delimitador.

$patron = "/[\s,]+/";
$datos = "nombre, apellido   direccion ciudad";

$arrayDatos = preg_split($patron, $datos);
print_r($arrayDatos);
/*
Salida:
Array
(
    [0] => nombre
    [1] => apellido
    [2] => direccion
    [3] => ciudad
)
*/

El patrón [\s,]+ indica uno o más espacios en blanco o comas, funcionando como separadores.

Sintaxis de patrones en PCRE

Los patrones en expresiones regulares se delimitan con caracteres especiales como /, # o %. Es común utilizar / como delimitador:

$patron = "/expresion/";

Algunos metacaracteres y constructores comunes son:

• . cualquier carácter excepto salto de línea.
• ^ inicio de la cadena.
• $ fin de la cadena.
• * 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.
• [] definición de clases de caracteres.
• | alternación (OR).
• () agrupación y captura.

Por ejemplo, para validar un correo electrónico básico:

$correo = "usuario@dominio.com";
$patron = "/^[\w\-\.]+@([\w\-]+\.)+[a-zA-Z]{2,7}$/";

if (preg_match($patron, $correo)) {
    echo "El correo es válido.";
} else {
    echo "El correo no es válido.";
}
// Salida: El correo es válido.

En este patrón, se utilizan clases de caracteres y cuantificadores para definir la estructura de un correo electrónico.

Modificadores de patrones

Los patrones pueden incluir modificadores que alteran su comportamiento. Algunos modificadores comunes son:

• i realiza una búsqueda insensible a mayúsculas.
• m cambia el comportamiento de ^ y $ para trabajar en multilínea.
• s el punto . incluye también los saltos de línea.
• u activa el soporte Unicode.

Ejemplo con modificador i:

$patron = "/php/i";
$texto = "El lenguaje PHP es popular.";

if (preg_match($patron, $texto)) {
    echo "Se encontró 'php'.";
} else {
    echo "No se encontró 'php'.";
}
// Salida: Se encontró 'php'.

Aquí, aunque en el texto 'PHP' está en mayúsculas, el modificador i permite que la búsqueda sea insensible a mayúsculas.

Grupos de captura y referencias

Las expresiones regulares permiten capturar grupos de caracteres para usarlos posteriormente. Los paréntesis () se utilizan para definir grupos de captura.

$patron = "/(\d{4})-(\d{2})-(\d{2})/";
$fecha = "Fecha: 2024-05-15";

if (preg_match($patron, $fecha, $coincidencias)) {
    echo "Año: $coincidencias[1]"; // Salida: Año: 2024
    echo " Mes: $coincidencias[2]"; // Salida: Mes: 05
    echo " Día: $coincidencias[3]"; // Salida: Día: 15
}

En este ejemplo, se capturan el año, mes y día de una fecha con formato YYYY-MM-DD.

Es posible utilizar referencias de backtracking en preg_replace() para reordenar o manipular los grupos capturados.

$patron = "/(\w+)\s(\w+)/";
$texto = "Apellido Nombre";

$nuevoTexto = preg_replace($patron, "$2 $1", $texto);
echo $nuevoTexto; // Salida: Nombre Apellido

Aquí, los grupos capturados se referencian como $1, $2, etc., permitiendo reorganizar el texto.

Validación de datos con expresiones regulares

Las expresiones regulares son esenciales para validar entradas de usuario, como números de teléfono, códigos postales o contraseñas.

Ejemplo de validación de contraseña segura:

$contraseña = "Passw0rd!";
$patron = "/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)(?=.*[\W_]).{8,}$/";

if (preg_match($patron, $contraseña)) {
    echo "La contraseña es segura.";
} else {
    echo "La contraseña no cumple los requisitos.";
}
// Salida: La contraseña es segura.

El patrón verifica que la contraseña tenga al menos una mayúscula, una minúscula, un dígito, un carácter especial y un mínimo de 8 caracteres.

Manejo de errores

Es importante manejar posibles errores al trabajar con expresiones regulares. Si el patrón es inválido, las funciones preg_ retornarán false y generarán una advertencia. Se recomienda validar o depurar los patrones antes de su uso en producción.

Utilidades adicionales

Para probar y depurar expresiones regulares, existen herramientas en línea como regex101.com, que permiten escribir patrones y ver su funcionamiento en tiempo real.

Además, PHP ofrece la función preg_replace_callback(), que permite utilizar funciones de devolución de llamada para realizar reemplazos más complejos.

$texto = "El precio es 50 EUR.";

$nuevoTexto = preg_replace_callback(
    "/\d+/",
    function ($coincidencias) {
        return $coincidencias[0] * 1.2;
    },
    $texto
);

echo $nuevoTexto; // Salida: El precio es 60 EUR.

En este ejemplo, se incrementa el valor numérico en un 20% utilizando una función anónima como callback.

Con un manejo adecuado de las expresiones regulares y patrones, es posible realizar operaciones avanzadas de manipulación de cadenas en PHP, mejorando la eficiencia y la seguridad de las aplicaciones.

Interpolación de variables en cadenas

La interpolación de variables en cadenas es una característica de PHP que permite incluir variables directamente dentro de cadenas de texto. Esto facilita la construcción de mensajes y la generación de contenido dinámico sin necesidad de concatenar cadenas y variables manualmente.

En PHP, existen dos tipos principales de delimitadores para las cadenas: comillas simples (' ') y comillas dobles (" "). La interpolación de variables sólo es posible cuando se utilizan comillas dobles. Las comillas simples tratan el contenido como texto literal.

Por ejemplo, utilizando comillas dobles:

$nombre = "Carlos";
echo "Bienvenido, $nombre!"; // Salida: Bienvenido, Carlos!

En este caso, la variable $nombre se interpola dentro de la cadena, reemplazándose por su valor. Si se utilizan comillas simples, la variable no se interpolará:

$nombre = "Carlos";
echo 'Bienvenido, $nombre!'; // Salida: Bienvenido, $nombre!

Como se puede observar, con comillas simples, el signo dólar y el nombre de la variable se muestran tal cual, sin interpretarse.

Cuando se desea interpolar variables complejas o evitar ambigüedades, es recomendable utilizar llaves {} para delimitar la variable dentro de la cadena:

$fruta = "manzana";
echo "Me gusta comer {$fruta}s."; // Salida: Me gusta comer manzanas.

Sin las llaves, PHP podría interpretar erróneamente el nombre de la variable:

$fruta = "manzana";
echo "Me gusta comer $frutas."; // Salida: Me gusta comer .

En este ejemplo, PHP busca una variable llamada $frutas, que no existe, resultando en una salida vacía. Las llaves aclaran el límite de la variable.

La interpolación también funciona con elementos de arrays y propiedades de objetos. Para arrays asociativos:

$persona = ['nombre' => 'Ana', 'edad' => 28];
echo "Nombre: {$persona['nombre']}"; // Salida: Nombre: Ana

Es importante incluir las comillas simples alrededor de la clave del array y las llaves alrededor de toda la expresión.

Para arrays indexados:

$colores = ['rojo', 'verde', 'azul'];
echo "Color favorito: $colores[1]"; // Salida: Color favorito: verde

Con objetos, se puede interpolar directamente sus propiedades:

class Usuario {
    public $nombre;
}

$usuario = new Usuario();
$usuario->nombre = "Luis";
echo "Bienvenido, $usuario->nombre!"; // Salida: Bienvenido, Luis!

Si es necesario evaluar expresiones más complejas, se pueden utilizar llaves, pero es recomendable concatenar para mayor claridad:

$a = 5;
$b = 3;
echo "La suma es " . ($a + $b) . "."; // Salida: La suma es 8.

Sin embargo, para expresiones complejas, es preferible realizar el cálculo antes y luego interpolar la variable resultante:

$sum = $a + $b;
echo "La suma es $sum."; // Salida: La suma es 8.

Las cadenas con comillas dobles interpretan también ciertos caracteres especiales, o secuencias de escape, como \n para nueva línea o \t para tabulación:

echo "Línea 1\nLínea 2"; 
// Salida:
// Línea 1
// Línea 2

Con comillas simples, estas secuencias no se interpretan:

echo 'Línea 1\nLínea 2'; // Salida: Línea 1\nLínea 2

Si se necesita incluir caracteres especiales sin que sean interpretados, se utiliza la barra invertida \ para escapar:

$precio = 9.99;
echo "El precio es \$$precio."; // Salida: El precio es $9.99.

PHP ofrece también las sintaxis heredoc y nowdoc para cadenas multilínea. En el caso de heredoc, permite la interpolación de variables:

$nombre = "Elena";
$mensaje = <<<EOT
Hola, $nombre.
Bienvenida al sistema.
Gracias.
EOT;

echo $mensaje;

/* Salida:
Hola, Elena.
Bienvenida al sistema.
Gracias.
*/

La sintaxis nowdoc, similar a comillas simples, no interpreta variables ni secuencias de escape:

$mensaje = <<<'EOD'
Esto es un mensaje literal, $nombre.
No se interpretan variables ni \n secuencias.
EOD;

echo $mensaje;

/* Salida:
Esto es un mensaje literal, $nombre.
No se interpretan variables ni \n secuencias.
*/

La interpolación de variables mejora la legibilidad y mantenimiento del código, reduciendo la necesidad de concatenaciones repetitivas. Sin embargo, es importante tener en cuenta:

• Utilizar llaves cuando sea necesario para evitar confusiones en el intérprete de PHP.
• Controlar los datos interpolados para prevenir inyecciones o problemas de seguridad, especialmente si se manejan entradas de usuario.
• En construcciones complejas, considerar la concatenación o asignaciones previas para mantener el código claro.

A continuación, se presentan algunos ejemplos prácticos.

Generación de URLs dinámicas:

$id = 42;
echo "https://misitio.com/articulo.php?id=$id";
// Salida: https://misitio.com/articulo.php?id=42

Envío de correos electrónicos:

$destinatario = "contacto@dominio.com";
$asunto = "Consulta";
$mensaje = "Estimado equipo,\nMe gustaría obtener más información.";

$cabeceras = "From: usuario@correo.com";
mail($destinatario, $asunto, $mensaje, $cabeceras);

No es posible interpolar el resultado de funciones directamente dentro de cadenas. Por ejemplo:

echo "La fecha es {date('Y-m-d')}."; // No funciona como se espera

Para incluir el resultado de una función, se debe concatenar:

echo "La fecha es " . date('Y-m-d') . "."; // Salida: La fecha es 2024-06-15.

O asignar el resultado a una variable:

$fecha = date('Y-m-d');
echo "La fecha es $fecha."; // Salida: La fecha es 2024-06-15.

Al trabajar con cadenas que incluyen caracteres especiales o provenientes de diferentes codificaciones, es importante asegurarse de que la interpolación no genere errores. Utilizar siempre la codificación adecuada y funciones como htmlspecialchars() cuando se muestre contenido en HTML:

$usuario = "<script>alert('Hack');</script>";
echo "Usuario: " . htmlspecialchars($usuario, ENT_QUOTES, 'UTF-8');
// Salida: Usuario: &lt;script&gt;alert(&#039;Hack&#039;);&lt;/script&gt;

La interpolación de variables en cadenas es una funcionalidad esencial de PHP que simplifica la construcción de textos dinámicos. Aprovechar esta característica puede mejorar notablemente la eficiencia y legibilidad del código, siempre y cuando se utilice con cuidado y considerando las buenas prácticas de seguridad y mantenimiento.