Funciones incorporadas para ubicar caracteres: strpos(), strrpos(), strstr(), strchr(), strspn(), strcspn()
En la sección anterior revisamos funciones en PHP para detectar y extraer porciones de caracteres desde una línea de caracteres (o dicho de otro modo, desde un string).
Ahora revisaremos funciones de PHP para detectar y ubicar la presencia o no de caracteres desde un conjunto de strings. Se aclara que todas las funciones a revisar retornarán false si no hallan el caracter buscado.
Hallar la primera ocurrencia de caracter con strpos()
Halla la primera ocurrencia (es decir, halla el primer caracter y su índice de posición) a partir de un string.
En .PHP
<?php
// String inicia en índice cero
$nombreCalle = "Avenida 9 de Octubre";
// Buscar el PRIMER caracter e
$pos = strpos($nombreCalle, "e");
// Ojo con el uso de corchetes
echo("el primer número está en el índice {$pos}");
// el primer número está en el índice 2
?>
Hallar la última ocurrencia de caracter con strrpos()
Halla la última ocurrencia a partir de un string.
En .PHP
<?php
// String inicia en índice cero
$nombreCalle = "Avenida 9 de Octubre";
// Buscar el ÚLTIMA caracter 'e'
$pos = strrpos($nombreCalle, "e");
// Ojo con el uso de corchetes
echo("el primer número está en el índice {$pos}");
// el primer número está en el índice 19
?>
Hallar la primera ocurrencia de caracter y todos los que le siguen, con strstr()
Halla la primera ocurrencia de un caracter y devuelve todos los caracteres que le siguen (desde el primer caracter hallado en adelante). Así mismo, la función stristr() indicará que no habrá discriminará la búsqueda entre mayúsculas o minúsculas.
En .PHP
<?php
// String inicia en índice cero
$nombreCalle = "Avenida 9 de Octubre";
// Buscar el ÚLTIMA caracter 'e'
// IMPORTANTE Si ES EN MAYÚSCULA O MINÚSCULA
$pos = strstr($nombreCalle, "e");
// Ojo con el uso de corchetes
echo("El texto que le sigue a la primeta letra 'e' es: {$pos}");
// El texto que le sigue a la primeta letra 'e' es: enida 9 de Octubre
echo "
";
// FUNCIÓN stristr()
// Aplica búsqueda sea en mayúscula o minúscula
// NO IMPORTA si es en mayúscula o minúscula
$sea_Mayuscula_o_Minuscula = stristr($nombreCalle, "e");
echo $sea_Mayuscula_o_Minuscula;
// enida 9 de Octubre
?>
Hallar la última ocurrencia de caracter y todos los que le siguen, con strrchr()
Halla la última ocurrencia de un caracter y devuelve todos los caracteres que le siguen (desde el último caracter hallado en adelante). OJO: discrimina caracteres mayúsculas o minúsculas.
En .PHP
<?php
$frase = "Guayaquil Ecuador";
$pos = strrchr($frase, "a");
echo("El texto anexo a la última 'a' es: {$pos}");
// El texto anexo a la última 'a' es: ador
?>
El muy raro conteo de la función strspn()
Admito que esta función me mareó por unos minutos. strspn() cuenta los caracteres en común (no cuenta el índice, que se contaría desde el cero en adelante).
Primero se indica un string inicial. Luego, un string de caracteres permitidos cuya cantidad de apariciones será contabilizada a partir del string inicial. Todo eso desde la función strspn().
Luego, inicia el conteo de cada caracter en común y siempre al inicio del string inicial; pero cuando aparece un caracter NO COMÚN, la función detiene el conteo. Luego, la función devuelve solo el número de caracteres comunes.
Pero ojo aquí: si la función haya un primer caracter que no está en el string inicial, EL CONTEO SE DETENDRÁ. Y el resultado será CERO.
Funciones como strspn() permiten, por ejemplo, validar que los tipos de datos de un registro sean los que se piden. En el ejemplo de abajo, se usa la función strlen() que devuelve la longitud total de la cadena (el número de caracteres).
En .PHP
<?php
// String inicial
$cadena = "hello123";
// String con caracteres cuya recurrencia AL INICIO será contabilizada
// Si el primer caracter no es 'h', todo se detiene y da cero
$permitidos = "hel";
echo strspn($cadena, $permitidos);
echo "<hr>";
// 4
/* CONTEO:
h ... 1
e ... 2
l ... 3
l ... 4
*/
// NUEVO EJEMPLO: VALIDAR REGISTROS
$entrada = "123";
$permitidos = "12abc";
// Solo dígitos permitidos
if (strspn($entrada, $permitidos) == strlen($entrada)) {
echo "La entrada es válida.";
} else {
echo "La entrada contiene caracteres no permitidos.";
}
// La entrada contiene caracteres no permitidos.
?>
Descomponer URLs con parse_url()
Devuelve un arreglo con los elementos de una URL:
En .PHP
<?php
$ruta = parse_url("https://duduromeroa.com/infografias/impresas");
print_r($ruta);
// Resultado:
/*
Array (
[scheme] => http
[host] => duduromeroa.com
[path] => /infografias/impresas
)
*/
?>
Expresiones regulares con el muy versátil preg_match()
Las expresiones regulares o regex hallan caracteres y sus coincidencias (o, detecta que no las hay).
Una vez obtenidas esas coincidencias podremos alterarlas, sustituirlas o extraerlas por porciones. Por ejemplo, si deseamos hallar la expresión 'quil' en la palabra 'Guayaquil', entonces diremos que sí hay una ocurrencia de ese grupo de letras. La expresiones regulares usan metacaracteres (o lo que es lo mismo decir, sintaxis de código) para indicar qué grupo de caracteres necesitamos comparar en una palabra o frase.
A continuación una tabla explicando cada metacaracter y su uso en la sintaxis de regex:
Signo y uso |
||
|
Barras inclinadas dobles: Delimita la expresión regular. Modo de uso: solo indica que entre esas barras solo se ubicará la sintaxis de una expresión regular. |
|
|
Barra vertical. Indica condición del Ó booleano (este ó este) para sumar regex entre sí. | |
|
Punto. Coincide con cualquier carácter excepto nueva línea (\n). | |
|
Indica que el/los siguientes caracteres después de | |
|
Indica que la búsqueda de la coincidencia debe iniciar al inicio de la cadena de caracteres. Pero en caso de existir un punto luego de metacaracter | |
|
Indica que la búsqueda debe iniciar desde el final de la cadena de caracteres o antes que la cadena finalice. También indica que la sintaxis de regex debe ser leída hasta esa ubicación de la sintaxis.
| |
|
Indica que el siguiente caracter será tratado como un símbolo literal, y no como una sintaxis RegEx. | |
|
Agrupa las partes de una expresión regular compuesta. | |
|
Indica que alguno de esos caracteres dentro de los corchetes deberían activar una o más coincidencias. Si la regex halla alguna, la expresión devolverá true. | |
|
Especifica la cantidad de repeticiones (o el rango de repeticiones) en una cantidad de números. | |
|
Coincide con una o más repeticiones de un carácter indicado en la regex. | |
|
Metacaracter de opcionalidad.
Ejemplo de uso:
| |
|
Signo | |
|
Signo | |
Luego de lo anterior, expongo ejemplos de uso mediante sintaxis PHP:
Ejemplos de uso mediante código PHP
Uso de metacaracter //
Indica que entre las barras estará la porción de caracteres que coincidirá o no con el string; sea al inicio, en medio o al final del string indicado.
En .PHP
<?php
echo preg_match("/me/", "me gusta el ceviche con chifles");
// true
echo preg_match("/gusta/", "me gusta el ceviche con chifles");
// true
echo preg_match("/el /", "me gusta el ceviche con chifles");
// true
echo preg_match("/fles/", "me gusta el ceviche con chifles");
// true
// + + + + +
echo preg_match("/megus/", "me gusta el ceviche con chifles");
// false
echo preg_match("/gusta/", "...");
// false
echo preg_match("/elceviche/", "me gusta el ceviche con chifles");
// false
echo preg_match("/flez/", "me gusta el ceviche con chifles");
// false
?>
Abajo, ejemplo de uso de comillas dobles o simples y uso de diagonales al momento de identificar una coincidencia, o para convertir un metacaracter a un caracter literal simple (acción llamada como escapar):
En .PHP
<?php
/* Se pide identificar la presencia del signo $
seguido de unos valores dados. */
// En comillas dobles:
// Se usa doble diagonal invertida para primero:
// - Convertir (escapar) el metacaracter $ a un literal común
// - Establecer la porción de coincidencia
echo preg_match("/\\$15.00/", "Préstame $15.00 porfi");
// 1 (true)
// + + +
// En comillas simples:
// - Solo escapar el signo $ con una sola diagonal
echo preg_match('/\$5.00/', 'Préstame $5.00 porfi');
// 1 (true)
// + + +
// En comillas simples:
// - Solo escapar el signo $ con una sola diagonal
echo preg_match('/\$5.00/', 'Préstame $15.00 porfi');
// 0 (false) No existe esa cantidad
?> Ejemplo con metacaracter de barra vertical recta: |
En .PHP
<?php
// Cadena de referencia
$cadena = "Tengo un gato";
/* Cualquiera de las palabras exactas 'gato ó perro'
darán coincidencia */
// CUIDADO: No separar palabras con la barra
if (preg_match("/gato|perro/", $cadena)) {
echo "Coincide con 'gato' o 'perro'.";
}
// Coincide con 'gato' o 'perro'.
echo "<hr>";
// ---
// Para indicar coincidencia de iniciales en palabras
// El * dice 'toda palabra que '
if (preg_match("/t.*|g.*/", $cadena)) {
echo "Coincide con alguna palabra que inicie con 't' o 'g'.";
}
?> Ejemplo, abajo: Metacaracter punto ....pero ojo, que la coincidencia será sensible letras mayúsculas o minúsculas.
En .PHP
<?php
// Referencia
$cadena = "xxxchatxxx";
/* Lo siguiente activará una coindidencia si:
- El string inicia con 'at'
- El string termina con 'at'
- El string tiene 'at' dentro de la palabra
*/
if (preg_match("/.at/", $cadena)) {
echo "Contiene 'at' al inicio, al final, o dentro de la palabra.";
}
// Contiene 'at' al inicio, al final, o dentro de la palabra.
?>
Así mismo, puede ser aplicado para hallar la presencia de una primera letra indicada, luego hallar cualquier letra, y después una segunda letra indicada:
En .PHP
<?php
/* Buscará la letra 'M' mayúscula,
luego cualquier otra letra,
y luego la letra 'l' minúscula */
echo preg_match("/M.l/", "Malecón 2000");
/* 1 - true (sí existe al inicio la mayúscula M,
luego cualquier letra,
y finalmente la minúscula 'l'), */
echo preg_match("/m.L/", "Malecón");
// 0 - false (no conciden mayúsculas o minúsculas)
echo preg_match("/c.t/", "ct");
// 0 - false (no existe cualquier letra entre 'ct')
?>
Abajo: metacaracter \d
En .PHP
<?php
// Referencia
$cadena = "El código es 12345";
/* Si la función halla 'algo' (o sea, no es null)
devolverá 1, que es igual a TRUE */
// Ojo: mira cómo luego de la condición se agregó el otro argumento
if (preg_match("/\d{4}/", $cadena)) {
echo "Se encontró una secuencia de 4 dígitos.";
} else {
echo "No se encontró una secuencia de al menos 4 dígitos.";
}
// Se encontró una secuencia de 4 dígitos.
?> Abajo: metacaracter ^. Este metacaracter es comúmnente usado con la función preg_match(). Donde devolverá el valor 1 –true- si halla una coincidencia, ó devolverá el valor 0 –false– si no la halla, ó si la sintaxis es incorrecta. Por otro lado, si el metacaracter ^ antecede a un punto, como en la forma preg_match("/^.abc/", $string); eso indicará que primero buscará cualquier caracter y luego las letras 'abc'.
En .PHP
<?php
$cadena = "Hola, mundo";
$patron = "/^Hola/";
// Busca si "Hola" está al inicio de la cadena
// Existen coincidencias en algún argumento?
if (preg_match($patron, $cadena)) {
echo "La cadena comienza con 'Hola'.";
} else {
echo "La cadena NO comienza con 'Hola'.";
}
// La cadena comienza con 'Hola'
// + + + +
$cadena = "encebollado con pan";
$buscar = preg_match("/^ence/", $cadena);
echo $buscar;
// Devuelve 1 (true), porque "ence" está al inicio de
// + + + +
$cadena = "encebollado con pan";
$buscar = preg_match("/^.ence/", $cadena);
echo $buscar;
/* Devuelve 0 (false), porque no
halló ninguna otra letra al inicio
de 'encebollado' */
?> Otras funciones que aprovechan el metacaracter ^ son: preg_replace(), y preg_grep(), revisadas a continuación. En el segundo ejemplo de código, la función print_r() que devuelve la estructura de los datos; en este caso, de un arreglo.
En .PHP
<?php
// Metacaracter ^ con reg_replace()
// Se pide reemplazar solo los dígitos por la palabra 'mono'
$cadena = "2025Guayaco";
$modificado = preg_replace("/^\d+/", "Mono-", $cadena);
echo $modificado;
// Mono-Guayaco
// + + + +
// Metacaracter ^ con preg_grep()
/* Pide hallar coincidencias al inicio
de toda palabra que INICIE con las letras 'ma'*/
$lista = ["eduardo", "ediciones", "ciencias"];
$resultado = preg_grep("/^ed/", $lista);
print_r($resultado);
/* DEVUELVE:
([0] => eduardo [1] => ediciones)
*/
?> Finalmente, el metacaracter ^ sirve para negar una coincidencia. Es decir, para indicar que la coincidencia NO DEBE contener ciertos rangos de caracteres dados. Sólo si no lo contiene, entonces el resultado será true.
En .PHP
<?php
// Hallar coincidencia que inicie con 'g',
// luego con cualquier letra QUE NO SEA aeiou,
// y luego le siga una 'a'
echo preg_match("/g[^aeiou]a/", "soy guayaco");
// false –aunque se halle 'gua', la 'u' SÍ pertenece al rango [aeiou]
echo preg_match("/g[^aeiou]a/", "soy gxayaco");
// true –aunque se halle 'gxa', la 'x' NO pertenece al rango [aeiou]
?> Abajo: metacaracter $
En .PHP
<?php
// Referencia
$cadena = "Hola, mundo";
// Si halla algo, será 1 (true)
// Podría haber sido /\.$/ (buscar un punto al final)
// Podría haber sido /\s$/ (buscar un espacio en blanco al final)
// Podría haber sido /@gmail\.com$/ (buscar @gmail.com al final)
if (preg_match("/mundo$/", $cadena)) {
echo "La cadena termina con 'mundo'.";
// si no, será cero (false)
} else {
echo "La cadena NO termina con 'mundo'.";
}
// Existe al menos una cadena que termina con 'mundo'.
// Si hubiera sido "Hola, mundo " (con espacio al final)...
// ..no hubiera coincidencia.
?> Abajo: metacaracter \
En .PHP
<?php
$cadena = "El precio es de 50$.";
$patron = "/\$/";
// Se usa \ para escapar el $
// es decir, para indicar que el signo $ es un caracter más
if (preg_match($patron, $cadena)) {
echo "Se encontró el signo de dólar en la cadena.";
} else {
echo "No se encontró el signo de dólar en la cadena.";
}
?> Abajo: metacaracter (), útil para agrupar coincidencias –también llamados subpatrones–.
En .PHP
<?php
// Cadena de referencia
$cadena = "Hola Mundo";
// Expresión regular que agrupa "Hola" y "Mundo"
if (preg_match("/(Hola) (Mundo)/", $cadena, $coincidencias)) {
echo "Coincidencia encontrada: " . $coincidencias[0] . "\n";
echo "Primer grupo: " . $coincidencias[1] . "\n";
// "Hola"
echo "Segundo grupo: " . $coincidencias[2] . "\n";
// "Mundo"
} else {
echo "No se encontró coincidencia.";
}
// + + + +
/*
- Busca coincidencias exactas donde
primero aparezca la letra "s"
- Seguida sí o sí por una o más veces
por la palabra "perla " (con espacio),
- Seguida sí o sí por "que surgiste".
*/
echo preg_match("/s (perla )+que surgiste/",
"Eres perla que surgiste");
// true
?> Abajo: el metacaracter [] puede ser usado también anteponiendo caracteres que identifiquen coincidencias al inicio, en medio y al final de un string dado. Recordar que los corchetes [] indican algo similar a 'cualquiera de estos caracteres, pero solo uno de ellos':
En .PHP
<?php
// USO COMÚN
$cadena = "Hola, cómo estás?";
// Usamos preg_match para encontrar al menos una vocal en la cadena
// Ojo con los corchetes rectos
if (preg_match("/[aeiou]/", $cadena)) {
echo "Se encontró al menos una vocal en la cadena.";
} else {
echo "No se encontraron vocales.";
}
// + + + +
/* OJO. La porción [aeiou] significa
que sólo tomará UNA SOLO CARACTER de ese conjunto */
// Hallar coindicencia con cualquier porción de string si:
// La primera letra es 'G' mayúscula
// la segunda, cualquiera (una sola letra) entre [aeiou]
// La tercera letra es 'a' minúscula
echo preg_match("/G[aeiou]a/", "Mi Guayaquil querido");
// true –si lo anterior se cumple–
// + + + +
// La primera letra es 'c' minúscula
// la segunda, cualquiera entre [aeiou]
// La tercera letra es 'ma' minúscula
echo preg_match("/c[aeiou]ma/", "Ceviche de camarón");
// true –si lo anterior se cumple–
// + + + +
// La primera letra es 'g' minúscula
// la segunda, cualquiera entre [aeiou]
// La tercera letra es 'a' minúscula
echo preg_match("/g[aeiou]a/", "Viva Quito");
// false -nada se cumple-
// + + + +
// La primera letra es 'a' minúscula
// la segunda, cualquiera entre [bcdef]
// La tercera letra es 'g' minúscula
echo preg_match("/a[bcdef]g/", "abcdefg");
// false –nada se cumple–
// Pues si bien el string inicia con 'a'...
// y luego le sigue una 'b'...
// pero le siguen otras letras hasta llegar a la 'g'
// + + + +
// Aquí sí hallará la coincidencoa
echo preg_match("/a[bcdef]g/", "abg");
// true
// Hallará 'a', luego cualquier letra entre '[bcdef]'
// y finalmente hallará una 'g'
?> Abajo: metacaracter {}. También son usados para indicar la cantidad de caracteres en los que se deben buscar las coincidencias.
En .PHP
<?php
// Cadena de prueba
$texto = "El código de verificación es 1234.";
// Busca exactamente 4 dígitos seguidos
if (preg_match("/\d{4}/", $texto, $coincidencias)) {
echo "Se encontró un número de 4 dígitos: " . $coincidencias[0];
} else {
echo "No se encontró un número de exactamente 4 dígitos.";
}
// + + + +
// INDICANDO CANTIDADES Y RANGOS
// En el primer grupo, hallar un dígito entre 0 a 9
// En el segundo grupo, hallar dos dígitos entre 0 a 9
// En el tercer grupo, hallar tres dígitos entre 0 a 9
echo preg_match("/[0-9]{1}-[0-9]{2}-[0-9]{3}/", "3-55-121");
// true (sí existen coincidencias en esos rangos)
// + + + +
echo preg_match("/[0-9]{1}-[0-9]{2}-[0-9]{3}/", "23-355-2121");
// false (no existen coincidencias en la cantidad de rangos)
// Porqué? Observar y explicar
// Pista: no coinciden la cantiadad de caracteres a coincidir
?> Abajo: metacaracter +
En .PHP
<?php
// Cadena de referencia
$cadena = "Holaaa mundo";
// Buscar una o más repeticiones de la letra "a"
if (preg_match("/a+/", $cadena)) {
echo "Hay al menos una repetición de 'a'";
} else {
echo "No se encontró coincidencia.";
}
// Salida esperada:
// Se encontró una coincidencia con 'a'
// repetida una o más veces.
?> Abajo, metacaracter de opcionalidad. Si es ()? el caracter entre paréntesis indicará que ese caracter (o conjunto de caracteres) será opcional; es decir, habrá coincidencia si están o no.
Ejemplo de uso:
/color(es)?/ –donde se pide hallar una coincidencia con la palabra 'color', aunque termine o no en 'es'–. En otro ejemplo especial, la expresión
/col?r/ podrá coincidir con una referencia, ya sea si en esa referencia existe o no la letra que precede al signo. Se explica eso en el siguiente código:
En .PHP
<?php
// 1ER EJEMPLO: COINCIDENCIA OPCIONAL
$cadena = "colores";
// (es) es opcional
if (preg_match("/color(es)?/", $cadena)) {
echo "Coincide con 'color' o 'colores'.";
}
// Coincide con 'color' o 'colores'.
// --- ---- --- --- ---- ---
// 2DO EJEMPLO: COINCIDENCIA OPCIONAL
// String de referencia
$cadena = "color";
// Función regex pide que el caracter anterior a ? sea opcional
if (preg_match("/colo?r/", $cadena)) {
echo "Coincide con 'color' o 'colr'.";
}
// Tanto con 'color' o con 'colr, la coincidencia será activada
// R: Coincide con 'color' o 'colr'.
?>
Abajo. Usado entre corchetes rectos, el signo - define un rango de coincidencia entre valores (numéricos y/o alfanuméricos).
En .PHP
<?php
// [a-z] Coincide con minúsculas, de "a" a "z".
// [A-Z] Coincide con mayúsculas, de "A" a "Z".
// [0-9] Coincide con dígito, de "0" a "9".
// [0-9a-f] Coincide con cualquier dígito hexadecimal, ya sea de 0 a 9 o de "a" a "f".
// OTROS EJEMPLOS
$cadena = "abc123";
// regex para coincidencia con MINÚSCULAS
if (preg_match("/[a-z]/", $cadena)) {
echo "Coincide con al menos una letra minúscula de 'a' a 'z'.";
}
// Coincide con al menos una letra minúscula de 'a' a 'z'.
echo "<hr>";
if (preg_match("/[0-9]/", $cadena)) {
echo "Coincide con al menos un número.";
}
// Coincide con al menos un número.
echo "<hr>";
if (preg_match("/[a-z0-9]/", $cadena)) {
echo "Coincide con al menos una letra o un número.";
}
// Coincide con al menos una letra o un número.
?>
Combinación de sintaxis RegEx complejas
Finalmente, dos ejemplos de combinación de sintaxis RegEx para indicar coincidencias más complejas, o negarlas:
En .PHP
<?php
// Ubicar coincidencia AL INICIO DEL STRING (signo ^)
// en un rango entre a-z y A-Z
// ó con un número de 0 a 9
echo preg_match("/^([a-zA-Z]|[0-9])/", "Eres perla que surgiste");
// True
// USANDO PARA NEGAR
// Ojo como el signo ^ se usa para negar aquí
// Y si deseamos negar lo anterior?
// Es decir, ¿Inicia el string con letras
// que no sean a-z, A-Z o con cualquier número?
echo preg_match("/^[^a-zA-Z0-9]/", "#Holi amigos");
// True -sí inicia con cualquier otra cosa
// que no sean letras o números
?>
Coincidencias insensibles a mayúsculas o minúsculas mediante el caracter /i
En .PHP
<?php
/* Hallar la coincidencia desde la porción 'gua'
en la frase 'Hola GuAyaquileños', sean o no mayúsculas */
echo preg_match("/gua/i", "Hola GuAyaquileños"); // true
?>
Las RegEx es una potente sintaxis para hallar caracteres o conjuntos de ellos desde PHP; es decir, desde instrucciones dadas hacia el servidor en remoto, y no en local, como sí se lo podría hacer desde el lenguaje Javascript.
En la siguiente sección revisaremos otras sintaxis útiles.
BIBLIOGRAFÍA
www.php.net (2025). ¿Qué es PHP?Kevin Tatroe and Peter MacIntyre (2020). Programming PHP