Las expresiones regulares en PERL nos permiten evaluar o comparar la existencia de un patrón de búsqueda en una cadena o un valor determinado; así por ejemplo, si se tiene un archivo de muchas líneas y se quiere imprimir las líneas que tengan en su inicio un determinado carácter, o se desea reemplazar todas las ocurrencias de una determinada palabra dentro del fichero , se deben emplear las expresiones regulares. Se pueden dividir las expresiones regulares en los siguientes tipos:

• Expresiones regulares de comparación : Nos permiten evaluar si un patrón de búsqueda se encuentra en una cadena de caracteres, de modo que mediante este tipo de expresiones regulares obtendremos un valor lógico verdadero o falso según se encuentre el patrón deseado. La sintaxis de este tipo de expresiones regulares es la siguiente:

  	valor a comparar =~ /patrón de búsqueda/;
  

  El principal uso de las expresiones regulares de comparación es la formulación de condiciones en cualquiera de las estructura lógica estructuras lógicas
permitidas en PERL. Las expresiones regulares de comparación soportan la siguiente opción:
• i; formato: /(PATRON)/i. Mediante esta opción se consigue que la comparación entre la variable y el patrón se realize sin importar minusculas o mayusculas.

• Expresiones regulares de sustitución: Esta herramienta permite cambiar los patrones de busqueda por caracteres nuevos definidos por el usuario que componen el patrón de sustitución, la sintaxis es la siguiente :

    valor a sustituir =~ s/patrón de búsqueda/sustitución/;
  

  Dentro de las expresiones regulares de sustitución encontramos las siguientes opciones:
  • opción: i; formato: (s/PATRON DE BUSQUEDA /SUSTITUCION DE SUSTITUCION/i) : funciona de igual manera que en el caso de una comparación, ignora las mayúsculas en el reemplazo.

  • opción: g; formato: (s/PATRON DE BUSQUEDA /PATRON DE SUSTITUCION/g) : esta opción permite reemplazar todas las ocurrencias del patrón de búsqueda. En el caso de no emplear esta opción, la sustitución se realizará sólo con la primera ocurrencia del patrón de sustitución.

  • opción: e; formato: (s/PATRON DE BUSQUEDA/PATRON DE SUSTITUCION/e): con esta opción se puede evaluar la parte de la sustitución (SUSTITUCION),con valores devueltos por una función.

• Expresiones regulares de traducción: Este tipo de expresiones regulares tienen una manera de trabajar muy parecida a la de las sustituciones. En este caso se trata de comparar uno a uno los caracteres del patrón de búsqueda con los de la cadena de sustitución, de modo que cada vez que se encuentra una ocurrencia que coincide con uno de los caracteres del patrón se intercambia por su correspondiente en la cadena del patrón de sustitución. La sintaxis general de esta expresion regular es la siguiente:

     variable =~ tr/(patrón de búsqueda)/(cadena_a_traducir)      
  

  Las expresiones regulares de traducción no tienen opciones, la busqueda y sustitución se realiza en el contenido de toda la variable.

  Pasamos a mostrar un ejemplo que ilustre todo lo anteriormente dicho de las expresiones regulares:

  Supongamos que tene una archivo de tipo texto con el siguiente contenido:

    tres perros tres gatos y tres elefantes.
  

  Las siguientes expresiones regulares casuarán los efectos que se especifican:

       
  open (AR,'prueba.prb')|| die "$!\n";
   while (<AR>)
    { 
      if( $_  =~ /tres/
     {  print  "Se ha encontrado la cadena 'tres'";}
    }
     

  El segmento de codigo anterior realiza las siguientes operaciones: abre un fichero prueba.prb de tipo texto y lo asigna a la variable AR, trás lo que realiza un bucle while que permite recorrer todo el contenido del fichero. Dentro de este bucle, utilizando la variable predefinida $_ (que guarda el contenido de la última linea del fichero definido como entrada); observa mediante una condición if si dentro del registro existe una cadena igual a 'tres'. Como se ve dentro de la condición se utiliza una expresión regular de comparación que devolvera cierto si se encuentra la cadena patrón dentro de la variable ( en este caso el contenido de una línea). En el caso de que la expresión regular devuelva cierto se indica que se encontró la cadena buscada.

       
  open (AR,'prueba.prb')|| die "$!\n";
   while (<AR>)
    { 
       $_  =~ s/tres/---/g;
      print  ;
    }
     

  Este ejemplo, entra de manera similar al anterior dentro del fichero prueba.prb, tras lo que sustituye dentro de este fichero todas las ocurrencias de la cadena 'tres' por la cadena '---'. Esto se realiza mediante una expresión regular de sustitución. Con esto la salida por pantalla sería la siguiente:

       --- perros --- gatos y --- elefantes.
  
     
       
  open (AR,'prueba.prb')|| die "$!\n";
   while (<AR>)
    { 
      $_  =~ tr/tre/1234/;
      print ;
    }
     

  La salida por pantalla de este ejemplo es la siguiente:

   123s p322os 123s ga1os y 123s 313fan13s.

  El código anterior realiza una traducción en el contenido de nuestro fichero prueba.prb, el cual es abierto de la misma manera que en los otros casos. Como se ve en el resultado, cada vez que hay una ocurrencia del caracter 't' este se sustituye por '1', cuando aparace un caracter 'r' la sustitución se hace por el '2' y por último cuando aparace un caracter 'e' la traducción lo sustutituye por el tercer valor de la cadena de sustitución, en este caso 3. El caracter de sustitución 4 es ignorado ya que no tiene correspondencia con ninguno de los caracteres del patrón (solo hay tres caracteres en el patrón).

       
  open (AR,'prueba.prb')|| die "$!\n";
   while (<AR>)
    { 
      $_   =~ tr/tre/12/;
       print ;
    }
     

  La salida por pantalla de este ejemplo es la siguiente:

   122s p222os 122s ga1os y 122s 212fan12s.

  Este ejemplo es identico a el anterior pero en este caso sólo tenemos dos caracteres en la cadena de sustitución. Así, cuando el número de caracteres en la cadena de sustitución es menor que el número de caracteres del patrón, las ocurrencia de los caracteres del patrón que no tienen correspondencia con ningún caracter de sustitución, son intercambiados por el último de los caracteres de sustitución.

• Caracteres Especiales. < A>

  Los caracteres especiales en PERL están intimamente relacionados con las expresiones regulares, ya que estos se suelen usar para denotar ocurrencias como fin de linea, comienzo de linea, un tabulador ..., lo cual como se verá es especialmente práctico dentro de la utilización de las expresiones regulares. Estos son los caracteres especiales que pueden utilizarse en PERL:

  • Carácter: ^ ; comienzo de linea. Con este caracter expresamos el comienzo de una cadena o registro de caracteres. Así por ejemplo supongamos que se quiere escribir una variable si en su parte inicial se encuentra la cadena 'XXX'. El fragmento de código en PERL que realiza esto sería el siguiente:

      if($var   =~ /^XXX/)
         {
           print  $var;
         }
    

    Como se ve en el ejemplo, las expresiones regulares y los caracteres especiales suelen estar intimamente relacionados.

  • Carácter: $ ; final de linea. Paralelamente al caracter anterior este expresa el final de una cadena o un registro de caracteres. Asi si deseamos escribir una variable si en su parte final contiene la cadena 'END' se escribiria la siguiente expresión regular:

      if($var   =~ /$END/)
         {
          $var;  print 
         }
    

  • Carácter: ( ) ; parentesis. Estos se utilizan en PERL para delimitar ciertos patrones de comparación, para posteriormente aplicarles un
  operador de repetición o una referencia a patrón.
  • Carácter: [ ] ; corchetes. Se utilizan para delimitar dentro de un determinado patrón un conjunto de caracteres que pueden encontrarse dentro de la variable afectada por una expresión regular. Así por ejemplo, supongamos que en una determinada cadena se quieren sustituir todos las ocurrencias de los numeros 1 ó 4 por la cadena 'X_X'. Para realizar esta sustitución se utilizan los corchetes de la siguiente manera:

              $var = '1sdffl3l54l6y547';
              $var  =~ s/[14]/X_X/g;
              $var;  print 
     
        

    La salida por pantalla del ejemplo sera la siguiente:

      X_Xsdff1315X_X6y5X_X7 

    Cuando se utiliza el carácter ^ con los corchetes, queremos decir la no existencia de la cadena que está entre los corchetes. Así si nuestro ejemplo hubiese sido de esta manera:

              $var = '1s4s547';
              $var  =~ s/[^14]/X_X/g;
              $var;  print 
    
         

    la salida por pantalla sería la siguiente:

      1X_X4X_XX_X4X_X 

  • Carácter: - ; guión. Mediante este carácter denotamos un rango de caracteres o números. Asi por ejemplo, si queremos sustituir en una variable o texto todas las palabras minusculas por palabras mayusculas lo realizaremos mediante la siguiente expresión regular que intercambia cualquier ocurrencia de un caracter en minuscula por su correspondiente el mayúculas:

     $var = tr/[a-z]/[A-Z]/;

  • Carácter: { } ; llaves. Dentro de una expresión regular representa la longitud de una cadena. Así para referenciar una cadena de caracteres con tres caracteres ? se expresa de la siguiente manera:

     /?{3}/

  • Carácter: . ; punto. Sirve para representar cualquier carácter. Asi supongamos que queremos sustituir los cuatro primeros caracteres de una cadena:

              $var = 'Paco Gomez';
              $var =~ s/.{4}/Manolo/;
               print  $var;
    
        

    así la salida que se obtiene es la siguiente:

     Manolo Gomez 

  • Carácter: \d . Mediante este caracter se significa la existencia de un digito. Como ejemplo imaginemos que se quieren sustituir todos los dígitos de una variable por el caracter XXX, lo que se hace de la siguiente manera:

              $var = '1flying burrito2';
              $var =~ s/\d/XXX/;
               print  $var;
    
        

    la salida por pantalla es:

     XXXflying burritoXXX 

    Los siguientes caracteres tienen un significado paralelo al anterior por lo que no se darán ejemplos de ellos:

  • Carácter: \w . Expresa un carácter alfanumérico.
  • Carácter: \b . Expresa un espacio en blanco.
  • Carácter: \t . Significa un tabulador.
  • Carácter: \r . Expresa un retorno de carro.
  • Carácter: \n . Significa un final de línea.
  • Carácter: \s . Expresa un separador de cadena de caracteres.

    Los anteriores caracteres especiales, en su formato en mayúsculas significan lo contrario, esto es, \W expresa un carácter no alfanumérico, \D expresa un valor no numerico ... Por ultimo el carácter \ permite referenciar un caracter especial en PERL como un carácter normal, así por ejemplo la siguiente sentencia:

         $var =~ s/\\d/XXX/g;
     

    nos permite sustituir todas las ocurrencias de la cadena \d por XXX. Si dentro de la expresion regular se hubiese escrito solo \d, la sustitución se realizaría en todos los valores numericos. En general ocurre lo mismo con el resto de caracteres especiales de PERL.

  < A>

• Operadores de Repetición. Como los caracteres especiales, también se encuentran muy unidos a la aplicación de las expresiones regulares. En este caso, este tipo de operadores nos permiten repetir un número determinado de veces una cadena de caracteres dentro de una expresión regular.

  Los operadores de repetición son los siguientes:

  • Operador: * ; con él podemos representar un patrón 0 ó más veces. Así supongamos que se quieren sustituir en una cadena todas las ocurrencias de la expresion 'EO' al final de una cadena de caracteres por 'XX',de modo, que a priori no podemos conocer el número de ocurrencias de 'EO'. Para resolver este problema se utilizará el operador * de la siguiente manera:

              $var = 'EOflyingburritoEOEOEO';
              $var =~ s/(EO)*$/XX/;
               print  $var;
        

    La salida de este programa en PERL es la siguiente:

     EOflyingburritoXX 

    Como se observa, ha sustituido un número indeterminado de ocurrencias de 'EO' al final de la cadena por una sola ocurrencia de la cadena 'XX'. Si no se hubiese utilizado el operador '*' junto con el carácter especial '$', la sentencia habría sustituido todas las ocurrencias de EO por XX. Como se observa en este ejemlo se utilizan los parentesis para indicar que la operación de repetición afecta a la cadena EO por entero, de no haberse utilizado los parentesis la repetición afectaria unicamente al caracter O.

  • Operador: + ; este operador funciona de manera similar que el operador '*', pero con la diferencia de que el patrón es representado una o mas veces.

  • Operador: ? ; mediante este operador representamos una cadena de caracteres opcional dentro de un patrón. Así si se quiere sustituir la cadena 'usted' y su plural por la cadena '---' se puede realizar el siguiente codigo en PERL:

              $var =~ s/usted(es)?/---/;
            
        

    con esto consiguimos sustituir todas las ocurrencias de la cadena usted o ustedes por '---'.

  < A>
• Referencia a patrones. Se utilizán para referenciar patrones de comparación o sustitución en las expresiones regulares. PERL trabaja con dos tipos de operadores de comparación:

• Operador: $1..9 ; sirven para referenciar uno de los patrones de búsqueda de la expresión regular. El número del 1 al 9 representa el patrón al que queremos nos referimos dentro de la expresión regular. Así un ejemplo del uso de este operador se puede observar en este código en PERL que añade el articulo 'El' a un nombre común:

            $var = 'PERRO';
            $var =~ s/(PERRO)/EL $1/;
             print  $var;
      

  Como se observa utilizamos la referencia $1 para referirnos al primer patrón de búsqueda (la cadena `PERRO` en nuestro caso) dentro del apartado dedicado a los patrónes de sustitución, de modo que dentro de la sustitución se encuentra el patrón de busqueda. Después de la ejecución la variable $var tiene la siguiente cadena:

   EL PERRO 

• Operador: \1..9 ; este operador tiene la misma utilidad que el anterior, esto es, se utiliza para referenciar patrónes de busqueda, pero en este caso la referencia se reliza en la parte de la expresión regular que se dedica a la escritura de patrones de búsqueda y no en la parte dedicada a los patrónes de sustitución, como en el formato anterior. Así para evaluar el principio y el final de una cadena se escribe el siguiente codigo:

            if($var =~ /^(\w)+.*\1$/);
  
      

  Esta expresión regular de comparación tiene el siguiente significado: mediante la cadena ^(\w)+ nos referimos a todos los caracteres alfanuméricos que forman parte del principio de la cadena contenida en $var, esto es tomo como primer patrón todos los carcteres alfanuméricos de la cadena; con la cade .* referencio un conjunto arbitrario de caracteres de longitud desconocida; con la cadena \1 expreso el primer patrón utilizado y con $ significo que este patrón debe de estar al final de la cadena contendia en $var. En definitiva la expresión regular tomará el valor cierto, cuando la cadena de caracteres contenida en $var tenga la misma cadena de caracteres alfanuméricos al principio y al final. Así por ejemplo, si $var tiene una cadena de caracteres como esta: 'hola juansdfa hola' el valor de la expresión regular será cierto, ya que los espacios en blanco no se consideran caracteres alfanuméricos.

Expresiones regulares: comparación y sustitución -- 2

Una forma todavía más directa de trabajar con estos ficheros de texto que tienen una estructura regular (que son la mayoría), es usar expresiones regulares. Una expresión regular es una forma de expresar gramaticalmente la estructura de cualquier cadena alfanumérica. Por ejemplo, una cadena compuesta por una letra inicial, con una letra o un número a continuación se podría expresar de la forma siguiente

donde | expresa una alternativa y * indica que puede aparecer 0 o más veces. Pues bien, estas expresiones regulares se utilizan enormemente en PERL (de hecho ya hemos usado una, aunque compuesta por un solo carácter, en la línea 4 del programa anterior), y cada vez que hemos usado split. Las expresiones regulares se usan para hacer comparaciones, es decir, hallar si un texto sigue o contiene una determinada expresión regular, y también para sustituir una subcadena que cumpla una expresión regular por otra cadena.

La expresión regular más simple es la propia cadena con la que se quiere comparar; es decir, una cadena coincidirá consigo misma. Las expresiones regulares en PERL siempre van encerradas entre //, o bien m{} (las llaves pueden ser sustituidas por cualquier otro elemento que no esté incluido en la expresión regular), y si no se indica nada, comparará la expresión regular con la variable por defecto, $_, es decir, que /pepe/ será cierto si $_ contiene íntegra la cadena pepe. El programilla

$_ = "pepeillo"; print "si" if /pepe/;

imprimirá

si

Las expresiones regulares usan símbolos convencionales para referirse a grupos de caracteres y otros para repetición o señales de puntuación. En algunos casos, si el símbolo significa algo dentro de la expresión regular (o en PERL), se precede por \ (escape). Por ejemplo, . significa "cualquier carácter" dentro de una expresión regular; luego para referirnos al punto como tal, usaremos \.. También se usa \/,\? y \*, por ejemplo. Otras expresiones más complicadas incluirían repeticiones de símbolos; por ejemplo, \w+ casaría con cualquier palabra (un carácter alfanumérico repetido uno o más veces).

Para agrupar símbolos se usa el paréntesis, que además sirve para indicarle a PERL que con lo que coincida con la expresión en su interior se va a hacer algo. Para empezar, se asigna a la variable $&; pero además, podemos asignar a otra variable el resultado de la comparación; en general, una comparación con una expresión regular que incluya paréntesis devuelve una lista con todo lo que coincida con el contenido de los paréntesis

$zipi = "Pepeillo Gonzalez MacKenzie 8000";
@parejas = ($zipi =~ /(\D+) (\d+)/);

(el nombre de la variable y el símbolo =~ se pueden suprimir si la comparación se hace sobre la variable por defecto $_); @parejas contendrá ("Pepeillo Gonzalez MacKenzie",8000), ya que la primera expresión regular indica "uno o más caracteres no numéricos", mientras que la segunda representa "uno o más caracteres numéricos".

Por ejemplo, el fichero de paganinis usado en ejemplos anteriores anterior tiene la estructura siguiente: una o más palabras, separadas por un espacio, una cantidad (números y puntos), una hora (números y dos puntos) y una fecha (números y /). Esto se dice en PERL mediante la expresión siguiente(\D+) (\d+\.?\d+) (\S+) (\d+)\/(\d+)\/(\d+)que puede parecer un poco críptica (y en realidad lo es), pero cuyo significado se puede resolver mirando la tabla 4. Con esta modificación, el bucle central del programa totales.pl se queda reducido a

while(<>) {
    ($paganini, $pasta, $hora, $dia, $mes) = 
          /(\D+) (\d+\.?\d+) (\S+) (\d+)\/(\d+)\/(\d+)/;
    $totalDia{"$mes-$dia"}+=$pasta;
}

Más compacidad no se puede pedir. Además, ya de camino, nos vamos ahorrando algunas variables. En la primera línea del interior del bucle se asigna la parte de la cadena que coincide con lo descrito en el interior de los paréntesis a cada una de las variables, es decir, divide la línea en cinco campos, cada uno de los cuales tiene un tipo diferente. Hay cinco pares de paréntesis, para cinco variables. Veamos cada expresión regular por partes.

Las expresiones regulares se usan en casi todos los lenguajes de programación; el ligro Mastering Regular Expressions: Powerful Techniques for Perl and Other Tools , de Jeffrey E. Friedl (Editor), Andy Oram (Editor), el libro del búho. Es un libro avanzado, pero útil para quien quiera descifrar el arcano arte de las expresiones regulares

La primera expresión regular es \D+. Como se ve en la tabla 4, \D coincide con todo lo que no sea numérico, y en particular letras y espacios. Este campo es problemático, porque puede incluir una o varias palabras; sin embargo, sabemos que el siguiente campo comienza por un número; por tanto, incluiremos en este campo todo lo que haya hasta que encontremos un número. Se puede insertar el código siguiente print $paganini; en el bucle para ver qué se incluye dentro de ese campo.

La siguiente expresión regular, (\d+\.?\d+), no describe otra cosa que un número real en notación de coma flotante, es decir, una o más cifras (\d+), seguidas o no por un punto (\.?, no olvidar que el punto tiene significado especial en las expresiones regulares), que a su vez debe de estar seguido por una o más cifras (\d+). Esta expresión regular coincide además con aquellos números sin punto enmedio.

Y la siguiente \S+ coincide con la hora, aunque quizás podría coincidir con cualquier cosa, simplemente coge todo lo que haya entre los dos espacios. En realidad, si pusiéramos toda la expresión regular anterior como(\S+) (\S+) (\S+) (\S+) funcionaría perfectamente.

Y para terminar,(\d+)\/(\d+)\/(\d+)coincide con el día, el mes y el año, que están separados por una barra diagonal.

Con estas expresiones regulares se pueden construir programas superpotentes, que convierten casi cualquier texto en casi cualquier otro. Incluso, si uno se atreve (nuestro político corrupto no creemos que se atreva) un analizador sintáctico de un lenguaje de alto nivel, aunque sea simplificado. Otra utilidad es hacer filtros de correo electrónico, o de noticias de USENET (de hecho, el killfile o fichero que incluye todas las expresiones regulares de mensajes que deben de ser borrados, usa expresiones regulares). También se pueden usar expresiones regulares en archie y en la Web; el problema es que la mayoría de las veces usan convenciones diferentes, pero en cualquier caso, nunca viene mal saberlas.

El político corrupto decide no contarle al señor X todo el dinero obtenido (por no mencionar a Hacienda), y poniéndose a trabajar sobre los ficheros generados anteriormente (como cliente.mas), elabora el siguiente programilla (changec.pl)

#!/usr/local/bin/perl -p
s/(\d+\.?\d+)/$&*0.85/e;

que ni siquiera pongo en un cuadro aparte, porque no merece la pena.

En este programa se introducen novedades desde la primera línea. Para empezar, se usa PERL con un switch en la línea de comandos, -p. Este switch indica que alredededor de lo que hay debajo hay que sobreentender el siguiente bucle

while(<>)
{
    s/(\d+\.?\d+)/$&*0.85/e;
    print;
}

; es decir, un bucle que abre y lee del fichero que se pasa en la línea de comandos, ejecuta las órdenes encontradas en el fichero, y al final imprime la variable por defecto. Si el switch fuera -n en vez de -p no imprimiría.

También se incluye la nueva orden s///[switches]tomada, como otras órdenes, del editor de UNIX sed. En concreto, esta orden lo que hace es sustituir la expresión regular encontrada entre los primeros // por la expresión en los segundos. En este caso actúa sobre la variable por defecto, pero en general$zipi="pepeillo"; $zipi=~ s/p/q/g;daría "qeqeillo". El switch e que aparece al final de la orden en el programa indica que se tiene que evaluar la expresión que aparece en la segunda parte de la orden; el g que aparece aquí indica que se tiene que hacer una sustitución global, es decir, que tienen que sustituirlo todas las veces que aparezca en la primera expresión, no solo una vez.

Por último, la variable $& contiene la cadena que coincida con la expresión regular en la primera parte de la orden; los paréntesis indican qué parte de la expresión hay que asignar a tal variable. Si hay varios paréntesis, las cadenas correspondientes serán asignadas a las "variables" \1, \2 (dentro de la orden s), o $1, $2... fuera de la expresión (estas variables sólo funcionan un ratito, asi que no van a estar disponibles hasta que uno quiera; en caso de duda, es mejor asignarlas inmediatamente a otra variable.

Toda la información sobre expresiones regulares está en la página de manual perldoc perlre.

Expresiones Regulares -- 3

La forma en que se usan en Perl es muy similar a la que utiliza el comando grep de Unix. Dicho comando se suele utilizar para buscar en los ficheros de entrada (o bien en la entrada estándar) las líneas que contienen un patrón especificado.

Comando grep del Unix

Desde la línea de órdenes llamamos al comando grep con la opción -e para indicarle la expresión regular que queremos utilizar, y justo después le indicamos los ficheros donde queremos buscar esa expresión regular. Por ejemplo:

	$ grep -e "grep\|Unix" *.txt
	

Como fichero de ejemplo, todos utilizaremos el mismo, cuyo contenido es el que aparece a continuación:

	Esto es simplemente un fichero
	de texto normalito, para hacer pruebas
	con el comando grep
	del Unix.
	
	Para hacer recuentos de cadenas y todo eso
	teniendo en cuenta las mayusculas y minusculas (Unix
	UnIx
	uNiX
	gReP
	
	y todo eso...
	

Entre las muchas opciones del comando, podemos especificarle que no nos imprima las líneas donde ha encontrado el patrón, sino que nos imprima el número de veces que se cumple dicho patrón. Así, el siguiente ejemplo

	$ grep -c -e "grep\|Unix" *.txt
	

	3
	

Otra opción interesante es la posibilidad de indicarle que no haga distinciones entre mayúsculas y minúsculas, usando la opción -i. Así, no hará distinción entre Unix o uNiX, por ejemplo. Veamoslo con un ejemplo:

	$ grep -c -e "grep\|Unix" *.txt

	6
	

Otra opción interesante es que nos indique la línea en la que se produjo la coincidencia entre el patrón y la línea del fichero. Esto lo podemos conseguir con la opción -n.

	$ grep -n -e "grep\|Unix" *.txt
	

Por último, a veces nos interesa especificar una expresión regular que no queremos que se cumpla. Eso lo podemos hacer con la opción -v.

	$ grep -v -c -e "grep\|Unix" *.txt
	9
	

Además de las alternativas en la expresión regular, especificada con el caracter |, podemos especificar rangos de caracteres, utilizando los corchetes ([ ]); un caracter cualquiera utilizando el punto (.); que cierto sub-patrón aparezca como mucho una vez (?) o que aparezca cero o mas veces (*) o que aparezca una o mas veces (+); etc, etc.

Formato de las expresiones regulares en Perl.

Para utilizarlas, las debemos encerrar entre // (mientras que en grep se colocaban indicadas con -e y entre comillas). Normalmente devolverán un valor lógico indicando si la variable sobre la que queremos aplicarla contiene o no el patrón. Si no se indica otra cosa, por defecto comparará la expresión con la variable "por defecto" $_. Por ejemplo:

	/pepe/ 

El programa:

	$_ = "hola pepe";
	print "si\n"  if (/pepe/);
	

Si queremos utilizar otra variable diferente a la $_ debemos utilizar el operador =~ , por ejemplo:

	$cad =~ /pepe/ 

Las expresiones regulares son sensitivas a mayúsculas, así, la expresión:

	$cad = "Pepe come queso";
	$cad =~ /pepe/;
	

El operador que hace lo contrario que el =~ es el !~ , así, la expresión:

	$cad = "Pepe come queso";
	$cad !~ /pepe/;
	

Construyendo expresiones regulares complejas

• una expresión regular se cumple para una cadena dada si alguna de las laternativas de la expresión regular se cumple. Las alternativas se especifican separadas con el caracter |, se evalúan de izquierda a dechera y se para de evaluar ante la primera coincidencia.

• una alternativa se cumple si cada item que la compone coincide en el orden en que los items están especificados.

• cada item esta formado o bien por un modificador o por un átomo cuantificado. Los posibles modificadores son:
  • ^ que indica que debe coincidir al principio de la cadena
  • $ que indica que debe coincidir al final de la cadena
  • \b que especifica los límites de una palabra
  • \B que especifica los límites fuera de una palabra
  
  Los posibles átomos cuantificados son:
  • {n,m} el átomo debe aparecer entre n y m veces
  • {n,} el átomo debe aparecer al menos n veces
  • {n} el átomo debe aparecer exactamente n veces
  • * el átomo debe aparecer 0 o más veces (como {0,})
  • + el átomo debe aparecer 1 o más veces (como {1,})
  • ? el átomo debe aparecer 0 o 1 veces (como {0,1})

• Los átomos que podemos utilizar son:
  • una cadena tal cual, encerrada o no entre paréntesis
  • un . especifica cualquier caracter salvo el retorno de carro
  • una lista de caracteres entre corchetes ([ ]) especifica uno de esos caracteres. Un caracter ^ delante de los corchetes niega la clase.
  • se pueden especificar rangos en los corchetes, de la forma a-z
  • existen ciertos caracteres especiales:
    • \n retorno de carro (nueva línea)
    • \r retorno de carro (vuelta al principio de línea)
    • \t tabulador
    • \d un dígito (igual que [0-9])
    • \D un caracter que no sea dígito
    • \w un caracter alfanumérico (como [0-9a-z_A-Z])
    • \W un caracter no alfanumérico
    • \s un caracter de espaciado (como [ \t\r\n])
    • \S un caracter que no sea de espaciado
    • un \0 seguido de un número corresponde con ese número en octal
    • un \x seguido de un número hexadecimal corresponde con ese número en hexadecimal
  • cualquier otro caracter "escapado" coincide consigo mismo.
  • cualquier caracter no mencionado coincide consigo mismo.

A modo de resumen de todo lo dicho, véase la tabla siguiente:

Veamos algunos ejemplos ilustrativos:

Los dos últimos ejemplos nos muestran que debemos ir con cuidado a la hora de colocar las alternativas en las expresiones regulares. Se suelen usar los paréntesis para encerrar las alternativas en las expresiones regulares y para agrupar patrones a recordar para después, mientras que se usan los corchetes para especificar clases.

A veces nos convendrá utilizar el contenido de una variable dentro de la expresión regular. Así, dependiendo del valor de esa variable podemos buscar diversos patrones (por ejemplo, buscar el contenido de la variable $a dentro de la variable $b).

Pues bien, podemos hacer uso de las variables dentro de las expresiones regulares directamente, como se ve en el siguiente ejemplo:

	#!/usr/bin/perl
	
	$a = <>;
	$b = <>;
	
	chop($a);
	chop($b);
	
	if( $b =~ /$a/ ) {
		print "$a esta incluida en $b \n";
	}
	

Pero se plantea un problema... ¿y si la expresión regular es algo más compleja? Supongamos que queremos comprobar si $a seguida de una "P" se encuentra en $b. En este caso no podemos poner if( $b =~ /$aP/ ) { porque Perl intentaría buscar en $b el contenido de la variable $aP, y no el de la variable $a seguida de una "P". En este caso hay que hacer algo como if( $b =~ /${a}P/ ) { (nótese el uso de las llaves rodeando el nombre de la variable).

2.- Sustitución

Además de identificar expresiones regulares, Perl puede hacer sustituciones basadas en los "emparejamientos" identificados en las expresiones. La forma de hacer eso es con la función s///.

Para hacer una sustitución de loco por Loco en la cadena $cad, usamos:

	$cad =~ s/loco/Loco/;
	

	s/loco/Loco/;
	

Opciones

	$cad =~ s/loco/Loco/g;

Si queremos replazar ocurrencias como lOco, lOcO, LoCo, etc por Loco, podemos hacer:

	$cad =~ s/[Ll][Oo][Cc][Oo]/Loco/g;
	

	$cad =~ s/loco/Loco/gi;
	

Si lo que queremos es evaluar algo, en la segunda parte de la expresión regular, debemos utilizar la opción e.

En el siguiente ejemplo, se lee de entrada estándar (sobre $_) y para cada línea (se supone que tiene un número real, ¡con su punto y todo!) se realiza una operación matemática, quedando el resultado almacenado en $_. En este ejemplo se hace uso de una variable especial $& que "recuerda" cierta parte del patrón correspondiente a una parte de la expresión regular que hayamos encerrado entre paréntesis.

	while(<>) {
		s/(\d+\.\d+)/$&*100/e;
		print;
	}

3.- Translación

Para hacer una translación utilizamos la función tr///. Así, la siguiente expresión reemplaza cada "a" por "e", cada "b" por "d" y cada "c" por "f" en la cadena $cad:

	$cad =~ tr/abc/edf/;
	

El siguiente ejemplo cuenta el número de asteriscos en la cadena $cad:

	$contador = ( $cad =~ tr/*/*/ );
	

El siguiente ejemplo transforma a mayúsculas la cadena $_:

	tr/a-z/A-Z/;
	

4.- Recordando patrones

A veces, en una expresión regular conviene recordar los patrones encontrados para ser usados posteriormente (en la expresión o fuera de ella). Esto se consigue, encerrando los patrones a recordar entre paréntesis y referenciándolos mediante las variables $1, $2, ... $9 (de sólo lectura) fuera de la expresión, o con las variables \1, \2, ... \9 dentro de la expresión.

Por ejemplo, el siguiente programa, sustituye las letras mayúsculas por dichas letras pero entre asteriscos:

	$_ = "Hola Don Pepe";
	s/([A-Z])/\*\1\*/g;
	print "$_";
	
		Resultado:
		*H*ola *D*on *P*epe
	

En el siguiente ejemplo utilizamos los patrones encontrados fuera de la expresión regular, mediante la variable $1 para encontrar las palabras repetidas:

	if( /(\b.+\b) \1/ ) {
	   print "encontrada la palabra $1 \n";
	}
	

El siguiente ejemplo intercambia el primer y último caracteres de la cadena $_:

	s/^(.)(.*)(.)$/\3\2\1/;
	

El siguiente ejemplo intercambia las dos primeras palabras de la cadena $_:

	$_ = "Hola Don Pepe";
	s/^([^ ]*) *([^ ]*)/\2 \1/;
	print "$_";
	
		Resultado:
		Don Hola Pepe
	

Tras el uso de una expresión regular, podemos utilizar las variables especiales $`, $&, $', (las tildes esas son las que están junto con la [ y con la {) que guardan lo que hay antes, lo encontrado y lo que hay después en la cadena:

	$_ = "Hola Don Pepe";
	/on/;
	print "\n $` \n $& \n $' \n";
	   
		Resultado:
	   	Hola D
	   	on
	   	 Pepe
	

Ejercicios

1. Hacer un programa que cuente el número de líneas que contienen la palabra este.

2. Hacer un programa que cuente el número de veces que aparece la palabra este dentro de un fichero. Ampliar el ejercicio haciendo la sustitución de dicha palabra por aquel y devolver el número de sustituciones hechas.

3. Hacer un programa que cuente el número de caracteres repetidos que hay en un fichero, y obtener otro de salida con el mismo texto, pero dichos caracteres entre parentesis. Por ejemplo, ante la linea 1) debe dar la 2):

         Aquello no era un perro, era un castillo.   (1)
         [3] Aque(ll)o no era un pe(rr)o, era un casti(ll)o.   (2)
   

4. Hacer un programa con el que obtengamos el texto que hay entre los tags <H1> y </H1> (generalizando también para H2, H3, H4, etc) en un fichero HTML.

5. Hacer un programa con el que, a partir de un fichero del siguiente tipo:

        12345:Lopez,Juan:JL
        58694:Martinez,Luis:LM
        36495:Abad,Ramon:RA
        93764:Garcia,Jose:JG
   

   obtengamos una salida del siguiente tipo:

        ID     Iniciales    Nombre
       12345       JL      Juan Lopez
       58694       LM      Luis Martinez
       36495       RA      Ramon Abad
       93764       JG      Jose Garcia
   

6. Dado un fichero que contenga varias líneas en el formato siguiente:

   Apellido1 Apellido2,Nombre Nota_num_Real

   poner los nombres en el formato

   Nombre Apellido1 Apellido2 Nota_num_Real

   ordenándolos (ascendentemente) por orden de nota.

7. Dado un fichero que contenga URL, generar otro que incluya alrededor de las mismas una referencia del tipo

   <a href=URL>URL</a>

8. Hacer un programa que imprima los ficheros de cabecera incluidos en un programa en código fuente C. Estos tienen el formato #include<"nombre_fich">.

Obtener un fichero comprimido con textos de ejemplo para cada ejercicio

Tanto trabajo está acabando con la salud de nuestro político. La campaña electoral está cerca, tiene que inaugurar unas cuantas obras inacabadas todavía, y decide descargarse de un poco de trabajo. Para ello contrata a un militante de base como experto de Informática con cargo a los fondos reservados. Este se encuentra un trabajo ingente, y para empezar decide facilitar un poco su labor escribiendo una utilidad que le permita sacar directorios un poco más monos. Y, ni corto ni perezoso ("Este chico llegará lejos", comenta nuestro político) escribe el programa dir.pl,que aparece en el listado siguiente.

1 #!/usr/bin/perl
2 
3 sub inverso {
4 #Añade la secuencia ANSI de escape para video inverso
5 	return "@_";
6 }
7 
8 sub negrita {
9 #Añade la secuencia ANSI de escape para letra resaltada
10 	return "@_";
11 }
12 
13 sub borra {
14 #Borra pantalla
15 	print  "";
16 }
17 
18 sub normal {
19 #Restablece modo normal
20 	print "";
21 }
22 
23 &borra;
24 $dirSep = "/";				#Solo para MS-DOS
25 
26 
27 if ($ARGV[0] eq "" ) {
28 	$dir = $dirSep;
29 }else {
30 	$dir = $ARGV[0];
31 }
32 
33 #Abre directorio
34 opendir( DIR, $dir );
35 while( $fichero = readdir( DIR ) ) {
36 	push( @ficheros, $fichero );
37 }
38 closedir( DIR);
39 
40 #Cabecera del listado
41 $msg = "Listado del directorio ".&inverso( $dir ); 
42 print "$msg\n";&normal;
43 print "=" x (length($msg) - length(&inverso(""))); print "\n";
44 
45 if ( $dir !~ m!\\$! ) {
46 	$prefijo = $dir.$dirSep;
47 } else {
48 	$prefijo = "$dirSep";
49 }
50 
51 foreach (sort @ficheros ) {
52 	print &inverso( $_ ) if -f "$prefijo$_";
53 	print &negrita( $_ ) if -d "$prefijo$_";
54 	&normal;
55 	print "\n";
56 }

En este programa ya estamos hablando de palabras mayores. Para empezar, es un poco más largo. Para continuar, es sólo para MS-DOS o Win95, pero se puede adaptar más o menos fácilmente a cualquier otro sistema operativo cambiando el separador de directorios contenido en la variable $dirSep (: para el Mac, / para UNIX). El programa saca un listado del directorio, ordenado en orden alfabético, resaltando los directorios con un tipo de letra más brillante, y los ficheros en video inverso.

Se le llama de la forma siguiente

C:\> perl dir.pl <nombre del directorio>

Si no se da ningún nombre de directorio, toma el directorio raíz; para el directorio actual hay que introducir

perl dir.pl .

Veremos primero el truco de sacar las cosas en diferentes tonos, y que se expresan en el programa con extraños signos (para obtener la flechica p'atrás, se pulsa control-P, y sin dejar de pulsarlo, control-[; difícil, pero es así). El programa usa secuencias de escape ANSI, que son órdenes estándar para trabajar con terminales; son tanto aplicables a terminales UNIX (por ejemplo, los tipo vt-100 o ansi), como MS-DOS; en este último habrá que añadir la línea

device=c:\dos\ansi.sys

al fichero config.sys. Con estas secuencias de escape se puede imprimir en diferentes lugares de la pantalla, borrar líneas o la pantalla completa, y cambiar, como aquí, los atributos de partes de la pantalla, todo ello de forma más o menos independiente del sistema. Es algo así como el interfaz gráfico de usuario de los pobres.

El siguiente concepto que introduce este programa es el de subrutinas. Las subrutinas en PERL se pueden declarar en cualquier parte del programa, al principio o al final. Para declararlas, simplemente se precede el nombre de la subrutina con la palabra sub y se le sigue del bloque de instrucciones que se van a ejecutar. Pueden no utilizar parámetros (como borra y normal). En este caso se llaman precediéndo el nombre con el símbolo &, o bien escribiendo do borra. También se puede llamar a una subrutina con parámetros, en cuyo caso forman todos parte de la matriz @_, como se ve por ejemplo en la subrutina negrita. Los elementos de esta matriz son, como es natural, $_[0], $_[1] y así sucesivamente, aunque se pueden asignar todos de una vez a parámetros locales de la subrutina, de esta formalocal($zipi, $zape) = @_;En esta sentencia se declaran simultáneamente $zipi y $zape como variables locales y se les asignan los dos primeros parámetros que se le han pasado a la subrutina. Si no se declararan como local, las variables serían visibles por todo el programa, como sucede en el resto de las variables en PERL.

[v5]En realidad, local crea variables globales pero con valores locales; es decir, se crea una variable que se puede ver en todo el programa, pero cuyo valor se guarda al principio de la subrutina y se recupera al final de la subrutina. En la versión 5 se introduce la palabra clave my, que declara verdaderas variables locales. En la versión 5, por tanto, se suele preferir my para declarar las variables de las subrutinas. [/v5]

La lectura del directorio se hace a partir de la línea 31; para eso utiliza funciones similares a las que hay en C o Pascal; una funcion, opendir, "abre" el directorio, y las otras van leyendo secuencialmente los nombres de todos los ficheros de ese directorio y metiéndolos en la matriz @ficheros.

Luego, a partir de la línea 49, y utilizando los operadores -f y -d, que comprueban si el fichero cuyo nombre viene después es un fichero normal o un directorio, se va imprimiendo con los atributos correspondientes. Estos son un ejemplo de los operadores de fichero que se utilizan mucho en PERL (ver la tabla 4), y que vienen heredados de comandos similares en los shell de UNIX (como csh y bash), nosotros tenemos la suerte de poder usarlos en ms-dos también. Otros operadores figuran en la tabla 4.

Subrutinas --2

Introducción.

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.

Parametros.

	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";
	}
	

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/ );
	}
	

	$a = "liMonaDa";
	$b = "lImOn";
	$r = &vars_globales;
	print "\n$r  $a  $b\n";
	
		Imprimiría:
		1  LIMONADA  LIMON
	

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"
	

Variables locales.

	sub vars_locales {
		local($a, $b);
		($a, $b) = ($_[0], $_[1]);
		( $a =~ /$b/  ||  $b =~ /$a/ );
	}
	

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]);
	

Valores de retorno.

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
	

	sub maximo {
		if( $_[0] > $_[1] ) {
			return $_[0];
		}else{
			return $_[1];
		}
	}
	
	$mayor = &maximo(37,23);  #devuelve 37
	

En realidad, la contratación de este nuevo genio de la informática, al que ya le está buscando también colocación en la empresa que controla los ordenadores de la campaña electoral, le ha dejado algún tiempo libre a nuestro [censurado] político. Para emplear este tiempo libre, decide conectarse con eso que le ha dicho su amigo Borrell, que se llama internez o algo así; dentro de la internez, y de una parte especialmente yanqui llamada usanez o algo así, hay unos grupos de discusión de temas de máxima actualidad. En concreto, un grupo denominado alt.binaries.pictures.erotica.politics publica interesantes fotos de políticas de la oposición en actitud de debate (al menos eso es lo que le han contado).

Pero su gozo se encuentra en un pozo cuando sólo ve letras y más letras en los mensajes que le van llegando. Su informático residente le explica que vienen codificadas con un programa denominado uuencode, y que tiene que salvarlas cada una por separado y decodificarlas después, antes de verlas. Con la pericia que dan las ganas, escribe el siguiente programa, uudec.pl.

1 #!/usr/bin/perl
2 
3 while( <$ARGV[0]>) {
4       	
5     open( IN, "<$_" );
6     while (<IN>) {
7 	if ( /begin \d+\s+(\S+)/ ) {
8 	    $fileName = $1;	
9 	    open ( OUT, >$fileName );
10 	}			
11 	print OUT, unpack("u",$_) if /^[MC]/;
12     }			
13 }
14 close OUT;

Este programa utiliza la orden unpack para decodificar cadenas, y las escribe en salida estándar. La descripción es incluso más corta que el programa. Los mensajes en ciertos foros de USENET vienen divididos en varias partes, cada una de las cuales contiene un pedazo de un fichero codificado con uuencode (puede ser un .GIF, un .WAV o cualquier otro). Para usar el programa, se salvan todas las partes del mensaje correlativamente en un fichero. El programa busca primero el nombre del fichero codificado, que aparece en una línea de la formabegin 644 nomfich.gif, abre un fichero con ese nombre, y va escribiendo en él las cadenas decodificadas.

Para llamar a este fichero, se escribe

UNIX% uudec.pl fichero.uu

y se crea el fichero codificado, que luego podrá uno contemplar con su visor de GIFs preferido (o escuchar con la SoundBlaster). Se pueden dar comodines en la línea de comandos; el bucle lo irá abriendo uno por uno.

En realidad, la orden unpack decodifica de formatos de codificación internos a cadenas; la orden pack hace exactamente lo contrario. La utilidad de todo esto se me escapa un poco, salvo que, por ejemplo, se quieran almacenar números reales de forma que pueda leerlos directamente un programa en C. En ese caso, se escribiría

print pack( "f", $zipi);

Un número real escrito así se podría leer directamente con la orden read del C (pero, ojo, no con la scanf, que sirve solamente para ficheros de texto). Otra forma de usarlo es para formatear ficheros de salida; usando

print
pack("A7",$cadena)

, haremos que la salida ocupe justamente 7 caracteres,ni más mi menos; así aparecerá todo en bonitas columnas. Por ejemplo, nuestro archiconocido memoria.pl se podría convertir en este memoria-col.pl

1 #!/usr/bin/perl
2 until(0) {
3      print "Cliente, cantidad\n";
4      chop($_ = <>); 
5      last if !$_;
6      ($paganini, $cantidad) = split(/,/,$_);
7      $comision = $cantidad * 0.25;
8      ($seg, $min, $hora, $dia, $mes, $anho, @zape) = localtime(time);
9      $mes++;
10      $zipi = pack("A16",$paganini).pack("A7",$comision)."$hora:$min $dia/$mes\n";
11      push( @mem, $zipi );     
12 };
13 
14 print @mem;

Este programa, sobre el fichero siguiente

uno, 1605168
este es el dos, 166166
este puede ser el tres, 1616136

produciría la siguiente salida

uno             401292 19:54 25/7
este es el dos  41541.519:54 25/7
este puede ser e404034 19:54 25/7

(dependiendo, claro está, de cuando se hayan producido las susodichas transacciones cambiarán horas y fechas).

Cuando nuestro político corrupto descubre que UNIX tiene ya preprogramadas muchas de las funciones que le hacía el militante de base, lo despide y decide usar esos programas de UNIX desde, por supuesto, un programa en PERL; además, decide tirar Windows95 a la basura e instalalarse Linux. Por ejemplo, para contar las palabras que hay en un fichero basta con usar la orden wc de UNIX. Pero si se presenta en modo bonito, puede salir el siguiente programa, llamado wc.pl

#!/usr/bin/perl
while (<*>) {
    ($zipi, $lineas, $palabras, $bytes, $nombref) = split(/\s+/,`wc $_`);
    print "El fichero $nombref tiene $palabras palabras y $lineas lineas\n";
}

La primera línea del bucle usa una bonita capacidad de PERL, llamada globbing o generalización. Lo que hace es que, si se pone algún comodín de ficheros del tipo * repetirá el bucle para cada fichero que cumpla ese patrón, asignando el nombre del fichero a la variable por defecto. Ese nombre se le pasa al comando wc, usando ``, es decir, comillas invertidas, que ejecutan un comando en UNIX devolviendo su salida estándar. Esa orden completa agarra la salida del comando, del tipo
lineas palabras bytes nombre del fichero
y la parte en sus componentes. Como las diversas palabras están separadas por varios espacios o tabuladores, se una el patrón \s+. Al principio de la línea hay una serie de espacios, por lo que el primer componente devuelto no tendrá nada.

Hay otra forma diferente de controlar programas en UNIX, esta vez interactivamente, usando los denominados pipes o tuberías, que se suelen indicar con el carácter |. Por ejemplo, la orden open( FICHERO, "|pepe" ), abre una tubería a la orden pepe, que a partir de entonces ejecutará los comandos que reciba del programa en PERL, ya que éste programa le suministrará la entrada estándar. Esto se puede usar de la siguiente forma (si se dispone del programa gnuplot):

open( GNU, "|gnuplot" );
print "Fichero a trazar? "; chop($fileN = <STDIN>);
print GNU "plot \"$fileN\" with lines 1\n";

que abrirá una tubería al programa y le enviará la orden para trazar un fichero con líneas. Con este tipo de órdenes y con gnuplot, y con unas pocas ganas, se pueden hacer animaciones. Sin embargo, hay que tener en cuenta que sólo se podrá hacer con programas que acepten comandos por su entrada estándar.

Como nuestro político corrupto^TM ya es todo un guru de perl, la secretaría de prensa del partido decide encargarle el seguir en la Internet todos los sitios web que hablen del Señor X, para luego poder así denunciar la conspiración judeo-masónica-telefónica-mundial (o séase, de El Mundo) en contra de la democracia y de sus figuras más prominentes. Por eso, decide hacer un programa que cuente todas las páginas en las que aparece la cadena "Señor X"; así luego puede hacer un gráfico con su evolución y ver si la cosa va a más o a menos. Decide usar el buscador Altavista, ver el número de páginas que devuelve, e imprimirlo. Para ello, hace el siguiente programa (altax.pl):

1  #!/usr/bin/perl
2  
3  use LWP::Simple;
4  use URI::Escape;
5  
6  my $codedQuery = uri_escape( '"Señor X"' );
7  my $url="http://www.altavista.com/cgi-bin/query?
   pg=q&sc=on&hl=on&q=$codedQuery&kl=XX&stype=stext&search.x=27&search.y=7";
8  print "Conectando a $url\n";
9  my $respuesta = get( $url );
10 my ($encontrados) = ($respuesta =~ /\S+;(\d+) pages found/gs);
11 print "Encontradas $encontrados respuestas\n";

Este programa imprimiría algo así como

Conectando a http://www.altavista.com/cgi-bin/query? 
pg=q&sc=on&hl=on&q=%22Se%F1or%20X%22&kl=XX&stype=stext&search.x=27&search.y=7
Encontradas 49 respuestas

Este programa, tal cual, seguro que no funciona en un ordenador. Usa un par de librerías (o "bibliotecas" para los puristas), que no se encuentran en la instalación estándar de PERL: la LWP::Simple y la URI::Escape. Lo primero que habrá que hacer es bajarse e instalar estas páginas.

Si está uno en Windows, es bastante fácil. Con la instalación de PERL viene un programa, ppm, que sirve directamente para bajarse e instalar módulos. Simplemente tecleando ppm, y luego

ppm> install  LWP::Simple
ppm> install  URI::Escape

el programa baja, compila si es necesario, y prueba los dos módulos. A veces esto que parece tan simple no lo es, porque necesita compiladores externos y otra serie de cosas, pero si hay suerte, todo irá bien. Con ppm se pueden usar otras órdenes, tales como

ppm> search WWW

que dará una lista de todos los módulos que incluyan WWW en su nombre. En este caso, además, las dos librerías vienen en un sólo paquete, el libwww-perl, que se puede bajar uno sólo tecleando install libwww-perl

En Linux y otros Unixes, es un poco más complicado, pero no mucho. Todos los módulos para PERL se crean y empaquetan de una forma estándar. Tras localizarlos, habitualmente en alguno de los sitios CPAN (http://www.cpan.org), se hace lo siguiente:

[yo@localhost tmp]# tar xvfz libwww-perl-5.47.tar.gz
libwww-perl-5.47/
libwww-perl-5.47/t/
(más cosas...)
[yo@localhost tmp]# cd libwww-perl-5.47
[yo@localhost libwww-perl-5.47]# perl Makefile.PL
(aquí comprobará que todas las librerías que se necesitan previamente
están instaladas, y crea un Makefile)
[yo@localhost libwww-perl-5.47]# make
[yo@localhost libwww-perl-5.47]# make install
(y también, si se quiere)
[yo@localhost libwww-perl-5.47]# make test

En este caso, también se acaba antes bajándose, para empezar, el módulo CPAN.pm, con el cual, tecleando perl -MCPAN -e shell; tiene uno un entorno similar al que hemos mencionado antes para Windows. Eso sí, para instalar algo hará falta, tanto en este caso como en el anterior, ser superusuario.

Las librerías no sólo instalan el código, instalan también los manuales correspondiente. En este caso, se puede consultar el manual escribiendo perldoc LWP; y merece la pena hacerlo, porque nos encontraremos muchas cosas interesantes. Como indicamos en la sección sobre el zen del PERL, merece la pena conocer bien las librerías antes de ponerse a hacer cualquier cosa en PERL, porque en la mayoría de los casos se encontrará con la mitad del trabajo hecho.

Además, en este caso las librerías son dos palabras separadas por ::; esto es porque los módulos están organizados en una especie de jerarquía. Cada módulo puede estar dentro de una jerarquía o no, dependiendo de lo que quiera el autor y dependiendo de su funcionalidad. En este caso, Simple está dentro de LWP (lib-www-perl), porque va de eso; pero hay muchas más de la misma familia (por ejemplo, LWP::UserAgent un módulo más flexible para bajarse páginas). Lo mismo ocurre con el otro módulo.

Ya que tenemos las librerías instaladas, podemos ir al programa. Las dos líneas que empiezan por use importan las librerías. En realidad, hacen algo más que eso: traen todos los identificadores de la librería al espacio global de nombres, de forma que podemos usar las subrutinas y variables de la librería como si hubieran sido declaradas en el mismo programa. En realidad, en este caso usamos sólo una función de cada librería, así que, para no contaminar el espacio de nombres, podríamos haber escrito

use LWP::Simple qw(get);
use URI::Escape qw(uri_escape);

con exactamente el mismo resultado. Esta expresión, aunque pueda parecer un poco rara, usa el mecanismo quote del PERL, que sirve para definir matrices, cadenas y otras cosas sin necesidad de escribir demasiado; o séase, que se ahorra uno comillas, comas y cosas por el estilo. qw( a b c) equivaldría a ('a','b','c'). Por supuesto, el operador qw y todos los demás por el estilo (ver la página de manual perlop) pueden usarse en cualquier punto del programa PERL.

Hasta ahora, en realidad, no hemos hecho nada, salvo importar las librerías; el programa de verdad empieza en la línea 6, que requiere un poco de explicación. Usa la subrutina uri_escape del módulo URI::Escape, que sirve para codificar cadenas que incluyan caracteres no alfanuméricos de forma que se pueda incluir dentro de un URL o dirección Web, tal como la que usan los buscadores. En este caso, la cadena contiene espacios, comillas y la letra ñ, que no puede ir tal cual en un URL. Por eso se codifica, quedando así: %22Se%F1or%20X%22. Generalmente, cuando se vayan a hacer peticiones a buscadores desde un programa, habrá que hacer este tipo de codificación.

El URL que se va a solicitar se compone en la siguiente línea. El único truco aquí es ver que la petición que se hace a Altavista va dentro de la variable q (no tienes más que hacer una búsqueda de cualquier palabra, y ver dónde aparece en el URL de la respuesta); eso se puede ver mirando al código HTML de la página, si no es demasiado complicado. En este caso, encontramos una línea HTML que dice:

<input type=text name=q size=35 maxlength=800 value="">

con lo cual, se ve que la variable q es la que contiene la petición del usuario. Algo similar se puede hacer en casi todos los demás buscadores.

La dos líneas siguientes imprimen un mensaje, y se bajan efectivamente el URL. La función get está sacada del módulo LWP::Simple, y simplemente se baja una página y la mete en una variable. También se puede imprimir usando getprint o meterse en un fichero usando getstore. Como siempre, más información escribiendo perldoc LWP::Simple.

Finalmente, usando expresiones regulares (¿recuerdas las expresiones regulares? Mira en Regularizando la situación) se extrae el número de páginas que se han encontrado, y se imprime. Y nuestro político corrupto, finalment, comprueba que últimamente ya casi ni se habla del tema.

Ya que hemos aprendido todo lo que debíamos aprender sobre PERL, no está de más dar unos cuantos consejos para realizar buenos programas.

Mucho cuidado con los espacios, con los puntos y comas y los demás caracteres que no están ahí de adorno

Un espacio entre el $ y el nombre de una variable, dará un error de sintaxis. O un espacio entre el # y el !, que dará un error extraño, ya que el shell interpretará el resto de la línea como un comentario. Y no olvidemos nunca el ; al final de las sentencias, ni las llaves alrededor de cualquier bloque, como por ejemplo en los bucles.

Sigue siempre la via PERL

Aunque nos permita recurrir a lo que conocemos de otros lenguajes, PERL permite hacer las cosas de forma mucho más compacta, elegante y a veces rápida. Por ejemplo, en vez de

$zipi= $matriz[0];
$zape = $matriz[1];

en PERL se puede hacer:

($zipi,$zape) = @matriz;

O para dividir algo como "González McKenzie, Pepeillo", lo más rápido es ($Ap1, $Ap2, $Nombre) = /(\S+) (\S+), (\S+)/; (previa asignación a $_); en vez de utilizar split dos veces. O @fichero= <FILE>; en vez de usar un bucle para leer el fichero línea a línea. Los operadores de asignación de matrices, las variables asociativas y las expresiones regulares son fundamentales en casi cualquier programa PERL; dominarlas es alcanzar el Zen del PERL

Aprovéchate del depurador

Tiene órdenes bastante simples, y permite hacer muchas cosas; de hecho, todo lo que se puede hacer con PERL. Aunque parezca un poco espartano, es la mejor opción para empezar a crear un programa.

Conoce tus bibliotecas

Aparte de las muchas librerías estándar que trae PERL, hay otras, disponibles sobre todo en el CPAN, para hacer casi todo, desde acceso a base de datos hasta realizar tablas astrológicas. El conocer qué librerías hay disponibles, o mirar antes ahí, ahorrará mucho trabajo.

Como nuestro político corrupto está en la oposición, ya no tiene tanto tiempo de corromperse, y sí mucho más tiempo de aprender PERL, así que decide poner orden en sus cuentas, y ha oido hablar de una cosa que se llama XML, así que, ya puestos, lo hace en XML, para poder trabajar fácilmente con bases de datos, y para añadir un poco de metainformación a todo lo que tiene. Su fichero de clientes, en XML, podría tener esta pinta:

<clientela>
  <cliente>
    <nombre>Filemon Pi</nombre>
    <pasta> 404041.5</pasta> 
    <fecha>13:50 30/1/2000</fecha> </cliente>
<cliente>
    <nombre>Pantuflo Zapatilla</nombre>  
    <pasta>3750 </pasta>
    <fecha>13:50 23/2/2000</fecha></cliente>
<cliente>
    <nombre>Superintendente Vicente</nombre>  
    <pasta>64041.5</pasta>
    <fecha> 13:50 25/2/2000</fecha></cliente>
<cliente>
    <nombre>Zape Zapatilla</nombre> 
    <pasta>50000</pasta>
    <fecha> 13:50 22/3/2000</fecha></cliente>
<cliente>
    <nombre>Zipi Zapatilla</nombre> 
    <pasta>5000</pasta>
    <fecha> 13:50 29/3/2000</fecha></cliente>
</clientela>

Por supuesto, hizo un programa en PERL para pasarlo del formato anterior a este. En realidad, visto así, el XML no es tan complicado: basta con poner:

• Una etiqueta raíz, que en este caso es clientela.
• Todas las etiquetas tienen que estar bien emparejadas, es decir, deben de "terminar" en orden contrario al que "empezaron".

Esto, y algún detalle más, es lo que se denomina XML bien formado. Ya es más fácil procesarlo que el texto anterior, sobre todo si la información que hay en cada "campo" no siempre tiene el mismo formato, y se puede hacer simplemente con expresiones regulares. Sin embargo, es más simple hacerlo usando el módulo que se llama apropiadamente XML::Simple de esta forma (xml.pl):

1  #!/usr/bin/perl
2  use XML::Simple;
3  my $clientes = XMLin("/root/txt/tutoperl2000/clientes.xml");
4  for( @{$clientes->{cliente}} ) {
5    print "$_->{nombre} => $_->{pasta} ($_->{fecha})\n";
6  } 

Cuando se dice que una cosa es simple, es que es simple: 5 líneas, que podrían ser 3. La función XMLin, que se importa automáticamente del módulo XML::Simple, toma un fichero XML, se lo traga entero, y lo mete en una estructura de datos compuesta de hashes de hashes de hashes. En nuestro caso, en $clientes->{cliente} habrá un array con todos los clientes, es decir, todos los contenidos de todas las etiquetas clientes; pero esos contenidos estarán también analizados, y, por tanto, dentro de $clientes->{cliente}[0]{nombre} estará el contenido de la etiqueta nombre del primer cliente. En el programa, en la línea 4, se hace un bucle sobre el array principal, y se van imprimiendo los contenidos de las etiquetas del "segundo nivel".

Si cada cliente tuviera varios nombres, el contenido de la etiqueta nombre, en vez de ser simplemente el nombre, sería un array. En resumen, lo que se hace es traducir el árbol en el que se convierte el fichero XML a un árbol de matrices asociativas: cada etiqueta se convierte en una clave de una matriz asociativa, y si hay varias etiquetas en un nivel el contenido de esa clave es un array con todos los interiores de las etiquetas

Algunas notas sobre la instalación

Instalar el módulo XML::Simple es relativamente fácil; basta con dar la orden correspondiente desde el Perl Package Manager o desde el módulo CPAN. Sin embargo, previamente tiene que estar instalado el programa y la librería de expat, que es un parser de XML. Expat se lo puede uno bajar desde http://expat.sourceforge.net/, tanto en fuentes como en RPMs (para RedHat).

Para saber más

Si quieres saber más sobre XML, hay un curso completo dentro de GeNeura:Formación, incluyendo una lección sobre parsers de XML en PERL, el único que hay en castellano en la red.

1. - Introduccion

Los scripts CGI pueden generar documentos HTML cuyo contenido varie dependiendo de los argumentos que se le pasen o de determinadas condiciones. De esta forma podemos hacer accesos a bases de datos, realizar compras, etc.

Al diseñar un CGI hay que crear la parte que el usuario ve, el programa y el resultado que se le presenta al usuario.

2.- Modo de trabajo de los CGI

1. El browser llama a una URL que es un CGI.
2. El servidor recibe la petición, detecta que la URL es un CGI y ejecuta el script.
3. El script realiza unas acciones (las que se le han programado).
4. El script formatea los resultados de forma que el browser pueda interpretarlos.
5. El usuario ve el resultado en el browser.

• Los scripts deben tener permisos de ejecución para el usuario definido por el servidor web.
• Pueden ser agujeros de seguridad en el sistema.
• Pueden estar realizados en cualquier lenguaje, interpretado o binario.

3.- Configuración del servidor para permitir CGI

Para que un servidor pueda ejecutar CGI, hay que configurar adecuadamente el daemon.

En general, los scripts deben estar en un directorio concreto reservado para los mismos, de forma que si el URL indica un fichero en ese directorio, el servidor ve que es un programa y no una página HTML.

Si utilizamos el servidor del CERN, debemos editar el fichero httpd.conf, donde encontraremos una linea del tipo:

     Exec /cgi-bin/* /home/www/cgi-bin/*

Puede haber varias líneas de este tipo, indicando que en esos directorios se pueden colocar los CGI.
La segunda parte de la línea es el nombre a usar para llamar a los CGI en las URL. La tercera parte es el camino físico en el disco donde estará los CGI.

Si utilizamos el servidor de NCSA, en el fichero srm.conf debemos añadir una línea del tipo:

     ScriptAlias /cgi-bin/ /home/www/cgi-bin/

4.- Cabecera de los scripts

Lo primero que debe hacer el script es informar del tipo de salida que va a dar como resultado (HTML, GIF, etc).

El tipo de documento se especifica en una línea del tipo:

     Content-type: tipo_MIME

• text/html
• test/plain
• image/gif
• image/jpeg
• application/postcript
• video/mpeg
• etc.

Tras esta linea, hay que enviar otra en blanco (dos retornos de carro). Por ejemplo, en Perl:

     print "Content-type: text/html\n\n";
     ....

5.- Datos de salida

Una vez especificada la cabecera, hay que proporcionar el documento acorde al tipo especificado como cabecera. Los datos se envian al browser simplemente sacándolos por salida estándar.

Por ejemplo:

	#!/usr/bin/perl
	print "Content-type: text/plain\n\n";
	print "Mi primer CGI";
	

Probar el ejemplo...

Es importante que los datos enviados al browser (sacados por salida estándar) sean compatibles con el formato especificado en la cabecera.

Por ejemplo, si indicamos que vamos a generar un fichero HTML, el browser interpretará correctamente los tags que incluyamos:

	#!/usr/bin/perl
	print "Content-type: text/html\n\n";
	print "<HTML>";
	print "<BODY>";
	print "<HR>";
	print "<H1>Segundo CGI...</H1>";
	print "<HR>";
	print "</BODY>";
	print "</HTML>";
	

6.- Consejos para evitar y resolver problemas

Cuando ejecutemos un CGI a través de un browser, si el CGI tiene algún error de programación, el únco error que obtendremos será algo del tipo:

	Internal Server Error
	
	The server encountered an internal error or 
	misconfiguration and was unable to complete your request.
	
	Please contact the server administrator, adm@server.dom.dom
	and inform them of the time the error occurred, 
	and anything you might have done that may have caused the error.
	

Es conveniente (que no obligatorio) hacer uso de sentencias print cortas y claras, terminándolas con retornos de carro, para que el código HTML generado sea claro y fácil de depurar.

De esta forma, y antes de probar un script a través del browser, lo que haremos será ejecutarlo desde la línea de órdenes (shell), con lo cual, si hay errores, nos saldrá la línea/s donde los hay, y si todo está bien, nos imprimirá el código HTML que formaría la página a visualizar.

Por otro lado, si el código generado es fácil de seguir, nos será más fácil después ver porqué los elementos y la información generada para visualizar en el browser cliente no aparece como deseamos (si es que aparece mal).

7.- Ejemplos

Hora actual en formato texto

	#!/usr/bin/perl
	
	# parte activa del programa
	($s,$m,$h, @resto) = localtime(time);
	
	# composicion del documento a mostrar
	print "Content-type: text/plain\n\n";
	print "Hora actual: $h:$m:$s ";
	

Procesado de las variables de entorno

	#!/usr/bin/perl
	# composicion del documento a mostrar
	print "Content-type: text/html\n\n";
	print <<escribiendo;
	<html>
	<body>
	escribiendo;
	
	foreach $clave (keys(%ENV)) {
		print "$clave = $ENV{$clave} <BR>\n";
	}
	
	print "</body></html>\n";
	

Pasarle valores a los CGIs al llamarlos

El ejemplo que pondremos aqui simplemente es llamado y cuenta el número de argumentos pasados y los muestra si ha habido alguno:

	#!/usr/bin/perl

	# composicion del documento a mostrar
	print "Content-type: text/plain\n\n";

	if( $#ARGV < 0 ) {
	  print "NO hay argumentos \n";
	}else{
	  print "SI hay argumentos (del 0 al $#ARGV) \n";
	  for($i=0; $i <= $#ARGV ;$i++){
	    print "$i   $ARGV[$i] \n";
	  }
	}
	

Hora y fecha actuales en formato HTML

Contador de visitas

Algunas funciones

A continuación se describen algunas de las funciones más utilizadas en la programación de un perl script, esto no pretende ser un manual de referencia luego para conseguir el formato puedes usar el comando man perl:

• abs: devuelve el valor absoluto de la expresion pasada.

• chmod: cambia los permisos de los ficheros dados.

chop: recorta y retorna el último carácter de una cadena.
• chown: cambia el propietario de los ficheros dados.

• close : cierra un fichero.

• cos: devuelve el coseno del angulo dado en radianes.

• defined: sirve para comprobar si existe una variable,formato, subrutina,etc..

• delete: borra un valor de un array asociativo a traves de su clave.

• die:imprime en la salida del error estandar un mensaje pasado como parametro cuando ocurre un error en la ejecucion de una sentencia.

• eof: retorna verdadero si el final del fichero dado.

• eval: evalua la expresión pasada como si se tratase de un pequeño programa perl.

• exec: ejecuta lo que pasemos como parametro y sale del programa.

• exit: hace que salgamos del perl script devolviendo al sistema operativo el valor pasado como argumento.

• exp: retorna el numero e elevado a la potencia pasada como parametro.

• fileno: devuelve el descriptor del manejador del fichero pasado como parametro.

• fork: realiza una llamada fork.

• getc: lee el siguiente caracter del fichero especificado.

• hex: devuelve el valor decimal del numero hexadecimal pasado como parametro.

• index: devuelve la posicion de la primera ocurrencia de una cadena en otra.

• int: devuelve la parte entera del parametro pasado.

• join: une las cadenas pasadas como argumento con un separador tambien pasado como argumento.

• keys: devuelve todas las claves de un array asociativo.

• length: devuelve la longitud en caracteres del parametro pasado.

• local: declara como locales las variables pasadas como argumentos.

• log: devuelve el logaritmo del numero dado.

• mkdir: crea un directorio en el camino dado.

• oct: devuelve el valor decimal del numero octal pasado como parametro.

• open: abre el fichero fichero dado asociandole un manejador de fichero especificado tambien como parametro.

• pop: retorna y borra el ultimo elemento del array dado.

• print: muestra en la salida standard o en el fichero especificado la expresion dada.

• push: añade el valor dado al final del array pasado como parametro.

• rand: devuelve un numero aleatorio entre 0 y el valor pasado como argumento.

• read: lee un determinado numero de caracteres desde el fichero pasado como argumento.

• rename: sirve para renombrar un fichero.

• require: sirve para incluir codigo externo en nuestro guion.

• return: devuelve un valor desde una subrutina.

• rmdir: borra un directorio.

• seek: situa un puntero a fichero en un lugar determinado.

• select: sirve para seleccionar el manejador de fichero que sera utilizado por defecto para la salida de los comandos o funciones que no especifiquen un determinado manejador de fichero como parametro.

• shift: devuelve el primer valor del array dado borrandolo posteriormente.

• sin: devuelve el seno del angulo pasado en radianes.

• sleep: causa que el perl script o guion se detenga el numero de segundos especificados.

• sort: ordena el array dado.

• split: divide una cadena en subcadenas segun el separador especificado.

• sqrt: devuelve la raiz cuadrada del numero pasado.

• system: igual que exec pero no se sale del perl script.

• tell: devuelve la posicion actual del puntero a fichero del manejador de fichero especificado.

• values: devuelve todos los valores del array asociativo dado.

• write: escribe un registro con formato en el fichero asociado a ese formato.

Operadores

PERL soporta una gran cantidad de operadores, la mayoria de ellos heredados del lenguaje C. En PERL los operadores conservan el mismo uso que en el resto de lenguajes, y se utilizan para realizar operaciones aritmeticas, operaciones logicas ..., entre las variables del programa. Los operadores pueden clasificarse en los siguientes tipos:

• Operadores de comparación: mediante estos operadores podemos enfrentar dos expresiones, de manera, que dependiendo de su valor se generará un resultado que puede ser lógico o numérico. PERL tiene los siguientes operadores de comparación:
  • == . Este operador sirve para comparar dos valores iguales, de manera que cuando las expresiones a su izquierda y su derecha son iguales, devuelve un valor lógico verdadero y cuando no lo son devuelve falso:

              if ($var == 3) { ...}
      

    en el caso de que el contenido de la variable sea tres se realizan las operaciones entre parentesis.

  • eq . Es empleado para comparar expresiones no numéricas, esto es, se utiliza de igual manera que == pero para cadenas.

  • != . Con este operador se comparan cantidades numéricas diferentes.

              if ($var != 3) { ...}
      

    si los valores son diferentes se ejecutan la instrucciones entre llaves.

  • ne . Se utiliza para comparar cantidades no numericas diferentes. Su funcionamiento es similar que el de != .

  • < . Verifica el valor de una cantidad numérica con repecto del valor de la expresión de la derecha, de modo que si el valor de esta expresión es mayor que el de la cantidad numérica se devuelve cierto, en caso contrario se devuelve falso:

              if ($var < 3) { ...}
      

    ejecuta las instrucciones entre parentesis si el valor de var es menor que tres.

  • > . Verifica el valor de una cantidad numérica con repecto del valor de la expresión de la derecha, de modo que si el valor de esta expresión es menor que el de la cantidad numérica se devuelve cierto, en caso contrario se devuelve falso:

              if ($var > 3) { ...}
      

    ejecuta las instrucciones entre parentesis si el valor de var es mayor que tres. Los operadores para los terminos menor o igual y mayor o igual son <= y >= respectivamente, y en ambos casos además de el significado de cada término explicado anteriormente, se devuelve cierto si las expresiones son iguales.

    Como en el caso de las operaciones anteriores, existen equivalentes que se utilizan con las cadenas no númericas para los terminos < y > . Estos operadores son: lt que devuelve cierto si el orden de la cadena de la izquierda es menor que el de la cadena de la derecha, y gt que devuelve cierto si la cadena de la izquierda es mayor que el orden de la cadena de la derecha.

  • cmp . Este termino es utilizado para comparar caracteres, de manera que, retorna 0 si los caracteres comparados son iguales, 1 si la cadena de la derecha se encuentra al comienzo de la de la izquierda, y -1 en el caso contrario:

      
      'one' cmp 'one'
    DEVUELVE 0             
      'one dog ' cmp 'one'    
    DEVUELVE 1
      'dog one' cmp 'one'        
    DEVUELVE -1
       'es diferente' cmp 'one'
    DEVUELVE -1
     

  • <=> . Este termino se utiliza para comparar valores numericos, retornando 0 cuando son iguales, 1 cuando el termino de la derecha es menor que el de la izquierda y -1 en el caso contrario.

  • =~ . Este termino es usado en las expresiones regulares para indicar la presencia de un patrón de compración dentro de una variable que contiene una cadena de caracteres:

              if ($var =~/pepe/) { ...}
      

    verifica si la cadena 'pepe' se encuentra dentro de var y si es así, ejecuta el código entre llaves.

  • !~ . Meditante este operador se verifica la no existencia del patrón de busqueda en una cadena:

              if ($var !~/pepe/) { ...}
      

    si la cadena 'pepe' no esta en var se ejecuta el codigo entre llaves.

• Operadores de asignación: los terminos de asignación se utilizan en PERL para dar valores a cualquiera de las variables validas en PERL. Existen en Perl los siguientes operadores de asignación:
  • = . Con este termino se asigna a la variable que se encuentra a la izquierda del operador el valor de la expresión de la derecha. Asi mediante este valor se pueden dar valores iniciales a cualquier variable:

              $var = 'Buenos dias';
      

    asigna la cadena 'Buenos dias' a la variable var.

  • =~ . A parte de la función de verificación de existencia de un patrón dentro de una cadena que anteriormente se explicó, este operador dentro de una expresión regular de sustitución se utiliza para sustituir un patrón de comparación por otra cadena:

              $var =~ s/one/uno/;
      

    se reemplaza la ocurrencia de la cadena 'one' por la cadena 'uno'.

• Operadores aritméticos: Mediante estos terminos se realizan las operaciones aritméticas necerias para el manejo de las expresiones. A parte de los operadores aritméticos comunes; +(suma), -(resta), *(multiplicación) y /(división), PERL tambien incluye los siguientes operadores:
  • ** Este término se emplea para obtener la potencia de un valor numérico, ejemplo :

     $var = 6;
     $var**2;  
    

    el valor almacenado en var es 36.

  • . Este término se emplea para concatenar dos cadenas de caracteres, ejemplo:

      $var = 'Juan ';  
      $var . 'Ramirez';  
     

    var contendrá la cadena Juan Ramirez.

  • x Este término multiplica n veces la cadena de caracteres especificada, ejemplo :

      'd' x 20;      
     

    expresa una cadena de 20 caracteres d.

  • % Permite obtener el módulo de la división entre dos números, ejemplo :

      $var = 5 % 2; 
    

    el valor que se asigna a var es 1.

  • | Este término cuando se emplea entre 2 valores numéricos, permite realizar una operación binaria 'o' entre ellos, ejemplo

      $var = 3 | 2; 
    

    el valor que se asigna a la variable es 3.

  • & Este término cuando se emplea entre 2 valores numéricos, permite realizar una operación binaria 'y' entre ellos, ejemplo :

      $var = 3 & 2; 
    

    el valor asignado es 2.

  El operador de asignación
= está muy relacionado con los operadores aritméticos de modo que PERL permite que se combinen ambos siguiendo este formato general:

  $variable (operador aritmetico)= expresión;

En general lo que se consigue con este formato es realizar la operación aritmetica, y posteriormente asignar el valor a la variable. Así aquí vemos algunos ejemplos de esta combinación:

  $var = 5;
  $var += 6;

después de esta asignación el valor de var sera 11 (ha sumado 6 al valor anterior de la variable y posteriormente ha asignado el resultado).

  $var = 5;
  $var %= 2;

el valor actual de la variable sera 1.

• | . Este operador se utiliza en las expresiones regulares como operador lógico 'o', de modo que retorna cierto siempre que cualquiera de los patrónes de busqueda que componen la expresión sea cierto y falso cuando los dos son falsos. Por ejemplo

            if ($var !~/pepe | juan/) { ...}
    

  el código entre llaves se ejecuta si en la cadena que se encuentra dentro de la varible existe una ocurrencia igual a 'pepe' o igual a 'juan'.

  Además de utilizarse dentro de las expresiones regulares, también se utiliza para unir mediante la operación 'o' dos expresiones condicionales. Así por ejemplo:

            if ($var == 6 | $var < 3) { ...}
    

  ejecuta el código entre llaves si la variable es igual a 6 o menor que 3.

• || . También representa la operación lógica 'o' pero en este caso se utiliza sobre instrucciones no sobre expresiones.

• & . Este operador trabaja como un operador lógico 'y' en expresiones regulares, permite confrontar 2 patrones, de modo que para que se produzca un valor cierto se tiene que cumplir la existencia de ambos en la cadena donde se realiza la comparación, en el caso contrario el valor devuelto es falso, ejemplo:

       if  ($var =~ /coche & moto/) { ...}
  

  el código entre parentesis se ejecuta si dentro de la variable existe una ocurrencia de la cadena 'coche' y otra de la cadena 'moto'. Como en el caso del operador | también se utiliza para relaccionar expresiones condicionales.

• && . Al igual que el operador anterior trabaja como un operador lógico 'y', pero con la diferencia de que este operador se emplea sobre instrucciones y no sobre expresiones regulares.

• ! . Con este operador realizamos una evaluación negativa de la expresión, ejemplo:

        if  (!$var) { ...}
  

  el código entre llaves se ejecuta si la variable var es nulo o 0.

• -r : indica si el archivo tiene permiso de lectura.

• -W : indica si el archivo tiene permiso de escritura.

• -T : indica si el archivo es de tipo texto.

• -e : indica si el archivo existe.

• -z : indica si el archivo tiene tamaño 0.

• -s : indica si el archivo es mayor que 0.

• -f : indica si el archivo es plano.

• -d : indica si se trata de un directorio.

• -M : indica el número dias despues de la última modificación

• -B : indica si el archivo es binario.

• -t : indica si el archivo esta abierto en un terminal.

Variables predefinidas

Los siguientes nombres tienen un significado especial en PERL sólo incluiremos los más interesantes, para una información más detallada consulta tu manual de usuario:

• $_ contiene el contenido del último registro leido de un fichero.

• $. contiene el número de la última línea leida de un fichero.

• $/ separador de campo para la entrada.

• $, separador de campo para la salida, aplicable a print.

• $\ separador de registro para la salida, aplicable a print.

• $~ contiene el nombre del formato o report definido para la salida actual.

• $^ contiene el nombre de la cabecera de formato o report definido para la salida actual.

• $$ número de proceso perl scripts que se esta ejecutando actualmente.

• $& representa el valor de la último cadena de caracteres comparada exitosamente.

• $` y $' estos dos terminos se utilizan conjuntamente para separar cadenas de caracteres comparadas exitosamente.

• $! contiene el valor actual de ERRNO, es decir, el último error acontecido.

• $0 contiene el nombre del fichero que hemos dado a nuestro perl script.

• $[ contiene el valor del primer indice de una array de escalares, por defecto es 0.

• $< uid real del proceso actual.

• $> uid efectivo del proceso actual.

• $( gid real del proceso actual.

• $) gid efectivo del proceso actual.

• @ARGV contiene los parámetros pasados a nuestro perl script.

• %ENV array asociativo que contiene las variables de entorno bajo el que se ejecuta nuestro perl script.

Libros

Perl viene con todo el material necesario para trabajar; en el caso de la versión 4, con una macro-página de manual en formato UNIX, y en el caso de la versión 5, con varias páginas de manual, e incluso páginas de manual en HTML. Hay, además varios libros publicados:

• Programming Perl, de Larry Wall y Randall L. Schwartz, O'Reilly and associates. Se le suele llamar "The Camel Book" por el camello de la portada. Escrito por el gran guru, incluye manual de referencia, muchos ejemplos, y una explicación de cada una de las estructuras.




• Professional Perl Programming, de Peter Wainwright, Shelley Powers, Aldo Calpini, Arthur Corliss, Simon Cozens, JJ Merelo-Guervós, Aalhad Saraf, Chris Nandor, Wrox Press. A este se le podría llamar el "libro de las cabezas". Un libro muy completo, que trata todos los aspectos de Perl en profundidad, incluyendo algunos que otros libros se dejan fuera: programación usando locale, por ejemplo, módulos, procesos y programación dirigida a objetos.




• Learning Perl, de Randall L. Schwartz y otros, O´Reilly and associates. El "Llama book"; se puede obtener de la misma forma, por ejemplo, de Amazon. Si quieres aprender, después de leer este tutorial, puedes seguir con este libro. Más educativo que el anterior.





• Perl cookbook, de Larry Wall y otros, un libro con un montón de ejemplos, que muestra todo lo que puede hacer Perl, desde CGIs hasta conectar con otras máquinas usando telnet. A este se le debe conocer por el libro del cabrito, o algo así.


• The Perl Cd Bookshelf : 6 Bestselling Books on Cd-Rom, todos los libros anteriores, y además en CD-ROM, para poder buscar lo que a uno le interesa. Imprescincible.


• Programming the Perl DBI por Alligator Descartes, Tim Bunce , que explica claramente cómo usar este módulo que sirve para acceder a bases de datos, y una introducción general sobre cómo trabajar con bases de datos y Perl.


• Teach yourself Perl in 21 Days, David Till, SAMS Publishing; un tocho considerable que me encontré en una librería al lado de la Facultad. Muy completo, pero no tan divertido como el "Camel Book". Por cierto, que me lo han chorizado, por favor, si alguien lo ve, que me lo diga.
• Developing Applications in Perl, de Tom Christiansen, Byte, April 1994, p. 231-236.

Además, se han publicado tutoriales en diversas publicaciones, como UNIX World (Mayo-Julio 1990), y en la fenecida revista Click!, de marzo a junio de 1995 (una versión anterior de este mismo tutorial).

Sitios generalistas

• Alguna cosilla hay en http://www.perl.com, sitio central dedicado al Perl. Este sitio contiene noticias, listas de correo, enlaces a todos los sitios de donde puede uno bajarse las diferentes versiones de Perl.
• Los sitios CPAN (Comprehensive Perl Archive Network), o red de sitios con archivos, módulos, y librerías relacionados con el Perl.
• Los sitios PerlMongers (http://www.pm.org) están dedicados a grupos de usuarios de perl; y también hay un www.perl.org.
• La documentación de Perl se puede encontrar en PerlDoc.
• Hay varios sitios que incluyen noticias periódicas sobre Perl: Use Perl y Perl News, ambos incluyen noticias sobre nuevos módulos, nuevas versiones, eventos relacionados con Perl y cotilleos en general.
• La versión para WindowsNT/98/95/2K se puede bajar de la empresa ActiveState http://www.activestate.com/.
• Hay unos cuantos grupos de usenet dedicado al Perl; comp.lang.perl, tiene un tráfico de unos 100 mensajes al día, y normalmente los propios desarrolladores de Perl, Larry, Tom Christiansen (que, por cierto, habla español) y Randy Schwartz contestan a tus dudas. Mucho tráfico, pero nada que no pueda salvar un buen killfile; otros grupos se dedican a anuncios comp.lang.perl.announce, y a una version de Perl combinada con tcl/tk, el tkPerl, comp.lang.perl.tk.
• Indigo Star ha creado una versión de Perl, IndigoPerl, que incluye un servidor Apache; es ideal para depurar CGIs en sistemas WinXX (todo lo ideal que pueda ser en estos sistemas).

Sitios en castellano: tutoriales, noticias

Además, hay una serie de sitios sobre Perl que están en castellano

• En el Yahoo español hay bastantes punteros a recursos en castellano, varios cursos, sitios con código y demás.
• Otro sitio en castellano, Código Perl, con programas de ejemplo y tutoriales. Enfocado sobre todo a programar CGIs en Perl.
• El sitio de Perl en español, creado por el grupo de usuarios de Perl en Tijuana, México, con enlaces a varios tutoriales y FAQs traducidas al español.
• Hay diversas listas de correo que tratan de Perl en español, muchas de ellas alojadas en YahooGroups . La principal es perl-es. Tiene mensajes de todo tipo, desde el básico hasta el avanzado, y viene a tener 1-2 mensajes al día.
• Un tutorial bastante extenso, y en postscript, es el escrito por Diego Sevilla, que es además uno de los habituales en la lista de correo anterior. Es muy completo, y llega incluso a explicar cómo acceder a bases de datos por ODBC en Windows (el enlace al tutorial de Perl está al final de la página.
• El que tiene la portada más cachonda es la guía del programador, con lo de Perl lava más blanco y demás. Sirve para principiantes, pero también explica como programar server side includes y CGIs.
• Uno de los clásicos, la introducción al lenguaje Perl, de Víctor Osuna y Eleuterio Rodríguez, en la Universidad de Córdoba (España), en la que todavía parpadean los fallos HTML y la fecha de última modificación, hace 4 años.Incluye ejercicios, una pequeña guía de referencia, y llega hasta las expresiones regulares. Bastante básico, pero está bien si quieres aprender expresiones regulares. Este tutorial desapareció de su sitio original y apareció en Colombia, lo cual demuestra que los buenos tutoriales de Perl nunca mueren.
• Desde Colombia, nos llega El Evangelio de Perl (en .doc), un tutorial bastante avanzado, que incluye cómo usar referencias y otras características de la versión 5. El HTML es un poco espartano, eso sí. También he tenido que buscarlo por el mundo; ha aparecido en Argentina.
• Un excelente tutorial en castellano sobre Perl DBI, de Javier García Castellano, enfocado principalmente al comercio electrónico, que explica cómo programar carritos de la compra usando Perl, DBI y MySQL.
• Otro excelente tutorial en castellano sobre expresiones regulares, CGIs y subrutinas en Perl, de Pedro Castillo Valdivieso.
• Aparte de todo, este tutorial es uno de los más copiados en Internet, aparte de las réplicas oficiales en LuCAS; no hay más que buscar en google. Por favor, si queréis poner un tutorial de Perl en vuestras páginas, poned un enlace a este tutorial; o por lo menos reconocer quién ha sido el que lo ha escrito (el menda).
• Hay algunos sitios web sobre perl "regionales", como Perl en Español (la carpeta spanish contiene un montón de tutoriales), el grupo Perl Mongers de Madrid (con enlaces a cursos), de Barcelona, La Rioja (con enlaces a diferentes tutoriales)
• Barrapunto de perl en castellano, colección de noticias relacionadas con el Perl, el español.

Preguntas habituales

¿Cómo se pueden hacer CGIs en PERL?¿Qué diferencia hay entre CGI y PERL?

CGI no es un lenguaje, es una forma de escribir programas que se pueden escribir en cualquier lenguaje; en especial, se pueden escribir en PERL; que está especialmente diseñado para ello. Escribir un CGI en PERL es tan simple como esto:

print "Content-type: text/html\n\n";
print "Hola";

. Por supuesto, habrá que colocarlo en la zona correspondiente del servidor para que sea accesible como CGI. Otra forma, a partir de la versión 5, es:

use CGI;
print header, start_html, title('titulo'),end_html;

que usa el módulo estándar CGI.pm, que sirve precisamente para escribir CGIs. Más información, escribiendo perldoc CGI

¿Cómo se puede acceder a una base de datos en PERL?¿Qué bases de datos puedo usar?

Lo más fácil es usar el módulo DBI (que, como todos los demás, está en el CPAN), con un driver específico para el gestor de bases de datos, o si hay ninguno específico, y la BD está accesible usando ODBC, pues con ODBC. En WinXX hay un módulo alternativo, específico para ODBC, denominado Win32::ODBC. Con cualquiera de estos dos módulos, se puede usar con cualquier SGBD; en Linux/Unix, se puede usar con MySQL o MiniSQL, o Postgres; y en Windows se puede usar con Microsoft SQL server combinado con ODBC. Eso sí, como es inherente a las conexiones ODBC, es más bien tirando a lento.

Tengo este error en un programa en PERL. Por favor, ¿puedes echarle un vistazo a ver qué le pasa? O, una variación de la anterior: por favor, ¿puedes mandarme un programa que haga tal cosa?

Pues generalmente, no. Bastante tengo con hallar los errores de mi código, para ponerme a hallar los errores ajenos. Y en cuanto a la segunda, si lo tuviera y quisiera darlo, estaría entre los ejemplos, y si no está, en fin, hay gente que se gana la vida programando el PERL, echadles una mano... Ojo, esto no significa que no podáis preguntarme dudas, estoy encantado de contestarlas. Pero no corregir programas ajenos, o hacer programas para alguien (aunque por un módico precio, podemos llegar a un acuerdo). En estos casos, lo mejor es que escribáis a alguna lista de correo que trate de PERL, tal como PERL-ES; seguro que habrá gente encantada de ayudaros.

¿Funcionan exactamente igual los programas PERL en Windows y en Unix?

En general, sí. En particular, hay algunas cosas que no funcionan de la misma forma: por ejemplo, la orden fork no funciona (salvo en la nueva versión 5.6), el acceso a base de datos no se hace igual (se usa el módulo DBD/DBI en Linux y en Windows, generalmente, el Win32::ODBC, aunque también se puede usar el mismo); para ejecutar un programa en PERL hay que definir una serie de cosas. Pero en general, cualquier programa que no use ninguna característica específica de un sistema operativo funciona exactamente igual en los dos sistemas operativos. Y si hay alguna duda, se puede insertar código particular detectando el valor de la variable $OSNAME, $^O o $Config{osname} . Por ejemplo, se puede hacer algo así:

if ( $^O eq 'linux' ) {
    [código específico para Linux];
} else {
    [código para otros SOs menos afortunados];
}

¿Existe algún sitio web, preferentemente gratuito, donde se puedan poner scripts en PERL?

Existen varios: Lycos, por ejemplo, deja poner CGIs y PHP; si tienes algún proyecto en SourceForge, puedes poner también CGIs, aunque la versión de Perl está anticuada. La mayoría de los hosting comerciales permiten poner Perl sin problemas.

Oye, qué tutorial más chachipiruli tienes. ¿Puedo copiarlo a mi sitio web, o incluirlo en un CD que voy a repartir, o que voy a vender? En resumen: temas de licencia y copyright

La respuesta corta es vale, si y no; la respuesta larga es que, en general, este tutorial se puede copiar sin problemas, siempre que lo dejes como está y pongas un enlace a su sitio original, este; lo mismo sirve para cachos del tutorial, o los ejemplos. En cuanto a los CDs, si los CDs son de algún modo comerciales, es decir, se venden a un precio que supone ganancia para el que los vende, no, no hay permiso; si los CDs son sin ánimo de lucro, gratuitos, parte de un curso, o incluidos junto con otras muchas cosas en una revista, sí, si hay permiso, siempre que se incluya tal cual, y se me mande una copia (inclusive revista, si fuese así) a

JJ Merelo
Depto. Arquitectura y Tecnología de Computadores
ETS Ingeniería Informática
C/ Daniel Saucedo Aranda, s/n
18071 Granada (España)

Todo esto, por supuesto, afecta también a cualquier parte del tutorial o a los ejemplos que se incluyen con el mismo.