11 материалов по регулярным выражениям


Оглавление (нажмите, чтобы открыть):

Учебник: Регулярные выражения (regular expressions)

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

  • Вы пишете программу, в которой обрабатываются номера телефонов, допустим в формате +7(ххх)ххх-хх-хх. Возможно их надо найти в тексте, а может быть — проверить корректность. На месте номеров могли бы быть номер банковской карты, IP-адрес, электронная почта, ФИО (в формате Петров А.Ю.), да и вообще что угодно.
  • В Microsoft Word при поиске и замене можно включить режим поддержки регулярных выражений поставив галочку напротив пункта «подстановочные знаки». Потом можно искать все то, что указано в первом пункте, но программу писать не требуется. И заменять можно. В LibreOffice/OpenOffice это тоже поддерживается.
  • Естественно, регулярные выражения поддерживаются во всех современных средах разработки — Qt Creator, Microsoft Visual Studio, NetBeans, IntelliJ IDEA и даже блокнотах — Notepad++, kate, gedit и др. Вы пишете код и решили что-то переименовать, да как-то особенно…

Остается научиться всем этим пользоваться. Значительную часть описанных ниже примеров можно проверить в том же Notepad++ или Microsoft Word. Для других (связанных с программированием) — можно использовать сервис regex101, он удобен не только для обучения, но и для реальной разработки.

Содержание:

1 Теоретический раздел

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

1.1 Одиночные символы

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

Если же нас интересуют не все варианты замены символа — используется представление с квадратными скобками. В скобках перечисляются альтернативные символы. Также, в квадратных скобках можно задавать диапазоны символов с помощью «тире». Ниже приведена схема для выражения «var_[a-d][123]», можно попробовать выписать строки, которое оно описывает:

Если символ «тире» должен являться частью перечисления — его нужно ставить первым или последним. Например, в таком выражении:

ставить тире между «+» и «*» нельзя, так как это будет интерпретировано как диапазон.

Также с помощью перечислений можно искать «все символы кроме», для этого первым символом перечисления должен быть «^» . Так, чтобы найти в тексте все символы кроме «ё» , «й» и символов «a-z» можно использовать такое выражение: «[^ёйa-z]» .

Если символ «^» стоит вне квадратных скобок — то он задает начало строки (до сих пор поиск осуществлялся во всем тексте). Символ «$» соответствует концу строки.

Если вдруг вам нужно найти в тексте какой-либо из «управляющих символов» — то его нужно экранировать с помощтю слеша. Так, например, символы «^» , «[» в регулярном выражении должны быть заменены на «\^» , «\[» . На практике часто приходится искать символ слеша, который также является управляющим и заменяется на «\\» .

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

Выражение Символ
«\d» цифра
«\D» все кроме цифры «[^0-9]»
«\s» пробельный символ (табуляции, пробелы)
«\S» все, кроме пробельных символов
«\w» буква (любой язык, в любом регистре)
«\W» все кроме букв
«\b» граница слова
«\B» не граница слова

Такие обозначения могут использоваться в качестве элементов перечисления, например «[\d\w]» соответствует букве или цифре.

1.2 Квантификация

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

Выражение Количество повторений
«*» 0 или более раз
«+» 1 или более раз
«?» 0 или 1 раз
«« точно n раз
«« от n до m раз

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

Под такое описание подойдут, например, строки «1234-1234-1234-1234» и «12345678 12345678» .

1.3 группировка (подвыражения)

Выражение может состоять из подвыражений, заключенных в круглые скобки. Для программиста это очень важно, так как к подвыражению можно обратиться по индексу. Кроме того, подвыражения используются для задания альтернатив, которые можно перечислять с помощью вертикальной черты. Так, например, следующее выражение соответствует строкам «+7 902», «8(902)» и еще множеству вариантов:

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

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

мы ожидаемо получим три строки, однако что если, к уже найденному подвыражению требуется применить какие-то дополнительные «фильтры»? То есть, после этой проверки мы хотим еще раз проверить названия языков. Сделать это можно заменив «?:» на «?=» .

Теперь будут получены только две строки — Lua и Lisp, а второе подвыражение «(.*)» будет сопоставлено с типами соответствующих языков.

Негативное заглядывания вперед ищет несоответствие строки шаблону «(?!pattern)» . Такое выражение выбирает подстроки, не соответствующие «pattern» без запоминания подстроки и не смещая текущую позицию поиска. Так, для рассмотренного выше примера, такой тип заглядывания вернет единственную строку с языком Logo. Первое подвыражение выберет строки с языками Basic, Prolog, С++ и Logo, а второе — оставит из них только те, чьи названия начинаются с символа «L» .

1.4 Что есть еще?

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

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

Ряд реализаций поддерживает очень удобный поиск по условию: «(?(?=если)то|иначе)» . Нечто подобное позволяет реализовать «просмотр вперед». «Если» условие выполнится — будет выполнено сопоставление с «то», в противном случае — с «иначе». Сопоставление в данном случае создает группу, к которой можно обратиться по индексу из вашего кода.

2 Практический раздел. Ссылки

Перед тем, как использовать регулярные выражения, стоит посмотреть в документацию по вашему языку программирования и используемой библиотеке, так как диалекты обладают особенностями. Например в Perl и некоторых версиях php можно описывать рекурсивные регулярные выражения, которые не поддерживаются большинством других реализаций; механизмом флагов отличается JavaScript и так далее. Незначительными отличиями могут обладать даже различные версии одной и той же библиотеки.

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

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

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

  • для валидации вводимых в поля данных: QVal >javax.faces.validator.Validator ;
  • для парсинга сайтов: Парсер сайта на Qt, использование QRegExp. В примере с сайта-галереи выбираются и скачиваются картинки заданных категорий;
  • для валидации данных, передаваемых в формате JSON ряд библиотек позволяет задавать схему. При этом для строковых полей могут быть заданы регулярные выражения. В качестве упражнения можно попробовать составить выражение для пароля — проверить что строка содержит символы в разном регистре и цифры.

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

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

Регулярные выражения (regex или regexp) очень эффективны для извлечения информации из текста. Для этого нужно произвести поиск одного или нескольких совпадений по определённому шаблону (т. е. определённой последовательности символов ASCII или unicode).

Области применения regex разнообразны, от валидации до парсинга/замены строк, передачи данных в другие форматы и Web Scraping’а.

Одна из любопытных особенностей регулярных выражений в их универсальности, стоит вам выучить синтаксис, и вы сможете применять их в любом (почти) языке программирования (JavaScript, Java, VB, C #, C / C++, Python, Perl, Ruby, Delphi, R, Tcl, и многих других). Небольшие отличия касаются только наиболее продвинутых функций и версий синтаксиса, поддерживаемых движком.

Давайте начнём с нескольких примеров.

Основы

Якоря — ^ и $

Квантификаторы — * + ? и <>

Оператор ИЛИ — | или []

Символьные классы — \d \w \s и .

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

У операторов \d , \w и \s также есть отрицания ― \D, \W и \S соответственно.

Например, оператор \D будет искать соответствия противоположенные \d .

Непечатаемые символы также можно искать, например табуляцию \t , новую строку \n , возврат каретки \r .

Флаги

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

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

  • g (global) ― не возвращает результат после первого совпадения, а продолжает поиск с конца предыдущего совпадения.
  • m (multi line) ― с таким флагом, операторы ^ и $ вызовут совпадение в начале и конце строки ввода (line), вместо строки целиком (string).
  • i (insensitive) ― делает выражение регистронезависимым (например, /aBc/i соответствует AbC).

Средний уровень

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

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

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

Скобочные выражения ― []

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

Жадные и ленивые сопоставления

Квантификаторы ( * + <> ) ― это «жадные» операторы, потому что они продолжают поиск соответствий, как можно глубже ― через весь текст.

Например, выражение соответствует

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

Продвинутый уровень

Границы слов ― \b и \B

\b ― соответствует границе слова, наподобие якоря (он похож на $ и ^ ), где предыдущий символ ― словесный (например, \w ), а следующий ― нет, либо наоборот, (например, это может быть начало строки или пробел).

\B ― соответствует несловообразующей границе. Соответствие не должно обнаруживаться на границе \b .


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

Регуля́рные выраже́ния (англ. regular expressions , жарг. регэ́кспы или ре́гексы) — система обработки текста, основанная на специальной системе записи образцов для поиска. Образец (англ. pattern ), задающий правило поиска, по-русски также иногда называют «шаблоном», «маской».

Сейчас регулярные выражения используются многими текстовыми редакторами и утилитами для поиска и изменения текста на основе выбранных правил. Многие языки программирования уже поддерживают регулярные выражения для работы со строками. Например, Perl и Tcl имеют встроенный в их синтаксис механизм обработки регулярных выражений. Набор утилит (включая редактор sed и фильтр grep), поставляемых в дистрибутивах Unix, одним из первых способствовал популяризации понятия регулярных выражений.

Содержание

Базовые понятия [ править ]

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

Перечисление Вертикальная черта разделяет допустимые варианты. Например, «gray|grey» соответствует gray или grey. Группировка Круглые скобки используются для определения области действия и приоритета операторов. Например, «gray|grey» и «gr(a|e)y» являются разными образцами, но они оба описывают множество, содержащее gray и grey. Квантификация Квантификатор после символа или группы определяет, сколько раз предшествующее выражение может встречаться. общее выражение, повторений может быть от n до m включительно. общее выражение, n и более повторений. <,m>общее выражение, не более m повторений. общее выражение, ровно n повторений ? Знак вопроса означает 0 или 1 раз, то же самое, что и . Например, «colou?r» соответствует и color, и colour. * Звёздочка означает 0, 1 или любое число раз ( ). Например, «go*gle» соответствует gogle, google, gooogle, ggle, и др. + Плюс означает хотя бы 1 раз ( ). Например, «go+gle» соответствует gogle, google и т. д. (но не ggle).

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

В теории формальных языков [ править ]

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

  • (пустое множество) ∅ обозначает ∅
  • (пустая строка) ε обозначает множество
  • (строка) a в Σ обозначает множество <a>

и следующие операции:

  • (связь, конкатенация) RS обозначает множество < αβ | α из R и β из S >. Пример: <"ab", "c"><"d", "ef">= <"abd", "abef", "cd", "cef">.
  • (перечисление) R|S обозначает объединение R и S.
  • (замыкание Клини, звезда Клини) R* обозначает минимальное надмножество из R, которое содержит ε и закрыто связью строк. Это есть множество всех строк, которые могут быть получены связью нуля или более строк из R. Например, <"ab", "c">* = <ε, "ab", "c", "abab", "abc", "cab", "cc", "ababab", … >.

Многие книги используют символы ∪, + или ∨ для перечисления вместо вертикальной черты.

Синтаксис [ править ]

Традиционные регулярные выражения в Unix [ править ]

Синтаксис «базовых» регулярных выражений Unix на данный момент определён POSIX как устаревший, но он до сих пор широко распространён из соображений обратной совместимости. Многие Unix-утилиты используют такие регулярные выражения по умолчанию.

В этом синтаксисе большинство символов соответствуют сами себе («a» соответствует «a» и т. д. ). Исключения из этого правила называются метасимволами:

. Соответствует любому единичному символу.
[ ] Соответствует любому единичному символу из числа заключённых в скобки. Символ «-» интерпретируется буквально только в том случае, если он расположен непосредственно после открывающей или перед закрывающей скобкой: [abc-] или [-abc]. В противном случае, он обозначает интервал символов. Например, [abc] соответствует «a», «b» или «c». [a-z] соответствует буквам нижнего регистра латинского алфавита. Эти обозначения могут и сочетаться: [abcq-z] соответствует a, b, c, q, r, s, t, u, v, w, x, y, z.

Чтобы установить соответствие символам «[» или «]», достаточно, чтобы закрывающая скобка была первым символом после открывающей: [][ab] соответствует «]», «[», «a» или «b».

[^ ] Соответствует единичному символу из числа тех, которых нет в скобках. Например, [^abc] соответствует любому символу, кроме «a», «b» или «c». [^a-z] соответствует любому символу, кроме символов нижнего регистра в латинском алфавите.
^ Соответствует началу текста (или началу любой строки в мультистроковом режиме). Ищет с начала текста.
$ Соответствует концу текста (или концу любой строки в мультистроковом режиме).
\(\) Объявляет «отмеченное подвыражение» (иногда называется «захват»), которое может быть использовано позже (см. следующий элемент: \n). «Отмеченное подвыражение» также является «блоком». В отличие от других операторов, этот (в традиционном синтаксисе) требует бэкслеша.
\n Где n — это цифра от 1 до 9; соответствует n-му отмеченному подвыражению. Эта конструкция теоретически нерегулярна, она не была принята в расширенном синтаксисе регулярных выражений.
*
  • Звёздочка после выражения, соответствующего единичному символу, соответствует нулю или более копий этого выражения. Например, «[xyz]*» соответствует пустой строке, «x», «y», «zx», «zyx», и т. д.
  • \n*, где n — это цифра от 1 до 9, соответствует нулю или более вхождений для соответствия n-го отмеченного подвыражения. Например, «\(a.\)c\1*» соответствует «abcab» и «abcaba», но не «abcac».
  • Выражение, заключённое в «\(» и «\)» и сопровождаемое «*», следует считать неправильным. В некоторых случаях оно соответствует нулю или более вхождений строки, которая была заключена в скобки. В других, оно соответствует выражению, заключённому в скобки, учитывая символ «*».
\<x,y\> Соответствует последнему блоку, встречающемуся не менее x и не более y раз. Например, «a\<3,5\>» соответствует «aaa», «aaaa» или «aaaaa». В отличие от других операторов, этот (в традиционном синтаксисе) требует бэкслеша.

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

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

POSIX класс подобно Perl означает
[:upper:] [A-Z] символы верхнего регистра
[:lower:] [a-z] символы нижнего регистра
[:alpha:] [A-Za-z] символы верхнего и нижнего регистра
[:alnum:] [A-Za-z0-9] цифры, символы верхнего и нижнего регистра
[A-Za-z0-9_] \w цифры, символы верхнего, нижнего регистра и «_»
[^A-Za-z0-9_] \W не цифры, символы верхнего, нижнего регистра и «_»
[:digit:] [0-9] \d цифры
[^0-9] \D не цифры
[:xdigit:] [0-9A-Fa-f] шестнадцатеричные цифры
[:punct:] [. …] знаки пунктуации
[:blank:] [ \t] пробел и TAB
[:space:] [ \t\n\r\f\v] \s символы пробелов(пропуска)
[^ \t\n\r\f\v] \S не символы пробелов(пропуска)
[:cntrl:] [\x00-\x1F\x7F] символы управления
[:graph:] [:alnum:] ∪ [:punct:] символы печати
[:print:] [\x20-\x7E] символы печати и символы пропуска(видимые символы и пробелы)

Защита метасимволов [ править ]

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

«Жадные» выражения [ править ]

Квантификаторам в регулярных выражениях соответствует максимально длинная строка из возможных (квантификаторы являются «жадными», англ. greedy). Это может оказаться значительной проблемой. Например, часто ожидают, что выражение ( ) найдёт в тексте теги HTML. Однако этому выражению соответствует целиком строка

Википедия — свободная энциклопедия, в которой каждый может изменить или дополнить любую статью

Эту проблему можно решить двумя способами. Первый состоит в том, что в регулярном выражении учитываются символы, не соответствующие желаемому образцу ( ]*> для вышеописанного случая). Второй заключается в определении квантификатора как нежадного (ленивого, англ. lazy)— большинство реализаций позволяют это сделать, добавив после него знак вопроса.

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

Википедия — свободная энциклопедия, в которой каждый может изменить или дополнить любую статью

  • *? — «не жадный» («ленивый») эквивалент *
  • +? — «не жадный» («ленивый») эквивалент +
  • ? — «не жадный» («ленивый») эквивалент

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

Также существуют квантификаторы повышения жадности, то, что захвачено ими однажды, назад уже не отдается. Сверхжадные квантификаторы (possessive quantifiers)

  • *+ — «сверхжадный» эквивалент *
  • ++ — «сверхжадный» эквивалент +
  • + — «сверхжадный» эквивалент

Современные (расширенные) регулярные выражения в POSIX [ править ]

Регулярные выражения в POSIX аналогичны традиционному Unix-синтаксису, но с добавлением некоторых метасимволов:

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

Также было отменено использование обратной косой черты: \ <…\>становится <…>и \(…\) становится (…).

Perl-совместимые регулярные выражения (PCRE) [ править ]

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

Элементы языка регулярных выражений — краткий справочник Regular Expression Language — Quick Reference

Регулярное выражение – это шаблон, который обработчик регулярных выражений пытается сопоставить с введенным текстом. A regular expression is a pattern that the regular expression engine attempts to match in input text. Шаблон состоит из односимвольных или многосимвольных литералов, операторов или конструкций. A pattern consists of one or more character literals, operators, or constructs. См. краткое описание регулярных выражений .NET. For a brief introduction, see .NET Regular Expressions.

В каждом разделе этого краткого справочника приводится перечень конкретной категории символов, операторов и конструкций, которые можно использовать для задания регулярных выражений. Each section in this quick reference lists a particular category of characters, operators, and constructs that you can use to define regular expressions.

Мы также представили эту информацию в двух форматах, чтобы вы могли ее загрузить и распечатать для справки: We’ve also provided this information in two formats that you can download and print for easy reference:

Escape-знаки Character Escapes

Обратная косая черта (\) в регулярных выражениях указывает, что следующий за ней символ либо является специальным знаком (как показано в следующей таблице), либо должен интерпретироваться буквально. The backslash character (\) in a regular expression indicates that the character that follows it either is a special character (as shown in the following table), or should be interpreted literally. Дополнительные сведения см. в разделе Escape-символы. For more information, see Character Escapes.

Escape-символ Escaped character Описание Description Шаблон Pattern Число соответствий Matches
\a Соответствует знаку колокольчика, \u0007. Matches a bell character, \u0007. \a «\u0007» в «Error!» + ‘\u0007’ «\u0007» in «Error!» + ‘\u0007’
\b В классе символов соответствует знаку BACKSPACE, \u0008. In a character class, matches a backspace, \u0008. [\b]

«\b\b\b\b» в «\b\b\b\b» «\b\b\b\b» in «\b\b\b\b»
\t Соответствует знаку табуляции, \u0009. Matches a tab, \u0009. (\w+)\t «item1\t» , «item2\t» в «item1\titem2\t» «item1\t» , «item2\t» in «item1\titem2\t»
\r Соответствует знаку возврата каретки, \u000D. Matches a carriage return, \u000D. ( \r не эквивалентен знаку начала новой строки, \n .) ( \r is not equivalent to the newline character, \n .) \r\n(\w+) «\r\nThese» в «\r\nThese are\ntwo lines.» «\r\nThese» in «\r\nThese are\ntwo lines.»
\v Соответствует знаку вертикальной табуляции, \u000B. Matches a vertical tab, \u000B. [\v]

«\v\v\v» в «\v\v\v» «\v\v\v» in «\v\v\v»
\f Соответствует знаку перевода страницы, \u000C. Matches a form feed, \u000C. [\f]

«\f\f\f» в «\f\f\f» «\f\f\f» in «\f\f\f»
\n Соответствует знаку новой строки, \u000A. Matches a new line, \u000A. \r\n(\w+) «\r\nThese» в «\r\nThese are\ntwo lines.» «\r\nThese» in «\r\nThese are\ntwo lines.»
\e Соответствует escape-знаку, \u001B. Matches an escape, \u001B. \e «\x001B» в «\x001B» «\x001B» in «\x001B»
\ nnn \ nnn Использует восьмеричное представление для указания символа (nnn состоит из двух или трех цифр). Uses octal representation to specify a character (nnn consists of two or three digits). \w\040\w «a b» , «c d» в «a bc d» «a b» , «c d» in «a bc d»
\x nn \x nn Использует шестнадцатеричное представление для указания символа (nn состоит ровно из двух цифр). Uses hexadecimal representation to specify a character (nn consists of exactly two digits). \w\x20\w «a b» , «c d» в «a bc d» «a b» , «c d» in «a bc d»
\c X \c X

\c x \c x

Соответствует управляющему символу ASCII, который задан как X или x, где X или x является буквой управляющего символа. Matches the ASCII control character that is specified by X or x, where X or x is the letter of the control character. \cC «\x0003» в «\x0003» (Ctrl-C) «\x0003» in «\x0003» (Ctrl-C)
\u nnnn \u nnnn Совпадение со знаком Юникода в шестнадцатеричном представлении (строго четыре цифры, представленные как nnnn). Matches a Unicode character by using hexadecimal representation (exactly four digits, as represented by nnnn). \w\u0020\w «a b» , «c d» в «a bc d» «a b» , «c d» in «a bc d»
\ Если за этим знаком следует символ, не распознанный как escape-символ из этой и других таблиц данной темы, то соответствует в точности этому символу. When followed by a character that is not recognized as an escaped character in this and other tables in this topic, matches that character. Например, \* — это то же самое, что и \x2A , а \. — то же самое, что и \x2E . For example, \* is the same as \x2A , and \. is the same as \x2E . Это позволяет обработчику регулярных выражений распознавать языковые элементы (такие как *или ?) и символьные литералы (представленные как \* или \? ). This allows the regular expression engine to disambiguate language elements (such as * or ?) and character literals (represented by \* or \? ). \d+[\+-x\*]\d+ «2+2» и «3*9» в «(2+2) * 3*9» «2+2» and «3*9» in «(2+2) * 3*9»

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

Класс символов соответствует какому-либо одному набору символов. A character class matches any one of a set of characters. Классы символов состоят из языковых элементов, приведенных в следующей таблице. Character classes include the language elements listed in the following table. Дополнительные сведения см. в разделе Классы символов. For more information, see Character Classes.

Класс знаков Character class Описание Description Шаблон Pattern Число соответствий Matches
[ character_group ] [ character_group ] Соответствует любому одиночному символу, входящему в character_group. Matches any single character in character_group. По умолчанию при сопоставлении учитывается регистр. By default, the match is case-sensitive. [ae] «a» в «gray» «a» in «gray»

«a» , «e» в «lane» «a» , «e» in «lane»

[^ character_group ] [^ character_group ] Отрицание: соответствует любому одиночному символу, не входящему в character_group. Negation: Matches any single character that is not in character_group. По умолчанию символы в character_group чувствительны к регистру. By default, characters in character_group are case-sensitive. [^aei] «r» , «g» , «n» в «reign» «r» , «g» , «n» in «reign»
[ первыйпоследний ] [ firstlast ] Диапазон символов: соответствует одному символу в диапазоне от первого до последнего. Character range: Matches any single character in the range from first to last. [A-Z] «A» , «B» в «AB123» «A» , «B» in «AB123»
. Подстановочный знак: соответствует любому одиночному символу, кроме \n. Wildcard: Matches any single character except \n.

Для сопоставления символа точки (. To match a literal period character (. или \u002E ) перед ней нужно поставить дополнительную обратную косую черту ( \. ). or \u002E ), you must precede it with the escape character ( \. ).

a.e «ave» в «nave» «ave» in «nave»

«ate» в «water» «ate» in «water»

\p< имя > \p< name > Соответствует любому одиночному символу в общей категории Юникода или в именованном блоке, указанном в параметре имя. Matches any single character in the Unicode general category or named block specified by name. \p

\p

«C» , «L» в «City Lights» «C» , «L» in «City Lights»

«Д» , «Ж» в «ДЖem» «Д» , «Ж» in «ДЖem»

\P< имя > \P< name > Соответствует любому одиночному символу, не входящему в общую категорию Юникода или в именованный блок, указанный в параметре имя. Matches any single character that is not in the Unicode general category or named block specified by name. \P

\P

«i» , «t» , «y» в «City» «i» , «t» , «y» in «City»

«e» , «m» в «ДЖem» «e» , «m» in «ДЖem»

\w Соответствует любому алфавитно-цифровому знаку. Matches any word character. \w «I» , «D» , «A» , «1» , «3» в «ID A1.3» «I» , «D» , «A» , «1» , «3» in «ID A1.3»
\W Соответствует любому символу, который не является буквенно-цифровым знаком. Matches any non-word character. \W » » , «.» в «ID A1.3″ » » , «.» in «ID A1.3»
\s Соответствует любому знаку пробела. Matches any white-space character. \w\s «D » в «ID A1.3» «D » in «ID A1.3»
\S Соответствует любому знаку, не являющемуся пробелом. Matches any non-white-space character. \s\S » _» в «int __ctr» » _» in «int __ctr»
\d Соответствует любой десятичной цифре. Matches any decimal digit. \d «4» в «4 = IV» «4» in «4 = IV»
\D Соответствует любому символу, не являющемуся десятичной цифрой. Matches any character other than a decimal digit. \D » » , «=» , » » , «I» , «V» в «4 = IV» » » , «=» , » » , «I» , «V» in «4 = IV»

Привязки Anchors

Привязки, или атомарные утверждения нулевой ширины, приводят к успеху или сбою сопоставления, в зависимости от текущей позиции в строке, но не предписывают обработчику перемещаться по строке или обрабатывать символы. Anchors, or atomic zero-width assertions, cause a match to succeed or fail depending on the current position in the string, but they do not cause the engine to advance through the string or consume characters. Метасимволы, приведенные в следующей таблице, являются привязками. The metacharacters listed in the following table are anchors. Дополнительные сведения см. в разделе Привязки. For more information, see Anchors.

Утверждение Assertion Описание Description Шаблон Pattern Число соответствий Matches
^ По умолчанию соответствие должно начинаться в начале строки. В многострочном режиме соответствие должно начинаться в начале линии. By default, the match must start at the beginning of the string; in multiline mode, it must start at the beginning of the line. ^\d

«901» в «901-333-» «901» in «901-333-«
$ По умолчанию соответствие должно обнаруживаться в конце строки или перед символом \n в конце строки. В многострочном режиме соответствие должно обнаруживаться до конца линии или перед символом \n в конце линии. By default, the match must occur at the end of the string or before \n at the end of the string; in multiline mode, it must occur before the end of the line or before \n at the end of the line. -\d<3>$ «-333» в «-901-333» «-333» in «-901-333»
\A Соответствие должно обнаруживаться в начале строки. The match must occur at the start of the string. \A\d

«901» в «901-333-» «901» in «901-333-«
\Z Соответствие должно обнаруживаться в конце строки или до символа \n в конце строки. The match must occur at the end of the string or before \n at the end of the string. -\d<3>\Z «-333» в «-901-333» «-333» in «-901-333»
\z Соответствие должно обнаруживаться в конце строки. The match must occur at the end of the string. -\d<3>\z «-333» в «-901-333» «-333» in «-901-333»
\G Соответствие должно обнаруживаться в той точке, где заканчивается предыдущее соответствие. The match must occur at the point where the previous match ended. \G\(\d\) «(1)» , «(3)» , «(5)» в «(1)(3)(5)[7](9)» «(1)» , «(3)» , «(5)» in «(1)(3)(5)[7](9)»
\b Соответствие должно обнаруживаться на границе между символом \w (алфавитно-цифровым) и символом \W (не алфавитно-цифровым). The match must occur on a boundary between a \w (alphanumeric) and a \W (nonalphanumeric) character. \b\w+\s\w+\b «them theme» , «them them» в «them theme them them» «them theme» , «them them» in «them theme them them»
\B Соответствие не должно обнаруживаться на границе \b . The match must not occur on a \b boundary. \Bend\w*\b «ends» , «ender» в «end sends endure lender» «ends» , «ender» in «end sends endure lender»

Конструкции группирования Grouping Constructs

Конструкции группирования отображают части выражений регулярных выражений и обычно захватывают части строки входной строки. Grouping constructs delineate subexpressions of a regular expression and typically capture substrings of an input string. Конструкции группирования состоят из языковых элементов, приведенных в следующей таблице. Grouping constructs include the language elements listed in the following table. Для получения дополнительной информации см. Конструкции группирования. For more information, see Grouping Constructs.

Конструкция группирования Grouping construct Описание Description Шаблон Pattern Число соответствий Matches
( часть выражения ) ( subexpression ) Захватывает соответствующую часть выражения и назначает ей порядковый номер, отсчитываемый от единицы. Captures the matched subexpression and assigns it a one-based ordinal number. (\w)\1 «ee» в «deep» «ee» in «deep»
(? имя > часть выражения ) (? name > subexpression ) Выделяет соответствующую часть выражения в именованную группу. Captures the matched subexpression into a named group. (? \w)\k «ee» в «deep» «ee» in «deep»
(? имя1имя2 > часть выражения ) (? name1name2 > subexpression ) Задает сбалансированное определение группы. Defines a balancing group definition. Дополнительные сведения см. в разделе «Сбалансированное определение группы» статьи Конструкции группирования. For more information, see the «Balancing Group Definition» section in Grouping Constructs. (((?’Open’\()[^\(\)]*)+((?’Close-Open’\))[^\(\)]*)+)*(?(Open)(?!))$ «((1-3)*(3-1))» в «3+2^((1-3)*(3-1))» «((1-3)*(3-1))» in «3+2^((1-3)*(3-1))»
(?: часть выражения ) (?: subexpression ) Определяет невыделяемую группу. Defines a noncapturing group. Write(?:Line)? «WriteLine» в «Console.WriteLine()» «WriteLine» in «Console.WriteLine()»

«Write» в «Console.Write(value)» «Write» in «Console.Write(value)»

(?imnsx-imnsx: часть выражения ) (?imnsx-imnsx: subexpression ) Применяет или отключает указанные параметры в части выражения. Applies or disables the specified options within subexpression. Для получения дополнительной информации см. Параметры регулярных выражений. For more information, see Regular Expression Options. A\d<2>(?i:\w+)\b «A12xl» , «A12XL» в «A12xl A12XL a12xl» «A12xl» , «A12XL» in «A12xl A12XL a12xl»
(?= часть выражения ) (?= subexpression ) Утверждение положительного просмотра вперед нулевой ширины. Zero-width positive lookahead assertion. \w+(?=\.) «is» , «ran» и «out» в «He is. The dog ran. The sun is out.» «is» , «ran» , and «out» in «He is. The dog ran. The sun is out.»
(?! часть выражения ) (?! subexpression ) Утверждение отрицательного просмотра вперед нулевой ширины. Zero-width negative lookahead assertion. \b(?!un)\w+\b «sure» , «used» в «unsure sure unity used» «sure» , «used» in «unsure sure unity used»
(? часть выражения ) (? subexpression ) Утверждение положительного просмотра назад нулевой ширины. Zero-width positive lookbehind assertion. (? «99» , «50» , «05» в «1851 1999 1950 1905 2003» «99» , «50» , «05» in «1851 1999 1950 1905 2003»
(? часть выражения ) (? subexpression ) Утверждение отрицательного просмотра назад нулевой ширины. Zero-width negative lookbehind assertion. (? «51» , «03» в «1851 1999 1950 1905 2003» «51» , «03» in «1851 1999 1950 1905 2003»
(?> часть выражения ) (?> subexpression ) Часть выражения поиска без возврата (или «жадного» поиска). Nonbacktracking (or «greedy») subexpression. [13579](?>A+B+) «1ABB» , «3ABB» и «5AB» в «1ABB 3ABBC 5AB 5AC» «1ABB» , «3ABB» , and «5AB» in «1ABB 3ABBC 5AB 5AC»

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

Квантор указывает количество вхождений предшествующего элемента (знака, группы или класса знаков), которое должно присутствовать во входной строке, чтобы было зафиксировано соответствие. A quantifier specifies how many instances of the previous element (which can be a character, a group, or a character class) must be present in the input string for a match to occur. Кванторы состоят из языковых элементов, приведенных в следующей таблице. Quantifiers include the language elements listed in the following table. Для получения дополнительной информации см. Квантификаторы. For more information, see Quantifiers.

Квантификатор Quantifier Описание Description Шаблон Pattern Число соответствий Matches
* Соответствует предыдущему элементу ноль или более раз. Matches the previous element zero or more times. \d*\.\d «.0» , «19.9» , «219.9» «.0» , «19.9» , «219.9»
+ Соответствует предыдущему элементу один или более раз. Matches the previous element one or more times. «be+» «bee» в «been» , «be» в «bent» «bee» in «been» , «be» in «bent»
? Соответствует предыдущему элементу ноль или один раз. Matches the previous element zero or one time. «rai?n» «ran» , «rain» «ran» , «rain»
< n > < n > Предыдущий элемент повторяется ровно n раз. Matches the previous element exactly n times. «,\d<3>« «,043» в «1,043.6» , «,876» , «,543» и «,210» в «9,876,543,210» «,043» in «1,043.6» , «,876» , «,543» , and «,210» in «9,876,543,210»
< n ,> < n ,> Предыдущий элемент повторяется как минимум n раз. Matches the previous element at least n times. «\d<2,>« «166» , «29» , «1930» «166» , «29» , «1930»
< n , м > < n , m > Предыдущий элемент повторяется как минимум n раз, но не более чем m раз. Matches the previous element at least n times, but no more than m times. «\d<3,5>« «166» , «17668» «166» , «17668»

«19302» в «193024» «19302» in «193024»

*? Предыдущий элемент не повторяется вообще или повторяется, но как можно меньшее число раз. Matches the previous element zero or more times, but as few times as possible. \d*?\.\d «.0» , «19.9» , «219.9» «.0» , «19.9» , «219.9»
+? Предыдущий элемент повторяется один или несколько раз, но как можно меньшее число раз. Matches the previous element one or more times, but as few times as possible. «be+?» «be» в «been» , «be» в «bent» «be» in «been» , «be» in «bent»
?? Предыдущий элемент не повторяется или повторяется один раз, но как можно меньшее число раз. Matches the previous element zero or one time, but as few times as possible. «rai??n» «ran» , «rain» «ran» , «rain»
< n >? < n >? Предыдущий элемент повторяется ровно n раз. Matches the preceding element exactly n times. «,\d<3>?» «,043» в «1,043.6» , «,876» , «,543» и «,210» в «9,876,543,210» «,043» in «1,043.6» , «,876» , «,543» , and «,210» in «9,876,543,210»
< n ,>? < n ,>? Предыдущий элемент повторяется как минимум n раз (как можно меньше). Matches the previous element at least n times, but as few times as possible. «\d<2,>?» «166» , «29» , «1930» «166» , «29» , «1930»
< n , м >? < n , m >? Предыдущий элемент повторяется не менее n и не более m раз (как можно меньше). Matches the previous element between n and m times, but as few times as possible. «\d<3,5>?» «166» , «17668» «166» , «17668»

«193» , «024» в «193024» «193» , «024» in «193024»

Конструкции обратных ссылок Backreference Constructs

Обратная ссылка позволяет впоследствии идентифицировать ранее найденную соответствующую часть выражения в том же регулярном выражении. A backreference allows a previously matched subexpression to be identified subsequently in the same regular expression. В следующей таблице перечислены конструкции обратных ссылок, поддерживаемые регулярными выражениями .NET. The following table lists the backreference constructs supported by regular expressions in .NET. Для получения дополнительной информации см. Конструкции обратных ссылок. For more information, see Backreference Constructs.


Конструкция обратных ссылок Backreference construct Описание Description Шаблон Pattern Число соответствий Matches
\ число \ number Обратная ссылка. Backreference. Соответствует значению нумерованной части выражения. Matches the value of a numbered subexpression. (\w)\1 «ee» в «seek» «ee» in «seek»
\k имя > \k name > Именованная обратная ссылка. Named backreference. Соответствует значению именованного выражения. Matches the value of a named expression. (? \w)\k «ee» в «seek» «ee» in «seek»

Конструкции чередования Alternation Constructs

Конструкции изменения модифицируют регулярное выражение, включая сопоставление по принципу «либо-либо». Alternation constructs modify a regular expression to enable either/or matching. Такие конструкции состоят из языковых элементов, приведенных в следующей таблице. These constructs include the language elements listed in the following table. Дополнительные сведения см. в разделе Конструкции чередования. For more information, see Alternation Constructs.

Конструкция изменения Alternation construct Описание Description Шаблон Pattern Число соответствий Matches
| Соответствует любому элементу, разделенному вертикальной чертой ( | ). Matches any one element separated by the vertical bar ( | ) character. th(e|is|at) «the» , «this» в «this is the day.» «the» , «this» in «this is the day.»
(?( выражение ) да | нет ) (?( expression ) yes | no ) Соответствует да в случае соответствия шаблона регулярного выражения, определяемого выражением; в противном случае соответствует дополнительной части нет. Matches yes if the regular expression pattern designated by expression matches; otherwise, matches the optional no part. Выражение интерпретируется как утверждение нулевой ширины. expression is interpreted as a zero-width assertion. (?(A)A\d<2>\b|\b\d<3>\b) «A10» , «910» в «A10 C103 910» «A10» , «910» in «A10 C103 910»
(?( имя ) да | нет ) (?( name ) yes | no ) Соответствует да в случае соответствия именованной или нумерованной группы захвата имя; в противном случае соответствует дополнительной части нет. Matches yes if name, a named or numbered capturing group, has a match; otherwise, matches the optional no. (? «)?(?(quoted).+?»|\S+\s) «Dogs.jpg » , «\»Yiska playing.jpg\»» в «Dogs.jpg \»Yiska playing.jpg\»» «Dogs.jpg » , «\»Yiska playing.jpg\»» in «Dogs.jpg \»Yiska playing.jpg\»»

Подстановки Substitutions

Подстановки — это языковые элементы регулярных выражений, которые поддерживаются в шаблонах замены. Substitutions are regular expression language elements that are supported in replacement patterns. Для получения дополнительной информации см. Подстановки. For more information, see Substitutions. Приведенные в следующей таблице метасимволы являются атомарными утверждениями нулевой ширины. The metacharacters listed in the following table are atomic zero-width assertions.

Знак Character Описание Description Шаблон Pattern Шаблон замены Replacement pattern Входная строка Input string Результирующая строка Result string
$ число $ number Замещает часть строки, соответствующую группе число. Substitutes the substring matched by group number. \b(\w+)(\s)(\w+)\b $3$2$1 «one two» «two one»
$< имя > $< name > Замещает часть строки, соответствующую именованной группе имя. Substitutes the substring matched by the named group name. \b(? \w+)(\s)(? \w+)\b $ $

«one two» «two one»
$$ Подставляет литерал «$». Substitutes a literal «$». \b(\d+)\s?USD $$$1 «103 USD» «$103»
$& Замещает копией полного соответствия. Substitutes a copy of the whole match. \$?\d*\.?\d+ **$&** «$1.30» «**$1.30**»
$` Замещает весь текст входной строки до соответствия. Substitutes all the text of the input string before the match. B+ $` «AABBCC» «AAAACC»
$’ Замещает весь текст входной строки после соответствия. Substitutes all the text of the input string after the match. B+ $’ «AABBCC» «AACCCC»
$+ Замещает последнюю захваченную группу. Substitutes the last group that was captured. B+(C+) $+ «AABBCCDD» «AACCDD»
$_ Замещает всю входную строку. Substitutes the entire input string. B+ $_ «AABBCC» «AAAABBCCCC»

Параметры регулярных выражений Regular Expression Options

Можно определить параметры, управляющие интерпретацией шаблона регулярного выражения обработчиком регулярных выражений. You can specify options that control how the regular expression engine interprets a regular expression pattern. Многие из этих параметров можно указать в шаблоне регулярного выражения либо в виде одной или нескольких констант RegexOptions. Many of these options can be specified either inline (in the regular expression pattern) or as one or more RegexOptions constants. Этот краткий справочник перечисляет только встраиваемые параметры. This quick reference lists only inline options. Дополнительные сведения о встроенных параметрах и параметрах RegexOptions см. в статье Параметры регулярных выражений. For more information about inline and RegexOptions options, see the article Regular Expression Options.

Встроенный параметр можно задать двумя способами: You can specify an inline option in two ways:

С помощью прочих конструкций (?imnsx-imnsx) , где минус (-) перед параметром или набором параметров отключает эти параметры. By using the miscellaneous construct (?imnsx-imnsx) , where a minus sign (-) before an option or set of options turns those options off. Например, (?i-mn) включает сопоставление без учета регистра ( i ), отключает многострочный режим ( m ) и отключает захват неименованных групп ( n ). For example, (?i-mn) turns case-insensitive matching ( i ) on, turns multiline mode ( m ) off, and turns unnamed group captures ( n ) off. Параметр применяется к шаблону регулярного выражения от точки, в которой определен параметр, и действует либо до конца шаблона, либо до точки, в которой другая конструкция отменяет параметр. The option applies to the regular expression pattern from the point at which the option is defined, and is effective either to the end of the pattern or to the point where another construct reverses the option.

С помощью конструкции группирования (?imnsx-imnsx: часть выражения ) , которая определяет параметры для только для указанной группы. By using the grouping construct (?imnsx-imnsx: subexpression ) , which defines options for the specified group only.

Механизм регулярных выражений .NET поддерживает следующие встроенные параметры. The .NET regular expression engine supports the following inline options.

Параметр Option Описание Description Шаблон Pattern Число соответствий Matches
i Использовать соответствие без учета регистра. Use case-insensitive matching. \b(?i)a(?-i)a\w+\b «aardvark» , «aaaAuto» в «aardvark AAAuto aaaAuto Adam breakfast» «aardvark» , «aaaAuto» in «aardvark AAAuto aaaAuto Adam breakfast»
m Использовать многострочный режим. Use multiline mode. ^ и $ соответствуют началу и концу строки (line), а не началу и концу строки (string). ^ and $ match the beginning and end of a line, instead of the beginning and end of a string. Пример см. в подразделе «Многострочный режим» раздела Параметры регулярных выражений. For an example, see the «Multiline Mode» section in Regular Expression Options.
n Не захватывать неименованные группы. Do not capture unnamed groups. Пример см. в подразделе «Только явные захваты» раздела Параметры регулярных выражений. For an example, see the «Explicit Captures Only» section in Regular Expression Options.
s Использовать однострочный режим. Use single-line mode. Пример см. в подразделе «Однострочный режим» раздела Параметры регулярных выражений. For an example, see the «Single-line Mode» section in Regular Expression Options.
x Игнорировать знаки пробела в шаблоне регулярного выражения, не преобразованные в escape-последовательность. Ignore unescaped white space in the regular expression pattern. \b(?x) \d+ \s \w+ «1 aardvark» , «2 cats» в «1 aardvark 2 cats IV centurions» «1 aardvark» , «2 cats» in «1 aardvark 2 cats IV centurions»

Прочие конструкции Miscellaneous Constructs

Прочие конструкции либо изменяют шаблон регулярных выражений, либо предоставляют сведения о нем. Miscellaneous constructs either modify a regular expression pattern or provide information about it. В следующей таблице перечислены все прочие конструкции, поддерживаемые .NET. The following table lists the miscellaneous constructs supported by .NET. Для получения дополнительной информации см. Прочие конструкции. For more information, see Miscellaneous Constructs.

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

Эта страница была переведена автоматически с английской версии вики используя Переводчик Google.

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

Язык
Заголовочные файлы
Концепты
Поддержка языка
Ошибка
Утилиты
Строки
Контейнеры
Алгоритмы
Итераторы
Работа с числами
Ввод/вывод
Локализация
Регулярные выражения (C++11)
Атомарные операции (C++11)
Потоки (C++11)
Файловая система (C++17)
Технические спецификации

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

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

  • Целевая последовательность. Последовательность символов, искомая по шаблону. Эта последовательность может быть представлена парой итераторов, нуль-терминированной строкой или объектом std::string .
  • Шаблон. Представляет собой само регулярное выражение. Шаблон определяет совпадение с содержимым целевой строки и является объектом типа std::basic_regex , созданным из строки с особым синтаксисом.
  • Массив совпадений. Информация о совпадениях, доступ к которой осуществляется через объект типа std::match_results .
  • Строка замены. Строка определяющая, как следует заменять совпадения, управляемых специальными флагами.

Содержание

[править] Основные классы

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

Руководство по регулярным выражениям в JavaScript

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

Регулярные выражения (RegExp) — это очень эффективный способ работы со строками.

Составив регулярное выражение с помощью специального синтаксиса вы можете:

  • искать текст в строке
  • заменять подстроки в строке
  • извлекать информацию из строки

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

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

Регулярные выражения реализованные в UNIX, таких как grep, sed и популярных текстовых редакторах, начали набирать популярность и были добавлены в язык программирования Perl, а позже и в множество других языков.

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

Сложно, по полезно

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

Регулярные выражения сложно писать, сложно читать и сложно поддерживать/изменять.

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

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

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

Как выглядят регулярные выражения

В JavaScript регулярные выражения это объект, который может быть определён двумя способами.

Первый способ заключается в создании нового объекта RegExp с помощью конструктора:

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

Вы знаете что в JavaScript есть литералы объектов и литералы массивов? В нём также есть литералы regexp.

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

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

Как они работают?

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

Это довольно просто.

Вы можете попробовать протестировать регулярное выражение с помощью метода RegExp.test(String) , который возвращает логическое ( boolean ) значение:

В примере выше мы просто проверили удовлетворяет ли «hey» шаблону регулярного выражения, который храниться в re1 .

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

Закрепление

сработает независимо от того где находится hey внутри строки.

Если вы хотите найти строки, которые начинаются с hey , то используйте оператор ^ :

Если вы хотите найти строки, которые заканчиваются на hey , то используйте оператор $ :

Объединяя два предыдущих оператора вы можете найти строку, которая полностью совпадает с hey :

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

Поиск элементов по диапазону

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

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

Диапазоны можно комбинировать:

Поиск многократных совпадений элемента диапазона

Вы можете проверить содержит ли строка только один символ из диапазона с помощью символа — :

Инверсия шаблона


Символ ^ в начале шаблона привязывает его к началу строки.

Использование этого символа внутри диапазона инвертирует диапазон, поэтому:

Метасимволы

  • \d совпадает с любым числом, эквивалентно [0-9]
  • \D совпадает с любым символом, который не является числом, эквивалентно [^0-9]
  • \w совпадает с любым буквенно-числовым символом, эквивалентно [A-Za-z0-9]
  • \W совпадает с любым символом, который не является буквенно-числовым значением, эквивалентно [^A-Za-z0-9]
  • \s совпадает с любым пробельным символом: пробел, табуляция, символ новой строки и пробелы Unicode
  • \S совпадает с любым символом, который не является пробелом
  • \0 совпадает с null
  • \n совпадает с символом новой строки
  • \t совпадает с символом табуляции
  • \uXXXX совпадает с символом Unicode с кодом XXXX (требуется флаг u )
  • . совпадает с любым символовом, кроме символа новой строки (таким как \n ) (если вы не используете флаг s , объясним позже)
  • [^] совпадает с любым символом, включая символ новой строки. Полезно при работе с многострочными строками

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

Если вы хотите выбрать одну или другую строку, используйте оператор | .

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

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

Вы можете использовать квантификатор ? , который сделает этот символ необязательным. В нашем случае цифра должна встречаться 0 или 1 раз:

но что если мы хотим чтобы регулярное выражение срабатывало на несколько цифр?

Вы можете сделать это 4 способами, используя + , * , и .

Совпадает с одним или более (>=1) элементами:

Совпадает с 0 или более (>=0) элементами:

Совпадает точно с n количеством элементов:

Совпадает с диапазоном от n до m элементов:

m можно опустить и оставить второй предел без ограничений, чтобы было минимум n элементов:

Опциональные элементы

Следующий за элементом знак ? , сделает его необязательным:

Группы

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

Пример ниже ищет точное совпадение из 3 цифр за которым следует один или более буквенно-числовые символов:

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

Захват групп

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

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

Вы можете делать это с помощью групп, а точнее с помощью захвата групп.

По умолчанию, группы итак захватываются. Теперь вместо использования RegExp.test(String) , который просто возвращает логическое значение, мы будем использовать один из следующих методов:

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

Если совпадений не найдено, то он возвращает null .

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

Опциональные группы

Захват групп можно сделать опциональным с помощью (. )? . Если ничего не будет найдено, то в возвращаемый массив будет добавлен элемент undefined :

Ссылка на найденную группу

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

Именованный захват групп

Это новая возможность ES2020.

Группе можно назначить имя, а не просто слот в возвращаемом массиве:

Использование match и exec без групп

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

Незахватываемые группы

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

Флаги

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

  • g : ищет совпадения глобально
  • i : делает регулярное выражение не чувствительным к регистру
  • m : включает многострочный режим. В этом режиме ^ и $ совпадают с началом и концом всей строки. Без этого флага, с многострочными строками они совпадают с началом и концом каждой строки.
  • u : включает поддержку Unicode (добавлено в ES6/ES2015)
  • s : (новое в ES2020) сокращение от «single line», он позволяет . совпадать с символами новой строки

Флаги можно комбинировать, а также они добавляются в конец строки литерала:

или передаются вторым параметром в конструктор объекта RegExp:

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

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

  • source — строка шаблона
  • multiline — принимается значение true если установлен флаг m
  • global — принимается значение true если установлен флаг g
  • ignoreCase — принимается значение true если установлен флаг i
  • lastIndex

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

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

Границы строк

\b и \B позволяют определить находится ли строка в начале или конце слова:

  • \b совпадает если набор символов находится в начале или конце слова
  • \B совпадает если набор символов не находится в начале или конце слова

Замена с помощью регулярных выражений

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

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

Теперь давайте рассмотрим как заменять части строки на основе шаблона.

У объекта String в JavaScript есть метод replace() , который можно использовать без регулярных выражений для одной замены в строке:

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

Использование флага g — это единственный способ заменить несколько вхождений в строке на ванильном JavaScript:

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

Вместо строки можно использовать функцию, чтобы делать ещё более интересные вещи. В неё будет передан ряд аргументов, таких как возвращают методы String.match(RegExp) или RegExp.exec(String) , где количество аргументов зависит от количества групп:


Жадность

Регулярные выражения называются жадными по умолчанию.

Возьмём например это регулярное выражение:

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

но что если у нас есть больше слов после числа, это отвлекает

Почему? Потому что регулярное выражение после знака $ совпадает с любым символом .+ и не останавливается пока не достигнет конца строки. Затем он останавливается, потому что \s? делает конечное пространство необязательным.

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

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

Опережение: соответствие строки в зависимости от того что за ней следует

Используйет ?= для поиска совпадений в строке за которой следует определённая подстрока

?! выполняет обратную операцию и находит совпадений в строке за которыми не следует определённая подстрока:

Ретроспектива: соответствие строки в зависимости от того что ей предшествует

Это новая возможность ES2020.

Опережение использует символ ?= . Ретроспектива использует ? :

Инверсия ретроспективы использует ? :

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

Флаг u является обязательным при работе с Unicode строками, в частности когда может понадобится обрабатывать строки в астральных плоскостях, которые не включены в первые 1600 символов Unicode.

Например эмодзи, но и только они.

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

Поэтому, всегда используйте флаг u .

Unicode, как и обычные символы, может обрабатывать диапазоны:

JavaScript проверяет внутренние коды представления, поэтому ? \u1F436 \u1F43A \u1F98A . Посмотрите полный список эмодзи чтобы увидеть коды и узнать их порядок.

Экранирование свойств Unicode

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

Экранирование свойств Unicode — это возможность ES2020, которая добавляет очень крутую функцию, расширяя эту концепцию на всех Unicode символы и добавляя \p<> и \P<> .

У любого Unicode символа есть набор свойств. Например Script определяет семейство языков, ASCII — это логическое значение равное true для ASCII символов и т.д. Вы можете положить это свойство в фигурные скобки и регулярное выражение будет проверять чтобы его значение было истинным:

ASCII_Hex_Digit — это ещё одно логическое свойство, которое проверяет содержит ли строка тольк валидные шестнадцатеричные цифры:

Существует много других логических свойств, которые вы можете проверить просто добавив их имя в фигурные скобки, включая Uppercase , Lowercase , White_Space , Alphabetic , Emoji и другие:

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

Прочитать больше обо всех свойствах вы можете здесь.

Примеры

Извлечение числа из строки

Предположим, что есть строка содержащая только одно число, которое нужно извлечь. /\d+/ должен сделать это:

Поиск E-mail адреса:

Простейший подход заключается в проверке безпробельных символов до и после знака @ , с помощью \S :

Однако, это упрощенный пример, так как под него попадает множество не валидных E-mail адресов.

Захват текста между двойными кавычками

Представим, что у вас есть строка, которая содержит текст заключённый в двойные кавычки и вам нужно извлечь этот текст.

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

Мы найдём то что нам нужно в result[1] :

Получение содержимого из HTML тега

Например получить содержимое из тега span , допуская при этом любое количество аргументов у тега:

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

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

В народе: регэкспы, регулярки.

По-простому — это выражения для поиска и замены подстроки по шаблону.

В PHP используется название PCRE (Perl Compatible Regular Expressions —
перл совместимые регулярные выражения). В этой статье я постараюсь раскрыть
потенциал это мощного инструмента программиста. Не пытайтесь понять все сразу,
впитывайте порциями и приходите за добавкой.

Начнем

// наша строка для испытаний
$string = ‘abcdefghijklmnopqrstuvwxyz0123456789’ ;

Если нам нужно просто узнать есть ли шаблон ‘abc’ в строке $string
мы можем набросать такой код:

echo preg_match ( «/abc/» , $string ) ;
?>

Этот код выведет ‘1’. Потому что он нашел 1 (одно) вхождение шаблона в строке.
Если шаблон в строке не обнаружен, preg_match вернет 0. При нахождении первого вхождения,
функция сразу возвращает результат! Дальнейший поиск не продолжается (см. preg_match_all)

Нахождение начала строки

Теперь мы желаем узнать, начинается ли строка с ‘abc’.
Символ начала строки в регулярках — ‘^’ (caret — знак вставки).

// тест на начало строки
if ( preg_match ( «/^abc/» , $string ) )
<
// окей, строка начинается с абс
echo ‘The string begins with abc’ ;
>
else
<
echo ‘это фэйл’ ;
>
?>

Пример выведет:
The string begins with abc

Оборачивающие слэши — разделители, содержат регуряное выражение. Это могут быть любые парные символы,
например @regex@, #regex#, /regex/ и .т.п.

Символ ^ сразу после первого разделителя указывает что выражение начинается сначала строки и НИКАК иначе.

Что делать с регистром символов (строчные-прописные)

Перепишем код, чтобы он искал строку ‘ABC’:

Скрипт вернет:
Не думаю

Все потому что поиск регистро-зависимый. Шаблон ‘abc’ не тоже самое что ‘ABC’.
Чтобы найти оба варианта, нужно использовать модификатор. В регулярных выражениях
для этого применяется модификатор ‘i’, который нужно указать за закрывающим разделителем
регулярного выражения.

if ( preg_match ( «/^ABC/i» , $string ) ) <
echo ‘Совпадение, строка начинается с abc’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Теперь скрипт найдет паттерн ‘abc’. Также теперь будут попадать под шаблон
строки вида abc, ABC, Abc, aBc, и т.п.

Позже будет рассказано подробнее о модификаторах.

Как указать в паттерне конец строки

Делается это также как и в случае с поиском начала строки.
Распространенная ошибка, допускаемя многими прогерами — использование символа $ для указания конца строки в шаблоне.
Это неверно, правильное решение — использовать утверждение \z. Посмотрите на этот код

Сниппет вернет true, потому что $ = \Z, что в свою очередь можно описать выражением (?=\z|\n\z).
Когда нам нужно получить в результате строку без «разделителей строк», $ не должен использоваться.
Также $ совпададет больше одного раза с модификатором /m, в противоположность \z. Изменим немного код,
удалим каретку (^) в начале паттерна и добавим \z в конце, также уберем зависимость от регистра модификатором /i.

// паттерн в конце строки?
if ( preg_match ( «/89 \z /i» , $string ) ) <
echo ‘Совпадение, строка заканчивается на 89’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
>> Совпадение, строка заканчивается на 89

Потому что мы определили конец строки 89. Вот так.

Мета символы

Ранее мы поэкспериментировали с простыми регулярками. Познакомились с кареткой (^) и долларом ($)/
Эти символы имееют особенное значение. Каретка (^) обозначает начало страки и доллар ($) — ее конец.
Такие символы в купе с остальными специальными называются мета символами (meta characters).

Список мета символов в регулярных выражениях:

Разберем все символы на примерах.
Если вам нужно составить шаблон в котором содержится такой символ, его необходимо экранировать (см. preg_quote)
Например шаблон: «1+1», нужно записать как-то так:

// образец
$string = ‘1+1=2’ ;

if ( preg_match ( «/^1 \+ 1/i» , $string ) ) <
// yep
echo ‘The string begins with 1+1’ ;
> else <
// nope
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
The string begins with 1+1

Потому что интерпретатор проигнорировал специальное значение символа «+», обозначенного символом экранирования «\» (бэкслэш).
Если бы мы не добавили экран к плюсу, то preg_match(«/^1+1/i», $string) не нашло бы совпадений с шаблоном.
Сам бэкслэш в свою очередь тоже нужно экранировать, если мы ищем именно этот символ «\\».


Что означают остальные мета символы

Квадратные скобки [ ] обозначают «строковой класс».

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

Или как диапазон, разделенный символом «-«:

// Ищем шаблон
echo preg_match ( «/b[aoiu]g/» , $string , $matches ) ;

Результат скрипта:
return 1

Потому что preg_match() нашел совпадение.
Этот код также найдет совпадение со строками ‘bag’ ‘bog’ ‘big’, но не с ‘beg’.
Диапазон символов [a-f] равнозначен такой записи [abcdef]. Словами формулируется так [от ‘a’ до ‘f’].
Еще раз повторю, выражения регистрозависимые, и [A-F] не тоже самое что и [a-f].

Мета символы не работыют внутри классов, поэтому их не нужно экранировать внутри квадратных скобок [. ].
Например класс [abcdef$] совпадет с символами a b c d e f $. Доллар ($) внутри класса — это простой бакс знак доллара без какого либо специального мета-свойства.

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

// осуществляем поиск
preg_match ( «/[^b]/» , $string , $matches ) ;

// выведем все совпадения в цикле foreach
foreach ( $matches as $key => $value ) <
echo $key . ‘ -> ‘ . $value ;
>
?>

Результат скрипта:
0 -> a

Здесь preg_match() нашел первое совпадение с шаблоном /[^b]/.
Изменим скрипт и используем preg_match_all() для нахождения всех вхождений соответствующих шаблону /[^b]/.

// ищем ВСЕ совпадения
preg_match_all ( «/[^b]/» , $string , $matches ) ;

// выведем все совпадения в цикле foreach
foreach ( $matches [ 0 ] as $value ) <
echo $value ;
>
?>

Результат скрипта:
acefghijklmnopqrstuvwxyz0123456789

Выведет все символы, которые НЕ совпадают с шаблоном «b».

Так мы можем отфильтровать все цифры в строке:

// все символы не являющиеся цифрами от 0 до 9
preg_match_all ( «/[^0-9]/» , $string , $matches ) ;

foreach ( $matches [ 0 ] as $value ) <
echo $value ;
>
?>

Результат скрипта:
abcefghijklmnopqrstuvwxyz

Шаблон [^0-9] расшифровывается как все НЕ включая цифры от 0 до 9.

Продолжаете слушать нашу радиостанцию?
Тогда продолжим.

Метасимвол Бэкслэш (\).

Основное значение — экранирование других метасимволов.

// create a string
$string = ‘This is a [templateVar]’ ;

// try to match our pattern
preg_match_all ( «/[ \[ \] ]/» , $string , $matches ) ;

// loop through the matches with foreach
foreach ( $matches [ 0 ] as $value ) <
echo $value ;
>
?>

Здесь мы хотели найти все символы []. Без экранирования шаблон выглядел бы так — «/[[]]/»,
но мы добавили бэеслэши к скобкам [], чтобы отменить их мета-статус.
Также, к примеру, поступим с путем к файлу.
c:\dir\file.php
В паттерне будем использовать разделитель «\\».

Бэкслэш также ортодоксально используется в строках для указания специальных последовательностей: \n, \r и др.

Еще он неймспейсы разделяет!

Следующий символ «.» (точка) ака «полный стоп».

`Точка` совпадает с любым символом кроме символов разрыва строки \r или \n.
С помощью точки мы можем найти любой одиночный символ, за исключением разрыва строки.
Чтобы точка также совпадала с переводом каретки и разрывом строки, можно использовать флаг /s.

Ищем одиночный символ

$string = ‘sex at noon taxes’ ;

echo preg_match ( «/s.x/» , $string , $matches ) ;
?>

Результат скрипта:
1

Да, да preg_match() нашел одно совпадение. Пример также сработает с sax, six, sox, sux, и s x, но не совпадет с «stix».

Теперь попробуем найти \n.

// create a string
$string = ‘sex’ . » \n » . ‘at’ . » \n » . ‘noon’ . » \n » . ‘taxes’ . » \n » ;

// echo the string
echo nl2br ( $string ) ;

// look for a match
echo preg_match_all ( «/ \s /» , $string , $matches ) ;

Результат скрипта:
sex
at
noon
taxes
4

preg_match_all() нашел 4 совпадения разрыва строки «\n» потому что мы использовали флаг \s. Подробнее про флаге в разделе Спец Последовательностей..

Следующий волшебный символ — звездочка (*) asterisk
Совпадает с НОЛем и/или БОЛЕЕ вхождений шаблона, находящегося перед звездочкой.
* означает опциональный шаблон — допускается что символы могут быть, а могут и отсутствовать в строке.
Так шаблон .* совпадает с любым количеством любых символов. Пример:

// create a string
$string = ‘php’ ;

// look for a match
echo preg_match ( «/ph*p/» , $string , $matches ) ;

Результат скрипта:
1

Нашлось одно совпадение. В примере это один символ «h».
Пример также совпадет также со строкой «pp» (ноль символов «h»), и «phhhp» (три символа «h»).

Добрались до мета символа символа «+»

Плюс почти тоже самое что и звездочка, за исключением того что плюс совпадает с ОДНИМ и БОЛЬШЕ символом.
Так в примере звездочка «*» совпала со строкой ‘pp’, с плюсом «+» такое не пройдет.

// create a string
$string = ‘pp’ ;

// look for a match
echo preg_match ( «/ph+p/» , $string , $matches ) ;

Результат скрипта:

Потому что ни одного символа «h».

Следубщий пациент
Мета символ «?»

Знак вопроса совпадет с НУЛЕМ или ОДНИМ вхождением символа или регулярным выражением,
указанным сразу перед ним. Полезен для указания опциональных символов (которых может и не быть).

Например, телефонный номер в Австралии: 1234-5678.

// create a string
$string = ‘12345678’ ;

// look for a match
echo preg_match ( «/1234-?5678/» , $string , $matches ) ;

Результат скрипта:
1

Потому что -? совпал 0 раз с символом «-«. Изменение строки на «1234-5678» выдаст тот же результат.

Фигурные скобки <>

Указывает на количество совпавших символов или их интервал.
Например, за фразой PHP должно следовать ТОЧНО ТРИ цифры:

// create a string
$string = ‘PHP123’ ;

// look for a match
echo preg_match ( «/PHP[0-9]<3>/» , $string , $matches ) ;

Результат скрипта:
1

Шаблон PHP 0-9(цифры от 0 до 9) <3>(три раза) совпал.

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

Бэкслэш (\) используется для спец. последовательностей:

* \d — любая цифра (тоже самое что и [0-9])
* \D — любая НЕ цифра ([^0-9])
* \s — все «недосимволы» — пробелы, переводы строки, табуляция ([ \t\n\r\f\v])
* \S — все НЕ «недосимволы» ([^ \t\n\r\f\v])
* \w — все альфа-цифровые символы (буквенно-числовые) ([a-zA-Z0-9_])
* \W — все НЕ альфа-цифровые символы ([^a-zA-Z0-9_])

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

// match our pattern containing a special sequence
preg_match_all ( «/[ \w ]/» , $string , $matches ) ;

// loop through the matches with foreach
foreach ( $matches [ 0 ] as $value ) <
echo $value ;
>
?>

Результат скрипта:
abcefghijklmnopqrstuvwxyz0123456789

Мы нашли (preg_match_all) все цифры и буквы (\w) класса ( [] ).

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

// create a string
$string = ‘2 bad for perl’ ;


// echo our string
if ( preg_match ( «/^ \d /» , $string ) ) <
echo ‘String begins with a number’ ;
> else <
echo ‘String does not begin with a number’ ;
>
?>

Метасимвол «.» (Точка, полный стоп)

Совпадает один раз с любым символом (кроме разрыва строки)

// create a string
$string = ‘abcdefghijklmnopqrstuvwxyz0123456789’ ;

// try to match any character
if ( preg_match ( «/./» , $string ) ) <
echo ‘The string contains at least on character’ ;
> else <
echo ‘String does not contain anything’ ;
>
?>

Результат скрипта:
The string contains at least on character

Конечно, код содержит хотябы один символ.

Ранее была рассмотрена проблема нахождения символа разрыва строки, потому что «.» не совпадает с таким символом (\n).
Здесь нам на помощь придет флаг \s. Он найдет любой пробельный символ (недосимвол).

Для примера используем \n.

// create a string
$string = ‘sex’ . » \n » . ‘at’ . » \n » . ‘noon’ . » \n » . ‘taxes’ . » \n » ;

// echo the string
echo nl2br ( $string ) ;

// look for a match
echo preg_match_all ( «/ \s /» , $string , $matches ) ;

Результат скрипта:
sex
at
noon
taxes
4

preg_match() нашел 4 совпадения перевода строки \n.

Теперь все вместе, хором

Более сложные выражения.
Рассмотрим оператор OR (ИЛИ).
В регулярных выражениях это символ «|» (труба, канал).

Настало время показательного «Hello World» скрипта.

// a simple string
$string = «This is a Hello World script» ;

// try to match the patterns This OR That OR There
echo preg_match ( «/^(This|That|There)/» , $string ) ;
?>

Усложним задачу: попытаемся найти одновременно Hello или Jello в строке.

// a simple string
$string = «This is a Hello World script» ;

// try to match the patterns Jello or Hello
if ( ! preg_match ( «/(Je|He)llo/» , $string ) ) <
echo ‘Pattern not found’ ;
> else <
echo ‘pattern found’ ;
>
?>

Хотя шаблон совпал, мы не видим какую имеено сроку мы нашли.
Для возвращения найденных результатов в preg_match добавляется третий параметр (&$matches):

// a simple string
$string = «This is a Hello World script» ;

// try to match the patterns Jello or Hello
// put the matches in a variable called matches
preg_match ( «/(Je|He)llo/» , $string , $matches ) ;

// loop through the array of matches and print them
foreach ( $matches as $key => $value ) <
echo $key . ‘->’ . $value . ‘
‘ ;
>
?>

Элемент массив $matches[0] содержит всю совпавшую подстроку (всегда), в примере — Hello.
Последующие элементы содержат последовательно вхождения субпаттернов «()».
$matches[1] совпадает с первым субпатерном. В примере — (Je|He)

Модификаторы и утверждения

Модификаторы изменяют поведения шаблонов регулярных выражений.

i — регистронезависимый (Ignore Case, case insensitive)
U — нежадный поиск (Make search ungreedy)
s — включая перевод строки (Includes New line)
m — мультистрока (Multiple lines)
x — Extended for comments and whitespace
e — Enables evaluation of replacement as PHP code. (preg_replace only)
S — Extra analysis of pattern

b — граница слова (Word Boundry)
B — НЕ граница слова (Not a word boundary)
A — начало шаблона (Start of subject)
Z — конец шаблона или разрыв строки (End of subject or newline at end)
z — конец шаблона (End of subject)
G — первая совпавшая позиция в шаблоне (First matching position in subject)
?>

Простой пример модификатора «i»

// create a string
$string = ‘abcdefghijklmnopqrstuvwxyz0123456789’ ;

// try to match our pattern
if ( preg_match ( «/^ABC/i» , $string ) ) <
echo ‘Совпадение, строка начинается с abc’ ;
> else <
echo ‘Не думаю’ ;
>
?>
?>

Использование модификатора «s»

/*** create a string with new line characters ***/
$string = ‘sex’ . » \n » . ‘at’ . » \n » . ‘noon’ . » \n » . ‘taxes’ . » \n » ;

/*** look for a match */
echo preg_match ( «/sex.at.noon/» , $string , $matches ) ;

Результат скрипта:

«.» не находит символы разрыва строки, добавим модификатор «s»
чтобы это исправить

/*** create a string with new line characters ***/
$string = ‘sex’ . » \n » . ‘at’ . » \n » . ‘noon’ . » \n » . ‘taxes’ . » \n » ;

/*** look for a match using s modifier ***/
echo preg_match ( «/sex.at.noon/s» , $string , $matches ) ;
?>
?>

Результат скрипта:
1

Разрывы строк позволяют нам использовать модификатор «m».
Это улично-магический модификатор. Он принимает строку за однострочнкую с символом разрыва на конце,
даже если в строке на самом деле больше символов разрыва (мультистрока).
Т.е. если в строке нет символов разрыва строк, этот модификатор ничего не значит.

// create a string
$string = ‘sex’ . » \n » . ‘at’ . » \n » . ‘noon’ . » \n » . ‘taxes’ . » \n » ;

// look for a match
if ( preg_match ( «/^noon/im» , $string ) ) <
echo ‘Pattern Found’ ;
> else <
echo ‘Pattern not found’ ;
>
?>

Результат скрипта:
Pattern Found

Конечно регулярное выражение найдет совпадение.
Все что следует после первого символа разрыва строки отбрасывается из-за модификатора «m».

В примере используюся вместе модификаторы «i» и «m», их действие комбинируется.

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

// create a string
$string = ‘sex’ . » \n » . ‘at’ . » \n » . ‘noon’ . » \n » . ‘taxes’ . » \n » ;

// create our regex using comments and store the regex
// in a variable to be used with preg_match
$regex = ‘
/ # opening double quote
^ # caret means beginning of the string
noon # the pattern to match
/imx
‘ ;

// look for a match
if ( preg_match ( $regex , $string ) ) <
echo ‘Pattern Found’ ;
> else <
echo ‘Pattern not found’ ;
>
?>

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

Модификатор «e»

Спец млжификатор, который изменяет выполнение сопоставления шаблону. Ниже будет выделена целая секция для его описания.

Модификатор «S»

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

Паттерн может успорить выполение шаблона в случае с множественными совпадениями.
В следующем примере появляется множественное вхождение шаблона, поэтому добавим «S».

// match our pattern containing a special sequence
preg_match_all ( «/[ \w ]/S» , $string , $matches ) ;

// loop through the matches with foreach
foreach ( $matches [ 0 ] as $value ) <
echo $value ;
>
?>

Результат скрипта:
abcefghijklmnopqrstuvwxyz01234567890

На практике модификатор используется достаточно редко.

Модификатор границы слова (word boundary) «\b»

Граница слова создается между двух «\b» модификаторов.
Это специальный «подпирающий тип модификаторов, которые позволяют указть ТОЧНОЕ совпадение.
Текст должен совпасть только с точным шаблоном заключенным в «\b»
Например, шаблон «cat» не совпадет с «catalog».

$string = ‘eregi will not be available in PHP 6’ ;

// ищем строку «lab»
if ( preg_match ( «/ \b lab \b /i» , $string ) ) <
// Совпадение
echo $string ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
Не думаю

Мы пытаемся найти совпадение с паттерном «lab», которое находится внутри строки в слове «available».
Из за использования границ слов, шаблон не совпал с подстрокой.
Давайте попробуем пример, не используя модификатора границ слов.

$string = ‘eregi will remain in the computer lab’ ;

// ищем строку «lab»
if ( preg_match ( «/ \b lab \b /i» , $string ) ) <
// Совпадение
echo $string ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
eregi will remain in the computer lab

Мы видим что совпадение произошло с целым словом «lab». (\blab\b).

Модификатор \B

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

$string = ‘This lathe turns wood.’ ;

// match word boundary and non-word boundary
if ( preg_match ( «/ \B the \b /» , $string ) ) <
echo ‘Совпал шаблон «the».’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
>> Совпал шаблон «the».

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

$string = ‘The quick brown fox jumps over the lazy dog.’ ;


// match word boundary and non-word boundary
if ( preg_match ( «/ \B the \b /» , $string ) ) <
echo ‘Совпал шаблон «the».’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
Не думаю

В этот раз мы ничего не нашли, потому что «the» стоит на границе слова, а мы использовали модификатор \B.

Последний модификатор — \U

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

Чтобы отключить такую «жадность» регулярных выражений
— используем ограничитель «?», например «(.*?)»
— используем модификатор «\U».

Новичкам желательно использовать этот модификатор по-умолчанию, чтобы не возникало конфузов.

$string = ‘foobar foo—bar fubar’ ;

// try to match the pattern
if ( preg_match ( «/foo(.*)bar/U» , $string ) ) <
echo ‘Совпадение’ ;
> else <
echo ‘Не думаю’ ;
>

Результат скрипта:
Совпадение

Другой пример — дан кусок html

Попытаемся найти все ссылки выражением preg_match_all(«/.*/s», $string),
код вернет всю искомую строку вместо трех ссылок. Добавив Нежадный модификатор, все три ссылки поотдельности.

Вычисление с preg_replace

Приветствуем на сцене модификатор «e».

Этот модификатор вычисляет заменяемый аргумент.
До этого мы не рассматривали preg_replace(), поэтому быстрый пример:

$string = ‘We will replace the word foo’ ;

// заменяем `for` на `bar`
$string = preg_replace ( «/foo/» , ‘bar’ , $string ) ;

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

// строка с шаблонными переменными
$string = ‘This is the <_FOO_>bought to you by <_BAR_>‘ ;

// создади массив со значениями переменных
$templateVars = [ «FOO» => «The PHP Way» , «BAR» => «PHPro.orG» ] ;

// заменяем и вычисляем
$string = preg_replace ( «/<_(.*?)_>/ime» , » \$ templateVars[‘$1’]» , $string ) ;

Без модификатора «е» скрипты выдаст результат:
This is a $template_vars[FOO] and this is a $template_vars[BAR]

С модификатором переменные вычислятся после замены:
This is the The PHP Way bought to you by PHPro.orG

Таким образом, модификатор «e» обладает потенциалом встроенного шаблонизатора.

Заглядывание вперед (Look Aheads)

Возможность регулярных выражений «заглянуть вперед» шаблона для определения дальнейших совпадений.
«Подглядывание вперед» бывает положительное и отрицательное

Рассмотрим сначала заглядывание вперед с отрицанием. Обозначается в шаблоне символами «?!».
Полезно при поиске шаблона, стоящего впереди от совпадения, которое нам нужно.

$string = ‘I live in the whitehouse’ ;

// try to match white not followed by house
if ( preg_match ( «/white+(?!house)/i» , $string ) ) <
// if we find the word white, not followed by house
echo ‘Совпадение’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
No match is found

Потому что слово «white» следует за словом «house».
Подадим блюдо под другим соусом:

$string = ‘I live in the white house’ ;

// try to match white not followed by house
if ( preg_match ( «/white+(?!house)/i» , $string ) ) <
// if we find the word white, not followed by house
echo ‘Совпадение’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
Совпадение

Есть совпадение, потому что слово «white» не следует сразу же за словом «house» (как в «whitehouse»)

Позитивное/положительное заглядывание вперед «?=»

$string = ‘This is an example eg: foo’ ;

// try to match eg followed by a colon
if ( preg_match ( «/eg+(?=:)/» , $string , $match ) ) <
print_r ( $match ) ;
> else <
echo ‘Нет совпадений’ ;
>
?>

Результат скрипта:
Array < [0]=>‘eg’ >

Код ищет паттерн «eg», стоящий перед «:» двоеточием.
Но что если нам нужно найти что-то до двоеточия, например дом из предудыщего примера.
Для этого на помощь приходят «заглядывания назад».

Заглядывание назад (Look Behinds)

Позволяет просмотреть строку назад и определить наличие совпадений с шаблоном.
Также разделяется на положительное и отрицательное.
Положительное — записывается «?

$string = ‘I live in the whitehouse’ ;

// try to match house preceded by white
if ( preg_match ( «/(? , $string ) ) <
// if we find the word white, not followed by house
echo ‘Совпадение’ ;
> else <
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
Совпадение

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

Если мы хотим, чтобы «house» НЕ следовал за словом «white»?
Используем отрицительное заглядывание назад — «?

/*** a simple string ***/
$string = ‘I live in the whitehouse’ ;

/*** try to match house preceded by white ***/
if ( preg_match ( «/(? , $string ) )
<
/*** if we find the word white, not followed by house ***/
echo ‘Совпадение’ ;
>
else
<
/*** if no match is found ***/
echo ‘Не думаю’ ;
>
?>

Результат скрипта:
no match is found

Потому что отрицательное заглядывание не нашло шаблона «house» c шаблоном «white» в начале его.
Давайте поменяем цвет «дома», белым слишком девственный для правительственного здания.

$string = ‘I live in the bluehouse’ ;

// ищем `house` с непредшествующим `white`
if ( preg_match ( «/(? , $string ) ) <
/*** if we find the word white, not followed by house ***/
echo ‘Совпадение’ ;
> else <
/*** if no match is found ***/
echo ‘Не думаю’ ;
>
?>

Мы изменили «whitehouse» на «bluehouse» и теперь наша регулярка сработала, потому что
шаблон «white» не обнаружен перед «house».

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

/*** 4 x and 4 z chars ***/
$string = «xxxxzzzz» ;

/*** greedy regex ***/
preg_match ( «/^(.*)(z+)$/» , $string , $matches ) ;

/*** results ***/
echo $matches [ 1 ] ;
echo «
» ;
echo $matches [ 2 ] ;
?>

Первый паттерн (.*) совпал со всеми четыремя «x» и тремя из четырех символов «z».
Сработала жадность — шаблон забрал столько символов, сколько было в искомой строке.
Проще простого помочь перестать квантификаторам быть жадными, добавив «?» к квантификатору как в примере:

/*** string of characters ***/
$string = «xxxxzzzz» ;

/*** a non greedy match ***/
preg_match ( «/^(.*?)(z+)$/» , $string , $matches ) ;

/*** show the matches ***/
echo $matches [ 1 ] ;
echo «
» ;
echo $matches [ 2 ] ;
?>

Теперь $matches[1] содержит четыре «x» символа и $matches[2] четыре символа «z».
Потому что квантификатор «?» изменил поведение шаблона с «взять как можно БОЛЬШЕ» на «взять как можно МЕНЬШЕ».

Чтобы сделать нежадным весь шаблон, используем модификатор «U».

/*** string of characters ***/
$string = «xxxxzzzz» ;

/*** a non greedy match ***/
preg_match ( «/^(.*)(z+)$/U» , $string , $matches ) ;

/*** show the matches ***/
echo $matches [ 1 ] ;
echo «
» ;
echo $matches [ 2 ] ;
?>

Результат как в предыдущем примере.

Подводные камни c ? и U

Важно заметить, что модификатор «U» не только делает поиск нежадным, он инвертирует поведение жадности квантификатора «?».
Если использовался квантификатор «?» и одновременно модификатор «U», действие «?» будет инвертировано.

/*** string of characters ***/
$string = «xxxxzzzz» ;

/*** a non greedy match ***/
preg_match ( «/^(.*?)(z+)$/U» , $string , $matches ) ;

/*** show the matches ***/
echo $matches [ 1 ] ;
echo «
» ;
echo $matches [ 2 ] ;
?>

Результат скрипта:
xxxxzzz
Delimiters

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

Поэтому в качестве разделителя можно взять любой символ, например #, @, ^ и т.п.

/*** get the host name from a url ***/
preg_match ( ‘#^(?:http://)?([^/]+)#i’ , «http://www.phpro.org/tutorials» , $matches ) ;

/*** show the host name ***/
echo $matches [ 1 ] ;
?>


Примеры

// the string to match against
$string = ‘The cat sat on the mat’ ;

// match the beginning of the string
echo preg_match ( «/^The/» , $string ) ;

// match the end of the string
// returns 1
echo preg_match ( «/mat \z /» , $string ) ;

// match anywhere in the string
// returns 0 as no match was found for dog.
echo preg_match ( «/dog/» , $string ) ;
?>

Поиск нескольких шаблонов

// the string to match against
$string = ‘The cat sat on the matthew’ ;

// matches the letter «a» followed by zero or more «t» characters
echo preg_match ( «/at*/» , $string ) ;

// matches the letter «a» followed by a «t» character that may or may not be present
echo preg_match ( «/at?/» , $string ) ;

// matches the letter «a» followed by one or more «t» characters
echo preg_match ( «/at+/» , $string ) ;

// matches a possible letter «e» followed by one of more «w» characters anchored to the end of the string
echo preg_match ( «/e?w+ \z /» , $string ) ;

// matches the letter «a» followed by exactly two «t» characters
echo preg_match ( «/at<2>/» , $string ) ;

// matches a possible letter «e» followed by exactly two «t» characters
echo preg_match ( «/e?t<2>/» , $string ) ;

// matches a possible letter «a» followed by exactly 2 to 6 «t» chars (att attt atttttt)
echo preg_match ( «/at<2,6>/» , $string ) ;

Запомните, preg_match() возвращает только 0 или 1, и останавливается после первого успешного нахождения шаблона.

Чтобы найти все совпадения — используйте preg_match_all().

Чит Шит

\w — Any “word” character (a-z 0-9 _)
\W — Any non “word” character
\s — Whitespace (space, tab CRLF)
\S — Any non whitepsace character
\d — Digits (0-9)
\D — Any non digit character
. — (Period) – Any character except newline

^ — Start of subject (or line in multiline mode)
$ — End of subject (or line in multiline mode)
[ — Start character class definition
] — End character class definition
| — Alternates, eg (a|b) matches a or b
( — Start subpattern
) — End subpattern
\ — Escape character

n- Zero or more of n
n+ — One or more of n
n? — Zero or one occurrences of n
— n occurrences exactly
— At least n occurrences
— Between n and m occurrences (inclusive)

i — Case Insensitive
m — Multiline mode — ^ and $ match start and end of lines
s — Dotall — . class includes newline
x — Extended– comments and whitespace
e — preg_replace only – enables evaluation of replacement as PHP code
S — Extra analysis of pattern
U — Pattern is ungreedy
u — Pattern is treated as UTF-8

\b — Word boundary
\B — Not a word boundary
\A — Start of subject
\Z — End of subject or newline at end
\z — End of subject
\G — First matching position in subject

(?=) — Positive look ahead assertion foo(?=bar) matches foo when followed by bar
(?!) — Negative look ahead assertion foo(?!bar) matches foo when not followed by bar
(? ) — Once-only subpatterns (?>\d+)bar Performance enhancing when bar not present
(?(x)) — Conditional subpatterns
(?(3)foo|fu)bar — Matches foo if 3rd subpattern has matched, fu if not
(?#) — Comment (?# Pattern does x y or z)

Дополнения от меня

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

Дополнительные шорткуты для шаблонов. Могут применяться только внутри классов.
Пример для поиска числа с пробелами — preg_match(«@[[:space:]\d]+@», $string)

Внутренние модификаторы шаблонов

Модификаторы m, s, x, U, X, J могут использоваться внутри шаблона.
Например (?im) установит мультистроковой регистронезивисимый метод поиска для паттерна.
Отключить внутренние модификаторы можно перечислив их через дефис, например (?im-sx)

Пример:
шаблон (?i:foo) совпадет с «FoO»

Именованный «захват»

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

Записывается: (? ), (?’name’) или (?P ).
Раньше поддерживался только такой синтаксис: (?P ). [

preg_match ( ‘/Name: (.+), Age: ( \d +)/’ , $text , $matches ) ;
preg_match ( ‘/Name: (?P .+), Age: (?P \d +)/’ , $text , $matches ) ;
?>

Результат скрипта:
array(‘Name’ => ‘строка’, ‘Age’ => ‘число’)

Замена через callback-функцию

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

\s * \w |’ ,
create_function (
‘$matches’ ,
‘return strtoupper($matches[0]);’
) ,
$line
) ;
?>

Данный код заменит все первые буквы в параграфах на заглавные.

В php >= 5.3 callback-функцию можно записать в сокращенном виде

\s * \w |’ ,
function ( $matches ) <
return strtoupper ( $matches [ 0 ] ) ;
> ,
$line
) ;
?>

Форум

Справочник

Поиск по форуму
Расширенный поиск
К странице.

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

Регулярные выражения в javascript имеют особую краткую форму и стандартный PCRE-синтаксис.

Работают они через специальный объект RegExp.

Кроме того, у строк есть свои методы search,match,replace, но чтобы их понять — разберем-таки сначала RegExp .

Объект RegExp

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

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

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

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

При поиске можно использовать большинство возможностей современного PCRE-синтаксиса.

Спецсимволы в регулярном выражении

Символ Значение
\ Для обычных символов — делает их специальными. Например, выражение /s/ ищет просто символ ‘s’. А если поставить \ перед s, то /\s/ уже обозначает пробельный символ.И наоборот, если символ специальный, например *, то \ сделает его просто обычным символом «звездочка». Например, /a*/ ищет 0 или больше подряд идущих символов ‘a’. Чтобы найти а со звездочкой ‘a*’ — поставим \ перед спец. символом: /a\*/ .
^ Обозначает начало входных данных. Если установлен флаг многострочного поиска («m») , то также сработает при начале новой строки.Например, /^A/ не найдет ‘A’ в «an A», но найдет первое ‘A’ в «An A.»
$ Обозначает конец входных данных. Если установлен флаг многострочного поиска, то также сработает в конце строки.Например, /t$/ не найдет ‘t’ в «eater», но найдет — в «eat».
* Обозначает повторение 0 или более раз. Например, /bo*/ найдет ‘boooo’ в «A ghost booooed» и ‘b’ в «A bird warbled», но ничего не найдет в «A goat grunted».
+ Обозначает повторение 1 или более раз. Эквивалентно <1,>. Например, /a+/ найдет ‘a’ в «candy» и все ‘a’ в «caaaaaaandy».
? Обозначает, что элемент может как присутствовать, так и отсутствовать. Например, /e?le?/ найдет ‘el’ в «angel» и ‘le’ в «angle.»Если используется сразу после одного из квантификаторов * , + , ? , или <> , то задает «нежадный» поиск (повторение минимально возможное количество раз, до ближайшего следующего элемента паттерна), в противоположность «жадному» режиму по умолчанию, при котором количество повторений максимально, даже если следующий элемент паттерна тоже подходит.Кроме того, ? используется в предпросмотре, который описан в таблице под (?=) , (?!) , и (?: ) .
. (Десятичная точка) обозначает любой символ, кроме перевода строки: \n \r \u2028 or \u2029. ( можно использовать [\s\S] для поиска любого символа, включая переводы строк). Например, /.n/ найдет ‘an’ и ‘on’ в «nay, an apple is on the tree», но не ‘nay’.
( x ) Находит x и запоминает. Это называется «запоминающие скобки». Например, /(foo)/ найдет и запомнит ‘foo’ в «foo bar.» Найденная подстрока хранится в массиве-результате поиска или в предопределенных свойствах объекта RegExp: $1, . $9 .Кроме того, скобки объединяют то, что в них находится, в единый элемент паттерна. Например, (abc)* — повторение abc 0 и более раз.
(?: x ) Находит x , но не запоминает найденное. Это называется «незапоминающие скобки». Найденная подстрока не сохраняется в массиве результатов и свойствах RegExp.Как и все скобки, объединяют находящееся в них в единый подпаттерн.
x (?= y ) Находит x , только если за x следует y . Например, /Jack(?=Sprat)/ найдет ‘Jack’, только если за ним следует ‘Sprat’. /Jack(?=Sprat|Frost)/ найдет ‘Jack’, только если за ним следует ‘Sprat’ или ‘Frost’. Однако, ни ‘Sprat’ ни ‘Frost’ не войдут в результат поиска.
x (?! y ) Находит x , только если за x не следует y . Например, /\d+(?!\.)/ найдет число, только если за ним не следует десятичная точка. /\d+(?!\.)/.exec(«3.141») найдет 141, но не 3.141.
x | y Находит x или y . Например, /green|red/ найдет ‘green’ в «green apple» и ‘red’ в «red apple.»
Где n — положительное целое число. Находит ровно n повторений предшествующего элемента. Например, /a<2>/ не найдет ‘a’ в «candy,» но найдет оба a в «caandy,» и первые два a в «caaandy.»
Где n — положительное целое число. Находит n и более повторений элемента. Например, /a <2,>не найдет ‘a’ в «candy», но найдет все ‘a’ в «caandy» и в «caaaaaaandy.»
Где n и m — положительные целые числа. Находят от n до m повторений элемента.
[ xyz ] Набор символов. Находит любой из перечисленных символов. Вы можете указать промежуток, используя тире. Например, [abcd] — то же самое, что [a-d] . Найдет ‘b’ в «brisket», а также ‘a’ и ‘c’ в «ache».
[^ xyz ] Любой символ, кроме указанных в наборе. Вы также можете указать промежуток. Например, [^abc] — то же самое, что [^a-c] . Найдет ‘r’ в «brisket» и ‘h’ в «chop.»
[\b] Находит символ backspace. (Не путать с \b .)
\b Находит границу слов (латинских), например пробел. (Не путать с [\b] ). Например, /\bn\w/ найдет ‘no’ в «noonday»; /\wy\b/ найдет ‘ly’ в «possibly yesterday.»
\B Обозначает не границу слов. Например, /\w\Bn/ найдет ‘on’ в «noonday», а /y\B\w/ найдет ‘ye’ в «possibly yesterday.»
\c X Где X — буква от A до Z. Обозначает контрольный символ в строке. Например, /\cM/ обозначает символ Ctrl-M.
\d находит цифру из любого алфавита (у нас же юникод). Испльзуйте [0-9], чтобы найти только обычные цифры. Например, /\d/ или /[0-9]/ найдет ‘2’ в «B2 is the suite number.»
\D Найдет нецифровой символ (все алфавиты). [^0-9] — эквивалент для обычных цифр. Например, /\D/ или /[^0-9]/ найдет ‘B’ в «B2 is the suite number.»
\f,\r,\n Соответствующие спецсимволы form-feed, line-feed, перевод строки.
\s Найдет любой пробельный символ, включая пробел, табуляцию, переводы строки и другие юникодные пробельные символы. Например, /\s\w*/ найдет ‘ bar’ в «foo bar.»
\S Найдет любой символ, кроме пробельного. Например, /\S\w*/ найдет ‘foo’ в «foo bar.»
\t Символ табуляции.
\v Символ вертикальной табуляции.
\w Найдет любой словесный (латинский алфавит) символ, включая буквы, цифры и знак подчеркивания. Эквивалентно [A-Za-z0-9_] . Например, /\w/ найдет ‘a’ в «apple,» ‘5’ в «$5.28,» и ‘3’ в «3D.»
\W Найдет любой не-(лат.)словесный символ. Эквивалентно [^A-Za-z0-9_] . Например, /\W/ и /[^$A-Za-z0-9_]/ одинаково найдут ‘%’ в «50%.»
\ n где n — целое число. Обратная ссылка на n-ю запомненную скобками подстроку. Например, /apple(,)\sorange\1/ найдет ‘apple, orange,’ в «apple, orange, cherry, peach.». За таблицей есть более полный пример.
\0 Найдет символ NUL. Не добавляйте в конец другие цифры.
\x hh Найдет символ с кодом hh (2 шестнадцатиричных цифры)
\u hhhh Найдет символ с кодом hhhh (4 шестнадцатиричных цифры).

Проверка результатов: метод test

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

Метод test начинает поиск, начиная со свойства lastIndex объекта RegExp , если оно установлено.

Поиск совпадений: метод exec

Метод exec возвращает массив и ставит свойства регулярного выражения.
Если совпадений нет, то возвращается null.

В результате выполнения скрипта будут такие результаты:

Объект Свойство/Индекс Описания Пример
myArray Содержимое myArray . [«dbBd», «bB», «d»]
index Индекс совпадения (от 0) 1
input Исходная строка. cdbBdbsbz
[0] Последние совпавшие символы dbBd
[1], . [ n ] Совпадения во вложенных скобках, если есть. Число вложенных скобок не ограничено. [1] = bB
[2] = d
myRe lastIndex Индекс, с которого начинать следующий поиск. 5
ignoreCase Показывает, что был включен регистронезависимый поиск, флаг » i «. true
global Показывает, что был включен флаг » g » поиска всех совпадений. true
multiline Показывает, был ли включен флаг многострочного поиска » m «. false
source Текст паттерна. d(b+)(d)

Если в регулярном выражении включен флаг » g «, Вы можете вызывать метод exec много раз для поиска последовательных совпадений в той же строке. Когда Вы это делаете, поиск начинается на подстроке str , с индекса lastIndex . Например, вот такой скрипт:

Этот скрипт выведет следующий текст:

В следующем примере функция выполняет поиск по input. Затем делается цикл по массиву, чтобы посмотреть, есть ли другие имена.

Предполагается, что все зарегистрированные имена находятся в массиве А:

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

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

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

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

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

Метод search(regexp)

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

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

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

Метод match(regexp)

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

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


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

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

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

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

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

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

Замена, replace

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

regexp Объект RegExp. Его вхождения будут заменены на значение, которое вернет параметр номер 2 substr Строка, которая будет заменена на newSubStr . newSubStr Строка, которая заменяет подстроку из аргумента номер 1. function Функция, которая может быть вызвана для генерации новой подстроки (чтобы подставить ее вместо подстроки, полученной из аргумента 1).

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

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

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

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

Спецсимволы в строке замены

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

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

Замена через функцию

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

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

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

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

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

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

Статичные регэкспы

В некоторых реализациях javascript регэкспы, заданные коротким синтаксисом /. / — статичны. То есть, такой объект создается один раз в некоторых реализациях JS, например в Firefox. В Chrome все ок.

По стандарту эта возможность разрешена ES3, но запрещена ES5.

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

При поиске всех совпадений в цикле проблем не возникает, т.к. последняя итерация (неудачная) обнуляет lastIndex .

Дополнительно

Для общего понимания регулярных выражений можно почитать Статью в wikipedia.

Более подробно они описаны в книге (англ.) Beginning Regular Expressions.

Как новичку разобраться в регулярных выражениях

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

Все изменилось, когда мне пришлось более плотно работать с Google Analytics и Google Tag Manager в Netpeak. Без понимания регулярных выражений сложно представить себе нормальную настройку фильтров, пользовательских сегментов в GA или правил в GTM. К слову, если хотите сэкономить время на настройке аналитических инструментов, обращайтесь:

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

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

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

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

Большинство символов в регулярных выражениях представляют сами себя, за исключением группы специальных символов «[ ] \ / ^ $ . | ? * + ( ) < >». Если эти символы нужно представить в качестве символов текста, их следует экранировать обратной косой чертой «\».

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

  • «^» — каретка, циркумфлекс или просто галочка. Начало строки;
  • «$» — знак доллара. Конец строки;
  • «.» — точка. Любой символ;
  • «*» – знак умножения, звездочка. Любое количество предыдущих символов;
  • «+» – плюс. 1 или более предыдущих символов;
  • «?» – вопросительный знак. 0 или 1 предыдущих символов;
  • «( )» – круглые скобки. Группировка конструкций;
  • «|» – вертикальная линия. Оператор «ИЛИ»;
  • «[ ]» – квадратные скобки. Любой из перечисленных символов, диапазон. Если первый символ в этой конструкции – «^», то массив работает наоборот – проверяемый символ не должен совпадать с тем, что перечислено в скобках;
  • «< >» – фигурные скобки. Повторение символа несколько раз;
  • «\» – обратный слеш. Экранирование служебных символов.

Также существуют специальные метасимволы, ими можно заменить некоторые готовые конструкции:

  • \b — обозначает не символ, а границу между символами;
  • \d — цифровой символ;
  • \D — нецифровой символ;
  • \s — пробельный символ;
  • \S — непробельный символ;
  • \w — буквенный или цифровой символ или знак подчеркивания;
  • \W — любой символ, кроме буквенного или цифрового символа или знака подчеркивания.

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

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

1. Изучаем регулярные выражения в текстовом редакторе

Почти всем новичкам я сразу рекомендую ставить текстовый редактор NotePad++ и начинать тренироваться в нём. Почему именно в этом текстовом редакторе:

  • в большинстве случаев спецсимволы не нужно экранировать;
  • Notepad++ сохраняет конструкции предыдущих запросов;
  • функция «Пометки» наглядно показывает результат поиска по заданной конструкции и позволяет быстро внести правки:

2. Проверяем знания регулярных выражений в Regex

Онлайн-сервис regex101.com позволяет ввести набор данных и регулярное выражение. После этого в наборе данных подсветятся строки, соответствующие выражению. В специальном окне Explanation регулярное выражение разбирается по частям:

Давайте потренируемся: задача — подсветить всю строку полностью. Нужно поставить галочку напротив «multi line».

Регулярные выражения для проверки знаний:

  • выбрать все страницы;
    • (.*) — любое количество любых символов;
  • выбрать все страницы с https;
    • ^https.* — все URL, начинающиеся с https;
  • все страницы на украинском языке;
    • .*/ua/.* — все страницы, в URL которых содержится /ua/. Если использовать просто ua, в выборку попадет http://www.site.com/duals/index.html, это лишнее;
  • все индексные страницы;
    • .*index\.(php|html) — аналогично прошлому выражению, нельзя просто использовать index;
  • все карточки товаров (для русской и украинской версий);
    • .*product(s|y).* или .*product[sy].* — оба варианта подходят.

3. Тестируем регулярные выражения с помощью Jsfiddle

Jsfiddle — инструмент для экспериментов с JavaScript. В нем можно проверить условия для запуска функции или демонстрации нужных результатов.

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

4. Проверяем ошибки в регулярных выражениях с помощью Google Analytics

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

5. Нестандартные методы освоения регулярных выражений

Для тех, кто любит интерактив:

Жадные и ленивые кванторы

Кванторы в регулярных выражениях позволяют определить часть шаблона, которая должна повторяться несколько раз подряд. «Жадный» квантор старается захватить наибольший кусок текста, который только может. А «ленивая» версия (добавляется символ-модификатор «?») ищет наименьшее из возможных вхождений.

Жадный квантор (*) захватывает все — от первых кавычек до последних:

Ленивая версия квантора (*?) ищет наименьшее совпадение, поэтому найдет каждую подстроку по отдельности:

Где использовать регулярные выражения

SEO-специалисты прибегают к регулярным выражениям при работе с Google Analytics, Яндекс.Метрикой, RewriteRule в .htaccess, в текстовых редакторах, при работе с краулерами (Netpeak Spider).

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

1. Выделить всё, кроме домена:

Использую, когда есть большой список URL-адресов (например, внешних ссылок) и для анализа нужно вычленить только домен. В NotePad++ с помощью функции замены меняю на пустую строку и получаю чистый список доменов:

2. Выделить URL заданной вложенности:

Здесь конструкция (/.*?/) обозначает один уровень вложенности.

Использую это выражение, когда нужно задать максимально разрешенную вложенность URL при сканировании сайта в Netpeak Spider.

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

Что еще почитать о регулярных выражениях

  • 8 полезных регэкспов с наглядным разбором;
  • Некоторые ошибки при написании регэкспов;
  • Регулярные выражения, пособие для новичков (первая, вторая часть);
  • Истинное могущество регулярных выражений;
  • Шпаргалка по регулярным выражениям и объяснения к шпаргалке.

Выводы

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

Его достаточно сложно освоить, ещё сложнее научиться правильно применять. Взамен этот инструмент существенно облегчит вашу работу и сделает её гораздо эффективнее.

Набросаем любимых регулярных выражений в комментариях?

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

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

Управляющие символы (., ?, *, +, <>, [], |, $, ^):
. Заменяет один произвольный символ a.c aac, abc .
^ Отрицание [^0-9] Все кроме цифр. (Ставится внутри скобок)
^ Начало строки ^a Все строки, которые начинаются с буквы a (Ставится в начале строки)
| Альтернативный оператор a|b|c или [abc] Строка содержит либо «a» либо «b» либо «c».
* НОЛЬ или более символов [a-z]* Подряд может идти сколь угодно букв
+ ОДНО или более повторений [a-z]+ Должна быть минимум одна буква
? Ноль или одно повторение 0?7 7, 07
[a-z] <1,3>Подряд может идти от одного до трех букв
[a-z][0-9] Сначала в строке идут n символов, потом k цифр
[a-z] <0,>Символ может встречаться n и более раз. Тоже самое [a-z]*
$ Конец строки zz$ Все строки, которые заканчиваются строкой «zz»
() Сохранение результата [a-z] <0,>Символ может встречаться n и более раз. Тоже самое [a-z]*
/s Пробел, табуляция, новая строка
/S Все, что не совпадает с /s
/w Слово
/W Все, что не совпадает с /w
/d Цифры
/D Все, что не совпадает с /d

Примеры:
«\\[text\\]» — Поиск строки «[text]» (с управляющим символом).
«/^[a-zA-Z0-9]+$/» — Имя пользователя состоит из букв и цифр.

Мастер Йода рекомендует:  Как не быть тем парнем, а писать функции лучше
Добавить комментарий