Регулярные выражения для новичка: как читать и применять

ИИ может за секунду написать строку вроде /^[A-Za-z0-9]{3,12}$/, но без расшифровки она выглядит как случайный набор знаков. Слепо вставлять такой код рискованно: одно лишнее условие способно запретить нормальное имя, а одно пропущенное — принять мусор. Тебе не нужно становиться специалистом по регуляркам, чтобы уверенно работать с кодом Claude Code. Достаточно понимать назначение основных символов, читать выражение слева направо и проверять его на хороших и плохих примерах.

Что такое регулярное выражение простыми словами

Регулярное выражение, или регулярка, — это шаблон, который описывает текст. Программа сравнивает с ним строку и отвечает на один из вопросов:

• соответствует ли вся строка заданным правилам;
• есть ли внутри строки подходящий фрагмент;
• какие фрагменты подходят;
• что нужно заменить.

Ближайшая бытовая аналогия — маска поиска файлов. Если в папке указать *.jpg, компьютер найдёт файлы с любым именем, но только с расширением .jpg. Звёздочка означает «какая-то последовательность символов», а .jpg должна находиться в конце имени. Регулярные выражения развивают ту же идею: в них можно описать цифру, пробел, начало строки, повторение и несколько допустимых вариантов.

Например, шаблон для четырёх цифр можно записать так:

^\d{4}$

Он читается как инструкция: «от начала строки должны идти ровно четыре цифры, после них строка заканчивается». Строка 2048 подходит, а уровень 2048, 204 и 2048 очков — нет.

Слово «выражение» иногда создаёт ложное впечатление, будто регулярка что-то вычисляет. Она не складывает числа и не понимает смысл текста. Она проверяет форму. Шаблон способен определить, что строка похожа на номер телефона, но не знает, существует ли этот номер. Он может проверить внешнюю форму email, но не подтвердит, что почтовый ящик зарегистрирован и принимает письма.

У регулярного выражения обычно есть две части: сам шаблон и настройки его применения. В JavaScript запись /snake/i содержит шаблон snake и флаг i, который отключает различие между заглавными и строчными буквами. Поэтому совпадут snake, Snake и SNAKE.

Регулярки полезны, когда правило относится именно к последовательности символов. Чем сложнее смысл данных, тем меньше пользы от попытки уместить всю проверку в один шаблон. Дату 31.02.2026 можно заставить выглядеть как дату, но календарно она останется невозможной. Для такой проверки после регулярки нужен обычный программный код.

Где новичок встретит регулярки в своём приложении

Даже небольшое приложение постоянно работает со строками: получает значения из полей формы, показывает сообщения, сохраняет имена и ищет данные. Поэтому регулярные выражения появляются раньше, чем кажется.

Проверка email и телефона в форме

Пользователь вводит email для регистрации или телефон для связи. Перед отправкой форма проверяет хотя бы общую структуру: есть ли у email часть до @, домен и точка; начинается ли российский номер с +7 и содержит ли нужное количество цифр.

Такая проверка помогает сразу заметить опечатку, но не доказывает подлинность данных. Подтверждение email делают письмом со ссылкой, телефона — кодом, отправленным на номер. У проверки адресов, реквизитов и других реальных данных тоже есть граница между форматом и существованием. Подробнее об этом — в материале про валидацию адресов и ИНН через DaData.

Поиск по тексту

Обычный поиск находит точную последовательность букв. Регулярка умеет искать семейство вариантов. Например, выражение уровень\s+\d+ найдёт уровень 5 и уровень 12: между словом и числом разрешён один или несколько пробельных символов.

Такой поиск пригодится в журнале событий «Змейки». Можно найти все записи о достигнутых уровнях, даже если количество пробелов в них отличается.

Замена

Регулярное выражение может найти лишние фрагменты, а программа — заменить их. Несколько пробелов подряд превращают в один, дефисы в телефоне удаляют, а старый формат записи результата приводят к новому.

Например, строку Ada 120 можно очистить так, чтобы между именем и счётом остался один пробел. Шаблон ищет последовательности пробельных символов, а replace подставляет вместо каждой последовательности обычный пробел.

Разбор строк

Иногда данные приходят одной строкой: player=Ada;score=120. Регулярка способна извлечь имя и число. Это называется разбором строки: программа отделяет части по известной структуре.

Для простого и стабильного формата такой подход уместен. Для JSON, HTML и других языков с собственной грамматикой лучше использовать готовый парсер — инструмент, который понимает структуру формата целиком.

Код, который написал ИИ

В работе с Claude Code регулярку чаще создаёт ИИ. Твоя задача — не вспомнить синтаксис по памяти, а проверить четыре вещи:

1. Какую строку шаблон должен принимать.
2. Должен ли он проверять всю строку или искать фрагмент внутри неё.
3. Какие допустимые варианты ИИ случайно запретил.
4. Какие неправильные варианты он случайно разрешил.

Если ИИ добавил /^[A-Za-z0-9]{3,12}$/ для имени игрока, ты уже можешь попросить расшифровку: начало строки, от 3 до 12 латинских букв или цифр, конец строки. После этого правило становится проверяемым требованием, а не магией.

Для форм с несколькими полями регулярки часто работают вместе с библиотекой управления состоянием и ошибками. Практический пример есть в статье про формы с валидацией на React Hook Form.

Базовые кирпичики регулярных выражений

Регулярное выражение читают слева направо. Каждый элемент сообщает, какой символ ожидается сейчас, где находится совпадение или сколько раз предыдущий элемент может повториться.

Обычные символы и точка

Большинство букв и цифр обозначают самих себя. Выражение snake ищет последовательность из букв s, n, a, k, e именно в таком порядке.

Некоторые знаки имеют специальный смысл. Точка . — это не точка в тексте, а «почти любой один символ». Шаблон v1.2 совпадёт не только с v1.2, но и с v1-2 или v1X2. Чтобы искать настоящую точку, перед ней ставят обратную косую черту: v1\.2.

Такое добавление обратной косой черты называется экранированием. Оно говорит движку регулярных выражений: «воспринимай следующий специальный знак буквально».

Классы символов

Квадратные скобки описывают один символ из набора. [abc] — не слово abc, а выбор между a, b и c. Диапазон [a-z] означает одну строчную латинскую букву, [A-Z] — одну заглавную, [0-9] — одну цифру.

Наборы можно объединять: [A-Za-z0-9] разрешает одну латинскую букву любого регистра или одну цифру. Знак ^ сразу после открывающей квадратной скобки переворачивает условие: [^0-9] означает любой символ, кроме цифры. Вне квадратных скобок тот же знак обозначает начало строки. Контекст меняет его смысл.

Короткие классы экономят место:

• \d — цифра;
• \w — латинская буква, цифра или подчёркивание в обычном режиме JavaScript;
• \s — пробел, табуляция или другой пробельный символ;
• \D, \W, \S — противоположные варианты: не цифра, не символ слова, не пробельный символ.

У \w есть ловушка: русские буквы он обычно не покрывает. Если в имени разрешена кириллица, нельзя молча заменить [A-Za-z] на \w. Попроси ИИ явно учесть Unicode и показать тесты с русскими именами.

Кванторы: сколько раз повторить

Квантор ставится после символа, класса или группы и определяет количество повторений. В выражении \d{10} квантор {10} относится к \d, поэтому ожидаются ровно десять цифр. В (go){2} он относится ко всей группе, поэтому подходит gogo.

Разница между тремя короткими кванторами принципиальна:

• * разрешает отсутствие элемента: ноль, один или много раз;
• + требует хотя бы один элемент;
• ? разрешает ноль или один элемент.

Если поле не должно быть пустым, шаблон \d* часто ошибочен: ноль цифр тоже удовлетворяет *. Для одной или нескольких цифр нужен \d+, а для строго заданного количества — \d{n}.

Диапазон {3,12} означает «не меньше 3 и не больше 12 повторений». Запись {3,} задаёт только нижнюю границу: три или больше. Верхнюю границу полезно указывать для пользовательского ввода, чтобы слишком длинные строки не проходили проверку.

Якоря начала и конца

Без якорей движок ищет совпадающий фрагмент где угодно внутри строки. Регулярка \d{4} найдёт четыре цифры в тексте Счёт: 2048 очков. Для поиска это удобно, для проверки поля — обычно нет.

Шаблон ^\d{4}$ требует, чтобы от начала ^ до конца $ находились только четыре цифры. Он принимает 2048, но отклоняет Счёт: 2048, 20480 и строку с пробелом после числа.

Хороший вопрос к любой регулярке в форме: «Есть ли здесь ^ и $, если требуется проверить значение целиком?» Их отсутствие не всегда ошибка, но должно быть осознанным решением.

Группы и альтернатива

Круглые скобки собирают несколько элементов в одну часть. К группе можно применить квантор или получить из неё отдельный фрагмент результата. Шаблон (ab)+ принимает ab, abab, ababab.

Вертикальная черта | означает «или». Выражение easy|normal|hard находит любой из трёх уровней сложности. Если нужно проверить всю строку, варианты группируют и добавляют якоря:

^(easy|normal|hard)$

Без группы запись ^easy|normal|hard$ читается иначе: начало относится только к easy, а конец — только к hard. Это пример, когда выражение выглядит почти правильно, но допускает лишние строки.

Группы по умолчанию ещё и запоминают совпадение. Это удобно при перестановке частей в replace. Если запоминание не нужно, ИИ может использовать группу вида (?:...). Для первого чтения достаточно знать: (?:...) объединяет элементы, но не сохраняет отдельный результат.

Как читать готовое регулярное выражение по шагам

Не пытайся охватить шаблон одним взглядом. Перепиши его как последовательность требований. Сначала отдели служебные ограничители JavaScript /.../ и флаги после последнего слеша, затем двигайся слева направо.

Удобный порядок разбора:

1. Найди якоря ^ и $: проверяется вся строка или ищется фрагмент.
2. Отметь группы ( ) и варианты через |.
3. Расшифруй классы [ ], \d, \w, \s.
4. Привяжи каждый квантор к элементу непосредственно перед ним.
5. Найди экранированные специальные знаки: \., \+, \(.
6. Проверь флаги после закрывающего /.
7. Придумай строки на границах правила и запусти тесты.

Разбор простой проверки email

Возьмём распространённый упрощённый шаблон:

/^[^\s@]+@[^\s@]+\.[^\s@]+$/

Читаем его по частям:

Шаблон принимает player@example.com и отклоняет player example.com, player@@example.com и player@example. Он подходит для быстрой клиентской проверки очевидных ошибок, но не описывает все правила существующих email-адресов. Попытка сделать «идеальную регулярку для email» обычно рождает длинное выражение, которое трудно проверить и поддерживать.

Правильная продуктовая логика состоит из двух уровней: простая проверка формы адреса и подтверждение владения ящиком через письмо. Регулярка отвечает только за первый уровень.

Разбор российского телефона в формате +7

Допустим, приложение принимает только строгий формат: знак +, затем 7, затем ровно десять цифр без пробелов, скобок и дефисов. Шаблон выглядит так:

/^\+7\d{10}$/

Расшифровка:

+79991234567 подходит. 89991234567, +7 999 123-45-67, +7999123456 и Телефон: +79991234567 не подходят.

Это не означает, что номер с пробелами неправильный. Он лишь не соответствует выбранному формату ввода. Есть два разумных решения: показать человеку подсказку о формате или сначала убрать разрешённые разделители, а затем проверить очищенную строку. Второй вариант удобнее для пользователя:

const rawPhone = '+7 (999) 123-45-67';
const normalizedPhone = rawPhone.replace(/[\s()-]/g, '');
const isValid = /^\+7\d{10}$/.test(normalizedPhone);

После замены normalizedPhone содержит +79991234567, и isValid становится true. Такая проверка всё равно подтверждает только формат, а не существование номера и не принадлежность человеку.

Регулярные выражения в JavaScript

В JavaScript регулярку можно создать литералом — записью между косыми чертами:

const pattern = /^[A-Za-z0-9]{3,12}$/;

Литерал удобен, когда шаблон известен заранее. Есть и конструктор new RegExp(), но в нём обратные косые черты приходится экранировать ещё раз. Для новичка это лишний источник ошибок. Если шаблон не собирается динамически из переменных, попроси Claude Code использовать литерал.

Косые черты / не являются частью проверяемого правила. Они показывают JavaScript, где начинается и заканчивается регулярное выражение. После последней черты могут стоять флаги.

Флаги g, i и m

Флаг меняет режим работы всего выражения:

• g — искать все совпадения, а не только первое;
• i — не различать регистр букв;
• m — считать начало и конец каждой строки многострочного текста отдельными позициями для ^ и $.

Флаги можно сочетать: /score/gi найдёт все варианты score, Score и SCORE.

Флаг g не нужен для обычной проверки поля через test. Более того, повторные вызовы test с одной и той же глобальной регуляркой могут давать чередующиеся результаты, потому что объект запоминает позицию прошлого совпадения. Для проверки имени используй шаблон без g.

Флаг m не означает, что точка начнёт захватывать переносы строк. Он меняет поведение только якорей. Это отдельная настройка, и её нужно учитывать при чтении сгенерированного кода.

Метод test: подходит ли строка

Метод test возвращает true или false. Для формы это самый понятный вариант.

В «Змейке» имя для таблицы рекордов должно состоять только из латинских букв и цифр, а длина — от 3 до 12 символов:

const PLAYER_NAME_PATTERN = /^[A-Za-z0-9]{3,12}$/;

function isPlayerNameValid(name) {
  return PLAYER_NAME_PATTERN.test(name);
}

console.log(isPlayerNameValid('Ada7'));         // true
console.log(isPlayerNameValid('Max'));          // true
console.log(isPlayerNameValid('AB'));           // false: слишком коротко
console.log(isPlayerNameValid('Snake Master')); // false: есть пробел
console.log(isPlayerNameValid('Игрок7'));       // false: есть кириллица

Выражение читается так: ^ — начало, [A-Za-z0-9] — одна допустимая латинская буква или цифра, {3,12} — от 3 до 12 таких символов, $ — конец. Якоря не дают спрятать допустимый фрагмент внутри недопустимого имени.

Если требования изменятся и появится поддержка кириллицы, менять нужно не случайный символ, а само продуктовое правило. Попроси ИИ предложить читаемый Unicode-вариант и добавить тесты для Лена7, смешанного алфавита, дефиса и пробела.

Метод match: получить совпадения

Метод match возвращает найденный фрагмент или массив фрагментов. С флагом g он собирает все совпадения.

Допустим, журнал игры хранится в таком виде:

const log = 'level 2; level 5; level 11';
const levels = log.match(/level \d+/g);

console.log(levels); // ['level 2', 'level 5', 'level 11']

Здесь level — обычный текст, \d+ — одна или несколько цифр, g — поиск всех фрагментов. Без g вернулось бы только первое совпадение вместе с дополнительными сведениями о нём.

Если совпадений нет, match может вернуть null, а не пустой массив. Код, который сразу вызывает levels.map(...), должен учесть этот вариант. Claude Code можно прямо попросить: «Обработай случай, когда регулярка ничего не нашла».

Метод replace: найти и заменить

Метод replace принимает шаблон и замену. Например, он может сжать несколько пробельных символов до одного:

const rawResult = 'Ada     120';
const cleanResult = rawResult.replace(/\s+/g, ' ');

console.log(cleanResult); // 'Ada 120'

\s+ находит последовательность из одного или нескольких пробельных символов, а g заставляет заменить каждую такую последовательность в строке.

Группы позволяют сохранить найденные части и поменять их местами:

const record = 'Ada:120';
const readable = record.replace(/^([A-Za-z0-9]{3,12}):(\d+)$/, '$1 — $2');

console.log(readable); // 'Ada — 120'

Первая группа содержит имя, вторая — счёт. В строке замены $1 и $2 ссылаются на содержимое этих групп.

JavaScript работает и в браузере, и в Node.js, поэтому базовый синтаксис регулярных выражений встречается в клиентском и серверном коде. Если пока неясно, чем эти среды отличаются, начни с объяснения что такое Node.js. А типы переменных, функций и результатов подробнее разобраны в материале про TypeScript для новичка.

Где проверять регулярные выражения онлайн

Существуют онлайн-сервисы, в которых можно вставить шаблон, добавить тестовый текст и увидеть совпадения. Для запроса «регулярные выражения онлайн» ты найдёшь несколько таких инструментов. Конкретное расположение полей и набор возможностей со временем меняются, поэтому ориентируйся на общую схему работы, а не на название кнопки.

Для проверки нужны три компонента:

1. Само выражение, например ^[A-Za-z0-9]{3,12}$.
2. Режим или язык JavaScript, если сервис предлагает выбор движка.
3. Набор тестовых строк с ожидаемыми результатами.

В одних сервисах косые черты /.../ и флаги вводятся вместе с шаблоном, в других для них есть отдельные поля. Если всё ожидаемо подсвечивается как ошибка, сначала проверь формат ввода самого сервиса. Не меняй регулярку наугад.

Для имени игрока вставь по одной строке:

Ada7
Max
AB
Snake Master
Игрок7
VeryLongPlayerName

Первые две должны пройти, остальные — нет. Затем добавь граничные случаи: имя ровно из 3 символов, ровно из 12, из 2 и из 13. Такой набор показывает, правильно ли работает {3,12}.

Проверка регулярных выражений на одном удачном примере почти ничего не доказывает. Если шаблон принял Ada7, он может заодно принимать Ada7!!!. Поэтому для каждого правила нужны как минимум три группы:

• обычные правильные значения;
• правильные значения на границе;
• неправильные значения, нарушающие по одному условию.

Онлайн-проверка удобна для исследования, но тесты в проекте надёжнее: они останутся рядом с кодом и запустятся после будущих изменений. Попроси ИИ перенести проверенные примеры в автоматический тест.

Не вставляй в сторонний сервис настоящие телефоны, email, токены доступа, пароли и пользовательские данные. Для отладки достаточно вымышленных значений. Регулярное выражение тоже может раскрывать внутренние правила продукта, поэтому рабочие шаблоны из закрытого проекта лучше проверять локально.

Поиск регулярных выражений в интернете полезен как источник идей, но найденный шаблон нельзя считать готовым только потому, что он длинный или часто копируется. Сначала уточни, для какого языка он написан: синтаксис и поддерживаемые возможности у движков различаются. Затем переведи его на обычный русский и проверь на своих данных.

Типичные ошибки в регулярных выражениях

Большинство проблем возникает не из-за незнания редких конструкций, а из-за нескольких повторяющихся ловушек.

Жадные кванторы захватывают слишком много

Кванторы * и + по умолчанию жадные: они стараются забрать максимально длинный подходящий фрагмент, а затем при необходимости отступают.

Пусть есть строка:

"Ada" набрала "120" очков

Шаблон ".*" начнёт с первой кавычки и закончит на последней. Результатом станет вся часть "Ada" набрала "120", а не два отдельных значения.

Ленивый вариант ".*?" берёт минимально возможный фрагмент и в этом примере отдельно находит "Ada" и "120". Знак ? после квантора меняет его поведение с жадного на ленивое.

Ещё яснее бывает ограничить допустимые символы: "[^"]*" означает кавычку, затем любое количество символов, кроме кавычки, затем закрывающую кавычку. Такой шаблон точнее выражает правило.

Забытое экранирование точки

Точка означает любой символ. Шаблон score.json найдёт не только score.json, но и scoreXjson. Для настоящей точки нужен вариант score\.json.

В литерале JavaScript он выглядит так:

/^score\.json$/

Если то же выражение записано строкой для new RegExp(), понадобится дополнительное экранирование на уровне строки:

new RegExp('^score\\.json$')

Два слоя правил трудно читать. Это ещё одна причина выбирать литерал, когда динамический конструктор не нужен.

Специальный смысл есть не только у точки. Обычно внимания требуют ^, $, *, +, ?, круглые и квадратные скобки, фигурные скобки, |, / и обратная косая черта. Если нужен буквальный знак, попроси ИИ проверить экранирование именно для JavaScript и показать тест.

Регулярка используется вместо нормального парсера

HTML и JSON имеют вложенную структуру, кавычки, экранирование и множество допустимых вариантов. Короткая регулярка может сработать на одном фрагменте, но сломаться на переносе строки, вложенном элементе или кавычке внутри значения.

Для JSON есть JSON.parse:

const data = JSON.parse('{"player":"Ada","score":120}');
console.log(data.score); // 120

Для HTML в браузере есть DOMParser и обычные методы DOM. Регулярку можно применить к узкой, заранее известной строке, но не стоит строить на ней полноценный разбор документа.

То же относится к URL, датам и адресам. Часто у платформы уже есть объект или библиотека, которая понимает формат лучше самодельного шаблона. Регулярка проверяет внешнюю форму; парсер разбирает структуру и сообщает содержательную ошибку.

Катастрофический откат на длинных строках

Некоторые выражения заставляют движок перебирать огромное количество вариантов. На коротком тексте задержка незаметна, а специально подобранная длинная строка может надолго занять процессор. Это называют катастрофическим откатом.

Классический опасный пример:

/^(a+)+$/

Внутренний a+ повторяется внешним +. На строке из множества a, после которых стоит неподходящий символ, движок может снова и снова делить одну последовательность на группы разными способами.

Практические меры защиты:

• не вкладывай друг в друга неоднозначные кванторы без необходимости;
• задавай разумную максимальную длину пользовательского ввода до проверки;
• используй более конкретные классы и границы;
• добавляй тесты с длинной неподходящей строкой;
• проси ИИ оценить шаблон на риск катастрофического отката;
• не принимай сложное выражение только потому, что оно короче обычного кода.

Такой риск особенно существенен на сервере: одна тяжёлая проверка может задержать обработку других запросов. В браузере она способна подвесить интерфейс. Если выражение приходит от пользователя или собирается из его текста, отдельно нужно экранировать специальные символы и ограничивать сложность.

Проверяется фрагмент вместо всей строки

Шаблон /\d{3}/ вернёт true для строки abc123xyz, потому что внутри есть три цифры. Если поле должно содержать ровно три цифры, нужны якоря: /^\d{3}$/.

Эта ошибка коварна тем, что хорошие примеры проходят в обоих случаях. Её обнаруживает только плохой тест с правильным фрагментом внутри лишнего текста.

Шаблон и требования расходятся

Требование «латинские буквы и цифры» не отвечает на все вопросы. Допустимы ли заглавные буквы? Может ли имя начинаться с цифры? Нужны ли дефис и подчёркивание? Следует ли обрезать пробелы по краям? Считается ли длина до очистки или после неё?

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

Когда регулярка не нужна

Регулярные выражения хороши для шаблонов, но простые строковые методы часто понятнее. Код, смысл которого виден без расшифровки, легче менять и безопаснее проверять.

includes для поиска известного фрагмента

Если нужно узнать, содержит ли сообщение слово score, хватит includes:

const message = 'New high score!';
const hasScore = message.includes('score');

Регулярка /score/.test(message) тоже сработает, но ничего не добавит. includes сразу сообщает намерение: найти точную подстроку.

startsWith и endsWith для начала и конца

Проверить префикс или суффикс можно без якорей:

const fileName = 'scores.json';

console.log(fileName.startsWith('scores')); // true
console.log(fileName.endsWith('.json'));    // true

Такой код проще, чем /^scores/ и /\.json$/, если других условий нет.

split для разделения по известному знаку

Строка стабильного формата Ada:120 легко делится по двоеточию:

const [player, score] = 'Ada:120'.split(':');

Регулярка нужна, если разделители бывают разными или вокруг них допустимо переменное количество пробелов. При одном точном разделителе split читается лучше.

Сравнение и числовая проверка

Для точного совпадения используй ===, для проверки числа — преобразование в число и числовые условия. Регулярка /^(100|[1-9]?\d)$/ способна ограничить диапазон от 0 до 100, но обычное сравнение выражает правило яснее:

const score = Number(inputValue);
const isValidScore = Number.isInteger(score) && score >= 0 && score <= 100;

Выбор можно сформулировать так: если задача звучит как «содержит», «начинается», «заканчивается», «раздели по точному знаку» или «сравни число», сначала проверь обычный метод. Если нужно описать меняющуюся последовательность символов, регулярка может быть уместна.

Как просить ИИ написать регулярку и что проверить

Запрос «напиши регулярку для имени» слишком расплывчатый. ИИ вынужден самостоятельно решить, какие алфавиты, знаки и длину разрешить. Чем точнее условия и примеры, тем легче проверить ответ.

Хороший запрос к Claude Code может выглядеть так:

Напиши для JavaScript проверку имени игрока в «Змейке».

Требования:
- только латинские буквы A-Z и a-z и цифры 0-9;
- длина от 3 до 12 символов включительно;
- пробелы, дефисы, подчёркивания и кириллица запрещены;
- должна проверяться вся строка;
- используй литерал регулярного выражения и метод test;
- объясни каждый элемент выражения простыми словами;
- добавь тесты для допустимых, недопустимых и граничных значений;
- оцени риск медленной работы на длинном вводе.

Если регулярка уже появилась в проекте, попроси не переписывать её сразу, а провести разбор:

Прочитай регулярное выражение /^[A-Za-z0-9]{3,12}$/ слева направо.
Для каждой части объясни её смысл.
Перечисли строки, которые оно принимает и отклоняет.
Укажи расхождения с требованиями, но пока не меняй код.

Для сложного выражения добавь просьбу предложить более простой вариант обычным кодом. Иногда лучший результат ревью — удалить регулярку и заменить её includes, split или несколькими прозрачными проверками.

Набор хороших и плохих примеров

До изменения кода составь таблицу ожиданий:

Каждый плохой пример должен нарушать по возможности одно правило. Тогда при падении теста понятно, что именно сломалось.

Что проверить в ответе ИИ

Пройди короткий список:

• указан ли правильный язык и движок регулярных выражений;
• проверяется ли вся строка, если это нужно;
• совпадает ли разрешённый набор символов с требованиями;
• правильно ли заданы минимальная и максимальная длина;
• не допускает ли * пустую строку;
• экранированы ли точки, плюсы и другие специальные символы;
• нужны ли указанные флаги и нет ли лишнего g рядом с test;
• обрабатывается ли null, если используется match;
• есть ли ограничение длины входных данных;
• есть ли тесты на границах и на заведомо плохих строках;
• не пытается ли шаблон заменить готовый парсер.

После этого попроси Claude Code запустить тесты и показать сырой результат команды. Фраза ИИ «должно работать» не заменяет фактический прогон.

Практика: проверка имени игрока в «Змейке»

Соберём требования, код и сообщения об ошибках в один небольшой пример. Поле принимает латинские буквы и цифры, длина — от 3 до 12 символов.

HTML:

<label for="player-name">Player name</label>
<input
  id="player-name"
  name="playerName"
  minlength="3"
  maxlength="12"
  autocomplete="nickname"
>
<p id="player-name-error" aria-live="polite"></p>

JavaScript:

const form = document.querySelector('form');
const nameInput = document.querySelector('#player-name');
const error = document.querySelector('#player-name-error');
const playerNamePattern = /^[A-Za-z0-9]{3,12}$/;

form.addEventListener('submit', (event) => {
  const playerName = nameInput.value;

  if (!playerNamePattern.test(playerName)) {
    event.preventDefault();
    error.textContent = 'Use 3–12 Latin letters or digits.';
    nameInput.focus();
    return;
  }

  error.textContent = '';
});

Интерфейс «Змейки» остаётся на английском, поэтому текст ошибки тоже английский. Сообщение не говорит «Invalid value», а объясняет, что именно исправить.

Атрибуты minlength и maxlength помогают браузеру и пользователю, но не заменяют JavaScript-проверку разрешённых символов. Если результат отправляется на сервер, сервер обязан повторить проверку: код в браузере можно обойти.

Попроси ИИ добавить автоматические тесты отдельно от обработчика формы:

const cases = [
  ['Ada', true],
  ['Player2026', true],
  ['AB', false],
  ['ABCDEFGHIJKLM', false],
  ['Snake Master', false],
  ['Игрок7', false],
  ['', false],
];

for (const [name, expected] of cases) {
  const actual = playerNamePattern.test(name);
  console.assert(actual === expected, `${name}: expected ${expected}`);
}

Этот фрагмент удобен для первого эксперимента. В реальном проекте тесты лучше оформить средствами уже выбранного тестового инструмента, чтобы команда проверки завершалась с ошибкой при несовпадении ожиданий.

Осталось принять продуктовое решение о пробелах по краям. Можно отклонять Ada и просить исправить ввод, а можно сначала применять trim(). Оба подхода технически допустимы, но поведение должно быть осознанным и отражённым в тестах:

const playerName = nameInput.value.trim();

После trim() строка Ada превратится в Ada и пройдёт регулярку. Пробел внутри Snake Master останется и будет отклонён.

Короткий ориентир для чтения любой регулярки

Когда встретишь незнакомое выражение в коде, не начинай с вопроса «как запомнить все знаки». Начни с назначения строки и преврати шаблон в правила.

Для /^\+7\d{10}$/ получится: вся строка; буквальный +7; затем десять цифр. Для /^[A-Za-z0-9]{3,12}$/ — вся строка; только латинские буквы и цифры; от 3 до 12 символов. Для /\s+/g — каждая последовательность из одного или нескольких пробельных символов.

Если расшифровка не помещается в несколько ясных предложений, это сигнал запросить у ИИ объяснение, тесты и более простой вариант. Длина шаблона сама по себе не делает код профессиональнее.

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

Нужно ли учить регулярные выражения наизусть?

Нет. Для старта достаточно узнавать классы символов, кванторы, якоря, группы и флаги. Редкие конструкции можно уточнить у ИИ или в документации, а затем подтвердить тестами.

Чем регулярное выражение отличается от обычного поиска?

Обычный поиск ищет точный текст. Регулярка описывает множество подходящих строк: например, не конкретный номер, а любую последовательность из десяти цифр.

Может ли регулярка проверить, что email или телефон настоящие?

Нет. Она проверяет только формат строки. Реальность email подтверждают письмом, телефона — кодом, а существование адреса или реквизитов — отдельным источником данных.

Почему одна и та же регулярка работает в одном сервисе и не работает в другом?

У языков и инструментов разные движки и синтаксические возможности. Укажи JavaScript при онлайн-проверке и не переноси шаблон из другого языка без тестов.

Всегда ли для проверки формы нужны якоря ^ и $?

Если вся строка обязана соответствовать формату, обычно да. Без якорей подходящий фрагмент может находиться внутри лишнего текста. Для поиска внутри большого текста якоря, наоборот, часто не нужны.

Что делать, если ИИ написал очень длинную регулярку?

Попроси расшифровать её по частям, перечислить ограничения, добавить хорошие и плохие тесты и предложить вариант без регулярки. Для сложных форматов готовый парсер или несколько обычных условий часто надёжнее.