RegExp
======

Сводка
------

Конструктор **`RegExp`** создаёт объект регулярного выражения для сопоставления текста с шаблоном.

Введение в то, что представляют собой регулярные выражения, читайте в главе «Регулярные выражения» в руководстве по JavaScript.

Интерактивный пример
--------------------

Синтаксис
---------

Возможны как литеральная запись, так и запись через конструктор:
```

/pattern/flags
new RegExp(pattern, flags)
```

### Параметры

`pattern`

Текст регулярного выражения.

`flags`

Если определён, может принимать любую комбинацию нижеследующих значений:

`g`

глобальное сопоставление

`i`

игнорирование регистра при сопоставлении

`m`

сопоставление по нескольким строкам; символы начала и конца (^ и $) начинают работать по нескольким строкам (то есть, происходит сопоставление с началом или концом *каждой* строки (строки разделяются символами \n или \r), а не только с началом или концом всей вводимой строки)

`y` 
Экспериментальная возможность

«липкий» поиск; сопоставление в целевой строке начинается с индекса, на который указывает свойство `lastIndex` этого регулярного выражения (и не пытается сопоставиться с любого более позднего индекса).


Описание
--------

Существует два способа создания объекта `RegExp`: литеральная запись и использование конструктора. При записи строк параметры в литеральной записи не используют символы кавычек, в то время как параметры функции-конструктора используют кавычки. Так что следующие выражения создают одинаковые регулярные выражения:


```js
/ab+c/i;
new RegExp("ab+c", "i");
```


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

Конструктор объекта регулярного выражения, например, `new RegExp('ab+c')`, обеспечивает компиляцию регулярного выражения во время выполнения. Используйте функцию-конструктор, если вы знаете, что шаблон регулярного выражения будет меняться или если вы не знаете шаблон и получаете его из внешних источников, например, из пользовательского ввода.

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


```js
var re = /\w+/;
var re = new RegExp("\\w+");
```

Значение специальных символов в регулярных выражениях
-----------------------------------------------------

* Символьные классы
* Наборы символов
* Границы
* Группировка и обратные ссылки
* Квантификаторы

| Символьные классы |
| --- |
| Символ | Значение |
| `.` | 
 (Точка, десятичная запятая) сопоставляется с любым символом
 *за исключением* символов новой строки: `\n`,
 `\r`, `\u2028` или `\u2029`.


 Обратите внимание, что флаг многострочности `m` не изменяет
 поведение точки. Так что для сопоставления с шаблона с несколькими
 строками используйте набор символов `[^]` (конечно, если
 только вам не нужно поддерживать старые версии IE), он сопоставляется
 с любым символом, включая символы новой строки.


 Например, шаблон `/.н/` сопоставляется с подстрокой «ан»,
 но не подстрокой «ну», во фразе «ну что, потанцуем».
  |
| `\d` | 
 Сопоставляется с символом цифры в базовом латинском алфавите.
 Эквивалентен набору символов `[0-9]`.


 Например, шаблоны `/\d/` и
 `/[0-9]/` сопоставляются с подстрокой «2» в строке «B2 —
 это номер люкс».
  |
| `\D` | 
 Сопоставляется с любым символом, который не является цифрой в базовом
 латинском алфавите. Эквивалентен набору символов `[^0-9]`.


 Например, шаблоны `/\D/` и
 `/[^0-9]/` сопоставляются с подстрокой «B» в строке «B2 —
 это номер люкс».
  |
| `\w` | 
 Сопоставляется с любым алфавитно-цифровым символом из базового
 латинского алфавита, включая символ подчёркивания. Эквивалентен набору
 символов `[A-Za-z0-9_]`.


 Например, шаблон `/\w/` сопоставляется с подстрокой «a» в
 строке «apple», с подстрокой «5» в строке «$5.28» и с подстрокой «3» в
 строке «3D».
  |
| `\W` | 
 Сопоставляется с любым символом из базового латинского алфавита, не
 являющимся символом, из которых состоят слова. Эквивалентен набору
 символов `[^A-Za-z0-9_]`.


 Например, шаблоны `/\W/` и
 `/[^A-Za-z0-9_]/` сопоставляются с подстрокой «%» в строке
 «50%».
  |
| `\s` | 
 Сопоставляется с одиночным пробельным символом, который включает в
 себя пробел, табуляцию, подачу страницы, перевод строки и другие
 пробельные символы Юникода. Эквивалентен набору символов
 `[
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.


 Например, шаблон `/\s\w*/` сопоставляется с подстрокой «
 bar» в строке «foo bar».
  |
| `\S` | 
 Сопоставляется с одиночным символом, не являющимся пробельным.
 Эквивалентен набору символов
 `[^
\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]`.


 Например, шаблон `/\S\w*/` сопоставляется с подстрокой
 «foo» в строке «foo bar».
  |
| `\t` | Сопоставляется с символом табуляции. |
| `\r` | Сопоставляется с символом возврата каретки. |
| `\n` | Сопоставляется с символом перевода строки. |
| `\v` | Сопоставляется с символом вертикальной табуляции. |
| `\f` | Сопоставляется с символом подачи страницы. |
| `[\b]` | 
 Сопоставляется с символом забоя (не перепутайте его с символьным классом
 `\b`).
  |
| `\0` | Сопоставляется с нулевым символом. Не ставьте за ним другую цифру. |
| `\c*X*` | 
 Где `*X*` является буквой от «A» до «Z».
 Сопоставляется с управляющим символом в строке.


 Например, шаблон `/\cM/` сопоставляется с символом
 control-M в строке.
  |
| `\x*hh*` | 
 Сопоставляется с символом с кодом `*hh*` (две
 шестнадцатеричные цифры).
  |
| `\u*hhhh*` | 
 Сопоставляется с символом со значением Юникода
 `*hhhh*` (четыре шестнадцатеричные цифры).
  |
| `\` | 
 Для символов, которые обычно трактуются буквально, указывает, что
 следующий символ является специальным и не должен интерпретироваться
 буквально.


 Например, шаблон `/b/` сопоставляется с символом «b».
 Поместив перед ним символ обратного слеша, то есть превратив шаблон в
 `/\b/`, символ приобретёт специальное значение,
 обозначающее сопоставление с границей слова.

*или*

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


 Например, звёздочка «\*» является специальным символом, обозначающим
 ноль или более вхождений предшествующего символа при сопоставлении;
 поэтому шаблон `/a*/` означает сопоставление с нулём или
 более символов «a». Для буквального сопоставления со звёздочкой
 `*` предварите её символом обратного слеша; например,
 шаблон `/a\*/` сопоставляется со строкой «a\*».
  |
| Наборы символов |
| --- |
| Символ | Значение |
| `[xyz]` | 
 Набор символов. Сопоставляется с любым из заключённых в квадратные
 скобки символов. С помощью дефиса вы можете определить диапазон
 символов.


 Например, шаблон `[абвгд]` означает тоже самое, что и
 шаблон `[а-д]`. Они сопоставляются с символом «г» в слове
 «грудинка» и символом «б» в слове «отбивная».
  |
| `[^xyz]` | 
 Отрицательный или дополнительный набор символов. То есть он
 сопоставляется со всеми символами, что не заключены в квадратные
 скобки. С помощью дефиса вы можете определить диапазон символов.


 Например, шаблон `[^абвгд]` означает тоже самое, что и
 шаблон `[^а-д]`. Они сопоставляются с символом «е» в слове
 «бекон» и символом «о» в слове «отбивная».
  |
| Границы |
| --- |
| Символ | Значение |
| `^` | 
 Сопоставляется c началом ввода. Если установлен флаг многострочности,
 также сопоставляется с позицией сразу за символом переноса строки.


 Например, шаблон `/^Б/` не сопоставляется с буквой «Б» в
 строке «буква Б», но сопоставляется с первой буквой «Б» в строке
 «Буква Б».
  |
| `$` | 
 Сопоставляется c концом ввода. Если установлен флаг многострочности,
 также сопоставляется с позицией сразу перед символом переноса строки.


 Например, шаблон `/т$/` не сопоставляется с буквой «т» в
 слове «кормить», но сопоставляется с ней в слове «кормит».
  |
| `\b` | 
 Сопоставляется с границей слова нулевой ширины, например с позицией
 между буквой и пробелом (не путайте его с набором символов
 `[\b]`).


 Например, шаблон `/\bпол/` сопоставляется с подстрокой
 «пол» в строке «в полдень»; шаблон `/но\b/` сопоставляется
 с подстрокой «но» в строке «возможно завтра».
  |
| `\B` | 
 Сопоставляется с границей не-слов нулевой ширины, например с позицией
 между двумя буквами или двумя пробелами.


 Например, шаблон `/\Bдень/` сопоставляется с подстрокой
 «день» в строке «в полдень»; шаблон `/за\B/` сопоставляется
 с подстрокой «за» в строке «возможно завтра».
  |
| Группировка и обратные ссылки |
| --- |
| Символ | Значение |
| `(*x*)` | 
 Сопоставляется с `*x*` и запоминает сопоставление.
 Называется «захватывающие скобки».


 Например, шаблон `/(foo)/` сопоставляется с подстрокой
 «foo» и запоминает её в строке «foo bar». Сопоставленную подстроку
 можно достать из элементов `[1], ..., [n]` результирующего
 массива или из предопределённых свойств
 `$1, ..., $9` объекта `RegExp`.


 Захват групп ведёт к проседанию производительности. Если вам не нужно
 повторно ссылаться на захваченную подстроку, лучше использовать скобки
 без захвата (смотрите ниже).
  |
| `\*n*` | 
 Где `*n*` является целым положительным числом.
 Обратная ссылка на последнюю сопоставившуюся подстроку в
 *n*-ных по счёту круглых скобках в регулярном выражении
 (нумерация скобок идёт слева направо).


 Например, шаблон `/яблоко(,)\sапельсин\1/` сопоставится
 подстроке «яблоко, апельсин,» в строке «яблоко, апельсин, вишня,
 персик». Более подробный пример смотрите после этой таблицы.
  |
| `(?:*x*)` | 
 Сопоставляется с `*x*`, но не запоминает сопоставление. Называется «незахватывающие скобки».
 Сопоставленную подстроку нельзя достать из элементов
 `[1], ..., [n]` результирующего массива или из
 предопределённых свойств `$1, ..., $9` объекта
 `RegExp`.
  |
| Квантификаторы |
| --- |
| Символ | Значение |
| `*x**` | 
 Сопоставляется с предшествующим элементом *x* ноль или более
 раз.


 Например, шаблон `/ела*/` сопоставляется с подстрокой «ел»
 в строке «Призрак просвистел» и подстрокой «ела» в строке «Птица
 пропела», но ни с чем не сопоставится в строке «Козёл хмыкнул».
  |
| `*x*+` | 
 Сопоставляется с предшествующим элементом *x* один или более
 раз. Эквивалентен квантификатору `{1,}`.


 Например, шаблон `/о+/` сопоставляется с символом «о» в
 строке «конфета» и со всеми символами «о» в строке «коооооонфета».
  |
| `*x**?``*x*+?` | 
 Сопоставляется с предшествующим элементом *x* подобно
 квантификаторам `*` и `+`, описанным выше,
 однако ищет минимально возможное сопоставление.


 Например, шаблон `/".*?"/` сопоставляется с подстрокой
 «"foo"» в строке «"foo" "bar"» и не сопоставляется со строкой «"foo"
 "bar"», поскольку за звёздочкой `*` следует символ вопроса
 `?`.
  |
| `*x*?` | 
 Сопоставляется с предшествующим элементом *x* ноль или один
 раз.


 Например, шаблон `/о?то?/` сопоставляется с подстрокой «от»
 в строке «кот» и подстрокой «то» в строке «ток».


 Если символ используется сразу после какого-то из квантификаторов
 `*`, `+`, `?`, или `{}`,
 то он делает этот квантификатор «нежадным» (сопоставление происходит
 минимально возможное количество раз), в противоположность «жадному»
 поведению квантификатора по умолчанию (сопоставление происходит
 максимально возможное количество раз).


 Также символ используется в квантификаторах предпросмотра
 `(?=)`, `(?!)` и `(?:)`, также
 описанных в этой таблице.
  |
| `*x*(?=*y*)` | 
 Сопоставляется с `*x*`, только если за `*x*` следует `*y*`. Например, шаблон `/Джек(?=Шпрот)/` сопоставляется со
 строкой «Джек» только если за ней следует строка «Шпрот». Шаблон
 `/Джек(?=Шпрот|Мороз)/` сопоставляется со строкой «Джек»
 только если за ней следуют строки «Шпрот» или «Мороз». Однако, ни
 «Шпрот», ни «Мороз» не являются частью результата сопоставления.
  |
| `*x*(?!*y*)` | 
 Сопоставляется с `*x*`, только если за `*x*` не следует
 `*y*`. Например, шаблон `/\d+(?!\.)/` сопоставляется с числом
 только если за ним не следует десятичная запятая.


 Выражение `/\d+(?!\.)/.exec('3.141')` сопоставится с «141»
 но не с «3.141».
  |
| `(?<=*y*)*x*` | 
`Сопоставляется с
*x*`, только если `*x*` предшествует
 `*y*`

 Например, /`(?<=Пётр)Иванов/` сопоставится с "Иванов"
 только если ему будет предшествовать "Петр".`/(?<=Пётр|Владислав)Иванов/`
 сопоставится с "Иванов" только если ему будет предшествовать "Пётр"
 или "Владислав".В любом случае, ни "Пётр" ни "Владислав" не
 войдут в результат сопоставления.
  |
| `(?<!*y*)*x*` | 

|  |
| --- |
| 
`Сопоставляется с
*x*`, только если `*x*` не предшествует
 `*y*`

 Например, `/(?<!-)\d+/` сопоставится с цифрой,
 только если ей не предшествует минус.`/(?<!-)\d+/.exec('3')`
 вернёт "3".`/(?<!-)\d+/.exec('-3')` не
 сопоставится с цифрой, тк цифре перед цифрой 3 присутствует
 минус.
  |

 |
| `*x*|*y*` | Сопоставляется либо с `*x*`, либо с `*y*`.

 Например, шаблон `/зелёное|красное/` сопоставится с
 подстрокой «зелёное» в строке «зелёное яблоко» и подстрокой «красное»
 в строке «красное яблоко».
  |
| `*x*{*n*}` | 
 Где `*n*` является целым положительным числом.
 Сопоставляется точно с `*n*` вхождениями
 предшествующего элемента *x*.


 Например, шаблон `/о{2}/` не сопоставится с символом «о» в
 слове «конфета», но сопоставится со всеми символами «о» в слове
 «коонфета» и с первыми двумя символами «о» в слове «кооонфета».
  |
| `*x*{*n*,}` | 
 Где `*n*` является целым положительным числом.
 Сопоставляется по крайней мере с `*n*` вхождениями
 предшествующего элемента *x*.


 Например, шаблон `/о{2,}/` не сопоставится с символом «о» в
 слове «конфета», но сопоставится со всеми символами «о» в словах
 «коонфета» и даже в «кооооооонфета».
  |
| `*x*{*n*,*m*}` | 
 Где `*n*` и `*m*` являются целыми
 положительными числами. Сопоставляется по крайней мере с
 `*n*` но не более, чем с
 `*m*` вхождениями предшествующего элемента
 *x*.


 Например, шаблон `/о{1,3}/` ни с чем не сопоставится в
 слове «кнфета», с символом «о» в слове «конфета», с двумя символами
 «о» в слове «коонфета» и с первыми тремя символами «о» в слове
 «кооооооонфета». Обратите внимание, что при сопоставлении со словом
 «кооооооонфета» сопоставимость только подстрока «ооо», хотя слово
 содержало гораздо больше символов «о».
  |

Свойства
--------

`RegExp.prototype` (en-US)

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

`RegExp.length`

Значение `RegExp.length` равно 2.

Методы
------

Глобальный объект `RegExp` не имеет собственных методов, однако, он наследует некоторые методы через цепочку прототипов.

Экземпляры регулярного выражения
--------------------------------

### Свойства

{{page('/ru/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Properties')}}### Методы

{{page('/ru/docs/Web/JavaScript/Reference/Global\_Objects/RegExp/prototype', 'Methods')}}Примеры
-------

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

Следующий скрипт использует метод `replace()` экземпляра строки `String` для сопоставления с именем в формате *имя фамилия* и выводит его в формате *фамилия, имя*. В тесте замены скрипт использует заменители `$1` и `$2`, которые заменяются на результаты соответствующих сопоставившихся подгрупп регулярного выражения.


```js
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);

// пример с русскими буквами
var re = /([а-яё]+)\s([а-яё]+)/i;
var str = "Джон Смит";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);
```


Пример выведет «Smith, John» и «Смит, Джон»

### Пример: использование регулярного выражения для разбиения строк с различными символами конца строки

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


```js
var text = "Некоторый текст\nЕщё текст\r\nИ ещё\rЭто конец";
var lines = text.split(/\r\n|\r|\n/);
console.log(lines); // выведет [ 'Некоторый текст', 'Ещё текст', 'И ещё', 'Это конец' ]
```


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

### Пример: использование регулярных выражений на нескольких строках


```js
var s = "Please yes\nmake my day!";
s.match(/yes.\*day/);
// Вернёт null
s.match(/yes[^]\*day/);
// Вернёт 'yes\nmake my day'
```

### Пример: использование регулярных выражений с флагом «липучести»

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


```js
var text = "Первая строка\nВторая строка";
var regex = /(\S+) строка\n?/y;

var match = regex.exec(text);
console.log(match[1]); // напечатает 'Первая'
console.log(regex.lastIndex); // напечатает '14'

var match2 = regex.exec(text);
console.log(match2[1]); // напечатает 'Вторая'
console.log(regex.lastIndex); // напечатает '27'

var match3 = regex.exec(text);
console.log(match3 === null); // напечатает 'true'
```


Во время выполнения можно проверить, поддерживается ли флаг «липучести», при помощи блока `try { … } catch { … }`. Для этого надо использовать либо выражение с `eval(…)`, либо конструктор `RegExp(строка-регулярки, строка-с-флагами)` (поскольку нотация `/регулярка/флаги` обрабатывается во время компиляции, исключение будет выброшено до того, как выполнение достигнет блока `catch`). Например:


```js
var supports_sticky;
try {
  RegExp("", "y");
  supports_sticky = true;
} catch (e) {
  supports_sticky = false;
}
console.log(supports_sticky); // напечатает 'true'
```

### Пример: регулярные выражения и символы Юникода

Как уже сказано выше, символьные классы `\w` и `\W` сопоставляются только с базовыми символами ASCII; то есть, с символами от «a» до «z», от «A» до «Z», от «0» до «9» и символом «\_». Для сопоставления с символами из других языков, например, с кириллическими или иврита, используйте форму `\uhhhh`, где «hhhh» — это значение символа Юникода, записанное в шестнадцатеричной форме. Этот пример демонстрирует, как можно выделить символы Юникода, составляющие слова.


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

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

var match2 = regex.exec(text);
console.log(match2[0]); // напечатает 'на' [не 'text']
console.log(regex.lastIndex); // напечатает '15'

// и так далее
```


Вот на этом внешнем ресурсе можно составить полный диапазон блоков Юникода для различных письменностей: regexp-unicode-block.

### Пример: извлечение имени поддомена из URL


```js
var url = "http://xxx.domain.com";
console.log(/[^.]+/.exec(url)[0].substr(7)); // напечатает 'xxx'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-regular-expression-objects |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

### Примечания по Gecko

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


```js
// Firefox 33 или более ранние
"x".replace(/x(.)?/g, function (m, group) {
  console.log("'group:" + group + "'");
}); // 'group:'

// Firefox 34 или более новые
"x".replace(/x(.)?/g, function (m, group) {
  console.log("'group:" + group + "'");
}); // 'group:undefined'
```


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

Смотрите также
--------------

* Глава про регулярные выражения в руководстве по JavaScript
* `String.prototype.match()`
* `String.prototype.replace()`