Introducción al Perl

1. ¿Qué es Perl?
Perl (Practical Extraction and Report Languaje) es un lenguaje creado a principio de los
noventa por Larry Wall, el cual lo realizó casi como una obra altruista, por eso, su
distribución es gratuita.

Perl es un lenguaje pensado para la manipulación de cadenas de caracteres, archivos y

procesos. Esta manipulación se va simplificada por el importante número de operadores a
disposición del usuario. El lenguaje Perl se percibe habitualmente como un lenguaje
intermedio entre los shell scripts y la programación en C. En efecto, los programas en Perl
son una sucesión de instrucciones y son similares a los shell scripts porque no existe un
procedimiento principal como la subrutina main en C. Sin embargo, se parece al lenguaje C
en su sintaxis y en el número importante de funciones que permiten la manipulación de
cadenas de caracteres y archivos.

El lenguaje Perl no es precompilado, pero aún así es más rápido que la mayoria de
lenguajes interpretados, en especial que el Bourne Shell. Esto se debe a que los programas
en Perl son analizados, interpretados y compilados por el interprete perl antes de su
ejecución.

Estas características hacen que el mantenimiento y la depuración de un programa en Perl

sean mucho más sencilla que el mismo programa escrito en C.

Por todo esto, Perl es un lenguaje muy utilizado en los dos campos siguientes:

1. La administración de sistemas operativos. Debido a sus características Perl es muy

potente en la creación de pequeños programas que pueden ser usados como filtros para
obtener información de ficheros, realizar búsquedas, etc. Además, aunque Perl nació en un
entorno Unix, hay versiones para casi todas las plataformas existentes.
2. La creación de formularios en la Web. Es decir, se utilizan para la creación de scripts
CGI (Common Gateway Interface). Estos scripts realizan el intercambio de información
entre aplicaciones externas y servicios de información, es decir, se encargan de tratar y
hacer llegar la información que el cliente WWW manda al servidor a través de un
formulario.

2. Acerca de las versiones de Perl.

Actualmente existen dos versiones altamente populares de Perl, la 4.3 y la 5.0, de hecho
hay diferencias importantes entre una versión y otra. Seguramente el lector se pregunta
porque surge la duda entre usar una versión vieja y una nueva, por regla general las nuevas
versiones son mejores que las anteriores de modo que las opacan en todo sentido, Perl no es
la excepción a esta regla, el único factor que impide una transición inmediata es que no son
100% compatibles. La versión 5 de Perl es una reescritura total que ya incluye un manejo
de estructuras abstractas de datos mucho mas poderoso, incluso, soporta la orientación a
objetos a su manera (lo que rompe en gran medida con la filosofía tradiconal de Perl de
una programación más parecida a los Shells de Unix que al modular lenguaje C). De
modo que las librerías, por ejemplo para creación de CGIs no funcionan de una función a
otra por lo que la migración es poco practica.

En este tutorial seguiremos la filosofía tradicional de Perl y no nos adentraremos en la

orientación a objetos.

La sintaxis de Perl
1. Un lenguaje interpretado.
Como sabemos Perl es un lenguaje interpretado, en consecuencia para ejecutar un script en
Perl debemos indicarle al sistema en ese mismo instante el interprete que vamos a utilizar
para ejecutar dicha script en Perl. Esto se puede realizar de dos formas:

1. Insertando en la primera línea del archivo la instrucción: #!/usr/local/bin/perl.

Esta sentencia indica al sistema operativo que lo que sigue es un script de Perl y que perl es
el programa con el que debe ejecutarse. Dicho programa está en /usr/local/bin. Por tanto la
secuencia !# es reconocida por Unix no por Perl.
2. Especificando el intérprete desde la línea de comando: perl script.pl.
Vemos como directamente se ejecuta el interprete de Perl pasando como primer paramétro
el script a ejecutar. En el caso de haber más parámetros, éstos se tomarán como parámetros
del programa.

Así sólo nos queda saber que para ejecutar un script, el fichero que lo contiene en este caso
script.pl debe tener permiso de ejecución al menos sólo desde el punto de vista del usuario.
Para saber los permisos que contiene un fichero en el sistema operativo Unix basta
simplemente con teclear el siguiente comando: ls -l.
Si cuando tecleamos esto y vemos que no tiene permiso de ejecución, utilizaremos el
siguiente comando para darle dicho permiso: chmod 700 script.pl.
De esta manera, sólo podremos leer, escribir y ejecutar el archivo nosotros como usuarios
del mismo.

2. El intérprete de Perl.
Como ya hemos dicho en el capítulo anterior, una de las maneras de ejecutar un script de
Perl era ejecutando dicho script como un parámetro de un interprete de Perl determinado.
Pues bien, dicho intérprete posee ciertas opciones que nos proporcionan o bien información
sobre el mismo, o bien ciertas facilidades a la hora de ejecutar los script como se podrá ver
a continuación.

 perl -v :  Muestra la versión del intérprete de Perl que estamos utilizando.

 perl -V :  Muestra información sobre la configuración del intérprete de perl.
 perl -e expresión :  Ejecuta la expresión como si ésta fuera un programa de una
línea. Por ejemplo: perl -e "print 'hola a todos\n';"
 perl -ne expresión :  Ejecuta la expresión como si está fuera un bucle repetitivo. He
aquí un ejemplo: perl -ne "print if /M+/;" usuarios.txt . Este ejemplo extrae todos los
usuarios cuyo nombre empieze por la letra M.
 perl -d script : Ejecuta el script bajo el depurador.
 perl -w script : Da avisos sobre las contrucciones con errores.
 perl -pe expresión :  Ejecuta la expresión como si está fuera un bucle repetitivo y
además imprime cada línea. He aquí un ejemplo: perl -pe "print if /M+/;"
usuarios.txt . Observar diferencia con la opción -ne. La diferencia es que mientras la
primera versión sólo imprimía los nombres que empezaban por M, la segunda por
su parte imprimía todos los nombre una vez salvo los que empiezan por M que los
imprime dos veces.
 perl -x script : Empieza a interpretar el fichero que contiene el script cuando
encuentra la referencia al intérprete, por ejemplo: #!/usr/bin/perl.
 perl -i archivo :  Permite editar archivos. Por ejemplo, si ejecutamos lo siguiente
sobre la línea de comandos: perl -p -i -e "s/\$seg/\$segundos/g;" tiempo.pl. Esta
orden cambiará el nombre de la variable $seg por $segundos en el script contenido
en el fichero tiempo.pl.

3. El primer programa en Perl.

Un script en Perl es una sucesión de instrucciones. Éstas se delimitan por punto y coma (;).
Los comentarios en los scripts deben ir precedidos por el símbolo #. Los caracteres que
siguen a este símbolo y que está contenidos en la misma línea se consideran comentarios y
se ignoran.

El siguiente script muestra la cadena de caracteres "¡Hola, mundo!". Este script se llamará
hola.pl y contendrá las siguientes líneas.

#!/usr/local/bin/perl
print "¡Hola, mundo!";

Una vez que hayamos verificado los permisos de dicho script estaremos listos para
ejecutarlo simplemente tecleando en la línea de comandos: hola.pl.

Por último hacer notar que lo de la extensión .pl es simplemente una formalidad y que nos
es absolutamente necesario que el fichero que contenga nuestro script lleve dicha notación.
 Los tipos de datos
1. Los tipos básicos de datos básicos.
Perl permite representar los tipos de datos básicos como son los reales, los enteros, las
cadenas de caracteres y el tipo booleano.

1.1. Los tipos numéricos (reales y enteros).

Los valores numéricos espresados literalmente se presentan en forma de valores reales
codificados en doble precisión. Este formato interno se utiliza para todas las operaciones
aritméticas. Por ejemplo:
$x = 0.897;          # un real
$y = 6.23e-24;       # un real
$n = 567;            # un entero
$i = -234;           # un entero
Nota: El 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 codificación octal o hexadecimal. El código octal se antecede con en cero 0; el
código hexadecimal se antecede con un 0x o 0X. Por ejemplo:

$x = 0377;           # equivale a 255

$y = 0xff;           # equivale a 255

1.2. Las cadenas de caracteres.

Las cadenas de caracteres se especifican literalmente por medio de un sucesión de

caracteres delimitada por comillas ("..") o apóstrofes ('..'). Estas dos representaciones se
distinguen por la interpretación hecha por Perl de las cadenas de caracteres. Cuando van
delimitadas por comillas (".."), toda variable referenciada en el interior de la cadena se
evalúa y se reemplaza por su valor. Por ejemplo, las instruciones siguientes:

$wld = "mundo";
$str = "¡Hola $wld!";

asignan al escalar la cadena de caracteres "¡Hola mundo!". Por el contrario, las cadenas de
caracteres delimitadas por apóstrofes se dejan intactas. Por ejemplo:

$str = '¡Hola $wld!';

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

Existe una tercera sintaxis que permite delimitar una cadena de caracteres. Se utiliza
cuando la cadena de caracteres contiene varias líneas y/o comillas o apóstrofes. Su sintaxis
es la siguiente:

$str = <<etiqueta;
    ....
etiqueta

donde la etiqueta es una cadena de caracteres cualquiera. El fin de la cadena se determina

por la nueva línea que contiene únicamente el identificador. Éste no debe ir precedido por
un espacio ni marca de tabulación. Por ejemplo:

$msg = <<SALUDO;
hola,
buenos días,
adios,
SALUDO

1.3. El tipo booleano.

El tipo booleano existe, al igual que en C, de modo implícito, es decir, un número es falso
si es igual a cero y verdadero en cualquier otro caso. Como el cero está asociado a la ristra
vacía (""), ésta también equivale al valor falso.

2. Las representaciones de datos.

El lenguaje Perl posee tres tipos de representaciones de datos:

 los escalares.
 los arrays.
 los arrays de indexación literal o listas asociadas.

Estas tres representaciones permiten asociar a cada variable utilizada un tipo. Por otra parte,
las variables Perl no tienen que declararse antes de su uso. Se asignan de manera dinámica
y se les asigna un valor predeterminado en función del contexto.

2.1. Los escalares.

El escalar representa el tipo básico en Perl. Permite representar enteros, reales y cadenas de
caracteres. Las variables de tipo escalar van precedidas por el símbolo $. A continuación
veremos algunos ejemplos:
$real = 4.53;
$entero = -45;
$ristra = "Hola";
Las variables en Perl se asignan de manera dinámica y se les asigna un valor
predeterminado en función del contexto. En un contexto numérico el valor predeterminado
es 0, mientras que en un contexto de cadena de caracteres el valor predeterminado es la
cadena vacía "".

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 símbolo $. Este análisis se denomina
interopolación de variables y puede evitarse poniendo delante del símbolo $ una barra
oblicua inversa \ o delimitando la cadena de caracteres con apóstrofes. He aquí un ejemplo:

$adr = "www";
$msg = "El servidor web ${adr}.ulpgc.es"; print $msg, "\n";
$msg = "El servidor web $adr.ulpgc.es"; print $msg, "\n";
$msg = "El servidor web \$adr.ulpgc.es"; print $msg, "\n";
$msg = 'El servidor web $adr.ulpgc.es'; print $msg, "\n";

Observe la contrucción ${...} para referenciar el nombre de una variable en una cadena de
caracteres. Si lo hubieramos omitido, el ejemplo anterior habría hecho referencia a la
variable $adr.ulpgc.es no definida.

El tipo y el valor de las variables en Perl se determina a partir del contexto. Así, una cadena
de caracteres conteniendo un valor numérico será convertida en variable numérica en un
contexto numérico. Consideremos el código siguiente:

$x = 4.1;            # un real
$y = "11";           # una cadena de caracteres
$z = $x + $y;        # adición de dos valores numéricos
$t = $x . $y;        # concatenación de dos cadenas
print $z, "\n", "$t \n";

Al final del código 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 declaración de tipos, ni es
necesario el operador cast, ni tampoco es necesario dar formato a los valores a la hora de
imprimirlos como ocurría en C. Esta interpolación se produce a menudo en unas líneas de
código tales como las siguientes:

$year = 35;
print "Tengo $year años";

El resultado de estas líneas de código es: "Tengo 35 años"; el contenido de la variable year
se ha convertido en una cadena de caracteres.

2.2. 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. Las variables de tipo array se identifican por el prefijo
arroba @. Por ejemplo:

@numeros = (2, 1, 667, 23, 2.2, 5, 6);

@letras = ("perro", "gato", "león");
@mezcla = ("hola", 23, "adios", 31.234);

También se permite definir los elementos de un array a partir de sus valores extremos como
se muestra a continuación:

@alfabeto = (a..z);

Los elementos de un array se referencian mediante índices. El primer elemento se

referencia por el índice 0. Por ejemplo:

$numero[4];                  # vale 2.2

$letras[2];                  # vale "león"
$mezcla[0];                  # vale "hola"

También se puede  acceder a un array mediante el operador que define una horquilla de
índices. Por ejemplo:

@num1 = @numeros[1..3];     # @num1 = (1, 667, 23)

@str = @letras[0,2];        # @str = ("perro", "león")
($ristra, $num) = @mezcla;  # $ristra = "hola", $num = 23

Esta última instrucción vemos que permite asignar los dos primeros valores del array
@mezcla  a las variables escalares $ristra y $num. Por otro lado, el acceso a un array fuera
de rango devuelve un valor indefinido 0 o "" según el contexto.

Por último, si vemos las siguientes líneas de código:

@a=(1,2,3);
@b=(5,6,7);
@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 podría
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 posición indicada del array que ha de
contenerlos, para hacer array de arrays deberemos usar referencias a estos. Como veremos
en el apartado 4 de este capítulo.

2.3. Las listas asociativas (arrays de indexación literal).

Una lista asociativa está indexada por cadenas en lugar de por números. Se utiliza % para
definir el tipo de lista asociativa y un elemento está indexado por el anterior formando
ambos parejas del tipo (clave, valor).

%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:

$id = $cuota{"pat"};      # $id = 256

Esta lista puede completarse añadiendo 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.

3. Los identificadores de las variables.

En cuanto a las ristras de caracteres que representan a nuestras variables decir que los
caracteres permitidos son las letras, dígitos y el carácter underscore (_). Las letras
mayúsculas y minúsculas son diferenciadas en los nombres de variables. Los nombre de las
variables siempre deben comenzar por una letra. Se recomienda que los nombre de las
variables estén en consonancia con lo que ellas representan, sin embargo estos tampoco
deben ser demasiado largos. 

4. Las referencias.
Las referencias son el equivalente a los punteros en C. Es un tipo de datos que permite
referenciar datos contenidos en otra entidad. No forman una nueva representación de datos,
ya que éstos son tratados como un tipo más de escalar.

La definición de referemcia se usa mediante el operador de referencia backslash ("\"). No

existe un operador de desrreferencia.

A diferencia de C, Perl no deja "huella" de las referencias en memoria sino que tiene un
mecanismo de "papelera de reciclaje" que consiste en un registro que posee las diversas
referencias a cada elemento en memoria y las destruye cuando descubre que nadie hace
referencia a él.

4.1. Creación de referencias.

Podemos crear una referencia usando un operador de referenciación en una variable o un
valor. En el caso de la variable es crear un medio alternativo de acceder al valor de la
variable.
$rescalar = \$escalar;
$rarreglo = \@arreglo;
$rhash = \%hash;

Por otro lado, cuando usamos el operador de referenciación con un valor, creamos objetos
anónimos que sólo pueden ser accedidos por medio de la referencia.

$rescalar=\"hola"; #referencia a la cadena anónima "hola"

$rarray=[1,2,3];   #referencia al array anónimo (1,2,3)
$rlista={"llave1" => "dato1","llave2" => "dato2"};
Nota: En esta representación usamos el operador "=>" para la representación de listas asociativas anónimas.

De esta manera se pueden construir estructuras de datos más complejas como se ve en el

siguiente ejemplo:

%rNumeros = {"arabes" => [1,2,3], "romanos" => [I, V, X]}

El ejemplo que acabamos de ver forma una lista asociativa anónima donde las claves son
cadenas de caracteres y los valores son referencia  a arrays.

4.2. Uso de referencias.

A continuación se dará la forma de acceder a las referencias y modifiar su valor. Como
veremos en el ejemplo que viene a continuación para acceder al valor referenciado se usa el
operador $ por duplicado. 
$nombre="entero";
$entero=5;
$rentero=\$entero;
$$nombre=6;
$$rentero=7;

Como se puede ver en este ejemplo cambia el valor de $entero de 5 a 6 y después de 6 a 7.

A continuacuón veremos el uso de las referencias a arrays y listas asociativas.

$rarray=[1,2,3,4]   #crea arreglo anónimo (1,2,3,4)

$$rarray[2]="tres";
#modifica el array anónimo a (1,2,"tres",4)
@$rarray=();        #limpia el arreglo anónimo
Como forma de abreviar la referencia a listas asociativas o arrays se añadió en operador "-
>". A continuación veremos un ejemplo de uso del mismo.
$rarray->[2]="hola";
# Coloca "hola" como 3º elemento del array referenciado
$rlista->["clave1"]="valor1";
# Coloca el par ("clave1" => "valor1")
Se pueden realizar referencias a referencias y arreglos a referencias de forma que los arryas
multidimensionales se pueden hacer con la misma facilidad que en C. Ejemplo:

$array3d->[0]->[0]->[0]=1;
# Forma abreviada:
$array3d[0][0][0]=1;
# También se puede usar
$array3d->[0][0][0]=1;

Los operadores en
Perl
En Perl distinguiremos tres tipos de operadores dependiendo de la representación de datos
sobre la que queremos actuar. De este manera habrá tres tipos de operadores: los
operadores asociados a los escalares, los asociados a los arrays y por último, los vinculados
a las listas asociativas.

1. Los operadores asociados a escalares.

Los operadores definidos en Perl tienen todos los operadores estándar (de tipo C) a los que
añaden operadores específicos para la manipulación de cadenas de caracteres. Como
veremos más adelante la precedencia de estos operadores sigue el mismo criterio que en el
lenguaje C.

1.1. Operadores aritméticos.

Perl suministra los siguientes operadores aritméticos.

Entre los operadores artiméticos también distinguimos los de autoincremento (++) y

autodecremento (--). Estos operadores son unarios y se realiza el incremento o decremento
de la variable que se le aplica. Además de la acción de modificar la variable devuelven el
valor de la variable.
El operador de incremento o decremento puede ir delante o detrás de la variable, teniendo
diferente significado. Si el operador ++ se situa después de la variable se denomina
postincremento, haciendo que primero se tome el valor y después se incremente la variable.
Ejemplo:
$n = $k++;
 # el valor de k se asigna a n y después se incrementa k

Por otro lado, si el operador ++ se sitúa después de la variable se denomina preincremento

y hace que primero se incremente la variable y después se tome el valor. Ejemplo:

$n = ++$k;
 # primero se incrementa k y luego se asigna a n

Finalmente, decir que con el operador de decremento se actúa de forma análoga obteniendo
así el predecremento y el postdecremento.

1.2. Operadores relacionales.

Perl distingue dos tipos de operadores relacionales: los operadores específicos a valores
numéricos y los propios  de las cadenas de caracteres. Estos operadores se resumen en la
siguiente tabla:

A parte de los operadores que hay en la tabla cabe distinguir otros operadores únicamente
característicos del lenguaje Perl.

 cmp. Este operador es utilizado para comparar caracteres, de manera

que, retorna 0 si los caracteres comparados son iguales, 1 si la cadena
de la derecha se encuentra al comienzo de la de la izquierda, y -1 en
el caso contrario. Para aclarar el funcionamiento de este operador he
aquí un ejemplo:

'one' cmp 'one'       # devuelve 0

'one dog ' cmp 'one'  # devuelve 1
'dog one' cmp 'one'   # devuelve -1
'two' cmp 'one'       # devuelve -1    
  <=>. Este operador se utiliza para comparar valores numéricos,
retornando 0 cuando son iguales, 1 cuando el termino de la derecha
es menor que el de la izquierda y -1 en el caso contrario.
 =~. Este operador es usado en las expresiones regulares para indicar
la presencia de un patrón de compración dentro de una variable que
contiene una cadena de caracteres. Por ejemplo:

if ($ristra =~ /str/) {
   print $ristra;
}
else {
   print "No se encuentra el patrón";
}
# verifica si 'str' se está en $ristra

 !~.Meditante este operador se verifica la no existencia del patrón de

búsqueda en una cadena. He aquí un ejemplo:

if ($ristra !~ /str/) {
   print "No se encuentra el patrón";
}
else {
   print $ristra;
}

1.3. Operadores lógicos.

Los operadores lógicos están relacionados con los relacionales ya que normalmente los
operadores que se usan son resultado de expresiones relacionales.

Los valores resultantes son cero o ristra vacía ("") y distinto de cero o ristra vacía  para
falso o verdadero respectivamente.

He aquí un ejemplo:

if (($alfa>4) && ($beta<3)) {

   print $alfa * $beta;
   # Sólo entra si se cumplen ambas expresiones.
}
if (($pal1 eq "N") || ($pal1 eq "n") {
   print "La operación no se efectua";
   &salida();
   # Entra si se cumple alguna de las dos expresiones
}
if (!($num < 5)) {
   print "$num es mayor que 5";
   # Entra si la expresión no se cumple
}

1.4. Operador de selección.

Es un operador triario que requiere una condición y dos expresiones. Se utiliza para
ejecutar una expresión u otra dependiendo de la condición. Su formato es el siguiente:
                                             Condición? Exp1: Exp2
Si se cumple la condición se evalúa y devuelve la expresión Exp1 si no la Exp2. Por
ejemplo:

i = (x<y? 6:k+1); # si x<y entonces i=6, si no i=k+1

1.5. Operadores de asignación.

Una asignación también es un operador que devuelve la variable modificada. El la siguiente

tabla veremos los operadores de asignación contenidos en Perl que como se podrá observar
son muy parecidos a los del lenguaje C.

A parte de estos operadores Perl posee el operador =~ que también es un operador de

asignación, ya que este operador se utiliza dentro de una expresión regular de sustitución
para sustituir un patrón de comparación por otra cadena. Ejemplo:
$var =~ s/uno/dos/;
# reemplaza la primera ocurrecia "uno" por "dos" en
# la cadena dada

1.6. Operadores a nivel de bits.

Al igual que C, Perl toma como uno de sus objetivos no alejarse de la máquina, para ello
posee esta serie de operadores a nivel de bits.

1.7. El operador ",".

El opearador "," evalúa varias expresiones donde la sintaxis solamante permite una, siendo
el valor resultante la última expresión evaluada. La evaluación se realiza de izquierda a
derecha. En Perl 5 también se usa el operador => para lo mismo que la coma ",". Ejemplo:

i = (f(3), j+5, k*8, 4/2); # i = 4/2

1.8. Símbolos de puntuación.

Además en Perl tenomos los símbolos de puntuación que a diferencia de otros lenguajes
son considerados operadores en Perl. Básicamente tenemos cuatro símbolos que nos
permiten agrupar otros símbolos para darles una interpretación especial.

 ' '. Especifica valores literales. No hace sustituciones. Ejemplo:

$fecha = "14 de Julio";

print 'hoy es $fecha';  # imprime "hoy es $fecha"

 " ". Especifica valores literales. Realiza sustituciones. Ejemplo:

$fecha = "14 de Julio";

print "hoy es $fecha"; 
         # imprime "hoy es 14 de Julio"
  ` `. Ejecuta el comando contenido haciendo las sustituciones
indicadas. Igual que muchos Shells de Unix. Por Ejemplo:

print `date`; # ejecuta comando date

 / /. Delimita expresiones regulares. Ejemplo:

if ($var =~/exe/) {
   print $var;
}
  # Se imprime $var si contiene el patrón exe

 1.9. Precedencia de operadores.

Normalmente las expresiones en Perl se evalúan de izquierda a derecha, aunque hay

algunas excepciones que es necesario tener en cuenta. No se evalúan de izquierda a derecha
los operadores de asignación y el operador de selección. Cuando una expresión tiene
diversas posibilidades se aplica el orden de precedencia para establecer el cálaculo a
realizar. La precedencia de los operadoes se mostrará en la siguiente tabla, aunque se
recomienda emplear paréntesis para que nunca haya duda en el orden de evaluación.

1.10. Funciones predefinidas para el tratamiento de cadenas de caracteres.

Perl posee una serie de funciones predefinidas que nos facilitan el tratamiento de cadenas
de caracteres. Si ellas, realizar operaciones con este tipo de datos sería casi imposible. A
continuación nombraremos las funciones básicas para efectuar dicho tratamiento:

 length(cadena de caracteres). Esta función nos permite conocer la longitud

de una cadena de caracteres. Por ejemplo:

$ristra = "hola";
lon = length($ristra); # lon = 2
  chop(cadena de caracteres). Elimina el último carácter de la ristra y retorna
dicho carácter. Esta función se suele usar para eliminar el carácter de nueva
línea que contienen las ristras que se introducen por teclado o se leen de un
fichero. Ejemplo:

print "Teclea algo y pulsa enter:\n";

$input = <STDIN>; # $input contiene el "enter"
chop($input);     # $input no lo contiene

 index(ristra, subristra, [posición]). Esta función retorna la posición de la

primera ocurrencia de la subristra en la ristra indicada. El parámetro
posición indica el número de caracteres desde el inicio que se deben ignorar
en la búsqueda. Si se omite este parámetro se considera que no se desea
ignorar ningún carácter, es decir, se considera posición igual a 0. Si no se
encuentra la subristra la función devuelve la posición desde la que comienza
a buscar -1, esto es, el parámetro posición menos 1.  Ejemplo:

$ristra = "El automóvil";

$subristra = "auto";
$pos = index($ristra, $subristra);    # $pos = 4
$pos = index($ristra, $subristra, 6); # $pos = 5

 rindex(ristra, subristra, [posición]). Esta posición trabaja igual que index

salvo que retorna de la última ocurrencia de la subristra en la ristra. Posición
es el número de caracteres desde el inicio que se ignorá en la búsqueda. Si
no se encuentra posición, el valor retornado es posición menos 1. Ejemplo:

$ristra = "carro y motocarro";

$subristra = "carro";
$pos = rindex($ristra, $subristra); # $pos = 13;

 substr(ristra, desplazamiento, [longitud]). Esta función extrae una

subristra de la ristra dada, desde la posición indicada por desplazamiento
hasta el número de caracteres indicado  por longitud. Si el parámetro
longitud se omite se tomará la subristra que va desde el parámetro
desplazamiento hasta el final de la ristra. Considerar que el primer carácter
de una ristra es el que esta en la posición cero. Ejemplo:

$ristra = "Universidad de Las Palmas de G.C.";

$subristra = substr($ristra,15,10);
# $subristra = "Las Palmas"
$subristra = substr($ristra,15);
# $subristra = "Las Palmas de G.C."

 pack("tipos a convertir", valores a convertir). La función pack es un

convertidor de tipos que ofrece en su primer parámetro varias opciones de
 conversión para convertir el tipo de la lista de valores que se dan en el
segundo parámetro a caracter ASCII. A continuación se muestran las tipos
de conversión más usados:

Para enteder mejor el funcionamiento de esta función veremos a continuación algunos

ejemplos:

$ristra = pack("cccc",65, 66, 67, 68);

# $ristra = "ABCD"
$ristra = pack("c4", 65, 66, 67, 68);
# $ristra = "ABCD"
$ristra = pack("ccxxcc", 65, 66, 67, 68);
# $ristra = "AB\0\0CD"

Esta función, junto con la función hex(valorBase16) que pasa de hexadecimal a entero, son
muy útiles para convertir datos procedentes de formularios Web, ya que, en este caso, todos
los caracteres de puntación, de control, llegan en formato hexadecimal al servidor y
necesitan convertirse en formato ASCII. Esto se haría introduciendo en el programa de
conversión y tratamiento de formulario la siguiente línea:

$StringForm =~ s/\%(..)/pack("c",hex($1))/ge;

2. Los operadores asociados a arrays.

2.1. El operador $#.
El operador $# permite delimitar el último índice válido de un array. Este valor
norepresenta el tamaño del array, porque esto depende también del índice de base (es decir,
el primer elemento del array). Esto se define por la variable $[ cuyo valor predeterminado
es 0. Mediante estos dos elementos se puede delimitar el tamaño del array. Por ejemplo, si
@A es un array, el código siguiente permite determinar su tamaño:
$n = $#A - $[ + 1;
print "La matriz tiene $n elementos\n";

Los arrays se asignan de manera dinámica y su tamaño se modifica en función de la

asignación de nuevos elementos. También es posible asignar el tamaño de memoria
necesario antes de utilizar el array. Esto se hace asignado un valor requerido al operador $#.
Por ejemplo:

$mes = 11; # el array tiene 12 elemento de 0 a 11

2.2. Los operadores push y pop.

Los operadores push y pop permiten respectivamente insertar y extraer el último elemento
de un array. Por ejemplo:

push(@list, $val);      # equivale @list = (@list, $val)

$oldval = pop(@list);   # extrae el último elemento
@list = (1,2,3);     
@five = push(@list, (4,5)); # @five = (1,2,3,4,5)
$num = pop(@list);      # $num = 5

2.3. Los operadores shift y unshift.

Los operadores shift y unshift permiten respectivamente suprimir e insertar el primer

elemento de un array. Por ejemplo:

unshift(@list, $val); # equivale a @list = ($val, @list)

unshift(@list, $a, $b, $c);
               # equivale a @list = ($a, $b, $c, @list)
@five = (3,4,5);
unshift(@five,1,2); # @five = (1,2,3,4,5)
$x = shift(@five);  # $x=1, @five=(2,3,4,5)

2.4. Los operadores reverse y sort.

El operador reverse invierte los valores del array mientras que el operador sort los ordena
en sentido creciente. Por ejemplo:

@five = (2,3,4,5,1);
sort(@five);          # @five = (1,2,3,4,5)
reverse(@five);       # @five = (5,4,3,2,1)

2.5. Los operadores split y join.

Los operadores split y join permiten transformar una cadena en una lista de caracteres. Por
ejemplo, cuando un usuario envía un formulario a un servidor WWW, su contenido se
transmite al concatenar pares nombre-valor separados por el símbolo &.  Para acceder a la
información transmitida, es necesario descomponer esta cadena de caracteres.

La función split admite tres argumentos, aunque de éstos, el tercero es opcional. El primero
de estos argumentos es una expresión regular y el segundo es una cadena de caracteres. La
expresión regular define el modelo que deberá descomponer la cadena de caracteres. La
sintaxis es la siguiente:

@lista = split(/expresión/, cadena)

donde se representa una expresión regular cualquiera. Por ejemplo:

$datos = "x=3&dbase=Lycos";
@lista = split(/&/, $datos);
foreach $par (@lista) {
   ($nombre, $valor) = split(/=/, $par);
}

Por último, el tercer parámetro consiste en un campo entero que limita el número de
campos que divide la lista de caracteres, despreciando los sobrantes, por ejemplo si en él
código que acabamos de ver no queremos el campo representado en la variable valor,
realizaremos los siguientes cambios.

$datos = "x=3&dbase=Lycos";
@lista = split(/&/, $datos);
foreach $par (@lista) {
   $nombre = split(/=/, $par,1);
}

El operador join realiza la tarea inversa. Así, a partir de un serparador de un lista de

valores, concatena los elementos de la lista y la cadena de caracteres que representa el
separador. La sintaxis del operador join es la siguiente:

$cadena = join(separador, @lista)

donde el separador representa una cadena de caracteres cualesquiera. Por ejemplo:
@lista = ("x=3", "dbase=Lycos");
$msg = join("&", @lista);        # x=3&dbase="Lycos"

3. Los operadores asociados a listas asociadas.

3.1. El operador keys.
El operador keys proporciona la lista de claves o índice de una lista asociativa. Por
ejemplo:
%cuotas = ("root", 10000, "pat", 256);
@list = keys(%cuotas); # @list = ("root", "pat")
3.2. El operador values.

El operador values devuelve los valores de una lista asociativa. Por ejemplo:

%cuotas = ("root", 10000, "pat", 256);

@list = values(%cuotas); # @list = (10000, 256)

3.3. El operador each.

También se puede acceder a una lista asociativa por pares clave-valor, permitiendo el
operador each recorrerla iterativamente. El ejemplo siguiente ilustra un acceso a los pares
clave-valor una lista asociativa.

%cuotas = ("root", 10000, "pat", 256);

while (($clave, $valor)=each(%cuotas)) {
    print "Login: $clave, Cuota: $valor\n";
}

3.4. El operador delete.

Para suprimer elementos de una lista asociada se usa el operador delete. Este operador
permite suprimir un par clave-valor de una lista asociativa. Por ejemplo:

%cuotas = ("root", 10000, "pat", 256);

delete $cuota{"pat"}; #%cuotas = ("root", 10000)

Estructuras de
control
El desarrollo de un programa viene determinado por el orden en que aparecen las
instrucciones. El lenguaje Perl posee controlar un conjunto de instrucciones que permiten
controlar el desarrollo de un programa. Estas instrucciones se denominan estructuras de
control porque permiten ejecutar un conjunto de instrucciones cuando se verifica una
condición o ejecutar iterativamente un bloque de instrucciones mientras una expresión sea
válida.

1. La instrucción if.
Es muy parecida a la utilizada en C. La sintaxis de la instrucción if es la siguiente:
if (expresión) {
   instrucción o bloque de intrucciones 1;
}
[else {
   instrucción o bloque de intrucciones 2;
}]

El programa evalúa la expresión. Cuando esta expresión resulta verdadera, se ejecuta la

instrucción o el bloque de instrucciones 1. Por contra, cuando es falsa de ejecuta la
instrucción o bloque de instrucciones 2. Esta última parte es opcional. Para representar una
estructura de varios casos se utilizará la sintaxis siguiente:

if (expresión 1) {
   instrucción o bloque de instrucciones 1;
}
elsif (expresión 2) {
   instrucción o bloque de instrucciones 2;
}
elsif (expresión 3) {
   instrucción o bloque de instrucciones 3;
}
else {
   intrucción o bloque de instrucciones 4;
}

A continuación veremos un ejemplo sencillo del uso de esta estructura para comprender
mejor su funcionamiento:

print "Introduzca un número del cero al dos y pulse Enter:\n";

$var  =  <STDIN>;
if ($var == 0) {
   print "Esta es la opción 0\n";
}
elsif ($var == 1) {
   print "Esta es la opción 1\n";
}
elsif ($var == 2) {
   print "Esta es la opción 2\n";
}
else {
   print "No existe al opción tecleada\n";
}

2. La instrucción while.
La instrucción while ejecuta iterativamente un bloque de instrucciones mientras una
expresión sea válida, evaluando la comprobación en cada iteración. Cuando la prueba es
válida, se ejecuta la instrucción o el bloque de instrucciones delimitado por las llaves. La
sintaxis de esta instrucción es:

while (expresión) {
   instrucción o bloque de instrucciones;
}

He aquí un sencillo ejemplo de manejo de esta estructura:

print "Teclea \"x\" para salir:\n";

$ristra = "";
while ($ristra ne "x") {
   $ristra = <STDIN> ;
   chop($ristra);
   print "Has escrito $ristra\n";
}
print "Salida.\n"

3. La instrucción for.
La instrucción for permite ejecutar iterativamente un conjunto de instrucciones. La sintaxis
de la instrucción for es:

for (inicial_exp; test_exp; incremento_exp) {

    instrucción o bloque de intrucciones;
}

donde:

 inicial_exp es la instrucción que inicializa el bucle. Consiste generalmente en la

asignación de un valor a una variable que permite controlar el número de
iteraciones.
 test_exp es la expresión evaluada en cada iteración. Cuando esta expresión es
verdadera, el bloque de instrucciones se ejecuta.
 incremento_exp es la expresión que permite la actualización de la variable que
controla el número de iteraciones.

A continuación veremos un ejemplo de esta estructura para iniciarnos en su manejo:

print "10 Iteraciones\n";

for ($i=0; $i<10; $i++) {
         print "Interación número $i\n";
}
4. La instrucción foreach.
La instrucción foreach es similar a la función del mismo nombre de los Shells de Unix.
Asocia iterativamente a una variable cada elemento de la lista. Esta sucesión de valores
sirve para parametrizar la ejecución del bloque de instrucción. La sintaxis de la instrucción
foreach es:

foreach $variable (@lista) {

    instrucción o bloque de instrucciones;
}

Las intrucciones for y foreach son equivalentes. Sin embargo, la utilización de una de estas
instrucciones se justifica generalmente por el contexto. El ejemplo siguiente lo ilustra:

@lista = ("elem1", "elem2", "elem3", "elem4");

for ($i = 0; $i<= $#lista; $i++) {
   print $lista[$i], "\n";
}

Este ejemplo no utiliza las características de los arrays en Perl. La utilización de la

instrucción foreach permitirá recorrer la lista de forma más elegante. El ejemplo siguiente
lo ilustra:

@lista = ("elem1", "elem2", "elem3", "elem4");

foreach $elem_actual (@lista) {
   print $elem_actual, "\n";
}

5. La instrucción goto.
La instrucción goto label permite cambiar el recorrido lineal de las líneas de código
prosiguiendo la ejecución del programa en la línea de etiqueta label. La etiqueta se define
colocando al final del identificador dos puntos (:). En el siguiente ejemplo se podrá ver
mejor la contrucción del goto.

if ($expr ne $expr_correcta) {
   goto error;
}
...
error: print "expresión incorrecta";

La utilización del goto en Perl no es recomendable. Por que le quita al código legibilidad y
aumenta la posibilidad de errores.

6. La instrucción last.
La instrucción last interrumpe la ejecución del bucle actual y se ejecuta la instrucción que
sigue al bloque. El ejemplo siguiente permite interrumpir el bucle while cuando la variable
i toma el valor 3.

$i = 0;
while($i < 6) {
   if($i == 3) {
     last;
   }
   $i++;
}
print "el valor de \$i es $i";

Cuando la instrucción tiene como argumento una etiqueta, la ejecución prosigue en la línea
indicada por la etiqueta.

7. La instrucción next.
La instrucción next es idéntica a la instrucción continue en C. Interrumpe la ejecución del
bloque de instrucción actual y prosigue la ejecución en la iteración siguente. Esta
instrucción no interrumpe completamente la ejecución del bucle; la expresión que controla
el bucle se evalúa. Si el resultado de la expresión es válido, el bucle se ejecuta de nuevo.

Cuando una instrucción tiene como argumento una etiqueta, la instrucción prosigue en la
línea identificada por la etiqueta y no al principio del bloque.

Seguidamente veremos un ejemplo de dicha instrucción:

print "Teclea \"x\" para salir:\n";

print "Si se pulsa la tecla \"s\" no se imprime:\n";
$ristra = "";
while ($ristra ne "x") {
   $ristra = ; chop($ristra);
   if ($ristra eq "s") {
      next;
   }
   print "Has escrito $ristra\n";
}
print "Salida.\n"

8. La instrucción until.
La instrucción until al igual que la instrucción while permite ejecutar un conjunto de
instrucciones un número repetido de veces. Pero al contrario que la la instrucción while, la
intrucción until ejecuta dicho bloque de instrucciones mientras no se verifique la
comprobación. La sintaxis es:

until (expresión) {
   instrucción o bloque de instrucciones;
}

He aquí el ejemplo anterior pero utilizando la instrucción until.

print "Teclea \"x\" para salir:\n";

print "Si se pulsa la tecla \"s\" no se imprime:\n";
$ristra = "";
until ($ristra eq "x") {
   $ristra = ; chop($ristra);
   if ($ristra eq "s") {
      next;
   }
   print "Has escrito $ristra\n";
}
print "Salida.\n"

9. La instrucción unless.
Esta instrucción es análoga al if, salvo que permite considerar la no verificación de la
prueba. Su sintaxis es la siguiente:

unless (expresión) {
   instrucción o bloque de intrucciones 1;
}

Para ver mejor el funcionamiento del unless, modificaremos el ejemplo anterior para
adaptarlo a dicha instrucción.

print "Teclea \"x\" para salir:\n";

print "Si se pulsa la tecla \"s\" no se imprime:\n";
$ristra = "";
until ($ristra eq "x") {
   $ristra = ; chop($ristra);
   unless ($ristra eq "s") {
      next;
   }
   print "Has escrito $ristra\n";
}
print "Salida.\n"
Expresiones regulares
Una expresión regular es un modelo o una forma de comparar con una cadena de
caracteres. Esta comparación es conocida con el nombre de pattern matching o
reconocimiento de patrones, permite identificar las ocurrencias del modelo en los datos
tratados. La utilización principal de las expresiones regulares en Perl consiste en la
identificación de cadenas de caracteres para la búsqueda modificación y extracción de
palabras clave. De esta manera se pueden dividir las expresiones regulares en varios tipos
que son: expresiones regulares de sustitución, expresiones regulares de comparación y
expresiones regulares de traducción.

1. Expresiones regulares de comparación.

Nos permiten evaluar si un patrón de búsqueda se encuentra en una cadena de caracteres, de
modo que mediante este tipo de expresiones regulares obtendremos un valor lógico
verdadero o falso según se encuentre el patrón deseado. La sintaxis de este tipo de
expresiones regulares es la siguiente:
                                                                      valor a comparar =~ patrón de búsqueda

He aquí un ejemplo:

# imprimimos todas las líneas que contengan "html". Ej.: "htmlexe"

if ($linea =~ /html/) {
     print $linea;
}

Los patrones de búsqueda pueden integrar información relativa al contexto, tal como la
búsqueda de líneas que empiecen por la cadena de caracteres, la extracción de palabras que
tengan prefijos o sufijos particulares... Estos contextos se tienen mediante una
representación particular del modelo. Esta representación se explica en los siguientes
apartados:

1.1. Patrones definidos por una clase de caracteres.

A menudo resulta práctico extraer las palabras que contienen una cifra, una vocal, o
caracteres de control particulares. El modelo así definido no se indica por un carácter
particular sino por un clase de caracteres mediante el operador [ ]. He aquí algunas posibles
construcciones:
[aeiou]        # Cualquier vocal
[0-9]          # Cualquier número del 0 al 9.
[0123456789]   # Igual [0-9]
[0-9a-z]       # Cualquier letra o cualquier numéro
[\~\@;:\^_]    # Cualquiera de los caracteres(~,@,;,:^,_)
Generalmente de puede definir una clase de caracteres valiéndose de la complementaria.
Ésta se expesifica mediante la sintaxis [^ ]. Siendo el símbolo ^ el que representa la
negación de los caracteres o clase de caracteres consecutivos:

[^0-9]         # Carácter que no sea un dígito

La definición del patrón por clase se contempla con un conjunto de caracteres de control.
Estos facilitan la definición de modelos complejos en rutinas de comparación. Estos
facilitan la definición de patrones complejos en rutinas de comparación. La siguiente tabla
representa estas extenciones:

Por otro lado, decir que los símbolos \n, \r, \f y \t tienen su significado habitual, es decir,
significan nueva línea, retorno de carro, salto de página y tabulación respectivamente.

A continuación veremos otra lista de caracteres genéricos que aumentarán la flexibilidad en

la contrucción de patrones de búsqueda. Estos caracteres se muestran en la siguiente tabla:

1.2. Referencia de patrones.

 Se utilizán para referenciar patrones en las expresiones regulares. Perl trabaja con dos tipos
de operadores de comparación:

 $1,$2,...,$9. Sirven para referenciar uno de los patrones de búsqueda de la

expresión regular. El número del 1 al 9 representa el patrón al que queremos
referirnos dentro de la expresión regular. Así un ejemplo del uso de este
operador se puede observar en este código en Perl que añade el articulo 'El' a
 un nombre común: (en este ejemplo se utilizará una expresión regular de
sustitución que veremos en el siguiente apartado).

$var = "coche";
$var =~ s/(coche)/El $1/; # $1 equivale a coche
print $var;

 \1,\2,...,\9. Este operador tiene la misma utilidad que el anterior se utiliza

para referenciar patrones, pero esta vez la referencia se ha de producir dentro
de la expresión regular. He aquí un ejemplo:

if ($var =~ (/^(\w)+.*\1$/) {
   print $var;
}

Esta expresión regular de comparación tiene el siguiente significado: mediante la cadena

^(\w)+ nos referimos a todos los caracteres alfanuméricos que forman parte del principio de
la cadena contenida en $var, es decir, la cadena ha de empezar por uno o más caracteres
alfanuméricos. Con la cadena .* referenciamos un conjunto arbitrario de caracteres de
longitud desconocida, finalmente con la cadena \1 expresamos el primer patrón utilizado y
con $ significamos que este patrón debe de estar al final de la cadena contendia en $var. En
definitiva la expresión regular tomará el valor verdadero, cuando la cadena de caracteres
contenida en $var tenga la misma cadena de caracteres alfanuméricos al principio y al final.
Así por ejemplo, si $var tiene una cadena de caracteres como esta: 'hola juansdfa hola' el
valor de la expresión regular será cierto, ya que los espacios en blanco no se consideran
caracteres alfanuméricos.

1.3. Utilización de carácteres reservados.

En la especificación del modelo, cada carácter se interpreta para determinar las ocurrencias
en los datos. Sin embargo, los caracteres siguientes:

+?.*^$()[]{}|&\

son reservados por el lenguaje y deben ir precedidos por el símbolo de barra inversa \. Esto
permita ignorar su especificidad y considerar los como un carácter cualquiera. Por ejemplo:

# busca ocurrencia de "ford" en $car

$marca = "ford";
if ($car =~ /$marca/) {
   print $car;
}
# busca ocurrencia de "$marca" en $car
if ($car =~ /\$marca/) {
   print $car;
}
1.4. Combinación de expresiones regulares.

Se realiza con los operadores | y & que equivalen al or y al and lógico respectivamente. Por
ejemplo, con el operador | podemos representar una lista de alternativas, es decir:

if ($car =~ /ford | audi/) {

   print $car;
}

mientras que con el operador & exigimos que la variable contenga las dos expresiones
regulares propuestas:

if ($direccion =~ /calle & piso/) { 

   print $direccion;
}

2. Expresiones regulares de sustitución.

Las expresiones regulares de sustitución permiten cambiar los patrones de búsqueda por
caracteres nuevos definidos por el usuario que componen el patrón de sustitución, la
sintaxis es la siguiente:
                          valor a sustituir =~ s/patrón de búsqueda/patrón de sustitución/opciones
Las opciones las podemos ver en la siguiente tabla:

A continución vamos a ver unos ejemplos para aclarar su manejo:

$var = 'abc123yz';
$var =~ s/d+/$&*2/e;              # $var = 'abc246yz'
$var =~ s/d+/sprintf("%5d",$&)/e; # $var = 'abc   246yz'
$var =~ s/\w/$& x 2/eg;           # $var = 'aabbccc   224466yyzz'
Nota: Como veremos en el capítulo 10 con más profundidad, $& es una variable predefinida por el lenguaje
que contiene el valor de la última cadena de caracteres comparada exitosamente.

3. Expresiones regulares de traducción.

Este tipo de expresiones regulares tienen una manera de trabajar muy parecida a la de las
sustituciones. En este caso se trata de comparar uno a uno los caracteres del patrón de
búsqueda con los de la cadena de sustitución, de modo que cada vez que se encuentra una
ocurrencia que coincide con uno de los caracteres del patrón se intercambia por su
correspondiente en la cadena del patrón de sustitución. La sintaxis general de esta expresion
regular es la siguiente:
                                                variable =~ tr/patrón de búsqueda/cadena a
traducir/opciones
Las opciones las podemos ver en la siguiente tabla:

También decir que este operador devuelve el número de reemplazados  o borrados. He aquí
algunos ejemplos que nos servirán para tener una manejo:

$var =~ tr/A-Z/a-z/;    # transforma mayúsculas a minúsculas

$cnt = $var =~ tr/*/*/; # cuenta los arteriscos de $sky
$cnt = $var =~ tr/0-9//;# cuenta y suprime las cifras de $sky
$var =~ tr/a-zA-z//s;   # elimina duplicados. bbookk -> bok
$var =~ tr/a-zA-z/ /cs;
# cambia los caracteres no alfabéticos en espacios y elimina duplicados

4. Ejemplo.
Seguro que ha estas alturas todavía no se tiene claro la diferencia entre los distintos tipos de
expresiones regulares, para aclarar el concepto introducimos los siguientes ejemplos:

En primer lugar vemos una expresión regular de búsqueda que dará cierto si en la variable
$copia se encuentra el patroón copia. Si es  así, como veremos se imprimirá un mensaje.

$copia = "copy, xcopy, diskcopy";

if ($copia =~ /copy/) {
   print "Encontrada la cadena copy";
}

A continuación viene un ejemplo de expresión regular de sustitución:

$copia ="copy, xcopy, diskcopy";

$copia =~ s/copy/copia/g;

Esta operación reemplaza todas las ocurrencias de copy por copia quedando:
                                                                   "copia, xcopia, diskcopia"

En último lugar realizaremos un ejemplo con una expresión regular de traducción:

$copia = "copy, xcopy, diskcopy";
$copia =~ tr/copy/12345/;

Como se ve en este caso, se sustituye cade ocurrecia de 'c' por 1, de 'o' por 2, de 'p' por 3 y
de 'y' por 4. El carácter de traducción 5 es ignorado puesto que no tiene ninguna
correspondencia con ninguno de los caracteres de patrón. Por tanto, el contenido de la
variable $copia será:
                                                                      "1234, x1234, disk1234"

Otro caso podría ser el siguiente:

$copia = "copy, xcopy, diskcopy";

$copia =~ tr/copy/123/;

Este ejemplo es idéntico a el anterior pero en este caso sólo tenemos dos caracteres en la
cadena de traducción. Así, cuando el número de caracteres en la cadena de traducción es
menor que el número de caracteres del patrón, las ocurrencia de los caracteres del patrón
que no tienen correspondencia con ningún caracter de traducción, son intercambiados por el
último de los caracteres de traducción. Por tanto, el contenido de la variable $copia será:
                                                                       "1233, x1233, disk1233"

Definición de
funciones
La definición de funciones permite asociar un nombre a un conjunto de instrucciones Perl.
La sintaxis para la definición de función es:

sub nombre_de_función {
   instrucciones;
   [return Variable o expresión;]
}

donde nombre_de_función representa el nombre de la función. A cada llamada a la función,

el código de instrucciones delimitadas por llaves se ejecuta. La definición de una función es
global y en consecuencia puede insertarse al principio o al final del archivo.

La llamada a la función se puede realizar de dos formas:

& nombre_de_función;
do nombre_de_función();
Las dos formas producen el mismo resultado con la excepción de que en el caso de do hay
siempre que poner los paréntesis. Una llamada a una función puede insertarse  en las
estructuras y operadores en Perl.

El valor devuelto por la llamada a una función corresponde al valor precisado por el
operador return. Cuando este está ausente, el resultado de la última instrucción corresponde
al resultado de la última instrucción ejecutada en el cuerpo de la función. Por ejemplo:

sub diferencia {
   if ($x < $y) {
     print "$x es inferior a $y\n";
     $y-$x;
   }
   else {
     print "$x es superior o igual a $y\n";
     $x-$y;
   }
}
$x = 2; $y = 3;
$abs = &diferencia; # $abs = 1

En este ejemplo, la función visualiza un mensaje y devuelve el valor absoluto de la

diferencia de $x y $y. Permutando las instrucciones de visualización y de cálculo, la
función devolverá 1, valor correspondiente a una visualización correcta.

Los argumentos de una función.

Al llamar a una función cuando esta va seguida de una lista de variables, éstas últimas se
consideran como sus argumentos. El lenguaje Perl duplica el contenido de estas variables
en la variable predefinida @_ durante la ejecución de la función. La variable @_ permite
así acceder a los parámetros de la función. Estos se colocan en la matriz $_[0], $_[1], ...,
$_[n-1] referenciando los diferentes argumentos de la función. Por ejemplo.

sub diferencia {
  if ($_[0] < $_[1]) {
    $_[1]-$_[0];
 }
  else {
    $_[0]-$_[1];
 }
}
$abs = &diferencia(2,3); # $abs = 1

Las variables locales y globales.

Las variables referenciadas en una función son de modo predeterminado variables globales,
es decir, comunes a todo el script. Para evitar los conflictos entre las variables propias de la
función y las otras variables, es necesario declarar explícitamente las variables locales
(propias de la función) mediante el operador local. Este operador tiene como argumentos
una lista de nombres de variables a las que asocia variables locales. Cuando hay conflicto
entre nombre de variables locales y globales en la definición de una función, sólo se tiene 
en cuenta la variable local en el cuerpo de la función y el valor global queda sin cambios.
Por ejemplo:

sub producto {
  local($p) = 1;
  foreach $_(@_) {
    $p *= $_;
 }
}
$p = 3;
print &producto(2,3,4);  # visualiza 24
print "$p\n";            # visualiza 3

Es aconsejable asignar  a las variables locales los argumentos pasados a la función. Esto
permite una mejor legibilidad de las funciones. Esto se realiza combinando el operador
local con la variable predefinida @_. Por ejemplo:

sub Area_cuadrado {
  local($radio) = @_;
  return $radio*$radio;   # el return sobra
}

Paso de parámetros por referencia.

Hasta ahora hemos visto el pasa de parámetros por valor, es decir, no es posible cambiar los
valores globales de los argumentos. Para hacer esto posible es necesario pasar a la función
no los valores, sino los nombres de estas variables. Este modo se denomina paso por
referencia y se implementa prefijando el nombre de la variable con un arterisco *.

En el momento de la definición de una funcioón cuyos argumentos se pasan por referencia,

la asignación de los argumentos a las variables locales se hacen mediante el operador
local(*nombre). El ejemplo siguiente ilustra este modo de paso de argumentos describiendo
la rutina swap que hace la permuta de los valores de los argumentos.

sub swap {
   local(*x, *y) = @_; # asignación local de los argumentos
   local($t);          # variable local
   $t = $x;
   $x = $y;
   $y = $t;
   return @_;          # resultado de la función
}
$a = 4; $b = 1;
&swap(*a, *b);         # $a =1; $b = 4;

Resulta esencial que la asignación de los argumentos a las variables locales se haga
mediante el operador local. Ya que la asignación directa de la variable local mediante
*nombre=valor modifica las ocurrencias de la variable nombre en el script. Por ejemplo:

sub swap {
  (*a, *b) = @_;         # asignación de argumentos
  local($t);
  $t = $a;
  $a = $b;
  $b = $t;
  return @_;
}
$a = 4; $b = 1;
$x = "pi"; $y = 1.414;
&swap(*x, *y);            # $x = 1.414; $y = "pi"
print "a=$a, b=$b\n";     # $a = 1.414; $b = "pi"

Entrada / Salida
Perl interactúa con el usuario o con el sistema operativo por medio de entradas salidas que
permiten el intercambio de información. Este intercambio de datos se gestiona por medio
de operadores específicos que configuran una interfaz entre el script y su entorno.

1. El acceso a archivos en Perl.

Perl accede a los archivos de tipo ASCII por medio de punteros a archivos. Estos se
referencian mediante variables y constituyen el enlace entre el script y el archivo
consultado. Se utilizarán mayúsculas para representar estas variables a fin de no
equivocarse con otras variables. Los archivos se consultan mediante la rutina open que
admite dos argumentos, un puntero de archivo y un nombre de archivo:

open(PUNTERO, "modo de acceso + nombre de archivo");

El argumento de open que representa el nombre de archivo puede tener cualquiera de los
prefijos que se muestran en la siguiente tabla, estos prefijos indican el modo de acceso al
archivo (si no se pone ningún prefijo es que se toma el modo de acceso por defecto que es
el de lectura):
En cuanto a los punteros a archivos decir que, cuando se ejecuta un programa en Perl su
primera actividad es asignar un puntero o manejador de archivo para el canal de entrada,
otro para el canal de salida y otro para el de información de errores. Estos punteros son
respectivamente STDIN, STDOUT y STDERR, donde se puede observar que STD
significa estándar. Los tres STD se usan con tanta frecuencia en Perl que a menudo se
suponen que existen, y por consiguiente, Perl no necesita que se mencionen explícitamente,
en lugar de ello, Perl los crea y les asigna canales automáticamente. Por ejemplo:

print "hola";
print STDOUT "hola";

Estas dos líneas realizan lo mismo ya que Perl supone que STDOUT es el monitor y por
eso visualiza sin necesidad de indicar en ningún lugar STDOUT.

En el ejemplo que se puede ver a continuación, forzamos un error muy típico en los
progrmadores no cerrar comillas:

print "hola;

El resultado de la ejecución de este programa será un mensaje paracido a este:

Can't find string terminator...line 3

Sabemos que con el simbolo > podemos redirigir una salida de pantalla a un archivo. Pero
si tecleamos:

hola.pl > error.txt

El archivo error está vacío. Esto es porque la salida estándar de los errores STDERR es la
pantalla. Para que se grave el error en el archivo hay que direccionar el canal de error, que
en Unix es el 2, al archivo. Esto se hace como sigue:
hola.pl 2>error.txt

2. El operador de entrada <>.

Una vez iniciado el puntero mediante la rutina open, este mismo puntero permite acceder al
contenido del archivo por medio del operador <>. El contenido del archivo se recorre línea
por línea mediante la estructura <PUNTERO>. Al final de la utilización el archivo se cierra
mediante el operador close. El ejemplo siguiente indica como acceder al contenido del
archivo data.txt y guardar el resultado en el archivo out.txt:

open(IN, "data.txt");
open(OUT, ">out.txt");
while($linea = <IN>) {
  # manipula los caracteres leidos y puestos en la variable
  # $linea. Por ejemplo convertir los caracteres a minúsculas
  $linea =~ tr/A-Z/a-z/;
  # escritura del resultado
  print OUT $linea;
}
close(IN);
close(OUT);

El ejemplo siguiente visualiza en la consola el nombre  de cada usuario y su directorio

predeterminado. Esta información se extrae del archivo "/etc/passwd" que contiene la
descripción de cada login. Para ello es necesario saber que cada línea del archivo passwd
está compuesta por: el nombre que usa el usuario para entrar (login), la contraseña
encriptada (password), número que identifica al usuario (uid), número que identifica al
grupo al que pertenece el usuario (gid), información sobre el usuario (User_Information),
directorio inicial del usuario (login_directory) y el interprete de comandos usado por dicho
usario (login_shell). Esta información relativa al usuario se estructura en dicho fichero en
una línea de la siguiente manera:

login:password:uid:gid:User_Information:login_directory:login_shell

Por tanto, este ejemplo se realizará de la siguiente manera:

open(PASSWD, "/etc/passwd");
while ($p = <PASSWD>) { # lee una línea del archivo
    chop($p); #quitamos el salto de línea
    @field = split(/:/, $p);
    print " Usuario $field[0] y su directorio es $field[5]";
}
close(PASSWD);

A continuación se da de alta a un usuario si clave de paso, esto se realiza escribiendo en el

archivo "/etc/passwd":
open(PASS, ">>/etc/passwd");
print PASS, "$login::$uid:$gid:$information:";
print PASS, "$login_dir:$login_shell\n";
close(PASS);

Si STDIN se encuentra del operador <>, lee una línea cada vez desde ese manejador de
archivo. Por ejemplo:

$uno = <STDIN>;
$dos =<STDIN>;
print $uno.$dos;

Al ejecutar este script, teclear unas palabras seguidas de enter y repetir lo mismo una
segunda vez. A medida que escribimos <STDIN> lee lo que tecleamos y al pulsar enter lo
asigna a la variable $uno. Lo mismo ocurre le ocurre a $dos. Pero, si se ejecuta este otro
script:

while ($linea = <STDIN>) {

   print $linea;
}

Este script permite hacer un bucle para leer y escribir tantas líneas como queramos. La
condición se escribe entre paréntensis y las líneas que hacen el bucle entre llaves. Para
finalizar la entradadesde el teclado pulsar Control+Z.

Por otro lado, el acceso en lectura a un archivo es dependiente del contexto. En un contexto
escalar, Perl lee un archivo línea por línea y lo asigna al escalar. En un contexto de array o
lista, el acceso al contenido del archivo entraña una lectura completa del archivo. Cada
elemento del archivo contiene entonces una línea completa del archivo leído. Por ejemplo:

$file = "datos.txt";
open(DATA, $file) || die "no se puede abrir el archivo\n";
@lineas = <DATA>   # lee todo el archivo.
close(DATA);
La función die manda una cadena de caracteres por el canal de error.

Esta propiedad debe utilizarse con precaución, porque la lectura completa de un archivo
corre el riesgo de ser muy costosa en memoria. Por otra parte, el lenguaje Perl utiliza
caches para las entradas/salidas y en consecuencia la lectura completa de un archivo no
entraña necesariamente una ganancia en materia de rendiemiento.

3. Los canales de comunicación (pipes).

La rutina open de Perl puede utilizarse tambiém para ejecutar mandatos del shell, modificar
sus entradas y recuperar sus salidas. Cuando el nombre del archivo lleva como prefijo el
carácter |, este nombre se trata como un mandato. Este mandato se ejecuta y comunica con
el script Perl mediante la rutina print. Veamos un ejemplo:

open(MAIL, "Mail root"); # prepara un mail al superusuario

# contenido del mail
print MAIL "La cuenta del usuario a2344 ha expedido";
# envío del mail
close(MAIL);

Por otro lado, cuando el nombre del archivo va seguido del carácter |, el mandato se ejecuta
y se puede acceder a su resultado por medio del operador <>. Por ejemplo:

# examina las personas conectadas a la máquina

open(WHO, "who|");
while($who = <WHO>) {
   chop $who; # suprime el retorno de carro
   ($user, $tty, $junk) = split(/\s+/, $who, 3);
   print "El usuario $user está en la terminal $tty\n";
}
close(WHO);

4. Los operadores de comprobación de archivos.

Estos operadores tratan de resolvernos diferentes problemas como la verificación de la
existencia de un archivo antes de modificarlo o la supresión de archivos existentes en la
creación de archivos con el mismo nombre. Estas verificaciones se llevan a cabo mediante
operadores que proporcionan información relativa a los archivos. Estos opeadores que
veremos en la tabla que se muestra a continuación son unarios, su argumento es un puntero
de archivo.

Por ejemplo:

$data = "data.txt";
if (e- $data) {
   # OK, el archivo existe
   open ...
}
else {
   print "el archivo $data no existe.\n";
}

5. Las funciones print, printf  y sprintf.

Las funciones print y printf permiten la escritura o la visualización de un resultado. El
operador print envía la cadena de caracteres al puntero de archivo pasado como argumento.
Cuando éste está ausente, el utilizado es el puntero STDOUT que representa la salida
estándar (la consola). La sintaxis de este operador es:

print PUNTERO $str1, $str1, ..., $strN;

Por otro lado la función printf permite especificar el formato de escritura. El texto así
formateado se envía al puntero de archivo pasado como argumento. Este formato es
idéntico al del lenguaje C. Por lo tanto el texto formateado consta de una ristra de
caracteres. Los caracteres de ristra se escriben tal cual a excepción del %. El % indica que
hay que mostrar un parámetro de la lista, el siguiente al último mostrado, con un formato en
concreto el cual lo indica el caracter que sigue al %. Los caracteres más comunes y el tipo
de datos que representa se muestra en la siguiente tabla:

Si se desea imprimir el % como un carácter dentro de una cadena de control, debe utilizarse
%%.

Hay que tener en cuenta que los literales de ristras permiten escribir caracteres especiales
con lo que se denomina un secuencia de escape. La secuencia de escape comienza siempre
con "\" y a continuación se escribe otro carácter que representa el código especial o el
número en octal o hexadecimal de su código ASCII. Las secuencias de escape representan
un único carácter en la ristra donde aparecen.

Un ejemplo sencillo:

printf PUNTERO "%s %f", $string, $float;

printf "Enteros: base10=%s, base8=%o, base16=%x\n", $y, $z, $w;
# El identificador es STDOUT (visualización por pantalla).

La función sprintf devuelve una cadena de caracteres formateada por la conveciones

normalmente utilizadas por printf, para ello se recomienda ver las dos tablas anteriores.
Para ver mejor el funcionamiento de esta rutina introducimos el siguiente ejemplo:

$lenguaje = "Perl";
$longitud = 10;
$conformato = sprintf("%s", $lenguaje);
print $conformato,"\n";                      # Imprime:Perl
$conformato = sprintf(">>%s<<", $lenguaje);
print $conformato,"\n";                      # Imprine:>>Perl<<
$conformato = sprintf(">>%s <<", $lenguaje);
print $conformato,"\n";                      # Imprime:>>Perl <<
$conformato = sprintf(">>%10s<<", $lenguaje);
print $conformato,"\n";                      # Imprime:>> Perl<<
$conformato = sprintf(">>%-10s<<", $lenguaje);
print $conformato,"\n";                      # Imprime:>>Perl <<
$conformato = sprintf(">>%-${longitud}s<<", $lenguaje);
print $conformato,"\n";                      # Imprime:>>Perl <<

6. Las funciones para manejo de ficheros.

Para realizar un mejor tratamiento de los datos que se encuentran en ficheros, Perl posee
una serie de funciones predefinidas que nos ayudan a realizar esta tarea con gran facilidad y
simpleza. A continuación mencionaremos a las funciones más usadas por todos los
programadores de Perl.

 read(manejador, variable, longitud, [desplazamiento]). Esta función lee

desde un fichero, especificado en el parámetro manejador, un número de
bytes, especificado por el parámetro longitud, y lo introduce en una variable
de tipo escalar representada por el parámetro variable. El parámetro
desplazamiento, si se especifica, indica desde que posición del fichero se
empieza a leer. Por defecto, es la posición donde se encuentra el puntero. He
aquí algunos ejemplos:

open(DAT,"<datos.txt");
read(DAT, $var, 30);
# $var tiene los primeros 30 caracteres de
# datos.txt

 seek(manejador, posición, referencia). La función seek pone el puntero del

fichero especificado por el parámetro manejador en el lugar indicado por el
parámetro posición. El parámetro posición puede tener un valor positivo que
nos indica un desplazamiento hacia el final del fichero o un valor negativo
que nos indica un deplazamiento hacia el inicio del fichero. Este
desplazamiento indicado en el parámetro posición se puede hacer desde el
principio del fichero, desde la posición del puntero actual del fichero o desde
el final del fichero. Esto lo determina el parámetro referencia con los valores
0,1 y 2 respectivamente. Ejemplo:

open(DAT,"<datos.txt");
read(DAT, $var, 30);
seek(DAT,-31,1);
read(DAT, $var, 30); # Volvemos a leer lo mismo.

 tell(manejador). Esta función retorna la posición del puntero en el fichero

especificado en el parámetro manejador. Ejemplo:

open(DAT,"<datos.txt");
read(DAT, $var, 30);
$ptr = tell(DAT);    # $ptr = 31;

 eof(manejador). Esta función retorna 1 (verdadero) si el fichero

especificado por el parámetro manejador tiene el puntero en el final del
mismo. Tambiém devolverá uno si el manejador no está asociado a ningún
fichero. En el ejemplo que viene a continuación se leerá un fichero de
nombre en el que cada uno de ellos está en una línea del fichero y ocupa 50
caracteres contando con el de salto de línea.
open(NOM,"<nombres.txt);
while (!(eof(NOM))) {
    read(NOM, $nombre, 50);
    print $nombre;
}

Variables
predefinidas
Las siguientes variables tienen un especial significado para el lenguaje Perl. Estas variables
se pueden clasificar en tres tipos:

1. De fichero.
Estas variables contienen algunos valores perteneciente la manejador de ficheros
seleccionado actualmente. Cada manjador de fichero necesita su propio conjunto de
valores. Cuando seleccionamos otro manejador de fichero, el manejador de fichero anterior
mantiene sus valores pero las variables reflejarán ahora los valores del nuevo. Los variables
predefinidas de fichero son las siguientes:

 $%: Número de página del canal de salida actual.

 $=: Tamaño de página del canal de salida actual.
 $- : Número de líneas restantes en la página del canal de salida actual.
 $|: Si no es cero, fuerza a vaciar el buffer después de cada operación de escritura.
 $~: Contiene el nombre del formato o report definido para la salida actual.
 $^: Es el nombre del formato o report de la cabecera definido para la salida actual.  

2. Locales.
Estas variables son locales al bloque de código actual. Las variables locales predefinidas
son las siguientes:

 $1...$9: Contiene la subcadena desde el correspondiente al conjunto de paréntesis en

la última cadena comparada con éxito.
 $&: Representa el valor de la última cadena de caracteres comparada con éxito.
 $`y $’: Estos dos términos se utilizan conjuntamente para separar cadenas de
caracteres comparadas con éxito. ` es la anterior y ‘ es la siguiente. Ejemplo:
$linea = 'abcdefghi';
$linea =~ /def/;
print "$`:$&:$'\n";     # imprime abc:def:ghi

 $+: El último éxito de la última búsqueda del último patrón. Es útil cuando no se
sabe que patrón de un conjunto fue el encontrado.   

3. Globales.
Estas variables tiene el mismo significado en todo el script, así como en los paquetes que
utiliza. Las variables globales predefinidas son las siguientes:

 $_: Contiene el contenido del último registro leído de un fichero. Es el argumento

predeterminado que poseen varias funciones y construcciones en Perl. Por ejemplo:

if (/html/) {               if ($linea =~ /html/) {

   print $_;                  print $linea;
}                           }
while (<STDIN>){            while ($linea = <STDIN>){
 print "escrito: ", $_        print "escrito: ", $linea;
}                           }
$_ = "nom1&nom2";           $linea = "nom1&nom2";
@lista = split(/&/);        @lista = split(/&/, $linea);

 $.: Contiene el número de la última línea leída de un fichero.

 $/: Separador de campo para la entrada.
 $,: Separador de campo para la salida, aplicable a print.
 $\: Separador de registro para la salida, aplicable a print.
 $"": Como $, se aplica a arrays en búsquedas de cadenas entre dobles comillas
(cadenas que se interpreten de la misma forma).
 $#: El formato de salida para mostrar números.
 $$ : Es el número de proceso perl del scripts que se esta ejecutando actualmente.
 $?:  El valor de estado devuelto por la última tubería (pipe) que se cerró, por el
comando ejecutado con el backquote (`\`) o por una operación del sistema.
 $*: Puesto a 1 realiza búsquedas en varias líneas con una misma cadena, a 0 para
indicar al compilador que las cadenas son de una única línea para optimizar
búsquedas.
 $[: Contiene el valor del primer índice de una array de escalares, por defecto es 0.
 $]: Contiene la cadena mostrada cuando se invoca "perl -v", es decir la versión del
compilador, etc. Puede ser útil para comprobar al comienzo del script, que la
versión del intérprete que ejecuta el script es la correcta.
 $;: Es el separador para emular arrays multi-dimensionales.
 $!: Contiene el valor actual de ERRNO, es decir, el último error acontecido.
 $0: Contiene el nombre del fichero que hemos dado a nuestro perl script.
  $<: Uid real del proceso actual.
 $>: Uid efectivo del proceso actual.
 $@: Contiene el mensaje de error de sintaxis de perl del último comando evaluado.
Si es nulo quiere decir que el último comando se ejecutó correctamente y estaba
bien escrito.
 $(: Gid real del proceso actual.
 $): Gid efectivo del proceso actual.
 @ARGV: Contiene los parámetros pasados a nuestro script Perl. Por ejemplo:

# Lee argumentos de la línea de comando y los lista.

$NumArg = $#ARGV; # Almacena el número de argumentos

$Cuenta = 0;
while ($Cuenta < $NumArg) {
  print "Argumento0 ",$Cuenta,"-->",$ARGV[$Cuenta], "\n";
  $Cuenta++;
}

 %ENV: Array asociativo que contiene las variables de entorno bajo el que se
ejecuta nuestro script Perl.
 $:: El conjunto actual de caracteres tras los que una cadena se rompe para llenar los
campos siguientes (que empiecen con ^) en un formato.
 $^D: Los valores actuales de los flags de depuración.
 $^F: El máximo descriptor de fichero del sistema, normalmente 2. Los descriptores
de fichero del sistema son pasados a los procesos hijos, mientras que los superiores
no. Durante una apertura, los descriptores de fichero del sistema se guardan, incluso
si falla la operación.
 $^I: Contiene el valor actual de la extensión del editor. Con undef se desactiva.
 $^L: Qué formato utilizar para realizar un salto de línea. Por defecto: \f.
 $^P: Flags internos que el depurador borra. Se puede desactivar el depurador
borrándolos.
 $^T: El tiempo, en segundos, transcurrido desde que el script comenzó a ejecutarse.
 $^X: El nombre con el que Perl se ejecutó, argv[0].
 $ARGV: Contiene el nombre del fichero actual cuando se lee de <ARGV> .
 @INC: El array INC contiene la lista de lugares en donde buscar scripts en Perl
para ser evaluados por el comando "do EXPR" o "require". Contiene inicialmente
los argumentos de cualquier línea de comando -I , seguido de la librería Perl por
defecto, probablemente "/usr/local/lib/perl", y un punto ".",para representar el
directorio actual.
 %INC: El array asociativo INC contiene entradas para cada nombre de fichero que
ha sido incluido vía "do" o "require". La clave es el nombre del fichero especificado
y el valor es la localización del fichero encontrado. El comando "require" usa este
array para determinar cuando un fichero ha sido incluido.
 $ENV{expr}: Es un array asociativo que contiene tu entorno actual. El entorno de
los procesos hijo se puede cambiar colocando un valor en este array.
 $SIG{expr}: Es otro array asociativo usado para inicializar manejadores de señales
para distintas señales. Este array sólo contiene valores para las señales inicializadas
por el script.