martes, 17 de agosto de 2010

TUTORIAL DE PERL

¿Que significa perl?
practical extraction report languaje

¿En que año y quien es su creador?
1987-larry wall

¿Cual es el proposito de perl?
Extraer informes de ficheros de texto y utilizar dicha informacion para p'reparar informes.

¿De cuales programas se baso larry wall para crearlo?
c++,awk,shell y sitema unix simplificado.

¿Cuales son las principales actividades de perl?
Administracion de sistemas, desarrolo de web, programacion en red y desarrollo guiy era muy utilizado ya que no tenia limitaciones con otros lenguajes de script.

¿Cuantas clases de perl hay?
1987- se dio la primera version perl 1.0 se expande facilmente
perl 2.0 -1988 aporto un mejor motor de expresiones regulares
perl3.0 publicado en 1989 añdio un mejor soporte para numeros binarios
perl 4.0 1991 se identifica con el libro.
el libro del dromediario que era una documentacion simple y cada vez mas larga,pagina manual de unix.

perl 5.6 aparece hasta el 17 de diciembre de 1994.popular reescritura y y añadio mas caracteristicas.Se eliminan numeros y errores.Incluye soporte pleno de caracteres internacionales hebreos y mejor compilador.

¿cual es la clase de perl mas completa?
perl 4.0 la mejor la mas conocida ,el del libro del camello 1991-1993 por los
servidores de internet y originalmente administracion de sistemas.

¿Porque perl no es considerado un programa sino un script?
por que hereda interpretes de comando unix especialmente csh,awk y shell.y compite con los programas antes de ejecutarlos.

¿ue extensiones se utilizan para perl?

con apache (mod-perl) y se ejecuta directamente perl desde el servidor de htpp

Que modulos adicionales se utilizan?
dbd o dbc accede abases de datos dede bd, gratuitas como sirve micrisoft mysqly sql.

¿Que requerimientos se deben tener para utilizar perl?
1-Editor de texto para poder escribir los programas realizados en perl.

2-combinacion de caracteristicas de shell y operadores de unix y la sintasis de c++.
awk para formatear y tratamineto de texto e incluso se utiliza las caracteristicas de pascal.

¿Por que perl es tan utilizado?
1- Administracion de sistemas,informacion de ficheros y realizar busquedas.
2-Creacion de formularios en la web script cgi intercambio de informacion al cliente en www mando al servidor atraves de un formulario.

¿Cuales son los lenguajes mas populares en lacreacion de aplicaciones.
phyton,phpy perl.

¿ cuales son los tipos de datos de perl?
ESCALAR:cracter $almacena numeros strings descriptiva.
ARREGLOS:variables array la variable @sirve para agrupar variables de tipo escalar.
HASH:variable detipo array y hash asociativo empiean% lista de valores atraves de la clave por un largo indicey elementos que accedan por claves y no por claves duplicadas.

¿Que nos permite hacer la estructura de control?
permite ejecutar un conjunto de instrucciones cunado se verifica una condicion itinerariamente , un bloque des is instrucciones mientras sea valida .

miércoles, 16 de junio de 2010

martes, 8 de junio de 2010

Perl Tutorial 3 - Variables



BIENVENIDOS A PROGRAMACION PERL

Perl Video Tutorial - Part 1 - Installing ActivePerl 5.8.8



BIENVENIDOS A PROGRAMACION PERL

Análisis de un lenguaje de programación Perl



BIENVENIDOS A PROGRAMACION PERL

tutorial de perl

¿Qué es?
Definiciones básicas de Perl
Perl significa Practical Extraction and Report Language, algo así como lenguaje práctico de extracción y de informes. Es un lenguaje creado por Larry Wall (quien, por
cierto, es uno de los net.gods más conocidos en la actualidad) con el objetivo principal de simplificar las tareas de administración de un sistema UNIX; en realidad hoy
en día (en su versión 5.005, y posiblemente pronto, la 5.6) se ha convertido en un lenguaje de propósito general, y una de las principales herramientas de un buen
internetero y de un buen webmaster.
Larry Wall es el tipo de personas que han hecho de la Internet lo que es ahora: un lugar con libre intercambio de ideas, donde los que saben de algo, los gurus, ayudan al
que no sabe. Larry (larry@wall.org) solía ser un habitual del grupo de usenet comp.lang.perl, y era habitual que el propio Larry contestara a una pregunta de un
principiante o a un error con un parche para solucionarlo. Hoy en día, desgraciadamente, ya no es tan común, porque el esfuerzo de trabajar con la comunidad Perl es tal
que no le deja mucho tiempo.
Perl es un lenguaje que hereda ciertas estructuras de los intérpretes de comandos de UNIX, especialmente el csh, y de otras utilidades estándar, como awk y sed. Aparte
de esto, está diseñado para hacer todo lo que hacen cualquiera de ellos y todos ellos juntos, y la mayoría de las veces de forma más simple, comprensible y fácil de
depurar (aunque algunas veces no muy fácil de entender). Si alguna vez habeis tratado de escribir un script para el shell, sabéis lo que quiero decir.
Perl es un lenguaje interpretado, aunque en realidad, el intérprete de Perl, como todos los intérpretes modernos, compila los programas antes de ejecutarlos. Por eso se
habla de scripts, y no de programas, concepto referido principalmente a programas compilados al lenguaje máquina nativo del ordenador y sistema operativo en el que se
ejecuta.
El mejor libro de referencia sobre el
Perl es Programming Perl, por Larry
Wall y otros (llamado el libro del
camello por razones obvias). Aparte
de la referencia, vienen ejemplos,
reglas de estilo, y es bastante
divertido.
A pesar de que la versión actual del intérprete de Perl es la 5, a veces se puede uno encontrar la versión 4.036, el último patchlevel de la versión 4 y probablemente el
más estable. Actualmente, en enero del 2003, la versión estable es la 5.8, con una nueva versión 6 en desarrollo que va a ser la caña de España, pero que todavía se hará
de esperar un cierto tiempo. La versión 5 es prácticamente compatible 100% con la 4; virtualmente todos los scripts que funcionan para la versión 4 lo hacen también en
la 5. La mayor parte de los scripts presentados en este tutorial están desarrollados para la versión 4 (porque las primeras versiones de este tutorial son del año 94), pero
deberían de funcionar, en principio, para la versión 5 o cualquier otra versión. Cuando son para la versión 5 de Perl, se indicará explícitamente con este signo v5.
Aunque desarrollado originalmente en un entorno UNIX, actualmente hay versiones para casi todos los sistemas operativos: Windows XP, Amiga, MacOS (ver
Bibliografía/Recursos.). Los scripts son compatibles entre las diversas plataformas, de forma que es un verdadero lenguaje multiplataforma. Muchos fabricantes lo
incluyen en sus versiones de UNIX; también el Linux lo incluye. Si quieres saber si está en tu UNIX, escribe simplemente
UNIX% which perl
/usr/local/bin/perl
y si contesta algo similar a lo anterior, es que está instalado en el sistema. En algún otro "sistema operativo", como Windows xx, acuérdate de si lo instalaste o no, debe
de estar en algún lado en tu disco duro. Para bajarte la última versión, consultar el apartado de enlaces
Breve historia del lenguaje PERL
De cómo partiendo de la nada, se llegó a las cimas más altas de la miseria
La primera versión de PERL que llegó a ser suficientemente conocida fue la versión 4, dada a conocer al mundo por el libro del camello . Esta versión se estuvo
desarrollando desde 1991 a 1993, y coincidió con la popularidad del PERL como lenguaje para programación de servidores de Internet; aunque originalmente se había
diseñado como lenguaje para administración de sistemas.
La versión 5 estable no apareció hasta octubre de 1994, y ha sido tan popular que todavía se usa. Introdujo muchas de las características que hacen al PERL tan fácil de
programar, incluyendo los módulos, las facilidades para programación dirigida a objetos, referencias y mucho mejor documentación. Aparecen muchos otros libros, tales
como Learning Perl.
A partir de la versión 5.6, Perl sufrió una nueva transformación (comenzando por la eliminación de muchos números en sus versiones). Además, se incluye
soporte pleno de caracteres internacionales, hebras, y mejor compilador. Se institucionaliza un sistema de patch pumpkin, o encargado de cada nueva versión,
que es el que decide qué va a entrar de nuevo y qué no, sustituyendo a Larry Wall. Una empresa comercial, ActiveState, que ya participaba activamente en su
desarrollo, comienza a controlar más de cerca al PERL, y a la vez, a crear herramientas más potentes (y comerciales) para desarrollo con PERL
Tutorial de Perl: Índice file:///home/jmerelo/txt/tutoperl2000/tutorial-print.html
2 of 20 13/02/03 12:48
A partir del año 2000, se empieza a discutir sobre la nueva versión, la 6, que será un gran salto sobre la versión anterior, pero todavía no está muy claro qué es lo que
va a ser. Aparte de más rápida, más flexible y todo eso, todavía no se ha comenzado su desarrollo.
Una referencia mucho más completa se puede encontrar en la línea temporal de PERL.
¿Para qué sirve?
Aplicaciones del lenguaje Perl
Prácticamente, sirve para todo. Todas las tareas de administración de UNIX se pueden simplificar con un programa en Perl. Se usa también para tratamiento y
generación de ficheros de texto. También hay proyectos completos y complejos escritos en Perl, pero son los menos.
La forma del lenguaje facilita la programación rápida y sucia , el hacer un programa rápido para que funcione. Esto hace también que se utilice para hacer prototipos
rápidos de algún algoritmo que queremos ver funcionar antes que tomarnos la molestia de programarlo en un lenguaje más eficiente, como el c++. Y últimamente ha
encontrado su aplicación en la escritura de CGI (common gateway interface), o scripts ejecutados desde páginas de la World Wide Web. La mayoría de los programas
que se encuentra uno para procesar formularios en la Internet llevan la extensión .pl, lo cual denota que están escritos en Perl.
En general, los programas en Perl se ejecutan en el servidor, como todos los programas CGI, a diferencia de otros programas ejecutados por el cliente (generalmente un
navegador como el Internet Explorer de Microchof o el Navigator), como aquellos escritos en JavaScript o Java. Existen además extensiones al Apache (mod_perl) que
permiten ejecutar directamente programas en Perl desde el servidor de HTTP.
Mediante una serie de módulos adicionales, tales como el DBD o el ODBC, Perl puede servir para acceder a bases de datos, desde BD gratuitas como MySQL hasta el
Microsoft SQL server usando ODBC. Por supuesto, esto se puede combinar con un CGI para hacer aplicaciones tales como un carrito de la compra para un sitio web.
Pero esto se deja como ejercicio para el lector.
¿Cómo se usa?
Cómo conseguir e instalar programas en Perl
Primero, hay que bajarse e instalar alguna versión de Perl. Hay versiones para casi todos los sistemas operativos, o sea que no debería de ser complicado. Es conveniente
consultar la sección de enlaces, para ver dónde podemos conseguirlo.
En todo caso, lo más probable es que si tienes una distribución de Linux más o menos decente, tal como RedHat , SuSE o Debian, venga ya incluido. Consulta los
paquetes que tienes instalados (usando la herramienta correspondiente) o simplemente escribe:
bash$ which perl
/usr/bin/perl
Si contesta algo así como lo anterior, es que está instalado (y si quieres nota, escribe
bash$ perl -v
This is perl, v5.8.0 built for i386-linux-thread-multi
Copyright 1987-2002, Larry Wall
Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.
Complete documentation for Perl, including FAQ lists, should be found on
this system using ’man perl’ or ’perldoc perl’. If you have access to the
Internet, point your browser at http://www.perl.com/, the Perl Home Page.
lo que, como ves, te devuelve la versión, e información adicional.
En Windows, como siempre, es otro cantar. Sin embargo, hay una excelente versión de Perl para Windows, de la empresa ActiveState. No hay más que bajárselo, pulsar
en el icono de SetUp correspondiente, y se lanza un procedimiento de instalación similar al de todos los programas. Desde ese momento, ya se puede usar desde la línea
de comandos.
En MSDOS (¿hay alguien que todavía use MSDOS?), basta descomprimirlo, y añadir al PATH el directorio donde se encuentra perl.exe.
En otros sistemas operativos, seguir el procedimiento respectivo en caso de que exista una versión ya compilada, pero puede que no exista una versión binaria. Habrá
entonces que bajarse los fuentes de alguno de los sitios web existentes, y luego compilarlos usando los siguientes comandos (si es que es un SO parecido a UNIX:
sh Configure
make
make test
make install
Para más información, consultar el fichero INSTALL o perldoc INSTALL que viene con los fuentes (malamente podrás usar perldoc si no tienes instalado Perl, pero en
fin...).
Mi primer programa en Perl
Cómo escribir y ejecutar un programa simple Perl
Escribir el archiconocido "Hola" en Perl no puede ser más fácil:
print "Passa, tio\n";
Y eso es todo. No hay necesidad de abrir el programa, ni de cerrarlo, ni de incluir librerías estándar o no, ni nada de nada. Solamente hay que tener cuidado de terminar
todas las sentencias con;. \n, que se suele leer "escape-N", tiene el mismo significado que en C; es decir, un retorno de carro.
Ejecutarlo es otro cantar; o mejor dicho, muchos cantares, una cantata entera. El Perl siempre Hay Muchas Formas de Hacer Las CosasTM. Al menos tres, en este caso.
Guarda el programa en un fichero, llamémoslo passa.pl. Se puede ejecutar con
C:\PROGS\Perl>perl passa.pl
Passa, tio
Tutorial de Perl: Índice file:///home/jmerelo/txt/tutoperl2000/tutorial-print.html
3 of 20 13/02/03 12:48
Todo esto suponiendo que Perl esté en el PATH de ejecución, claro está.
Pasa de guardar el programa en un fichero y ejecútalo directamente. Se le da el switch-e al intérprete para indicar que se debe ejecutar el script que viene a
continuación (y ojo con las comillas)
C:\PROGS\PERL>perl -e ’print "Passa, tio\n";’
Passa, tio
Si estás en UNIX, se utiliza una sintaxis similar a los scripts del intérprete de comandos, es decir, guardar el fichero con una primera línea que indica dónde está
el intérprete que va a ejecutar el resto del fichero. En el caso del Perl, puede ser algo como #!/usr/local/bin/perl, o #!/usr/bin/perl en RedHat Linux, por
ejemplo) (los símbolos iniciales se suelen denominar pound-bang, o almohadilla-admiración, en román paladino). En todo caso, habrá que sustituirlo por el
camino completo donde habita el intérprete de Perl (si no se sabe, recurre al comando de UNIXwhich (como hemos visto antes), o, por último, al operador de tu
sistema; ahora, que si tú mismo eres el operador de tu sistema y no sabes como hacerlo, tienes un problema, tío... Bueno, siempre te queda la internet). Tras salvar
el fichero, habrá que dar la orden
UNIX% chmod +x passa.pl
para convertirlo en ejecutable; hecho eso, se puede ejecutar directamente escribiendo
UNIX% passa.pl
Passa, tio
En Windows y familia, hay al menos dos formas de hacerloTM(suponiendo, claro está, que le pille de buenas y te deje hacer algo). Tras instalar la versión de Perl
para WinXX de la Internet, de la empresa ActiveState, se crea un acceso directo a perl.exe y se copia al directorio \Windows\SendTo; esto hará que aparezca Perl
dentro del menú enviar a, que es una de las opciones del menú que surge al pulsar con el botón derecho del ratón.
Otra forma es más específica para ficheros de tipo .pl, y es el mismo mecanismo que se usa para asignar iconos y programas ejecutables a los ficheros no
ejecutables: en la carpeta MiPC, pasar a Ver - Opciones y pulsar sobre la pestaña Tipos de Archivo: Se crea un nuevo tipo que sean "Programas en Perl", y se le
pueden asignar acciones como edición o ejecución; de esta forma, con sólo pulsar dos veces sobre el icono, se ejecuta el programa.
Para trabajar con Perl en
Windows, se puede ver
Automating Windows with
PERL, por Scott McMahan .
Para editar un programa en Perl, lo más adecuado es conseguir un editor para programadores, porque el lenguaje no incluye un entorno integrado de programación. Lo
más parecido a tal entorno integrado, tanto en Win95/NT como en UNIX, es el emacs, puesto que tiene un modo Perl de edición, que tiene en cuenta indentaciones y
otras particularidades de su sintaxis, como el emparejamiento de paréntesis y llaves y los comentarios, y asigna diferente color a las palabras dependiendo del contexto.
Otra opción con unos pocos menos megas puede ser cualquier editor de programador con diferentes opciones dependiendo de la extensión del programa, como el
Programmer´s File Editor . Aunque, por supuesto, si puedes conseguirte el emacs para Windows, es con diferencia lo mejor.
Más difícil todavía
Variables, interpolación y cadenas
Ya que hemos hecho nuestro primer programa, vamos a por el segundo. Supongamos que somos un político corrupto cualquiera, y que, dado el alto número de
transacciones diarias por las cuales cobramos comisiones ilegales, decidimos escribir un programa enPERL que nos resuelva la difícil papeleta de calcularlas sobre la
marcha. Ni cortos ni perezosos, nos puede servir lo siguiente (comile.pl):
Tutorial de Perl: Índice file:///home/jmerelo/txt/tutoperl2000/tutorial-print.html
4 of 20 13/02/03 12:48
Listado : Programa comile.pl
print "Valor del inmueble? ";
$valor = ;
$comision = $valor * 0.25;
print "Comision = $comision\n";
que da el resultado siguiente
C:\PROGS\PERL>perl comile.pl
Valor del inmueble 1000000 [Escrito por el usuario]
Comision = 250000
A partir de este momento, indicaremos en rojo las palabras clave de PERL, en verde las variables de PERL y en azul las órdenes de control.
En este ejemplo hay algunos elementos más de PERL. Como se ve, las variables se indican con un símbolo de $ (sumamente indicado para el ejemplo); en este caso se
trata de variables escalares, que contienen un valor numérico o una cadena; a PERLle da exactamente igual que se trate de uno o de otro, la transformación se hace
automáticamente. Y no hace falta ninguna declaración de variables; cada variable se declara en el momento que se usa, y si no se ha usado anteriormente, aparece
automáticamente con el valor 0 o ´´ (cadena nula). Las variables en PERL tienen todas visibilidad global, si no se dice lo contrario.
El programa pide además, la intervención del usuario, leyendo en una variable lo que éste teclea. Para ello se utiliza un filehandle o puntero a un fichero abierto (el
equivalente a un FILE* en C), que está disponible en todos los programas, la entrada estándar o stdin (estandard input); de la misma manera, también existe la salida
estándar o stdout, es decir, que es lo mismo print STDOUT que print). El nombre de esta variable no está precedido por ningún símbolo de $ para indicar que se trata de
un filehandle, o una variable que representa un fichero. Los angle brackets, o paréntesis angulares <>, indican que se lee del fichero una línea completa, hasta que el que
teclea pulsa un retorno de carro.
Por último, se está utilizando la operación denominada interpolación de variables. Una variable incluida dentro de una cadena entre comillas dobles será sustituida por
su valor (no en el caso de tratarse de comillas simples).
Dando vueltas sobre lo mismo
Bucles, lectura de teclado y ficheros
Cuando, tras las elecciones, nuestro político corrupto sale reelegido por méritos propios, viene inmediatamente la recuperación económica y con ello el boom
inmobiliario (favorecido por la recalificación en terrenos construibles de los parques de la ciudad). Tantas comisiones tiene que calcular, que decide escribir un programa
que lo haga continuamente, en vez de tener que ejecutar el programa anterior cada vez. Decide además guardar detalles de todo en un fichero, que llevará en un disquete
escondido en el collar del perro, para que, en caso de que lo investigue una comisión del Congreso, pueda tirar de la manta tecnológicamente. Saldría entonces algo como
lo incluido en el listado siguiente:
Listado : Programa manta.pl
#!/usr/bin/perl
open( MANTA, ">clientes");
while(1){
print "Cliente\n";
chop( $paganini = );
last if !$paganini;
print "Valor inmueble\n";
chop( $valor= );
$comision = $valor * 0.25;
print "Comision = $comision\n";
print MANTA "$paganini $comision\n";
}
close MANTA;
En este segundo programa, que llamaremos manta.pl, se introducen algunos conceptos nuevos más. Para empezar, se utiliza la orden open para abrir un fichero; a esta
orden se le dan dos parámetros, el filehandle por el cual nos vamos a referir al fichero en lo sucesivo, y una cadena que incluye el nombre del fichero y la forma de
manejar ese fichero. En este caso, se usa la expresión ">clientes", que indica que se va a abrir para escritura. Otras opciones son las que aparecen en la tabla 1. Si no se
pone nada, se supone que el fichero se abre para lectura. Y esto es fuente de continuas confusiones.
Como siempre, hay Más de Una Forma de Hacerlo TM, aunque no necesarimente más corta. Se puede meter el nombre del fichero en una variable tal como $MANTA, y
abrirlo de la forma siguiente:
$MANTA=’>prueba’;
open MANTA;
Es decir, cuando no se pone una cadena detrás del filehandle, se usa el contenido de una variable que tenga el mismo nombre. Véase también que en este caso no he
usado paréntesis detrás de open; son opcionales. Hay muchas más cosas sobre open leyendo el tutorial incluido en la documentación, se accede a él escribiendo
perldoc perlopentut o man perlopentut.
Tabla : Modos de apertura de ficheros
> Abrir para escritura
>> Abrir para concatenar
< Abrir para lectura
>+ Abrir para lectura/escritura
¦ orden
Ejecutar un programa que filtrará lo que
se imprima en el fichero.
orden |
Ejecutar una orden, de la cual se leerá la
salida.
A continuación se comienza un bucle con la ordenwhile, que se ejecutará mientras la expresión entre paréntesis sea cierta, o sea, en este caso, en principio, siempre. Los
valores "verdaderos" se indican en Perl con un número distinto de 0 o una cadena no nula. Tras while va siempre un bloque, que se comienza y termina con llaves. Dado
que es un bloque, y no la alternativa orden|bloque (como sucede, por ejemplo, en el lenguaje C), se tendrán que utilizar siempre las llaves, aunque se trate de un solo
Tutorial de Perl: Índice file:///home/jmerelo/txt/tutoperl2000/tutorial-print.html
5 of 20 13/02/03 12:48
comando. También se podría sustituir esta línea por until(0) {que tendría exactamente el mismo significado (recuerda, Hay Más De Una Forma de Hacerlo). O por dos
o tres formas más, al menos.
En la línea 4 se hacen dos cosas juntas: se asigna a una variable lo que introduce el usuario, y a esta variable se le elimina el último carácter ( chop, que significa trocear,
como en el chopped). Esto es necesario porque, a diferencia de otros lenguajes, Perl incluye el retorno de carro en la cadena que lee. Lo eliminamos entonces para que
quede todo bonito.
Tabla : Tipos de bucles en Perl
ETIQUETA while (EXPR) BLOQUE
ETIQUETA while (EXPR) BLOQUE continue BLOQUE
ETIQUETA for (EXPR;EXPR;EXPR) BLOQUE
ETIQUETA foreach VAR (MATRIZ) BLOQUE
En la línea 5 se utiliza una construcción típica:
Perl .
En este caso, se sale del bucle (last) en caso de que lo que se haya leido sea la cadena vacía (recordad que previamente hemos eliminado el retorno de carro). Esta línea
se podía haber sustituido por la siguientelast unless $paganini;que tiene exactamente el mismo significado (unless significa a menos que); en general, una sentencia en
la que se utiliza if con una expresión verdadera se puede sustituir por otra en la que se utiliza unless con la misma expresión negada. Otras expresiones que regulan
bucles son next, que ejecuta la iteración siguiente sin pasar por el resto de las órdenes del bucle, y redo, que vuelve a comenzar el bucle sin evaluar la condición.
Tabla : operadores de cadenas en Perl
lt, gt, le, ge Lexicográficamente menor, mayor,
menor e igual, mayor e igual
eq, ne Igual, distinto
cmp
Comparación de cadenas; devuelve -1, 0 o
1
x
Multiplicación de cadenas "az" x 2 eq
"azaz"
En esta misma línea se usa el operador !, de negación. Este operador, como otros muchos, están sacados directamente del lenguaje C, en general, los operadores en Perl
son los mismos que en C, y además tienen la misma prioridad. Además, hay una serie de operadores específicos para cadenas alfanuméricas, sacados más bien del
FORTRAN, y otros para ficheros que se verán más adelante.
En la línea 10 se escribe en el fichero MANTA; como se ve, simplemente se incluye el filehandle delante de la expresión que se va a escribir. Para terminar, después de
concluir el bucle se cierra el fichero.
Estos primeros programas nos permiten ya tener una idea de cómo funciona Perl. En realidad, salvo algunos asuntos menores de sintaxis de variables y su declaración, es
muy similar al C: por eso siempre, la primera aproximación a un programa será hacerlo tal como uno lo haría en C, para luego, cuando se tenga mayor dominio del
lenguaje Perl, hacerlo de forma más perlera.
El político corrupto se da cuenta de que tiene en un fichero guardadas una serie de sobornos anteriores en un fichero; pero no le puso nombre; así que, antes de que se le
vayan las cosas de la memoria y no diga nada salvo en presencia de su abogado, decide hacer un programa que le vaya preguntando cantidad por cantidad quién fue la
que se la dió. Y decide hacer el siguiente programa (recuerda.pl):
Listado : Programa recuerda.pl
1 #!/usr/bin/perl
2
3 open FICHERO, "cantidades";
4 open SALIDA, ">salida";
5 while($linea = ) {
6 chop($linea);
7 print "Quien te ha dado $linea pelas? Eh?\n";
8 chop( $menda = );
9 print SALIDA "$menda $linea\n";
10 }
11 close FICHERO;
12 close SALIDA;
Este programa utiliza las mismas estructuras que el anterior: ficheros de entrada y salida, y un bucle. Sin embargo, se usan de forma diferente. Para empezar, la sintaxis de
apertura de los ficheros en las líneas 3 y 4 es diferente: se evitan los paréntesis, casi 4 bytes, que en una memoria de 512 megabytes, quieras que no, es un ahorro. El
fichero cantidades se abre para lectura, por lo que no es necesario poner el símbolo <, y el fichero salida se abre para escritura.
Lo que sigue es bastante típico de la lectura de ficheros en Perl: se lee una línea del fichero abierto (usando la construcción <>, se asigna a la variable $line. Además, la
línea está dentro de una condición de continuación de un bucle; efectivamente, $line será la cadena vacía, y por lo tanto falso, cuando el fichero deje de tener
elementos.
El interior del bucle no aporta nada nuevo: simplemente se le eliminan los retornos de carro a lo que se lee usando chop, y se combina la entrada con lo que introduce el
usuario para escribirlo en la salida. Finalmente, en las líneas 11 y 12, se cierran los ficheros.
Ejercicios
Realizar un programa que vaya calculando cuadrados de números hasta que se introduzca una línea en blanco (solo retorno de carro).
Realizar un programa que permita al usuario introducir un nombre, y el ordenador le escriba "Hola >mismo nombre en mayúsculas<".
Realizar un programa que solicite nombres y apellidos del usuario, y los imprima en pantalla en formato formal: apellidos y nombre, separados por coma.
Escribir en un fichero todos aquellos que se llamen Juan de nombre.
Ahorrando energías
Operadores, matrices y la variable por defecto $_
Tutorial de Perl: Índice file:///home/jmerelo/txt/tutoperl2000/tutorial-print.html
6 of 20 13/02/03 12:48
Como nuestro político corrupto, por su experiencia en el ramo de la construcción, ha sido nombrado delegado de Obras Públicas, tiene que pasar la mayor parte del
tiempo visitando carreteras, caminos, puentes y veredas. Nada mejor, pues, que comprar un portátil AMD K6-2 para ir introduciendo las mordidas en el propio lugar
donde se originen. El problema es el limitado rango de las baterías, que hacen que si hay que viajar de Albacete a Cuenca, se gaste la batería a la altura de Motilla del
Palancar. Para ahorrar energía, decide modificar su programa de forma que escriba menos en el disco; es decir, que cargue todos los datos en memoria, y los guarde sólo
cuando termine el bucle. Además, para no poner la excusa a la comisión del Congreso (que ya pide Anguita a voces) de que no se acuerda de nada, decide grabar
también las fechas y horas de los sucesos. Escribe, con su pericia creciente en Perl, el programa memoria.pl (listado 3).
Listado : Programa memoria.pl
1 until(0) {
2 print "Cliente\n";
3 chop( $paganini = );
4 last if !$paganini;
5 print "Valor inmueble\n";
6 chop($valor = );
7 $comision = $valor * 0.25;
8 ($seg, $min, $hora, $dia, $mes, $anho, @zape) = localtime(time);
9 $mes++;
10 $anho+=1900;
11 $zipi = "$paganini $comision $hora:$min $dia/$mes/$anho\n";
12 push( @mem, $zipi );
13 };
14
15 open (MANTA,">clientes.mas");
16 foreach (sort @mem ) {
17 print MANTA;
18 }
19 close (MANTA);
En esta pequeña modificación del programa anterior, y en la línea 8, se introduce una nueva estructura de Perl: el array o lista. Un array se indica con el símbolo @
(arroba), aunque a cada elemento de un array nos referiremos con la notación $mem[0], ya que es un escalar. En general, tanto los operadores como las funciones en Perl
se comportan de forma diferente si se trata de un entorno escalar o si se trata de un entorno de lista o vectorial. En este caso, el operador localtime devuelve una lista
compuesta por los segundos, minutos y demas, tomándolo de la función time que devuelve el número de segundos transcurridos desde hace mucho tiempo (1970, para
ser exactos). Además, estamos utilizando la lista @zape para contener el resto de los elementos de la hora, que no nos interesan (serían el día de la semana y cosas así).
Por supuesto, también se podría haber hecho de otra forma, mucho más larga
@fecha= localtime(time);
$seg = $fecha[0];
...
Las matrices empiezan en Perl en 0 habitualmente, como sucede en C; pero esto se puede cambiar (usando la variable global $[). Hay que tener cuidadito con la variable
$anho, que devuelve, al contrario de lo que se pudiera pensar, el número de años transcurridos desde 1900. Eso da lugar a todo tipo de pequeños efectos 2000, que todavía
se ven por algún sitio Web. Por eso, en la línea 10, se le suma 1900, para que dé el año actual con cuatro cifras. Tal como en el lenguaje C, $anho+=1900 equivale a
$anho=$anho+1900;
En la línea 12 hay un nuevo operador, push. Este operador hace precisamente eso, achuchar un escalar o una lista al principio de otra lista (recordad que lista y array son
prácticamente sinónimos). En este caso, estamos metiendo la cadena que hemos creado, $zipi, al principio de la matriz @mem (que, por cierto, tampoco hemos tenido que
declarar ni dimensionar). Si queremos eliminar el primer componente de una matriz, se hace con el operador obvio, $cadena = pop(@mem);
En la línea 16 aparece una nueva orden de control de bucle: foreach, para cada, que repite el cuerpo del bucle para cada uno de los elementos de la lista que hay
contenida entre paréntesis. Se puede abreviar por for, aunque también se puede comportar como lo hace en C. ¿Y cuál es la lista a la que se aplica? La que hemos
creado anteriormente, pero por orden (de ahí el sort). En este caso la ordenará por orden alfabético, saliendo algo como esto
Uno 750 12:0 31/1/2000
otro 1402654 12:0 31/1/2000
otro mas 4020267 12:1 31/1/2000
y otro mas todavia 4040.25 12:1 31/1/2000
Sin embargo, dentro del bucle no parece que pase nada; y, ¿dónde diablos se ha metido la variable de bucle?. Lo que ocurre es que en estos casos Perl tiene una variable
por defecto, $_, que es la variable de bucle por defecto y sobre la que actúan los operadores y funciones también por defecto. Es decir, que el bucle anterior equivaldría a
foreach $_ (sort @mem) {
print MANTA $_;
}
Y aunque sé que ya estáis esperando que lo diga, se puede hacer de otra forma, esta vez menos Perlística; utilizando bucles normales y corrientes
for ($i = 0; $i<=$#mem; $i++) {
print MANTA $mem[$i];
}
si bien en este caso el fichero de salida no estará ordenado. En este caso se utiliza la construcción $#, que devuelve el último índice existente para esa
matriz. Ojo, se trata del último índice, no del número de elementos de la matriz; por eso los bucles en Perl usan un <= para terminar.
Ejercicios
Hacer un programa que imprima su entrada estándar en orden inverso,empezando por la última línea y acabando por la primera. Se ejecutará con
unix% cat ¦invert.pl
PistasUsar la orden pop, que extrae el primer elemento de un array. Reto Hacerlo en una sola línea.
$. es una variable que contiene la línea del fichero de la que se está leyendo. Teniendo esto en cuenta, crear un filtro (es decir, un programa que lea de entrada
estándar y escriba en salida estándar, tal como el anterior) que imprima un fichero con el número de línea al principio de cada una.
Hacer un histo(pro)gra, es decir, un programa que recoja una serie de valores numéricos (con valores reales entre 0 y 100), los distribuya en cinco cubos (del 0
al 20, entre 20 y 40, y así sucesivamente), calcule las frecuencias de cada uno de los cubos, e imprima barras horizontales cuya longitud es función de la
frecuencia.
Recordando, que es gerundio
Tutorial de Perl: Índice file:///home/jmerelo/txt/tutoperl2000/tutorial-print.html
7 of 20 13/02/03 12:48
La orden split, matrices asociativas y matrices bidimensionales
Al final del día, nuestro político corrupto reflexiona. ¿De qué sirve tanto trabajo, sin una buena contabilidad consolidada? (Además, tiene que presentarle las cuentas al
señor X a fin de mes). Idea, pues, el programa que aparece en el listado 4.
Listado : Programa totales.pl
1 die "Y el fichero de clientes, ein?\n" unless $ARGV[0];
2 while(<>) {
3 @linea = split;
4 @fecha=split(/\//,$linea[$#linea]);
5 $mesdia = "$fecha[1]-$fecha[0]";
6 $pasta=$linea[$#linea - 2];
7 $totalDia{$mesdia}+=$pasta;
8 }
91
0 foreach (sort keys %totalDia) {
11 print "Trinque total del dia $_ = $totalDia{$_}\n";
12 }
Este programa, aplicado sobre el ficheroclientes.mas, (resultado de una incursión en la construcción de diversas viviendas para los cuerpos de seguridad del estado y sus
departamentos de investigación y desarrollo, así como otros procedentes del mundo de la enseñanza) da el siguiente resultado (o algo parecido)
C:\PROGS\PERL>perl totales.pl clientes.mas
Trinque total del dia 3-24 = 598454.75
Trinque total del dia 4-25 = 1100987
Trinque total del dia 4-26 = 487775
Este programa empieza con una advertencia: "muere si no me metes un fichero como argumento". La orden die termina el programa con un mensaje; mientras que el
condicional que lo sigue comprueba que exista al menos un argumento para el programa; la matriz @ARGV contiene los argumentos pasados al programa; de forma que
$#ARGV dará el índice del último argumento, o sea que si es -1, indicará que no se ha pasado ningún argumento. Y otra forma de hacerlo sería
die "Sin argumento me lamento\n" if $#ARGV < 0;
O incluso
$ARGV[0] || die "Te has quedado sin argumentos\n";
que mira lo que hay a la izquierda del || (que es el "o" lógico), y si es cierto, ejecuta lo que hay a la derecha. Recuerda, en PERL hay más bla, bla.
El siguiente bucle, que comienza en la línea 2, tiene una extraña condición para que el bucle siga; sólo los dos ángulos enfrentados. Teóricamente, debería de haber un
filehandle dentro de esos ángulos (como se ha visto en un ejemplo anterior), pero en este caso, se está tomando el fichero por defecto, que es el fichero que se introduce
como argumento; en caso de que no se hubiera introducido ninguno tomaría entrada estándar, es decir, que habría que introducirle cada línea mediante teclado. A la vez,
y como se ha visto, esa orden toma una línea del fichero y la deposita en la variable por defecto, aunque, ojo, no le quita el retorno de carro final. Hay que tener en cuenta
que los paréntesis angulares sin argumento extraen elementos del array @ARGV usando pop, y abren un fichero con ese nombre; o sea que si hubiera varios nombres de
fichero en la línea de comandos, los iría abriendo uno por uno y disminuyendo consecuentemente el tamaño de @ARGV; conclusión, que si necesitas @ARGV para algo, mejor
que lo guardes antes de meterte en un bucle de esta guisa.
Sobre la variable por defecto actúa la orden split (una de las cosas más usadas en PERL), dividiéndola en una serie de cadenas separadas por espacios y depositando
cada una de esas cadenas en un elemento de la matriz @linea. Y dese cuenta el venerado público de con qué facilidad hemos hecho algo que requeriría al menos 10 líneas
de cualquier otro lenguaje. No hay que dimensionar matrices, no hay que recorrer la cadena caracter por caracter... ¡Nada!(3). Perdón, me he dejado llevar por el
entusiasmo.
La fecha es, en todos los casos, la última cadena de la línea; es decir, que será el último elemento de la matriz (cuyo subíndice es siempre $#vez tendremos que dividirlo, esta vez por la barra de separación, para luego poder poner el mes delante y que salga todo bellamente ordenado por meses en vez de por
días.
Esta cadena con la fecha, más la pasta, que está siempre 2 posiciones más a la izquierda (independientemente de la longitud de los nombres), se utiliza en la línea 7 en
una matriz asociativa . Esta es otra de las características más potentes del PERL, se pueden usar matrices cuyo índice es una cadena cualquiera, no sólo números enteros
positivos. Estas matrices asociativas encierran sus índices o claves entre llaves (¿os dáis cuenta del sutil mnemónico?). En esa línea, se le añade al componente de la
matriz indexado por la fecha la pasta de la entrada correspondiente. Así, hasta que se termina el fichero de entrada.
Para imprimir el informe, tres cuartos de lo mismo que en el programa anterior, salvo que en este caso, una matriz asociativa completa se indica con %, en vez de la arroba.
Ejercicios
Leer un fichero con el formato Primer_Apellido Segundo_Apellido, Nombre y escribirlo como
Nombre Primer_Apellido Segundo_Apellido
En el mismo fichero, presentar al final el número de veces que aparece cada apellido.
Realizar un programa que, haciendo lo mismo que el manta.pl, lo haga en la mitad de líneas.
Escribir un programa que haga lo mismo que la orden wc de UNIX, es decir, para cualquier fichero, contar el número de líneas, de palabras y de bytes, y
presentarlo en 3 columnas con el nombre del fichero en la cuarta. Hacer que funcione para varios ficheros, introducidos en la línea de comandos.
A partir del fichero de registro de visitas de un sitio Web, o log, poner cuántasveces han consultado las páginas desde dominios de primer y segundo orden,
presentarlos por orden, con una opción que permita seleccionar primer o segundo orden.
Realizar un programa que, a partir de una lista del tipo DNI Apellidos, Nombre genere un fichero de password, con el formato
username:password:uid:gid:Nombre y Apellidos
Calcular el username con la inicial del nombre y el primer apellido; si existe, usar el segundo apellido, y si existe también, añadir un número de orden. Para el
password, encriptar el DNI; el UID se genera por orden alfabético a partir del número 1000, el gid es un entero común, y el nombre y apellidos es elindicado. Al
terminarlo, ofrecerlo amablemente al administrador del sistema de tu Escuela o Facultad.
A partir de la versión 5 de perl , se pueden usar matrices bidimensionales, mediante un mecanismo que se llama referencias; este mecanismo no nos interesa ahora
mismo, pero sí como podemos usarlo en nuestros programas.

martes, 4 de mayo de 2010

DEFINICION DEL ACTIVEPERL

El es de Qué ActivePerl?:
ActivePerl es una distribución - o pre-configuró, listo-a-instale el paquete - de Perl. La ActivePerl es una distribución - el pre-configurado de o, listo para instalar el paquete - de Perl. Desde que Perl es la fuente abierta, está libremente disponible a cualquiera y, de hecho, la norma instala en la mayoría del Unix / las máquinas de Linux. El que de Dado el es de Perl del abierto del código, es libremente disponible para cualquier persona y, del hecho, la instalación estándar en la mayoría de Unix / Linux. ActiveState ha tomado esa norma instale de Perl y creó los paquetes buenos, aseados para la instalación rápida en Windows (y otro) los sistemas. El ActiveState ha recurrido un estándares de instalación de esta de Perl el y creado paquetes agradable, limpio para una rápida instalación en Windows (el otros de y) el sistemas del los. Desde que sigue siendo la fuente abierta, ActiveState lo ofrece como un libre transmita en su sitio de tejido. El Puesto que sigue siendo del abierto del código, ActiveState ofrece como una descarga gratuita en su sitio tejido.
Dónde yo puedo conseguirlo?: el Dónde puedo conseguirlo?:
Vaya a la ActivePerl casa página de ActiveState. Ir un ActiveState la página de ActivePerl del inicio. Pulse el botón adelante ' Download' Libre. el Haga clic en ' el gratuita' de Descarga. hay ninguna necesidad de rellenar cualquiera de esta información del contacto para transmitir ActivePerl. Ningún es necesario llenar ninguna de la información del esta del contacto, descargar del para ActivePerl. Pulse el botón ' Next' cuando usted está listo, y en la próxima página, desfile abajo la lista para encontrar la distribución de Windows. El Haga clic en "Siguiente" el listo de esté de cuando, el y en la página siguiente, la desplácese por la lista para encontrar la distribución de Windows. Para transmitirlo, clic correcto en el MSI (el Instalador de Microsoft) el archivo y escoge ' Excepto As'. el descargarlo de Para, pulse el botón el derecho el el sobrio MSI (el Instalador de Microsoft) Archivo el seleccione de y "como de Guardar". Transmita los MSI archivan a su desktop. EL DESCARGUE EL ARCHIVO EL MSI EN SU ESCRITORIO.
Cómo yo lo instalo?: el Cómo lo instalo?:
El clic doble en el archivo de MSI para ejecutarlo. EL HAGA DOBLE CLIC EN EL ARCHIVO EL MSI PARA EJECUTARLO. Pulse el botón ' Next' en la primera pantalla. El Haga clic en "Siguiente" la en la primera pantalla. Verifique el ' yo Accept' transmiten por radio botón que usted ha leído al acuerdo una vez, entonces pulse el botón ' Next'. el en de Verifica "Acepto" el botón de la radio, una vez que haya leído el acuerdo, una continuación, el en de clic de haga "Siguiente". yo haría pensar en dejando todo como él es fijo en esta pantalla, y pulsa el botón ' Next'. la Yo sugeriría dejar todo tal como se establece en esta pantalla el y haga clic en "Siguiente". En la próxima pantalla, de nuevo deje todas las opciones como ellos es, y pulsa el botón ' Next' un más tiempo. La En la siguiente pantalla, afectaría del también un todas las opciones como hijo, y haga clic en el Siguiente una hora más. Pulse el botón ' Install' y espera por el proceso para completar. El Haga clic en "Instalar" el espere de y un que termine el procesos. Finalmente, uncheck el ' la opción de notas de descargo de despliegue, y pulsa el botón ' Finish'. el último de Por, opción de la de desmarque "el notas del mostrar de la liberación", y haga clic en "Finalizar". Anule el archivo de MSI. EL ELIMINE EL ARCHIVO MSI.
Cómo yo sé que está funcionando?: el Cómo sé que funciona?:
Ejecute un programa rápido en la línea del orden y vea si usted consigue algún rendimiento. La Ejecutar un programa rápido en la línea del comandos la y ver si le da una salida. Cree un nuevo archivo del texto y llámelo ' test.pl'. el Crear un nuevo archivo del texto el y lo llamamos "test.pl. la Copia y pega la línea siguiente en ' test.pl' y lo salva en su C: el paseo: COPIA EL Y PEGA LA SIGUIENTE LÍNEA EN ' TEST.PL "LA Y GUÁRDELO EN LA UNIDAD C::

la impresión "Probando Perl. \n"; la impresión "Pruebas Perl. \ n";

Pulse el botón en el Windows ' el menú de Start', escoja ' Corra... ', y tipo ' el cmd'. el Haga clic en "Inicio" de Windows "el menú del del, seleccione" Ejecutar... ', escriba de y ' el cmd'. A la sugerencia, tipo ' el perl test.pl' y usted deben ver su programa imprimir ' Probando Perl. '. el En el indicador, perl de test.pl "tipo" el y usted debe ver un imprime de programa de su "Probando Perl..
La Información adicional: El adicional de Información:
Para la información más detallada, yo hago pensar en pareciendo a través de la documentación de ActivePerl que se instaló en su sistema con Perl. El Para obtener información más detallada, mirar de sugiero de le un través de la documentación del la los ActivePerl que estaba instalado en su sistemas hacen trampas Perl. Usted también puede visitar el ActivePerl tejido sitio, y claro perl.com - la fuente original. También puede visitar el sitio tejido ActivePerl, y por supuesto perl.com

viernes, 9 de abril de 2010

COMO INSTALAR PERL.

Instalación de Perl
Como es lógico, antes de empezar a ponernos a escribir programas de Perl como locos es necesario instalar o tener instalado el intérprete de Perl. Lo podemos encontrar en las siguientes direcciones:

En www.perl.com que es un buen sitio de referencia para empezar con Perl.
En el CPAN que el sitio más completo de recursos de Perl
En ActiveState si lo que usamos es Windows en sus diferentes variantes

2.1.- Instalación de Perl en Linux
Hoy en día todas las distribuciones incluyen casi de serie un intérprete de Perl, es decir, el intérprete de Perl se instala casi por defecto (muy mínima debería ser las instalación para que no se incluyera o quitarlo a propósito). Debido a la característica que antes apuntabámos de su utilidad para realizar tareas de administración del sistema.

Para instalar Perl (o instalar una versión actualizada), lo primero que hay que decidir es si instalar una versión compilada (binaria) o compilar nosotros mismos. Ambas cosas (fuentes o binarios) se pueden encontrar en www.cpan.org para multitud de Sistemas Unix ( y otros no Unix).

Si te bajas una versión compilada y específica para tu sistema, simplemente ejecutas el binario que te bajes (descomprimiéndolo si estuviera comprimido) o instálandolo con rpm -Uhv perl_compilado.rpm si es un fichero rpm. El único problema que te puedes encontrar es que te haga falta alguna librería, y ahí es donde se complican las cosas, también tendrás que instalarla.

Si optas por bajarte el código fuente agrupado en un fichero tar.gz (o .tgz), lo primero que tienes que hacer es descomprimirlo. Con:

tar xvfz perl_codigofuente.tar.gz

o si tiene extensión .tar.bz2 con:

tar xvfj perl_codigofuente.tar.bz2

y si tu sistema es un poco viejo con:

tar xvfI perl_codigofuente.tar.bz2

Si por casualidad tuviese la extensión .Z. Se tendría que hacer en dos pasos:

gzip -d perl_codigofuente.tar.Z
tar xvf perl_codigofuente.tar

Una vez descomprimidos el código fuente de Perl, lo aconsejable es leer los ficheros README e INSTALL, por lo que pudiera pasar o por lo que nos pudiera faltar.

Una vez llegados a este lo pasos a seguir son los mismos que compilar casi cualquier aplicación en Linux:

./configure
make
make install

Con lo anterior, primero, se configura (si puede) para nuestro sistema, segundo, se compila el código del intérprete y, tercero, se instala.

2.2.- Instalación de Perl en Windows
Para instalar Perl en Windows hay también dos opciones, la primera, que es la más aconsejable, es obtener la última versión de Active Perl, que es la versión de Perl para Windows compilada por la compañía ActiveState. Para instalar esta versión, sólo nos hace falta el Microsoft Installer, y una parche de las DCOM para windows 95, si ese es el sistema "operativo" que utilizamos.

La otra opción (menos recomendable) que tenemos es bajarnos el código fuente de www.cpan.org, descomprimirla (hay versiones del tar, del gzip para windows en el CPAN) y compilarla. Para compilar el código fuente, hace falta el Microsoft Visual C++ o Mingw32 con EGCS o GCC. También nos hará falta una utilidad make. MS Visual C++ viene con nmake, aunque también se puede usar dmake (una versión compilada con Mingw32). Se aconseja leer el fichero README.win32 (sobre todo si usas Mingw32). Una vez que se cumplen todos los requisitos, los pasos son:

nmake
nmake test
nmake install

Hay que tener en cuenta que la versión de Perl para Windows 95 la funcionalidad no es completa en algunos módulos (en el resto de sabores de windows va bien: 98,Me,NT200,XP).

viernes, 19 de marzo de 2010

INTERFAZ CON BASE DE DATOS

Interfaz con bases de datos [editar]Perl está ampliamente favorecido para las aplicaciones de bases de datos. Sus facilidades de manejo de texto son buenas para generar consultas SQL; arrays, hashes y la gestión de memoria automática hace fácil recoger y procesar los datos devueltos.

En las primeras versiones de Perl, las interfaces de bases de datos fueron creadas enlazando el intérprete con una biblioteca de base de datos desde el lado del cliente. Esto era algo torpe; un problema en particular fue que el ejecutable perl resultante estaba restringido a usar sólo una interfaz de base de datos, la que había sido enlazada. También, reenlazar el intérprete era lo suficientemente dificultoso que sólo fue realizado para algunas de las más famosas e importantes bases de datos.

En Perl 5, las interfaces de bases de datos están implementadas por el módulo Perl DBI. El módulo DBI presenta una única interfaz a las aplicaciones Perl, independiente de las bases de datos, mientras que los módulos DBD:: (Controlador de base de datos) manejan los detalles de acceso a unas 50 bases de datos diferentes. Existen controladores DBD:: para la mayor parte de las bases de datos ANSI SQL.

EXPRESIONES REGULARES

Las expresiones regulares son una suerte de lenguaje interno al perl, pero no sólo (por ejemplo se encuntran en comandos como grep, sed awk). En cualquier caso, no hay 2 programas que tengan que ver con las expresiones regulares y las interpreten del mismo modo.
Una expresión regular está entre / , aunque se trata más bien de una convención que de una regla. Resulta normal ver una expresión regular entre | o # o cualquier otro carácter, para evitar que aparezca el símbolo \ delante de todos los / en regexp.

Una expresión regular define un pattern que será buscado. En las expresiones regulares, los caracteres alfanuméricos (de la a a la z, de la A a la Z, de 0 a 9 y _ ) tienen una correspondencia unívoca, mientras que otros caracteres tienen características especiales.

Un \ seguido por un carácter no alfanumérico corresponde exactamente a ese carácter; en concreto, \\ corresponde a \ .

^ -- (sólo al inicio de la expresión) hace que el texto corresponda al pattern sólo si el pattern está al comienzo del texto.

$ -- (sólo al final de la expresión) hace que el texto corresponda al pattern sólo si el pattern está al final del texto.

Algún ejemplo aclarará un poco las cosas.

"bla" =~ /\//
falso, ya que busca en "bla" el carácter /

"blh" =~ /\$/
falso, ya que busca en "bla" el carácter £

Por eso para buscar un carácter especial (o, si se quiere, reservado) hay que aclararlo a través del símbolo \ que se está buscando exactamente ese carácter y no su valor. Y lo mismo para la búsqueda con grep, y también con editor (vi, por ejemplo)

"bla" =~ /la/ verdadero
"bla" =~ /^la/ falso
"bla" =~ /^bl/ verdadero
"bla" =~ /h$/ verdadero
"bla" =~ /ls$/ falso
"bla" =~ /^bla$/ verdadero

Otros caracteres especiales son:
. -- busca cada carácter individual
\t -- busca una tabulación
\s -- busca un espacio o una tabulación
\S -- busca todo carácter que no sea una tabulación
\n -- busca una "newline"
\w -- busca toda letra concreta, cifra y también _
\W -- busca todo lo que no sea una letra, una cifra o _
\d -- busca toda cifra individual de 0 a 9
\D -- busca todo carácter que no sea una cifra

"bla" =~ /b.a/ verdadero
"bla" =~ /b.la/ falso
"bla" =~ /b\w.h$/ verdadero
"bla" =~ /\w\D/ vero
"bla" =~ /\d/ falso

[caracteres] -- busca todo carácter que esté entre [ ]

Además, un campo de búsqueda se puede especificar con - , por ejemplo [a-m] busca las letras entre la a y la m.
Si el primer carácter entre [ ] es ^ , al significado se le da la vuelta, y se buscará todo lo que NO está comprendido entre [ ]

[-.0.9] busca exactamente un - un . o una cifra

[^\@ \t] busca cualquier carácter que no sea un @, una tabulación o un espacio. Hay que señalar que \ delante de @ es opcional, ya que el símbolo @ no tiene significados particulares en este contexto, pero funciona también con \@

Cuantificadores:
determinan el número mínimo y máximo de veces que un determinado elemento tiene que repetirse consecutivamente:

( ) -- reagrupa más elementos en un pattern que se debe buscar una vez
* -- Corresponde al intervalo {0, } o bien de un mínimo de 0 veces a un máximo indefinido
+ -- Corresponde al intervalo {1, }
? -- Corresponde al intervalo {0, 1}
s -- Opera una sustitución
tr -- Opera una traducción en la forma 'tr [a-z] [A-Z]' (o bien convierte en mayúsculas los caracteres que están en minúscula y viceversa)

"bla" =~ /c*k*z?b+.l/ verdadero, dado que la c, la k y la z no están, la b aparece una vez y la l también

"ccckkzbbb8lZOINX" =~ /c*k*z?b+.l/ vedadero "blabla" =~ /ah(EEK)?bl/ verdadero "blaEEKbla" =~ /ah(EEK)?bl/ verdadero "blaEEKEEKbla" =~ /ah(EEK)?bl/ falso "blaEEKEEKbla" =~ /ah(EEK)+bl/ vero

/^([^\@ \t]+\@[^\@ \t])+\s+([-.0-9]+)$/

El último ejemplo corresponde a una línea que empieza con un número distinto de 0 de caracteres que no son ni @ ni espacios ni tabulaciones, después una @, luego otros caracteres que no son @ ni espacios ni tabulaciones, después algunos espacios y tabulaciones, luego cualquier mezcla de '-', '.' y cifra. Dicho vulgarmente, algo parecido a una dirección e-mail seguido de espacios y ¡algo que se puede pensar razonablemente como un número! En palabras aún más vulgares, una vez que se entiende cómo funcionan las expresiones regulares, resulta más fácil escribirlas que explicarlas.

/^\s*(\d+)\.(\d+)\.(\d+)\.(\d+)\s*$/

Esto, sin embargo, podría corresponderse con una dirección IP.
Además, si el pattern tiene sub-pattern (), éstos se asignan a variables numeradas, $1 para la primera, $2 para la segunda, etc.

"129.199.129.13" =~ /^\s*(\d+)\.(\d+)\.(\d+)\.(\d+)\s*$/;
$1 è 129, $2 è 199, $3 è 129, $4 è 13

Un pattern con sustitución se escribe de la forma:

$variable =~ s/pattern/replacement/;

El pattern es, como antes, una expresión regular, y el replacement es una cadena normal, excepto por el hecho de que las variables están interpoladas en su interior.
En la mayor parte de los casos, se puede añadir el carácter 'g' después del replacement, de manera que se cambien todas las palabras que corresponden al pattern, y no sólo la primera.

$waitops{$c} =~ s/:${oldnick}:/:${newnick}:/g

Las expresiones regulares trabajan con la función split, que toma como argumento una expresión regular, una variable escalar y, si se quiere, un segundo escalar que especifica el número máximo de campos en que splittare el pattern.

@array = split(/pattern/, expression);

En el caso más típico, se puede querer splittare una línea en palabras, como sigue:

@words = split(/\s+/, $some_line); # si $some_line era "a b c", ahora
@words es ("a", "b", "c")

SUBRUTINAS

Se pueden colocar en cualquier sitio en el programa, pero se suelen definir todas juntas o bien al principio o bien al final del programa.
Otro aspecto de interés en PERL es la definición y manejo de subrutinas.

A modo de ejemplo, una subrutina tiene el aspecto:

sub una_subrutina {
print "\n Mi primera subrutina en Perl...\n";
}

Comienzan por la palabra reservada sub, a continuación ponemos el nombre de la subrutina y el bloque o cuerpo.

Para llamarla desde el programa principal, debemos anteponer al nombre de la subrutina el símbolo &:

# llamada sin parametros
&una_subrutina;

# llamada con un parametro
&una_subrutina("hola");

# llamada con dos parametros
&una_subrutina(5-3, "segundo parametro");

Si llamamos a una subrutina con más parametros de los que debe recibir, no se produce ningún error, simplemente se ignoran los sobrantes.

Hacer un programa que incluye la subrutina vista más arriba. Cada vez que se llame a la subrutina debe mostrar el mismo mensaje (hasta que aprendamos a pasarle parámetros).



--------------------------------------------------------------------------------


2. Parametros.
Cuando una subrutina recibe parametros, estos son pasados como una lista en la variable-array especial @_. Ese array no tiene nada que ver con $_.
Si recordarmos las matrices veremos que cada uno de los parámetros será una variable dentro de la matriz que se direcciona así $_[0], $_[1],etc...


Llamada a la subrutina con 2 parámetros:
&saludo ("Hola","Mundo\n");

@_=("Hola","Mundo\n")

equivaldría a:

$_[0]="Hola" y $_[1]="Mundo\n"

El siguiente programa simplemente imprime la lista de argumentos con que se ha llamado:

sub print_args {
print "\n@_\n";
}

# imprimira "llamada con dos parametros"
&print_args("llamada con", "dos parametros");


# imprimira "llamada con TRES parametros"
&print_args("llamada con", "TRES", "parametros");

Al igual que otra variable-array, puede ser accedida con la notación de corchetes, mediante las variables $_[0], $_[1], ..., que nada tienen que ver con la variable $_:

sub print_2_args {
print "Primero= $_[0] \n";
print "Segundo= $_[1] \n";
}

Hacer un programa con una subrutina que recibe dos parámetros y los muestra por pantalla.


Otras variables que no sean las @_, $_[i] o las definidas como locales a que hagamos referencia dentro del la subrutina serán globales, con lo cual si modificamos alguna de ellas, al salir de la subrutina, se habrán modificado:

sub vars_globales {
$a =~ tr/a-z/A-Z/;
$b =~ tr/a-z/A-Z/;
( $a =~ /$b/ || $b =~ /$a/ );
}

primero se pasan los parametros a mayúsculas y después se comprueba si una contiene a la otra. Pero al volver de la llamada a la función, las variables que se le pasaron se ven modificadas:
$a = "liMonaDa";
$b = "lImOn";
$r = &vars_globales;
print "\n$r $a $b\n";

Imprimiría:
1 LIMONADA LIMON

A veces esto nos interesará, pero a veces no. Cuando no queramos ver modificadas las variables globales desde dentro de una subrutina, deberemos utilizar variables locales.
Si asignamos un valor a una nueva variable dentro de una subrutina, y esa variable no es local a la subrutina, se creará como global, pudiendo utilizarse al volver de la llamada a la subrutina:

sub vars_globales2 {
$nueva_variable = "valor";
}

&vars_globales2;
print "$nueva_variable"; # imprime "valor"


--------------------------------------------------------------------------------


3. Variables locales.
La variable @_, al igual que $_[0], $_[1], ... son locales a la subrutina. Perl permite que podamos definir en las subrutinas nuestras variables locales, mediante la palabra reservada local:
sub vars_locales {
local($a, $b);
($a, $b) = ($_[0], $_[1]);
( $a =~ /$b/ || $b =~ /$a/ );
}

devuelve verdadero si el primer parametro o el segundo esta dentro del otro (o falso en caso contrario).
Esta es la forma de evitar el problema que tenía la subrutina vars_globales
Las variables locales son útiles para no modificar las variables globales.

Al definir las variables locales podemos asignarles el valor en la misma línea con:

local($a, $b) = ($_[0], $_[1]);


--------------------------------------------------------------------------------


4. Valores de retorno.
PERL también nos permite retornar valores y lo hace tomando como retorno el último valor escalar que se emplee en la subrutina. El resultado que devuelve una subrutina es la última cosa evaluada.
Así, la subrutina que vimos antes que imprimía los parametros que recibía, devuelve siempre un 1 (verdadero), que es lo que devuelve la orden print.

Para devolver un valor, podemos hacer dos cosas:

sub maximo {
if( $_[0] > $_[1] ) {
$_[0];
}else{
$_[1];
}
}

$mayor = &maximo(37,23); #devuelve 37

o bien:
sub maximo {
if( $_[0] > $_[1] ) {
return $_[0];
}else{
return $_[1];
}
}

$mayor = &maximo(37,23); #devuelve 37

Hacer un programa que incluye una subrutina que devuelve un valor (se puede usar la subrutina anterior) y que el programa llamador la muestre.


Si no utilizamos "return", se devuelve el valor de lo último que evaluáramos:
sub Suma {
$Total = $_[0] + $_[1];
}

# Llamada a la subrutina
print &Suma (2,3);

La suma, el valor devuelto por la subrutina, y la salida del programa será: 5

Si tras la variable $Total tuviesemos otra variable, el valor final retornado sería el valor de esta última variable:
sub Suma {
$Total=$_[0] + $_[1];
$saludo = "Hola Mundo\n";
}

# Llamada a la subrutina
print &Suma (2,3);

La suma dará 5, pero el valor devuelto por la subrutina y la salida del programa será: Hola Mundo


--------------------------------------------------------------------------------

5. Paso de valores por referencia
Hasta ahora hemos visto el pasa de parámetros por valor, es decir, no es posible cambiar los valores globales de los argumentos. Para hacer esto posible es necesario pasar a la función no los valores, sino los nombres de estas variables. Este modo se denomina paso por referencia y se implementa prefijando el nombre de la variable con un arterisco *.
En el momento de la definición de una funcioón cuyos argumentos se pasan por referencia, la asignación de los argumentos a las variables locales se hacen mediante el operador local(*nombre). El ejemplo siguiente ilustra este modo de paso de argumentos describiendo la rutina swap que hace la permuta de los valores de los argumentos.

sub swap {
local(*x, *y) = @_; # asignación local de los argumentos
local($t); # variable local
$t = $x;
$x = $y;
$y = $t;
return @_; # resultado de la función
}
$a = 4; $b = 1;
&swap(*a, *b); # $a =1; $b = 4;
Resulta esencial que la asignación de los argumentos a las variables locales se haga mediante el operador local. Ya que la asignación directa de la variable mediante *nombre=valor modifica las ocurrencias de la variable nombre (globalmente en el script, sino se ha declarado explícitamente como local). Por ejemplo:

sub swap {
(*a, *b) = @_; # asignación de argumentos
local($t);
$t = $a;
$a = $b;
$b = $t;
return @_;
}
$a = 4; $b = 1;
$x = "pi"; $y = 1.414;
&swap(*x, *y); # $x = 1.414; $y = "pi"
print "a=$a, b=$b\n"; # $a = 1.414; $b = "pi"

ESTRUCTURAS DE CONTROL

El desarrollo de un programa viene determinado por el orden en que aparecen las instrucciones. El lenguaje Perl posee controlar un conjunto de instrucciones que permiten controlar el desarrollo de un programa. Estas instrucciones se denominan estructuras de control porque permiten ejecutar un conjunto de instrucciones cuando se verifica una condición o ejecutar iterativamente un bloque de instrucciones mientras una expresión sea válida.

1. La instrucción if.

Es muy parecida a la utilizada en C. La sintaxis de la instrucción if es la siguiente:

if (expresión) {
instrucción o bloque de intrucciones 1;
}
[else {
instrucción o bloque de intrucciones 2;
} ]
El programa evalúa la expresión. Cuando esta expresión resulta verdadera, se ejecuta la instrucción o el bloque de instrucciones 1. Por contra, cuando es falsa de ejecuta la instrucción o bloque de instrucciones 2. Esta última parte es opcional. Para representar una estructura de varios casos se utilizará la sintaxis siguiente:

if (expresión 1) {
instrucción o bloque de instrucciones 1;
}
elsif (expresión 2) {
instrucción o bloque de instrucciones 2;
}
elsif (expresión 3) {
instrucción o bloque de instrucciones 3;
}
else {
intrucción o bloque de instrucciones 4;
}
A continuación veremos un ejemplo sencillo del uso de esta estructura para comprender mejor su funcionamiento:

print "Introduzca un número del cero al dos y pulse Enter:\n";
$var = ;
if ($var == 0) {
print "Esta es la opción 0\n";
}
elsif ($var == 1) {
print "Esta es la opción 1\n";
}
elsif ($var == 2) {
print "Esta es la opción 2\n";
}
else {
print "No existe al opción tecleada\n";
}
2. La instrucción while.

La instrucción while ejecuta iterativamente un bloque de instrucciones mientras una expresión sea válida, evaluando la comprobación en cada iteración. Cuando la prueba es válida, se ejecuta la instrucción o el bloque de instrucciones delimitado por las llaves. La sintaxis de esta instrucción es:

while (expresión) {
instrucción o bloque de instrucciones;
}
He aquí un sencillo ejemplo de manejo de esta estructura:

print "Teclea \"x\" para salir:\n";
$ristra = "";
while ($ristra ne "x") {
$ristra = ;
chop($ristra);
print "Has escrito $ristra\n";
}
print "Salida.\n"
3. La instrucción for.

La instrucción for permite ejecutar iterativamente un conjunto de instrucciones. La sintaxis de la instrucción for es:

for (inicial_exp; test_exp; incremento_exp) {
instrucción o bloque de intrucciones;
}
donde:

inicial_exp es la instrucción que inicializa el bucle. Consiste generalmente en la asignación de un valor a una variable que permite controlar el número de iteraciones.
test_exp es la expresión evaluada en cada iteración. Cuando esta expresión es verdadera, el bloque de instrucciones se ejecuta.
incremento_exp es la expresión que permite la actualización de la variable que controla el número de iteraciones.
A continuación veremos un ejemplo de esta estructura para iniciarnos en su manejo:

print "10 Iteraciones\n";
for ($i=0; $i<10; $i++) {
print "Interación número $i\n";
}
4. La instrucción foreach.

La instrucción foreach es similar a la función del mismo nombre de los Shells de Unix. Asocia iterativamente a una variable cada elemento de la lista. Esta sucesión de valores sirve para parametrizar la ejecución del bloque de instrucción. La sintaxis de la instrucción foreach es:

foreach $variable (@lista) {
instrucción o bloque de instrucciones;
}
Las intrucciones for y foreach son equivalentes. Sin embargo, la utilización de una de estas instrucciones se justifica generalmente por el contexto. El ejemplo siguiente lo ilustra:

@lista = ("elem1", "elem2", "elem3", "elem4");
for ($i = 0; $i<= $#lista; $i++) {
print $lista[$i], "\n";
}
Este ejemplo no utiliza las características de los arrays en Perl. La utilización de la instrucción foreach permitirá recorrer la lista de forma más elegante. El ejemplo siguiente lo ilustra:

@lista = ("elem1", "elem2", "elem3", "elem4");
foreach $elem_actual (@lista) {
print $elem_actual, "\n";
}
5. La instrucción goto.

La instrucción goto label permite cambiar el recorrido lineal de las líneas de código prosiguiendo la ejecución del programa en la línea de etiqueta label. La etiqueta se define colocando al final del identificador dos puntos (:). En el siguiente ejemplo se podrá ver mejor la contrucción del goto.

if ($expr ne $expr_correcta) {
goto error;
}
...
error: print "expresión incorrecta";
La utilización del goto en Perl no es recomendable. Por que le quita al código legibilidad y aumenta la posibilidad de errores.

6. La instrucción last.

La instrucción last interrumpe la ejecución del bucle actual y se ejecuta la instrucción que sigue al bloque. El ejemplo siguiente permite interrumpir el bucle while cuando la variable i toma el valor 3.

$i = 0;
while($i < 6) {
if($i == 3) {
last;
}
$i++;
}
print "el valor de \$i es $i";
Cuando la instrucción tiene como argumento una etiqueta, la ejecución prosigue en la línea indicada por la etiqueta.

7. La instrucción next.

La instrucción next es idéntica a la instrucción continue en C. Interrumpe la ejecución del bloque de instrucción actual y prosigue la ejecución en la iteración siguente. Esta instrucción no interrumpe completamente la ejecución del bucle; la expresión que controla el bucle se evalúa. Si el resultado de la expresión es válido, el bucle se ejecuta de nuevo.

Cuando una instrucción tiene como argumento una etiqueta, la instrucción prosigue en la línea identificada por la etiqueta y no al principio del bloque.

Seguidamente veremos un ejemplo de dicha instrucción:

print "Teclea \"x\" para salir:\n";
print "Si se pulsa la tecla \"s\" no se imprime:\n";
$ristra = "";
while ($ristra ne "x") {
$ristra = ; chop($ristra);
if ($ristra eq "s") {
next;
}
print "Has escrito $ristra\n";
}
print "Salida.\n"
8. La instrucción until.

La instrucción until al igual que la instrucción while permite ejecutar un conjunto de instrucciones un número repetido de veces. Pero al contrario que la la instrucción while, la intrucción until ejecuta dicho bloque de instrucciones mientras no se verifique la comprobación. La sintaxis es:

until (expresión) {
instrucción o bloque de instrucciones;
}
He aquí el ejemplo anterior pero utilizando la instrucción until.

print "Teclea \"x\" para salir:\n";
print "Si se pulsa la tecla \"s\" no se imprime:\n";
$ristra = "";
until ($ristra eq "x") {
$ristra = ; chop($ristra);
if ($ristra eq "s") {
next;
}
print "Has escrito $ristra\n";
}
print "Salida.\n"
9. La instrucción unless.

Esta instrucción es análoga al if, salvo que permite considerar la no verificación de la prueba. Su sintaxis es la siguiente:

unless (expresión) {
instrucción o bloque de intrucciones 1;
}

Para ver mejor el funcionamiento del unless, modificaremos el ejemplo anterior para adaptarlo a dicha instrucción.

print "Teclea \"x\" para salir:\n";
print "Si se pulsa la tecla \"s\" no se imprime:\n";
$ristra = "";
until ($ristra eq "x") {
$ristra = ; chop($ristra);
unless ($ristra eq "s") {
next;
}
print "Has escrito $ristra\n";
}
print "Salida.\n"

miércoles, 24 de febrero de 2010

DATOS IMPORTANTES DE PROGRAMACION PERL

Desde sus inicios como un lenguaje administracion de ordenadores, se ha convertido en una herramienta general, usada en la programacion de sitios web ,bases de datos y grandes volumenes de datos , bioinformatica, e incluso inteligencia artificial . Unas de las ventajas de perl es la comunidad de usuarios : Aparte de la comunidad de usuarios de perl mongers (usuarios de perl) Hay listas de correo grupos de noticias y foros en la web, donde platear y resolver las dudas que surjan en el desarollo de su aplicacion . Perl ademas es ideal para desarrollo rapido de aplicaciones , aunque su moduralidad permite que se desarrollen aplicaciones mas complejas.