Generador de Patrones Regex

Construye expresiones regulares visualmente con bloques de tokens y recetas RFC verificadas.

Sin subidasSin registroResultados instantáneos
13 recetas verificadas RFC y DevConstructor visual de reglas y cuantificadoresFragmentos JS · Python · Go · Rust
Generar Regex
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Generador de Patrones Regex gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Bloques de Tokens Visuales Componibles

Construye expresiones regulares legibles paso a paso encadenando anclas, clases de caracteres, cuantificadores acotados, grupos de no captura ((?:...)) y capturas con nombre ((?<name>...)).

Recetas para Desarrolladores Alineadas con RFC

Carga plantillas verificadas para correos prácticos según RFC 5322, direcciones IPv4/IPv6 acotadas, marcas de tiempo ISO-8601 / RFC 3339, etiquetas SemVer 2.0.0, UUID según RFC 9562, URL, slugs y colores hexadecimales CSS.

Fragmentos de Código Multilenguaje

Exporta código listo para compilar en JavaScript (RegExp), Python (re.compile con cadenas crudas), Go (regexp.MustCompile con literales crudos) y Rust (regex::Regex), adaptando automáticamente la sintaxis de grupos con nombre.

Validación Instantánea de Casos de Prueba y Privacidad

Verifica cadenas de muestra positivas y negativas en tiempo real mientras ajustas los bloques. Cada personalización de recetas, validación y exportación de código se ejecuta 100 % en el cliente sin llamadas de red.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Bloques de Tokens Visuales Componibles Construye expresiones regulares legibles paso a paso encadenando anclas, clases de caracteres, cuantificadores acotados, grupos de no captura ((?:...)) y capturas con nombre ((?<name>...)). Opciones limitadas sin personalización avanzada
Recetas para Desarrolladores Alineadas con RFC Carga plantillas verificadas para correos prácticos según RFC 5322, direcciones IPv4/IPv6 acotadas, marcas de tiempo ISO-8601 / RFC 3339, etiquetas SemVer 2.0.0, UUID según RFC 9562, URL, slugs y colores hexadecimales CSS. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Generador de Patrones Regex en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Selecciona una Receta Verificada o Añade Bloques de Tokens

Elige una plantilla probada según RFC (correo electrónico, IPv4/IPv6, fecha ISO-8601, SemVer, UUID, URL, slug o color hexadecimal) o añade anclas, conjuntos de caracteres, literales y cuantificadores visualmente.

2

Configura Anclas, Grupos y Cadenas de Prueba

Alterna entre validación exacta de cadena (^...$) y coincidencia de subcadenas, asigna envoltorios con nombre ((?<name>...)) o de no captura ((?:...)), y comprueba casos de prueba positivos y negativos.

3

Copia la Expresión Regular Cruda o Código Multilenguaje

Exporta el patrón en bruto o copia fragmentos idiomáticos para JavaScript, Python, Go o Rust con el escape de cadenas crudas y la sintaxis de captura específica de cada motor aplicados.

Composición de un Patrón de Producción desde Bloques Visuales hasta Código Multilenguaje

Respuesta rápida: Encadena bloques de tokens anclados de forma secuencial, asigna nombres de campo semánticos mediante grupos de captura con nombre ((?<name>...)), valida frente a casos de prueba positivos y negativos de casos límite, y exporta fragmentos idiomáticos con cadenas crudas adaptados a JavaScript, Python, Go y Rust.

Escribir expresiones regulares densas a mano y de memoria suele introducir defectos sutiles, como puntos sin escapar (. coincide con cualquier carácter en lugar del punto literal .), falta de anclas de inicio o fin, o errores de ceros a la izquierda. Mediante la composición visual de tokens, supongamos que necesitas un validador estricto de Versionado Semántico 2.0.0 (SemVer) que acepte un prefijo v opcional y extraiga los identificadores de metadatos major, minor, patch, prerelease y build.

Cada regla estructural se asocia limpiamente a una secuencia explícita de bloques de tokens:

{
  "anchoring": "exact_line (^...$)",
  "blocks": [
    { "type": "literal", "value": "v", "quantifier": "optional (?)" },
    { "type": "named_capture", "name": "major", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "minor", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "patch", "pattern": "0|[1-9]\\d*" },
    {
      "type": "non_capturing",
      "pattern": "-(?<prerelease>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    },
    {
      "type": "non_capturing",
      "pattern": "\\+(?<build>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    }
  ]
}

Observa cómo 0|[1-9]\d* aplica la Sección 2 de SemVer 2.0.0 al permitir 0 pero rechazar ceros a la izquierda como 01, y cómo los envoltorios de no captura (?:...)? protegen los delimitadores - y + sin crear grupos numerados adicionales. Validar frente a casos de prueba positivos y negativos y exportar código multilenguaje produce declaraciones precisas para cada motor automáticamente:

# Patrón sintetizado para ECMAScript / Rust
^v?(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$

# Casos de prueba positivos (Coinciden)
1.0.0
v2.14.3-rc.1+build.5114f85

# Casos de prueba negativos (Rechazados: cero a la izquierda en el núcleo numérico de la versión)
v01.2.0
1.02.3

# Python (cadena cruda re.compile + sintaxis de grupo con nombre (?P<name>...))
SEMVER_RE = re.compile(r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$")

# Go (literal crudo con comillas invertidas RE2 regexp.MustCompile + sintaxis (?P<name>...))
var semverRe = regexp.MustCompile(`^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$`)

Como el generador evita las referencias hacia atrás (backreferences) y las búsquedas anticipadas o retrospectivas (lookarounds) en las recetas estándar, la expresión exportada se compila sin modificaciones tanto en motores RE2 de tiempo lineal (Go y Rust) como en motores con backtracking (JavaScript y Python).

Portabilidad entre Motores Regex, Matices de Validación RFC y Reglas de Escape

Respuesta rápida: Los motores de expresiones regulares se dividen en autómatas NFA con backtracking (JavaScript RegExp, Python re) y motores NFA de Thompson / DFA en tiempo lineal (Go regexp, Rust regex). Los patrones portables evitan lookarounds y referencias hacia atrás, utilizan literales de cadena cruda nativos y aplican límites exactos de octetos y nibbles según las RFC.

NFA con Backtracking vs Autómatas de Tiempo Lineal (Go RE2 y Rust `regex`)

Los motores de expresiones regulares en producción se dividen en dos modelos de ejecución distintos:

  1. NFA con Backtracking (JavaScript RegExp, Python re): Explora ramas de alternancia de forma recursiva, lo que permite referencias hacia atrás (\1, \k<name>) y aserciones arbitrarias de lookahead y lookbehind ((?=...), (?!...), (?<=...), (?<!...)), a costa de un posible tiempo de ejecución exponencial en el peor de los casos ante patrones ambiguos.
  2. NFA de Thompson / DFA Perezoso (Go regexp, Rust regex): Avanza todos los estados activos del autómata simultáneamente por cada byte o punto de código de entrada, garantizando una complejidad temporal de O(m * n) en el peor de los casos según el tamaño del patrón m y la longitud de la entrada n. Para preservar límites de estado finitos, Go regexp y Rust regex excluyen por diseño las referencias hacia atrás y los lookarounds.

La sintaxis de los grupos de captura con nombre también varía según la biblioteca estándar: ECMAScript requiere (?<name>...); Python re y Go regexp requieren (?P<name>...); Rust regex (1.9+) acepta tanto (?<name>...) como (?P<name>...).

Escape de Cadenas Crudas en el Lenguaje Anfitrión

Incrustar un patrón dentro de una cadena ordinaria entre comillas dobles hace que el compilador del lenguaje anfitrión interprete primero las secuencias de escape de barra invertida, obligando a duplicar \d+\.\d+ como "\\d+\\.\\d+" y corriendo el riesgo de una corrupción silenciosa (por ejemplo, que "\b" se convierta en el carácter ASCII 0x08 de retroceso en lugar de un límite de palabra). Los fragmentos exportados utilizan la forma literal de cadena cruda nativa de cada lenguaje:

  • JavaScript: Notación literal /patrón/flags (escapando únicamente las barras diagonales sin escapar como \/), o new RegExp(String.raw..., flags) para la construcción dinámica.
  • Python: Literales de cadena cruda re.compile(r"...") (ten en cuenta que una cadena cruda en Python no puede terminar con un número impar de barras invertidas).
  • Go: regexp.MustCompile con literales crudos entre comillas invertidas (backticks), sustituyendo \x60 si es necesario coincidir con un carácter de comilla invertida literal.
  • Rust: regex::Regex::new(r"...") o literales crudos con almohadillas r#"..."# cuando el propio patrón contiene comillas dobles.

Límites de Precisión RFC en Recetas para Desarrolladores

  • IPv4 e IPv6 (RFC 4291 / RFC 5952): Un patrón ingenuo como \d{1,3}(?:\.\d{1,3}){3} acepta octetos ilegales de hasta 999. La validación estricta de IPv4 acota cada octeto decimal mediante (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), mientras que las recetas IPv6 contemplan la compresión de ceros :: de aparición única y las colas mapeadas desde IPv4 (::ffff:192.0.2.128).
  • UUID (RFC 9562, que reemplaza a RFC 4122): El diseño hexadecimal canónico 8-4-4-4-12 ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$ restringe el nibble de versión (1–8, cubriendo UUIDv7 y UUIDv8) y los bits de variante IETF (8, 9, a, b), con una relajación opcional para los valores centinela Nil (00000000-...) y Max (ffffffff-...).
  • Fechas ISO-8601 / RFC 3339 y Correos Electrónicos Prácticos: Las expresiones léxicas imponen meses acotados (0[1-9]|1[0-2]), días (0[1-9]|[12]\d|3[01]), horas ([01]\d|2[0-3]) y desplazamientos de zona horaria (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), dejando la aritmética de años bisiestos del calendario (como rechazar el 30 de febrero) y la verificación del buzón SMTP a la lógica de análisis posterior.

Generador de Patrones Regex vs Probador y Depurador de Regex: ¿Cuál Necesitas?

Respuesta rápida: Usa el Generador de Patrones Regex cuando construyas una nueva expresión regular visualmente a partir de bloques de tokens, personalices una plantilla RFC verificada o exportes código escapado para JavaScript, Python, Go y Rust. Usa el Probador y Depurador de Regex cuando inspecciones desplazamientos de coincidencias, diccionarios de capturas y reemplazos de cadenas en vivo.

Elegir entre ambas herramientas depende de si estás creando una expresión o diagnosticando una. El Generador de Patrones Regex se centra en la síntesis estructurada, la personalización de recetas RFC y la generación de código multilenguaje. Una vez que tengas una expresión y necesites inspeccionar cada desplazamiento de coincidencia en un texto multilínea, alternar banderas ECMAScript con estado o previsualizar sustituciones de cadenas con $<name>, abre el Probador y Depurador de Regex.

Capacidad Generador de Patrones Regex Probador y Depurador de Regex
Tarea Principal de Ingeniería Construir nuevos patrones visualmente o personalizar recetas RFC verificadas Depurar patrones existentes, desplazamientos de coincidencias, banderas y sustituciones
Ensamblaje de Patrones Bloques de tokens componibles (anclas, clases, cuantificadores, grupos con nombre) Edición directa y libre de expresiones regulares
Biblioteca de Recetas Verificadas Plantillas integradas para Email, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug y Hex Enfocado en patrones arbitrarios definidos por el usuario y cargas de registros (logs)
Exportación de Código Multilenguaje Fragmentos listos para copiar en JavaScript, Python, Go y Rust Salida de literal regex para JavaScript / ECMAScript
Inspección de Capturas y Posiciones Validación instantánea de casos de prueba positivos y negativos Rangos [start, end) por coincidencia, capturas $1–$99 y diccionario (?<name>...)
Vista Previa de Reemplazo en Vivo No diseñado para previsualizar sustituciones de cadenas Vista previa en tiempo real de replace / replaceAll ($1, $<name>, $&, $$)

Flujo de Trabajo Recomendado

Ensambla tu expresión base o carga una plantilla RFC aquí en el Generador de Patrones Regex para obtener una estructura de agrupación limpia, límites de cuantificadores en tiempo lineal y código base correctamente escapado para tu lenguaje de backend o frontend. Cuando necesites probar cómo interactúa ese patrón con archivos de registro multilínea, el estado de lastIndex, pares sustitutos Unicode o plantillas de replaceAll, transfiere el patrón al Probador y Depurador de Regex.

Preguntas frecuentes

Preguntas frecuentes y guía técnica de Generador de Patrones Regex

Todo lo que necesitas saber sobre el uso gratuito en línea de generador de regex en Utiliome.

¿Por qué difiere la sintaxis del regex generado entre JavaScript, Python, Go y Rust?

Aunque las clases de caracteres principales y los cuantificadores coinciden entre lenguajes, la sintaxis de captura con nombre y las restricciones del autómata divergen. JavaScript requiere (?<name>...), mientras que el módulo re de Python y el paquete regexp de Go requieren (?P<name>...) (el crate regex de Rust admite ambas formas). Además, Go y Rust compilan patrones en máquinas de estados NFA de Thompson / DFA de tiempo lineal que omiten intencionadamente las referencias hacia atrás (\1) y los lookarounds ((?=...), (?<=...)), mientras que los motores con backtracking de JavaScript y Python sí los admiten.

¿Debo validar direcciones de correo electrónico con una expresión regular de gramática RFC 5322 completa?

No. Una gramática literal completa de RFC 5322 ocupa varios kilobytes para permitir espacios en blanco entrecomillados obsoletos, comentarios anidados y dominios de literales IP que los servidores de correo modernos rechazan, sin demostrar si un buzón puede recibir correo realmente. Los servicios en producción combinan un patrón estructural conciso (^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$) con los límites de longitud en bytes de RFC 5321 (64 octetos para la parte local, 254 octetos para la dirección total) y el envío de un correo de confirmación.

¿Cómo evitan los literales de cadena cruda los errores de doble escape de barra invertida entre lenguajes?

En las cadenas entrecomilladas estándar, el compilador anfitrión procesa las secuencias de escape de barra invertida antes de pasar la cadena al compilador regex, obligando a duplicar \d+\s+ como "\\d+\\s+" y convirtiendo "\b" en un carácter ASCII de retroceso en lugar de un límite de palabra. Los literales crudos nativos omiten el desescapado del compilador anfitrión: utiliza literales /\d+\s+/ en JavaScript, r"\d+\s+" en Python, literales con comillas invertidas en Go y r"\d+\s+" o r#"..."# en Rust.

¿Cuál es la diferencia entre la validación exacta de cadenas y la extracción de subcadenas?

La validación exacta envuelve toda la expresión en anclas de inicio y fin (^...$, o \A...\z en Python, Go y Rust, donde $ en Python re también puede coincidir inmediatamente antes de un \n final). Sin anclas, una expresión de fecha como \d{4}-\d{2}-\d{2} se comporta como una búsqueda de subcadenas y da por válidas entradas mal formadas como foo-2026-11-01-bar. Mantén activado el anclaje exacto para validar payloads de API y formularios, o prueba rangos de extracción sin anclas en el Probador y Depurador de Regex.

¿Cómo distingue la receta UUID de RFC 9562 los UUID válidos de cadenas hexadecimales arbitrarias de 36 caracteres?

La RFC 9562 (que reemplaza a la RFC 4122) codifica el número de versión de 4 bits en el nibble superior del tercer grupo ([1-8] para UUIDv1 hasta UUIDv8) y la variante IETF en el nibble superior del cuarto grupo ([89abAB], que representa el binario 10xx). Si tu base de datos también almacena el UUID Nil de todos ceros (00000000-0000-0000-0000-000000000000) o el UUID Max de todos unos (ffffffff-ffff-ffff-ffff-ffffffffffff), activa la variante hexadecimal relajada o añade ramas de alternancia explícitas.