Analizador de portabilidad de expresiones regulares
Pega una expresión regular, sin delimitadores o con el formato `"/pattern/flags"` de JavaScript, para detectar qué partes fallarían o se comportarían silenciosamente de forma distinta en el módulo `re` de Python o un motor de la familia PCRE (PHP, Perl), y por qué.
El análisis se realiza localmente en tu navegador. El archivo nunca se carga al servidor.
Cómo usar esta herramienta
- Pega una expresión regular sin delimitadores (por ejemplo, `\d{4}-\d{2}`) o delimitada (`/\d{4}-\d{2}/g`); los datos no salen de tu navegador.
- Selecciona «Analizar patrón».
- Revisa cada construcción señalada: si es un error de sintaxis en otro entorno, un cambio silencioso de comportamiento o una nota de compatibilidad en una sola dirección.
- Usa la reescritura sugerida cuando se ofrezca. Algunas construcciones (cuantificadores posesivos, grupos atómicos, recursión) no tienen un equivalente mecánico sencillo en JavaScript; se explican en vez de adivinar.
Supuestos
- Es un análisis estático del texto del patrón, no un motor de regex: nunca ejecuta el patrón sobre texto de muestra ni analiza toda la gramática (clases de caracteres, grupos anidados y casos límite de escape que no sean objeto de una regla específica).
- La comparación se limita a tres ecosistemas: `RegExp` de JavaScript (ECMAScript) como contexto de origen, el módulo `re` de Python y la familia PCRE, seguida de cerca por las funciones `preg_*` de PHP y las regex de Perl.
- Solo señala discrepancias documentadas a nivel de especificación; quedan fuera las peculiaridades específicas poco comunes de motores y los errores propios de versiones.
Fuentes y datos de referencia
Metodología
El cuerpo del patrón (sin los delimitadores opcionales `/pattern/flags`) se examina en busca de ocho construcciones que causan problemas de portabilidad entre lenguajes: sintaxis de grupos con nombre y referencias inversas exclusiva de Python, cuantificadores posesivos, grupos atómicos, anclas `\A`/`\Z`/`\z`, referencias a patrones recursivos PCRE, indicadores inline en mitad del patrón y los valores predeterminados ASCII frente a Unicode para `\d`/`\w`/`\s`. Cada regla usa una coincidencia estrecha y específica, no un analizador regex de propósito general. Solo se ofrece una reescritura cuando es segura mecánicamente e inequívoca.
Ejemplo resuelto
Anclas `\A` y `\Z`
Datos de entrada: /\Afoo.*bar\Z/
Resultado: JavaScript no tiene anclas `\A` ni `\Z`: interpreta silenciosamente `\A` como la letra literal "A" y `\Z` como "Z". Así, el patrón coincide con algo completamente distinto en vez de fallar al compilar. Se señala como error precisamente porque falla de forma silenciosa.
Grupo con nombre al estilo Python
Datos de entrada: (?P<year>\d{4})
Resultado: `(?P<year>...)` produce un SyntaxError en JavaScript, que requiere `(?<year>...)` sin la `P`. Se ofrece quitar la `P` de forma segura; PCRE y .NET también aceptan la forma simple.
Cuantificador posesivo y grupo atómico
Datos de entrada: (?>a++)b
Resultado: Tanto `(?>...)` (grupo atómico) como `a++` (cuantificador posesivo) son construcciones de PCRE/Java sin sintaxis equivalente en JavaScript. Ambos se señalan como errores sin reescritura automática: reproducir el efecto requiere reestructurar el patrón con una anticipación capturadora, no sustituir texto.
Ancla de inicio al estilo Python
Datos de entrada: /\Afoo/
Resultado: Python y algunos otros motores usan `\A` para el inicio absoluto de la cadena. JavaScript no tiene esa ancla: en un patrón JavaScript, el escape no ancla el inicio y puede tratarse como escape de identidad que coincide con `A`. El comprobador detecta esta construcción en el texto; no la ejecuta sobre cadenas de muestra.
Orientación práctica
- No dependas de `\A` ni de `\Z`/`\z` si el patrón puede ejecutarse en JavaScript. Usa `^`/`$` con el indicador `m` desactivado deliberadamente y verifica el comportamiento exacto que necesitas ante una nueva línea final.
- JavaScript usa `(?<name>...)` para los grupos con nombre; Python `re` usa `(?P<name>...)`. No hay una única sintaxis de grupo con nombre compatible con ambos: adapta el patrón para cada lenguaje.
- Considera los cuantificadores posesivos, grupos atómicos y patrones recursivos como señal de que hay que reestructurar el patrón (o usar un analizador real) antes de ejecutarlo en JavaScript: no existe una sintaxis equivalente que se pueda sustituir directamente.
Errores comunes
- Suponer que un patrón que compila en JS equivale en comportamiento a la versión Python/PCRE de origen. `\A`/`\Z` y los valores predeterminados Unicode de `\d`/`\w`/`\s` compilan, pero pueden coincidir con valores distintos.
- Suponer que una sintaxis de grupo con nombre funciona en ambos lenguajes: JavaScript requiere `(?<name>...)` y Python `re` requiere `(?P<name>...)`.
Preguntas frecuentes
¿Por qué `\A`/`\Z` son más peligrosas que las construcciones posesivas o los grupos atómicos?
Los cuantificadores posesivos y los grupos atómicos son errores de sintaxis (o equivalentes) en JavaScript: el fallo es inmediato y evidente. `\A` y `\Z` compilan y coinciden silenciosamente con las letras "A"/"Z" en vez de anclar; el problema puede pasar inadvertido hasta que el patrón se comporte mal con datos reales.
¿Por qué sugiere `(?<name>...)` para JS pero lo señala como advertencia para Python?
La forma «correcta» depende del motor: JS/PCRE/.NET usan la forma sin `P`, mientras que Python la exige. Como la herramienta no sabe qué entorno te importa, informa de ambas direcciones y solo fuerza una reescritura cuando la forma pegada es inequívocamente inválida para JS (la sintaxis Python `(?P<name>...)`).
¿Puede corregir automáticamente un cuantificador posesivo o un grupo atómico?
No. Reproducir el efecto en JavaScript suele requerir emular un grupo atómico mediante una anticipación capturadora (`(?=(pattern))\\1`), lo cual cambia la estructura del patrón y no solo su texto. Es una decisión de quien mantiene el patrón, no algo que deba adivinar la herramienta.
Última revisión:
Este escáner de texto estrecho, construcción por construcción, no es un analizador ni un motor regex: reconoce ocho problemas de portabilidad concretos y documentados, no extensiones específicas inusuales, casos límite de grupos anidados ni el comportamiento real de coincidencia. Nunca ejecuta el patrón sobre datos de muestra.
Las preferencias de tema y de herramientas, junto con las listas de herramientas guardadas y recientes, se almacenan solo en este navegador.