perlrequick

СОДЕРЖАНИЕ

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

ИМЯ

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

ОПИСАНИЕ

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

Руководство

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

Простой поиск слов

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

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

В этом выражении World является регулярным выражением, а // ограничивает /World/ указывает Perl на поиск соответствия в строке. Оператор =~ связывает строку с соответствием по регулярному выражению и возвращает значение true, если регулярное выражение совпало, или false, если не совпало. В нашем случае 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 Unicode-символам. Подробности см. в разделе «Последовательности экранирования» в 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{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'

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

См. 'strict' в re.

ОШИБКИ

Нет.

См. также

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

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

Copyright (c) 2000 Mark Kvale Все права защищены.

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

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

Автор хотел бы поблагодарить Mark-Jason Dominus, Tom Christiansen, Ilya Zakharevich, Brad Hughes и Mike Giroux за все их полезные замечания.