Генератор і конструктор 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% локально у браузері (0 завантажень на сервер) Завантажує дані на зовнішні хмарні сервери
Вартість і реєстрація 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), увімкніть послаблений шістнадцятковий режим або додайте явні гілки альтернативи.