PDF de programación - jugando con perl v1 00

Jugando
con Perl

Una breve introducción a Perl

Por Nacho Cabanes,

www.nachocabanes.com

Versión 1.00

Pág. 1

Jugando con Perl – 1: Instalación y comprobación
Perl no es el lenguaje que más de moda esté en este momento, pero sigue ahí. Y dicen que es un
lenguaje potente, adecuado para automatizar tareas en un servidor, para crear CGIs o para
integrarlo con Apache en un servidor web, por ejemplo. Y de hecho, muchos servidores de
Internet lo incluyen, además de otros lenguajes que actualmente se oyen mencionar más, como
PHP, o como Python (otro que aprenderé pronto... ;-) )

El caso es que, aprovechando las vacaciones, he decidido dedicar algo de tiempo a aprender cosas
"nuevas". Y una de las que tenía en la lista es Perl. Cuento con la ayuda del libro "Perl in a
Nutshell", que adquirí hace ya algún tiempo y que hasta ahora no había mirado más que por
encima.

Iré avanzando y practicando, y dejando constancia de mis avances, por si a alguien más le
resultaran útiles.

Comenzaremos con un primer acercamiento. Un primer vistazo a la sintaxis básica del lenguaje
y al uso del intérprete bajo Windows.

Primer paso: descargar (e instalar) la versión "lista para usar" bajo Windows, desde

http://www.activestate.com/Products/ActivePerl/

Se trata de una descarga de unos 15 Mb de tamaño. En concreto, la versión que he descargado es
la 5.8.8, en formato MSI (instalador de Windows). La instalación es poco más que hacer 3 clics en
el botón "Siguiente". El resultado ocupa unos 78 Mb en el disco duro, y él mismo se encarga de
situarlo en el Path (o eso se supone), para que podamos usarlo desde cualquier otra carpeta de
nuestro ordenador.

Segundo paso: probar que funciona. Abro un intérprete de comandos (Inicio / Ejecutar / "cmd", o
bien Inicio / Todos los programas / Accesorios / Símbolo del sistema, en ambos casos bajo XP).

Está instalado de c:\Perl así que voy hasta esa carpeta (concretamente hasta su subcarpeta "bin",
que es donde se encuentra el intérprete):
c:
cd \perl\bin
dir

Y efectivamente, en esa carpeta hay 106 ficheros, en su mayoría ficheros EXE o ficheros BAT.

La sintaxis básica de Perl es muy parecida a la de C. Podemos escribir programas completos
(eso mañana), pero también pedir al intérprete que ejecute una única orden, usando la opción
"-e", así:
perl -e "print 'hola' "

Esto escribiría la palabra "hola" (sin las comillas, claro) en pantalla. Pero también podemos hacer
algo ligeramente más complejo, como

Pág. 2

perl -e "for ($i=0; $i<5; $i++) { print 'hola '; } "

que escribiría "hola hola hola hola hola " en pantalla.

Jugando con Perl – 2: Variables, print, if, while
Ahora vamos a ver alguna de las características básicas de Perl como lenguaje, para poder
comparar con otros como C.

Un ejemplo de cómo dar valores a variables y mostrar estos valores podría ser éste:

$x = 1;
$nombre = 'Nacho';
print "Hola, $nombre. x vale $x\n";

Como se puede ver, las variables "normales" (lo que en Perl se suele llamar "variables escalares")
tienen un nombre que comienza por el símbolo $, y no es necesario declararlas ni indicar qué tipo
de datos almacenarán, sino que se deduce a partir del contexto.

Por ejemplo, $x = 1 hará que la variable "x" almacene un número entero, de valor 1. De igual
modo, $nombre='Nacho' guarda la cadena de texto "Nacho" en la variable "nombre".

Las cadenas de texto se pueden delimitar entre comillas dobles o comillas simples. La diferencia es
que si se encierra entre comillas dobles, se sustituirán las variables que haya en su interior,
escribiendo el valor de la variable en vez del nombre.

Estas tres órdenes se podrían teclear en un fichero llamado ejemplo1.pl, y pondríamos este
programa en funcionamiento con
perl ejemplo1.pl

El resultado que obtendríamos sería
Hola, Nacho. x vale 1

(Al igual que en C, existen ciertos caracteres especiales, como el \n que nos permite avanzar de
línea).

Eso de que no sea necesario declarar variables tiene su parte negativa: en este programa
$nombre = 'Nacho';
print "Bienvenido, $nombr.";

lo que se muestra en pantalla no es "Bienvenido, Nacho." sino "Bienvenido, .", porque hemos
escrito mal el nombre de la variable.

(para evitar estos problemas, se puede obligar a que haya que declarar variables, ya veremos cómo).

Pág. 3

Muchas de las estructuras básicas (comparaciones, bucles) recuerdan mucho a las de otros lenguajes
como C. Un ejemplo podría ser:
$x = 5;
if ($x == 5) { print "x vale 5\n"; }
print "La tabla de multiplicar del 2 es:\n";
for ($i=1; $i<=10; $i++) {
print "2 x $i es " . $i*2 . "\n";
}
print "Y la tabla de multiplicar del 3 es:\n";
$i = 1;
while ($i<=10) {
print "3 x $i es " . $i*3 . "\n";
$i++;
}

La principal diferencia es que las llaves { y } después de las órdenes como "if" o como "for" son
obligatorias, aunque sólo haya una orden en su interior. Por otra parte, el punto (.) se usa para crear
una cadena formada por otras dos: $saludo = "Hola" . "Nacho"; haría que la variable "saludo"
contuviese el texto "HolaNacho".

(Existen más variantes, como "unless" o "until", que veremos en la próxima entrega).

Jugando con Perl – 3: Arrays
Ahora vamos a ver un poco sobre cómo manejar arrays (matrices, vectores) desde Perl.

La primera idea importante es que para declarar un array, el nombre de la variable no se precede
con el símbolo de dolar ($) sino con la arroba (@), y los valores se detallan entre paréntesis,
separados por comas:
@lista = (4, 3, 2, 1);

Se puede acceder a los valores individuales usando corchetes: el primer elemento sería @lista[0] y
el cuarto sería @lista[3]. También se puede contar "hacia atrás": el último dato sería @lista[-1] y
el penúltimo sería @lista[-2].

El tamaño se puede saber simplemente asignando el valor de un array a una variable "normal"
(una variable "escalar", siguiendo la nomenclatura de Perl):
$longitud = @lista;

También existe una orden que permite recorrer una array de forma más sencilla que un "for". Se
trata de "foreach", que se usa
foreach variable (lista) {
órdenes
}

Pág. 4

por ejemplo
foreach $nombre (@listaNombres) {
print $nombre . "\n";
}

Este sería un ejemplo completo de todo ello:
@listaNumeros = (10,20,30,35);
@listaNombres = ("Juan", "Pedro", "Alberto");
print "Los numeros son: ";
for ($i=0; $i<=3; $i++) {
print @listaNumeros[$i] . " ";
}
print "\nLos numeros (de otra forma) son: ";
foreach $i (@listaNumeros) {
print $i . " ";
}
print "\nLos nombres son: ";
foreach $j (@listaNombres) {
print $j . " ";
}
print "\nEl primer nombre es: ".
$listaNombres[0] . "\n";
print "El ultimo numero es: ".
$listaNumeros[-1] . "\n";
$cantidadNumeros = @listaNumeros;
print "La cantidad de numeros es: ".
$cantidadNumeros . "\n";
@listaNumeros = ();
print "Ahora la cantidad de numeros es: ".
@listaNumeros . "\n";

que tendría como resultado:
Los numeros son: 10 20 30 35
Los numeros (de otra forma) son: 10 20 30 35
Los nombres son: Juan Pedro Alberto
El primer nombre es: Juan
El ultimo numero es: 35
La cantidad de numeros es: 4
Ahora la cantidad de numeros es: 0

En el próximo apartado... las variantes en el manejo de if, while, etc...

Pág. 5

Jugando con Perl – 4: unless, until, next, last, redo
Hemos visto el manejo básico de las condiciones "if" y "while", pero estas órdenes dan más juego
del que parece:

Para que el código fuente sea más legible, tenemos también órdenes parecidas pero que
comprueban el caso contrario, como
unless (condición) {órdenes}

(las "órdenes" se ejecutaran en caso de que NO se cumpla la condición).

De igual modo, existe una orden similar a while, pero que repite mientras las condición no se
cumple (o "hasta que la condición se cumpla"):
until (condición) {órdenes}

Además, estas 4 ordenes (if, while, unless, until) se pueden usar también como modificadores, al
final de otra orden:
$y =5 if ($x <>
$y -- unless ($y==0);
print $y while($y <10);
...

pero hay más: también podemos encadenar varios "if" con "elsif":
if ($x <>
elsif ($x > 0) print "Es positivo";
else print "Es cero";

Si alguien viene de C y echa en falta "break" y "continue", también tiene equivalencias:

•
•

"last" hace lo que el "break": termina el bucle (for, while o el que se esté usando).
"next" equivale a "continue": termina la iteración actual del bucle y comienza la siguiente
pasada.

• También existe "redo", que da una nueva pasada sin volver a comprobar la condición.

Por cierto, la orden "goto" existe, pero como su uso es evitable casi siempre, no comento mas
sobre ella... ;-)

Jugando con Perl – 5: Expresiones regulares
Una de las grandes ventajas de Perl sobre otros lenguajes "más antiguos" como C es el manejo
más sencillo de cosas frecuentes, como las cadenas de texto. Otro es la enorme cantidad de
funciones incorporadas, que permiten hacer gran cantidad de cosas con una cierta sencillez. Otro
es el uso de expresiones regulares directamente desde el lenguaje. Eso es lo que vamos a ver hoy:
las expresiones regulares, y de paso, algo más sobre el manejo de cadenas.

En C, para ver si una cadena empieza por "a", haríamos algo como
if (texto[0] == 'a') ...

Pág. 6

Si queremos ver si empieza por "ab", la cosa se va haciendo más engorrosa
if ((texto[0] == 'a') && (texto[1] == 'b')) ...

Esto, además de ser más largo y más difícil, tiene "problemas menores": ¿si mi cadena tiene sólo
longitud 1, debería yo acceder a la segunda posición? La mayoría de los compiladores, si no se
cumple la primera parte de una condición unida por &&, no se molestarían en seguir
comprobando, pero... ¿y si mi cadena es "a"? Podría ir afinando un poco la comparación haciendo
if ((strlen(texto) >=2) && (texto[0] == 'a') && (texto[1] == 'b')) ...

Está claro que apenas una comparación tan sencilla como "empieza por ab en minúsculas" ya va
siendo engorrosa de programar en C.

En Perl todo esto es mucho más sencillo, gracias al uso de expresiones regulares. Vamos a ver
cómo se haría y luego detallamos qué hemos hecho:
$frase1 = "abcde";
if ($frase1 =~