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, это применяет более строгие правила, чем обычно, при компиляции шаблонов регулярных выражений. Это может находить вещи, которые, хотя и допустимы, могут не соответствовать вашим намерениям.

См. 'строгий' режим в re.

ОШИБКИ

Нет.

См. также

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

Автор и авторские права

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

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

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

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