1. Заменить множественные пробелы и нетекстовые символы на одиночные пробелы:

   $text = "Here is the text."
   $text =~ tr[\000-\040\177\377][\040]s;
   print $text;
   Here is the text.

2. Сократить удвоенные, утроенные и т.д. буквы:

   $text = "Here is the texxxxxxt.";
   $text =~ tr/a-zA-Z/s;
   print $text;
   Here is the text.

3. Пересчитать количество небуквенных символов:

   $xcount=($text =~ tr/A-Za-z//c);

4. Обнулить восьмой бит символов, удалить нетекстовые символы:

   $text =- tr{\200-\377}{\000-\l77};
   $text =~ tr[\000-\037\177]d;

5. Заменить нетекстовые и 8-битные символы на одиночный пробел:

   $text =~ tr/\021-\176/ /cs;
   

Поиск отдельных слов

Чтобы выделить слово, можно использовать метасимвол \S соответствующий символам, отличным от "пробельных":

$text = "Now is the time.";
$text =- /(\S+)/;
print ;
Now

Однако метасимвол \S соответствует также и символам, обычно не используемым для идентификаторов. Чтобы отобрать слова, составленные из латинских букв, цифр и символов подчеркивания, нужно использовать метасимвол \w:

$text = "Now is the time.";
$text =~ /(\w+)/;
print ;
Now

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

$text = "Now is the time.";
$text =~ /(+)/;
print ;
Now

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

$text = "How is the time.";
$text=~/\b(+)\b/;
print ;
Now

Привязка к началу строки

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

$line = ".Hello!";
if($line=~m/^\./){
print "Shouldn"t start a sentence with a period!\n";
}
Shouldn"t start a sentence with a period!

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

Привязка к концу строки

Чтобы привязать шаблон к концу строки, используется метасимвол (мнимый символ) $ . В нашем примере мы используем привязку шаблона к началу и к концу строки, чтобы убедиться, что пользователь ввел только слово "exit":

While(<>){
if(m/"exlt$/) {exit;}
}

Поиск чисел

$test = "Hello!";
if($text =~ /\D/){
print "It is not a number.\n";
}
It is not a number.

To же самое можно проделать, использовав метасимвол \d:

$text = "333";
if($text =~ /^\d+$/){
print "It is a number.\n";
}
It is a number.

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

$text= "3,1415926";
if($text =~ /^(\d+\.\d*|\d+)$/){
print "It is a number.\n";
}
It is a number.

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

$text = "-2.7182";
if ($text =~ /^([+-]*\d+)(\.\d*|)$/) {
print "It is a number.\n";

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

$text = "+0.142857142857142857";
if ($text =~ /^(+|-|)\d+(\.\d*\)$/) {
print "It is a number.\n";
}
It is a number.

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

$text = "1AO";
unless (ftext =~ m/^+$/) {
print "It is not a hex number, \n";
}

Проверка идентификаторов

С помощью метасимвола \w можно проверить, состоит ли текст только из букв, цифр и символов подчеркивания (это те символы, которые perl называет словесными (word characters)):

$text="abc";
if($text=~/^\w+$/){
print "Only word characters found. \n";
}
Only word characters found.

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

$text = "аbс";
if($text=~ /^+$/) { print "Only letter characters found.\n"; }
Qnly letter characters found.

Наконец, для проверки, что текст является идентификатором, то есть начинаетcя с буквы и содержит буквы, цифры и символы подчеркивания, можно испольpовать команду:

$text = "X125c";
if($text=~ /^\w+$/) {
print "This is identifier.\n";
}
This is identifier.

Как найти множественные совпадения

Для поиска нескольких вхождений шаблона можно использовать модификатор g . Следующий пример, который мы уже видели ранее, использует команду m/.../ с модификатором g для поиска всех входжений буквы x в тексте:

$text="Here is texxxxxt";
while($text=~m/x/g) {
print "Found another x.\n";
}
Found another x.
Found another x.
Found another x.
Found another x.
Found another x.

Модификатор g делает поиск глобальным. В данном (скалярном) контексте perl помнит, где он остановился в строке при предыдущем поиске. Следующий поиск продолжается с отложенной точки. Без модификатора g команда m/.../ будет упорно находить первое вхождение буквы х, и цикл будет продолжаться бесконечно.

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

$text = "Here is texxxxxt.";
$text =~ s/x/z/g;
print $text;
Here is tezzzzzt.

Без модификатора g команда s/.../.../ заменит только первую букву х. Команда s/.../.../ возвращает в качестве значения число сделанных подстановок, что может оказаться полезным:

$text= "Here is texxxxxt.";
print (text =~ s/x/z/g)
5

Поиск нечувствительных к регистру совпадений

Вы можете использовать модификатор i , чтобы сделать поиск нечувствительным к разнице между заглавными и строчными буквами. В следующем примере про-грамма повторяет на экране введенный пользователем текст до тех пор, пока не будет введено Q , или q (сокращение для QUIT или quit), после чего программа прекращает работу:

While(<>) {
chomp;
unless (/^q$/i){ print
} else {
exit;
}
}

Выделение подстроки

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

$record = "Product number:12345
Product type: printer
Product price: 5";
if($record=~/Product type:\s*(+)/i){
print "The product"s type Is^.\n";
}
product"s type is printer.

Вызов функций и вычисление выражений при подстановке текста

Используя для команды s/.../.../ модификатор е, вы тем самым показываете, что правый операнд (то есть подставляемый текст) - это то выражение perl, которое надо вычислить. Например, с помощью встроенной функции perl uc (uppercase) можно заменить все строчные буквы слов строки на заглавные:

$text = "Now is the time.";
$text=~ s/(\w+)/uc()/ge;
print $text;
NOW IS THE TIME.

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

Поиск n-го совпадения

С помощью модификатора g перебираются все вхождения заданного шаблона. Но то делать, если нужна вполне определенная точка совпадения с шаблоном, например, вторая или третья? Оператор цикла while в сочетании с круглыми cкобками, выделяющими нужный образец, поможет вам:

$text = "Name:Anne Nanie:Burkart Name:Glaire Name: Dan";
while ($text =~ /Name: \s*(\w+)/g) {
++$match;
print "Match number $match is .\n";
}

Match number 1 is Anne
Match number 2 is Burkart
Match number 3 is Claire
Match number 4 is Dan

Этот пример можно переписать, используя цикл for:

$text = "Name:Anne Name:Burkart Name:Ciaire Name:Dan";
for ($match = 0;
$text =~ /Name:\s*(\w+)/g;
print "Match number ${\match} is .\n")
{}
Match nuwber 1 Is Anne
Match number 2 is Burkart
Match number 3 is Claire
Match number 4 is Dan

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

$text = "Name:Anne Name:Burkart Name:Claire Name:Dan";
$match =0;
$text =~ s/(Name:\s*(\w+))/ # начинается код perl
if (++$match == 2) { # увеличить счетчик
"Name:John ()" # вернуть новое значение
} else { }# оставить старое значение
/gex;
print $text;
Name:Anne Name:John (Burkart) Name:ClaireName:Dan

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

Как ограничить "жадность" квантификаторов

По умолчанию квантификаторы ведут себя как "жадные" объекты. Начиная с текущей позиции поиска, они захватывают самую длинную строку, которой может соответствовать регулярное выражение, стоящее перед квантификатором. Алгоритм перебора с возвратами, используемый perl, способен ограничивать аппетит квантификаторов, возвращаясь назад и уменьшая длину захваченной строки, если не удалось найти соответствия между текстом и шаблоном. Однако этот механизм не всегда работает так, как хотелось бы. Рассмотрим следующий пример. Мы хотим заменить текст "That is" текстом "That"s". Однако в силу "жадности" квантификатора регулярное выражение " .*is " сопоставляется фрагменту текста от начала строки и до последнего найденного "is":

$text =~ s/.*is/That"s/;
print $texts;
That"sn"t it?

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

• *? - ноль или несколько совпадений,
• +? - одно или несколько совпадений,
• ?? - ноль совпадений или одно совпадение,
• {n}? - ровно n совпадений,
• {n,}? - по крайней мере n совпадений,
• {n,m}? - совпадений по крайней мере n , но не более, чем m.

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

$text = "That is some text, isn"t it?";
$text =~ s/.*?is/That"s/;
print $texts;
That"s some text, isn"t it?

Как удалить ведущие и завершающие пробелы

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

$text = " Now is the time.";
$text =~ s/^\s+//;
print $texts;
Now is the time.

Чтобы отсечь "хвостовые" пробелы, годится команда:

$text = "Now is the time. ";
$text =~ s/\s+$//;
print $texts;
Now is the time.

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

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

$text="blah-blah";
if($text=~m!<()>(.*?)/\1!ig) {
print "\n";
}

найдет все слова, стоящие между тегами и .

В регулярных выражениях пристутствует своя семантика: быстрота, торопливость и возврат. Если квантификатор * совпадает во многих случаях, то в результате быдет выведен наибольший по длинне результат. Это жадность. Быстрота: поиск старается найти как можно быстрее. "Text"=~/m*/ , по смыслу символов m нет, но в результате будет возвращено значение 0 . Т.е. формально 0 и более символов.

$test="aaooee ooaao";
$test=~s/o*/e/;
print $test;
eaaooee ooaao

потому что 1 элемент сторки - 0 и более символов.

Если добавить квантификатор g , то результат будет таким:

Eaeaeeeeee eeaeaee

т.к строка содержит 13 мест, где может встречатся o , в том числе и пустых.

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

• /i игнорировать регистр
• /x игнорировать пропуски в шаблоне и разрешить комментарии.
• /g модификатор разрешающий выполнение поиска/замены везде, где это возможно
• /gc не сбрасывается позиция при неудачном поиске.
• /s разрешается совпрадение. с \n , игнорируется $* .
• /m разрешить совпадение ^ и $ для начала и конца строки во внутренних переводах строк
• /o однократная компиляция
• /e правая часть s/// представляет собой выполняемый код
• /ee правая часть s/// выполняется, после чего возвращаемое значение интерпретируется снова.

при вызове use locаle учитываются локальные настройки. Модификатор /g может заполнить массив значений @nums = m/(\d+)/g; но это сработает для ненакладывающихся совпадений. Чтобы поймать совпадения нужно воспользоваться оператором?=... Если ширина = 0 , то механизм поиска остался на прежнем месте. Найденые данные остаются внутри скобок. Если есть модификатор /g , то текущая позиция остается прежней, но происходит перемещение на один символ вперед.

$numbers="123456789";
@one=$numbers=~/(\d\d\d)/g;
@two=$numbers=~/(?=(\d\d\d))/g;
print "@one \n";
print "@two \n";

Модификаторы m и s нужны для поиска последовательностей символов, содержащих перевод строки. При s точка совпадает с \n и игнорируется $* . m делает совпадающими ^ и $ до и после \n . e правая часть выполняется как программный код: perl -i -n -p -e "s/(.)/lc()/g" *.html приводит все литеры во всех файлах *.html текущей директории к нижнему регистру.

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

Метасимволы

Метасимволы делятся на две группы. Одни из них действуют внутри шаблонов вообще, а другие внутри символьных определений.
«()» обозначают начало и конец второстепенного шаблона.
«» — начало и конец символьных определений.
Обратный слеш перед некоторыми буквами означает их служебную функцию, например «\n» означает переход на новую строку, а «\» перед «+-\(){}» означает их реальное значение. ^ в начале символьного определения говорит о том, что выражение не должно содержать таких символов, поэтому шаблон «[^aeiouy]» значит что символ не является гласной.
Вне квадратных скобок те же символы имеют обратное значение: например, знак «\d» означает число, «\D» – все кроме чисел, знак «^» означает начало выражения, а знак $ — конец.
Выражение «{x,y}» , где x и y – числа(x + — то же самое, что и {1,}
* — {0,}
? – {0,1}
«.» означает любой символ, кроме перехода на новую строку. Так для выделения комментариев в C++ подойдет шаблон (/\*.*\*/). Ему соответствует строка, заключенная между «/*» и
«*/».

Альтернатива

Теперь о конкретных случаях. Например, полный номер телефона можно записать так «+7-095-1234567» или «8-095-1234567» не создавать же два шаблона. Для таких случаев и предусмотрены альтернативы, вводимые знаком «|». Итак, «((8|\+7)\-(\d{3})\-(\d{5,}))» и есть нужный шаблон. Поясню: сначала идет выбор между «+7» и «8», далее «-» и трехзначный код, опять «-» и 5 или более цифр.

Проверки(Assertions)

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

«qwe(?=rty)» означает, что после «qwe» следует «rty»
«qwe(?!rty)» означает, что после «qwe» не следует
«rty»

Шаблону «{3,10}(? А строка, соответствующая шаблону «{1,10}(?

Таким образом можно задать и проверку Интернет-адреса, используя шаблон:

((http|ftp)\://((.(?

Сначала идет выбор между строками «http» и «ftp», далее «://». Затем идет последовательность любых символов(не являющихся «/»), завершающаяся точкой и комбинацией из двух трех или четырех букв и цифр (опция (?i) означает, что буква может быть как строчной, так и прописной). Далее идут «/» и любые другие символы. Тоже можно сделать и без конструкции(?

С увеличением длины строки увеличивается и время ее проверки, так шаблон «((\d+)qwe)», примененный к строке «123456789asd» будет работать примерно так:
9 цифр + qwe – не подходит,
8 цифр + qwe – не подходит,
7 цифр + qwe – не подходит,
и так вплоть до 1 цифры. Если строка длиннее, то сервер может просто зависнуть. Для предотвращения такой траты ресурсов и были придуманы одноразовые шаблоны. Вводятся они выражением «>?». Если шаблон «((?>\d+)qwe)» дошел до числа 9 и не удовлетворен результатом, то он не возвращается в начало, а продолжает проверку.

Рекурсивные шаблоны

Вместо создания вложенных шаблонов можно ввести рекурсию, обозначаемую в регулярных выражениях знаком «(?R)». Например шаблон «(\(((?>[^()]+)|(?R))*\))», примененный к строке «(abcd(ef(ghi)» оставит строку «(ghi)». Разберемся:

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

Условные шаблоны

Условные шаблоны названы условными, так как они соответствуют какому-либо условию. Они вводятся конструкциями
(?(условие)выражениееслида) и (?(условие)выражениееслида|
выражениееслинет). Вернемся к нашим баранам…… нет, шаблонам. Телефонный номер можно вводить с кодом города и без, тогда используя шаблон»((?(?

Я рассказал лишь о ключевых элементах шаблонов, оставив позади некоторые тонкости, тем не менее, остается ясно, что шаблоны предоставляют огромный контроль над информацией. Любую последовательность символов можно описать используя шаблоны. Единственное, что мешает – это различие форматов. Дело в том, что шаблоны могут
соответствовать стандарту POSIX или PCRE (Perl Compatible Regular Expressions). Хотя особых различий в них нет, разные языки предоставляют свои функции для каждого стандарта, но это уже совсем другая история…

В данной главе описывается синтаксис регулярных выражений. Чаще всего в Перл они используюстя в операторах поиска и замены таких как s// m/ операторах связки =~ или!= и т.д.

Как правило все эти операторы имеют схожие опции такие как:

i - не различать строчные и заглавные буквы
m - считать строку многострочной
s - однострочная строка
x - расширенный синтаксис (использование пробелов и комментариев)

Обычно все эти опции обозначают как "/x". Их можно использовать даже внутри шаблонов использую новую конструкцию (?...)

Регулярные выражения или шаблоны (pattern) то же самое что и regexp процедуры в Юниксе. Выражения и синтаксис заимствован из свободно распространяемых процедур V8 Генри Спенсера (Henry Spencer) там же они подробно и описаны.

В шаблонах используются следующие метасимволы (символы обозначающие группы других символов) часто называемых egrep - стандартом:

\ - считать следующий метасимвол как обычный символ
^ - начало строки
. - один произвольный символ. Кроме "\n" - конец строки
$ - конец строки
| - альтернатива (или)
() - группировка
- класс символов

Метасимволы имеют модификаторы (пишутся после метасимвола):

* - повторяется 0 или большее число раз
+ - повторяется 1 или большее число раз
? - 1 или 0 раз
{n} - точно n раз
{n,} - по меньшей мере раз
{n,m} - не менше n, но и не больше m

Во все других случаях фигурные скобки считаются обычными (регулярными) символами. Таким образом "*" эквивалентна {0,} , "+" - {1,} и "?" - {0,1}. n и m не могут быть больше 65536.

По умолчанию действие метасимволов "жадно" (greedy). Совпадение распространяется столько раз сколько возможно не учитывая результат действия следуюющих метасимволов. Если вы хотите "уменьшить их аппетит" то используйте символ "?". Это не изменяет значение метасимволов просто уменьшает распространение. Таким образом:

*? - станет 0 и более
+? - 1 и более
?? - 0 или 1 раз
{n}? - точно n раз
{n,}? - не меньше n раз
{n,m}? - больше или равно n и меньше m раз

Шаблоны работают так же, как и двойные кавычки поэтому в них можно использовать `\` - символы (бакслэш-символы):

\t - символ табуляции
\n - новая строка
\r - перевод каретки
\а - перевол формата
\v - вертикальная табуляция
\a - звонок
\e - escape
\033 - восьмеричная запись символа
\x1A - шестнадцатеричная
\c[ - control символ
\l - нижний регистр следующего символа
\u - верхний регистр следующего символа
\L - все символы в нижнем регистре до \E
\U - в верхнем регистре до \E
\E - ограничитель смены регистра
\Q - отмена действия как метасимвола

Дополнительно в Перл добавлены следующие метасимволы:

\w - алфавитно-цифровой или "_" символ
\W - не алфавитно-цифровой или "_" символ
\s - один пробел
\S - один не пробел
\d - одна цифра
\D - одна не цифра

Обратите внимание что все это "один" символ. Для обозначения последовательности применяйте модификаторы. Так:

\w+ - слово
\d+ - целое число
[+-]?\d+ - целое со знаком
[+-]?\d+\.?\d* - число с точкой

Кроме того существуют мнимые метасимволы. Обозначающие не существующие символы в месте смены значения. Такие как:

\b - граница слова
\B - не граница слова
\A - начало строки
\Z - конец строки
\G - конец действия m//g

Граница слова (\b) - это мнимая точка между символами \w и \W. Внутри класса символов "\b" обозначает символ backspace (стирания). Метасимволы \A и \Z - аналогичны "^" и "$" но если началостроки "^" и конец строки "$" действуют для каждой строки в многосторочной строке, то \A и \Z обозначают начало и конец всей многосторчной строки.

Если внутри шаблона применяется группировка (круглые скобки) то номер подстроки группы обозначается как "\цифра".

Заметьте что за шаблоном в пределах выражения или блока эти группы обозначаются как "$цифра". Кроме этого существуют дополнительные переменные:

$+ - обозначает последнее совпадение
$& - все совпадение
$` - все до совпадения
$" - все после совпадения

$s = "Один 1 два 2 и три 3"; if ($s =~ /(\d+)\D+(\d+)/) { print "$1\n"; # Результат "1" print "$2\n"; # "2" print "$+\n"; # "2" print "$&\n"; # "1 два 2" print "$`\n"; # "Один " print "$"\n"; # " и три 3" }

Перл версии 5 содержит дополнительные конструкции шаблонов:

(?#комментарий) - комментарий в теле шаблона.
(?:шаблон) - группировка как и "()" но без обратной ссылки
(?=шаблон) - "заглядывание" вперед.

Например /\w+(?=\t)/ соответствует слову, за которым идет табуляция, но символ "\t" не включается в результат.

$s = "1+2-3*4"; if ($s =~ /(\d)(?=-)/) # Наити цифру за которой стоит "-" { print "$1\n"; # Результат "2" } else { print "ошибка поиска\n"; }

(?!шаблон) - "заглядывание" вперед по отрицанию.

$s = "1+2-3*4"; if ($s =~ /(\d)(?!\+)/) # Наити цифру за которой не стоит "+" { print "$1\n"; # Результат "2" } else { print "ошибка поиска\n"; }

(?ismx) - "внутренние" модификаторы. Удобно применять в шаблонах, где например нужно внутри шаблона указать модификатор.

Правила регулярного выражения. (regex)

1. Любой символ обозначает себя самого если это не метасимвол. Если вам нужно отменить действие метасимвола то поставьте перед ним "\".
2. Строка символов обозначает строку этих символов.
3. Множество возможных символов (класс) заключается в квадратные скобки "" это значит что в данном месте может стоять один из указанных в скобках символ. Если первый символ в скобках это "^" - значит не один из указанных символов не может стоять в данном месте выражения. Внутри класса можно употреблять символ "-" обозначающий диаппазон символов. Например a-z один из малых букв латинского алфавита, 0-9 - цифра и т.д.
4. Все символы, включая специальные можно обозначать с помощью "\" как в языке С.
5. Альтернативные последовательности разделяются символом "|" Заметьте, что внутри квадратных скобок это обычный символ.
6. Внутри регулярного выражения можно указыват "подшаблоны", заключая их в крунлые скобки и ссылаться на них как "\номер" Первая скобка обозначается как "\1".

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

1. Введение

Пара слов для тех, кто не совсем в курсе, о чем идет речь. Вы видели когда-нибудь маски имен файлов — всякие там *.html, filename.{txt|csv} и тд? Так вот, регулярные выражения — это те же «маски», только более сложные. В умелых руках регулярные выражения могут быть невероятно мощным инструментом . Так или иначе они используются в 95% моих скриптов.

Многие небезосновательно считают, что регулярные выражения — это скорее самостоятельный язык программирования, чем часть какого-либо языка. Регулярные выражения есть в Perl, PHP, Python , JavaScript, конфигурационных файлах Apache… В зависимости от языка, могут иметь место небольшие различия в синтаксисе регулярных выражений, но основные идеи везде одни и те же.

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

if (preg_match ("//" , $text ) ) {
// в тексте есть цифры
} else {
// в тексте нет ни одной цифры
}

и такой — на Perl:

if ($text =~ // ) {
# в тексте есть цифры
} else {

}

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

2. Простые примеры

Как всегда, учиться будем на примерах. Квадратные скобки в регулярных выражениях означают «здесь должен быть один из перечисленных символов». Например, приведенному выше выражению соответствует любая строка, содержащая хотя бы одну цифру. Аналогично, выражению соответствует любая строка, содержащая хотя бы одну из первых трех букв латинского алфавита. Чтобы обозначить любой символ, кроме заданных, используется запись [^abcdef] , то есть с символом крышки сразу за открывающейся квадратной скобкой.

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

if ($text =~ // ) {
# в тексте есть цифры
} else {
# в тексте нет ни одной цифры
}

И еще пара примеров:

if ($text =~ // ) {
# в тексте есть цифры и/или строчные буквы
# подходит: abc, ZZaZZ, ===17
# не подходит: EPIC FAIL, @^*!@#
}

if ($text =~ /[^0-9]/ ) {
# в тексте есть символы, отличные от цифр
# подходит: abc, 123abc456, 0x1111111111
# не подходит: 123, 123456, 9999999999
}

if ($text =~ // ) {
# в тексте есть буквы латинского алфавита
# подходит: ___Abba___, zyx
# не подходит: 0123, ^_^
}

if ($text =~ // ) {
# текст содержит цифры и буквы от A до F
# подходит: ***777***, DeadC0de, intel, 0_o
# не подходит: Xor, wiki
}

Усложним задачу. Теперь нам нужно проверить не просто наличие или отсутствие определенных символов, а соответствие строки определенному формату. Вот несколько простых примеров:

if ($text =~ /num=/ ) {
# подходит: num=1, some_num=000, bebenum=2(&^*
# не подходит: NUM=1, my_num=-1, num=abc
}

if ($text =~ // ) {
# подходит:
# zzzzzz
#
# не подходит:
#
#
}

Внимательный читатель поинтересуется, что это за знак плюса стоит в последнем регулярном выражении? Этот символ означает «один или более символов, указанных перед этим плюсом». Почти то же самое обозначает символ звездочка — «от нуля до сколько угодно символов, указанных перед звездочкой». Например, выражению A+ будет соответствовать последовательность из одного и более символов A, а выражению * — любое количество цифр, в том числе и ни одной.

Иногда количество символов нужно задать точнее. Это можно сделать с помощью фигурных скобок . Например, выражению {8} соответствует любая последовательность из ровно восьми цифр, а выражению {3,8} — последовательность, содержащая от 3-х до 8-и символов латинского алфавита.

Число на второй позиции можно не указывать. То есть выражение {3,} также может иметь место. Оно означает «не менее трех строчных букв латинского алфавита». Выражение {0,} полностью аналогично звездочке, а {1,} — плюсу. Выражение {0,1} можно записать более коротко, используя знак вопроса .

Пример (не самый простой, зато интересный):

if ($text =~ // ) {
# подходит:
# dfgddfgdfg
#
# не подходит:
#
#
}

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

3. Как выдрать кусок строки?

Символ вертикальной черты (он же «пайп» или просто «палка») в регулярных выражениях означает «или». Например, выражению {20}|{25} соответствуют все строки, содержащие 20 символов латинского алфавита или 25 цифр подряд. Обычно этот символ используется совместно с круглыми скобками , предназначенных для группировки частей регулярного выражения. Пример:

if ($filename =~ /backup(19|20){2}-{2}-{2}/ ) {
# подходит: backup2011-04-01, backup1999-01-13
# не подходит: backup1873-12-12, backup2101-07-07
}

У круглых скобок есть еще одна функция. С их помощью можно выдирать куски соответствующих строк. В PHP результат сохраняется в переменную, указанную третьим аргументом функции preg_match . В Perl совпадения для 1-ой, 2-ой … 9-ой пары скобок сохраняются в переменные $1, $2, …, $9 . Но удобнее использовать такую конструкцию:

if (my ($y , $m , $d ) =
$filename =~ /backup({4})-({2})-({2})/ ) {
print ;
}

Спрашивается, под каким номером искать совпадение в возвращаемом массиве, если регулярное выражение содержит вложенные скобки? Все просто — совпадения возвращаются в том же порядке, в котором идут открывающиеся скобки. Пример:

my $filename = "./dumps/backup2011-04-01.tgz" ;
$filename =~ /backup((20|19){2})-({2})-({2})/ ;
print "$1, $2, $3, $4\n " ;
# выведет: 2011, 20, 04, 01

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

if (my ($y , $m , $d ) =
$filename =~ /backup((?:20|19){2})-({2})-({2})/ ) {
print "year = $y, month = $m, day = $d\n " ;
}

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

4. Начало и конец строки

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

if ($text =~ /^*/ ) {
# текст, начинающийся с десятичной цифры
# подходит: 3, 801403, 6543bebebe
# не подходит: 0275, -123, abc11111
}

if ($text =~ /^0x{1,8}$/ ) {
# шестнадцатеричное число в C-нотации
# подходит: 0x5f3759df, 0xDEADBEEF
# не подходит: 0x1234xxx, xxx0x5678, xxx0x9ABCxxx
}

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

Примечание: Если кого-нибудь интересует, что это за «магические числа» 0x5f3759df и 0xDEADBEEF , обращайтесь к Википедии.

5. Специальные символы

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

if (my ($name ) = $arg =~ /^--name=(.+)$/ ) {
print "Hello, $name!\n " ;
}

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

<span > Text <em > text</ em > text</ span > Source: http://сайт/</ span >

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

# в регулярном выражении содержится слэш, поэтому
# приходится использовать вместо него другой ограничитель
(.*)#;
print $text ;
# выведет наиболее длинное совпадение:
# Text text textSource: http://сайт/

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

my ($text ) = $data =~ m #(.*?)#;
print $text ;
# выведет первое совпадение:
# Text text text

Да, следующие строки делают одно и то же:

# обычная запись...
$text =~ /({4})-({2})-({2})/ ;
# на самом деле - лишь сокращение оператора m//
$text =~ m/({4})-({2})-({2})/ ;
# вместо слэша можно использовать разные скобочки:
$text =~ m { ([ 0 - 9 ] { 4 } ) - ([ 0 - 9 ] { 2 } ) - ([ 0 - 9 ] { 2 } ) } ;
$text =~ m< ([ 0 - 9 ] { 4 } ) - ([ 0 - 9 ] { 2 } ) - ([ 0 - 9 ] { 2 } ) >;
$text =~ m [ ([ 0 - 9 ] { 4 } ) - ([ 0 - 9 ] { 2 } ) - ([ 0 - 9 ] { 2 } ) ] ;
$text =~ m (([ 0 - 9 ] { 4 } ) - ([ 0 - 9 ] { 2 } ) - ([ 0 - 9 ] { 2 } ) ) ;
# или даже такие символы:
$text =~ m ! ([ 0 - 9 ] { 4 } ) - ([ 0 - 9 ] { 2 } ) - ([ 0 - 9 ] { 2 } ) !;
$text =~ m | ([ 0 - 9 ] { 4 } ) - ([ 0 - 9 ] { 2 } ) - ([ 0 - 9 ] { 2 } ) |;
$text =~ m #({4})-({2})-({2})#;
# а также крышку, кавычки, двоеточие, запятую, точку, ...

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

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

# экранированная обратным слэшем точка
# означает именно точку, а не "любой символ"
my ($ext ) = $fname =~ /\.(+)$/ ;
print "file name: $fname, extension: $ext\n " ;

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

• \t — обозначает символ табуляции (t ab)
• \r и \n — символы возврата каретки (r eturn) и новой строки (n ew line)
• \xNN — соответствует символу с ASCII кодом NN, например \x41 соответствует заглавной букве A латинского алфавита
• \s — соответствует пробелу (s pace), табуляции, символу новой строки или символу возврата каретки
• \d — означает любую цифру (d igit), а точнее — то, что считается цифрой в Юникоде (см слайд номер 102 в этой презентации)
• \w — означает так называемое «слово» (w ord), аналог

В последних трех выражениях запись буквы в верхнем регистре означает отрицание. Например, \D соответствует выражению [^0-9] , \W — выражению [^0-9a-zA-Z_] , а \S — любому «не пробельному» символу.

Все эти «буквенные» выражения можно использовать внутри квадратных скобок. Например, выражение полностью эквивалентно .

Особого внимания заслуживают выражения \b и \B , означающие границу слова (в том же понимании «слова», как и в случае с \w ) и отсутствие границы слова соответственно. Например, выражению perl\b соответствует строка «perl rulez!», но не соответствует «perlmonk». С выражением perl\B все с точностью наоборот. Надеюсь, идея ясна.

И еще один пример:

# разбиваем полное имя файла на путь и имя
my ($path , $fname ) = $full_name =~ /^(.*)\/([^\/]+)$/ ;

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

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

Поведение регулярных выражений можно менять с помощью модификаторов. Например, как вы уже могли заметить, соответствие строки регулярному выражению проверяется с учетом регистра символов. Изменить это поведение можно с помощью модификатора #(.*?)#g;
# будьте осторожны при использовании /g в скалярном контексте
# подробности здесь: http://koorchik.blogspot.com/2011/07/perl-5.html
print "$_\n " for (@words ) ;

Как было сказано выше, точка обозначает любой символ, кроме символа новой строки . Изменить такое поведение можно с помощью модификатора /s :

# выдираем из HTML-файла содержимое статьи,
# которое может содержать далеко не одну и не две строчки
my ($article ) = $html =~ m #

#s;

Кстати, если в регулярном выражении нужно обозначить «любой символ» без использования модификатора /s , используйте выражение [\d\D] . Оно означает «любой символ, являющийся цифрой, или не являющийся цифрой», то есть вообще любой символ.

Наконец, ничто не мешает использовать несколько модификаторов одновременно:

# выдираем из HTML-файла все, что выделено жирным
my @words = $html =~ m #(.*?)#gi;
# сработает для , или даже

Дополнение: Еще один полезный модификатор — /o . Он означает «компилировать регулярное выражение только один раз». В некоторых случаях этот модификатор может существенно ускорить скрипт. Правда, я не уверен, что он поддерживается где-то, кроме как в Perl. За наводку спасибо товарищу

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

perlre - регулярные выражения Perl
В этом руководстве описан синтаксис регулярных выражений в языке Perl. Описание того, как практически использовать регулярные выражения в операциях сопоставления с образцом, а также разнообразные примеры на эту тему можно найти в разделах m// и s/// на странице справочного руководства perlop .

ОПИСАНИЕ регулярных выражений

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

Последний обычно называют "модификатор /x", хотя рассматриваемый разделитель может и не быть косой. Фактически, любой из этих модификаторов может быть встроен в регулярное выражение с помощью новой конструкции (?...) . См. ниже.

Сам модификатор /x требует немного более подробного рассмотрения. Он заставляет синтаксический анализатор регулярных выражений игнорировать пробельные символы, не замаскированные обратной косой и не входящие в класс символов. Это можно использовать для разбиения регулярного выражения на (немного) более понятные части. Символ # также рассматривается как метасимвол начала комментария, как в остальном коде на Perl. Взятые вместе, эти возможности делают Perl 5 намного более удобочитаемым языком. См. пример кода для удаления комментариев в программе на C на странице справочного руководства perlop .

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

Шаблоны, используемые при сопоставлении с образцом, являются регулярными выражениями типа используемых в версии 8 библиотеки regexp . (Фактически, соответствующие функции являются производными (хотя и весьма далекими) от свободно распространяемой реализации версии 8, которую выполнил Henry Spencer.) Подробнее см. раздел "Регулярные выражения версии 8" .

В частности, следующие метасимволы имеют стандартные, знакомые по egrep , значения:

По умолчанию, символ "^ " гарантированно соответствует только началу строки, а символ "$ " - только концу строки (или позиции перед символом перевода строки в конце), причем Perl выполняет ряд оптимизаций исходя из предположения, что буфер содержит только одну строку. Встроенным переводам строк не будут соответствовать метасимволы "^ " или "$ ". Может, однако, понадобиться рассматривать буфер как многострочный, так чтобы "^ " соответствовал позиции после символа перевода строки в буфере, а "$ " - позиции перед символом перевода строки. За счет незначительного повышения накладных расходов это можно сделать с помощью модификатора /m в операторе сопоставления с образцом. (Старые программы для этого устанавливали $* , но такая практика теряет смысл в Perl 5.)

Чтобы упростить многострочные подстановки, символ ". " никогда не соответствует символу перевода строки, если только не используется модификатор /s , сообщающий Perl о необходимости рассматривать буфер как однострочный, - даже если в нем несколько строк. Модификатор /s также отменяет установку $* , если используется (неудачный) старый код, устанавливающий его в другом модуле.

Распознаются следующие стандартные квантификаторы :

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

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

Учтите, что изменяется не значение квантификаторов, а "вес" , - они будут сопоставляться с наименьшей возможной подстрокой :

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

\t	табуляция
\n	перевод строки
\r	возврат каретки
\f	form feed
\a	звуковой сигнал
\e	escape (вспомните troff )
\033	восьмеричный символ (вспомните PDP-11)
\x1B	шестнадцатеричный символ
\c[	управляющий символ
\l	перевести следующий символ в нижний регистр (вспомните vi )
\u	перевести следующий символ в верхний регистр (вспомните vi )
\L	переводить в нижний регистр до \E (вспомните vi )
\U	переводить в верхний регистр до \E (вспомните vi )
\E	конец изменения регистра символов (вспомните vi )
\Q	маскировать метасимволы regexp до \E

Кроме того, Perl определяет следующие метасимволы :

Учтите, что \w соответствует одному алфавитно-цифровому символу, а не целому слову. Чтобы указать соответствие слову, необходимо использовать \w+ . Метасимволы \w , \W , \s , \S , \d и \D можно использовать при задании классов символов (но не в качестве одной из границ диапазона).

Perl определяет следующие утверждения нулевой длины (zero-width assertions):

Граница слова (\b ) определяется как точка между двумя символами, с одной стороны от которой находится \w , а с другой - \W (в любом порядке), считая воображаемые символы начала и конца строки соответствующими \W . (Внутри классов символов \b представляет забой - backspace, а не границу слова.) Метасимволы \A и \Z аналогичны "^ " и "$ ", но не будут сопоставляться несколько раз при использовании модификатора /m , тогда как "^ " и "$ " будут сопоставляться с границей каждой внутренней строки. Чтобы указать соответствие с реальным концом строки, не исключая символ перевода строки, можно использовать \Z(?!\n) .

При использовании скобочной конструкции (...) , \<цифра> соответствует <цифра> -й подстроке. За пределами шаблона всегда используйте перед цифрой "$ " вместо "\ ". (Запись \<цифра> может в редких случаях срабатывать за пределами текущего шаблона, но на это не надо полагаться. См. ниже.) Область действия $ (а также $` , $& и $" ) распространяется до конца охватывающего блока или оцениваемой строки, или до следующего успешного сопоставления с образцом, в зависимости от того, что будет раньше. Если вы хотите использовать скобки для ограничения подшаблона (например, набора альтернатив), не запоминая его как подшаблон, укажите ? после (.

Можно использовать любое количество скобок. Если имеется более 9 подстрок, переменные $10 , $11 , ... будут ссылаться на соответствующую подстроку. В шаблоне \10 , \11 и т.д. ссылаются на уже сопоставленные подстроки, если их уже было столько до этой обратной ссылки. В противном случае (для обратной совместимости) \10 совпадает с \010 , или символом забоя, а \11 совпадает с \011 , символом табуляции. И так далее. (Последовательности от \1 до \9 всегда рассматриваются как обратные ссылки.)

$+ возвращает то, с чем сопоставилась последняя конструкция в скобках. $& возвращает всю сопоставившуюся строку. (Раньше для этого использовался $0 , но больше не используется.) $` возвращает все, что идет до начала сопоставившейся строки. $" возвращает все, что идет после сопоставившейся строки. Примеры:

S/^([^ ]*) *([^ ]*)/$2 $1/; # поменять местами # два первых слова if (/Time: (..):(..):(..)/) { $hours = $1; $minutes = $2; $seconds = $3; }

Обратите внимание, что все метасимволы, предваряемые обратной косой, в Perl - алфавитно-цифровые, например, \b , \w , \n . В отличие от некоторых языков регулярных выражений, здесь обратная косая не предваряет метасимволы, не являющиеся алфавитно-цифровыми. Поэтому все конструкции вида \\ , \(, \) , \< , \> , \{ или \} всегда интерпретируются как литеральные символы, а не как метасимволы. Это упрощает маскировку строки, которую необходимо использовать в качестве шаблона, но которая, как вы опасаетесь, может содержать метасимволы. Просто замаскируйте все не алфавитно-цифровые символы:

$pattern =~ s/(\W)/\\$1/g;

Для этого можно также использовать встроенную функцию quotemeta() . Еще проще замаскировать метасимволы прямо в операторе сопоставления можно следующим образом

/$unquoted\Q$quoted\E$unquoted/

Perl 5 определяет последовательный синтаксис расширений для регулярных выражений. Для этого используется пара круглых скобок, первым символом в которых указан знак вопроса (в Perl 4 это было синтаксической ошибкой). Символ после знака вопроса задает функцию расширения. Поддерживается несколько расширений:

(?#text)	Комментарий. Текст игнорируется. Если использован переключатель /x для вставки форматирующих пробелов, достаточно указать просто # .
(?:regexp)	Группирует элементы аналогично "() ", но не создает обратных ссылок, как "() ". Поэтому split(/\b(?:a|b|c)\b/) аналогично Split(/\b(a|b|c)\b/) но не порождает дополнительные поля.
(?=regexp)	Положительный просмотр вперед нулевой длины. Например, /\w+(?=\t)/ соответствует слову, после которого идет символ табуляции, но табуляция не включается в $& .
(?!regexp)	Отрицательный просмотр вперед нулевой длины. Например, /foo(?!bar)/ соответствует любому вхождению "foo ", за которым не идет "bar ". Учтите, однако, что просмотр вперед и просмотр назад - НЕ одно и то же. Нельзя использовать эту конструкцию для поиска назад: /(?!foo)bar/ не найдет вхождение "bar ", перед которым не идет "foo ". Так происходит потому, что (?!foo) означает, что дальше не должна идти строка "foo " -- а она и не идет, идет "bar ", поэтому "foobar " будет соответствовать этому шаблону. Необходимо задавать что-то вроде /(?foo)...bar/ . "Вроде" - потому, что перед "bar " может и не быть трех символов. Этот случай можно охватить следующим образом: /(?:(?!foo)...|^..?)bar/ . Иногда все же проще написать: if (/foo/ && $` =~ /bar$/)
(?imsx)	Один или несколько встроенных модификаторов сопоставления с образцом. Это особенно полезно для шаблонов, заданных в отдельной таблице, когда некоторые из них должны учитывать регистр символов, а другие - нет. Для учитывающих регистр символов достаточно просто включить (?i) перед шаблоном. Например: $pattern = "foobar"; if (/$pattern/i) # более гибкий способ: $pattern = "(?i)foobar"; if (/$pattern/)

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

Регулярные выражения: Поиск с возвратом

Фундаментальное свойство сопоставления регулярных выражений связано с понятием, которое называется поиск с возвратом (backtracking) и используется (при необходимости) всеми квантификаторами регулярных выражений, а именно * , *? , + , +? , {n,m} и {n,m}? .

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

Вот пример поиска с возвратом: предположим, необходимо найти слово, идущее после "foo " в строке "Food is on the foo table. ":

$_ = "Food is on the foo table."; if (/\b(foo)\s+(\w+)/i) { print "$2 follows $1.\n"; }

При выполнении сопоставления для первой части регулярного выражения (\b(foo) ) найдется возможное соответствие прямо в начале строки, при этом в $1 будет помещено значение "Foo ". Однако, как только механизм сопоставления увидит, что после сохраненного в $1 значения "Foo " нет пробела, он поймет свою ошибку и начнет снова со следующего символа после неудавшегося сопоставления an. В этот раз он пройдет до следующего вхождения "foo ". Все регулярное выражение в целом теперь сопоставляется и будет получен ожидаемый результат, "table follows foo. ".

Иногда минимальное сопоставление может оказаться очень полезным. Предположим, необходимо найти все, что идет между строками "foo " и "bar ". Сразу можно написать что-то вроде:

$_ = "The food is under the bar in the barn."; if (/foo(.*)bar/) { print "got <$1>\n"; }

Что, возможно, неожиданно, выдает:

Got

Так произошло потому, что шаблон .* был жадным, вот вы и получили все от первого "foo " до последнего "bar ". В этом случае более эффективно использовать минимальное сопоставление, гарантирующее, что вы получите текст между "foo " и первым же вхождением "bar " после него.

If (/foo(.*?)bar/) { print "got <$1>\n" } got

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

$_ = "I have 2 numbers: 53147";
if (/(.*)(\d*)/) { #Ошибка! print "Beginning is <$1>, number is <$2>.\n"; }

Это вообще не сработает, поскольку шаблон .* был жадным и поглотил всю строку. Поскольку \d* может соответствовать пустой строке, все регулярное выражение в целом успешно сопоставляется.

Beginning is , number is <>.

Вот еще несколько вариантов, большинство из которых не сработает:

$_ = "I have 2 numbers: 53147"; @pats = qw{ (.*)(\d*) (.*)(\d+) (.*?)(\d*) (.*?)(\d+) (.*)(\d+)$ (.*?)(\d+)$ (.*)\b(\d+)$ (.*\D)(\d+)$ }; for $pat (@pats) { printf "%-12s ", $pat; if (/$pat/) { print "<$1> <$2>\n"; } else { print "FAIL\n"; } } В результате будет выдано:
(.*)(\d*) <> (.*)(\d+) <7> (.*?)(\d*) <> <> (.*?)(\d+) <2> (.*)(\d+)$ <7> (.*?)(\d+)$ <53147> (.*)\b(\d+)$ <53147> (.*\D)(\d+)$ <53147>

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

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

$_ = "ABC123"; if (/^\D*(?!123)/) { # Ошибка! print "Yup, no 123 in $_\n"; }

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

$x = "ABC123" ; $y = "ABC445" ; print "1: got $1\n" if $x =~ /^(ABC)(?!123)/ ; print "2: got $1\n" if $y =~ /^(ABC)(?!123)/ ; print "3: got $1\n" if $x =~ /^(\D*)(?!123)/ ; print "4: got $1\n" if $y =~ /^(\D*)(?!123)/ ;

Будет выдано

2: got ABC 3: got AB 4: got ABC

Вы могли ожидать, что проверка 3 не сработает, поскольку она кажется более универсальной версией 1. Важное различие между ними состоит в том, что проверка 3 содержит квантификатор (\D*) и поэтому может использовать поиск с возвратом, тогда как проверка 1 - нет. На самом деле вы спрашиваете: "Правда ли, что в начале $x , после 0 или более не цифр, идет нечто, отличающееся от 123 ?". Если механизм сопоставления позволит \D* расшириться до "ABC ", весь шаблон в целом не сопоставится. Поисковая машина первоначально сопоставит \D* с "ABC ". Затем она попытается сопоставить (?!123) c "123 ", что, конечно, невозможно. Но поскольку в регулярном выражении использован квантификатор (\D*) , поисковая машина может вернуться и поискать другое сопоставление в надежде найти сопоставить все регулярное выражение в целом.

Теперь, поскольку сопоставление шаблона так желанно для поисковой машины, она использует стандартный возврат и повторную попытку regexp (backoff-and-retry) и позволяет на это раз \D* расшириться только до "AB ". Теперь и в самом деле имеется нечто после "AB ", что не совпадает с "123 ". Это "C123 ", что вполне устраивает.

Справиться с эти можно, используя совместно утверждение и отрицание. Мы скажем, что после первой части в $1 должна идти цифра, но там должно идти нечто, отличное от "123 ". Помните, что просмотры вперед - это выражения нулевой длины -- при сопоставлении выполняется только проверка, но не берется часть строки. После таких изменений будет получен желаемый результат; т.е. в случае 5 - неудача, а в случае 6 - успех:

Print "5: got $1\n" if $x =~ /^(\D*)(?=\d)(?!123)/ ; print "6: got $1\n" if $y =~ /^(\D*)(?=\d)(?!123)/ ; 6: got ABC

Другими словами, два утверждения нулевой длины (zero-width assertions), идущие подряд, работают так, как если бы проверялась их конъюнкция, так же, как и при использовании любых встроенных утверждений: шаблон /^$/ сопоставляется, только если вы находитесь в начале строки И в конце строки одновременно. Более глубокое основание этого - в том, что соседство в регулярных выражениях всегда означает И, кроме явного указания ИЛИ с помощью вертикальной черты. /ab/ означает сопоставить "a " И (затем) сопоставить "b ", хотя попытки сопоставления и делаются в разных позициях, т.к. "a " - утверждение не нулевой длины, но длины один.

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

/((a{0,5}){0,5}){0,5}/

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

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

Если вам не знакомы "стандартные" функции библиотеки regexp версии 8, вот правила сопоставления с образцом, не описанные выше.

Любой одиночный символ сопоставляется с сами собой, если только это не метасимвол, имеющий специальное значение, описанное здесь или выше. Символы, обычно работающие как метасимволы, можно потребовать интерпретировать литерально, предваряя их символом "\ " (например, "\. " соответствует ". ", а не любому символу; "\\ " соответствует "\ "). Последовательность символов сопоставляется с такой же последовательностью символов в целевой строке, поэтому шаблон blurfl сопоставится с "blurfl " в целевой строке.

Можно задать класс символов, включив список символов в квадратные скобки , которые будут сопоставляться с любым из символов в списке. Если первый символ после "[ " - "^ ", класс сопоставляется с любым символом, не указанным в списке. В списке символ "- " используется для указания диапазона, так что a-z представляет все символы от "a " до "z ", включительно.

Символы можно задавать с использованием синтаксиса метасимволов, во многом аналогичного используемому в C: "\n " соответствует переводу строки, "\t " - табуляции, "\r " - возврату каретки, "\f " - form feed и т.д. В общем случае, \nnn , где nnn - это строка восьмеричных цифр, соответствует символу, значение кода ASCII для которого - nnn . Аналогично, \xnn , где nn - это шестнадцатеричные цифры, соответствует символу, значение кода ASCII для которого - nn . Выражение \cx соответствует символу ASCII control-x . Наконец, метасимвол ". " соответствует любому символу, кроме "\n " (если только не используется /s ).

Можно задавать набор альтернатив для шаблона, разделяя их метасимволом "| ", так что fee|fie|foe сопоставится с любой из подстрок "fee ", "fie " или "foe " в целевой строке (так же, как и f(e|i|o)e ). Учтите, что первая альтернатива включает все от последнего разделителя шаблона ("(", "[ " или от начала шаблона) до первого символа "| ", а последняя альтернатива включает все от последнего символа "| " до следующего разделителя шаблона. Поэтому альтернативы обычно берут в круглые скобки, чтобы не сомневаться, где они начинаются и заканчиваются. Учтите, однако, что в квадратных скобках "| " интерпретируется как литерал, поэтому если вы напишите , сопоставление произойдет только с .

В шаблоне можно выделять подшаблоны (путем взятия их в круглые скобки) для дальнейших ссылок и можно ссылаться обратно на n -й подшаблон в дальнейшем с помощью метасимвола \n . Подшаблоны нумеруются слева направо по открывающим круглым скобкам. Учтите, что обратная ссылка сопоставляется с тем, с чем сопоставился подшаблон в рассматриваемой строке, а не с правилами, задающими этот подшаблон. Поэтому (0|0x)\d*\s\1\d* сопоставится с "0x1234 0x4321 ", но не с "0x1234 01234 ", поскольку подшаблон 1 фактически сопоставился с "0x ", хотя правило 0|0x потенциально могло сопоставиться с начальным 0 во втором числе.

ПРЕДУПРЕЖДЕНИЕ о \1 и $1

Некоторые люди слишком привыкли писать вещи типа

$pattern =~ s/(\W)/\\\1/g;

Корни такой привычки восходят к правой части оператора замены в sed , но это плохая привычка. Дело в том, что с точки зрения Perl правая часть s/// - это строка в двойных кавычках. \1 в обычной строке в двойных кавычках означает control-A . Обычное для Unix значение \1 сохранено в s/// . Однако, если вы привыкните делать именно так, у вас будут проблемы при добавлении модификатора /e .

S/(\d+)/ \1 + 1 /eg; или если вы попытаетесь выполнить s/(\d+)/\1000/;

Этой двусмысленности нельзя избежать, написав \{1}000 , но можно, если написать ${1}000 . Просто операцию интерполяции не надо путать с операцией сопоставления с обратной ссылкой. Конечно, они имеют разное значение в левой части оператора s/// .

Поделись статьей:

Похожие статьи

17 апреля 2015
Что можно узнать по серийному номеру iPhone

17 апреля 2015
Роль и функции телевидения с современном обществе

17 апреля 2015
Модуль бесконтактной оплаты или что такое технология NFC в телефоне?

17 апреля 2015
Ламповый звук - мифы и факты