Herramienta gratuita

    Probador de RegEx

    Prueba, depura y visualiza expresiones regulares con coincidencia en tiempo real.

    Expresión regular

    //g
    Banderas:
    Ajustes predefinidos:

    Cadena de prueba

    ¿Qué son las expresiones regulares?

    Las expresiones regulares (Regex) son patrones que se utilizan para encontrar coincidencias entre combinaciones de caracteres en cadenas de texto. Son compatibles con prácticamente todos los lenguajes de programación y resultan esenciales para el procesamiento de texto, la validación de entradas, la búsqueda y sustitución, y el análisis de registros.

    Indicadores de Regex en JavaScript

    • g — Global: busca todas las coincidencias, no solo la primera
    • i — Coincidencia sin distinción entre mayúsculas y minúsculas
    • m — Multilínea: ^ y $ coinciden con los límites de línea
    • s — Dotall: . coincide con los caracteres de salto de línea

    Casos de uso habituales

    • Validación de direcciones de correo electrónico, números de teléfono y URL
    • Extracción de datos de archivos de registro y texto estructurado
    • Buscar y sustituir en editores de código e IDE
    • Creación de máscaras de entrada y validadores de formularios
    • Análisis y transformación de datos CSV, JSON y XML

    Cuándo recurrir a Regex

    Las expresiones regulares son ideales para patrones cortos y bien definidos en los que es necesario buscar coincidencias, extraer o sustituir texto: análisis de líneas de registro, reglas de enrutamiento de URL, validación de campos de formulario y búsqueda y sustitución dentro de un editor. Sin embargo, se convierten en un lastre cuando la entrada es en realidad un lenguaje estructurado: HTML, JSON, código fuente o cualquier cosa con delimitadores anidados. Para esos casos, utiliza un analizador sintáctico propiamente dicho; la RegEx que escribas hoy fallará silenciosamente ante el próximo caso extremo.

    Regex Preguntas frecuentes

    Respuestas rápidas a las dudas sobre Regex con las que te encuentras realmente al escribir patrones a mano.

    ¿Qué variante de Regex utiliza este programa de pruebas?
    Expresiones regulares de ECMAScript/JavaScript (el motor integrado en tu navegador). Los patrones que funcionan aquí también lo harán en `String.prototype.match`, `RegEx.test` y en la mayoría de los linters modernos basados en JavaScript o extensiones de editor. Los patrones escritos para PCRE (PHP, Perl), `re` de Python o `regexp` de Go pueden comportarse de forma diferente; las miradas hacia atrás, los grupos atómicos y la sintaxis de los grupos con nombre son puntos de divergencia habituales.
    ¿Cómo puedo hacer que mi patrón no distinga entre mayúsculas y minúsculas?
    Activa el indicador `i` (sin distinción entre mayúsculas y minúsculas). Se aplica la conversión de mayúsculas y minúsculas a todo el patrón, por lo que `/Hello/i` coincide con `hello`, `HELLO` y `HeLLo`. Si solo quieres que una parte del patrón sea insensible a mayúsculas y minúsculas, tienes que enumerar los caracteres explícitamente, ya que los RegEx de JavaScript no admiten modificadores en línea como `(?i:...)`.
    ¿Por qué mi Regex no encuentra coincidencias en varias líneas?
    Hay dos indicadores que afectan al comportamiento en varias líneas. El indicador `m` (Multiline) modifica `^` y `$` para que coincidan en los límites de línea en lugar de solo al principio o al final de toda la cadena, lo cual resulta útil para la validación línea por línea. Por otra parte, el indicador `s` (dotAll) hace que `.` también coincida con los saltos de línea; sin él, `.*` se detiene en el primer `\n`. La mayoría de los casos de uso multilínea necesitan ambos.
    ¿Cuál es la diferencia entre los cuantificadores «greedy» y «lazy»?
    Por defecto, los cuantificadores como «*», «+» y «{n,m}» son «glotones»: consumen toda la entrada posible siempre que la coincidencia global se mantenga válida. Al añadir «?» se convierten en «perezosos»: consumen lo mínimo y dejan que las partes posteriores del patrón se encarguen del resto. El cuantificador «codicioso» `<.+>` frente a `` coincide con toda la cadena; el «perezoso» `<.+?>` solo coincide con ``. Los cuantificadores «perezosos» suelen ser los más adecuados a la hora de extraer campos entre delimitadores.
    ¿Cómo puedo escapar los caracteres especiales en mi patrón?
    ¿Por qué mi Regex encuentra más (o menos) coincidencias de las esperadas?