Introduccin al uso del lenguaje Perl

Perl significa Practical Extraction and Report Language, algo as como lenguaje prctico de extraccin y de informes. Es un lenguaje creado por Larry Wall (quien, por cierto, es, o era, uno de los pioneros de la red ms conocidos) con el objetivo principal de simplificar las tareas de administracin de un sistema UNIX; en realidad hoy en da (en su versin 5.8, y posiblemente pronto, la 5.10 y quizs la 6) se ha convertido en un lenguaje de propsito general, y una de las principales herramientas de un buen internetero y de un buen webmaster, aunque tambin se usa extensivamente en Bioinformtica y, en general, en casi todo. Perl es un lenguaje que hereda ciertas estructuras de los intrpretes de comandos de UNIX, especialmente el csh, y de otras utilidades estndar, como awk y sed. Aparte de esto, est diseado para hacer todo lo que hacen cualquiera de ellos y todos ellos juntos, y la mayora de las veces de forma ms simple, comprensible y fcil de depurar. Perl es un lenguaje interpretado, aunque en realidad, el intrprete de Perl, como todos los intrpretes modernos, compila los programas antes de ejecutarlos. Por eso se habla de scripts, y no de programas. Actualmente hay versiones para casi todos los sistemas operativos: Windows XP, Amiga, o MacOS. Los scripts son compatibles entre las diversas plataformas, de forma que es un verdadero lenguaje multiplataforma. Muchos fabricantes lo incluyen en sus versiones de UNIX; tambin el Linux lo incluye.

Aplicaciones del lenguaje Perl

Prcticamente, sirve para todo. Todas las tareas de administracin de UNIX se pueden simplificar con un programa en Perl. Se usa tambin para tratamiento y generacin de ficheros de texto. Tambin hay proyectos completos y complejos escritos en Perl, pero son los menos. La forma del lenguaje facilita la programacin rpida y sucia, el hacer un programa rpido para que funcione. Esto hace tambin que se utilice para hacer prototipos rpidos de algn algoritmo que queremos ver funcionar antes que tomarnos la molestia de programarlo en un lenguaje ms eficiente, como el c++. Y ltimamente ha encontrado su aplicacin en la escritura de CGI (common gateway interface), o scripts ejecutados desde pginas de la World Wide Web. La mayora de los programas que se encuentra uno para procesar formularios en la Internet llevan la extensin .pl, lo cual denota que estn escritos en Perl.

Cmo conseguir e instalar Perl

Hay versiones de Perl para casi todos los sistemas operativos, o sea que no debera de ser complicado. En todo caso, lo ms probable es que si tienes una distribucin de Linux venga ya incluido. Consulta los paquetes que tienes instalados o simplemente escribe:
bash$ which perl /usr/bin/perl

Si contesta algo as como lo anterior, es que est instalado. Y si quieres nota, escribe
bash$ perl -v This is perl, v5.8.0 built for i386-linux-thread-multi Copyright 1987-2002, Larry Wall Perl may be copied only under the terms of either the Artistic License or the GNU General Public License, which may be found in the Perl 5 source kit. Complete documentation for Perl, including FAQ lists, should be found on this system using 'man perl' or 'perldoc perl'. If you have access to the Internet, point your browser at http://www.perl.com/, the Perl Home Page.

lo que, como ves, te devuelve la versin, e informacin adicional. Para bajarte la ltima versin para Windows, ve a http://www.activestate.com/activeperl

Cmo escribir y ejecutar un programa Perl

Para editar un programa en Perl, lo ms adecuado es conseguir un editor para programadores, porque el lenguaje no incluye un entorno integrado de programacin. Cualquier editor de texto servir, pero hay que asegurarse de que guarde el texto como texto plano.

Bajo Linux/Unix emacs, x-emacs, gedit, kwrite, etc, son perfectos para editar pequeos programas. Bajo Windows, lo mejor es instalarse un editor para programadores, como el notepad++, o en todo caso, usar el edit o el Wordpad (desaconsejo el Notepad de Windows). Por otro lado, hay entornos de programacin especficos para perl, como PerlIDE o Komodo. Este ltimo es de pago, pero se puede usar durante un tiempo limitado. Estos entornos permiten desarrollar proyectos completos ms comodamente, pero, para los efectos de ste curso, un editor de textos orientado a programacin es suficiente. Para crear nuestro primer programa, slo tenemos que abrir el editor de textos y teclear:
print este es mi primer programa en Perl \n;

Y eso es todo! No hay necesidad de abrir el programa, ni de cerrarlo, ni de incluir libreras estndar, ni nada de nada. Solamente hay que tener cuidado de terminar todas las sentencias con punto-y-coma (;). El smbolo \n se suele leer "escape-N" y tiene el mismo significado que en C, es decir, un retorno de carro. Guardaremos el programa en un fichero con el nombre primero.pl y lo ejecutaremos, si estamos en Linux, con:
~/tutoriales$ perl primero.pl este es mi primer programa en Perl

o si estamos en Windows (y tenemos Perl instalado y perl.exe est en el PATH de ejecucin), desde el smbolo del sistema (CMD), con:
C:\tutoriales> perl primero.pl este es mi primer programa en Perl

Si ests en Linux/UNIX, se utiliza una sintaxis similar a los scripts del intrprete de comandos, es decir, guardar el fichero con una primera lnea que indica dnde est el intrprete que va a ejecutar el resto del fichero. En el caso del Perl bajo Linux, debe ser algo como:
#!/usr/bin/perl print este es mi primer programa en Perl \n;

En el caso de Windows, tambin podemos hacer algo similar:

#!c:/perl/bin/perl.exe print este es mi primer programa en Perl \n;

Tras guardarlo (seguimos con el ejemplo bajo Linux), le damos permisos de ejecucin, y ya podemos ejecutarlo sin invocar directamente al intrprete:
~/tutoriales$ chmod 755 primero.pl ~/tutoriales$ ./primero.pl este es mi primer programa en Perl

En Windows, la instalacin del ActivePerl nos har la asignacin de la extensin .pl al Perl.exe, por lo que podemos hacer doble clic sobre los programas y el sistema llamar automticamente al intrprete de Perl.

Los tipos bsicos de datos

Perl permite representar los tipos de datos bsicos como los reales, los enteros, las cadenas de caracteres y el tipo booleano. Cada dato bsico se representa en un contenedor o variable.

Los identificadores de las variables

Los nombres de variables siguen las reglas de C, C++ o Java: los caracteres permitidos son las letras, dgitos y el carcter underscore (_). Adems, las letras maysculas y minsculas son diferenciadas en los nombres de variables. Los nombres de las variables siempre deben comenzar por una letra. Se recomienda que los nombre de las variables estn en consonancia con lo que representan. A diferencia de C, C++ o Java, las variables de tipo escalar van precedidas por el smbolo $. En un programa Perl, podemos definir una nueva variable en cualquier punto del programa, y aunque no hay que indicar un tipo de dato (al contrario que en C++), conviene definir cada variable anteponindole la palabra reservada my (slo en el momento de su creacin). Por otro lado, el mbito de definicin de las variables en los bloques de cdigo es similar al C++.

Los tipos numricos (reales y enteros)

Los valores numricos expresados literalmente se presentan en forma de valores reales codificados en doble precisin. Este formato interno se utiliza para todas las operaciones aritmticas. Por ejemplo:
my $x = 0.897; my $y = 6.23e-24; my $n = 567; my $i = -234; # un real # un real # un entero # un entero

Que todas las variables contengan un $ significan que representan un escalar. Esto lo veremos en el siguiente apartado. Los valores enteros no pueden empezar por cero porque esto permite especificar un entero mediante su codificacin octal o hexadecimal. El cdigo octal se antecede con en cero 0; el cdigo hexadecimal se antecede con un 0x o 0X. Por ejemplo:
my $x = 0377; my $y = 0xff; # equivale a 255 # equivale a 255

Las cadenas de caracteres

Las cadenas de caracteres se especifican literalmente por medio de un sucesin de caracteres delimitada por comillas ("..") o apstrofes ('..'). Estas dos representaciones se distinguen por la interpretacin hecha por Perl de las cadenas de caracteres. Cuando van delimitadas por comillas (".."), toda variable referenciada en el interior de la cadena se evala y se reemplaza por su valor. Por ejemplo, las instrucciones siguientes:
my $wld = "mundo"; my $str = "Hola $wld!";

asignan al escalar la cadena de caracteres "Hola mundo!". Por el contrario, las cadenas de caracteres delimitadas por apstrofes se dejan intactas. Por ejemplo:
my $str = 'Hola $wld!';

asigna al escalar $str la cadena de caracteres "Hola $wld!".

El tipo booleano
El tipo booleano existe, al igual que en C, de modo implcito, es decir, un nmero es falso si es igual a cero y verdadero en cualquier otro caso. Como el cero est asociado a la ristra vaca (""), sta tambin equivale al valor falso.

Las representaciones de datos

El lenguaje Perl posee tres tipos de representaciones de datos:

los escalares. los arrays.

los arrays de indexacin literal o listas asociadas.

Estas tres representaciones permiten asociar a cada variable utilizada un tipo. Por otra parte, las variables Perl se asignan de manera dinmica y se les asigna un valor predeterminado en funcin del contexto.

Los escalares
El escalar representa el tipo bsico en Perl. Permite representar enteros, reales y cadenas de caracteres. A continuacin veremos algunos ejemplos:
my $real = 4.53; my $entero = -45; my $cad = "Hola";

Las variables en Perl se asignan de manera dinmica y se les asigna un valor predeterminado en funcin del contexto. En un contexto numrico el valor predeterminado es 0, mientras que en un contexto de cadena de caracteres el valor predeterminado es la cadena vaca "". Como ya hemos dicho, cuando una cadena de caracteres se delimita por comillas, el contenido de esta cadena es analizado por Perl para el reemplazo eventual por su valor de las variables escalares identificadas por el smbolo $. Este anlisis se denomina interpolacin de variables y puede evitarse poniendo delante del smbolo $ una barra oblicua inversa \ o delimitando la cadena de caracteres con apstrofes. El tipo y el valor de las variables en Perl se determina a partir del contexto. As, una cadena de caracteres conteniendo un valor numrico ser convertida en variable numrica en un contexto numrico. Consideremos el cdigo siguiente:
my $x = 4.1; my $y = "11"; my $z = $x + $y; my $t = $x . $y; # un real # una cadena de caracteres # suma de dos valores numricas # concatenacin de dos cadenas

print $z, "\n", "$t \n";

Al final del cdigo la variable $z tiene el valor 15.1. Por otro lado, la variable $t contiene el valor "4.111". Por lo tanto en Perl no es necesario realizar una declaracin de tipos, ni es necesario el operador cast, ni tampoco es necesario dar formato a los valores a la hora de imprimirlos como ocurra en C. Esta interpolacin se produce a menudo en unas lneas de cdigo tales como las siguientes:
my $year = 35; print "Tengo $year aos";

El resultado de estas lneas de cdigo es: "Tengo 35 aos"; el contenido de la variable year se ha convertido en una cadena de caracteres.

Los arrays
Un array es una lista de datos de tipo escalar. Cada elemento de la lista es una variable escalar a la que se le asocia un valor. Igual que a las variables escalares se les antepone el smbolo $, las variables de tipo array se identifican por el prefijo arroba @. Por ejemplo:
my @numeros = (2, 1, 667, 23, 2.2, 5, 6); my @letras = ("perro", "gato", "len"); my @mezcla = ("hola", 23, "adios", 31.234);

Tambin se permite definir los elementos de un array a partir de sus valores extremos utilizando el operador "..", como se muestra a continuacin:
my @alfabeto = ('a'..'z');

Los elementos de un array se referencian mediante ndices (al estilo de las tablas de C++). El primer elemento se referencia por el ndice 0. El ltimo ndice viene dado por el operador " $# " El nmero de elementos de un array se podra calcular como: ( $#matriz + 1 )

Puesto que un elemento del array ser (en principio) un escalar, se acceder a l usando la sintaxis de corchetes y anteponindole el smbolo $. Por ejemplo:
$numeros[4]; $letras[2]; $mezcla[0]; # vale 2.2 # vale "len" # vale "hola"

Tambin se puede acceder a un array mediante el operador que define una horquilla de ndices (".."). Por ejemplo:
my @num1 = @numeros[1..3]; my @str = @letras[0,2]; my ($cadena, $num) = @mezcla; # @num1 = (1, 667, 23) # @str = ("perro", "len") # $cadena ="hola", $num =23

Esta ltima instruccin vemos que permite asignar los dos primeros valores del array @mezcla a las variables escalares $cadena y $num. Por otro lado, el acceso a un array fuera de rango devuelve un valor indefinido 0 o "" segn el contexto. Por ltimo, si vemos las siguientes lneas de cdigo:
my @a=(1,2,3); my @b=(5,6,7); my @c=(@a,4,@b,8);

Estas expresiones generan tres arrays, (1,2,3), (5,6,7) y (1,2,3,4,5,6,7,8), y no, como podra pensarse un array de arrays, cuando incluimos un array dentro de otro, Perl "aplana" el array insertado uno a uno todos sus elementos en la posicin indicada del array que ha de contenerlos, para hacer array de arrays deberemos usar referencias a estos.

Insertar / extraer contenido a los arrays

Podemos usar dos parejas de funciones para insertar/sacar por el principio o el final. push() inserta un elemento por el final del array, mientras que pop() saca un elemento por el final.
my @matriz = (1, 3, 5); push(@matriz, 2,4,6); my $a = pop(@matriz);

tras la segunda instruccin, @matriz pasa a tener (1,3,5, 2,4,6). Tras la tercera instruccin, @matriz pasa a tener (1,3,5,2,4) y $a tiene 6. unshift() inserta un elemento por el principio del array, mientras que shift() saca un elemento del principio.
my @matriz = (1,3,5,2,4); unshift(@matriz, 7,8); my $b = shift(@matriz);

tras la segunda instruccin, @matriz pasa a tener (7,8, 1,3,5,2,4). Tras la tercera instruccin, @matriz pasa a tener (8,1,3,5,2,4) y $b tiene 7.

Las listas asociativas (arrays de indexacin literal)

Una lista asociativa (o hash) est indexada por cadenas en lugar de por nmeros. Se utiliza el smbolo % para definir el tipo de lista asociativa, y un elemento est indexado por el anterior formando ambos parejas del tipo (clave, valor).
my %cuota = ("root", 1000, "pat", 256, "fiona", 4000);

En este caso, para acceder a cualquiera de los elementos de %cuota debemos conocer su clave. Por ejemplo:
my $id = $cuota{"pat"}; # $id = 256

Este tipo de dato se puede utilizar para guardar los datos relativos a un objeto, de forma que ms tarde accedamos a travs de los nombres de sus caractersticas, y no mediante un ndice a cada caracterstica. Esta lista puede completarse aadiendo nuevos valores y asociando a cada clave el valor correspondiente. Por ejemplo:
$cuota{"dave"} = 250;

donde la clave es "dave" y el valor asociado es 250.

Tipos complejos: arrays de arrays

Podemos crear matrices N-dimensionales definiendo arrays de arrays. Realmente se trata de arrays de referencias a arrays. Veamos un ejemplo sobre cmo crear un array bidimensional:
my @matriz = ([1,2],['juan','pepe','luis'],['gato',2]); print $matriz[1][2]; # mostrar luis

Para asignarle valores a las casillas de la matriz bidimensional:

for (my $x = 0; $x <= 10; $x++) { for (my $y = 0; $y <= 10; $y++) { $AoA[$x][$y] = &func($x, $y); } }

Un error comn a la hora de mostrar los valores de una matriz N-dimensional es intentar imprimir el objeto @matriz, lo cual mostrar una lista de las referencias a cada fila de la matriz:
print @matriz; # muestra una lista de referencias

Entrada/Salida estndar
Para leer desde entrada estndar (teclado habitualmente, salvo si hacemos redireccin), usamos <STDIN>
my $nombre = <STDIN> ; my @valores = <STDIN> ;

en el primer caso se lee una lnea (hasta pulsar el retorno de carro). En el segundo caso se leen varias lneas asignndolas a cada casilla de la matriz, hasta que se pulsa CTRL-D Para escribir en la salida estndar, smplemente utilizamos el operador print que ya hemos visto.

Entrada/Salida con ficheros

El lenguaje Perl incluye varias operaciones primitivas para acceder a ficheros. Hay funciones para abrirlos, cerrarlos, y operadores para realizar lecturas.

Abrir ficheros
Debemos utilizar el operador open() como sigue:
open(LEER, "path_fichero_leer"); open(SUSTITUIR, ">path_fichero_sustituir"); open(AADIR, ">>path_fichero_aadir");

debemos indicar un manejador de fichero (el que queramos; se siguen las normas de declaracin de variables), y tambin si vamos a leer, sustituir el contenido, o aadir al final del fichero:
open(F, "<path_fichero"); # abrir para lectura open(F, ">path_fichero"); # abrir para escritura sustituyendo el contenido open(F, ">>path_fichero"); # abrir para escritura aadiendo al final

Cerrar ficheros
Debemos utilizar el operador close() como sigue:
close(MANEJADOR);

Acceder a los ficheros abiertos

Debemos utilizar el operador <MANEJADOR> para leer, y el print para escribir, como sigue:
open(F1, "fich_origen"); open(F2, ">fich_destino"); while ( <F1> ) { print F2 $_; } close(F1); close(F2);

El cdigo anterior copia un fichero en otro: se va leyendo el contenido del primer fichero y se va escribiendo en el segundo (hasta que se vaca el primero). Una forma alternativa para leer de un fichero es almacenando todo el contenido del fichero en un array. Despus ya podremos acceder al array:
open(F, "fich_origen"); my @datos=<F>; close(F); my $linea; foreach $linea ( @datos ) { print $linea; }

Existe una variable especial ($_) en la que se almacena cualquier cosa que se lea de un fichero o de entrada estndar (si no se indica otra a la que se asigna lo ledo).

Leer los parmetros de la lnea de comandos

Igual que en C++ tenemos dos variables argc y argv para acceder a los parmetros que nos han pasado a travs de la lnea de comando, en Perl podemos usar dicha informacin a travs de un array especial llamado ARGV
my $argv1 = $ARGV[0]; my $argv2 = $ARGV[1]; my $argc = $#ARGV+1;

Cada posicin del array contiene un parmetro.

Ejecutar rdenes de shell

Igual que en C++ podemos usar la funcin exec para ejecutar programas externos, en Perl podemos hacer uso de la funcin system() De esta forma, si nuestro programa Perl necesita obtener el listado de procesos que se estn ejecutando, podemos usar como orden ps y la sentencia Perl quedara como system("ps");
my $valor = system("ps"); if($valor) { print "Error al ejecutar la orden"; }else{ print "Salida de la orden ejecutada: $valor "; }

Estructuras de control en Perl

La instruccin if
Es muy parecida a la utilizada en C. La sintaxis de la instruccin if es la siguiente:
if (expresin) { instruccin o bloque de instrucciones 1; } [else { instruccin o bloque de instrucciones 2; } ]

El programa evala la expresin. Cuando esta expresin resulta verdadera, se ejecuta la instruccin o el bloque de instrucciones 1. Por contra, cuando es falsa de ejecuta la instruccin o bloque de instrucciones 2. Esta ltima parte es opcional. Perl es muy verstil, y se pueden usar otras construcciones condicionales:
my $a = <STDIN>; print todo bien if ( $a eq ok);

Una construccin similar al if .. else es la ?: (existe tambin en C y C++). Permite consultar una condicin, y en funcin del resultado, asignar un valor u otro:
my $a = <STDIN>; my $b = ($a eq ok) ? todo bien : algo mal ;

En este ejemplo, si la variable $a ha recibido el valor ok, entonces la variable $b recibe el valor todo bien. En otro caso, la variable $b recibe el valor algo mal.

La instruccin unless
Esta instruccin es anloga al if, salvo que permite considerar la no verificacin de la prueba. Su sintaxis es la siguiente:
unless (expresin) { instruccin o bloque de instrucciones 1; }

La instruccin while
La instruccin while ejecuta iterativamente un bloque de instrucciones mientras una expresin sea vlida, evaluando la comprobacin en cada iteracin. Cuando la prueba es vlida, se ejecuta la instruccin o el bloque de instrucciones delimitado por las llaves. La sintaxis de esta instruccin es:
while (expresin) { instruccin o bloque de instrucciones; }

He aqu un sencillo ejemplo de manejo de esta estructura:

print "Teclea \"x\" para salir:\n"; my $cadena = ""; while ($cadena ne "x") { $cadena = <STDIN>; chop($cadena); print "Has escrito $cadena\n"; } print "Salida.\n"

La instruccin for
La instruccin for permite ejecutar iterativamente un conjunto de instrucciones. La sintaxis de la instruccin for es:
for (inicial_exp; test_exp; incremento_exp) { instruccin o bloque de instrucciones; }

donde inicial_exp es la instruccin que inicializa el bucle. Consiste generalmente en la asignacin de un valor a una variable que permite controlar el nmero de iteraciones. test_exp es la expresin evaluada en cada iteracin. Cuando esta expresin es verdadera, el bloque de instrucciones se ejecuta. incremento_exp es la expresin que permite la actualizacin de la variable que controla el nmero de iteraciones. A continuacin veremos un ejemplo de esta estructura para iniciarnos en su manejo:
print "10 Iteraciones\n"; for (my $i=0; $i<10; $i++) { print "Interacin nmero $i\n"; }

La instruccin foreach
La instruccin foreach es similar a la funcin del mismo nombre de los Shells de Unix. Asocia iterativamente a una variable cada elemento de la lista. Esta sucesin de valores sirve para parametrizar la ejecucin del bloque de instruccin. La sintaxis de la instruccin foreach es:
foreach $variable (@lista) { instruccin o bloque de instrucciones; }

Las instrucciones for y foreach son equivalentes. Sin embargo, la utilizacin de una de estas instrucciones se justifica generalmente por el contexto. El ejemplo siguiente lo ilustra:
my @lista = ("elem1", "elem2", "elem3", "elem4"); for ($i = 0; $i<= $#lista; $i++) { print $lista[$i], "\n"; }

Este ejemplo no utiliza las caractersticas de los arrays en Perl. La utilizacin de la instruccin foreach permitir recorrer la lista de forma ms elegante. El ejemplo siguiente lo ilustra:
my @lista = ("elem1", "elem2", "elem3", "elem4"); foreach $elem_actual (@lista) { print $elem_actual, "\n"; }

Existe en Perl una variable especial llamada $_ que se utiliza principalmente en este tipo de bucles. En cada pasada del bucle el valor extraido del array se instancia a la variable escalar $_ que pasa a utilizarse en el cuerpo del bucle:
my @lista = ("elem1", "elem2", "elem3", "elem4"); foreach (@lista) { print $_, "\n"; }

La instruccin goto
La instruccin goto label permite cambiar el recorrido lineal de las lneas de cdigo prosiguiendo la ejecucin del programa en la lnea de etiqueta label. La etiqueta se define colocando al final del identificador dos puntos (:). En el siguiente ejemplo se podr ver mejor la construccin del goto.
if ($expr ne $expr_correcta) { goto error; } ... error: print "expresin incorrecta";

La utilizacin del goto en Perl no es recomendable. Por que le quita al cdigo legibilidad y aumenta la posibilidad de errores.

La instruccin next
La instruccin next es idntica a la instruccin continue en C. Interrumpe la ejecucin del bloque de instruccin actual y prosigue la ejecucin en la iteracin siguiente. Esta instruccin no interrumpe completamente la ejecucin del bucle; la expresin que controla el bucle se evala. Si el resultado de la expresin es vlido, el bucle se ejecuta de nuevo. Cuando una instruccin tiene como argumento una etiqueta, la instruccin prosigue en la lnea identificada por la etiqueta y no al principio del bloque.

La instruccin until
La instruccin until al igual que la instruccin while permite ejecutar un conjunto de instrucciones un nmero repetido de veces. Pero al contrario que la instruccin while, la instruccin until ejecuta dicho bloque de instrucciones mientras no se verifique la comprobacin. La sintaxis es:
until (expresin) { instruccin o bloque de instrucciones; }

Introduccin a las subrutinas en Perl

Al igual que otros lenguajes, Perl permite al usuario definir sus propias funciones, llamadas subrutinas. Se pueden colocar en cualquier sitio en el programa, pero se suelen definir todas juntas o bien al principio o bien al final del programa. A modo de ejemplo, una subrutina tiene el aspecto:
sub una_subrutina { print "\n Mi primera subrutina en Perl...\n"; }

Comienzan por la palabra reservada sub, a continuacin ponemos el nombre de la subrutina y el bloque o cuerpo. Para llamarla desde el programa principal slo tenemos que escribir su nombre. Si no tiene parmetros no estamos forzados ni a poner los parntesis vacos (como s ocurre en C++):
# llamada sin parmetros una_subrutina; # llamada con un parmetro una_subrutina("hola"); # llamada con dos parmetros una_subrutina(5-3, "segundo parmetro");

Si llamamos a una subrutina con ms parmetros de los que debe recibir, no se produce ningn error, simplemente se ignoran los sobrantes.

Parmetros
Cuando una subrutina recibe parmetros, estos son pasados como una lista en el array especial @_. Ese array no tiene nada que ver con la variable $_. Si recordamos las matrices veremos que cada uno de los parmetros ser una variable dentro de la matriz que se direcciona as $_[0], $_[1], etc.
# Llamada a la subrutina con 2 parmetros: saludo ("Hola","Mundo\n"); @_=("Hola","Mundo\n");

equivaldra a:
$_[0]="Hola" y $_[1] = "Mundo\n";

El siguiente programa simplemente imprime la lista de argumentos con que se ha llamado:

sub print_args { print "\n@_\n"; } # imprimir "llamada con dos parmetros" print_args("llamada con", "dos parmetros"); # imprimir "llamada con TRES parmetros" print_args("llamada con", "TRES", "parmetros");

Al igual que otra variable-array, puede ser accedida con la notacin de corchetes, mediante las variables $_[0], $_[1], ..., que nada tienen que ver con la variable $_:
sub print_2_args { print "Primero= $_[0] \n"; print "Segundo= $_[1] \n"; }

Otras variables que no sean las @_, $_[i] o las definidas como locales a que hagamos referencia dentro de la subrutina sern globales, con lo cual si modificamos alguna de ellas, al salir de la subrutina, se habrn modificado. A veces esto nos interesar, pero a veces no. Cuando no queramos ver modificadas las variables globales desde dentro de una subrutina, deberemos utilizar variables locales.

Si asignamos un valor a una nueva variable dentro de una subrutina, y esa variable no es local a la subrutina, se crear como global, pudiendo utilizarse al volver de la llamada a la subrutina:
sub vars_globales2 { $nueva_variable = "valor"; } vars_globales2; print "$nueva_variable"; # imprime "valor"

Variables locales
La variable @_, al igual que $_[0], $_[1], ... son locales a la subrutina. Perl permite que podamos definir en las subrutinas nuestras variables locales, mediante la palabra reservada my. Otra opcin es usar la palabra reservada local:
sub vars_locales { local($a, $b); ($a, $b) = ($_[0], $_[1]); ( $a =~ /$b/ || $b =~ /$a/ ); }

devuelve verdadero si el primer parmetro o el segundo esta dentro del otro (o falso en caso contrario). Esta es la forma de evitar el problema que tena la subrutina vars_globales Las variables locales son tiles para no modificar las variables globales. Al definir las variables locales podemos asignarles el valor en la misma lnea con:
local($a, $b) = ($_[0], $_[1]);

Valores de retorno
Perl tambin nos permite retornar valores y lo hace tomando como retorno el ltimo valor escalar que se emplee en la subrutina. El resultado que devuelve una subrutina es la ltima cosa evaluada. As, la subrutina que vimos antes que imprima los parmetros que reciba, devuelve siempre un 1 (verdadero), que es lo que devuelve la orden print. Para devolver un valor, podemos hacer dos cosas:
sub maximo { if( $_[0] > $_[1] ) { $_[0]; }else{ $_[1]; } } $mayor = maximo(37,23); #devuelve 37

o bien:
sub maximo { if( $_[0] > $_[1] ) { return $_[0]; }else{ return $_[1]; } } $mayor = maximo(37,23); #devuelve 37

Si no utilizamos "return", se devuelve el valor de lo ltimo que evaluramos. Adems de devolver valores escalares, podemos devolver valores ms complejos, como un array:
sub devolver_matriz { local(@matriz); $matriz[0]=hola; $matriz[1]=adios; return @matriz; } # Llamada a la subrutina que devuelve una matriz print devolver_matriz();

Buscando patrones en cadenas de texto. Expresiones regulares

Una expresin regular es una forma de expresar gramaticalmente la estructura de cualquier cadena alfanumrica. La forma en que se usan en Perl es muy similar a la que utiliza el comando grep de Unix. Dicho comando se suele utilizar para buscar en los ficheros de entrada (o bien en la entrada estndar) las lneas que contienen un patrn especificado.

Comando grep del Unix

La forma de utilizar este comando es bastante sencilla... lo complicado es especificar la expresin regular que defina los patrones que queremos buscar. Desde la lnea de rdenes llamamos al comando grep con la opcin -e para indicarle la expresin regular que queremos utilizar, y justo despus le indicamos los ficheros donde queremos buscar esa expresin regular. Por ejemplo:
$ grep -e "grep\|Unix" *.txt

nos buscar en los ficheros con extensin .txt del directorio donde estamos en ese momento cualquier lnea que contenga las cadenas grep o Unix. Adems de las alternativas en la expresin regular, especificada con el carcter |, podemos especificar rangos de caracteres, utilizando los corchetes ([ ]); un carcter cualquiera utilizando el punto (.); que cierto sub-patrn aparezca como mucho una vez (?) o que aparezca cero o mas veces (*) o que aparezca una o mas veces (+); etc, etc.

Formato de las expresiones regulares en Perl

Las expresiones regulares en Perl tienen la misma sintaxis que la utilizada por el comando grep de Unix. Para aplicar una expresin regular, necesitamos indicar la variable que contiene la cadena dentro de la cual vamos a buscar, el operador de "aplicar expresin regular", y el patrn que queremos buscar:
my $cad = "cadena en la que vamos a buscar el patrn"; $cad =~ /busca/;

Para utilizarlas, debemos encerrar entre // el patrn (mientras que en grep se colocaban indicadas con -e y entre comillas). Normalmente devolvern un valor lgico indicando si la variable sobre la que queremos aplicarla contiene o no el patrn. Si no se indica otra cosa, por defecto comparar la expresin con la variable "por defecto" $_. Por ejemplo:
/pepe/

devolver el valor cierto si $_ contiene la cadena pepe. Las instrucciones:

$_ = "hola pepe"; print "si\n" if (/pepe/);

imprimirn si, ya que la expresin regular devuelve el valor lgico de verdadero. Si queremos utilizar otra variable diferente a la $_ debemos utilizar el operador =~ , por ejemplo:
my $cad =~ /pepe/

es cierto si la cadena pepe est incluida en $cad Las expresiones regulares son sensibles a maysculas, as, la expresin:
my $cad = "Pepe come queso"; $cad =~ /pepe/;

es falsa, ya que $cad no contiene la subcadena pepe, aunque contenga la subcadena Pepe. El operador que hace lo contrario que el =~ es el !~ , as, la expresin:
my $cad = "Pepe come queso"; $cad !~ /pepe/;

es cierta.
my $cad = "Pepe come queso";

if($cad !~ /pepe/) { print "la cadena NO incluye el patrn"; } if($cad =~ /pepe/) { print "la cadena SI incluye el patrn"; }

Construyendo expresiones regulares complejas

La forma en que podemos construir expresiones regulares ms complejas que las vistas hasta ahora (especificadas por una cadena de caracteres simple) es la dada en las siguientes reglas: Una expresin regular se cumple para una cadena dada si alguna de las alternativas de la expresin regular se cumple. Las alternativas se especifican separadas con el carcter |, se evalan de izquierda a derecha y se para de evaluar ante la primera coincidencia. Una alternativa se cumple si cada item que la compone coincide en el orden en que los items estn especificados. Cada item esta formado o bien por un modificador o por un tomo cuantificado. Los posibles modificadores son:

^ que indica que debe coincidir al principio de la cadena $ que indica que debe coincidir al final de la cadena \b que especifica los lmites de una palabra \B que especifica los lmites fuera de una palabra Los posibles tomos cuantificados son: {n,m} el tomo debe aparecer entre n y m veces {n,} el tomo debe aparecer al menos n veces {n} el tomo debe aparecer exactamente n veces * el tomo debe aparecer 0 o ms veces (como {0,}) + el tomo debe aparecer 1 o ms veces (como {1,}) ? el tomo debe aparecer 0 o 1 veces (como {0,1}) una cadena tal cual, encerrada o no entre parntesis un . especifica cualquier carcter salvo el retorno de carro una lista de caracteres entre corchetes ([ ]) especifica uno de esos caracteres. Un carcter ^ delante de los corchetes niega la clase. se pueden especificar rangos en los corchetes, de la forma a-z \n retorno de carro (nueva lnea) \r retorno de carro (vuelta al principio de lnea) \t tabulador \d un dgito (igual que [0-9]) \D un carcter que no sea dgito \w un carcter alfanumrico (como [0-9a-z_A-Z]) \W un carcter no alfanumrico \s un carcter de espaciado (como [ \t\r\n]) \S un carcter que no sea de espaciado un \0 seguido de un nmero corresponde con ese nmero en octal un \x seguido de un nmero hexadecimal corresponde con ese nmero en hexadecimal

Los tomos que podemos utilizar son:

Existen ciertos caracteres especiales:

Cualquier otro carcter "escapado" coincide consigo mismo. Cualquier carcter no mencionado coincide consigo mismo.

Aplicaciones para aplicar expresiones regulares

No solo disponemos de herramientas de shell como el comando grep, sino que tambin podemos utilizar las expresiones regulares tipo Perl mediante aplicaciones visuales. regexxer es un programa visual que permite utilizar expresiones regulares del tipo de Perl para buscar o sustituir patrones en ficheros de texto. Es una herramienta muy potente fcil de usar. Se puede descargar de http://regexxer.sourceforge.net/ La siguiente imagen muestra un ejemplo de bsqueda de la palabra "ustring" en un fichero de cdigo. Se especifica la expresin regular \bustring\b para que busque la palabra completa sin que forme parte de otras palabras mayores.

Enlaces
http://www.perl.com http://www.activestate.com/ http://merelo.net/tutoperl/ http://merelo.net/tutoperl/tutoperl18.html http://atc.ugr.es/pedro/tutoriales/cursos/perl/ http://atc.ugr.es/pedro/tutoriales/cursos/cgi/ http://www.amazon.com/exec/obidos/ASIN/0879305894/perltutobyjjmere http://http//samie.sourceforge.net/samiedoc/perlide.html http://http//www.activestate.com/Products/Komodo/