programación ii

Programación II

Ing. Diego J. Arcusin [email protected]

8 – Perl

Introducción

Perl - "Practical Extraction and Report Language“ Es un lenguaje surgido de otras herramientas UNIX como sed,

grep, awk y los Shells. Sirve principalmente para el procesamiento de texto y para

programación en general. Actualmente se encuentra consolidado como uno de los lenguajes

más utilizados para el desarrollo de aplicaciones para la Web. Para correr un programa perl:

perl –e ‘print “Hola Mundo\n”;

perl programaperl.pl

Para visualizar los warnings se utiliza la opción -w

Primer Programa$ cat miprograma.pl

#!/usr/bin/perl -w

# Este es mi primer programa en perl

use strict;

print "Hola, Mundo!\n";

La primera línea indica la ruta al intérprete perl. La segunda incorpora un comentario. Todo lo que se encuentre a la derecha de “#” será

ignorado por el intérprete. La tercera línea exige que todas las variables sean declaradas. (Recomendable para programar

mejor). La tercera línea imprime Hola, Mundo! y un caracter nueva línea. En general todas las líneas de un programa deben finalizar con el caracter “;”. Si al programa se le dan permisos de ejecución, el mismo se puede ejecutar directamente. Por

ejemplo:

$ ./miprograma.pl

Variables

Escalares (Scalars). Los escalares son variables del tipo “Número” o “Cadena”, comienzan siempre con el

caracter “$”. Por ejemplo:$minumero = 1;$mitexto = ‘Hola Mundo’;

Para declarar variables (Escalar o de cualquier otro tipo) se utiliza “my”. Por ejemplo:my $contador = 1;

El operador es quien determina si el escalar es un número o una cadena. Para “parsear” el valor de un Escalar se utiliza comillas dobles. Por ejemplo:

my $total = 100;print “El valor es $total”;# Despliega: El valor es 100

Para evitar el parseo de un Escalar se utilizan comillas simples.Por ejemplo:my $total = 100;print ‘El valor es $total’;# Despliega: El valor es $total

Variables (cont.)

Arreglos (Arrays). Son vectores de Escalares. Comienzan con el caracter “@”. Por ejemplo:

my @nombres;$nombres[0]=‘Carlos’;$nombres[1]=‘María’;$nombres[2]=‘Juan’;$nombres[3]=‘Laura’;

Si bien @nombres es un array, cada uno de sus elementos es un escalar. Por eso cada una de las asignaciones empieza con “$”.

Otra forma de asignar el arreglo es:my @nombres = (‘Carlos’, ‘María’, ’Juan’, ‘Laura’);

En el ejemplo anterior se utiliza un Lista para asignar al array sus valores. Un List es una lista de uno o más escalares, separados por coma.

Variables (cont.)

La función “push” permite agregar valores a un arreglo y recibe como parametros un array y una lista: push ARRAY, list. Por ejemplo:

push @nombres, (‘Pedro’, ‘Marcela’, ‘Oscar’);

Un arreglo entre paréntesis actúa como una lista. Por ejemplo:@nombres = (@familiares, @amigos, @otros);

Un arreglo también permite asignar valores a una lista. Por ejemplo:($papa, $mama, $tio, $tia) = @nombres;

El tamaño del array se obtiene asignando el array a un escalar. Por ejemplo:

my $cantarray = @nombre;

Hashes (Arreglos Asociativos) Son como arreglos de Escalares pero utilizando una cadena para sus índices

(llamadas KEYS) en lugar de un número. Comienzan con un “%”. Los Hashes utilizan { } para encerrar cada KEY, a diferencia de los [ ] utilizados

en los arreglos. A diferencia de los arreglos, un Hash no puede ser interpretado como un lista.

Por lo que no se puede utilizar como argumento de la función push. Cada elemento de un HASH consiste de un KEY y un VALUE Para acceder a lista de los indices de un HASH se utiliza la función keys.

Variables (cont.)

my %cenas;

$cenas{‘Lunes’}=‘Pollo’;

$cenas{‘Martes’}=‘Carne’;

$cenas{‘Miercoles’}=‘Ensalada’;

$cenas{‘Jueves’}=‘Arroz’;

$cenas{‘Viernes’}=‘Pasta’;

# Para desplegar todos los keys en una sola línea:

print keys %cenas, “\n”

# Para ver los pares uno por uno

foreach my $dia (keys %cenas) {

my $comida = $cenas{$dia};

print “El dia $dia como $comida.\n”;

}

Si bien %cenas es un HASH, cada uno de sus valores es un escalar. Por eso al asignarlo se

utiliza el caracter “$”.

Variables (cont.)

Un asignación de Hash mas legible.

my %cenas = (

lunes => ‘Pollo’,

Martes => ‘Carne’,

Miercoles => ‘Ensalada’,

Jueves => ‘Arroz’,

Viernes => ‘Pasta’,

);

La última asignación puede o no terminar con ,

Variables (cont.)

No existen diferencias sustanciales entre una subrutina (definida por el programador) y

una función (predefinida en PERL). En forma opcional las subrutinas pueden ser invocadas con un &. El tipo de dato de la subrutina / función está dado por el valor que devuelve dicha

subrutina / función. Las subrutinas empiezan con la palabra “sub”, y el valor se devuelve con la instrucción

“return”. Los argumentos recibidos por la subrutina se encuentran en el Array @_ También se pueden obtener los argumentos de a uno mediante la instrucción “shift”. Ejemplos:

# Esta subrutina devuelve un escalar.

sub ReturnScalar {

my $first_argument = shift;

return "El argumento es: $first_argument";

}

Subrutinas y Funciones

Ejemplos:

# Esta subrutina devuelve un Array.

sub ReturnArray {

my $array_size = shift;

my @array = ();

for (my $i=0; $i < $array_size; $i++ )

{ $array[$i] = “El valor es $i”; }

return @array;

}

# Esta Rutina recibe tres argumentos y los muestra

sub MuestraTresArgs {

my ($arg2, $arg2, $arg3) = @_;

print “Los valores son: $arg1 - $arg2 - $arg3”;

}

Subrutinas y Funciones (cont.)

Ejemplos de uso de subrutinas:

# Ejemplo de Uso de ReturnScalar

print "Scalar:\n";

print ReturnScalar('test 1'), "\n", ReturnScalar('test 2'), "\n";

# Ejemplo de Uso de ReturArray

print "Array:\n";

my @test_array = returnArray(5);

for (my $i = 0; $i <= @test_array - 1; $i++)

{ print "$test_array[$i]\n"; }

Cuando se corre un programa desde la línea de comandos, se puede

interpretar como una subrutina.

La única diferencia es que se usa el array @ARGV en vez de @_ para la

recepción de los parámetros de la línea de comandos.

Subrutinas y Funciones (cont.)

Los References en Perl son como los punteros en C. Apuntan a una dirección de memoria donde se almacena el valor

de una variable. Si bien se pueden hacer referencias a cualquier tipo de variable,

la referencia en si se trata siempre como un Escalar por lo que

comienzan con $. Para crear una referencia a una variable se usa. Ejemplos:

# Crear referencias

my $scalar = 'hola';

my $scalar_ref = \$scalar;

print "Scalar: $$scalar_ref\n";

References

my @arr = (1, 2, 3);

my $arr_ref = \@arr;

print "Array: @$arr_ref\n";

my %hash = (

nombre => 'Carlos',

apellido => 'Sanchez',

edad => 25,

);

my $hash_ref = \%hash;

print "Hash size: ", scalar(keys %$hash_ref), "\n";

Una subrutina que devuelve un array o un hash muy grande es

ineficiente. Es más eficiente devolver una referencia al array o al

hash.

References (cont.)

Se puede crear una referencia a una lista usando [ ]en lugar de ( ). Por ejemplo:# Referencia a una lista my $ref_a_arreglo = [ 'a0', 'a1', 'a2' ]; print "$ref_a_arreglo->[1]\n";

Mediante esta técnica se pueden implementar arreglos multidimensionales.# Referencia a una lista de listas (o sea, un array multi-dimension)my $ref_a_multi_arreglo = [

[ 'a0', 'a1', 'a2' ], [ 'b0', 'b1', 'b2', 'b3' ], [ 'c0', 'c1', 'c2' ],

]; # Desplegar elemento (1,3) = 'b3' print "$ref_a_multi_arreglo->[1][3]\n";

References (cont.)

En Perl los valores verdadero y falso se evalúan siempre como un Escalar y mediante las siguientes reglas: Una cadena siempre es verdad, menos las cadenas “” y “0” Un número siempre es verdad, menos el número 0 Una referencia siempre es verdad Un valor no definido siempre es falso

Ejemplos:0 # Como la cadena "0" - falso 1 # Como la cadena "1" - verdad 10 - 10 # Igual a 0, como la cadena "0" - falso 0.00 # Como número evalua a 0, como la cadena "0" - falso "0.00" # No igual a la cadena "0" - verdad "0.00" + 0 # Evalua a 0 - falso "" # NULL - falso \$ref # Una referencia contiene la dirección adonde apunta,

# siempre <> 0 - verdad undef() # Devuelve un valor no definido - falso

Verdadero / Falso

Numéricos Iguales a los de cualquier lenguaje: + - * / % ** Ejemplos:

$a = 1; $b = '3' + $a; # $b = 4 $b *= 5; # $b = 20 $c = $b % 3; # $c = 2 $d = $b ** 2; # $d = 400

Operadores

Cadenas $a = ‘Hola Mundo’; $b = ‘Que tal?’; $c = $a . ‘ ‘ . $b # $c = “Hola Mundo Que tal?”

# El operador “.” concatena $d = ‘chau ’; $e = $d x 4; # $e = “chau chau chau chau ”

# El operador x copia n instancias de la cadena

Operadores (cont.)

Lógicos “||” o “or” # Operador lógico “o” “&&” o “and” # Operador lógico “y” “!” o “not” # Operador lógico “no”

Los operadores de C && || !son iguales de los más legibles and, or, not.La única diferencia es que and, or y not tienen menor precedencia al momento de la evaluación.

al igual que en cualquier lenguaje para forzar la precedencia en la evaluación lógica se utilizan los paréntesis.

Incremento y Decremento “++” o “- -” $b = $a ++; # Esto es lo mismo que $b = $a; $b = $b + 1;

Comparación == != < > <= >= # Operadores aplicables a números eq ne lt gt le ge # Operadores aplicables a cadenas.

Operadores (cont.)

Ejemplos de Operadores Lógicos$a = '0'; $b = $a || 2;# Como $a evalúa a "0" (falso),

# se evalúa la parte derecha de ||, $b = 2 $b = ($a || 2); # Igual que el ejemplo anterior (paréntesis opcionales) $b = ($a or 2); # Igual que el ejemplo anterior (paréntesis requeridos)

$a = '3'; $b = $a || 2; # Como $a evalúa a "3" (verdad),

# se ignora la parte derecha de ||, $b = 3 $b = ($a || 2); # Igual que el ejemplo anterior $b = ($a or 2); # Igual que el ejemplo anterior

$a = '0'; $b = $a && 2; # Como $a evalúa a "0" (falso),

# se ignora la parte derecha de &&, $b = 0 $b = ($a && 2); # Igual que el ejemplo anterior $b = ($a and 2); # Igual que el ejemplo anterior

$a = '3'; $b = $a && 2; # Como $a evalúa a "3" (verdad),

# se evalúa la parte derecha de ||, $b = 2 $b = ($a && 2); # Igual que el ejemplo anterior $b = ($a and 2); # Igual que el ejemplo anterior

Operadores (cont.)

Ejemplos de Operadores Incremento y Decremento$a = 1; $b = $a++; # $a=2, $b=1 $c = ++$a; # $a=3, $c=3 $d = 5; $e = $d--; # $d=4, $e=5 $f = --$d; # $d=3, $e=5, $f=3

Operadores (cont.)

Condiciones if, else, elsif, unless, while, until

Ejemplos:if ($edad < 18)

{ print "Joven\n"; } elsif ($edad < 65)

{ print "Adulto\n"; } else { print "Viejito ;-)\n"; }

while ($contador < 1000) { $contador ++; } print “Llegue a 1000!\n";

Control de Flujo

if, else, elsif, while

Ejemplos:if ($edad < 18)

{ print "Joven\n"; } elsif ($edad < 65)

{ print "Adulto\n"; } else { print "Viejito ;-)\n"; }

while ($contador < 1000) { $contador ++; } print “Llegue a 1000!\n";

Control de Flujo - Condiciones

unless, untilunless es la negación de ifuntil es la negación de while.

Ejemplos: unless ($edad >= 18) ... # igual que if ($edad < 18) until ($contador >= 1000) ... # igual que ($contador < 1000)

Perl también permite incorporar condiciones de la siguiente forma:

print "Hoy es lunes\n" if ($weekday eq 'lunes');

Control de Flujo - Condiciones

forSe utiliza para obtener un índice específico.

Ejemplo:

for (my $i = 0; $i <= @array; $i++)

{ if ($i == 123)

{print “Este es el elemento 123\n";}

}

Control de Flujo - loops

foreachEl foreach se utiliza para procesar todo los

elementos de un array o un hash.

Ejemplo:

foreach my $dia (keys %cenas) {

my $comida = $cenas{$dia};

print “El dia $dia como $comida.\n”;

}


En Perl el next y last son instrucciones válidas dentro de un loop foreach o for.

Ejemplos:for (my $i = 0; $i <= @array; $i++)

{ # Ignore index less then 100 and index 5000 if ($i < 100 or $i == 5000)

{next;} # Exit loop when found a special case if ($array[$i] == '999')

{print "Found at $i!\n"; last;} }


Perl no cuenta con un comando tipo select o switch.Una forma posible para emular una instrucción de este tipo es:

for ($marca) {

/Mercedes/ and do { print “OK, pero caro!\n"; last; } ;/Volvo/ and do { print "Un poco viejo...\n"; last; } ; /Peugeot/ and do { print "No tan mal...\n"; last; } ; print "El Auto $marca no conozco.\n";

}

Control de Flujo – select / case

open, read, print, close

Ejemplo de lectura de un archivo a una variable escalar.open(FH, '</var/log/messages'); read(FH, my $contents, 10000); # Leer maximo 10000 bytes close(FH); print $contents;

También es posible cargar el archivo en un arreglo, una linea por elemento:

open(FH, '</var/log/messages'); my @contents = <FH>; # Todo el archivo va al arreglo close(FH); foreach my $line (@contents)

{ print "$line"; }

Archivos

Para escribir a un archivo:open(FH, '>/tmp/test'); print FH "Esto escribo al archivo /tmp/test\n"; close(FH);

Para agregar al final de un archivo: open(FH, '>>/tmp/test'); print FH "Esto agrego al final del archivo /tmp/test\n";close(FH);

Archivos (cont.)

Perl utiliza sintáxis similar al comando UNIX “test” para hacer pruebas sobre los archivos.

Por ejemplo: if (-f $filename) ... # Verdadero si el archivo existe

# y es u archivo regular

Para borrar un archivo:unlink $filename;

Archivos (cont.)

$variable =~ m/ExprReg/Esta expresión será verdadera si se encuentra el patrón ExprReg en $variable.

$variable !~ m/ExprReg/Esta expresión será verdadera si NO se encuentra el patrón ExprReg en $variable.

$variable =~ s/ExprReg1/ ExprReg2/Se sustituye el patrón ExprReg1 por el patrón ExprReg2 en $variable.

Expresiones Regulares

Ejemplos:

my $saludo = ‘Hola que tal!';

# Match using 'm//' if ($saludo =~ m/Hola/)

{ print “Encontré ‘Hola' en '$saludo'\n"; }

# Substitute using 's///' $saludo =~ s/Hola/Buenas/; if ($saludo =~ m/Hola/)

{ print “Encontré ‘Hola' en '$saludo'\n"; } if ($salud !~ m/Hola/)

{ print “No volví a encontrar 'Hola' en '$saludo'\n"; }

Expresiones Regulares (cont.)

El Perl permite el uso de los siguientes metacaracteres:\ Para podear matchear a otro metacaracter. Ej: \*| O logico.( ) Agrupador lógico[ ] Opciones o intervalos de caracteres^ Matchea al inicio de la cadena.$ Matchea al final de la cadena.*+? Operadores “cerradura”. Matchea una instancia de cualquier caracter.{ } Cuantificadores.

{n,m} Se requieren como mínimo n matches y como máximo m

{n,} Se requieren como mínimo n matches. (Sin máximo){n} Se requieren exactamente n matches.


El Perl también permite el uso de los siguientes caracteres especiales:

\t Tabulación\n Nueva línea\d Matchea a un dígito. Equivalente a /[0-9]/\D Matchea cualquier caracter que no sea un dígito\s Matchea un caracter de espacio (espacios, tabs, nueva línea,

etc)\S lo opuesto de \s\w Matchea un caracter alfanumérico. Equivalente a /[a-zA-Z_0-9]/


Los siguientes operadores se agregan al final de las instrucciones. Ejemplo: s/Hola/Chau/g

e La cadena de sustitución se evalúa. Permite la utilización de funciones. Por ejemplo: $variable =~ s/Rojo/&ColoralAzar()/eSustituye la cadena ‘Rojo’ por lo que devuelve la función ColoralAzar().

g Sustituye globalmente (todos los matches de la línea).i insensitive. Matchea indistintamentemayúsculas o minúsculas.m multiple. Si la cadena contiene \n trata la cadena como varias líneas. s single. Aunque la cadena contenga \n, la trata como una única líneas.

Nota: m y s modifican el comportamiento de ^ y $.

Ejemplos:


Preguntas

?

8.1. Desarrolle un dado en Perl qué genere números al azar entre 1 y 6. Utilice la función: rand (perldoc –f rand)

8.2. Crear un programa que pida por pantalla una línea del tipo:key1=value1luego deberá separar el key del value.Utilice: print "Ingresar: "; chomp(my $input = <STDIN>);y la función split

8.3. Desarrolle un programa que pida 5 números desde el teclado, y que los ordene en forma ascendente.Utilice las funciones push y sort

Ejercicios

programación ii

Documents