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.