El documento proporciona una introducción al lenguaje de programación Perl. Explica que Perl es un lenguaje interpretado creado por Larry Wall en 1987 para procesar texto y administrar sistemas UNIX. Describe los tipos básicos de datos en Perl como escalares, arrays y hashes, y cubre conceptos como variables, operadores, control de flujo, subrutinas y funciones.

1. Perl (Practical Extraction and
Report Language)
Óliver Centeno Álvarez
1

2. Contenidos
1. El Lenguaje Perl
2. Tipos de Variables
3. Control de Flujo
4. Subrutinas, Funciones y Procedimientos
5. Entrada y Salida
6. Expresiones Regulares
7. Librerías y módulos
8. Orientación a Objeto
9. Interacción con Sistemas
2

3. ¿Qué es Perl?
 PERL
 Practical
 Extraction and
 Report
 Language
 Leguaje interpretado (script)
 Larry Wall (1987) --> Perl v5 (1994)
 Combina C, AWK, SED, shell,…
3

4. ¿Qué es Perl?
 Procesamiento de ficheros/texto
 Administración UNIX
 Convertido a propósito general
 Incluyendo CGI
 Múltiples módulos extensibles
 Repositorio de código CPAN
 http://www.cpan.org
 ActiveState
4

5. Herramientas Perl
 ActivePerl
 Intérprete de ActiveState
 http://www.activestate.com/
 Komodo IDE + PDK
 perl -v
 EPIC
 Plugin para Eclipse
 http://e-p-i-c.sf.net/updates
5

6. Primer Programa Perl
 Fichero .pl
#!/usr/bin/perl –w
#!C:Perlbinperl.exe
print "Hola Perl!n";
6

7. Primer Programa Perl
 Cómo ejecutarlo
perl script.pl
./script.pl
perl –e 'print "Hola Perl!n";'
7

8. Perl (Practical Extraction and
Report Language)
2. Tipos de Variables
Escalares
Arrays
Hashes
8

9. Variables en Perl
 No hay definición de tipos
 Se distinguen por un carácter especial
 Que precede la variable
 E indica el formato de la misma
 Es case-sensitive
 Tras el carácter especial una letra
 Se pueden usar dígitos y underscore
9

10. Variables Escalares
 Comienzan por $
 Numéricas
 $a=3; # entero
 $b=7.5; # real
 $c=033; # octal
 $d=0xA5; # hexadecimal
 $e=1.3E12; # científico
 Booleanas
 $falso=0;
 $otro_falso="";
10

11. Variables Escalares
 Comienzan por $
 Texto
 $nombre='Oliver';
 $saludo="Hola $nombre";
 $msj="Incrustar una ${var}iable";
 Multilínea
 $texto = <<MARCA_FIN;
Para poder asignarle textos
más complejos con saltos de línea
MARCA_FIN
11

12. Operadores
 Aritméticos
 +, -, *, / # texto o número
 %, ** # resto y potencia
 Cadena
 . # Concatenación
 x # Repetición
 Ejemplos
 $triple="hola "x3;
 $k=2**10;
12

13. Operadores
 Combinados
 ++, -- # auto(in/de)cremento
 +=, -= # auto acumulación
 *=, /=, %=, **=, .=
 Otros operadores
 <<, >> # desplaza bit a bit
 , # evaluación múltiple
 Ejemplos
 6 << 3; # devuelve 6*23 = 48
 52 >> 3; # devuelve 52/23 = 6
13

14. Precedencia de Operadores
 !, ++, --
 *, **, /, %
 +, -
 <<, >>
 >, <, <=, >=
 ==, !=
 &, ^, |, &&, ||, ? :
 +=, *=, %=, /=, -=
14

15. Funciones Predefinidas
 Salida por pantalla
 print $texto1, $texto2, ...
 warn $texto1, $texto2, ...
 Manejo de textos
 length($texto)
 chop($texto) # devuelve el último carácter
 substr($texto, $desde, [$tamaño])
 Búsqueda en texto
 index($texto, $buscado, [$desde])
 rindex($texto, $buscado, [$desde])
15

16. Funciones Predefinidas
 Conversión a entero
 hex($texto_hexadecimal)
 oct($texto_octal)
 int($texto_decimal)
 Conversión a carácter
 chr($codigo_ascii)
 Conversión CASE
 lc($texto) # convierte a minúsculas
 uc($texto) # convierte a mayúsculas
 lcfirst($texto) # sólo la primera letra
 ucfirst($texto) # sólo la primera letra
16

17. Funciones Predefinidas
 Funciones matemáticas
 abs($numero)
 exp($numero)
 log($numero)
 rand([$hasta])
 crypt($password, $semilla) # DES
 Otras funciones
 eval($instrucción)
17

18. Arrays
 Comienzan por @
 Los elementos son escalares ($)
 Se asignan entre paréntesis
 Se puede asignar un rango de valores
 Elementos accesibles por índice en base 0
 Se puede acceder a varios elementos
 Asignables a escalares
 ($a, $b) = @array;
 Concatenables en 1 dimensión
18

19. Arrays
 Ejemplos
 @valores = (1,"hola",025,"adios");
 @rango = ("a".."z");
 $saludo = $valores[1];
 @subrango = @rango[6..12];
 @vocales = @rango[0,4,8,14,20];
 @concat = (@valores, @vocales);
19

20. Funciones para Arrays
 Tratamiento de Listas
 push(@array, $valor) # al final
 pop(@array)
 unshift(@array, $valor) # al ppio
 shift(@array)
 Índices
 $[ # primer índice
 $#array # último índice
 $size = @array # tamaño
 Ordenación
 sort(@array)
 reverse(@array)
20

21. Funciones para Arrays
 Arrays y texto
 join($separador, @array)
 split(/patrón/, $texto, [$maximo])
 Ejemplos
 @ordenado = sort(@valores);
 $ultimo = pop(@valores);
 $primero = unshift(@valores);
 $texto = join(", ", @vocales);
 @array = split(",", $texto);
21

22. Tablas Hash
 Almacenan pares clave-valor
 Comienzan por %
 Dos formas de definirlas:
 %tabla = (uno, 1, dos, 2);
 %tabla = (
uno => 1, dos => 2, nulo => undef
);
 Acceso a elementos escalares con {key}
 $elemento = $tabla{uno};
22

23. Funciones para Tablas Hash
 Acceso a claves y valores
 keys(%tabla) # array de claves
 values(%tabla) # array de valores
 each(%tabla) # recorre el hash
 Acceso a elementos
 exists $tabla{elemento}
 defined $tabla{elemento}
 delete $tabla{elemento}
23

24. Funciones para Tablas Hash
 Ejemplos
 %tabla=("i",7, "j",undef, "k",9);
 @claves = keys(%tabla);
 @valores = values(%tabla);
 ($k, $v) = each(%tabla);
 $valor = $tabla{i};
 delete $tabla{k};
 $falso = defined $tabla{j};
 $falso = exists $tabla{x};
24

25. Referencias
 Como los punteros de C
 Anteponer el carácter '' a una variable
 $ref_escalar = $escalar;
 $ref_array = @array;
 $ref_hash = %tabla;
 Anónimas
 $ref_escalar = "hola";
 $ref_array = [1, 2, 3];
 $ref_hash = {"x"=>2, "y"=>"hola"};
25

26. Referencias
 Referencia Simbólica
 $ref = "escalar";
 Acceso a referencias
 Pseudo-casting
 $$ref_escalar
 @$ref_array
 %$ref_hash
 $$ref_array[2]
 Modo Puntero
 $referencia->[2]
26

27. Referencias
 Arrays multidimensionales
 @array2d = (@array1, @array2);
 @Array2D = (
[1,2,3],
[5,8,13],
);
 $Ref2D = @Array2D;
 Acceso a valores
 $array2d[0][1] = 7;
 $Ref2D->[0]->[1] = 7;
27

28. Perl (Practical Extraction and
Report Language)
3. Control de Flujo
Operadores Condicionales
Estructuras Condicionales
Estructuras iterativas
28

29. Operadores Booleanos
 Relacionales
 ==, !=, <, >, <=, >=
 eq, ne, lt, gt, le, ge
 Lógicos
 &&, ||, !
 and, or, not
29

30. Operadores Booleanos
 Operadores a nivel de bit
 &, |, ~ # AND, OR, NOT bit a bit
 ^ # XOR bit a bit
 Operadores con asignación
 &=, |=, !=
 ^=
 Operador de selección condicional
 ? :
 $x = $y > 5 ? "mayor" : "menor";
30

31. Operadores Especiales
 Operadores de Comparación
 cmp
 Compara cadenas según su ASCII
 $x cmp $y;
 <=>
 Compara números
 $x <=> $y
 ¿Y cómo funcionan?
 1 si $x > $y
 0 si $x == $y
 -1 si $x < $y
31

32. Operadores Especiales
 Operadores de Comparación
 Ejemplos
"hola" cmp "hola"; #devuelve 0
"hola pepe" cmp "hola"; #devuelve 1
"adios" cmp "hola"; #devuelve -1
12 <=> 7; #devuelve 1
7 <=> 12; #devuelve -1
32

33. Estructuras de Control
 Condición
 if(expresión){...}
 unless(expresión){...}
 Condición múltiple
 if(expresión){
...
}elsif(expresion){
...
}else{
...
}
33

34. Estructuras de Control
 Iteraciones condicionales
 while(expresión){...}
 until(expresión){...}
 do{
...
}while(expresion);
 do{
...
}until(expresion);
34

35. Estructuras de Control
 Iteraciones controladas
 for(init; eval; inc){...}
 foreach $var (@array){...}
 Control de iteraciones
 next; #equivale a un continue
 last; #equivale a un break
35

36. Perl (Practical Extraction and
Report Language)
4. Subrutinas y Procedimientos
Funciones y Procedimientos
Parámetros y variables locales
Funciones interesantes
36

37. Funciones y Subrutinas
 Todas se identifican por sub
 Su código va entre llaves (bloque)
 Puede tener un return opcional
 Si no, se retorna la última instrucción
 Se invocan mediante
 función
 función()
 &función
 &funcion()
37

38. Funciones y Subrutinas
 Los paréntesis son opcionales
 sub función{ ... }
 sub función($$@){ ... }
 Siempre admite una lista de parámetros
 Para recoger esos argumentos:
 Variable implícita @_
 Parámetros $_[0], $_[1], ...
 Función implícita shift
 Función splice
 splice @array, [$desde, $n, @nuevo]
38

39. Funciones y Subrutinas
 Todas las variables son globales
 Para que sea local declararla
 local($var1, $var2, $var3)
 my($var1, $var2, $var3)
 El paso de parámetros es por valor
 Para que se pase por referencia
 local(*a, *b) = @_;
 &funcion(*a, *b);
39

40. Funciones y Subrutinas
 Ejemplos
 sub mayor{
local($msj) = " es mayor que ";
$salida = $_[0] > $_[1] ?
$_[0].$msj.$_[1] : $_[1].$msj.$_[0];
}
 sub swap{
local(*x, *y) = @_;
local($tmp) = $x;
$x = $y;
$y = $tmp;
}
40

41. Perl (Practical Extraction and
Report Language)
5. Entrada y Salida
Entrada y Salida estándar
Variables de entorno
Lectura y Escritura de ficheros
41

42. Entrada/Salida
 Operador de entrada
 <>
 Contiene una entrada de datos
 Teclado, fichero, correo, comando,...
 Lectura de teclado
 Puntero STDIN
 Lee hasta pulsar Intro
 Se cancela con Ctrl+Z o Ctrl+D
42

43. Entrada/Salida
 Lectura de teclado
 $linea = <STDIN>;
 La cadena leída incluye el "n"
 Función chop
 chop($linea = <STDIN>);
 Lectura de fichero por argumento
 @fichero = <>;
 perl script.pl fichero.txt
 Variable @ARGV;
43

44. Entrada/Salida
 Lectura de fichero
 Crear un puntero a fichero
 open(FICHERO, "ruta/al/fichero");
 close(FICHERO);
 Lectura línea a línea ó en bloque
 $linea = <FICHERO>;
 @lineas = <FICHERO>;
 Admite modificadores de acceso
 Normalmente delante de la ruta
44

45. Entrada/Salida
 Lectura de fichero
 Modificadores:
< Modo de lectura (por defecto)
> Modo de escritura (sobrescribe)
>> Modo de concatenación
+> Modo de lectura/escritura creador
+< Modo de lectura/escritura no creador
| Modo tubería (se pone detrás de la ruta)
45

46. Entrada/Salida
 Operador de salida
 Salida estándar
 print STDOUT "Hola";
 Escritura de fichero
 Crear un puntero de escritura a fichero
 print FICHERO $dato;
 Salida con formato
 printf "cadena formateada", @valores
 sprintf "cadena formateada", @valores
46

47. Entrada/Salida
 Formatos de escritura
 %d Número entero
 %o Entero octal
 %x Entero hexadecimal
 %f Número real
 %e Notación científica
 %c Carácter
 %s Cadena de caracteres
 %ld Entero largo
 %lf Flotante doble precisión
47

48. Entrada/Salida
 Secuencias de escape especiales
 n Salto de línea
 t Tabulador
 b Borrado de un carácter
 a Pitido
 f Salto de página
 v Tabulador vertical
 Backslash
 " Comillas
 000 Carácter ASCII octal
48

49. Entrada/Salida
 Operadores para ficheros
 -e Indica si el fichero existe
 -r Indica si el fichero es legible
 -w Indica si el fichero es modificable
 -x Indica si el fichero es ejecutable
 -d Indica si es un directorio
 -l Indica si es un acceso directo
 -M Fecha de la última modificación
 -A Fecha del último acceso
49

50. Entrada/Salida
 Ejemplos
if(-e "fichero.txt"){
open(FICHERO, "fichero.txt");
}
if(-e "mi_fichero.txt"
&& -r "mi_fichero.txt"){
print "Existe y es legiblen" ;
}
open(FICHERO, "+<mi_fichero.txt") || die
("no se ha podido abrir");
50

51. Entrada/Salida
 Funciones para ficheros
 read(FICHERO, $var, $cuantos, [$buffer])
 Lee $cuantos caracteres
 Desde la posición actual
 Y los guarda en $var
 $buffer indica cuántos se de la última lectura
 tell(FICHERO)
 Devuelve la posición del puntero
51

52. Entrada/Salida
 Funciones para ficheros
 eof(FICHERO)
 Comprueba si estamos al final del fichero
 seek(FICHERO, $despl, $desde)
 Mueve el puntero $despl posiciones
 Empezando a contar
 Desde el principio ($desde=0)
 Desde el puntero ($desde=1)
 Desde el final ($desde=2)
52

53. Entrada/Salida
 Ejemplos
#leo 10 caracteres
read(FICHERO, $leido, 10);
#leo 7 desde el puntero y 5 del anterior
read(FICHERO, $leido, 7, 5);
#muevo el puntero 2 caracteres a la derecha
seek(FICHERO, 2, 1);
#muevo el puntero a 10 caracteres antes del final
seek(FICHERO, -10, 2);
#muevo el puntero a 3 caracteres del anterior
seek(FICHERO, 4, 0);
#leo 7 desde el puntero y 3 del anterior
read(FICHERO, $leido, 7, 3);
53

54. Perl (Practical Extraction and
Report Language)
6. Expresiones Regulares
Búsqueda de patrones
Caracteres especiales
Sustitución de cadenas
54

55. Expresiones Regulares
 Modelo/forma de comparar texto
 Permite definir patrones de texto
 Búsqueda, modificación y extracción
de palabras clave
 Expresiones de sustitución
 Expresiones de comparación
 Expresiones de traducción
 $& contiene la última cadena encontrada
55

56. Expresiones de Comparación
 Se escriben entre barras /patrón/
 Se evalúan mediante =~, !~
 $texto =~ /patron/;
 También se usa para sustituir patrones
 $var =~ s/uno/dos/;
 El patrón puede ser simple
 /Hola/
 O elaborado
 /[a-zA-Z0-9@]/
56

57. Expresiones Regulares
 Algunos Patrones:
/[…]/ cualquiera de los caracteres entre
corchetes
/[^…]/ ninguno de los caracteres entre
corchetes
/^…/ contiene la cadena al principio
/…$/ contiene la cadena al final
/^$/ cadena vacía
* repetición cero o más veces
+ repetición una o más veces
? elemento opcional
57

58. Expresiones Regulares
 Ejemplos:
/^c./ Empieza por 'c'
/.c$/ Termina con 'c'
/a*b+/ Cero o más aes seguidas de una o
más bes
/c?/ Una 'c' opcional
/[a-zA-Z][a-zA-Z0-9_]*/
/[a-zA-Z][a-zA-Z0-9_]*
@[a-zA-Z0-9_]+.[a-zA-Z]+/
58

59. Expresiones Regulares
 Caracteres especiales
 Para facilitar la creación de patrones
 w Caracteres alfanuméricos
 d Caracteres numéricos
 s Espacio en blanco
 ^ Carácter ^
 ~ Carácter ~
 b inicio o fin de una palabra
 A inicio de cadena (equivale a ^)
59

60. Expresiones Regulares
 Caracteres especiales
 {n,m} entre n y m repeticiones
 () separación de patrones
 | OR para patrones
 & AND para patrones
 La versión en mayúsculas niega el patrón
 W Caracteres no alfanuméricos
 D Caracteres no numéricos
 …
60

61. Expresiones Regulares
 Sustitución
 Formato s/…/…/
 Sustituye el primer patrón por el segundo
 Formato s/…/…/g
 Sustituye todas las ocurrencias
 Formato s/…/…/i
 Independiente de mayúsculas y minúsculas
 Formato s/…/…/e
 Evalúa la sustitución como Perl
 s/d+/$&*5/e Multiplica los números por 5
61

62. Expresiones Regulares
 Sustitución
 Variables $1 a $9
 Referencian uno de los patrones encontrados
 s/(Hola)(Mundo)/Fin del $2/
 s/(w)(d)/Encontrados $1 y $2/
 Variables 1 a 9
 Referencias dentro del patrón
 /^([a-zA-Z0-9_]).1$/
62

63. Expresiones Regulares
 Traducción
 Formato tr/…/…/
 Sustituye carácter a carácter
 Si se acaban se repite el último carácter
 tr/aeiou/qwerty/
 Sustituye las 'a' por 'q',…
 tr/qwerty/abc/
 Sustituye las 't' por 'c'
63

64. Expresiones Regulares
 Traducción
 Formato tr/…/…/c
 Sustituye los que no cumplan el patrón
 Formato tr/…/…/s
 Elimina las letras repetidos seguidas
 Formato tr/…/…/d
 No reemplaza sino que borra los encontrados
64

65. Expresiones Regulares
 Funciones interesantes
 pack("formato", @variables)
 Empaquetado
 Convierte a ASCII variables según un formato
 unpack("formato", "cadena")
 Desempaquetado
 Recupera variables desde formato ASCII
65

66. Expresiones Regulares
 Funciones interesantes
 Formatos
 c Carácter con signo
 s Entero corto con signo
 l Entero largo con signo
 i Entero con signo
 f Real en punto flotante
 d Real en precisión doble
 x Byte nulo
66

67. Expresiones Regulares
 Ejemplos
 $var =~ tr/A-Z/a-z/;
 $cuenta = $var =~ tr/w*/w*/;
 $var =~ s/(Hola )(w*)/Adios $2/
 $var =~ s/w/$& x 2/eg;
 $var =~ /boso/; # encaja oso
 $var =~ /Boso/; # encaja perezoso
 $packed = pack("icf", 345, 64, 256.99);
 ($x, $y, $z) = unpack("icf", $packed);
67

68. Perl (Practical Extraction and
Report Language)
7. Liberías y Módulos
Módulos
Paquetes
CPAN
68

69. Módulos y Paquetes
 Módulo: Fichero .pm reutilizable
 Paquete: Carpeta que contiene módulos
 Creación de módulos
 Primera línea
 package Nivel1::Nivel2::Nivel3;
 Pragma de programación segura
 use strict;
 Variables my
 Claves de HASH entre comillas
 Error al usar como referencia algo que no lo es
69

70. Módulos y Paquetes
 Creación de módulos
 Módulo exportador de funciones
 require Exporter;
 Array de herencia
 @ISA="Exporter";
 Array de símbolos exportados
 @EXPORT=qw(f1 f2 $escalar @vector);
 Retorno del módulo
 1;
70

71. Módulos y Paquetes
 Ejemplo de módulo
package MisModulos::FechaHora;
require Exporter;
@ISA=qw(Exporter);
@EXPORT=qw(fecha);
sub fecha{
($sg,$min,$h,$d,$m,$a)=localtime(time);
$a+=1900; $m++;
return "$d/$m/$a $h:$min:$sg";
}
1;
71

72. Módulos y Paquetes
 Importación de módulos
 use Nivel1::Nivel2;
 use modulo [version] [lista funciones];
 Función qw() convierte a lista de textos
 use Modulo qw(f1 f2 f3);
 use vars qw($nombre @EXPORT @ISA);
 Acceso a funciones en módulos
 Si está exportada e importada, usarla
 Si no, Paquete::modulo::funcion;
72

73. Módulos y Paquetes
 Repositorios de Paquetes
 CPAN
 http://search.cpan.org/
 Búsqueda y descarga
 PPM
 Perl Package Manager
 ActiveState
 PPM Repositories
 http://www.bribes.org/perl/ppm/
73

74. Módulos y Paquetes
 Ejemplos de uso de módulos
 use Switch;
switch($x){
case ["a".."z"] {print "minúscula";}
case [1,2,3,5,7] {print "primo";}
case 4 {print "potencia de 2";}
else{ print "X"; }
}
74

75. Módulos y Paquetes
 Ejemplos de uso de módulos
 use XML::Simple;
my $xml = XML::Simple::XMLin($fichero);
$ref_nodo = $xml->{nodo};
@ref_nodos = @$ref_nodo;
for $d (@ref_nodos){
$d->{atributo} = "valor";
}
$salida = XMLout($xml, RootName=>"raiz");
75

76. Módulos y Paquetes
 Ejemplos de uso de módulos
 use IO::Compress::Zip qw(zip $ZipError);
chop($entrada = <STDIN>);
if(defined $entrada){
zip $entrada => "comprimido.zip"
or die "Error al comprimir";
}else{
zip '<*.txt>' => '<*.zip>'
or die "Error al comprimir";
}
print "Comprimidon";
76

77. Módulos y Paquetes
 Ejemplos de uso de módulos
 use LWP::UserAgent;
my $navegador = LWP::UserAgent->new;
my $pagina = $navegador-> get('http:
//search.cpan.org/');
if ($pagina->is_success) {
print $pagina->decoded_content;
}else {
die $pagina->status_line;
}
77

78. Módulos y Paquetes
 Documentación POD
 Añadida al fichero .pm
 =head1 NAME
 Nombre del módulo
 =head1 ABSTRACT | SYNOPSIS
 Descripción breve, uso del módulo
 =head1 DESCRIPTION
 =head2 Nombre función
 =back
 …
78

79. Módulos y Paquetes
 Comandos de conversión
 A texto, html o man de UNIX
 pod2man Modulo.pm > fichero
 pod2html Modulo.pm > fichero
 pod2text Modulo.pm > fichero
79

80. Perl (Practical Extraction and
Report Language)
8. Orientación a Objeto
Conceptos
Ámbito de Variables
Creación y uso de objetos
80

81. Conceptos
 Programación Orientada a Objeto
 Para facilitar la programación
 Se define una estructura más compleja
 Las variables son estructuras
 Compuestas de datos (atributos)
 Y de subrutinas/funciones (métodos)
 Cada variable contienen sus propios
valores y todas las funciones
81

82. Conceptos
 Programación Orientada a Objeto
 ¿Se puede aplicar en Perl?
 $, @ y % contienen datos
 ¿Y qué es &?
 Existen otros tipos de dato
 CODE
 FILEHANDLE
 FORMAT
82

83. Conceptos
 Programación Orientada a Objeto
 $, @ y % contienen referencias
 También existe & como referencia
 Puedo crear variables escalares que
contengan referencias
 Y usarlas mediante puntero/casting
 $$ref_escalar
 $ref_array->[0]
 $ref_tabla->{id}
 $ref_sub->()
83

84. Creación y Uso de Objetos
 Programación Orientada a Objeto
 Puedo crear objetos como referencias
 Y acceder a su contenido como puntero
 $objeto->funcion;
 $objeto->atributo;
 Debo definir el tipo de dato en un Módulo
 Y "bendecir" los objetos
 $objeto = {atributo=>5};
 bless $objeto, "Tipo";
 print "El tipo es ", ref $objeto;
84

85. Creación y Uso de Objetos
 Ámbito de las variables
 Por defecto ámbito GLOBAL
 Ámbito local
 Ámbito privado (my)
 Ámbito compartido (our)
 Acceso por ámbito
 $var # acceso a ámbito
 $::var # acceso a Global
 main::var # acceso a paquete main
85

86. Creación y Uso de Objetos
 El constructor
 Función especial new()
 Que asigna valores a los atributos
 $objeto = Modulo->new();
 El destructor
 En otros lenguajes existe función destructora
 En Perl basta con asignar valor undef
 Se libera la memoria automáticamente
 $objeto = undef;
86

87. Creación y Uso de Objetos
 Ejemplo de módulo de objetos
package Coche;
sub new{
my $clase = shift;
my $objeto = {
marca=>shift, modelo=>shift
};
bless $objeto, $clase;
return $objeto;
}
87

88. Creación y Uso de Objetos
 Ejemplo de uso de objetos
use Coche;
$miCoche = Coche->new("Peugeot", 207);
$otro = Coche->new("Opel", "Astra");
print "Tengo un ", $miCoche->{marca},
" ", $miCoche->{modelo};
88

89. Creación y Uso de Objetos
 Una pequeña mejora
sub Marca{
return shift->{marca};
}
print "Tengo un ", $miCoche->Marca;
sub Modelo($){
my ($obj, $valor) = (shift,shift);
if(defined $valor){$obj->{modelo} = $valor;}
else{ return $obj->{modelo};}
}
89

90. Conceptos Avanzados
 Métodos Privados
my $metodo_privado = sub{...};
sub metodo_publico{
shift->$metodo_privado(@_);
}
 Sobrecarga
use overload '+' => 'sumar',
'-' => 'restar',
'""' => 'toString',
'0+' => 'toNumber';
90

91. Perl (Practical Extraction and
Report Language)
9. Interacción con sistemas
Conexión a BBDD
Comandos del sistema
Interacción Web
91

92. Interacción con BBDD
 Módulo DBI
 DataBase Interface
 use DBI;
 Necesito conocer
 Host ($host)
 Instancia de BBDD ($bd)
 Driver de BBDD ($driver)
 Usuario ($usr)
 Contraseña ($pwd)
 Necesito descargar el driver (DBD)
92

93. Interacción con BBDD
 Módulo DBI
 Cadena de conexión formateada
 dbi:$driver:database:$bd;host=$host
 Conexión
 $cnn=DBI->connect($cadena,$usr,$pwd);
 Consulta
 $q=$cnn->prepare("SELECT * FROM Tabla");
 $q->execute()
93

94. Interacción con BBDD
 Módulo DBI
 Cadena de conexión formateada
 dbi:$driver:database:$bd;host=$host
 Tratamiento de los registros
 while(@registro = $q->fetchrow_array()){
$x = $registro[0];
}
 Desconexión
 $q->finish;
 $cnn->disconnect;
94

95. Interacción con BBDD
 Módulo DBI
 Más funciones
 $cnn->ping
 $cnn->do($sql)
 $cnn->commit
 $cnn->rollback
 $q->fetchrow_arrayref
 $q->fetchrow_hashref
 $q->rows
95

96. Interacción Web
 Módulo CGI
 Common Gateway Interface
 use CGI qw/:standard/;
 Funciones HTML
 header
 start_html y end_html
 h1, h2, h3, h4, h5, h6
 p, br, hr
 em, b, i, u, font
 start_form y end_form
96

97. Interacción Web
 Módulo CGI
 Funciones de formulario
 textfield
 checkbox_group
 radio_group
 popup_menu
 hidden
 button
 submit
 param
97

98. Interacción Web
 Ejemplo
 print start_html('Mi Web'),
start_form,
"Introduce tu nombre",
textfield('nombre'),
submit,
end_form;
if(param){
print "Te llamas ", param('nombre');
}
print end_html;
98

99. Interacción Web
 Ejecutar en IIS 4-6
 Administrador de IIS
 Propiedades de un Sitio Web
 Directorio particular > configuración
 Agregar extensión .pl asociada a C:
Perlbinperlis.dll
 Copiar el fichero .pl a ejecutar
99

100. Interacción Web
 Ejecutar en IIS 7
 Administrador de IIS
 Habilitar 32-bit en el Application Pool
 Añadir un mapeo al Handler Mapping
 Module Mapping
 IsapiModule
 Extensión PL
 Ejecutable C:PerlbinPerlEx30.dll
 Copiar el fichero .pl a ejecutar
100

101. Interacción Web
 Ejecutar en Apache
 Instalar mod_perl
 sudo apt-get install libapache2-mod-perl2
 Editar el fichero de configuración
 /etc/apache2/apache2.conf
 AddHandler cgi-script .cgi .pl
<Files ~ ".pl$">
Options +ExecCGI
</Files>
<Files ~ ".cgi$">
Options +ExecCGI
</Files>
101

102. Interacción Local
 Ejecutar comandos del sistema
 Modo entrada:
 Modificador tubería
 open(DIR, "dir|")
 open(IPCONFIG, "ipconfig /all|")
 Modo salida (sistemas tipo UNIX):
 open(TALK, "talk oliver");
 print TALK "Hola majo!";
102

103. Perl (Practical Extraction and
Report Language)
FIN
Óliver Centeno Álvarez
oliver.centeno@gmail.com
103