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

Зачем это нужно

Методы строк (includes, indexOf, split) ищут конкретный текст. Но часто нужно найти текст определённого вида: «шесть цифр подряд», «слово после #», «что-то похожее на email». Для этого есть регулярные выражения (regular expressions, коротко regex) — маленький язык шаблонов.

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

Как записать шаблон

Регулярное выражение пишут между двумя косыми чертами. Метод test отвечает, есть ли в строке совпадение:

const pattern = /кот/;
console.log(pattern.test("Мой кот спит"));
console.log(pattern.test("Моя собака спит"));

Вывод:

true
false

После второй черты пишут флаги: /кот/i — без учёта регистра, /кот/g — искать все совпадения, а не только первое.

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

Вместо конкретной буквы можно указать вид символа:

Шаблон	Что совпадает
\d	цифра 0–9
\w	латинская буква, цифра или _
\s	пробельный символ: пробел, табуляция, перенос строки
\D, \W, \S	наоборот: не цифра, не буква, не пробел
.	любой символ, кроме переноса строки
[abc]	один из символов a, b, c
[a-z], [0-9]	диапазон
[^0-9]	любой, кроме перечисленных

console.log(/\d\d:\d\d/.test("Встреча в 14:30"));
console.log(/[аеиоуыэюя]/i.test("ПРИВЕТ"));

Вывод:

true
true

Точка, скобки, +, ? и другие символы имеют особый смысл. Чтобы найти их буквально, перед ними ставят обратную косую черту: \. — именно точка, \( — именно скобка.

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

Шаблон	Сколько
a+	один или больше
a*	ноль или больше
a?	ноль или один (необязательно)
a{3}	ровно 3
a{2,4}	от 2 до 4
a{2,}	2 и больше

console.log("Цены: 5, 120 и 3500 сомони".match(/\d+/g));
console.log(/^colou?r$/.test("color"), /^colou?r$/.test("colour"));

Вывод:

["5","120","3500"]
true true

Начало и конец строки

^ означает начало строки, $ — конец. Без них шаблон ищет совпадение где угодно внутри строки — частая причина ошибок при проверке форм:

console.log(/\d{4}/.test("год 2026!"));     // четыре цифры где-то внутри
console.log(/^\d{4}$/.test("год 2026!"));   // строка целиком из четырёх цифр
console.log(/^\d{4}$/.test("2026"));

Вывод:

true
false
true

Группы и «или»

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

console.log(/^(ha)+$/.test("hahaha"));
console.log(/^(cat|dog)s?$/.test("dogs"));

const m = "Дата: 2026-11-02".match(/(\d{4})-(\d{2})-(\d{2})/);
console.log(m[0]);            // всё совпадение
console.log(m[1], m[2], m[3]); // группы по порядку

Вывод:

true
true
2026-11-02
2026 11 02

Группам можно дать имена — тогда код читается лучше:

const { groups } = "2026-11-02".match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
console.log(groups.day + "." + groups.month + "." + groups.year);

Вывод:

02.11.2026

Методы: найти все совпадения

Метод	Что делает
regex.test(str)	есть ли совпадение → true / false
str.match(regex)	без g: первое совпадение с группами (или null); с g: массив всех совпадений
str.matchAll(regex)	все совпадения с группами (нужен флаг g)
str.replace(regex, замена)	заменить (все — с флагом g)
str.split(regex)	разбить по шаблону

matchAll перебирает все совпадения, и у каждого есть группы:

const text = "Аня: 5, Тимур: 4, Лола: 5";
for (const m of text.matchAll(/([А-Яа-яЁё]+): (\d)/g)) {
  console.log(m[1] + " получил(а) " + m[2]);
}

Вывод:

Аня получил(а) 5
Тимур получил(а) 4
Лола получил(а) 5

А чтобы получить массив, совпадения разворачивают через spread: [...text.matchAll(/…/g)].

Жадность

Квантификаторы + и * жадные: забирают как можно больше символов. Иногда это не то, что нужно:

const html = "<b>раз</b> и <b>два</b>";
console.log(html.match(/<b>.+<\/b>/)[0]);    // жадно: от первого <b> до последнего </b>
console.log(html.match(/<b>.+?<\/b>/)[0]);   // ? после + — как можно меньше

Вывод:

<b>раз</b> и <b>два</b>
<b>раз</b>

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

Замена

В replace можно подставлять группы: $1, $2… — или передать функцию, которая вернёт замену:

console.log("2026-11-02".replace(/(\d{4})-(\d{2})-(\d{2})/, "$3.$2.$1"));
console.log("   много    пробелов   ".trim().replace(/\s+/g, " "));
console.log("цена 100 и 250".replace(/\d+/g, (n) => n * 2));

Вывод:

02.11.2026
много пробелов
цена 200 и 500

И разбиение по шаблону — например, по запятым с любыми пробелами вокруг:

console.log("яблоки ,груши,  сливы".split(/\s*,\s*/));

Вывод:

["яблоки","груши","сливы"]

Как это работает внутри

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

Регулярное выражение с флагом g помнит, где остановилось (свойство lastIndex). Поэтому один и тот же объект /…/g при повторных вызовах test может давать разные ответы. Для проверок test флаг g не нужен.

Частые ошибки

1. Нет ^ и $ в проверке. /\d{6}/ пропустит "abc1234567xyz": шесть цифр там есть.
2. Неэкранированная точка. /a.b/ совпадёт и с "a-b". Буквальная точка — \..
3. Забытый флаг g. replace без g заменит только первое совпадение, а matchAll без g выбросит ошибку.
4. \w и кириллица. \w — только латиница, цифры и _. Для русских букв пиши [А-Яа-яЁё].
5. Слишком сложный шаблон. Если регулярка не помещается в голове — разбей задачу на шаги: сначала очистить строку, потом проверить.

Шпаргалка

Что	Как
Есть ли совпадение	/шаблон/.test(str)
Все совпадения	str.match(/шаблон/g)
С группами	[...str.matchAll(/(..)/g)]
Заменить все	str.replace(/шаблон/g, "новое")
Цифра, буква, пробел	\d, \w, \s
Не цифра	\D
Сколько раз	+, *, ?, {n}, {n,m}
Вся строка	^…$
Группа, «или»	(…), `a
Без регистра	флаг i