Manipulación de cadenas

Una cadena de caracteres (string) son un conjunto de caracteres, donde un caracter vale lo mismo que un byte. Podemos alterar una cadena (modificar una cadena, imprimir una cadena, buscar un determinado caracter de una cadena, reemplazar un caracter, etc...) mediante una serie de funciones que nos permitirán trabajar con cadenas de texto.

Funciones y operaciones disponibles para la manipulación de cadenas de caracteres, según su uso.
Aunque las denominemos funciones, algunas son construcciones del lenguaje (sentencias):

Texto como secuencia de caracteres individuales

Un texto se define con una variable asignada por un valor encerrado entre comillas (simples o dobles):

$text = 'texto';

	// 'strlen' devuelve la cantidad de caracteres de una cadena 
	for($c = 0; $c < strlen($text); $c++){
		
		$caracter = $text($c);
		print ('Carácter : $text <br />');
		
	}
Carácter : t
Carácter : e
Carácter : x
Carácter : t
Carácter : o

Impresión de cadenas

Modificación de una cadena

Podremos modificar una cadena de caracteres como si fuera una matriz.

$modif = '1234';

$modif[2] = '1'; // Al índice '2' le asigna el valor '1' 

	print($modif); // Muestra 1214  
1214

Funciones para impresión:

Funciones específicas para la impresión y visualización del contenido de una cadena de caracteres.


Sentencia echo()
Imprime cadenas de texto
Esto es una cadena de texto separada por coma

Función print()
Imprime cadenas de texto

Función printf()
Temperatura 15 grados a las 09h 45m

El número 122 en diferentes formatos:

Dec: 122, ........ Decimal
Bin: 1111010, .. Binario
Oct: 172, ........ Octal
Hex: 7a, .......... Hexadecimal
Car: z, ............ ASCII Carácter

Atención redondeos: 450.0 euros
No hay truncamientos: -55550.0 euros


Función sprintf()
fecha: 02 / 05 / 2013

Función vprintf()
fecha: 02 / 05 / 2013

Modo de definición de formato

A partir de una cadena de descriptores obtenemos la especificación del formato, algunos sin cambios en el formato, otros con formato, estos últimos actuan como indicadores de conversión y empiezan con el símbolo %.
La especificación de conversión consiste en un signo de porcentaje %, seguido por uno o varios de estos elementos, en orden:

Funciones de formato

Búsqueda en cadenas

Búsqueda de subcadenas dentro de cadenas de carecteres. Para poder llevar a cabo este tipo de búsquedas disponemos de varias funciones:

strstr(micadena, mibusca): Busca la primera aparición de la subcadena mibusca en la cadena micadena y devuelve toda la subcadena que va desde el literal encontrado (incluyéndolo) hasta el final de la cadena.
Sensible a mayúsculas y minúsculas y si no encuentra la subcadena, devuelve False.

// Busca la subcadena "m" minúscula y devuelve todos los 
// caracteres de esta posición hacia el inicio de la cadena
// mediante true, false sería al inverso.
echo strstr("Quim Medio" ,'M', true); 

Quim
// strstr() - Busca por su valor ASCII
// Busca el valor ASCII de la 'm' que es '109' y devolver todos 
// los caracteres de esta posición hasta el final de la cadena.
echo strchr('Quim Medio' ,109);
  

m Medio

strchr(micadena, mibusca): Es un alias de strstr().
Busca la primera aparición de la subcadena mibusca en la cadena micadena y devuelve toda la subcadena que va desde el literal encontrado (incluyéndolo) hasta el final de la cadena.
Sensible a mayúsculas y minúsculas y si no encuentra la subcadena, devuelve False.

// Busca la subcadena "m" minúscula y devuelve todos los 
// caracteres de esta posición hacia el inicio de la cadena
// mediante true, false sería al inverso.
echo strchr("Quim Medio" ,'M', true); 

Quim
// strchr() - Busca por su valor ASCII
// Busca el valor ASCII de la 'm' que es '109' y devolver todos 
// los caracteres de esta posición hasta el final de la cadena.
echo strchr('Quim Medio' ,109);
  

m Medio

stristr(micadena, mibusca): Busca la primera aparición de la subcadena mibusca en la cadena micadena y devuelve toda la subcadena que va desde el literal encontrado (incluyéndolo) hasta el final de la cadena.
Insensible a mayúsculas y minúsculas y si no encuentra la subcadena, devuelve False.

$cadena = 'PE ACHE PE';
// Insensible a mayúsculas y minúsculas, buscará la primera 'a' de la cadena 
echo stristr($cadena, 'a'); 
ACHE PE
$cadena = 'PEACHEPE';
echo stristr($cadena, 104) . ''; // 104 = h minúscula  
HEPE

strrchr(micadena, mibusca): Busca la última aparición de la subcadena mibusca (pero sólo utilizando su primer caráctet) en la cadena micadena y devuelve toda la subcadena que va desde el literal encontrado (incluyénldolo) hasta el final de la cadena.
Si no encuentra la subcadena. devuelve False. Si no encuentra la cadena, se utiliza su valor entero y se aplica como valor ordinal) de un carácter.

// Devuelve a partir del primer caracter de la 
// subcadena, todos los caracrteres hasta el final. 
echo strrchr('Quim Medio P.' ,'Medio'); 

Medio P.
// strrchr() - Buscar por su valor ASCII
// Busca el valor ASCII de la "m" que es '109' y devueve todos 
// los caracteres de esta posición hasta el final de la cadena. 
echo strrchr("Quim Medio" ,109); 

m Medio

strpos(micadena, mibusca [,desplazamiento]): Devuelve la posición de la primera aparición de una cadena a partir de un desplazamiento detemrinado (si se omite, es cero).
Sensible a mayúsculas y minúsculas.

// Encuentra la primera coincidencia entre
// los caracteres de las dos cadenas. 
echo strpos('Es código php, todo con PHP', 'php'); // Devuelve posición 11  
Posición coincidente: 11

strrpos(micadena, mibusca): Devuelve la posición de la última aparición de un carácter dentro de la cadena micadena (aunque mibusca tenga varios caracteres, sólo se considera su primera posición). Si no encuentra el carácter, devuelve False.
Sensible a mayúsculas y minúsculas. S¡ mibusca no es una cadena, se utiliza su valor entero y se aplica como valor ordinal de un carácter.

$algo = "0123456789a123456789b123456789c";
$algo2 = "0123456789a123456789b123456789c";

// Empieza desde atrás cinco posiciones, sigue contando hacia 
// atrás 7 posiciones menos, calcula la posición desde 0 
// hasta la última cuenta (12). Devuelve: int(17). 
var_dump(strrpos($algo, '7', -5)); 

// Inicia la búsqueda de 0 a 20 posiciones, más '7'. Devuelve: int(27). 
var_dump(strrpos($algo, '7', 20));  

// Inicia la búsqueda de 0 a 28 posiciones, más '7', como 
// sobrepasa la longitud de caracteres es False. Devuelve: bool(false). 
// Para mostrar mensaje, guardamos en una variable, y pasamos por una condicional
$posalgo = strrpos($algo2, '7', 28);
  
	// Si no existe '7' en la posición ...
	if($posalgo ===  false) { 
		
		echo 'No existe esta posición!';
		
	}else{
		
		// Si existe ... 
		var_dump(strrpos($algo2, '7', 28)); // Muestra False 
		
	} 
int(17) int(27) No existe esta posición!

strripos(micadena, mibusca [,desplazamiento]): Devuelve la posición de la última aparición de un carácter dentro de la cadena micadena (aunque mibusca tenga varios caracteres, sólo se considera su primera posición). Si no encuentra el carácter, devuelve False.
Insensible a mayúsculas y minúsculas. Un desplazamiento positivo permite empezar la búsqueda en cualquier posición. Un desplazamiento negativo permite detener la búsqueda antes del final de la cadena..

// Encuentra la última coincidencia entre
// los caracteres de las dos cadenas. 
echo strripos('Es código php, todo con php', 'PHP'); // Devuelve posición 25  
Posición coincidente: 25

strspn(micadena, mibusca): Devuelve la longitud del segmento inicial más largo compuesto por caracteres contenidos en mibusca. Al encuentra un carácter que no está en mibusca. abandona el análisis de la cadena micadena.
Sensible a mayúsculas y minúsculas.

// Devuelve el número de caracteres que se encuentran en la cadena 
// En el caracter 'X' abandona el análisis de la cadena,
// por no encontrarlo entre los caracteres de la primera cadena. 
echo strspn('Quim Medio', 'mQMiXuo'); // Devuelve 4 caracteres coincidentes antes de 'X' 
Caracteres coincidentes hasta X: 4

strcspn(micadena, mibusca): Devuelve la longitud del segmento inicial más largo compuesto por caracteres no contenidos en mibusca. Apenas se encuentra un carácter que está en mibusca, abandona el análisis de la cadena micadena.
Sensible a mayúsculas y minúsculas. Es la función opuesla a strspn().

// La posición de inicio es 0 y
// la longitud de la cadena a buscar es 7.
// 'm' indica el caracter final para 
// calcular su longitud desde '0'. 
echo strcspn('Quim Medio',  'm',  0,  7);  // Devueve 3  
Longitud hasta el caracter m: 3

Comparación de cadenas

Funciones para la comparación de cadenas suministradas por PHP:

strcmp (cadena1, cadena2): Compara dos cadenas y devuelve 0 si las cadenas son iguales, un valor negativo si cadena2 es mayor y positivo si cadena1 es mayor. Sensible a mayúsculas y minúsculas.

// strcmp() 

echo strcmp("PHP", "PHP"); // Las dos cadenas son iguales 
echo strcmp("PHP" ,"PH"); // Cadena1 es mayor que cadena2
echo strcmp("PH" ,"PHP"); // Cadena2 es mayor que cadena1  
0 ... cadenas son iguales.
1 ... cadena1 es mayor.
-1 .. cadena2 es mayor.

strcasecmp(cadena1, cadena2): Compara dos cadenas y develve 0 si las cadenas son iguales, un valor negativo si cadena2 es mayor y un valor positivo si cadena1 es mayor. Insensible a mayúsculas y minúsculas.

// strcasecmp() 

$a1 = 'HTML';
$a2 = 'html';
$a3 = 'HTM';
$a4 = 'HTML';
	
	// Son iguales, la comparación es insensible a mayúsculas y minúsculas  
    echo '$a1 y $a2 -> ' . strcasecmp($a1, $a2) . '<br />';
	
	// La comparación $a2 es mayor que $a3 
    echo '$a2 y $a3 -> ' . strcasecmp($a2, $a3) . '<br />';
	
	// La comparación $a4 es mayor que $a3 
    echo '$a3 y $a4 -> ' . strcasecmp($a3, $a4);
$a1 y $a2 -> 0 ya que en la comparación se muestra insensible a mayúsculas y minúsculas
$a2 y $a3 -> 1 ya que en la comparación $a2 es mayor que $a3
$a3 y $a4 -> -1 ya que en la comparación $a4 es mayor que $a3

strncmp(cadena1, cadena2, n): Similar a strcmp(), con la diferencia de que se puede especificar el (limite superior del) número de caracteres desde cada string a ser usado en la comparación. Sensible a mayúsculas y minúsculas.

// strncmp()

// caracter 1 es mayor que elemento 2 hasta el caracter nº 6 = '1' 
echo strncmp('Quim Medio!', 'Quim Ledio!', 6) . '<br />';

// elemento 2 es mayor que elemento 1 hasta el caracter nº 6 = '-1'
// Sensible a mayúsculas y minúsculas 
echo strncmp('Quim Medio!', 'Quim medio!', 6) . ', 
              Sensible a mayúsculas y minúsculas. <br />';

// elemento 2 es mayor que elemento 1 hasta el caracter nº 6 = '-1' 
echo strncmp('Quim Medio!', 'Quim Nedio!', 6) . '<br />';

// elemento 1 es igual que elemento 2 hasta el caracter nº 5 = '0' 
echo strncmp('Quim Medio!', 'Quim Nedio!', 5) . '<br />';
elem1 > elem2 =1
elem2 > elem1 =-1, Sensible a mayúsculas y minúsculas.
elem2 > elem1 =-1
elem1 = elem2 =0

strnatcmp(cadena1, cadena2): Parecido a strcmp, Comparación de strings utilizando un algoritmo de 'orden natural'. Sensible a mayúsculas y minúsculas.

$matriz1 = $matriz2 = array('imag1',  'imag2', 'imag10', 'imag01',
						  'imag100', 'imag20', 'imag30', 'imag200');

echo 'Comparación de cadenas ESTÁNDART';

// Ordenar comparando sus valores 
usort($matriz1, 'strcmp');

	foreach($matriz1 as $cla1 => $val1){
		
		echo $cla1 . ' ' . $val1 . ' -- ';
		
	}
	
________________________________________________________ 


echo 'Comparación de cadena, ORDEN NATURAL';

// Ordenar comparando sus valores 
usort($matriz2, 'strnatcmp');

	foreach($matriz2 as $cla2 => $val2){
		
		echo $cla2 . ' ' . $val2 . ' -- ';
	}

Comparación de cadenas ESTÁNDART

0 imag01 -- 1 imag1 -- 2 imag10 -- 3 imag100 -- 4 imag2 -- 5 imag20 -- 6 imag200 -- 7 imag30 --
________________________________________________________

Comparación de cadena, ORDEN NATURAL

0 imag01 -- 1 imag1 -- 2 imag2 -- 3 imag10 -- 4 imag20 -- 5 imag30 -- 6 imag100 -- 7 imag200 --

strnatcasecmp(cadena1, cadena2): Parecido a strnatcmp(), pero es Insesible a mayúsculas y minúsculas.

$matriz1 = $matriz2 = array('imag1',  'imag2', 'imag10', 'imag01',
						  'imag100', 'imag20', 'imag30', 'imag200');

echo 'Comparación de cadenas ESTÁNDART';

// Ordenar comparando sus valores 
usort($matriz1, 'strcmp');

	foreach($matriz1 as $cla1 => $val1){
		
		echo $cla1 . ' ' . $val1 . ' -- ';
		
	}
	
________________________________________________________ 


echo 'Comparación de cadena, ORDEN NATURAL';

// Ordenar comparando sus valores 
usort($matriz2, 'strnatcasecmp');

	foreach($matriz2 as $cla2 => $val2){
		
		echo $cla2 . ' ' . $val2 . ' -- ';
	}

Comparación de cadenas ESTÁNDART

0 imag01 -- 1 imag1 -- 2 imag10 -- 3 imag100 -- 4 imag2 -- 5 imag20 -- 6 imag200 -- 7 imag30 --
________________________________________________________

Comparación de cadena, ORDEN NATURAL

0 imag01 -- 1 imag1 -- 2 imag2 -- 3 imag10 -- 4 imag20 -- 5 imag30 -- 6 imag100 -- 7 imag200 --

similar_text(cadena1, cadena2): Calcula la similitud entre dos cadenas e indica la cantidad de caracteres coincidentes entre ambas.

// Calcula la longitud de la cadena hasta
// que deja de coincidir los caracteres. 
echo similar_text('quim Medio', 'Quim Medio');
// Devuelve 9, sensible a mayúsculas y minúsculas

echo similar_text('Quim Medio', 'Quim Medio');
// Devuelve 10 caracteres iguales

9caracteres iguales
10
// similar_text(en (%) tanto por ciento) 
// similar_text()
// Calcular la similitud de las dos variables en porcentaje.
// Devuelve el porcentaje de caracteres coincidentes de las dos cadenas. 

$similA = 'HTML  PDF  GIF';
$similB = 'TXT  RGB  FDN';

similar_text('$similA, $similB, $percent);
echo $percent. '%'; // Devuelve  26.086956521739%

26.0869565217%

Similitud de cadenas

Funciones para la evaluación de similitudes de texto y similitudes a nivel fonético:

Similitud a nivel escrito (texto), utilizar la métrica levenshtein().

La función levenshtein() en su forma más simple recibe como parámetros los dos textos a comparar, dando como resultado un número entero que indicará el valor mínimo de modificaciones que necesitará para igualar los dos textos, esta modificación implicará (eliminaciones, reemplazos de caracteres, añadidos, etc...).

Insensible a mayúsculas y minúsculas.

En caso de devolución -1, quiere decir que uno de los dos textos (argumentos) son mayor que el límite de 255 caracteres.

Una función parecida es similar_text() que develve la cantidad de caracteres coincidentes entres ambas cadenas, pero la función levenshtein () es más rápida que la función similar_text() aunque, similar_text() duvuelve un resultado más preciso con menos modificaciones necesarias.

echo 'Número de modificaciones:' . levenshtein("Quim Medio", "Qum edio"); 
// Devuelve 2  
Número de modificaciones: 2
// Otra variante tomará tres parámetros adicionales que definen 
// el costo de las operaciones de insertar (1), reemplazar (2) y eliminar (3). 
// Compara la similitud de la 1ª cadena con la 2ª cadena 
// Devuelve 1, Insertar 'C' 
echo levenshtein('omo estás', 'Como estás' , 1, 2, 3);

// Devuelve 2, reemplazar 'E mayúscula'
echo levenshtein('Como Estás', 'Como estás' , 1, 2, 3);

// Devuelve 3, eliminar 'm'
echo levenshtein('Como estás', 'Coo estás' , 1, 2, 3);

// Devuelve 0, cadenas idénticas
echo levenshtein('Como estás', 'Como estás' , 1, 2, 3);

1
2
3
0
// Palabra de entrada mal escrita 
$entrada = 'zanahria';

// Array de textos a verificar 
$arrtextos = array('manzana', 'piña', 'banana', 'naranja', 'rábano',
				   'zanahoria', 'guisante', 'haba', 'patata' );

// No se ha encontrado la distancia más corta, aún 
$menor = -1;

// bucle a través de las palabras para encontrar la más cercana 
foreach ($arrtextos as $texto) {

    // Calcula la distancia entre la palabra
    // de entrada y la palabra actual 
    $longitud = levenshtein($entrada, $texto);

    // Verifica por una coincidencia exacta 
    if ($longitud == 0) {

        // La palabra más cercana es esta (coincidencia exacta)
        $cercano = $texto;
        $menor = 0;

        // Salir del bucle, se ha encontrado una coincidencia exacta 
        break;
		
    }

    // si esta distancia es menor que la siguiente distancia
    // más corta o si una siguiente palabra más corta aun no se ha encontrado 
    if ($longitud <= $menor || $menor < 0) {
        
	// establece la coincidencia más cercana y la distancia más corta 
        $cercano  = $texto;
        $menor = $longitud;
		
    }
}

echo '<br /> <br />Palabra de entrada: ' . $entrada;

	if ($menor == 0):
	
		echo 'Resultado exacto encontrado: ' . $cercano;
	else:
		echo 'Quiso decir '.  $cercano . '?';
		
	endif; 


Palabra de entrada: zanahria
Quiso decir zanahoria

Similitud fonética

Las claves soundex tienen la propiedad que palabras pronunciadas de forma similar producen la misma clave soundex y por lo tanto puede ser usada para simplificar búsquedas en bases de datos donde se conoce la pronunciación pero no la ortografía.

Una clave soundex es una cadena alfanumérica larga de 4 caracteres que representan (pronunciación de Inglés) de una palabra.

La función soundex () crea la misma clave para palabras que suenan similares.

// Calcular esta clave fonética 


$cadenasoun = "Peachepe";
echo "Fonética de Peachepe:" . soundex($cadenasoun); // Devuelve P210  

Fonética de Peachepe: P210
// soundex() en dos palabras que suenan similares

$cadena1 = "Assistance";
$cadena2 = "Assistants";

// Comprobar palabras pronunciadas 
echo "cadena 1: " . soundex($cadena1);  // Devuelve A223 

echo "cadena 2: " . soundex($cadena2); // Devuelve A223  

Fonética de Assistance: A223
Fonética de Assistants: A223

Manipulación de subcadenas

Las subcadenas o substring son una parte de una cadena. Para poder extraer de distintas formas esas partes de una cadena utilizaremos las siguientes funciones:

substr(cadena, inicio [,longitud]):

Devuelve una subcadena de cadena definida por los parámetros inicio [,longitud].
Si inicio es negativo indicar que se ha de empezar a contar desde el fnal de la cadena, si [,longitud] es negativo indica cuántos caracteres del final de la cadena no se considerarán.

// Números positivos: 
echo substr('Ahora peHpe', 0, 10) . '<br />'; // Devuelve Ahora peHp 
echo substr('Ahora peHpe', 6) . '<br />'; // Devuelve peHpe 
echo substr('Ahora peHpe', 1, 5) . '<br />'; // Devuelve hora 
echo substr('Ahora peHpe', -3) . '<br />'; // Devuelve Hpe 

echo '<br />';

// Números negativos: 
echo substr('Ahora peHpe', 0, -1) . '<br />'; // Devuelve Ahora peHp 
echo substr('Ahora peHpe', -10, -2) . '<br />'; // Devuelve hora peH 
echo substr('Ahora peHpe', 0, -6) . '<br />'; // Devuelve Ahora 
echo substr('Ahora peHpe', -2 -3) . '<br />'; // Devuelve peHpe  

Cadena utilizada: Ahora peHpe.

Números positivos:
-------- Ahora peHp
-------- peHpe
-------- hora
-------- Hpe

Números negativos:
-------- Ahora peHp
-------- hora peH
-------- Ahora
-------- peHpe



// El acceso a caracteres específicos en una cadena 
// se puede conseguir usando 'corchetes' 
$string = 'PHPHTML';
echo $string[0];	                // P 
echo $string[4];	                // T 
echo $string[strlen($string)-1]; // L 
------------- P
------------- T
------------- L
Subir

substr_replace(cadenal, cadena2, inicio [,longitud]):

Devuelve una subcadena de cadena.
Esta subcadena se forma a partir de la cadena pasada como parámetro cadena1 por la cadena como parámetro cadena2, los caracteres sustituidos los seleccionamos desde la posición indicada con parámetro inicio y hasta su final, excepto si especifica el parámetro [,longitud].
Si el parámetro inicio es negativo indica que se debe empezar a contar desde el final de la cadena, si [,longitud] es negativo indica cuántos caracteres del final de la cadena no se considerarán.

// Sustituye las subcadenas desde la posición '6' en adelante 

echo substr_replace("Ahora XHTML", "PHP", 6); // Sustituye XHTML por PHP  

Indicador número positivo: Ahora PHP

// Sustituye las subcadenas empezando a contar desde el último
//  caracterhacia atrás la cantidad indicada en número negativo. 

echo substr_replace("Ahora XHTML", "PHP", -5); // Sustituye XHTML por PHP  

Indicador número negativo: Ahora PHP

// Invertir dos cadenas. 

echo substr_replace(" Ahora", "XHTML ", 0, 0); // Invierte las cadenas  

Invertir dos cadenas0
XHTML Ahora

//  Reemplazar múltiples cadenas de una sola vez. 
$replace = array('1: YYY', '2: ZZZ', '3: XXX');

// Reemplazar máyúsculas de cada cadena por HHH.
// 'implode()' Une elementos de un array en un string. 
echo implode('<br />', substr_replace($replace, "HHH", 3, 3)); 

Reemplazar múltiples cadenas de una sola vez

1: HHH
2: HHH
3: HHH

//  Reemplazar múltiples cadenas de una sola vez. 
$entrada = array('A: XXX', 'B: XXX', 'C: XXX');

// Un caso simple: remplazar XXX en cada cadena con YYY. 
// 'implode()' Une elementos de un array en un string. 
echo implode('; ', substr_replace($entrada, 'YYY', 3, 3)) . '<br />';

// Un caso más complicado donde cada remplazo es diferente. 
$reemplaza = array('AAA', 'BBB', 'CCC');
echo implode('; ', substr_replace($entrada, $reemplaza, 3, 3)) . '<br />';

// Remplaza un número diferente de caracteres cada vez. 
$longitud = array(1, 2, 3);
echo implode('; ', substr_replace($entrada, $reemplaza, 3, $longitud)) . 
'<br />'; 

Reemplazar múltiples cadenas de una sola vez

A: YYY; B: YYY; C: YYY

Diferentes reemplazos.

A: AAA; B: BBB; C: CCC

Remplaza un número diferente de caracteres cada vez.

A: AAAXX; B: BBBX; C: CCC

Subir

str_replace(busca, reemplaza, cadena): Devuelve una cadena formada a partir de la cadena pasada en el parámetro cadena, reemplaza las coincidencias de la cadena pasada en el parámetro busca por la cadena pasada en el parámetro reenplaza.
Sensible a mayúsculas y minúsculas.

// Busca 'peHpe' - en cadena encuentra coincidencia 
// 'peHpe' y la reemplaza por 'Quim'. 
echo str_replace('peHpe', 'Quim', 'Autor peHpe');

Remplaza parte de la cadena.Autor Quim

// Usamos una matriz y una variable '$i' de recuento.  
$arr = array('azul', 'rojo', 'verde', 'amarillo');

// Cadena 'rojo' por 'rosa' y lo remplaza del array '$arr'.
// '$i' variable de recuento. 
echo(str_replace('rojo', 'rosa', $arr, $i));
echo '<br />' . 'Replacements: $i';

Ahora los elementos del Array son estos:

azul - rosa - verde - amarillo
Reemplazos: 1
Subir

strtr(cadena, busca, reemplaza): Función de traducción de caracteres. Devuelve una cadena formada a partir de la cadena pasada en el parámetro cadena, reemplazando cada una de las coincidencias de los caracteres busca por los correspondientes caracteres del parámetro reemplaza.
Sensible a mayúsculas y minúsculas.

// Busca los caracteres ',iUu', los traduce de la
// cadena y los reemplaza por los caracteres '-eAa'. 
echo strtr('Pi_h_pi , Uhoru',',iUu','-eAa'); 
Pe_h_pe - Ahora
Subir

strtr(cadena, matriz): Alternativa a la función strtr() Utilizaremos dos parámetros. El primer parámetro es la cadena y el segundo paránetro la matriz asociativa, cuyos índices son los datos a traducir y sus valores las traducciones.
Sensible a mayúsculas y minúsculas.

// Transformar 2 argumentos
// 'Hola' por 'Saludos' y 'saludo' por 'dijo hola' 
$transfor = array('Hola' => 'Saludos', 'saludo' => 'dijo hola');

// Sustituir caracteres de esta cadena por los 
// elementos indicados en el Array '$transfor'. 
echo strtr('Hola a todos, me saludo', $transfor) . '<br />'; 

Transformar con 2 argumentos:

Saludos a todos, me dijo hola

Comparación del comportamiento strtr(): con tres argumentos, strtr() reemplaza bytes y con dos argumentos, puede reemplazar subcadenas más largas.

// Comparación del comportamiento 

// TRES ARGUMENTOS 
echo strtr('luzul', 'ul', '01'), '<br />'; // Transforma 'u' por '0' y 'l' por '1' 

//  DOS ARGUMENTOS 
$transfor2 = array('ul' => '01');
echo strtr('luzul', $transfor2); // Transforma 'ul' por '01' 

Comparación del comportamiento strtr()

TRES ARGUMENTOS

10z01

DOS ARGUMENTOS

luz01
Subir

substr_count(cadena, busca, inicioBusqueda, longitudBusqueda): Devuelve la cantidad de veces que aparece el texto busca dentro de cadena. Existe la posibilidad de un 3er y 4o parámetros, inicioBusqueda indica la posición de inicio de la búsqueda y longitudBusqueda longitud de la búsqueda. Sensible a mayúsculas y minúsculas.

// substr_count()

// Busca la cadena del 2o parámetro dentro del 1er parámetro 
echo substr_count ('Programar con PHP y con AJAX', 'con'); // Devuelve 2 coincidencias

Número de coincidencias: 2

// substr_count(cadena, busca, inicioBusqueda, longitudBusqueda)

// Uso de todos sus parámetros 
$str = "Estas aspero";
echo strlen ($str) . "<br />"; // Devolver la longitud de la  cadena 
echo substr_count ($str, "as") . "<br />"; // Veces que "as" tiene lugar en la cadena 
echo substr_count ($str, "as", 3) . "<br />"; // Cadena reducida a "as aspero" 
echo substr_count ($str, "as", 4) . "<br />"; // Cadena reducida a "s aspero" 
echo substr_count ($str, "as", 4, 3) . "<br />"; // Cadena reducida a "s a"  

Cadena: Estas aspero
Número de veces que aparece el texto según parámetros 3o y 4o
12 = longitud completa de la cadena.
2 = veces que 'as' tiene lugar en la cadena.
2 = cadena reducida a 'as aspero'.
1 = cadena reducida a 's aspero'.
0 = cadena reducida a 's a'.

Subir

Subdivisión de cadenas

strtok(): utiliza dos argumentos: uno es la cadena que debe analizar y subdividir en elementos o fokens y la otra cadena indica cuál es el delimitador a utiliza en el texto. La primem llamada a la función develve el primer elemento y se realiza un bucle de llamadas a la función strtok() para recorrer el resto de elementos, y omitirá la cadena que es analizada, sólo con el argumento del carácter separador.
El separador puede estar compuesto por más de un carácter, estos serán analizados individualmente y no como un grupo o secuencia de caracteres.

// strtok() 
$divCadena = "Cadenaydivididayporytextos";
  
  // Al encontrar el caracter 'y', divide 
  // el texto sin mostrar el delimitador 'y' 
  $token = strtok($divCadena, 'y ');

echo "Cadena a dividir: Cadenaydivididayporytextos";

echo "Resultado:";

	// Mientras variable distinto de 'false'
	// ejecutará el contenido del bucle.  
	while ($token != false){
   
		echo $token . '<br />'; // Devuelve texto dividido 
		
		$token = strtok('y'); // Volver a indicar delimitador 'y' 
	
    } 

Cadena a dividir: Cadenaydivididayporytextos
Resultado:

1/ Cadena
2/ dividida
3/ por
4/ textos
Subir

explode(): Separa la cadena en subcadenas y el resultado se coloca en una matriz siendo los elementos de esta las subcadenas obtenidas. El parámetro de separador puede tener uno o más caracteres y serán tratados como un conjunto o grupo, nunca individualmente, eso quiere decir que no cuenta que aparezca cualquier caracter del grupo, sino que a de aparecer esa secuencia de caracteres que forman el grupo completo.
Opcionalmente podremos entrar un tercer parámetro que indicará un límite; límite con valor positivo: la matriz devuelta tendrá como máximo esa cantidad de elementos y el último elemento tendrá el resto de la cadena.
Límite con valor negativo: devuelve una matriz con todos los elenrcntos excepto los últimos indicados por el valor límite. Si valor negativo es -2, la matriz resultante no incluirá los dos últimos elementos.
Si el valor del límite es 0. se tratará como si fuese un l.

// explode() 
$str = 'Cadena dividida por textos.';
	
	// Separador = espacio en blanco  
	$rslt = explode(" ", $str);
	
	// Recorrer valores 
	foreach($rslt as $clave => $valor){
		
		if($clave == 3):
		
			// Sin guión final 
			echo $clave . '/' . $valor;
		else:
		
			// Con guión final 
			echo $clave . '/' . $valor . ' - ';
		endif;
		
	}
	
	echo "<br />";

Cadena a dividir: Cadena dividida por textos.

0/Cadena - 1/dividida - 2/por - 3/textos.
Subir

Conversión de cadenas

bin2hex(cadena): Convierte byte a byte la cadena cadena a su representación hexadecimal.

// bin2hex()
Convertir cadena "peHpe 2 AJAX" a los valores hexadecimales 
$cadenabin = bin2hex ("peHpe 2 AJAX");

echo($cadenabin) . '<br />'; 

Convertir cadena 'peHpe 2 AJAX' a hexadecimal:

7065487065203220414a4158
// bin2hex()
// Convertir un valor de cadena de binario a hexadecimal y viceversa 

$bincadena2 = "PHP, XHTML";

// Convertir cadena a valor hexadecimal 
echo 'Valor hexadecimal de cadena: ' . bin2hex($bincadena2) . "<br />";

// Convierte valores en representación hexadecimal en caracteres ASCII 
// 'H*': 'H' = hexadecimal, '*' = resto de caracteres. 
echo 'Cadena de caracteres ASCII: ' . pack("H*",bin2hex($bincadena2)) . 
"<br />";

Valor hexadecimal de cadena: 5048502c205848544d4c

Cadena de caracteres ASCII: PHP, XHTML

Subir

str_split(cadena [,longitud]): convierte una cadena en una matriz. Si parámetro obcional [,longitud] se específica, devuelve array separado en fragmentos los cuales cada uno tendrá una longitud de [,longitud].
Si parámetro obcional [,longitud] no se específica, cada fragmento tendrá una longitud de 1 caracter.
Devuelverá false si [,longitud] es menor que 1. Si la longitud [,longitud] excede la longitud de , el string entero es devuelto como el primero y único elemento del array.

// str_split()
// Convierte cadena en Array 
$strDivision = str_split("JavaScript");

	foreach($strDivision as $clastr => $vlastr){
		
		echo $clastr . '/ ' . $vlastr;
		
	} 
0/ J1/ a2/ v3/ a4/ S5/ c6/ r7/ i8/ p9/ t
// str_split() 
$strCadena = 'XHTML-jQuery';

echo 'Dividir esta cadena cada "4" caracteres: ' . $strCadena . '';

// Especificar el parámetro de longitud
// Divide cadena cada '4' caracteres. 
	$cadDividida = str_split($strCadena ,4);
		
		// Recorrer elementos de cadena dividida 
		foreach($cadDividida as $strclave => $strvalor){
			
			echo $strclave . '/ ' . $strvalor . '<br />';
			
		} 

Dividir esta cadena cada "4" caracteres: XHTML-jQuery

0/ XHTM
1/ L-jQ
2/ uery
Subir

chunk_split(cadena [,longitud [,finLinea]]): Divide una cadena en trozos más pequeños.
Utilizado frecuentemente para dividir una cadena en trozos más pequeños.

// chunk_split() 
$chunkCadena = "PHP AJAX";

// Cada '1' carácter, hace un trozo de la cadena y coloca un guión '-' 
echo '' . chunk_split($chunkCadena, 1, " - ") . ''; 

Cadena: PHPAJAX

Cadena troceada:

-P - H - P - A - J - A - X - Subir

strtolower(cadena): Convierte la cadena cadena a minúsculas.

// strtolower()
// Convertir a minúsculas 
echo strtolower("html, AJAX, PHP") . '<br />'; 

Cadena a convertir a minúsculas: html, AJAX, PHP

html, ajax, php
Subir

strtoupper(cadena): Convierte la cadena cadena a mayúsculas.

// strtoupper()
// Convertir a mayúsculas 
echo strtoupper("html, AJAX, php") . '<br />' 

Cadena a convertir a mayúsculas: html, AJAX, php

HTML, AJAX, PHP
Subir

ucfirst(): Covrvierle el primer carácter de la cadena a mayúscula, siempre y cuando sea alfabético.

// ucfirst()
// Convertir primer caracter a mayúsculas 
echo ucfirst("html, ajax, php") . '<br />'

Convertir primer caracter a mayúsculas: html, ajax, php

Html, ajax, php
Subir

lcfirst(cadena): Convierte el primer carácter de la cadena a minúsculas, siempre y cuando sea de tipo string.

// lcfirst()
// Convertir primer caracter a minúsculas 
echo lcfirst("Html, AJAX, PHP") . '<br />'

Convertir primer caracter de una cadena a minúsculas: Html, AJAX, PHP

hTML, AJAX, PHP
Subir

ucwords(cadena): Convierte a mayúsculas el primer caracter de cada palabra en una cadena.

// ucwords()
// Convertir primer caracter a mayúsculas 
echo ucwords("html, ajax, php") . '<br />'

Cadena a convertir el 1er carácter de cada palabra a mayúsculas: html, ajax, php

Html, Ajax, Php
Subir

Recorte de cadenas

PHP dispone de estas funciones para recortar una cadena:

chop(cadena): Devuelve una cadena sin los caracteres de espacios y los caracteres de fin de línea que aparecen al final. Es un alias de la función rtrim().
Sensible a mayúsculas y minúsculas.

// chop()
// Eliminar caracteres desde el extremo derecho de la cadena 
$chopCadena = "Html5 CSS3";
echo 'Cadena completa: ' . $chopCadena . '<br />';
echo 'Eliminar texto: ' . chop($chopCadena, "CSS3"); // Eliminará texto 'CSS3'  

Cadena completa: Html5 CSS3

Eliminar texto: Html5

// chop()
// Eliminar saltos de línea '\n' desde el extremo derecho de cadena 
$chopCadena2 = "Html5 CSS3 \n\n";

// Cadena original con salto de línea final "\n\n" 
echo $chopCadena2;

// Eliminar saltos de línea anterior 
echo chop($chopCadena2);  
Html5 CSS3 Html5 CSS3
Subir

trim(cadena [,caracteres_a_ser_eliminados]): Devuelve la cadena sin los carásteres de espacio (u otro tipo de caracteres) que aparecen al principio y al final de la cadena.
trim() eliminará estos otros caracteres:

// trim()
// Eliminar saltos de línea '\n' de inicio y final de cadena 
$trimCadena = "\n\n Html5 CSS3 \n\n";

// Cadena original con salto de línea inicial y final "\n\n" 
echo '$trimCadena;

echo '<br />';

// Eliminar saltos de línea inicial y final: 
echo trim($trimCadena); 
Html5 CSS3
Html5 CSS3
// trim()
// Eliminar caracteres indicados de inicio y final de cadena 
$trimCadena2 = "Html5 CSS3";

// Cadena original 
echo  $trimCadena2;

echo '<br />Eliminar los caracteres indicados  
      en el parámetro opcional "Ht3"<br />';

// Eliminar caracteres indicados de inicio y fin de cadena 
echo trim($trimCadena2, 'Ht3'); 

Cadena original:

Html5 CSS3

Eliminar los caracteres indicados en el parámetro opcional "Ht3"

ml5 CSS
Subir

ltrim(cadena [,caracteres_a_ser_eliminados]): Devuelve una cadena sin los caracteres secuenciales de la parte izquierda (inicio) de una cadena.
Sensible a mayúsculas y minúsculas.
trim() eliminará los caracteres:

// trim()
// Cadena a modificar 
$ltrimCadena = 'jQuery y CSS3';

// Eliminamos caracteres indicados 
echo trim($ltrimCadena, "jQuery"); // Devuelve y CSS3  

Eliminar caracteres indicados de la izquierda (jQuery)

y CSS3
// ltrim() 
$ltrimCadena2 = "\n\n\nXHTML JavaScript";

echo "Sin función ltrim(): " . $ltrimCadena2;

echo "<br />";

// Eliminamos saltos de lína de la izquierda 
echo "Con función ltrim(): " . ltrim($ltrimCadena2); 

Eliminamos los 3 saltos de línea en la segunda cadena.

Sin función ltrim(): XHTML JavaScript
Con función ltrim():XHTML JavaScript
Subir

rteim(cadena): Devuelve una cadena sin los caracteres de espacios y los caracteres de fin de línea que aparecen al final. Es un alias de la función chop().
Sensible a mayúsculas y minúsculas.

// rtrim()
// Eliminar caracteres desde el extremo derecho de la cadena 
$rtrimCadena = "Html5 CSS3";
echo 'Cadena completa: ' . $rtrimCadena . '<br />';
echo 'Eliminar texto: ' . rtrim($rtrimCadena, "CSS3"); // Eliminará texto 'CSS3'  

Cadena completa: Html5 CSS3

Eliminar texto: Html5

Subir

Relleno de cadenas

str_pad(cadena, longitud [,relleno [,tipo_relleno]): Rellena una cadena hasta la longitud indicada por el parámetro longitud, el parámetro relleno es opcional, si no se indica nada en este parámetro indicará espacio en blanco.
El tipo de relleno puede ser STR_PAD_RIGHT(relleno por la derecha 'predeterminada'), STR_PAD_LEFT(relleno por la izquierda) y STR_PAD_BOTH(relleno por ambos extremos equilibradamente).

// str_pad() 

$padCadena = "XHTML";

echo 'Espacios derecha (predeterminado): ' . str_pad($padCadena, 10); 
// Devuelve "XHTML     " 

echo 'Relleno izquierda: ' . str_pad($padCadena, 10, """", STR_PAD_LEFT); 
// Devuelve """"""XHTML" 

echo 'Ambos extremos: ' . str_pad($padCadena, 11, "[^]", STR_PAD_BOTH); 
// Devuelve "[^]XHTML[^]" 

echo 'Relleno derecha: ' . str_pad($padCadena, 8 , "****"); 
// Devuelve "XHTML***"  

Espacios derecha (predeterminado): XHTML

Relleno izquierda: """""XHTML

Relleno ambos extremos: [^]XHTML[^]

Relleno derecha: XHTML***

Máscara de caracteres

Marcado de caracteres especiales. Estos caracteres los podemos escapar con la (\) barra invertida, pero PHP incluye funciones para añadir o eliminar autotomáticamente los caracteres de escape (\).

addslashes(cadena): Añade barras invertidas (\) a una cadena para los caracteres de escape.
Devuelve una cadena con barras invertidas delante de los carácteres que necesitan escaparse en situaciones como consultas de bases de datos, etc. Los carácteres que se escapan son la comilla simple ('), comilla doble ("), barra invertida (\) y NUL (el byte NULL).
Nota: PHP se ejecuta addslashes() en los GET, POST, y COOKIE por defecto. Por lo tanto, no debemos utilizar addslashes() en cadenas que ya se han escapado. Este causará doble escape. El get_magic_quotes_gpc función () se puede utilizar para comprobar esto.

// addslashes() 
$addslashesEscape = "¿Quién es 'Rasmus Lerdorf '?";

// Sin escapar caracteres 
echo $addslashesEscape . " Consulta NO SEGURA hacia base de datos.<br />";

// Función para escapar caracteres especiales 
echo addslashes($addslashesEscape) . " Consulta SEGURA hacia base de datos."; 

// Escapar comillas simples: 
echo addslashes("Sir. O'Conner") . " Escapar comillas simples.";
¿Quién es 'Rasmus Lerdorf'? Consulta NO SEGURA hacia base de datos.
¿Quién es \'Rasmus Lerdorf\'? Consulta SEGURA hacia base de datos.

Escapar comilla simple:
Sir. O\'Conner Escapar comillas simples.

Subir

stripslashes(cadena): Esta función eliminará las barras invertidas agregadas por la función addslashes().
Nota: Esta función se puede utilizar para limpiar los datos recuperados de una base de datos o de un formulario HTML.

// stripslashes() 
echo "Eliminar barras invertidas de escape: <br />";

// Función para eliminar barra invertida de caracteres escapados 
echo stripslashes("Sir. O\'Conner"); 

Eliminar barras invertidas de escape:
Sir. O'Conner.

Subir

addcslashes(cadena, lista): Si parámetro lista contiene caracteres como , , , etc., seran convertidos en la misma forma y manera que el estilo de C, y los caracteres con códico ASCII inferior a 32 y superior a 126 serán convertidos a representación octal, (ejemplo: \0, .., \31), indicará rango de 0 a 31.
Si el primer carácter del rango tiene un valor ASCII superior al segundo carácter que define el rango, no se puede formar el rango. Es decir, que no se pueden definir rangos descendentes y por tanto solo se escaparán el primer carácter del rango, el segundo y los puntos que separan a los caracteres. Para obtener el valor ASCII de un carácter, podremos utilizar la función:

// addcslashes()
// Escapar el primer caracter de una cadena 
echo 'Escapar los caracteres 'a' de la cadena: ' JavaScript o jQuery ' <br />';

$addcsCadena = addcslashes('JavaScript o jQuery', 'a');
echo $addcsCadena; 

Escapar los caracteres "a" de esta cadena: "JavaScript o jQuery"
J\av\aScript o jQuery

// addcslashes()
// Barras invertidas, indicando a que caracteres se a de agregar para una cadena 
$addcsCadena2 = "Lenguaje PHP creado por ' Rasmus Lerdorf '";

echo 'Cadena a escapar: ' . $addcsCadena2;

echo 'Escapar las (r):' . addcslashes($addcsCadena2, 'r');

echo 'Escapar las (comillas simples y L):' . addcslashes($addcsCadena2,'\'L'); 

Cadena a escapar:
Lenguage PHP creado por ' Rasmus Lerdorf '

Escapar las (r):

Lenguaje PHP c\reado po\r ' Rasmus Le\rdo\rf '

Escapar las (comillas simples y L):

\Lenguaje PHP creado por \' Rasmus \Lerdorf \'

// addcslashes()
// Barras invertidas a una serie de caracteres de una cadena 
$addcsCadena3 = "Lenguaje PHP creado por ' Rasmus Lerdorf ' ";

// Cadena original 
echo $addcsCadena3 . '<br />';

// Escapar todas las mayúsculas 
echo addcslashes($addcsCadena3, 'A..Z') . '<br />';

// Escapar todas las minúsculas 
echo addcslashes($addcsCadena3, 'a..z') . '<br />';

// Escapar minúsculas de la 'a' hasta la 'p', ambas incuidas 
echo addcslashes($addcsCadena3, 'a..p');
Cadena original
Lenguaje PHP creado por ' Rasmus Lerdorf '

Escapar todas las mayúsculas
\Lenguaje \P\H\P creado por ' \Rasmus \Lerdorf '

Escapar todas las minúsculas
L\e\n\g\u\a\j\e PHP \c\r\e\a\d\o \p\o\r ' R\a\s\m\u\s L\e\r\d\o\r\f '

Escapar minúsculas de la 'a' hasta la 'p', ambas incuidas
L\e\n\gu\a\j\e PHP \cr\e\a\d\o \p\or ' R\as\mus L\er\d\or\f 'Subir

ord(), Devuelve el valor ASCII como un entero, del primer carácter de una cadena.

// FUNCIÓN ord()

// Valor ASCII del primer carácter 
echo ord('X') . '<br />'; // Devuelve 88 

// Valor ASCII del primer carácter 
echo ord('XHTML') . '<br />'; // Devuelve 88 

Cadena: X y XHTML; cacar el valor ASCII del primer carácter con función ord():

X => 88
XHTML => 88

Subir

stripcslashes(cadena): Devuelve una cadena sin las barras invertidas. Reconoce las marcas tipo C , , , ... etc, y también la representación octal y hexadecimal.

// stripcslashes()

// Elimina la barra invertida (\) 
echo stripslashes("AJAX, \PHP"); // Devuelve: AJAX, PHP  
AJAX, PHP
Subir

quotemeta(cadena): Develve una cadena de caracteres con una bara invertida delante de cada uno de los siguientes caracteres: ., \, +, *, [, ?, ], (, ), $, ^ 'acento circunflejo'.
Devuelve FALSE si una cadena vacía es dada como str. Esta función es segura con material binario.

// quotemeta()

$quoteCaracter = "(PHP) o (HTML). Que prefieres? ";

echo 'Cadena a tratar: ' . $quoteCaracter;

// Agregar barra invertida a caracteres predefinidos 
echo quotemeta($quoteCaracter); 

Agregar barras invertidas delante de los caracteres predefinidos

Cadena a tratar: (PHP) o (HTML). Que prefieres?

\(PHP\) o \(HTML\)\. Que prefieres\?
// quotemeta()

$quot1 = "2 + 2 = 4";
$quot2 = "4 * 1 = 4";
$quot3 = "Curso PHP. 100 $";
$quot4 = "Como programar rápido ?";
$quot5 = "'^' señalaba que ch y x se pronunciaban [ k ] y [ ks ] ...";

// Agregar barras invertidas a los caracteres predefinidos 
echo quotemeta($quot1) . '<br />';
echo quotemeta($quot2) . '<br />';
echo quotemeta($quot3) . '<br />';
echo quotemeta($quot4) . '<br />';
echo quotemeta($quot5) . '<br />'; 

Agregar barras invertidas delante de varios caracteres predefinidos

2 \+ 2 = 4
4 \* 1 = 4
Curso PHP\. 100 \$
Como programar rápido \?
'\^' señalaba que ch y x se pronunciaban \[ k \] y \[ ks \] \.\.\.
Subir

strip_tags(cadena [,etiqueta_permitida]): Elimina de la cadena las etiquetas HTML y PHP.
Se puede usar un segundo parámetro [,etiqueta_permitida] opcional para especificar cuales etiquetas no deben ser retiradas.

// strip_tags() 

// Párrafo a tratar 
$stripEtiqueta = '<p>Permite etiquetas de <strong>párrafos</strong> e imagenes
		    <img src="../../images/iconoPHP.png" />,
		    <br /> pero el resto las <a href='#'>elimina</a>. <p>';

// Sin la función strip_tags() 
echo 'Sin strip_tags():';
echo $stripEtiqueta;

// Con strip_tags(), permite etiquetas <p> y <img> 
echo "Con strip_tags(), permite etiquetas <p> e <img>:"; 
echo strip_tags($stripEtiqueta, ' <p><img> ');

Sin strip_tags():

Permite etiquetas de párrafos e imagenes ,
pero el resto las elimina.

Con strip_tags(), permite etiquetas <p> e <img>:

Permite etiquetas de párrafos e imagenes , pero el resto las elimina.

// strip_tags() 
echo "<p>Sin strip_tags():  ----> Programar <estrong><u>Java</u></strong> </p>";

echo "<p> Con strip_tags(): ----> ";

// El segundo parámetro especifica las etiquetas permitidas 
echo strip_tags("Programar <strong><u>Java</u></strong>", "<strong>") . '</p>'; 

Esta cadena permite la etiqueta '<strong>'

Sin strip_tags(): -----> Programar Java

Con strip_tags(): ----> Programar Java

Subir

Transformación para HTML

Convertir caracteres en entidades se utilizan a menudo para evitar que los navegadores lo utilicen como un elemento HTML. Esto puede ser especialmente útil para evitar que el código se ejecute cuando los usuarios tienen acceso a la pantalla de entrada de su página principal.

Funciones transformación para HTML:

htmlentities(cadena [,indicadores [, codificacion [, bool codificacion_doble]]]): Convierte cadena para que esos caracteres sean utilizables en HTML. Es decir convierte los caracteres a entidades HTML.
Los caracteres que no se traducen a una entidad HTML se mantendrán sin cambio alguno. Se trabajará con el juego de caracteres ISO-8859-I.

Para el segundo parámetro '[,indicadores]', una máscara de bits de uno o más de los siguientes indicadores, especificarán como manejar las comillas, secuencias de unidad de código inválidas y el tipo de documento utilizado. Por defecto es ENT_COMPAT | ENT_HTML401.

Constantes disponibles para indicadores

Para el tercer parámetro (opcional) se define la codificación usada en la conversión. Si se omite, el valor por defecto para este argumento es ISO-8859-1 en versiones de PHP anteriores a 5.4.0, y es UTF-8 desde PHP 5.4.0 en adelante. Aunque este argumento es técnicamente opcional, es altamente recomendable especificar el valor correcto para el código.

Caracteres soportados:

Para el cuarto parámetro : Cuando se desactiva codificacion_doble PHP no codificará a las entidades html existentes. El valor por defecto es convertir todo.
Devuelve la cadena codificada.
Si la cadena de entrada contiene una secuencia de unidad de código no válida dentro del parámetro codificacion dado, una cadena vacía será devuelta, a menos que se definan los indicadores ENT_IGNORE o ENT_SUBSTITUTE.

// htmlentities() 
$entidad = "'PHP' lo creó "Rasmus Lerdorf"";


echo "Tratar las comillas:, los acentos los cuenta como caracteres.";


echo 'CADENA: ';


// Cadena original 
echo $entidad;


// Longitud de la cadena original 
print "Longitud de la cadena original: " . strlen($entidad) . " caracteres";


// Produce: La 'cita' está en <strong>negrita</strong>
// Convierte las comillas dobles y deja las sencillas 
echo 'ENT_COMPAT por defecto: ' . htmlentities($entidad) . ' => ';
// Longitud de la cadena 
print "Longitud : " . strlen($entidad) . " caracteres";


// Produce: La &\#039;cita&\#039; está en <strong>negrita</strong>
// Convierte las comillas dobles y deja las sencillas 
echo 'ENT_COMPAT: ' . htmlentities($entidad, ENT_COMPAT) . ' => ';
// Longitud de la cadena 
print "Longitud : " . strlen(htmlentities($entidad, ENT_COMPAT)) . 
					" caracteres";


// Convierte las comillas dobles y sencillas 
echo 'ENT_QUOTES: ' . htmlentities($entidad, ENT_QUOTES) . ' => ';
// Longitud de la cadena 
print "Longitud : " . strlen(htmlentities($entidad, ENT_QUOTES)) . 
					" caracteres";


// Comillas dobles y sencillas sin convertir 
echo 'ENT_NOQUOTES: ' . htmlentities($entidad, ENT_NOQUOTES) . ' => ';
// Longitud de la cadena 
print "Longitud: " . strlen(htmlentities($entidad, ENT_NOQUOTES)) . 
					" caracteres "; 

Tratar las comillas:, los acentos los cuenta como caracteres.

CADENA: 'PHP' lo creó "Rasmus Lerdorf"
Longitud de la cadena original: 48 caracteres
ENT_COMPAT por defecto: 'PHP' lo creó <strong>"Rasmus Lerdorf"</strong> => Longitud : 48 caracteres
ENT_COMPAT: 'PHP' lo creó <strong>"Rasmus Lerdorf"</strong> => Longitud : 76 caracteres
ENT_QUOTES: 'PHP' lo creó <strong>"Rasmus Lerdorf"</strong> => Longitud : 86 caracteres
ENT_NOQUOTES: 'PHP' lo creó <strong>"Rasmus Lerdorf"</strong> => Longitud : 66 caracteres

// htmlentities(ENT_QUOTES, " UTF-8 ") x8\TqFiM4^ 

// Reemplaza los caracteres inválidos por el carácter (  )
// \x8F = Carácter especial que no muestra todo lo que tiene detrás de él 
$entidadvacia = "!!!"; 

echo 'Cadena vacia: ';

// Longitud cadena 
echo 'Longitud cadena: ' . strlen($entidadvacia) . '';
// Produce una cadena vacía 
echo 'CADENA vacia: ' . htmlentities( $entidadvacia, ENT_QUOTES, " UTF-8 " ); 

Cadena vacia:

Longitud cadena: 9
CADENA vacia:

//  htmlentities(ENT_IGNORE, 'UTF-8') 

// Simplemente no muestra todas las secuencias de unidad de código no válidas.
// Lo que veremos en su lugar seria algo así (  ) 
$ignore = "!!!";

echo " Constante predefinida ENT_IGNORE ";
// Longitud cadena 
echo 'Longitud cadena: ' . strlen($ignore);

// Devuelve "!!!" 
echo 'CADENA: ' . htmlentities( $ignore, ENT_QUOTES | ENT_IGNORE, " UTF-8 " ); 

Constante predefinida ENT_IGNORE

Longitud cadena: 4
CADENA: !!!

// htmlspecialchars(ENT_IGNORE)

// Reemplaza los caracteres inválidos por el carácter (  ) 
$ignore = 'ab';

// ENT_IGNORE Abandona todas las secuencias de unidad de código no válidos 
echo 'CADENA: ' . $ignore;

// Longitud de cadena 
echo 'Longitud cadena original: ' . strlen($ignore);

echo 'Cadena convertida: ' . htmlspecialchars($ignore, ENT_IGNORE); 
// Devuelve ab 

// Longitud de cadena convertida
echo 'Longitud cadena convertida: ' . 
		strlen(htmlspecialchars($ignore, ENT_IGNORE));

CADENA: ab
Longitud cadena original: 3
Cadena convertida: ab
Longitud cadena convertida: 2

Subir

htmlspecialchars(cadena): Es similar a la función htmlentities() salvo que la conversión está limitada a los siguientes caracteres: &, comilla doble, < y >, que los reemplaza por amp, quot, lt y gt respectivamente.

// htmlspecialchars(ENT_IGNORE)

// ENT_QUOTES: convertirá comillas dobles como ( &ldquo; &rdquo; )
// y comillas sencillas como ( &lsquo; &rsquo; ).

// ENT_HTML5: Maneja el código como HTML 5.

// ENT_DISALLOWED:  Reemplaza los puntos de código no válidos para el tipo de documento
// dado que se entregará con un Caracter de Reemplazo Unicode U+FFFD (UTF-8) o &#FFFD.

// ENT_SUBSTITUTE:  Reemplaza las secuencias de unidad de código inválidas 
// con un Caracter Unicode de Reemplazo U+FFFD (UTF-8) ó &#FFFD.

// ENT_IGNORE: descarta unidades de secuencia de código no válidas en lugar de 
				devolver una cadena vacía. 

echo htmlspecialchars( " <\x80Se Acabó\xef\xbf\xbf> ", ENT_QUOTES | ENT_HTML5 |
                   		ENT_DISALLOWED | ENT_SUBSTITUTE, 'UTF-8');
                                        
echo htmlspecialchars( " <\x80Se Acabó\xef\xbf\xbf> ", ENT_QUOTES | ENT_HTML5 |
                   		ENT_DISALLOWED | ENT_IGNORE, 'UTF-8'); 

Cadena a tratar: <\x80Se Acabó\xef\xbf\xbf>

ENT_SUBSTITUTE: <�Se Acabó�>
ENT_IGNORE: <Se Acabó�>

Comillas dobles = &ldquo; &rdquo;.
Comillas sencillas = &lsquo; &rsquo;.

Subir

nl2br(cadena): Convierte los caracteres de nueva línea por los saltos de línea de HTML.

// nl2br()
// Convierte salto de nueva línea (\n) por etiqueta (<br />)
// '\n' salto, la cadena funciona con COMILLAS DOBLES, las COMILLAS SIMPLES NO !   
$salto1 = "Línea uno.\n Línea dos.";

// Convertir cadena    
$salto2 = nl2br ($salto1);
 

echo 'Cadena original: ' . $salto1 . ' <br />';

// Longitud cadena   
echo 'Longitud cadena original: ' . strlen ($salto1) . ' <br />';

// Conversión   
echo 'Cadena convertida: <br />' . $salto2; // primera línea. <br /> segunda línea. 

// Longitud cadena   
echo '<br />Longitud cadena convertida: '. strlen ($salto2); 

nl2br(): salto de línea \n a saltos de HTML <br />

Cadena original: Línea uno. Línea dos.
Longitud cadena original: 24
Cadena convertida:
Línea uno.
Línea dos.

Longitud cadena convertida: 30

get_html_translation_table(): devuelve la tabla de traducción de entidades utilizada por las funciones htmlentities() y htmlspecialchars(), devolviendo la codificación más común.

// get_html_translation_table() 

// Muestra caracteres 
var_dump (get_html_translation_table(HTML_SPECIALCHARS));
// Devuelve entidades para HTML_SPECIALCHARS: 
    ["] => &quot;
    [&] => &amp;
    [<] => &lt;
    [>] => &gt;
  
var_dump (get_html_translation_table(HTML_ENTITIES)); 
// Devuelve entidades para HTML_ENTITIES: 
    ["] => &quot;
    [&] => &amp;
    [<] => &lt;
    [>] => &gt;
    [ ] => &nbsp;
    [¡] => &iexcl;
    [¢] => &cent;
    [£] => &pound;
    [¤] => &curren;
    [¥] => &yen;
    ........... más entidades. 
entidades para HTML_SPECIALCHARS: 
	["] => &quot;
	[&] => &amp;
	[<] => &lt;
	[>] => &gt;

entidades para HTML_ENTITIES: 
	["] => &quot;
	[&] => &amp;
	[<] => &lt;
	[>] => &gt;
	[ ] => &nbsp;
	[¡] => &iexcl;
	[¢] => &cent;
	[£] => &pound;
	[¤] => &curren;
	[¥] => &yen;
	[¦] => &brvbar;
	[§] => &sect;
	[¨] => &uml;
	[©] => &copy;
	[ª] => &ordf;
	[«] => &laquo;
	[¬] => &not;
	[­] => &shy;
	[®] => &reg;
	[¯] => &macr;
	[°] => &deg;
	[±] => &plusmn;
	[²] => &sup2;
	[³] => &sup3;
	[´] => &acute;
	[µ] => &micro;
	[¶] => &para;
	[·] => &middot;
	[¸] => &cedil;
	[¹] => &sup1;
	[º] => &ordm;
	[»] => &raquo;
	[¼] => &frac14;
	[½] => &frac12;
	[¾] => &frac34;
	[¿] => &iquest;
	[À] => &Agrave;
	[Á] => &Aacute;
	[Â] => &Acirc;
	[Ã] => &Atilde;
	[Ä] => &Auml;
	[Å] => &Aring;
	[Æ] => &AElig;
	[Ç] => &Ccedil;
	[È] => &Egrave;
	[É] => &Eacute;
	[Ê] => &Ecirc;
	[Ë] => &Euml;
	[Ì] => &Igrave;
	[Í] => &Iacute;
	[Î] => &Icirc;
	[Ï] => &Iuml;
	[Ð] => &ETH;
	[Ñ] => &Ntilde;
	[Ò] => &Ograve;
	[Ó] => &Oacute;
	[Ô] => &Ocirc;
	[Õ] => &Otilde;
	[Ö] => &Ouml;
	[×] => &times;
	[Ø] => &Oslash;
	[Ù] => &Ugrave;
	[Ú] => &Uacute;
	[Û] => &Ucirc;
	[Ü] => &Uuml;
	[Ý] => &Yacute;
	[Þ] => &THORN;
	[ß] => &szlig;
	[à] => &agrave;
	[á] => &aacute;
	[â] => &acirc;
	[ã] => &atilde;
	[ä] => &auml;
	[å] => &aring;
	[æ] => &aelig;
	[ç] => &ccedil;
	[è] => &egrave;
	[é] => &eacute;
	[ê] => &ecirc;
	[ë] => &euml;
	[ì] => &igrave;
	[í] => &iacute;
	[î] => &icirc;
	[ï] => &iuml;
	[ð] => &eth;
	[ñ] => &ntilde;
	[ò] => &ograve;
	[ó] => &oacute;
	[ô] => &ocirc;
	[õ] => &otilde;
	[ö] => &ouml;
	[÷] => &divide;
	[ø] => &oslash;
	[ù] => &ugrave;
	[ú] => &uacute;
	[û] => &ucirc;
	[ü] => &uuml;
	[ý] => &yacute;
	[þ] => &thorn;
	[ÿ] => &yuml;
	[Œ] => &OElig;
	[œ] => &oelig;
	[Š] => &Scaron;
	[š] => &scaron;
	[Ÿ] => &Yuml;
	[ƒ] => &fnof;
	[ˆ] => &circ;
	[˜] => &tilde;
	[Α] => &Alpha;
	[Β] => &Beta;
	[Γ] => &Gamma;
	[Δ] => &Delta;
	[Ε] => &Epsilon;
	[Ζ] => &Zeta;
	[Η] => &Eta;
	[Θ] => &Theta;
	[Ι] => &Iota;
	[Κ] => &Kappa;
	[Λ] => &Lambda;
	[Μ] => &Mu;
	[Ν] => &Nu;
	[Ξ] => &Xi;
	[Ο] => &Omicron;
	[Π] => &Pi;
	[Ρ] => &Rho;
	[Σ] => &Sigma;
	[Τ] => &Tau;
	[Υ] => &Upsilon;
	[Φ] => &Phi;
	[Χ] => &Chi;
	[Ψ] => &Psi;
	[Ω] => &Omega;
	[α] => &alpha;
	[β] => &beta;
	[γ] => &gamma;
	[δ] => &delta;
	[ε] => &epsilon;
	[ζ] => &zeta;
	[η] => &eta;
	[θ] => &theta;
	[ι] => &iota;
	[κ] => &kappa;
	[λ] => &lambda;
	[μ] => &mu;
	[ν] => &nu;
	[ξ] => &xi;
	[ο] => &omicron;
	[π] => &pi;
	[ρ] => &rho;
	[ς] => &sigmaf;
	[σ] => &sigma;
	[τ] => &tau;
	[υ] => &upsilon;
	[φ] => &phi;
	[χ] => &chi;
	[ψ] => &psi;
	[ω] => &omega;
	[ϑ] => &thetasym;
	[ϒ] => &upsih;
	[ϖ] => &piv;
	[ ] => &ensp;
	[ ] => &emsp;
	[ ] => &thinsp;
	[‌] => &zwnj;
	[‍] => &zwj;
	[‎] => &lrm;
	[‏] => &rlm;
	[–] => &ndash;
	[—] => &mdash;
	[‘] => &lsquo;
	[’] => &rsquo;
	[‚] => &sbquo;
	[“] => &ldquo;
	[”] => &rdquo;
	[„] => &bdquo;
	[†] => &dagger;
	[‡] => &Dagger;
	[•] => &bull;
	[…] => &hellip;
	[‰] => &permil;
	[′] => &prime;
	[″] => &Prime;
	[‹] => &lsaquo;
	[›] => &rsaquo;
	[‾] => &oline;
	[⁄] => &frasl;
	[€] => &euro;
	[ℑ] => &image;
	[℘] => &weierp;
	[ℜ] => &real;
	[™] => &trade;
	[ℵ] => &alefsym;
	[←] => &larr;
	[↑] => &uarr;
	[→] => &rarr;
	[↓] => &darr;
	[↔] => &harr;
	[↵] => &crarr;
	[⇐] => &lArr;
	[⇑] => &uArr;
	[⇒] => &rArr;
	[⇓] => &dArr;
	[⇔] => &hArr;
	[∀] => &forall;
	[∂] => &part;
	[∃] => &exist;
	[∅] => &empty;
	[∇] => &nabla;
	[∈] => &isin;
	[∉] => &notin;
	[∋] => &ni;
	[∏] => &prod;
	[∑] => &sum;
	[−] => &minus;
	[∗] => &lowast;
	[√] => &radic;
	[∝] => &prop;
	[∞] => &infin;
	[∠] => &ang;
	[∧] => &and;
	[∨] => &or;
	[∩] => &cap;
	[∪] => &cup;
	[∫] => &int;
	[∴] => &there4;
	[∼] => &sim;
	[≅] => &cong;
	[≈] => &asymp;
	[≠] => &ne;
	[≡] => &equiv;
	[≤] => &le;
	[≥] => &ge;
	[⊂] => &sub;
	[⊃] => &sup;
	[⊄] => &nsub;
	[⊆] => &sube;
	[⊇] => &supe;
	[⊕] => &oplus;
	[⊗] => &otimes;
	[⊥] => &perp;
	[⋅] => &sdot;
	[⌈] => &lceil;
	[⌉] => &rceil;
	[⌊] => &lfloor;
	[⌋] => &rfloor;
	[〈] => &lang;
	[〉] => &rang;
	[◊] => &loz;
	[♠] => &spades;
	[♣] => &clubs;
	[♥] => &hearts;
	[♦] => &diams; 
// get_html_translation_table() 

// Podemos ver fácilmente la transformación echando un vistazo a las tablas de conversión
// ENT_HTML401, ENT_HTML5, ENT_XML1 y ENT_XHTML 

// Caracteres especiales en los diferentes tipos de documentos actuales
// Devuelve: array (size = 5) 
var_dump (get_html_translation_table( HTML_ENTITIES ,  ENT_QUOTES  |  
							     ENT_XML1 ));

// Devuelve: array (size = 253) 
var_dump (get_html_translation_table( HTML_ENTITIES ,  ENT_QUOTES  |  
							   ENT_HTML401 ));

// Devuelve: array (size = 1510) 
var_dump (get_html_translation_table( HTML_ENTITIES ,  ENT_QUOTES  |  
							     ENT_HTML5 ));

// Devuelve: array (size = 253) 
var_dump (get_html_translation_table( HTML_ENTITIES ,  ENT_QUOTES  |  
							     ENT_XHTML )); 
Subir

html_entity_decode(cadena [, estilocomillas[, juegocaracteres]]): es lo opuesto de la función htmlentities(). html_entity_decode() convierte todas las entidades HTML que aparecen en el parámetro cadena a sus caracteres correspondientes.
El parámetro [, juegocaracteres] define el juego de caracteres que se emplea en la conversión ISO-88-59-1, Europeo Occidental, Latín-1.

// html_entity_decode() 

$cadena = 'Programar "PHP & AJAX" no tienen > difcultad, que JS.';


$cadA = htmlentities($cadena);

$cadB = html_entity_decode($cadA);

// Programar \"PHP &amp; AJAX\" no tienen &gt;  &lt; strong &gt; dificultad &lt; /strong &gt;, que JS. 
echo 'Con htmlentities(): ' . $cadA . '<br />'; 

// Programar "PHP & AJAX" no tienen <strong&gt;dificultad</strong>, que JS. 
echo 'Con html_entity_decode: ' . $cadB . '<br />'; 

Con htmlentities(): Programar "PHP &amp; AJAX" no tienen <em>&gt;</em> <strong>difcultad</strong>, que JS.
Con html_entity_decode: Programar "PHP & AJAX" no tienen > difcultad, que JS.

Subir

htmlspecialchars_decode(cadena): Es lo opuesto a la función htmlspecialchars(). Es decir, convierte entidades HTML especiales de nuevo en los caracteres.
Las entidades convertidas son: &amp;, " (cuando ENT_NOQUOTES no se ha establecido) y ' (cuando ENT_QUOTES se ha establecido), &lt; y &gt.

// htmlspecialchars_decode() 

$specialchars = " ( jQuery ) & ' AJAX ' ";

echo 'Cadena a tratar:  &#040; jQuery &#041; &amp; &#039; AJAX &#039; ';

// Sólo Convertirá las comillas dobles 
echo 'htmlspecialchars_decode() con tipo de dato: ENT_COMPAT' . 
		htmlspecialchars_decode($specialchars, ENT_COMPAT); 
echo "<br />";

// Convierte comillas dobles y simples 
echo 'htmlspecialchars_decode() con tipo de dato: ENT_QUOTES' . 
		htmlspecialchars_decode($specialchars, ENT_QUOTES); 
echo "<br />";

// No convierte comillas dobles ni sencillas 
echo 'htmlspecialchars_decode() con tipo de dato: ENT_NOQUOTES' . 
		htmlspecialchars_decode($specialchars, ENT_NOQUOTES); 

Cadena a tratar: &#040; jQuery &#041; &amp; &#039; AJAX &#039;
Longitud: 45

htmlspecialchars_decode() con tipo de dato: ENT_COMPAT( jQuery ) & ' AJAX '
Longitud: 41
htmlspecialchars_decode() con tipo de dato: ENT_QUOTES( jQuery ) & ' AJAX '
Longitud: 31
htmlspecialchars_decode() con tipo de dato: ENT_NOQUOTES( jQuery ) & ' AJAX '
Longitud: 41

Subir

Expresiones regulares

Las expresiones regulares son patrones de texto y permiten definir patrones de coincidencia y aplicarlos a cadenas de texto para conocer si esa cadena o parte de ella cumple el patrón al compararse, incluso realizan transformaciones de la cadena.
Debemos tener muy claro cuando usar una expresión regular, ya que utilizarlas con exceso hace considerablemente más costoso el procesamiento que una sencilla búsqueda de strings, por ejemplo utilizando strstr.
Existen varias clases de expresiones regulares:

Códigos especiales

Crear una expresión regular equivale a crear un string especial para hacer una búsqueda y comparación en otro string. Si esta expresión coincide (hace "match" o coincidencia) en el string, el resultado de la operación es satisfactoria.

METACARACTERES
Patrón Explicación
$ Metacaracter, Coincidencia al final del string o (fin línea, en modo multilínea).
. Metacaracter, Coincide con cualquier carácter excepto con el de nueva línea (por defecto).
| Metacaracter, Inicio de rama alternativa.
\ Metacaracter, Carácter de escape general, para escribir delante de caracteres especiales: ^ . [ ] % ( ) | * ? { } \
^ Metacaracter, Coincidencia al principio del string o (línea, en modo multilínea).
< > Metacaracter, Concuerda con una palabra.
\s Metacaracter, Coincidencia con cualquier espacio en blanco.
\S Metacaracter, Coincidencia con cualquier carácter que no sea un espacio en blanco.
\d Metacaracter, Coincidencia con cualquier dígito.
\D Metacaracter, Coincidencia con cualquier carácter que no sea un dígito.
\w Metacaracter, Coincidencia con cualquier carácter que pueda ser parte de una palabra (letra, digitos, guión bajo, tildes, ñ, ç, ...).
\W Metacaracter, Coincidencia con cualquier carácter que no pueda ser parte de una palabra (letra, número, guión bajo).
\A Metacaracter, Inicio de un string.
\a Metacaracter, alarma, esto es, el caracter BEL (hexadecimal 07).
\Z Metacaracter, Final de un string.
\z Metacaracter, fin de la cadena de asunto (independiente del modo multilínea).
\cx Metacaracter, 'control-x', donde x es cualquier caracter.
\e Metacaracter, esc o escape (hexadecimal 1B).
\f Metacaracter, alimentación de página (hexadecimal 0C).
\xhh Metacaracter, caracter con código hexadecimal hh.
\ddd Metacaracter, aracter con código octal ddd, o referencia hacia atrás.
\b Metacaracter, límite de palabra.
\B Metacaracter, no-límite de palabra.
\G Metacaracter, primera posición de coincidencia en el asunto.
\040 Metacaracter, es otro modo de escribir un espacio.
\40 Metacaracter, es lo mismo, siempre que haya menos de cuarenta sub-patrones de captura previos .
\7 Metacaracter, siempre es una referencia hacia atrás.
\11 Metacaracter, puede ser una referencia hacia atrás, u otra forma de escribir un tabulador .
\011 Metacaracter, siempre es un tabulador.
\0113 Metacaracter, es un tabulador seguido del caracter '3'.
\113 Metacaracter, es el caracter con el código octal 113 (ya que no puede haber más de 99 referencias hacia atrás).
\377 Metacaracter, es un byte que consiste completamente de bits 1.
\81 Metacaracter, puede ser una referencia hacia atrás, o un cero binario seguido por los caracteres '8' y '1' .
? Cuantificador, El caracter puede aparecer 0 o 1 vez.
* Cuantificador, El caracter puede aparecer 0 o mas veces. Cualquier cosa que no sea letra, dígito o guión bajo.
+ Cuantificador, El caracter puede aparecer 1 o mas veces.
- Cuantificador, Define el rango de caracteres, define un rango desde hasta
{ n } Cuantificador, El caracter aparece exactamente n veces.
{ n, } Cuantificador, El caracter aparece n o más veces.
{ n,m } Cuantificador, El caracter puede aparecer entre n y m veces.
[ ] Agrupador, Permiten agrupar creando rangos, por ejemplo /ab[0-5]+c/ hará match con cualquier string que contenga ab, una o más veces un número entre 0 y 5, y finalmente una c. Por ejemplo: ab12c.
( ) Agrupador, Nos permiten crear sub-expresiones (subpatrón), expresiones regulares contenidas dentro de otras: /a(bc.)+e/. Tiene un uso especial en formas como (…), que permite capturar todo lo que encierren los paréntesis, y (a|b) que hace match o coincidencia con a o b.

La formación de los patrones "\ ...expresiones.. \" contiene un conjunto de expresiones que nos permiten definir las condiciones de la comparación.

Patrón Explicación
i Modificadores, Coincidir indistintamente entre mayúsculas y minúsculas.
m Modificadores, Coincidencia multilínea.
s Modificadores, Con el modificador 's' se consigue que el punto coincida también con el salto de línea '\n'.
u Modificadores, Hacer las coincidencias en modo UTF8
x Modificadores, Ignorar espacios.
Patrones exclusivos y compatibles con Perl y que no existen en POSIX extendido.
[[:ascii:]] Modificadores, caracteres con código ASCII de 0 a 127.
[[:blank:]] espacios o tabuladores
[[:cntrl:]] caracteres de control
[[:graph:]] caracteres de impresión, salvo el espacio
[[:print:]] caracteres de impresión, espacio incluido
[[:word:]]
cualquier letra o dígito y el guión bajo
[[:xdigit:]] cualquier dígito hexadecimal
POSIX extendido y compatibles con Perl, con una diferencia muy importante, las clases de carácter que incluyen caracteres alfabéticos ([[:alnum:]], [[:alpha:]], etc.) en POSIX no incluyen vocales acentuadas, ñ, ç, etc, mientras que en PECR sí.
[[:alnum:]] Cualquier letra o dígito
[[:alpha:]] Cualquier letra
[[:digit:]] Cualquier dígito
[[:lower:]] cualquier letra minúscula
[[:punct:]] Cualquier marca de puntuación
[[:space:]] Cualquier espacio en blanco
[[:upper:]] Cualquier letra mayúscula
[:punct:] Carácter de puntuación

Ejemplos de Expresiones regulares

Funciones para expresiones regulares

Las funciones PCRE no son muchas, pero son muy potentes. Entre ellas la más utilizada es preg_match() que Realiza una comparación con una expresión regular.

preg_match($patron, $cadena, $matches, PREG_CAPTURE_OFFSET): el parámetro $patron es un patrón regex, el segundo parámetro $cadena se utiliza en la comparación, el tercer parámetro es obcional y será la matriz de las coincidencias encontradas.
Si no hay coincidencias, la función devuelve 0 y si la hay, devuelve 1, obcionalmente podemos incluir un cuarto parámetro denominado PREG_CAPTURE_OFFSET, y se utiliza contra el tercer parámetro (matriz resultado) para indicar también el desplazamiento de las coincidencias.

// Función preg_match()

// Mostrar coincidencias entre patrón y cadena a comparar 
$sujeto = 'abcdef';
$patrón = '/^def/';

	preg_match($patrón, substr($sujeto,3), $coincidencias, 
					PREG_OFFSET_CAPTURE);

echo "Array dimensión 2";

// Tabla para array bidimensional 
echo '<table>';

	// Array nº 1 contiene otro array 
	echo '<thead> <tr>  <th>ARRAY</th>  <th> COINCIDENCIAS </th>  
	      </tr> </thead>';
		
	echo '<tbody>';
	
	// Recorrer el primer array 	
	foreach($coincidencias as $clv1 => $vlr1){
		
		// Recorrer el array interior 
		foreach($vlr1 as $clv2 => $vlr2){
			
			// Array nº 2, contiene 2 elementos 
			echo '<tr>';
			echo '<td>' .   $clv2   . '</td>';
			echo '<td>' . $vlr2 . '</td>';
			echo '</tr>';
			
		}
		
		// Cerrar fila 
		echo '</tr>';
		
	}
	
	// Cerrar tabla 
	echo '</tbody>';
	echo '</table>'; 

Array dimensión 2

ARRAY COINCIDENCIAS
0def
10

Ejem preg_match()
Si retorna '1' hay coincidencias.
Si retorna '0' no existen coincidencias.

// preg_match() delimitador 
$match1 = preg_match("/AJAX/", "AJAX"); // / se utiliza como delimitador 
echo $match1;

$match1 = preg_match("@AJAX@", "AJAX"); // @ es delimitador 
echo $match1;

$match1 = preg_match("!AJAX!", "AJAX"); // ! es delimitador 
echo $match1; 

1 -- 1 -- 1
// preg_match() Metacaracteres 
$match4 = preg_match("/AJAX/", "AJAX"); // Coincidir cadena literal 
echo $match4;

$match4 = preg_match("/^AJAX/", "AJAX"); // Coincidir al inicio de la cadena literal 
echo $match4;

$match4 = preg_match("/AJAX$/", "AJAX"); // Coincidir al final de la cadena literal 
echo $match4;

$match4 = preg_match("/^AJAX$/", "AJAX"); // Coincidir el contenido exacto de la cadena 
echo $match4;

$match4 = preg_match("/^$/", ""); // Coincidir una cadena vacía 
echo $match4; 

1 -- 1 -- 1 -- 1 -- 1
// preg_match() delimitador 
$match1 = preg_match("/http:\/\//", "http://"); 
// match http:// Prefijo del protocolo con delimitador / 
echo $match1;

$match1 = preg_match("#http://#",   "http://"); 
// match http:// Prefijo del protocolo con delimitador # 
echo $match1; 

1 -- 1
// preg_match() in/sensibles  
$match1 = preg_match("/ajax/i", "AJAX"); 
// Cadena insensible a mayúsculas y minúsculas con 'i'  
echo $match1; 

1
// preg_match() comodines
// Coincidir un carácter, cada punto '.' cuenta como un carácter 
$match1 = preg_match("/A.A/", "AJAX"); 
echo $match1;

// Coincidir múltiples caracteres después del asterisco '*' 
$match1 = preg_match("/A.*A/", "AJAX"); 
echo $match1;

// Coincidir caracteres con rango 'A-Z' 
$match1 = preg_match("/A[A-Z]A/", "AJAX"); 
echo $match1;

// Coincidencia para conjunto de caracteres '[A y J]' 
$match1 = preg_match("/[AJ]*/", "AJAX"); 
echo $match1;

// Coincidir con un carácter que pueda formar parte de una palabra 'A\wA' 
$match1 = preg_match("/A\wA/", "AJAX"); 
echo $match1;

// Coincidir los caracteres 'AJAX', pero no 'AJAX' como una cadena literal 
$match1 = preg_match("/\bAJAX\b/", "regex en AJAX");
echo $match1; 

1 -- 1 -- 1 -- 1 -- 1 -- 1
// preg_match() cuantificadores 
// Coincidir exactamente 3 caracteres de conjunto [AJ]{3} 
$match1 = preg_match("/[AJ]{3}/","AJAX"); 
echo $match1;

// Coincidir exactamente 3 caracteres de conjunto [AJ]{3,3} 
$match1 = preg_match("/[AJ]{3,3}/", "AJAX"); 
echo $match1;

// Coincidir con un máximo de 3 caracteres del conjunto [AJ]{,3} 
$match1 = preg_match("/[AJ]{,3}/", "AJAX"); 
echo $match1;

// Coincidir al menos 3 caracteres del conjunto [AJ]{3,} 
$match1 = preg_match("/[AJ]{3,}/", "AJAX"); 
echo $match1; 

1 -- 1 -- 0 -- 1
Subir

preg_match_all($patron, $cadena, $matches, {PREG_PATTERN_ORDER o PREG_GET_ORDER): Identico a preg_match() pero preg_match_all() seguirá buscando coincidencias después de haber encontrado la primera.
El tercer parametro es obligatorio ($matches) matriz de coincidencias ya que devuelve la cantidad de coincidencias encontradas. el cuarto parámetro (PREG_PATTERN_ORDER o PREG_GET_ORDER) es obcional y es el que nos permite ordenar en el array de salida los elementos encontrados o coincidentes con el patrón.
Con preg_match_all() podríamos saber la cantidad de imágenes que se encuentran en una página web, para recoger fechas, en cuestión para recorrer objetos definidos que no conocemos.

// Función preg_match_all() 
$cadnmatchall = '24/05-13  26/05/13';
 
// Sacar las fechas y saber qué separador usan 
echo 'Sacar las fechas y saber qué separador usan';

// El patrón contiene esta expresión regular (\/|\-)
// la cual busca coincidencias entre 'barra' y 'guión'. 
// Patrón: dígitos del 0 al 9 y de 2 dígitos (dia), tipo de separador, dígitos del 0 al 9
// y de 2 dígitos (mes), tipo de separador, dígitos del 0 al 9 y de 4 dígitos (anyo).  
preg_match_all ('/[0-9]{2}(\/|\-)[0-9]{2}(\/|\-)[0-9]{2}/', 
			       $cadnmatchall, $vector, PREG_PATTERN_ORDER);


// Mostrar cadena 
echo $vector[0][0] . " y " . $vector[0][1] . '<br />';

// Mostrar 'matriz de coincidencias', primer y segundo elemento del array 1 
echo $vector[1][0] . " y " . $vector[1][1] . '<br />';

// Mostrar 'matriz de coincidencias', primer y segundo elemento del array 2 
echo $vector[2][0] . " y " . $vector[2][1] . '<br />'; 

Sacar las fechas, saber qué separador usan y ordenar el array con el parámetro PREG_PATTERN_ORDER que ordena los resultados de forma que \$matches[0] es un array de coincidencias del patrón completo, \$matches[1] es un array de cadenas coincidentes por el primer subpatrón entre paréntesis, y así sucesivamente.

Cadena: 24/05-2013 y 26/05/2013

/ y /
- y /

// Función preg_match_all() 
$cadnmatchall = '24/05-13  26/05/13';
 
// Sacar las fechas y saber qué separador usan 
echo 'Sacar las fechas y saber qué separador usan';

// El patrón contiene esta expresión regular (\/|\-)
// la cual busca coincidencias entre 'barra' y 'guión'. 
// Patrón: dígitos del 0 al 9 y de 2 dígitos (dia), tipo de separador, dígitos del 0 al 9
// y de 2 dígitos (mes), tipo de separador, dígitos del 0 al 9 y de 4 dígitos (anyo).  
preg_match_all ('/[0-9]{2}(\/|\-)[0-9]{2}(\/|\-)[0-9]{2}/', 
			       $cadnmatchall, $vector, PREG_SET_ORDER);


// Mostrar cadena 
echo $vector[0][0] . " y " . $vector[1][0] . '<br />';

// Mostrar 'matriz de coincidencias', primer y segundo elemento del array 1 
echo $vector[0][1] . " y " . $vector[1][1] . '<br />';

// Mostrar 'matriz de coincidencias', primer y segundo elemento del array 2 
echo $vector[0][2] . " y " . $vector[1][2] . '<br />'; 

Sacar las fechas, saber qué separador usan y ordenar el array con el parámetro PREG_SET_ORDER que ordena los resultados de forma que \$matches[0] es un array del primer conjunto de coincidencias, \$matches[1] es un array del segundo conjunto de coincidencias, y así sucesivamente.

Cadena: 24/05-2013 y 26/05/2013

/ y /
- y /

Subir

preg_split($patron, $cadena [, num_límite [, num_indicador]] ): Subdivide una cadena en base a un patrón regex. Devuelve una matriz de la cadena dividida en subcadenas. Su funcionalidad es parecida a la función explode() o str_split().
Se puede indicar con el tercer parámetro num_límite obcional, un límite a la cantidad de subdivisiones. Si se especifica límite, entonces sólo se devuelve una cantidad de hasta límite subcadenas, y si el límite es -1, 0 o NULL, significa 'sin límite', lo cual es útil cuando se quiere pasar un valor al parámetro Si se especifica limite, entonces sólo se devuelve una cantidad de hasta limite subcadenas, y si limite es -1, quiere decir 'sin límite', lo cual es útil cuando se quiere pasar un valor al parámetro flag o num_indicador.

flag o num_indicador, puede ser cualquier combinación de los siguientes indicador (combinados con el operador de bits |):

Obtener las partes de una cadena:

// Función preg_split() 
$cadsplit = 'Lenguaje PreProcesador Hipertexto, PHP';

// Separa la frase por cualquier numero de comas o caracteres de espacio
// incluyendo " ", \r, \t, \n y \f 
$cadArray = preg_split(\"/[\s,]+/\", $cadsplit);

echo "Cadena: " . $cadsplit . " <br />

	Longitud de cadena: " . strlen($cadsplit) . " <br /> <br />";

	foreach($cadArray as $clave => $valor){
		
		echo $clave . "/ " . $valor . " <br />";	
		
	}

Cadena: Lenguaje PreProcesador Hipertexto, PHP
Longitud de cadena: 106

Separamos la cadena por cualquier numero de comas o caracteres de espacio indicado en el patrón: (" ", \r, \t, \n o \f).

0/ Lenguaje
1/ PreProcesador
2/ Hipertexto
3/ PHP

Separar los caracteres de una cadena (PREG_SPLIT_NO_EMPTY):

// Función preg_split()
// Separar los caracteres de una cadena mediante '//' 

echo "Cadena: PEACHEPE";
// num_indicador = -1 o 0, separa caracteres uno a uno.
// num_indicador = 3, devuelve 'P E ACHEPE'. 
$cadsplit2 = 'PEACHEPE';
$cadenaArray = preg_split('//', $cadsplit2, -1, PREG_SPLIT_NO_EMPTY);

	// Recorremos caracteres separados  
	foreach($cadenaArray as $clasplit => $valsplit){
		
			echo $clasplit . " ::> " . $valsplit . " <br />";
		
	} 

Cadena: PEACHEPE

0::> P
1::> E
2::> A
3::> C
4::> H
5::> E
6::> P
7::> E

Separar la cadena en coincidencias y sus desplazamientos (PREG_SPLIT_OFFSET_CAPTURE):

// Función preg_split()
// Separar la cadena en coincidencias y sus desplazamientos mediante ' / / '. 
$cadsplit3 = 'Lenguaje PreProcesador Hipertexto, PHP ';

$caractSplit = preg_split('/ /', $cadsplit3, -1, PREG_SPLIT_OFFSET_CAPTURE);


	// Tabla para array bidimensional 
	echo '<table>';

	// Array nº 1, contiene otro array 
	echo '<thead> <tr>  <th>ARRAY</th>  
		<th>COINCIDENCIAS y DESPLAZAMIENTOS</th>  </tr> </thead>';
		
	echo '<tbody>';
	
	// Dimensión 1 
	foreach($caractSplit as $clvsplit_1 => $valrsplit_1) { 
		
		// Elementos del primer array 
		echo "<tr> <td> " . $clvsplit_1 . " </td> <th>Texto e inicio, 
		      en nº de byte </th> <tr>";
		
		// Dimensión 2 
		foreach($valrsplit_1 as $clvsplit_2 => $valrsplit_2) { 
			
		echo '<tr>';
		echo "<th>" . $clvsplit_2 . " </th>"; // Devuelve texto 
		echo '<td>' . $valrsplit_2 . '</td>'; // Devuelve nº byte de inicio texto 
		echo '</tr>';
			
		}
		
	}

	// Cerrar tabla 
	echo '</tbody>';
	echo '</table>'; 

preg_split(), separar cada texto de la cadena en coincidencias y sus desplazamientos mediante ' / / ', y número de byte donde empieza.

ARRAY COINCIDENCIAS y DESPLAZAMIENTOS
0 Texto e inicio, en nº de byte
0 Lenguaje
1 0
1 Texto e inicio, en nº de byte
0 PreProcesador
1 9
2 Texto e inicio, en nº de byte
0 Hipertexto,
1 23
3 Texto e inicio, en nº de byte
0 PHP
1 35

Subir

preg_replace(patrón, reemplazo, asunto, limite, conteo): La función recibe como parámetros un patón, una subcadena de reemplazo y la cadena que se desea modificar. Devuelve el resultado de reemplazar cada coincidencia con la subcadena de reemplazo. Se puede indicar un límite a la cantidad de reemplazos.
Devolverá una matriz si el parámetro asunto es una matriz, si el parámetro asunto es una cadena devolverá otra cadena.
Para el parámetro límite será la cantidad máxima posible de reemplazos para cada patrón en cada cadena asunto. Su valor predeterminado es -1 (sin límite). El parámetro conteo representada por una variable, será llenada con el número de reemplazos afectuados.
Si no se encuentran coincidencias, el nuevo asunto será devuelto intacto.

// Función preg_replace()
// Matriz indexada 
$cadreplace = 'El rápido zorro marrón saltó sobre el perro perezoso.';

// Cadena original 
echo "Cadena: $cadreplace ";

// Palabras a reemplazar 
$patrreplace[0] = '/rápido/';
$patrreplace[1] = '/marrón/';
$patrreplace[2] = '/zorro/';
$patrreplace[3] = '/saltó/';
$patrreplace[4] = '/perro/';
$patrreplace[5] = '/perezoso/';

// Cadenas de reemplazo con claves desordenadas 
$reemplazos[5] = 'despistado';
$reemplazos[4] = 'can';
$reemplazos[3] = 'abalanzose';
$reemplazos[2] = 'oso';
$reemplazos[1] = 'pardo';
$reemplazos[0] = 'lento';

	// Cadena desordenada 
	echo preg_replace($patrreplace, $reemplazos, $cadreplace); 
	
	// Ordenar índices de '$patrreplace' '$reemplazos' 
ksort($patrreplace);
ksort($reemplazos);

	// Índices ordenados 
	$rsltreplaceOrden = preg_replace($patrreplace, 
      $reemplazos, $cadreplace)

		echo 'Índices ordenados: ' . $rsltreplaceOrden;

Cadena: El rápido zorro marrón saltó sobre el perro perezoso.

Reemplazo:

El despistado abalanzose can oso sobre el pardo lento.

Índices ordenados:

El lento oso pardo abalanzose sobre el can despistado.

preg_replace(). Uso de referencias hacia atrás seguidas de literales numéricos

// Función preg_replace()
// Uso de referencias hacia atrás seguidas de literales numéricos 
$cadreplace2 = 'Mayo 18, 2013';

// PATRÓN
// '\w ' cualquier carácter que pueda ser parte de una palabra y '+ ' que aparezca 1 o más veces.
// '\d ' cualquier dígito y '+ ' que aparezca 1 o más veces.
// después de la ', ' coma, '\d ' cualquier dígito y '+ ' que aparezca 1 o más veces.
// 'i ' insensible a mayúsculas y minúsculas. 
$patrreplace2 = '/(\w+)  (\d+), (\d+)/i';

// REEMPLAZO
// '$ ' Coicidencia al final del cadena, '{1} ' para que aparezca 1 vez
// '27 ' reemplazar el dígto por el nº. 27.
// '$3 ' Coicidencia al final del cadena con el dígito '3 '. 
$reemplazos2= '${1}27,$3';

	
	echo preg_replace($patrreplace2, $reemplazos2, $cadreplace2); 

Mayo 18, 2013

preg_replace(). Reemplazo de varios valores

// Función preg_replace()
// Reemplazo de varios valores 
$patrreplacevalores = array ('/(19|20)(\d{2})-(\d{1,2})-(\d{1,2})/', 
				 '/^\s*{(\w+)}\s*=/');
				 
$reemplazos3 = array ('//', '$ =');

	echo preg_replace($patrreplacevalores, $reemplazos3, 
			    '{fechaInicio} = 2013-5-27');

$fechaInicio = 5/27/2013

// Función preg_replace()
// Uso del modificador 'e' 
echo 'Esto pasa a mayúsculas todas las etiquetas HTML en el texto de entrada.';

preg_replace("/(<\/?)(\w+)([^>]*>)/e", "'\\1'.strtoupper('\\2').'\\3'",
		$etiquetas_html); 

Esto pasa a mayúsculas todas las etiquetas HTML en el texto de entrada.

Contenido HTML con las etiquetas cambiadas a mayúsculas.

preg_replace(). Eliminar espacios de más de una cadena.

// Función preg_replace()
// Eliminar espacios en blanco 
$cadreplace4 = 'Sin    espacios   entre   palabras';
echo 'Cadena con espacios: ' . $cadreplace4;

$cadreplace4 = preg_replace('/\s\s+/', '', $cadreplace4);
// Cadena sin espacios 
echo 'Cadena SIN espacios: ' .$cadreplace4; 

Cadena con espacios:Sin espacios entre palabras

Cadena SIN espacios:Sinespaciosentrepalabras

preg_replace(). Utilizando el parámetro conteo

// Función preg_replace()
// Uso del parámetro conteo 
$cadconteo = 0;

// Patrón de Array, '\d' que coincida con cualquier dígito y '\s' cualquier espacio en blanco
// Reemplazar por este símbolo '~'
// Cadena 'ht 22 ml'
// Parámetro límite (-1) 'sin límite'
// Aplicamos el parámetro 'conteo' mediante la variable '$cadconteo'. 
echo preg_replace(array('/\d/', '/\s/'), '~', ' ht 22 ml' , -1 , $cadconteo);
	
	echo 'Conteo= ' . $cadconteo; // 2 dígitos más 2 espacios en blanco: conteo = 4  

El parámetro conteo es una variable que será llenada con el número de reemplazos afectuados.

Cadena: ht 22 ml

Reemplazo: ht~~~~ml

Conteo= 4

Subir

preg_replace_callback(): Esta función es casi identica a la función preg_replace(), excepto el segundo parámetro que es una función callback y no una subcadena de reemplazo. Es decir, en lugar del parámetro reemplazo, deberemos especificar una llamada_de_retorno que será usada pasándole una matriz de los elementos coincidentes en la cadena fuente.
Devolverá la subcadena que se utiliza como reemplazo.

// Función preg_replace_callback()
// Texto utilizado (anyo 2011 y 2015)
// Vamos a actualizarlo para el 2013 y 2016 
$cadreplacecalback = "La navidad anterior fue: 23/06/2011  <br />";
$cadreplacecalback .= "La crisis puede terminar en: 15/04/2015  ";

// Función para aumentar en 1 el anyo de la cadena 
function suma_uno($coincisubpatron){
	
  // $coincidencias[0] = coincidencia completa
  // $coincidencias[1] = coincidencia para el primer subpatron
  // ubicado entre ' ( ) ' y asi sucesivamente. 
  return $coincisubpatron[1] . ($coincisubpatron[2] + 1); // Sumar 1 a ambos años
  
}

// ' \d ' Coincidencias con cualquier dígito, ' {2} ' limitado a dos dígitos
// ' / ' coincidencia con barra, 'suma_uno' llamar a función para 
// llevar a cabo las coincidencias para el primer ' (\d{2}/\d{2}/) ' y 
// segundo ' (\d{4}) ' subpatrón, ubicados entre ' ( ) ' paréntesis.
// Cadenas a comparar ' $cadreplacecalback '. 
echo preg_replace_callback( "|(\d{2}/\d{2}/) (\d{4})|", 
     "suma_uno", $cadreplacecalback ); 

La navidad anterior fue: 23/06/2012
La crisis puede terminar en: 15/04/2016

// Función preg_replace_callback() 

// Aumentar en +1 los números de 1 o 2 dígitos de una cadena 
$cadcallback = "Quedamos el dia 15 a las 9 horas.";
 
function modificar( $demo ) {
	
	// $demo[0] vale 16 y 10, que son los números encontrados por el patrón. 
	return $demo[0] + 1;

}

// Reemplaza solo los dígitos de '2' o '1' byte,
// llamada a la función 'modificar' y
// cadena a buscar coincidencias '$cadcallback'. 
echo preg_replace_callback ("/\d{2}|\d{1}/", "modificar", $cadcallback); 

Aumentar en +1 los números de 1 o 2 dígitos de una cadena.

Quedamos el dia 16 a las 10 horas.

Subir

create_function(): Cuando usamos la función preg_replace_callback() generalmente necesitaremos una función de llamada de retorno ubicada en un lugar. Para ello podemos usar create_function() que crea una función anónima desde los parámetros pasados entre comillas simples, y devuelve un nombre único para ella.
La razón de usar comillas simples es proteger a los nombres de las variables de ser analizados, de otro modo, si se usan comillas dobles necesitaremos escapar los nombres de las variables "\$var" con barra invertida.
Devolverá un nombre de función único como cadena, o FALSE en caso de error.

// create_function
// Filtro de linea de comandos tipo Unix para convertir letras
// mayúsculas al comienzo de los parágrafos a minúsculas.
// 'r' = (reader) acepta lectura en archivo. 
$minus = fopen("quimLeer.php", "r") or die ("No se puede leer quimLeer");

while (!feof( $minus )) {
	
    $paragrafo = fgets($minus);
    $paragrafo = preg_replace_callback('|<p>\s*\w|', create_function(
            
    // Las comillas sencillas son cruciales aqui,
	// o alternativamente escapar todos los signos $ con barra invertida \$ 
    '$coincidencias', 'return strtolower($coincidencias[0]);'), $paragrafo);
   
    echo $paragrafo;
	// Devuelve:
	este es el 1er párrafo del archivo quimLeer.php.
	este es el 2o párrafo del archivo quimLeer.php.  

}

fclose( $minus ); 

Se ha creado el archivo quimLeer.php, del cual, solo se podrá leer lo que se encuentra ya escrito en él. El archivo también podia ser un archivo con la extensión .txt.
Contenido de quimLeer.php:

este es el 1er párrafo del archivo quimLeer.php.

este es el 2o párrafo del archivo quimLeer.php.

Se a reemplazado el primer carácter de los párrafos de
mayúsculas a minúsculas. Esto no influye en los saltos de línea (\n).

create_function() Usar funciones anónimas como funciones de llamada de retorno

// Utilización de función anónima 
// como función callback (devolución de llamada) 
$pre = array("Esto es ", "Código ", "Programar ", "Todo ");

array_walk($pre, create_function('&$v,$k', '$v = $v . "PHP";'));

	foreach($pre as $clave => $valor){
		
		echo $clave . "/ " . $valor . " <br />";	
		
	} 

0/ Esto es PHP
1/ Código PHP
2/ Programar PHP
3/ Todo PHP

Subir

preg_grep(patron, cadenArray, [num_indicador o PREG_GREP_INVERT): Esta función utiliza un patrón y una matriz para devolver otra matriz nueva fomada con los elementos que tienen coincidencias con el patrón regex.
El parámetro patrón busca coincidencias con la cadenArray, devolviendo un nuevo Array con las coincidencias. El tercer parámetro es obcional [num_indicador o PREG_GREP_INVERT], si se establece parámetro PREG_GREP_INVERT, la función devuelve los elementos de la matriz de entrada que NO coinciden con el patrón.

// Función preg_grep()

// Devolverá todos los elementos del Array
// que contengan números de punto flotante 
$array = array (12.65, 12.32, 53);
	
	// Recuperar solo dígitos con decimales
	// '^' = coincidencia cuando empieza por un dígito, o más '(\d+)'
	// '?' = puede aparecer 0 o 1 vez, '\.' = cualquier carácter
	// '\d+' = 1 o más dígitos, '\$' = al final de cadena. 
	$arrayFloat = preg_grep("|^(\d+)?\.\d+$|", $array);
	
	// Recorre el array mostrando las coincidencias 
	foreach($arrayFloat as $clavefloat => $valorfloat){
		
		echo '' . $clavefloat . ' ::> ' . $valorfloat . ' <br />';	
		
	} 

preg_grep(), devolverá todos los elementos del Array que contengan números de punto flotante.

Dígito_1 ::> 12.65
Dígito_2 ::> 12.32
// Función preg_grep() 
$cadArray[] = 'PHP contiene HTML';
$cadArray[] = 'con código incluido';
$cadArray[] = 'en el mismo que proboca';
$cadArray[] = 'un comportamiento.';

// Coincidencia con cadena que termine ' $ ' con ' html ' 
// literalmente e insensible a mayúsculas y minúsculas ' i '. 
$patronArray = '/html$/i';

$vector = preg_grep( $patronArray, $cadArray);
 	// Recorrer el array buscando coincidencias 
	foreach( $vector as $claArray => $valArray){
		
		echo "Coincidencia: $valArray";
		
	} 

Array: PHP contiene HTML con código incluido en él mismo que proboca un comportamiento.
Patrón: /html$/i

Coincidencia = PHP contiene HTML

Subir

preg_quote(): Inserta caracteres de escape 'barra invertida \' en cadenas que se utilizarán como patrones regex. La función devuelve una cadena con caracteres de escape en cada carácter especial.
útil si tiene una cadena en tiempo de ejecución que necesite comparar con algún texto, y la cadena pueda contener caracteres de expresiones regulares especiales como: . \ + * ? [ ^ ] $ ( ) { } = ! < > | : -

Poner en negrita una palabra dentro de un texto.

// Función preg_quote()
// preg_quote( $cadenaquote ) se usa para que los ( * )
// asteriscos sigan teniendo un significado especial
// en la expresión regular. 
$cadenaquote = 'PHP no resulta *muy* difícil de aprender.';
$rslt = ' *muy* ';

$cadenaquote = preg_replace ('/' . 
	       preg_quote($rslt) . '/', '<strong>' . 
		 $rslt . '</strong>', $cadenaquote);

	echo $cadenaquote; // Devuelve el texto 'muy' en negrita  

PHP no resulta *muy* difícil de aprender.

Escapar con barra invertida el símbolo dolar ' $ ' y barra ' / '

// Función preg_quote()
// Escapar con barra invertida el símbolo dolar '$' y barra '/' 

$barraEscape = '65$ por una impresore stylus/750';
echo "Cadena sin preg_quote(): " . $barraEscape;

$barraEscape = preg_quote($barraEscape, '/');

echo 'Cadena con preg_quote(): ';

echo $barraEscape; // devuelve 65\$ por una impresore stylus\/750  

Cadena sin preg_quote(): 65$ por una impresore stylus/750

Cadena con preg_quote(): 65\$ por una impresore stylus\/750

Subir

preg_last_error(): Develve el código de error de la ejecución de la última función regex PCRE.

// Función preg_last_error()

// Esta es la última ejecución de expresión regular 
preg_match('/(?:\D+|<\d+>)*[!?]/', 'PHP, Ajax, JavaScript');

echo "Evaluar la última ejecución de función regular.";
	
	// Evalua la última ejecución de función regular 
	if (preg_last_error() == PREG_BACKTRACK_LIMIT_ERROR) {
		echo '¡El límite de marcha atrás se agotó!';
	} 

Evaluar la última ejecución de función regular.

¡El límite de marcha atrás se agotó!

Constantes que puede devolver:

// Función preg_last_error()
// Ejemplo de constantes 
if (preg_last_error() == PREG_NO_ERROR) {
    print 'No hay error.';
}
else if ( preg_last_error() == PREG_INTERNAL_ERROR) {
    print 'No es un error interno!';
}
else if ( preg_last_error() == PREG_BACKTRACK_LIMIT_ERROR) {
    print 'Límite (Backtrack) marcha atrás se agotó!';
}
else if ( preg_last_error() == PREG_RECURSION_LIMIT_ERROR) {
    print 'Límite de recursividad se agotó!';
}
else if ( preg_last_error() == PREG_BAD_UTF8_ERROR) {
    print 'Error UTF8 inadecuado!';
}
else if ( preg_last_error() == PREG_BAD_UTF8_ERROR) {
    print 'Error de desplazamiento UTF8 inadecuado!';
} 

Evaluación de la última ejecución de función regular:

Límite (Backtrack) marcha atrás se agotó!

TABLA DE CONSTANTES

CONSTANTE DEFINICIÓN Versión
PREG_PATTERN_ORDER Ordena los resultados de forma que $coincidencias[0] es una matriz de coincidencias del patrón completo, $coincidencias[1] es una matriz de cadenas que coinciden con el primer sub-patrón entre paréntesis, y así sucesivamente. Esta bandera sólo se usa con preg_match_all().
PREG_SET_ORDER Ordena los resultados de forma que $coincidencias[0] es una matriz del primer conjunto de coincidencias, $coincidencias[1] es una matriz del segundo conjunto de coincidencias, y así sucesivamente. Esta bandera sólo se usa con preg_match_all().
PREG_OFFSET_CAPTURE Véase la descripción de PREG_SPLIT_OFFSET_CAPTURE. 4.3.0
PREG_SPLIT_NO_EMPTY Este indicador le solicita a preg_split() que devuelva sólo elementos que no estén vacíos.
PREG_SPLIT_DELIM_CAPTURE Esta indicador le solicita a preg_split() que capture también la expresión entre paréntesis en el patrón delimitador. 4.0.5
PREG_SPLIT_OFFSET_CAPTURE Si se aplica este indicador, por cada coincidencia producida, el índice de la cadena añadida también será devuelto. Observe que esto cambia los valores devueltos a una matriz donde cada elemento es una matriz consistente en la cadena coincidente en el índice 0, y su índice dentro de la cadena objetivo en el índice 1. Esta indicador sólo es usado por preg_split(). 4.3.0
PREG_NO_ERROR Devuelto por preg_last_error() si no se produjeron errores. 5.2.0
PREG_INTERNAL_ERROR Devuelto por preg_last_error() si se produjo un error interno de PCRE. 5.2.0
PREG_BACKTRACK_LIMIT_ERROR Devuelto por preg_last_error() si el límite de marcha atrás fue agotado. 5.2.0
PREG_RECURSION_LIMIT_ERROR Devuelto por preg_last_error() si el límite de recursividad fue agotado. 5.2.0
PREG_BAD_UTF8_ERROR Devuelto por preg_last_error() si el último error fue causado por datos UTF-8 malformados (sólo cuando se ejecuta una expresión regular en modo UTF-8). 5.2.0
PREG_BAD_UTF8_OFFSET_ERROR Devuelto por preg_last_error() si el índice no correspondió con el inicio de un punto de código UTF-8 válido (sólo cuando se ejecuta una expresión regular en modo UTF-8). 5.3.0
PCRE_VERSION Versión y fecha de distribución de PCRE (p.ej. "7.0 18-Dec-2006"). 5.2.4

Subir

Funciones generales

strlen(cadena): Obtiene la longitud de una cadena.
Funciones similares:

// Función strlen()

// Cadena nula 
$longitud = NULL;
$longitudNull = strlen(NULL);
// Cadena vacia 
$longitudVacia = '';
// Cadena de caracteres 
$longitudCadena = 'Cuantos bytes tiene esta cadena?';


if (strlen($longitud) === 0) 
	echo 'Longitud nula, es cero. <br />';
if ($longitudNull === 0) 
	echo 'Longitud nula, sigue siendo cero. <br />';
if ($longitudVacia === '') 
	echo 'Cadena vacia. <br />';
if($longitudCadena !== 0) 
	echo $longitudCadena . ': ' . strlen($longitudCadena) . '<br />';

// Comprobar longitud con otra funciones 
echo 'Longitud con función mb_strlen()' . mb_strlen($longitudCadena) . '<br />';
echo 'Longitud con función count()' . count($longitudCadena) . '<br />'; 
Longitud nula, es cero.
Longitud nula, sigue siendo cero.
Cadena vacia.
Cuantos bytes tiene esta cadena?: 32
Longitud con función mb_strlen(): 32
Longitud con función count(): 1

Los espacios en blanco y signos de interrogación también forman parte de una cadena.

Subir

chr(número): Devuelve un carácter del valor ASCII especificado.
El valor ASCII se puede especificar en decimal, octal o valores hexadecimales. Valores octales se definen por un 0, mientras que los valores hexadecimales se definen por el prefijo 0x.

chr() sacar caracteres ASCII de los valores especificados.

// Función chr()

// Sacar cadena con valores ASCII 
$caracter1 = chr(43); // Corresponde al valor ASCII '+' 
$caracter2 = chr(61); // Corresponde al valor ASCII '=' 
	
	echo("2 $caracter1 2 $caracter2 4 <br />");  // Devuelve 2 + 2 = 4  
2 + 2 = 4

chr() sacar carácter ASCII, decimal, octal y hexadecimal de unos valores específicos.

// Función chr() 
echo 'Decimal ---> ' . chr(52) . '<br />'; 		// Devuelve decimal '4' 
echo 'Octal ---> ' . chr(052) . '<br />'; 		// Devuelve octal '*' 
echo 'Hexadecimal ---> ' . chr(0x52) . '<br />';  // Devuelve hexadecimal 'R'  
Decimal ---> 4
Octal ---> *
Hexadecimal ---> R
Subir

count_chars(cadena [,modo]):Devuelve la cantidad de caracteres de cada tipo (desde ASCII 0 hasta ASCII 255) o de las claves que se han utilizado o no se ha utilizado en una cadena. El parámetro modo determina el modo en el que se devuelven los datos:

count_chars() contar cuántas veces aparece un carácter ASCII en una cadena, con el parámetro "modo" siendo 1.

// Función count_chars()

// Contar cuántas veces aparece un carácter ASCII en una cadena 
$countchars = "PHP Hypertext Preprocessor";
$cadenaArray = count_chars($countchars, 1);

	foreach ($cadenaArray as $clave => $valor) {
		
		// Si se encuentra solo una coincidencia 
		if($valor === 1) {
		
			echo "El carácter '" . chr( $clave )
			     . "' se encontró $valor vez <br />";
			
		// Si se encuentran más de una coincidencias 
		}else {
			
			echo "El carácter '" . chr( $clave )
			     . "' se encontró $valor veces <br />";
			
		}
		
	} 

El carácter ' ' se encontró 2 veces

El carácter 'H' se encontró 2 veces

El carácter 'P' se encontró 3 veces

El carácter 'c' se encontró 1 vez

El carácter 'e' se encontró 4 veces

El carácter 'o' se encontró 2 veces

El carácter 'p' se encontró 2 veces

El carácter 'r' se encontró 4 veces

El carácter 's' se encontró 2 veces

El carácter 't' se encontró 2 veces

El carácter 'x' se encontró 1 vez

El carácter 'y' se encontró 1 vez

count_chars() con el parámetro "modo" siendo 4. Devuelverá una matriz con las claves que no se han utilizado.

// Función count_chars() 
echo "Los caracteres que no se utililzan en esta cadena son:";

$crtrcountchars4 = "(Programar una 'web' con; "PHP")";

// Devuelve los caracteres no utilizados en la cadena 
count_chars($crtrcountchars4, 4);

// Devuelverá una matriz con las claves que no se han utilizado.
// Excepto los caracteres indicados en el segundo parámetro de 'trim()'. 
echo trim ( count_chars ($crtrcountchars4, 4), 
		  utf8_decode("!#$%&'*+,-./0123456789:<=>@ABCDEFGI
		  JKLMNOQRSTUVWXYZ[\]^`dfhijklpqstvxyz|~€‚ƒ„…†‡ˆ‰Š‹ŒŽ''
		  ""•–—˜™š›œžŸ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉ
		  ÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ")); 

Los caracteres que no se utililzan en esta cadena son:

 !#$%&*+,-./0123456789:<=>@ABCDEFGIJKLMNOQRSTUVWXYZ[\]^`dfhijklpqstvxyz|~

count_chars() con el parámetro "modo" siendo 3. devuolverá una matriz con las claves que se han utilizado, (no indicará la cantidad).

// Función count_chars() 
echo "Los caracteres que se utililzan en esta cadena son:";

$crtrcountchars3 = "(Programar una web con; "PHP")";

// Devuelve los caracteres que se han utilizados en la cadena 
count_chars ( $crtrcountchars3, 3);

// Devuelverá una matriz con las claves que se han utilizado. 
echo count_chars ( $crtrcountchars3, 3); 

Los caracteres que se utililzan en esta cadena son:

"();HPabcegmnoruw

count_chars() con el parámetro "modo" siendo 2.

Devuelve una matriz donde la clave es el valor ASCII y el valor es la cantidad de veces que apareció ese carácter, pero listará solo las claves con valores 0:

// Función count_chars()

// Devuelve una matriz donde la clave es el valor ASCII y el valor es la cantidad 
// de veces que apareció ese carácter, pero listará solo las claves con valores '0'. 
$crtrcountchars2 = "(Programar una web con; "PHP")";

// Devuelve matriz, solo con los valores '0' 
count_chars ($crtrcountchars2, 2);


$rslt2 = count_chars ($crtrcountchars2, 2);

	foreach($rslt2 as $cla2 => $val2) {
		
		// Salimos del bucle para no llenar la página con 
		// la misma información para cada clave. 
		if ($cla2 >= 22):
		
		   echo $cla2 . ' -->' . $val2 . ' ... y así hasta 
		   	 el nº 255 -->0.';
			
		   // Salimos del bucle. 
		   break;
		
		else:
		
		   echo $cla2 . ' -->' . $val2 . '|| ';
		
		endif;
		
	} 

0 -->0|| 1 -->0|| 2 -->0|| 3 -->0|| 4 -->0|| 5 -->0|| 6 -->0|| 7 -->0|| 8 -->0|| 9 -->0|| 10 -->0|| 11 -->0|| 12 -->0|| 13 -->0|| 14 -->0|| 15 -->0|| 16 -->0|| 17 -->0|| 18 -->0|| 19 -->0|| 20 -->0|| 21 -->0|| 22 -->0 .... y así hasta el nº 255 -->0.

count_chars() con el parámetro "modo" siendo 0.

Devuelve una matriz donde la clave es el valor ASCII y el valor es la cantidad de veces que apareció ese carácter:

// Función count_chars()

// Devuelve una matriz donde la clave es el valor ASCII y el 
// valor es la cantidadde veces que apareció ese carácter. 
$crtrcountchars0 = "(Programar una web con; "PHP")";

// Devuelve matriz 
count_chars ($crtrcountchars0, 0);


$rslt0 = count_chars ($crtrcountchars0, 0);

	foreach($rslt0 as $cla0 => $val0) {
		
	// Salimos del bucle para no llenar la página con 
		 // la misma información para cada clave. 
	if ($cla0 >= 22):
		
	  echo $cla0 . ' -->' . $val0 . ' ... y así hasta el nº 255 -->0.';
			
	  // Salimos del bucle. 
	  break;
		
	else:
		
	  echo $cla0 . ' -->' . $val0 . '|| ';
		
	endif;
		
	} 

0 -->0|| 1 -->0|| 2 -->0|| 3 -->0|| 4 -->0|| 5 -->0|| 6 -->0|| 7 -->0|| 8 -->0|| 9 -->0|| 10 -->0|| 11 -->0|| 12 -->0|| 13 -->0|| 14 -->0|| 15 -->0|| 16 -->0|| 17 -->0|| 18 -->0|| 19 -->0|| 20 -->0|| 21 -->0|| 22 -->0 .... y así hasta el nº 255 -->0.

Subir

explode(separador, cadena [límite]): Crea una matriz a partir de una cadena. El parámetro separador es el carácter que utilizaremos para separar la cadena. Cada vez que encuentra el separador en la cadena, (rompe la cadena) y genera un elemento nuevo para la matriz. El parámetro límite es obcional e indica un máximo de elementos en la matriz generada, y a partir de PHP 5.1.0 soporta números negativos.

explode() crear una matriz a partir de una cadena.

// Función explode()

// Crear una matriz a partir de una cadena 
$cadexplo = "AJAX: JavaScript asíncrono y XML";

// El separador es un espacio en blanco 
$rslt = explode(" ", $cadexplo);
	
	echo 'Cadena: AJAX: JavaScript asíncrono y XML <br /> <br />';	
		
		foreach($rslt as $clarslt => $valrslt) {
			
			echo $clarslt . ' //' . $valrslt . '<br />';
		
		} 

Cadena: AJAX: JavaScript asíncrono y XML

0 //AJAX:
1 //JavaScript
2 //asíncrono
3 //y
4 //XML

explode() usamos el parámetro límite para devolver un número de elementos de la matriz.

// Función explode() 
$cadExplode = 'AJAX, JavaScript, asíncrono, XML';

// El separador es el carácter coma ' , '. Límete cero ' 0 ' 
$limitCero = explode(',', $cadExplode, 0);

echo 'Con límite 0: <br />';	
	
	foreach($limitCero as $claCero => $valCero) {
		
	  echo 'Límite cero:' . $claCero . ' ::> ' . $valCero . '<br />';
	
	}


// Límite positivo 
$limitPositivo = explode(',', $cadExplode, 2);

	echo '<br />Con límite 2: <br />';
	
	foreach($limitPositivo as $claPosi => $valPosi) {
		
	  echo 'Límite positivo:' . $claPosi . ' ::> ' . $valPosi . '<br />';
	
	}


// Límite negativo 
$limitNegativo = explode(',', $cadExplode, -1);

	echo '<br />Con límite -1: <br />';
	
	foreach($limitNegativo as $claNeg => $valNeg) {
		
	  echo 'Límite negativo:' . $claNeg . ' ::> ' . $valNeg . '<br />';
	
	} 

Cadena: AJAX, JavaScript, asíncrono, XML

Con límite 0:
Límite cero:0 ::>AJAX, JavaScript, asíncrono, XML

Con límite 2:
Límite positivo:0 ::>AJAX
Límite positivo:1 ::> JavaScript, asíncrono, XML

Con límite -1:
Límite negativo:0 ::>AJAX
Límite negativo:1 ::> JavaScript
Límite negativo:2 ::> asíncrono

Subir

implode(separador, matriz): Une elementos de un Array a una cadena. A la cadena resultante le incluye el carácter indicado en el parámetro separador entre cada valor de la matriz. El parámetro separador es opcional, sin embargo, es recomendable utilizar siempre dos parámetros para la compatibilidad con versiones anteriores.
Devuelve una cadena que contiene la representación de todos los elementos del array en el mismo orden, con el carácter "separador" entre cada elemento. Función segura con material binario.

// Función implode() 
$implodeArray = array('PHP', 'AJAX', 'jQuery');

//Utilizar varios caracteres como parámetro 'separador' 
$entreComas = implode ( ", ", $implodeArray );
$entreBarras = implode ( "/ ", $implodeArray );
$entreAsteriscos = implode ( "* ", $implodeArray );
$entreAlmoadillas = implode ( "# ", $implodeArray );

echo $entreComas;
echo $entreBarras;
echo $entreAsteriscos;
echo $entreAlmoadillas;


 ____________________________________________________ 


// Función implode() 

// Si se usa un Array vacio, no habrá valor resultante 
$arrayVacio = implode ( ' /separador/ ', array() );
	
	// Si array vacio ... 
	if($arrayVacio === ' ' ) {
		
		echo 'Array vacio ::> .....';
			
	}
	// Si array contiene elementos ... 
	else{
		
		echo $arrayVacio;
		
	} 

PHP , AJAX , jQuery
PHP / AJAX / jQuery
PHP * AJAX * jQuery
PHP # AJAX # jQuery

Si el Array está vacio, no devuelve nada.
Array vacio ::> .....

Subir

join(separador, matriz): Es un alias de implode(). Une los elementos de una matriz como una cadena. A la cadena resultante le incluye el carácter indicado en el parámetro separador entre cada valor de la matriz. El parámetro separador es opcional, sin embargo, es recomendable utilizar siempre dos parámetros para la compatibilidad con versiones anteriores.
Devuelve una cadena que contiene la representación de todos los elementos del array en el mismo orden, con el carácter "separador" entre cada elemento. Función segura con material binario.

// Función join() 
$joinArray = array('PHP', 'AJAX', 'jQuery');

//Utilizar varios caracteres como parámetro 'separador' 
$joinComas = join ( ", ", $joinArray );
$joinBarras = join ( "/ ", $joinArray );
$joinAsteriscos = join ( "* ", $joinArray );
$joinAlmoadillas = join ( "# ", $joinArray );

echo $joinComas;
echo $joinBarras;
echo $joinAsteriscos;
echo $joinAlmoadillas;


 ____________________________________________________ 


// Función join() 

// Si se usa un Array vacio, no habrá valor resultante 
$arrayjoinVacio = join ( ' /separador/ ', array() );
	
	// Si array vacio ... 
	if($arrayjoinVacio === ' ' ) {
		
		echo 'Array vacio ::> .....';
			
	}
	// Si array contiene elementos ... 
	else{
		
		echo $arrayjoinVacio;
		
	} 

PHP , AJAX , jQuery
PHP / AJAX / jQuery
PHP * AJAX * jQuery
PHP # AJAX # jQuery

Si el Array está vacio, no devuelve nada.
Array vacio ::> .....

Subir

ord(cadena o carácter): Retorna el valor ASCII del primer caracter de una cadena como un entero. Sensible a mayúsculas y minúsculas.
Esta funcion Complementa a la función chr() vista anteriormente y que devuelve una cadena de un caracter que contiene el carácter especificado por ASCII.

// Función ord() 
echo ord ('J') . '<br />';  // Devuelve 74 
echo ord ('JavaScript');    // Devuelve 74  

Carácter ASCII de la primera letra: "J"


J --------------------> 74
JavaScript --------> 74

Función ord()

// Función ord() 
$caracterOrd = "\n";

// En este caso el primer caracter no es la barra invertida '\'
// sino que coje '\n' como carácter único ya que pertenece a un 
// carácter especial por defecto de PHP, al igual que '\t', '\r', '\f'. 
$caracterOrd = "\n"; // Carácter ASCII de 'salto de línea'  

	
	if (ord ($caracterOrd) == 10 ) {
		echo "El primer caracter de $caracterOrd es un salto de linea. \n";
	}else{
		echo "Otra cosa.";
	} 

Variable $caracterOrd = "\n"
El primer caracter de $caracterOrd es un salto de linea.\n

Subir

parse_str(cadena, array): Analiza el parámetro cadena enviada por un URL y extrae los valores para generar variables locales. Si figura el parámetro array, es su lugar las variables serán almacenadas en esta variable como elementos de array.
Para obtener el QUERY_STRING actual, se puede utilizar la variable $_SERVER['QUERY_STRING'].
La configuración magic_quotes_gpc afecta la salida de esta función, ya que parse_str() usa el mismo mecanismo que PHP utiliza para poblar las variables $_GET, $_POST, etc.

// Función parse_str() 

// Analizar cadena de consulta en variables 
parse_str ('calle=Simancas&numero=164&pobla=Barcelona');

echo 'Calle: ' . $calle . '<br />'; // Devuelve Simancas 
echo 'Número: ' . $numero . '<br />'; // Devuelve 164 
echo 'Población: ' . $pobla . '<br />'; // Devuelve Barcelona  
Calle: Simancas
Número: 164
Población: Barcelona
// Función parse_str()

// Guardar las variables en un Array (2º parámetro) 
parse_str ('calle=Simancas&numero=164&pobla=Barcelona', $ArrayStr);

	foreach( $ArrayStr as $clastr => $valstr ) {
		
		echo $clastr . '/ ' . $valstr . '<br />';
		
	}
calle/ Simancas
numero/ 164
pobla/ Barcelona
Subir

wordwrap(cadena [,ancho [,ruptura]]): Corta una cadena en la cantidad especifica que indica el parámetro ancho que indica el ancho de la linea (asume 75); la ruptura de la línea se realiza con el parámetro ruptura (asunme \n, es decir. nueva línca).
Sin el tercer parámetro 'TRUE' no se puede romper por una palabra de una cadena, lo que hará será terminar de completar la palabra y romper a partir de ahi.

// Función wordwrap() 
$cadenaWordwrap = 'Cada 'tantos' caracteres especificados en el 2º parámetro,
				     habrá un salto de línea';

// Corta la cadena cada 20 bytes y le da un salto de línea 
echo wordwrap ( $cadenaWordwrap, 20, '<br />'); 
Cada "tantos"
caracteres
especificados en el
2º parámetro,
habrá un salto de
línea

wordwrap(), dando uso de todos sus parámetros.

// Función wordwrap() 
$cadenaWordwrap2 = 'Cada 'tantos' caracteres especificados en el 2º parámetro,
				     habrá un salto de línea';

// Corta la cadena cada 8 bytes y le da un salto de línea
// Con el tercer parámetro 'TRUE' podemos romper una palabra de la cadena 
echo wordwrap ( $cadenaWordwrap2, 8, '<br />', 'TRUE); 
Cada
"tantos"
caracter
es
especifi
cados en
el 2º
parámet
ro,
habrá
un salto
de
línea
Subir

fopen(), fwrite(), fclose(): Crea archivo externo

Si buscamos el archivo ejemploquim.txt, encontraremos que contiene el mismo párrafo que se ha añadido entre los paréntesis de la función fwrite().
La ruta del archivo ha de ser correcta para poder entrar los datos, en caso contrario se ha añadido la sentencia or die, la cual nos avisa que el archivo no ha sido encontrado.

// CREAR UN ARCHIVO EXTERNO
// fopen() = PHP crea un archivo.txt -- 
// fwrite() = Variable que guarda el archivo más texto o variable que contiene el texto --
// fclose() = cerrar siempre el archivo después de abrirlo con fopen() -- 
$archivo = fopen("ejemploquim.txt", "w+"); // 'w+' = (write) acepta escritura en archivo. 

   fwrite($archivo, 'Cadena creada dentro del archivo externo 'ejemploquim.txt'' );

fclose($archivo);
// create_function
// Filtro de linea de comandos tipo Unix para convertir letras
// mayúsculas al comienzo de los parágrafos a minúsculas.
// 'r' = (reader) acepta lectura en archivo. 
$minus = fopen("quimLeer.php", "r") or die ("no se puede leer stdin");

while (!feof( $minus )) {
	
    $paragrafo = fgets($minus);
    $paragrafo = preg_replace_callback('|<p>\s*\w|', create_function(
            
	// Las comillas sencillas son cruciales aqui,
		 // o alternativamente escapar todos los signos $ con barra invertida \$ 
       '$coincidencias', 'return strtolower($coincidencias[0]);'), $paragrafo);
   
    echo $paragrafo;
	// Devuelve:
	este es el 1er párrafo del archivo quimLeer.php.
	este es el 2o párrafo del archivo quimLeer.php.  

}

fclose( $minus ); 

Contenido de quimLeer.php:

este es el 1er párrafo del archivo quimLeer.php.

este es el 2o párrafo del archivo quimLeer.php.

Se a reemplazado el primer carácter de los párrafos de
mayúsculas a minúsculas. Esto no influye en los saltos de línea (\n).