Генератор и конструктор Regex

Собирайте регулярные выражения визуально из блоков-токенов и проверенных RFC-шаблонов.

Без загрузки на серверБез регистрацииМгновенный результат
13 проверенных RFC и Dev-шаблоновВизуальный конструктор правил и квантификаторовСниппеты JS · Python · Go · Rust
Сгенерировать Regex
Офлайн-движок готов100% приватная работа в браузере • Без облачных загрузок
100% Конфиденциально • Без загрузки файлов на сервер

Почему выбирают бесплатный Генератор и конструктор Regex от Utiliome?

Создано с нуля для полной конфиденциальности, мгновенной работы и комфорта. Без подписок, платных подписок и регистрации.

Визуальные блоки-токены

Пошагово конструируйте читаемые регулярные выражения, соединяя якоря, символьные классы, ограниченные квантификаторы, незахватывающие группы ((?:...)) и именованные группы захвата ((?<name>...)).

Проверенные рецепты по стандартам RFC

Загружайте готовые шаблоны для email по RFC 5322, строго ограниченных адресов IPv4/IPv6, меток времени ISO-8601 / RFC 3339, версий SemVer 2.0.0, UUID по RFC 9562, URL, слагов и HEX-цветов CSS.

Экспорт кода для разных языков

Генерируйте готовый к компиляции код для JavaScript (RegExp), Python (сырые строки re.compile), Go (сырые литералы regexp.MustCompile) и Rust (regex::Regex) с автоматической адаптацией синтаксиса именованных групп.

Мгновенная валидация фикстур и приватность

Проверяйте позитивные и негативные тестовые строки в реальном времени при каждом изменении блоков. Настройка шаблонов, валидация и экспорт кода выполняются на 100% локально в браузере без сетевых запросов.

Utiliome в сравнении с облачными аналогами

Сравните наш локальный движок WebAssembly с традиционными облачными сервисами.

Критерий Utiliome (Локально в браузере) Облачные конвертеры
Визуальные блоки-токены Пошагово конструируйте читаемые регулярные выражения, соединяя якоря, символьные классы, ограниченные квантификаторы, незахватывающие группы ((?:...)) и именованные группы захвата ((?<name>...)). Ограниченные настройки без гибкой кастомизации
Проверенные рецепты по стандартам RFC Загружайте готовые шаблоны для email по RFC 5322, строго ограниченных адресов IPv4/IPv6, меток времени ISO-8601 / RFC 3339, версий SemVer 2.0.0, UUID по RFC 9562, URL, слагов и HEX-цветов CSS. Требует сторонних программ или ручной обработки
Конфиденциальность и обработка 100% локально в браузере (без загрузки на сервер) Загружает данные на внешние облачные серверы
Стоимость и регистрация 100% бесплатно навсегда без создания аккаунта Требует регистрации аккаунта или платной подписки
Как это работает

Генератор и конструктор Regex: как пользоваться за 3 простых шага

Установка программ не требуется. Все работает прямо в вашем веб-браузере.

1

Выберите проверенный рецепт или добавьте блоки-токены

Возьмите готовый пресет по RFC (email, IPv4/IPv6, дата ISO-8601, SemVer, UUID, URL, slug или HEX-цвет) либо визуально соберите цепочку из якорей, наборов символов, литералов и квантификаторов.

2

Настройте якоря, группы и тестовые строки

Переключайтесь между строгой проверкой всей строки (^...$) и поиском подстроки, задавайте именованные ((?<name>...)) или незахватывающие ((?:...)) обёртки и проверяйте позитивные и негативные фикстуры.

3

Скопируйте чистое выражение или код для нужного языка

Экспортируйте сам шаблон или скопируйте идиоматичный код для JavaScript, Python, Go или Rust с учётом экранирования сырых строк и синтаксиса групп конкретного движка.

Сборка продакшен-шаблона из визуальных блоков с экспортом в код

Быстрый ответ: Последовательно соедините блоки-токены с якорями, назначьте семантические имена полям через именованные группы захвата ((?<name>...)), проверьте выражение на позитивных и негативных граничных случаях и экспортируйте идиоматичные сниппеты с сырыми строками для JavaScript, Python, Go и Rust.

Написание сложных регулярных выражений вручную по памяти часто приводит к малозаметным ошибкам: неэкранированным точкам (. совпадает с любым символом вместо литеральной точки .), пропущенным якорям начала и конца строки или багам с ведущими нулями. Рассмотрим визуальную сборку из блоков на примере строгого валидатора семантического версионирования Semantic Versioning 2.0.0 (SemVer), который допускает необязательный префикс v и извлекает идентификаторы major, minor, patch, prerelease и метаданные сборки build.

Каждое структурное правило наглядно переводится в явную последовательность блоков-токенов:

{
  "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 (?)"
    }
  ]
}

Обратите внимание, как подшаблон 0|[1-9]\d* реализует требование Раздела 2 спецификации SemVer 2.0.0, разрешая 0, но отклоняя ведущие нули вроде 01, а незахватывающие обёртки (?:...)? изолируют разделители - и +, не создавая лишних нумерованных групп. Проверка на позитивных и негативных фикстурах и экспорт кода автоматически формируют точные объявления под каждый движок:

# Synthesized ECMAScript / Rust Pattern
^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-]+)*))?$

# Positive Fixtures (Match)
1.0.0
v2.14.3-rc.1+build.5114f85

# Negative Fixtures (Reject: leading zero in numeric version core)
v01.2.0
1.02.3

# Python (re.compile raw string + (?P<name>...) named group syntax)
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 (RE2 regexp.MustCompile backtick raw literal + (?P<name>...) syntax)
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-]+)*))?$`)

Поскольку генератор не использует обратные ссылки (backreferences) и просмотры вперёд/назад (lookarounds) в стандартных рецептах, экспортируемое выражение компилируется без изменений как в линейных по времени рантаймах на базе RE2 (Go и Rust), так и в движках с возвратами (JavaScript и Python).

Переносимость между движками Regex, нюансы валидации по RFC и правила экранирования

Быстрый ответ: Среды выполнения регулярных выражений делятся на НКА с возвратами (JavaScript RegExp, Python re) и линейные по времени автоматы Томпсона / ДКА (Go regexp, Rust regex). Переносимые шаблоны избегают lookaround-проверок и обратных ссылок, используют нативные сырые строковые литералы и строго ограничивают диапазоны октетов и нибблов по RFC.

НКА с возвратами против автоматов с линейным временем (Go RE2 и Rust `regex`)

Промышленные движки регулярных выражений делятся на две принципиально разные модели выполнения:

  1. НКА с возвратами / Backtracking NFA (JavaScript RegExp, Python re): рекурсивно перебирает ветви альтернатив, что позволяет поддерживать обратные ссылки (\1, \k<name>) и произвольные проверки просмотра вперёд и назад ((?=...), (?!...), (?<=...), (?<!...)), но ценой потенциально экспоненциального времени работы в худшем случае на неоднозначных шаблонах.
  2. НКА Томпсона / Ленивый ДКА (Go regexp, Rust regex): синхронно продвигает все активные состояния автомата на каждый входной байт или кодовую точку, гарантируя линейную временную сложность O(m * n) в худшем случае для шаблона размера m и входа длины n. Чтобы сохранить конечные границы состояний, пакет regexp в Go и крейт regex в Rust намеренно исключают обратные ссылки и lookaround-утверждения.

Синтаксис именованных групп захвата также различается между стандартными библиотеками: ECMAScript требует (?<name>...); Python re и Go regexp требуют (?P<name>...); Rust regex (начиная с версии 1.9+) принимает обе формы — и (?<name>...), и (?P<name>...).

Экранирование сырых строк в целевых языках

Встраивание шаблона в обычную строку в двойных кавычках приводит к тому, что компилятор языка первым интерпретирует escape-последовательности с обратной косой чертой: в результате \d+\.\d+ приходится удваивать до "\\d+\\.\\d+", что создаёт риск тихого повреждения шаблона (например, "\b" превращается в управляющий ASCII-символ забоя 0x08 вместо границы слова). Экспортируемые сниппеты используют нативный формат сырых литералов каждого языка:

  • JavaScript: литеральная нотация /pattern/flags (экранируются только прямые слеши как \/), либо new RegExp(String.raw..., flags) для динамической сборки.
  • Python: сырые строковые литералы re.compile(r"...") (учитывайте, что сырая строка в Python не может заканчиваться нечётным числом обратных слешей).
  • Go: regexp.MustCompile с сырыми литералами в обратных кавычках (backticks) и заменой самого символа обратной кавычки на шестнадцатеричный код \x60, если он встречается в шаблоне.
  • Rust: regex::Regex::new(r"...") или хешированные сырые литералы r#"..."#, когда сам шаблон содержит двойные кавычки.

Точные границы RFC в рецептах для разработчиков

  • IPv4 и IPv6 (RFC 4291 / RFC 5952): наивный шаблон \d{1,3}(?:\.\d{1,3}){3} пропускает недопустимые октеты вплоть до 999. Строгая валидация IPv4 ограничивает каждый десятичный октет конструкцией (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), а рецепты IPv6 учитывают однократное сжатие нулей :: и встроенные IPv4-хвосты (::ffff:192.0.2.128).
  • UUID (RFC 9562, заменивший RFC 4122): каноническая шестнадцатеричная структура 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}$ проверяет ниббл версии (1–8, включая UUIDv7 и UUIDv8) и биты варианта IETF (8, 9, a, b), с опциональным послаблением для специальных значений Nil (00000000-...) и Max (ffffffff-...).
  • Даты ISO-8601 / RFC 3339 и практичные Email-адреса: лексические выражения строго ограничивают месяцы (0[1-9]|1[0-2]), дни (0[1-9]|[12]\d|3[01]), часы ([01]\d|2[0-3]) и смещения часовых поясов (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), оставляя календарную арифметику високосных лет (например, отсев 30 февраля) и проверку существования SMTP-ящика на уровень бизнес-логики парсера.

Генератор и конструктор Regex или Тестер и отладчик Regex: что выбрать?

Быстрый ответ: Используйте Генератор и конструктор Regex, когда нужно визуально собрать новое регулярное выражение из блоков-токенов, адаптировать проверенный пресет по RFC или экспортировать экранированный код для JavaScript, Python, Go и Rust. Используйте Тестер и отладчик Regex для анализа смещений совпадений, словарей групп захвата и интерактивной замены строк.

Выбор между этими двумя инструментами зависит от того, создаёте ли вы новое выражение с нуля или отлаживаете уже существующее. Генератор и конструктор Regex ориентирован на структурный синтез, настройку RFC-рецептов и генерацию кода для разных языков. Когда выражение уже готово и вам нужно детально изучить индексы каждого совпадения в многострочном тексте, переключить флаги состояния ECMAScript или проверить подстановку $<name> при замене, откройте Тестер и отладчик Regex.

Возможность Генератор и конструктор Regex Тестер и отладчик Regex
Основная инженерная задача Визуальная сборка новых шаблонов и адаптация проверенных RFC-рецептов Отладка готовых выражений, смещений совпадений, флагов и замен
Конструирование шаблона Комбинируемые блоки-токены (якоря, классы, квантификаторы, именованные группы) Прямое редактирование регулярного выражения в свободной форме
Библиотека проверенных рецептов Встроенные пресеты для Email, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Hex Фокус на произвольных пользовательских шаблонах и лог-файлах
Экспорт кода для разных языков Готовые к копированию сниппеты для JavaScript, Python, Go и Rust Вывод литерала регулярного выражения JavaScript / ECMAScript
Инспекция групп и смещений Мгновенная валидация на списке позитивных и негативных фикстур Диапазоны [start, end) для каждого совпадения, группы $1–$99 и словарь (?<name>...)
Предпросмотр замены в реальном времени Не предназначен для предпросмотра строковых подстановок Живой предпросмотр replace / replaceAll ($1, $<name>, $&, $$)

Рекомендуемый рабочий процесс

Соберите базовое выражение или загрузите пресет по RFC здесь, в инструменте Генератор и конструктор Regex, чтобы получить чистую структуру групп, безопасные для линейного времени границы квантификаторов и корректно экранированный шаблонный код для вашего бэкенда или фронтенда. А когда потребуется протестировать, как этот шаблон ведёт себя на многострочных логах, со свойством lastIndex, суррогатными парами Unicode или шаблонами replaceAll, передайте выражение в Тестер и отладчик Regex.

Частые вопросы

Частые вопросы и руководство: Генератор и конструктор Regex

Все, что нужно знать об использовании бесплатного онлайн-инструмента генератор регулярных выражений от Utiliome.

Почему сгенерированный синтаксис регулярных выражений отличается для JavaScript, Python, Go и Rust?

Хотя базовые символьные классы и квантификаторы совпадают во всех этих языках, синтаксис именованных групп захвата и ограничения конечных автоматов различаются. JavaScript требует записи (?<name>...), тогда как модуль re в Python и пакет regexp в Go требуют (?P<name>...) (крейт regex в Rust поддерживает оба варианта). Кроме того, Go и Rust компилируют шаблоны в линейные по времени конечные автоматы Томпсона (NFA / DFA), которые намеренно не поддерживают обратные ссылки (\1) и проверки просмотра ((?=...), (?<=...)), тогда как движки с возвратами в JavaScript и Python их поддерживают.

Стоит ли валидировать email-адреса полным регулярным выражением по грамматике RFC 5322?

Нет. Дословная грамматика RFC 5322 занимает несколько килобайт, чтобы разрешать устаревшие пробелы в кавычках, вложенные комментарии и доменные IP-литералы, которые современные почтовые серверы всё равно отклоняют, и при этом она никак не доказывает, что почтовый ящик реально способен принимать письма. В продакшене лаконичный структурный шаблон (^[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])?)+$) сочетают с проверкой ограничений длины в байтах по RFC 5321 (до 64 октетов для локальной части и до 254 октетов для всего адреса) и отправкой письма с подтверждением.

Как сырые строковые литералы предотвращают ошибки двойного экранирования обратных слешей?

В обычных строках в кавычках компилятор языка обрабатывает escape-последовательности ещё до передачи строки компилятору регулярных выражений: из-за этого \d+\s+ приходится удваивать до "\\d+\\s+", а "\b" превращается в ASCII-символ забоя (backspace) вместо границы слова. Нативные сырые литералы отключают предварительную распаковку обратных слешей компилятором: используйте литералы /\d+\s+/ в JavaScript, r"\d+\s+" в Python, обратные кавычки в Go и r"\d+\s+" или r#"..."# в Rust.

В чём разница между строгой валидацией всей строки и извлечением подстроки?

Строгая валидация оборачивает всё выражение в якоря начала и конца (^...$, либо \A...\z в Python, Go и Rust, поскольку $ в модуле re языка Python также может срабатывать непосредственно перед завершающим переводом строки \n). Без якорей выражение для даты вроде \d{4}-\d{2}-\d{2} работает как поиск подстроки и успешно срабатывает на некорректном вводе вроде foo-2026-11-01-bar. Оставляйте строгую привязку к границам строки включённой для проверки тела API-запросов и веб-форм, а поиск без якорей тестируйте в инструменте Тестер и отладчик Regex.

Как рецепт UUID по RFC 9562 отличает валидные UUID от произвольных 36-символьных HEX-строк?

Стандарт RFC 9562 (пришедший на смену RFC 4122) кодирует 4-битный номер версии в старшем ниббле третьей группы ([1-8] для версий с UUIDv1 по UUIDv8) и вариант IETF в старшем ниббле четвёртой группы ([89abAB], что соответствует двоичной маске 10xx). Если ваша база данных также хранит полностью нулевой Nil UUID (00000000-0000-0000-0000-000000000000) или состоящий из одних единиц Max UUID (ffffffff-ffff-ffff-ffff-ffffffffffff), включите ослабленный шестнадцатеричный режим или добавьте явные ветви альтернативы.