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

Содержание

Введение в регулярные выражения в JavaScript | by Victoria Likhanova | NOP::Nuances of Programming

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

Регулярные выражения — это не просто ещё одна часть языка JavaScript, вроде свойства или чего-то подобного. По сути, это небольшой самостоятельный язык, независимый от других. Ещё одно достоинство регулярных выражений: они крайне удобны, так как позволяют выполнять сложные манипуляции со строками и при этом экономить код.

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

Если с помощью JavaScript вы хотите создать регулярное выражение (описать шаблон), есть два способа это сделать.

Конструктор регулярных выражений

Первый способ — использование конструктора. Это громкое слово на самом деле означает функцию-конструктор объекта RegExp. Конструктор принимает два параметра. Первый — шаблон, который вы хотите описать. Это обязательный параметр. В конце концов, зачем вообще создавать регулярное выражение, если нет шаблона?

Второй параметр — строка с флагами (flags). Не волнуйтесь, скоро мы с ними познакомимся. Этот параметр необязательный. Стоит запомнить одно: после создания регулярного выражения флаги уже нельзя будет добавить или убрать. Поэтому, если хотите использовать флаг, добавьте его на этапе создания выражения.

// Синтаксис конструктора регулярных выражений
new RegExp(pattern[, flags])// Создание регулярного выражения
// с помощью конструктора
// без флагов
const myPattern = new RegExp('[a-z]')// Создание регулярного выражения
// с помощью конструктора
// с одним флагом
const myPattern = new RegExp('[a-z]', 'g')

Литерал регулярных выражений

Второй способ — использование литерала. Как и конструктор, литерал регулярных выражений состоит из двух частей. Первая часть — это описываемый шаблон. Он заключается в слэши (//). После закрывающего слэша идёт вторая часть — флаги. Они необязательны.

// Синтаксис литерала регулярных выражений
/pattern/flags// Создание регулярного выражения
// с помощью литерала
// без флагов
const myPattern = /[a-z]/// Создание регулярного выражения
// с помощью литерала
// с одним флагом
const myPattern = /[a-z]/g

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

Конструктор или литерал?

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

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

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

test()

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

// Синтаксис метода test()
// /шаблон/.test('проверяемый текст')
// Проверка строки,
// когда test() не находит совпадений
myPattern.test('There was a cat and dog in the house.')
// false
// Создание переменной,
// которой присваивается текст для проверки
const myString = 'The world of code.'
// Создание шаблона
const myPattern = /code/
// Проверка текста с помощью шаблона,
// когда test() находит совпадение
myPattern.test(myString)
// true

exec()

Ещё один метод, который можно использовать — exec(). Если есть совпадение, метод exec() возвращает массив. Массив содержит в себе информацию об используемом шаблоне, позиции, на которой было найдено совпадение, проверяемом тексте и наборах. Если совпадений нет, метод exec() возвращает null.

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

// Синтаксис метода exec()
// /шаблон/.exec('проверяемый текст')
// Создание строки для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование exec() для проверки текста,
// когда exec() находит совпадение
myPattern.exec(myString)
// [
//   'code',
//   index: 13,
//   input: 'The world of code is not full of code.',
//   groups: undefined
// ]
// Описание другого шаблона
const myPatternTwo = /JavaScript/// Использование exec() с новым шаблоном для новой проверки текста,
// когда exec() не находит совпадений
myPatternTwo.exec(myString)
// null

test() и exec() — не единственные методы, которые можно использовать для поиска совпадений строки с шаблоном. Есть ещё search(), match() и matchAll(). Эти методы принадлежат не объекту RegExp, а строкам. Несмотря на это, они позволяют применять регулярные выражения.

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

search()

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

// Синтаксис метода search()
// 'проверяемый текст'.search(/шаблон/)
// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование search() для поиска
//совпадения строки с шаблоном,
//когда search() находит совпадение
myString.search(myPattern)
// -13
// Вызов search() прямо на строке,
// когда search() не находит совпадений
'Another day in the life.'.search(myPattern)
// -1

match()

match() — второй метод объекта String, который позволяет использовать регулярные выражения. Он работает аналогично exec(): при нахождении совпадения метод match() возвращает массив с информацией об использованном шаблоне, позиции в строке, на которой было найдено совпадение, проверяемом тексте и наборах.

Так же как и exec(), match() возвращает null при отсутствии совпадений. При использовании метода match() с флагом g для поиска всех совпадений с шаблоном возвращается массив из всех совпадений.

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)
// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [
//   'code',
//   index: 13,
//   input: 'The world of code is not full of code.',
//   groups: undefined
// ]'Another day in the life.'.match(myPattern)
// null
// Использование match() для поиска всех совпадений
// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/g // добавление флага 'g'// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [ 'code', 'code' ]

matchAll()

Подобно методу match(), matchAll() возвращает все совпадения при использовании флага g в шаблоне. Однако работает он по-другому. Метод matchAll() возвращает объект RegExp String Iterator. Есть несколько способов извлечь из него все совпадения.

Во-первых, можно пройтись по объекту циклом for…of и вернуть или записать все совпадения. Также можно использовать Array.from(), чтобы создать массив из содержимого объекта, или оператор spread, который даст точно такой же результат, как и Array.from().

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/g
// Обратите внимание, что используется флаг 'g'// Использование matchAll() для поиска совпадений в тексте
const matches = myString.matchAll(myPattern)// Использование цикла for...of для получения всех совпадений
for (const match of matches) {
console.log(match)
}
// [
//   [
//     'code',
//     index: 13,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ],
//   [
//     'code',
//     index: 33,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ]
// ]
// Использование Array.from() для получения всех совпадений
const matches = Array.from(myString.matchAll(myPattern))
// [
//   [
//     'code',
//     index: 13,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ],
//   [
//     'code',
//     index: 33,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ]
// ]// Использование оператора spread для получения всех совпадений
const matches = [...myString.matchAll(myPattern)]
// [
//   [
//     'code',
//     index: 13,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ],
//   [
//     'code',
//     index: 33,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ]
// ]

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

// Создание простого шаблона
// с использованием литерала регулярного выражения
const myPattern = /JavaScript/// Проверка строки на совпадения с шаблоном
myPattern.test('One of the most popular languages is also JavaScript.')
// true// Проверка строки на совпадения с шаблоном
myPattern.test('What happens if you combine Java with scripting?')
// false

До сих пор мы использовали регулярные выражения из простых шаблонов.\t\r\n\v\f]).

Примеры:

// . - любой символ, кроме первой строки
const myPattern = /./console.log(myPattern.test(''))
// falseconsole.log(myPattern.test('word'))
// trueconsole.log(myPattern.test('9'))
// true
// \d - одноразрядное число
const myPattern = /\d/console.log(myPattern.test('3'))
// trueconsole.log(myPattern.test('word'))
// false
// \w - отдельный буквенно-числовой словообразующий символ
const myPattern = /\w/console.log(myPattern.test(''))
// falseconsole.log(myPattern.test('word'))
// trueconsole.log(myPattern.test('9'))
// true
// \s - отдельный символ разделителя
const myPattern = /\s/console.log(myPattern.test(''))
// falseconsole.log(myPattern.test(' '))
// trueconsole.log(myPattern.test('foo'))
// false
// \D - отдельный нечисловой символ
const myPattern = /\D/console.log(myPattern.test('Worm'))
// trueconsole.log(myPattern.test('1'))
// false
// \W - отдельный несловообразующий символ
const myPattern = /\W/console.log(myPattern.test('Worm'))
// falseconsole.log(myPattern.test('1'))
// falseconsole.log(myPattern.test('*'))
// trueconsole.log(myPattern.test(' '))
// true
// \S - отдельный символ, который не является разделителем
const myPattern = /\S/console.log(myPattern.test('clap'))
// trueconsole.log(myPattern.test(''))
// falseconsole.log(myPattern.test('-'))
// true

Операторы контроля

Ещё один вид специальных символов — это операторы контроля. Такие символы позволяют описывать шаблоны с границами, то есть указывать, где начинается или заканчивается слово или строка. С помощью операторов контроля также можно создавать более сложные шаблоны, такие как опережающие проверки, ретроспективные проверки и условные выражения.re/console.log(myPattern.test(‘write’))
// falseconsole.log(myPattern.test(‘read’))
// trueconsole.log(myPattern.test(‘real’))
// trueconsole.log(myPattern.test(‘free’))
// false
// $ — Конец строки
const myPattern = /ne$/console.log(myPattern.test(‘all is done’))
// trueconsole.log(myPattern.test(‘on the phone’))
// trueconsole.log(myPattern.test(‘in Rome’))
// falseconsole.log(myPattern.test(‘Buy toner’))
// false
// \b — Граница слова
const myPattern = /\bro/console.log(myPattern.test(‘road’))
// trueconsole.log(myPattern.test(‘steep’))
// falseconsole.log(myPattern.test(‘umbro’))
// false// Или
const myPattern = /\btea\b/console.log(myPattern.test(‘tea’))
// trueconsole.log(myPattern.test(‘steap’))
// falseconsole.log(myPattern.test(‘tear’))
// false
// \B — Несловообразующая граница
const myPattern = /\Btea\B/console.log(myPattern.test(‘tea’))
// falseconsole.log(myPattern.test(‘steap’))
// trueconsole.log(myPattern.test(‘tear’))
// false
// x(?=y) — Опережающая проверка
const myPattern = /doo(?=dle)/console.log(myPattern.test(‘poodle’))
// falseconsole.log(myPattern.test(‘doodle’))
// trueconsole.log(myPattern.test(‘moodle’))
// false
// x(?!y) — Негативная опережающая проверка
const myPattern = /gl(?!u)/console.log(myPattern.test(‘glue’))
// falseconsole.log(myPattern.test(‘gleam’))
// true
// (?<=y)x — Ретроспективная проверка
const myPattern = /(?<=re)a/console.log(myPattern.test(‘realm’))
// trueconsole.log(myPattern.test(‘read’))
// trueconsole.log(myPattern.test(‘rest’))
// false
// (?<!y)x — Негативная ретроспективная проверка
const myPattern = /(?<!re)a/console.log(myPattern.test(‘break’))
// falseconsole.log(myPattern.test(‘treat’))
// falseconsole.log(myPattern.test(‘take’))
// true

Квантификаторы

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

/* Квантификатор - Значение */
* - 0 или более совпадений с предшествующим выражением.
+ - 1 или более совпадений с предшествующим выражением.
? - Предшествующее выражение необязательно (то есть совпадений 0 или 1).
x{n} - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно "n".
x{n, } - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно, как минимум, "n".
x{n, m} - "n" может быть равно 0 или целому положительному числу. "m" - целое положительное число. Если "m" > "n", количество вхождений предшествующего выражения "x" равно минимум "n" и максимум "m".

Примеры:

// * - 0 или более совпадений с предшествующим выражением
const myPattern = /bo*k/console.log(myPattern.test('b'))
// falseconsole.log(myPattern.test('bk'))
// trueconsole.log(myPattern.test('bok'))
// true
// + - 1 или более совпадений с предшествующим выражением
const myPattern = /\d+/console.log(myPattern.test('word'))
// falseconsole.log(myPattern.test(13))
// true
// ? - Предшествующее выражение необязательно, совпадений 0 или 1
const myPattern = /foo?bar/console.log(myPattern.test('foobar'))
// trueconsole.log(myPattern.test('fooobar'))
// false
// x{n} - Количество вхождений предшествующего выражения "x" равно "n"
const myPattern = /bo{2}m/console.log(myPattern.test('bom'))
// falseconsole.log(myPattern.test('boom'))
// trueconsole.log(myPattern.test('booom'))
// false
// x{n, } - Количество вхождений предшествующего выражения "x" равно, как минимум, "n"
const myPattern = /do{2,}r/console.b-g]/console.log(myPattern.test('bcd'))
// false (нет других символов, кроме входящих в диапазон от 'b' до 'g')console.log(myPattern.test('jklm'))
// true (есть другие символы, кроме входящих в диапазон от 'b' до 'g')
// (x) - "x", значение запоминается для дальнейшего использования.
const myPattern = /(na)da\1/console.log(myPattern.test('nadana'))
// true - \1 запоминает и использует совпадение 'na' из первого выражения в скобках.console.log(myPattern.test('nada'))
// false
// (?<name>x) - Создание именованной скобочной группы, к которой можно обратиться по указанному имени.
const myPattern = /(?<foo>is)/console.log(myPattern.test('Work is created.'))
// trueconsole.log(myPattern.test('Just a text'))
// false
// (?:x) - "x", значение не запоминается.
const myPattern = /(?:war)/console.log(myPattern.test('warsawwar'))
// trueconsole.log(myPattern.test('arsaw'))
// false

Альтернация

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

/* Альтернация - Значение */
| - выражение до или после символа |, как в булевом ИЛИ (||).

Примеры:

// | - Выражение до или после символа |
const myPattern = /(black|white)swan/console.log(myPattern.test('black swan'))
// trueconsole.log(myPattern.test('white swan'))
// trueconsole.log(myPattern.test('gray swan'))
// false

Флаги

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

/* Флаг - Значение */
g – Глобальный поиск, не останавливается после нахождения первого совпадения." и заканчивается "$" (начало и конец каждой строки).

Примеры:

// флаг g - Глобальный поиск
const myPattern = /xyz/gconsole.log(myPattern.test('One xyz and one more xyz'))
// true// флаг i - Игнорирование регистра
const myPattern = /xyz/iconsole.log(myPattern.test('XyZ'))
// true - регистр символов не имеет значения при нечувствительном к регистру поиске.
// флаг s - Точка (.) соответствует переводу на новую строку
const myPattern = /foo.bar/sconsole.log(myPattern.test('foo\nbar'))
// trueconsole.log(myPattern.test('foo bar'))
// trueconsole.log(myPattern.test('foobar'))
// false

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

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

Введение

Как создавать регулярные выражения?

Если с помощью JavaScript вы хотите создать регулярное выражение (описать шаблон), есть два способа это сделать.

Конструктор регулярных выражений

// Синтаксис конструктора регулярных выражений
new RegExp(pattern[, flags])

// Создание регулярного выражения
// с помощью конструктора
// без флагов
const myPattern = new RegExp('[a-z]')

// Создание регулярного выражения
// с помощью конструктора
// с одним флагом
const myPattern = new RegExp('[a-z]', 'g')

Литерал регулярных выражений

// Синтаксис литерала регулярных выражений
/pattern/flags

// Создание регулярного выражения
// с помощью литерала
// без флагов
const myPattern = /[a-z]/

// Создание регулярного выражения
// с помощью литерала
// с одним флагом
const myPattern = /[a-z]/g

), то есть \ /.

Конструктор или литерал?

Как использовать регулярные выражения с методами объекта RegExp?

test()

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

test(). При использовании этого метода необходимо передать функции проверяемую строку в качестве аргумента. В результате метод возвращает булево значение: true — если в строке есть совпадения с шаблоном, false — если совпадений нет.

// Синтаксис метода test()
// /шаблон/.test('проверяемый текст')


// Проверка строки,
// когда test() не находит совпадений
myPattern.test('There was a cat and dog in the house.')
// false


// Создание переменной,
// которой присваивается текст для проверки
const myString = 'The world of code.'


// Создание шаблона
const myPattern = /code/


// Проверка текста с помощью шаблона,
// когда test() находит совпадение
myPattern.test(myString)
// true

exec()

exec() возвращает null.

// Синтаксис метода exec()
// /шаблон/.exec('проверяемый текст')


// Создание строки для проверки
const myString = 'The world of code is not full of code.'

// Описание шаблона
const myPattern = /code/

// Использование exec() для проверки текста,
// когда exec() находит совпадение
myPattern.exec(myString)
// [
//   'code',
//   index: 13,
//   input: 'The world of code is not full of code.',
//   groups: undefined
// ]


// Описание другого шаблона
const myPatternTwo = /JavaScript/

// Использование exec() с новым шаблоном для новой проверки текста,
// когда exec() не находит совпадений
myPatternTwo.exec(myString)
// null

Как использовать регулярные выражения с методами объекта String?

search()

// Синтаксис метода search()
// 'проверяемый текст'.search(/шаблон/)


// Создание текста для проверки
const myString = 'The world of code is not full of code.'.

// Описание шаблона
const myPattern = /code/

// Использование search() для поиска
//совпадения строки с шаблоном,
//когда search() находит совпадение
myString.search(myPattern)
// -13


// Вызов search() прямо на строке,
// когда search() не находит совпадений
'Another day in the life.'.search(myPattern)
// -1

match()

Так же как и exec(), match() возвращает null при отсутствии совпадений. При использовании метода match() с флагом

g для поиска всех совпадений с шаблоном возвращается массив из всех совпадений.

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)


// Создание текста для проверки
const myString = 'The world of code is not full of code.'

// Описание шаблона
const myPattern = /code/

// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [
//   'code',
//   index: 13,
//   input: 'The world of code is not full of code.',
//   groups: undefined
// ]

'Another day in the life.'.match(myPattern)
// null


// Использование match() для поиска всех совпадений
// Создание текста для проверки
const myString = 'The world of code is not full of code.'

// Описание шаблона
const myPattern = /code/g // добавление флага 'g'

// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [ 'code', 'code' ]

matchAll()

Подобно методу match(), matchAll() возвращает все совпадения при использовании флага

g в шаблоне. Однако работает он по-другому. Метод matchAll() возвращает объект RegExp String Iterator. Есть несколько способов извлечь из него все совпадения.

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)

// Создание текста для проверки
const myString = 'The world of code is not full of code.'

// Описание шаблона
const myPattern = /code/g
// Обратите внимание, что используется флаг 'g'

// Использование matchAll() для поиска совпадений в тексте
const matches = myString.matchAll(myPattern)

// Использование цикла for...of для получения всех совпадений
for (const match of matches) {
  console.log(match)
}
// [
//   [
//     'code',
//     index: 13,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ],
//   [
//     'code',
//     index: 33,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ]
// ]


// Использование Array.from() для получения всех совпадений
const matches = Array.from(myString.matchAll(myPattern))
// [
//   [
//     'code',
//     index: 13,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ],
//   [
//     'code',
//     index: 33,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ]
// ]

// Использование оператора spread для получения всех совпадений
const matches = [...myString.matchAll(myPattern)]
// [
//   [
//     'code',
//     index: 13,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ],
//   [
//     'code',
//     index: 33,
//     input: 'The world of code is not full of code.',
//     groups: undefined
//   ]
// ]

Как создавать простые шаблоны?

// Создание простого шаблона
// с использованием литерала регулярного выражения
const myPattern = /JavaScript/

// Проверка строки на совпадения с шаблоном
myPattern.test('One of the most popular languages is also JavaScript.')
// true

// Проверка строки на совпадения с шаблоном
myPattern.test('What happens if you combine Java with scripting?')
// false

Как создавать сложные шаблоны со специальными символами?

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

Символьные классы

Символьные классы — это своеобразные сокращения для разных типов символов. К примеру, есть свои классы для букв, цифр, пробелов и т. д.

/* Символьный класс - Значение */
. - любой символ, кроме первой строки
\d - одноразрядное число (то же, что и [0-9])
\w - отдельный буквенно-числовой словообразующий символ из латинского алфавита, включая подчёркивание (то же, что и [A-Za-z0-9_)
\s - отдельный символ разделителя (пробел, табуляция и т.\t\r\n\v\f]).

Примеры:

// . - любой символ, кроме первой строки
const myPattern = /./

console.log(myPattern.test(''))
// false

console.log(myPattern.test('word'))
// true

console.log(myPattern.test('9'))
// true


// \d - одноразрядное число
const myPattern = /\d/

console.log(myPattern.test('3'))
// true

console.log(myPattern.test('word'))
// false

// \w - отдельный буквенно-числовой словообразующий символ
const myPattern = /\w/

console.log(myPattern.test(''))
// false

console.log(myPattern.test('word'))
// true

console.log(myPattern.test('9'))
// true


// \s - отдельный символ разделителя
const myPattern = /\s/

console.log(myPattern.test(''))
// false

console.log(myPattern.test(' '))
// true

console.log(myPattern.test('foo'))
// false


// \D - отдельный нечисловой символ
const myPattern = /\D/
console.log(myPattern.test('Worm'))
// true
console.log(myPattern.test('1'))
// false


// \W - отдельный несловообразующий символ
const myPattern = /\W/

console.re/

console.log(myPattern.test('write'))
// false

console.log(myPattern.test('read'))
// true

console.log(myPattern.test('real'))
// true

console.log(myPattern.test('free'))
// false

// $ - Конец строки
const myPattern = /ne$/

console.log(myPattern.test('all is done'))
// true

console.log(myPattern.test('on the phone'))
// true

console.log(myPattern.test('in Rome'))
// false

console.log(myPattern.test('Buy toner'))
// false


// \b - Граница слова
const myPattern = /\bro/

console.log(myPattern.test('road'))
// true

console.log(myPattern.test('steep'))
// false

console.log(myPattern.test('umbro'))
// false

// Или
const myPattern = /\btea\b/

console.log(myPattern.test('tea'))
// true

console.log(myPattern.test('steap'))
// false

console.log(myPattern.test('tear'))
// false

// \B - Несловообразующая граница
const myPattern = /\Btea\B/
console.log(myPattern.test('tea'))
// false
console.log(myPattern.test('steap'))
// true
console.log(myPattern.test('tear'))
// false

// x(?=y) - Опережающая проверка
const myPattern = /doo(?=dle)/

console.log(myPattern.test('poodle'))
// false

console.log(myPattern.test('doodle'))
// true

console.log(myPattern.test('moodle'))
// false


// x(?!y) - Негативная опережающая проверка
const myPattern = /gl(?!u)/

console.log(myPattern.test('glue'))
// false

console.log(myPattern.test('gleam'))
// true


// (?<=y)x - Ретроспективная проверка
const myPattern = /(?<=re)a/

console.log(myPattern.test('realm'))
// true

console.log(myPattern.test('read'))
// true

console.log(myPattern.test('rest'))
// false

// (?<!y)x - Негативная ретроспективная проверка
const myPattern = /(?<!re)a/

console.log(myPattern.test('break'))
// false

console.log(myPattern.test('treat'))
// false

console.log(myPattern.test('take'))
// true

Квантификаторы

/* Квантификатор - Значение */
* - 0 или более совпадений с предшествующим выражением.
+ - 1 или более совпадений с предшествующим выражением.
? - Предшествующее выражение необязательно (то есть совпадений 0 или 1).
x{n} - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно "n".
x{n, } - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно, как минимум, "n".
x{n, m} - "n" может быть равно 0 или целому положительному числу. "m" - целое положительное число. Если "m" > "n", количество вхождений предшествующего выражения "x" равно минимум "n" и максимум "m".

Примеры:

// * - 0 или более совпадений с предшествующим выражением
const myPattern = /bo*k/

console.log(myPattern.test('b'))
// false

console.log(myPattern.test('bk'))
// true

console.log(myPattern.test('bok'))
// true


// + - 1 или более совпадений с предшествующим выражением
const myPattern = /\d+/

console.log(myPattern.test('word'))
// false

console.log(myPattern.test(13))
// true


// ? - Предшествующее выражение необязательно, совпадений 0 или 1
const myPattern = /foo?bar/

console.log(myPattern.test('foobar'))
// true

console.log(myPattern.test('fooobar'))
// false


// x{n} - Количество вхождений предшествующего выражения "x" равно "n"
const myPattern = /bo{2}m/

console.log(myPattern.test('bom'))
// false

console.log(myPattern.test('boom'))
// true

console.log(myPattern.test('booom'))
// false


// x{n, } - Количество вхождений предшествующего выражения "x" равно, как минимум, "n"
const myPattern = /do{2,}r/
console.log(myPattern.test('dor'))
// false
console.log(myPattern.test('door'))
// true
console.log(myPattern.test('dooor'))
// true


// x{n, m} - Количество вхождений предшествующего выражения "x" равно минимум "n" и максимум "m"
const myPattern = /zo{1,3}m/

console.log(myPattern.test('zom'))
// false

console.log(myPattern.test('zoom'))
// true

console.log(myPattern.test('zooom'))
// true

console.log(myPattern.test('zoooom'))
// false

Наборы и диапазоны

Наборы и диапазоны могут пригодиться, когда нужно указать специальные символы набора или их диапазон.b-g]/ console.log(myPattern.test(‘bcd’)) // false (нет других символов, кроме входящих в диапазон от ‘b’ до ‘g’) console.log(myPattern.test(‘jklm’)) // true (есть другие символы, кроме входящих в диапазон от ‘b’ до ‘g’) // (x) — «x», значение запоминается для дальнейшего использования. const myPattern = /(na)da\1/ console.log(myPattern.test(‘nadana’)) // true — \1 запоминает и использует совпадение ‘na’ из первого выражения в скобках. console.log(myPattern.test(‘nada’)) // false // (?<name>x) — Создание именованной скобочной группы, к которой можно обратиться по указанному имени. const myPattern = /(?<foo>is)/ console.log(myPattern.test(‘Work is created.’)) // true console.log(myPattern.test(‘Just a text’)) // false // (?:x) — «x», значение не запоминается. const myPattern = /(?:war)/ console.log(myPattern.test(‘warsawwar’)) // true console.log(myPattern.test(‘arsaw’)) // false

Альтернация

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

/* Альтернация - Значение */
| - выражение до или после символа |, как в булевом ИЛИ (||).

Примеры:

// | - Выражение до или после символа |
const myPattern = /(black|white)swan/

console.log(myPattern.test('black swan'))
// true

console.log(myPattern.test('white swan'))
// true

console.log(myPattern.test('gray swan'))
// false

Флаги

/* Флаг - Значение */
g – Глобальный поиск, не останавливается после нахождения первого совпадения.
i – Игнорирование регистра (соответствует верхнему и нижнему регистрам).
s - Точка (.) соответствует переводу на новую строку." и заканчивается "$" (начало и конец каждой строки).

Примеры:

// флаг g - Глобальный поиск
const myPattern = /xyz/g

console.log(myPattern.test('One xyz and one more xyz'))
// true

// флаг i - Игнорирование регистра
const myPattern = /xyz/i

console.log(myPattern.test('XyZ'))
// true - регистр символов не имеет значения при нечувствительном к регистру поиске.

// флаг s - Точка (.) соответствует переводу на новую строку
const myPattern = /foo.bar/s

console.log(myPattern.test('foo\nbar'))
// true

console.log(myPattern.test('foo bar'))
// true

console.log(myPattern.test('foobar'))
// false

Заключение

Регулярные выражения для новичков

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

Если вам когда-нибудь приходилось работать с командной строкой, вы, вероятно, использовали маски имён файлов. Например, чтобы удалить все файлы в текущей директории, которые начинаются с буквы «d», можно написать rm d*.

Регулярные выражения представляют собой похожий, но гораздо более сильный инструмент для поиска строк, проверки их на соответствие какому-либо шаблону и другой подобной работы. Англоязычное название этого инструмента — Regular Expressions или просто RegExp. Строго говоря, регулярные выражения — специальный язык для описания шаблонов строк.

Реализация этого инструмента различается в разных языках программирования, хоть и не сильно. В данной статье мы будем ориентироваться в первую очередь на реализацию Perl Compatible Regular Expressions.

Основы синтаксиса

В первую очередь стоит заметить, что любая строка сама по себе является регулярным выражением. Так, выражению Хаха, очевидно, будет соответствовать строка «Хаха» и только она. Регулярные выражения являются регистрозависимыми, поэтому строка «хаха» (с маленькой буквы) уже не будет соответствовать выражению выше.xyz] соответствует любой символ, кроме, собственно, «x», «y» или «z».

Итак, применяя данный инструмент к нашему случаю, если мы напишем [Хх][аоие]х[аоие], то каждая из строк «Хаха», «хехе», «хихи» и даже «Хохо» будут соответствовать шаблону.

Предопределённые классы символов

Для некоторых наборов, которые используются достаточно часто, существуют специальные шаблоны. Так, для описания любого пробельного символа (пробел, табуляция, перенос строки) используется \s, для цифр — \d, для символов латиницы, цифр и подчёркивания «_» — \w.

Если необходимо описать вообще любой символ, для этого используется точка — .. Если указанные классы написать с заглавной буквы (\S, \D, \W) то они поменяют свой смысл на противоположный — любой непробельный символ, любой символ, который не является цифрой, и любой символ кроме латиницы, цифр или подчёркивания соответственно. — начало текста, а $ — конец. Так, по паттерну \bJava\b в строке «Java and JavaScript» найдутся первые 4 символа, а по паттерну \bJava\B — символы c 10-го по 13-й (в составе слова «JavaScript»).

Комикс про регулярные выражения с xkcd.ru

Диапазоны

У вас может возникнуть необходимость обозначить набор, в который входят буквы, например, от «б» до «ф». Вместо того, чтобы писать [бвгдежзиклмнопрстуф] можно воспользоваться механизмом диапазонов и написать [б-ф]. Так, паттерну x[0-8A-F][0-8A-F] соответствует строка «xA6», но не соответствует «xb9» (во-первых, из-за того, что в диапазоне указаны только заглавные буквы, во-вторых, из-за того, что 9 не входит в промежуток 0-8).

Механизм диапазонов особенно актуален для русского языка, ведь для него нет конструкции, аналогичной \w. Чтобы обозначить все буквы русского алфавита, можно использовать паттерн [а-яА-ЯёЁ]. Обратите внимание, что буква «ё» не включается в общий диапазон букв, и её нужно указывать отдельно.

Квантификаторы

Вернёмся к нашему примеру. Что, если в «смеющемся» междометии будет больше одной гласной между буквами «х», например «Хаахаааа»? Наша старая регулярка уже не сможет нам помочь. Здесь нам придётся воспользоваться квантификаторами.

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

Обратите внимание, что квантификатор применяется только к символу, который стоит перед ним.

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

Спецобозначения квантификаторов в регулярных выражениях.

Таким образом, с помощью квантификаторов мы можем улучшить наш шаблон для междометий до [Хх][аоеи]+х[аоеи]*, и он сможет распознавать строки «Хааха», «хееееех» и «Хихии».

Ленивая квантификация

Предположим, перед нами стоит задача — найти все HTML-теги в строке

<p><b>Tproger</b> — мой <i>любимый</i> сайт о программировании!</p>

Очевидное решение <.>]*>, которое запретит считать содержимым тега правую угловую скобку. Второй — объявить квантификатор не жадным, а ленивым. Делается это с помощью добавления справа к квантификатору символа ?. Т.е. для поиска всех тегов выражение обратится в <.*?>.

Ревнивая квантификация

Иногда для увеличения скорости поиска (особенно в тех случаях, когда строка не соответствует регулярному выражению) можно использовать запрет алгоритму возвращаться к предыдущим шагам поиска для того, чтобы найти возможные соответствия для оставшейся части регулярного выражения. Это называется ревнивой квантификацией. Квантификатор делается ревнивым с помощью добавления к нему справа символа +. Ещё одно применение ревнивой квантификации — исключение нежелательных совпадений. Так, паттерну ab*+a в строке «ababa» будут соответствовать только первые три символа, но не символы с третьего по пятый, т.к. символ «a», который стоит на третьей позиции, уже был использован для первого результата.

Чуть больше о жадном, сверхжадном и ленивом режимах квантификации вы сможете узнать из статьи о регулярных выражениях в Java.

Скобочные группы

Для нашего шаблона «смеющегося» междометия осталась самая малость — учесть, что буква «х» может встречаться более одного раза, например, «Хахахахааахахооо», а может и вовсе заканчиваться на букве «х». Вероятно, здесь нужно применить квантификатор для группы [аиое]+х, но если мы просто напишем [аиое]х+, то квантификатор + будет относиться только к символу «х», а не ко всему выражению. Чтобы это исправить, выражение нужно взять в круглые скобки: ([аиое]х)+.

Таким образом, наше выражение превращается в [Хх]([аиое]х?)+ — сначала идёт заглавная или строчная «х», а потом произвольное ненулевое количество гласных, которые (возможно, но не обязательно) перемежаются одиночными строчными «х». Однако это выражение решает проблему лишь частично — под это выражение попадут и такие строки, как, например, «хихахех» — кто-то может быть так и смеётся, но допущение весьма сомнительное. Очевидно, мы можем использовать набор из всех гласных лишь единожды, а потом должны как-то опираться на результат первого поиска. Но как?…

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

Оказывается, результат поиска по скобочной группе записывается в отдельную ячейку памяти, доступ к которой доступен для использования в последующих частях регулярного выражения. Возвращаясь к задаче с поиском HTML-тегов на странице, нам может понадобиться не только найти теги, но и узнать их название. В этом нам может помочь регулярное выражение <(.*?)>.

<p><b>Tproger</b> — мой <i>любимый</i> сайт о программировании!</p>

Результат поиска по всему регулярному выражению: «», «», «», «», «», «».
Результат поиска по первой группе: «p», «b», «/b», «i», «/i», «/i», «/p».

На результат поиска по группе можно ссылаться с помощью выражения \n, где n — цифра от 1 до 9. Например выражению (\w)(\w)\1\2 соответствуют строки «aaaa», «abab», но не соответствует «aabb».

Если выражение берётся в скобки только для применения к ней квантификатора (не планируется запоминать результат поиска по этой группе), то сразу после первой скобки стоит добавить ?:, например (?:[abcd]+\w).

С использованием этого механизма мы можем переписать наше выражение к виду [Хх]([аоие])х?(?:\1х?)*.

Перечисление

Чтобы проверить, удовлетворяет ли строка хотя бы одному из шаблонов, можно воспользоваться аналогом булевого оператора OR, который записывается с помощью символа |. Так, под шаблон Анна|Одиночество попадают строки «Анна» и «Одиночество» соответственно. Особенно удобно использовать перечисления внутри скобочных групп. Так, например (?:a|b|c|d) полностью эквивалентно [abcd] (в данном случае второй вариант предпочтительнее в силу производительности и читаемости).

С помощью этого оператора мы сможем добавить к нашему регулярному выражению для поиска междометий возможность распознавать смех вида «Ахахаах» — единственной усмешке, которая начинается с гласной: [Хх]([аоие])х?(?:\1х?)*|[Аа]х?(?:ах?)+

Полезные сервисы

Потренироваться и / или проверить своё регулярное выражение на каком-либо тексте без написания кода можно с помощью таких сервисов, как RegExr, Regexpal или Regex101. Последний, вдобавок, приводит краткие пояснения к тому, как регулярка работает.

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

RegExp Builder — визуальный конструктор функций JavaScript для работы с регулярными выражениями.

Больше инструментов можно найти в нашей подборке.

Задания для закрепления

Найдите время

Время имеет формат часы:минуты. И часы, и минуты состоят из двух цифр, пример: 09:00.script] вполне подходит символ «S».

Цвет

Напишите регулярное выражение для поиска HTML-цвета, заданного как #ABCDEF, то есть # и содержит затем 6 шестнадцатеричных символов.

Итак, нужно написать выражение для описания цвета, который начинается с «#», за которым следуют 6 шестнадцатеричных символов. Шестнадцатеричный символ можно описать с помощью [0-9a-fA-F]. Для его шестикратного повторения мы будем использовать квантификатор {6}.

#[0-9a-fA-F]{6}

Разобрать арифметическое выражение

Арифметическое выражение состоит из двух чисел и операции между ними, например:

1 + 2
1.2 *3.4
-3/ -6
-2-2

Список операций: «+», «-», «*» и «/».

Также могут присутствовать пробелы вокруг оператора и чисел.

Напишите регулярное выражение, которое найдёт как всё арифметическое действие, так и (через группы) два операнда.

Регулярное выражение для числа, возможно, дробного и отрицательного: -?\d+(\.\d+)?.

Оператор – это [+*/\-]. Заметим, что дефис мы экранируем. Нам нужно число, затем оператор, затем число, и необязательные пробелы между ними. Чтобы получить результат в требуемом формате, добавим ?: к группам, поиск по которым нам не интересен (отдельно дробные части), а операнды наоборот заключим в скобки. В итоге:

(-?\d+(?:\.\d+)?)\s*([-+*\/])\s*(-?\d+(?:\.\d+)?)

Кроссворды из регулярных выражений

Такие кроссворды вы можете найти у нас.

Удачи и помните — не всегда задачу стоит решать именно с помощью регулярных выражений («У программиста была проблема, которую он начал решать регэкспами. Теперь у него две проблемы»). Иногда лучше, например, написать развёрнутый автомат конечных состояний.

Задачи и их разборы с javascript.ru; в статье использованы комиксы xkcd.

javascript — Regex для подтверждения возраста, который принимает возраст от 0 до 200, используя только Javascript

Я хочу регулярное выражение, которое позволяет пользователям вводить только цифры от 0 до 200.(0?[1-9]|[1-9][0-9]|[1][1-9][1-9]|200)$

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

if(age >= 0 &&  age <= 200)  
{
   //code
}

Rahul Tripathi 6 Апр 2015 в 07:41

Вы можете просто проверить условие if без необходимости регулярного выражения, как:

if( input >=0 && input <= 200 ) {
    //its valid
}

Sudhir Bastakoti 6 Апр 2015 в 07:26

Я настоятельно рекомендую использовать для этого оператор if, поскольку регулярное выражение в этом случае неэффективно.

В любом случае, если вы действительно хотите использовать RegEx, попробуйте следующее:

var age_regex=/\s[0-1]{1}[0-9]{0,2}/;

Regex демо и объяснение.

EDIT :

Используя это регулярное выражение в <input>:

(рабочая демонстрация)

p{
  color: red;
}

<form action="#">
  Enter Age: <input type="text" name="number" pattern="[0-1]{1}[0-9]{0,2}" title="Please enter a valid number between 0 and 200.">
  <input type="submit">
</form>

<p>This form will give error if number does not pass the regex.</p>

Arno Chauveau 19 Апр 2016 в 14:54

30 примеров полезных регулярных выражений

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

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

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

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

Как известно, регулярные выражения не «привязаны» к какому-то определенному языку программирования, поэтому вы можете использовать приведенные ниже примеры выражений при разработке проектов на различных языках.(?=.*[A-Z].*[A-Z])(?=.*[!@#$&*])(?=.*[0-9].*[0-9])(?=.*[a-z].*[a-z].*[a-z]).{8}$

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

Код цвета в шестнадцатеричном формате


  
\#([a-fA-F]|[0-9]){3, 6}

Шестнадцатеричные коды цветов используются при веб-разработке очень часто. Это регулярное выражение может быть поможет сравнить: совпадает ли какая-либо строка с шаблоном шестнадцатеричного кода.

Проверка адреса электронной почты


  
/[A-Z0-9._%+-]+@[A-Z0-9-]+.+.[A-Z]{2,4}/igm

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

IP-адрес (v4)


  
/\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/

Как e-mail может использоваться для идентификации посетителя, так IP-адрес является идентификатором конкретного компьютера в сети. Приведенное регулярное выражение проверяет соответствие строки формату IP-адреса v4.

IP-адрес (v6)


  
(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.\s]*$    //соответствует фразе из 5 и более ключевых слов

Это действительно полезные выражения для пользователей Google Analytics и инструмента для веб-мастеров. Ведь с помощью них можно отсортировать ключевые фразы, используемые посетителями при поиске по количеству слов, входящих в них.

Выражения могут проверять фразы, содержащие определенное количество слов (например, 5), а также фразы количество слов в которых более двух, трех и т.д. Одно из самых мощных выражений, используемое для сортировки данных аналитики.

Поиск валидной строки Base64 в PHP


  
\?php[ \t]eval\(base64_decode\(\'(([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?){1}\'\)\)\;

Если вы являетесь PHP-разработчиком, то иногда вам может понадобиться найти объект, закодированный в формате Base64. Указанное выше выражение может использоваться для поиска закодированных строк в любом PHP-коде.

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


  
^\+?\d{1,3}?[- .(?:0?[1-9]|1\d|2[0-8])(\/|-|\.)(?:(?:0?[1-9])|(?:1[0-2]))\4(?:(?:1[6-9]|[2-9]\d)?\d{2})$

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

В PHP имеется отличная функция date(), но она не всегда подходит, ведь в нее может быть передана необработанная строка. Поэтому для проверки указанного формата даты нужно использовать приведенное выше регулярное выражение.

Совпадение строки с адресом видеоролика на YouTube


  
/http:\/\/(?:youtu\.be\/|(?:[a-z]{2,3}\.)?youtube\.com\/watch(?:\?|#\!)v=)([\w-]{11}).*/gi

На протяжении нескольких лет на Youtube не меняется структура URL-адресов. Youtube является самым популярным видео хостингом в Интернет, благодаря этому, видео с Youtube набирают наибольший трафик.

Если вам необходимо получить ID какого-либо видеоролика с Youtube, воспользуйтесь приведенным выше регулярным выражением.\s*[a-zA-Z\-]+\s*[:]{1}\s[a-zA-Z0-9\s.#]+[;]{1}

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

Этот код можно использовать когда будет необходимо «вытянуть» какое-либо CSS-правило из списка правил для какого-нибудь селектора.

Удаление комментариев в HTML


  
<!--(.*?)-->

Если вам необходимо удалить все комментарии из блока HTML-кода, воспользуйтесь этим регулярным выражением. Чтобы получить желаемый результат, вы можете воспользоваться PHP-функцией preg_replace().

Проверка на соответствие ссылке на Facebook-аккаунт


  
/(?:http:\/\/)?(?:www\.)?facebook\.com\/(?:(?:\w)*#!\/)?(?:pages\/)?(?:[\w\-]*\/)*([\w\-]*)/

Если вам необходимо узнать у посетителя вашего сайта адрес его странички в Facebook, попробуйте это регулярное выражение..*MSIE [5-8](?:\.[0-9]+)?(?!.*Trident\/[5-9]\.0).*$

Несмотря на то, что Microsoft выпустил новый браузер Edge, многие пользователи до сих пор пользуются Internet Explorer. Веб-разработчикам часто приходится проверять версию этого браузера, чтобы учитывать особенности разных версий при работе над своими проектами.

Вы можете использовать это регулярное выражения в JavaScript-коде чтобы узнать какая версия IE (5-11) используется.

«Вытягиваем» цену из строки


  
/(\$[0-9,]+(\.[0-9]{2})?)/

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

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

Разбираем заголовки в e-mail


  
/\b[A-Z0-9._%+-]+@(?:[A-Z0-9-]+\. ]*))/g

Вы можете составить свои собственные регулярные выражения для манипулирования результатами поиска по вашим запросам в поисковой системе Google. Например, знак плюс (+) добавляет дополнительные ключевые слова, а минус (-) означает, что слова должны быть проигнорированы и удалены из результатов.

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

Заключение

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

Голосов: 723 | Просмотров: 35635

Онлайн калькулятор: Проверка регулярных выражений

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

По моему опыту, чтобы разобраться, надо просто найти толковое описание. Могу порекомендовать главу 24 из книги Джозефа и Бена Албахари «C# 3.0. Справочник» издательства O’Reilly. До C# 3.0 дело у меня так и не дошло, и это единственная глава из книги, которую я прочитал, но про регулярные выражения написано понятно.

Собственно, регулярки — крутейшая вещь. И везде они есть, в том числе и на Javascript, на котором пишутся все калькуляторы на нашем сайте. В нем есть такой объект RegExp. Вот ты туда текст регулярки пихаешь, и начинаешь ее по всякому использовать.

Как использовать?

Во-первых, есть такой метод test(string) — возвращает выражение true, если регулярка заматчилась (нашлось совпадение в тексте), и false, если ничего не нашлось.

Во-вторых, есть метод exec(string) — который позволяет извлечь то, что заматчилось. В результате вызова этого метода получаем массив результатов. Он нужен, если в тексте регулярки мы использовали группировку скобками ().
Массив там, кстати, не очень массив. Если были группы, то нулевой элемент массива это все совпадение целиком, а все последующие — это группы. Кроме того, там есть два свойства, input — это вообще вся строка, которую передали на вход, и index — видимо, индекс в массиве (не знаю, зачем оно нужно).

В-третьих, можно использовать регулярку для замены по строке, вызовом source_string.replace(regex, replace_string). Наверно, для этого ее используют больше всего.

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

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

На выходе получаем результаты вызовов методов test, exec, и replace на введенном тексте. Вот так можно на ходу тренироваться на кошках, если не уверен, что твоя регулярка правильно сработает.

Проверка регулярных выражений

Вот текст, с номерами вида 1111111, или 2323434, или 5557777. Вообще, с учетом вида регулярки, номера могут содержать 5-7 и больше цифр, и все равно распознаваться и приводиться к красивому виду, смотри 77777 или 5-2222. Почувствуйте мощь регулярок!

Исходный текст

Результат вызова метода test

Результат вызова метода exec

Результат вызова метода replace

 Ссылка  Сохранить  Виджет

Регулярные выражения в JavaScript — CoderLessons.com

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

Если вы когда-нибудь программировали на Perl или вам приходилось работать системным администратором Unix, то вы, вероятно, уже давно знакомы с регулярными выражениями . Но даже если Perl выглядит для вас спагетти, и вы чувствуете, что ни один простой смертный не может управлять системой Unix, тот факт, что JavaScript включает поддержку регулярных выражений в стиле Perl, является хорошей новостью … поверьте мне!

В этой статье я начну с объяснения, что такое регулярные выражения и что они могут сделать для вас. Затем я представлю обзор наиболее распространенных функций регулярных выражений (которые поклонники Perl в аудитории могут безопасно пропустить). Наконец, я закончу объяснением того, как регулярные выражения используются в JavaScript, с практическим примером или двумя, чтобы помочь гелевым понятиям. К концу этой статьи вы, вероятно, все еще будете простым смертным, но вы наверняка сможете произвести впечатление на вечеринках своими новыми навыками жонглирования текстом!

Кто они такие?

Регулярные выражения используют специальные (и на первый взгляд несколько запутанные) коды для обнаружения шаблонов в строках текста. Например, если вы предоставляете своим посетителям HTML-форму для ввода их информации, у вас может быть одно поле для номера телефона. Теперь давайте посмотрим правде в глаза: некоторые посетители сайта лучше следуют инструкциям, чем другие. Даже если вы поместите небольшую подсказку рядом с текстовым полем, указывающим требуемый формат номера телефона (например, «(XXX) XXX-XXXX» для номеров в Северной Америке), некоторые люди поймут это неправильно. Написание скрипта для проверки каждого символа введенной строки, чтобы убедиться, что все числа находятся там, где они находятся, с круглыми скобками и тире в правильных местах, было бы довольно утомительным кодом для написания. А телефонный номер — это относительно простой случай! Что если вам нужно проверить, действительно ли пользователь ввел адрес электронной почты или, что еще хуже, URL?

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

Как они выглядят?

Регулярные выражения иногда могут выглядеть довольно сложными, но когда дело доходит до этого, на самом деле они просто текстовые строки. Следующее, например, является регулярным выражением, которое ищет текст «JavaScript» (без кавычек):

JavaScript

Не так много, не так ли? Говорят, что любая строка, содержащая текст «JavaScript», соответствует этому регулярному выражению.A-Za-z0-9_])

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

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

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

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

 var myRE = /regexp/;

Где regexp — это код регулярного выражения, как описано выше. Например, следующее создает первое примерное регулярное выражение, которое я представил в предыдущем разделе, которое обнаруживает строку «JavaScript»:

 var myRE = /JavaScript/;

Аналогично, вот как создать последний пример:

 var myRE = /^(ba|na)+$/;

По умолчанию регулярные выражения JavaScript чувствительны к регистру и ищут только первое совпадение в любой заданной строке. Добавив модификаторы g (для глобальных ) и i (для игнорирования регистра ) после второй / , вы можете выполнять регулярное выражение для поиска всех совпадений в строке и игнорировать регистр соответственно. Вот несколько примеров регулярных выражений. Для каждого я указал, какой части строки "test1 Test2 TEST3" они будут соответствовать:

RegExp	Спички):
/ Тест [0-9] + /	Только «Test2»
/ Тест [0-9] + / I	Только «test1»
/ Тест [0-9] + / г	«Test1», «Test2» и «TEST3»

Используя регулярные выражения легко. Каждая переменная JavaScript, содержащая текстовую строку, поддерживает три метода (или функции, если вы не привыкли к объектно-ориентированной терминологии) для работы с регулярными выражениями: match() , replace() и search() . , чтобы указать, что любое совпадение должно начинаться с начала строки. Далее следует $ это будет просто соответствовать открывающей скобке. Мы добавили перед символом обратную косую черту, чтобы удалить его специальное значение в синтаксисе регулярного выражения (чтобы отметить начало набора альтернатив для сопоставления). Как упоминалось ранее, \d специальный код, который соответствует любой цифре, таким образом, \d\d\d соответствует любым трем цифрам. Мы могли бы написать [0-9][0-9][0-9] для достижения того же эффекта, но это короче . Остальная часть шаблона должна быть достаточно понятной. $ Соответствует закрывающей скобке, пробел соответствует пробелу, который должен быть оставлен в номере телефона, затем \d\d\d-\d\d\d\d соответствует трем цифрам, за которыми следует тире, а затем еще четыре цифры. Наконец, $ указывает, что любое совпадение должно заканчиваться в конце строки.

Кстати, мы могли бы сократить это регулярное выражение до следующего, используя другой ярлык, который мы не упомянули выше.$\d{3}$ \d{3}-\d{4}$/;

Затем наша функция проверяет, имеет ли значение phoneNo.match(phoneRE) значение true или false . Другими словами, он проверяет, соответствует ли строка, содержащаяся в phoneNo нашему регулярному выражению (таким образом, возвращает массив, который в JavaScript будет иметь значение true ). Если совпадение обнаружено, наша функция возвращает true чтобы подтвердить, что строка действительно является номером телефона. Если нет, отображается сообщение, предупреждающее о проблеме, и функция возвращает значение false .

Наиболее часто используемым для этого типа функций является проверка пользовательского ввода в форме перед тем, как разрешить ее отправку. Вызвав нашу функцию в onSubmit события onSubmit для формы, мы можем предотвратить onSubmit формы, если введенная информация не отформатирована должным образом. Вот простой пример, демонстрирующий использование нашей функции checkPhoneNumber() :

 <form action="..."> <label>Enter phone number (eg (123) 456-7890): <input type="text" name="phone"> </label> <input type="submit"> </form> <script> var form = document.querySelector('form'); form.addEventListener('submit', function() { return checkPhoneNumber(this.phone.value); }); </script>

Пользователь не сможет отправить эту форму, пока не будет введен номер телефона. Любая попытка сделать это приведет к появлению сообщения об ошибке, сгенерированного нашей checkPhoneNumber() .

заменить ()

Как следует из его названия, replace() позволяет заменить совпадения с данным регулярным выражением какой-либо новой строкой. Допустим, вы были орфографом и хотели применить старую поговорку «Я до Е, кроме С», чтобы исправить такие орфографические ошибки как «acheive» и «cieling». Нам нужна функция, которая принимает строку и выполняет две операции поиска и замены. Первый заменит «cie» на «cei».

Вот код:

 theString = theString.replace(/cie/gi,"cei");

Достаточно просто, верно? Первый параметр — это регулярное выражение, которое мы ищем (обратите внимание, что мы установили его как «игнорировать регистр» и быть «глобальным», чтобы он обнаруживал все вхождения, а не только первый), а второй параметр — строка, которой мы хотим заменить любые совпадения.

Вторая замена немного сложнее. Мы хотим заменить «xei» на «xie», где «x» — любая буква, кроме «c». Регулярное выражение для обнаружения экземпляров «xei» довольно легко понять:

 /[abd-z]ei/gi

Он просто обнаруживает любую букву, кроме «c» («a», «b» и «d» — «z» включительно), за которой следует «ei», и делает это глобально, без учета регистра.

Сложность заключается в определении нашей замещающей строки. Очевидно, мы хотим заменить совпадение на «xie», но сложность заключается в написании «x».(ba|na)+$ ). Как оказалось, скобки имеют и другое значение. Они позволяют нам «помнить» часть совпадения, чтобы мы могли использовать ее в строке замены. В этом случае мы хотим запомнить часть совпадения, которая соответствует [abd-z] в регулярном выражении. Таким образом, мы окружаем его круглыми скобками:

 /([abd-z])ei/gi

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

 theString = theString.replace(/([abd-z])ei/gi,"$1ie");

Подводя итог, вот полная функция для выполнения нашей автокоррекции:

 function autoCorrect(theString) { theString = theString.replace(/cie/gi,"cei"); theString = theString.replace(/([abd-z])ei/gi,"$1ie"); return theString; }

Прежде чем перейти на эту страницу и использовать эту функцию, поймите, что есть исключения из правила «Я до Е, кроме С». Странно, а?

поиск()

Функция search() похожа на хорошо известную indexOf() , за исключением того, что она принимает регулярное выражение вместо строки. Затем он ищет строку для первого совпадения с данным регулярным выражением и возвращает целое число, указывающее позицию в строке (например, 0, если совпадение находится в начале строки, 9, если совпадение начинается с 10-го символа в строке ). Если совпадений не найдено, функция возвращает значение -1.

 var theString = "test1 Test2 TEST3"; theString.search(/Test[0-9]+/);

Подводя итоги

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

Регулярных выражений — JavaScript | MDN

Регулярное выражение создается одним из двух способов:

Использование литерала регулярного выражения, состоящего из шаблона, заключенного между косыми чертами, как показано ниже: Литералы регулярного выражения обеспечивают компиляцию регулярного выражения при загрузке скрипта. Если регулярное выражение остается постоянным, это может повысить производительность.
Или вызовите функцию конструктора объекта RegExp следующим образом:
```
  let re = новое регулярное выражение ('ab + c');
  
```
Использование функции конструктора обеспечивает компиляцию регулярного выражения во время выполнения.Используйте функцию-конструктор, если вы знаете, что шаблон регулярного выражения будет изменяться, или если вы не знаете шаблон и получаете его из другого источника, например из пользовательского ввода.

Шаблон регулярного выражения состоит из простых символов, например / abc / , или комбинации простых и специальных символов, например / ab * c / или / Chapter (\ d +) \. \ D * / . Последний пример включает круглые скобки, которые используются как запоминающее устройство. Совпадение, сделанное с этой частью шаблона, запоминается для дальнейшего использования, как описано в разделе Использование групп.

Примечание: Если вы уже знакомы с формами регулярного выражения, вы также можете прочитать шпаргалку для быстрого поиска определенного шаблона / конструкции.

Использование простых шаблонов

Простые шаблоны состоят из символов, для которых вы хотите найти прямое соответствие. Например, шаблон / abc / соответствует комбинациям символов в строках только тогда, когда встречается точная последовательность «abc» (все символы вместе и в этом порядке).Такое совпадение будет успешным в строках «Привет, ты знаешь свою азбуку?» и «Последние конструкции самолетов произошли от плиточных кораблей». В обоих случаях совпадение с подстрокой «abc» . В строке «Grab crab» нет совпадения, потому что, хотя она содержит подстроку «ab c» , она не содержит точной подстроки «abc» .

Использование специальных символов

Когда для поиска совпадения требуется нечто большее, чем прямое совпадение, например, поиск одного или нескольких символов b или поиск пробелов, вы можете включить в шаблон специальные символы.Например, чтобы сопоставить с одним "a" , за которым следует ноль или более "b" s, за которыми следует "c" , вы должны использовать шаблон / ab * c / : * после «b» означает «0 или более вхождений предыдущего элемента». В строке «cbbabbbbcdebc» этот шаблон будет соответствовать подстроке «abbbbc» .

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

Утверждения: Утверждения включают в себя границы, которые указывают начало и конец строк и слов, а также другие шаблоны, указывающие каким-либо образом, что совпадение возможно (включая упреждающее, ретроспективное и условные выражения).
Классы символов: Различают разные типы персонажей. Например, различение букв и цифр.
Группы и диапазоны: Указывает группы и диапазоны символов выражения.
Квантификаторы: Укажите количество символов или выражений для сопоставления.
Свойство Unicode экранирует: Различать на основе свойств символов Юникода, например прописных и строчных букв, математических символов и знаков препинания.

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

Специальные символы в регулярных выражениях.
Персонажи / конструкции	Соответствующая статья
`\` , `.` , `\ cX` , `\ d` , `\ D` , `\ f` , `\ n` , `\ r` , `\ s` , `\ S` , `\ t` , `\ v` , `\ w` , `\ W` , `\ 0` , `\ xhh` , `\ uhhhh` , `\ uhhhhh` , `[\ b]`	Классы символов
`^` , `$` , `x (? = Y)` , `x (?! Y)` , `(? <= Y) x` , `(? , \ b , \ B`	Утверждения
`(x)` , `(?: X)` , `(? x)` , `x \| y` , `[xyz]` , `[^ xyz]` , `\ Номер`	Группы и диапазоны
`*` , `+` , `?` , г. `x { n }` , `x { n ,}` , `x { n , м }`	Кванторы
`\ p { UnicodeProperty }` , `\ P { Свойство Unicode }`	Свойство Unicode экранирует

Экранирование

Если вам нужно использовать какой-либо из специальных символов буквально (например, при поиске "*" ), вы должны экранировать его, поставив перед ним обратную косую черту.Например, для поиска "a" , за которым следует "*" , за которым следует "b" , вы должны использовать / a \ * b / - обратная косая черта "экранирует" "*" , делая его буквальным, а не специальным.

Точно так же, если вы пишете литерал регулярного выражения и вам нужно сопоставить косую черту ("/"), вам нужно убрать его (в противном случае он завершает шаблон). Например, для поиска строки «/ example /», за которой следует один или несколько буквенных символов, вы должны использовать / \ / example \ / [a-z] + / i - обратная косая черта перед каждой косой чертой делает их буквальными.

Чтобы соответствовать буквальной обратной косой черте, вам нужно избежать обратной косой черты. Например, чтобы соответствовать строке «C: \», где «C» может быть любой буквой, вы должны использовать / [AZ]: \\ / - первая обратная косая черта экранирует следующую после нее, поэтому выражение ищет одинарная обратная косая черта.

При использовании конструктора RegExp со строковым литералом помните, что обратная косая черта является escape-символом в строковых литералах, поэтому, чтобы использовать ее в регулярном выражении, вам нужно экранировать ее на уровне строкового литерала.$ {} () | [\] \\] / g, '\\ $ &'); }

Буква «g» после регулярного выражения - это параметр или флаг, который выполняет глобальный поиск, просматривая всю строку и возвращая все совпадения. Это подробно объясняется ниже в разделе «Расширенный поиск с помощью флагов».

Почему это не встроено в JavaScript? Есть предложение добавить такую функцию в RegExp, но оно было отклонено TC39.

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

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

Регулярные выражения используются с методами RegExp test () и exec () и с методами String match () , replace () , search () и Сплит () .

Метод	Описание
`exec ()`	Выполняет поиск совпадения в строке.Он возвращает массив информации или `null` при несоответствии.
`тест ()`	Проверяет соответствие в строке. Он возвращает `true` или `false` .
`совпадение ()`	Возвращает массив, содержащий все совпадения, включая группы захвата, или `null` , если совпадений не найдено.
`matchAll ()`	Возвращает итератор, содержащий все совпадения, включая группы захвата.
`поиск ()`	Проверяет соответствие в строке. Он возвращает индекс совпадения или `-1` , если поиск не удался.
`заменить ()`	Выполняет поиск совпадения в строке и заменяет совпавшую подстроку замещающей подстрокой.
`replaceAll ()`	Выполняет поиск всех совпадений в строке и заменяет совпавшие подстроки заменяющей подстрокой.
`раздельный ()`	Использует регулярное выражение или фиксированную строку для разбиения строки на массив подстрок.

Если вы хотите узнать, найден ли шаблон в строке, используйте методы test () или search () ; для получения дополнительной информации (но более медленного выполнения) используйте методы exec () или match () . Если вы используете exec () или match () и в случае успешного сопоставления эти методы возвращают массив и обновляют свойства связанного объекта регулярного выражения, а также предопределенного объекта регулярного выражения, RegExp .Если совпадение не удается, метод exec () возвращает null (что приводит к false ).

В следующем примере сценарий использует метод exec () для поиска совпадения в строке.

  var myRe = / d (b +) d / g;
var myArray = myRe.exec ('cdbbdbsbz');

Если вам не нужен доступ к свойствам регулярного выражения, альтернативный способ создания myArray - это сценарий:

  var myArray = / d (b +) d / g.exec ('cdbbdbsbz');

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

Если вы хотите построить регулярное выражение из строки, другой альтернативой является этот сценарий:

  var myRe = new RegExp ('d (b +) d', 'g');
var myArray = myRe.exec ('cdbbdbsbz');

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

Результат выполнения регулярного выражения.
Объект	Имущество или индекс	Описание	В этом примере
`myArray`		Соответствующая строка и все запомненные подстроки.	`['dbbd', 'bb', индекс: 1, ввод: 'cdbbdbsbz']`
	`индекс`	Отсчитываемый от 0 индекс совпадения во входной строке.	`1`
	`ввод`	Исходная строка.	`'cdbbdbsbz'`
	`[0]`	Последние совпавшие символы.	`'dbbd'`
`myRe`	`lastIndex`	Индекс, с которого начинается следующее совпадение. (Это свойство устанавливается только если в регулярном выражении используется параметр g, описанный в Расширенный поиск по флагам.)	`5`
`myRe`	`источник`	Текст выкройки. Обновлено в то время, когда регулярное выражение создается, а не выполняется.	`'d (b +) d'`

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

  var myRe = / d (b +) d / g;
var myArray = myRe.exec ('cdbbdbsbz');
console.log ('Значение lastIndex равно' + myRe.lastIndex);

Однако, если у вас есть этот сценарий:

  var myArray = /d(b+)d/g.exec('cdbbdbsbz ');
console.log ('Значение lastIndex равно' + / d (b +) d / g.lastIndex);

Вхождения / d (b +) d / g в двух операторах являются разными объектами регулярных выражений и, следовательно, имеют разные значения для своего свойства lastIndex . Если вам нужно получить доступ к свойствам регулярного выражения, созданного с помощью инициализатора объекта, вы должны сначала назначить его переменной.

Расширенный поиск с флагами

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

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

или

  var re = new RegExp ('шаблон', 'флаги');

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

Например, re = / \ w + \ s / g создает регулярное выражение, которое ищет один или несколько символов, за которыми следует пробел, и ищет эту комбинацию по всей строке. и $ соответствуют началу или концу любой строки во входной строке, а не началу или концу всей строки.

Использование флага глобального поиска с exec ()

Поведение, связанное с флагом g , отличается при использовании метода .exec () . Роли «класса» и «аргумента» меняются местами: в случае .match () строковый класс (или тип данных) владеет методом, а регулярное выражение является просто аргументом, тогда как в случае .exec () , это регулярное выражение, которому принадлежит метод, а строка является аргументом. Сравните это str.match (re) с re.exec (str) . Флаг g используется с методом .exec () для получения итеративной прогрессии.

  var xArray; в то время как (xArray = re.exec (str)) console.log (xArray);

Примечание: Несколько примеров также доступны в:

Справочные страницы для exec () , test () , match () , matchAll () , search () , replace () , split ()
Статьи этого руководства: классы символов, утверждения, группы и диапазоны, квантификаторы, экранирование свойств Unicode

Использование специальных символов для проверки ввода

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

Регулярное выражение ищет:

три цифровых символа \ d {3} OR | левая скобка \ (, за которой следуют три цифры \ d {3} , за которой следует закрывающая скобка \) , в группе без захвата (? :)
, за которым следует один дефис, косая черта или десятичная точка в группе захвата ()
, за которым следуют три цифры \ d {3}
, за которым следует совпадение, записанное в (первой) захваченной группе \ 1
, за которым следуют четыре цифры \ d {4}

Событие click активируется, когда пользователь нажимает Enter устанавливает значение phoneInput.значение .

HTML

  
  Введите свой номер телефона (с кодом города) и нажмите «Проверить».
  

  Ожидаемый формат такой: ### - ### - ####.


  <вход>

JavaScript

  var re = /(?:\d{3}|\(\d{3}\))([-\/\.pting)\d{3}\1\d{4}/;
function testInfo (phoneInput) {
  var OK = re.exec (phoneInput.ценить);
  var out = document.querySelector ('# out');
  if (! OK) {
    out.textContent = `$ {phoneInput.value} не является номером телефона с кодом зоны!`;
  } еще {
    out.textContent = `Спасибо, ваш номер телефона $ {OK [0]}`;
  }
}

Результат

Шпаргалка по синтаксису регулярных выражений — JavaScript

`.`	Имеет одно из следующих значений: Соответствует любому одиночному символу , кроме терминаторов строки : `\ n` , `\ r` , `\ u2028` или `\ u2029` .] можно использовать — он соответствует любому символу включая новые строки. ES2018 добавил флаг `s` «dotAll», который позволяет точке также совпадают с терминаторами строк.
`\ д`	Соответствует любой цифре (арабской цифре). Эквивалент `[0-9]` . Например, `/ \ d /` или `/ [0-9] /` соответствует «2» в «B2 — номер сюиты».0-9] / соответствует «B» в «B2 — номер набора».
`\ w`	Соответствует любому буквенно-цифровому символу основного латинского алфавита, включая подчеркивание. Эквивалент `[A-Za-z0-9_]` . Для Например, `/ \ w /` соответствует «a» в «яблоке», «5» в «5,28 доллара США» и «3» в «3D».
`\ Вт`	Соответствует любому символу, кроме словесного символа из основного Латинский алфавит.A-Za-z0-9 _] / соответствует «%» в «50%».
`\ с`	Соответствует одиночному символу пробела, включая пробел, табуляцию, форму фид, перевод строки и другие пробелы Unicode. Эквивалентно `[ \ f \ n \ r \ t \ v \ u00a0 \ u1680 \ u2000- \ u2028 \ u2029 \ u202f \ u205f \ u3000 \ ufeff]`. Например, `/ \ s \ w * /` соответствует «bar» в «foo bar».
`\ S`	Соответствует одиночному символу, кроме пробела.\ f \ n \ r \ t \ v \ u00a0 \ u1680 \ u2000- \ u2028 \ u2029 \ u202f \ u205f \ u3000 \ ufeff] . Например, `/ \ S \ w * /` соответствует «foo» в «foo bar».
`\ т`	Соответствует горизонтальной табуляции.
`\ r`	Соответствует возврату каретки.
`\ п`	Соответствует переводу строки.
`\ v`	Соответствует вертикальной табуляции.
`\ f`	Соответствует подаче формы.
`[\ b]`	Соответствует пробелу. Если вы ищете символ границы слова ( `\ b` ), см. Границы.
`\ 0`	Соответствует символу NUL. Не добавляйте после этого другую цифру.
`\ c X`	Соответствует управляющему символу с помощью обозначение каретки, где «X» — буква от A до Z (соответствует кодовым точкам `U + 0001` — `U + 001F` ).Например, `/ \ cM /` соответствует «\ r» в «\ r \ n».
`\ x hh`	Соответствует символу с кодом `hh` (два шестнадцатеричные цифры).
`\ u хххх`	Соответствует кодовой единице UTF-16 со значением `хххх` (четыре шестнадцатеричных цифры).
`\ u {хххх} или \ u {ххххх}`	(Только когда установлен флаг `u` .) Соответствует символу с значение Unicode `U + hhhh` или `U + hhhhh` (шестнадцатеричные цифры).
`\`	Указывает, что следующий символ требует особого обращения, или «сбежал». Он ведет себя одним из двух способов. Для символов, которые обычно трактуются буквально, означает, что следующий символ является особенным и не должен интерпретироваться буквально.Например, `/ b /` соответствует символу «b». Поместив обратная косая черта перед «b», то есть при использовании `/ \ b /` , символ становится специальным, чтобы обозначать соответствие границе слова. Для символов, которые обычно обрабатываются особым образом, означает, что следующий символ не является особенным и должен интерпретироваться буквально. Например, «» — это специальный символ, который означает 0 или должны совпадать больше вхождений предыдущего символа; для Например, `/ a /` означает соответствие 0 или более «a».Чтобы соответствовать `` буквально, перед ним стоит обратная косая черта; Например, `/ a \ /` соответствует «a ». Обратите внимание, что некоторые символы, такие как `:` , `-` , `@` и т. Д. Не имеют особого значения при экранировании и когда не экранирован. Последовательности выхода, такие как `\:` , `\ -` , `\ @` будет эквивалентно их литералу, неэкранированные эквиваленты символов в регулярных выражениях.Однако в регулярные выражения с unicode, это вызовет ошибку недопустимого выхода идентификатора* . Это сделано для обеспечения обратной совместимости с существующим кодом, использующим новый escape-последовательности, например `\ p` или `\ k` . Примечание: Чтобы буквально соответствовать этому символу, экранируйте его. с собой. Другими словами, для поиска `\` используйте `/ \\ /` .

Классы символов — JavaScript | MDN

`.`	Имеет одно из следующих значений: Соответствует любому одиночному символу , кроме терминаторов строки : `\ n` , `\ r` , `\ u2028` или `\ u2029` . Например, `/.y/` соответствует «мой» и «ау», но не «да», в «да, сделай мой день».] можно использовать — он соответствует любому символу включая новые строки. ES2018 добавил флаг `s` «dotAll», который позволяет точке также совпадают с терминаторами строк.
`\ д`	Соответствует любой цифре (арабской цифре). Эквивалент `[0-9]` . Например, `/ \ d /` или `/ [0-9] /` соответствует «2» в «B2 — номер сюиты».0-9] / соответствует «B» в «B2 — номер набора».
`\ w`	Соответствует любому буквенно-цифровому символу основного латинского алфавита, включая подчеркивание. Эквивалент `[A-Za-z0-9_]` . Для Например, `/ \ w /` соответствует «a» в «яблоко», «5» в «5,28 доллара США», «3». в «3D» и «м» в «Эмануэль».
`\ Вт`	Соответствует любому символу, кроме словесного символа из основного Латинский алфавит.A-Za-z0-9 _] / соответствует «%» в «50%» и «É» в «Эмануэль».
`\ с`	Соответствует одиночному символу пробела, включая пробел, табуляцию, форму фид, перевод строки и другие пробелы Unicode. Эквивалентно `[ \ f \ n \ r \ t \ v \ u00a0 \ u1680 \ u2000- \ u2028 \ u2029 \ u202f \ u205f \ u3000 \ ufeff]`. Например, `/ \ s \ w * /` соответствует «bar» в «foo bar».
`\ S`	Соответствует одиночному символу, кроме пробела.\ f \ n \ r \ t \ v \ u00a0 \ u1680 \ u2000- \ u2028 \ u2029 \ u202f \ u205f \ u3000 \ ufeff] . Например, `/ \ S \ w * /` соответствует «foo» в «foo bar».
`\ т`	Соответствует горизонтальной табуляции.
`\ r`	Соответствует возврату каретки.
`\ п`	Соответствует переводу строки.
`\ v`	Соответствует вертикальной табуляции.
`\ f`	Соответствует подаче формы.
`[\ b]`	Соответствует пробелу. Если вы ищете символ границы слова ( `\ b` ), см. Утверждения.
`\ 0`	Соответствует символу NUL. Не добавляйте после этого другую цифру.
`\ c X`	Соответствует управляющему символу с помощью обозначение каретки, где «X» — буква от A до Z (соответствует кодовым точкам `U + 0001` — `U + 001A` ).Например, `/ \ cM \ cJ /` соответствует «\ r \ n».
`\ x hh`	Соответствует символу с кодом `hh` (два шестнадцатеричные цифры).
`\ u хххх`	Соответствует кодовой единице UTF-16 со значением `хххх` (четыре шестнадцатеричных цифры).
`\ u {хххх} или \ u {ххххх}`	(Только когда установлен флаг `u` .) Соответствует символу с значение Unicode `U + hhhh` или `U + hhhhh` (шестнадцатеричные цифры).
`\ p { UnicodeProperty }` , `\ P { Свойство Unicode }`	Соответствует персонажу на основе его Свойства символов Юникода (для соответствия, например, символам эмодзи или японскому катакана символов или китайские / японские символы хань / кандзи, и т.п.).
`\`	Указывает, что следующий символ требует особого обращения, или «сбежал». Он ведет себя одним из двух способов. Для символов, которые обычно трактуются буквально, означает, что следующий символ является особенным и не должен интерпретироваться буквально. Например, `/ b /` соответствует символу «b». Поместив обратная косая черта перед «b», то есть при использовании `/ \ b /` , символ становится специальным, чтобы обозначать соответствие границе слова. Для символов, которые обычно обрабатываются особым образом, означает, что следующий символ не является особенным и должен интерпретироваться буквально. Например, «» — это специальный символ, который означает 0 или должны совпадать больше вхождений предыдущего символа; для Например, `/ a /` означает соответствие 0 или более «a». Чтобы соответствовать `` буквально, перед ним стоит обратная косая черта; Например, `/ a \ /` соответствует «a ». Примечание:* Чтобы буквально соответствовать этому символу, экранируйте его. с собой. Другими словами, для поиска `\` используйте `/ \\ /` .

Утверждения — JavaScript | MDN

Утверждения включают в себя границы, которые указывают начало и конец строк и слов, а также другие шаблоны, указывающие каким-либо образом, что совпадение возможно (включая упреждающий просмотр, ретроспективный просмотр и условные выражения).A / не соответствует «A» в «A», но соответствует первая «А» в «Ан А».

Примечание: Этот символ имеет другое значение, когда он появляется в начале группа.

$

Соответствует концу ввода. Если для многострочного флага установлено значение true, также соответствует непосредственно перед символом разрыва строки.Например, / t $ / не соответствует букве «t» в слове «eater», но соответствует ей в «есть».

\ б

Соответствует границе слова. Это позиция, в которой символ слова не следует за другим словом-символом и не предшествует ему, например, между буква и пробел. Обратите внимание, что граница совпадающего слова не включен в матч. Другими словами, длина совпадающего слова граница нулевая.

Примеры:

/ \ bm / соответствует букве «м» в слове «луна».
/ oo \ b / не соответствует «oo» в «moon», потому что «oo» за ним следует «n», который является символом слова.
/ oon \ b / соответствует «oon» в «moon», потому что «oon» — это конец строки, за которым не следует символ слова.
/ \ w \ b \ w / никогда ничего не найдет, потому что слово за символом никогда не может идти ни слово, ни слово персонаж.

Чтобы сопоставить символ обратного пробела ( [\ b] ), см. Классы персонажей.

\ B

Соответствует границе, не являющейся словом. Это позиция, в которой предыдущие и следующий символ того же типа: либо оба должны быть словами, либо оба должны быть не словами, например, между двумя буквами или между двумя пробелы.Начало и конец строки не считаются словами. Так же, как и совпадающая граница слова, совпадающая несловая граница тоже не попал в матч. Например, / \ Bon / соответствует «на» в «в полдень», и / ye \ B / соответствует «ye» в «возможно вчера».

Другие утверждения

Примечание: ? Символ также может использоваться в качестве квантификатора.

Персонажи	Значение
`x (? = Y)`	Утверждение Lookahead: Соответствует «x», только если «x» равно за которым следует «у». Например, / `Jack (? = Sprat) /` соответствует «Джек», только если за ним следует «Килька». `/ Джек (? = Килька \| Мороз) /` соответствует «Джек», только если за ним следует «Килька» или «Мороз». Тем не мение, Ни «Килька», ни «Мороз» в результатах матча не фигурируют.
`х (?! У)`	Утверждение отрицательного просмотра вперед: Соответствует «x», только если «x» не следует за «y». Например, `/\d+(?!\.)/` соответствует число, только если за ним не стоит десятичная точка. `/\d+(?!\.)/.exec('3.141 ')` соответствует «141», но не «3».
`(? <= Y) x`	Утверждение просмотра назад: Соответствует "x", только если "x" равно перед "y".Например, `/ (? <= Jack) Sprat /` соответствует "Sprat", только если это предшествует «Джек». `/ (? <= Jack \| Tom) Sprat /` совпадений «Килька», только если ей предшествует «Джек» или «Том». Однако ни «Джек» и «Том» не фигурируют в результатах матча.
`(?`	Утверждение об отрицательном просмотре назад: Соответствует "x", только если «x» не предшествует «y».Например, `/ (? соответствует числу, только если это не так перед знаком минус. /(? соответствует «3». /(? совпадение не соответствует найдено, потому что перед числом стоит знак минус.`

Общий пример обзора типа границы

 
buggyMultiline = `яблоко светло-серого цвета
запахи на греческой трапе;


buggyMultiline = buggyMultiline.А] /. Тест (плод));

console.log (fruitStartsWithNotA);

Соответствие границе слова

  let fruitWithDescription = [«Красное яблоко», «Оранжевый апельсин», «Зеленый авокадо»];


let enEdSelection = fruitWithDescription.filter (descr => /(en|ed)\b/.test(descr));

console.log (enEdSelection);

Утверждение опережающего просмотра

 

пусть regex = / First (? = test) / g;

console.log ('Первый тест'. ?!] .?!] + [?!] / gi
console.log (orangeNotLemon.match (selectNotOrangeRegex));

Утверждение просмотра назад

  let апельсины = ['спелый апельсин A', 'зеленый апельсин B', 'спелый апельсин C',];

let ripe_oranges = oranges.filter (fruit => fruit.match (/ (? <= спелый) апельсин /));
console.log (ripe_oranges);

RegExp - JavaScript | MDN

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

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

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

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

  пусть re = / ab + c / i;
пусть re = new RegExp ('ab + c', 'i')
пусть re = new RegExp (/ ab + c /, 'i')

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

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

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

Начиная с ECMAScript 6, new RegExp (/ ab + c /, 'i') больше не генерирует TypeError ( "не может предоставить флаги при построении одного RegExp из другого" ), когда первым аргументом является RegExp , а вторым flags аргумент присутствует. Вместо этого создается новое RegExp из аргументов.

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

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

  пусть re = / \ w + /
пусть re = new RegExp ('\\ w +')

Perl-подобные свойства RegExp

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

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

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

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

  пусть re = / (\ w +) \ s (\ w +) /
let str = 'Джон Смит'
пусть newstr = str.replace (re, '$ 2, $ 1')
console.log (новая строка)

Отображается «Смит, Джон» .

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

Окончание строки по умолчанию зависит от платформы (Unix, Windows и т. Д.)]*день/);

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

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

  let str = '# foo #'
пусть регулярное выражение = / foo / y

regex.lastIndex = 1
regex.test (str)
regex.lastIndex = 5
regex.test (str)
regex.lastIndex

Разница между липким флагом и глобальным флагом

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

  рэ = / \ д / у;
в то время как (r = re.exec ("123 456")) console.log (r, "И re.lastIndex", re.lastIndex);

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

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

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

Для сопоставления символов из других языков, таких как кириллица или иврит, используйте \ uhhhh , где hhhh - это значение Unicode символа в шестнадцатеричном формате.

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

  let text = 'Образец текста на русском языке'
пусть регулярное выражение = / [\ u0400- \ u04FF] + / g

let match = regex.exec (текст)
console.log (совпадение [0])
console.log (regex.lastIndex)

пусть match3 = regex.exec (текст)
console.log (match3 [0])
console.log (regex.lastIndex)

Функция экранирования свойств Unicode предлагает решение, позволяя использовать такой простой оператор, как \ p {scx = Cyrl} ..] + /. exec (url) [0] .substr (7))

Примечание: Вместо использования регулярных выражений для синтаксического анализа URL-адресов обычно лучше использовать встроенный в браузеры анализатор URL-адресов с помощью API URL-адресов.

Таблицы BCD загружаются только в браузере

Примечания для Firefox

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

 
'Икс'.replace (/ x (.)? / g, function (m, group) {
  console.log ("'группа:" + группа + "'");
});



'x'.replace (/ x (.)? / g, function (m, group) {
  console.log ("'группа:" + группа + "'");
});

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

Ссылка на регулярное выражение JavaScript

Объект RegExp

Регулярное выражение - это объект, описывающий набор символов.

Регулярные выражения используются для сопоставления с образцом и Функции поиска и замены в тексте.

Синтаксис

Объяснение примера:

/ w3schools / i - регулярное выражение.
w3schools - шаблон (для поиска).
i - модификатор (изменяет поиск без учета регистра).

Учебное пособие по регулярным выражениям см. В нашем учебном пособии по JavaScript RegExp.

Модификаторы

Модификаторы используются для выполнения глобального поиска без учета регистра:

Модификатор	Описание
г	Выполнить глобальное сопоставление (найти все совпадения, а не останавливаться после первого совпадения)
и	Выполнить сопоставление без учета регистра
м	Выполнение многострочного сопоставления

Кронштейны

Скобки используются для поиска диапазона символов:

Выражение	Описание
[abc]	Найдите любой символ в скобках
[^ abc]	Найдите любой символ НЕ в скобках
[0-9]	Найдите любой символ в скобках (любую цифру)
[^ 0-9]	Найдите любой символ, НЕ заключенный в скобки (любой нецифровой)
(х \| у)	Найдите любую из указанных альтернатив

Метасимволы

Метасимволы - это символы со специальным значением:

Метасимвол	Описание
.	Найти один символ, кроме символа новой строки или символа конца строки
\ w	Найти символ слова
\ Вт	Найдите символ, не являющийся словом
\ д	Найдите цифру
\ D	Найти нецифровой символ
\ с	Найти пробел
\ S	Найти непробельный символ
\ б	Найдите совпадение в начале / конце слова, начинающегося так: \ bHI, заканчиваться так: HI \ b
\ B	Найдите совпадение, но не в начале / конце слова
\ 0	Найти нулевой символ
\ п	Найти новый строчный символ
\ f	Найти символ подачи страницы
\ r	Найти символ возврата каретки
\ т	Найдите символ табуляции
\ в	Найдите символ вертикальной табуляции
\ xxx	Найдите символ, указанный в восьмеричном числе xxx
\ xdd	Найдите символ, заданный шестнадцатеричным числом dd
=	Найдите символ Юникода, заданный шестнадцатеричным числом dddd

Квантификаторы

Квантификатор	Описание
п +	Соответствует любой строке, содержащей хотя бы один n
n *	Соответствует любой строке, содержащей ноль или более вхождений n
n?	Соответствует любой строке, содержащей ноль или одно вхождение n
n {X}	Соответствует любой строке, содержащей последовательность X n
n {X, Y}	Соответствует любой строке, содержащей последовательность от X до Y n
n {X,}	Соответствует любой строке, содержащей последовательность не менее X n
n $	Соответствует любой строке с n в конце
^ n	Соответствует любой строке с n в начале
? = N	Соответствует любой строке, за которой следует определенная строка n
?! П	Соответствует любой строке, за которой не следует конкретная строка n

Свойства объекта RegExp

Имущество	Описание
конструктор	Возвращает функцию, создавшую прототип объекта RegExp
по всему миру	Проверяет, установлен ли модификатор "g"
ignoreCase	Проверяет, установлен ли модификатор "i"
lastIndex	Задает индекс, с которого начинается следующее совпадение
многострочный	Проверяет, установлен ли модификатор «m»
источник	Возвращает текст шаблона RegExp

Методы объекта RegExp

Метод	Описание
компиляция ()	Не рекомендуется в версии 1.5. Компилирует регулярное выражение
exec ()	Проверяет соответствие в строке. Возвращает первое совпадение
тест ()	Проверяет соответствие в строке. Возвращает истину или ложь
toString ()	Возвращает строковое значение регулярного выражения

Тестер регулярных выражений - Javascript, PCRE, PHP

Классы символов
.abc $	начало / конец строки
\ б	граница слова
Экранированные символы
\. \ * \\	экранированные специальные символы
\ t \ n \ r	табуляция, перевод строки, возврат каретки
\ u00A9	экранированный код Юникода ©
Группы и поиск
(abc)	группа захвата
\ 1	обратная ссылка на группу №1
(?: Abc)	группа без захвата
(? = Abc)	положительный прогноз
(?! Abc)	негативный прогноз
Квантификаторы и чередование
а * а + а?	0 или более, 1 или более, 0 или 1
а {5} а {2,}	ровно пять, два или больше
a {1,3}	между одним и тремя
а +? а {2,}?	совпадений как можно меньше
ab \| cd	соответствует ab или cd