perlrequick

СОДЕРЖАНИЕ

• НАЗВАНИЕ
• ОПИСАНИЕ
• Руководство
  • Сопоставление простых слов
  • Использование классов символов
  • Сопоставление этого или того
  • Группировка элементов и иерархическое сопоставление
  • Извлечение совпадений
  • Сопоставление повторений
  • Дополнительное сопоставление
  • Поиск и замена
  • Оператор split
  • Использование re 'strict'
• ОШИБКИ
• СМОТРИТЕ ТАКЖЕ
• АВТОР И АВТОРСКИЕ ПРАВА
  • Благодарности

НАЗВАНИЕ

perlrequick - Быстрый старт с регулярными выражениями Perl

ОПИСАНИЕ

Эта страница охватывает самые основы понимания, создания и использования регулярных выражений ('regex') в Perl.

Руководство

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

Сопоставление простых слов

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

"Hello World" =~ /World/;  # matches

В этом утверждении World является регулярным выражением, а // вложенные /World/ говорят Perl о поиске совпадения в строке. Оператор =~ связывает строку с совпадением регулярного выражения и возвращает истинное значение, если регулярное выражение совпало, или ложное значение, если регулярное выражение не совпало. В нашем случае, World соответствует второму слову в "Hello World", поэтому выражение истинно. Эта идея имеет несколько вариаций.

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

print "It matches\n" if "Hello World" =~ /World/;

Смысл совпадения можно обратить, используя оператор !~:

print "It doesn't match\n" if "Hello World" !~ /World/;

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

$greeting = "World";
print "It matches\n" if "Hello World" =~ /$greeting/;

Если вы сопоставляете с $_, часть $_ =~ может быть опущена:

$_ = "Hello World";
print "It matches\n" if /World/;

Наконец, // стандартные разделители для совпадения можно изменить на произвольные разделители, поместив 'm' перед ними:

"Hello World" =~ m!World!;   # matches, delimited by '!'
"Hello World" =~ m{World};   # matches, note the matching '{}'
"/usr/bin/perl" =~ m"/perl"; # matches after '/usr/bin',
                             # '/' becomes an ordinary char

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

"Hello World" =~ /world/;  # doesn't match, case sensitive
"Hello World" =~ /o W/;    # matches, ' ' is an ordinary char
"Hello World" =~ /World /; # doesn't match, no ' ' at end

Perl всегда ищет совпадение с самого начала строки:

"Hello World" =~ /o/;       # matches 'o' in 'Hello'
"That hat is red" =~ /hat/; # matches 'hat' in 'That'

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

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

Метасимвол можно сопоставить буквально, поместив перед ним обратную косую черту:

"2+2=4" =~ /2+2/;    # doesn't match, + is a metacharacter
"2+2=4" =~ /2\+2/;   # matches, \+ is treated like an ordinary +
'C:\WIN32' =~ /C:\\WIN/;                       # matches
"/usr/bin/perl" =~ /\/usr\/bin\/perl/;  # matches

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

Большинство метасимволов не всегда являются специальными, и другие символы (например, разделяющие шаблон) становятся специальными в различных обстоятельствах. Это может быть запутанно и привести к неожиданным результатам. use re 'strict' может уведомить вас об этом.

Непечатаемые символы ASCII представляются последовательностями экранирования. Общие примеры — \t для табуляции, \n для новой строки и \r для возврата каретки. Произвольные байты представляются восьмеричными последовательностями экранирования, например \033, или шестнадцатеричными последовательностями экранирования, например \x1B:

"1000\t2000" =~ m(0\t2)  # matches
"cat" =~ /\143\x61\x74/  # matches in ASCII, but
                         # a weird way to spell cat

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

$foo = 'house';
'cathouse' =~ /cat$foo/;   # matches
'housecat' =~ /${foo}cat/; # matches

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

"housekeeper" =~ /keeper/;         # matches
"housekeeper" =~ /^keeper/;        # doesn't match
"housekeeper" =~ /keeper$/;        # matches
"housekeeper\n" =~ /keeper$/;      # matches
"housekeeper" =~ /^housekeeper$/;  # matches

Использование классов символов

Класс символов позволяет сопоставить набор возможных символов, а не только один символ, в определенной точке регулярного выражения. Существует множество различных типов классов символов, но обычно, когда люди используют этот термин, они имеют в виду тип, описанный в этом разделе, который технически называется "классами символов в квадратных скобках", потому что они обозначаются квадратными скобками [...], а набор символов для возможного совпадения находится внутри. Но мы опустим "в квадратных скобках" ниже, чтобы соответствовать общему использованию. Вот несколько примеров классов (в квадратных скобках) символов:

/cat/;            # matches 'cat'
/[bcr]at/;        # matches 'bat', 'cat', or 'rat'
"abc" =~ /[cab]/; # matches 'a'

В последнем утверждении, даже если 'c' — это первый символ в классе, самая ранняя точка, в которой регулярное выражение может совпасть, это 'a'.

/[yY][eE][sS]/; # match 'yes' in a case-insensitive way
                # 'yes', 'Yes', 'YES', etc.
/yes/i;         # also match 'yes' in a case-insensitive way

Последний пример показывает совпадение с модификатором 'i', который делает совпадение нечувствительным к регистру.

Классы символов также имеют обычные и специальные символы, но наборы обычных и специальных символов внутри класса символов отличаются от тех, что находятся вне класса символов. Специальные символы для класса символов — -]\^$ и сопоставляются с использованием обратной косой черты:

/[\]c]def/; # matches ']def' or 'cdef'
$x = 'bcr';
/[$x]at/;   # matches 'bat, 'cat', or 'rat'
/[\$x]at/;  # matches '$at' or 'xat'
/[\\$x]at/; # matches '\at', 'bat, 'cat', or 'rat'

Специальный символ '-' действует как оператор диапазона в классах символов, поэтому громоздкие [0123456789] и [abc...xyz] превращаются в изящные [0-9] и [a-z]:

/item[0-9]/;  # matches 'item0' or ... or 'item9'
/[0-9a-fA-F]/;  # matches a hexadecimal digit

Если '-' является первым или последним символом в классе символов, он обрабатывается как обычный символ.

Специальный символ ^ в первой позиции класса символов обозначает отрицательный класс символов, который соответствует любому символу, кроме тех, что находятся в скобках. Как [...] так и [^...] должны сопоставиться с символом, иначе совпадение не будет найдено. Затем

/[^a]at/;  # doesn't match 'aat' or 'at', but matches
           # all other 'bat', 'cat, '0at', '%at', etc.
/[^0-9]/;  # matches a non-numeric character
/[a^]at/;  # matches 'aat' or '^at'; here '^' is ordinary

В Perl есть несколько сокращений для распространенных классов символов. (Эти определения — те, которые использует Perl в ASCII-безопасном режиме с /a модификатором. В противном случае они также могут соответствовать многим другим не-ASCII символам Юникода. Подробнее см. "Последовательности обратной косой черты" в perlrecharclass.)

• \d — цифра и представляет

  [0-9]

• \s — символ пробела и представляет

  [\ \t\r\n\f]

• \w — символ слова (буквенно-цифровой или _) и представляет

  [0-9a-zA-Z_]

• \D — отрицание \d; оно представляет любой символ, кроме цифры

  [^0-9]

• \S — отрицание \s; оно представляет любой символ, не являющийся пробелом

  [^\s]

• \W — отрицание \w; оно представляет любой символ, не являющийся символом слова

  [^\w]

• Точка '.' соответствует любому символу, кроме "\n"

Сокращения \d\s\w\D\S\W можно использовать как внутри, так и вне классов символов. Вот несколько примеров их использования:

/\d\d:\d\d:\d\d/; # matches a hh:mm:ss time format
/[\d\s]/;         # matches any digit or whitespace character
/\w\W\w/;         # matches a word char, followed by a
                  # non-word char, followed by a word char
/..rt/;           # matches any two chars, followed by 'rt'
/end\./;          # matches 'end.'
/end[.]/;         # same thing, matches 'end.'

Якорь слова \b соответствует границе между символом слова и символом, не являющимся символом слова \w\W или \W\w:

$x = "Housecat catenates house and cat";
$x =~ /\bcat/;  # matches cat in 'catenates'
$x =~ /cat\b/;  # matches cat in 'housecat'
$x =~ /\bcat\b/;  # matches 'cat' at end of string

В последнем примере конец строки считается границей слова.

Для обработки естественного языка (например, чтобы апострофы включались в слова), используйте \b{wb}

"don't" =~ / .+? \b{wb} /x;  # matches the whole string

Сопоставление этого или того

Мы можем сопоставить различные строки символов с метасимволом альтернации '|'. Чтобы сопоставить dog или cat, мы формируем регулярное выражение dog|cat. Как и прежде, Perl будет пытаться сопоставить регулярное выражение с самого начала строки. В каждой позиции символа Perl сначала будет пытаться сопоставить первый вариант dog. Если dog не сопоставляется, Perl попробует следующий вариант cat. Если cat также не сопоставляется, совпадение завершается, и Perl переходит к следующей позиции в строке. Вот несколько примеров:

"cats and dogs" =~ /cat|dog|bird/;  # matches "cat"
"cats and dogs" =~ /dog|cat|bird/;  # matches "cat"

Даже если dog является первым вариантом во втором регулярном выражении, cat может сопоставиться раньше в строке.

"cats"          =~ /c|ca|cat|cats/; # matches "c"
"cats"          =~ /cats|cat|ca|c/; # matches "cats"

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

Группировка элементов и иерархическое сопоставление

Метасимволы группировки () позволяют рассматривать часть регулярного выражения как единое целое. Части регулярного выражения группируются путем заключения их в скобки. Регулярное выражение house(cat|keeper) означает сопоставление house за которым следует либо cat или keeper. Вот еще несколько примеров:

/(a|b)b/;    # matches 'ab' or 'bb'
/(^a|b)c/;   # matches 'ac' at start of string or 'bc' anywhere

/house(cat|)/;  # matches either 'housecat' or 'house'
/house(cat(s|)|)/;  # matches either 'housecats' or 'housecat' or
                    # 'house'.  Note groups can be nested.

"20" =~ /(19|20|)\d\d/;  # matches the null alternative '()\d\d',
                         # because '20\d\d' can't match

Извлечение совпадений

Метасимволы группировки () также позволяют извлекать части строки, которые совпали. Для каждой группы часть, которая совпала внутри, попадает в специальные переменные $1, $2, и т. д. Их можно использовать как обычные переменные:

# extract hours, minutes, seconds
$time =~ /(\d\d):(\d\d):(\d\d)/;  # match hh:mm:ss format
$hours = $1;
$minutes = $2;
$seconds = $3;

В контексте списка совпадение /regex/ с группировками возвращает список совпавших значений ($1,$2,...). Поэтому мы могли бы переписать это как

($hours, $minutes, $second) = ($time =~ /(\d\d):(\d\d):(\d\d)/);

Если группировки в регулярном выражении вложены, $1 получает группу с самой левой открывающей скобкой, $2 — следующую открывающую скобку и т. д. Например, вот сложное регулярное выражение и указанные ниже переменные сопоставления:

/(ab(cd|ef)((gi)|j))/;
 1  2      34

Связанные с соответствующими переменными $1, $2, ... являются обратные ссылки \g1, \g2, ... Обратные ссылки — это соответствующие переменные, которые могут использоваться внутри регулярного выражения:

/(\w\w\w)\s\g1/; # find sequences like 'the the' in string

$1, $2, ... должны использоваться только вне регулярного выражения, а \g1, \g2, ... только внутри него.

Сопоставление повторений

Метасимволы квантификаторов ?, *, +, и {} позволяют определить количество повторений части регулярного выражения, которую мы считаем совпадением. Квантификаторы ставятся непосредственно после символа, класса символов или группировки, которую мы хотим указать. Они имеют следующие значения:

• a? = сопоставить 'a' 1 или 0 раз

• a* = сопоставить 'a' 0 или более раз, то есть любое количество раз

• a+ = сопоставить 'a' 1 или более раз, то есть по крайней мере один раз

• a{n,m} = сопоставить по крайней мере n раз, но не более m раз.

• a{n,} = сопоставить по крайней мере n или более раз

• a{n} = сопоставить ровно n раз

Вот несколько примеров:

/[a-z]+\s+\d*/;  # match a lowercase word, at least some space, and
                 # any number of digits
/(\w+)\s+\g1/;    # match doubled words of arbitrary length
$year =~ /^\d{2,4}$/;  # make sure year is at least 2 but not more
                       # than 4 digits
$year =~ /^\d{4}$|^\d{2}$/; # better match; throw out 3 digit dates

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

$x = 'the cat in the hat';
$x =~ /^(.*)(at)(.*)$/; # matches,
                        # $1 = 'the cat in the h'
                        # $2 = 'at'
                        # $3 = ''   (0 matches)

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

Больше сопоставлений

Есть еще несколько вещей, которые вам может быть нужно знать о операторах сопоставления. Глобальный модификатор /g позволяет оператору сопоставления совпадать в строке как можно больше раз. В скалярном контексте последовательные совпадения со строкой будут иметь /g перемещаться от совпадения к совпадению, отслеживая положение в строке по мере продвижения. Вы можете получить или установить позицию с помощью функции pos(). Например,

$x = "cat dog house"; # 3 words
while ($x =~ /(\w+)/g) {
    print "Word is $1, ends at position ", pos $x, "\n";
}

выводит

Word is cat, ends at position 3
Word is dog, ends at position 7
Word is house, ends at position 13

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

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

@words = ($x =~ /(\w+)/g);  # matches,
                            # $word[0] = 'cat'
                            # $word[1] = 'dog'
                            # $word[2] = 'house'

Поиск и замена

Поиск и замена выполняются с помощью s/regex/replacement/modifiers. replacement — это строка Perl с двойными кавычками, которая заменяет в строке то, что совпадает с regex. Оператор =~ также используется здесь для сопоставления строки с s///. При сопоставлении с $_, $_ =~ можно опустить. Если совпадение найдено, s/// возвращает количество выполненных замен; в противном случае возвращает false. Вот несколько примеров:

$x = "Time to feed the cat!";
$x =~ s/cat/hacker/;   # $x contains "Time to feed the hacker!"
$y = "'quoted words'";
$y =~ s/^'(.*)'$/$1/;  # strip single quotes,
                       # $y contains "quoted words"

С оператором s///, сопоставленные переменные $1, $2, и т. д. немедленно доступны для использования в выражении замены. При глобальном модификаторе s///g будет производиться поиск и замена всех вхождений регулярного выражения в строке:

$x = "I batted 4 for 4";
$x =~ s/4/four/;   # $x contains "I batted four for 4"
$x = "I batted 4 for 4";
$x =~ s/4/four/g;  # $x contains "I batted four for four"

Неразрушающий модификатор s///r вызывает возврат результата замены вместо изменения $_ (или любой переменной, к которой была привязана замена с помощью =~)

$x = "I like dogs.";
$y = $x =~ s/dogs/cats/r;
print "$x $y\n"; # prints "I like dogs. I like cats."

$x = "Cats are great.";
print $x =~ s/Cats/Dogs/r =~ s/Dogs/Frogs/r =~
    s/Frogs/Hedgehogs/r, "\n";
# prints "Hedgehogs are great."

@foo = map { s/[a-z]/X/r } qw(a b c 1 2 3);
# @foo is now qw(X X X 1 2 3)

Модификатор вычисления s///e обертывает eval{...} вокруг строки замены, а результат вычисления заменяет сопоставленный подстроку. Некоторые примеры:

# reverse all the words in a string
$x = "the cat in the hat";
$x =~ s/(\w+)/reverse $1/ge;   # $x contains "eht tac ni eht tah"

# convert percentage to decimal
$x = "A 39% hit rate";
$x =~ s!(\d+)%!$1/100!e;       # $x contains "A 0.39 hit rate"

Последний пример показывает, что s/// может использовать другие разделители, такие как s!!! и s{}{}, и даже s{}//. Если используются одинарные кавычки s''', то регулярное выражение и замена обрабатываются как строки в одинарных кавычках.

Оператор разделения

split /regex/, string разделяет string на список подстрок и возвращает этот список. Регулярное выражение определяет последовательность символов, по которой string разделяется. Например, для разделения строки на слова используйте

$x = "Calvin and Hobbes";
@word = split /\s+/, $x;  # $word[0] = 'Calvin'
                          # $word[1] = 'and'
                          # $word[2] = 'Hobbes'

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

$x = "1.618,2.718,   3.142";
@const = split /,\s*/, $x;  # $const[0] = '1.618'
                            # $const[1] = '2.718'
                            # $const[2] = '3.142'

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

$x = "/usr/bin";
@parts = split m!(/)!, $x;  # $parts[0] = ''
                            # $parts[1] = '/'
                            # $parts[2] = 'usr'
                            # $parts[3] = '/'
                            # $parts[4] = 'bin'

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

use re 'strict'

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

См. 'strict' в re.

ОШИБКИ

Нет.

СМОТРИТЕ ТАКЖЕ

Это всего лишь краткое руководство. Более подробное руководство по регулярным выражениям см. в perlretut, а справочную страницу — в perlre.

АВТОР И АВТОРСКИЕ ПРАВА

Авторские права (c) 2000 Марк Квале Все права защищены.

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

Благодарности

Автор хотел бы поблагодарить Марка-Джейсона Доминуса, Тома Кристиансена, Илью Захаревича, Брэда Хьюза и Майкла Жируа за все их ценные замечания.