Гайды

Почему регулярка в JavaScript срабатывает через раз — и при чём тут флаг g

Иллюстрация: одинаковые карточки на конвейере — сканер подсвечивает только каждую вторую

Форма проверяет почту. Первый раз ты вводишь адрес — всё ок. Нажимаешь «Отправить» второй раз с тем же адресом — «Неверный email». Третий раз — снова ок.

Адрес не менялся. Регулярка не менялась. Ты проверяешь в консоли:

const re = /cat/g

re.test('cat')   // true
re.test('cat')   // false
re.test('cat')   // true

Одна и та же строка, одна и та же регулярка — и ответ скачет. Это не мистика и не баг браузера. У регулярки с флагом g есть память. Ниже три типичные причины, начиная с самой частой. Для каждой — как проверить и как починить.

Причина 1. Флаг g и общий test()

Что происходит. Флаг g (global) значит «найти все совпадения по очереди». Чтобы искать по очереди, регулярка запоминает, где остановилась. Это число лежит в свойстве lastIndex.

Разберём пример выше по шагам:

  1. Первый test('cat') ищет с позиции 0. Нашёл. Запомнил lastIndex = 3 — конец совпадения.
  2. Второй вызов ищет с позиции 3. Строка 'cat' там уже закончилась. Не нашёл — false. Сбросил lastIndex в 0.
  3. Третий вызов снова ищет с нуля — true.

Отсюда «через раз». Особенно больно в filter:

const re = /cat/g
['cat', 'cat', 'cat'].filter(w => re.test(w))
// ['cat', 'cat'] — одна потерялась

Нейросети часто дописывают g «на всякий случай». Для проверки «подходит или нет» он не нужен совсем.

Как проверить. Выведи re.lastIndex до и после вызова. Не ноль после true — это оно.

Как починить. Самый простой способ — убрать g:

const re = /cat/   // без g у test() нет памяти

Флаг нужен для другой задачи? Тогда сбрасывай позицию перед каждой проверкой: re.lastIndex = 0. Или создавай регулярку внутри функции, а не снаружи. Та же память есть и у флага y (sticky).

Причина 2. Одна регулярка на разных строках

Что происходит. Это та же память, но симптом другой. После длинной строки lastIndex остаётся большим. Следующая строка короче — и поиск начинается за её концом:

const re = /cat/g
re.test('мой чёрный cat')   // true, lastIndex = 14
re.test('cat')              // false — ищет с 14-й позиции

На сервере это выглядит страшнее. Регулярка объявлена вверху модуля, одна на всех. Один пользователь отправил длинную строку — проверка у следующего пользователя падает. Воспроизвести локально почти невозможно: «у меня всё работает».

Как проверить. Найди регулярки с g, объявленные вне функции, и посмотри, где их используют с test() или exec(). Поиск по проекту /g помогает. Как искать такое в большом проекте — в статье как найти код в большом проекте.

Как починить. Так же, как в причине 1. Для проверки «подходит ли строка» флаг g не нужен никогда.

Причина 3. Цикл с exec() зависает

Что происходит. Ручной цикл поиска всех совпадений:

const re = /\d+/       // забыли g
let m
while ((m = re.exec('a1 b22 c333'))) {
  console.log(m[0])
}

Без g у регулярки нет памяти. Она каждый раз находит первое совпадение — '1' — и цикл крутится вечно. Вкладка зависает. Подробнее о таких циклах — в статье почему цикл не заканчивается.

Есть и обратный вариант — с g, но регулярка умеет совпадать с пустотой, например /a*/g. Пустое совпадение не двигает lastIndex. Цикл снова стоит на месте.

Как проверить. Вкладка зависла на поиске? Поставь в цикл счётчик и break после сотни итераций. Посмотри, что выводится. Одно и то же совпадение снова и снова — это оно.

Как починить. Не пиши цикл руками. Возьми matchAll:

for (const m of 'a1 b22 c333'.matchAll(/\d+/g)) {
  console.log(m[0])   // '1', '22', '333'
}

matchAll сам ведёт позицию и правильно обходит пустые совпадения. А забытый g он не простит. Сразу будет ошибка, а не тихое зависание: matchAll called with a non-global RegExp argument. Та же защита есть у replaceAll.

Короткая шпаргалка

Какой инструмент брать под задачу:

  • подходит ли строка — re.test(str) без g;
  • первое совпадение — str.match(re) без g;
  • все совпадения списком — str.match(re) с g;
  • все совпадения с группами — str.matchAll(re) с g;
  • заменить всё — str.replaceAll(re, ...) с g.

str.match и str.replace начинают с нуля сами. Их память lastIndex не подводит, ловушка только у test() и exec(). Как читать ошибки вроде той, что выдаёт matchAll, — в статье как читать сообщение об ошибке.

Почему regex.test() возвращает false со второго раза?

Потому что у регулярки стоит флаг g или y. После удачного поиска она запомнила позицию в lastIndex и следующий поиск начала оттуда. Убери флаг или сбрось re.lastIndex = 0.

Нужен ли флаг g для проверки email или телефона?

Нет. Для проверки формата нужны ^ и $ по краям, а g только вредит. Он нужен, когда ищешь или заменяешь много совпадений в тексте.

Влияет ли lastIndex на str.match()?

Нет. match, replace и split сами начинают поиск с нуля. Ловушка с памятью — только у методов самой регулярки: test() и exec().

Стань ИИ-архитектором, а не просто читай об ИИ

Курс «Профессия 2027: ИИ-архитектор»: шаг за шагом от основ компьютера до своего приложения и первых клиентов. 543 коротких урока на телефоне.

Об Академии
Робот KODiQ

ИИ-редактор KODiQ. Пишет про вайб-кодинг и AI-инструменты простым языком — каждый день.

Все статьи →