Ver índice
Clases y objetos (I)

        Ocultar índice  

   Índice de contenidos
   Instalación en Windows
   Instalación en Ubuntu
   Servidores seguros
   Páginas dinámicas
   Sintaxis básica
   Operaciones
   Arrays
   Formatos de presentación
   Operadores
   Bucles
   Extraer y ord. información
   Funciones
   Ficheros externos
   Imágenes dinámicas
   Gestión de directorios
   Cookies y sesiones
   Clases y objetos
   Ficheros en formato PDF
   Bases de datos MySQL
   PHP y XML
   PDO - Bases SQLite / MySQL
   MySQL a traves de misqli
   Algo de JavaScript y AJAX


Clases y objetos

Aunque PHP 5 no es un lenguaje orientado a objetos, sí tiene recursos que permiten definir clases y construir objetos. El modelo de objetos de PHP 5 ha sido reescrito en su práctica totalidad y presenta sustanciales diferencias respecto a las versiones anteriores. El uso de clases y objetos (POOProgramación Orientada a Objetos) no añade ninguna funcionalidad nueva a las posibilidades de PHP. Su verdadera utilidad es la de hacer la programación de otra manera, con un código más legible y reutilizable.

Las clases

Una clase no es otra cosa que una especie de plantilla dentro de la cual se pueden definir una serie de variables llamadas propiedades –que pueden contener valores predefinidos– y un conjunto de funciones denominadas métodos que pueden ser invocadas desde cualquier parte del documento por un objeto o instancia de esa clase.

La sintaxis que permite definir una clase es siguiente:

class nombre {
....
... definición de variables y/o propiedades....
....
.. constructor (opcional)...
....
.. destructor (opcional)...
....
.. definición de métodos o funciones ...
....
}

Vayamos por partes. La palabra reservada class es obligatoria y ha de ir seguida de un nombre mediante el que será identificada la clase. La definición de la clase comienza con un llave de apertura ({) y acaba con una llave de cierre (}). Entre ambas llaves podemos incluir sus variables o propiedades y también sus métodos o funciones.

A las variables o propiedades pueden serles asignados valores, aunque no es imprescindible hacerlo. Los métodos o funciones tienen una sintaxis muy similar a la utilizada en la programación estructurada.

Entre los métodos o funciones susceptibles de ser incluidos en una clase existen dos bastante especiales. Son los llamados constructor y destructor. Ninguno de ellos tiene carácter obligatorio. Su peculiaridad estriba en que se ejecutan de forma automática en determinadas circunstancias. Hablaremos de ellas un poco más adelante.

Definición de las propiedades

Para definir una variable o propiedad en una clase es obligatorio anteponer a su nombre una de estas tres palabras reservadas: public, private o protected. Por compabilidad con versiones anteriores de PHP si se usa la palabra var será interpretada como un alias de public. El nombre de la variable utiliza la sintaxis habitual de PHP y en el caso de que tratemos de asignarle un valor, bastará con poner detrás del nombre el signo = seguido de ese valor que en el caso de ser una cadena tienen que ir entre comillas.

A modo de ejemplo podemos decir que public $pepe="Jose" es una sintaxis válida, pero que $pepe="Jose" no lo es dado que le falta la palabra reservada (opción de visibilidad) que obligatoriamente debe llevar delante de su nombre y que de no ser incluida provocaría un error.

Lo que se conoce como encapsulamiento es uno de los pilares básicos de la Programación Orientada a Objetos. Permite establecer las condiciones y/o restricciones de visibilidad de los diferentes elementos (propiedades y métodos) de una clase. Cuando al definir una variable o propiedad anteponemos a su nombre la palabra public estamos estableciendo ese carácter público de visibilidad que significa que sus valores pueden ser vistos e incluso modificados desde cualquier parte del script en que sean invocadas.

Por el contrario, si establecemos la visibilidad como private (privada) estamos encapsulando la información de forma que sus valores sólo son accesibles a través de métodos o propiedades incluidos en la propia clase. La tercera de las posibilidades, protected (protegida), flexibiliza un poco la condición private al permitir que el método o propiedad sea ser visible desde la propia clase y desde sus clases extendidas (las trataremos un poco más adelante cuando nos refiramos a la herencia).

Funciones o métodos de clase

Los métodos o funciones definidas en las clases que tienen una sintaxis casi idéntica al resto de las funciones PHP

function nombre( ){
... instrucciones....
....
}

Las diferencias más sustanciales respecto a las funciones de la programación estructurada son:

Prestemos mucha atención. El $ va siempre delante de la palabra this y solo se escribe una vez y en esa posición. El nombre de la variable (que va siempre después de -> no lleva el $.

Este es un ejemplo de una clase muy sencilla. Como ves el nombre de la clase es MiClase. Como es lógico, si tratas de ejecutar el ejemplo no obtendrás ningún resultado. Será necesario que un objeto utilice esta clase.

<?php
class MiClase{
    public    $factor1=7; // esta es pública
    private   $factor2=8;  // variable privada
    protected $factor3=3; // variable protegida
    function calcula($a=3,$b=5){ // al no indicar visibilidad será public
        return $this->factor1-$b^2+$this->factor2*$a-$this->factor3;
       }
}
 ?>
ejemplo299.php

Los objetos

Las clases son solo plantillas y sus métodos no serán ejecutados en tanto no exista un objeto que requiera su aplicación. Dicho en forma coloquial, una clase es como una sartén. En tanto no tengamos algo que freir carece de utilidad alguna. Su razón de ser son los objetos susceptibles de se cocinados por ella. Lo mismo ocurre con las clases cuya auténtica razón de ser es servir para la creación y manejo de sus objetos.

Creación y destrucción de objetos

Para crear un nuevo objeto (instancia de la clase) que utilice una clase determinada debemos usar la siguiente sintaxis:

$objeto = new clase

donde objeto es una palabra cualquiera con la que identificar el objeto (como si se tratara de una variable), new es una palabra reservada obligatoria y clase es el nombre de una clase que puede estar escrita en el mismo documento o en un fichero externo. Si la clase está escrita en un documento distinto del que contiene el script que crea el objeto habremos de utilizar include o require para incluirla.

¡Cuidado! Fíjate que por el momento no hemos puesto los () requeridos para invocar las funcionesdetrás del nombre de la clase.

Cuando se trata de eliminar un objeto (liberar el área de memoria que contiene toda la información relativa a este) podemos utilizar la siguiente sintaxis:

$objeto = null
o
unset(objeto )

si bien es cierto que se destruyen de forma automática una vez termina la ejecución del script que los crea y utiliza.

Utilización de los objetos

Una vez creado un objeto ya se podrán utilizar (si su visibilidad lo permite) y modificar sus propiedades y también las funciones o métodos de su clase. Los métodos se invocan mediante la siguiente sintaxis:

$objeto->funcion()
o
$objeto->funcion(p,q)
o
$objeto->funcion(p)

dónde $objeto es el objeto creado en la instrucción anterior, el -> es obligatorio, funcion es el nombre de uno de los métodos o funciones definidos en la clase invocada y donde los () son obligatorios y además –como ocurría en las demás funciones PHP– puede contener valores, variables, etcétera separadas por comas.

Las propiedades (siempre que su visibilidad lo permita) son accesibles mediante:

$objeto->propiedad
o
$objeto->propiedad=valor

En el primer caso estaríamos leyendo el valor de esa propiedad y en el segundo le estaríamos asignando el incluido después del signo igual.

<?php
/* incluimos el fichero que contiene la clase que pretendemos utilizar */
include('ejemplo299.php');
/* creamos un objeto utilizando el nombre exacto de la clase*/
$MiObjeto1=new MiClase; //no lleva paréntesis
/* leeremos los valores de las propiedades */
print "<br />Valor por defecto de la propiedad factor1: ";
/* solo podremos leer desde aquí la propiedad publica factor1
Las propiedades privadas y protegidas solo son accesibles desde la propia clase
y aquí estamos haciendo desde uno objeto que la instancia */
print $MiObjeto1->factor1;
print "<br />Aplicación del método calcula ";
print "<br />No pasamos argumentos. Por tanto calcula con 'a'=3 y 'b'=5: ";
print $MiObjeto1->calcula();
print "<br />Pasamos 15 como argumento por  tanto calcula con 'a'=15 y 'b'=5: ";
print $MiObjeto1->calcula(15);
print "<br />Pasamos 125 y -98 como argumentos por  tanto calcula con 'a'=125 y 'b'=-98: ";
print $MiObjeto1->calcula(125,-98);
/* solo podemos modificar desde aquí la propiedad factor1. Las otras dos por su carácter
  privado y restringido solo podrían ser modificadas desde dentro de la propia clase
  o de una clase extendida */
print "<br />Modificamos el valor de la propiedad factor1: ";
$MiObjeto1->factor1=196;
print$MiObjeto1->factor1;
print "<br />Cálculo con los nuevos valores por defecto: ";
print $MiObjeto1->calcula();
print "<br />Cálculo con nuevos valores por defecto pero asignando a 'a' el valor 25: ";
print $MiObjeto1->calcula(25);
print "<br />Cálculo con nuevos valores por defecto con 'a'=15 y 'b'=-8: ";
print$MiObjeto1->calcula(15,-8);
/* creamos un nuevo objeto y comprobamos que la modificación de la propiedad factor1
no afectará al nuevo objeto (la modificación se hizo en el objeto anterior no en la clase) */
$MiObjeto2=new MiClase;
print "<br />Cálculo con valores por defecto del nuevo objeto: ";
print $MiObjeto2->calcula();
print "<br />Cálculo con valores por defecto del objeto anterior: ";
print $MiObjeto1->calcula();
/* destruimos el primero de los objetos aunque no sea necesario hacerlo.
   Al finalizar el script se destruiría de forma automática */
$MiObjeto1=null;
?>
ejemplo300.php

En este otro ejemplo trataremos de ver el comportamiento de los métodos y propiedades de carácter no público.

<?php
/* crearemos una clase con los diferentes tipos de variables y métodos */
class Coche{
  /* las propiedades han de tener especificada su visibilidad */
  public $potencia="135 C.V.";
  public $tipo_iva="33";
  private $precio="24535 euros";
  protected $modelo="HF345";
  /* un método publico ya que no especificamos visibilidad */
  function precio_final(){
        return (int)($this->precio)*(1+$this->tipo_iva/100);
  }
  /* un método privado al que solo podremos acceder desde la propia clase*/
  private function precio_amigo($descuento=15){
        return $this->precio_final()*(1-$descuento/100);
  }
  /* un metodo publico que nos lleva a otro privado. La funcion siguiente es accesible
     por su condición de pública. Ella puede acceder a las funciones
     privadas de la propia clase. Asi que le pedimos que "se cuele"
     por "la puerta trasera" en el método precio_amigo y nos devuelva el resultado */
  function puerta_trasera($porcentaje){
        return $this->precio_amigo($porcentaje);
        }
  /* un metodo publico que accede a una propiedad privada. No podemos cambiar precios directamente
     porque están en una variable privada. Pero esta función pública si tiene acceso
     a cualquier propiedad o método de su clase. La utilizamos para cambiar el precio */
  function cambia_precios($precio){
        $this->precio=$precio;
        }
}
/*Hasta aquí la clase. Ahora toca instanciar objetos de la clase Coche */
$MiNuevoCoche= new Coche;
/* visualizamos sus propiedades publicas */
print "<br>La potencia es: ".$MiNuevoCoche->potencia;
print "<br>El tipo de IVA es: ".$MiNuevoCoche->tipo_iva;
print "<br>No puedo conocer el modelo. Es una propiedad absurdamente protegida";
print "<br>Tampoco puedo acceder al precio. Es una propiedad privada";
print "<br>Cambio el precio: a 100 euros";
$MiNuevoCoche->cambia_precios('100 euros');
print "<br>Compruebo el precio final: ".$MiNuevoCoche->precio_final(); 
print "<br>El precio de amigo (25% descuento)es: ".$MiNuevoCoche->puerta_trasera(25); 
/* instanciemos un nuevo objeto. Al nuevo cliente no le afectarán las modificaciones anteriores */
$TuNuevoCoche= new Coche;
print "<br>Para el nuevo objeto el precio final: ".$TuNuevoCoche->precio_final(); 

?>
ejemplo298.php

Constructores y destructores

Un constructor es una función que se ejecuta de forma automática cada vez que se instancia un nuevo objeto. Para que PHP considere a una función como tal ha de estar definida en la propia clase y además debe tener por nombre la palabra reservada __construct que tal como puedes ver comienza por «dos guiones bajos».

Cuando está definido, el constructor la instancia del nuevo objeto puede hacerse de una de estas formas:

$objeto=new nombre_clase;

No difiere en nada de la comentada anteriormente. El constructor usuará como valores de las variables que necesite utilizar los definidos en la propia función __construct y/o los valores de la propiedades establecidas en la propia clase.

$objeto=new nombre_clase (valor1, valor2, ...)

En este caso se incluyen, dentro del paréntesis, los valores que deben asignarse a una o varias de las variables que requieran ser utilizadas por la función __construct. Cuando se le pasan valores la función se ejecuta sin tomar en consideración los asignados por defecto y cuando se le pasan sólo parte de esos valores utiliza los valores recibidos y para los no asignados en la llamada utiliza los valores del constructor.

Un destructor es también una función que se ejecuta de forma automática cada vez que se destruye objeto. Esa función ha de estar definida en la propia clase con el nombre __destruct (también comienza por «dos guiones bajos»). Hemos de tener en cuenta que esta función no destruye el objeto. Simplemente se ejecuta cuando se produce esa destrucción. Podríamos decir que es algo así como un timbre de alarma. El timbre no provoca el incendio. Lo único que hace es sonar cuando se produce uno.

Los objetos van a dejar de ser necesarios cuando se finalice la ejecución de un script. Al llegar a ese punto será cuando, de forma autómatica, se libere la memoria usada para contenerlos y como consecuencia de ello se destruyan. Al producirse ese evento (liberación de memoria) será cuando se ejecute la secuencia de instrucciones contenidas en la función __destruct.

También podríamos destruir un objeto en cualquier punto del proceso por medio de $objeto= null o unset($objeto) tal como ya hemos comentado. El objeto $objeto sería eliminado de la memoria y como consecuencia de esa destrucción se ejecutaría de forma automática la función __destruct. Aquí tienes un ejemplo de una clase que incluye un constructor y un destructor.

<?php
class Operador1{
    public    $factor1=7; // esta es pública
    private   $factor2=8;  // variable privada
    protected $factor3=3; // variable protegida
    function __construct($a=0,$b=0){
         print "El constructor de MiObjeto".$a." ha fabricado esta fecha: ";
         print date("j-n-Y",(time()+($this->factor1+$b)*24*3600));
         print "<br />";
    }
    function opera($a=3,$b=46){
        return $this->factor1-$b^2+$this->factor2*$a-$this->factor3;
       }
    function __destruct(){
              print "O se acaba de destruir un objeto o me han llamado (soy __destruct)<br />";
      }
}
 ?>
ejemplo301.php

Si intentas ejecutar el ejemplo anterior no obtendrás ningún resultado. Sólo es una clase. En este otro ejemplo instanciaremos esa clase y crearemos algunos objetos para tratar de comprobar el funcionamiento del constructor y el destructor.

<?php
/* incluimos el fichero que contiene la clase que pretendemos utilizar */
include('ejemplo301.php');
/* creamos vaios objeto utilizando la clase que acabamos de incluir*/
$MiObjeto0=new Operador1; //no lleva paréntesis y no incluye ningun valor
$MiObjeto1=new Operador1(1); //solo lleva el primero de los parámetros del constructor
$MiObjeto2=new Operador1(2,8); //incluye dos parámetros
$MiObjeto3=new Operador1(3,98);
/* llamo a la función destruct que pese a su nombre no destruye nada.
   Se llama así porque se ejecuta automáticamente cuando un objeto deja
   de estar referenciado por una variable y se autodestruye. */
$MiObjeto0->__destruct();
print "El destructor no destruyó. El objeto mantiene sus propiedades Este es factor 1: ";
print $MiObjeto0->factor1."<br />";
print "
Cálculos en MiObjeto1. Empezamos por valores por defecto: "; print $MiObjeto1->opera(); print "<br />Cálculo con valores por defecto pero asignando a 'a' el valor 25: "; print$MiObjeto1->opera(25); print "<br />Cálculo con 'a'=15 y 'b'=-8: "; print$MiObjeto1->opera(15,-8); print "<br />Modificamos el valor de la propiedad factor1 en el objeto 1: "; $MiObjeto1->factor1=196;
/* vamos a destruir MiObjeto2 y comprobaremos como al hacerlo se dispara automaticamente la funcion __destruct */ print "<br>Me van a borrar ahora mismo: "; $MiObjeto2 = null; print $MiObjeto1->factor1; print "<br />Cálculo con los nuevos valores por defecto: "; print $MiObjeto1->opera(); print "<br />Cálculo en MiObjeto3 pero asignando a 'a' el valor 25 al objeto 3: "; print $MiObjeto3->opera(25); print "<br />Cálculo con nuevos valores por defecto con 'a'=15 y 'b'=-8 al objeto 4: "; print $MiObjeto3->opera(15,-8); print "<br />Vamos a acabar el script. Lo objetos se autodestruirán y aparecerán los mensajes alusivos a eso.<br />"; print "Quedan tres objetos y tres autodestrucciones. Cada una de ellas disparará la función __destruct<br />"; ?>
ejemplo302.php

Clases extendidas y clases finales

La herencia es otra de las razones de ser de la Programación Orientada a Objetos. En PHP también tenemos la posibilidad de crear clases extendidas o clases derivadas de una clase padre. Su característica más importante es que pueden heredar todas las propiedades y métodos de esta y, además, tienen la posibilidad de agregar otros nuevos y/o modificar o redefinir los heredados (polimorfismo).

Sintaxis de las clases extendidas

Para definir una clase clases extendida se requiere la siguiente sintaxis:

class hija extends padre {
....
... definición o redefinición de variables (opcional)....
....
.. constructores (opcional)...
....
.. definición o redefinición de funciones (opcional)...
....
}

dónde hija es el nombre de la nueva clase (la extendida), padre es el nombre de la clase padre y extends es la palabra reservada que indica a PHP que se trata de una clase extendida.

Se puede impedir que una clase pueda extenderse. Para ello basta con anteponer a la palabra class la palabra final. Si escribimos:

final class nieta extends hija {.....}

estaremos imposibilitando que puedan definirse clases extendidas de la clase nieta. Las restricciones de PHP 5 en lo relacionado con las herencias son las que puedes ver en este gráfico:

Este es un ejemplo de clase extendida de una de las anteriores. Si intentas ejecutar el script te dará un mensaje de error advirtiendo de que no encuentra la clase padre. En este caso es irrelevante dado que el documento solo tiene la finalidad de escribir la clase extendida.

<?php
/* esta clase no podra ser extendida y es hija de la llamada Operador1.
    Heredará de ella sus métodos y sus propiedades. Podrá modificarlos
    y también incluir los propios */
final class Operador2 extends Operador1{
    /* modificamos esta propiedad cambiando su valor */
    public    $factor1=297; // esta es pública
    /* añadimos una nueva propiedad */
     public    $factor4=-67;
    /* Este es el constructor de la clase extendida. Sustituiría al de la clase padre */
        function __construct(){
         print "Soy el constructor extendido y punto.<br>";
            }
    /* redefinimos la función opera. Dará otros resultados */
    function opera($a=3,$b=46){
      /* utilizaremos solo factor1 y factor3 porque son los únicos visibles
      desde esta clase. factor1 por su condición de público y factor3 porque su
      condición de protegido le hace también visible desde la clase extendida */
        return $this->factor1-$a^2+$this->factor3*$b+$this->factor3;
       }
    /* omitimos la función __destruct pero podremos usar la definida en la clase padre */
    function nueva(){
              print "Soy el resultado de una nueva función. <br />";
      }
}
 ?>
ejemplo303.php

Aquí tienes un ejemplo de utilización de algunas de las posibilidades de la clase extendida anterior. Ahora ya incluimos ambas clases (padre y extendida) y no tendremos mensajes de error al ejecutar el script.

<?php
/* hemos de incluir los ficheros que contienen ambas clases */
include('ejemplo301.php');
include('ejemplo303.php');
/* crearemos un objeto instanciando la clase padre y otro instanciando la extendida*/
$Objeto_de_clase_padre=new Operador1;
/* este primer objeto no va a tomar en cuenta nada de lo contenido en la clase extendida*/
$Objeto_de_clase_extendida=new Operador2;
/*este segundo objeto ya va a utilizar el constructor de la clase extendida.
Al ejecutar el script podrán verse las diferencias */
print "<br>Este el valor del factor1 en el objeto creado a partir de la clase padre: ";
print $Objeto_de_clase_padre->factor1;
print "<br>Este el valor del factor1 en el objeto creado a partir de la clase extendida: ";
print $Objeto_de_clase_extendida->factor1;
/* la función (método) nueva solamente puede ser usada en objetos creados
mediante la clase extendida ya que para la clase padre no está definida. */
print "<br>Soy el resultado de la funcion nueva() aplicada al objeto de la clase extendida: ";
$Objeto_de_clase_extendida->nueva();
/* la función (método) opera es distinta según el objeto pertenezca a una u otra clase. */
print "<br>Soy el resultado de la funcion opera() aplicada al objeto de la clase padre: ";
print $Objeto_de_clase_padre->opera();
print "<br>Soy el resultado de la funcion opera() aplicada al objeto de la clase extendida: ";
print $Objeto_de_clase_extendida->opera();
print "<br>Esta es la última instrucción del script. Lo que leas de aquí en adelante ";
print "será obra de los destructores que se activarán al destruirse los dos objetos<br>";
?>
ejemplo304.php

Bibliotecas de clases

Una de las ventajas más importantes de las clases es la posibilidad de reutilización de sus scripts tanto si se trata de rutinas propias o de desarrollos de terceros. Bastaría con disponer del fichero que contiene la clase correspondiente conocer sus métodos públicos (los únicos accesibles de la forma que lo hemos hecho en los ejemplos anteriores) y utilizarlos con la sintaxis que hemos venido usando en los ejemplos anteriores.

Existen algunos sitios en la red en los que pueden obtener una gran cantidad de materiales de este tipo. Uno de los más populares puedes encontrarlo en la dirección: phpclasses.org. Además existen otros sitios dónde se pueden obtener algunas clases muy interesantes.

Cuando tratemos lo relativo a ficheros en formato PDF veremos el enorme abanico de posibilidades que nos ofrece la clase TCPDF. Por el momento, para intentar ilustrar un poco la utilización de clases de terceros, incluimos un ejemplo que permite el envío de mensajes de correo con ficheros adjuntos (similares a los que hemos podido ver al tratar el tema de mensajes de correo) utilizando la clase phpmailer.

Pese a que el enlace de descarga incluye abundante material y documentación solo hemos extraido de él los dos ficheros que necesitamos para el ejemplo: class.phpmailer.php y class.smtp.php que podemos utilizar de la siguiente forma:

<?php
/* evito con esta opción init_set evitamos queaparezca un mensaje de advertencia
   relativo a una función utilizada en la clase y que está deprecated */
ini_set('display_errors','Off');
/* incluimos el fichero que contiene la clase llamada PHPMailer */
require("class.phpmailer.php");
/* creamos un nuevo objeto (mi_mensaje) instanciando la clase PHPMailer*/
$mi_mensaje = new PHPMailer();
$mi_mensaje->IsSMTP(); // este metodo publico especifica el tipo de servidor a utilizar (SMTP)

/* asignamos valores a una serie de propiedades (variables) de la clase */
$mi_mensaje->Host = "127.0.0.1"; //modificamos la propiedad Host asignandole la IP del servidor
$mi_mensaje->From = "juan@mispruebas.as";  // Correo del remitente asignado a al propiedad From
$mi_mensaje->FromName = "Juan Mis Pruebas";  // nombre del remitente a la propiedad FromName
$mi_mensaje->AddAddress("perico@mispruebas.as", "Perico Mis Pruebas"); // un destinatario
$mi_mensaje->AddAddress("andres@mispruebas.as"); // otro destinatario el nombre es opcional
$mi_mensaje->AddReplyTo("juan@mispruebas.as", "Juan Mis Pruebas"); //dirección de respuesta
$mi_mensaje->WordWrap = 50; // longitud de la línea del mensaje
$mi_mensaje->Subject = "Prueba con adjuntos usando la clase phpmailer"; //Asunto
$mi_mensaje->Body = "Este es un mensaje de prueba con ficheros adjuntos
                             que usa la clase phpmailer"; //cuerpo
$mi_mensaje->AltBody = "Este es un mensaje de prueba con ficheros adjuntos
                     que usa la clase phpmailer";  //cuerpo cuando no utiliza HTML

/* aplicamos al objeto los métodos (funciones) de la clase necesarios para nuestro propósito */

$mi_mensaje->IsHTML(true); // enviar mensaje con formato html
$mi_mensaje->AddAttachment("apachito.zip"); // añadir adjunto
$mi_mensaje->AddAttachment("casa08.jpg", "leocadio.jpg"); // adjunto con nombre
/* aplicamos al objeto el método Send  y comprobamos si tod se ha realizado correctamente */
    if(!$mi_mensaje->Send()){
            echo "El mensaje no ha podido enviarse. <br />";
            echo "Error al enviar el mensaje: " . $mi_mensaje->ErrorInfo;
            exit;
    }else{
            echo "El mensaje ha sido enviado";
    }
?>
  ¡Cuidado!  

No olvides que para ejecutar este script es imprescindible que tengas activo tu servidor de correo.

Como habrás podido ver, la única dificultad que nos plantea el uso de esta clase es conocer los métodos y propiedades que incluye y la utilidad de los mismos. Ese tipo de información suele venir incluida como comentarios dentro de la propia clase y/o en la documentación relativa a la misma.

Uso de la clase phpmailer mediante el SMTP de gmail

Para enviar mensajes de correo externos utilizando el SMTP de Gmail sólo es necesario disponer de una cuenta de usuario en Gmail y agregar o sustituir en el script del ejemplo anterior lo siguiente:

$mi_mensaje->Host = 'ssl://smtp.gmail.com';
$mi_mensaje->Port = 465;
$mi_mensaje->SMTPAuth = true;
$mi_mensaje->Username = '
direccion_completa_de_la_cuenta_de_gmail';
$mi_mensaje->Password = '
contraseña_de_la_cuenta_de_gmail';
$mi_mensaje->From = '
direccion_completa_de_la_cuenta_de_gmail';

Como es obvio, además de tener en marcha el servidor Apache en modo local es preciso que nuestro equipo disponga de acceso a Internet.