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
Posted on 31-08-20092009 in PHP | 0 comments
En esta lección vamos a ver como algunas funciones relacionadas con el tiempo y la fecha, así como algunos ejemplos prácticos.
time
Devuelve el numero de segundos transcurridos desde el 1 de Enero de 1970. A esta forma de expresar fecha y hora se le denomina tmestamp.
date(formato, timestamp)
La funció date devuelve una cadena formateada según los código de formato. Si no le pasamos la variable timestamp nos devuelve la cadena formateada para la fecha y la hora actual.
Los códigos de formato para la función date son:
| CODIGO |
DESCRIPCIÓN |
| a |
am o pm |
| A |
AM o PM |
| d |
Día del mes con ceros |
| D |
Abreviatura del día de la semana (inglés) |
| F |
Nombre del mes (inglés) |
| h |
Hora en formato 1-12 |
| H |
Hora en formato 0-23 |
| i |
Minutos |
| j |
Día del mes sin ceros |
| l |
Dia de la semana |
| m |
Número de mes (1-12) |
| M |
Abreviatura del mes (inglés) |
| s |
Segundos |
| y |
Año con 2 dígitos |
| Y |
Año con 4 dígitos |
| z |
Dia del año (1-365) |
Para ver algunos ejemplos supongamos que ahora es el 7 de abril de 2000 a las 14 horas 30 minutos y 22 segundos:
- date(“d-m-Y”) -> 07-04-2000
- date(“H:i:s”) -> 14:30:22
- date(“Y”) -> 2000
- date(“YmdHis”) -> 20000407143022
- date(“d/m/y H:i a”) -> 07/04/00 14:30 pm
- date(d-m-Y H:i, time()) -> el momento actual
mktime(hora, min, seg, mes, dia, año)
La funcion mktime devuelve una variable de tipo timestamp a partir de las coordenadas dadas. La principal utilidad de esta funcion es la de añadir o quitar una determinada cantidad de fecha u horas a una dada.
<?PHP
function restarDias($numdias, $date) {
if (isset($date)) {
$date = time();
}
list($hora, $min, $seg, $dia, $mes, $anno) = explode( ” “, date( “H i s d m Y”));
$d = $dia – $numdias;
$fecha = date(“d-m-Y”, mktime($hora, $min, $seg, $mes, $d, $anno));
return $fecha;
}
echo restarDias(5).”<BR>”;
echo restarDias(10).”<BR>”;
?>
chekdate (mes, dia, año)
La función chekdate comprueba si una fecha es válida, si es así devuelve TRUE y si no lo es FALSE. Una fecha se considera válida si el año está entre 1900 y 32767, el mes entre 1 y 12, y el dia es menor o igual que número de días total del mes en cuestión.
<?PHP
if (checkdate(31, 2, 2000)) {
echo “La fecha es correcta”;
} else {
echo “La fecha es incorrecta”;
}
?>
Para el ejemplo anterior nos daría que la fecha es incorrecta, febrero nunca tiene un día 31.
read more
Posted on 31-08-20092009 in PHP | 0 comments
Cómo ahorranos líneas de código
En las lecciones anteriores hemos aprendido el uso básico de las funciones de PHP para trabajar con MySQL. En esta lección y sucesivas vamos a ver nuevas funciones que nos facilitan y potencian nuestras páginas web.
Por lo general, todos nuestros script tienen partes de código iguales, las funciónes include() y require() nos van ahorrar muchas de estas lineas de código. Ambas funciones hacen una llamada a un determinado fichero pero de dos maneras diferentes, con include(), insertamos lo que contenga el fichero que llamemos de manera literal en nuestro script, mientras que con require(), le decimos que el script necesitará parte de código de se encuentra en el fichero que llama require().
Como todo esto es un poco lioso, veamos unos ejemplos que nos lo aclará.
<?php
include (“header.inc”);
echo “Hola Mundo”;
include (“footer.inc”);
?>
Si tenemos encuenta que el fichero header.inc contiene:
<html>
<body>
y el fichero footer.inc contiene:
</body>
</html>
Nuestro script sería equivalente a:
<html>
<body>
<?php
echo “Hola Mundo”;
?>
</body>
</html>
Ahora veamos el script de ejemplo para la función require():
<?php
require (“config.inc”);
include (“header.inc”);
echo $cadena;
include (“footer.inc”);
?>
Donde el fichero config.inc tendría algo como ésto:
<?php
$cadena = “Hola Mundo”;
?>
read more
Posted on 31-08-20092009 in PHP | 0 comments
Muchas veces, cuando trabajamos en el desarrolo de una aplicación, nos surge la necesidad de ejectar un mismo bloque de código en diferentes partes de nuestra aplicación. Una Función no es más que un bloque de código al que le pasamos una serie de parámetros y nos devuelve un valor. Como todos los lenguaje de programación, PHP trae una gran cantidad de funciones para nuestro uso, pero las funciones más importantes son las que nosotros creamos.
Para declara una funcion debemos utilizar la instrucción function seguido del nombre que le vamos a dar, y después entre parentesis la lista de argumentos separados por comas, aunque también habrá funciones que no recogan ningún argumento.
function nombre_de_funcion (arg_1, arg_2, …, arg_n)
{
bloque de código
}
Cualquier instrucción válida de PHP puede aparecer en el cuerpo (lo que antes hemos llamado bloque de código) de una función, incluso otras funciones y definiciones de clases.
En PHP no podemos redefinir una función previamente declarada, y además en PHP3, las funciones deben definirse siempre antes de que se invoquen, en PHP4 este requerimiento ya no existe.
La instrucción RETURN
Cuando invocamos una función, la ejecución del programa pasa a ejecutar las líneas de código que contenga la función, y una vez terminado, el programa continua su ejecución desde el punto en que fué llamada la función.
Existe una manera de terminar la ejecución de la función aunque aún haya código por ejecutar, mediante el uso de la instrución return terminamos la ejecución del código de una función y devolvemos un valor. Podemos tener varios return en nuestra función, pero por lo general, cuantos más return tengamos menos reutilizable será nuestra función.
<?php
function mayor ($x, $y)
{
if ($x > $y) {
return $x.” es mayor que “.$y;
} else {
return $y.” es mayor que “.$x;
}
}
?>
Aunque quedariá mejor:
<?php
function mayor ($x, $y)
{
$msg = “”;
if ($x > $y) {
$msg = $x.” es mayor que “.$y;
} else {
$msg = $y.” es mayor que “.$x;
}
return $msg;
}
?>
Con la instrución return puede devolverse cualquier tipo de valor, incluyendo tablas y objetos. PHP solo permite a las funciones devolver un valor, y para solventar este pequeño problema, si queremos que nuestra función devuelva varios tenemos que utilizar una tabla (array).
Parámetros de las funciones
Existen dos formas de pasar los parámetros a una función, por valor o por referencia.
Cuando pasamos una variable por valor a una funcion, ocurra lo que ocurra en ésta en nada modificará el contenido de la variable. Mientras que si lo hacemos por referencia, cualquier cambio acontecido en la función sobre la variable lo hará para siempre.
En PHP, por defecto, las variables se pasan por valor. Para hacerlo por referencia debemos anteponer un ampersand (&) a la variable.
<?php
function suma ($x, $y)
{
$x = $x + 1;
return $x+$y;
}
$a = 1;
$b = 2;
//parámetros por valor
echo suma ($a, $b); // imprimirá 4
echo $a; // imprimirá 1
//parámetros por referencia
echo suma (&$a, $b); // imprimirá 4
echo $a; //imprimirá 2
?>
Si queremos que un parámetro de una función se pase siempre por referencia debemos anteponer un ampersand (&) al nombre del parámetro en la definición de la función.
En PHP podemos definir valores por defecto para los parámetro de una función. Estos valores tienen que ser una expresión constante, y no una variable o miembro de una clase. Además cuando usamos parámetros por defectos, éstos deben estar a la derecha de cualquier parámetro sin valor por defecto, de otra forma PHP nos devolverá un error.
<?php
function suma ($x=1, $y)
{
$x = $x + 1;
return $x+$y;
}
?>
Si ejecutarmos esta función nos daría error, ya que hemos dado a $x el valor 1 por defecto y la hemos colocado a la izquierda de un parámetro que no tiene valor por defecto. La forma correcta es:
<?php
function suma ($y, $x=1)
{
$x = $x + 1;
return $x+$y;
}
?>
Cabe destacar que PHP3 no soporta un número variables de parámetros, pero PHP4 sí.
Llegados a este punto, damos un paso atrás y volvemos a las variables, para distinguir entre variables estáticas (static) y globales (global). Las variables estáticas se definen dentro de una función, la primera vez que es llamada dicha función la variable se inicializa, guardando su valor para posteriores llamadas.
<?php
function contador ()
{
static $count = 0;
$count = $count + 1;
return $count;
}
echo contador().”<BR>”; // imprimirá 1
echo contador().”<BR>”; // imprimirá 2
echo contador().”<BR>”; // imprimirá 3
?>
Las variables globales, no se pueden declarar dentro de una función, lo que hacemos el llamar a una variable que ya ha sido declarada, tomando el valor que tenga en ese momento, pudiendo se modificado en la función.
<?php
var $a = 1;
function ver_a()
{
global $a;
echo $a.”<BR>”; // imprimirá el valor de $a
$a += 1; // sumamos 1 a $a
}
echo ver_a(); // imprimirá 1
echo ver_a(); // imprimirá 2
$a = 7;
echo ver_a(); // imprimirá 7
echo ver_a(); // imprimirá 8
?>
Funciones Variable
PHP soporta el concepto de funciones variables, esto es significa que si una variable tiene unos parentesis añadidos al final, PHP buscará un función con el mismo nombre que el contenido de la variable, e intentará ejecutarla.
<?php
function imprime($texto) {
echo $texto . “\n”;
}
function imprimeNegrilla($texto){
echo “<B>$texto</B>\n”;
}
$MiFunc = “imprime”;
$MiFunc(“Hola”); //imprimirá Hola
$MiFunc = “imprimeNegrilla”;
$MiFunc(“Hola”); //imprimirá Hola
?>
Recursión
PHP también permite la recursión, es decir, una función se puede llamar así misma. Para aclarar el concepto de recursión, vamos a crear una función que comprueba si un número es entero o no.
Un número que no sea entero (7’4), tiene una parte entera y otra decimal (comprendida entre 0 y 1), lo que vamos a hacer para comprobar si un número es entero o no, será restarle 1 al número en cuestión hasta que nos que demos sin parte entera, y entoces comprobaremos si tiene parte decimal (un poco lioso todo ésto).
<?php
function esEntero($numero) {
if ($numero > 1) {
return (esEntero($numero -1));
} elseif ($numero < 0) {
/* como los núm. son simétricos
chequeamos lo convertimos a positvo */
return (esEntero((-1) * $numero -1));
} elseif (($numero > 0) AND ($numero < 1)) {
return (“NO”);
} else {
/* el cero es entero por definición */
return (“SI”);
}
} //fin function
echo “¿Es 0 un número entero? “.esEntero(0).”<BR>\n”;
echo “¿Es 3.5 un número entero? “.esEntero(3.5).”<BR>\n”;
echo “¿Es -7 un número entero? “.esEntero(-7).”<BR>\n”;
echo “¿Es -9.2 un número entero? “.esEntero(9.2).”<BR>\n”;
?>
read more
