Sintaxis PHP con funciones de reemplazo (parte 4) preg_replace(), preg_match_all(), preg_grep() y preg_quote().

Funciones ya revisadas

En la sección anterior revisamos las funciones strpos(), strrpos(), strstr(), strrchr(), strspn(), parse_url(), junto con algunas formas de expresiones regulares. Sin embargo será necesario aclarar el concepto de escape, muy usado en lenguajes como Javascript y PHP.

Ahora revisaremos funciones PHP de búsqueda y reemplazo de caracteres (y de escape de caracteres) según una cadena de texto ya dados.

Función preg_replace()

Según Tatroe y MacIntyre (2020) esta función busca y reemplaza caracteres, similar a un editor de texto. Es decir "halla la presencia (ocurrencia) de un patrón de caracteres y recambia esos caracteres con algún otro ya indicado" en la sintaxis.

Llamaremos ocurrencia (occurrence en inglés) a la presencia de uno o más conjuntos de caracteres en un conjunto de ellos. Por ejemplo, la ocurrencia de la letra 'e' en la palabra 'ejemplo' es de dos (dos veces aparece la letra 'e' en esa palabra).

En .PHP

<?php 

    $frase1 = "Hola mundo cruel";
    // Buscar 'cruel' y cambiarlo por 'hermoso'
    $nuevo = preg_replace("/cruel/", "hermoso", $frase1);
    echo "$nuevo\n";
    // Resultado: Hola mundo hermoso

    // +++

    // Reemplazar más de una posible ocurrencia
    $frase2 = "La casa es blanca";
    // Buscar 3 posibles ocurrencias y cambiarlas por 'azul'
    $nueva2 = preg_replace("/blanca|roja|verde/", "azul", $frase2);
    echo "$nueva2\n";
    // Resultado: La casa es azul

?>

<?php 

// ##
// ## OJO: Solo las comillas dobles 
// ## interpretan la sintaxis de escape
// ##

// A más caracteres \n más saltos de línea hacia abajo
echo "Ejemplo de salto de línea:\n";
echo "Línea uno\nLínea dos\n\n";
/* 
Línea uno
Línea dos
*/

// A más caracteres \t más tabs de espacio
echo "Ejemplo de tabulación:\n";
echo "Nombre\t\tEdad\n";
echo "Carlos\t\t30\n";
/*
Dudu      30
Adrian    25
*/

echo "Ejemplo de comillas escapadas:\n";
echo "Dijo: \"Hola mundo\"\n";
echo 'It\'s a good day' . "\n\n";
/* 
Dijo: "Hola mundo"
It's a good day
*/

echo "Ejemplo de barra invertida:\n";
echo "Ruta: C:\\xampp\\htdocs\\dudu\n";
// Ruta: C:\xampp\htdocs\dudu

// +++

// Y mediante uso de variables
$nombre = 'Guayaquil';
$apellido = 'Ecuador';
echo "$nombre\n$apellido"; 
// Guayaquil
// Ecuador

/* OJO: con comillas simples 
los caracteres de escape serán interpretados como 
un caracter simple. */ 

?>

En otro ejemplo, se captura un grupo de caracteres (uno o más letras) y luego se las muestra:

En .PHP

<?php 
    $nombresYapellidos = array(
        'Pedro Martínez', 
        'Ana Ramírez', 
        'Carlos Gómez');

    $ejemplo = preg_replace('/(\w)\w* (\w+)/', '\1 \2', $nombresYapellidos);
    print_r($ejemplo);

    /*
    Array
    (
        [0] => P Martínez
        [1] => A Ramírez
        [2] => C Gómez
    )
    */
?>

La explicación de la función preg_replace() y sus argumentos:

• (\w) Captura la primera letra de la primera palabra del arreglo ya dado. Es decir, capturó P, L y C
• \w* → Reconoce (detecta la presencia) de caracteres después de la primera letra capturada. En otras palabras, \w* reconoce que existe algo; y detectó 'edro', 'ucía' y 'arlos' pero NO los guarda.
• (\w+) → Captura todo el apellido (los paréntesis definen un grupo de captura). Capturó Martínez, Ramírez y Gómez
• \1 hace referencia al primer grupo de captura, es decir, la primera letra de la primera palabra (por ejemplo, "P", "A", "C"). O sea, \1 es la primera letra de cada nombre.
• \2 es el grupo de captura; es decir, "Martínez", "Ramírez", "Gómez").
• Finalmente, se muestra el primer grupo de captura junto con el segundo grupo.

Funciones compatibles con expresiones regulares

Para Kevin Tatroe and Peter MacIntyre (2020) las siguientes funciones hallan "coincidencia, activan reemplazo, división, filtrado; además de una función de utilidad para citar texto".

Función preg_match()

A partir de un uno o más caracteres contenidos en una expresión regular, esta función halla la primera coincidencia y envía 1. Si no halla la coincidencia envia 0. Es decir, esta función extrae fragmentos de caracteres cuando indicamos qué fragmentos son.

Los argumentos de la función preg_match() serán clave, pues cada uno (y en estricto orden!) representa lo siguiente: un contenido; el o los datos a hallar; y el arreglo contenedor de esos datos hallados. Ya que la función envía true (1, si halla) o false (0, si no halla) será útil usar una condicional if para evaluar el resultado. Esto es, se dará el índice [0] luego del argumento (de la función). Recordemos que ese argumento representa un arreglo-contenedor del dato hallado.

En .PHP

<?php 

// Contenido
$DesdeAqui = "Hola Guayaquil de mis amores";

// Dato a hallar
$hallarEsto = "/mundo/";

// Dato a hallar
$hallarEstoOtro = "/aquil/";

// Dato a hallar
$hallarEstoOtro_Pilas = "/de mis amores/";

// Orden obligatorio de los argumentos
if (preg_match($hallarEsto, $DesdeAqui, $guardarAqui)) {

    // Ojo con arreglo e índice donde se guarda dato hallado
    echo "Coincidencia encontrada: " . $guardarAqui[0];

} else {
    echo "No hay coincidencia.";
}

// Respuesta: No hay coincidencia.

// ---

/* OJO como en esta nueva búsqueda 
solo hemos agregado el nuevo dato a hallar */
if (preg_match($hallarEstoOtro, $DesdeAqui, $guardarAqui)) {

    // Ojo con arreglo e índice donde se guarda dato hallado
    echo "Coincidencia encontrada: " . $guardarAqui[0];

} else {
    echo "No hay coincidencia.";
}

// Respuesta: Coincidencia encontrada: aquil
 

?>

¿Por qué el último argumento aloja siempre en el índice [0]?

Cuando existe un solo hallazgo, entonces será un solo índice. Si existieran más hallazgos, habrán más índices para guardar. Recordemos que ese último argumento de la función preg_match() es un arreglo. Los arreglos son tipos de datos que alojan un valor en un casillero digital de memoria, tal cual un cajón de mesa. A diferencia de los datos tipo objeto, los valores del arreglo están enumerados del cero en adelante.

Por ejemplo, si se desear capturar por separado cada hallazgo:

En .PHP

<?php 

    // String base
$texto = "hola guayaquileños como estan";

// Se indican dos grupos de hallazgos
$hallarEsto = "/(como) (estan)/"; 

// función de hallazgo
// Recordar que el último argumento aloja en dato arreglo
preg_match($hallarEsto, $texto, $guardarAqui);

/*
Muestra todo el arreglo: 
la coindidencia completa y las independientes
*/
print_r($guardarAqui);
/*
    Array
    (
        [0] => como estan
        [1] => como
        [2] => estan
    )
*/

// Mostrar indice cero
echo $guardarAqui[0]; 
// como estan

// Mostrar indice 1
echo $guardarAqui[1]; 
// hola

// Mostrar indice 2
echo $guardarAqui[2]; 
// amigos

?>

Agrupamiento de hallazgos según exacto antecedente de caracteres

Dentro de la sintaxis de expresión regular (o de búsqueda de patrones) el metacaracter (\w+) es clave. En la forma:

En .PHP

// Ojo cómo ambas líneas de caracter inician EXACTAS
$enEsteTexto = "Eres perla que surgiste...";
$buscarEsto = "/Eres perla que (\w+) (\w+)/";


// ESTO DARIA ERROR PORQUE INICIA CON MINÚSCULA
// $buscarEsto = "/eres perla que (\w+) (\w+)/";

La última línea indica que "por cada metacaracter (\w+) captura cada palabra que sigue a: Eres perla". Cuidado: ambos pedidos de coincidencia deben ser EXACTOS!. Es decir, la función preg_match() no admite cambios entre mayúsculas y minúsculas. En otras palabras, es case sensitivity.

Por lo tanto, para acceder a una coincidencia con antecedente exacto de caracteres mediante el metacaracter (\w+) sería:

En .PHP

// OJO OJO OJO
// Si ambas líneas no tienen IGUALES caracteres
// O tienen minúsculas o mayúsculas de forma diferente
// La activación no ocurrirá!
$texto = "Soy guayaco buena onda";

//  Cada (\w+) -> Captura una palabra luego de 'Soy guayaco'
$patron = "/Soy guayaco (\w+) (\w+)/";
preg_match($patron, $texto, $resultado);

print_r($resultado);
/*
Array
(
    [0] => Soy guayaco buena onda
    [1] => buena
    [2] => onda
)
*/

echo $resultado[0];
// Soy guayaco buena onda

echo $resultado[1];
// onda

echo $resultado[2];
// buena

Finalmente, ¿cómo activar coincidencias cuando las líneas de caracter no sean idénticas en mayúsculas o minúsculas?. Se agrega el operador i (insensitive) al final de la expresión regular.

En .PHP

$texto = "aaa bbb ccc ddd";

// Indicamos diferencia de caracteres mayúsculas y minúsculas
$patron = "/AAA bBb (\w+) (\w+)/i";

// Indicamos coincidencias y alojamiento
preg_match($patron, $texto, $resultado);

// Ojo con el uso del separador \n -new line-
echo $resultado[0] . "\n";
// aaa bbb ccc ddd 

echo $resultado[1] . "\n";
// ccc

echo $resultado[2] . "\n";
// ddd

Hallar más de una coincidencia en un conjunto de caracteres dados con preg_match_all()

En el ejemplo de abajo la expresión regular dada indica lo siguiente:

• "/ /" Contenedor de sintaxis de expresión regular
• \b Indica un punto invisible donde cambia un carácter, pero NO es un caracter, sino un espacio o un salto de línea.
• [A-Z] Indica Alguna de las letras mayúsculas entre A-Z
• \w+ Uno o más caracteres alfa-numéricos o de guion bajo (a-z, A-Z, 0-9, _).

En .PHP

<?php 

// Texto base
$texto = "Carlos salió con Juan y Pedro.";

// Ex. Regular del patrón de coincidencias
$hallarEsto = "/\b[A-Z]\w+/";

// Función para hallar y alojar coincidencias
preg_match_all($hallarEsto, $texto, $alojarAqui);

// Mostrar el contenido del arreglo
print_r($alojarAqui);
/*
(
    [0] => Array
        (
            [0] => Carlos
            [1] => Juan
            [2] => Pedro
        )
)
*/

echo $alojarAqui[0][0] . "\n";
// Carlos

echo $alojarAqui[0][1] . "\n";
// Juan

echo $alojarAqui[0][2] . "\n";
// Pedro

?>

Función preg_split()

Extrae y muestra fragmentos de caracteres cuando indicamos cuáles son los separadores de esos fragmentos que deseamos extraer. Por ejemplo, si deseamos extraer las palabras presentes luego de una coma. En otras palabras, esta función sirve para extraer todo lo que existe entre cierto signo.

La expresión regular "/,\s*/" que corresponde al primer argumento de la función preg_split() es explicada a continuación:

• "//" Contenedores de la expresión regular.
• , Hallar y mostrar caracteres ubicados entre una coma.
• \s En cero o más caracteres de espacio en blanco (espacios, tabulaciones, saltos de línea).
• * una o más veces

En .PHP

<?php 

$text = "uno, dos, dudu";
$resultado = preg_split("/,\s*/", $text);

print_r($resultado);
/*
	Array
	(
	    [0] => uno
	    [1] => dos
	)
*/

// Mostramos el elemento 1 del arreglo
echo $resultado[1];
// dos

En el siguiente ejercicio se hallan caracteres entre comas, se cuenta la cantidad de elementos del arreglo y se muestra solo el último -de forma automática–. La expresión regular del primer argumento es "/,\s*/" e indica lo siguiente: Hallar coincidencias de cada coma entre todos los espacios en blanco, una o más veces

En .PHP

<?php 

$text = "Guayaquil, Quito, Cuenca, Loja";

$resultado = preg_split("/,\s*/", $text);

echo "la última palabra es " . 
$resultado[count($resultado) - 1] . 
" y en total hay " . 
count($resultado) . 
" palabras"; 

// la última palabra es Loja y en total hay 4 palabras

?>

Y en este ejercicio se extraen solo los números de una expresión matemática. Obviamente, la función preg_split() se encargó de ubicar cada número tomando en cuenta qué signo le antecedía. La expresión regular (del primer argumento de la función preg_split()) fue la siguiente:

• "//" Contenedor de la RegEx
• [ ] busca cualquier carácter que esté dentro de los corchetes
• +\-* Los caracteres de suma, resta (ojo, ese signo está escapado o neutralizado con la barra \) y multiplicación.
• \/ El caracter de división / (está escapado con la barra \ de la RegEx).

En .PHP

<?php 

    // De esta operación math
    $text = "3+5/2";

    // Ubicar los números entre estos signos matemáticos
    $operandos = preg_split("/[+\-*\/]/", $text);

    // Mostrarlo como arreglo
    print_r($operandos)."\n";

    // Mostrar solo elemento cero
    echo $operandos[0]."\n";
    // 3

    // Mostrar solo el elemento uno
    echo $operandos[1]."\n";
    // 5

?>

Función preg_grep()

Extrae caracteres o palabras según un indicador de caracter. Por ejemplo, al pedir que se extraiga SOLO las palabras que inicien con g minúscula (el signo ^ sirve para indicar que inicia con). Ojo con esto, pues aquellas palabras que inicien con G mayúscula NO serán tomadas en cuenta.

En .PHP

<?php 

// De esta conjunto de palabras
$palabra = ["guayaco", "guayaca", "rock", "Juan", "Guayaquito"];

// Extraer todas las palabras que inicien con P
$resultado = preg_grep("/^g/", $palabra);

print_r($resultado);
/* 
Array
(
    [0] => guayaco
    [1] => guayaca
)
*/

// Muestra el elemento cero
echo $resultado[0]. "\n";
// guayaco

// Muestra el elemento uno
echo $resultado[1];
// guayaca

?>

Así mismo, para invertir la orden de coincidencias con una expresión regular (es decir, para buscar las palabras que NO coincidan con que inicien con P) será de la siguiente forma.

¡Pero ojo con dos asuntos! Primero, los índices mantienen su numeral de índice a pesar de ser activada la función; y segundo, existe un tercer parámeto a usar para indicar que una activación de RegEx haga lo contrario a lo que se le ha pedido:

En .PHP

<?php 

$lenguajes = ["guayaco", "guayaca", "rock", "Juan", "Guayaquito"];
$resultado = preg_grep("/^g/", $lenguajes, PREG_GREP_INVERT);
print_r($resultado);

echo $resultado[0]. "\n";
echo $resultado[2];
// guayaca

/*
Array
(
    [2] => rock
    [3] => Juan
    [4] => Guayaquito
)
*/

?>

Función preg_quote()

Al recorrer todos los caracteres de una cadena de caracteres Y SI HALLA UN CARACTER DE REGEX entonces lo escapará (o sea, lo convertirá a caracter común) agregándole antes del caracter una \. Es decir, si debe escapar el signo + (un signo que significa –uno– más) lo escapará en la forma \+

En .PHP

<?php 

// expresión matemática común
$expr = "2+(2/10)*9";

// Escapa
// - Todos los caracteres especiales regex
// - Ah! y también esa barra
echo preg_quote($expr, "/");

// R: 
// 2\+\(2\/10\)\*9

?>

Esta función ayuda a construir expresiones regulares a partir de expresiones con signos y sin que esos signos iniciales rompan el código. Pero ¿para qué sirve?.

Si deseamos hallar coincidencias en textos cuya estructura contenga signos de RegExp como barras / o \, +, o de -, * y o códigos con signos * [] () como en trozos de código y expresiones aritméticas. En otras palabras, preg_quote() impide interpretar los símbolos como instrucciones regex, pero sí como caracteres comunes.

Así mismo, preg_grep() permitirá crear patrones RegEx seguros (o a prueba de fallos). Es decir, que no causarán comportamientos inesperados al procesar cadenas que puedan contener caracteres especiales de regex.

En .PHP

<?php 

$busqueda = "2(2*2)";

// Cadena de texto con símbolos que 
// podrían ser interpretados como RegEx, 
// pero no deseamos que esa interpretación ocurra.
$texto = "No olviden la operación 2(2*2)";

// Aquí limpiamos (escapamos) los signos regEx
// Ojo como hemos insertado la variable $busqueda
$expresRegEx = "/" . preg_quote($busqueda, "/") . "/";

// Busca en $texto la expresión $expresRegEx
if (preg_match($expresRegEx, $texto)) {
    echo "¡La expresión fue encontrada!";
} else {
    echo "No se encontró la expresión.";
}

// R:
// ¡La expresión fue encontrada!

?>

En la siguiente sección revisaremos con detalle el concepto de arreglo, que es un tipo de dato para alojar datos en forma de elementos de datos ubicados en orden de índices (desde cero en adelante).