Programas en Pearl

4. Aspecto de un programa Perl

El siguiente script en el fichero ejemplo1.pl
es el típico ejemplo del hola mundo con el que se suele empezar
el aprendizaje de un lenguaje de programación:

#!/usr/bin/perl -w # El tipico hola mundo en varios sabores print 'Hola mundo\n'; print "Hola mundo\n"; print("Hola mundo\n");

Como vemos todos los scripts de Perl comienzan con la sentencia
#!/usr/bin/perl -w
que invoca al intérprete de perl, de forma
análoga a como los scripts para la shell tienen una línea
que invoca a la shell. El intérprete tiene varias opciones por línea
de comandos,  entre las que destacan:

-w	habilita varios warnings útiles (RECOMENDADO)
-W	habilita todos los warnings
-Idirectory	especifica los directorios donde se buscaran módulos para ser incluidos. Se permiten varios -I's
--help	muestra los posibles argumentos

Salvo la línea anterior, cualquier conjunto
de caracteres que venga después del símbolo #
se considera como comentario y termina en el siguiente salto de
línea.
Todas las líneas ejecutables terminan con
un ; 
al igual que en C o en Java
De las tres sentencias print (que imprime una
serie de caracteres en un stream - en este caso por la pantalla) las dos
últimas son equivalentes. Perl permite la notación funcional
(argumentos entre paréntesis) pero no es obligatorio seguirla.
La diferencia entre la primera sentencia y la
segunda se ve claramente en el resultado que muestran cada una por pantalla:

$ perl ejemplo1.pl Hola mundo\nHolamundo Holamundo

En rojo se ha puesto la salida que da el primer print.
Al igual que en C, se pueden mandar secuencias de escape en cadenas de
caracteres. En concreto la secuencia \n
es el salto de línea. Pero perl dispone de dos maneras de escribir
cadenas de caracteres: una con comillas simples '  

' en la que no se sustituye lo que hay
dentro (variables, secuencias de escape, ...) y otra con comillas
dobles "  "
en las que si que se realiza esa sustitución. Por tanto en
el segundo y tercer print se cambia de línea pero en el primero
no.

5. Variables y constantes. Tipos y operadores (página
man: perldata)

En Perl no es necesario declarar las variables,
aunque es un buen hábito de programación hacerlo. Hay tres
tipos de variables: escalares, arrays y arrays asociativos.

ESCALARES - ejemplo2.pl Las variables escalares anteponen al nombre identificador el símbolo $, es decir que los siguientes nombres harían referencia a variables escalares: $i  , $velocidad  ,   $nombre Son escalares los números (en sus diferentes bases: decimal, octal, hexadecimal), las cadenas de caracteres (ej: "Casa"), las referencias a variables (que como veremos son como una especie de punteros, es decir que contienen la dirección de otras variables), los descriptores de fichero (si bien estos últimos son una excepción a la regla de la notación, ya que no llevan el $ en el nombre), etc... Las constantes escalares no llevan ningún símbolo especial (salvo los propios de la base). Algunos ejemplos de asignaciones que se podrían hacer en un script son: $i = 2; $velocidad = 3.0e8; $hexadecimal = 0xF3A; $binario = 0b001010101; $octal = 036567; $nombre = "José"; $nombre = 'José'; En el caso de cadenas de caracteres, si van entre " " se sustituirían las secuencias de escape o variables por su valor(es), como ocurre en el siguiente ejemplo: $edad = 20; $apellidos = "García López"; $nombre = "Ana"; $frase = "$nombre  $apellidos  tiene $edad  años\n" $frase tendría el siguiente valor:   "Ana García López tiene 20 años\n" y el retorno de carro se produciría. Las variables escalares con contenido númerico se pueden sumar (+), restar (-), multiplicar (*), dividir (/) y hallar el módulo (%). Hay operadores de autoincremento (++) y autodecremento (--) , etc... Estos operadores y otros están muy bien descritos en la página del manual perlop Las cadenas de caracteres se pueden concatenar vía el operador concatenación (.) Hay una serie de variables escalares predefinidas por Perl y que podemos usar en todo momento. Normalmente suelen empezar por $ y en la mayoría de los casos le sigue algún carácter no alfanúmerico (ej: $_, $ | , $$ , ... ) Se pueden ver todas estas variables y su significado en la página man (perlvar)

ARRAYS - ejemplo3.pl Los arrays son colecciones de escalares que se acceden según una secuencia determinada. Los identificadores globales de array van precedidos por el símbolo @, mientras que para acceder a los elementos individuales, se usa el $, al ser éstos escalares normales. ejemplo: @persona1 = ($nombre, $apellidos, $edad); @persona2 = ("Juan", "González Pérez", 24); print $persona1[1];                      produciría por pantalla  "García López", mientras que print $persona2[2];                     produciría por pantalla el número 24 Los arrays segun vemos son colecciones de escalares pero que se acceden siempre en el mismo orden (y los índices van de 0 al número de elementos - 1) Ojo!! No es lo mismo $persona2[2] que $persona2, en el primer caso nos estamos refiriendo al tercer elemento del array @persona2, mientras que en el segundo caso nos referimos a una variable escalar $persona2 que no tiene nada que ver con el array. No hace falta reservar memoria para ellos (perl lo hace por nosotros y también se encarga de liberarla cuando ya no se use). Igualar un array a un escalar hace que el escalar contenga el número de elementos: ej: $nelementos = @persona2; hace que $nelementos valga 3. Sin embargo Perl ya nos proporciona una variable asociada a cada array que contiene su longitud. En el caso de @persona2 esta variable se llama $#persona2 Existen multitud de funciones para manipular arrays. Las más comunes:  pop - Extrae y devuelve el último elemento del array. La longitud del array se decrementa en 1 ej:   $edad = pop(@persona2); $edad valdrá 24 y el array persona será  ("Juan","Gonzalez Pérez") push - Añade un elemento o una lista al final del array, incrementando su longitud. ej:   push(@persona2,24); reverse - Devuelve un array con los elementos en orden contrario ej:  reverse @persona; sort - Ordena un array y devuelve un array ordenado. En condiciones normales la ordenación se hace comparando alfabéticamente strings (es decir, que los números se transformarían en cadenas de caracteres e irían antes que las cadenas de caracteres que no empiezan por un número) ej:  sort (@persona); splice, shift, unshift - Se encargan respectivamente de: extraer un subarray (o substituirlo por otro) de un array, extraer el primer elemento del array y añadir un elemento al principio del array Todas estas funciones y otras más están documentadas en la página man perlfunc También Perl pone a disposición una serie de arrays predefinidos. Entre los más conocidos están @ARGV (párametros que se pasaron al script pot línea de comandos), y @_ (parámetros pasados a una subrutina).

ARRAYS ASOCIATIVOS (HASH) -
ejemplo4.pl Los array asociativos son colecciones de escalares que se diferencian
de los arrays normales en el modo de acceder a sus elementos. Este acceso
se hace via una clave y no via un índice numérico. Son muy
usados en Perl.
Los identificadores de los arrays asociativos llevan delante el símbolo
%
y para acceder a un elemento se usa el formato  $identificador{
key
}
ej:
%personas = ();                             
Crea un hash vacío

$personas{"Juan"} 
= 23;

$personas{"María"}
= 21;


Asignar un array asociativo a una variable de tipo array hace que ésta
contenga los elementos del hash en la forma key, value, key, value, ....
ej:
@personas = %personas;
hace que @personas valga ( "Juan"
, 23 , "María"
, 21 )


Las funciones más comunes para los arrays asociativos son:


delete - borra un elemento (es decir un
par clave - valor ) de una array hash. También se puede usar para
arrays normales.
ej:   delete $personas{"Juan"};




each - Llamado en un contexto escalar devuelve
el siguiente valor en el hash. En un contexto de arrays, devuelve una pareja
(clave , valor)
ej:
$edad = each(%personas);                           
$edad valdrá 23
o 21

@item = each(%personas);

($key,$value)
= each(%personas);




keys - Devuelve en contexto escalar el
número de claves que hay en el hash. En contexto de array devuelve
un array con todas las claves.
ej:
$nkeys = keys(%personas);

@keys = keys(%personas);




values - Lo mismo que lo anterior pero
para los valores, en vez de para las claves.
También hay un array asociativo predefinido muy importante:
%ENV{ } que contiene las variables de entorno
pasadas por el proceso invocador al script de Perl