Perl - Expresiones regulares

Una expresión regular es una cadena de caracteres que define el patrón o patrones que está viendo. La sintaxis de las expresiones regulares en Perl es muy similar a la que encontrará en otros programas de soporte de expresiones regulares, comosed, grepy awk.

El método básico para aplicar una expresión regular es utilizar los operadores de enlace de patrones = ~ y !~. El primer operador es un operador de prueba y asignación.

Hay tres operadores de expresiones regulares dentro de Perl.

• Coincidir con expresión regular - m //
• Expresión regular sustituta - s ///
• Transliterar expresión regular - tr ///

Las barras diagonales en cada caso actúan como delimitadores de la expresión regular (regex) que está especificando. Si se siente cómodo con cualquier otro delimitador, puede utilizarlo en lugar de la barra diagonal.

El operador de partidos

El operador de coincidencia, m //, se utiliza para hacer coincidir una cadena o declaración con una expresión regular. Por ejemplo, para hacer coincidir la secuencia de caracteres "foo" con la barra $ escalar, puede usar una declaración como esta:

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

First time is matching
Second time is matching

El m // en realidad funciona de la misma manera que la serie de operadores q //. Puede usar cualquier combinación de caracteres que coincidan naturalmente para actuar como delimitadores de la expresión. Por ejemplo, m {}, m () y m> <son todos válidos. Entonces, el ejemplo anterior se puede reescribir de la siguiente manera:

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Puede omitir m de m // si los delimitadores son barras inclinadas, pero para todos los demás delimitadores debe utilizar el prefijo m.

Tenga en cuenta que la expresión de coincidencia completa, que es la expresión a la izquierda de = ~ o! ~ Y el operador de coincidencia, devuelve verdadero (en un contexto escalar) si la expresión coincide. Por lo tanto, la declaración:

$true = ($foo =~ m/foo/);

establecerá $ true en 1 si $ foo coincide con la expresión regular, o 0 si la coincidencia falla. En un contexto de lista, la coincidencia devuelve el contenido de cualquier expresión agrupada. Por ejemplo, cuando extraemos las horas, los minutos y los segundos de una cadena de tiempo, podemos usar:

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Modificadores de operador de coincidencia

El operador de coincidencia admite su propio conjunto de modificadores. El modificador / g permite la coincidencia global. El modificador / i hará que la coincidencia no distinga entre mayúsculas y minúsculas. Aquí está la lista completa de modificadores

No Señor.	Modificador y descripción
1	i Hace que la coincidencia no distinga entre mayúsculas y minúsculas.
2	m Especifica que si la cadena tiene caracteres de retorno de carro o de línea nueva, los operadores ^ y $ ahora coincidirán con un límite de línea nueva, en lugar de un límite de cadena.
3	o Evalúa la expresión solo una vez.
4	s Permite el uso de. para que coincida con un carácter de nueva línea.
5	x Le permite utilizar espacios en blanco en la expresión para mayor claridad.
6	g Encuentra globalmente todas las coincidencias.
7	cg Permite que la búsqueda continúe incluso después de que falle una coincidencia global.

Coincidencia sólo una vez

También hay una versión más simple del operador de coincidencia: el? PATRÓN? operador. Esto es básicamente idéntico al operador m // excepto que solo coincide una vez dentro de la cadena que está buscando entre cada llamada para restablecer.

Por ejemplo, puede usar esto para obtener el primer y último elemento dentro de una lista:

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/;
   $last = $1 if /(foo.*)/;
}
print "First: $first, Last: $last\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

First: foo, Last: footbrdige

Variables de expresión regular

Las variables de expresión regular incluyen $, que contiene lo que coincida con la última coincidencia de agrupación; $&, que contiene toda la cadena coincidente; $`, que contiene todo antes de la cadena coincidente; y$', que contiene todo lo que sigue a la cadena coincidente. El siguiente código demuestra el resultado:

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/;
print "Before: $`\n";
print "Matched: $&\n";
print "After: $'\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

Before: The
Matched: foo
After: d is in the salad bar

El operador de sustitución

El operador de sustitución, s ///, es en realidad solo una extensión del operador de coincidencia que le permite reemplazar el texto que coincide con algún texto nuevo. La forma básica del operador es:

s/PATTERN/REPLACEMENT/;

El PATRÓN es la expresión regular del texto que estamos buscando. REPLACEMENT es una especificación para el texto o expresión regular que queremos usar para reemplazar el texto encontrado. Por ejemplo, podemos reemplazar todas las apariciones dedog con cat usando la siguiente expresión regular -

#/user/bin/perl

$string = "The cat sat on the mat";
$string =~ s/cat/dog/;

print "$string\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

The dog sat on the mat

Modificadores de operador de sustitución

Aquí está la lista de todos los modificadores usados ​​con el operador de sustitución.

No Señor.	Modificador y descripción
1	i Hace que la coincidencia no distinga entre mayúsculas y minúsculas.
2	m Especifica que si la cadena tiene caracteres de retorno de carro o de línea nueva, los operadores ^ y $ ahora coincidirán con un límite de línea nueva, en lugar de un límite de cadena.
3	o Evalúa la expresión solo una vez.
4	s Permite el uso de. para que coincida con un carácter de nueva línea.
5	x Le permite utilizar espacios en blanco en la expresión para mayor claridad.
6	g Reemplaza todas las apariciones de la expresión encontrada con el texto de reemplazo.
7	e Evalúa el reemplazo como si fuera una declaración de Perl y usa su valor de retorno como texto de reemplazo.

El operador de traducción

La traducción es similar, pero no idéntica, a los principios de sustitución, pero a diferencia de la sustitución, la traducción (o transliteración) no usa expresiones regulares para su búsqueda de valores de reemplazo. Los operadores de traducción son:

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

La traducción reemplaza todas las apariciones de los caracteres en SEARCHLIST con los caracteres correspondientes en REPLACEMENTLIST. Por ejemplo, usando "El gato se sentó en la alfombra". cadena que hemos estado usando en este capítulo -

#/user/bin/perl

$string = 'The cat sat on the mat';
$string =~ tr/a/o/;

print "$string\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

The cot sot on the mot.

También se pueden utilizar rangos estándar de Perl, lo que le permite especificar rangos de caracteres por letra o valor numérico. Para cambiar el caso de la cadena, puede utilizar la siguiente sintaxis en lugar de lauc función.

$string =~ tr/a-z/A-Z/;

Modificadores del operador de traducción

A continuación se muestra la lista de operadores relacionados con la traducción.

No Señor.	Modificador y descripción
1	c Complementos SEARCHLIST.
2	d Elimina los caracteres encontrados pero no reemplazados.
3	s Aplasta los caracteres reemplazados duplicados.

El modificador / d elimina los caracteres que coinciden con SEARCHLIST que no tienen una entrada correspondiente en REPLACEMENTLIST. Por ejemplo

#!/usr/bin/perl 

$string = 'the cat sat on the mat.';
$string =~ tr/a-z/b/d;

print "$string\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

b b   b.

El último modificador, / s, elimina las secuencias duplicadas de caracteres que fueron reemplazados, entonces -

#!/usr/bin/perl

$string = 'food';
$string = 'food';
$string =~ tr/a-z/a-z/s;

print "$string\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

fod

Expresiones regulares más complejas

No solo tiene que hacer coincidir cadenas fijas. De hecho, puede hacer coincidir casi cualquier cosa con la que pueda soñar utilizando expresiones regulares más complejas. Aquí hay una hoja de trucos rápida:

La siguiente tabla enumera la sintaxis de expresión regular que está disponible en Python.

No Señor.	Patrón y descripción
1	^ Coincide con el comienzo de la línea.
2	$ Coincide con el final de la línea.
3	. Coincide con cualquier carácter individual excepto nueva línea. El uso de la opción m también le permite hacer coincidir la nueva línea.
4	[...] Coincide con cualquier carácter individual entre paréntesis.
5	[^...] Coincide con cualquier carácter individual que no esté entre corchetes.
6	* Coincide con 0 o más apariciones de la expresión anterior.
7	+ Coincide con 1 o más ocurrencias de la expresión anterior.
8	? Coincide con 0 o 1 aparición de la expresión anterior.
9	{ n} Coincide exactamente con n número de apariciones de la expresión anterior.
10	{ n,} Coincide con no más ocurrencias de la expresión anterior.
11	{ n, m} Coincide con al menos n y como máximo m apariciones de la expresión anterior.
12	a| b Coincide con a o b.
13	\w Coincide con caracteres de palabras.
14	\W Coincide con caracteres que no son palabras.
15	\s Coincide con los espacios en blanco. Equivalente a [\ t \ n \ r \ f].
dieciséis	\S Coincide con espacios que no son en blanco.
17	\d Coincide con dígitos. Equivalente a [0-9].
18	\D Coincide con no dígitos.
19	\A Coincide con el comienzo de la cadena.
20	\Z Coincide con el final de la cuerda. Si existe una nueva línea, coincide justo antes de la nueva línea.
21	\z Coincide con el final de la cuerda.
22	\G Los partidos apuntan donde terminó el último partido.
23	\b Coincide con los límites de las palabras cuando están fuera de los corchetes. Coincide con el retroceso (0x08) cuando está entre corchetes.
24	\B Coincide con los límites que no son de palabras.
25	\n, \t, etc. Coincide con nuevas líneas, retornos de carro, pestañas, etc.
26	\1...\9 Coincide con la enésima subexpresión agrupada.
27	\10 Coincide con la enésima subexpresión agrupada si ya coincidió. De lo contrario, se refiere a la representación octal de un código de carácter.
28	[aeiou] Coincide con un solo carácter en el conjunto dado
29	[^aeiou] Coincide con un solo carácter fuera del conjunto dado

El metacarácter ^ coincide con el comienzo de la cadena y el metasímbolo $ coincide con el final de la cadena. A continuación se muestran algunos breves ejemplos.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Echemos un vistazo a otro ejemplo.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm;
print "First word: $start\n","Line starts: @lines\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

First word: Cats
Line starts: Cats When

Límites coincidentes

los \bcoincide con cualquier límite de palabra, según lo definido por la diferencia entre la clase \ w y la clase \ W. Como \ w incluye los caracteres de una palabra y \ W lo contrario, esto normalmente significa la terminación de una palabra. los\Baserción coincide con cualquier posición que no sea un límite de palabras. Por ejemplo

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Selección de alternativas

El | carácter es como el estándar o bit a bit OR dentro de Perl. Especifica coincidencias alternativas dentro de una expresión regular o grupo. Por ejemplo, para hacer coincidir "gato" o "perro" en una expresión, puede usar esto:

if ($string =~ /cat|dog/)

Puede agrupar elementos individuales de una expresión para admitir coincidencias complejas. La búsqueda de los nombres de dos personas se puede lograr con dos pruebas separadas, como esta:

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/))

This could be written as follows

if ($string =~ /(Martin|Sharon) Brown/)

Agrupación de coincidencias

Desde el punto de vista de las expresiones regulares, no hay diferencia entre ellas excepto, quizás, que la primera es un poco más clara.

$string =~ /(\S+)\s+(\S+)/;

and 

$string =~ /\S+\s+\S+/;

Sin embargo, el beneficio de la agrupación es que nos permite extraer una secuencia de una expresión regular. Las agrupaciones se devuelven como una lista en el orden en que aparecen en el original. Por ejemplo, en el siguiente fragmento hemos extraído las horas, minutos y segundos de una cadena.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Además de este método directo, los grupos coincidentes también están disponibles dentro de las variables especiales $ x, donde x es el número del grupo dentro de la expresión regular. Por lo tanto, podríamos reescribir el ejemplo anterior de la siguiente manera:

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/;
my ($hours, $minutes, $seconds) = ($1, $2, $3);

print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

Hours : 12, Minutes: 05, Second: 30

Cuando se usan grupos en expresiones de sustitución, la sintaxis $ x se puede usar en el texto de reemplazo. Por lo tanto, podríamos reformatear una cadena de fecha usando esto:

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

1999/03/26

La afirmación \ G

La aserción \ G le permite continuar buscando desde el punto donde ocurrió la última coincidencia. Por ejemplo, en el siguiente código, usamos \ G para que podamos buscar la posición correcta y luego extraer alguna información, sin tener que crear una expresión regular única más compleja:

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g;
($time) = ($string =~ /\G(\d+:\d+:\d+)/);
$string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

Time: 12:31:02, Date: 4/12/00

La aserción \ G es en realidad solo el metasímbolo equivalente de la función pos, por lo que entre las llamadas de expresión regular puede continuar usando pos, e incluso modificar el valor de pos (y por lo tanto \ G) usando pos como una subrutina lvalue.

Ejemplos de expresiones regulares

Caracteres literales

No Señor.	Ejemplo y descripción
1	Perl Coincidir con "Perl".

Clases de personajes

No Señor.	Ejemplo y descripción
1	[Pp]ython Coincide con "Python" o "python"
2	rub[ye] Coincide con "ruby" o "rube"
3	[aeiou] Coincide con cualquier vocal minúscula
4	[0-9] Coincide con cualquier dígito; igual que [0123456789]
5	[a-z] Coincide con cualquier letra ASCII minúscula
6	[A-Z] Coincide con cualquier letra ASCII mayúscula
7	[a-zA-Z0-9] Coincide con cualquiera de los anteriores
8	[^aeiou] Coincide con cualquier otra cosa que no sea una vocal en minúscula
9	[^0-9] Coincide con cualquier cosa que no sea un dígito

Clases de personajes especiales

No Señor.	Ejemplo y descripción
1	. Coincide con cualquier carácter excepto nueva línea
2	\d Coincide con un dígito: [0-9]
3	\D Coincide con un no dígito: [^ 0-9]
4	\s Coincide con un carácter de espacio en blanco: [\ t \ r \ n \ f]
5	\S Coincide con espacios que no son en blanco: [^ \ t \ r \ n \ f]
6	\w Coincide con un carácter de una sola palabra: [A-Za-z0-9_]
7	\W Coincide con un carácter que no es una palabra: [^ A-Za-z0-9_]

Casos de repetición

No Señor.	Ejemplo y descripción
1	ruby? Coincide con "rub" o "ruby": la y es opcional
2	ruby* Coincide con "frotar" más 0 o más ys
3	ruby+ Coincide con "frotar" más 1 o más ys
4	\d{3} Coincide exactamente con 3 dígitos
5	\d{3,} Coincide con 3 o más dígitos
6.	\d{3,5} Coincide con 3, 4 o 5 dígitos

Repetición no maligna

Esto coincide con el menor número de repeticiones:

No Señor.	Ejemplo y descripción
1	<.*> Repetición codiciosa: coincide con "<python> perl>"
2	<.*?> Nongreedy: coincide con "<python>" en "<python> perl>"

Agrupar con paréntesis

No Señor.	Ejemplo y descripción
1	\D\d+ Sin grupo: + repeticiones \ d
2	(\D\d)+ Agrupados: + repeticiones \ D \ d par
3	([Pp]ython(, )?)+ Coincidir con "Python", "Python, python, python", etc.

Referencias anteriores

Esto vuelve a coincidir con un grupo previamente emparejado:

No Señor.	Ejemplo y descripción
1	([Pp])ython&\1ails Coincide con python y cubos o Python y cubos
2	(['"])[^\1]*\1 Cadena de comillas simples o dobles. \ 1 coincide con cualquier coincidencia del primer grupo. \ 2 coincide con lo que coincida con el segundo grupo, etc.

Alternativas

No Señor.	Ejemplo y descripción
1	python|perl Coincide con "python" o "perl"
2	rub(y|le)) Coincide con "ruby" o "rublo"
3	Python(!+|\?) "Python" seguido de uno o más. o uno ?

Anclas

Esta necesidad de especificar posiciones coincidentes.

No Señor.	Ejemplo y descripción
1	^Python Coincide con "Python" al comienzo de una cadena o línea interna
2	Python$ Coincide con "Python" al final de una cadena o línea
3	\APython Coincide con "Python" al comienzo de una cadena
4	Python\Z Coincide con "Python" al final de una cadena
5	\bPython\b Coincide con "Python" en el límite de una palabra
6	\brub\B \ B es un límite sin palabras: coincide con "rub" en "rube" y "ruby" pero no solo
7	Python(?=!) Coincide con "Python", si va seguido de un signo de exclamación
8	Python(?!!) Coincide con "Python", si no va seguido de un signo de exclamación

Sintaxis especial con paréntesis

No Señor.	Ejemplo y descripción
1	R(?#comment) Coincide con "R". Todo lo demás es un comentario.
2	R(?i)uby No distingue entre mayúsculas y minúsculas al coincidir con "uby"
3	R(?i:uby) Lo mismo que arriba
4	rub(?:y|le)) Agrupar solo sin crear \ 1 referencia inversa