PDF de programación - El Evangelio de Perl

El Evangelio de Perl



que es Perl
variables
valores
mas sobre arreglos
mas sobre hashes
verdadero y falso
expresiones lógicas
operadores
funciones
bloques
mas funciones integradas
enunciados
referencias
archivos
regex
mas sobre regex
variables especiales



Tabla de contenido
Lo básico...



Lo bueno... aquí se le saca la utilidad...



Algo mas... siempre es bueno saber mas...



meta-documento...



Lo básico...

Que es Perl



mas sobre archivos
como procesa Perl un programa
la linea de comando de Perl
mas sobre contexto
herencia de objetos

paquetes
objetos
2 clases de métodos
el módulo CGI
el módulo DBI
el módulo LWP

que se pretende
realimentación



Perl es un lenguaje de computador interpretado muy original...
a pesar de su apariencia de taquigrafía tiene mucho de los lenguajes
naturales... resolver un problema en Perl es increíblemente mas
Fácil (y mas corto) que en cualquier otro lenguaje.
Perl no tiene esas reglas de los otros lenguajes que lo distraen a uno y
lo hacen perder tiempo... en Perl uno no tiene que pensar si la variable
es numérica o carácter... no tiene que pensar si el valor cabe en la
variable...



y por supuesto no hay que compilar... lo que no quiere decir que
Perl sea lento...
tampoco hay duda de que Perl se aprende rápido... al menos lo básico...
es muy fácil hacer pequeños programas para aclarar rápidamente las
dudas...
esta también la ventaja de su portabilidad... Perl existe hasta en
es como volver a la época en que todos los computadores tenían Basic...
solo que Perl es superior a cualquier lenguaje que yo haya visto...
ahora si vamos al grano...

$a = 5;
$b ="xxx";
$c = $a++; # $a++ es como en C ósea $a + 1

las instrucciones terminan en punto y coma...
Perl se confunde muy fácil si se olvida el punto y coma

todo lo que este después de # en la misma línea
es un comentario

un escalar puede tener números, strings u otras cosas
mas complicadas como referencias y descriptores



Windows...



variables



por $



argumentos



las variables escalares empiezan por $



note esto sobre las instrucciones:


note esto sobre comentarios


note esto sobre escalares:



para empezar no es necesario declarar las variables previamente...
las variables se pueden empezar a usar directamente en las expresiones
existen 3 tipos básicos de variables
1. escalares



2. arreglos



las variables arreglos empiezan por @



note esto sobre arreglos:



nota sobre print



print es una de las muchas funciones de Perl
en Perl hay mucha flexibilidad para escribir los



print ( $a, $b ); # con parentesis
print $a, $b; # sin parentesis

los elementos de un arreglo son escalares que empiezan
los subíndices empiezan por 0 como en C
el escalar $a no tiene que ver nada con $a[ ]

@a = (95, 7, 'fff' );
print $a[2];
# imprime el tercer elemento: fff
print @a
# imprime: 957fff ...todo pegado

los elementos se accesan por claves
no hay claves duplicadas

%a = ('x', 5, 'y', 3 );
$a{x}=7;
print $a{x};
# imprime: 7

%a = ( 'x', 5, 'y', 3);
# llena 2 elementos del hash
print $a{'x'};
# imprime: 5
print $a{'y'};
# imprime: 3

las variables hash empiezan por %
para crear un elemento de un hash se requiere una lista de 2
el primer elemento es la clave y el segundo es el valor



si la clave es un string sencillo se puede omitir las comillas

si se reasigna un elemento se pierde el valor viejo



note esto sobre los hashes



3. hashes o arreglos asociativos



valores



valores

los valores son las cosas que uno mete a las variables...

en Perl los valores se guardan separados de las variables e incluso

cada valor tiene un contador que indica cuantas variables lo estan

usando... cuando el contador es cero el valor desaparece


valores interesantes:
1. los strings



letras



$a{x} es lo mismo que $a{'x'}

$a = "abcd";
$a = 'abcd';

$a = 'pueblo'
print "hola $a";
# imprime: hola pueblo
print 'hola $a';
# no hay interpolación en comillas simples...
# imprime: hola $a

los strings pueden escribirse con comillas dobles o simples



cuando se usa doble comilla se pueden interpolar variables
escalares y arreglos ...interpolar significa intercalar... en el
resultado final la variable se sustituye por su valor...



uno se puede preguntar como se interpola una variable entre
sin que se altere el nombre de la variable...
p.e. como se coloca $a antes de una letra como "s"



"abc$as";
# no sirve... trata de interpolar la variable $as
"abc${a}s"

# interpola correctamente $a

$a = 1234;
print "valor=$a\$";
# imprime: valor=1234$

print "aaa \n";
# salta linea
print 'aaa \n';
# no salta... imprime: aaa \n


entre las comillas dobles se pueden tambien poner caracteres
como \n (salto de linea), \t (tabulador), \b (backspace),...



entre las comillas doble. se tiene que escapar los caracteres
que tienen significado especial en Perl... como $, ", \ ...



la "escapada" se hace con backslash antes del caracter
entre las comillas simples solo se tiene que escapar ' y \


cuando se interpola un arreglo, Perl regala un separador que es
blanco



el separador es realmente el valor de la variable escalar $" ...
$" puede ser reasignada
$" = ',';

print "val=@a";


# imprime: val=95,7,fff

@a = (95, 7, "fff" );
print "val=@a" ;
# imprime: val=95 7 fff

print 'abc\'s';
# imprime: abc's



especiales



un



2. las listas



3. strings con comillas invertidas



las comillas invertidas se comportan como en los shelles de Unix



$a = `ls -l`;
# $a queda con la salida del comando "ls -l"



$a = (2, 7, 'sss');
# $a queda con el último valor: 'sss'
@a = (2, 7, 'sss');
$a = @a;
# $a queda con el número de elementos de @a: 3

p.e. (2, 7, 'sss' )



note que (2, 7, 'sss') es un valor
mientras que @a es un arreglo - recuerde que las variables y los
valores son 2 cosas distintas
existen abreviaturas para algunas listas
$a = (2..7);

# $a queda con (2,3,4,5,6,7);

$a = ('a'..'e');


# $a queda con ('a','b','c','d','e')



en comillas invertidas se puede interpolar variables...
en comillas dobles se puede intercalar comillas invertidas


$a = 5;
# aqui 5 es el valor de $a
$b = $a;
# aqui el valor 5 de $b es otro valor

para que se utilice un solo valor para 2 variables se necesita
utilizar referencias... referencias se ven mas adelante...



asociar un valor con una variable se llama bind...



los subíndices positivos recorren los elementos al derecho


@a = ('a'..'e');

los subíndices negativos recorren los elementos al revez


@a = ('a'..'e');

@a = ('a'..'e');
$n = @a;
# aqui $n es 5
lo del contexto es una caracteristica de Perl...
Perl evalua una expresiòn segun el uso que se piensa
dar a la expresión: contexto escalar o contexto de lista

un arreglo en contexto escalar retorna el número de elementos



subarreglos:



mas sobre arreglos


# $a[0] es 'a' $a[4] es 'e'



# $a[-1] es 'e' $a[-5] es 'a'



@a = ('a'..'e');

@b = @a[3, 0];

# @b = ('d', 'a');

@c = @a[2-5];



igual
($a, $b ) = @x



@a[3, 0] = @a[0, 3];



@a = ('a'..'e');
$a = join ":", @a
# $a queda con "a:b:c:d:e";

# @a[2,3,4,5] o @a[2..5]


es posible colocar una lista de variables escalares a la izquierda del

# intercambia los elementos 0 y 3

# $a queda con el valor de $x[0]
# $b queda con el valor de $x[1]



es posible colocar un subarreglo a la izquierda del igual

la función join convierte un arreglo en un escalar



la función split convierte un escalar en un arreglo... muy útil para
separar los campos en un registro de un archivo texto



$a = 'a:b:c:d:e';
# no le recuerda esto al /etc/passwd?
@a = split /:/, $a

# @a queda con ('a', 'b', 'c', 'd', 'e')
aqui el segundo parámetro es mas que un string...
es una regex... regex es un cuento largo que se ve mas adelante

@a = ('a'..'e');
$b = shift @a;
# $b queda con 'a'
# @a queda con ('b'..'e');

@a = ('a'..'e');
$b = pop @a;

# $b queda con 'e'
# @a queda con ('a'..'d');

unshift @a, 'a';
# agrega 'a' al principio del arreglo
push @a, 'e';
# agrega 'e' al final del arreglo
unshift y push pueden tambien agregar una lista de elementos
en lugar se un solo elemento



la función shift entrega el 1er elemento del arreglo y ademas le

quita ese elemento al arreglo



la función pop entrega el último y bota el último del arreglo



se puede intuir que hacen las funciones unshift y push...



la función splice permite extraer un subarreglo

y modificar a la vez el arreglo original...



original



mas sobre hashes

para que sea mas claro la asig