@xeBuz

Crazy little thing called Perl: Introducción al lenguaje

05.03.2014 — dev, perl — 2 min read

Perl está disponible para múltimples plataformas, pueden descargarlo desde acá o desde el sistema de paquetes que utilicen. Para verificar si tienen instalado perl, en la terminal escriban perl -v, si hay salida ya lo tienen instalado.

Para la instalación de librerías se utiliza CPAN, que es una colección de módulos libres para Perl. Pueden descargar este script o sino instalarlo desde los repositorios, por ejemplo, en un Linux basado en Debian basta correr:

1aptitude install cpanminus

Una vez instalado, para instalar módulos deben correr desde la consola el siguiente comando (teniendo en cuenta que el nombre del módulo es case-sensitive):

1cpan install Modulo

Variables

Perl maneja tres tipos de variables:

Scalar
Array
Hash

Scalar

Las variables escalares representan un valor simple. Los valores escalares pueden ser cadenas, enteros o números de coma flotante y se definen anteponiendo el signo $ al nombre de la variable. No hay necesidad de pre-declarar sus tipos de variables, Perl los convertirá automáticamente entre ellos según sea necesario.

1my $animal = "turtle";
2    my $answer = 42;

Array

Las variables de tipo Array representan una lista de valores. Se declaran anteponiendo el signo @ al nombre de la variable

1my @animals = ("turtle", "llama", "cat");
2    my @numbers = (23, 42, 69);
3    my @mixed   = ("whale", 666, 1.23);

Los Arrays son indexados a cero. Se puede acceder a los valores de la siguiente manera:

1print $animals[0];    # imprime "turtle". Se utiliza $ porque es un valor scalar
2    print $animals[1];    # imprime "llama"

La variable especial $#nombrearray nos indica el índice del último elemento.

1print $#mixed;            # imprime 2
2    print $mixed[$#mixed];    # último elemento, imprime 1.23

Si utilizamos @mixed en contexto escalar, obtendremos el tamaño de nuestro Array:

1$arrayLength = @mixed;
2    print $arraylength;     #imprime 3

Para obtener múltiples valores de nuestro Array:

1@animals[0,1];          # Devuelve ("turtle", "llama"), @ porque devuelve un array;
2    @animals[0..2];         # Devuelve ("turtle", "llama", "cat");
3    @animals[1..$#animals]; # Devuelve todo excepto el primer elemento

Hash

Un hash representa un conjunto de pares clave / valor. En realidad hash son tipo de Arrays, con la excepción de que el índice puede ser un número o una cadena. Están precedidos por el signo % de la siguiente manera:

1my %fruit_color = ("apple", "red", "banana", "yellow");

Se pueden utilizar los espacios en blanco y el operador => para dejarlo mas claro:

1my %fruit_color = (
2        apple => "red",
3        banana => "yellow",
4    );

Para obtener un elemento del hash:

1$fruit_color{"apple"}      # Devuelve "red"

Podemos obtener una lista con las claves o valores con las funciones predefinidas keys() y values():

1my @frutas = keys(%fruit_color);
2    my colores = values(%fruit_color);

Alcance de las variables

En la sección anterior declaramos:

1my $animal = "turtle";

El modificador my no es necesario, también se puede usar:

1$animal = "turtle";

Sin embargo, el uso anterior creará variables globales a través de su programa, que es mala práctica de programación. my crea variables con ámbito local. Las variables locales están disponibles en el ámbito del bloque (es decir, un grupo de estados rodeadas de llaves) en el que están definidos.

1my $x = "foo";
2    my $condicion = 1;
3    if ($condicion) {
4        my $y = "bar";
5        print $x;           # imprime "foo"
6        print $y;           # imprime "bar"
7    }
8    print $x;               # imprime "foo"
9    print $y;               # no imprime nada ; $y no está en ese scope

Tabla de conversiones de tipos

	(1,2,3)	[1,2,3]	{a=>x}	(a=>1)	"pepe"
Arity	Lista	Scalar	Hash Ref.	Hash	Scalar
Elemento	$x[0]	$x->[1]	$x->{a}	$x{a}	$x
Lista	@x	@{$x}	%{$x}	%x	($x)
Hash			%{$x}	%x	{e=> $x}
Ref.	\@x	$x	$x	\%x	\$x
Ref. Copia	[@x]	[@{$x}]	{%{$x}}	{%x}	[$x]

Sintaxis básica if, elsif, else, unless

1# La sintaxis es muy similar a otros lenguajes
2    if ($var == 3) {
3      do_magic();
4    }
5
6    # unless se usa para un if negativo
7    if (!$var) {
8      do_magic();
9    }
10    unless ($var) {
11      do_magic();
12    }
13
14    # Por supuesto también existe else
15    if ($var) {
16        do_magic();
17    } else {
18       do_another_magic();
19    }
20    # y se pueden anidar
21    if ($var) {
22       do_magic();
23    } elsif ($another_var) {
24       do_another_magic();
25    } else {
26       do_something_else();
27    }

while, do while, until

1my $counter = 10;
2
3    while ($counter > 0) {
4       say $counter;
5       $counter -= 1;
6    }
7
8    do {
9      say $counter;
10      $counter += 1;
11    } while ($counter < 10);
12
13    until( $counter > 20 ){
14       say "$counter";
15       $counter += 1;
16    }
17
18    say 'tadaaa';

for, for each

1# for ( init; condition; increment )
2    for( $i = 1; $i < 20; $i = $i + 1 ){
3        print "value: $i\n";
4    }
5
6    my @list = (1, 20, 33, 45, 59);
7    foreach $i (@list){
8        say '$i';
9    }

Funciones En realidad las funciones son subrutinas, quizás sea porque el lenguaje es viejo :P ... la sintáxis es también bastante común.

1sub name{
2       # blablabla
3       return $x;
4    }

Para pasar parámetros se hace de esta forma

1sub TestScalar{
2       my $x = @_;      #parámetro scalar
3       # blabla
4    }
5    sub TestArray{
6       my @list = @_;   #parámetro array
7       # blabla
8    }
9    sub TestHash {
10       my (%hash) = @_; #parámetro hash
11       # blabla
12    }
13
14    # Si esperamos varios parámetros, se pueden acceder
15    # desde la variable @_ como un array
16    sub TestScalar{
17       my $x = @_[0];
18       my $y = @_[1];
19       # blabla
20    }

Variables privadas

1sub TestPrivateVars{
2       my $var; # inaccesible fuera de TestPrivateVars()
3       $varx;   # accesible fuera de TestPrivateVars(), no hacerlo
4
5       my ($another, @my_array, %my_hash); # declaración múltiple privada
6    }

TDD con Perl Para hacer TDD en necesario bajar un paquete de CPAN, Test::More. Acá un ejemplo de como correr un test, sobre una función específica.

1# En esta línea declaramos el uso de Test::More
2    # y le decimos que solo se corre una vez
3    use Test::More test => 1;
4
5    # is() es la función que ejecuta el test, consta de 3 parámetros
6    # 1ro función a ejecutar con sus respectivos parámetros
7    # 2do resultado esperado
8    # 3ro nombre descriptivo
9    is(replace("hola"), "chau", "Reemplazo de nombres");
10    is(replace("chay"), "chau", "Reemplazo de nombres");
11
12    # Esta es la función que se ejecuta
13    sub replace( my ($text) = @_;
14        $text =~ s/\bhola\b/chau/gi;
15        return $text;
16    }
17
18    #Con esta función declaramos el fin del testing
19    done_testing()