Debido a que un par de foreros me lo han pedido, voy a hacer un pequeño tutorial sobre clases en PHP.
La programación orientada a objetos (POO u OOP en inglés) se usa en muchos lenguajes y en PHP desde su versión 5, cosa que deja una puerta abierta hacia su futuro como lenguaje. Desde mi punto de vista, este tipo de programación es muy importante, teniendo en cuenta que cada vez se utiliza más e ignorar su existencia nos complicaría la vida bastante al querer encontrar trabajo en este campo puesto que estos conocimientos son a veces requeridos.
Las clases agrupan en una misma estructura variables y funciones las cuales pueden ser públicas, privadas o protegidas. Este tutorial pretende ser una introducción, por lo que nos centraremos solo en las públicas y privadas.
La estructura de una clase es muy sencilla:
<?php
class miClase // Nombre de la clase.
{
// Variables a usar en nuestra clase.
var $variable;
// Funciones de nuestra clase.
public function mostrarVariable()
{
$this->variable = "Hola mundo\n";
return $this->variable;
}
}
?>Y su ejecución (debemos guardar la clase, por ejemplo, como "miClase.php"):
<?php
// Yo utilizo require_once para incluir solo una vez la clase,
// ya que a veces puede ser que necesitemos llamar a una
// clase desde una función y si la ejecutamos más de una vez,
// nos lanzaría un error.
require_once("miClase.php");
$consulta = new miClase(); // Declaramos la variable del tipo "miClase".
echo $consulta->mostrarVariable(); // Mostramos el resultado obtenido de la función.
?>Si os fijáis, cuando tratamos dentro de nuestra clase las variables, les hacemos referencia con $this->variable, ("variable" es el nombre de nuestra variable sin "$"). Esto es muy útil cuando trabajamos con variables privadas, ya que estas solo pueden ser modificadas internamente, por lo que desde la misma clase controlamos su contenido.
Para declarar una variable privada, solo debemos cambiar "var" por "private" (solo se pueden declarar como privadas las variables de la clase, no las que declaramos dentro de las funciones, puesto que estas por defecto solo son visibles dentro).
Entonces, si son privadas, ¿cómo las podemos modificar?. Pues para ello debemos crear una función para modificar esa variable, por ejemplo, basándonos en el código anterior:
<?php
class miClase
{
private $variable;
public function cambiarVariable($xNuevoValor)
{
$this->variable = $xNuevoValor;
}
public function mostrarVariable()
{
return $this->variable;
}
}
?>Y su ejecución:
<?php
require_once("miClase.php");
$consulta = new miClase();
$consulta->cambiarVariable("Contenido nuevo");
echo $consulta->mostrarVariable();
?>Es muy importante tener en cuenta que las funciones de la clase deben ser públicas (public) para poder utilizarlas fuera de ella y decir también que si no indicamos que es pública o privada, por defecto PHP las establece como públicas. Yo personalmente siempre indico el tipo, de esta forma veo con más facilidad qué tipo de funciones estoy creando.
Otra cosa imprescindible en una clase es un constructor. Esto sirve para definir unos valores por defecto al hacer referencia a nuestra clase. El constructor es una función con un nombre estático "__construct" (doble guión bajo):
<?php
class coche
{
private $marca;
private $modelo;
private $color;
private $precio;
// La función _construct se ejecuta automáticamente
// al crear el nuevo objeto.
function __construct()
{
// Estos valores serán los valores
// por defecto de nuestros coches.
$this->marca = "Sin marca";
$this->modelo = "Sin modelo";
$this->color = "Transparente";
$this->precio = 0;
}
public function establecerValores($xMarca, $xModelo, $xColor, $xPrecio)
{
$this->marca = $xMarca;
$this->modelo = $xModelo;
$this->color = $xColor;
$this->precio = $xPrecio;
}
public function mostrarCoche()
{
echo "Marca: ".$this->marca."\n";
echo "Modelo: ".$this->modelo."\n";
echo "Color: ".$this->color."\n";
echo "Precio: ".$this->precio." euros\n";
}
}
?>
Y su ejecución:
<?php
require_once("claseCoche.php");
$coche = new coche();
// Si mostramos ahora nuestro coche,
// obtendríamos los valores por defecto.
$coche->mostrarCoche(); // Esto devuelve:
// Marca: Sin marca
// Modelo: Sin modelo
// Color: Transparente
// Precio: 0 euros
$coche->establecerValores("Opel", "Astra", "Blanco", 24000);
// De esta forma, hemos modificado los valores por defecto.
$coche->mostrarCoche(); // Esto devuelve:
// Marca: Opel
// Modelo: Astra
// Color: Blanco
// Precio: 24000 euros
?>Tal vez parezca algo laborioso para mostrar unas simple variables, pero esto es solo un ejemplo sencillo para entender su funcionamiento. Ahora os pondré un ejemplo más elaborado de cómo utilizar las clases:
<?php
// Crearemos una clase para modificar el tamaño
// de una imagen usando la librería GD.
class imagenGD
{
// Definimos las variables
// a usar en nuestra clase.
private $imagen;
private $ancho;
private $alto;
private $calidad;
// Creamos el constructor para los valores
// por defecto. Al introducir un argumento,
// obligamos que al llamar a nuestra clase,
// se introduzca directamente.
function __construct($xImagen)
{
// Obtenemos el tipo de imagen.
$tipoImagen= exif_imagetype($xImagen);
// Filtramos el tipo de imagen
// para crear la nueva a partir de
// la indicada.
if($tipoImagen == IMAGETYPE_JPEG)
{
$this->imagen = imagecreatefromjpeg($xImagen);
}
elseif($tipoImagen == IMAGETYPE_GIF)
{
$this->imagen = imagecreatefromgif($xImagen);
}
elseif($tipoImagen == IMAGETYPE_WBMP)
{
$this->imagen = imagecreatefromwbmp($xImagen);
}
elseif($tipoImagen == IMAGETYPE_PNG)
{
$this->imagen = imagecreatefrompng($xImagen);
}
else
{
$this->imagen = imagecreatefromjpeg($xImagen);
}
// Establecemos los valores por defecto
// del resto de atributos.
$this->ancho = 50;
$this->alto = 50;
$this->calidad = 100;
}
// Creamos una función para cambiar el tamaño.
public function nuevoTamano($xAncho, $xAlto)
{
$this->ancho = $xAncho;
$this->alto = $xAlto;
}
// Creamos una función para cambiar la calidad.
public function nuevaCalidad($xCalidad)
{
$this->calidad = $xCalidad;
}
// Creamos una función para mostrar
// la imagen sin guardarla.
public function dibujar()
{
// Creamos la imagen.
$thumb = imagecreatetruecolor($this->$ancho, $this->alto);
// La mostramos sin guardarla.
imagejpeg($thumb);
// Liberamos la memoria usada.
imagedestroy($this->imagen);
}
// Creamos una función para guardar
// la imagen en la ruta indicada.
public function guardar($xDestino)
{
// Creamos la imagen.
$thumb = imagecreatetruecolor($this->$ancho, $this->alto);
// Cambiamos su tamaño.
imagecopyresampled($thumb, $this->imagen, 0, 0, 0, 0, $this->ancho, $this->alto, imagesx($this->imagen), imagesy($this->imagen));
// La guardamos en la ruta especificada.
imagejpeg($thumb, $xDestino, $this->calidad);
// Liberamos la memoria usada.
imagedestroy($this->imagen);
}
}
?>De esta forma, ya tenemos una clase imagenGD con distintos tipos de ejecución que os pondré a continuación:
1. Mostrar una imagen modificada con tamaño por defecto:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("carpeta/mi_imagen.jpg");
$miImagen->dibujar();
// Con solo estas dos líneas ya obtendríamos nuestra imagen
// tratada con ancho = 50; alto = 50; y calidad = 100;
// sin introducir nada más que la imagen a tratar y la función
// que la muestra (dibujar).
?>2. Guardar una imagen modificada con tamaño por defecto:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("origen/mi_imagen.jpg");
$miImagen->guardar("destino/nueva_imagen.jpg");
?>3. Mostrar una imagen modificada por completo:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("origen/mi_imagen.jpg");
$miImagen->nuevoTamano(500, 300);
$miImagen->nuevaCalidad(85);
$miImagen->dibujar();
?>4. Guardar una imagen modificada por completo:
<?php
require_once("claseGD.php");
$miImagen = new imagenGD("origen/mi_imagen.jpg");
$miImagen->nuevoTamano(500, 300);
$miImagen->nuevaCalidad(85);
$miImagen->guardar("destino/nueva_imagen.jpg");
?>Solo con una clase hemos obtenido distintos comportamientos y esto solo es un pequeño ejemplo.
Las clases pueden ser mucho más complejas y funcionales y sobretodo, reciclables en otros proyectos. Todo el trabajo que empleéis en construir una clase, si la programáis bien, os lo ahorraréis cuando la necesitéis de nuevo.
Yo os he abierto una puerta, el resto es cosa vuestra.
Un saludo
