Instalar phpmyadmin en Ubuntu

Con el sistema recién formateado instalé Apache, PHP y MySQL, como de costumbre, pero ya iba echando algo de menos, y es que soy un enamorado de phpmyadmin.

Bien, con un sencillo paso tendremos este cliente de base de datos instalado en nuestra máquina:

ahornero@6581-D:~$ sudo apt-get install phpmyadmin

Después reiniciamos el servidor:

ahornero@6581-D:~$ sudo service apache2 restart

Y listo. Si tenemos algún problema accediendo a: http://elnombredetuhost/phpmyadmin crearemos la siguiente ruta simbólica: read more

Leer más » 1 Comentario

Diferencia entre require e include en PHP

Cuando aprendes a programar en PHP, dos de las primeras funciones que usas son include y require. Prácticamente sirven para lo mismo, insertar código de un tercer fichero en el fichero actual (en otros lenguajes de programación hay funciones o construcciones similares). Pero, ¿cuál es la diferencia entre ellas?

Antes de la versión 4.0.2 de PHP (que prácticamente ninguno usaréis, o al menos deberéis usar), la diferencia radicaba en que require siempre leía el archivo al que hacía referencia, incluso si la línea de código en que se encontraba no se ejecutaba nunca (por ejemplo dentro de un condicional). include en cambio sí que se veía afectado por los condicionales y sí que podíamos hacer que no se ejecutara (por lo que tampoco se ejecutaba el código del archivo diferenciado). read more

Leer más » 3 Comentarios

Restringir el acceso mediante la dirección IP usando PHP

Si por razones de seguridad o por política de empresa, queremos bloquear las direcciones a un determinado rango o conjunto de IP, os voy a comentar cómo hacerlo de forma simple haciendo uso de PHP.

Lo primero que debemos hacer es crear una función que nos permita conocer la dirección IP del cliente:

function obtenerDireccionIP()
{
    if (!empty($_SERVER ['HTTP_CLIENT_IP'] ))
      $ip=$_SERVER ['HTTP_CLIENT_IP'];
    elseif (!empty($_SERVER ['HTTP_X_FORWARDED_FOR'] ))
      $ip=$_SERVER ['HTTP_X_FORWARDED_FOR'];
    else
      $ip=$_SERVER ['REMOTE_ADDR'];

    return $ip;
}

Una vez hecho esto, el proceso es simple. Veamos distintas posibilidades.

Permitir/restringir acceso a una sola IP

Con esta función, restringimos el acceso sólo a la IP que se le envía a la función. Podemos cambiar el “==” por “!=” para hacer lo contrario.

function restringirIp($ip) { $ipCliente = obtenerDireccionIP(); if($ipCliente == $ip) { return true; } else { header('location: http://direccion_envio_salida'); exit; } } read more

Leer más » 5 Comentarios

Curso PHP orientado a objetos – Clases de terceros, encapsulamiento

Una de las grandes ventajas, además de todas las ya explicadas y comentadas, es la facilidad con que se puede encapsular todo, para que en desarrollos posteriores no haya problema alguno. La implementación pasa a un segundo plano y se utiliza como una caja negra que funciona de manera simple. Los atributos: públicos, privados y protegidos; que hemos comentado en un punto anterior, son la base del encapsulamiento.

Imaginad que en una aplicación web, necesitamos generar un fichero PDF o interactuar con el servidor de correo de Gmail o Google Apps. Como es lógico, sería costoso perder tanto tiempo en desarrollar algo de cierta dificultad y que ya existe. La solución, encontrar una clase que se encargue de alguna de estas labores. Quien dice estas dos labores, dice otras muchas, pero he puesto estos dos ejemplos porque he tenido que hacer uso de los mismos hace no mucho.

¿Cómo utilizar dichas clases?

Lo primero es encontrarlas. Por ejemplo, en el caso de interactuar con el servicio de correo de Google tenemos PHP Mailer. Las clases se presentan en ficheros fuente de PHP que deberemos agregar convenientemente a nuestro código con algunas de las instrucciones (elegiremos cada una en función a nuestras necesidades) que mostramos a continuación y que seguro que habéis usado en más de una ocasión:

  • require(ruta_fichero);
  • include(ruta_fichero);
  • require_once(ruta_fichero);
  • include_once(ruta_fichero);

Una vez agregado a nuestro código ya podremos interactuar con ella. Primero la instanciaremos y luego interactuaremos con sus atributos y sus métodos. Con PHPMailer podríamos hacer algo así:

<?php require_once 'class.phpmailer.php'; $correo = new PHPMailer (); $correo->From = "nombre_usuario@gmail.com"; $correo->FromName = "Foo"; $correo->AddAddress ("destinatario@dominio.com"); $correo->Subject = "Mensaje de parte del equipo Linux Hispano"; $correo->Body = "<h3>Enviando con Gmail<h3/>"; $correo->IsHTML (true); $correo->IsSMTP(); $correo->Host = 'ssl://smtp.gmail.com'; $correo->Port = 465; $correo->SMTPAuth = true; $correo->Username = 'nombre_usuario@gmail.com'; $correo->Password = '******'; if(!$correo->Send()) { echo 'Ha ocurrido un error: ' . $mail->ErrorInfo; } else { echo 'Correo enviado con éxito'. } ?> read more

Leer más » 6 Comentarios

Curso PHP orientado a objetos – Herencia

A través de la herencia, una clase hija hereda de su padre los atributos y métodos, de manera que si por ejemplo tenemos una clase padre “Figura” con un atributo “área”, y dos clases hijas: “Rectángulo” y “Triángulo”.

Árbol de herencia

En PHP la palabra clave para definir la herencia es: “extend” y la forma en que se define es:

  • class Padre
  • class Hija extends Padre

El constructor y los atributos, “base” y “altura” están definidos en la clase “Figura”. El método “área” es propio de cada hija. Veamos la implementación y el resultado:

<?php class Figura { protected $base; protected $altura; function __construct($base, $altura) { $this->base = $base; $this->altura = $altura; } } class Rectangulo extends Figura { function area(){ return $this->base * $this->altura; } } class Triangulo extends Figura { function area(){ return $this->base * $this->altura /2; } } $rectangulo = new Rectangulo(2,2); $triangulo = new Triangulo(2,2); echo "<div>Para base = 2 y altura = 2: <ul> <li>Área para el rectángulo: " . $rectangulo->area() . ">/li> <li>Área para el triángulo: " . $triangulo->area() . "</li> </ul> </div>" ?> read more

Leer más » 5 Comentarios

Curso PHP orientado a objetos – Sobrecarga

Otro concepto importante de la orientación a objetos es la sobrecarga de funciones. En lenguajes que no permiten la sobrecarga debemos definir dos métodos distintos (con nombre distinto) para poder trabajar con dos funciones que hacen lo mismo, pero reciben distintos tipos de datos. La sobrecarga es muy importante para el constructor ya que normalmente tendremos distintas formas de crear la clase.

En PHP no existen las sobrecargas como tal. Sin embargo, existen mecanismos para imitarla. Como ya he dicho, la sobrecarga es muy importante en el caso del constructor, así que haremos el ejemplo siguiente, sobrecargando esta función.

El mecanismo que seguimos para imitar a la sobrecarga es usar los atributos opcionales. Imaginad que queremos tener dos constructores distintos:

  • Usuario(id, nombre, apellidos, códigoPostal): Recibe los cuatro valores y los inicializa.
  • Usuario(nombre, apellidos, códigoPostal): Recibe los tres valores, los inicializa y el identificador también lo inicializa pero de forma aleatoria (o viendo cuál le corresponde si trabajáramos con una base de datos).

La implementación, sería tal como indicamos a continuación (tenemos que poner el parámetro $id al final para poder jugar con los atributos opcionales):

function __construct($nombre, $apellidos, $codigoPostal, $id = 0)
{
	if($id != 0)
	{
		$this->id = $id;
		$this->nombre = $nombre;
		$this->apellidos = $apellidos;
		$this->codigoPostal = $codigoPostal;
	}
	else
	{
		$this->id = rand(0,100);
		$this->nombre = $nombre;
		$this->apellidos = $apellidos;
		$this->codigoPostal = $codigoPostal;
	}
}

Al poner el identificador al final, igualado a cero en la declaración, lo que le estamos diciendo al compilador es que:

  • Si se llama con tres argumentos, el valor del identificador lo iguale a cero y por lo tanto entre en la parte inferior de la condición, donde se calcula el identificador aleatorio.
  • Si se llama con cuatro argumentos, el identificador tomará el valor que el usuario le pase y por lo tanto funcionará como lo ha hecho hasta ahora.Veamos un par de ejemplos de invocación de este constructor.

$usuario_1 = new Usuario("José", "Gómez Martínez", 14004); $usuario_2 = new Usuario("José", "Gómez Martínez", 14004, 10); read more

Leer más » 11 Comentarios

Cursos PHP orientado a objetos – Crear una clase (constructor)

Constructor

El constructor en PHP se define como se muestra a continuación:

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

Como podéis apreciar, es una función, con un nombre determinado “__construct” que recibe los parámetros necesarios para la clase y los asigna a los atributos de la clase.

Creando nuestra primera clase

Con todo lo que ya hemos explicado, podemos crear un ejemplo completo. Crearemos un par de objetos inicializándolos con unos valores que introduciremos nosotros y luego los mostraremos por pantalla. Para representarlo haremos uso de HTML.

Si en lugar de incluir nosotros los datos a mano, los incluyéramos a través de, por ejemplo, una conexión con una base de datos MySQL, en la que la clase también apareciera como una tabla, estaríamos creando las bases para una completa aplicación de usuarios con base de datos, que a la vez de fácil de implementar, sería fácil de modificar, mantener y mejorar.

Crearemos los objetos llamando al constructor, los insertaremos en un array y al final, los mostraremos por pantalla recorriendo el array de objetos que acabamos de crear. Usaremos las funciones de acceso a los atributos, ya que si intentamos acceder directamente a ellos nos devolverá el siguiente error al tratarse de atributos privados: “Fatal error: Cannot access private property Usuario::$id”.

<?php include("clases.php"); $vector_usuarios = array(); $tmp = new Usuario(1, "José", "Gómez Martínez", 14004); array_push($vector_usuarios, $tmp); $tmp = new Usuario(2, "Javier", "Pérez García", 28080); array_push($vector_usuarios, $tmp); $tmp = new Usuario(3, "Jorge", "Reina Ramírez", 18001); array_push($vector_usuarios, $tmp); echo "<h2>Ejemplo orientaci&oacute;n a objetos con PHP para Linux Hispano</h2>"; foreach($vector_usuarios as $elemento_vector) { echo "<div> <h3>Usuarios sistema</h3> <ul> <li>Id. - " . $elemento_vector->getId() . "</li> <li>Nombre - " . $elemento_vector->getNombre() . "</li> <li>Apellidos - " . $elemento_vector->getApellidos() . "</li> <li>C&oacute;digo postal - " . $elemento_vector->getCodigoPostal() . "</li> </ul> </div>"; } ?> read more

Leer más » 7 Comentarios

Cursos PHP orientado a objetos – Crear una clase (atributos y propiedades)

Lo primero que haremos será declarar la clase con sus atributos en PHP. La operación es muy similar a la declaración de un struct en C o de otro elemento similar en otro lenguaje.

Comenzaremos definiendo los atributos. Delante de cada uno indicamos el tipo de atributo del que se trata (público, privado o protegido). Si no indicamos nada, el atributo será considerado público (además, es posible que nos lance algún tipo de advertencia el intérprete de PHP).

¿Qué es eso de público, privado y protegido?

  • Público (public): Se puede acceder desde fuera de la clase.
  • Privado (private): Sólo se puede acceder desde dentro de la clase.
  • Protegido (protected): Se puede accede desde dentro de la clase y desde clases herederas.

Como éste es un artículo de introducción a la programación orientada a objetos con PHP no voy a centrarme demasiado en definir estos términos, ni otros relacionados como la herencia o el polimorfismo.

Pasemos a implementar ya la creación de nuestra clase usuario siguiendo el diseño propuesto en el punto anterior.

class Usuario{
	private $id;
	private $nombre;
	private $apellidos;
	private $codigoPostal;
}

Pero si son privados, ¿cómo accedemos a los atributos? La solución es crear métodos, funciones propias de la clase, pública que accedan al atributo.

¿Qué ventajas tenemos con esta metodología? Aunque en este caso el acceso va a ser directo, en casos donde haya que realizar una comprobación, nos aseguramos que los objetos de la clase siempre tienen datos válidos, además de ocultar la implementación interna de la clase, creando una caja negra mucho más útil en grandes proyectos. Por ejemplo, un método “setNIF” en el que antes de igualar el atributo al valor enviado por el usuario, se compruebe si la letra del NIF es válida, y en caso de no serlo, no se almacene el nuevo valor.

Veamos la implementación de esos métodos dentro de la clase.

function getId(){ return $this->id; } function setId($id){ $this->id = $id; } function getNombre(){ return $this->nombre; } function setNombre($nombre){ $this->nombre = $nombre; } function getApellidos(){ return $this->apellidos; } function setApellidos($apellidos){ $this->apellidos = $apellidos; } function getCodigoPostal(){ return $this->codigoPostal; } function setCodigoPostal($codigoPostal){ $this->codigoPostal = $codigoPostal; } read more

Leer más » 4 Comentarios

Curso PHP orientado a objetos – Introducción

Aunque PHP nació como un lenguaje orientado a la programación procedimental, con el tiempo se fue adaptando a las necesidades de los desarrolladores y comenzó a añadir características propias de los lenguajes orientados a objetos.

Esta es la primera entrada de un mini curso de varias entregas en el que trataremos de explicaros cómo usar los mecanismos propios de la orientación a objetos en este lenguaje tan popular del lado del servidor.

Clases, atributos y operaciones

Simplificando mucho, una clase es la representación software de un elemento de la vida real. Si para un determinado problema, que es el que vamos a utilizar, nos importan los usuarios, tendremos la clase “usuario”. La representación software serán los datos y el comportamiento del mismo que nos importe de cara a nuestro sistema. Imaginemos un sencillo sistema de gestión de usuarios que almacene los siguientes datos: read more

Leer más » 2 Comentarios

Instalar PHP GD en Ubuntu

Las librerías GD de PHP son la más completa lista de funciones integradas en un mismo paquete para el procesamiento y tratamiento de imágenes con este lenguaje de programación.

Anteayer fue a echar mano de estas para crear unos thumbnails de unas imágenes dentro de un directorio, más concretamente a través de la función imagecopyresized, pero me di cuenta que no podría hacer uso de esta sin antes instalar el módulo de las funciones GD en PHP.

En mi caso estaba usando una distribución Ubuntu Linux. No debe ser diferente en el resto de distribuciones basadas en Debian. Así, para instalarlo me bastó con abrir un terminal y: read more

Leer más » 2 Comentarios