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


Регулярные выражения (РВ) это, по существу, крошечный язык программирования, встроенный в Python и доступный при помощи модуля re. Используя его, вы указывается правила для множества возможных строк, которые вы хотите проверить; это множество может содержать английские фразы, или адреса электронной почты, или TeX команды, или все что угодно. С помощью РВ вы можете задавать вопросы, такие как «Соответствует ли эта строка шаблону?», или «Совпадает ли шаблон где-нибудь с этой строкой?». Вы можете также использовать регулярные выражения, чтобы изменить строку или разбить ее на части различными способами.

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


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

Простые шаблоны

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

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

Соответствие символов

Большинство букв и символов соответствуют сами себе. Например, регулярное выражение test будет в точности соответствовать строке test (Вы можете включить режим без учета регистра, что позволит этому регулярному выражению также соответствовать Test или TEST, но об этом позже).

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

Вот полный список метасимволов; их значения будут обсуждаться в остальной части этого HOWTO.

. ^ $ * + ? { [ ] | ( )


Первые метасимволы, что мы рассмотрим это [ и ]. Они используются для определения класса символов, являющегося набором символов, с которыми вы ищите совпадение. Символы могут быть перечислены по отдельности, или в виде некоторого диапазона символов, обозначенного первым и последним символом, разделенных знаком '-'. Например, [abc] будет соответствовать любому из символов a, b или c; это то же самое, что выражение [a-c], использующее диапазон для задания того же множества символов. Если вы хотите сопоставить только строчные буквы, РВ будет иметь вид [a-z].

Метасимволы не активны внутри классов. Например, [akm$] будет соответствовать любому из символов 'a', 'k', 'm' или '$'. Знак '$' это обычно метасимвол (как видно из списка символов выше), но внутри класса символов он лишается своей особой природы.

Для того, чтобы находить соответствие символам вне этого класса, в начале класса добавляется символ '^'. Например, выражение [^5]


соответствует любому символу, кроме ‘5’.

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

Некоторые из специальных последовательностей, начинающихся с '' представляют предопределенные наборы символов, часто бывающие полезными, такие как набор цифр, набор букв, или множества всего, что не является пробелами, символами табуляции и т. д. (whitespace). Следующие предопределенные последовательности являются их подмножеством. Полный список последовательностей и расширенных определений классов для Юникод-строк смотрите в последней части Regular Expression Syntax.

d
Соответствует любой цифре; эквивалент класса [0-9].
D
Соответствует любому нечисловому символу; эквивалент класса [^0-9].
s
Соответствует любому символу whitespace; эквивалент [ tnrfv].
S
Соответствует любому не-whitespace символу; эквивалент [^ tnrfv]


.
w
Соответствует любой букве или цифре; эквивалент [a-zA-Z0-9_].
W
Наоборот; эквивалент [^a-zA-Z0-9_].

Эти последовательности могут быть включены в класс символов. Например, [s,.] является характер класс, который будет соответствовать любому whitespace-символу или запятой или точке.

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

Повторяющиеся вещи

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

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

Например, ca*t будет соответствовать ct (0 символов a), cat (1 символ a), caaat (3 символа a), и так далее. Движок регулярных выражений имеет различные внутренние ограничения вытекающие из размера int


типа для C, что не позволяет проводить ему сопоставление более 2 миллиардов символов ‘a’. (Надеюсь, вам это не понадобится).

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

Пошаговое рассмотрение какого-нибудь примера сделает объяснение более ясным. Давайте рассмотрим выражение a[bcd]*b. Оно соответствует букве 'a', нулю или более символов из класса [bcd], и наконец, заключительной букве 'b'. Теперь представим себе сопоставление этого регулярного выражения строке abcbd. Вот как происходит сравнение поэтапно:

1. a — ‘a’ соответствует регулярному выражению
2. abcbd — движок сопоставляет [bcd]* на как можно большем числе символов, то есть до конца строки (поскольку все символы соответствуют классу в скобках [])
3. Провал — движок пытается сопоставить последний символ в регулярном выражении — букву b, но текущая позиция уже в конце строки, где нет никаких символов, так что он терпит неудачу.
4. abcb — вернулись назад, уменьшили на один символ сопоставление с [bcd]*
5. Провал — пытаемся снова найти b


, но в конце только d
6. abc — снова возвращаемся назад, теперь [bcd]* это только bc
7. abcb — снова ищем последний символ регулярного выражения — b. Теперь он действительно находится на нужной позиции и мы добиваемся успеха

Итак, был достигнут конец РВ и сопоставление с ним дало abcb. Этот пример показал, как движок сначала забирается так далеко, как может, и, если не находит соответствия, возвращается назад, снова и снова работая с остатком регулярного выражения. Он будет делать так до тех пор, пока не получит ноль совпадений для [bcd]*, и, если и тогда не получится совпадения, то заключит, что строка совсем не соответствует шаблону РВ.

Другой метасимвол повторения это +, повторяющий последовательность сравнения один или более раз. Обратите особое внимание на разницу между * и +. * требует соответствия необходимой части ноль или более раз, то есть повторяемое может и не присутствовать вовсе, а + требует, по крайней мере одно вхождение. Для аналогичного примера ca+t будет сопоставляться cat или, например, caaat, но никак не ct.

Есть еще два повторяющих спецификатора. Знак вопроса, ?, проверяющий наличие совпадения ноль или один раз. Например, home-?brew соответствует как homebrew


, так и home-brew.

Наиболее полный повторяющий спецификатор это {m,n}, где m и n — целые числа. Этот определитель означает, что здесь должно быть не менее m и не более n повторений. Например, a/{1,3}b соответствует a/b, a//b и a///b. Это не может быть ab, строка в которой нет слэшей или a////b, в которой их четыре.

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

Читатели уже могли заметить, что все три остальных спецификатора могут быть выражены через последний. {0,} это то же, что *, {1,} эквивалентно +, и {0,1} может заменять знак ?.

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

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

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

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


>>> import re
>>> p = re.compile(‘ab*’)
>>> print p
<_sre.SRE_Pattern object at 0x…>

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

>>> p = re.compile('ab*', re.IGNORECASE)

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

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

Бэкслеш бедствие
(Или обратная косая чума 🙂 )

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


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

Скажем, вы хотите написать регулярное выражение, соответствующее section, которое надо найти в LaTeX-файле. Чтобы выяснить, что написать в коде программы, начнем со строки, которую необходимо сопоставить. Далее, вы должны избежать любых бэкслешей и других метасимволов, экранировав их обратной косой чертой, в результате чего в строке появляется часть \. Тогда, результирующая строка, которая должна быть передана re.compile () должен быть \section. Однако, для того, чтобы выразить это как строковый литерал Python, оба бэкслеша должны быть экранированы снова, то есть "\\section".

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

Решение заключается в использовании для регулярных выражений «сырых» строк (raw string); в строковых литералах с префиксом 'r' слэши никак не обрабатываются, так что r"n" это строка из двух символов (» и ‘n’), а "n" — из одного символа новой строки. Поэтому регулярные выражения часто будут записываться с использованием сырых строк.


Regular String Raw string
‘ab*’ r’ab*’
‘\\section’ r’\section*’
‘\w+\s+\1’ r’w+s+1′

Выполнение сопоставлений

После того, как у вас есть объект, представляющий скомпилированное регулярное выражение, что вы с ним будете делать? Объекты шаблонов имеют несколько методов и атрибутов. Только самые важные из них будут рассмотрены здесь; для получения полного списка ознакомьтесь с документацией re.

Метод/атрибут Цель
match() Определить, начинается ли совпадение регулярного выражения с начала строки
search() Сканировать всю строку в поисках всех мест совпадений с регулярным выражением
findall() Найти все подстроки совпадений с регулярным выражением и вернуть их в виде списка
finditer() Найти все подстроки совпадений с регулярным выражением и вернуть их в виде итератора

Если не было найдено ни одного совпадения, то match() и search() возвращают None. Если поиск успешен, возвращается экземпляр MatchObject, содержащий информацию о совпадении: где оно начинается и заканчивается, подстрока соответствия, и так далее.

Вы можете узнать об этом, интерактивно поэкспериментировав с модулем re. Вы также можете взглянуть на Tools/scripts/redemo.py, демонстрационную программу, включенную в дистрибутив Python. Она позволяет вводить регулярные выражения и строки, и отображает, есть ли совпадение с регулярным выражением или нет. redemo.py может быть весьма полезна для отладки сложных регулярных выражений. Kodos Фила Шварца — еще один интерактивный инструмент для разработки и тестирования моделей РВ.

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

>>> import re
>>> p = re.compile(‘[a-z]+’)
>>> p
<_sre.SRE_Pattern object at 0x…>

Теперь вы можете попробовать сравнить строки для регулярного выражения [a-z]+. Пустая строка ему не будет соответствовать, потому что + означает повторение «один или больше» раз. match() в этом случае должен вернуть None, что и видим:

>>> p.match("")
>>> print p.match("")
None

Теперь попробуем строку, которая должна совпасть с шаблоном: 'tempo'. В этом случае match() вернет MatchObject, который вы можете разместить в какой-то переменной, чтобы использовать ее в дальнейшем:

>>> m = p.match(‘tempo’)
>>> print m
<_sre.SRE_Match object at 0x…>

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

Метод/атрибут Цель
group() Вернуть строку, сошедшуюся с регулярным выражением
start() Вернуть позицию начала совпадения
end() Вернуть позицию конца совпадения
span() Вернуть кортеж (start, end) позиций совпадения

>>> m.group()
‘tempo’
>>> m.start(), m.end()
(05)
>>> m.span()
(05)

Так как метод match() проверяет совпадения только с начала строки, start() всегда будет возвращать 0. Однако метод search() сканирует всю строку, так что для него начало не обязательно в нуле:

>>> print p.match(‘::: message’)
None
>>> m = p.search(‘::: message’) ; print m
<_sre.SRE_Match object at 0x…>
>>> m.group()
‘message’
>>> m.span()
(411)

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

p = re.compile( … )
m = p.match( ‘string goes here’ )
if m:
    print ‘Match found: ‘, m.group()
else:
    print ‘No match’

Два метода возвращают все совпадения для шаблона. findall() возвращает список совпавших подстрок:

>>> p = re.compile(d+’)
>>> p.findall(’12 drummers drumming, 11 pipers piping, 10 lords a-leaping’)
[’12’’11’’10’]

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

>>> iterator = p.finditer(’12 drummers drumming, 11 … 10 …’)
>>> iterator
<callable-iterator object at 0x401833ac>
>>> for match in iterator:
…     print match.span()

(02)
(2224)
(2931)

Функции на уровне модуля

Вам не обязательно нужно создавать объекты шаблонов и вызывать их методы; модуль re также предоставляет функции верхнего уровня match(), search(), findall(), sub() и так далее. Эти функции принимают те же аргументы, что и для шаблонов, со строкой РВ в качестве первого аргумента и также возвращают None или MatchObject.

>>> print re.match(r‘Froms+’‘Fromage amk’)
None
>>> re.match(r‘Froms+’‘From amk Thu May 14 19:12:10 1998’)
<_sre.SRE_Match object at 0x…>

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

Должны вы использовать эти функции или шаблоны с методами? Это зависит от того, как часто будет использоваться регулярное выражение и от вашего личного стиля кодинга. Если регулярное выражение используется только в одном месте кода, то такие функции, вероятно, более удобны. Если программа содержит много регулярных выражений, или повторно использует одни и те же в нескольких местах, то будет целесообразно собрать все определения в одном месте, в разделе кода, который предварительно компилирует все регулярные выражения. В качестве примера из стандартной библиотеки, вот кусок из xmllib.py:

ref = re.compile( ... )
entityref = re.compile( ... )
charref = re.compile( ... )
starttagopen = re.compile( ... )

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

Флаги компиляции

Флаги компиляции позволяют изменять некоторые аспекты того, как работают регулярные выражения. Флаги доступны в модуле под двумя именами: длинным, таким как IGNORECASE и коротким, в однобуквенной форме, таким как I. Несколько флагов могут быть заданы в форме двоичного ИЛИ; например re.I | re.M устанавливает флаги I и M.

DOTALL, S
Сопоставление, такое же как '.', то есть с любым символом, но при включении этого флага, в рассмотрение добавляется и символ новой строки.

IGNORECASE, I
Сопоставление без учета регистра; Например, [A-Z] будет также соответствовать и строчным буквам, так что Spam будет соответствовать Spam, spam, spAM и так далее.

LOCALE, L
Делает w, W, b, B зависящими от локализации. Например, если вы работаете с текстом на французском, и хотите написать w+ для того, чтобы находить слова, но w ищет только символы из множества [A-Za-z] и не будет искать ‘é’ или ‘ç’. Если система настроена правильно и выбран французский язык, ‘é’ также будет рассматриваться как буква.

MULTILINE, M
(Метасимволы ^ и $ еще не были описаны; они будут представлены немного позже, в начале второй части этого пособия.

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

UNICODE, U
Делает w, W, b, B, d, D, s, S соответствующими таблице Unicode.

VERBOSE, X
Включает многословные (подробные) регулярные выражения, которые могут быть организованы более ясно и понятно. Если указан этот флаг, пробелы в строке регулярного выражения игнорируется, кроме случаев, когда они имеются в классе символов или им предшествует неэкранированный бэкслеш; это позволяет вам организовать регулярные выражения более ясным образом. Этот флаг также позволяет помещать в регулярные выражения комментарии, начинающиеся с '#', которые будут игнорироваться движком.

Пример того, как РВ становится существенно проще читать:

charref = re.compile(r"""
 &[#]                     # Start of a numeric entity reference
 (
     0[0-7]+            # Octal form
   | [0-9]+              # Decimal form
   | x[0-9a-fA-F]+   # Hexadecimal form
 )
 ;                           # Trailing semicolon
"""
re.VERBOSE)

Без verbose это выглядело бы так:

charref = re.compile("&#(0[0-7]+"
                     "|[0-9]+"
                     "|x[0-9a-fA-F]+);")

В приведенном выше примере была использована автоматическая конкатенация Python строковых литералов для разбивки РВ на более мелкие части, но, все равно, без пояснений это пример труднее понять, чем версию с помощью re.VERBOSE.

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

Продолжение

habr.com

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

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

 )( ] [  ^ $ . | ? * + 

Их следует экранировать, т.е. поставить обратный слеш ().

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

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

Метасимвол точка

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

Создайте пример из трёх строк. Если мы добавим квантификатор + после точки (.+), то тем самым зададим поиск совпадающих символов от одного до бесконечности.

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

Поскольку точка не совпадает с символом перевода строки, шаблон найдет совпадение до конца строки.

Мы знаем, что можно экранировать метасимвол точки, чтобы найти обычную точку.

Есть и другой способ — поместить точку в символьный класс, где она рассматривается как обычный символ: [.]+.

Использовать метасимвол точки полезно, когда есть строка с динамической составляющей, которая меняется. http://example.com/pictures/123/

Тогда для строки /pictures/123/, где числа 123 могут меняться, применим паттерн:

 /pictures/.../ 

Мы экранировали слеши, ищем слово pictures, а также любые три символа (обязательно) после этого слова и слеша.

Наборы символов [Квадратные скобки]

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

Такой пример /pictures/[0-9]/ будет находить строку /pictures/1/ (с одним символом), но не найдет /pictures/123/

Можно указать буквы [a-z] — любой символ алфавита.

Символ ^ означает НЕ — [^ae]

Можно указывать не диапазон, а просто указать нужные символы. Например, [19] (напоминаю, только один символ)

Тогда /pictures/[19]/ найдет варианты /pictures/1/ и /pictures/9/

Есть готовые сокращения для диапазонов

 9 [0-9] цифры D [^d] не цифры s [fnrtv] пробельный символ S [^s] не пробельный символ w [da-zA-Z_] буквенный символ W [^w] не буквенный символ 

Позиция

Если мы хотим найти какой-то конкретный текст, который заканчивается с определенным набором символов, то используется символ $

 Рыжик - это кот. Рыжик - это кот кот по имени Рыжик. 

Тогда выражение кот$ найдет слово только во второй строке. В первой в конце есть точка. В третьей слово начинается, а не заканчивается.

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

Символ b определяет границу слова, B — не границу слова.

Например, выражение [A-Z] будет находить все заглавные буквы. В том числе по два символа в словах TextView, StatusBar, EditText

Если использовать b[A-Z] то ищутся символы, которые является границей слова. Т.е. будет находить первые заглавные буквы в указанных словах. Соответственно, B[A-Z] наоборот найдет вторые заглавные буквы в этих словах.

Последовательности {Фигурные скобки}

Последовательности задаются фигурными скобками.

Если использовать [A-Z] то найдутся большие заглавные буквы, но один раз. А выражение [A-Z]{1,4} указывает, что нужно показать все повторяющиеся символы от 1 до 4 раз. Можно указать точное значение [A-Z]{3} — найдет слова, где идут именно три заглавные буквы подряд.

До четырех символов [A-Z]{,4}
От четырех символов [A-Z]{4,}

Существует сокращения для них *, +, ?

* — {0,} ноль или более символов
+ — {1,} один или более символов
? — {0,1} ноль или один символ

^.*слово$ — такое выражение найдет целую строку, которое заканчивается на слово.

Перебор

TExT|TEXT — найдет два варианта слова, которые написаны в разных регистрах. | — это или. Как вариант TE(x|X)T — третий символ мы определили в двух вариантах.

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

 ([0-9]+)s.*s(dddd)$ 

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

 044 - 1234 asdf 123 asdf 1234  ^[tT]eled$ 

Крышка — начало строки. Далее маленькая или большая буква T. Дальше три литерала. В конце строки должна быть цифра. Пример.

 Tele2 tele1 
 ([mM]y name is|I am)s[Mm]ykhailo [Pp]oliarush 

Разные вариации

 My name is Mykhailo Poliaruhs I am mykailo Poliaruhs 

Задачи

Телефонный номер 066.225-23-23

Три цифры, точка обязательно, три цифры, тире, две цифры, тире, две цифры.

 [0-9]{3}.(d{2,3}|-)* 

Как вариант, можно было написать

 d{3}.d{3}-d{2}-d{2} 

parse http: http://host.com/parameters

 [htps]+://w{2,}.w+/w+ 

parse email

 email@gmail.com w+@w+.w+ 

html tag

 <a> <[^<]+?> 

hexidecimal color #aabbcc

 #?[0-9A-Fa-f]{6} 

Применение

UNIX — найти запущенные процессы из папки bin.
Найти все email в тексте

Notepad++ (47.40)

Java (54.35)

developer.alexanderklimov.ru

(?:(?:rn)?[ t])*(?:(?:(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*|(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)*<(?:(?:rn)?[ t])*(?:@(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*(?:,@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*)*:(?:(?:rn)?[ t])*)?(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*>(?:(?:rn)?[ t])*)|(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)*:(?:(?:rn)?[ t])*(?:(?:(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*|(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)*<(?:(?:rn)?[ t])*(?:@(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*(?:,@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*)*:(?:(?:rn)?[ t])*)?(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*>(?:(?:rn)?[ t])*)(?:,s*(?:(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*|(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)*<(?:(?:rn)?[ t])*(?:@(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*(?:,@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*)*:(?:(?:rn)?[ t])*)?(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|"(?:[^"r\]|\.|(?:(?:rn)?[ t]))*"(?:(?:rn)?[ t])*))*@(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*)(?:.(?:(?:rn)?[ t])*(?:[^()<>@,;:\".[] 00-31]+(?:(?:(?:rn)?[ t])+|Z|(?=[["()<>@,;:\".[]]))|[(?:[^[]r\]|\.)*](?:(?:rn)?[ t])*))*>(?:(?:rn)?[ t])*))*)?;s*)

lurkmore.to

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

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

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

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

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

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

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

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

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

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

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

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

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

функция «Пометки» наглядно показывает результат поиска по заданной конструкции и позволяет быстро внести правки

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

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

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

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

Нужно поставить галочку напротив «multi line»

Тестовые данные:

https://www.site.ua/  www.site.com/search?q=widget+thinger  http://www.site.com/page1/page2/page3/  http://www.site.com/index.php  https://www.site.com/products/100.php  http://www.site.us/products/101.php  http://www.site.com/products/102.php  http://www.site.ua/duals/index.html  http://www.site.com/ourteam/index.php  https://www.site.com/  http://site.com/profile  http://www.site.ru/ua/index.php  http://www.site.com/ua/producty/100.php  http://www.site.com/ua/producty/101.php  https://www.site.com/ua/producty/102.php  http://1.site.com/search?q=widget  http://www.site.com/search?q=widget+thinger  https://www.site.com/search?q=smidges  http://www.site.com/index/yy.jpg

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

  • выбрать все страницы;
    • (.*) — любое количество любых символов;
  • выбрать все страницы с 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 заданной вложенности:

.*://site.com/.*?/.*?/.*?/

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

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

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

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

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

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

Выводы

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

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

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

netpeak.net

Заключение

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

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

Почитать оригинал статьи

mattweb.ru

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

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

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

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

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

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

Однако уже здесь следует быть аккуратным — как и любой язык, регулярные выражения имеют спецсимволы, которые нужно экранировать. Вот их список: . ^ $ * + ? { } [ ] | ( ). Экранирование осуществляется обычным способом — добавлением перед спецсимволом.

Набор символов

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

Здесь нам на помощь придут наборы — вместо указания конкретного символа, мы можем записать целый список, и если в исследуемой строке на указанном месте будет стоять любой из перечисленных символов, строка будет считаться подходящей. Наборы записываются в квадратных скобках — паттерну [abcd] будет соответствовать любой из символов «a», «b», «c» или «d».

Внутри набора большая часть спецсимволов не нуждается в экранировании, однако использование перед ними не будет считаться ошибкой. По прежнему необходимо экранировать символы «» и «^», и, желательно, «]» (так, [][] обозначает любой из символов «]» или «[», тогда как [[]х] – исключительно последовательность «[х]»). Необычное на первый взгляд поведение регулярок с символом «]» на самом деле определяется известными правилами, но гораздо легче просто экранировать этот символ, чем их запоминать. Кроме этого, экранировать нужно символ «-», он используется для задания диапазонов (см. ниже).

Если сразу после [ записать символ ^, то набор приобретёт обратный смысл — подходящим будет считаться любой символ кроме указанных. Так, паттерну [^xyz] соответствует любой символ, кроме, собственно, «x», «y» или «z».

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

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

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

Если необходимо описать вообще любой символ, для этого используется точка — .. Если указанные классы написать с заглавной буквы (S, D, W) то они поменяют свой смысл на противоположный — любой непробельный символ, любой символ, который не является цифрой, и любой символ кроме латиницы, цифр или подчёркивания соответственно.

Также с помощью регулярных выражений есть возможность проверить положение строки относительно остального текста. Выражение b обозначает границу слова, B — не границу слова, ^ — начало текста, а $ — конец. Так, по паттерну bJavab в строке «Java and JavaScript» найдутся первые 4 символа, а по паттерну bJavaB — символы c 10-го по 13-й (в составе слова «JavaScript»).

Диапазоны

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

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

Квантификаторы (указание количества повторений)

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

Квантификатор Число повторений Пример Подходящие строки
{n} Ровно n раз Ха{3}ха Хаааха
{m,n} От m до n включительно Ха{2,4}ха Хаа, Хааа, Хааааха
{m,} Не менее m Ха{2,}ха Хааха, Хаааха, Хааааха и т. д.
{,n} Не более n Ха{,3}ха Хха, Хаха, Хааха, Хаааха

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

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

Квантификатор Аналог Значение
? {0,1} Ноль или одно вхождение
* {0,} Ноль или более
+ {1,} Одно или более

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

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

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

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

Очевидное решение <.*> здесь не сработает — оно найдёт всю строку целиком, т.к. она начинается с тега абзаца и им же заканчивается. То есть содержимым тега будет считаться строка

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

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

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

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

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

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

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

Запоминание результата поиска по группе (обратная связь)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Время имеет формат часы:минуты. И часы, и минуты состоят из двух цифр, пример: 09:00. Напишите регулярное выражение для поиска времени в строке: «Завтрак в 09:00». Учтите, что «37:98» – некорректное время.

Java[^script]

Найдет ли регулярка Java[^script] что-нибудь в строке Java? А в строке JavaScript?

Цвет

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

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

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

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

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

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

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

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

Интересное и полезное времяпрепровождение! Найти такие кроссворды можно в нашей подборке.

tproger.ru


You May Also Like

About the Author: admind

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте, как обрабатываются ваши данные комментариев.