Introducción a la programación en Perl, CGI y Javascript
Tabla de contenido 2
Indice de tablas 4
Indice de ilustraciones 6
Objetivos de este trabajo 9
Introducción al Lenguaje Perl 10
Obtención en instalación de Perl 10
Perl básico 11
Hola mundo 11
Uso de variables y asideros de archivo6 11
Más sobre el uso de variables 12
Más sobre el uso de asideros 13
Arreglos, Arreglos asociativos y lazos 13
Arreglos y lazos con for 13
Arreglos asociativos y lazos con foreach 14
Lazos con while y uso de split() 14
Estructuras de decisión 15
Uso de patrones en búsquedas y reemplazos, usando expresiones regulares 17
Ejercicio 1: Uso de estructuras de decisión, patrones y estructuras de repetición 19
Solución: 19
Uso de rutinas en Perl 19
Referencias en Perl 21
Ejercicio 2: Uso de rutinas y referencias 22
Solución 23
Validación de programas en Perl 25
Seguridad en Perl 25
Depuración de programas en Perl 26
Perl en modo de advertencias (-w) 26
Perl en modo de depuración (-d) 27
Corregir sólo la sintaxis con -c 29
Ejercicio 3: Seguridad en Perl y depuración de programas 29
Solución 30
CGI (Common Gateway Interface) 31
Protocolos de comunicación 31
Modelo OSI y TCP/IP 31
HTTP 32
Modelo cliente - servidor 33
El cliente 33
El servidor 33
CGI 34
Funcionamiento de CGI 34
Generación dinámica de HTML 35
Ejercicio 4: Generación dinámica de HTML 36
Solución: 36
Métodos de comunicación 37
Método GET 38
Método POST 38
Variables de entorno adicionales 39
Codificación de los datos 39
Ejercicio 5: Variables de entorno 39
Solución 39
Formas en HTML 40
Elementos que contiene la etiqueta FORM 40
Uniendo todo: Manejo de los datos de una forma, seguridad 43
Ejercicio 6: Uso de formas y CGI 46
Solución 47
Introducción a Javascript 51
Objetos en Javascript 52
Métodos de los objetos en Javascript. Programación orientada a eventos. 53
Hola mundo en Javascript 54
Variables en Javascript 55
Funciones en Javascript 55
Estructuras de repetición 56
Sintaxis y ejemplo de Do - while 56
Sintaxis y ejemplo de For 56
Sintaxis y ejemplo de For in 56
Sintaxis y ejemplo de while: 57
Estructuras de decisión 57
Cajas de alerta, confirmación y preguntas 58
Expresiones regulares y arreglos 59
Arreglos 59
Expresiones regulares 60
Formas y validación 61
Ejercicio 7: Validación de Formas con Javascript 64
Solución 64
Referencias bibliográficas 67
Autor: José Vicente Núñez Zuleta (jose@ing.ula.ve) 1
Tabla de contenido 2
Indice de tablas 4
Indice de ilustraciones 6
Objetivos de este trabajo 9
Introducción al Lenguaje Perl 10
Obtención en instalación de Perl 10
Perl básico 11
Hola mundo 11
Uso de variables y asideros de archivo6 11
Más sobre el uso de variables 12
Más sobre el uso de asideros 13
Arreglos, Arreglos asociativos y lazos 13
Arreglos y lazos con for 13
Arreglos asociativos y lazos con foreach 14
Lazos con while y uso de split() 14
Estructuras de decisión 15
Uso de patrones en búsquedas y reemplazos, usando expresiones regulares 17
Ejercicio 1: Uso de estructuras de decisión, patrones y estructuras de repetición 19
Solución: 19
Uso de rutinas en Perl 19
Referencias en Perl 21
Ejercicio 2: Uso de rutinas y referencias 22
Solución 23
Validación de programas en Perl 25
Seguridad en Perl 25
Depuración de programas en Perl 26
Perl en modo de advertencias (-w) 26
Perl en modo de depuración (-d) 27
Listando código fuente y el contenido de las variables 27
Ejecutando el código fuente 28
Puntos de quiebre, ejecución continua del programa 28
Busqueda con patrones 29
Corregir sólo la sintaxis con -c 29
Ejercicio 3: Seguridad en Perl y depuración de programas 29
Solución 30
CGI (Common Gateway Interface) 31
Protocolos de comunicación 31
Modelo OSI y TCP/IP 31
HTTP 32
Modelo cliente - servidor 33
El cliente 33
El servidor 33
CGI 34
Funcionamiento de CGI 34
Generación dinámica de HTML 35
Ejercicio 4: Generación dinámica de HTML 36
Solución: 36
Métodos de comunicación 37
Método GET 38
Método POST 38
Variables de entorno adicionales 39
Codificación de los datos 39
Ejercicio 5: Variables de entorno 39
Solución 39
Formas en HTML 40
Elementos que contiene la etiqueta FORM 40
Input: Recolecta información acerca del usuario 40
Option: Ocurre dentro del elemento select, el cual le permite al usuario escoger entre varias alternativas, y es usado para representar cada opción de select. 41
Select: Le permite al usuario escoger entre múltiples alternativas 41
Textarea: Recolecta múltiples líneas de texto por el usuario. Al usuario se le presenta un panel cuadrado en el cual puede escribir. Se usa en pares. 41
Uniendo todo: Manejo de los datos de una forma, seguridad 43
Ejercicio 6: Uso de formas y CGI 46
Solución 47
Introducción a Javascript 51
Objetos en Javascript 52
Métodos de los objetos en Javascript. Programación orientada a eventos. 53
Hola mundo en Javascript 54
Variables en Javascript 55
Funciones en Javascript 55
Estructuras de repetición 56
Sintaxis y ejemplo de Do - while 56
Sintaxis y ejemplo de For 56
Sintaxis y ejemplo de For in 56
Sintaxis y ejemplo de while: 57
Estructuras de decisión 57
Cajas de alerta, confirmación y preguntas 58
Expresiones regulares y arreglos 59
Arreglos 59
Expresiones regulares 60
Formas y validación 61
Ejercicio 7: Validación de Formas con Javascript 64
Solución 64
Referencias bibliográficas 67
Autor: José Vicente Núñez Zuleta (jose@ing.ula.ve) 1
Tabla de contenido 2
Indice de tablas 4
Indice de ilustraciones 6
Objetivos de este trabajo 9
Introducción al Lenguaje Perl 10
Obtención en instalación de Perl 10
Perl básico 11
Hola mundo 11
Uso de variables y asideros de archivo6 11
Más sobre el uso de variables 12
Más sobre el uso de asideros 13
Arreglos, Arreglos asociativos y lazos 13
Arreglos y lazos con for 13
Arreglos asociativos y lazos con foreach 14
Lazos con while y uso de split() 14
Estructuras de decisión 15
Uso de patrones en búsquedas y reemplazos, usando expresiones regulares 17
Ejercicio 1: Uso de estructuras de decisión, patrones y estructuras de repetición 19
Solución: 19
Uso de rutinas en Perl 19
Referencias en Perl 21
Ejercicio 2: Uso de rutinas y referencias 22
Solución 23
Validación de programas en Perl 25
Seguridad en Perl 25
Depuración de programas en Perl 26
Perl en modo de advertencias (-w) 26
Perl en modo de depuración (-d) 27
Listando código fuente y el contenido de las variables 27
Ejecutando el código fuente 28
Puntos de quiebre, ejecución continua del programa 28
Busqueda con patrones 29
Corregir sólo la sintaxis con -c 29
Ejercicio 3: Seguridad en Perl y depuración de programas 29
Solución 30
CGI (Common Gateway Interface) 31
Protocolos de comunicación 31
Modelo OSI y TCP/IP 31
HTTP 32
Modelo cliente - servidor 33
El cliente 33
El servidor 33
CGI 34
Funcionamiento de CGI 34
Generación dinámica de HTML 35
Ejercicio 4: Generación dinámica de HTML 36
Solución: 36
Métodos de comunicación 37
Método GET 38
Método POST 38
Variables de entorno adicionales 39
Codificación de los datos 39
Ejercicio 5: Variables de entorno 39
Solución 39
Formas en HTML 40
Elementos que contiene la etiqueta FORM 40
Input: Recolecta información acerca del usuario 40
Option: Ocurre dentro del elemento select, el cual le permite al usuario escoger entre varias alternativas, y es usado para representar cada opción de select. 41
Select: Le permite al usuario escoger entre múltiples alternativas 41
Textarea: Recolecta múltiples líneas de texto por el usuario. Al usuario se le presenta un panel cuadrado en el cual puede escribir. Se usa en pares. 41
Uniendo todo: Manejo de los datos de una forma, seguridad 43
Ejercicio 6: Uso de formas y CGI 46
Solución 47
Introducción a Javascript 51
Objetos en Javascript 52
Métodos de los objetos en Javascript. Programación orientada a eventos. 53
Hola mundo en Javascript 54
Variables en Javascript 55
Funciones en Javascript 55
Estructuras de repetición 56
Sintaxis y ejemplo de Do - while 56
Sintaxis y ejemplo de For 56
Sintaxis y ejemplo de For in 56
Sintaxis y ejemplo de while: 57
Estructuras de decisión 57
Cajas de alerta, confirmación y preguntas 58
Expresiones regulares y arreglos 59
Arreglos 59
Expresiones regulares 60
Formas y validación 61
Ejercicio 7: Validación de Formas con Javascript 64
Solución 64
Referencias bibliográficas 67
Está trabajo teórico / práctico persigue los siguientes objetivos:
Obtención de destrezas básicas en la programación y depuración de programas en Perl.
Comprensión de que es y como funciona CGI, así como la elaboración y depuración de programas sencillos.
Introducir a la programación con Javascript y la validación de formas en aplicaciones cliente - servidor.
Introducir a la programación de scripts seguros (con y sin CGI).
Durante todo este trabajo se presenta código fuente como ejemplo para explicar los conceptos teóricos. Al final de cada sección se proponen ejercicios para que sean realizados por el lector.
La plataforma utilizada para la elaboración de los ejercicios fue Linux Slackware 3.4, por lo que algunos comandos podrían variar de plataforma en plataforma. El servidor Web utilizado para correr los ejemplos fue Apache versión 1.3.0. Los programas hechos en Javascript fueron probados con Netscape Communicator 4.05. La versión de Perl Utilizada fue 5.04, la versión de Javascript fue 1.2.
Algunos conceptos fueron omitidos o tratados de manera breve por razones de espacio. Nada puede reemplazar la práctica y la investigación, por lo que se remite al lector interesado a la bibliografía al final de este documento.
Se supone que el lector tiene conocimientos básicos de programación en algún lenguaje estructurado, que tiene conocimientos básicos sobre Unix y HTML y que sabe utilizar un browser para navegar por internet.
Sí encuentra fallas o desea hacer algún comentario adicional puede escribir a:
Jose@ing.ula.ve
José Vicente Núñez Zuleta.
Perl es un lenguaje que permite la manipulación de archivos de texto y procesos. Perl provee una manera concisa y fácil para hacer las cosas las cuales pueden más difíciles en C o en Shell. Esas fueron las ideas que motivaron a su autor (Larry Wall)[11].
En el principio, Perl fue pensado como un leguaje de reducción de datos, Un lenguaje que permitiera navegar con facilidad y de manera arbitraria por archivos de texto de manera eficiente; Sin embargo Perl ha evolucionado tanto que hoy en día se le considera como una herramienta de programación en Internet y Administración de sistemas y redes Unix.
Las siguientes son algunas de las razones por las cuales Perl es popular:
Reduce el ciclo de programación. No tiene que compilar su aplicación, Perl es interpretado y por ello sus programas pueden ser corridos en muchas plataformas sin necesidad de ser recompilado.1
Es portable, ya que hay un interpretador de Perl para cada variedad de Unix y Windows, por lo que los cambios que debe hacer a su aplicación son mínimos o nulos.
Puede hacer mejor muchas cosas que serían más difíciles en otros lenguajes como C o Shell, como la manipulación de archivos de texto.
La sintaxis de otros lenguajes como Shell, Sed, AWK o C es muy similar a la de Perl. Inclusive cuenta con herramientas para traducir código de Sed y AWK a Perl de manera automática.
Es extensible. En Internet puede conseguir una enorme cantidad de módulos los cuales pueden ser incluidos en sus programas sin ninguna dificultad. Si lo desea, puede desarrollar sus propias extenciones.
No cuesta nada. Perl esta protegido por una licencia artística, la cual permite su libre distribución.
Es confiable y robusto. Programas como dnswalk, Majordomo y otros están hechos en Perl.
Sin embargo, pueden haber cosas del lenguaje que no le gusten como:
Cualquiera puede ver el código fuente de su aplicación porque el código es interpretado y no compilado.
Por ser interpretado y no compilado su velocidad puede ser inferior a la versión en C en algunos casos.
Teniendo esto en cuenta, usted puede decidir si Perl se adapta o no a sus necesidades.
Puede conseguir la última versión de Perl2 en su página Web [8]:
http://www.perl.com
Básicamente, lo que debe hacer para instalar Perl es lo siguiente:
Descomprimalo con gunzip xxx.tar.gz
Desempaquetelo en un directorio con tar -xvf xxx.tar.gz
Ejecute el script configure (por ejemplo configure -Dcc=gcc)
Escoja el sistema operativo sobre el cual correrá Perl
De aquí en adelante responderá muchas preguntas, de acuerdo a su sistema operativo (Crear las dependencias del programa con make depend, entre otros)3
Luego corra los tests (el instalador le dirá como) y finalmente ejecute el comando make install.
A continuación se muestra el programa "hola mundo", escrito en Perl:4
#!/usr/bin/perl
print("Hola mundo cruel\n");
Guarde este pequeño fragmento de código como hola_mundo.pl, cambie su permisología a ejecución sólo por el usuario, y córralo:
$host> chmod u+x hola.pl
$host> hola.pl
Hola mundo
La línea 1 contiene lo que se conoce como una "galleta mágica" y le indica al programa en donde se encuentra el interpretador de Perl. La segunda línea le dice a Perl que imprima un mensaje por pantalla (Nótese el enorme parecido con la orden printf de C). Fíjese que cada comando en Perl termina en punto y coma ";".
Otra forma de correr ese script es eliminando la primera línea y diciéndole a Perl que corra el script directamente:
$host> perl hola.pl
Hola mundo
$host>
La línea de comandos de Perl es muy extensa, por lo que mencionaremos sólo lo necesario5.
El programa anterior es bastante limitado, por lo que extenderemos su utilidad con el uso de variables:
#!/usr/bin/perl
print("Por favor introduzca su nombre\n");
$nombre=<STDIN>;
print("Hola $nombre, ese es un nombre bonito\n");
En la línea 3 hace una asignación a la variable $nombre de lo que se "capture" por el asidero de archivos estándar STDIN (Standard Input). Luego mostramos el contenido de esa variable en la línea 4. STDIN, STDOUT y STDERR son llamados asideros y vienen por omisión en cualquier sistema operativo, por lo que Perl provee acceso directo a ellos. STDIN, STDOUT y STDERR son entrada, salida y error estándar respectivamente. Note como al declarar a la variable $nombre no se le especifico ningún tipo.
Corramos el programa para ver que hace:
$host> hola.pl
Escriba por favor su nombre
Jose Vicente
Hola Jose Vicente
, ese es un nombre bonito
¡Hay algo mal!, El programa está capturando el retorno de carro introducido después de obtener el nombre. Eso lo podemos solucionar con la rutina chop(), la cual elimina el último carácter de una variable:
#!/usr/bin/perl
print("Escriba por favor su nombre\n");
$nombre=<STDIN>;
chop($nombre); # Eliminamos el retorno de carro
print("Hola $nombre, ese es un nombre bonito\n");
Vea como en la línea 4 introducimos un comentario, utilizando el carácter #.
Corra el programa de nuevo y note el cambio.
En Perl:
No se utilizan tipos de datos en la declaración de variables
Las variables pueden declararse a cualquier altura del código
Los asideros permiten acceder a recursos del sistema como la salida y entrada por omisión.
En Perl no hace falta declarar el tipo de una variable como en C o Pascal; Otra diferencia es que Perl internamente utiliza sólo dos tipos de variables: Cadena de caracteres o números reales. Veamos por ejemplo, como el siguiente programa es correcto.
#!/usr/bin/perl
# Colocamos una cadena de caracteres
$variable="Hola, contengo una cadena";
print("El contenido de \$variable es :\t $variable\n");
# Colocamos ahora un numero real
$variable=3.141616;
print("El contenido de \$variable es :\t $variable\n");
# Colocamos ahora un entero
$variable=55;
print("El contenido de \$variable es :\t $variable\n");
Veamos su salida por pantalla:
leon[80] $host> variables.pl
El contenido de $variable es : Hola, contengo una cadena
El contenido de $variable es : 3.141616
El contenido de $variable es : 55
Hemos introducido dos trucos nuevos: el uso del carácter "\" delante de otro (Le dice a Perl que no interprete el carácter, sino que lo proteja y "\t" (Deje una tabulación).
Veamos otras formas de asignación de variables:
$respuesta=666; # Un número entero
$pi=3.141516; # Un número real
$cantidad=55e2; # Notación cientifica
$mascota='Godzila'; #Una cadena
$aviso="$mascota, cuando el tamaño cuenta\n"; # Interpolación de variables
$Directorio='ls'; # Guarda el resultado de la ejecución de un comando
Note que Perl distingue el uso de mayúsculas y minúsculas en la declaración de variables.
La importancia real de los asideros está en que nos permiten redirigir la entrada y la salida de información en nuestro programa. Veamos brevemente las operaciones posibles con los asideros:
open(ASIDERO,"nombre del archivo"); # Abre el archivo para lectura
open(ASIDERO,">nombre del archivo"); # Abre el archivo para lectura, escritura
open(ASIDERO,">>nombre del archivo"); # Le agrega al archivo
open(ASIDERO,"| comando de salida"); # Envía salida a un filtro
open(ASIDERO,"nombre del archivo |"); # Recoge la salida de un filtro
En el siguiente ejemplo, los asideros se utilizarán para acceder a las facilidades del sistema:
#!/usr/bin/perl
# Veamos el contenido del archivo /etc/hosts
# para ello se utiliza cat y eliminamos todos los
# comentarios
open(ARCHIVO,"cat /etc/hosts|grep -v '#' |");
print <ARCHIVO>,"\n";
# cerramos el archivo (No hace falta, perl lo hace solo)
close(ARCHIVO);
Fíjese como en la línea 5 abrimos un asidero, utilizando un filtro compuesto por cat y grep para luego mostrar el resultado imprimiendo el contenido del asidero. Más adelante se explicará porque este programa es inseguro.
Perl cuenta con ciertas estructuras de repetición, las cuales le permiten procesar cierto grupo de instrucciones de manera repetitiva.
Un arreglo no es más que un conjunto de elementos almacenados en direcciones contiguas de memoria. Veamos como funcionan con el siguiente ejemplo:
#!/usr/bin/perl
@usuarios=('jose','luis','pepe'); #Nombres de los usuarios
@peso_kg=(70.5,90,65.4); #Peso
$num=@usuarios;
print("Usuarios a ser procesados: $num\n");
for($i=0;$i<=$#usuarios;$i++) {
print("Nombre:\t$usuarios[$i],\tPeso:\t$peso_kg[$i]\n");
}
En las líneas 1 y dos se muestra como se puede inicializar a un arreglo (Denotado con el símbolo @). Obtenemos la cantidad de elementos que tiene almacenados con la instrucción que se muestra en la línea 3 y luego mostramos elemento por elemento en un lazo de repetición (utilizando un blucle for) el cual se mueve desde el primer elemento (con índice 0) hasta el último ($#usuarios), incrementando el contador de uno en uno.
Este programa pudo ser implementado de otra forma. Perl cuenta con una estructura llamada arreglo asociativo o hash, la cual asocia una clave con un valor:
#!/usr/bin/perl
# Guardamos el nombre y peso de la persona en un solo sitio
%usuarios=(
'jose', 70.5,
'luis', 90,
'pepe', 65.4,
);
# Averiguamos cuantos elementos tiene el hash
$num=0;
# Repetimos el lazo por cada una de las claves del
# hash, incrementando el contador
foreach $aux (keys(%usuarios)) {
$num++;
}
print("Usuarios a ser procesados: $num\n");
foreach $aux (keys(%usuarios)) {
print("Nombre:\t$aux,\tPeso:\t$usuarios{$aux}\n");
}
Fíjese como la iniciación de un hash (líneas 3 a la 7) implica llenar dos valores: uno de ellos es la clave (en este caso el nombre) y el otro su valor asociado (el peso). Note también la forma de acceder a los valores del hash: Si no conocemos las claves, entonces las obtenemos por medio de la función keys(), luego vemos el contenido asociado usando $hash{$clave}.
El comando foreach7 obtiene todas las claves del hash usuarios con ayuda de keys() y hace un recorrido (una por una) guardándolas en $aux.
Los lazos con for y foreach son útiles, pero tienen limitaciones cuando se trata de utilizar una condición lógica complicada en la estructura de repetición. Es allí donde el uso de lazos con while se hace obligatorio. Ilustraremos esto con un programa que lee el contenido de una base de datos:
150.185.128.1 merlin SunOS
150.185.128.15 gandalf Solaris
150.185.128.2 arha SunOS
150.185.128.128 randu Linux
150.185.128.12 melchor SunOS
150.185.128.80 medussa Solaris
150.185.128.123 sorceles Linux
150.185.131.1 zeus Windows
Veamos el código que permite ver sus valores por pantalla:
#!/usr/bin/perl
print("Cargando la base de datos...");
open(ARCHIVO,"maquinas.txt") || die "no pude abrir el archivo $!\n";
print("listo!\n");
while(<ARCHIVO>) {
chop($_); # Eliminamos el retorno de carro
($ip,$nombre,$so)=split(' ',$_);
print("Nombre :$nombre <$ip,$so>\n");
}
En la línea 2 se utiliza el operador lógico || ("or", más adelante se explicará con más detalle) para validar la si se ha podido abrir el archivo; Si falla la apertura del archivo, la función die() muestra un mensaje por pantalla y aborta la ejecución del script; Este es el uso más común de die().
En la línea 5 el programa entra en el lazo condicional de un bucle while. Este continuará repitiéndose indefinidamente mientras la condición encerrada entre paréntesis sea verdadera (En este caso, que no haya fin de archivo). Si la condición no se cumple, se sale del bucle, o nunca se entra. En este caso cada ciclo del bucle avanza el apuntador al archivo que al principio estaba en la primera línea a la siguiente, hasta que se llegue al fin del archivo. Como se abrió el archivo para lectura, cada línea es "leída del archivo" y es referenciada por <ARCHIVO>.
En la línea 6 se utiliza una variable especial llamada "$_". Significa "la variable actual", y en este caso se refiere a la línea que esta siendo leída en el bucle. Se necesita quitar el carácter de retorno de carro al final de la línea, por lo que se utiliza a la rutina chop().
En la línea 7 se divide a la variable $_ en tres partes para ser almacenados en $ip, $nombre y $so respectivamente, con ayuda de la rutina split(). Split utiliza como separador de campos un espacio en blanco (hablamos de un separador de campos ya que cada palabra en la línea esta separada por un espacio).
En la línea 8 se muestra el contenido de la base de datos con la función print().
Las estructuras de decisión tienen la siguiente forma en Perl:
If (condición) {
Código;
} elsif (condición) {
más código;
} else {
aún más código;
}
Supongamos que en el ejemplo anterior, se modifica a la base de datos para indique si la máquina es un servidor o no, el programa debe mostrar el nuevo campo por pantalla. Se cometio un error intencional en el archivo, colocando el tipo de medussa en minúsculas. Este tipo de error de entrada de datos es muy común, y se solucionará más adelante:
150.185.128.1 merlin SunOS Servidor
150.185.128.15 gandalf Solaris Cliente
150.185.128.2 arha SunOS Servidor
150.185.128.128 randu Linux Cliente
150.185.128.12 melchor SunOS Cliente
150.185.128.80 medussa Solaris cliente
150.185.128.123 sorceles Linux Servidor
150.185.131.1 zeus Windows Cliente
El siguiente código muestra el uso de las estructuras de decisión:
#!/usr/bin/perl
print("Cargando la base de datos...");
open(ARCHIVO,"maquinas2.txt") || die "no pude abrir el archivo $!\n";
print("listo!\n");
while(<ARCHIVO>) {
chop($_); # Eliminamos el retorno de carro
($ip,$nombre,$so,$tipo)=split(' ',$_);
if ($tipo eq "Servidor") {
print("Servidor->\t");
} elsif ($tipo eq "Cliente") {
print("Cliente->\t");
} else {
print("Desconocido->\t");
}
print("Nombre :$nombre <$ip,$so>\n");
}
En la línea 8 se valida que la variable $tipo sea igual a "Servidor", utilizando el comparador de cadenas; Si no se cumple entonces comparamos para ver si es un "Cliente". Si no es ninguno de los dos tipos le asignamos "Desconocido":
leon[246] Si maestro while2.pl
Cargando la base de datos...listo!
Servidor-> Nombre :merlin <150.185.128.1,SunOS>
Cliente-> Nombre :gandalf <150.185.128.15,Solaris>
Servidor-> Nombre :arha <150.185.128.2,SunOS>
Cliente-> Nombre :randu <150.185.128.128,Linux>
Cliente-> Nombre :melchor <150.185.128.12,SunOS>
Desconocido-> Nombre :medussa <150.185.128.80,Solaris>
Servidor-> Nombre :sorceles <150.185.128.123,Linux>
Cliente-> Nombre :zeus <150.185.131.1,Windows>
La comparación de cadenas presenta el inconveniente de que la comparación es absoluta, es decir la cadena buscada tiene que coincidir de manera exacta con la cadena candidata, sino falla la.
Las condiciones lógicas de los if - else pueden ser tan complejas como se desee, y pueden estar anidadas si se quiere. Suponga por ejemplo que ninguna de las máquinas con Windows es servidora, entonces podría hacerce la siguiente modificación al programa en la línea 8, utilizando una comparación compuesta unida por una condición "y":
if (($tipo eq "Servidor") && ($so ne "Windows")) {
Se muestra a continuación un pequeño resumen de las posibles comparaciones lógicas que pueden hacerce bajo Perl:
|
Operador lógico |
Significado |
Resultado |
|
$a && $b |
And (Y) |
Verdadero si a y b son verdaderos |
|
$a || $b |
Or (O) |
$a si $a es verdadero, de lo contrario $b |
|
! $a |
Not (Negación) |
Verdadero si $a es falso |
Tabla 1: Operadores lógicos posibles bajo Perl
Y estas son las comparaciones entre variables que se pueden hacer:
|
Prueba numérica |
Prueba de cadena |
Significado |
|
== |
Eq |
Es igual a |
|
!= |
En |
diferente |
|
> |
Gt |
Más grande que |
|
>= |
Ge |
Mayor o igual |
|
< |
Lt |
Menor que |
|
<= |
Le |
Menor o igual |
|
< = > |
Cmp |
No es igual, con signo |
Tabla 2: Comparaciones lógicas posibles
Una de las características más atractivas de Perl es que permite identificar o cambiar porciones de texto de manera flexible, utilizando lo que se conocen como patrones. La sintaxis de un patrón es:
|
Patrón de búsqueda |
Resultado |
|
$variable =~ /patrón/ |
Retorna verdadero si patrón está dentro de $variable |
|
$variable =~ s/patrón viejo/nuevo patrón/ |
Sustituye el patrón viejo por el patrón nuevo |
|
$variable =~ tr/a-z/A-Z/ |
Convierte de minúsculas a mayúsculas el contenido de $variable. |
Tabla 3: Patrones de búsqueda y reemplazo más comunes
El programa que se mostró en el paso anterior tenía el inconveniente de que realizaba comparaciones absolutas; Para un usuario seria más cómodo poder escribir en mayúsculas o minúsculas en el archivo de datos y que el progerama se ocupara de corregir la apariencia del contenido; También sería comodo poder utilizar uno o más espacios o tabuladores para separar la información de cada máquina:
150.185.128.1 merlin SunOS Servidor
150.185.128.15 gandalf Solaris Cliente
150.185.128.2 arha SunOS SERVIDOR
150.185.128.128 randu Linux cLiENte
150.185.128.12 melchor SunOS Cliente
150.185.128.80 medussa Solaris cliente
150.185.128.123 sorceles Linux Servidor
150.185.131.1 zeus Windows CliENTE
El siguiente código permite hacer eso utilizando caracteres especiales y expresiones regulares:
#!/usr/bin/perl
print("Cargando la base de datos...");
open(ARCHIVO,"maquinas3.txt") || die "no pude abrir el archivo $!\n";
print("listo!\n");
while(<ARCHIVO>) {
chop($_); # Eliminamos el retorno de carro
($ip,$nombre,$so,$tipo)=split('\s+',$_);
$tipo =~ tr/a-z/A-Z/; #Convertimos el tipo a mayusculas
$aux=$so; # Guardamos el viejo valor de $so
$so =~ tr/a-z/A-Z/; #Convertimos $so a mayusculas
if (($tipo eq "SERVIDOR") && ($so ne "WINDOWS")) {
print("Servidor->\t");
} elsif ($tipo eq "CLIENTE") {
print("Cliente->\t");
} else {
print("Desconocido->\t");
}
$so=$aux;
print("Nombre :$nombre <$ip,$so>\n");
}
En la línea 7 se sutituye el espacio en blanco (que es poco flexible), por la expresión \s+. Para entender lo que significa, se descompondrá la expresión:
Proteja el carácter "s" poniéndole un \ adelante8
El carácter s significa un carácter de espacio (espacio en blanco, tabulación).
+ significa uno o más
La conversión de minúsculas a mayúsculas se hace en las líneas 8 y 10. En las líneas 11 y 13 se hace una comparación con los valores, pero en mayúsculas, lo cual facilita la programación.
La siguiente tabla contiene caracteres para expresiones regulares:
|
Carácter especial |
Significado |
|
. |
Encuentra cualquier carácter, excepto una nueva línea |
|
[a-z0-9] |
Encuentra cualquier carácter del conjunto |
|
[^a-z-0-9] |
Encuentra cualquier carácter que no este en el conjunto |
|
\d |
Encuentra cualquier dígito |
|
\D |
Encuentra cualquier cosa que no sea un dígito |
|
\w |
Encuentra cualquier carácter alfanumérico |
|
\W |
Encuentra cualquier carácter no alfanumérico |
|
\s |
Encuentra un carácter de espacio (espacio, tabulación, nueva línea) |
|
\S |
Encuentra un carácter que no sea de espacio (espacio, tabulación, nueva línea) |
|
\n |
Encuentra una nueva línea |
|
\r |
Encuentra un retorno |
|
fi|fa|fo |
Encuentra a fi o a fo o a fu en una cadena de caracteres |
|
x? |
Encuentra uno o cero x |
|
x* |
Encuentra cero o más x |
|
x+ |
Encuentra una o más x |
|
\b |
Encuentra dentro de un bloque de palabra |
|
\B |
Encuentra fuera de un bloque de palabra |
|
^ |
Encuentra al principio de la línea |
|
$ |
Encuentra al final de la línea |
Tabla 4: Algunas expresiones regulares
Haga un programa que muestre el siguiente menú por pantalla:
¡Bienvenido al la votación del mundial, Francia 98!:
Por favor, escriba el nombre del país por el cual desea votar:
Brasil
Colombia
Alemania
Argentina
Salir: escriba "gol" o "salir"
Para salir debe escribir "gol" o "salir". Si el usuario escribe una opción que no está especificada, el programa vuelve a mostrar el menú.
Al terminar el programa, debe mostrar la cantidad de votos obtenidos por cada País.
#!/usr/bin/perl -w
$respuesta="";
%votacion=(
brasil=>0,
colombia=>0,
alemania=>0,
argentina=>0,
);
while (($respuesta ne "gol") && ($respuesta ne "salir")) {
if ($respuesta eq "brasil") {
$votacion{'brasil'}++;
} elsif ($respuesta eq "colombia") {
$votacion{'colombia'}++;
} elsif ($respuesta eq "alemania") {
$votacion{'alemania'}++;
} elsif ($respuesta eq "argentina") {
$votacion{'argentina'}++;
}