Hace mucho tiempo me volví loco para encontrar un script, función o cualquier tipo de ayuda para enviar un email con archivos adjuntos en PHP, ya que todo lo que encontraba no me funcionaba. Supongo que al igual que a mi, hay más gente en las mismas, por lo que me dispongo a copiar una función que encontré aquí. Está hecha de forma totalmente sencilla, en la que para ejecutarla, simplemente tengamos que escribir:
//Ejemplo de usar la función para enviar un fichero llamado fichero.exe que se encuentra en la misma ruta que el script
mail_attachment("fichero.exe","","destinatario@hotmail.com","remitente@delanover.com","Administrador","no-reply@delanover.com","Asunto","Mensaje de prueba");
En caso de que se ejecute correctamente veremos el mensaje de mail send … OK. En caso contrario, veremos el otro mensaje: mail send … ERROR!.
Recordemos que para usar este script, nuestro servidor web ha de ser capaz de enviar correos electrónicos. De no ser así, obviamente no funcionará, pero para los que esteis seguros que funciona, este script debería de funcionar.
Un sitio web puede tener más de una cookie en el ordenador del usuario que navega, pero las cookies críticas son las que nos permiten la identificación del usuario en la página web. De esta manera, mediante técnicas como los conocidos XSS o los MITM seriamos capaces de obtener cookies críticas que nos permitan falsificar y hacer creer al sistema que nosotros somos el usuario objetivo.
El problema viene cuando el objetivo de un esnifado de red es únicamente saber las cookies críticas del que navega. Con todos los paquetes de datos que recibimos, incluso filtrándolos por HTTP en Wireshark, tendriamos mucho trabajo por delante.
De este problema me surgió la necesidad de crear un script en PHP, el cual quiero compartir en el blog, que nos permite, no solo ordenar y obtener las cookies de manera agradable para la vista, sino que, incluyo una función en la que a partir de un array cuyo índice sea el domino y el valor sea el nombre de la cookie crítica de ese sitio, nos lo colorea de rojo, permitiéndonos así localizarlas más fácilmente. De la misma manera, nos quita las cookies de los hosts repetidos.
El código está completamente comentado y dividio en dos funciones que nos hacen el entendimiento más fácil. El archivo que tenemos que pasarle al script, ha de ser el fichero pcap guardado del wireshark una vez esté filtrado usando el siguiente filtro: http contains "Cookie: "
Esto nos permite obtener los paquetes que contenga “Cookie:” que son los que nos interesan.
Este es un ejemplo del resultado. Sabemos que la cookie crítica de twitter es auth_token:
Script:
Documento sin título
//http contains "Cookie: "
$fichero = "asd.pcap";
//Leemos el archivo
$f=fopen($fichero,"r") or die("Error al abrir el fichero");
while(!feof($f))
$contenido.=fgets($f);
//Cerramos el fichero
fclose($f);
preg_match_all("/(Host:).*(\r\n).*(\r\n).*(\r\n).*(\r\n).*(\r\n).*(\r\n).*(\r\n).*(\r\n).*(\r\n).*/",$contenido,$resultados);
//Con esto, obtenemos una matriz con los resultados de los paquetes en los que aparece el Host y la Cookie justo en esa posición
//Usamos el substr_count para saber si tiene la palabra "Cookie".
//En este caso, la añadimos a nuestra matriz final
foreach($resultados[0] as $valor) {
if(substr_count($valor,"Cookie")>0)
$final[] = $valor;
}
//La matriz "final" contiene por cada valor, un paquete con host y cookie
//"resultado" es una matriz vacia en la que se almacenará el resultado devuelto
parsear_matriz($final,$resultado);
//Printeamos el resultado
foreach($resultado as $clave => $valor){
echo $clave;
unset($final);
$nuevo = explode(";",$valor);
foreach($nuevo as $valor2)
$final .= "" . $valor2 . " ";
echo $final . "";
}
//FUNCIONES
function parsear_matriz($matriz,&$resultado) {
foreach($matriz as $valor) {
$host = explode("Host: ",$valor);
$host = explode("\r\nUser",$host[1]);
//Host[0] tiene cada host
$cookie = explode("Cookie: ",$valor);
//Cookie[1] tiene el valor de la cookie en cada host
detectar_cookies_criticas($host[0],$cookie[1]);
$host[0] = "" . $host[0] . ": ";
$resultado[$host[0]] = $cookie[1];
//Devolvemos el resultado
}
}
function detectar_cookies_criticas($host,&$cookie){
$buscar = array("twitter.com" => "auth_token");
//Esta matriz contiene el host y la cookie crítica que destacará en el caso de que la encuentre
if(array_key_exists($host,$buscar)){
$nuevo = explode($buscar[$host],$cookie);
$cookie = $nuevo[0] . "" . $buscar[$host];
$nuevo = explode(";",$nuevo[1]);
$cookie .= $nuevo[0] . ";" . $nuevo[1];
}
}
?>
Esta libreria nos permite crear de una manera muy cómoda y sencilla un documento PDF bastante personalizado: cabeceras, pies de página, colores, imágenes (jpeg, png, gif), saltos de línea, saltos de página y diferentes fonts y codificaciones entre otras cosas.
Podemos realizar incluso referencias al propio documento y poderosas tablas, las cuales pueden venir muy bien para resultados de consultas en bases de datos.
Instalación
Descargamos la versión más reciente desde su página oficial, en la cual nos encontraremos un archivo comprimido zip con tutoriales y explicaciones de cada función en particular (también disponibles en la página oficial). El archivo más importante del zip es el llamado fpdf.php aunque también necesitaremos tener en nuestro directorio local, el archivo fpdf.css y la carpeta de font.
Errores comunes
Antes de empezar a jugar con esta libreria, comentaré un error que puede aparecernos, para de esta manera, poder evitarlo. Puede que nos saltase un error que nos dijera “Cannot modify header information – headers already sent by …”. Esto es solucionable si en el script en donde vamos a realizar el pdf no introducimos nada antes ni después de los tags de inicio y fin de php, es decir, nada antes ni después de “, ?>, ,
, o cualquier otro). Esto puede ser debido a que esta libreria toca la cabecera de nuestro documento, por lo que no debe de haber nada antes de tal.
Otro error común, sobre todo para los castellano parlantes, puede ser el uso de terminadas letras, como la ñ o las vocales acentuadas. Para ello, suponiendo que nuestro texto se encuentre en una variable, la parsearemos de la siguiente manera:
$str = utf8_decode($str);
Por otra parte, puede que sea un caracter “extraño” como el símbolo del euro. Por ello, para estos casos, los definiremos de la siguiente forma:
define('EURO', chr(128));
$str = "Ejemplo de € y " . EURO;
// En nuestro PDF nos muestra lo siguiente: "Ejemplo de ? Y €"
Introducción
Para indicar que estamos usando esta libreria, tenemos que hacer referencia al archivo fpdf.php de la siguiente forma:
require("fpdf.php");
Por otra parte, para iniciar la creación del documento PDF, tenemos que indicarlo del siguiente modo:
$pdf=new FPDF();
El funcionamiento a grosso modo es muy simple. Vamos añadiendo páginas y en cada una añadimos lo que queramos. Cuando queramos editar propiedades del tipo colores o fuentes de texto, tenemos que declararlas justo antes de usarlas. Es decir, si queremos hacer dos líneas de texto con fuentes distintas, primero tenemos que declarar las propiedades de la primera fuente, luego escribir la primera línea, declarar las propiedades de la segunda y escribirla.
De igual modo, si alguna vez escribimos algo que ocupe más de una página, esta se añade automáticamente, aunque disponemos de una función (Addpage) para añadir páginas, la cual nos permite acabar de escribir en una página o poner páginas en blanco.
Hay algunas propiedades también, como las cabeceras o los piés de página, que no basta con declarar lo que queremos, sino que hay que realizar la propia función como veremos más adelante. De la misma forma que anteriormente hemos indicado que se iniciaba la configuración del documento pdf, para exportarlo y que salga como tal, dispondremos de otra función que tendremos que aplicar al final (Output).
Funciones básicas
Addpage (añade una página), Cell (crea una celda), setFont (declaramos un estilo de fuente), Ln (salto de línea), Image (añade una imagen), setFillColor (establece un color de relleno), setTextColor (establece un color para el texto), SetX (posicionar en el eje X), SetY (posicionar en el eje Y), GetX (obtener posición en el eje X), GetY (obtener posición en el eje Y). Ejemplo:
require("fpdf.php");
$pdf=new FPDF();
//Cargamos y creamos el nuevo objeto.
$pdf->AddPage();
//Añadimos una página.
$pdf->Addpage();
//Añadimos otra página. De esta manera, la primera quedará en blanco.
$pdf->SetFont('Arial','B',16);
//Seleccionamos la font de nuestros textos. Serial Arial, Bold, de tamaño 16. Ver fonts permitidas en la línea
//104 del archivo fpdf.php. Los estilos permitidos son B (negrita), U (subrayado), I (cursiva), vacio (normal).
$pdf->Cell(10, 20, "Texto interior", 1);
//Creamos una celda de 10 de ancho, 20 de alto, con ese texto en su interior, y 1 de borde.
$pdf->setFillColor(10, 200, 14);
//Declaramos un color de relleno RGB (verde claro).
$pdf->Ln(30);
//Salto de línea de tamaño 30.
$pdf->Cell(50, 20, "Otro texto", 2, 2, L, true);
//50 de ancho, 20 de alto, con ese texto, 2 de borde, L de alineado (landscape), y true es el relleno definido antes
//El segundo 2, nos permite decidir dónde irá el elemento posterior a este. En caso de estar en 2, irá debajo.
// Si hay un 1, al comienzo de la línea siguiente. Si hay un 0, irá a la derecha.
$variable = $pdf->GetY();
// obtenemos la posición Y.
$pdf->SetX($variable);
//Declaro que quiero que el siguiente elemento tenga de posición X, lo que tenía de posición Y.
$pdf->Cell(5, 5, $variable, 1);
//Creamos esta celda.
$pdf->Image("google.jpg", 80, 0, 70, 40);
//Ponemos una imagen. El segundo y el tercer parámetro son las coordenadas X e Y, los dos siguientes
//son la anchura y la altura respectivamente.
$pdf->Output();
//Función que nos permite obtener el PDF.
?>
Funciones más interesantes
En este apartado trataremos de hacer una cabecera y un pie de página para que salgan en todas las páginas. Para esto, hay que extender la clase FPHP como veremos posteriormente de manera que habrá que crear las funciones Footer y Header. Por otra parte, aprenderemos a referenciar objetos dentro del propio documento y establecer el número de páginas totales y actual.
SetFont('Arial','B',15);
//Declaramos una fuente
$this->Cell(30,10,'Titulo',1,0,'C');
//Titulo
$this->Ln(20);
//Salto de línea
}
//Pie de página
function Footer()
{
$this->SetY(-15);
//Posición: a 1,5 cm del final
$this->SetFont('Arial','I',8);
$this->Cell(0,10,'Página '.$this->PageNo().'/{nb}',0,0,'C');
//PageNo nos muestra el número de página actual
//El "/{nb}" es para que nos muestre el número de páginas máximo
//de tal forma que se quede del tipo "Página 1/2"
//Esto es debido a la función posterior "AliasNbPages"
}
}
//Creación del objeto de la clase heredada
$pdf=new PDF();
$pdf->AliasNbPages();
//Es la función que nos declara un Alias por defecto para
//obtener el número de páginas máximo
$pdf->AddPage();
$link = $pdf->AddLink();
//Establecemos el link
$pdf->Write(5, "Pulsar aquí", $link);
//Al pulsar en ese texto, nos linkeamos gracias al link declarado anteriormente
$pdf->AddPage();
$pdf->AddPage();
$pdf->SetLink($link, 70);
//Establecemos el link a 1,5 centímetros (eje Y)
$pdf->Output();
?>
Para finalizar, decir que hay multitud de funciones para un uso más intensivo y completo de esta libreria que se encuentran en la parte de “Manual” su página web. En estas breves páginas he intentado escribir las más importantes y útiles para un sencillo uso.
Strcspn nos devuelve el número de caracteres que hay en una cadena que no aparecen en otra. Es complicado de explicar pero fácil de entender con algún ejemplo.
Su sentencia es:
$var = strcspn($cadena1, $cadena2);
?>
Cadena1 será la cadena de texto que compararemos. Cadena2 será la cadena de texto que tendrá los caracteres que no queremos contar.
Ejemplo
$texto = "xyzmnoptq"; //esta cadena de texto tiene 9 caracteres
$noContables = "abcdefg";
echo strcspn($texto, $noContables);
//Imprime 9, porque se han contado todos los caracteres del texto
$noContables = "abco";
echo strcspn($texto, $noContables);
//Imprime 5, porque cuenta caracteres hasta que llega al caracter "o", y ahí para de contar.
?>
Strip_tags nos permite controlar los tags que queremos mostrar de una cadena de texto, incluso eliminarlos todos.
Su sentencia es:
$var = strip_tags($cadena, ($tagsPermitidas));
?>
Cadena es la cadena de texto entrante a la que vamos a realizarle los cambios. tagsPermitidas es la cadena de texto en la que ponemos las tags que si que queremos permitir. Este parámetro es opcional, y si no ponemos nada, no se filtra ninguna y se eliminan todas.
Ejemplo
$cadena = "Textodeejemplo";
echo strip_tags($cadena) . " ";
echo strip_tags($cadena, "");
//Solo vamos a filtrar la negrita, el resto no aparecerá.
?>
Devuelve:
Texto de ejemplo Texto de ejemplo
Stripcslashes nos permite traducir a los símbolos unicode. Con un ejemplo se entiende:
echo stripcslashes("\xb6");
?>
Nos devuelve: ¶
Stripos nos devuelve la posición en la que se encuentra uno o varios caracteres dentro de una cadena.
echo stripos("Hola mundo", "u")
?>
Nos devuelve 6. En caso de no encontrar nada, no devuelve nada.
Stripslashes nos devuelve la cadena de texto introducida sin los caracteres de la barra inclinada \
Stristr nos permite, dado un caracter o cadena de texto, obtener lo que hay detrás o lo que hay delante.
$email = 'correo@dominio.com';
echo stristr($email, '@') . " ";
echo stristr($email, '@', true); //Esta función solo funciona de la versión 5.3.0 hacia adelante
?>
str_split nos permite dada una cadena de texto, obtener una matriz cuyos valores sean cada carácter de la cadena, e incluso poner un límite numérico para que por ejemplo, cada elemento de la matriz contenga N caracteres.
Su sentencia es:
$matriz = str_split($cadena, ($limite));
?>
Cadena es la cadena de texto que vamos a dividir en la matriz. Límite es el número máximo de caracteres que puedo contener cada elemento de la matriz. Es opcional.
str_word_count nos permite contar las palabras que existen en una cadena, separadas por cualquier caracter que no sea una letra. Por ejemplo, en la frase: OLPC tiene 3 años, diria que solo existen 3 palabras, OLPC, tiene, y años. Tambien podriamos hacer la prueba con la frase: OLPC t1ene 3 años, diciendo que tendria 4 palabras, OLPC, t, ene, y años. Es decir, cualquier caracter que no sea una letra, actúa como separador entre palabras, aunque podemos añadir excepciones.
Cadena es la cadena de texto en la cual vamos a contar el número de palabras existentes. Formato es un número del cero al dos, que nos permite personalizar el resultado. Si ponemos un 0, devuelve el número de palabras (por defecto), si ponemos un 1, devuelve un array cuyos elementos sean las palabras encontradas, y si ponemos un 2, devuelve un array cuyos elementos sean las palabras encontradas y cuyo índice es la posición de la letra de cada palabra. Lista es la lista de caracteres que queremos excepcionar para que no sean separadores de palabras. Por defecto son todos, salvo las letras mayúsculas y minúsculas (incluyendo la Ñ y las vocales con acentos)
Ejemplo
$cadena = "OLPC tiene 3 años";
$resultado1 = str_word_count($cadena);
//Simplemente obtenemos el número de palabras
$resultado2 = str_word_count($cadena, 1);
//Obtenemos cada palabra en un elemento del array resultado2
$resultado3 = str_word_count($cadena, 2, "3");
//Hacemos que '3' se convierta en una excepcion (osea que hay 4 palabras) y cada elemento del array pertenece a cada palabra de la cadena, cuyos indices son la posicion de la primera letra de cada palabra
echo $resultado1 . "
";
foreach($resultado2 as $clave => $valor)
echo "Clave: $clave y Valor: $valor ";
echo " ";
foreach($resultado3 as $clave => $valor)
echo "Clave: $clave y Valor: $valor ";
?>
Nos devuelve:
3
Clave: 0 y Valor: OLPC
Clave: 1 y Valor: tiene
Clave: 2 y Valor: años
Clave: 0 y Valor: OLPC
Clave: 5 y Valor: tiene
Clave: 11 y Valor: 3
Clave: 13 y Valor: años
strcasecmp nos permite comparar el primer caracter de dos cadenas de texto, y obtener la diferencia de posiciones (respecto la tabla ASCII) que hay entre ellas. No distingue entre mayúsculas o minúsculas en el caso de las letras. En caso de que la cadena sea de más de un carácter y el primer carácter sea igual, pasará al segundo carácter (lo veremos más claro con el ejemplo)
Su sentencia es:
$resultado = strcasecmp($cadena1, $cadena2);
?>
Cadena1 y Cadena2 son las cadenas de texto, cuyos primeros caracteres se van a comparar.
Ejemplo
$resultado = strcasecmp("a", "b");
//Se resta el primero menos el segundo, por eso el resultado saldrá negativo
echo $resultado . " ";
$resultado2 = strcasecmp("hola", "Hona");
//Aqui, como h es igual a H, pasa a comprobar el siguiente caracter, y como también es igual, pasa a comprobar el tercero, entre 'l' y 'n'. Podemos observar que hay una diferencia de 2 posiciones entre ambos
echo $resultado2 . " ";
$resultado3 = strcasecmp("=", "-");
echo $resultado3 . " ";
//Ahora, pasaremos los caracteres = y - a ASCII y los restaremos, para ver que nos da el mismo resultado:
$otro = ord("=") - ord("-");
echo $otro;
?>
Nos devuelve:
-1
2
16
16
strchr y strstr (usaré strstr para los ejemplos pero funcionan de manera idéntica) nos permiten obtener una cadena de texto posterior o anterior a un separador.
Cadena es la cadena de texto que vamos a dividir. Separador es la cadena de texto que nos permitirá dividir la otra cadena de texto entrante. Bool es un valor, que puede ser true o false. Por defecto está en false. Es opcional. Nota: el último parámetro solo funciona a partir de la versión de PHP 5.3.0
strcmp y strcoll funcionan de una manera parecida a strcasecmp. Devuelve 0 si las cadenas son iguales. Devuelve 1 si la el carácter de la segunda es mayor (en la table ascii) que el de la primera cadena, y -1 en caso contrario.
Su sentencia es:
$resultado = strcmp($cadena1, $cadena2);
?>
Cadena1 y Cadena2 serán las cadenas cuyos primeros caracteres se compararan. Es sensible a mayúsculas y minúsculas, al contrario que strcasecmp.
Objeto es el string que queremos encontrar para cambiarlo. Remplazo es el string sustituto de lo que vamos a cambiar. Cadena es el string en donde va a buscar. Nueva es la nueva cadena de texto que se va a formar.
Ejemplo
$cadena = "Esta es una cadena de texto de ejemplo";
$nuevaCadena = str_ireplace("de", "DE", $cadena);
echo $nuevaCadena;
?>
El resultado será: Esta es una caDEna DE texto DE ejemplo
str_pad nos permite, dada una cadena, rellenarla con caracteres hasta alcanzar cierta longitud. Podemos elegir por donde queremos rellenarlo (izquierda, derecha, ambos), y también el/los carácter(es) con los que lo vamos a rellenar.
Cadena es la cadena de texto en la que vamos a rellenar. Longitud es el número de caracteres que queremos tener al final, una vez rellenado. Caracter es el caracter (o caracteres) con los que vamos a rellenar nuestra cadena. Es opcional, por defecto se rellena con espacios en blanco. Lugar es por donde se va a rellenar la cadena, izquierda, derecha, o ambos.
Ejemplo
echo str_pad("ejemplo1", 15, "*");
echo " ";
echo str_pad("ejemplo2", 13, "=______________=", STR_PAD_LEFT);
//Nota: aquí se nota que va a sobrar. Lo veremos reflejado en el resultado.
echo " ";
echo str_pad("ejemplo3", 20, "-", STR_PAD_BOTH);
?>
Devuelve:
ejemplo1*******
=____ejemplo2
——ejemplo3——
str_repeat nos permite multiplicar una cadena de texto tantas veces como queramos.
Su sentencia es:
echo str_repeat($cadena, $veces);
?>
Cadena es la cadena de texto que se repetirá. Veces es el número de veces que se repetirá.
Ejemplo
echo str_repeat("(*)", 5);
?>
Nos devuelve:
(*)(*)(*)(*)(*)
str_replace funciona de manera exactamente igual que str_ireplace, aunque a continuación escribiremos un ejemplo si se dieran matrices como cadena.
$cadena[] = "Esta es una cadena de texto de ejemplo";
$cadena[] = "Esta es otra cadena de texto dedede ejemplo";
$nuevaCadena = str_ireplace("de", "DE", $cadena);
echo $nuevaCadena[0];
echo " ";
echo $nuevaCadena[1];
?>
Resultando: Esta es una caDEna DE texto DE ejemplo
Esta es otra caDEna DE texto DEDEDE ejemplo
str_rot13 nos permite cifrar mediante ROT13. Es un tipo de encriptación César (denominado así porque el primero en usar este tipo de encriptación fue Julio César. Se encarga de usar las letras del abecedario que se encuentran en otra posición). Es decir, que nos devuelve caracteres que se encuentran 13 posiciones antes (en el abecedario, sin contar la Ñ). Funciona con mayúsculas y minúsculas, y todo lo que no sean letras, se queda exactamente igual.
Su sentencia es:
echo str_rot13($cadena);
?>
Cadena es la cadena de texto que se va a cifrar.
Ejemplo
echo str_rot13("abCD12ñ");
?>
Nos devuelve: noPQ12ñ
str_shuffle nos permite desordenar aleatoriamente los caracteres de una cadena.
Su sentencia es:
echo str_shuffle($cadena);
?>
Cadena es la cadena de texto que se desordenará aleatoriamente.
preg_grep nos permite, a partir de un array, generar otra matriz que tenga los valores del array que coinciden con un patrón.
Su sentencia es:
$matriz = preg_grep($patron, $otraMatriz);
?>
Patrón es el parámetro expresado mediante expresiones regulares que nos permite encontrar algo definido dentro de, en este caso, una matriz dada. otraMatriz es la matriz principal en la que tenemos diversos valores y en donde vamos a buscar, mediante el patrón, las coincidencias que queramos.
Si recordemos que en expresiones regulares se distinguen mayúsculas de minúsculas, y para evitar esa distinción ponemos una i al final del patrón, quedando: $patron = ‘/hola/i’;
preg_quote nos devuelve una cadena de texto con los caracteres especiales de las expresiones regulares escapados, por lo que es útil para combinarlo con estas.
Estos caracteres especiales son: . \ + * ? [ ^ ] $ ( ) { } = ! < > | : –
Su sentencia es:
$resultado = preg_quote($cadena, ($caracter));
?>
Cadena es la cadena de texto que introducimos. Caracter es un carácter que introducimos si también queremos escaparlo (es opcional). Resultado es la cadena de texto de salida, que se encuentra con los caracteres escapados (mediante la barra \)
Nos devuelve: Ej\emplo\-nu\evo
Porque escapa el carácter especial por defecto “-” y el que queriamos nosotros, ‘e’.
preg_replace_callback nos permite, al igual que preg_replace, reemplazar datos, pero en este caso, lo podemos realizar a través de funciones, siendo el resultado más personalizable y complejo.
Patrón es la expresión que nos permite encontrar los datos que queremos. Función es el nombre de la función que utilizaremos. Input es el valor que introduciremos en la función anterior.
Ejemplo
$cadena = "El pasado día 15 hubo una revuelta";
function cambiar($ejemplo) {
return $ejemplo[0]+2;
//ejemplo[0] vale 15, que es el número encontrado por el patrón.
}
echo preg_replace_callback("/\d{2}/", "cambiar", $cadena);
//Se encarga de cambiar el número 15, por 15+2 (es decir, 17), junto con el resto de la cadena.
?>
El objetivo de esta función es añadir 2 días más a la fecha que pone en la cadena. Nos devuelve: El pasado día 17 hubo una revuelta
preg_split nos permite partir una cadena de texto, dando como resultado una matriz en donde se guarde en cada clave esos valores.
Patrón es el conjunto de expresiones regulares a partir de las cuales, cuando encuentre una coincidencia partirá la expresión, almacenando el resultado en una matriz. Cadena es la cadena de texto que deseamos partir. Límite es el número máximo de cadenas que queremos obtener. Este parámetro es opcional. Si se escribe un 0, o no se pone, se entiende que no hay límite. Opciones nos permite personalizar el resultado de la matriz resultante. Explicaré las 3 opciones más comunes.
Ejemplo
$cadena = preg_split("/(a)/", "Esta es una cadena de texto de ejemplo.", 0);
//No me complico la vida con el patrón, pero podría usar cualquier tipo de expresión regular válida
foreach($cadena as $clave => $valor)
echo "Valor: $valor ";
?>
Nos devuelve: Valor: Est
Valor: es un
Valor: c
Valor: den
Valor: de texto de ejemplo.
Podemos observar que cada valor de la matriz, corresponde al trozo de cadena partida (sin el separador).
Ahora explicaré las diferentes opciones que podríamos añadir: PREG_SPLIT_NO_EMPTY se encarga de que la matriz no tenga ningún elemento vacio. ¿Cómo es posible que tenga elementos vacios la matriz?
Imaginemos que usamos de patrón un punto, y de cadena, una frase terminada en punto: “Esto es un ejemplo.”
preg_split separa en dos trozos lo que hay antes, y lo que hay detrás del punto. Como detrás del punto no hay nada, se guarda un valor vacio (null).
PREG_SPLIT_DELIM_CAPTURE se encarga de que nuestra matriz venga con los delimitadores como valores nuestra propia matriz (esto solo funciona si se han usado paréntesis en la expresión regular de patrón). Es decir, en nuestro anterior ejemplo nos devolvería lo siguiente: Valor: Est
Valor: a
Valor: es un
Valor: a
Valor: c
Valor: a
Valor: den
Valor: a
Valor: de texto de ejemplo. PREG_SPLIT_OFFSET_CAPTURE genera una matriz de dos dimensiones, de manera que, en cada coincidencia nos muestra la posición del primer carácter de la cadena partida. Lo veremos claramente mediante un ejemplo:
$cadena = preg_split("/(a)/", "Esta es una cadena de texto de ejemplo.", 0, PREG_SPLIT_OFFSET_CAPTURE);
foreach($cadena as $clave => $valor)
echo "Valor: $valor[0] y $valor[1] ";
?>
Nos devuelve: Valor: Est y 0
Valor: es un y 4
Valor: c y 11
Valor: den y 14
Valor: de texto de ejemplo. y 18
Repito, el número obtenido es la posición del primer carácter de cada uno, respecto la cadena original.
preg_match_all nos sirve para cuando queremos buscar algo en una cadena de texto, y queremos que nos devuelva eso que ha encontrado. Nos podría servir por ejemplo, para saber todas las imágenes que hay en una página web o sencillamente, para recoger fechas y cosas definidas desconocidas.
Patron serán los filtros que pongamos para que busque dentro del string. Este patrón se expresa con expresiones regulares. String es la cadena de texto en donde vamos a buscar lo que necesitamos. Salida será la matriz final en la que tengamos los resultados de la búsqueda y algunos otros resultados. Opciones será el parámetro que nos permita ordenar en el array de salida los elementos obtenidos (son opcionales). Por ejemplo:
$cadena = '18/01-85 26/01/92';
preg_match_all('/[0-9]{2}(\/|\-)[0-9]{2}(\/|\-)[0-9]{2}/', $cadena, $salida, PREG_PATTERN_ORDER);
//Este script nos sirve para sacar las fechas y saber qué separador usan.
echo $salida[0][0] . " y " . $salida[0][1];
echo " ";
echo $salida[1][0] . " y " . $salida[1][1];
echo " ";
echo $salida[2][0] . " y " . $salida[2][1];
?>
Nos devuelve:
18/01-85 y 26/01/92
/ y /
– y /
El siguiente ejemplo:
$cadena = '18/01-85 26/01/92';
preg_match_all('/[0-9]{2}(\/|\-)[0-9]{2}(\/|\-)[0-9]{2}/', $cadena, $salida, PREG_SET_ORDER);
//Solo cambia el patrón y lo de abajo
echo $salida[0][0] . " y " . $salida[1][0];
echo " ";
echo $salida[0][1] . " y " . $salida[1][1];
echo " ";
echo $salida[0][2] . " y " . $salida[1][2];
?>
Devuelve: 18/01-85 y 26/01/92
/ y /
– y /
preg_match lo usaremos para saber simplemente, si en una cadena de texto se encuentra lo que buscamos. Si hemos entendido preg_match_all, con este no deberia de haber ningún problema. Usa una sentencia igual (en los dos primeros parámetros) que preg_match_all:
preg_match_all($patron, $string)
?>
Usaremos un ejemplo para explicar su funcionamiento:
Nos devuelve 1, porque lo ha encontrado. Si no lo hubiera encontrado nos habria devuelto 0.
preg_replace nos permite, a partir de una cadena dada, reemplazar, reordenar y cambiar datos de esta cadena de forma sencilla.
Su sentencia es:
preg_replace($patron, $sustitucion, $cadena)
?>
Patrón se expresa mediante Expresiones Regulares. Sustitución es la cadena ordenada y reorganizada a la que dará resultado. Usaremos $N en donde N serán números indicadores de la posición de los patrones, por los que sustituiremos (con el ejemplo se ve mucho más fácil). Cadena es la cadena de texto a la que realizaremos la edición.
$cadena = 'Enero 26, 1992';
$patron = '/(\w+) (\d+), (\d+)/i';
$sustitucion = 'Nací el $2 de $1 de $3';
echo preg_replace($patron, $sustitucion, $cadena);
?>