Gestión de archivos en PHP - · PDF fileTu mejor ayuda para aprender a hacer webs Gestión de archivos por PHP El tratamiento de archivos resulta ser una práctica muy común en

Tu mejor ayuda para aprender a hacer webswww.desarrolloweb.com

Gestión de archivos en PHP

Autores del manual

Este manual ha sido realizado por los siguientes colaboradores de DesarrolloWeb.com: Rubén AlvarezRedactor de DesarrolloWeb.comhttp://www.desarrolloweb.com (4 capítulos)

Miguel Angel AlvarezDirector de DesarrolloWeb.comhttp://www.desarrolloweb.com (5 capítulos)

Rene Sterling Neira (1 capítulo)

Alfredo AnayaDirector Técnico de ADR Formacionhttp://www.adrformacion.com (1 capítulo)

Emmanuel García De CaroWebmaster de Blasten.comhttp://www.blasten.com (2 capítulos)

Gestión de archivos en PHP: http://www.desarrolloweb.com/manuales/75/ © Los manuales de DesarrolloWeb.com tienen el copyright de sus autores. No reproducir sin autorización.

1

http://www.desarrolloweb.com/

http://www.desarrolloweb.com/manuales/75/

http://www.blasten.com/

http://www.adrformacion.com/




Gestión de archivos por PHP

El tratamiento de archivos resulta ser una práctica muy común en cualquier sitio web. Muy a menudo nos vemos en la necesidad de procesar un texto para cambiarle el formato, buscar una cadena en su interior o cualquier otro tipo de operación.

PHP propone un sinfín de funciones para la gestión de archivos que van desde las más elementales de apertura, lectura y cierre a otras más rebuscadas como el cálculo de espacio en el disco duro, tamaño del archivo, gestión de derechos de acceso...

En este artículo pretendemos mostraros cuáles son las funciones más esenciales para el tratamiento de archivos para posteriormente ejemplificarlas en un par de scripts que os pueden resultar útiles:

Funciones de gestión de archivosFunció

n Descripción Sintaxis

copy Copia un archivo copy($origen,$destino)

rename Cambia el nombre del archivo de $antes a $despues

rename($antes,$despues)

unlink Borra el archivo unlink($archivo)

Funciones para la lectura de archivosFunción Descripción Sintaxis

fopen Abre un archivo y le asigna un identificador id. Veremos el modo más adelante

$id = Fopen($archivo, $modo)

fgets Lee una línea de un archivo hasta un numero máximo de caracteres fgets($id,$max)fwrite Escribe una cadena dentro del archivo fwrite($id, $cadena)fseek Avanza o retrocede el puntero del archivo un cierto numero de posiciones fseek($id,$posiciones)feof Comprueba si el puntero que lee el archivo ha llegado al final feof($id)

fpassthru lee completamente el archivo y lo muestra fpassthru($id)

fclose Cierra el archivo abierto previamente fclose($id)

Las operaciones más elementales, copia, borrado y cambiar el nombre, requieren únicamente el nombre (y path) del archivo sobre el cual se ejerce la operación. Para operaciones más complejas, como la lectura de líneas o la escritura de texto dentro del archivo, se requiere de una previa apertura del archivo al cual le asignaremos un indentificador $id.

Una vez abierto el archivo, podremos desplazarnos a lo largo de él por medio de un puntero imaginario que avanza o retrocede por las líneas de texto y mediante el cual nos situaremos en el lugar escogido para insertar, modificar o simplemente copiar una cadena.

Existen distintos modos de apertura que nos permiten definir las acciones que podemos realizar sobre el archivo. Aquí os mostramos los diferentes modos que, como veréis, son de lo más variado:

Modos de apertura de archivosSintaxi Descripción


2



http://www.php.net/manual/en/ref.filesystem.php


s'r' Sólo lectura

'r+' Lectura y escritura'w' Sólo escritura

'w+' Lectura y escritura. Suprime el contenido anterior si se escribe. El archivo es creado si no existe.

'a' Sólo escritura. El archivo es creado si no existe y el puntero se coloca al final.'a+' Lectura y escritura. El archivo es creado si no existe y el puntero se coloca al final.

A notar que si tratamos con archivos en binario hemos de colocar una b delante del modo (ej. ba, bw+,...)

Recordamos que esta lista no es más que una recopilacion y que muchas otras funciones relacionadas pueden sernos también útiles.

Nota:También puedes profundizar más en la gestión de archivos con nuestro manual Gestión de archivos en PHP

Artículo por Rubén Alvarez

Lectura secuencial de archivos con PHP

Sigamos con nuestro aprendizaje práctico del uso de ficheros en PHP. Ya hemos visto cómo abrir un archivo por medio de la función fopen con un ejemplo práctico de cómo verificar una URL. El paso siguiente es aprender a leer el contenido del archivo, tarea que llevaremos a cabo por medio de la función fgets.

Esta función se encarga de leer línea a línea el contenido de un archivo texto por lo que su utilización ha de ser incluida dentro de una estructura de tipo bucle.

En el ejemplo que os mostramos a continuación nos hemos servido de esta lectura secuencial para localizar dentro del texto una cadena cualquiera a la que, a continuación, le cambiamos el formato para ponerla en negrita por medio de la etiqueta <b>. Esto nos puede resultar útil si llevamos a cabo búsquedas internas en nuestro sitio y queremos resaltar la cadena de búsqueda en el texto de la página encontrada.

Evidentemente, la utilidad de fgets resulta ser mucho más amplia. Podemos emplearla, por ejemplo, con archivos remotos para extraer las etiquetas meta o para muchas otras cosas que se nos puedan ocurrir.

Aquí os proponemos el script:

<?function negrita($path,$cadena){ //Iniciamos la variable $texto = ""; //Abrimos el archivo en modo lectura $fp = fopen($path,"r");


3



http://www.desarrolloweb.com/articulos/402.php








//Leemos linea por linea el contenido del archivo while ($linea= fgets($fp,1024)) { //Sustituimos las ocurrencias de la cadena que buscamos $linea = str_replace($cadena,"<b>$cadena</b>",$linea); //Anadimos la linea modificada al texto $texto .= $linea; } return $texto;}//Definimos el path y la cadena$path="escribe el camino de acceso a tu archivo";$cadena = "escribe tu cadena";//Llamamos la funcion$texto = negrita ($path,$cadena);//Mostramos el textoecho $texto;?>

Podéis ver el resultado de esta función en una variante del script donde hemos incluido un formulario para recibir el parámetro cadena y que busca las ocurrencias dentro del texto de este mismo articulo:

Introduce la cadena de búsqueda:

El script es utilizado en forma de función para facilitaros su empleo y almacenamiento. Su modo de actuar es el siguiente:

• Inicializa la variable texto en la cual iremos almacenando las líneas leídas en el bucle.

• Abre el archivo (local o remoto) en modo lectura por medio de la función fopen.

• Lee una por una las líneas del archivo hasta una longitud de 1024 caracteres y remplaza las posibles ocurrencias de la cadena de búsqueda por la misma cadena colocada entre las etiquetas <b> y </b> por medio de la función str_replace. El texto, modificado o no, es almacenado en la variable texto.

• Devolvemos la variable texto como resultado de la función.

El resto de script es simplemente un ejemplo de llamada a la función donde los parámetros path y cadena han de ser especificados.


Escritura en archivos con PHP

Siguiendo con la gestión de archivos por medio de PHP, en este artículo veremos los pasos


4

Buscar!




elementales para la creación y escritura de un archivo texto por medio de esta tecnología de lado servidor. Tras haber visto como funciona la lectura secuencial de un archivo, podemos imaginar que escribir sobre éste no debe de resultar mucho más complicado.

Por otra parte, las posibilidades que estas dos operaciones nos pueden ofrecer conjuntamente son realmente sorprendentes. Sin ir más lejos, y guardando las distancias, escribir y leer archivos puede en cierta manera sustituir muy primariamente a una base de datos. En efecto, si por diversas razones (hosting, presupuesto, conocimientos...) nos resulta difícil la puesta en marcha de una base de datos elemental, siempre podremos solventar el inconveniente almacenando nuestros datos en archivos que luego podrán ser leídos. Por supuesto, este método no tiene nada de seguro ni de versátil y sólo es valido para un sitio sin información confidencial y con poca cantidad de datos.

Podemos pensar también en crear documentos dinámicos a partir de datos introducidos en un formulario: cartas, páginas HTML y otros.

Otro ejemplo particularmente práctico es la creación dinámica de archivos que nos ahorren recursos de servidor. Imaginemos que tenemos una página, o archivo, en nuestro sitio que carga muy frecuentemente y que realiza constantemente llamadas a bases de datos o ejecuta scripts medianamente largos. Si el contenido que estamos mostrando es el mismo para todos los usuarios y no tiene necesidad de ser actualizado constantemente, podemos contentarnos con crear un script accesorio que ejecute una única vez el script principal y que almacene su resultado en forma de archivo HTML que será en realidad el que mostraremos a nuestros visitantes. De esta forma, evitamos por una parte la ejecución masiva de un mismo script con el consiguiente ahorro de recursos y por otra automatizamos la actualización de una determinada página o sección ejecutando periódicamente el script accesorio.

La escritura de archivos pasa, como es de esperar, por la previa apertura de archivo en un modo apropiado. Una vez abierto, el paso siguiente será introducir por medio de la función fwrite, o su alias fputs, la cadena que deseamos incluir en nuestro archivo.

Para ejemplificar esta nueva función de escritura y combinarla con la de lectura, fgets, os proponemos este contador inspirado en una nota de la página oficial de PHP:

<?function incremento_contador($archivo){// $archivo contiene el numero que actualizamos$contador = 0;

//Abrimos el archivo y leemos su contenido$fp = fopen($archivo,"r"); $contador = fgets($fp, 26); fclose($fp);

//Incrementamos el contador++$contador;

//Actualizamos el archivo con el nuevo valor$fp = fopen($archivo,"w+"); fwrite($fp, $contador, 26); fclose($fp);


5



http://www.php.net/manual/en/function.fwrite.php





echo "Este script ha sido ejecutado $contador veces"; }

?>

Aquí podéis ver el resultado producido cuando llamamos a esta función.

Como en otros ejemplos, el script es expresado en forma de función para que sea más sencilla su reutilización. Las etapas que llevamos a cabo son verdaderamente cortas y comprensibles:

• Iniciamos nuestra variable contador. • Abrimos el archivo en modo lectura y extraemos el valor actual del contador leyendo la

primera y única línea. Cerramos el archivo. • Aumentamos de una unidad el valor de contador. • Abrimos el archivo y lo sobrescribimos (modo +w) con el valor contador modificado.

Ni que decir tiene que para que este tipo de scripts funcionen, el archivo al que queremos acceder ha de estar autorizado para lectura y escritura.

La función fwrite puede ser utilizada también para enviar datos en otros tipos de aperturas como son las de sockets o de programas. Pero esto ya es otra historia...


Gestión de directorios por PHP

Siguiendo con la saga de artículos referentes a la explotación de archivos por medio de PHP, vamos a presentar algunas funciones que nos pueden ser muy útiles en la navegación por directorios. Este tipo de funciones podrían, por ejemplo, servirnos para crear exploradores de archivos en nuestro navegador.

Funciones de gestión de directoriosFunción Descripción Sintaxis

opendir Abre un directorio situado en $path y le asigna un identificador $dir $dir = opendir($path)

readdir Lee un elemento del directorio $dir abierto previamente con opendir y desplaza el puntero al elemento siguiente readdir($dir)

rmdir Elimina el directorio $dir rmdir($dir)

mkdir Crea un directorio situado en $path con los derechos de acceso $derechos (entero) mkdir($path, $derechos)

rewinddir Vuelve el puntero de lectura del directorio $dir al primer elemento rewinddir($dir)

closedir Cierra el directorio $dir abierto previamente con opendir closedir($dir)

La forma de tratar con estas funciones es la similar a la que ya hemos visto para le lectura secuencial de archivos. Podemos distinguir tres etapas elementales:

• Apertura del directorio por medio de la función opendir asignándole al mismo tiempo un


6



http://www.desarrolloweb.com/articulos/ejemplos/tallerphp/fwrite.php


identificador• Realización de las tareas necesarias en relación con ese directorio• Clausura del identificador por medio de la función closedir

A notar que, para que un directorio pueda ser borrado, hace falta previamente haber eliminado cada uno de los elementos contenidos dentro del directorio. Para esto, nos podemos servir de la función unlink, presentada en otor artículo.

Por otra parte, la creación de un directorio por medio de la función mkdir requiere la definición de los derechos de acceso por medio de un numero entero. Esperamos poder explicar en qué consisten estos derechos próximamente.

Como ejemplo sencillo de lo que podemos hacer con estas funciones, aquí os presentamos un pequeño script de lectura que os permite visualizar el contenido de un directorio:

<?//definimos el path de acceso$path = "mi/camino";

//abrimos el directorio$dir = opendir($path);

//Mostramos las informacioneswhile ($elemento = readdir($dir)){ echo $elemento."<br>";}

//Cerramos el directorioclosedir($dir); ?>

Otra forma de abordar la gestión de directorios es por medio de la clase dir que permite la creación de un objeto sobre el cual podremos aplicar toda una serie de métodos equivalentes a las funciones previamente vistas. Si estas familiarizado con la programación orientada a objetos, puede que esta modalidad te resulte mas intuitiva. Si no sabes en qué consiste la programación orientada a objetos, puedes visitar este artículo.

En este caso, la forma de operar es análoga a la ya vista:

• Creamos un objeto $dir con la instrucción: $dir = dir($path)• Realizamos las tareas necesarias llamando a los métodos de la clase dir• Cerramos el directorio con el método close

Algunos de los métodos que podemos utilizar con esta clase son los siguientes:

Métodos de la clase dirMétodo Descripción Sintaxis

path Indica el path del directorio $objeto->pathread Lee un elemento del directorio $objeto->read

rewind Vuelve el puntero de lectura del directorio al primer elemento

$objeto->rewind


7






close Cierra el directorio $objeto->close

Como ejemplo, he aquí el script equivalente al abordado para el caso de las funciones, esta vez usando la clase dir:

<?//definimos el path de acceso$path="mi/camino/";

//instanciamos el objeto$dir=dir($path);

//Mostramos las informacionesecho "Directorio ".$dir->path.":<br><br>";

while ($elemento = $dir->read()){ echo $elemento."<br>";}//Cerramos el directorio$dir->close();?>

Los scripts propuestos no son más que ejemplos sencillos de lo que estas funciones pueden ofrecernos. En vuestras manos queda el combinar estas funciones con otras vistas en este mismo taller de manera a crear aplicaciones que gestionen los archivos y directorios de vuestro servidor.

Recordamos que esta lista no es más que una recopilación y que muchas otras funciones relacionadas pueden sernos también útiles.


Upload de archivos con PHP

En PHP tenemos muchas funcionalidades desarrolladas desde el principio y sin necesidad de instalar ningún añadido en nuestro servidor. Es el caso de subir archivos a un servidor web por HTTP y a través de una página con un formulario, donde se permite seleccionar el archivo que queremos cargar de nuestro disco duro.

El ejemplo se encuentra bien documentado en un montón de páginas para desarrolladores, sin ir más lejos en la página de la propia tecnología: http://www.php.net/manual/es/features.file-upload.php. Nosotros en este caso vamos a intentar ir un poco más allá, realizando un par de comprobaciones al subir el fichero y combinando en el mismo formulario campos de tipo file y tipo text.

El formulario para subir seleccionar los archivos


8



http://www.php.net/manual/es/features.file-upload.php





Es un formulario cualquiera, pero tiene una serie de particularidades y campos file, que no solemos utilizar habitualmente.

<form action="subearchivo.php" method="post" enctype="multipart/form-data"> <b>Campo de tipo texto:</b> <br> <input type="text" name="cadenatexto" size="20" maxlength="100"> <input type="hidden" name="MAX_FILE_SIZE" value="100000"> <br> <br> <b>Enviar un nuevo archivo: </b> <br> <input name="userfile" type="file"> <br> <input type="submit" value="Enviar"> </form>

Para empezar vemos que se ha colocado un nuevo atributo en el formulario: enctype="multipart/form-data", necesario para subir en un mismo formulario datos y archivos.

También tenemos el campo hidden MAX_FILE_SIZE, que sirve para indicar el tamaño en bytes de los archivos a subir. Este campo algunos navegadores no tienen porqué entenderlo o hacerle caso. Además, es fácil saltarse esa protección, por lo que deberemos en las propias páginas PHP comprobar que el archivo tenga el tamaño que deseamos.

Por último, tenemos el campo tipo file, donde se seleccionará el archivo a subir. También hemos colocado un campo de tipo text, para subir datos por POST de tipo texto acompañados a los datos binarios del archivo.

Página que sube los archivos

Esta página debe hacer las comprobaciones necesarias para saber si las características del archivo a subir son las que deseamos y realizar la copia del archivo en un directorio del servidor.

Para hacer las comprobaciones, PHP nos crea una serie de variables que podemos acceder con la información del archivo enviado.

$HTTP_POST_FILES['userfile']['name'] El nombre original del fichero en la máquina cliente.

$HTTP_POST_FILES['userfile']['type'] El tipo mime del fichero (si el navegador lo proporciona). Un ejemplo podría ser "image/gif".

$HTTP_POST_FILES['userfile']['size'] El tamaño en bytes del fichero recibido.

$HTTP_POST_FILES['userfile']['tmp_name'] El nombre del fichero temporal que se utiliza para almacenar en el servidor el archivo recibido.

<? //tomo el valor de un elemento de tipo texto del formulario $cadenatexto = $_POST["cadenatexto"]; echo "Escribió en el campo de texto: " . $cadenatexto . "<br><br>";


9




//datos del arhivo $nombre_archivo = $HTTP_POST_FILES['userfile']['name']; $tipo_archivo = $HTTP_POST_FILES['userfile']['type']; $tamano_archivo = $HTTP_POST_FILES['userfile']['size']; //compruebo si las características del archivo son las que deseo if (!((strpos($tipo_archivo, "gif") || strpos($tipo_archivo, "jpeg")) && ($tamano_archivo < 100000))) { echo "La extensión o el tamaño de los archivos no es correcta. <br><br><table><tr><td><li>Se permiten archivos .gif o .jpg<br><li>se permiten archivos de 100 Kb máximo.</td></tr></table>"; }else{ if (move_uploaded_file($HTTP_POST_FILES['userfile']['tmp_name'], $nombre_archivo)){ echo "El archivo ha sido cargado correctamente."; }else{ echo "Ocurrió algún error al subir el fichero. No pudo guardarse."; } } ?>

Para empezar, recogemos el campo de texto enviado por POST, de la forma habitual. Aunque esto no tenga nada que ver con subir archivos, es muy normal que en el mismo formulario deseemos mezclar varios tipos de información.

Luego se recogen los datos necesarios del archivo, como su nombre, extensión y tamaño para, en el siguiente if, comprobar que la extensión sea .gif o .jpg y que el tamaño menor que 100000 bytes.

Si el archivo tenía las características deseadas, se puede subir al servidor. Para ello se utiliza la función move_uploaded_file(), que recibe el nombre del archivo temporal que se desea subir y el nombre del archivo que se desea dar.

Cuando se sube el archivo, el servidor lo copia en una localización temporal para que seamos nosotros los que elijamos la posición definitiva donde queremos que se almacene. Si no lo copiamos a ningún sitio, después de la ejecución de la página, se borra de su localización temporal.

La función move_uploaded_file() se utiliza para mover el archivo a la posición definitiva. Recibe por un lado el nombre temporal del fichero y por otro el nombre que deseamos colocarle definitivamente y, si se desea, la ruta para llegar al directorio donde queremos guardarlo. En el caso del ejemplo sólo se indica el nombre del archivo, por ello el fichero se subirá al mismo directorio donde están las páginas PHP que hacen el upload. Esta función devuelve un boleano que indica si hubo o no éxito al subir el archivo.

Nota: Es importante señalar que el upload de archivos es un proceso crítico que puede dar lugar a errores y agujeros de seguridad. Por ejemplo, si los directorios destino están protejidos contra escritura, nos dará un error. Podemos ver los errores comunes relatados en la página de PHP.

Recomendamos una vez más ampliar esta información en la página de PHP: http://www.php.net/manual/es/features.file-upload.php

Se pueden descargar los códigos del ejemplo en este enlace.

Artículo por Miguel Angel Alvarez


10



http://www.desarrolloweb.com/descargas/descargar.php?descarga=4198


http://www.php.net/manual/es/features.file-upload.common-pitfalls.php


Personalizacion de documentos con PHP

GENERAR CONTRATOS

Este script sirve basicamente para remplazar varios textos que esten en la base de datos por unas respuestas dadas y almacenadas en una tabla.

<? /* CABEZA DEL FORMULARIO FUNCTION*/ cabeza_selector(); /* SEGMENTO PARA GUARDAS CLAUSULAS ASOCIADAS A LAS RESPUESTAS EN UNA TEMPORAL*/

$claves = mysql_query("select tem_claves.id_respuesta, tem_claves.id_pregunta, respuestas.detalle_respuesta, cuestionario.pregunta from tem_claves, respuestas, cuestionario where tem_claves.clave_excluyente = $id and respuestas.id_r_2 = tem_claves.id_respuesta and cuestionario.id = tem_claves.id_pregunta"); $numero = mysql_num_rows($claves);

$claves2 = mysql_query("select tem_claves.id_respuesta, tem_claves.id_pregunta, respuestas.detalle_respuesta, cuestionario.pregunta from tem_claves, respuestas, cuestionario where tem_claves.clave_excluyente = $id and respuestas.id_r_2 = tem_claves.id_respuesta and cuestionario.id = tem_claves.id_pregunta");

while($rowr = mysql_fetch_array($claves2)) { $clausulas = mysql_query("select * from asociacion_clausulas, clausulas where asociacion_clausulas.id_respuesta = '$rowr[0]' and clausulas.id = asociacion_clausulas.id_clausula");

while($rowc = mysql_fetch_array($clausulas)) { $ingresar = mysql_query("insert into tem_clausulas (id_clausula, id_respuesta, clausula, clave_excluyente) values ($rowc[1], $rowr[0], '$rowc[5]', $id)"); } } /*SEGMENTO PARA REEMPLAZAR PARRAFOS, 1. ASOCIAR LOS PARRAFOS EN EL LUGAR DE LA CLAUSULA QUE SE DESEE PARA QUE SEA BUSCADA Y REMPLAZA POR LA RESPUESTA SELECCIONADA

2. ES IMPORTANTE CREAR UNA CLAVE IGUAL A LA RESPUESTA E INCLUIR ESTA CLAVE EN LA CLAUSULA, DE ESTA MANERA EL BUSCADOR ENCONTRARA ESTA CLAVE, BUSCARA EL PARRAFO CON ID DE LA CLAVE LO TRAERA Y LO REEMPLAZARA POR EL PARRAFO

EJEMPLO: TENEMOS UNA CLAUSULA PREAMBULO LA CUAL TIENE QUE ESTAR ARMADA POR UN PARRAFO, PERO ESTE PARRAFO DEPENDE DE UNA RESPUESTA SELECCIONADA

PREAMBULO CON PARRAFO 'ESTE ES UN EJEMPLO' SI LA RESPUESTA DADA ES QUE EJEMPLO Y ESTA RESPUETA GENERA LA CLAVE -1254- ENTONCES EN LA CLAUSULA PREAMBULO ASOCIAMOS

01 PREAMBULO -1254-

*/ /* $clave2 = mysql_query("select distinct parrafos.id, parrafos.detalle from tem_claves, asociar_parrafos, parrafos where tem_claves.clave_excluyente = $id and asociar_parrafos.id_respuesta = tem_claves.id_respuesta and parrafos.id = asociar_parrafos.id_parrafo"); */ $clave2 = mysql_query("select distinct parrafos.id, parrafos.detalle from parrafos"); while($rowcl = mysql_fetch_array($clave2))


11




{ $modificar1 = mysql_query("select clausula from tem_clausulas where clave_excluyente = $id order by id_respuesta"); $cantidad = mysql_num_rows($modificar1) -1;

$i = 0; for($i;$i<= $cantidad;$i++) { $r = mysql_result($modificar1,$i); $cm2 = str_replace('-par'.$rowcl[0].'-', $rowcl[1], $r); $ing = mysql_query("update tem_clausulas set clausula = '$cm2' where clave_excluyente = $id and clausula = '$r'"); } } /* EL RESULTADO ES 01 PREAMBULO 'ESTE ES UN EJEMPLO' DIGAMOS QUE EL PARRAFO Y LA CLAUSULA LE ASOCIAMOS UNA CLAVE PARA SER REEMPLAZADA POR OTRA RESPUESTA

EJEM 01 PREAMBULO -1684- 'ESTE ES UN EJEMPLO -1896-'

Y ESTA CLAVES PERTENECEN AL RESPUESTA: -1684- = HOLA -1896- = MUNDO

/*SEGMENTO PARA REEMPLAZAR CLAVES UNA VEZ INCLUIDO EL PARRAFO

*/ $clave2 = mysql_query("select * from tem_claves where clave_excluyente = $id"); while($rowcl = mysql_fetch_array($clave2)) { $modificar1 = mysql_query("select clausula from tem_clausulas where clave_excluyente = $id order by id_respuesta"); $cantidad = mysql_num_rows($modificar1) -1; $i = 0; for($i;$i<= $cantidad;$i++) { $r = mysql_result($modificar1,$i); $cm2 = str_replace('-'.$rowcl[0].'-', $rowcl[2], $r); $ing = mysql_query("update tem_clausulas set clausula = '$cm2' where clave_excluyente = $id and clausula = '$r'"); } } /* EL RESULTADO ES

01 01 PREAMBULO HOLA 'ESTE ES UN EJEMPLO MUNDO'

SEGMENTO PARA IMPRIMIR CONTRATO

*/ $genera_contrato= mysql_query("select distinct clausulas.numero_clausula, clausulas.titulo, clausulas.tipo_clausula, tem_clausulas.clausula from tem_clausulas, clausulas where tem_clausulas.clave_excluyente = $id and clausulas.id = tem_clausulas.id_clausula order by clausulas.numero_clausula");


12




while($cont = mysql_fetch_array($genera_contrato)) {?> <form method='POST' action='--WEBBOT-SELF--'> <table border='0' cellpadding='0' cellspacing='0' style='border-collapse: collapse' bordercolor='#111111' width='100%' id='AutoNumber1'> <tr> <td width='50%'><font color="#FF9933"><? echo $cont[0].' '.$cont[1]; ?></font></td> </tr> <tr> <td width='50%'><? echo $cont[3];?> </td> </tr> <tr> <td width='50%' height="31"></td> </tr> <? } ?> </table> </form> </form> <? pie_selector(); ?>

Artículo por Rene Sterling Neira

Generar documentos de Word RTF con php

En muchos desarrollos web surge la necesidad de crear documentos que proceden de la combinación de un documento origen con los datos almacenados en la Intranet/Extranet de la empresa, algo parecido a lo que se consigue con la combinación de correspondencia de Word.

Ejemplos prácticos pueden ser los siguientes:

Generación de etiquetas a partir de una base de datos de clientes o artículos Certificados o diplomas para los alumnos de un curso Listados de participantes en un evento. El control de la impresión desde un documento HTML es algo bastante complejo, por lo que generar un documento DOC, o mejor dicho RTF, nos permitirá resolver nuestro problema de una manera muy efectiva.

En este artículo desarrollaremos un ejemplo práctico, el de obtener un certificado de asistencia para cada uno de los alumnos que asisten a un curso.

La estrategia: Nuestra estrategia se fundamenta en los siguientes pasos:

Partimos del documento en formato de Word que queremos obtener. Convertimos el formato .DOC en .RTF. (Los archivos .RTF son de texto legible) Introducimos en el documento .RTF unos códigos manuales que serán sustituidos por los datos procedentes de la base de datos. Creamos una aplicación en PHP que lea el archivo .RTF y sustituya los códigos introducidos por los datos buscados.


13




Primer paso, Preparar la plantilla:

Para nuestro ejemplo partimos de un documento .DOC que certifica que un alumno ha realizado un curso. En la siguiente imagen vemos un certificado tipo.

Será preciso crear un certificado para cada uno de los alumnos que ha realizado un curso, los datos que varía son los del alumno y los del curso realizado.

Una vez abierto el documento con Word, lo guardamos en formato RTF y sustituimos cada dato variable por unos códigos fácilmente reconocibles. Ojo, el formato RTF es muy puñetero, por lo que será preciso escribir los códigos sin confundirse para que no se introduzcan caracteres raros.


14




En el caso del ejemplo utilizamos la # y el * de tal manera que por ejemplo, sustituimos el nombre del alumno por #*NOMBRE*#

Guardaremos el documento con el nombre de plantilla.rtf

Segundo paso, El programa PHP:

Crearemos dos funciones auxiliares, la primera se llama leef().

Esta función como se puede ver, recibe como argumento el nombre del fichero RTF, lo abre y almacena el contenido en la variable de texto $todo. Esta función por tanto devuelve el contenido de un fichero.

La siguiente función, rtf(), es la que crea un RTF a partir de una plantilla y sustituyendo los códigos por los datos de la Intranet.


15




Esta función recibe cuatro argumentos:

$sql: la sentencia sql que devuelve los datos que se necesitan $plantilla: la plantilla RTF con los códigos $fsalida: el nombre del fichero resultado $matequivalencias: una matriz con las equivalencias entre los datos procedentes de la sentencia sql y los campos del certificado. Vamos a comentar línea por línea el programa:

Las líneas 13 y 14 determinan el nombre y la ruta del fichero de salida, utilizamos la función time() para asegurarnos de que no se producirán dos ficheros con el mismo nombre.

En la línea 17 se almacena el contenido de la plantilla en la variable $txtplantilla

En las líneas de la 19 a la 24 se extrae el cuerpo del documento RTF, el cuerpo del documento es lo que se repite, para extraerlo primero obtenemos la cabecera del documento, la cabecera queda determinada por la etiqueta rtf sectd. Un documento rtf termina siempre en }, con esa información extraemos el cuerpo.

En el paso 3, a partir de la línea 26 vamos escribiendo el archivo resultado.


16




En la línea 27 escribimos la cabecera del documento

En la línea 28 ejecutamos la consulta y en la 29 entramos un un bucle, en cada ciclo obtendremos los datos de un alumno y crearemos un certificado.

En la línea 30 creamos una copia del cuerpo del documento llamada $despues, sobre esa copia realizaremos los cambios.

En la línea 31 entramos en un bucle que recorre la matriz de equivalencias, la línea 32 obtiene de la base de datos el dato, la línea 34 obtiene de la matriz el código a sustituir en la plantilla y la línea 35 sustituye el dato por el código.

Una vez sustituidos todos los campos la línea 37 escribe el certificado del alumno y las líneas 38 y 39 generan un salto de página para volver a escribir el siguiente certificado.

Una vez que hemos salido del While que va extrayendo los datos, la línea 41 cierra el documento rtf y la 42 la escritura del fichero.

Tercer paso, Llamada a la función RTF: Una vez hemos creado estas dos funciones ya podemos llamar a la función rtf() y generar el documento.


17




Comentamos las líneas:

En la línea 48 especificamos cual es la plantilla.

En la línea 49 establecemos la sentencia SQL que extrae los datos, en el caso del ejemplo es un poco compleja pues extrae los datos de varias tablas.

En las líneas desde la 50 a la 71 creamos la matriz de equivalencias, se trata de una matriz de dos dimensiones que relaciona el código que se encontrará en el archivo RTF con el campo de la sentencia SQL.

La línea 72 llama a la función rtf()

Y por fin las líneas 73 y 74 generan un enlace al archivo resultado.

Mejoras y comentarios. Todo en esta vida es susceptible de ser mejorado, en este caso me queda pendiente el generar el archivo de salida directamente al navegador, con el objeto de no tenerlo que escribir en el disco duro.

Además tenemos desarrollados ejemplos de listados y de etiquetas que podemos documentar en posteriores artículos.

Un aspecto importante para seguir progresando en este tema es conocer la sintaxis de los documentos rtf, se trata de un trabajo un poco durillo que también podemos abordar en posteriores artículos.

Artículo por Alfredo Anaya

Creando archivos PDF en PHP

Las funciones PDF en PHP pueden crear archivos PDF utilizando la librería PDFlib creada por Thomas Merz.

La documentación en esta sección solamente es una descripción de las funciones de la librería PDFlib y no debería considerarse una referencia exhaustiva. Se ha de consultar la documentación incluida en el código fuente de la distribución de PDFlib para una completa y detallada explicación de cada función. Proporciona muy buena descripción de las capacidades de PDFlib y contiene actualizada la documentación de todas las funciones.

Todas las funciones de PDFlib y del módulo PHP tienen nombres iguales para las funciones y parámetros. Se necesitará entender algunos de los conceptos básicos de PDF y PostScript para un eficiente uso de esta extensión. Todas las longitudes y coordenadas se mesuran en puntos PostScript. Generalmente hay 72 puntos PostScript por pulgada, pero esto depende de la resolución de salida. Se puede consultar la documentación incluida en la distribución de PDFlib para una detallada explicación del sistema de coordenadas utilizado.

Hay que tener en cuenta que la mayoría de las funciones PDF requieren un primer parámetro pdfdoc. En los siguientes ejemplos hay más información.


18




Nota: Si se está interesado en alternativas de generadores gratis de PDF que no utilizen liberías externas PDF, mirar este FAQ relacionado.

Requerimientos PDFlib está disponible para descargar en http://www.pdflib.com/products/pdflib/index.html, pero requiere la compra de una licencia para uso comercial. Se requieren las librerías JPEG y TIFF para compilar esta extensión.

Compatibilidad con versiones antiguas de PDFlib Cualquier versión de PHP después del 9 de Marzo del 2000 no soporta versiones de PDFlib anteriores a la 3.0. PDFlib 3.0 o superior es compatible desde PHP 3.0.19 en adelante. Instalación Para los datos de la instalación, os adjunto aquí unas notas extraídas de la propia documentación de la librería:

To get these functions to work, you have to compile PHP with --with-pdflib[=DIR]. DIR is the PDFlib base install directory, defaults to /usr/local. In addition you can specify the jpeg, tiff, and pnglibrary for PDFlib to use, which is optional for PDFlib 4.x. To do so add to your configure line the options --with-jpeg-dir[=DIR] --with-png-dir[=DIR] --with-tiff-dir[=DIR].

When using version 3.x of PDFlib, you should configure PDFlib with the option --enable-shared-pdflib.

Configuración en tiempo de ejecución Esta extensión no tiene directivas de configuración en php.ini.

Confusiones con antiguas versiones de PDFlib Desde PHP 4.0.5, la extensión PHP para PDFlib es oficialmente soportada por PDFlib GmbH. Esto significa que todas las funciones descritas en el manual de PDFlib (V3.00 o superior) son soportadas por PHP 4 con el mismo funcionamiento y parámetros. Sólo los valores devueltos pueden variar en el manual PDFlib, ya que PHP adoptó la convención de devolver FALSE. Por razones de compatibilidad, PDFlib aún soporta las antiguas funciones, pero deberían reemplazarlas en sus nuevas versiones. PDFlib GmbH no dará soporte a cualquier problema causado por el uso de estas funciones obsoletas.

Ejemplos

La mayoría de las funciones son bastante fáciles de utilizar. La parte más difícil probablemente es la creación de un primer documento PDF. El siguiente ejemplo debería ayudar para comenzar. El ejemplo crea el archivo test.pdf en una página. La página contiene el texto "Times Roman outlined" en un contorno, con fuente de 30pt. El texto también está subrayado.

Ejemplo 1. Creando un documento PDF con PDFlib

<?php $pdf = pdf_new(); pdf_open_file($pdf, "test.pdf"); pdf_set_info($pdf, "Author", "Javier Tacon"); pdf_set_info($pdf, "Title", "Test for PHP wrapper of PDFlib 2.0"); pdf_set_info($pdf, "Creator", "See Author"); pdf_set_info($pdf, "Subject", "Testing"); pdf_begin_page($pdf, 595, 842); pdf_add_outline($pdf, "Page 1"); $font = pdf_findfont($pdf, "Times New Roman", "winansi", 1); pdf_setfont($pdf, $font, 10); pdf_set_value($pdf, "textrendering", 1); pdf_show_xy($pdf, "Times Roman outlined", 50, 750); pdf_moveto($pdf, 50, 740);


19



http://www.pdflib.com/products/pdflib/index.html


pdf_lineto($pdf, 330, 740); pdf_stroke($pdf); pdf_end_page($pdf); pdf_close($pdf); pdf_delete($pdf); echo "<A HREF=getpdf.php>finished</A>"; ?>

El script getpdf.php simplemente devuelve el documento pdf.

Ejemplo 2. Mostrando un documento PDF precalculado

<?php $len = filesize($filename); header("Content-type: application/pdf"); header("Content-Length: $len"); header("Content-Disposition: inline; filename=foo.pdf"); readfile($filename); ?>

La distrubución PDFlib contiene un ejemplo más complejo para crear un reloj analógico en una página. Aquí se utiliza el método de creación en memoria de PDFlib para no tener que crear un archivo temporal. El ejemplo se ha convertido a PHP desde uno de PDFlib (El mismo ejemplo está disponible en la documentación ClibPDF.)

Ejemplo 3. Ejemplo pdfclock de la distribución PDFlib

<?php $radius = 200; $margin = 20; $pagecount = 10;

$pdf = pdf_new();

if (!pdf_open_file($pdf, "")) { echo error; exit; };

pdf_set_parameter($pdf, "warning", "true");

pdf_set_info($pdf, "Creator", "pdf_clock.php"); pdf_set_info($pdf, "Author", "Uwe Steinmann"); pdf_set_info($pdf, "Title", "Analog Clock");

while ($pagecount-- > 0) { pdf_begin_page($pdf, 2 * ($radius + $margin), 2 * ($radius + $margin));

pdf_set_parameter($pdf, "transition", "wipe"); pdf_set_value($pdf, "duration", 0.5);

pdf_translate($pdf, $radius + $margin, $radius + $margin); pdf_save($pdf); pdf_setrgbcolor($pdf, 0.0, 0.0, 1.0);

/* minute strokes */ pdf_setlinewidth($pdf, 2.0); for ($alpha = 0; $alpha < 360; $alpha += 6) { pdf_rotate($pdf, 6.0); pdf_moveto($pdf, $radius, 0.0); pdf_lineto($pdf, $radius-$margin/3, 0.0); pdf_stroke($pdf);


20




}

pdf_restore($pdf); pdf_save($pdf);

/* 5 minute strokes */ pdf_setlinewidth($pdf, 3.0); for ($alpha = 0; $alpha < 360; $alpha += 30) { pdf_rotate($pdf, 30.0); pdf_moveto($pdf, $radius, 0.0); pdf_lineto($pdf, $radius-$margin, 0.0); pdf_stroke($pdf); }

$ltime = getdate();

/* draw hour hand */ pdf_save($pdf); pdf_rotate($pdf,-(($ltime['minutes']/60.0)+$ltime['hours']-3.0)*30.0); pdf_moveto($pdf, -$radius/10, -$radius/20); pdf_lineto($pdf, $radius/2, 0.0); pdf_lineto($pdf, -$radius/10, $radius/20); pdf_closepath($pdf); pdf_fill($pdf); pdf_restore($pdf);

/* draw minute hand */ pdf_save($pdf); pdf_rotate($pdf,-(($ltime['seconds']/60.0)+$ltime['minutes']-15.0)*6.0); pdf_moveto($pdf, -$radius/10, -$radius/20); pdf_lineto($pdf, $radius * 0.8, 0.0); pdf_lineto($pdf, -$radius/10, $radius/20); pdf_closepath($pdf); pdf_fill($pdf); pdf_restore($pdf);

/* draw second hand */ pdf_setrgbcolor($pdf, 1.0, 0.0, 0.0); pdf_setlinewidth($pdf, 2); pdf_save($pdf); pdf_rotate($pdf, -(($ltime['seconds'] - 15.0) * 6.0)); pdf_moveto($pdf, -$radius/5, 0.0); pdf_lineto($pdf, $radius, 0.0); pdf_stroke($pdf); pdf_restore($pdf);

/* draw little circle at center */ pdf_circle($pdf, 0, 0, $radius/30); pdf_fill($pdf);

pdf_restore($pdf);

pdf_end_page($pdf);

# to see some difference sleep(1); }

pdf_close($pdf);

$buf = pdf_get_buffer($pdf); $len = strlen($buf);

header("Content-type: application/pdf"); header("Content-Length: $len");


21




header("Content-Disposition: inline; filename=foo.pdf"); echo $buf;

pdf_delete($pdf); ?>

Artículo por Emmanuel García De Caro

Funciones Básicas de Archivos PHP

Cambiar los permisos de un archivo chmod ('El_archivo.xxx',0777);

Cambiar el nombre del propietario de un archivo chown ('El_archivo.xxx','Mi nombre');

Copiar un archivo copy('El_archivo.xxx','/nuevo_directorio/');

Optener el directorio inicial de un archivo o subdirectorio dirname('directorio_raiz/subdirectorio');

Obtener el espacio disponible en un directorio en Bytes. disk_free_space('directorio');

Verificar si un archivo existe file_exists ('archivo.xxx');

Obtener la hora del ultimo acceso a un archivo fileatime('archivo.xxx');

Obtener la hora de la ultima modificación de un archivo filemtime('archivo.xxx');

Obtener el dueño de una archivo fileowner ('archivo.xxx');

Obtener los permisos de una archivo fileperms ('archivo.xxx');

Obtener el tamaño en bytes de un archivo filesize('archivo.xxx');

Obtener el tipo de archivo filetype('archivo.xxx');

Abrir un archivo o dirección URL fopen ('archivo.xxx','r');

Saber si un archivo es ejecutable is_executable('archivo.xxx');

Indicar si el archivo se puede leer


22




is_readable('archivo.xxx');

Indica si un archivo fue subido mediante HTTP POST upload is_uploaded_file ('archivo.xxx');

Saber si un archivo se puede escribir is_writable ('archivo.xxx');

Crea un directorio con permisos. mkdir('/nuevo_directorio',0777);

Mover un archivo cargado a través de HTTP POST de un directorio a otro predefinido move_uploaded_file ('directorio/archivo.xxx','directorio2/archivo.xxx');

Leer el contenido resultante de archivo file_get_contents('el_archivo.xx');

Renombrar un archivo o directorio rename("/tmp/archivo_temp.txt", "/home/usuario/login/docs/mi_archivo.txt");

ELIMINAR UN DIRECTORIO rmdir('/directorio');

CREAR UN ARCHIVO TEMPORAL tmpfile();

ELIMINAR UN ARCHIVO unlink('ARCHIVO.XXX');

Importante: Alguna de estas funciones requieren tener permisos 0777 chmod para poder trabajar correctamente.

La mayoría de ellas devuelven un booleano, por lo cual se puede imprimir un resultado en pantalla de la siguiente manera:

if(unlink('el_archivo.txt') echo 'se ha eliminado el archivo'; else echo 'Imposible eliminar el archivo, compruebe que el fichero exista y que tenga permiso xxx.';

?>

Recuerda que para establecer permisos a directorios o archivos se deben emplear 4 cifras no 3 como usualmente se hace y produce error. Ejemplos: 0777, 0755, 0666, etc…

Esto se debe a que el número para especificar el permiso debe incluirse en octal (Base 8). En PHP y otros lenguajes de programación. Los números en Base 8 se escriben con un 0 delante para diferenciarlos de los números en Base 10 o sistema decimal.

Trabajando con archivosOtras de las gran ventajas de PHP, es la manipulación de archivos internos y remotos. Para ello se utiliza una función esencial fopen(); que se encarga de abrir un archivo o URL, Basándose en una serie de parámetros que iremos describiendo.


23




La sintaxis de esta función con la que trabajaremos es la siguiente: fopen ('archivo.xxx','Modo');

Donde archivo es el nombre del mismo y (.xxx) su extensión, cabe destacar que si la llamada de este archivo se hace de la siguiente forma: esquema://, se asume que es una URL y Php buscara un gestor de protocol para tal esquema. Recordemos que los protocoles pueden ser (http, https, ftp, ftps, pop, pop3, y otros), si Php no encuentra una o más envolturas registradas para dicho protol, se emitirá un mensaje de error.

Modo, se refiere a la forma en que abrimos el archivos (bajo que recursos). Por ejemplo:

Si queremos hacer una apertura para solo lectura, o lectura y escritura u otro. Estos modos se designan con Letras predefinidas en Php, que son las siguientes:

'r' Apertura para sólo lectura; ubica el apuntador de archivo al comienzo del mismo.

'r+' Apertura para lectura y escritura; ubica el apuntador de archivo al comienzo del mismo.

'w' Apertura para sólo escritura; ubica el apuntador de archivo al comienzo de éste y lo trunca a una longitud de cero. Si el archivo no existe, intenta crearlo.

'w+' Apertura para lectura y escritura; ubica el apuntador de archivo al comienzo de éste y lo trunca a una longitud cero. Si el archivo no existe, intenta crearlo.

'a' Apertura para sólo escritura; ubica el apuntador de archivo al final del mismo. Si el archivo no existe, intenta crearlo.

'a+' Apertura para lectura y escritura; ubica el apuntador de archivo al final del mismo. Si el archivo no existe, intenta crearlo.

'x' Creación y apertura para sólo escritura; ubica el apuntador de archivo al comienzo de éste. Si el archivo ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel E_WARNING. Si el archivo no existe, intenta crearlo. Esto es equivalente a especificar las banderas O_EXCL|O_CREAT en la llamada de sistema open(2) interna. Esta opción es soportada en PHP 4.3.2 y versiones posteriores, y sólo funciona con archivos locales. ´

'x+' Creación y apertura para lectura y escritura; ubica el apuntador de archivo al comienzo de éste. Si el archivo ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel E_WARNING. Si el archivo no existe, intenta crearlo. Esto es equivalente a especificar las banderas O_EXCL|O_CREAT en la llamada de sistema open(2) interna. Esta opción es soportada en PHP 4.3.2 y versiones posteriores, y sólo funciona con archivos locales.

Un ejemplo:

<? $archivo= fopen("documento.txt" , "r"); if ($archivo) { while (!feof($archivo)) { echo fgets($archivo, 255).'<br>'; } } fclose ($archivo); ?>

Explicando:


24




Primero abrimos el archivo en modo de lectura y lo agrupamos a la variable $archivo, si se puede realizar la apertura (ósea si fopen() devuelve TRUE), Ejecutamos un bucle WHILE y en el argumento introducimos la función feof(), Encargada de verificar si el apuntador a un fichero esta al final del mismo. Luego la función fgets(), se encarga de imprimir la línea del fichero apuntado. y finalmente cerramos el archivo con fclose();

Otro Ejemplo:

<? $archivo=fopen("documento.txt" , "w"); if ($archivo) { fputs ($archivo, "Resulto el script"); } fclose ($archivo); ?>

Explicando: Abrimos el archivo nuevamente pero esta vez en modo de solo Escritura. Si se puede ejecutar ese proceso if($archivo), agregamos una línea con fputs(), que tendrá como contenido Resulto el script.

El ultimo paso en esta oportunidad como ya conocemos es cerrar el archivo. Cabe destacar que para que este ultimo ejemplo funcione, obviamente el archivo documento.txt, requiere tener PERMISO DE ESCRITURA, preferiblemente 0777 CHMOD.

Más información:http://www.php.net/manual/es/ref.filesystem.html

Artículo por Emmanuel García De Caro

Comprobar la existencia de un fichero en el servidor con PHP

Vamos a ver cómo se puede comprobar mediante PHP si un fichero existe o no en el sistema de archivos del servidor, es decir, dentro del disco duro del servidor. Esta es una tarea que se debería comprobar antes de realizar acciones con cualquier fichero del servidor, porque, si no existe el fichero, las acciones a realizar sobre él no tendrían sentido.

En PHP existe una función que nos ayudará con la tarea de comprobar si existe o no un fichero en el servidor. Nosotros solamente tenemos que hacer uso de ella para saber si existe ese archivo y por tanto, podemos operar con él.

file_exists(nombre_del_fichero)

La función devuelve un boleano, indicando con true que existe el fichero y con false que no existe. Recibe una cadena de caracteres que es el nombre del fichero que se desea comprobar.

En principio, si sólo se indica un nombre de un fichero, se supone que se debe buscar su existencia dentro del mismo directorio donde se aloja la página PHP.

Ejemplos


25



http://www.php.net/manual/es/ref.filesystem.html


Vamos a ver si existe un archivo llamado "mifichero.txt" en el mismo directorio que la página PHP:

if (file_exists("mifichero.txt")){ echo "El fichero existe"; }else{ echo "El fichero no existe"; }

Si quisiéramos comprobar si existe ese fichero dentro de un directorio determinado, bastaría con que escribiésemos la ruta de directorios sobre la que deseamos buscar el fichero.

file_exists("datos/mifichero.txt")

Esta función buscaría el archivo "mifichero.txt" dentro del subdirectorio "datos". Este subdirectorio "datos" estaría contenido dentro del directorio donde colocamos el script PHP.

Indicando rutas absolutas

También podríamos buscar un archivo indicando una ruta absoluta dentro del sistema de archivos del servidor. En este caso habría que comprobar si desde PHP tenemos permisos para acceder a la ruta en la que se pretende buscar el archivo, sobretodo si la ruta es externa al directorio de publicación del servidor.

file_exists("c:/mif.txt")

Esta función buscaría el archivo mif.txt en el directorio raíz del disco c:. Habría que ver si tenemos permisos para acceder al directorio raíz del disco.

Podemos averiguar la ruta del directorio de publicación de la página con la variable del entorno del servidor $_SERVER["DOCUMENT_ROOT"]. Podemos utilizar esta variable para generar la ruta absoluta a un archivo que pretendamos comprobar su existencia.

file_exists($_SERVER["DOCUMENT_ROOT"] . "\mifichero.txt")

Esta función buscaría el archivo "mifichero.txt" dentro de la raíz del directorio de publicación.

Nota:Como se puede ver, hemos utilizado el carácter "\" (contrabarra) para separar los directorios en la ruta de un archivo. Esto es porque estas líneas están extraídas de ejemplos de PHP realizados sobre el sistema Windows. En Windows se utilizan contrabarras para escribir rutas, mientras que en Linux se utiliza el carácter "/" (barra normal). Hay que tener cuidado para saber qué barra debemos utilizar en cada sistema, de lo contrario, podemos equivocarnos y entonces PHP puede tener problemas para localizar un fichero determinado.

Ejemplo: si existe un fichero, abrirlo y si no existe, crearlo

Ahora vamos a mostrar un código muy típico que sirve para abrir un fichero con un nombre dado. Primero habría que comprobar si existe o no existe ese fichero. Si existe, entonces lo abrimos tal cual está y si no existe, lo crearemos previamente a abrirlo.

if (file_exists("mifichero.txt")){ echo "El fichero existe. Lo abro"; $reffichero = fopen("mifichero.txt", "a"); }else{ echo "El fichero no existe. Lo creo y abro.";


26




$reffichero = fopen("mifichero.txt", "w+"); }

En este código, primero se comprueba la existencia del fichero. Si existe (caso afirmativo del if), se abre con el modo "a", que indica que se desea añadir información al fichero. Si no existe fichero (caso else del if), se abre con el modo "w+", que indica lectura y escritura y además indica que si no existe el fichero, se creará en el sistema de archivos en la ruta indicada.

Después de este código, el fichero está abierto para escritura, con lo cual, podemos operar sobre el fichero (escribiendo información) y luego deberíamos cerrarlo. El código sería como este:

//operar con el fichero fwrite ($reffichero,"nuevo texto!!!!"); //cerrar el fichero fclose ($reffichero);


Contar el número de líneas y caracteres en archivo PHP

Vamos a continuar con nuestro manual de gestión de archivos con PHP con un sencillo script para realizar una cuenta del número de líneas y de caracteres de un archivo de texto. Es un script que puede resultarnos útil, por lo menos para practicar un poco con las funciones de manejo de archivos en PHP.

Como hemos dicho, se trata de hacer una cuenta del número de líneas de un archivo y además el número de caracteres que tiene. Para realizar esta cuenta debemos leer el archivo de texto línea a línea acumular uno por cada línea en una variable, así como acumular en otra variable el número de caracteres de cada línea.

El código sería el siguiente: <? //abro el archivo para lectura $archivo = fopen ("miarchivo.txt", "r");

//inicializo una variable para llevar la cuenta de las líneas y los caracteres $num_lineas = 0; $caracteres = 0;

//Hago un bucle para recorrer el archivo línea a línea hasta el final del archivo while (!feof ($archivo)) { //si extraigo una línea del archivo y no es false if ($linea = fgets($archivo)){ //acumulo una en la variable número de líneas $num_lineas++; //acumulo el número de caracteres de esta línea $caracteres += strlen($linea); } } fclose ($archivo); echo "Líneas: " . $num_lineas; echo "Caracteres: " . $caracteres; ?>


27





El script está comentado, pero daremos unas explicaciones adicionales.

Primero abrimos el archivo para lectura. El fichero se llama "miarchivo.txt" y se supone que está en el mismo directorio que este script PHP.

Luego creamos un par de variables para llevar la cuenta de las líneas y de los caracteres.

Seguidamente hacemos un bucle para recorrer el archivo. El bucle iterará mientras que no se llegue al final del fichero. En cada iteración del bucle extraigo una línea, a la vez que compruebo que lo que he extraído tiene validez (Con fgets() se extrae una línea de texto y si hay un error la función devuelve false). Si se extrajo correctamente la línea de texto se acumula 1 en la variable que cuenta el número de líneas y se acumula el número de caracteres que tenga en la variable que cuenta los caracteres del archivo.

Una vez finalizado el bucle, porque se ha llegado al final del fichero, se muestran los contenidos de las variables con el número de líneas y caracteres.


Listar directorios y subdirectorios con PHP

En PHP existen muchas funciones para el manejo del sistema de archivos del servidor. Con su ayuda se pueden hacer fácilmente todo tipo de acciones sobre la estructura de ficheros y directorios del servidor. Hemos visto ya interesantes ejemplos sobre estas funciones en nuestro Manual de gestión de ficheros con PHP. En este taller veremos una manera de hacer un listado de los directorios que cuelgan de una carpeta dada.

La función que vamos a realizar recibe una ruta y simplemente hace un listado de los directorios que cuelgan de esa ruta. A su vez, esos directorios pueden tener otros subdirectorios dentro y estos a su vez otros, en la típica estructura de árbol. El script debe recorrer todos los subdirectorios del árbol y listarlos. Para realizar esto, lo más habitual es hacer una función recursiva, que es una función que se llama a si misma para hacer todo el trabajo.

En nuestro caso, como se decía, vamos a utilizar unas cuantas funciones de PHP para facilitarnos la tarea. Son las siguientes:

is_dir() que recibe una ruta y devuelve un boleano. True si es un directorio y flase si no lo es.

opendir() que recibe la ruta de un directorio y genera un gestor de directorio, que utilizaremos luego para extraer los subdirectorios.

readdir() recibe un gestor de directorio devuelto por opendir() y sirve para leer todo el contenido de un directorio, tanto archivos como subdirectorios. Nosotros lo utilizaremos para obtener cada uno de los subdirectorios que contiene una ruta. En la primera llamada devuelve el primer archivo o subdirectorio, en la siguiente devuelve en segundo. Es decir, cuando se vuelve a llamar devuelve siempre el siguiente fichero y continúa hasta que se acaban, devolviendo false cuando no queda ninguno.

closedir() recibe un gestor de directorio y lo cierra.


28





Ahora veamos la función, que está comentada.

function listar_directorios_ruta($ruta){ // abrir un directorio y listarlo recursivo if (is_dir($ruta)) { if ($dh = opendir($ruta)) { while (($file = readdir($dh)) !== false) { //esta línea la utilizaríamos si queremos listar todo lo que hay en el directorio //mostraría tanto archivos como directorios //echo "<br>Nombre de archivo: $file : Es un: " . filetype($ruta . $file); if (is_dir($ruta . $file) && $file!="." && $file!=".."){ //solo si el archivo es un directorio, distinto que "." y ".." echo "<br>Directorio: $ruta$file"; listar_directorios_ruta($ruta . $file . "/"); } } closedir($dh); } }else echo "<br>No es ruta valida"; }

La función recibe una ruta. Por ejemplo, si queremos que liste los directorios de la carpeta donde está el archivo la llamaríamos con:

listar_directorios_ruta("./");

Lo primero que se hace es comprobar si la ruta recibida es un directorio.

if (is_dir($ruta)) {

Si lo es realizaremos las acciones, pero si no lo es, mostraremos un mensaje diciendo que no es una ruta válida.

En el siguiente if extraemos el gestor de directorio y lo guardamos en una variable $dh

if ($dh = opendir($ruta))

Con un bucle while recorreremos cada elemento de ese directorio.

while (($file = readdir($dh)) !== false)

Dentro del bucle hacemos un if para saber si el elemento es un directorio

if (is_dir($ruta . $file) && $file!="." && $file!="..")

En caso que sea un directorio, simplemente escribimos en la página. Además, tenemos que ver si ese directorio contiene a su vez otros directorios. Para eso llamamos a la función de nuevo pasándole ese nuevo directorio. Así la función se llama a si misma para mostrar todo el árbol de carpetas.

Por último se cierra el gestor de directorio abierto previamente.

closedir($dh);



29




Leer un archivo traído por FTP con PHP

La gestión de archivos por PHP incluye la conexión por FTP o HTTP para abrir un archivo. Esto significa que se puede indicar una URL, en vez de la ruta del archivo en el sistema de archivos del servidor local. Con ello podremos abrir un archivo remoto, que se encuentra en otro servidor.

Para abrir un archivo debemos utilizar la función del sistema de archivos (Filesystem function) fopen. Esta función la describimos con detalle en el manual sobre gestión de archivos por PHP. En este caso vamos a realizar un uso especial para conectar con ese archivo por FTP.

Antes que nada hay que decir que para que esto funcione, es decir, para poder conectar por FTP o por HTTP con un archivo remoto, tenemos que tener habilitada la directiva allow_url_fopen en el PHP.ini (allow_url_fopen = on).

La diferencia fundamental a la hora de conectar un archivo que se encuentra en un servidor remoto está en la línea del fopen:

$archivo = fopen ("ftp://usuario:[email protected]/html/archivo.txt", "r");

Simplemente indicamos la ruta del archivo con una URL por el protocolo FTP. En dicha URL se indican los siguientes datos.

• ftp:// es el protocolo. • usuario:clave es el usuario y la clave del acceso FTP que estemos utilizando. Si fuera un

ftp anónimo podríamos omitir estos datos. • @ para separar lo que es el usuario y la clave del nombre del servidor. También se

debería omitir en el caso de un servidor anónimo. • ftp.servidor.com es el nombre del servidor FTP al que estamos conectando • /html/archivo.txt es la ruta desde el directorio raíz del FTP hacia el archivo que se desea

abrir.

Luego trataríamos el archivo de manera similar a como hemos visto en otros casos en el manual sobre gestión de archivos por PHP.

Veamos un ejemplo completo de conexión por FTP para abrir, leer y mostrar un fichero de texto remoto:

<?php$archivo = fopen ("ftp://user:[email protected]/html/probando.txt", "r");if (!$archivo) {echo "<p>No puedo abrir el archivo para lectura</p>";exit;}$texto="";while ($linea = fgets($archivo,1024)) { if ($linea) $texto .= $linea;}echo $texto;fclose ($archivo);?>


30








31



Documents

Gestión de archivos en PHP - · PDF fileTu mejor ayuda para aprender a hacer webs Gestión de archivos por PHP El tratamiento de archivos resulta ser una práctica muy común en