Archivo

Archive for the ‘PHP’ Category

Curso PHP: Capítulo 9: Lectura y escritura de ficheros

15 junio, 2010 6 comentarios

Hasta ahora casi todo lo que hemos visto son algunos aspectos de PHP en lo referente al lenguaje, como:

- Manipular datos en variables, ya sean cadenas, enteros, flotantes, booleanos o arrays.

- Utilizar funciones definidas en la API de PHP y crear nuestras propias funciones.

- Utilizar operadores para realizar cálculos y las estructuras de control para cambiar el flujo de nuestros scripts.

- Nos hemos introducido en el mundo de la POO y hemos manipulado objetos.

- Hemos accedido a las datos que los usuarios envian a través de formularios con el método POST y GET.

Pero aún estamos muy lejos del camino de poder juntar todo lo aprendido para realizar aplicaciones webs dinámicas. En este capítulo vamos a ver como podemos manejar ficheros en el servidor con PHP.

En PHP5 existen un conjunto de funciones para manipular ficheros, no vamos a ver todas, solo las más utilizadas. Si quereis ver más ejemplos o una documentación más detallada como siempre podeis acudir a la documentación oficial en línea de PHP.

Apertura de ficheros

-fopen()

Para abrir un fichero en PHP se utiliza la función fopen() que devuelve un recurso que apunta al fichero abierto. Los 2 parámetros que se pasan a esta función son los siguiente:

- Nombre del fichero. PHP5 puede acceder a ficheros locales o ficheros remotos mediante HTTP y FTP. El fichero que se quiere abrir debe tener los permisos adecuados.

-Modo de apertura. Especifica el tipo de acceso que se tendrá al fichero. Os incluyo la tabla de la especificación oficial para que veais los diferentes modos de apertura:

modo Descripción
‘r’ Apertura para sólo lectura; coloca el puntero al principio del archivo.
‘r+’ Apertura para lectura y escritura; coloca el puntero al principio del archivo.
‘w’ Apertura para sólo escritura; coloca el puntero al  principio del archivo y trunca el archivo a longitud cero, por lo que borrará todo su contenido. Si el archivo no existe se intenta crear.
‘w+’ Apertura para lectura y escritura; coloca el puntero al principio del archivo y trunca el archivo a longitud cero, por lo que borrará todo su contenido. Si el archivo no existe se intenta crear.
‘a’ Apertura para sólo escritura; coloca el puntero al final del archivo. Si el archivo no existe se intenta crear.
‘a+’ Apertura para lectura y escritura; coloca el puntero  al final del archivo. Si el archivo no existe se intenta crear.
‘x’ Creación y apertura para sólo escritura; coloca el puntero al principio del archivo. Si el archivo ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel E_WARNING. Si
el archivo no exite se intenta crear.
‘x+’ Creación y apertura para lectura y escritura; coloca el puntero al principio del archivo. Si el archivo ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel E_WARNING. Si
el archivo no exite se intenta crear.

También se puede especificar b de binario o c de texto en combinación con los diferentes modos de apertura. Solo en sistemas Windows se diferencia entre archivos binarios y de texto, así que si se quiere lograr la mayor portabilidad del código sería más eficiente abrir los archivos en modo binario.

-El tercer parámetro es opcional, es un booleano que indica si debe buscar el archivo en la directiva include_path en el archivo de configuiración de PHP.

En este ejemplo abrimos un fichero en modo binario para leer y escribir al final del fichero, sin borrar el contenido. El tercer parámetro lo establecemos a true para que busque el fichero en el include_path. Utilizamos el operador para suprimir los posibles errores que muestre la función fopen() si algo va mal. Comprobamos si el puntero es FALSE, y en ese caso mostramos un mensaje de error.

<?php
$fichero = @fopen('archivo.txt', 'a+b', true );
if(!$fichero)
{
   echo 'No se puede abrir el fichero.';
}
?>

Escritura de ficheros

-fwrite() y fputs():

PHP cuenta con una serie de métodos para escribir en un fichero abierto para escritura. Podemos utilizar la función fwrite() o fputs(). A estas dos funciones que funcionan de la misma manera, ya que fputs() es un alias de fwrite(), se les tiene que pasar dos parámetros, el recurso apuntador del fichero y la cadena que quiere escribirse. El tercer parámetro es opcional e indica la longitud en bytes que se va a escribir. La función devuelve el número de bytes escritos o FALSE si hubo algún error.

<?php
$fichero = @fopen('archivo.txt', 'a+b', true );
if(!$fichero)
{
   echo 'No se puede abrir el fichero.';
}

$cadena="Hola, esto es un ejemplo de escritura en ficheros.";

fwrite($fichero, $cadena, strlen($cadena));
?>

Lectura de ficheros

PHP también cuenta con una serie de funciones para leer ficheros. Podemos utilizar por ejemplo la función fread(). Esta función toma dos parámetros, el recurso que apunta al fichero, y el número de bytes que queremos leer. Esta función es poco manejable cuando queremos buscar en un fichero, así que PHP cuenta con funciones más precisas para leer líneas del fichero apoyandose en otras funciones relacionadas.

-feof():

Esta función toma como parámetro el recurso que apunta al fichero y devuelve TRUE si el puntero se encuentra al final del archivo.

-fgets():

Esta función se utiliza para leer línea a línea un fichero. Toma como parámetro el puntero al fichero y opcionalmente una longitud y leerá una nueva línea o hasta que alcanze la longitud establecida en el segundo parámetro opcional. Utilizar esta función es la forma ideal de ir analizando el fichero línea a línea para encontrar la información que estamos buscando.

Vamos a ver un ejemplo de lectura utilizando la función fgets() y feof() para leer un fichero línea a línea y mostrarlo en pantalla:

<?php

$fichero = @fopen('archivo.txt', 'rb', true );
if(!$fichero)
{
   echo 'No se puede abrir el fichero.';
}
$num=1;
while (!feof($fichero))
{
     $linea = fgets ($fichero) ;
     echo 'Linea '.$num.': '.$linea.'<br />';
     $num++;
}
?>
-fgetc():

Esta función es muy parecida a la anterior pero devuelve un solo carácter.

-readfile() y file_get_contents():

Estas dos funciones sirven para leer todo el fichero de una vez. La función readfile() toma como parámetro la ruta absoluta del fichero y muestra todo su contenido en pantalla sin la necesidad de haber abierto el fichero para lectura. La función file_get_contents() funciona de manera similar pero no imprime el contenido en la salida estándar sino que lo guarda en una variable de tipo cadena.

<?php
$archivo = file_get_contents('archivo.txt', true);
echo $archivo;
?>

Cierre de ficheros

-fclose():

Cerrar un fichero es tan fácil como abrirlo. Para ello utilizamos la función fclose() que toma como parámetro el puntero al fichero que queremos cerrar.

<?php
$archivo = file_get_contents('archivo.txt', true);
echo $archivo;
fclose($archivo);
?>

Sistema de ficheros

PHP cuenta con una serie de funciones para manipular el sistema de ficheros, con ellas podemos copiar, renombrar y mover ficheros.

-copy():

Esta función copia un archivo a un destino. Toma dos parámetros, la ruta al archivo qeu se quiere copiar, y una ruta donde se quiere copiar el fichero. Devuelve TRUE en caso de éxito o FALSE en caso contrario.

<?php
$archivo = 'archivo.txt';
$nuevo_archivo = 'copia.txt';

if (!copy($archivo, $nuevo_archivo)) {
    echo 'Error al copiar.';
}
?>
-rename():

Esta función renombra un archivo. Toma dos parámetros la ruta al archivo que se quiere renombrar, y el nuevo nombre del archivo.

<?php
$archivo = 'archivo.txt';
$nuevo_archivo = 'nuevo.txt';

if (!rename($archivo, $nuevo_archivo)) {
    echo 'Error al renombrar.';
}
?>
-unlink():

Esta función borra un archivo. Toma como parámetro la ruta al archivo.

<?php
$archivo = 'archivo.txt';
if (!unlink($archivo)) {
    echo 'Error al borrar.';
}
?>
-file_exists():

Esta función comprueba si existe un fichero que se le pase como parámetro. Devuelve TRUE si existe, FALSE en caso contrario. Hay que tener en cuenta que el parámetro no es un puntero al fichero, sino el nombre del fichero.

<?php
$archivo = 'archivo.txt';
 
if (file_exists($nombre_archivo)) {
    echo "El archivo $archivo existe";
} else {
    echo "El archivo $archivo no existe";
}
?>

RESUMEN

Hemos visto algunas funciones interesantes para abrir, escribir, leer y cerrar ficheros, asi como para borrar, renombrar y copiar ficheros. PHP cuenta con muchas más funciones referentes al sistema de ficheros y directorios que no vamos a ver en este cpítulo para no hacerlo tan extenso. Podeis echarles un vistazo en la documentación oficial. Ya sabeis siempre que tengais alguna duda de si existe una función es mejor buscar una que te pueda servir en la API de php, y sino crearte la tuya propia. En el proximo capítulo veremos como subir archivos al servidor mediate un formulario.

Hasta la próxima.

Categorías:PHP Etiquetas:

Curso PHP. Capítulo 8: Programación orientada a objetos. (II/II)

15 junio, 2010 5 comentarios

Una vez visto gran parte de los conceptos orientados a objetos en PHP vamos a mostrar un ejemplo que maneja objetos para gestionar un videoclub. Antes de nada, hay que decir que este ejemplo no está completo, ni siquiera es la forma ideal de realizar una aplicación de gestión, pero nos sirve como ejemplo para aprender a manejar objetos.

Vamos a realizar en primer lugar un diagrama de clases en UML para representar gráficamente las clases que vamos a utilizar para gestionar los diferentes objetos. Para no alargar mucho el ejemplo, vamos a contar con una serie de clases muy limitadas:

-La clase Videoclub: es la clase principal de nuestra aplicación. Representa a un videoclub en el dominio del problema y cuenta con una colección de clientes y productos registrados. Así como métodos para alquilar un producto a un cliente, y registrar nuevos productos y clientes en el videoclub.

-La clase Cliente: representa a un cliente. Cuenta con una variable que representa la colección de productos alquilados.

-La clase Producto: clase abstracta que representa un producto del videoclub. No podemos instanciar objetos Producto. Cuenta con una serie de atributos que heredarán las subclases, nombre y precio.

-Las clases Pelicula, Cd, Juego: clases derivadas de la clase padre Producto. Representan los diferentes productos del que dispone el videoclub. Cada producto tiene asignado un precio diferente de alquiler. Para mostrar un ejemplo de clases abstractas, herencias y reemplazo de métodos, he diseñado la clase Producto con un método abstracto getPrecio() que deberán implementar las clases derivadas. Así cada tipo de Producto contará con un método getPrecio() que devolverá el precio en función del tipo de producto que sea. Las peliculas devolverán 2 euros, los cds de música devolverán 1 euro y los juegos 3 euros.

Tras esta breve descripción de las clases del dominio de nuestra aplicación, vamos a crear el código PHP que utilizaremos para instanciar objetos:

Clase Cliente

<?php

/* Clase que representa a un cliente en el dominio del problema */
class Cliente
{
	private $nombre;
	private $productosAlquilados;

	public function __construct($nombre)
	{
		$this->nombre=$nombre;
		$this->productosAlquilados=array();
	}

	public function getNombre()
	{
		return $this->nombre;
	}

	public function getProductosAlquilados()
	{
		return $this->productosAlquilados;
	}

	public function alquilarProducto($producto)
	{
		$this->productosAlquilados[]=$producto;
		return true;
	}
}
?>

Clase Producto

<?php
abstract class Producto
{
    protected $nombre;
    protected $precio;

    public function getNombre()
    {
       return $this->nombre;
    }

    abstract public function getPrecio();
}
?>

Clase Pelicula

<?php
class Pelicula extends Producto
{

	private $idioma;
	private $duracion;
	private $genero;

	public function __construct($nombre,$idioma,$duracion,$genero)
	{
		$this->nombre = $nombre;
		$this->precio = 2;
		$this->idioma = $idioma;
		$this->duracion = $duracion;
		$this->genero=$genero;
	}

    public function getPrecio()
	{
	   return $this->precio;
	}

	public function getIdioma()
	{
	   return $this->precio;
	}

	public function getDuracion()
	{
	   return $this->precio;
	}
}
?>

Clase Cd

<?php
class Cd extends Producto
{

	private $duracion;
	private $genero;

	public function __construct($nombre,$duracion,$genero)
	{
		$this->nombre = $nombre;
		$this->precio = 1;
		$this->genero = $genero;
		$this->duracion = $duracion;
	}

    public function getPrecio()
	{
	   return $this->precio;
	}

	public function getDuracion()
	{
	   return $this->duracion;
	}

	public function getGenero()
	{
	   return $this->Genero;
	}
}
?>

Clase Juego

<?php
class Juego extends Producto
{

	private $plataforma;
	private $genero;

	public function __construct($nombre,$plataforma,$genero)
	{
		$this->nombre = $nombre;
		$this->precio = 3;
		$this->idioma = $idioma;
		$this->duracion = $duracion;
	}

    public function getPrecio()
	{
	   return $this->precio;
	}

	public function getPlataforma()
	{
	   return $this->plataforma;
	}

	public function getGenero()
	{
	   return $this->Genero;
	}
}
?>

Clase Videoclub

<?php

include_once('class.cliente.php');
include_once('class.producto.php');
include_once('class.pelicula.php');
include_once('class.cd.php');
include_once('class.juego.php');

class Videoclub
{

	private $nombre;
	private $productos;
	private $clientes;

	public function __construct($nombre)
	{
		$this->nombre=$nombre;
		$this->productos=array();
		$this->clientes=array();
	}

	public function addProducto($producto)
	{
		$this->productos[]=$producto;
	}

	public function getProductos()
	{
		return $this->productos;
	}

	public function addCliente($cliente)
	{
		$this->clientes[]=$cliente;
	}

	public function getClientes()
	{
		return $this->clientes;
	}

	public function alquilar($cliente,$producto)
	{
		$cliente->alquilarProducto($producto);
	}

}
?>

Ya tenemos creadas las clases que vamos a utilizar para instanciar objetos y gestionar nuestro videoclub. Ahora realizamos un pequeño script de ejemplo que muestr el manejo de estos objetos.

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Prueba</title>
</head>
<body>

<?php

include_once('class.videoclub.php');

//Creamos un videoclub
$videoclub= new Videoclub('VideoMax');

//Creamos un nuevo cliente de nombre Francisco
$cliente=new Cliente('Francisco');

//Creamos una nueva pelicula
$pelicula=new Pelicula('El señor de los Anillos','Castellano','3 horas','Fantasía');

//Registramos el cliente y el producto en el videoclub
$videoclub->addCliente($cliente);
$videoclub->addProducto($pelicula);

//El cliente alquila la pelicula
$videoclub->alquilar($cliente, $pelicula);

//Obtenemos la lista de clientes registrados
$clientes = $videoclub->getClientes();

//Imprimimos la lista de clientes registrados
echo '<p>Lista de Clientes:</p>';
foreach($clientes as $cliente)
{
	echo $cliente->getNombre().'<br />';
}

//Obtenemos la lista de productos registrados
$productos = $videoclub->getProductos();
echo '<p>Lista de Productos:</p>';
foreach($productos as $producto)
{
	echo $producto->getNombre().'<br />';
}

?>

</body>
</html>

No hay mucho más que decir de este script de ejemplo ya que el código viene muy detallado. Creamos una instancia del videoclub, un nuevo cliente y un nuevo producto, los registramos dentro del videoclub, y alquilamos la pelicula al cliente. Despúes obtenemos los clientes y productos registrados y los mostramos por pantalla. Y hasta aquí nuestra pequeña aplicación de prueba.

Vuelvo a repetir, que no es una buena forma de implementar una aplicación de gestión, ya que no persisten los datos. Con cada nueva petición, se creará un nuevo videoclub vacio. Y se volverán a añadir el cliente y la película. Además las clases están incompletas, faltan métodos, como el de devolver el producto, eliminar un cliente, eliminar un producto, comprobar si el producto está disponible y no está alquilado, y ni siquiera interactúa con el usuario, simplemente sigue las mismas instrucciones con cada petición. En definitiva, que es una chapuza de aplicación lo que hemos creado, pero sirve bastante bien para ver como podemos manejar objetos a partir de clases creadas por nosotros mismos.

Cuando vayamos avanzando en el curso de PHP seremos capazes de crear aplicaciones profesionales, utilizando patrones de diseño,  frameworks orientados a objetos como symfony para estructurar bien el código siguiendo una arquitectura MVC (modelo-vista-controlador). Aprenderemos a persistir datos mediante ficheros y bases de datos. A persistir estados entre distintas peticiones del mismo usuario mediante las sesiones y mucho más. Paso a paso, nutriendonos  de conocimiento.

El próximo capítulo supongo que lo dedicaré al manejo de ficheros.

Hasta la próxima.

Curso PHP. Capítulo 8: Programación orientada a objetos. (I/II)

14 junio, 2010 3 comentarios

En este capítulo voy a explicar los conceptos relacionados con la programación orientada a objetos en PHP. No va a ser un curso dedicado al análisis y desarrollo de aplicaciones siguiendo esta metodología porque para ello haría falta un libro entero. Disponeis de un buen libro en la sección dedicada al analisis y diseño orientado a objetos.

PHP fue diseñado originalmente como un lenguaje de scripting, pero a medida que se avanzaba en su desarrollo, se fueron incluyendo características para programar con orientación a objetos. Hoy en día con PHP5 contamos ya con una buena plataforma de programación orientada a objetos.

Hay mucha controversia sobre la mejor forma de afrontar un proyecto web. Hay partidarios de utilizar PHP como un gran número de funciones separadas e ir realizando las llamadas necesarias, es decir, utilizar PHP como un simple lenguaje de scripting utilizando la metodología de la programación estructurada.

Por el contrario tenemos a desarrolladores que prefieren dedicar más tiempo a diseñar un buen sistema orientado a objetos utilizando los distintos frameworks disponibles, como symfony, zend o code igniter.

No tengo la experiencia necesaria para decantarme por uno de los diferentes métodos de desarrollo, es obvio, que utilizar la metodología de la programación estructurada es más sencillo ya que aprender a utilizar los distintos frameworks requiere tiempo y esfuerzo dando lugar a una curva de aprendizaje más larga. Aún así, este pequeño inconveniente no debería frenaros. En mi caso por ejemplo, empezé utilizando PHP probando el desarrollo con funciones separadas y organizadas en archivos. El paso a la programación orientada a objetos no me costó mucho porque ya había tocado lenguajes como Java o C# y algo de analisis y diseño OO con UML.

Hoy en día todavía no he aprendido a usar bien el primer framework con el que estoy practicando, symfony, pero poco a poco fui capaz de ir desarrollando pequeñas cosas con este framework dandote cuenta de la potencia que tiene este framework para desarrollar aplicaciones dinámicas. Cuando acabe el curso de PHP intentaré comenzar uno de Symfony.

En este capítulo voy a explicar los conceptos de la POO en PHP, y luego intentaré mostraros algunos ejemplos. Voy a presuponer que el lector tiene algunos conocimientos de los pilares básicos de la POO: encapsulación, herencia y polimorfismo, ya que no serán explicados en profundidad.

Clases y objetos:

Una clase es un tipo de datos que define el estado y el comportamiento de los objetos que se instancian a partir de ellas. Contiene un conjunto de atributos/propiedades/campos y un conjunto de funciones/métodos/operaciones. En PHP las clases se crean utilizando la palabra clave reservada class:

class nombreClase
{
}

Dentro de la definición de clase podemos declarar variables y funciones. Las variables pueden declararse utilizando la palabra clave var, pero en PHP5 ya existen los modificadores de acceso public, protected y private típicos de los lenguajes orientados a objetos.

class nombreClase
{
   private $atributo_privado;
   protected $atributo_protegido;
   public $atributo_publico;

   private function operacion_1()
   {
   }

   public function operacion_2()
   {
   }

}

Modificadores de acceso:

Si no especificamos ningún modificador de acceso, por defecto las variables y funciones son public, es decir, son accesibles desde dentro y fuera del objeto. Esto es una mala práctica de programación porque rompe con los principios de la POO, ya que hay que garantizar la integridad de los datos, es decir, lo ideal sería encapsular los datos para que solo el propio objeto pudiera manipularlos y exponer una interfaz para poder acceder a ellos.

Las variables y funciones declaradas como private solo son accesibles dentro de la clase. Las clases que hereden de ella tampoco tendrán acceso a las variables y funciones declaradas con el modificador de acceso private.

Si queremos que las variables y las funciones sean accesibles también para las clases que heredan pero que no se puedan manipular desde fuera podemos declararlas con el modificador de acceso protected.

Constructor:

Existe un conjunto de funciones especiales en la definicion de una clase. Una de ellas es el constructor de la clase. Cada vez que creemos/instanciemos un objeto se llama al constructor de la clase que es el encargado de inicializar los atributos del objeto. En versiones anteriores de PHP la función constructora se llamaba igual que el nombre de la clase. A partir de PHP5 se utiliza el nombre __construct(). Si en una clase no se encuentra una función con este nombre PHP buscará una función con el mismo nombre que la clase.

class nombreClase
{
   private $atributo_privado;
   protected $atributo_protegido;
   public $atributo_publico;

   function __construct($param1, $param2, $param3)
   {
      $atributo_privado=$param1;
      $atributo_protegido=$param2;
      $atributo_publico=$param3;
      echo 'Constructor de la clase';
   }

   private function operacion_1()
   {
   }

   public function operacion_2()
   {
   }

}

Cabe destacar que PHP5 admite la sobrecarga de funciones, lo que significa que podemos realizar dos funciones con el mismo nombre y diferentes tipos o cantidad de parámetros.

Destructor:

Otra de las funciones especiales de clase es el destructor. Su tarea es lo contrario al constructor. Esta función se ejecuta cada vez que se destruye un objeto, lo que ocurre cuando se eliminan todas las referencias al objeto. El nombre del destructor es __destruct(). Los destructores no aceptan parámetros.

class nombreClase
{
   private $atributo_privado;
   protected $atributo_protegido;
   public $atributo_publico;

   function __construct($param1, $param2, $param3)
   {
      $atributo_privado=$param1;
      $atributo_protegido=$param2;
      $atributo_publico=$param3;
      echo 'Constructor de la clase';
   }

   function __destruct()
   {
      echo 'Destructor de la clase';
   }

   private function operacion_1()
   {
   }

   public function operacion_2()
   {
   }

}

Atributos y funciones de clase:

Podemos utilizar los atributos y las funciones de clase dentro de nuestra clase. Para referirnos a ella contamos con la pseudo-variable $this que hace referencia a la propia clase.

Constantes de clase:

En PHP5 podemos crear constantes en una clase pudiendo acceder a ella desde fuera de la clase sin la necesidad de instanciar un objeto. Las constantes se crean con la palabra reservada const, y accedemos a ella con la siguiente sintaxis, nombreClase::nombreConstante.

class Matematicas
{
   const pi = 3.1416;
   const e = 2.7182;
}

echo Matematicas::pi.' '.Matematicas::e;

Métodos estáticos

En PHP5 podemos crear métodos estáticos y acceder a ellos sin la necesidad de instanciar un objeto. Las métodos estáticos se declaran con la palabra reservada static y se accede a ellos mediante la sintaxis, nombreClase::nombreFuncion. Cabe destacar que no podemos acceder a las constantes ni a los métodos estáticos con la pseudo-variable $this. Para poder acceder a ellas dentro de una clase utilizamos la pseudo-variable self::nombreConstante o self::nombreFuncion(). Por último decir que dentro del cuerpo de una función estática solo podemos utilizar variables estáticas, no variables de clase.

class Matematicas
{
   public static function cuadrado($numero)
   {
      return $numero*$numero;
    }
}

echo Matematicas::cuadrado(5);

Instancias:

La clase por sí sola no realiza nada, no es más que una plantilla con la que podemos crear/instanciar objetos. En PHP los objetos se instancian con el operador new seguido del nombre de la clase. A continuación entre paréntesis todos los parámetros que sean necesarios suministrar al constructor.

Podemos acceder a las variables y a las funciones publicas mediante el operador ->.

$variable_objeto = new nombreClase($param1, $param2, $param3);

$variable_objeto->operacion2();

Herencia

La herencia nos permite crear una relacion jerárquica entre las clases. La clase hija o subclase se comporta de la siguiente manera:

-Hereda automaticamente todas las variables y funciones miembros de la clase padre que tengan un modificador de acceso public y protected.

-Puede definir nuevas variables y funciones, así como reescribir variables y funciones de la clase padre siempre que no se hayan declarado como finales.

-Puede acceder a las variables y funciones de la clase padre mediante la pseudo-variable parent::.

En PHP podemos crear una subclase de una superclase utilizando la palabra reservada extends de la siguiente manera:

class SubClase extends SuperClase
{
}

En el interior de las llaves definiremos las nuevas variables y funciones de la clase hija, además podemos reemplazar las funciones definidas en la clase padre siempre que no se hayan deifnidido con el modificador final. Para ello solo tenemos que definir una funcion que se llame igual y contenga el mismo número de parámetros que en la clase padre.

Si la clase padre se ha declarado como final no se podrá heredar una subclase.

Interfaces

PHP no permite la herencia múltiple, es decir, poder crear una subclase a partir de varias superclases. Pero se puede simular su comportamiento si utilizamos las interfaces.

Una interfaz no es más que la declaración de un conjunto de constantes y funciones que deben ser definidas en la clase que implemente dicha interfaz. Una interfaz en PHP se crea utilizando la palabra reservada interface de la siguiente manera:

interface Listar
{
   function listar_nombre();
}

En este ejemplo hemos creado una interfaz llamada Listar que define una funcion listar_nombre(). La clase que implemente esta interfaz debera implementar todas las funciones de la interfaz. Una clase puede implementar una interfaz mediante la palabra reservada implements de la siguiente forma:

class Ejemplo implements Listar
{
   function listar_nombre()
   {
      echo 'Francisco';
   }
}

De esta forma podemos simular la herencia múltiple ya que podemos implementar todas las interfaces que queramos si las separamos por comas, con el inconveniente que debemos implementar todas las funciones declaradas en la interfaz.

Clases abstractas

PHP5 también incluye el concepto de clases abstractas típicas de otros lenguajes orientados a objetos.  Las clases abstractas se definen en PHP5 utilizando la palabra reservada abstract de la siguiente manera:

abstract class nombreClase
{
}

Una clase abstracta no puede ser instanciada, sirve como clase base para que otras hereden de ella. Una clase abstracta define una serie de funciones abstractas que no tienen implementación. Las clases que hereden de una clase abstacta tendrán que implementar esas funciones, sino automaticamente se convierten en clases abstractas.

Imaginaros la siguiente situación. Tenemos una clase Persona que representa una persona, con una serie de atributos como nombre, apellidos y dni. Y queremos construir clases que representen diferentes tipos de personas, como, Empleado, Director, Funcionario y  Conserje. Necesitamos un método que calcule el salario de cada tipo de persona. Para ello podemos definir una clase abstracta Persona con una serie de variables y una función asbtracta llamada calcular_salario(). Todas las demás clases heredarán de esta clase base y tendrán que sobreescribir el método calcular_salario() de la clase padre.

class Persona
{
   protected $nombre;
   protected $apellidos;

   abstract function calcular_salario();
}

class Director extends Persona
{

   function __construct($nombre, $apellidos)
   {
      $this->nombre=$nombre;
      $this->apellidos=$apellidos;
   }

   function calcular_salario()
   {
      return 10000;
   }

}

$director = new Director('Francisco','Belmonte Ruiz');

//Imprime 10000
echo $director->calcular_salario();

RESUMEN

Hasta ahora hemos visto una serie de conceptos orientados a objetos en PHP :  crear clases,  instanciar objetos, utilizar modificadores de acceso, crear constantes y funciones estáticas, crear clases abstractas e interfaces, aprender a heredar a partir de otras clases, acceder a las variables y funciones de los objetos, acceder a las variables y funciones de la clase padre, etc…

PHP cuenta con muchos más conceptos que los vistos aquí y no estaría mal que mirarais  la documentación oficial para ver algunos conceptos que no hemos visto en este curso, como el uso de métodos mágicos. Una vez visto los principales conceptos vamos a dedicar la segunda parte de este capítulo a crear un ejemplo básico de aplicación que utilize objetos, como un gestor de un videoclub.

Hasta la próxima.

Curso PHP. Capítulo 7: Formularios

9 junio, 2010 2 comentarios

A lo largo del curso ya hemos visto muchas características básicas de PHP pero la verdadera potencia del lenguaje reside en la comunicación con el usuario que utilize nuestras aplicaciones, para ello PHP puede acceder a las variables de los formularios o a través de la barra de dirección del navegador.

PHP cuenta con dos arrays super-globales $_POST y $_GET para acceder a las variables de formulario enviadas a través del método POST y GET respectivamente. En versiones anteriores de PHP se podía acceder a través de los arrays $HTTP_POST_VARS y $HTTP_GET_VARS, y aunque su uso ya sea obsoleto podemos utilizarlos igualente si activamos la directiva register_long_arrays. PHP también cuenta con un estilo corto para acceder a las variables de formulario utilizando directamente el nombre del atributo name de cada campo. Esta forma de acceder a los datos no es recomendable para la seguridad de nuestras aplicaciones, ya que un usuario malintencionado podría pasar otras variables que utilizaramos en nuestros códigos e interferir en la lógica programada. En la configuración de PHP ya viene desactivado su uso, pero para asegurarnos desactivaremos la directiva register_globals.

Formularios  XHTML

Antes de empezar a utilizar PHP para manipular las variables de formularios vamos a hacer un repaso de las etiquetas XHTML para el marcado de formularios y los distintos campos. No va a ser una guía en profundidad, más bien un repaso, ya que presupongo que si estais aprendiendo PHP es que ya teneis algunos conocimientos intermedios de HTML/XHTML.

La etiqueta <form> cuenta con una serie de atributos a destacar:

-method:  Este atributo puede ser POST o GET e indica el método con el que se pasaran los datos al servidor. Si utilizamos el método GET los datos se pasaran por la URL y serán visibles por todos los usuarios. Si utilizamos el método POST los datos van incluidos en el cuerpo de la petición HTTP al servidor.

-action: Este atributo indica el archivo PHP que procesará la información. Puede ser una ruta relativa o absoluta.

Dentro de la etiqueta <form> podemos encerrar distintos campos de texto, de password, checkbuttons, radiobuttons, listas, etc. De estos campos cabe destacar el atributo name ya que accederemos a los datos de cada campo en el servidor utilizando el valor de ese atributo.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Documento sin t&#237;tulo</title>
</head>
<body>

<form method="post" action="contacto.php">
  <label for="nombre">Nombre:</label>
  <input type="text" name="nombre" id="nombre" />
  <br />
  <label for="asunto">Asunto:</label>
  <input type="text" name="asunto" id="asunto" />
  <br />
  <label for="cuerpo">Cuerpo:</label>
  <br />
  <textarea name="cuerpo" id="cuerpo" rows="10" />
</form>

</body>
</html>

Un ejemplo de un formulario muy básico sin estilos CSS y no muy bien diseñado pero que nos sirve como ejemplo para explicar como acceder a los datos que el usuairo introduce. En nuestro ejemplo tenemos tres campos, nombre, asunto y cuerpo. Además enviamos los datos a través del método POST. Vamos a ver como acceder a estos datos a través de PHP.

<?php
$nombre = $_POST['nombre'];
$asunto = $_POST['asunto'];
$cuerpo = $_POST['cuerpo'];
?>

De esta forma accedemos a los datos del formulario a través del array super-global $_POST. Hemos declarado tres variables y hemos introducido el valor de cada campo en ellas, ahora podemos manipular esas variables como queramos. Si hubieramos enviado el formulario a través del método GET no cambiaría mucho la cosa, solo hay que tener en cuenta que no podemos enviar todo lo que queramos por GET porque tiene una limitación por caracteres y además es visible en la barra de direcciones.

Variables super-globales

PHP cuenta con una serie de arrays super-globales:

-$_GET: Almacena las variables que se pasan desde un formulario mediante el método GET.
-$_POST: Almacena las variables pasadas por POST.
-$_COOKIE: Guarda los valores que están almacenados en cookies. Ya veremos en capítulos sucesivos cómo utilizarlo.
-$_SESSlON: Guarda las variables que se pasan entre sesiones. Ya veremos en capítulos sucesivos cómo utilizarlo.
-$_SERVER: Contiene numerosos valores relativos al servidor.
-$_FILES : Los archivos que enviemos a través de un formulario serán recogidos en este array. Ya veremos en capítulos sucesivos cómo utilizarlo.

RESUMEN

En este capítulo hemos aprendido como acceder a los datos que introducen los usuarios a través de fomularios o la URL. No hemos entrado en detalles en temas sobre seguridad, pero hay que tener claro que nunca podemos confiar en los datos de entrada de los usuarios y tienen que pasar por un control exhaustivo para garantizar la integridad de la aplicación. Podeis ver una serie de artículos en este mismo blog dedicado a temas de vulnerabilidades web.

En el próximo capítulo entraremos en el mundo de la programación orientada a objetos en PHP.

En un principio puede parecer que cada curso no está muy detallado, en realidad no intenta ser un curso con muchos detalles sino más bien una introducción rápida al mundo de PHP. Esto es así porque posteriormente quiero entrar en temas más detallados y realizar algunos talleres de ejemplos de aplicaciones del mundo real.

Hasta la próxima.

Categorías:PHP Etiquetas:

Curso PHP. Capítulo 6: Arrays

9 junio, 2010 3 comentarios

Un array es una colección de datos que podemos almacenar en una variable con un único nombre. Para acceder a los datos podemos utilizar índices númericos o alfanuméricos. En PHP los arrays no se definen con un tipo base y pueden almacenar distintos tipos de variables en su interior, ya sean integers, cadenas u objetos. Además son dinámicos, esto quiere decir que no necesitamos definirlos con un tamaño como en la mayoría de lenguajes de programación, ya que van creciendo dinamicamente a medida que utilizamos nuevos índices.

Para crear un array podemos utilizar la funcion array() que crea un array con los datos que se le pasen como parámetros.

<?php
$numeros = array(1,2,3,4,5,6);
?>

En nuestro ejemplo hemos creado un array de índice numérico ya que para acceder a los datos de su interior utilizamos índices numéricos de esta forma:

<?php
$numeros = array(1,2,3,4,5,6);

$numero1=numeros[0]; //$numero1=1
$numero2=numeros[1]; //$numero2=2
$numero3=numeros[2]; //$numero3=3
?>

La función array() también nos permite crear arrays asociativos para acceder a los datos utilizando claves alfanuméricas.

<?php
$agenda = array("Lunes" => "Estudiar PHP",
                "Martes" => "Estudiar CSS",
                "Miércoles" => "Examen de Java",
                "Jueves" => "Estudiar SQL",
                "Viernes" => "Salir de fiesta");

//Imprime la cadena: Hoy es Lunes, toca Estudiar PHP
echo 'Hoy es Lunes, toca '.$agenda['Lunes'];
?>

En este ejemplo hemos almacenado en un array 5 par de claves/valor y hemos accedido al valor de la clave Lunes.

Arrays multidimensionales

Hasta ahora hemos utilizado un array unidimensional. PHP soporta arrays de varias dimensiones, aunque no suele utilizarse más allá de una tercera dimensión porque aumenta bastante la complejidad de manipularlos.

<?php

$tecnologias=array( 'web' => array( 'programacion' => 'PHP',
                                    'marcado' => 'XHTML',
                                    'presentacion' => 'CSS'),

                   'escritorio' => array( 'programacion' => 'Java',
                                          'otro' => 'C++'))
?>

Hemos creado un array de dos dimensiones. Para acceder a los datos podemos utilizar:

<?php
echo $tecnologias['web']['programacion']; //Imprime PHP
?>

Funciones de manipulación de arrays

La API de PHP tiene numerosas funciones de manipulación de arrays, como siempre para reducir la extensión del curso voy a referirme a alguna de ellas pero podeis encontrar información más exhaustiva en la documentación oficial en línea de PHP.

-count(), sizeof()

Esta función cuenta el número de elementos de un array. También puede utilizarse la función sizeof() que funciona de la misma manera.

<?php
$agenda = array("Lunes" => "Estudiar PHP",
                "Martes" => "Estudiar CSS",
                "Miércoles" => "Examen de Java",
                "Jueves" => "Estudiar SQL",
                "Viernes" => "Salir de fiesta");

echo count( $agenda ); //Imprime 5
?>
-in_array()

Esta función busca un valor pasado como argumento dentro del array pasado como argumento. Si lo encuentra devuelve true, en caso contrario, devuelve false.

<?php
$agenda = array("Lunes" => "Estudiar PHP",
                "Martes" => "Estudiar CSS",
                "Miércoles" => "Examen de Java",
                "Jueves" => "Estudiar SQL",
                "Viernes" => "Salir de fiesta");

if (in_array( "Salir de fiesta" , $agenda ) )
       echo "En nuestra agenda hay un día para salir de fiesta";
?>
-unset()

Podemos utilizar esta función para borrar un dato del interior del array, así como el array entero.

<?php
unset($agenda['Viernes']);
//Borramos de nuestra agenda el par clave/valor del Viernes.

unset($agenda)
//Borramos el array entero
?>

Recorrer un array mediante foreach

Cuando estudiamos las estructuras de control me salté la estructura de control llamada foreach que se utiliza para recorrer arrays. Es hora de estudiarla. Su sintaxis es la siguiente:

foreach($array as $valor )

o

foreach($array as $indice=>$valor )

Así podemos utilizar dentro del bucle las variables $indice y $valor que contendrán el índice y el valor respectivamente de cada elemento del array.

<?php
foreach( $agenda as $clave => $valor) {

   echo 'El día '.$clave.' toca '.$valor.'<br />'
}
?>

En nuestro ejemplo recorremos el array asociativo $agenda. En la variable $clave almacenamos la clave de cada elemento y en la variable $valor almacenamos el valor de cada elemento del array asociativo.

Recorrer un array utilizando funciones

Los arrays también podemos recorrerlos utilizando una serie de funciones que manejan el puntero interno del array. El puntero inicialmente apunta al inicio del array.

La función current() devuelve el valor del elemento al que apunta el puntero. Podemos incrementar el puntero con la función next() y decrementarlo con la función prev(). También podemos situar el puntero al inicio del array con la función reset() o al final del array con la función end().

Si el puntero llega al final del array la función next() devuelve false.

<?php
$valor_inicial=current($agenda);

echo $valor_inicial.'<br />'; //Imprime Estudiar PHP

while( next($agenda) )
{
    echo current($agenda).'<br />';
}

reset($agenda);
?>

En este ejemplo hemos recorrido el array $agenda de uno de los ejemplos anteriores utilizando el puntero interno y las funciones de recorrido. Podeis utilizar esta forma también, aunque es mucho más elegante recorrerlos con la estructura de control foreach.

Funciones para insertar o extraer elementos

-array_push(), array_pop()

La función array_push() inserta un elemento al final del array. Analogamente, la función array_pop() extrae y devuelve el último elemento del array.

<?php
$numeros=array(1,5,6,8,10,25);

array_push($numeros, 2, 5, 6);

echo array_pop($numeros); //Imprime 6
?>

Funciones para ordenar arrays

-asort(), arsort(), ksort(), krsort(), sort(), rsort()

Esta serie de funciones se utilizan para ordenar arrays. La función asort() ordena los valores del array ascendentemente. La función arsort() ordena el array por valores descendentes.

La función ksort() ordena el array por claves ascendentes. La función krsort() ordena el array por claves descendentes.

La función sort() ordena el array ascendentemente con el inconveniente de que se pierde la asociatividad entre la clave y el valor, es decir si le pasamos un array asociativo de vuelve un array de índice numérico.

La función rsort() tiene el mismo inconveniente y ordena los valores descendentemente.

<?php

$array_numerico=array( "Lunes", "Martes", "Miercoles", "Jueves", "Viernes"  );

var_dump(sort($array_numerico));
var_dump(rsort($array_numerico));

$array_asociativo=array("Lunes" => "Lentejas",
                        "Martes" => "Macarrones",
                        "Miercoles" => "Spaguettis",
                        "Jueves" => "Albondigas",
                        "Viernes" => "Morcilla");

var_dump(asort($array_asociativo));
var_dump(arsort($array_asociativo));

var_dump(ksort($array_asociativo));
var_dump(krsort($array_asociativo));
?>

En este ejemplo, hemos ordenado un array de índice numérico y un array asociativo, y hemos mostrado el valor de los arrays mediante la función var_dump(). Esta función más que nada sirve para depuración de los códigos ya que muestra el contenido de cualquier variable pasada como parámetro.

RESUMEN

Hemos visto como utilizar arrays de índice numéricos y arrays asociativos. Hemos aprendido a ordenarlos y a recorreros mediante la estructura de control foreach y el puntero interno. Hemos visto algunas funciones para manipular arrays. En el siguiente capítulo aprenderemos a acceder a las variables de formularios, tanto del método POST como del método GET.

Poco a poco vamos adentrandonos en el mundo de PHP, con el siguiente capítulo ya podreis crear algunas aplicaciones básicas. Pero todavía falta mucho por ver.

Hasta la proxima.

Categorías:PHP Etiquetas:
Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 126 seguidores