Tipos de datos y operadores en Perl

Clases de datos y operadores en Perl

F. Javier García Castellano
Web: http://genura.ugr.es/~javi, Mail: javi@geneura.ugr.es

(C) GeNeura Team
Web: http://geneura.ugr.es, Mail: todos@geneura.ugr.es

1.- Datos escalares

Los datos escalares son las variables simples y pueden contener enteros, reales, cadenas o referencias. Este tipo de variables van precedido siempre por $. Esta es una de las mayores diferencias con lenguajes como el C y es que a cualquier variable escalar se le antepone dicho signo ($). La forma de nombrar las variables también es similar, se puede usar letras números y _ empezando siempre por una letra.

En Perl las variables no se tienen porque declarar, aunque se declaran con my. Además la interpretación del tipo de variable se hace en función del contenido, aunque todas la variables numéricas internamente se tratan como reales.

Programilla con variables:

  #!/usr/bin/perl
 
  #Declaro una variable
  my $hola;
  
  #Asigno valores 
  $hola="Hola Mundo\n";
  $adios="adios\n";

  #Escribimos un poco en pantalla
  print $hola;
  $hola=23;
  print "Mira un número: $hola \n";
  print "Y $adios";

Como podemos ver en el anterior ejemplo las cadenas se encierran entre comillas dobles (" "), aunque también se pueden cerrar entre comillas simples (' '). Hay caracteres especiales (retorno de carro, tabulador, etc.) que como en muchos otros lenguajes se presentan mediante la barra de escape:

\n retorno de carro a una nueva línea
\b retorno a la posición anterior
\a pitido
\t tabulación (8 espacios)
\\ el caracter \
\" las comillas dobles (aunque si la cadena está delimita por comillas simples, no hace falta)
\' las comillas simples (aunque si la cadena está delimita por comillas dobles, no hace falta)

Operadores de datos escalares

El operador de asignación se utiliza, igual que en C, el símbolo =, como se puede obervar en el primer ejemplo de la página. También se pueden mezclar operadores ariméticos junto con la asignación.

Asignación y operadores aritméticos:

  #!/usr/bin/perl
 
  #Asigno valores a variables
  my $uno=123.67;
  $dos=123123.2334;
  $suma=$uno;
  $suma+=$dos;

  #Escribimos resultados en pantalla
  print "La suma de $uno y $dos es = $suma \n";

Los operadores de comparación, son similares a los de C, pero depende si estamos comparando cadenas o datos numéricos. Los operadores para números y para cadenas son:

Comparación	Números	Cadenas
igual	==	eq
no igual	!=	ne
menor que	<	lt
mayor que	>	gt
menor o igual que	<=	le
mayor o igual que	>=	ge

En Perl también tenemos los operadores de autoincremento (++)y autodecremento (--). Y además tenemos el operador potencia **(que es muy parecido aunque muy diferente)

Autoincremento y potencia:

  #!/usr/bin/perl
 
  #Asigno valores a variables
  my $contador=0;

  
  #Escribimos en pantalla
  print "Se contar:", $contador++ , ", ", $contador ++,"...\n";

  print "2 elevado a $contador es:", (2**$contador), "\n";

Para concatenar cadenas tenemos el operador punto (.) y la función chop para quitar el último caracter a una cadena.

Concatenar y chop:

  #!/usr/bin/perl
 
  #Asigno valores a variables
  my $cad1="Hola";
  my $cad2="Mundo";
  my $cad3=$cad1." ".$cad2;

  #Metemos una nueva línea y un caracter raro en $cad3
  $cad3=$cad3."\n=";

  #Y le quitamos el caracter raro
  chop($cad3);

  #Escribimos en pantalla
  print $cad3;

2.- Arrays

Un Array en Perl es como los de C, pero con la diferencia de que van precedidos del símbolo arroba @. (como las variables de $). La forma de acceder a ellos es mediante la indexación, contando desde cero. En Perl no nos tenemos que preocupar de reservar la memoria ni gestionarla de ninguna forma. Hay que tener en cuenta que cuando se accede a un elemento de un array, ya no se está haciendo referencia a un array sino a un dato escalar, por lo que debe ir precedido del símbolo $. Vamos a verlo con un ejemplo:

Ejemplo de Arrays:

  #!/usr/bin/perl

  #Declaramos la variable primer_array como un array
  my @primer_array;

  #asignamos unos cuatro valores al array
  @primer_array=(1,"dos",3,"cuatro");

  #Añadimos un quinto de forma individual
  $primer_array[4]=5.5;

  #Mostramos el tercer elemento del array
  print "El tercero es= ".$primer_array[3]." \n";

Para sacar/insertar elementos se pueden usar las funciones pop y push. Que sacan o insertan, respectivamente, un elemento al final, es decir, tratan el array como una pila. También podemos utilizar shift y unshift para sacar o insertar, respectivamente, un elemnto del principio del array.

Para ver el tamaño (número de elementos) de un array se utiliza el símbolo de sostenido (#) entre el símbolo $ y el nombre del array, es decir, con $#array. Este tamaño nos lo da contando desde 0 o, lo que es lo mismo, realmente nos da el último índice que existe en el array. Si el array no tuviese ningún elemento, su tamaño sería -1.

Ejemplo de pop/push, shift/unshift, y tamaño del array:

  #!/usr/bin/perl

  #asignamos unos cuatro valores al array
  @matriz=(1,"dos",3,"cuatro");

  #Añadimos con Push
  push(@matriz, 5, 6, "siete");

  #Mostramos el último elemento
  print "El último es ". $matriz[$#matriz]."\n";

  #sacamos con Pop
  $uno=pop(@matriz);

  print "He sacado $uno\n";

  #Añadimos con unshift
  unshift(@matriz, "cero", -1 );

  #Mostramos el primer elemento
  print "El primero es ". $matriz[0]."\n";

  #sacamos con shift
  $uno=shift(@matriz);
 
  print "He sacado $uno\n";

  print "La matriz tiene ".$#matriz." elementos\n";

En todo script de Perl existe el array @ARGV que contiene los parámetros de entrada.

Para añadir dimensiones a los arrays, simplemente se añaden corchetes. Como en el siguiente ejemplo:

Ejemplo arrays con más de una dimensión

  #!/usr/bin/perl

  my @array3D=([],[],[]);

  $array2D[0][0]=0;
  $array2D[0][1]=1;
  $array2D[1][0]=2;
  $array2D[1][1]=3;

  $array3D[0][0][0]=20;

  print $array2D[1][1]." ".$array3D[0][0][0]."\n";

3.- Arrays asociativos

Un array asociativo en Perl o tabla hash (como también se le denomina) es un array donde los elementos son referenciados mediante claves en vez de una posición. Para los array asociativos se utiliza el símbolo %. Al igual que sucede con los arrays normales, cuando se accede a un elemento de un array asociativo se debe referenciar como un escalar con el símbolo $. Además la indexación por clave no se hace utilizando los corchetes, sino que se utilizan las llaves ({ }).

Ejemplo de utilización de arrays asocitivos:

  #!/usr/bin/perl

  #asignamos valores a una tabla hash
  my %colorfruta;

  $colorfruta{"verde"}="kiwi";
  $colorfruta{"amarillo"}="platano";
  $colorfruta{"rojo"}="sandía";
  $colorfruta{"naranja"}="naranja";

  print "Una fruta verde es: ".$colorfruta{"verde"}."\n";


  %dias=("lunes",L,"martes",M,"miercoles",X,"jueves",J,"viernes",V,"sabado",S,"domingo",D);
  print "La representación del Martes es :". $dias{"martes"}." \n";

La asociación también se puede hacer con =>, por ejemplo:

  %semana=("Lunes"=> "L", "Martes" => "M");

La función keys devuelve un array con las claves de un array asocitivo. La función values devuelve un array con los valores de un array asocitivo. Con exits($hash{clave}) podemos ver si una clave existe o no. Con delete($hash{clave}) se elimina un elemento de un array asocitivo.

4. Ejercicios

Ejercicio: Coge el primer ejemplo de esta página (Programilla con variables) y cambia las cadenas que aparecen, de forma que se usen las comillas simples, en lugar de las comillas dobles. ¿Qué diferencia hay?.

Ejercicio: Compara dos enteros y dos cadenas y guarda el resultado en variables. Muestralas por pantalla. ¿Qué sale cuando son iguales?, ¿Y cuando son diferentes?.

Ejercicio: Cuenta los parámetros de un script en Perl y muestralo por pantalla. Muestra también el primer y último parámetro del script.

Ejercicio: Inicializa un array asociativo y muestra la segunda clave. (Nota: Usa la función keys).