Perl y el Web - Descripción Técnica

Perl tiene básicamente cuatro tipos de datos: escalares, arreglos (o listas), hashes y referencias. Escalares son aquellas variables que tienen un único valor definido. Pueden ser números (enteros o de punto flotante), strings o referencias. Se denotan con un nombre de variable precedido de un signo $.

Los arreglos o listas son conjuntos ordenados de escalares, indicados por un número (usualmente se cuenta desde cero ascendentemente). Arreglos completos se denotan con un nombre de variable precedido de un signo @; un valor específico de un arreglo, en cambio, se denota con un signo $ y un indice entre corchetes: {$}var[1].

Los hashes o arreglos asociativos son conjuntos no ordenados de escalares, indicados por una llave.

Las referencias son en realidad un tipo ``mágico'' de escalares. Contienen un índice a un area de memoria donde hay un dato almacenado, junto con un indicador del tipo de dato al que apuntan. Dado que son escalares, es posible construir arreglos o hashes de referencias; esto hace posible instanciar casi cualquier estructura de datos. Las referencias son especiales, además, porque son fuertemente tipadas: mientras que los escalares corrientes son números o strings dependiendo del contexto de evaluación, no es posible usar una referencia de otra manera que como fue definida (es decir, una referencia a un arreglo nunca puede ser una referencia a un escalar, etc.). Es posible leer una referencia en contexto de string, y esto entrega su valor (algo como "HASH(0x804b620)'' es la representación en string de una referencia a un hash).

Perl soporta las estructuras clásicas : if, for, while, do. Agrega tambipen otras menos corrientes : unless, foreach, until y el condicional ternario ?:. Estas estructuras pueden combinarse con etiquetas, obteniéndose resultados bastante interesantes. Veamos el siguiente :

OUTER: for my $wid (@argy1)
{
INNER : for my $jet (@ary2)
{
next OUTER if $wid > $jet;
wid += $jet;
}
}

Aquí vemos otra característica de Perl, la palabra clave "my'' que se usa para indicar el entorno léxico de una variable. En el caso del for del ejemplo, se indica que la variable $jet solo esta definida en el bloque INNER, y si tratara de leerse en el bloque OUTER (fuera de INNER) se encontraría indefinida.

Vemos también que next (Así como redo y last) pueden recibir una etiqueta de salto (Más bien, de bloque). Esto hace innecesaria la instrucción goto que plaga algunos programas en C debido a la inexistencia de estas etiquetas.

Perl provee manejo de objetos apropiado. Cada clase es un paquete que provee métodos para trabajar con los objetos que se definen; el paquete decide qué interfaces exporta para sus objetos. Esto provee un nivel de encapsulación apropiado.

Bajo el capó, un objeto en Perl es simplemente una referencia bendita (bless es una función que le indica a la referencia que pertenece a una clase.). A esa referencia pueden aplicársele los métodos que la clase define. Existen métodos especiales que devuelven un objeto; por ejemplo, un constructor. Perl soporta herencia múltiple.

Además de clases existen módulos. Los módulos son una forma procedural de encapsulación en Perl. Proveen espacios de nombres de variables separados del espacio principal; esto permite tener funciones separadas del cuerpo principal e importarlas según sea necesario. Las clases son, simplemente, una variante especial de módulos. Sistema de Tipos

Perl no es un lenguaje que controle la correctitud y unicidad de los tipos. Las variables en Perl cambian de tipo según el contexto (strings o números). Además, dependiendo del contexto los tipos múltiples (arreglos y hashes) pueden tener comportamientos especiales, como retornar la cantidad de elementos. Esto permite una extraordinaria flexibilidad, pero puede ocasionar serios problemas si no se tiene cuidado en el correcto manejo de las vriables y los resultados que arroja.

Veamos un ejemplo :

$a = 123;
$b = 456;
print $a + $b; # imprime 579
print $a . $b; # imprime 123456

Como vemos la primera operación corresponde a una operación entre enteros, mientras que la segunda es la concatenación de Strings. Los tipos de las variables dependerán del contexto en el cual están siendo instanciadas. Paso de parámetros

Perl siempre pasa los parámetros por valor. Si se desea pasar una referencia, como en C, debe primero crearse una variable escalar con esa referencia. Más aún, Perl nunca pasa arreglos o hashes: estas estructuras colapsan a los escalares que las conforman antes de pasarse a una función. Las invocaciones y los retornos pueden pasar tantos parámetros como se desee. Las invocaciones aparecen en la variable local @_.

sub max {
my $max = shift(@_);
foreach $foo (@_) {
$max = $foo if $max < $foo;
}
return $max;
}
...........
$bestday = max($mon,$tue,$wed,$thu,$fri);

Perl hace evaluación completa (o rápida) de expresiones. Exceptuando el código entre comillas entregado al operador eval, todo el código es compilado de inmediato al inicio del programa, y las expresiones se evalúan en cuanto se espera su valor.

Si bien es posible crear funciones anónimas y pasar referencias a ellas, esto no es más que un truco del lenguaje y no puede ser considerado evaluación floja (o lenta).

Desde la versión 5.005, Perl soporta hebras ("threads''), pero son todavía experimentales. Tiene los mecanismos necesarios para manejo multihebras: hebras asíncronas, entrega de control a otras hebras, espera de término de otra hebra, bloqueos entre variables y funciones, etc. Además, Perl soporta el mecanismo Unix estándar fork/exec para múltiples procesos.

Se provee un mecanismo para precompilar Perl a otros lenguajes (C, bytecode) que puede utilizarse para optimizar el tiempo de carga, etc.

Se provee un mecanismo de "chequeo de contaminación'' (taint checking) el cual puede generar programas muy seguros, aún para los más rebuscados inputs. Usado en CGIs, por ejemplo, es mucho mejor que el código C de un programador promedio.

Un primer progama de Ejemplo ... "Hello World!"

Este simple programa muestra el uso de "for" con una lista de parámetros que son asignados por turno a una variable anónima. El resultado es "Hello World!"

$hola = "Hello";
$mundo = "world!\n";
for $i ( $hola, $mundo)
{
print $i;
}

Un segundo programa de ejemplo

Este programa cuenta las palabras de un texto que recibe por STDIN. Ilustra varios conceptos típicos de Perl.

while (<>)
{ foreach $i (split){ $i =~ s/^(\w+)$/\L$1/; $v{$i}++; } }
foreach $i (keys %v){ print "$v{$i} veces $i\n" unless $v{$i}==1
}

Este ejemplo ilustra varias cosas tipicas de Perl:

• El uso del ciclo while.
• El uso del operador <> sobre un filehandle, que retorna una línea leida desde él o falso si el archivo retorna EOF. En caso de omitir el filehandle, se usa STDIN. En caso de omitir la variable sobre la cual se debe retornar, se escribe el valor en S.
• El constructor foreach, que itera con una variable anonima sobre todos los valores de una lista.
• La función split, que dado un string devuelve una lista de substrings, separados según una expresión. Si se omite la expresión, separa según los espacios en blanco; si se omite la línea, se usa $_ ( Efectivamente, $_ es una variable que se usa por omisión en muchos lugares).
• El uso del operador s/// para minusculizar una palabra usando expresiones regulares y ``backreferences''.
• El uso de un hash como estructura de memoria: {$}hash\{{$}llave\}.
• La función keys, que retorna todas las llaves definidas de un hash.
• La función print, que expande valores de variables conocidas.
• El constructo unless, que es una especie de if con la condición invertida.