Tengo una confesión que hará estremecer a los puristas de la expresión regular: durante los primeros años de mi carrera, escribí expresiones regulares copiando y pegando de Stack Overflow, cambiando un carácter, ejecutando el código, viéndolo fallar y repitiendo hasta que sucedió. trabajar. Lo hice ' No entiendo los patrones, los intimidé para que se sometieran. Fue lento y, peor aún, los patrones que envié eran frágiles en formas que pude ' No veo.
Lo que solucionó eso fue 't leyendo la teoría (aunque finalmente lo hice). Era un probador visual: un cuadro donde escribo el patrón, un cuadro donde pego cadenas de prueba y coincidencias que se iluminan en el instante en que cambio algo. De repente pude llevar porque \d+ Tomé más de lo que quería, o por qué mi patrón de correo electrónico rechazó una dirección perfectamente válida. Regex dejó de ser un juego de adivinanzas y se convirtió en un ciclo de retroalimentación ajustado.
Eso es exactamente lo que el Constructor de expresiones regulares en Toolz.dev es. Escribe un patrón, ingresa datos de prueba, alterna indicadores y observa las coincidencias y los grupos capturados resaltados en tiempo real. Se ejecuta completamente en su navegador, por lo que las líneas de registro o los datos del usuario que usted & 39;re prueba para nunca subirse a ninguna parte. Esta guía es la referencia de expresiones regulares que desearía que tuviera & # 39; Tenía en aquel entonces: los patrones que realmente reutilico, una hoja de trucos completa y el único error que puede acabar con un servidor de producción.
TL;Dr: Pegue su patrón y cadenas de prueba en el Constructor de expresiones regulares y alternar el
g/i/mBanderas para ver partidos resaltan en vivo. Inicie de manera simple, agregue restricciones para eliminar los falsos positivos y pruebe las entradas contradictorias para evitar el retroceso catastrófico. Para los datos extraídos, emparejarlo con el Formateador JSON y Convertidor Base64. Todo el lado del cliente, todo gratis.
¿Qué es exactamente una expresión regular?
Una expresión regular, regex o regexp, es una cadena compacta que describe un patrón de búsqueda. En lugar de " encuentra la palabra gato, " puedes decir " encuentra cualquier número de cinco dígitos, " " encuentra cualquier cosa que parezca un correo electrónico, " o " encuentra cada línea que comience con ERROR." Casi todos los idiomas y editores los admiten, que es lo que hace que la habilidad sea tan portátil: aprendela una vez y la usas en JavaScript, Python, tu grep, y su búsqueda y reemplazo de IDE.
El concepto surge de la teoría formal del lenguaje de la década de 1950, y Ken Thompson lo conectó a la informática en la década de 1960 para la edición de texto. Que la historia importa por una razón práctica por la que volveré a: "Regular" los idiomas tienen límites, por lo que la expresión regular genuinamente no puede analizar estructuras anidadas como HTML, no importa cuán inteligente seas.
Donde busco la expresión regular en una semana normal: validar la entrada del usuario antes de que llegue a la base de datos, extraer campos de líneas de registro no estructuradas, buscar y reemplazar en toda una base de código que una búsqueda simple no puede expresar y filtrar datos durante una migración. los Constructor de expresiones regulares Es donde prototipo cada uno de ellos antes de que se acerque al código real.
Estos son los componentes fundamentales: el alfabeto del que ensamblas patrones:
| sintaxis | significación | ejemplo | partidos |
|---|---|---|---|
. |
Cualquier personaje excepto NewLine | h.t |
Sombrero, Caliente, Golpe |
\d |
Cualquier dígito (0-9) | \d{3} |
123, 456 |
\w |
Palabra char (A-Z, A-Z, 0-9, _) | \w+ |
Hola, test_123 |
\s |
cualquier espacio en blanco | hello\sworld |
hola mundo |
^ |
Comienzo de cadena | ^Hello |
hola al principio |
$ |
fin de la cadena | end$ |
Termina al final |
* |
cero o más | ab*c |
CA, ABC, ABBC |
+ |
uno o más | ab+c |
ABC, ABBC |
? |
cero o uno | colou?r |
color, color |
{n} |
exactamente n veces | \d{4} |
2026 |
{n,m} |
entre n y m | \d{2,4} |
12, 123, 1234 |
[abc] |
Clase de personaje | [aeiou] |
cualquier vocal |
[^abc] |
Clase negada | [^0-9] |
Cualquier no dígito |
(...) |
Grupo de captura | (hello) |
Captura "Hola" |
a|b |
Alternativa (o) | cat|dog |
gato o perro |
¿Qué patrones de expresión regular debe tener a mano todos los desarrolladores?
Estos son los que he probado, roto, arreglado y ahora mantengo en un archivo de fragmento personal. cópielos directamente en el Constructor de expresiones regulares Y arroje sus propias cajas de borde a ellos.
Correo electrónico (el tipo práctico)
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
esto coincide [email protected] y [email protected], y rechaza @example.com investigaciones operacionales user@com. Sin embargo, aquí está la importante honestidad: la gramática completa de correo electrónico en RFC 5322 es monstruosamente complejo: técnicamente permite cadenas citadas y comentarios que casi nadie usa. Don' Persigue el 100% de cumplimiento de RFC con un expresiones regulares. Haga coincidir el práctico 99% con el patrón anterior, luego confirme que la dirección es real enviando un correo electrónico de verificación. Eso' es el error que más veo: equipos quemando días en un "airtight" correo electrónico regex que todavía puede ' No le digo a una bandeja de entrada real por un error tipográfico.
URL
^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$
partidos https://toolz.dev y http://www.example.com/path?query=value; rechaza ftp://... y texto sin formato.
Número de teléfono de EE. UU.
^(\+1)?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$
lo suficientemente flexible para 555-123-4567, (555) 123-4567, +1 555.123.4567y 5551234567.
Dirección IPv4
^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$
La alternancia anidada es lo que hace cumplir que cada octeto permanece en 0-255, por lo que rechaza correctamente 999.999.999.999.
Comprobación de contraseña segura
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
Requiere al menos 8 caracteres con minúsculas, mayúsculas, dígitos y símbolo. los (?=...) cada uno de los anticipados afirma una condición sin consumir personajes, un truco ingenioso que vale la pena comprender.
Fecha ISO (aaaa-mm-dd)
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$
partidos 2026-07-11, rechaza 2026-13-01 y 2026-02-32.
Color hexagonal
^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
partidos #4466EE, #abc, #000000.
La hoja de trucos de expresiones regulares
Mantenga esto clavado. Es la referencia que más verifico.
anclas
| modelo | especie |
|---|---|
^ |
Inicio de la cadena (o línea en modo multilínea) |
$ |
Fin de la cadena (o línea en modo multilínea) |
\b |
Límite de palabras |
\B |
Límite sin palabras |
cuantificadores
| modelo | especie |
|---|---|
* |
0 o más (codicioso) |
+ |
1 o más (codicioso) |
? |
0 o 1 (codicioso) |
*? +? ?? |
Versiones perezosas: combinen lo menos posible |
{n} {n,} {n,m} |
exactamente n / n o más / entre n y m |
Clases de personajes
| modelo | especie |
|---|---|
[abc] |
A, B o C |
[^abc] |
No A, B o C |
[a-z] [A-Z] [0-9] |
arandelas |
\d \D |
Dígito / No dígito |
\w \W |
Palabra char / char sin palabras |
\s \S |
Espacios en blanco / Espacios no blancos |
Grupos y Lookaround
| modelo | especie |
|---|---|
(abc) |
grupo de captura |
(?:abc) |
Grupo no capturado |
(?<name>abc) |
Grupo de captura con nombre |
(?=abc) / (?!abc) |
Lookhead positivo / negativo |
(?<=abc) / (?<!abc) |
Mirada positiva / negativa detrás |
banderas
| decaer a | especie |
|---|---|
g |
Global: encuentra todas las coincidencias |
i |
no distintivo de mayúsculas |
m |
Multilínea - ^ y $ Límites de línea de coincide |
s |
Dotall - . Coincide con las nuevas líneas |
u |
Soporte Unicode |
¿Cómo se construye y depura un patrón sin perder una hora?
Mi proceso es aburrido a propósito, porque aburrido es repetible:
- Comience con la cosa más simple que coincida con un ejemplo real. No intentes manejar todos los casos a la vez.
- Pega cadenas de prueba tanto positivas como negativas en el Constructor de expresiones regulares- cosas que deberían coincidir y cosas que no.
- Apriete para matar falsos positivos. Agregar anclas (
^,$) Entonces el patrón coincide con toda la cadena, y cambia.para clases específicas como[a-z]investigaciones operacionales[^,]. - Lanzar entrada contradictoria- cadenas vacías, entradas enormes, Unicode y caracteres de expresiones regulares literales como datos.
- Sólo entonces optimizar.
Cuando algo se porta mal, casi siempre es una de las tres cosas. si es coincide demasiado, tus cuantificadores son codiciosos, hazlos perezosos (*?) o sus clases más específicas. si es coincide con muy poco, probablemente necesites el i bandera u olvidó escapar de un carácter especial. si es no coincide con nada en absoluto, verifique si hay metacaracteres no escapados (., *, +, (, [, {, etc.) destinado a ser caracteres literales o invisibles como pestañas que se esconden en su cadena de prueba.
¿Qué es el retroceso catastrófico y por qué deberías temerlo?
Esta es la sección I&D tatuado sobre nuevos desarrolladores si pudiera. Al principio envié una expresión regular de validación de entrada que parecía completamente inocente, y una tarde, una sola solicitud marcó un núcleo de CPU al 100% y se quedó allí. El patrón era el problema.
Cuando un motor de expresión regular no puede encontrar una coincidencia, backpátidos- retrocede y prueba otras formas de satisfacer el patrón. Ciertas formas hacen que el número de caminos explote exponencialmente. El ejemplo del libro de texto:
^(a+)+$
alimentar que una entrada como aaaaaaaaaaaaaaaaaaaab (una racha de a terminando en un b, y los cuantificadores anidados dan al motor un número astronómico de formas de dividir el as, todo lo que intenta antes de concluir "no coincide". Su aplicación se congela. Esta es una verdadera clase de denegación de servicio llamada rebelde (Denegación de servicio de expresión regular), y los atacantes lo explotan.
Cómo mantenerse seguro:
- Nunca anidar cuantificadores.
(a+)+,(a*)*y(a+)*son banderas rojas. - Usar grupos atómicos o cuantificadores posesivos Donde el motor los soporta:
(?>a+)investigaciones operacionalesa++. - ser específico.
[a-z]+retrocede menos de.+Porque tiene menos caminos para explorar. - Ancla tus patrones Por lo tanto, el motor falla rápidamente en la entrada no coincidente.
- Prueba con cuerdas que casi coinciden pero fallan al final- eso' es el peor caso para retroceder.
Si estás en marcha, este problema simplemente no existe, lo que me lleva a la siguiente sección.
¿En qué difiere la expresión regular entre los idiomas?
La sintaxis central viaja bien, pero los detalles muerden. Estas son las diferencias que he tropezado.
JavaScript:
const regex = /\d{3}-\d{4}/g;
const pattern = new RegExp('\\d{3}-\\d{4}', 'g'); // note the doubled backslashes
'555-1234'.match(regex); // ["555-1234"]
const m = '2026-07-11'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
m.groups.year; // "2026"
Cuidado: LookBehind solo llegó a ES2018, \d Coincide solo con los dígitos ASCII y el g bandera hace .test() con estado vía lastIndex- una fuente sutil de errores en bucles.
pitón:
import re
pattern = re.compile(r'\d{3}-\d{4}') # raw strings avoid double-escaping
pattern.findall('Call 555-1234 or 555-5678') # ['555-1234', '555-5678']
Siempre use cadenas sin procesar (r'...'). recordar re.match sólo anclajes al inicio - utilizar re.search para encontrar en cualquier lugar. y re.VERBOSE Le permite escribir patrones comentados de varias líneas, que es un salvavidas para los complejos.
php: Los patrones necesitan delimitadores ('/\d{3}-\d{4}/'), utiliza el potente motor PCRe, y preg_match devoluciones 1, 0, o false en caso de error, así que consulte con ===.
ir: Utiliza el motor RE2, que deliberadamente Caídas de miradas, mira hacia atrás y referencias a cambio de una garantía de coincidencia en tiempo lineal. Eso significa que ni siquiera es posible un retroceso catastrófico, una compensación genuinamente diferente que vale la pena conocer cuando elige un idioma para la coincidencia de entradas que no son de confianza.
Un ejemplo real: analizar una línea de registro de Apache
Aquí está el tipo de cosas en las que la expresión regular es realmente genial. Una línea de registro de acceso Apache estándar se ve así:
192.168.1.1 - frank [11/Jul/2026:10:27:10 -0500] "GET /api/users HTTP/1.1" 200 1234
Este patrón lo separa:
^(\S+) \S+ (\S+) \[([^\]]+)\] "(\S+) (\S+) (\S+)" (\d{3}) (\d+)$
Pegar ambos en el Constructor de expresiones regulares Y cada grupo capturado se ilumina por separado:
| grupo | contenido | ejemplo |
|---|---|---|
| 1 | dirección IP | 192.168.1.1 |
| 2 | nombre de usuario | franquear |
| 3 | marca de tiempo | 11/Julio/2026:10:27:10 -0500 |
| 4 | Método HTTP | comprar |
| 5 | Ruta de solicitud | /api/usuarios |
| 6 | Versión HTTP | HTTP/1.1 |
| 7 | código de estado | 200 |
| 8 | Tamaño de la respuesta | 1234 |
Una vez que los grupos se alinean en el probador, traduciéndola a un re.findall en Python o un match() en JavaScript es trivial y ya sabes que funciona.
Preguntas frecuentes
¿Qué es un constructor de expresiones regulares?
Un generador de expresiones regulares es una herramienta interactiva donde se escribe una expresión regular e inmediatamente se ve coincidente con cadenas de prueba, con coincidencias y grupos capturados resaltados. Reemplaza el bucle de reescritura lenta-equivo-error en tu código con uno en vivo. los Constructor de expresiones regulares En Toolz.dev hace esto completamente en su navegador, por lo que los datos de prueba permanecen en su máquina.
¿Son los patrones de expresión regular idénticos en todos los lenguajes de programación?
La sintaxis central es casi idéntica, pero los detalles difieren lo suficiente como para causar errores. JavaScript más antiguo carecía de LookBehind, el motor RE2 de Go no tiene ninguna referencia ni referencias atrasadas, y los grupos de nombres de Python con (?P<name>...) en algunos contextos. Confirme siempre un patrón en el idioma al que realmente se dirige en lugar de asumir la portabilidad.
¿Cómo valide una dirección de correo electrónico con expresiones regulares?
Usa un patrón práctico como ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$, que maneja la gran mayoría de direcciones reales. No intente cumplir completamente con RFC 5322 en un expresiones regulares: la gramática es demasiado compleja y usted ' Aún así rechazará direcciones válidas o aceptará errores tipográficos. Empareje el expresiones regulares con un correo electrónico de verificación para confirmar que la bandeja de entrada realmente existe.
¿Por qué mi expresión regular congela la aplicación?
Casi siempre backtracking catastrófico. Patrones con cuantificadores anidados como (a+)+ Cree un número exponencial de rutas coincidentes cuando cumplan con la entrada que casi coincide pero finalmente falla, y el motor las prueba todas. Eliminar cuantificadores anidados, prefiere clases de caracteres específicas sobre .+, y agregue anclajes para que el motor pueda fallar rápidamente.
¿Puedo usar expresiones regulares para analizar HTML o JSON?
No, no para nada más allá de la extracción trivial. HTML y JSON no son lenguajes regulares: permiten un anidamiento arbitrario que la expresión regular fundamentalmente no puede rastrear. Utilice un analizador real: DOMParser o Cheerio para HTML, y JSON.parse o una herramienta JSON para JSON. Regex es la herramienta incorrecta que anida la estructura del momento.
¿Cuál es la diferencia entre la coincidencia codiciosa y la perezosa?
cuantificadores codiciosos (*, +, ?) Agarrar tanto como sea posible y retroceder si es necesario; los perezosos (*?, +?, ??) Agarra lo menos posible y expande solo si es forzado. contra <b>bold</b>, codicioso <.*> Se traga toda la cuerda mientras es perezoso <.*?> se detiene en la primera <b>. Elegir el correcto es a menudo la solución cuando un patrón coincide demasiado.
¿Cómo puedo escapar de los caracteres especiales en la expresión regular?
Pon una barra diagonal delante de cualquier metacarácter que quieras decir literalmente: \., \*, \+, \?, \(, \), \[, \], \{, \}, \^, \$, \|y \\. La mayoría de los idiomas también ofrecen un ayudante para escapar de una cadena completa por usted - re.escape() en Python, por ejemplo, es más seguro que escapar manualmente cuando la cadena proviene de la entrada del usuario.
¿Qué significan las banderas de expresiones regulares G, I y M?
g (global) encuentra cada partido en lugar de detenerse en el primero, i (Ignorar el caso) hace que el patrón sea insensible a las mayúsculas y minúsculas, y m (Multilina) hace ^ y $ Coincide en cada salto de línea en lugar de solo el inicio y el final de la cadena. Se combinan libremente, por lo que gim hace los tres. Un problema frecuente en JavaScript: reutilización de un g Regex a través de llamadas transport lastIndex entre ellos, lo que hace test() alterne verdadero y falso: recree el patrón o reinícielo lastIndex.
¿Qué es un lookhead en expresiones regulares?
Un lookhead afirma que algo no sigue o no, sin consumirlo. foo(?=bar) partidos foo solo cuando bar viene después; foo(?!bar) Coincide solo cuando no. Mirar hacia atrás ((?<=...), (?<!...)) hace lo mismo al revés y ha aterrizado en JavaScript, Python y PCRE modernos, pero no en Go's RE2, que rechaza ambos por completo. Las reglas de contraseña son el uso clásico: ^(?=.*\d)(?=.*[a-z]).{8,}$ Apila afirmaciones para que cada requisito se verifique de forma independiente en la misma posición.
¿Cómo coincido un número de teléfono con expresiones regulares?
Para un formato específico, sea explícito en lugar de inteligente: ^\(\d{3}\) \d{3}-\d{4}$ partidos (555) 123-4567. Para tolerar separadores variados, permita que los opcionales como ^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$. La numeración de teléfonos es complicada en todos los países, así que valide solo el formato que realmente acepte y normalice a dígitos antes de almacenarlo; cree y pruebe el patrón en vivo antes de confiar en él.
envolviendo
Regex pasó de mi habilidad más temida a una de las más utilizadas en el momento en que comencé a construir patrones en un probador en vivo en lugar de adivinar en mi editor. Comience de forma simple, pruebe contra la entrada real y contradictoria, respete el retroceso catastrófico y mantenga una biblioteca personal de patrones en los que confíe.
los Constructor de expresiones regulares en Toolz.dev, eso hace que el bucle sea rápido, con coincidencias en tiempo real, resaltado de grupos y cambios de bandera, todo ejecutándose en su navegador para que los datos de su prueba permanezcan privados. Cuando su patrón extraiga JSON, entréguelo al Formateador JSON; cuando captura un blob base64, decodifique con el Convertidor Base64. O navegue por más de 600 herramientas gratuitas en Toolz.dev.
