Funciones

Definición y uso

En Perl se puede definir una función es cualquier parte, aunque lo común es hacerlo al principio del fichero. La función solo se ejecuta cuando se llama expresamente. La función se define con la palabra sub.

Ejemplo:

   sub funcion_1 {

      $a = shift;         

# shift asume el array @_

# @_ contiene los argumentos

# que se dan al llamar la función

      $y = 2 * $a;

      return($y);  

# devuelve ese valor al que llamó la función

   }

La función se llama simplemente escribiendo su nombre:

   $x = 5;

   $z = funcion_1($x);    

# pasa $x como único elemento de @_

# por tanto, $z queda con 10.

Una función que no tiene un return explícito retorna, no obstante, el valor de la última expresión que se ha ejecutado; por tanto, la función funcion_1 anterior no necesita la sentencia return.

Cuanto se llama a una función, no es obligatorio recoger el valor devuelto por ésta.

Los parámetros de una función se pasan siempre por referencia; por consiguiente, si se modifica $_[1] se está cambiando el segundo parámetro usado en la expresión que llama a la función. Puede ser peligroso si no se maneja con cautela.

   sub funcion_2 {

           $_[0]=7;       

# Modifica el primer parámetro en el llamador

   }

   $a = 5;

   funcion_2($a); 

   print  $a;             

# Imprime: 7

Bloques

Un bloque consiste en un conjunto de expresiones dentro de llaves {}. Las funciones son bloques, pero también puede haber bloques sin la palabra sub. Una de las razones para tener bloques es la de disponer de variables locales que desaparecen cuando el bloque termina.

   $a=5;                  # variable global que nunca muere

   {

           $b=7;          # variable global que nunca muere

           my($c)= 3;             

# "my" crea una variable local que

# solo existe en este bloque

           funcion_3();   

# $c no es visible dentro de funcion_3

   }

   print  $a;             #  imprime: 5

   print  $b;             #  imprime: 7

   print  $c;             #  No imprime nada: $c no existe 

   sub funcion_3 {

           print $a;      #  imprime: 5

           print  $b;     #  imprime: 7

           print  $c;     #  No imprime nada: $c no existe 

   }

Cuando definimos una variable por regla general tiene un ámbito global al script, a no ser que utilicemos las funciones my o local para limitar su alcance. Su significado es muy parecido, con algún matiz:

·         La función my es la más utilizada para definir variables locales. Las variables declaradas con my son visibles sólo dentro del bloque, y no desde fuera. Tampoco son visibles a las funciones que se llaman desde el bloque.

·         La función local se usa para definir otras variables locales, pero a diferencia de las anteriores, si son visibles a las funciones que se llamen desde el bloque.

   $a = 5;        # variable global que nunca muere

   {

           local($a)=3;   

# El valor 5 se guarda temporalmente

# para reponerlo cuando el bloque termine

           local($b)=7;   

# Como $b no existia, al salir del bloque

# no va a existir

           funcion_4();   

# En funcion_4() se puede usar $a y $b

   }

   print  $a;     #  imprime: 5

   print  $b;     #  No imprime nada: $b no existe 

   sub funcion_4 {

           print  $a;     #  Imprime: 3

           print  $b;     #  Imprime: 7

   }

Funciones integradas en Perl

El intérprete de Perl viene dotado de un conjunto importante de funciones, de las cuales podemos considerar como más importantes las siguientes:

Manejo de strings

chop $a;

Borra el último caracter del string contenido en $a. Resulta útil para quitar el carácter “\n” al final de una línea que se lee de un archivo de texto. Ejemplo:

           $a = "abcdef";

           chop ( $a ) ;  

# $a queda con "abcde";

length $a;

Devuelve la longitud del string contenido en $a. Ejemplo:

           $a = "abcdf";

           print  length($a);     

# imprime: 5

index $a, $x;

Devuelve la posición del string $x en el string $a. Se asume que los índices comienzan en cero. Ejemplo:

           $a = "abcdef";

           $b = index ( $a, "cd" );

           print  $b;     

uc $a;

Devuelve un string con los caracteres de $a en mayúsculas, sin modificar $a.

lc $a;

Devuelve un string con los caracteres de $a en minúsculas, sin modificar $a.

substr $a, $pos, $len;

Sirve para extraer un string a partir de otro. El primer parámetro es el string de partida, el segundo parámetro es la posición de comienzo, y el tercer parámetro es la longitud del substring a extraer. Ejemplo:

           $a = "abcdef";

           print substr ($a, 2, 3);       

# Imprime: cde

Se puede usar substr al lado izquierdo de una asignación:

           $a = "abcdef";

           substr($a, 2, 3) = "xy";

# cambia "cde" por "xy"

           print $a;

# imprime: abxyf

Manejo de arrays

En estas funciones, si no se especifica un array concreto, se utiliza el array por defecto.

join expresion, array

Convierte un array en un escalar concatenando todos sus elementos con el elemento indicado en expresión.

   @a = ('a'..'e');

   $a = join ":", @a      

# $a queda con "a:b:c:d:e";

split /regexp/, expresion;

Convierte un escalar en un array; resulta muy útil para separar campos:

   $a = 'a:b:c:d:e';   

   @a = split /:/, $a  

# @a queda con ('a', 'b', 'c', 'd', 'e')

el primer parámetro es una expresión regular, que más adelante veremos en qué consiste.

shift array;

Devuelve el primer elemento del array reduciendo en uno el tamaño del mismo.

   @a = ('a'..'e');

   $b = shift @a;  

# $b queda con 'a'

# @a queda con ('b'..'e');

unshift array, lista;

Añade un elemento al princio del array (a la izquierda). La lista puede ser un escalar o una lista de valores.

   @a = (“b”, “c”);

   unshift @a, 'a';       

# @a vale (“a”, “b”, “c”);

pop array;

Devuelve el último elemento y lo quita del array

   @a = ('a'..'e');

   $b = pop @a;    

# $b queda con 'e'

# @a queda con ('a'..'d');

push array, lista;

Añade un elemento al final del array

   push @a, 'e';          

# Agrega 'e' al final del array

splice array, offset, longitud;

Permite extraer un subarray y modificar a la vez la matriz original.

   @a = ('a'..'e');

   @b = splice(@a, 1, 2);

# @b queda con 2 elementos de @a: $a[1] y $a[2];

# ('b', 'c')

# @a queda sin esos 2 elementos:

# ('a', 'd', 'e' );

map expresion, @a;

Devuelve un array después de evaluar la expresión para cada elemento del array que se le pasa como parámetro (@a).

   @a = ( 'a'..'f' ); 

   @b =  map( uc(), @a ); 

   print "@b";

# imprime: A B C D E F

Otro ejemplo:

# Cálculo de las 10 primeras potencias de 2

   sub Potencia2 { return (shift)**2;}

   @p = map Potencia2($_), (1..10);

   print “@p”;

grep expresion, @a;

Devuelve un array que contiene los elementos de @a donde la expresión es verdadera. En este ejemplo, @b se queda con los que empiecen por "b":

   @a = ("a1", "a2", "b1", "b2", "c1", "c2");

   @b = grep /^b/, @a;

   print  "@b";           

# imprime: b1 b2

sort BLOQUE @array;

Devuelve un array ordenado. El array que se pasa a la función no sufre ninguna modificación. Si se omite el BLOQUE, se obtiene un orden ascendente utilizando una comparación en modo texto. Ejemplos:

   @a = (3,2,7,8,1,4,6,9,5,10);   

   @b = sort @a;

   @c = sort {$a<=>$b} @a;

   @d = sort {$b<=>$a} @a;

   print "@b";    # Imprime: 1 10 2 3 4 5 6 7 8 9

   print "@c";    # Imprime: 1 2 3 4 5 6 7 8 9 10

   print "@d";    # Imprime: 10 9 8 7 6 5 4 3 2 1

reverse @array

Devuelve un array invertido. Ejemplo:

   @a = (1, 4, 5, 7);

   @c = reverse @b;        

   # @c vale (7, 5, 4, 1)

Funciones numéricas

abs($x)

cos($x)

exp($x)

hex($x)

int($x)

log($x)

srand($x)

rand($x)

sin($x)  

sqrt($x)