Noticias

Conceptos básicos de las expresiones regulares | Ubuntu

Esta es una nueva publicación directa del el artículo diferente en mi blog.

En mi equipo realizamos “clases magistrales” cada dos semanas, en las que cualquiera del equipo presenta un tema al resto del equipo.

Este artículo es básicamente el contenido de la clase sobre expresiones regulares (además conocido como regex) que di recientemente.

Es una preparación a los conceptos básicos de las expresiones regulares. Hay muchos como este, pero este es el mío.

Wikipedia define las expresiones regulares como:

«Una secuencia de caracteres que definen un patrón de búsqueda»

Están disponibles básicamente en todos los lenguajes de programación, y probablemente los encontrará más comúnmente utilizados para coincidencias de cadenas en condicionales que son demasiado complicados para comparaciones lógicas simples (como «o», «y», «en»).

Un par de ejemplos de expresiones regulares para comenzar:

[ -~]Cualquier carácter ASCII
(Los caracteres ASCII se encuentran entre el espacio y «~»)
^[a-z0-9_-]3,15$Nombres de afortunado entre 3 y 15 caracteres

Utilice las expresiones regulares con precaución. La complejidad de las expresiones regulares tiene un costo.

Evite codificar en expresiones regulares si puede

‘Algunas personas, cuando se enfrentan a un problema, piensan «Lo sé, usaré expresiones regulares». Ahora ellos tienen dos problemas.’ – Jamie Zawinski

En programación, solo use expresiones regulares como zaguero memorial. No resuelva problemas importantes con expresiones regulares.

  • regex es caro – regex es a menudo la parte más intensiva de CPU de un software. Y una expresión regular que no coincida puede ser incluso más costosa de compulsar que una que coincida.
  • regex es codicioso: es extremadamente sencillo hacer coincidir mucho más de lo previsto, lo que genera errores. Varias veces hemos tenido problemas con las expresiones regulares que son demasiado codiciosas, lo que causa problemas en nuestros sitios.
  • regex es opaco: incluso las personas que conocen aceptablemente el regex tardarán un tiempo en separar una nueva sujeción de regex, y es probable que cometan errores. Esto tiene un costo enorme para el mantenimiento del esquema a extenso plazo. (Echa un vistazo a esta increíble expresión regular para direcciones de correo electrónico RFC822)

Siempre trate de estar al tanto de todas las funciones de idioma a su disposición para proceder y compulsar cadenas, que podrían ayudarlo a evitar expresiones regulares. En Python, por ejemplo, el in palabra secreto, el poderoso [] indexación y métodos de sujeción como contains y startswith (que se puede impulsar con cadenas de tuplas para múltiples títulos) se puede combinar de guisa muy efectiva.

Más importante aún, las expresiones regulares no deben estar de moda para analizando instrumentos de cuerda. En su emplazamiento, debería utilizar o escribir un analizador a medida. Por ejemplo, no puede analizar HTML con expresiones regulares (en Python, use BeautifulSoup; en JavaScript, use DOM).

Cuando codificar en expresiones regulares

Por supuesto, hay ocasiones en las que las expresiones regulares pueden o deben estar de moda en programas:

  • Cuando ya exista y tengas que mantenerlo (aunque si puedes eliminarlo, deberías hacerlo)
  • Nervio de cadenas, donde no hay otra opción
  • Manipulación de cadenas (sustitución), donde no hay otra opción

Si está escribiendo poco más que la expresión regular más básica, es poco probable que los mantenedores puedan comprender su expresión regular fácilmente, por lo que es posible que desee considerar unir comentarios liberales. Por ejemplo, esto en Python:

>>> pattern = """
^                   # beginning of string
M0,4              # thousands - 0 to 4 M's
(CM|CD|D?C0,3)    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
                    #            or 500-800 (D, followed by 0 to 3 C's)
(XC|XL|L?X0,3)    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
                    #        or 50-80 (L, followed by 0 to 3 X's)
(IX|IV|V?I0,3)    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
                    #        or 5-8 (V, followed by 0 to 3 I's)
$                   # end of string
"""
>>> re.search(pattern, 'M', re.VERBOSE) 

Otros grandes usos de las expresiones regulares

Las expresiones regulares pueden ser extremadamente poderosas para resolver rápidamente problemas por sí mismo, donde el mantenimiento futuro no es una preocupación. P.ej:

Además vale la pena utilizar las oportunidades para usar expresiones regulares de estas formas para practicar sus habilidades de expresiones regulares.

Por ejemplo, recientemente utilicé la próximo sustitución de expresiones regulares en VSCode para formatear un volcado de texto en un formato de tabla:

Tenga en cuenta que los analizadores de expresiones regulares vienen en algunas variedades. Básicamente, cada habla implementa su propio analizador. Sin secuestro, el analizador de expresiones regulares de Perl es el standard de oro. Si tiene una opción, use Expresiones regulares compatibles con Perl.

Como se ve la expresión regular

La forma tradicional de escribir una expresión regular es rodeándola con barras.

/^he[l]2owworld$/

Así es como están escritos en Perl y JavaScript, y en muchas herramientas de cuerda de comandos como Less.

Sin secuestro, muchos lenguajes más modernos (por ejemplo, Python) han optado por no incluir un tipo de expresión regular nativo, por lo que las expresiones regulares simplemente se escriben como cadenas:

r"^he[l]2owworld$"

Caracteres comunes de expresiones regulares

.Coincide con cualquier carácter (excepto las nuevas líneas, normalmente)
Escapa de un carácter distinto (p. Ej. . coincide con un punto igual)
?El carácter preliminar puede estar presente o no (p. Ej. /hell?o/ coincidiría hello o helo)
*Se permite cualquier número del carácter preliminar (p. Ej. .* coincidirá con cualquier sujeción de una sola cuerda, incluida una sujeción vacía, y se usa mucho)
+Uno o más de los caracteres anteriores (.+ es lo mismo que .* excepto que no coincidirá con una sujeción vacía)
|«O», coincide con la sección preliminar o la próximo (p. Ej. hello|mad coincidirá con «hola» o «chalado»)
()agrupe una sección. Esto puede ser útil para condicionales ((a|b)), multiplicadores ((hello)+), o para crear grupos para sustituciones (ver más debajo)
Especifique cuántos del carácter preliminar (p. Ej. a12 coincide con 12 «a» seguidas)
[]Coincide con cualquier personaje de este conjunto. - define rangos (p. ej. [a-z] es cualquier grafema minúscula), ^ significa «no» (p. ej. [^,]+ coincidir con cualquier número de no comas seguidas)
^Principio de cuerda
$Fin de la cuerda

Atajos de caracteres en expresiones regulares

En la mayoría de las implementaciones de expresiones regulares, puede usar una mostrador invertida seguida de una grafema (x) como trocha para un ocio de caracteres. Aquí hay una nómina de algunos comunes de la hoja de trucos de expresiones regulares de rexegg.com.

Regex en condicionales

El caso de uso más simple para las expresiones regulares en la programación es una comparación de cadenas. Esto se ve diferente en diferentes idiomas, por ejemplo:

// Perl
if ( "hello world" =~ /^he[l]2osworld$/ ) ..
// JavaScript
if( /^he[l]2osworld$/.test("hello world") ) ..
# Python
Import re
If re.match(r"^he[l]2osworld$", "hello world"): ..

Regex en sustituciones

Además puede utilizar expresiones regulares para manipular cadenas mediante sustitución. En los siguientes ejemplos, se imprimirá «mundo chalado»:

// Perl
$hw = "hello world"; $hw =~ s/^(he[l]2o)s(world)$/mad 2/; print($hw)
// JavaScript
console.log("hello world".replace(/^(he[l]2o)s(world)$/, "mad $2"))
# Python
Import re
print(re.replace(r"^(he[l]2o)s(world)$", r"mad 2", "hello world"))

Modificadores de expresiones regulares

Puede alterar el comportamiento de las expresiones regulares basándose en algunos modificadores. Solo voy a ilustrar uno aquí, que es el modificador para que las expresiones regulares no distingan entre mayúsculas y minúsculas. En Perl, JavaScript y otros contextos de expresiones regulares más tradicionales, los modificadores se agregan luego del zaguero /. Los lenguajes más modernos suelen utilizar constantes en su emplazamiento:

// Perl
if ( "HeLlO wOrLd" =~ /^he[l]2osworld$/i ) ..
// JavaScript
if( /^he[l]2osworld$/i.test("HeLlO wOrLd") ) ..
# Python
Import re
If re.match(r"^he[l]2osworld$", "HeLlO wOrLd", flags=re.IGNORECASE): ..

Lookahead y lookbehind en expresiones regulares

Estos solo son compatibles con algunas implementaciones de expresiones regulares y le brindan la oportunidad de hacer coincidir cadenas que preceden o siguen a otras cadenas, pero sin incluir el prefijo o sufijo en la coincidencia en sí:

(Nuevamente, tomado de la hoja de trucos de expresiones regulares de rexegg.com)

Eso es todo lo que tengo por ahora. Si desea obtener más información, existen muchos fortuna bártulos:

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba