Tutorial de PERL

Regularizando la situación

Expresiones regulares: comparación y sustitución

Una forma todavía más directa de trabajar con estos ficheros de texto que tienen una estructura regular (que son la mayoría), es usar expresiones regulares. Una expresión regular es una forma de expresar gramaticalmente la estructura de cualquier cadena alfanumérica. Por ejemplo, una cadena compuesta por una letra inicial, con una letra o un número a continuación se podría expresar de la forma siguiente

donde | expresa una alternativa y * indica que puede aparecer 0 o más veces. Pues bien, estas expresiones regulares se utilizan enormemente en PERL (de hecho ya hemos usado una, aunque compuesta por un solo carácter, en la línea 4 del programa anterior), y cada vez que hemos usado split. Las expresiones regulares se usan para hacer comparaciones, es decir, hallar si un texto sigue o contiene una determinada expresión regular, y también para sustituir una subcadena que cumpla una expresión regular por otra cadena.

La expresión regular más simple es la propia cadena con la que se quiere comparar; es decir, una cadena coincidirá consigo misma. Las expresiones regulares en PERL siempre van encerradas entre //, o bien m{} (las llaves pueden ser sustituidas por cualquier otro elemento que no esté incluido en la expresión regular), y si no se indica nada, comparará la expresión regular con la variable por defecto, $_, es decir, que /pepe/ será cierto si $_ contiene íntegra la cadena pepe. El programilla

$_ = "pepeillo"; print "si" if /pepe/;

imprimirá

si

Las expresiones regulares usan símbolos convencionales para referirse a grupos de caracteres y otros para repetición o señales de puntuación. En algunos casos, si el símbolo significa algo dentro de la expresión regular (o en PERL), se precede por \ (escape). Por ejemplo, . significa "cualquier carácter" dentro de una expresión regular; luego para referirnos al punto como tal, usaremos \.. También se usa \/,\? y \*, por ejemplo. Otras expresiones más complicadas incluirían repeticiones de símbolos; por ejemplo, \w+ casaría con cualquier palabra (un carácter alfanumérico repetido uno o más veces).

Tabla 4: operadores de expresiones regulares

. Describe cualquier carácter, excepto newline. ( ) Agrupa una serie de patrones en un simple elemento. +,*,? Coinciden con el elemento al que preceden repetido 1 o más veces, 0 o más, ó 0 ó 1. Seguidos por {N,M}, indican el número mínimo y máximo que debede aparecer; {N} significa exactamente N veces; {N,}, como mínimo N veces. [..] Indica una clase de caracteres, [^...] niega la clase, - indica un rango decaracteres, como [a-z]. (..¦..¦..) coincide con una de las alternativas. \w,\W coincide con los alfanuméricos, \W con los no-alfanuméricos. \s,\S con los espacios en blanco, \S con los que no lo son. \d \D con los numéricos, \D no-numéricos. \b,\B con límites de palabra, \B con el interior de una palabra. $,^ con el final de una línea o cadena y con el principio.

Para agrupar símbolos se usa el paréntesis, que además sirve para indicarle a PERL que con lo que coincida con la expresión en su interior se va a hacer algo. Para empezar, se asigna a la variable $&; pero además, podemos asignar a otra variable el resultado de la comparación; en general, una comparación con una expresión regular que incluya paréntesis devuelve una lista con todo lo que coincida con el contenido de los paréntesis

$zipi = "Pepeillo Gonzalez MacKenzie 8000";
@parejas = ($zipi =~ /(\D+) (\d+)/);

(el nombre de la variable y el símbolo =~ se pueden suprimir si la comparación se hace sobre la variable por defecto $_); @parejas contendrá ("Pepeillo Gonzalez MacKenzie",8000), ya que la primera expresión regular indica "uno o más caracteres no numéricos", mientras que la segunda representa "uno o más caracteres numéricos".

Por ejemplo, el fichero de paganinis usado en ejemplos anteriores anterior tiene la estructura siguiente: una o más palabras, separadas por un espacio, una cantidad (números y puntos), una hora (números y dos puntos) y una fecha (números y /). Esto se dice en PERL mediante la expresión siguiente(\D+) (\d+\.?\d+) (\S+) (\d+)\/(\d+)\/(\d+)que puede parecer un poco críptica (y en realidad lo es), pero cuyo significado se puede resolver mirando la tabla 4. Con esta modificación, el bucle central del programa totales.pl se queda reducido a

while(<>) {
    ($paganini, $pasta, $hora, $dia, $mes) = /(\D+) (\d+\.?\d+) (\S+) (\d+)\/(\d+)\/(\d+)/;
    $totalDia{"$mes-$dia"}+=$pasta;
}

Más compacidad no se puede pedir. Además, ya de camino, nos vamos ahorrando algunas variables. En la primera línea del interior del bucle se asigna la parte de la cadena que coincide con lo descrito en el interior de los paréntesis a cada una de las variables, es decir, divide la línea en cinco campos, cada uno de los cuales tiene un tipo diferente. Hay cinco pares de paréntesis, para cinco variables. Veamos cada expresión regular por partes.

La primera expresión regular es \D+. Como se ve en la tabla 4, \D coincide con todo lo que no sea numérico, y en particular letras y espacios. Este campo es problemático, porque puede incluir una o varias palabras; sin embargo, sabemos que el siguiente campo comienza por un número; por tanto, incluiremos en este campo todo lo que haya hasta que encontremos un número. Se puede insertar el código siguiente print $paganini; en el bucle para ver qué se incluye dentro de ese campo.

La siguiente expresión regular, (\d+\.?\d+), no describe otra cosa que un número real en notación de coma flotante, es decir, una o más cifras (\d+), seguidas o no por un punto (\.?, no olvidar que el punto tiene significado especial en las expresiones regulares), que a su vez debe de estar seguido por una o más cifras (\d+). Esta expresión regular coincide además con aquellos números sin punto enmedio.

Y la siguiente \S+ coincide con la hora, aunque quizás podría coincidir con cualquier cosa, simplemente coge todo lo que haya entre los dos espacios. En realidad, si pusiéramos toda la expresión regular anterior como(\S+) (\S+) (\S+) (\S+) funcionaría perfectamente.

Y para terminar,(\d+)\/(\d+)\/(\d+)coincide con el día, el mes y el año, que están separados por una barra diagonal.

Con estas expresiones regulares se pueden construir programas superpotentes, que convierten casi cualquier texto en casi cualquier otro. Incluso, si uno se atreve (nuestro político corrupto no creemos que se atreva) un analizador sintáctico de un lenguaje de alto nivel, aunque sea simplificado. Otra utilidad es hacer filtros de correo electrónico, o de noticias de USENET (de hecho, el killfile o fichero que incluye todas las expresiones regulares de mensajes que deben de ser borrados, usa expresiones regulares). También se pueden usar expresiones regulares en archie y en la Web; el problema es que la mayoría de las veces usan convenciones diferentes, pero en cualquier caso, nunca viene mal saberlas.

El político corrupto decide no contarle al señor X todo el dinero obtenido (por no mencionar a Hacienda), y poniéndose a trabajar sobre los ficheros generados anteriormente (como cliente.mas), elabora el siguiente programilla (changec.pl)

#!/usr/local/bin/perl -p
s/(\d+\.?\d+)/$&*0.85/e;

que ni siquiera pongo en un cuadro aparte, porque no merece la pena.

En este programa se introducen novedades desde la primera línea. Para empezar, se usa PERL con un switch en la línea de comandos, -p. Este switch indica que alredededor de lo que hay debajo hay que sobreentender el siguiente bucle

while(<>)
{
    s/(\d+\.?\d+)/$&*0.85/e;
    print;
}

Tabla 5: Switches o interruptores que se pueden usar en la línea de comandos

-n Incluye el bucle while(<>) {}alrededor de las órdenes del fichero. -p Incluye el bucle while(<>) {print;} alrededor de las órdenes del fichero. -a Modo autosplit, es decir, que al principio del bucle anterior incluye la orden split. -d Modo de depuración. En vez de ejecutar el programa, se ejecuta el depurador sobre el programa. -i[extensión] En combinación con -p y -n, en vez de imprimir en salida estándar, trabaja sobre el mismo fichero, creando una copia de seguridad con la extensión que se indica,

; es decir, un bucle que abre y lee del fichero que se pasa en la línea de comandos, ejecuta las órdenes encontradas en el fichero, y al final imprime la variable por defecto. Si el switch fuera -n en vez de -p no imprimiría.

También se incluye la nueva orden s///[switches]tomada, como otras órdenes, del editor de UNIX sed. En concreto, esta orden lo que hace es sustituir la expresión regular encontrada entre los primeros // por la expresión en los segundos. En este caso actúa sobre la variable por defecto, pero en general$zipi="pepeillo"; $zipi=~ s/p/q/g;daría "qeqeillo". El switch e que aparece al final de la orden en el programa indica que se tiene que evaluar la expresión que aparece en la segunda parte de la orden; el g que aparece aquí indica que se tiene que hacer una sustitución global, es decir, que tienen que sustituirlo todas las veces que aparezca en la primera expresión, no solo una vez.

Por último, la variable $& contiene la cadena que coincida con la expresión regular en la primera parte de la orden; los paréntesis indican qué parte de la expresión hay que asignar a tal variable. Si hay varios paréntesis, las cadenas correspondientes serán asignadas a las "variables" \1, \2 (dentro de la orden s), o $1, $2... fuera de la expresión (estas variables sólo funcionan un ratito, asi que no van a estar disponibles hasta que uno quiera; en caso de duda, es mejor asignarlas inmediatamente a otra variable.

Toda la información sobre expresiones regulares está en la página de manual perldoc perlre.

Ejercicios

Dado un fichero que contenga varias líneas en el formato siguiente: Apellido 1 Apellido 2, Nombre Nota como un número real poner los nombres en el formato Nombre Apell1 Apell2 Nota como Calificación (Notable, Sobresaliente, etc), ordenándolos por orden de nota. Dado un fichero que contenga URLs, o direcciones internet, generar otro que incluya alrededor de las mismas una referencia del tipo <a href=URL>URL</a>. Hacer un programa que imprima todos los ficheros de cabecera incluidos en un programa en código fuente C. Estos tienen el formato #include <nombre-de- fichero.h>. Comprobarlo sobre algún fichero el directorio /usr/include (en UNIX), o cualquier otro que pille a mano. En un programa en código fuente C o PERL, imprimir las líneas en las que comience un bucle for, e imprimir la variable de bucle que se usa. En un programa en código fuente C, sustituir todas las constantes definida usando la directiva de precompilación #define por su valor, definido en la misma orden.

Presentando lo impresentable

Usando subrutinas y secuencias de escape ANSI

Tanto trabajo está acabando con la salud de nuestro político. La campaña electoral está cerca, tiene que inaugurar unas cuantas obras inacabadas todavía, y decide descargarse de un poco de trabajo. Para ello contrata a un militante de base como experto de Informática con cargo a los fondos reservados. Este se encuentra un trabajo ingente, y para empezar decide facilitar un poco su labor escribiendo una utilidad que le permita sacar directorios un poco más monos. Y, ni corto ni perezoso ("Este chico llegará lejos", comenta nuestro político) escribe el programa dir.pl,que aparece en el listado siguiente.

Listado : Programa dir.pl

1 #!/usr/bin/perl 2  3 sub inverso { 4 #Añade la secuencia ANSI de escape para video inverso 5  return "@_"; 6 } 7  8 sub negrita { 9 #Añade la secuencia ANSI de escape para letra resaltada 10  return "@_"; 11 } 12  13 sub borra { 14 #Borra pantalla 15  print ""; 16 } 17  18 sub normal { 19 #Restablece modo normal 20  print ""; 21 } 22  23 &borra; 24 $dirSep = "/"; #Solo para MS-DOS 25  26  27 if ($ARGV[0] eq "" ) { 28  $dir = $dirSep; 29 }else { 30  $dir = $ARGV[0]; 31 } 32  33 #Abre directorio 34 opendir( DIR, $dir ); 35 while( $fichero = readdir( DIR ) ) { 36  push( @ficheros, $fichero ); 37 } 38 closedir( DIR); 39  40 #Cabecera del listado 41 $msg = "Listado del directorio ".&inverso( $dir ); 42 print "$msg\n";&normal; 43 print "=" x (length($msg) - length(&inverso(""))); print "\n"; 44  45 if ( $dir !~ m!\\$! ) { 46  $prefijo = $dir.$dirSep; 47 } else { 48  $prefijo = "$dirSep"; 49 } 50  51 foreach (sort @ficheros ) { 52  print &inverso( $_ ) if -f "$prefijo$_"; 53  print &negrita( $_ ) if -d "$prefijo$_"; 54  &normal; 55  print "\n"; 56 }

En este programa ya estamos hablando de palabras mayores. Para empezar, es un poco más largo. Para continuar, es sólo para MS-DOS o Win95, pero se puede adaptar más o menos fácilmente a cualquier otro sistema operativo cambiando el separador de directorios contenido en la variable $dirSep (: para el Mac, / para UNIX). El programa saca un listado del directorio, ordenado en orden alfabético, resaltando los directorios con un tipo de letra más brillante, y los ficheros en video inverso.

Se le llama de la forma siguiente

C:\> perl dir.pl <nombre del directorio>

Si no se da ningún nombre de directorio, toma el directorio raíz; para el directorio actual hay que introducir

perl dir.pl .

Veremos primero el truco de sacar las cosas en diferentes tonos, y que se expresan en el programa con extraños signos (para obtener la flechica p'atrás, se pulsa control-P, y sin dejar de pulsarlo, control-[; difícil, pero es así). El programa usa secuencias de escape ANSI, que son órdenes estándar para trabajar con terminales; son tanto aplicables a terminales UNIX (por ejemplo, los tipo vt-100 o ansi), como MS-DOS; en este último habrá que añadir la línea

device=c:\dos\ansi.sys

al fichero config.sys. Con estas secuencias de escape se puede imprimir en diferentes lugares de la pantalla, borrar líneas o la pantalla completa, y cambiar, como aquí, los atributos de partes de la pantalla, todo ello de forma más o menos independiente del sistema. Es algo así como el interfaz gráfico de usuario de los pobres.

El siguiente concepto que introduce este programa es el de subrutinas. Las subrutinas en PERL se pueden declarar en cualquier parte del programa, al principio o al final. Para declararlas, simplemente se precede el nombre de la subrutina con la palabra sub y se le sigue del bloque de instrucciones que se van a ejecutar. Pueden no utilizar parámetros (como borra y normal). En este caso se llaman precediéndo el nombre con el símbolo &, o bien escribiendo do borra. También se puede llamar a una subrutina con parámetros, en cuyo caso forman todos parte de la matriz @_, como se ve por ejemplo en la subrutina negrita. Los elementos de esta matriz son, como es natural, $_[0], $_[1] y así sucesivamente, aunque se pueden asignar todos de una vez a parámetros locales de la subrutina, de esta formalocal($zipi, $zape) = @_;En esta sentencia se declaran simultáneamente $zipi y $zape como variables locales y se les asignan los dos primeros parámetros que se le han pasado a la subrutina. Si no se declararan como local, las variables serían visibles por todo el programa, como sucede en el resto de las variables en PERL.

[v5]En realidad, local crea variables globales pero con valores locales; es decir, se crea una variable que se puede ver en todo el programa, pero cuyo valor se guarda al principio de la subrutina y se recupera al final de la subrutina. En la versión 5 se introduce la palabra clave my, que declara verdaderas variables locales. En la versión 5, por tanto, se suele preferir my para declarar las variables de las subrutinas. [/v5]

La lectura del directorio se hace a partir de la línea 31; para eso utiliza funciones similares a las que hay en C o Pascal; una funcion, opendir, "abre" el directorio, y las otras van leyendo secuencialmente los nombres de todos los ficheros de ese directorio y metiéndolos en la matriz @ficheros.

Luego, a partir de la línea 49, y utilizando los operadores -f y -d, que comprueban si el fichero cuyo nombre viene después es un fichero normal o un directorio, se va imprimiendo con los atributos correspondientes. Estos son un ejemplo de los operadores de fichero que se utilizan mucho en PERL (ver la tabla 4), y que vienen heredados de comandos similares en los shell de UNIX (como csh y bash), nosotros tenemos la suerte de poder usarlos en ms-dos también. Otros operadores figuran en la tabla 4.

Decodificando

Usando pack y unpack

En realidad, la contratación de este nuevo genio de la informática, al que ya le está buscando también colocación en la empresa que controla los ordenadores de la campaña electoral, le ha dejado algún tiempo libre a nuestro [censurado] político. Para emplear este tiempo libre, decide conectarse con eso que le ha dicho su amigo Borrell, que se llama internez o algo así; dentro de la internez, y de una parte especialmente yanqui llamada usanez o algo así, hay unos grupos de discusión de temas de máxima actualidad. En concreto, un grupo denominado alt.binaries.pictures.erotica.politics publica interesantes fotos de políticas de la oposición en actitud de debate (al menos eso es lo que le han contado).

Pero su gozo se encuentra en un pozo cuando sólo ve letras y más letras en los mensajes que le van llegando. Su informático residente le explica que vienen codificadas con un programa denominado uuencode, y que tiene que salvarlas cada una por separado y decodificarlas después, antes de verlas. Con la pericia que dan las ganas, escribe el siguiente programa, uudec.pl.

Listado : Programa uudec.pl

1 #!/usr/bin/perl 2  3 while( <$ARGV[0]>) { 4  5  open( IN, "<$_" ); 6  while (<IN>) { 7  if ( /begin \d+\s+(\S+)/ ) { 8  $fileName = $1; 9  open ( OUT, ">$fileName ); 10  } 11  print OUT, unpack("u",$_) if /^[MC]/; 12  } 13 } 14 close OUT;

Este programa utiliza la orden unpack para decodificar cadenas, y las escribe en salida estándar. La descripción es incluso más corta que el programa. Los mensajes en ciertos foros de USENET vienen divididos en varias partes, cada una de las cuales contiene un pedazo de un fichero codificado con uuencode (puede ser un .GIF, un .WAV o cualquier otro). Para usar el programa, se salvan todas las partes del mensaje correlativamente en un fichero. El programa busca primero el nombre del fichero codificado, que aparece en una línea de la formabegin 644 nomfich.gif, abre un fichero con ese nombre, y va escribiendo en él las cadenas decodificadas.

Para llamar a este fichero, se escribe

UNIX% uudec.pl fichero.uu

y se crea el fichero codificado, que luego podrá uno contemplar con su visor de GIFs preferido (o escuchar con la SoundBlaster). Se pueden dar comodines en la línea de comandos; el bucle lo irá abriendo uno por uno.

En realidad, la orden unpack decodifica de formatos de codificación internos a cadenas; la orden pack hace exactamente lo contrario. La utilidad de todo esto se me escapa un poco, salvo que, por ejemplo, se quieran almacenar números reales de forma que pueda leerlos directamente un programa en C. En ese caso, se escribiría

print pack( "f", $zipi);

Un número real escrito así se podría leer directamente con la orden read del C (pero, ojo, no con la scanf, que sirve solamente para ficheros de texto). Otra forma de usarlo es para formatear ficheros de salida; usando

print
pack("A7",$cadena)

, haremos que la salida ocupe justamente 7 caracteres,ni más mi menos; así aparecerá todo en bonitas columnas. Por ejemplo, nuestro archiconocido memoria.pl se podría convertir en este memoria-col.pl

1 #!/usr/bin/perl
2 until(0) {
3      print "Cliente, cantidad\n";
4      chop($_ = <>); 
5      last if !$_;
6      ($paganini, $cantidad) = split(/,/,$_);
7      $comision = $cantidad * 0.25;
8      ($seg, $min, $hora, $dia, $mes, $anho, @zape) = localtime(time);
9      $mes++;
10      $zipi = pack("A16",$paganini).pack("A7",$comision)."$hora:$min $dia/$mes\n";
11      push( @mem, $zipi );     
12 };
13 
14 print @mem;

Este programa, sobre el fichero siguiente

uno, 1605168
este es el dos, 166166
este puede ser el tres, 1616136

produciría la siguiente salida

uno             401292 19:54 25/7
este es el dos  41541.519:54 25/7
este puede ser e404034 19:54 25/7

(dependiendo, claro está, de cuando se hayan producido las susodichas transacciones cambiarán horas y fechas).

Todo bajo control

Usando tuberías para controlar otros programas

Cuando nuestro político corrupto descubre que UNIX tiene ya preprogramadas muchas de las funciones que le hacía el militante de base, lo despide y decide usar esos programas de UNIX desde, por supuesto, un programa en PERL; además, decide tirar Windows95 a la basura e instalalarse Linux. Por ejemplo, para contar las palabras que hay en un fichero basta con usar la orden wc de UNIX. Pero si se presenta en modo bonito, puede salir el siguiente programa, llamado wc.pl

#!/usr/bin/perl
while (<*>) {
    ($zipi, $lineas, $palabras, $bytes, $nombref) = split(/\s+/,`wc $_`);
    print "El fichero $nombref tiene $palabras palabras y $lineas lineas\n";
}

La primera línea del bucle usa una bonita capacidad de PERL, llamada globbing o generalización. Lo que hace es que, si se pone algún comodín de ficheros del tipo * repetirá el bucle para cada fichero que cumpla ese patrón, asignando el nombre del fichero a la variable por defecto. Ese nombre se le pasa al comando wc, usando ``, es decir, comillas invertidas, que ejecutan un comando en UNIX devolviendo su salida estándar. Esa orden completa agarra la salida del comando, del tipo
lineas palabras bytes nombre del fichero
y la parte en sus componentes. Como las diversas palabras están separadas por varios espacios o tabuladores, se una el patrón \s+. Al principio de la línea hay una serie de espacios, por lo que el primer componente devuelto no tendrá nada.

Hay otra forma diferente de controlar programas en UNIX, esta vez interactivamente, usando los denominados pipes o tuberías, que se suelen indicar con el carácter |. Por ejemplo, la orden open( FICHERO, "|pepe" ), abre una tubería a la orden pepe, que a partir de entonces ejecutará los comandos que reciba del programa en PERL, ya que éste programa le suministrará la entrada estándar. Esto se puede usar de la siguiente forma (si se dispone del programa gnuplot):

open( GNU, "|gnuplot" );
print "Fichero a trazar? "; chop($fileN = <STDIN>);
print GNU "plot \"$fileN\" with lines 1\n";

que abrirá una tubería al programa y le enviará la orden para trazar un fichero con líneas. Con este tipo de órdenes y con gnuplot, y con unas pocas ganas, se pueden hacer animaciones. Sin embargo, hay que tener en cuenta que sólo se podrá hacer con programas que acepten comandos por su entrada estándar.

El cofre de la sabiduría

Como usar los módulos y librerías en programas en perl

Como nuestro político corrupto^TM ya es todo un guru de perl, la secretaría de prensa del partido decide encargarle el seguir en la Internet todos los sitios web que hablen del Señor X, para luego poder así denunciar la conspiración judeo-masónica-telefónica-mundial (o séase, de El Mundo) en contra de la democracia y de sus figuras más prominentes. Por eso, decide hacer un programa que cuente todas las páginas en las que aparece la cadena "Señor X"; así luego puede hacer un gráfico con su evolución y ver si la cosa va a más o a menos. Decide usar el buscador Altavista, ver el número de páginas que devuelve, e imprimirlo. Para ello, hace el siguiente programa (altax.pl):

1  #!/usr/bin/perl
2  
3  use LWP::Simple;
4  use URI::Escape;
5  
6  my $codedQuery = uri_escape( '"Señor X"' );
7  my $url="http://www.altavista.com/cgi-bin/query?pg=q&sc=on&hl=on&q=$codedQuery&kl=XX&stype=stext&search.x=27&search.y=7";
8  print "Conectando a $url\n";
9  my $respuesta = get( $url );
10 my ($encontrados) = ($respuesta =~ /\S+;(\d+) pages found/gs);
11 print "Encontradas $encontrados respuestas\n";

Este programa imprimiría algo así como

Conectando a http://www.altavista.com/cgi-bin/query?pg=q&sc=on&hl=on&q=%22Se%F1or%20X%22&kl=XX&stype=stext&search.x=27&search.y=7
Encontradas 49 respuestas

Este programa, tal cual, seguro que no funciona en un ordenador. Usa un par de librerías (o "bibliotecas" para los puristas), que no se encuentran en la instalación estándar de PERL: la LWP::Simple y la URI::Escape. Lo primero que habrá que hacer es bajarse e instalar estas páginas.

Si está uno en Windows, es bastante fácil. Con la instalación de PERL viene un programa, ppm, que sirve directamente para bajarse e instalar módulos. Simplemente tecleando ppm, y luego

ppm> install  LWP::Simple
ppm> install  URI::Escape

el programa baja, compila si es necesario, y prueba los dos módulos. A veces esto que parece tan simple no lo es, porque necesita compiladores externos y otra serie de cosas, pero si hay suerte, todo irá bien. Con ppm se pueden usar otras órdenes, tales como

ppm> search WWW

que dará una lista de todos los módulos que incluyan WWW en su nombre. En este caso, además, las dos librerías vienen en un sólo paquete, el libwww-perl, que se puede bajar uno sólo tecleando install libwww-perl

En Linux y otros Unixes, es un poco más complicado, pero no mucho. Todos los módulos para PERL se crean y empaquetan de una forma estándar. Tras localizarlos, habitualmente en alguno de los sitios CPAN (http://www.cpan.org), se hace lo siguiente:

[yo@localhost tmp]# tar xvfz libwww-perl-5.47.tar.gz
libwww-perl-5.47/
libwww-perl-5.47/t/
(más cosas...)
[yo@localhost tmp]# cd libwww-perl-5.47
[yo@localhost libwww-perl-5.47]# perl Makefile.PL
(aquí comprobará que todas las librerías que se necesitan previamente
están instaladas, y crea un Makefile)
[yo@localhost libwww-perl-5.47]# make
[yo@localhost libwww-perl-5.47]# make install
(y también, si se quiere)
[yo@localhost libwww-perl-5.47]# make test

En este caso, también se acaba antes bajándose, para empezar, el módulo CPAN.pm, con el cual, tecleando perl -MCPAN -e shell; tiene uno un entorno similar al que hemos mencionado antes para Windows. Eso sí, para instalar algo hará falta, tanto en este caso como en el anterior, ser superusuario.

Las librerías no sólo instalan el código, instalan también los manuales correspondiente. En este caso, se puede consultar el manual escribiendo perldoc LWP; y merece la pena hacerlo, porque nos encontraremos muchas cosas interesantes. Como indicamos en la sección sobre el zen del PERL, merece la pena conocer bien las librerías antes de ponerse a hacer cualquier cosa en PERL, porque en la mayoría de los casos se encontrará con la mitad del trabajo hecho.

Además, en este caso las librerías son dos palabras separadas por ::; esto es porque los módulos están organizados en una especie de jerarquía. Cada módulo puede estar dentro de una jerarquía o no, dependiendo de lo que quiera el autor y dependiendo de su funcionalidad. En este caso, Simple está dentro de LWP (lib-www-perl), porque va de eso; pero hay muchas más de la misma familia (por ejemplo, LWP::UserAgent un módulo más flexible para bajarse páginas). Lo mismo ocurre con el otro módulo.

Ya que tenemos las librerías instaladas, podemos ir al programa. Las dos líneas que empiezan por use importan las librerías. En realidad, hacen algo más que eso: traen todos los identificadores de la librería al espacio global de nombres, de forma que podemos usar las subrutinas y variables de la librería como si hubieran sido declaradas en el mismo programa. En realidad, en este caso usamos sólo una función de cada librería, así que, para no contaminar el espacio de nombres, podríamos haber escrito

use LWP::Simple qw(get);
use URI::Escape qw(uri_escape);

con exactamente el mismo resultado. Esta expresión, aunque pueda parecer un poco rara, usa el mecanismo quote del PERL, que sirve para definir matrices, cadenas y otras cosas sin necesidad de escribir demasiado; o séase, que se ahorra uno comillas, comas y cosas por el estilo. qw( a b c) equivaldría a ('a','b','c'). Por supuesto, el operador qw y todos los demás por el estilo (ver la página de manual perlop) pueden usarse en cualquier punto del programa PERL.

Hasta ahora, en realidad, no hemos hecho nada, salvo importar las librerías; el programa de verdad empieza en la línea 6, que requiere un poco de explicación. Usa la subrutina uri_escape del módulo URI::Escape, que sirve para codificar cadenas que incluyan caracteres no alfanuméricos de forma que se pueda incluir dentro de un URL o dirección Web, tal como la que usan los buscadores. En este caso, la cadena contiene espacios, comillas y la letra ñ, que no puede ir tal cual en un URL. Por eso se codifica, quedando así: %22Se%F1or%20X%22. Generalmente, cuando se vayan a hacer peticiones a buscadores desde un programa, habrá que hacer este tipo de codificación.

El URL que se va a solicitar se compone en la siguiente línea. El único truco aquí es ver que la petición que se hace a Altavista va dentro de la variable q (no tienes más que hacer una búsqueda de cualquier palabra, y ver dónde aparece en el URL de la respuesta); eso se puede ver mirando al código HTML de la página, si no es demasiado complicado. En este caso, encontramos una línea HTML que dice:

<input type=text name=q size=35 maxlength=800 value="">

con lo cual, se ve que la variable q es la que contiene la petición del usuario. Algo similar se puede hacer en casi todos los demás buscadores.

La dos líneas siguientes imprimen un mensaje, y se bajan efectivamente el URL. La función get está sacada del módulo LWP::Simple, y simplemente se baja una página y la mete en una variable. También se puede imprimir usando getprint o meterse en un fichero usando getstore. Como siempre, más información escribiendo perldoc LWP::Simple.

Finalmente, usando expresiones regulares (¿recuerdas las expresiones regulares? Mira en Regularizando la situación) se extrae el número de páginas que se han encontrado, y se imprime. Y nuestro político corrupto, finalment, comprueba que últimamente ya casi ni se habla del tema.

Ejercicios

Usando el módulo Benchmark, medir cuanto tarda en ejecutarse el código anterior. Programar también una petición similar para otro buscador, y comparar ambos resultados. Localizar una librería que sirva para hacer gráficos bidimensionales en PERL (pista: es parte de la jerarquía Chart), y usarla para hacer el histograma que se propuso en el tercer ejercicio del bloque segundo.

[/v5]

Algunos consejos

Ya que hemos aprendido todo lo que debíamos aprender sobre PERL, no está de más dar unos cuantos consejos para realizar buenos programas.

Mucho cuidado con los espacios, con los puntos y comas y los demás caracteres que no están ahí de adorno

Un espacio entre el $ y el nombre de una variable, dará un error de sintaxis. O un espacio entre el # y el !, que dará un error extraño, ya que el shell interpretará el resto de la línea como un comentario. Y no olvidemos nunca el ; al final de las sentencias, ni las llaves alrededor de cualquier bloque, como por ejemplo en los bucles.

Sigue siempre la via PERL

Aunque nos permita recurrir a lo que conocemos de otros lenguajes, PERL permite hacer las cosas de forma mucho más compacta, elegante y a veces rápida. Por ejemplo, en vez de

$zipi= $matriz[0];
$zape = $matriz[1];

en PERL se puede hacer:

($zipi,$zape) = @matriz;

O para dividir algo como "González McKenzie, Pepeillo", lo más rápido es ($Ap1, $Ap2, $Nombre) = /(\S+) (\S+), (\S+)/; (previa asignación a $_); en vez de utilizar split dos veces. O @fichero= <FILE>; en vez de usar un bucle para leer el fichero línea a línea. Los operadores de asignación de matrices, las variables asociativas y las expresiones regulares son fundamentales en casi cualquier programa PERL; dominarlas es alcanzar el Zen del PERL

Aprovéchate del depurador

Tiene órdenes bastante simples, y permite hacer muchas cosas; de hecho, todo lo que se puede hacer con PERL. Aunque parezca un poco espartano, es la mejor opción para empezar a crear un programa.

Conoce tus bibliotecas

Aparte de las muchas librerías estándar que trae PERL, hay otras, disponibles sobre todo en el CPAN, para hacer casi todo, desde acceso a base de datos hasta realizar tablas astrológicas. El conocer qué librerías hay disponibles, o mirar antes ahí, ahorrará mucho trabajo.

Preguntas frecuentemente preguntadas

¿Cómo se pueden hacer CGIs en PERL?¿Qué diferencia hay entre CGI y PERL?

CGI no es un lenguaje, es una forma de escribir programas que se pueden escribir en cualquier lenguaje; en especial, se pueden escribir en PERL; que está especialmente diseñado para ello. Escribir un CGI en PERL es tan simple como esto:

print "Content-type: text/html\n\n";
print "Hola";

. Por supuesto, habrá que colocarlo en la zona correspondiente del servidor para que sea accesible como CGI. Otra forma, a partir de la versión 5, es:

use CGI;
print header, start_html, title('titulo'),end_html;

que usa el módulo estándar CGI.pm, que sirve precisamente para escribir CGIs. Más información, escribiendo perldoc CGI

¿Cómo se puede acceder a una base de datos en PERL?¿Qué bases de datos puedo usar?

Lo más fácil es usar el módulo DBI (que, como todos los demás, está en el CPAN), con un driver específico para el gestor de bases de datos, o si hay ninguno específico, y la BD está accesible usando ODBC, pues con ODBC. En WinXX hay un módulo alternativo, específico para ODBC, denominado Win32::ODBC. Con cualquiera de estos dos módulos, se puede usar con cualquier SGBD; en Linux/Unix, se puede usar con MySQL o MiniSQL, o Postgres; y en Windows se puede usar con Microsoft SQL server combinado con ODBC. Eso sí, como es inherente a las conexiones ODBC, es más bien tirando a lento.

Tengo este error en un programa en PERL. Por favor, ¿puedes echarle un vistazo a ver qué le pasa? O, una variación de la anterior: por favor, ¿puedes mandarme un programa que haga tal cosa?

Pues generalmente, no. Bastante tengo con hallar los errores de mi código, para ponerme a hallar los errores ajenos. Y en cuanto a la segunda, si lo tuviera y quisiera darlo, estaría entre los ejemplos, y si no está, en fin, hay gente que se gana la vida programando el PERL, echadles una mano... Ojo, esto no significa que no podáis preguntarme dudas, estoy encantado de contestarlas. Pero no corregir programas ajenos, o hacer programas para alguien (aunque por un módico precio, podemos llegar a un acuerdo). En estos casos, lo mejor es que escribáis a alguna lista de correo que trate de PERL, tal como PERL-ES; seguro que habrá gente encantada de ayudaros.

¿Funcionan exactamente igual los programas PERL en Windows y en Unix?

En general, sí. En particular, hay algunas cosas que no funcionan de la misma forma: por ejemplo, la orden fork no funciona (salvo en la nueva versión 5.6), el acceso a base de datos no se hace igual (se usa el módulo DBD/DBI en Linux y en Windows, generalmente, el Win32::ODBC, aunque también se puede usar el mismo); para ejecutar un programa en PERL hay que definir una serie de cosas. Pero en general, cualquier programa que no use ninguna característica específica de un sistema operativo funciona exactamente igual en los dos sistemas operativos. Y si hay alguna duda, se puede insertar código particular detectando el valor de la variable $OSNAME, $^O o $Config{osname} . Por ejemplo, se puede hacer algo así:

if ( $^O eq 'linux' ) {
    [código específico para Linux];
} else {
    [código para otros SOs menos afortunados];
}

¿Existe algún sitio web, preferentemente gratuito, donde se puedan poner scripts en PERL?

Pues me temo que no, al menos que yo sepa. Si alguien sabe de alguno, por favor que avise. Algunas universidades sí permiten a sus alumnos ponerlos, con restricciones, pero la mayoría ofrece sólo unos scripts predeterminados (tales como contadores o libros de visitas).

Oye, qué tutorial más chachipiruli tienes. ¿Puedo copiarlo a mi sitio web, o incluirlo en un CD que voy a repartir, o que voy a vender? En resumen: temas de licencia y copyright

La respuesta corta es no, si y no; la respuesta larga es que, en general, no permito que se copie este tutorial en un sitio web ajeno, salvo que ese sitio tenga acceso restringido, es decir, que no se pueda ver desde cualquier parte de la Internet, o el acceso desde cualquier otro punto de la Internet sea demasiado lento. En cuanto a los CDs, si los CDs son de algún modo comerciales, es decir, se venden a un precio que supone ganancia para el que los vende, no, no hay permiso; si los CDs son sin ánimo de lucro, gratuitos, parte de un curso, o incluidos junto con otras muchas cosas en una revista, sí, si hay permiso, siempre que se incluya tal cual, y se me mande una copia (inclusive revista, si fuese así) a

JJ Merelo
Depto. Arquitectura y Tecnología de Computadores
Facultad de Ciencias
Campus Fuentenueva, S/N
18071 Granada (España)

Todo esto, por supuesto, afecta también a cualquier parte del tutorial o a los ejemplos que se incluyen con el mismo.

Bibliografía.

PERL viene con todo el material necesario para trabajar; en el caso de la versión 4, con una macro-página de manual en formato UNIX, y en el caso de la versión 5, con varias páginas de manual, e incluso páginas de manual en HTML. Hay, además varios libros publicados:

En castellano, se pueden encontrar los siguientes libros en BOL :
PERL. Páginas Web interactivas Palacio, Juan El único libro escrito en España. Muy completo, y enfocado principalmente a la programación de CGIs.	Guía de referencia para programadores de PERL 5 Duncan, Luke, Wyke, R. Allen
Perl 5 al descubierto Husain, Kamran	Programación en CGI con Perl 5 Herrmann, Eric

• Programming PERL, de Larry Wall y Randall L. Schwartz, O'Reilly and associates. Se le suele llamar "The Camel Book" por el camello de la portada. Escrito por el gran guru, incluye manual de referencia, muchos ejemplos, y una explicación de cada una de las estructuras.
  
  
  
• Learning PERL, de Randall L. Schwartz y otros, O´Reilly and associates. El "Llama book"; se puede obtener de la misma forma, por ejemplo, de Amazon. Si quieres aprender, después de leer este tutorial, puedes seguir con este libro. Más educativo que el anterior.
  
  
  
  
• Perl cookbook, de Larry Wall y otros, un libro con un montón de ejemplos, que muestra todo lo que puede hacer PERL, desde CGIs hasta conectar con otras máquinas usando telnet. A este se le debe conocer por el libro del cabrito, o algo así.
  
  
  
  
• The Perl Cd Bookshelf : 6 Bestselling Books on Cd-Rom, todos los libros anteriores, y además en CD-ROM, para poder buscar lo que a uno le interesa. Imprescincible.
  
  
  
  
  
  
• Programming the Perl DBI por Alligator Descartes, Tim Bunce , que explica claramente cómo usar este módulo que sirve para acceder a bases de datos, y una introducción general sobre cómo trabajar con bases de datos y PERL.
  
  
  
  
• Teach yourself PERL in 21 Days, David Till, SAMS Publishing; un tocho considerable que me encontré en una librería al lado de la Facultad. Muy completo, pero no tan divertido como el "Camel Book". Por cierto, que me lo han chorizado, por favor, si alguien lo ve, que me lo diga.
• Developing Applications in PERL, de Tom Christiansen, Byte, April 1994, p. 231-236.

Además, se han publicado tutoriales en diversas publicaciones, como UNIX World (Mayo-Julio 1990), y en la fenecida revista Click!, de marzo a junio de 1995 (una versión anterior de este mismo tutorial).

Recursos Internet

Enlaces a sitios en internet que hablan sobre PERL

• Alguna cosilla hay en http://www.perl.com/, sitio central dedicado al PERL. Este sitio contiene noticias, listas de correo, enlaces a todos los sitios de donde puede uno bajarse las diferentes versiones de PERL.
• Los sitios CPAN (Comprehensive Perl Archive Network), o red de sitios con archivos, módulos, y librerías relacionados con el PERL.
• Los sitios PerlMongers (http://www.pm.org) están dedicados a grupos de usuarios de perl; y también hay un http://www.perl.org/.
• La versión para WindowsNT/98/95/2K se puede bajar de la empresa ActiveState http://www.activestate.com/.
• Hay unos cuantos grupos de usenet dedicado al PERL; comp.lang.perl, tiene un tráfico de unos 100 mensajes al día, y normalmente los propios desarrolladores de PERL, Larry, Tom Christiansen (que, por cierto, habla español) y Randy Schwartz contestan a tus dudas. Mucho tráfico, pero nada que no pueda salvar un buen killfile; otros grupos se dedican a anuncios comp.lang.perl.announce, y a una version de PERL combinada con tcl/tk, el tkPerl, comp.lang.perl.tk.
• PERL para DOS: ftp://src.doc.ic.ac.uk/packages/ibmpc/simtel/perl; en el mismo sitio hay versiones para el Mac y el Amiga.

Además, hay una serie de sitios sobre PERL que están en castellano

• En el Yahoo español hay bastantes punteros a recursos en castellano, varios cursos, sitios con código y demás.
• Otro sitio en castellano, Código PERL, con programas de ejemplo y tutoriales. Enfocado sobre todo a programar CGIs en PERL. Estas páginas se encuentran también en Programacion.net.
• El sitio de PERL en español, creado por el grupo de usuarios de PERL en Tijuana, México, con enlaces a varios tutoriales y FAQs traducidas al español.
• Hay diversas listas de correo que tratan de PERL en español, muchas de ellas alojadas en eGroups (no hay más que buscar perl). La principal es perl-es. Tiene mensajes de todo tipo, desde el básico hasta el avanzado, y viene a tener 1-2 mensajes al día.
• Un tutorial bastante extenso, y en postscript, es el escrito por Diego Sevilla, que es además uno de los habituales en la lista. Es muy completo, y llega incluso a explicar cómo acceder a bases de datos por ODBC en Windows (el enlace al tutorial de PERL está al final de la página.
• El que tiene la portada más cachonda es la guía del programador, con lo de PERL lava más blanco y demás. Sirve para principiantes, pero también explica como programar server side includes y CGIs.
• Uno de los clásicos, la introducción al lenguaje PERL, de Víctor Osuna, en la Universidad de Córdoba (España), en la que todavía parpadean los fallos HTML y la fecha de última modificación, hace 4 años.Incluye ejercicios, una pequeña guía de referencia, y llega hasta las expresiones regulares. Bastante básico, pero está bien si quieres aprender expresiones regulares.
• Desde Colombia, nos llega El Evangelio de PERL, un tutorial bastante avanzado, que incluye cómo usar referencias y otras características de la versión 5. El HTML es un poco espartano, eso sí.
• Tutorial de PERL del Departamento de Comunicaciones de la ITESO, en México. Una buena introducción, pero con cosas avanzadas como los scripts suid.

Notas

1. Aunque el comportamiento es ligeramente diferente en UNIX y msdos; mientras que este separa las líneas con un retorno de carro y linefeed, UNIX y el Mac usa solo un linefeed. En cualquier caso, \n se comporta de la misma forma en los dos.

2. Tener en cuenta que UNIX y Windows95/NT distinguen entre nombres en mayúsculas y minúculas, a diferencia de MS-DOS. Aunque en realidad Windows NT no lo hace demasiado bien.

3. Aunque hay todavía una forma Más Fácil de Hacerlo.