Tutorial de Introduccin a Perl

Versin: 1.2, Julio, 2002

Autores: F. Javier Garca Castellano, Pedro Angel Castillo Valdivieso, Juan Julin Melero Guervs
Web: http://genura.ugr.es/~javi, Mail: javi@geneura.ugr.es

(C) GeNeura Team

Web: http://geneura.ugr.es, Mail: tutti@geneura.ugr.es

Introduccin
Qu es y qu herramientas vamos a usar
En este tutorial veremos los fundamentos para escribir programas con el lenguaje Perl (Practical Extraction Report Language). Perl es un lenguaje de script (o de guiones), lo que quiere decir que no hace falta un fichero binario para poder ejecutar las instrucciones que hemos codificado usando este lenguaje, es decir, es interpretado, aunque el intrprete de Perl "compila" los programas antes de ejecutarlos. Perl tiene caractersticas de muchos lenguajes de programacin (buscando lo mejor de cada uno), pero al que ms se parece es al C. Con Perl podemos programar casi de todo (hay libreras/mdulos para casi cualquier cosa que queramos), pero hay aplicaciones que requieren mucha rapidez en las cuales es mejor utilizar otros lenguajes que no sean interpretados (la ejecucin a travs del intrprete introduce retardos). Perl es un lenguaje que permite programar de forma muy rpida y es excelente para el tratamiento de cadenas. En sus comienzos fue un lenguaje restringido a sistemas UNIX, pero hoy en da existen versiones del intrprete de Perl para casi todos los sistemas. Para trabajar con Perl slo nos va a hacer falta:

Un editor para poder escribir los programas Perl, por ejemplo, el notepad en windows y el xemacs en Linux El intrprete de Perl, que ejecute nuestros programas realizados con Perl.

ndice
1. Introduccin a Perl 1. Introduccin 2. Instalacin de Perl 3. Separacin de instrucciones y comentarios 2. Clases de datos y operadores en Perl 1. Datos Escalares 2. Arrays

3.

4.

5.

6.

3. Arrays Asociativos 4. Ejercicios Estructuras de control y funciones 1. Estructuras de control de flujo 2. Funciones 3. Ejercicios Perl un poco ms a fondo 1. Entradas y salidas 2. Expresiones regulares 3. Funciones split y join 4. Mdulos 5. Ejercicios Objetos en Perl 1. Uso de clases y objetos 2. Como hacer nuestra propia clase 3. Ejercicios Ayuda, enlaces y sitios de referencia. 1. Ayuda de Perl 2. Enlaces y sitios de referencia

Introduccin a Perl
1.- Introduccin
Perl fue creado por Larry Wall para simplificar tareas de administracin de un sistema Unix, aunque hoy en da se ha convertido en una de las mejores herramientas para creacin de scripts o de construccin de sitios Web. Perl es un lenguaje rpido pese a ser interpretado, multiplataforma y dispone de una gran cantidad de bibliotecas para el desarrollo de casi cualquier tipo de aplicacin. Es software libre, no hay que pagarlo. El ejemplo ms sencillo de un programa en Perl, sera en Linux: Programa simple en Linux:
#!/bin/perl print "Hola Mundo\n";

Si estamos en windows sera: Programa simple en Windows:

#!c:/perl/bin/perl.exe print "Hola Mundo\n";

o incluso, si somos amantes del C, podra ser:

printf ("Hola Mundo\n");

Ahora, cogemos el anterior programa y lo guardamos en un fichero con extensin .pl que es la extensin de los scripts en Perl. Para ejecutarlo, basta con llamarlo por su nombre (si se tiene los permisos de ejecucin adecuados):
./hola.pl

Como se puede deducir, con la primera lnea indicamos donde est el intrprete de Perl, despus de #!. Esto no hara falta si, al ejecutar el script, lo hacemos usando el intrprete. Por ejemplo:
/usr/bin/perl hola.pl

o
c:\perl\bin\perl.exe hola.pl

Tambin se puede imaginar que con la segunda lnea se escribe el mensaje Hola Mundo.

2.- Instalacin de Perl

Como es lgico, antes de empezar a ponernos a escribir programas de Perl como locos es necesario instalar o tener instalado el intrprete de Perl. Lo podemos encontrar en las siguientes direcciones:

En www.perl.com que es un buen sitio de referencia para empezar con Perl.

En el CPAN que el sitio ms completo de recursos de Perl En ActiveState si lo que usamos es Windows en sus diferentes variantes

2.1.- Instalacin de Perl en Linux

Hoy en da todas las distribuciones incluyen casi de serie un intrprete de Perl, es decir, el intrprete de Perl se instala casi por defecto (muy mnima debera ser las instalacin para que no se incluyera o quitarlo a propsito). Debido a la caracterstica que antes apuntabmos de su utilidad para realizar tareas de administracin del sistema. Para instalar Perl (o instalar una versin actualizada), lo primero que hay que decidir es si instalar una versin compilada (binaria) o compilar nosotros mismos. Ambas cosas (fuentes o binarios) se pueden encontrar en www.cpan.org para multitud de Sistemas Unix ( y otros no Unix). Si te bajas una versin compilada y especfica para tu sistema, simplemente ejecutas el binario que te bajes (descomprimindolo si estuviera comprimido) o instlandolo con rpm -Uhv perl_compilado.rpm si es un fichero rpm. El nico problema que te puedes encontrar es que te haga falta alguna librera, y ah es donde se complican las cosas, tambin tendrs que instalarla.

Si optas por bajarte el cdigo fuente agrupado en un fichero tar.gz (o .tgz), lo primero que tienes que hacer es descomprimirlo. Con:
tar xvfz perl_codigofuente.tar.gz

o si tiene extensin .tar.bz2 con:

tar xvfj perl_codigofuente.tar.bz2

y si tu sistema es un poco viejo con:

tar xvfI perl_codigofuente.tar.bz2

Si por casualidad tuviese la extensin .Z. Se tendra que hacer en dos pasos:
gzip -d perl_codigofuente.tar.Z tar xvf perl_codigofuente.tar

Una vez descomprimidos el cdigo fuente de Perl, lo aconsejable es leer los ficheros README e INSTALL, por lo que pudiera pasar o por lo que nos pudiera faltar. Una vez llegados a este lo pasos a seguir son los mismos que compilar casi cualquier aplicacin en Linux:
./configure make make install

Con lo anterior, primero, se configura (si puede) para nuestro sistema, segundo, se compila el cdigo del intrprete y, tercero, se instala.
2.2.- Instalacin de Perl en Windows

Para instalar Perl en Windows hay tambin dos opciones, la primera, que es la ms aconsejable, es obtener la ltima versin de Active Perl, que es la versin de Perl para Windows compilada por la compaa ActiveState. Para instalar esta versin, slo nos hace falta el Microsoft Installer, y una parche de las DCOM para windows 95, si ese es el sistema "operativo" que utilizamos. La otra opcin (menos recomendable) que tenemos es bajarnos el cdigo fuente de www.cpan.org, descomprimirla (hay versiones del tar, del gzip para windows en el CPAN) y compilarla. Para compilar el cdigo fuente, hace falta el Microsoft Visual C++ o Mingw32 con EGCS o GCC. Tambin nos har falta una utilidad make. MS Visual C++ viene con nmake, aunque tambin se puede usar dmake (una versin compilada con Mingw32). Se aconseja leer el fichero README.win32 (sobre todo si usas Mingw32). Una vez que se cumplen todos los requisitos, los pasos son:
nmake nmake test nmake install

Hay que tener en cuenta que la versin de Perl para Windows 95 la funcionalidad no es completa en algunos mdulos (en el resto de sabores de windows va bien: 98,Me,NT200,XP).

3.- Separacin de instrucciones y comentarios

3.1.- Separacin de intrucciones

Como podemos ver en el programa de ejemplo aunque tenga una sla instruccin, para separar las instrucciones, como en la mayora de los lenguajes de programacin se utiliza el punto y coma (;). Esto que nos puede parecer obvio ser la fuente de las mayora de los errores que tengamos en nuestros programas en perl. Tiempo al tiempo.
3.2.- Comentarios

Los comentarios en Perl sa hacen con el carcter de sostenido (#) y ocupan el resto de la lnea a partir de dicho carcter. A diferencia de otros lenguaje no se utilizan comentarios multilnea. Si el comentario aparece en la primera lnea (sin espacios) del programa seguido con el signo de admiracin(#!), despus tendremos que poner el PATH al intrprete de Perl. Como hemos visto en nuestro primer ejemplo para Linux y Windows.

Clases de datos y operadores en Perl

1.- Datos escalares
Los datos escalares son las variables simples y pueden contener enteros, reales, cadenas o referencias. Este tipo de variables van precedido siempre por $. Esta es una de las mayores diferencias con lenguajes como el C y es que a cualquier variable escalar se le antepone dicho signo ($). La forma de nombrar las variables tambin es similar, se puede usar letras nmeros y _ empezando siempre por una letra. En Perl las variables no se tienen porque declarar, aunque se declaran con my. Adems la interpretacin del tipo de variable se hace en funcin del contenido, aunque todas la variables numricas internamente se tratan como reales. Programilla con variables:
#!/usr/bin/perl #Declaro una variable my $hola; #Asigno valores $hola="Hola Mundo\n"; $adios="adios\n"; #Escribimos un poco en pantalla

print $hola; $hola=23; print "Mira un nmero: $hola \n"; print "Y $adios";

Como podemos ver en el anterior ejemplo las cadenas se encierran entre comillas dobles (" "), aunque tambin se pueden cerrar entre comillas simples (' '). Hay caracteres especiales (retorno de carro, tabulador, etc.) que como en muchos otros lenguajes se presentan mediante la barra de escape:

\n retorno de carro a una nueva lnea \b retorno a la posicin anterior \a pitido \t tabulacin (8 espacios) \\ el caracter \ \" las comillas dobles (aunque si la cadena est delimita por comillas simples, no hace falta) \' las comillas simples (aunque si la cadena est delimita por comillas dobles, no hace falta)

Operadores de datos escalares

El operador de asignacin se utiliza, igual que en C, el smbolo =, como se puede obervar en el primer ejemplo de la pgina. Tambin se pueden mezclar operadores arimticos junto con la asignacin. Asignacin y operadores aritmticos:
#!/usr/bin/perl #Asigno valores a variables my $uno=123.67; $dos=123123.2334; $suma=$uno; $suma+=$dos; #Escribimos resultados en pantalla print "La suma de $uno y $dos es = $suma \n";

Los operadores de comparacin, son similares a los de C, pero depende si estamos comparando cadenas o datos numricos. Los operadores para nmeros y para cadenas son:
Comparacin igual no igual menor que Nmeros Cadenas == != < eq ne lt

mayor que

>

gt le ge

menor o igual que <= mayor o igual que >=

En Perl tambin tenemos los operadores de autoincremento (++)y autodecremento (--). Y adems tenemos el operador potencia **(que es muy parecido aunque muy diferente) Autoincremento y potencia:
#!/usr/bin/perl #Asigno valores a variables my $contador=0; #Escribimos en pantalla print "Se contar:", $contador++ , ", ", $contador ++,"...\n"; print "2 elevado a $contador es:", (2**$contador), "\n";

Para concatenar cadenas tenemos el operador punto (.) y la funcin chop para quitar el ltimo caracter a una cadena. Concatenar y chop:
#!/usr/bin/perl #Asigno valores a variables my $cad1="Hola"; my $cad2="Mundo"; my $cad3=$cad1." ".$cad2; #Metemos una nueva lnea y un caracter raro en $cad3 $cad3=$cad3."\n="; #Y le quitamos el caracter raro chop($cad3); #Escribimos en pantalla print $cad3;

2.- Arrays
Un Array en Perl es como los de C, pero con la diferencia de que van precedidos del smbolo arroba @. (como las variables de $). La forma de acceder a ellos es mediante la indexacin, contando desde cero. En Perl no nos tenemos que preocupar de reservar la memoria ni gestionarla de ninguna forma. Hay que tener en cuenta que cuando se accede a un elemento de un array, ya no se est haciendo referencia a un array sino a un dato escalar, por lo que debe ir precedido del smbolo $. Vamos a verlo con un ejemplo: Ejemplo de Arrays:

#!/usr/bin/perl #Declaramos la variable primer_array como un array my @primer_array; #asignamos unos cuatro valores al array @primer_array=(1,"dos",3,"cuatro"); #Aadimos un quinto de forma individual $primer_array[4]=5.5; #Mostramos el tercer elemento del array print "El tercero es= ".$primer_array[3]." \n";

Para sacar/insertar elementos se pueden usar las funciones pop y push. Que sacan o insertan, respectivamente, un elemento al final, es decir, tratan el array como una pila. Tambin podemos utilizar shift y unshift para sacar o insertar, respectivamente, un elemnto del principio del array. Para ver el tamao (nmero de elementos) de un array se utiliza el smbolo de sostenido (#) entre el smbolo $ y el nombre del array, es decir, con $#array. Este tamao nos lo da contando desde 0 o, lo que es lo mismo, realmente nos da el ltimo ndice que existe en el array. Si el array no tuviese ningn elemento, su tamao sera -1. Ejemplo de pop/push, shift/unshift, y tamao del array:
#!/usr/bin/perl #asignamos unos cuatro valores al array @matriz=(1,"dos",3,"cuatro"); #Aadimos con Push push(@matriz, 5, 6, "siete"); #Mostramos el ltimo elemento print "El ltimo es ". $matriz[$#matriz]."\n"; #sacamos con Pop $uno=pop(@matriz); print "He sacado $uno\n"; #Aadimos con unshift unshift(@matriz, "cero", -1 ); #Mostramos el primer elemento print "El primero es ". $matriz[0]."\n"; #sacamos con shift $uno=shift(@matriz); print "He sacado $uno\n"; print "La matriz tiene ".$#matriz." elementos\n";

En todo script de Perl existe el array @ARGV que contiene los parmetros de entrada.

Para aadir dimensiones a los arrays, simplemente se aaden corchetes. Como en el siguiente ejemplo: Ejemplo arrays con ms de una dimensin
#!/usr/bin/perl my @array3D=([],[],[]); $array2D[0][0]=0; $array2D[0][1]=1; $array2D[1][0]=2; $array2D[1][1]=3; $array3D[0][0][0]=20; print $array2D[1][1]." ".$array3D[0][0][0]."\n";

3.- Arrays asociativos

Un array asociativo en Perl o tabla hash (como tambin se le denomina) es un array donde los elementos son referenciados mediante claves en vez de una posicin. Para los array asociativos se utiliza el smbolo %. Al igual que sucede con los arrays normales, cuando se accede a un elemento de un array asociativo se debe referenciar como un escalar con el smbolo $. Adems la indexacin por clave no se hace utilizando los corchetes, sino que se utilizan las llaves ({ }). Ejemplo de utilizacin de arrays asocitivos:
#!/usr/bin/perl #asignamos valores a una tabla hash my %colorfruta; $colorfruta{"verde"}="kiwi"; $colorfruta{"amarillo"}="platano"; $colorfruta{"rojo"}="sanda"; $colorfruta{"naranja"}="naranja"; print "Una fruta verde es: ".$colorfruta{"verde"}."\n";

%dias=("lunes",L,"martes",M,"miercoles",X,"jueves",J,"viernes",V,"saba do",S,"domingo",D); print "La representacin del Martes es :". $dias{"martes"}." \n";

La asociacin tambin se puede hacer con =>, por ejemplo:

%semana=("Lunes"=> "L", "Martes" => "M");

La funcin keys devuelve un array con las claves de un array asocitivo. La funcin values devuelve un array con los valores de un array asocitivo. Con exits($hash{clave}) podemos ver si una clave existe o no. Con delete($hash{clave}) se elimina un elemento de un array asocitivo.

4. Ejercicios
Ejercicio: Coge el primer ejemplo de esta pgina (Programilla con variables) y cambia las cadenas que aparecen, de forma que se usen las comillas simples, en lugar de las comillas dobles. Qu diferencia hay?. Ejercicio: Compara dos enteros y dos cadenas y guarda el resultado en variables. Muestralas por pantalla. Qu sale cuando son iguales?, Y cuando son diferentes?. Ejercicio: Cuenta los parmetros de un script en Perl y muestralo por pantalla. Muestra tambin el primer y ltimo parmetro del script. Ejercicio: Inicializa un array asociativo y muestra la segunda clave. (Nota: Usa la funcin keys).

Estructuras de control y Funciones

1.- Estructuras de control de flujo

Perl mantiene todas las estructuras de control de flujo que pueda tener cualquier otro lenguaje, pero con la peculariedad de que un bloque siempre debe ir entre llaves ({ }), aun cuando el bloque contenga un nica sentencia. Un resumen general de las estrucuturas de control de flujo es:

if (EXPR) BLOQUE if (EXPR) BLOQUE else BLOQUE if (EXPR) BLOQUE elsif (EXPR) BLOQUE else BLOQUE SENTENCIA if (EXPR); unless (EXPR) BLOQUE unless (EXPR) BLOQUE else BLOQUE unless (EXPR) BLOQUE elsif (EXPR) BLOQUE else BLOQUE SENTENCIA unless (EXPR); while (EXPR) BLOQUE SENTENCIA while (EXPR); until (EXPR) BLOQUE SENTENCIA until (EXPR); do BLOQUE while (EXPR); do BLOQUE until (EXPR); for (EXPR;EXPR;EXPR) BLOQUE foreach $var (Array) BLOQUE

Donde EXPR es una expresin, BLOQUE es una sentecia o conjunto de estas encerrado entre llaves y SENTENCIA es una sola sentencia

Ejemplos de esctructuras de control:

#!/usr/bin/perl for ($i=0; $i < 20; $i++) { $matriz[$i]="Elemento $i"; } print "El ltimo es $matriz[$#matriz]\n" if ($#matriz==19); print "El ltimo: $matriz[$#matriz]\n" unless ($#matriz!=19); $i=0; while ($matriz[$i] ne "Elemento 5") { print "Buscando \"Elemento 5\" y encontrado $matriz[$i]\n"; $i++; } if ($i==5) { print 'La variable $i es 5'."\n"; } else { print 'La variable $i no es 5'."\n"; } #Vamos a mostrar los elementos del array foreach $elemento (@matriz) { print "$elemento\n"; } #Creamos una tabla hash %dias=("lunes",L,"martes",M,"miercoles",X,"jueves",J,"viernes",V,"saba do",S,"domingo",D); #Y mostramos sus claves foreach $clave (keys(%dias)) { print "\%dias{".$clave."}=".$dias{$clave}."\n"; }

2.- Funciones
En Perl tambin se pueden definir funciones (o subrutinas para los ms puristas), utilizando la siguiente sintaxis: sub NOMBRE BLOQUE. Viendo esto, podemos preguntarnos dnde estn los parmetros?. Los parmetros de una funcin estn en el aray @_. Y cmo se devuelven?. Pues con return como en casi todos los lenguajes de programacin. Ejemplo de funcin
#!/usr/bin/perl

$uno=23.34; $dos=26.66; #Llamamos a la funcin suma $sum=suma($uno,$dos); print "La suma de $uno + $dos es $sum\n"; #FUncin suma sub suma { #Cogemos los parmetros my ($primero,$segundo)=@_; #Tambin se podra hacer con my $primero=shift(@_); my $segundo shift(@_)]; #Devolvemos el resultado return ($primero+$segundo); }

Tambin podemos devolver ms de un parmetro a la vez, pero tenemos que tenerlo en cuenta a la hora de recogerlo.
... ($uno,$dos,$tres)=ejemplo($parametros); ... @salida=ejemplo($parametros); ... sub ejemplo { ... return ($a,$b,$c); }

Para pasar un array como parmetro a una funcin hay que convertirlo antes en una referencia y, posteriormente, en la funcin desreferenciarlo. Para obtener una referencia se utiliza la barra a la izquierda y para desreferenciarlo el smbolo del array. Ejemplo de array como parmetro
#!/usr/bin/perl for (my $i=0; $i<100; $i++) { $numeros[$i]=$i; } #Llamamos a la funcin maximo con una referencia a la matriz @numeros $max=maximo(\@numeros); print "El maximo de la matriz de $#numeros elementos es el $max\n"; #Funcin maximo sub maximo { #Cogemos los parmetros my ($uno)=@_;

#desreferenciamos my @matriz=@$uno; my $max=$matriz[0]; for (my $i=1; $i<=$#matriz; $i++) { $max=$matriz[$i] if ($matriz[$i] > $max); } #Devolvemos el resultado return ($max); }

3. Ejercicios
Ejercicio: Haz un bucle que recorra el array de argumentos del script y que los muestre por pantalla. Ejercicio: Rellenar mediante un bucle un array asociativo. Mostrar con un bucle foreach las claves y los contenidos. Ejercicio: Rellenar mediante un bucle for un array normal. Mostrar con diferentes tipos de bucles (while, until, do.., while, do ... until) su contenido. Ejercicio: Realizar una funcin que acepte tres nmeros y devuelva el mayor de los tres. Ejercicio: Modificar la anterior funcin para que devuelva los tres nmeros ordenados. Ejercicio: Modificar la anterior funcin para que reciba un array y devuelva el menor y el mayor.

Perl un poco ms a fondo

1.- Entradas y Salidas

Escribir en la salida estndar (pantalla) ya sabemos hacerlo, ahora nos interesa aprender como leer cosas desde el teclado y como escribir y leer en ficheros. Para leer de teclado se utiliza <STDIN>, que es un manejador de ficheros (Filehandle), que por costumbre se ponen en maysculas. (Tambin existe <STDOUT> y <STDERR> para la slida estndar y la slida de errores respectivamente). Lectura de STDIN:

#!/usr/bin/perl print "Hola. Cmo te llamas?\n"; $nombre=<STDIN>; #le quitamos el caracter de retorno de carro chop($nombre); if ($nombre eq "") { print 'Qu pasa? eres mudit@?'."\n"; } else { print "Hola $nombre, yo me llamo Flanagan. Estudias o trabajas?\n"; }

En el anterior ejemplos el script de Perl se espera a que el usuario pulse Return (retorno de carro), es decir, lee una lnea. Si en lugar de una variable se hubiese puesto un array, el script hubiese guardado tambin los retornos de carro hasta que se hubiese pulsado
CTRL+D

Para escribir en la salida estndar se utiliza print como hemos visto, pero si queremos escribir en la salida de errores sera poniendo despus de print el manejador de fichero de donde queremos escribir. Lectura de STDIN, escritura en STDERR y STDOUT:
#!/usr/bin/perl print "Hola. Cmo te llamas?\n"; $nombre=<STDIN>; #le quitamos el caracter de retorno de carro chop($nombre); if ($nombre eq "") { print STDERR 'Qu pasa? eres mudit@?'."\n"; } else { print STDOUT "Hola $nombre, yo me llamo Flanagan. trabajas o vives?\n"; }

Ya sabemos leer/escribir en un manejador de fichero (vale, que hasta ahora slo hemos usado pantalla y teclado). Ahora vamos a ver como se hara con ficheros. Para trabajar con un fichero hay que abrirlo, escribir/leer de l y cerrarlo. Para abrir un fichero se utiliza la funcin open y para cerrarlo con close. El formato para abrir un fichero es open (Manejador_de_fichero, Modo_y_NombreFichero). Lo modos de abrir un fichero se muestran en la siguiente tabla.
Modo Significado

"Nombre"

Abre Nombre para leer.

"<Nombre" Abre Nombre para leer. Igual que el anterior ">Nombre" Abre Nombre para escribir. Si no existe lo crea ">>Nombre" Abre Nombre para aadir al final "+>Nombre" Abre Nombre para lectura/escritura.

Veamos un ejemplo, de un script que copia un fichero en otro Ejemplo de ficheros:

#!/usr/bin/perl my $entrada="entrada.txt"; my $salida ="salida.txt"; open (ENTRADA,"<$entrada") || die "ERROR: No puedo abrir el fichero $entrada\n"; open (SALIDA,">$salida") || die "ERROR: No puedo abrir el fichero $salida\n"; while ($linea=<ENTRADA>) { print SALIDA $linea; } close (ENTRADA); close (SALIDA);

Si te fijas cuando abrimos los ficheros hemos utilizado algo especial, hemos puesto un O lgico y luego la funcin die seguido de un cadena; esto lo que hace es finalizar (die=morir) el programa si la parte de la izquierda del O lgico es falsa (no funciona correctamente) y, antes de finalizar, muestra la cadena que le sigue a die.

2.- Expresiones regulares

Las expresiones regulares de Perl es una de los principales factores que hacen de Perl un lenguaje muy potente en el tratamiento de cadenas. Una expresin regular es una forma de expresar gramaticalmente la estructura de cualquier cadena alfanumrica. La expresin regular se encierra entre barras y se aplica con =~ o con !~ para ver si se cumple o no, respectivamente. Por ejemplo, si queremos buscar la cadena "pepe" en una cadena, se hara como sigue:
... print "Est pepe!! \n" if ($cad=~/pepe/); ...

Como el uso de expresiones regulares es un mundo por si mismo, para los interesados pueden echarle un vistazo a http://geneura.ugr.es/~pedro/webmaster/expreg.htm

3.- Funciones split y join

Las funciones split y join se utilizan mucho y se les puede sacar mucho partido, por lo que haremos una mencin especial de ellas.
3.1.- split

La funcin split lo que hace es separar una cadena en los trozos dados por una expresin regular. Para entenderlo, lo mejor, un ejemplo. Ejemplo de split:
#!/usr/bin/perl my $cadena="0"; for (my $i=1; $i < 10 ; $i++) { $cadena.=", $i"; } print "La cadena antes de partirla es $cadena\n"; #Partimos la cadena en los elementos separados por las comas @elementos=split(/,/,$cadena); print "La cadena por partes es:\n"; foreach $elemento (@elementos) { print "$elemento\n"; }

3.2.- join

La funcin join nos permite unir diferentes partes en una sla, introduciendo un separador entre ellas, es decir, hace lo contrario de split. Ejemplo de uso de join:
#!/usr/bin/perl #Creamos una array de 10 nmeros my $i=0; push (@numeros,$i) while ($i++ <= 10); #Juntamos todos los nmero del array separndolos por una coma $cadena=join(",",@numeros); #mostramos la cadena print "$cadena\n";

Tambin nos puede ser util para leer un fichero completo en una variable.

Ejemplo de leer un fichero en una variable:

#!/usr/bin/perl my $entrada="entrada.txt"; my $salida ="salida.txt"; open (ENTRADA,"<$entrada") || die "ERROR: No puedo abrir el fichero $entrada\n"; open (SALIDA,">$salida") || die "ERROR: No puedo abrir el fichero $salida\n"; $fichero=join("",<ENTRADA>); print SALIDA $fichero; close (ENTRADA); close (SALIDA);

si en el anterior ejemplo hubiesemos querido obtener un array con las lneas del fichero, nos hubiese bastado con poner despus de join:
... @lineas)=split(/\\n/,$fichero); ...

4.- Mdulos
En Perl, como en la mayora de los lenguajes de programacin tenemos los mdulos o libreras o bibliotecas, segn se prefiera llamar. Un mdulo en Perl es un conjunto de funciones u objetos que se pueden acceder desde nuestro script. Se puede utilizar los mdulos utilizando la sentencia use, como, por ejemplo:
.... #Usamos las librerias de acceso a BD use DBI; ....

Para usar mdulos en Perl, tambin se pueden utilizar las sentencias do y require adems de use., las diferencias son:
1. do $nombreFichero lee el contenido de $nombreFichero en tiempo de ejecucin. 2. require $nombreFichero funciona de forma similar a do $nombreFichero excepto que comprueba antes si se ha leido el el contenido del mdulo $nombreFichero. Si se ha leido, no lo vuelve a leer. 3. use Modulo funciona de forma similar a require Modulo excepto que lo hace en tiempo de compilacin, en lugar de tiempo de ejecucin por lo que la ejecucin del script es ms rpida.

No es de extraar que en algunos casos los mdulos libreras son dos palabras separadas por ::; esto es porque los mdulos estn organizados en una especie de jerarqua, por ejemplo,el mdulo LWP::UserAgent es para bajarse pginas de la WWW.

Todos (o casi todos) los mdulos de Perl se encuentran en el CPAN (http://www.cpan.org) y probablemente all encontraremos cualquier cosa que nos haga falta. Si quieres aprender a como instalar mdulos en tu sistema, puedes echarle un vistazo a http://geneura.ugr.es/~javi/dbi/modulos.htm

5. Ejercicios
Ejercicio: Lee un fichero contador formado por un nmero, incrementalo y vuelve a guardarlo. Ejercicio: Lee un fichero formado por lneas de varios nmeros separados por espacios, en una cadena (usando join) y saca de esa variable todos los nmeros (usando split) y muestralos por pantalla. Ejercicio: La funcin que hicistes de encontrar el mximo y el mnimo de un array, mtela en un fichero aparte, y llmala como un modulo. Aplica la funcin de dicho mdulo al ejercicio anterior y encuentra el mximo y el mnimo del fichero. (Nota: usar require)

Objetos en Perl

1.- Uso de Clases y Objetos

Hasta ahora no lo hemos visto, pero Perl tambin soporta la Programacin Orientada a Objetos (POO). Empezando por el principio, una clase es una coleccin de variables y de funciones que acceden a esas variables. Un objeto es una instanciacin particular de una clase. En Perl, casi todos los mdulos son, en realidad, objetos. Veamos un ejemplo de uso de un objeto. Ejemplo de uso de la clase persona:
#!/usr/bin/perl #Usamos el mdulo/clase Persona use Persona; #Creamos un objeto del tipo persona $uno= Persona->new(); #Vamos a darle un nombre a ese objeto, usando el mtodo nombre $uno->nombre("Richal");

#Tambin vamos a darle una edad, usando el mtodo edad $uno->edad(23); #Mostramos la edad y el nombre print $uno->nombre." tiene ".$uno->edad. " aos \n"; #Y si hoy fuera su cumpleaos? $uno->cumple; #Mostramos la edad y el nombre print $uno->nombre." acaba de cumplir ".$uno->edad. " aos \n";

En el ejemplo anterior, tenemos la clase Persona y para crear un objeto de este tipo de clase ($uno) se utiliza el mtodo new, o sea, se usa el constructor de la clase. Posteriormente se han utilizado tres mtodos de la clase (nombre, edad y cumple) que nos muestran/modifican la edad y el nombre de la clase Persona. Tambin tenemos que decir que para crear un objeto de la clase Persona, se ha llamado directamente a dicha clase persona y es, por tanto, un mtodo de clase. Los mtodos de clase, tambin pueden ser llamados con la siguiente sintaxis:
... $uno=Persona::new("Persona"); ...

En el siguiente ejemplo se utiliza la clase XML::XSLT (un mdulo de Perl) para aplicar una hoja XSL a un documento XML Ejemplo de aplicacin 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 mtodo transform) $miXSL->transform ($miXML); #Lo pasamos a una cadena (usamos el mtodo toString) $salida=$miXSL->toString; #Lo mostramos por pantalla print $salida;

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

Si nos damos cuenta la forma de llamar a este constructor es un poco diferente a la vista en el primer ejemplo, eso se debe a que el objeto XSLT est dentro de la jerarqua XML.

2.- Como hacer nuestra propia clase

Lo primero, para construir nuestra propia clase, ser darle un nombre. Dicho nombre tambin ser el nombre del fichero (ms la extensin .pm -de perl module-) donde tendremos la clase. Despus tendremos que empezar la clase con: Encabezado de la clase Persona (fichero Persona.pm)
package Persona; use strict; #Nos ponemos serios

la primera lnea, sirve para indicar, que es una clase lo que estamos creando, y la segunda lnea 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 programacin.
2.1- Constructor

Despus tenemos que programar el constructor, que podemos llamar como nos apetezca, pero por convencin 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 .... }

En el anterior trozo de cdigo para averiguar la clase a la que pertenezco, se mira si es o no una referencia lo que se pasa. Esto es para que el constructor pueda ser llamado como un mtodo de clase (como parmetro tiene el tipo de referencia que recibe) o como un mtodo de objeto (como primer parmetro recibe el objeto). 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 aos ....

En el anterior trozo de cdigo, estamos usando una referencia (de ah la notacin con -> ) a un array asocitivo. De esta forma podremos darle nombres a las propiedades del objeto. Tambin podramos haber usado una referencia a un array indexado (con $self=[];), pero la forma de acceder a las propiedades sera mediante ndices:
.... $self=[]; $self ->[0] =undef ; #La clase Persona nace sin nombre $self ->[1] =0 ; #La clase Persona se construye con 0 aos ....

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 recin construida }

Tambin podramos haber bendecido slo el objeto en s (bless $self;), pero si lo hacemos as no sabremos a que clase pertenece y no se podr heredar de l. 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 aos bless $self, $class; #Perl nos tiene que dar el visto bueno (bendecirla) return ($self); #Devolvemos la clase recin construida }

2.2- Mtodos de la clase y destructor

Tambin tendremos que construir nuestros mtodos para la clase. Para ello slo tenemos que tener en cuenta que un mtodo de una clase es simplemente una funcin (o subrutina) que toma como primer parmetro el tipo de clase a la que pertenece el mtodo. Podemos hacer el destructor (no obligatorio), que es un mtodo, anlogo a los anteriores, pero con la nica diferencia en que se debe llamar DESTROY o END

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 "slo" un script que devuelve 1.
2.3- 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 aos bless $self, $class; #Perl nos tiene que dar el visto bueno (bendecirla) return ($self); #Devolvemos la clase recin construida } ###################################################################### #Mtodos de acceso a los datos de la clase # #metodo para ver/cambiar el nombre sub nombre{ my $self=shift; #El primer parmetro de un metodo es la

clase

#Miramos si se le ha pasado algn parmetro, 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 parmetro de un metodo es la la edad $self->{EDAD}=shift if (@_);

clase

#Miramos si se le ha pasado algn parmetro, en cuyo caso ser

#Devolvemos el nombre return $self->{EDAD}; } ###################################################################### #Mtodos de la clase # #metodo para cumplir aos sub cumple{ my $self=shift; #El primer parmetro de un metodo es la #Incrementamos la edad $self->{EDAD}++; #Devolvemos el nombre return $self->{EDAD}; }

clase

###################################################################### #Destructor # sub DESTROY { my $self=shift; #El primer parmetro de un metodo es la delete ($self->{NOMBRE}); delete ($self->{EDAD}); } #Fin 1; clase

2.4- Herencia

Para realizar la herencia, tan slo tenemos que aadir al array @ISA una lista de antecesores (si solo hay uno ser herencia simple y si hay ms es herencia mltiple). Cuando el intrprete de Perl no encuentre un mtodo en la clase, buscar dicho mtodo en la primera clase de la que hereda, despus en la segunda, etc. Clase Trabajador (fichero Trabajador.pm)
package Trabajador; #Heredamos de Persona use Persona; @ISA=qw(Persona); use strict; #Nos ponemos serios #Aadimos un mtodo con el salario del trabajador sub salario{ my $self=shift; #El primer parmetro de un metodo es la

clase

#Miramos si se le ha pasado algn parmetro, en cuyo caso ser la edad $self->{SALARIO}=shift if (@_); #Devolvemos el nombre. Si nunca se ha modificado devolvera una cadena vaca. return $self->{SALARIO}; } #Fin 1;

Si quisieramos utilizar un mtodo de la primera clase padre, bastara con llamarla. Si en el anterior ejemplos quisieramos que la propiedad SALARIO se inicializase a un valor por defecto, tendramos que crear un constructor que llamase al constructor de la clase Persona. Clase Trabajador con constructor redefinido
package Trabajador; #Heredamos de Persona use Persona; @ISA=qw(Persona); use strict; #Nos ponemos serios 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=$class->Persona::new("Persona"); #Inicializamos las propiedades con las usadas en Persona $self ->{SALARIO} = 0 ; #Inicializamos el salario bless $self, $class; #Perl nos tiene que dar el visto bueno (bendecirla) return ($self); #Devolvemos la clase recin construida } #Aadimos un mtodo con el salario del trabajador sub salario{ my $self=shift; #El primer parmetro de un metodo es la la edad $self->{SALARIO}=shift if (@_); #Devolvemos el nombre. Si nunca se ha modificado devolvera una cadena vaca. return $self->{SALARIO}; } #Fin 1;

clase

#Miramos si se le ha pasado algn parmetro, en cuyo caso ser

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

Enlaces y referencias de Perl

1.- Ayuda de Perl

Para ver la ayuda de Perl, hay un comando llamado perldoc. En la versin de Windows de ActiveState tambin se incluye la ayuda en formato HTML (en el subdirectorio docs) y en http://www.cpan.org tambin se puede descargar/consultar al ayuda en HTML. La forma de usar perldoc es: Para acceder a un documento:
perldoc NombreDelDocumento

Para ver la documentacin de una funcin

perldoc -f NombeDeLaFuncin

Por ejemplo para ver la documentacin de la funcion split, se escribira, perldoc -f split. Los distintos documentos que tiene Perl son: Documento perl Introduccin . perldelta perlfaq perltoc perldata perlsyn perlop perlre perlrun perlfunc perlvar perlsub perlmod Descripcin

Cambios desde la ltima versin . FAQ (Frequently asked questions) de Perl . Tabla de contenidos de la documentacin de Perl. Estructuras de datos en Perl. Sintaxis. Operadores y precedencia. Expresiones Regulares. Ejecucin y opciones. Funciones estndar de Perl. Variables predefinidas. Funciones (subrutinas). Como funcionan los mdulos.

perlmodlib perlform perllocale perlref perldsc perllol perltoot perlobj perltie perlbot perlipc perldebug perldiag perlsec perltrap perlport perlstyle perlpod perlbook perlembed perlapio perlxs perlxstut perlguts perlcall perlhist

Como crear nuestro propios mdulos. Formatos Soporte Local Referencias Instroducin a las estructuras de datos Estructuras de Datos: listas de listas Tutorial Orientado a Objetos Objetos Objetos ocultos detrs de variables simples Trucos de Objetos y ejemplos Comunicacin entre procesos Depuracin Mensajes de diagnstico Seguridad Trampas para los descuidados Gua de portabilidad Gua de estilo Antiguo formato de documentacin Informacin de libro Incluir Perl en aplicaciones de C o C++ Interfaz interno de abtracin de Entrada/Salida Interfaz de programacin de aplicaciones XS Tutorial de XS Funciones internas para realizar extensiones Convenciones para llamar subrutinas de Perl desde C Registros histricos

perlmodinstall Como instalar mdulos desde el CPAN.

2.- Enlaces y sitios de referencia

http://geneura.ugr.es/~javi/perl : Este tutorial de Perl en espaol. Para empezar a trabajar Perl. http://geneura.ugr.es/~jmerelo/tutoperl/ : Completo tutorial de Perl en espaol. Entretenido y avanzado. http://geneura.ugr.es/~javi/dbi/index.html : Tutorial de Perl DBI en espaol. Para trabajar con Bases de datos usando Perl. http://geneura.ugr.es/~javi/dbi/modulos.htm : Rpida referencia de como instalar un mdulo de Perl en Windows o Linux. En espaol. http://geneura.ugr.es/~pedro/curso_comercio/cgi.pm.htm: Tutorial en espaol de CGI usando Perl y el mdulo CGI.

http://geneura.ugr.es/~javi/wap/curso/index.html: Tutorial en espaol de CGI en WML usando Perl y el mdulo CGI::WML. http://geneura.ugr.es/~pedro/webmaster/expreg.htm: Breve tutorial en espaol sobre las Expresiones Regulares de Perl. http://geneura.ugr.es/~javi/xml/parser.htm: Breve tutorial en espaol de trabajar con el DOM (Modelo de Objeto Documento) de XML usando Perl. http://geneura.ugr.es/~javi/perlnet: Tutorial en espaol para trabajar con la platarforma .NET de Microsoft, usando PerlNET. http://geneura.ugr.es/~pedro/curso_soap: Tutorial en espaol para trabajar con SOAP, WSDL y UDDI usando Perl y Java. http://www.cpan.org:CPAN (Comprehensive Perl Archive Network) es una red de sitios con (casi) todos los archivos, documentos, distribuciones, y mdulos reclacionados con Perl. http://www.perl.com: Sitio central dedicado a Perl. Hay noticias, listas de correo y enlaces a todos los sitios de donde puede uno bajarse las diferentes versiones de Perl. http://www.activestate.com: Empresa que se encarga de portar las ltimas versiones de Perl a windows. Adems cuentan con entornos visuales y extensiones (De pago, claro). http://www.oreilly.com/: Editorial con los mejores libros dedicados a Perl.