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.