El evangelio de Perl

segun cjara, último arreglo: may-2001

tabla de contenido
lo básico...
 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 

lo bueno... aqui se le saca la utilidad...
 paquetes 
 objetos 
 2 clases de métodos 
 el módulo CGI 
 el módulo DBI 
 el módulo LWP 

algo mas... siempre es bueno saber mas...
 mas sobre archivos
 como procesa Perl un programa
 la linea de comando de Perl
 mas sobre contexto
 herencia de objetos

meta-documento...
 que se pretende
 realimentación
 enlaces


lo básico... que es Perl 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 increiblemente mas fácil (y mas corto) que en cualquier otro lenguaje. Perl no tiene esas reglas de los otros lenguajes que nos hacen perder tiempo... en Perl uno no tiene que pensar si la variable es numérica o caracter... no tiene que pensar si el valor cabe en la variable... y por supuesto no hay que compilar... lo que no significa que Perl sea lento... tampoco hay duda de que Perl se aprende rápido... al menos lo básico... es muy facil hacer pequeños programas para aclarar rapidamente las dudas... esta tambien la ventaja de su portabilidad... Perl existe hasta en Windows... es como volver a la época en que todos los computadores tenian Basic... solo que Perl es superior a cualquier lenguaje que yo haya visto... ahora si vamos al grano... variables 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 las variables escalares empiezan por $ $a = 5; $b ="xxx"; $c = $a++; # $a++ es como en C osea $a + 1 note esto sobre las instrucciones: las instrucciones terminan en punto y coma... Perl se confunde muy facil si se olvida el punto y coma note esto sobre comentarios todo lo que este después de # en la misma linea es un comentario note esto sobre escalares: un escalar puede tener números, strings u otras cosas mas complicadas como referencias y descriptores 2. arreglos las variables arreglos empiezan por @ @a = (95, 7, 'fff' ); print $a[2]; # imprime el tercer elemento: fff print @a # imprime: 957fff ...todo pegado note esto sobre arreglos: los elementos de un arreglo son escalares que empiezan por $ los subíndices empiezan por 0 como en C el escalar $a no tiene que ver nada con $a[ ] nota sobre print print es una de las muchas funciones de Perl en Perl hay mucha flexibilidad para escribir los argumentos print ( $a, $b ); # con parentesis print $a, $b; # sin parentesis 3. hashes o arreglos asociativos las variables hash empiezan por % para crear un elemento de un hash se requiere una lista de 2 valores el primer elemento es la clave y el segundo es el valor %a = ( 'x', 5, 'y', 3); # llena 2 elementos del hash print $a{'x'}; # imprime: 5 print $a{'y'}; # imprime: 3 si la clave es un string sencillo se puede omitir las comillas $a{x} es lo mismo que $a{'x'} si se reasigna un elemento se pierde el valor viejo %a = ('x', 5, 'y', 3 ); $a{x}=7; print $a{x}; # imprime: 7 note esto sobre los hashes los elementos se accesan por claves no hay claves duplicadas 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 los strings pueden escribirse con comillas dobles o simples $a = "abcd"; $a = 'abcd'; cuando se usa doble comilla se pueden intercalar variables escalares y arreglos... en el resultado final la variable se substituye por su valor... $a = 'pueblo' print "hola $a"; # imprime: hola pueblo print 'hola $a'; # no hay substitucion en comillas simples... # imprime: hola $a uno se puede preguntar como se substituye una variable entre letras 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 substituir la variable $as "abc${a}s" # substituye correctamente $a entre las comillas dobles se pueden tambien poner caracteres especiales como \n (salto de linea), \t (tabulador), \b (backspace),... print "aaa \n"; # salta linea print 'aaa \n'; # no salta... imprime: aaa \n entre las comillas doble. se tiene que escapar los caracteres que tienen significado especial en Perl... como $, ", \ ... $a = 1234; print "valor=$a\$"; # imprime: valor=1234$ la "escapada" se hace con backslash antes del caracter entre las comillas simples solo se tiene que escapar ' y \ print 'abc\'s'; # imprime: abc's cuando se substituye un arreglo, Perl regala un separador que es un blanco @a = (95, 7, "fff" ); print "val=@a" ; # imprime: val=95 7 fff el separador es realmente el valor de la variable escalar $" ... $" puede ser reasignada $" = ','; print "val=@a"; # imprime: val=95,7,fff 2. las listas p.e. (2, 7, 'sss' ) $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 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') 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" entre las comillas invertidas se pueden intercalar variables escalares... entre las comillas dobles se puede intercalar comillas invertidas asociar un valor con una variable se llama bind... $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... mas sobre arreglos los subíndices positivos recorren los elementos al derecho @a = ('a'..'e'); # $a[0] es 'a' $a[4] es 'e' los subíndices negativos recorren los elementos al revez @a = ('a'..'e'); # $a[-1] es 'e' $a[-5] es 'a' un arreglo en contexto escalar retorna el número de elementos @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 subarreglos: @a = ('a'..'e'); @b = @a[3, 0]; # @b = ('d', 'a'); @c = @a[2-5]; # @a[2,3,4,5] o @a[2..5] es posible colocar una lista de variables escalares a la izquierda del igual ($a, $b ) = @x # $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 @a[3, 0] = @a[0, 3]; # intercambia los elementos 0 y 3 la función join convierte un arreglo en un escalar @a = ('a'..'e'); $a = join ":", @a # $a queda con "a:b:c:d:e"; 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 la función shift entrega el 1er elemento del arreglo y ademas le quita ese elemento al arreglo @a = ('a'..'e'); $b = shift @a; # $b queda con 'a' # @a queda con ('b'..'e'); la función pop entrega el último y bota el último del arreglo @a = ('a'..'e'); $b = pop @a; # $b queda con 'e' # @a queda con ('a'..'d'); se puede intuir que hacen las funciones unshift y push... 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 splice permite extraer un subarreglo y modificar a la vez el arreglo original... @a = ( 'a'..'e'); @b = splice ( @a, 1, 2); # @b queda con 2 elementos de @a: $a[1] y $a[2]; # ( 'b', 'c') # @a queda sin esos 2 elementos: # ( 'a', 'd', 'e' ); splice con un argumento mas sirve para parchar el arreglo original @a = ( 'a'..'e'); @b = ( 1..3); splice ( @a, 2, 1, @b); # @a queda con ('a', 'b', 1, 2, 3, 'd', 'e'); # se cambio 'c' por (1, 2, 3) tambien se puede parchar sin botar nada... @a = ( 'a'..'e'); @b = ( 1..3); splice ( @a, 2, 0, @b); # @a queda con ('a', 'b', 1,2,3, c', 'd', 'e'); mas sobre hashes para que sea mas claro la asignación a un hash se pueden remplazar algunas comas por "=>"... %x = ( 'ope' => 'ver', 'nit' => 890900285 ); asi se ven mejor las parejas clave-valor en cualquier momento se puede agregar un elemento a un hash $a{fac}=3456; la función delete sirve para borrar un elemento delete $a{ope}; la función keys crea un arreglo con las claves de un hash %a = ( x => 5, y => 3, z => 'abc' ); @b = keys %a # @b queda con ( 'x', 'y', 'z'); la función values devuelve un arreglo con los valores del hash %a = ( x => 5, y => 3, z => 'abc' ); @v = values %a # @v queda con ( 5, 3, 'abc' ); la función exists prueba si existe la clave en el hash %a = ( x => 5, y => 3, z => 'abc' ); $b = exists $a{z}; # $b queda con 1 $c = exists $a{w}; # $c queda con "" verdadero y falso como en C, cualquier expresión tiene un significado lógico... p.e. las asignaciones tienen el valor de lo asignado... los valores falsos son: 1. los strings "" y "0" 2. el número 0. 3. el valor "no definido" de una variable... cuando existe la variable pero no tiene valor obviamente todo lo demas valores son verdaderos la funciones defined se usa para averiguar si una variable esta definida $a = 5; print "a definida" if (defined $a); print "b no definida" if (!defined $b); nota sobre ese if: el if escrito al revez parece muy cómodo porque uno se ahorra las llaves en el if normal nunca se pueden omitir las llaves if ( defined $b ) { print "b definido"; } mas adelantente se muestra otra forma de hacer lo mismo que me gusta mas... defined $b and print "b definido"; ojo que la función undef no es lo contrario de defined... lo que hace realmente es volver el argumento "no definido"... elimina el bind entre la variable y el valor... el valor desaparece si su contador de usuarios queda en cero expresiones lógicas una expresión lógica es una expresión cuyo valor es verdadero o falso... usualmente las expresiones lógicas se usan en condiciones... if ( $a and $b ) { print "A y B son verdaderos"; } if ( $a or $b ) { print "A o B son verdaderos"; } existen tambien los operadores && y || como en C... que tiene mas prioridad que and y or... las expresiones logicas tiene otro uso muy interesante usandolas como una istruccion en si misma... $a and $b; # no no... no es un error ! si $a es falso toda la expresión anterior es falsa por lo tanto no se evalúa el elemento $b... si $a es verdadero se tiene que evaluar $b para conocer el valor de la expresión... y eso aunque el valor de la expresión total no se utiliza para nada... $a and print "A es verdadero"; el print solo se hace si $a es verdadero equivale a print "A es verdadero" if $a; el otro caso es $a or $b: $a or print "A es falso"; el print solo se hace si $a es falso equivale a print "A es falso" if ! $a; o tambian a print "A es falso" unless $a; operadores operadores lógicos operadores para comparar números... como en C $a == $b and print "A igual a B"; $a != $b and print "A distinto de B"; $a >= $b and print "A >= B"; para comparar strings se usan otros operadores $a eq $b and print "A igual a B"; $a ne $b and print "A distinto de B"; $a ge $b and print "A >= B"; el siguiente ejemplo muestra porque se necesita distinguir una comparación numérica de una comparación de strings $a=5; $b=49; $x = ($a gt $b) # $x queda 1 ( verdadero) $x = ($a > $b) # $x queda "" ( falso) comparación de números ( starship operator ) $x = $a <=> $b # $x queda con -1 si $a < $b # $x queda con 0 si $a == $b # $x queda con 1 si $a > $b comparación de strings $x = $a cmp $b # $x queda con -1 si $a lt $b # $x queda con 0 si $a eq $b # $x queda con 1 si $a gt $b operador ternario una abreviatura de las 3 partes de algunos if... la condición , la acción para verdadero y la acción para falso... separdos por ? y : @a > 5 ? print "a es > 5": print "a no es > 5"; o $txt = $a > 5 ? "a es > 5" : "a no es > 5"; print $txt; operadores de strings repetir strings con operador "x" $a = "y"; $b = $a x 5 # $b queda con "yyyyy"; concatenar strings con operador "." $a = "abc" $b = $a . "def" ; # $b queda con "abcdef" operador de rango ".." para hacer listas @a = "ay" .. "bb"; # @a queda con ("ay", "az", "ba", "bb") @a = 1..5; # @a queda con (1, 2, 3, 4, 5) ojo no mezcle letras y números ojo no mezcle mayúsculas y minúsculas funciones en Perl se puede definir una función es cualquier parte... la función solo se ejecuta cuando se llama expresamente la función se define con sub sub fun1 { $a = shift; # shift asume el arreglo @_ # @_ es el arreglo que tiene los argumentos # que se dan al llamar la función $y = 2 * $a; return ( $y ); # devuelve ese valor al que llamó la función } la función se llama con & $x = 5; $z = &fun1( $x ); # pasa $x como único elemento de @_ # osea que $z queda con 10 una función que no tiene "return" de todas maneras retorna algo... retorna el valor de la última expresión... esto quiere decir que la función fun1 arriba no necesita el "return" no es obligación que el llamador utilice el valor del return... como en C... los parámetros de una función se pasan por referencia... osea que si se modifica $_[1] se alteraria el 2do parámetro usado en la expresión llamadora... algo peligroso sub fun1 { $_[0]=7; # altera el 1er parámetro en el llamador } $a = 5; &fun1($a); print $a; # imprime: 7 bloques un bloque son expresiones dentro de llaves las funciones que vimos son bloques pero tambien puede haber bloques sin la palabra sub... una de las razones para tener bloques es tener variables locales que desaparecen cuando el bloque termina... $a = 5; # variable global que nunca muere { $b = 7; # variable global que nunca muere my ( $c ) = 3; # "my" crea una variable local # que solo existe en este bloque &fun1 () # $c no es visible dentro de fun1 } print $a; # imprime: 5 print $b; # imprime: 7 print $c; # error... variable no existe sub fun1 { print $a; # imprime: 5 print $b; # imprime: 7 print $c; # error... variable no existe } la función my es la mas utilizada para definir variables locales... las variables "my" o lexicas son visibles solo dentro del bloque... no son visibles fuera del bloque... tampoco son visibles a las funciones que se llaman desde el bloque... la función local se usa para definir otras variables locales ... estas variables tapan provisionalmente las variables globales... estas variables si son visibles a las funciones que se llamen desde el bloque... $a = 5; # variable global que nunca muere { local ( $a ) = 3; # el viejo valor 5 se guarda provisionalmente # para reponerlo cuando este bloque termine local ( $b ) = 7; # como $b no existia entonces # se guarda "no definido" provisionalmente # para recordarlo cuando este bloque termine &fun1 (); # en fun1 se puede usar $a y $b } print $a; # imprime: 5 print $b; # error... variable "no definida" sub fun1 { print $a; # imprime: 3 print $b; # imprime: 7 } mas funciones integradas funciones de strings chop ($a); bota el último caracter del valor de $a $a = "abcdef"; chop ( $a ) ; # $a queda con "abcde"; muy usado para quitar el caracter "\n" al final de una linea de un archivo texto length ( $a) devuelve la longitud del valor de $a $a = "abcdf"; print length ( $a ); # imprime: 5 index ( $a , $x ); devuelve la posición de $x en $a $a = "abcdef"; $b = index ( $a, "cd" ); print $b; # imprime: 2 uc ( $a ); devuelve los caracteres de $a en mayusculas lc ( $a ); devuelve los caracteres de $a en minusculas substr ( $a, $pos, $len ); extrae un string de otro el 2do parámetro es la posición para empezar el 3er parámetro es la longitud $a = "abcdef"; print substr ($a, 2, 3); # imprime: cde interesante uso de substr al lado izquierdo de una asignación $a = "abcdef"; substr ( $a, 2, 3 ) = "xy"; # cambia "cde" por "xy" print $a # imprime: abxyf funciones de arreglos @b = map expresion, arreglo devuelve un arreglo después de applicar la expresion a cada elemento del arreglo... en la expresion "cada elemento" es $_ @a = ('ax'..'bc' ); @b = map uc($_) , @a ; print "@b"; # imprime: AX AY AZ BA BB BC @b = grep expresion, arreglo devuelve un subarreglo de @a... que contiene los elementos donde la expresión es verdadera... @a = ("a1", "a2", "b1", "b2", "c1", "c2"); @b = grep /^b/, @a; print "@b"; # imprime: b1 b2 ... los que empiezan por 'b' el arreglo que devuelve grep se puede tambien usar como un valor lógico... falso si ningun elemento del arreglo cumple la condición... @b = sort ( @a ) devuelve un arreglo ordenado ojo que el ordenado es @b... @a sigue desordenado... claro que se puede escribir impunemente: @a = sort @a @b = reverse ( @a ) devuelve un arreglo invertido @b = reverse sort @a # @b queda con @a ordenado descendente funciones de hash @b = each ( %a ); @b es una lista de 2 elementos ($key, $value)... correspondiente a un elemento del hash %a... cuando se llama varias veces con el mismo hash itera sobre todos los elementos del hash... while ( ($k, $v ) = each ( %a ) ) { print ( "key=$k val=$v \n"); } ... aunque yo prefiero hacer lo anterior asi: foreach ( keys %a ) { print ( "key=$_ val=$a{$_} \n"); } foreach trabaja sobre un arreglo... recorre el bloque por cada elemento del arreglo... $_ es cada elemento del arreglo... tambien es posible usar foreach con otra variable distinta de $_ foreach $k ( keys %a ) { print ( "key=$k val=$a{$k} \n"); } enunciados un "if" mas completo... observe el elsif... el elsif ahorra parentesis y ahorra indentaciones if ( /^[1..3]/ ) { print "$_ es cta de balance\n"; } elsif ( /^[4..7]/ ) { print "$_ es cta de resultado\n"; } else { print "$_ es cta de orden\n"; } # las condiciones arriba son "expresiónes regulares"... # uno de los temas mas facinates de Perl... que veremos # mas adelante nuevamente el foreach... @a = (1..5); foreach ( @a ) { $_ == 3 and $_ = "x"; } print "@a"; # imprime: 1 2 x 4 5 ojo que $_ es un alias temporal de cada elemento del arreglo ... osea que si se modifica $_ se altera el arreglo... pero tambien $_ es variable tipo "my" que no afecta ningun $_ global... ni es visible en subrutinas que se llamen desde dentro del foreach... palabras de salto last: salta fuera del bloque actual next: omite las instrucciones que siguen en el bloque y comienza una nueva iteración redo: reinicia el bloque un while mas complicado...observe el bloque "continue" while ( /^\d/ ) { /^47/ and next; print "empieza por digito\n"; } continue { # el codigo entre estos corchetes se hace antes antes # de repetir la condición del while... # aun si se ejecuta el next de arriba <f1>; # esto lea un registro de un archivo f1 } referencias las referencias son escalares que apuntan al valor de otra variable... "apuntan a" significa "tiene la dirección de"... $ra = \$a; # referencia a escalar $rb = \@b; # referencia a arreglo $rc = \%c; # referencia a hash $rx = \$rb; # referencia a referencia tambien hay referencias a función y referencias a objetos... las referencias interesantes son a arreglos y a hashes... veamos otra forma de crear una referencias a arreglo... observe el parentesis cuadrado $rb = [ 'e1', 'e2', 'e3']; aqui el arrray no tiene nombre... $rb es una referencia a un arreglo anónimo... otra forma de crear una referencia a hash... observe las llaves $rc = { k1 => 'v1', k2 => 'v2' }; aqui el hash no tiene nombre... $rc es una referencia a un hash anónimo... cuando una referencia es dereferenciada se obtiene el dato real $ra = \$a; # referencia a escalar $rb = \@b; # referencia a arreglo $rc = \%c; # referencia a hash $rx = \$rb; # referencia a referencia ${$ra} es la desreferencia de $ra... el valor de $a @{$rb} es la desreferencia de $rb... el valor de @a @{$ra} es un error porque $ra apunta a un escalar %{$rc} es la desreferencia de $rc... el valor de %c veamos una manera de accesar los elementos de un hash usando una referencia... muy útil si el hash es anónimo... $rc = { a => 1, b => 2 }; # $rc es una referencias a un hash anónimo print $rc->{a}; # imprime: 1 si ud es nuevo en referencias asegurese que entendio bien lo anterior... se lo digo por experiencia la función ref devuelve un string que indica el tipo del referenciado $ra = \$a; # referencia a escalar $rb = \@b; # referencia a arreglo $rc = \%c; # referencia a hash $rx = \$rb; # referencia a referencia $rf = \&f; # referencia a función ref ( $ra ); # devuelve "SCALAR" ref ( $rb ); # devuelve "ARRAY" ref ( $rc ); # devuelve "HASH" ref ( $rx ); # devuelve "REF" ref ( $rf ); # devuelve "CODE" si el operando de ref no es una referencia, ref devuelve falso "no definido" la función bless cambia el tipo de una referencia a otro tipo... muy utilizado para crear clases $rc = { ano => 1995, marca => 'renault', puertas => 4 }; ref ( $rc ); # devuelve "HASH" bless $rc "CARRO"; ref ( $rc ); # devuelve "CARRO" # esto tiene mas sentido cuando se hable de objetos y paquetes... diferencia entre trabajar con variables y trabajar con referencias... $a = 5; $b = $a; # $b recibe una copia del valor de $a $a = 7; # cambio el valor de $a print "$a $b\n"; # imprime: 7 5 # un cambio en $a no afecta a $b $a = 5; $ra = \$a; $rb = $ra; $a = 7; # cambio el valor de $a print "$a $$ra $$rb \n" ; # imprime 7 7 7 # las referencias si comparten en mismo valor... # el valor 7 aqui tiene 3 usuarios... las referencias a arreglos son muy útiles cuando se guardan en un arreglo porque ese arreglo simula un arreglo de n dimensiones... @x1 = ( 5, 6, 7 ); @x2 = ( 2, 3, 4 ); @x = ( \@x1, \@x2 ); en este caso el arreglo @x quedan como de 2 dimensiones... $x[0]->[0] es 5 $x[1]->[2] es 4 y como Perl lo hicieron programadores para programadores $x[0]->[0] se puede escribir $x[0][0] $x[1]->[2] se puede escribir $x[1][2] especulación: @x sería como un arreglo de 3 dimensiones si @x1 y @x2 fueran a su vez arreglos de referencias a arreglos... se perdio? no se complique la vida... en Perl no es tan necesario pensar en subíndices como en otros lenguajes.... archivos abrir archivos... open f1, "auxytd.98.3"; abre un archivo de lectura... el archivo se maneja con el descriptor f1 ... f1 es como el descriptor de c... otras formas de open... open f1, "< auxytd.98.3"; # abrir para leer... # el < se puede omitir... open f1, "> auxytd.98.3"; # abrir para escribir open f1, ">> auxytd.98.3"; # abrir para agregar leer un archivo texto... archivos donde cada linea termina en "\n" el operador diamante "<>" lee una linea del archivo open f1, "archivo.98"; while ( <f1> ) { print; } aqui <f1> llena $_ con una linea del archivo... que posteriormente se imprime con print... en Perl casi todo el mundo asume $_ ... en realidad <f1> en contexto escalar leen una linea... y en contexto lista lee todo el archivo... open f1, "auxytd.98.3"; @a = <f1>; # @a tiene todo el archivo # cada elemento de @a es una linea del archivo escribir en un archivo con print print descriptor @lista ojo que no hay coma entre descriptor y @lista si no hay descriptor se asume STDOUT si no hay @lista se asume $_ regex regex es una abreviatura de expresión regular una expresión regular es una forma general de describir un patron de caracteres que queremos buscar en un string... usualmente el patron se escribe entre slashes las regex se utilizan en 2 clases de expresiones 1. match del patron en un string... aqui la regex es una expresión lógica... devuelve verdad si el string contiene un patron $a = "abcdef"; $a =~ /bc/; # es verdadero $a =~ /ba/; # es falso "=~" se llama el operador de bind... "!~" es la negación de la expresión $a = "abcdef"; $a !~ /bc/; # es falso $a !~ /ba/; # es verdadero 2. substitución... s/// muy útil para remendar strings... $a = "<option>mod"; $a =~ s/>/ selected>/ print $a; # imprime: <option selected>mod cuando el escalar es $_ se omite $_ y =~... $_ = "abcdef"; /bc/; # es verdadero s/cd//; print; # imprime: abef cuantificadores se usan para indicar que algunas letras se repiten * : cero o mas del anterior caracter + : uno o mas del anterior caracter ? : cero o un del anterior caracter {3,5} : minimo 3 y maximo 5 del caracter anterior {3,} : minimo 3 del caracter anterior {,5} : maximo 5 del caracter anterior $_ = "abcccd"; /c+d/ ; # es verdadero puntos de referencia ^ : es el comienzo del string $ : es el final del string \b : es un borde de una palabra [palabras son letras números y _ ] $_ = "abcdef"; /^abc/; # es verdadero clases de caracteres comunes . : un caracter cualquiera \s : un epacio en blanco , tabulador o salto de linea \S : un caracter no blanco, no tabulador y no salto de linea \d : un digito \D : un no digito \w : un caracter de palabra: digito letra o _ \W : un caracter que no es de palabra $_ = "d15"; /\d+$/ ; # es verdadero clases de caracteres a la medida [abcef] : uno de esas 5 letras [a-f] : lo mismo que el anterior [0-9] : es lo mismo que \d [\t \n] : es lo mismo que \s [a-zA-Z_] : es lo mismo que \w [^a-zA-Z_]: es lo mismo que \W ... aqui ^ significa negación @a = ( 1..10); foreach ( @a ) { /^[1-3]/ and print "$_:"; } # imprime: 1:2:3:10: caracteres especiales \. : punto \\ : backslash \n : salto de linea \t : tabulador \$ : signo pesos mas sobre regex memoria de matchs... los parentesis se usan para almacenar los matchs en las variables $1, $2, $3, hasta $9... $_ = "1995 renault azul"; s/^(\w+)\s+(\w+)/$2 $1/; print $a; # imprime: renault 1995 azul print $1; # imprime: 1995 tambien es posible sacar los matchs a un arreglo $_ = "1995 renault azul"; @a = /^(\w+)\s+(\w+)/; print "@a"; # imprime: 1995 renault como si ya no fuera bastante, las regex tienen tambien opciones... /g : indica que haga varios "match" $_ = "f1=abc test=on"; s/=/ / ; # $_ queda con "f1 abc test=on" $_ = "f1=abc test=on"; s/=/ /g ; # $_ queda con "f1 abc test on" $_ = "1995 renault azul"; @a = /^(\w+)/g; # @a queda con 3 elementos claro que el split me parece mejor... @a = split; # la regex default de split es / +/ /i : ignore mayusculas y minusculas $_ = "Francisco francisco"; s/francisco/pacho/ig; # $_ queda con "pacho pacho" s///e : ejecuta la segunda expresión y su valor lo utiliza para remplazar el patron... $_ = "largo= 15"; s/(\d+)/$1 * 4/e; print; # imprime: largo= 60 el operador tr se usa para traducir caracteres... tiene un parecido con la substitución en regex $a = "f1=abc test=on"; tr/=/ / ; # $a queda "f1 abc test on" %x = split / /, $a; # $x{f1} queda con "abc" # $x{test} queda con "on"; variables especiales Perl tiene toda su maquinaria a la vista en unas variables especiales... variables que afectan arreglos $[ es el subscrito base de los arreglos [default es 0] $" el separador de elementos cuando se substituye un arreglo en un string de comilla doble [default es espacio] variables utilizadas en archivos $. contiene el último número de linea leido $/ terminación de registro de entrada [ default es '\n' ] $| si es diferente de cero se vacea el buffer de salida después de print o write (default es 0 ) se debe colocar en 1 para hablar con un puerto de tcp/ip... variables usadas con patrones $& contiene el último string que hizo match $+ contiene el string que coincidio con el último parentesis que hizo match $1, $2, $3... memoria de lo matches de los parentesis variables usadas en impresion $\ se agrega al final del print ( default nulo ) variables relacionadas con procesos $0 el nombre del script de Perl $! número de error o string con el texto del error %ENV hash que tiene las variables de ambiente del programa p.e. $ENV { QUERY_STRING ) que lo llena el apache antes de llamar un cgi-bin... tiene lo que va después de la ? en el URL del Netscape variables diversas $_ parámetro default de muchas funciones es como el "que" del español... @ARGV argumentos de la linea de comando... es como dar split / +/ a la linea de comando
lo bueno... paquetes un paquete es un espacio de nombres... los espacios de nombrs permiten que nosotros utilicemos codigo de otras personas sin que las variables de nosotros se confundan con las variables de la otra persona package C110; # estamos en el espacio de nombres C110 $a = 5; # variable del paquete C110 fun1 # función del paquete C110 { print "$a\n"; } package D110; # ahora estamos en el espacio de nombres D110 # ...salimos del paquete C110 $a = 7; # esta $a es del paquete D110 print $a; # imprime 7 print $C110::a; # imprime 5 # note como accesamos el espacio de nombres C110... # note el $ y los :: C110::fun1; # llama a fun1 de C110...imprime: 5 fun1 C110; # llama a fun1 de C110...imprime: 5 C110->fun1; # llama a fun1 de C110...imprime: 5 observe las 3 formas de llamar la función... cuando no usamos "package" estamos trabajando en el espacio de nombres "main"... como un paquete generalmente se hace para ser reutilizado muchas veces... se guarda en un archivo libreria de extension .pl como p.e. cgilib.pl... y los programas que lo quieren usar lo invocan con requiere requiere "cgilib.pl"; la función "requiere" lee el archivo "cgilib.pl" si este no ha sido leido antes... el archivo no tiene que tener "package" pero si debe devolver verdadero... osea que lo mejor es que termine con: return 1 las librerias ya no se usan tanto... porque llego la moda de los objetos que en Perl se implementan con módulos... ojo... parámetro adicional que reciben las funciones de un paquete. package C110; sub fun2 { print "fun2 recibio @_\n"; } package D110; C110::fun2("xyz"); # llama a fun2...imprime: fun2 recibio xyz esta forma de llamar funiones de paquete no se utiliza usualmente porque, como veremos enseguida, las funciones de paquete se escriben para recibir un parámetro adicional... C110->fun2("xyz"); # llama a fun2...imprime: fun2 recibio C110 xyz fun2 C110("xyz"); # equivalente al anterior... C110->fun2 ("xyz") observe que cuando se llama con C110->fun2, fun2 recibe un parámetro adicional...el nombre del paquete... "C110"... mas adelante veremos otra forma mas de llamar fun2... $r->fun2()... donde $r es una referencia a un objeto C110... en este caso el parámetro adicional que recibe fun2 es la referencia $r... un módulo es un paquete en un archivo de su mismo nombre y extension .pm... los nombres de los módulos empiezan por mayuscula... p.e. el módulo CARRO debe estar en el archivo CARRO.pm para utilizar un módulo en un programa se utiliza use la función "use" es como un "requiere" pero que ademas ejecuta una función del módulo llamada import... que vamos a ignorar por ahora... en seguida veremos como los módulos se utilizan pra representar objetos... objetos una clase es una abstracción de un objeto... por ejemplo la clase CARRO... una clase esta compuesta de propiedades y métodos que para nosotros corresponden muy bien a variables y funciones... es bueno distinguir la clase CARRO y un objeto de la clase CARRO... la clase carro podría tener la propiedad velocidad y la función acelerar para aumentar la velocidad... un carro epecifico podría tener velocidad=50 y llamar la función acelerar(7) para que cambie a velocidad=57; los módulos se utilizan para representar clases porque los paquetes aislan muy bien las variables y las funciones... tal como se desea con la moda de los objetos...lo que se llama "encapsulamiento"... el ejemplo que sigue utiliza 2 archivos 1. archivo CARRO.pm... para representar la clase CARRO package CARRO; # la clase CARRO tiene 3 métodos... # o el módulo CARRO tiene 3 funciones: # 1. new: crea objetos tipo CARRO # 2. acelarar : cambia la velocidad de un objeto CARRO # 3. status : muestra la velocidad de un objeto CARRO # el módulo CARRO tiene una variable # 1. vel: la velocidad del carro sub new # "new" es el nombre preferido para crear # instancias de una clase... un recuerdo de c++ { my ( $rc ); $rc = { vel => 0 }; # un hash es lo mas recomendado para representar # un objeco... recuerde que las llaves crean una # referencia a un hash anónimo bless $rc , "CARRO" # recuerde bless de referencias # $rc ahora es una referencia a un objeto tipo # "CARRO" return $rc; # devuelve una referencia tipo "CARRO"... # después de esto $rc muere... pero el hash # anónimo no muere si el llamador utiliza el # valor del return... } # si la función new es llamada de nuevo devuelve # tambien una referencia "CARRO"... pero a un carro # distinto sub acelerar { my ( $rc ) = shift; # el 1er shift entrega el parámetro adicional que # Perl antepone a los parametros que uso llamador... # en este caso la referencia con que nosotros llamamos # la función en el 2do archivo... $rc->{vel} += shift; # el 2do shift entrega el parámetro # con que nosotros llamamos la función en el 2do # archivo } sub status { my ( $rc ) = shift; print "velocidad=$rc->{vel}\n"; } return 1; # para que no falle el "use"... 2. archivo pd0010.pl... que utiliza el módulo CARRO #!/usr/bin/perl -w # ojo la anterior linea no es comentario # el -w es un parámetro de Perl... para que de buenos # warnings use CARRO; # como no usamos package... estamos en el package "main" $x = new CARRO; # lo mismo que CARRO->new(); # $x queda con una referencia a un tipo "CARRO"... $y = new CARRO; # $y es otro CARRO distinto $x->status; # otra forma de llamar una función del paquete "CARRO"... # ...con una referencia tipo "CARRO"... # imprime: velocidad=0 $x->acelerar(50); # el primer parámetro que "acelerar" recibe es $x # el segundo parámetro que "acelerar" recibe es 50 $x->status; # imprime: velocidad=50 $y->status; # imprime: velocidad=0 en este ejemplo vemos como el módulo CARRO representa la clase CARRO... y usando new de la clase CARRO creamos 2 objetos tipo CARRO: $x y $y ... podemos complicar un poco la función new de CARRO.pm para que reciba parámetros... pero hay que anotar que Perl le pone un parámetro adicional... en este caso el string "CARRO"...que por ahora no lo necesitamos... sub new { my ( $class ) = shift; # si new se llama como CARRO->new, $class queda # con "CARRO"... aparentemente esto no es # ninguna informacion... pero se vuelve muy útil # cuando se trabaja con objetos "heredados" de # CARRO... herencia es otro de los conceptos # modernos de objetos my ( $vel, $marca ) = @_; my $rc = { vel => $vel, marca => $marca }; bless $rc, $class; } y el archivo pd0010.pl sería... #!/usr/bin/perl -w use CARRO; $x = CARRO->new (50, "renault"); $y = CARRO->new (70, "mazda"); $x->status; # imprime: velocidad=50 $y->status; # imprime: velocidad=70 2 clases de métodos observe bien las 2 formas de llamar métodos de una clase... 1. CARRO->new(50, "renault") o new CARRO (50, "renault") aqui el método "new" recibe 3 parámetros: "CARRO", 50, "renault" 2. $x->acelerar(7); aqui el método "acelarar" recibe 2 parámetro: $x, 7 donde $x es una referencia a un objeto "CARRO" cualquier método se puede llamarse de las 2 maneras... aunque lo usual es que un método se llame con una de las 2 formas 1. cuando el método se llama como CARRO->new se dice que es un método de clase... osea que no esta asociada a un objeto especifico... aqui "new" es un método de clase 2. cuando el método se llama como $x->acelarar se dice que es un método de instancia... osea que esta asociada a un objeto... aqui "acelarar" es un método de instancia tambien existen variables de clase y variables de instancia... el módulo CGI este módulo se usa para leer los campos de una forma enviada desde el Netscape a nuestro programa Perl... a travez de un servidor http como el Apache # programa vt6100.pl use CGI; $q = new CGI; # $q es una referencia tipo CGI... # o mas simplemente un objeto CGI $nom = $q->param ('nom'); $art = $q->param ('art'); $can = $q->param ('can'); # param es una función de CGI que nos da el valor de un # campo de la forma... 'nom' 'art' 'can' son nombres # de campos de la forma en una página html que muy # posiblemente salio de nuestro servidor http # el pgma continúa revisando el pedido, aceptándolo si esta ok # y finalmente, dándole al cliente (con print por supuesto) # una respuesta adecuada... la historia completa es esta: un cliente pide nuestra forma de pedidos... digamos vt6100.html... vt6100.html es algo como esto: <h1>pedido</h1> <form method=post action=http://epq.com.co/cgi-bin/vt6100.pl> <p>nombre <input name=nom size=30> <p>codigo del articulo <input name=art size=8> <p>cantidad<input name=can size=10> <p><input type=submit value=enviar> </form> una vez que el cliente llena la forma y da click en "enviar" el Netscape del ciente envia los campos de la forma al servidor... el servidor ejecuta el programa vt6100.pl (el programa Perl que se habló arriba) y le pasa los campos de la forma... el programa vt6000.pl lee los campos de la forma usando el módulo CGI como se explicó arriba el módulo DBI este módulo se usa para accesar una base de datos como ORACLE... bueno hay otro módulo involucrado, DBD::Oracle, pero eso es invisible... ejemplo de una operación de consulta use DBI; use CGI; $qry = new CGI; $dbh = DBI->connect('dbi:Oracle:', 'useru', 'clave' ); # $dbh es un objeto de una clase $sth = $dbh->prepare ("select codemp, nomemp, vinemp from emp where ciaemp=?"); # esto hace que Oracle compile el "select"... # $sth es un objeto de otra clase $cia = $qry->param ( "cia"); # lea $cia de la forma del cliente $sth->execute ( $cia ) ; # esto crea el cursor while ( ($cod, $nom, $vin ) = $sth->fetchrow_array ) # aqui se lee el cursor { printf "%5s %30s %3s", $cod, $nom, $vin ; } $sth->finish; # esto cierra el cursor... # parece que no es muy necesario... yo ya no los uso ejemplo de una operación de actualización use DBI; $dbh = DBI->connect('dbi:Oracle:', 'usuario', 'clave' ); $sth = $dbh->prepare ("delete from emp where ciaemp=?"); $sth->execute ( $cia ) ; $dbh->commmit; el prepare y execute se pueden hacer simultaneamente con do... pero "prepare" permite utilizar "placeholders" (las interrogaciones) que se llenan en el "execute"... información sobre el resultado de un prepare o execute $DBI::err # número del error... análogo al sqlcode... # es falso (no definido) si no hay error $DBI::errstr # texto del error # es falso (no definido) si no hay error información que se puede obtener después del execute $DBI::rows # nro de filas afectadas... puede ser 0 # no sirve en SELECT información que se puede obtener después del execute de un select $sth->{NAME} # referencia al arreglo de los nombres de la columnas # se puede usar aunque no se seleccione ninguna fila $sth->{TYPE} # referencia al arreglo de los tipos de los campos $sth->{SCALE} # referencia al arreglo de longitudes de los campos el módulo LWP este módulo se usa para accesar servicios de internet como poner correo o leer una página... por supuesto que sin usar el Netscape el módulo LWP maneja varios objetos: LWP::UserAgent : el que se conecta al servidor HTTP::Request : lo que se pide al servidor HTTP::Response : lo que se recibe del servidor ejemplo para enviar correo: use LWP; # 1. crear un agente ( user-agent ) $wuag = new LWP::UserAgent; # 2. crear una peticion ( request ) $wreq = new HTTP::Request ( POST => 'mailto:cjara@epq.com.co' ); # 3. llenar el encabezado (header) de la peticion $wreq->header ( Subject => 'prueba de LWP' , From => 'alguien' ); # 4. llenar el contenido de la peticion $wreq->content ( "me gusta este tutorial"); # 5. enviar la peticion con el agente # y obtener una respuesta " $wres = $wuag->request ( $wreq ); # 6. examinar la respuesta $wres->is_success ? print "exito \n": print "error \n";
algo mas... mas sobre achivos pipes... open f1, "ps -xlw |"; # ejecutar el comando ps -xlw para leer su respuesta # usando el descriptor f1 while ( <f1> ) { /httpd/ and print; # selecciona los demonios de httpd } el operador diamante sin descriptor, osea <>, tiene un significado especial... lee los archivos que se escribieron en la linea de comando donde se ejecuto el programa Perl... cuando se termina un archivo empata con el siguiente... es bueno aclarar que Perl coloca los argumentos que se dieron en la linea de comando en el arreglo @ARGV... si @ARGV no existe, "<>" lee del STDIN... o por supuesto el archivo después del "<" en la linea de comando... osea la redirección del STDIN... como todo se puede en Perl... @ARGV puede ser alterado dentro del programa... @ARGV = ( "auxytd.98.3"); @a = <>; # @a tiene todo el archivo la función read para leer archivos binarios... osea archivos que no tienen lineas terminadas en "\n" open FX, "auxytd.bin" ; read FX, $buffer, 100; # lee hasta 100 bytes # retorna el numero de bytes leídos realmente la función select cambia el descriptor default de print y write y devuelve el viejo descriptor open ( F2, ">abc.dou"); $old = select ( F2 ); # $old contiene a STDOUT print "abcdef"; # imprime en el archivo "abc.dou" select ( $old ); # todo regresa a la normalidad el desriptor DATA se refiere a todo los que tiene el archivo del programa después de la linea __END__ ... antes de la linea __END__ esta el programa Perl... por supuesto que la linea __END__ es opcional... Perl tambien tiene los here documents de los shell de Unix... los here documents se utilizan cuando se requiere un string de muchas lineas... $x = << "ETX"; linea 1 linea 2 ETX $x queda con: linea 1\nlinea2\n ETX es cualquier palabra... $x queda con todas las lineas antes de la linea que tiene solo la palabra ETX... osea que si no se coloca ETX en una linea $x se traga todo el resto del archivo... ojo! no olvide el ";" después de "ETX" en la primera linea... como se procesa un programa Perl Perl procesa el programa en varias fases: 1. examina la linea #!/usr/bin/perl... buscando suiches... este paso lo hace el shell de Unix pero en W95/NT lo hace el Perl 2. ejecución previa... un recuerdo de awk... subrutinas BEGIN... funciones "use" para cargar módulos recuerde que los módulos empiezan por mayuscula... esta ejecución tenprana de "use" es otra diferencia con "requiere" ... requiere se ejecuta en la fase 4 funciones "use" para dar directivas al compilador en este caso la palabra que sigue a use empieza por minuscula... use integer; # indica al compilador que solo queremos enteros no integer; # indica al compilador que queremos números decimales 3. compilación... se habia dicho que Perl no necesita compilar... esta es una compilación a un codigo intermedio no a codigo de maquina... cancela si hay errores de sintaxis... 4. ejecución carnuda... ejecuta el codigo intermedio... hasta encontrar exit ... o hasta que se acabe el archivo... o hasta que encuentre una linea con __END__ 5. ejecución final...otro recuerdo de awk... subrutinas END... empezando por el último que se cargo en las subrutinas BEGIN y END se puede omitir sub BEGIN { print "esto se escribe en la fase 2\n"; print "aunque el programa tenga errores de sintaxis\n" } END { print "esto se escribe en la fase 5\n"; print "después que el programa termina \n" } print "esto se escribe en la fase 4 \n""; la linea de comando de Perl Perl se puede ejecutar con muchos suiches... algunos de estos suiches tambien se pueden colocar en la linea "shebang" del programa... la que empieza por #!... la primera linea del shell podría ser #!/usr/bin/perl -w la linea de conmando de Perl puede ser perl -v # da la version de Perl perl -V # muestra información sobre como se compilo el Perl... # al final muestra @INC que es otra e las variables especiales # de Perl # @INC tiene los directorios donde Perl busca los módulos # y las librerias que se invocan con "use" y "requiere" perl -w pd0010.pl # muestra warnings... muy útil... perl -d pd0010.pl # puede correr el programa en camara lenta... # ejecuta el programa bajo el Perl degugger perl -e '....' # ejecuta las instrucciones entre comillas # observe que no hay archivo de programa perl -e '@a=(1..5); print "@a \n"' # imprime: 1 2 3 4 5 el parámetro -e acompa#ado de otros parámetros se vuelve mas útil perl -n -e 's/pacho/francisco/; print' abc.txt esto equivale al siguiente programa while ( <> ) { s/pacho/francisco/; print; } donde <> toma archivos de @ARGV... en este caso ("abc.txt") ... recuerde el operador diamante cambiando -n por -p nos ahorramos escribir el print perl -p -e 's/pacho/francisco/' abc.txt esto eqivale al mismo programa while ( <> ) { s/pacho/francisco/; print; } agregando -i podemos modificar el archivo abc.txt perl -i.old -p -e 's/pacho/francisco/' abc.txt remienda abc.txt y deja el archivo viejo como abc.txt.old mas sobre contexto la función wantarray usada dentro de una subrutina devuelve 1 si el llamador de la subrutina desea un "contexto lista"... sub fun { wantarray ? (1..5): 7; } $a = fun; # $a queda con 7 @a = fun; # @a queda con (1..5) herencia de objetos la herencia es un concepto muy importante en la teoria de objetos... se supone que uno debe hacer un objeto complicado heredando de otros objetos mas simples... p.e. si alguien ha creado ya la clase VEHICULO uno podría empezar la clase CARRO diciendo que se deriva de VEHICULO... osea que las propiedades y métodos de VEHICULO se aprovechan para definir la clase CARRO... o tambien que CARRO hereda de VEHICULO... es una herencia espiritual... varias clases pueden heredar de VEHICULO... el arreglo @ISA le indica a Perl que si se invoca un método que no esta en el paquete lo puede buscar tambien en los paquetes mencionados en el arreglo @ISA... el ejemplo que sigue tiene 3 archivos. 1. archivo VEHICULO.pm package VEHICULO; sub funp1 { print "funp1 recibe @_"; } return 1; 2. archivo CARRO.pm package CARRO; @ISA = ( VEHICULO ); sub func1 { $x = funp1 ( "xxx") ; # gracias a @ISA se invoca VEHICULO->funp1 } return 1; 3. archivo pd0010.pl use CARRO; package main; CARRO->func1 (xxx) ; # imprime: funp1 recibe CARRO xxx # aqui podemos decir que CARRO hereda de VEHICULO... # o que CARRO se deriva de VEHICULO # los archivos 1 y 2 deben colocarse en alguno de los # directorios de @INC... o podemos poner un bloque BEGIN que # agregue nuestro directorio a @INC... recuerde perl -V BEGIN { unshift @INC, "/appl/pd"; } @ISA tiene un miembro automático llamado UNIVERSAL... todo los módulo heredan automaticamente del módulo UNIVERAL... si CARRO invoca un método que no esta en CARRO ni en VEHICULO se busca en el paquete UNIVERSAL... y si el método todavía no se encuentra se busca un método comodín llamado AUTOLOAD... primero en CARRO... luego en VEHICULO... y finalmente en UNIVERSAL...
meta-documento que se pretende la idea de este documento es divulgar Perl... Perl es demasiado interesante como para que uno se quede callado... son pocas las cosas bonitas, útiles y gratis que uno se encuentra en la vida yo le quité el miedo a Perl leyendo el tutorial en ingles de Robert Pepper... espero que este tutorial haga lo mismo con pesonas que les gusta leer en español me gustaria que el documento fuera interesante a gente que trabaja con CGIs... las páginas dinámicas de internet/intranet... y a la gente que trabaja con Oracle... creo que la combinación de Perl, Apache y Oracle es insuperable... el usuario tiene su GUI y nosotros un ambiente para resolver los problemas del usuario... no los problemas de Bill Gates... recientemente alguien se me quejó de que mencionara Oracle en lugar de software GNU como postgreSQL o mysql... he probado perl con mysql y es muy rapido... solo que extraño la comodidad del "commit" de Oracle que yo coloco al final del programa y que permite que el programa aborte en cualquier parte sin afectar la base de datos realimentación envíeme su comentario o su crítica... mi e-mail es cjara@epq.com.co enlaces tutorial de Robert Pepper no no... el evangelio no es una traducción ActiveState para los que no pueden vivir sin Microsoft :-( www.perl.com módulos y muchas cosas mas... CPAN la mina de oro de perl... los módulos de perl