Posted on 02-09-20092009 in PHP | 0 comments
PHP es uno de los lenguajes del lado del servidor más completos y con mayor número de funciones útiles. En este caso, estudiaremos las funciones que permiten trabajar con archivos, y en algunos casos con directorios.
basename()
Esta función devuelve la ubicación base de algún archivo. Es de utilidad cuando nos interesa eliminar la ruta física de algún archivo y devolver sólo el nombre de dicho archivo y su extensión:
<?
$ruta = “/home/httpd/html/file.php”;
$file = basename($ruta); //devuelve ‘file.php’
?>
Como ves, la función basename devuelve el archivo resultante de la eliminación de la ruta física. Su utilización es demasiado básica y no necesita de ninguna explicación amplia, aunque su utilidad también es un poco reducida.
chmod()
Increíblemente el PHP permite cambiar los permisos de algún archivo o directorio utilizando esta función. Obviamente está restringida y su aplicación no es más que un intento por cambiar el valor chmod de algún archivo o carpeta, pero para que verdaderamente funcione se requiere de soporte en el servidor.
La única particularidad de esta función es que para otorgar permisos se debe anteponer un 0 al valor del permiso. Por ejemplo, para 755 se debe escribir 0755.
La sintaxis de la función es:
<?
chmod(“/directorio/archivo”, permiso);
?>
En donde permiso, como ya mencionamos, debe ser el valor chmod que deseamos otorgar, con un 0 anteponiéndolo.
Para dar a archivo.txt permisos 777 debemos utilizar la siguiente sintaxis:
<?
chmod(“archivo.txt”, 0777);
?>
copy()
Como su nombre lo indica, esta función permite copiar archivos dentro del servidor. Muy útil se deseamos hacer un back-up online de modo que tengamos los archivos antiguos dentro del servidor evitando el peso de descargarlos todos. Aún así, las aplicaciones son muchísimas.
<?
copy($archivo, $destino);
?>
copy() devuelve true si se ejecutó el proceso correctamente y false si no se logró la copia.
Podemos aprovechar esta capacidad para mostrar mensajes de error según suceda:
<?
if(!copy(“archivo.txt”,”backup1.txt”)){
echo “Error al tratar de copiar el archivo.\n”;
}
?>
Lo anterior mostraría un mensaje de error si no se logra la copia del archivo archivo.txt a backup1.txt
dirname()
Devuelve el nombre del directorio de una ruta:
<?
$ruta = “/directorio/archivo”;
$dirname = dirname($ruta); //devuelve ‘/directorio’
?>
diskfreespace()
Esta extraña función devuelve el número de bytes de espacio libre que hay en algún directorio. Para verificar, por ejemplo, el espacio libre disponible en el directorio raíz de un sitio web se utiliza la sintaxis:
<?
$espacio = diskfreespace(“/”);
?>
readfile()
Lee un archivo completo y devuelve al final el número de bytes leídos. Si no se logra abrir la conexión con el archivo devuelve error.
<?
$archivo = readfile(“archivo.txt”);
echo $archivo; //escribe el contenido con el numero de bytes leidos
?>
Esta es una forma muy fácil de leer archivos aunque el problema está en que devuelve el número de bytes leídos, cosa que nadie desearía, para ello se utiliza más frecuentemente la función file() que devuelve un array con todas las líneas del archivo. Más adelante veremos cómo utilizarla.
fopen(), fclose(), fwrite(), fread()
fopen() crea una conexión a algún archivo, especificando el tipo de tratamiento que se le dará al archivo, es decir, si será de lectura, escritura o ambos. Por defecto, se puede leer un archivo pero para lograr escribir en él se requieren permisos chmod 755.
fclose() cierra la conexión para liberar memoria.
La sintaxis de fopen es:
$archivo = fopen(“archivo.txt”,permiso);
permiso equivale a una letra identificadora del tipo de tratamiento que le daremos al archivo. Existen tres básicamente: r (solo lectura), wa (ambos). En el caso de escritura el cursor se ubica al inicio del archivo por lo que la escritura afecta todo el contenido del mismo, mientras que a ubica el cursor al final del archivo para escribir nuevo contenido sin eliminar el existente.
Veremos un ejemplo de escritura en un archivo. (escritura) y
<?
$fp = fopen(“archivo.txt”,”w”); //abrimos el archivo para escritura
fwrite($fp, “Estoy escribiendo en un archivo!!!”);
fclose($fp); //cerramos la conexión y liberamos la memoria
?>
Ahora hemos introducido la función fwrite() que permite la escritura en un archivo, según la conexión creada.
La sintaxis es:
fwrite($conexion, textoaescribir);
Otra de las muchas formas de leer archivos es utilizar la función fread aunque ésta está un poco limitada, pues sólo lee un archivo hasta determinado número de bytes, para evitar esto se puede utilizar la función file_size para establecer el número de bytes totales y así leer todo el archivo. Más adelante encontrarás información sobre esta función.
<?
$fp = fopen(“archivo.txt”,”r”); //abrimos el archivo como solo lectura
$contenido = fread($fp, 2000); //leemos 2000 bytes del archivo establecido en $fp
fclose($fp);
?>
file()
Esta función toma el contenido total de cualquier archivo y lo guarda línea por línea en un array. Es la más útil de todas las formas de lectura de archivos pues permite crear scripts complejos que trabajen en líneas… por ejemplo un rotador de banners que tenga en cada línea un banner diferente para rotar. Pero para ello es necesario conocer algunas funciones de cadena, cosa que no se tratará en este artículo.
la sintaxis de file no tiene problemas:
$archivo = file(“archivo.txt”);
Con lo anterior, $archivo ya es un array con todas las líneas de archivo.txt.
Pero para poder recorrer cada línea de archivo.txt es necesario crear un bucle. ¿Pero cómo sabrá el bucle en donde parar? Para ello haremos uso de la función count() que devuelve la cantidad de elementos de un array.
Como $archivo es un array con cada línea de archivo.txt esto quiere decir que cada elemento en el array equivale en una línea, por ello se puede usar count() facilmente.
Pero para aclararlo veamos un ejemplo:
<?
$archivo = file(“archivo.txt”); //creamos el array con las lineas del archivo
$lineas = count($archivo); //contamos los elementos del array, es decir el total de lineas
for($i=0; $i < $lineas; $i++){
echo $archivo[$i];
}
?>
Como ves es muy sencillo. Primero abrimos el archivo y lo convertimos en vector (array). Posteriormente guardamos su número total de elementos (que equivale al número de líneas) en la variable $lineas.
Luego un bucle se encarga de recorrer cada línea y escribirla en pantalla.
La ventaja de este método es que podemos leer cualquier línea fácilmente, pues $archivo es un array. Si deseamos leer la primera línea podemos utilizar $archivo[0] y así sucesivamente.
file_exists()
Muy útil función que verifica la existencia de un archivo, devolviendo true si verdaderamente existe y false si no.
Veamos un ejemplo:
<?
$archivo = “archivo.txt”;
if(file_exists($archivo)){
echo “El archivo $archivo existe.\n”;
else{
echo “El archivo $archivo no existe.\n”;
}
?>
Hemos hecho uso de una estructura condicional para mostrar un mensaje de acuerdo a la existencia o no del archivo. Como PHP puede crear conexiones a servidores externos, es posible verificar la existencia de una URL con file_exists() antes de dirigir al usuario a dicha dirección.
fileatime()
Devuelve la fecha del último acceso a un archivo, o false en caso de error.
<?
echo fileatime(“archivo.txt”);
?>
Escribiría en pantalla la última fecha de acceso a archivo.txt
filesize()
Devuelve el número total de bytes que ocupa cualquier archivo. Es posible modificar estos valores mediante divisiones para convertirlo a megabytes, kilobytes, etc.
<?
$tam = filesize(“imagen.gif”);
echo $tam;
?>
El anterior código devolvería el tamaño total en bytes que está ocupando imagen.gif
is…
Las funciones is permiten conocer algunas características de un archivo o directorio. Todas poseen la misma sintaxis por lo que sólo veremos para qué sirve cada una.
La sintaxis base es:
<?
funcion($archivo);
?>
Donde funcion es alguna de las siguientes:
- is_dir: Devuelve true si $archivo es un directorio
- is_executable: Devuelve true si $archivo es ejecutable
- is_file: Devuelve true si $archivo es un archivo y no directorio
- is_readable: Devuelve true si se puede leer $archivo
- is_writeable: Devuelve true si se puede escribir en $archivo
mkdir()
Trata de crear una carpeta en el servidor:
mkdir(“/ruta/al/nuevo/directorio”,permiso);
El primer parámetro debe ser la ruta al nuevo directorio, es decir, al que se trata de crear y permiso es el permiso chmod en formato octal, es decir, con un 0 antes. El permiso permite establecer el chmod que deseamos al momento de crear el directorio. Funciona igual que chmod().
rename()
Trata de renombrar algún archivo.
<?
rename(“nombreviejo”,”nuevonombre”);
?>
Con eso terminamos la primera parte de este artículo sobre el tratamiento de directorios y archivos. El tema de próximos artículos será cómo aplicar realmente estas funciones, para lo cual crearemos un script que funcionará como administrador de archivos vía online. Tipo FTP pero más sencillo.
Una nota de importancia es que en casi todos los ejemplos se ha utilizado como archivo el nombre archivo.txt pero en realidad puede ser cualquiera.
read more
Posted on 02-09-20092009 in PHP | 0 comments
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
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 archivos
Otras 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.
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:
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.
read more
Posted on 31-08-20092009 in PHP | 0 comments
Las Clases son máximo exponente de la Programación Orientada a Objetos (POO). PHP no es un lenguaje orientad a objeto, pero implementa las características que permiten definir las clases.
Pero, ¿qué son las Clases y para que sirven?, empecemos por los segundo, sirven hacer el código más legible, y lo que es más importante, reutilizable. Escribir una Clase es sin duda más largo que escribir el código directamente, pero a la larga es más rentable por su portabilidad a otras aplicaciones y su mantenimiento.
Las Clases no son más que una serie de variables y funciones que describen y actúan sobre algo. Por ejemplo, vamos a crear la clase automóvil, la cual tendrá diversas variables, $color, $modelo, $marca, $potencia, $matricula y habrá una serie de funciones que actuarán sobre la clase automóvil como Precio(), Acelerar(), Frenar(), Girar()y Reparar().
Como ejemplo vamos a crear la clase mysql, que nos servirá para realizar consultas a las bases de datos MySQL.
<?php
class DB_mysql {
/* variables de conexión */
var $BaseDatos;
var $Servidor;
var $Usuario;
var $Clave;
/* identificador de conexión y consulta */
var $Conexion_ID = 0;
var $Consulta_ID = 0;
/* número de error y texto error */
var $Errno = 0;
var $Error = “”;
/* Método Constructor: Cada vez que creemos una variable
de esta clase, se ejecutará esta función */
function DB_mysql($bd = “”, $host = “localhost”, $user = “nobody”, $pass = “”) {
$this->BaseDatos = $bd;
$this->Servidor = $host;
$this->Usuario = $user;
$this->Clave = $pass;
}
/*Conexión a la base de datos*/
function conectar($bd, $host, $user, $pass){
if ($bd != “”) $this->BaseDatos = $bd;
if ($host != “”) $this->Servidor = $host;
if ($user != “”) $this->Usuario = $user;
if ($pass != “”) $this->Clave = $pass;
// Conectamos al servidor
$this->Conexion_ID = mysql_connect($this->Servidor, $this->Usuario, $this->Clave);
if (!$this->Conexion_ID) {
$this->Error = “Ha fallado la conexión.”;
return 0;
}
//seleccionamos la base de datos
if (!@mysql_select_db($this->BaseDatos, $this->Conexion_ID)) {
$this->Error = “Imposible abrir “.$this->BaseDatos ;
return 0;
}
/* Si hemos tenido éxito conectando devuelve
el identificador de la conexión, sino devuelve 0 */
return $this->Conexion_ID;
}
/* Ejecuta un consulta */
function consulta($sql = “”){
if ($sql == “”) {
$this->Error = “No ha especificado una consulta SQL”;
return 0;
}
//ejecutamos la consulta
$this->Consulta_ID = @mysql_query($sql, $this->Conexion_ID);
if (!$this->Consulta_ID) {
$this->Errno = mysql_errno();
$this->Error = mysql_error();
}
/* Si hemos tenido éxito en la consulta devuelve
el identificador de la conexión, sino devuelve 0 */
return $this->Consulta_ID;
}
/* Devuelve el número de campos de una consulta */
function numcampos() {
return mysql_num_fields($this->Consulta_ID);
}
/* Devuelve el número de registros de una consulta */
function numregistros(){
return mysql_num_rows($this->Consulta_ID);
}
/* Devuelve el nombre de un campo de una consulta */
function nombrecampo($numcampo) {
return mysql_field_name($this->Consulta_ID, $numcampo);
}
/* Muestra los datos de una consulta */
function verconsulta() {
echo “<table border=1>\n”;
// mostramos los nombres de los campos
for ($i = 0; $i < $this->numcampos(); $i++){
echo “<td><b>”.$this->nombrecampo($i).”</b></td>\n”;
}
echo “</tr>\n”;
// mostrarmos los registros
while ($row = mysql_fetch_row($this->Consulta_ID)) {
echo “<tr> \n”;
for ($i = 0; $i < $this->numcampos(); $i++){
echo “<td>”.$row[$i].”</td>\n”;
}
echo “</tr>\n”;
}
}
} //fin de la Clse DB_mysql
?>
Como habreis observado, para crear una clase utilizamos la sentencia class, y además hemos creado una función con el mismo nombre que la clase, a esa función se le llama constructor y se ejecutará cada vez que definamos una variable de esa clase. No es obligatorio crear un constructor en una definición de clase.
Otra cosa importante en las clases es el operador ->, con el que indicamos una variable o método (parte derecha del operador) de una clase (parte izquierda del operador). Para hacer referencia a la clase que estamos creando dentro de su definición, debemos utilizar this.
Y ahora veamos un ejemplo de la clase que hemos creado, y supongamos que el código anterior lo hemos guardado en un fichero llamado clase_mysql.inc.php.
<body>
<html>
<?php
require (“clase_mysql.inc.php”);
$miconexion = new DB_mysql ;
$miconexion->conectar(“mydb”, “localhost”, “nobody”, “”);
$miconexion->consulta(“SELECT * FROM agenda”);
$miconexion->verconsulta();
?>
</body>
</html>
read more
