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

Объект RegExp используется для сопоставления текста с шаблоном.

Для введения в регулярные выражения прочитайте главу Регулярные выражения в руководстве по JavaScript. Подробную информацию о синтаксисе регулярных выражений см. в справочнике по регулярным выражениям.

Описание

Буквальная нотация и конструктор

Существует два способа создания объекта RegExp: буквальная нотация и конструктор.

• Буквальная нотация принимает шаблон между двумя косыми чертами, за которыми следуют необязательные флаги после второй косой черты.
• Функция-конструктор принимает в качестве первого параметра строку или объект RegExp, а в качестве второго параметра — строку необязательных флагов.

Следующие три выражения создают один и тот же объект регулярного выражения:

const re = /ab+c/i; // literal notation
// OR
const re = new RegExp("ab+c", "i"); // constructor with string pattern as first argument
// OR
const re = new RegExp(/ab+c/, "i"); // constructor with regular expression literal as first argument

Перед использованием регулярных выражений их необходимо скомпилировать. Этот процесс позволяет им более эффективно выполнять сопоставления. Подробнее об этом процессе можно узнать в документации dotnet.

Буквальная нотация приводит к компиляции регулярного выражения при вычислении выражения. С другой стороны, конструктор объекта RegExp, new RegExp('ab+c'), приводит к компиляции регулярного выражения во время выполнения.

Используйте строку в качестве первого аргумента конструктора RegExp(), когда вы хотите создать регулярное выражение из динамических входных данных.

Флаги в конструкторе

Выражение new RegExp(/ab+c/, flags) создаст новый RegExp, используя исходный код первого параметра и флаги, предоставленные вторым.

При использовании функции-конструктора необходимы обычные правила экранирования строк (предшествование специальным символам с помощью \ при включении в строку).

Например, следующее эквивалентно:

const re = /\w+/;
// OR
const re = new RegExp("\\w+");

Специальная обработка для регулярных выражений

Некоторые встроенные методы обрабатывают регулярные выражения особым образом. Они определяют, является ли x регулярным выражением, выполняя несколько шагов:

1. x должен быть объектом (не примитивом).
2. Если x[Symbol.match] не undefined, проверьте, является ли он истинным.
3. В противном случае, если x[Symbol.match] является undefined, проверьте, был ли x создан с помощью конструктора RegExp. (Этот шаг должен происходить редко, поскольку если x является объектом RegExp, который не был изменен, он должен иметь свойство Symbol.match.)

Обратите внимание, что в большинстве случаев проверка будет проходить через Symbol.match, что означает:

• Реальный объект RegExp, у которого значение свойства Symbol.match является ложным, но не undefined (даже при сохранении всего остального, такого как exec и [Symbol.replace]()), может использоваться так, как будто это не регулярное выражение.
• Не RegExp объект со свойством Symbol.match будет трактоваться как регулярное выражение.

Этот выбор был сделан потому, что [Symbol.match]() является наиболее показательным свойством, указывающим на намерение использовать что-либо для сопоставления. (exec также мог бы использоваться, но поскольку это не символьное свойство, было бы слишком много ложных срабатываний.) Места, которые особо обрабатывают регулярные выражения, включают:

• String.prototype.endsWith(), startsWith() и includes() выдают TypeError, если первый аргумент является регулярным выражением.
• String.prototype.matchAll() и replaceAll() проверяют, установлен ли флаг глобальный, если первый аргумент является регулярным выражением, перед вызовом его метода [Symbol.matchAll]() или [Symbol.replace]().
• Конструктор RegExp() напрямую возвращает аргумент pattern только в том случае, если pattern является регулярным выражением (среди нескольких других условий). Если pattern является регулярным выражением, он также будет анализировать свойства pattern source и flags вместо приведения pattern к строке.

Например, String.prototype.endsWith() преобразует все входные данные в строки, но выдаст ошибку, если аргумент является регулярным выражением, поскольку он предназначен только для сопоставления строк, а использование регулярного выражения, вероятно, является ошибкой разработчика.

"foobar".endsWith({ toString: () => "bar" }); // true
"foobar".endsWith(/bar/); // TypeError: First argument to String.prototype.endsWith must not be a regular expression

Вы можете обойти проверку, установив [Symbol.match] в ложное значение, которое не является undefined. Это будет означать, что регулярное выражение не может быть использовано для String.prototype.match() (поскольку без [Symbol.match] match() создаст новый объект RegExp с двумя окружающими косыми чертами, добавленными re.toString()), но оно может быть использовано практически для всего остального.

const re = /bar/g;
re[Symbol.match] = false;
"/bar/g".endsWith(re); // true
re.exec("bar"); // [ 'bar', index: 0, input: 'bar', groups: undefined ]
"bar & bar".replace(re, "foo"); // 'foo & foo'

Свойства RegExp в стиле Perl

Обратите внимание, что несколько свойств RegExp имеют как длинные, так и короткие (в стиле Perl) имена. Оба имени всегда ссылаются на одно и то же значение. (Perl — это язык программирования, по образцу которого JavaScript создал свои регулярные выражения.) См. также устаревшие свойства RegExp.

Конструктор

RegExp()

Создает новый объект RegExp.

Статические свойства

RegExp.$1, …, RegExp.$9 Устарело

Статические свойства только для чтения, содержащие заключенные в скобки сопоставления подстрок.

RegExp.input ($_) Устарело

Статическое свойство, содержащее последнюю строку, с которой успешно сопоставилось регулярное выражение.

RegExp.lastMatch ($&) Устарело

Статическое свойство только для чтения, содержащее последнюю сопоставленную подстроку.

RegExp.lastParen ($+) Устарело

Статическое свойство только для чтения, содержащее последнее сопоставленное подстрока в скобках.

RegExp.leftContext ($`) Устарело

Статическое свойство только для чтения, содержащее подстроку, предшествующую последнему сопоставлению.

RegExp.rightContext ($') Устарело

Статическое свойство только для чтения, содержащее подстроку, следующую за последним сопоставлением.

RegExp[Symbol.species]

Конструктор, используемый для создания производных объектов.

Статические методы

RegExp.escape()

Экранирует любые потенциальные синтаксические символы регулярных выражений в строке и возвращает новую строку, которую можно безопасно использовать в качестве буквального шаблона для конструктора RegExp().

Свойства экземпляра

Эти свойства определены на RegExp.prototype и разделяются всеми экземплярами RegExp.

RegExp.prototype.constructor

Функция-конструктор, создавшая объект экземпляра. Для экземпляров RegExp начальное значение — конструктор RegExp.

RegExp.prototype.dotAll

Сопоставляет ли . символы новой строки или нет.

RegExp.prototype.flags

Строка, содержащая флаги объекта RegExp.

RegExp.prototype.global

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

RegExp.prototype.hasIndices

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

RegExp.prototype.ignoreCase

Игнорировать ли регистр при попытке сопоставления в строке.

RegExp.prototype.multiline

Искать ли в строках на нескольких строках.

RegExp.prototype.source

Текст шаблона.

RegExp.prototype.sticky

Является ли поиск липким.

RegExp.prototype.unicode

Включены ли функции Unicode.

RegExp.prototype.unicodeSets

Включен ли флаг v, являющийся обновлением режима u.

Эти свойства являются собственными свойствами каждого экземпляра RegExp.

lastIndex

Индекс, с которого начнется следующее сопоставление.

Методы экземпляра

RegExp.prototype.compile() Устарело

(Пере-)компилирует регулярное выражение во время выполнения скрипта.

RegExp.prototype.exec()

Выполняет поиск совпадения в строковом параметре.

RegExp.prototype.test()

Тестирует наличие совпадения в строковом параметре.

RegExp.prototype.toString()

Возвращает строковое представление указанного объекта. Переопределяет метод Object.prototype.toString().

RegExp.prototype[Symbol.match]()

Выполняет сопоставление с заданной строкой и возвращает результат сопоставления.

RegExp.prototype[Symbol.matchAll]()

Возвращает все совпадения регулярного выражения со строкой.

RegExp.prototype[Symbol.replace]()

Заменяет совпадения в заданной строке новой подстрокой.

RegExp.prototype[Symbol.search]()

Ищет совпадение в заданной строке и возвращает индекс найденного шаблона в строке.

RegExp.prototype[Symbol.split]()

Разделяет заданную строку на массив, разбивая строку на подстроки.

Примеры

Использование регулярного выражения для изменения формата данных

Следующий скрипт использует метод String.prototype.replace() для сопоставления имени в формате "имя фамилия" и вывода его в формате "фамилия, имя".

В тексте замены скрипт использует $1 и $2 для указания результатов соответствующих скобок в шаблоне регулярного выражения.

const re = /(\w+)\s(\w+)/;
const str = "Maria Cruz";
const newStr = str.replace(re, "$2, $1");
console.log(newStr);

Это выводит "Cruz, Maria".

Использование регулярного выражения для разделения строк с различными окончаниями строк/концами строк/переводами строк

Стандартное окончание строки зависит от платформы (Unix, Windows и т. д.). Разделение строк, представленное в этом примере, работает на всех платформах.

const text = "Some text\nAnd some more\r\nAnd yet\nThis is the end";
const lines = text.split(/\r?\n/);
console.log(lines); // [ 'Some text', 'And some more', 'And yet', 'This is the end' ]

Обратите внимание, что порядок шаблонов в регулярном выражении имеет значение.

Использование регулярного выражения на нескольких строках

По умолчанию символ . не сопоставляется с символами новой строки. Чтобы он сопоставлялся с символами новой строки, используйте флаг s (режим dotAll).

const s = "Please yes\nmake my day!";

s.match(/yes.*day/);
// Returns null

s.match(/yes.*day/s);
// Returns ["yes\nmake my day"]

Использование регулярного выражения с флагом "sticky"

Флаг sticky указывает, что регулярное выражение выполняет "липкое" сопоставление в целевой строке, пытаясь сопоставить, начиная с RegExp.prototype.lastIndex.

const str = "#foo#";
const regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex is taken into account with sticky flag)
regex.lastIndex; // 0 (reset after match failure)

Разница между флагом "sticky" и флагом "global"

С флагом "sticky" y следующее совпадение должно произойти в позиции lastIndex, в то время как с флагом "global" g совпадение может произойти в позиции lastIndex или позже:

const re = /\d/y;
let r;
while ((r = re.exec("123 456"))) {
  console.log(r, "AND re.lastIndex", re.lastIndex);
}

// [ '1', index: 0, input: '123 456', groups: undefined ] AND re.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] AND re.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] AND re.lastIndex 3
//  … and no more match.

С флагом "global" g будут сопоставлены все 6 цифр, а не только 3.

Регулярные выражения и символы Unicode

\w и \W сопоставляют только символы на основе ASCII; например, a до z, A до Z, 0 до 9 и _.

Чтобы сопоставлять символы из других языков, таких как кириллица или иврит, используйте \uHHHH, где HHHH — это шестнадцатеричное значение Unicode символа.

Этот пример демонстрирует, как можно выделить символы Unicode из слова.

const text = "Образец text на русском языке";
const regex = /[\u0400-\u04ff]+/g;

const match = regex.exec(text);
console.log(match[0]); // 'Образец'
console.log(regex.lastIndex); // 7

const match2 = regex.exec(text);
console.log(match2[0]); // 'на' (did not log 'text')
console.log(regex.lastIndex); // 15

// and so on

Функция экранирования свойств Unicode предоставляет более простой способ нацеливания на определенные диапазоны Unicode, позволяя использовать такие выражения, как \p{scx=Cyrl} (для сопоставления любой кириллической буквы) или \p{L}/u (для сопоставления буквы из любого языка).

Извлечение имени поддомена из URL

const url = "http://xxx.example.com";
console.log(/^https?:\/\/(.+?)\./.exec(url)[1]); // 'xxx'

Создание регулярного выражения из динамических входных данных

const breakfasts = ["bacon", "eggs", "oatmeal", "toast", "cereal"];
const order = "Let me get some bacon and eggs, please";

order.match(new RegExp(`\\b(${breakfasts.join("|")})\\b`, "g"));
// Returns ['bacon', 'eggs']

Спецификации

Совместимость с браузерами

Примечания, специфичные для Firefox

Начиная с Firefox 34, в случае захватывающей группы с квантификаторами, препятствующими ее выполнению, сопоставленный текст для захватывающей группы теперь undefined вместо пустой строки:

// Firefox 33 or older
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${JSON.stringify(group)}`);
});
// group: ""

// Firefox 34 or newer
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${group}`);
});
// group: undefined

Обратите внимание, что из-за совместимости с веб-браузерами RegExp.$N по-прежнему будет возвращать пустую строку вместо undefined (bug 1053944).

См. также

• Polyfill многих современных RegExp функций (dotAll, sticky флаги, именованные группы захвата и т. д.) в core-js
• Руководство по регулярным выражениям
• Регулярные выражения
• String.prototype.match()
• String.prototype.replace()
• String.prototype.split()