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.

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