formato de apunte - csrg

Lenguajes de Scripting
Perl
Horst H. von Brand
Agenda
Índice
1. Lenguajes de Scripting
1
2. Introducción al lenguaje Perl
2
3. Detalles del lenguaje
3.1. Tipos de datos . . . . . . . . . . .
3.2. Contextos . . . . . . . . . . . . .
3.3. Operadores . . . . . . . . . . . .
3.4. Estructuras de control . . . . . . .
3.5. Funciones predefinidas . . . . . .
3.6. Expresiones regulares . . . . . . .
3.7. Subrutinas . . . . . . . . . . . . .
3.8. Estructuras de datos y referencias .
.
.
.
.
.
.
.
.
4
4
5
5
7
8
11
13
14
4. Orientación a objetos en Perl
4.1. Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2. Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
14
14
15
1.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Lenguajes de Scripting
Caracterı́sticas de lenguajes de scripting
“Script” es guión
• Invocar programas automáticamente
• Lenguajes interpretados
• Muy alto nivel
Caracterı́sticas generales
• Manejo de strings y expresiones regulares
• Sin tipos, variables no se declaran
• Administración automática de memoria
Caracterı́sticas adicionales comunes
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
• Empotrable: Puede usarse desde dentro de programas
• Extensible: Pueden agregarse nuevas funcionalidades
Algunos lenguajes
Perl: Oficialmente, abreviatura de Practical Extraction and Report Language
Python: Por Monty Python
PHP: Abreviatura de PHP: Hypertext Processor
Ruby: La piedra preciosa (si hay perlas. . . )
TCL: Es Tool Control Language, creado con la idea de ser un lenguaje de extensión/configuración
expect: Una extensión de TCL, orientada a controlar programas interactivos
AWK: Lenguaje inventado por Aho, Weinberger, Kernighan.
2.
Introducción al lenguaje Perl
Perl
Practical Extracting and Report Language
Pathologically Eclectic Rubish Lister
Lema: “There’s more than one way to do it” (TMTOWTDI)
No pretende ser simple, regular, ortogonal
Si aspira a ser cómodo, natural y rápido de usar
Lı́nea de comandos
El tradicional programa en Perl puede escribirse:
perl -e ’print "Hello, world!\n";’
Acá -e indica que el argumento siguiente ha de considerarse como una lı́nea del script a ser procesado por perl.
Para evitar que el shell interprete el contenido del script (que comúnmente contendrá caracteres que son especiales
para él) el script mismo se encierra entre apóstrofes.
De ser más extenso el script, es permisible dar -e varias veces. Cada argumento se considerará una lı́nea aparte.
Lı́nea de comandos
Perl tiene una variedad de flags que controlan su operación. Por ejemplo, es posible repetir un comando (acá,
substituir el string hoy por ayer) sobre cada lı́nea de los archivos mencionados, que se editan en su lugar, quedando
los originales en los respectivos .bak:
perl -pi.bak -e ’s/hoy/ayer/g’ uno dos
2
Algunos flags importantes
Opciones para correr perl en perlrun(1).[3ex]
Flag
Significado
-h
Resumen de las opciones
-v
Versión
-d
Correr en el debugger
-i<extensión>
Archivos procesados con <> se procesan in situ, dejando el original
con la ¡extensión¿ dada
-n
El programa se aplica a cada lı́nea
El programa se aplica a cada lı́nea, imprimiendo automáticamente la
-p
lı́nea resultante cada vez
Algunos flags importantes (cont)
Flag
-t
-T
-w
Significado
Activa alertas para tainting, uso posiblemente riesgoso de
datos externos
Uso riesgoso de datos externos es un error
Alertar sobre construcciones dudosas (variables que sólo se
mencionan una vez, redefiniciones de rutinas, . . . )
Ejemplos simples
# ! / usr / bin / p e r l
while (<>) {
$ l i n e s ++;
$words += s p l i t ;
$chars += length ;
}
p r i n t ” $ l i n e s $words $chars \n ” ;
Ejemplos simples
# ! / u s r / b i n / p e r l −w
use s t r i c t ;
my( $ l i n e , $ l i n e s , $words , $chars , @tmp ) ;
while ( $ l i n e = <STDIN>) {
$ l i n e s ++;
@tmp = s p l i t ( / \ s + / , $ l i n e ) ; $words += @tmp ;
$chars += length ( $ l i n e ) ;
}
p r i n t STDOUT ” $ l i n e s $words $chars \n ” ;
Ejemplos simples
# ! / usr / bin / p e r l
while (<>) {
foreach $w ( s p l i t ( / \W+ / ) ) {
i f ( ! defined ( $ r {$w } ) ) {
$ r {$w} = $ . ;
3
} else {
$ r {$w} . = ” , $ . ” unless $ r {$w} =˜ / $ . / ;
}
}
}
foreach $w ( s o r t keys %r ) {
p r i n t ” $w : $ r {$w}\n ” i f $w ;
}
Ejemplos simples
# ! / usr / bin / p e r l
open (NOTAS, ”< notas ” ) o r die ” No se puede a b r i r notas ” ;
while(<NOTAS>) {
chomp ;
( $nombre , $nota ) = s p l i t ;
$notas {$nombre} . = $nota . ” ” ;
}
foreach $nombre ( s o r t keys %notas ) {
$suma = $n = 0 ;
foreach $nota ( s p l i t / / , $notas {$nombre } ) {
$suma += $nota ; $n ++;
}
p r i n t $nombre , ” : ” , $notas {$nombre } ,
” \ tPromedio : ” , $suma / $n , ” \n ” ;
}
close (NOTAS ) ;
Ejemplos simples
# ! / usr / bin / p e r l
open ( IN , ”< i n p u t ” ) ; chomp( @ l i s t = <IN >); close ( IN ) ;
open (PGM, ” s o r t i n p u t | ” ) ; open (OUT, ”> o u t p u t ” ) ;
while(<PGM>) {
chomp ;
f o r ( $ i = 0 ; $ i <= $# l i s t ; $ i ++) {
p r i n t OUT ” $ i : $ l i s t [ $ i ] \ n ” i f ( $ l i s t [ $ i ] eq $ ) ;
}
}
close (PGM, OUT ) ;
3.
3.1.
Detalles del lenguaje
Tipos de datos
Tipos de datos básicos
$escalar: Strings, números, referencias.
@arreglo: Elementos $arreglo[0], . . . , $arreglo[$#arreglo]
%hash: Arreglo asociativo, elementos $hash{”clave”}
Slices: @arreglo[1, 17, 3], @hash{”uno”, ”doce”, ”nueve”}
4
Inicializar:
• @a = (”Do”, ”Lu”, ”Ma”, ”Mi”, ”Ju”, ”Vi” , ”Sa”);
• %h = (”cero” => 0, ”uno” => 1, ”dos” => 2);
Constantes numéricas
Decimal: 100
Para legibilidad: 1 000
Decimales: 3.141592
Con exponente: 6.024e24
Octal: 0277
Hexadecimal: 0x3ff
Binario: 0b1010 0011
Constantes string
No interpola: ’ Hola!’, o también q($algo)
Interpola: ”Variable $a”, incluso qq(Variable $A[$i + 2])
Escapes en strings
Escape
”\cC”
Los de C, con algunos adicionales: [1ex]
”\x{263a}”
”\N{Nombre}”
Significado
Control-C
Unicode (smiley)
Caracter por nombre
Escapes activos en strings
Código
Acción
”\u”
Siguiente es mayúscula (titlecase)
Siguiente es minúscula
”\l ”
Mayúsculas
”\U”
”\L”
Minúsculas
Backslash antes de no-alfanuméricos
”\Q”
Fin de ”\U”, ”\L”, ”\Q”
”\E”
3.2.
Contextos
Contextos
Toda expresión se evalúa en el contexto dado por cómo se usa. Hay dos contextos básicos:
Escalar: Arreglos dan su largo, hashes dan estadı́sticas de su uso, y una variedad de funciones entregan resultados
escalares
Lista: Arreglos/listas dan sus valores; hashes dan los pares (clave, valor) en una lista; escalares dan una lista de un
elemento
5
Valores de verdad
Cuando se requiere un valor de verdad, esto provee implı́citamente contexto escalar. Perl usa los siguientes criterios:
Cualquier string, salvo \”\” y \”0\”, es verdadero
Todo número, salvo 0, es verdadero
Cualquier referencia es verdadera
Cualquier valor no definido es falso
3.3.
Operadores
Operadores
Básicamente los de C, pero con algunas adiciones:
Rango: 1..10, \”a0 \”..\” z9\”
Concatenación de strings: $saludo . ” , ” . $nombre
bien)
(Claro que se escribirı́a ”$saludo, $nombre” más
Repetir un string: ”\t ” x ($k / 8) . ” ” x ($k % 8)
Potencia: $num ∗∗ 5
Además las combinadas con asignación (salvo rango).
Operadores exóticos
También está el operador coma de C, con el que hay que tener cuidado:
$a = 1, 2, 117; da $a == 117 (Operador coma evalúa sus argumentos, descarta el primero)
@a = 1, 2, 117; da @a == (1, 2, 117) (Es una lista lo que se asigna)
$a = (1, 2, 117); da $a == 3 (Lista en contexto escalar)
El sı́mbolo => es el equivalente de coma, pero cita la palabra a su izquierda: hoy => 3 es equivalente a ’ hoy’, 3
(más que nada útil para inicializar hashes)
Asignación en Perl
En Perl la asignación es un operador que entrega el lvalue
Ası́, puede transformarse $t de Fahrenheit a Celsius mediante ($t −= 32) ∗ 5 / 9;
Asignación en Perl: Arreglos
Pueden asignarse arreglos completos, por ejemplo @a = @b; o @a = (1, 2, 4, 8, 16);
El lado izquierdo puede ser una lista de variables, o sea: ($a, $b) = (42, 117);
Las asignaciones se hacen en paralelo, o sea ($a, $b) = ($b, $a); intercambia los valores de $a y $b
De asignarse más valores, los sobrantes se descartan
Si hay arreglos, el primero consume todos los valores restantes: ($a, $b, @resto) = (1, 2, 3, 4, 5, 6);
Puede asignarse a undef para descartar valores. Si interesan sólo el segundo y cuarto de lo que retorna &unafunc:
(undef, $a, undef, $b) = unafunc();
6
Operadores lógicos adicionales
Hay operadores lógicos de muy baja precedencia equivalentes a sus versiones tradicionales (not, and, or, xor),
usados más que nada por su evaluación en cortocircuito: [1ex] open(IN, ”< $file” ) or die ”Can’t open $file” ;
[1ex] /ˆ #/ and next;
Comparaciones
Comparación
Menor que
Menor o igual que
Igual a
Mayor o igual que
Mayor que
No igual a
Comparar
3.4.
Número
<
<=
==
>=
>
!=
<=>
String
lt
le
eq
ge
gt
ne
cmp
Estructuras de control
Estructuras de control
i f ( CONDITION ) {
...
}
e l s i f ( CONDITION ) {
...
}
else {
...
}
unless ( CONDITION) {
...
}
Estructuras de control
while ( CONDITION ) {
...
last ;
...
next ;
...
} continue {
...
}
Estructuras de control
u n t i l ( CONDITION ) {
...
last ;
...
next ;
...
} continue {
7
...
}
Estructuras de control
f o r ( I N I T ; CONDITION ; UPDATE) {
...
next ;
...
last ;
...
}
Estructuras de control
foreach VAR ( LIST ) {
...
next ;
...
last ;
...
}
Modificadores
...
i f ( CONDITION ) ;
. . . unless ( CONDITION ) ;
. . . while ( CONDITION ) ;
. . . u n t i l ( CONDITION ) ;
. . . foreach LIST ;
Modificadores
do {
...
} while ( CONDITION ) ;
do {
...
} u n t i l ( CONDITION ) ;
Rótulos de ciclos
LABEL : {
...
next LABEL ;
...
l a s t LABEL ;
...
}
8
3.5.
Funciones predefinidas
Funciones predefinidas
push ARRAY, LIST
$var = pop ARRAY
$var = shift ARRAY
Por omisión, @ARGV o @
unshift ARRAY, LIST
Funciones predefinidas
join EXPR, LIST
split /PATTERN/, EXPR, LIMIT
O sea, se puede hacer algo como:
perl -e ’print join(" ", split //, shift), "\n";’ ’Alguna cháchara’
Funciones predefinidas
sort BLOCK ARRAY
BLOCK compara $a con $b
map BLOCK ARRAY o map EXPR, ARRAY
grep BLOCK ARRAY o grep EXPR, ARRAY
Funciones predefinidas
lc EXPR, uc EXPR
lcfirst EXPR, ucfirst EXPR
Funciones predefinidas
Manipulación de procesos
Hebras (threads)
Numéricas
Llamadas propias de U NIX
Un ejemplo de uso
Supongamos que tenemos un archivo con el siguiente “creativo” formato. Viene ordenado por apellido:
HERNANDEZ:GOMEZ:LUIS:234567-8
IN:OUT:GIGO:891234-6
LI:CHIANG:DANIEL ALBERTO:345678-9
NOGUERA:NORAMBUENA:NELLY NORA:987654-3
PEREZ:LOPEZ:JUAN PABLO:123456-7
SALGADO:NARDEZ:JOSEFO LUIS ALBERTO JAVIER:456789-K
ZAMORA:YUMA:ADAN BENJAMIN CARLOS DAVID:132547-6
9
Un ejemplo de uso
Se requiere un archivo con el rol, seguido por el nombre. Debe estar ordenado por rol:
123456-7:
132547-6:
234567-8:
345678-9:
456789-K:
891234-6:
987654-3:
Juan Pablo Perez Lopez
Adan Benjamin Carlos David Zamora Yuma
Luis Hernandez Gomez
Daniel Alberto Li Chiang
Josefo Luis Alberto Javier Salgado Nardez
Gigo In Out
Nelly Nora Noguera Norambuena
Un ejemplo de uso
# ! / usr / bin / p e r l
open (OUT, ” | s o r t ” ) ;
while (<>) {
chomp ;
@a = map { j o i n ’ ’ , map { u c f i r s t l c } s p l i t }
split / : / ;
p r i n t OUT ” \U$a [ 3 ] : ” , j o i n ( ’ ’ , @a[ 2 , 0 , 1 ] ) ,
” \n ” ;
}
close (OUT ) ;
Referencias cruzadas
# ! / usr / bin / p e r l
while (<>) {
foreach ( s p l i t / \W+ / ) {
/ ˆ $ / and next ;
$ref {$ } .= $ref {$ } ? ” , $ . ” : $ .
unless $ r e f { $ } =˜ / $ . / ;
}
}
p r i n t map ” $ : $ r e f { $ }\n ” , s o r t keys %r e f ;
Operadores especiales
Común
General
Int
Significa
’ ... ’
q {...}
No String
” ... ”
qq{...}
Si
String
‘...‘
qx{...}
Si
Comando
[3ex] Los delimitadores pueden ser “cualquier cosa” (no
qw{...}
No Palabras
/.../
m{...}imosx
Si
Calza patrón
Si
Patrón
qr {...} imosx
s {...}{...} egimosx Si
Reemplazo
tr {...}{...} cds
No Transliterar
alfanuméricos, claro), pero generalmente se usan /.../ . O pueden usarse diversos tipos de paréntesis ()[]{}<>, que
deben parearse.
Operadores especiales
10
i
No distinga mayúsculas/minúsculas
m Múltiples lı́neas
En m /.../ imosx y qr /.../ imosx: [1ex] o Compilar una sola vez (once)
[1ex] qr /.../ retorna un obs
Una sola lı́nea
x Expresiones regulares extendidas
jeto que puede darse en vez de un patrón al buscar/reemplazar.
Operadores especiales
e
g
i
En s /.../.../ egimosx: [1ex] m
o
s
x
Lado derecho es expresión
Globalmente
No distinga mayúsculas/minúsculas
Múltiples lı́neas
Compilar una sola vez (once)
Una sola lı́nea
Expresiones regulares extendidas
Operadores especiales
c
En tr /BUSCA/REEMPLAZO/cds: [1ex] d
s
Como tr /ABCDEFGHIJ/0123456789/
tr/0−9/9/
tr /A−Za−z//s: ’Mississippi’ ’Misisipi’
Complemento
Elimine los sin traducción (delete)
[1ex] tr /A−J/0−9/:
Secuencias duplicadas se reducen a uno (squash)
Aplicar a variables
Las operaciones anteriores operan sobre la variable por omisión $ .
Para operar sobre otra variable se usa, por ejemplo:
$var =˜ s/hoy/ayer/;
Incluso es posible aplicar estas operaciones “al pasar”:
($var = alguna fea expresion) ˜= tr /aeiou//d;
(recuérdese que la asignación da un lvalue)
3.6.
Expresiones regulares
Expresiones regulares
Son patrones de búsqueda en texto. Siendo Perl un lenguaje basado en manipular texto, son fundamentales. Mucha
manipulación de texto es “búsqueda y reemplazo”, donde obviamente son parte central.
Las de Perl existen también como biblioteca aparte para uso en otros programas: PCRE. En rigor, no son expresiones regulares, pero no seremos nosotros quienes cambien el uso del término. . .
Expresiones regulares
En los patrones hay caracteres “normales” (que se representan a sı́ mismos) y metacaracteres, con significado
especial. En Perl todos los metacaracteres son caracteres no alfanuméricos, y todos ellos pierden su significado especial
si se preceden con backslash. Esta es la función del escape \”\\Q...\\E”.
Expresiones regulares
Cada construcción calza con un patrón dado, en una posición especı́fica. A las construcciones que sólo registran
una posición (no calzan con caracteres) les llaman anchor.
Las construcciones en general son voraces: Calzan lo más que pueden. Pero también son poco previsoras: Calzan
en la primera oportunidad, aunque hayan calces “mejores” más adelante.
11
Expresiones regulares
. Calza con cualquier caracter (salvo ”\n”, si /s)
[...] Conjunto de caracteres.
ˆ niega, – rango.
[: ... :] conjunto POSIX
Expresiones regulares
”\w” Palabra (alfanumérico y )
”\W” No-palabra
”\s”
Espacio
”\S” No-espacio
Dı́gito
”\d”
”\D” No-dı́gito
Expresiones regulares
* Repetir lo anterior cero o más veces
+ Repetir lo anterior una o más veces
? Lo anterior es opcional
{m, n} Repetir lo anterior entre m y n veces, {n} exactamente n veces, {n,} al menos n veces
| Alternativas
(...) Agrupa (y recuerda en \”\\1” y $1, . . . )
Expresiones regulares
ˆ Principio del string (o la lı́nea, si /m)
$ Fin del string (o la lı́nea, si /m)
Expresiones regulares
”\b” Borde de palabra
”\B” No-borde de palabra
”\A” Principio del string
”\Z” Final del string (o antes de ”\n” final)
”\z” Final del string
Expresiones regulares extendidas
Permite espacios y comentarios.
(?imsx–imsx) Opciones (– apaga)
+?, *? Mı́nimo posible (no voraz)
(?# ...) Comentario
(?: ...) Agrupa sin recordar, (?imsx–imsx: ...) con opciones
(?= ...) Lookahead positivo, (?! ...) negativo
Hay mas. . .
12
Búsquedas y reemplazos
m/(\w+) \1/ # Palabras repetidas [1ex] ($h, $m, $s) = $hms =˜ m/(\d+):(\d+):(\d+)/; [1ex] m{ˆ(.∗): GIF}; # Ahora $1 es
[1ex] s<ˆ(?:foo|bar)([0−9]+)>[$1−baz−$1] [1ex] s/(\[0−9\]+)/$1 + 3/ge
3.7.
Subrutinas
Subrutinas
# ! / usr / bin / p e r l
sub Ul
{
my $x = s h i f t ;
r e t u r n u c f i r s t l c $x ;
}
while (<>) {
p r i n t Ul $ ;
}
Subrutinas
# ! / usr / bin / p e r l
sub acc
{
my $s ;
foreach (@ ) {$s += $ ; $
return @ ;
= $s ; }
}
while (<>) { p r i n t j o i n ’ ’ , acc s p l i t ; p r i n t ” \n ” ; }
Subrutinas – definición general
La definición general de subrutina tiene la forma: [0.75ex] sub NAME(PROTO): ATTRS BLOCK [0.75ex]
El prototipo y los atributos son opcionales.
Si no hay bloque, es declaración únicamente.
Si no se da nombre, es anónima.
Subrutinas – definición general
Escalar
$
@
Arreglo
\@
Referencia a arreglo
\%
Referencia a hash
&
Bloque
∗
Glob
\[$@] Escalar o arreglo
\ %;$ Referencia a hash, escalar opcional
Subrutinas – definición general
Mecanismo para limitar acceso o dar información sobre la subrutina. Básicamente definido por el usuario.
13
3.8.
Estructuras de datos y referencias
Múltiples dimensiones
En Perl es posible escribir por ejemplo: [1ex] $a [3][4] = $b{’Lu’}[2]{ ’ C−201’} [1ex] Claro que esto es diferente de lo que parece. . . Tenemos un hash %b que bajo ’ Lu’ tiene una referencia a un arreglo anónimo, cuyo tercer
elemento es una referencia a un hash anónimo del cual tomamos el valor con clave ’ C−201’.
Manejo explı́cito de referencias
Podemos depositar una referencia en una variable [0.7ex] $a = \$x; $b = \@y; $c = \ %h; [0.7ex] y después
usarla descaradamente [0.7ex] ${$a} = 37; push @{$b}, (1, 2, 3); ${$c}{’Lu’} .= ” , FIS”; [0.7ex] desmanes
que son aplicables también a rutinas [0.7ex] sub una fun; $f = \&una fun; &{$f}(1, 2, 3); [0.7ex] donde nada
impide que tengamos arreglos (o hashes) con elementos de diferentes tipos. . .
Objetos anónimos
Podemos crear objetos anónimos de los distintos tipos, y asignar referencias a ellos: [0.7ex] $a[0] = [1, 2, $x, @y];
[0.5ex] $a[1] = {’uno’ => 1, ’dos’ => 2}; # Hash [0.5ex] $a[2] = sub {map $ ∗ 3, @ };
# Rutina
Un ejemplo extraño
# ! / usr / bin / p e r l
$a [ 0 ] = [ 0 , 1 , 2 ] ; $a [ 0 ] [ 3 ] = 3 ; push @{$a [ 0 ] } , 4 , 5 ;
$a [ 1 ] = { ’ uno ’ => 1 , ’ dos ’ => 2 } ;
$a [ 1 ] { ’ t r e s ’ } = 3 ;
$a [ 2 ] = sub {map $
∗ 3 , @ };
p r i n t ” $ : $a [ 1 ] { $ }\n ” foreach ( s o r t keys %{$a [ 1 ] } ) ;
p r i n t j o i n ( ’ ’ , $a [ 2 ] (@{$a [ 0 ] } ) ) , ” \n ” ;
4.
4.1.
Orientación a objetos en Perl
Paquetes
Paquetes
# ! / usr / bin / p e r l
package Saludos ;
$Despedida = ” Chao . . . ” ;
$ h i = ” Hola ! ” ;
sub bye ( ) { $Despedida ; }
package main ;
p r i n t $Saludos : : h i . ” \n ” ;
p r i n t Saludos : : bye ( ) . ” \n ” ;
4.2.
Módulos
Módulos
14
# Arr
# ! / usr / bin / p e r l
use Modulo ;
p r i n t f u n c @ARGV;
p r i n t ” \n ” ;
Módulos
# Modulo .pm
package Modulo ;
BEGIN {
use E x p o r t e r ( ) ;
our ( $VERSION , @ISA,
@EXPORT, @EXPORT OK, %
EXPORT TAGS ) ;
@ISA
= qw( E x p o r t e r ) ;
@EXPORT
= qw(& f u n c ) ;
}
sub f u n c { ” | ” . ( j o i n ’ : ’ , @ ) . ” | ” ; }
1;
4.3.
Objetos
Objetos en Perl
1. Un objeto es una referencia que sabe a qué clase pertenece
2. Una clase es un paquete que provee métodos para referencias a objetos
3. Un método es una subrutina que recibe una referencia a un objeto (o el nombre del paquete, para métodos de
clase) como primer argumento
Estructura de la herencia
El arreglo @ISA de la clase contiene los nombres de las clases base. Búsqueda de métodos es en profundidad,
de derecha a izquierda.
Toda clase hereda de UNIVERSAL
Sintaxis de llamadas
$mage = Wizard−>summon( ” Gandalf ” ) ; # Metodo de c l a s e
$mage−>speak ( ” f r i e n d ” ) ;
#
de i n s t a n c i a
$ c l a s e = r e f ( $mage ) ;
# Clase a l a que pertenece
$ t r a v e l = $companion eq ” Shadowfax ” ? ” r i d e ” : ” walk ” ;
$mage−>$ t r a v e l ( ” seven leagues ” ) ; # Metodo r i d e o walk
15
Crear objetos
La función bless asocia una referencia con un paquete:
$obj = {};
# R e f e r e n c i a a hash anonimo
bless ( $ o b j ) ;
# En paquete a c t u a l
bless ( $obj , ” C r i t t e r ” ) ; # En paquete C r i t t e r
Comúnmente se usan hashes como almacenamiento de los objetos, pero puede usarse cualquier tipo de referencia.
Ejemplo de clase
# Clase .pm
package Clase ;
sub new {
my $ i n v o c a n t = s h i f t ;
my $ c l a s s = r e f ( $ i n v o c a n t ) | | $ i n v o c a n t ;
my $ s e l f = { @ } ; bless ( $ s e l f , $ c l a s s ) ;
return $ s e l f ;
}
sub get name ( ) { ${ $ [ 0 ] } { name } ; }
1;
Ejemplo de clase
# ! / usr / bin / p e r l
use Clase ;
$ o b j = Clase−>new ( name => ” i n t i ” ) ;
p r i n t $obj−>get name , ” \n ” ;
16