Objetos en Perl  F. Javier García Castellano Web: http://genura.ugr.es/~javi, Mail: javi@geneura.ugr.es

(C) GeNeura Team Web: http://geneura.ugr.es, Mail: todos@geneura.ugr.es

1.- Uso de Clases y Objetos

Hasta ahora no lo hemos visto, pero Perl también soporta la Programación Orientada a Objetos (POO). Empezando por el principio, una clase es una colección de variables y de funciones que acceden a esas variables. Un objeto es una instanciación particular de una clase.

En Perl, casi todos los módulos son, en realidad, objetos. Veamos un ejemplo de uso de un objeto.

Ejemplo de uso de la clase persona:

  #!/usr/bin/perl

  #Usamos el módulo/clase Persona
  use Persona;

  #Creamos un objeto del tipo persona
  $uno= Persona->new();

  #Vamos a darle un nombre a ese objeto, usando el método nombre
  $uno->nombre("Richal");

  #También vamos a darle una edad, usando el método edad
  $uno->edad(23);

  #Mostramos la edad y el nombre
  print $uno->nombre." tiene ".$uno->edad. " años \n";

  #¿Y si hoy fuera su cumpleaños?
  $uno->cumple;

  #Mostramos la edad y el nombre
  print $uno->nombre." acaba de cumplir ".$uno->edad. " años \n";

En el ejemplo anterior, tenemos la clase Persona y para crear un objeto de este tipo de clase ($uno) se utiliza el método new, o sea, se usa el constructor de la clase. Posteriormente se han utilizado tres métodos de la clase (nombre, edad y cumple) que nos muestran/modifican la edad y el nombre de la clase Persona.

En el siguiente ejemplo se utiliza la clase XML::XSLT (un módulo de Perl) para aplicar una hoja XSL a un documento XML

Ejemplo de aplicación de una hoja XSL a un documento XML:

#!/usr/bin/perl

#Uso la libreria para aplica XSLT a XML (clase XML/XSLT)
use XML::XSLT;

#Ficheros con los que vamos a trabajar
my $ficheroXML = "ejemplo.xml";
my $ficheroXSL = "ejemplo.xsl";


#Leemos el fichero XML
open ( IN, "<$ficheroXML" ) || die "\n No puedo abrir el fichero XML:$ficheroXML\n";
my $miXML = join("", <IN> );
close IN;

#Creamos un objeto XSLT (llamamos al constructor)
$miXSL = XML::XSLT->new ("$ficheroXSL", warnings => 1) || die "\n No puedo abrir el fichero XSL:$ficheroXSL\n";

#Aplicamos la XSL al XML (usamos el método transform)
$miXSL->transform ($miXML);

#Lo pasamos a una cadena (usamos el método toString)
$salida=$miXSL->toString;

#Lo mostramos por pantalla
print $salida;

#Liberamos la memoria ocupada por la XSL 
$miXSL->dispose ();

2.- Como hacer nuestra propia clase

Lo primero, para construir nuestra propia clase, será darle un nombre. Dicho nombre también será el nombre del fichero (más la extensión .pm -de perl module-) donde tendremos la clase. Después tendremos que empezar la clase con:

Encabezado de la clase Persona (fichero Persona.pm)

  package Persona;
  use strict; #Nos ponemos serios

la primera línea, sirve para indicar, que es una clase lo que estamos creando, y la segunda línea nos dice que tenemos que ser estrictos a la hora de programar, es decir, que hay que declarar las variables antes de usarlas, como en casi todos los lenguajes de programación.

2.1- Constructor

Después tenemos que programar el constructor, que podemos llamar como nos apetezca, pero por convención se utiliza el nombre new. En el contructor, primero miramos la clase que es,

sub new {
    my $this=shift; #Cogemos la clase que somos o una referencia a la clase (si soy un objeto)
    my $class = ref($this) || $this; #Averiguo la clase a la que pertenezco
    ....
}

Una vez que sabemos la clase que estamos contruyendo, declaramos las propiedades (variables de instancia) de la clase,

sub new {
     ....
     my $self={}; #Inicializamos la tabla hash que contendrá las var. de instancia (NOMBRE Y EDAD)
     $self ->{NOMBRE} =undef ; #La clase Persona nace sin nombre  
     $self ->{EDAD}   =0 ;     #La clase Persona se construye con 0 años
     ....
}

Una vez averiguada la clase que somos y declaradas las variables de instancia, Perl no tiene que dar el visto bueno a la clase (bendecirla) y al final, del constructor, devolvemos la clase creada.

sub new {
     ....
     bless $self, $class; #Perl nos tiene que dar el visto bueno (bendecirla)
     return ($self); #Devolvemos la clase recién construida
  }

De esta forma el contructor nos queda como sigue:

sub new {
    my $this=shift; #Cogemos la clase que somos o una referencia a la clase (si soy un objeto)
    my $class = ref($this) || $this; #Averiguo la clase a la que pertenezco

    my $self={}; #Inicializamos la tabla hash que contendrá las var. de instancia (NOMBRE Y EDAD)
    $self ->{NOMBRE} =undef ; #La clase Persona nace sin nombre  
    $self ->{EDAD}   =0 ;     #La clase Persona se construye con 0 años

    bless $self, $class; #Perl nos tiene que dar el visto bueno (bendecirla)
    return ($self); #Devolvemos la clase recién construida
  }

2.2- Métodos de la clase y destructor

También tendremos que construir nuestros métodos para la clase. Para ello sólo tenemos que tener en cuenta que un método de una clase es simplemente una función (o subrutina) que toma como primer parámetro el tipo de clase a la que pertenece el método.

Podemos hacer el destructor (no obligatorio), que es un método, análogo a los anteriores, pero con la única diferencia en que se debe llamar DESTROY

Para terminar ponemos un 1; esto es así para que Perl pueda interpretar la clase de forma independiente y con esto no hace nada, es "sólo" un script que devuelve 1.

2.1- Clase Persona (ejemplo)

Como resultado ya tenemos nuestra propia clase.

Clase Persona (fichero Persona.pm)

  package Persona;
  use strict; #Nos ponemos serios


  ######################################################################
  #Constructor de la clase
  #

  sub new {
     my $this=shift; #Cogemos la clase que somos o una referencia a la clase (si soy un objeto)
     my $class = ref($this) || $this; #Averiguo la clase a la que pertenezco

     my $self={}; #Inicializamos la tabla hash que contendrá las var. de instancia (NOMBRE Y EDAD)
     $self ->{NOMBRE} =undef ; #La clase Persona nace sin nombre  
     $self ->{EDAD}   =0 ;     #La clase Persona se construye con 0 años

     bless $self, $class; #Perl nos tiene que dar el visto bueno (bendecirla)
     return ($self); #Devolvemos la clase recién construida
  }
  
  ######################################################################
  #Métodos de acceso a los datos de la clase
  #

  #metodo para ver/cambiar el nombre
  sub nombre{
       my $self=shift; #El primer parámetro de un metodo es la  clase
 
       #Miramos si se le ha pasado algún parámetro, en cuyo caso será el nombre
       $self->{NOMBRE}=shift if (@_);

       #Devolvemos el nombre
       return $self->{NOMBRE};
  }

  #metodo para ver/cambiar la edad
  sub edad{
       my $self=shift; #El primer parámetro de un metodo es la  clase
 
       #Miramos si se le ha pasado algún parámetro, en cuyo caso será la edad
       $self->{EDAD}=shift if (@_);

       #Devolvemos el nombre
       return $self->{EDAD};
  }

  ######################################################################
  #Métodos de la clase
  #

  #metodo para cumplir años
  sub cumple{
       my $self=shift; #El primer parámetro de un metodo es la  clase
 
       #Incrementamos la edad
       $self->{EDAD}++;

       #Devolvemos el nombre
       return $self->{EDAD};
  }


  ######################################################################
  #Destructor
  #

  sub DESTROY {
        my $self=shift; #El primer parámetro de un metodo es la  clase
        delete ($self->{NOMBRE});  
        delete ($self->{EDAD});  
  }

  #Fin
  1;

3. Ejercicios

Ejercicio: Construye tu propia clase (Alumno), para guardar datos de alumnos y notas. Haz también un programa que pruebe la clase.