Regex генератор на шаблони

Създавайте регулярни изрази визуално чрез токен блокове и проверени RFC шаблони.

Без качване на файловеБез регистрацияНезабавни резултати
13 проверени RFC и Dev рецептиВизуален конструктор на правила и квантификаториJS · Python · Go · Rust фрагменти
Генериране на Regex
Офлайн модулът е готов100% поверителна офлайн работа в браузъра • Без качване в облака
100% Поверително • Без качване на файлове на сървър

Защо да използвате безплатния Regex генератор на шаблони от Utiliome?

Създаден от самото начало за пълна поверителност, моментално изпълнение и без излишни трудности. Без абонаменти или регистрация.

Модулни визуални токен блокове

Конструирайте четими регулярни изрази стъпка по стъпка чрез свързване на котви, класове от символи, ограничени квантификатори, неприхващащи групи ((?:...)) и именувани групи ((?<name>...)).

Проверени шаблони по RFC стандарти

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

Кодови фрагменти за множество езици

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

Мигновена валидация и пълна поверителност

Проверявайте положителни и отрицателни тестови низове в реално време, докато редактирате блоковете. Всяка промяна, валидация и експорт на код се изпълняват 100% локално в браузъра без мрежови заявки.

Utiliome срещу традиционните облачни алтернативи

Сравнете нашия локален WebAssembly двигател с остарелите облачни инструменти.

Функция Utiliome (Локален браузър) Остарели облачни конвертори
Модулни визуални токен блокове Конструирайте четими регулярни изрази стъпка по стъпка чрез свързване на котви, класове от символи, ограничени квантификатори, неприхващащи групи ((?:...)) и именувани групи ((?<name>...)). Ограничени опции без разширено персонализиране
Проверени шаблони по RFC стандарти Заредете готови шаблони за практични имейли по RFC 5322, валидни IPv4/IPv6 адреси, времеви отпечатъци по ISO-8601 / RFC 3339, SemVer 2.0.0 версии, UUID по RFC 9562, URL адреси, URL слъгове и шестнадесетични CSS цветове. Изисква външни инструменти или ръчна обработка
Поверителност и обработка 100% локална обработка в браузъра (0 качвания на сървър) Качва данните на външни облачни сървъри
Цена и изисквания за акаунт 100% безплатно завинаги без регистрация Изисква регистрация или платен абонамент
Как работи

Как да използвате Regex генератор на шаблони в 3 лесни стъпки

Не се изисква инсталиране на софтуер. Всичко работи директно във вашия уеб браузър.

1

Изберете готов шаблон или добавете токен блокове

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

2

Конфигурирайте котви, групи и тестови низове

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

3

Копирайте чистия Regex или код за конкретен език

Експортирайте чистия регулярен израз или копирайте идиоматични фрагменти за 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, и как неприхващащите обвивки (?:...)? обграждат разделителите - и +, без да създават излишни номерирани групи. Валидирането спрямо положителни и отрицателни тестови примери и експортирането на код за множество езици генерира автоматично точни декларации за съответния двигател:

# Синтезиран шаблон за 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-]+)*))?$

# Положителни примери (Съвпадат)
1.0.0
v2.14.3-rc.1+build.5114f85

# Отрицателни примери (Отхвърлят се: водеща нула в числовото ядро на версията)
v01.2.0
1.02.3

# Python (re.compile суров низ + синтаксис (?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 (RE2 regexp.MustCompile суров литерал с обратни кавички + синтаксис (?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-]+)*))?$`)

Тъй като генераторът избягва обратни препратки (backreferences) и проверки на обкръжението (lookarounds) в стандартните шаблони, експортираният израз се компилира без промени както в среди с линейно време на изпълнение като RE2 (Go и Rust), така и в двигатели с връщане назад (JavaScript и Python).

Преносимост между Regex двигатели, тънкости при RFC валидацията и правила за екраниране

Бърз отговор: Средите за изпълнение на регулярни изрази се делят на NFA двигатели с връщане назад (JavaScript RegExp, Python re) и линейни по време Thompson NFA / DFA автомати (Go regexp, Rust regex). Преносимите шаблони избягват lookaround проверки и обратни препратки, използват нативни сурови низове и налагат точни граници на октетите и полубайтовете според RFC.

NFA с връщане назад срещу линейни по време автомати (Go RE2 и Rust `regex`)

Продукционните двигатели за регулярни изрази се разделят на два основни модела на изпълнение:

  1. NFA с връщане назад / Backtracking NFA (JavaScript RegExp, Python re): Обхожда рекурсивно разклоненията на алтернациите, което позволява обратни препратки (\1, \k<name>) и произволни lookahead/lookbehind проверки ((?=...), (?!...), (?<=...), (?<!...)), но с цената на потенциално експоненциално време за изпълнение в най-лошия случай при двусмислени шаблони.
  2. Thompson NFA / Мързелив DFA (Go regexp, Rust regex): Придвижва всички активни състояния на автомата едновременно за всеки входен байт или кодова точка, гарантирайки времева сложност O(m * n) в най-лошия случай спрямо размера на шаблона m и дължината на входа n. За да запазят крайните граници на състоянията, Go regexp и Rust regex умишлено изключват обратни препратки и lookaround проверки.

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

Екраниране със сурови низове в целевия език

Вграждането на шаблон в обикновен низ с двойни кавички кара компилатора на езика първо да интерпретира екраниращите наклонени черти, което налага удвояването на \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 и практични имейли: Лексикалните изрази налагат точни граници за месеци (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 regex литерал
Инспекция на групи и отмествания Мигновена валидация спрямо положителни и отрицателни тестови примери Интервали [start, end) за всяко съвпадение, групи $1–$99 и речник (?<name>...)
Преглед на замествания на живо Не е предназначен за преглед на замествания на низове Преглед в реално време на replace / replaceAll ($1, $<name>, $&, $$)

Препоръчителен работен процес

Сглобете базовия си израз или заредете RFC шаблон тук в Regex генератор на шаблони, за да получите чиста структура на групиране, квантификатори с линейно време на изпълнение и правилно екраниран базов код за вашия бекенд или фронтенд език. Когато трябва да тествате как този шаблон взаимодейства с многоредови лог файлове, състоянието на lastIndex, сурогатни двойки в Unicode или шаблони за replaceAll, прехвърлете израза в Regex тестер и дебъгер.

ЧЗВ

Често задавани въпроси и техническо ръководство за Regex генератор на шаблони

Всичко, което трябва да знаете за използването на безплатния онлайн regex генератор от Utiliome.

Защо генерираният regex синтаксис се различава между JavaScript, Python, Go и Rust?

Макар основните класове от символи и квантификатори да съвпадат във всички езици, синтаксисът за именувани групи и ограниченията на автоматите се различават. JavaScript изисква (?<name>...), докато модулът re в Python и пакетът regexp в Go изискват (?P<name>...) (библиотеката regex в Rust поддържа и двете форми). Освен това Go и Rust компилират шаблоните в линейни по време Thompson NFA / DFA крайни автомати, които умишлено пропускат обратни препратки (\1) и lookaround проверки ((?=...), (?<=...)), докато двигателите с връщане назад в JavaScript и Python ги поддържат.

Трябва ли да валидирам имейл адреси с пълен регулярен израз по граматиката на 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 октета за целия адрес) и изпращане на имейл за потвърждение.

Как суровите низови литерали предотвратяват грешки от двойно екраниране с обратна наклонена черта в различните езици?

В стандартните низове в кавички компилаторът на езика обработва екраниращите последователности с обратна наклонена черта преди да предаде низа на regex компилатора, което налага удвояването на \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, тъй като $ в Python re може да съвпадне и непосредствено преди краен символ за нов ред \n). Без котви израз за дата като \d{4}-\d{2}-\d{2} действа като търсене на подниз и успява при невалидни входове като foo-2026-11-01-bar. Дръжте точното закотвяне включено при валидиране на API заявки и уеб формуляри или тествайте незакотвено извличане на интервали в Regex тестер и дебъгер.

Как шаблонът за UUID по RFC 9562 отличава валидните UUID от произволни 36-символни шестнадесетични низове?

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