Un aspecto importante de este lenguaje es que, por defecto, no es necesario declarar las variables
previamente a su uso. Las variables se pueden empezar a usar directamente en las expresiones, lo cual
ofrece mucha flexibilidad al momento de estar desarrollando el código.
Existen tres tipos básicos de variables, los cuales se citan a continuación.
1. Escalar: empiezan por el carácter $. Un escalar puede almacenar números, strings, referencias a
otras variables y descriptores de ficheros. Algunos ejemplos de la declaración de este tipo de datos
son los siguientes: $a = 5; $b = "xxx"; $c = $a++;
2. Arreglos: las variables array empiezan por el carácter @, y sirven para agrupar un conjunto de
variables de tipo escalar. En este aspecto también se debe de nombrar la existencia de matrices.
Algunos ejemplos son los siguientes: @a = (95, 7, 'fff' ); print @a;
3. Hash: las variables tipo hash o array asociativo empiezan por el carácter %. Se trata de un tipo
característico de Perl, y consiste básicamente en un array en el cual se accede a sus distintos
elementos a través de una clave en lugar de por un índice. Los elementos se accesan por claves y
no se permiten claves duplicadas. Para crear un elemento de un hash se requiere una lista de dos valores, siendo el primer elemento la clave y el segundo es el valor asociado a dicha clave, como
se muestra en el siguiente ejemplo: %almacen = ( 'Peras', 5, 'Manzanas', 3); print
$almacen{'Peras'};
Tipos de datos [editar]Perl tiene tres tipos de datos: escalares, listas y hashes:
Un escalar es un solo valor; puede ser un número, un string (cadena de caracteres) o una referencia
Una lista es una colección ordenada de escalares (una variable que almacena una lista se llama array)
Un hash, o memoria asociativa, es un mapeo de strings a escalares; los strings se llaman claves y los escalares valores.
Todas las variables están precedidas por un sigil, que identifica el tipo de dato que es accedido (no el tipo de dato de la misma variable). Se puede usar el mismo nombre para variables de diferentes tipos, sin que tengan conflictos.
$var # un escalar
@var # un array
%var # un hash
Los números se escriben de la forma usual; los strings están rodeados entre comillas de varias clases.
$n = 42;
$nombre = "juan";
$color = 'rojo';
Perl convertirá los strings en números y viceversa dependiendo del contexto en que sean usados. En el siguiente ejemplo los strings $n y $m son tratados como números cuando son argumentos del operador suma. Este código imprime el número '5', desechando cualquier información no numérica de la operación y dejando los valores de las variables intactos. (El operador de concatenación no es +, sino ..)
$n = "3 manzanas";
$m = "2 naranjas";
print $n + $m;
Perl también tiene un contexto booleano que utiliza en la evaluación de declaraciones condicionales. Los siguientes valores en Perl evalúan todos como falso:
$falso = 0; # el número cero
$falso = 0.0; # el número cero como flotante
$falso = '0'; # el string cero
$falso = ""; # el string vacío
$falso = undef; # el valor devuelto por undef
Todos los demás valores se evalúan a verdadero. Esto incluye el curioso string auto-descriptivo "0 pero verdadero", que de hecho es 0 como número, pero verdadero como booleano. (Cualquier string no numérico también tendrá esta propiedad, pero este string en particular es ignorado por Perl en contextos numéricos). Las expresiones booleanas evaluadas también devuelven valores escalares. Aunque la documentación no indica qué valor particular se devuelve como verdadero o falso (y por lo tanto no fiable), muchos operadores booleanos devuelven 1 por verdadero y el string vacío para falso (que evalúa a cero en contexto numérico). La función defined() le dice si la variable tiene algún valor. En el ejemplo anterior defined($falso) será verdadero con cada uno de los valores anteriores, excepto undef. Si, específicamente, quiere asegurarse de tener un resultado 1/0 (como en C), necesita realizar el cálculo siguiente:
my $resultado_real = $resultado_booleano ? 1 : 0;
Una lista se define listando sus elementos, separados por comas y rodeados por paréntesis donde así sea requerido por la precedencia de los operadores.
@puntuaciones = (32, 45, 16, 5);
Un hash puede ser inicializado desde una lista de pares clave/valor.
%favorito = (
joe => 'rojo',
sam => 'azul',
);
Los elementos individuales de una lista son accedidos utilizando un índice numérico, dentro de corchetes. Valores individuales en un hash son accedidos utilizando la correspondiente clave, dentro de llaves. El sigil $ identifica que el elemento accedido es un escalar.
$puntuaciones[2] # un elemento de @puntuaciones
$favorito{joe} # un valor de %favorito
Múltiples elementos pueden ser accedidos usando en su lugar el sigil @ (identificando el resultado como una lista).
@puntuaciones[2, 3, 1] # tres elementos de @puntuaciones
@favorito{'joe', 'sam'} # dos valores de %favorito
El número de elementos en un array puede ser obtenido evaluando el array en contexto escalar o con la ayuda del sigil $#. Éste último da el índice del último elemento dentro del array, no el número de elementos.
$numero = @amigos;
$#amigos; # el índice del último elemento en @amigos
$#amigos+1; # normalmente el número de elementos en @amigos,
# que es uno más que $#amigos porque el primer elemento tiene el índice 0, no 1
Hay unas pocas funciones que operan sobre hashes enteros.
@nombres_de_clientes = keys %direcciones; # guarda en @nombres_de_clientes todas las claves de %direcciones
@direcciones_de_email = values %direcciones; # guarda en @direcciones_de_email todos los valores de %direcciones
Estructuras de control [editar]Artículo principal: Estructuras de control, en inglés
Perl tiene varias clases de estructuras de control.
Tiene estructuras de control orientado al bloque, similar a los de los lenguajes de programación C y Java. Las condiciones están rodeadas por paréntesis y los bloques subordinados por llaves:
etiqueta while ( condición ) {... }
etiqueta while ( condición ) {... } continue {... }
etiqueta for ( expresión inicial; expresión condicional; expresión incremental ) {... }
etiqueta foreach var ( lista ) {... }
etiqueta foreach var ( lista ) {... } continue {... }
if ( condición ) {... }
if ( condición ) {... } else {... }
if ( condición ) {... } elsif ( condición ) {... } else {... }
Cuando se controla a una sola declaración, los modificadores de declaración proporcionan una sintaxis más ligera:
declaración if condición;
declaración unless condición;
declaración while condición;
declaración until condición;
declaración foreach lista;
Los operadores lógicos cortocircuito son normalmente usados para controlar el flujo del programa a nivel de expresión:
expr and expr
expr or expr
Las palabras clave de control de flujo next, last, return y redo son expresiones, por lo que pueden ser usadas con los operadores cortocircuito.
Perl también tiene dos construcciones implícitas para bucles:
resultados = grep {... } lista
resultados = map {... } lista
grep devuelve todos los elementos de lista en que el bloque subordinado evalúa a verdadero. map evalúa el bloque subordinado por cada elemento de lista y devuelve una lista de los valores resultantes. Estas construcciones permiten un estilo simple de programación funcional.
No hay declaración switch (salto multi-camino) en Perl 5. La documentación Perl describe media docena de formas de conseguir el mismo efecto usando otras estructuras de control. Existe sin embargo un módulo Switch, que proporciona la funcionalidad modelada para el próximo Perl 6.
Perl incluye una declaración goto etiqueta, pero es usada raramente. Las situaciones donde en otros lenguajes se utiliza goto no ocurren tan a menudo en Perl debido a sus amplias opciones de control de flujo.
Existe también una declaración goto &sub que realiza una llamada 'final'. Termina la subrutina actual e inmediatamente llama a la sub especificada. Esto se usa en situaciones donde una nueva subrutina puede realizar una gestión de la pila más eficiente que el propio Perl (porque típicamente no se requiere ningún cambio en la pila actual), y en una recursión muy profunda este tipo de llamadas puede tener un sustancial impacto positivo en el funcionamiento porque evita la sobrecarga de la gestión contexto/pila en el momento de retornar.
Subrutinas [editar]Las subrutinas se definen con la palabra clave sub e invocadas simplemente nombrándolas. Si la subrutina en cuestión no ha sido todavía declarada, es necesario, para el proceso de análisis sintáctico, poner los paréntesis.
foo(); # paréntesis necesarios aquí...
sub foo {... }
foo; #... pero no aquí
Una lista de argumentos pueden ser indicados después del nombre de la subrutina. Los argumentos pueden ser escalares, listas o hashes.
foo $x, @y, %z;
Los parámetros de una subrutina no necesitan ser declarados, ni en número ni en tipo; de hecho, pueden variar en cada llamada. Los arrays son expandidos a sus elementos, los hashes a una lista de pares clave/valor y todo el conjunto es pasado a la subrutina como una indiferenciada lista de escalares.
Cualesquiera de los argumentos pasados están disponibles para la subrutina en el array especial @_. Los elementos de @_ son asociados a los argumentos actuales; cambiando un elemento de @_ cambia el argumento correspondiente.
Los elementos de @_ pueden ser accedidos con los subíndices de la forma normal.
$_[0], $_[1]
Sin embargo, el código resultante puede ser difícil de leer y los parámetros tener una semántica de pase por referencia, que puede resultar algo no deseable.
Un modismo común es asignar @_ a una lista de variables con nombres.
my($x, $y, $z) = @_;
Esto afecta tanto a la mnemónica de los nombres de los parámetros como a la semántica de los valores pasados por valor. La palabra clave my indica que las siguientes variables están léxicamente embebidas en el bloque que las contienen.
Otro modismo es sacar los parámetros de @_. Esto es muy común cuando la subrutina toma un sólo argumento.
my $x = shift; # Si no se dice nada, nos referimos a @_
Las subrutinas pueden devolver valores.
return 42, $x, @y, %z;
Si la subrutina no sale vía declaración return, entonces devuelve la última expresión evaluada en el cuerpo de la subrutina. Arrays y hashes en el valor de retorno son expandidos a una lista de escalares, igual que si fueran argumentos de una función.
La expresión devuelta es evaluada en el contexto de la llamada de la subrutina; esto puede sorprender al desprevenido.
sub lista { (4, 5, 6) }
sub array { @x = (4, 5, 6); @x }
$x = lista; # devuelve 6 - último elemento de la lista
$x = array; # devuelve 3 - número de elementos de la lista
@x = lista; # devuelve (4, 5, 6)
@x = array; # devuelve (4, 5, 6)
Una subrutina puede descubrir su contexto de llamada con la función wantarray.
sub cualquiera { wantarray ? (1, 2) : "Naranjas" }
$x = cualquiera; # devuelve "Naranjas"
@x = cualquiera; # devuelve (1, 2)
