Scripting - csrg

Lenguajes de Scripting
Perl
Horst H. von Brand
Departamento de Informática
Universidad Técnica Federico Santa Marı́a
Agenda
Lenguajes de Scripting
Introducción al lenguaje Perl
Detalles del lenguaje
Tipos de datos
Contextos
Operadores
Estructuras de control
Funciones predefinidas
Expresiones regulares
Subrutinas
Estructuras de datos y referencias
Orientación a objetos en Perl
Paquetes
Módulos
Objetos
Agenda
Lenguajes de Scripting
Introducción al lenguaje Perl
Detalles del lenguaje
Tipos de datos
Contextos
Operadores
Estructuras de control
Funciones predefinidas
Expresiones regulares
Subrutinas
Estructuras de datos y referencias
Orientación a objetos en Perl
Paquetes
Módulos
Objetos
Caracterı́sticas de lenguajes de scripting
I
“Script” es guión
I
I
I
I
Caracterı́sticas generales
I
I
I
I
Invocar programas automáticamente
Lenguajes interpretados
Muy alto nivel
Manejo de strings y expresiones regulares
Sin tipos, variables no se declaran
Administración automática de memoria
Caracterı́sticas adicionales comunes
I
I
Empotrable: Puede usarse desde dentro de programas
Extensible: Pueden agregarse nuevas funcionalidades
Algunos lenguajes
I
Perl: Oficialmente, abreviatura de Practical Extraction and
Report Language
I
Python: Por Monty Python
I
PHP: Abreviatura de PHP: Hypertext Processor
I
Ruby: La piedra preciosa (si hay perlas. . . )
I
TCL: Es Tool Control Language, creado con la idea de ser
un lenguaje de extensión/configuración
I
expect: Una extensión de TCL, orientada a controlar
programas interactivos
I
AWK: Lenguaje inventado por Aho, Weinberger,
Kernighan.
Agenda
Lenguajes de Scripting
Introducción al lenguaje Perl
Detalles del lenguaje
Tipos de datos
Contextos
Operadores
Estructuras de control
Funciones predefinidas
Expresiones regulares
Subrutinas
Estructuras de datos y referencias
Orientación a objetos en Perl
Paquetes
Módulos
Objetos
Perl
I
Practical Extracting and Report Language
I
Pathologically Eclectic Rubish Lister
I
Lema: “There’s more than one way to do it” (TMTOWTDI)
I
No pretende ser simple, regular, ortogonal
I
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
Algunos flags importantes
Opciones para correr perl en perlrun(1).
Flag
-h
-v
-d
-i<extensión>
-n
-p
Significado
Resumen de las opciones
Versión
Correr en el debugger
Archivos procesados con <> se procesan in situ, dejando el original con la
dada
El programa se aplica a cada lı́nea
El programa se aplica a cada lı́nea,
imprimiendo automáticamente la 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
Contar lı́neas, palabras, caracteres
# ! / 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
Contar lı́neas, palabras, caracteres – versión “completa”
# ! / 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
Referencias cruzadas
# ! / usr / bin / p e r l
while (<>) {
foreach $w ( s p l i t ( / \W+ / ) ) {
i f ( ! defined ( $ r {$w } ) ) {
$ r {$w} = $ . ;
} 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
Promedios
# ! / 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
Entrada y salida
# ! / 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 ) ;
Agenda
Lenguajes de Scripting
Introducción al lenguaje Perl
Detalles del lenguaje
Tipos de datos
Contextos
Operadores
Estructuras de control
Funciones predefinidas
Expresiones regulares
Subrutinas
Estructuras de datos y referencias
Orientación a objetos en Perl
Paquetes
Módulos
Objetos
Tipos de datos básicos
I
$escalar: Strings, números, referencias.
I
@arreglo: Elementos $arreglo[0], . . . , $arreglo[$#arreglo]
I
%hash: Arreglo asociativo, elementos $hash{”clave”}
I
Slices: @arreglo[1, 17, 3], @hash{”uno”, ”doce”, ”nueve”}
I
Inicializar:
I
I
@a = (”Do”, ”Lu”, ”Ma”, ”Mi”, ”Ju”, ”Vi” , ”Sa”);
%h = (”cero” => 0, ”uno” => 1, ”dos” => 2);
Constantes numéricas
I
Decimal: 100
I
Para legibilidad: 1 000
I
Decimales: 3.141592
I
Con exponente: 6.024e24
I
Octal: 0277
I
Hexadecimal: 0x3ff
I
Binario: 0b1010 0011
Constantes string
I
No interpola: ’ Hola!’, o también q($algo)
I
Interpola: ”Variable $a”, incluso qq(Variable $A[$i + 2])
Escapes en strings
Los de C, con algunos adicionales:
Escape
”\cC”
”\x{263a}”
”\N{Nombre}”
Significado
Control-C
Unicode (smiley)
Caracter por nombre
Escapes activos en strings
Código
”\u”
”\l ”
”\U”
”\L”
”\Q”
”\E”
Acción
Siguiente es mayúscula (titlecase)
Siguiente es minúscula
Mayúsculas
Minúsculas
Backslash antes de no-alfanuméricos
Fin de ”\U”, ”\L”, ”\Q”
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
Valores de verdad
Cuando se requiere un valor de verdad, esto provee
implı́citamente contexto escalar. Perl usa los siguientes
criterios:
I
Cualquier string, salvo ” ” y ”0”, es verdadero
I
Todo número, salvo 0, es verdadero
I
Cualquier referencia es verdadera
I
Cualquier valor no definido es falso
Operadores
Básicamente los de C, pero con algunas adiciones:
I
Rango: 1..10, \”a0 \”..\” z9\”
I
Concatenación de strings: $saludo . ” , ” . $nombre
(Claro que se escribirı́a ”$saludo, $nombre” más bien)
I
Repetir un string: ”\t ” x ($k / 8) . ” ” x ($k % 8)
I
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:
I
$a = 1, 2, 117; da $a == 117 (Operador coma evalúa sus
argumentos, descarta el primero)
I
@a = 1, 2, 117; da @a == (1, 2, 117) (Es una lista lo que
se asigna)
I
$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
I
En Perl la asignación es un operador que entrega el lvalue
I
Ası́, puede transformarse $t de Fahrenheit a Celsius
mediante ($t −= 32) ∗ 5 / 9;
Asignación en Perl: Arreglos
I
Pueden asignarse arreglos completos, por ejemplo
@a = @b; o @a = (1, 2, 4, 8, 16);
I
El lado izquierdo puede ser una lista de variables, o sea:
($a, $b) = (42, 117);
I
Las asignaciones se hacen en paralelo, o sea
($a, $b) = ($b, $a); intercambia los valores de $a y $b
I
De asignarse más valores, los sobrantes se descartan
I
Si hay arreglos, el primero consume todos los valores
restantes: ($a, $b, @resto) = (1, 2, 3, 4, 5, 6);
I
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();
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:
open(IN, ”< $file” ) or die ”Can’t open $file” ;
/ˆ #/ and next;
Comparaciones
Comparación
Menor que
Menor o igual que
Igual a
Mayor o igual que
Mayor que
No igual a
Comparar
Número
<
<=
==
>=
>
!=
<=>
String
lt
le
eq
ge
gt
ne
cmp
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 {
...
}
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 ;
...
}
Funciones predefinidas
Manejo de arreglos como deque
I
push ARRAY, LIST
I
$var = pop ARRAY
I
$var = shift ARRAY
Por omisión, @ARGV o @
I
unshift ARRAY, LIST
Funciones predefinidas
Combinar/dividir strings
I
join EXPR, LIST
I
split /PATTERN/, EXPR, LIMIT
O sea, se puede hacer algo como:
perl -e ’print join(" ", split //, shift), "\n";’ ’
Funciones predefinidas
Manipulación de arreglos
I
sort BLOCK ARRAY
BLOCK compara $a con $b
I
map BLOCK ARRAY o map EXPR, ARRAY
I
grep BLOCK ARRAY o grep EXPR, ARRAY
Funciones predefinidas
Manipulación de strings
I
lc EXPR, uc EXPR
I
lcfirst EXPR, ucfirst EXPR
Funciones predefinidas
Otras clases
I
Manipulación de procesos
I
Hebras (threads)
I
Numéricas
I
Llamadas propias de U NIX
Un ejemplo de uso
Datos
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
Un ejemplo de uso
Salida deseada
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
El programa
# ! / 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
Una versión más sofisticada
# ! / 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
q {...}
qq{...}
qx{...}
qw{...}
m{...}imosx
qr {...} imosx
s {...}{...} egimosx
tr {...}{...} cds
Int
No
Si
Si
No
Si
Si
Si
No
Significa
String
String
Comando
Palabras
Calza patrón
Patrón
Reemplazo
Transliterar
Los delimitadores pueden ser “cualquier cosa” (no
alfanuméricos, claro), pero generalmente se usan /.../ . O
pueden usarse diversos tipos de paréntesis ()[]{}<>, que
deben parearse.
Operadores especiales
Calce de patrón
En m /.../ imosx y qr /.../ imosx:
i
m
o
s
x
No distinga mayúsculas/minúsculas
Múltiples lı́neas
Compilar una sola vez (once)
Una sola lı́nea
Expresiones regulares extendidas
qr /.../ retorna un objeto que puede darse en vez de un patrón
al buscar/reemplazar.
Operadores especiales
Reemplazo
En s /.../.../ egimosx:
e
g
i
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
Transliterar
En tr /BUSCA/REEMPLAZO/cds:
c
d
s
Complemento
Elimine los sin traducción (delete)
Secuencias duplicadas se reducen a uno (squash)
tr /A−J/0−9/: Como tr /ABCDEFGHIJ/0123456789/
tr/0−9/9/
tr /A−Za−z//s: ’Mississippi’
’Misisipi’
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)
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.
Expresiones regulares
Caracteres individuales
. Calza con cualquier caracter (salvo ”\n”, si /s)
[...] Conjunto de caracteres.
ˆ niega, – rango.
[: ... :] conjunto POSIX
Expresiones regulares
Caracteres individuales
”\w”
”\W”
”\s”
”\S”
”\d”
”\D”
Palabra (alfanumérico y )
No-palabra
Espacio
No-espacio
Dı́gito
No-dı́gito
Expresiones regulares
Operadores
* 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
Anchors
ˆ Principio del string (o la lı́nea, si /m)
$ Fin del string (o la lı́nea, si /m)
Expresiones regulares
Anchors
”\b”
”\B”
”\A”
”\Z”
”\z”
Borde de palabra
No-borde de palabra
Principio del string
Final del string (o antes de ”\n” final)
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. . .
Búsquedas y reemplazos
m/(\w+) \1/ # Palabras repetidas
($h, $m, $s) = $hms =˜ m/(\d+):(\d+):(\d+)/;
m{ˆ(.∗): GIF}; # Ahora $1 es lo que calza
s<ˆ(?:foo|bar)([0−9]+)>[$1−baz−$1]
s/(\[0−9\]+)/$1 + 3/ge
Subrutinas
Un ejemplo simple
# ! / 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
Manejo de arreglos
# ! / 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
Prototipos
La definición general de subrutina tiene la forma:
sub NAME(PROTO): ATTRS BLOCK
I
El prototipo y los atributos son opcionales.
I
Si no hay bloque, es declaración únicamente.
I
Si no se da nombre, es anónima.
Subrutinas – definición general
Prototipos
$
@
\@
\%
&
∗
\[$@]
\ %;$
Escalar
Arreglo
Referencia a arreglo
Referencia a hash
Bloque
Glob
Escalar o arreglo
Referencia a hash, escalar opcional
Subrutinas – definición general
Atributos
Mecanismo para limitar acceso o dar información sobre la
subrutina. Básicamente definido por el usuario.
Múltiples dimensiones
En Perl es posible escribir por ejemplo:
$a [3][4] = $b{’Lu’}[2]{ ’ C−201’}
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
$a = \$x; $b = \@y; $c = \ %h;
y después usarla descaradamente
${$a} = 37; push @{$b}, (1, 2, 3); ${$c}{’Lu’} .= ” , FIS”;
desmanes que son aplicables también a rutinas
sub una fun; $f = \&una fun; &{$f}(1, 2, 3);
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:
$a[0] = [1, 2, $x, @y];
# Arreglo
$a[1] = {’uno’ => 1, ’dos’ => 2}; # Hash
$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 ” ;
Agenda
Lenguajes de Scripting
Introducción al lenguaje Perl
Detalles del lenguaje
Tipos de datos
Contextos
Operadores
Estructuras de control
Funciones predefinidas
Expresiones regulares
Subrutinas
Estructuras de datos y referencias
Orientación a objetos en Perl
Paquetes
Módulos
Objetos
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 ” ;
Módulos
El usuario
# ! / 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
El módulo mismo
# 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;
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
I
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.
I
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
Crear objetos
La función bless asocia una referencia con un paquete:
$ o b j = { } ; # 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
Definición de la 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
Uso de la 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 ” ;