Шпаргалка по регулярным выражениям. в примерах

Специальные последовательности

Специальные последовательности упрощают написание часто используемых шаблонов. Вот список специальных последовательностей:

— Соответствует, если указанные символы находятся в начале строки.

Выражение	Строка	Совпадения
		Совпадает
	Не совпадает

— Соответствует, если указанные символы находятся в начале или в конце слова.

Выражение	Строка	Совпадения
		Совпадает
	Совпадает
		Не совпадает
	Совпадает
	Совпадает
	Не совпадает

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

Выражение	Строка	Совпадения
		Не совпадает
	Не совпадает
		Совпадает
	Не совпадает
	Не совпадает
	Совпадает

— Соответствует любой десятичной цифре. Эквивалентно

Выражение	Строка	Совпадения
		3 совпадения (в )
	Не совпадает

— Соответствует любой не десятичной цифре. Эквивалентно

Выражение	Строка	Совпадения
		3 совпадения (в )
	Не совпадает

— Соответствует строкам, содержащим любой пробельный символ. Эквивалентно .

Выражение	Строка	Совпадения
		1 Совпадает
	Не совпадает

— Соответствует строкам, содержащим любой непробельный символ. Эквивалентно .

Выражение	Строка	Совпадения
		2 совпадения (в )
	Не совпадает

— Соответствует любому буквенно-цифровому символу (цифрам и алфавитам). Эквивалентно . Кстати, подчеркивание тоже считается буквенно-цифровым символом.

Выражение	Строка	Совпадения
		3 совпадения (в )
	Не совпадает

— Соответствует любому не буквенно-цифровому символу. Эквивалентно

Выражение	Строка	Совпадения
		1 Совпадает (в )
	Не совпадает

— Соответствует, если указанные символы находятся в конце строки.

Выражение	Строка	Совпадения
		1 Совпадает
	Не совпадает
	Не совпадает

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

Определение регулярных выражений

В JavaScript регулярные выражения представлены объектом , который является нативным объектом JavaScript, таким как , и так далее. Существует два способа создания нового объекта RegExp: один использует литеральный синтаксис, а другой — конструктор .

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

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

При использовании синтаксиса конструктора необходимо дважды экранировать специальные символы; это означает, что для поиска «.» вам нужно написать вместо . Если есть только один обратный слеш, он будет интерпретирован синтаксическим анализатором строк JavaScript как экранирующий символ и будет удален.

Улучшена поддержка юникода

Внутренняя кодировка строк в JavaScript – это UTF-16, то есть под каждый символ отводится ровно два байта.

Но под всевозможные символы всех языков мира 2 байт не хватает. Поэтому бывает так, что одному символу языка соответствует два юникодных символа (итого 4 байта). Такое сочетание называют «суррогатной парой».

Самый частый пример суррогатной пары, который можно встретить в литературе – это китайские иероглифы.

Заметим, однако, что не всякий китайский иероглиф – суррогатная пара. Существенная часть «основного» юникод-диапазона как раз отдана под китайский язык, поэтому некоторые иероглифы – которые в неё «влезли» – представляются одним юникод-символом, а те, которые не поместились (реже используемые) – двумя.

Например:

В тексте выше для первого иероглифа есть отдельный юникод-символ, и поэтому длина строки , а для второго используется суррогатная пара. Соответственно, длина – .

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

Ими представлены редкие математические символы, а также некоторые символы для эмоций, к примеру:

В современный JavaScript добавлены методы String.fromCodePoint и str.codePointAt – аналоги и , корректно работающие с суррогатными парами.

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

…В то время как возвращает его Unicode-код суррогатной пары правильно:

Метод корректно создаёт строку из «длинного кода», в отличие от старого .

Например:

Более старый метод в последней строке дал неверный результат, так как он берёт только первые два байта от числа и создаёт символ из них, а остальные отбрасывает.

Есть и ещё синтаксическое улучшение для больших Unicode-кодов.

В JavaScript-строках давно можно вставлять символы по Unicode-коду, вот так:

Синтаксис: , где – четырёхзначный шестнадцатиричный код, причём он должен быть ровно четырёхзначным.

«Лишние» цифры уже не войдут в код, например:

Чтобы вводить более длинные коды символов, добавили запись , где – максимально восьмизначный (но можно и меньше цифр) код.

Например:

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

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

Для генерации произвольных сочетаний используются несколько юникодных символов: основа и один или несколько значков.

Например, если после символа идёт символ «точка сверху» (код ), то показано это будет как «S с точкой сверху» .

Если нужен ещё значок над той же буквой (или под ней) – без проблем. Просто добавляем соответствующий символ.

К примеру, если добавить символ «точка снизу» (код ), то будет «S с двумя точками сверху и снизу» .

Пример этого символа в JavaScript-строке:

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

Вот пример:

В первой строке после основы идёт сначала значок «верхняя точка», а потом – нижняя, во второй – наоборот. По кодам строки не равны друг другу. Но символ задают один и тот же.

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

В современном JavaScript это делает метод str.normalize().

Забавно, что в данной конкретной ситуации приведёт последовательность из трёх символов к одному: \u1e68 (S с двумя точками).

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

Для большинства практических задач информации, данной выше, должно быть вполне достаточно, но если хочется более подробно ознакомиться с вариантами и правилами нормализации – они описаны в приложении к стандарту юникод Unicode Normalization Forms.

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

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

Это значит, что литерал нельзя изменить динамически, в то время как конструктор — можно.

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

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

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

regexp.test(str)

Метод ищет совпадение и возвращает , в зависимости от того, находит ли он его.

Например:

Пример с отрицательным ответом:

Если регулярное выражение имеет флаг , то ищет, начиная с и обновляет это свойство, аналогично .

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

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

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

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

Это именно потому, что во втором тесте не равен нулю.

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

Операторы для работы с регулярными выражениями в Javascript

exec(regexp) — находит все совпадения (вхождения в шаблон «регулярки») в строке. Возвращает массив (при совпадении) и обновляет свойство regexp-а, или null — если ничего не найдено,.
С модификатором g — при каждом вызове этой функции, она будет возвращать следующее совпадение после предыдущего найденного — это реализовано с помощью ведения индекса смещения последнего поиска.

match(regexp) — найти часть строки по шаблону. Если указан модификатор g, то функция match() возвращает массив всех совпадений или null (а не пустой массив). Без модификатора g эта функция работает как exec();

test(regexp) — функция проверяет строку на соответствие шаблону. Возвращает true — если есть совпадение, и false — если совпадения нет.

replace(regexp, mix) — метод возвращает строку изменную в соответствии с шаблоном (регуляррным выражением). Первый параметр regexp также может содержать строку, а не регулярное выражение. Без модификатора g — метод в строке заменяет только первое вхождение; с модификатором g — происходит глобальная замена, т.е. меняются все вхождения в данной строке. mix — шаблон замены, может принитать значения строки, шаблона замены, функции (имя функции).

Стоит подробнее остановиться на методе replace(), его второй параметр mix нужно описать более детально.

Если второй параметр mix содержит строку, то мы можем использовать следующие спецсимволы:

• $$ — вставить $;
• $& — совпавшая подстрока;
• $` — часть строки перед совпавшей подстроки;
• $’ — часть строки после совпавшей подстроки;
• $n ($nn) — значение n-ой запоминающей скобки (если первый аргумент — объект RegExp);

Если второй параметр mix содержит функцию, то она будет вызванна при каждом совпадении. Значением для замены будет результат работы функции, т.е. return »;

Примеры таких функции:

Следующий вызов replace возвратит XXzzzz — XX , zzzz.

Как видите, тут две скобки в регулярном выражении, и потому в функции два параметра p1, p2.
Если бы были три скобки, то в функцию пришлось бы добавить параметр p3.

Следующая функция заменяет слова типа borderTop на border-top:

function styleHyphenFormat(propertyName)
{
  function upperToHyphenLower(match)
  {
    return '-' + match.toLowerCase();
  }
  return propertyName.replace(//, upperToHyphenLower);
}

Таким блоком кода я разбираю javascript вхождения в html:

Класс RegExp

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

RegExp(Регулярное выражение, Флаги)

Он принимает только один обязательный пареметр — это «Регулярное выражение», которое заключается в кавычки.
Параметр «флаги» представляет собой дополнительные условия поиска и может принимать значения:

• g — задается глобальный поиск, если этот флаг установлен, то выражение возвратит все подходящие слова.
• i — игнорирование регистра символов
• m — многострочный поиск

Для работы с регулярными варажениями используются три метода класса String:

• match — выполняет поиск в строке, используя регулярное выражение, переданное в качестве параметра
  и возвращает массив с результатами поиска. Если ничего не найдено, возвращается null.
• replace — выполняет поиск и замену в строке, используя регулярные выражения, и возвращает полученную строку.
• search — выполняет поик в строке, используя регулярное выражение, переданное в качестве параметра,
  и возвращает позицию первой подстроки, совпадающей с регулярным выражением.

Свойства

Свойство	Описание
lastIndex	Задает позицию начала поиска в строке
sourse	Возвращает строку регулярного выражения (только чтение)
global	Определяет наличие флага g и возвращает соответсявенно true или false
ignoreCase	Определяет наличие флага i и возвращает соответсявенно true или false
multilane	Определяет наличие флага m и возвращает соответсявенно true или false

Методы

Метод	Описание
compile (Регулярное выражение g,i,m)	Компилирует регулярное выражение во внутренний формат для ускорения работы, может использоваться для изменения регулярного выражения
exec(строка)	Аналогичен методу match класса String, но строка, где нужно произвести поиск, передается в качестве параметра
test(строка)	Аналогичен методу search класса String, возвращает true или false в зависимости о результатов поиска

Пример

Здесь этот участок скрипта производит поиск текста «www» в строке, которая была присвоена переменной «str» без учета регистра,
а метод match возвращает массив result, содержащий результаты поиска.

JavaScript Regular Expression Methods

As mentioned above, you can either use  or regular expression literal to create a RegEx in JavaScript.

In JavaScript, you can use regular expressions with methods:  and .

There are also some string methods that allow you to pass RegEx as its parameter. They are: , , , and .

Method	Description
	Executes a search for a match in a string and returns an array of information. It returns null on a mismatch.
	Tests for a match in a string and returns true or false.
	Returns an array containing all the matches. It returns null on a mismatch.
	Returns an iterator containing all of the matches.
	Tests for a match in a string and returns the index of the match. It returns -1 if the search fails.
	Searches for a match in a string and replaces the matched substring with a replacement substring.
	Break a string into an array of substrings.

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

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

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

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

str.replace(str|regexp, str|func)

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

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

Хотя есть подводный камень.

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

Вы можете видеть это в приведённом выше примере: только первый заменяется на .

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

Второй аргумент – строка замены. Мы можем использовать специальные символы в нем:

Спецсимволы	Действие в строке замены
	вставляет
	вставляет всё найденное совпадение
	вставляет часть строки до совпадения
	вставляет часть строки после совпадения
	если это 1-2 значное число, то вставляет содержимое n-й скобки
	вставляет содержимое скобки с указанным именем

Например:

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

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

Функция вызывается с аргументами :

1. – найденное совпадение,
2. – содержимое скобок (см. главу Скобочные группы).
3. – позиция, на которой найдено совпадение,
4. – исходная строка,
5. – объект с содержимым именованных скобок (см. главу Скобочные группы).

Если скобок в регулярном выражении нет, то будет только 3 аргумента: .

Например, переведём выбранные совпадения в верхний регистр:

Заменим каждое совпадение на его позицию в строке:

В примере ниже две скобки, поэтому функция замены вызывается с 5-ю аргументами: первый – всё совпадение, затем два аргумента содержимое скобок, затем (в примере не используются) индекс совпадения и исходная строка:

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

Или, если мы используем именованные группы, то объект с ними всегда идёт последним, так что можно получить его так:

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

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

a(bc)       создаём группу со значением bc -> тестa(?:bc)*    оперетор ?: отключает группу -> тестa(?<foo>bc) так, мы можем присвоить имя группе -> тест

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

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

Всесильные регулярные выражения и их особенности

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

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

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

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

Вот пример тестирования на валидность мобильного номера вида (+ХХХХХХХХХХХХ):

Также с помощью шаблонов можно производить поиск совпадений слов/выражений в тексте с искомым значением.

Строковые методы, поиск и замена

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

Все методы, кроме replace, можно вызывать как с объектами типа regexp в аргументах, так и со строками, которые автоматом преобразуются в объекты RegExp.

Так что вызовы эквивалентны:

var i = str.search(/\s/)
var i = str.search("\\s")

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

var regText = "\\s"
var i = str.search(new RegExp(regText, "g"))

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

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

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

function testinput(re, str){
   if (str.search(re) != -1)
      midstring = " contains ";
   else
      midstring = " does not contain ";
   document.write (str + midstring + re.source);
}

Если в regexp нет флага , то возвращает тот же результат, что .

Если в regexp есть флаг , то возвращает массив со всеми совпадениями.

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

Если Вы хотите получить первый результат — попробуйте r.

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

str = "For more information, see Chapter 3.4.5.1";
re = /chapter (\d+(\.\d)*)/i;
found = str.match(re);
alert(found);

Скрипт выдаст массив из совпадений:

• Chapter 3.4.5.1 — полностью совпавшая строка
• 3.4.5.1 — первая скобка
• .1 — внутренняя скобка

Следующий пример демонстрирует использование флагов глобального и регистронезависимого поиска с . Будут найдены все буквы от А до Е и от а до е, каждая — в отдельном элементе массива.

var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var regexp = //gi;
var matches = str.match(regexp);
document.write(matches);

// matches = 

Метод replace может заменять вхождения регулярного выражения не только на строку, но и на результат выполнения функции. Его полный синтаксис — такой:

var newString = str.replace(regexp/substr, newSubStr/function)

Объект RegExp. Его вхождения будут заменены на значение, которое вернет параметр номер 2

Строка, которая будет заменена на .

Строка, которая заменяет подстроку из аргумента номер 1.

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

Метод не меняет строку, на которой вызван, а просто возвращает новую, измененную строку.

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

Если первый аргумент — строка, то она не преобразуется в регулярное выражение, так что, например,

var ab = "a b".replace("\\s","..") // = "a b"

Вызов replace оставил строку без изменения, т.к искал не регулярное выражение , а строку «\s».

В строке замены могут быть такие спецсимволы:

Pattern	Inserts
	Вставляет «$».
	Вставляет найденную подстроку.
	Вставляет часть строки, которая предшествует найденному вхождению.
	Вставляет часть строки, которая идет после найденного вхождения.
or	Где или — десятичные цифры, вставляет подстроку вхождения, запомненную -й вложенной скобкой, если первый аргумент — объект RegExp.

Если Вы указываете вторым параметром функцию, то она выполняется при каждом совпадении.

В функции можно динамически генерировать и возвращать строку подстановки.

Первый параметр функции — найденная подстрока. Если первым аргументом является объект , то следующие параметров содержат совпадения из вложенных скобок. Последние два параметра — позиция в строке, на которой произошло совпадение и сама строка.

Например, следующий вызов возвратит XXzzzz — XX , zzzz.

function replacer(str, p1, p2, offset, s)
{
return str + " - " + p1 + " , " + p2;
}
var newString = "XXzzzz".replace(/(X*)(z*)/, replacer)

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

Следующая функция заменяет слова типа на :

function styleHyphenFormat(propertyName)
{
  function upperToHyphenLower(match)
  {
    return '-' + match.toLowerCase();
  }
  return propertyName.replace(//, upperToHyphenLower);
}

Могущество match

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

Однако JavaScript на самом деле действует более ловко: в действительности он возвращает объект, который содержит гораздо больше информации, если найдено совпадение, и , если совпадение не найдено:

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

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

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

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

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

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

Итого

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

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

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

Но обычно регулярные выражения удобнее.

Виды проверок:

Шаблон	Тип	Совпадение
	Позитивная опережающая	, если за ним следует
	Негативная опережающая	, если за ним НЕ следует
	Позитивная ретроспективная	, если следует за
	Негативная ретроспективная	, если НЕ следует за