Я провела бы его по лабиринту, где тропы орнаментом украшены…

(Эми Лоуэлл)

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

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

Во время работы над данной книгой язык Ruby находился в переходном состоянии. Старая библиотека регулярных выражений заменялась новой под названием Oniguruma. Этой библиотеке посвящен раздел 3.13 данной главы. Что касается интернационализации, то это тема главы 4.

Обычно регулярное выражение ограничено с двух сторон символами косой черты. Применяется также форма

%r

Таблица 3.1. Простые регулярные выражения

Сразу после регулярного выражения можно поместить однобуквенный модификатор. В таблице 3.2 приведены наиболее часто употребляемые модификаторы.

Таблица 3.2. Модификаторы регулярных выражений

Дополнительные примеры будут рассмотрены в главе 4. Чтобы завершить введение в регулярные выражение, в таблице 3.3 мы приводим наиболее употребительные символы и обозначения.

Таблица 3.3. Общеупотребительные обозначения в регулярных выражениях

Умение работать с регулярными выражениями — большой плюс для современного программиста. Полное рассмотрение этой темы выходит далеко за рамки настоящей книги, но, если вам интересно, можете обратиться к книге Jeffrey Friedl, Mastering Regular Expressions[8].

Дополнительный материал вы также найдете в разделе 3.13.

Для компиляции регулярных выражений предназначен метод

Regexp.compile

Regexp.new

pat1 = Regexp.compile("^foo.*") # /^foo.*/

pat2 = Regexp.compile(/bar$/i)  # /bar/ (i не переносится)

Если второй параметр задан, обычно это поразрядное объединение (ИЛИ) каких-либо из следующих констант:

Regexp::EXTENDED

Regexp::IGNORECASE

Regexp::MULTILINE

nil

options = Regexp::MULTILINE || Regexp::IGNORECASE

pat3 = Regexp.compile("^foo", options)

pat4 = Regexp.compile(/bar/, Regexp::IGNORECASE)

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

"N" или "n" означает отсутствие поддержки

"Е" или "е" означает EUC

"S" или "s" означает Shift-JIS

"U" или "u" означает UTF-8

Литеральное регулярное выражение можно задавать и не вызывая метод

new

pat1 = /^fоо.*/

pat2 = /bar$/i

Более подробная информация приводится в главе 4.

Метод класса

Regexp.escape

str1 = "[*?]"

str2 = Regexp.escape(str1) # "\[\*\?\]"

Синонимом является метод

Regexp.quote

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

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

^

$

string = "abcXdefXghi"

/def/ =~ string  # 4

/аbс/ =~ string  # 0

/ghi/ =~ string  # 8

/^def/ =~ string # nil

/def$/ =~ string # nil

/^аbс/ =~ string # 0

/ghi$/ =~ string # 8

Впрочем, я немного уклонился от истины. Эти якоря на самом деле соответствуют началу и концу не строки символов (string), а строки текста (line). Вот что произойдет, если те же самые образцы применить к строке, внутри которой есть символы новой строки:

string = "abc\ndef\nghi"

/def/ =~ string  # 4

/abc/ =~ string  # 0

/ghi/ =~ string  # 8

/^def/ =~ string # 4

/def$/ =~ string # 4

/^abc/ =~ string # 0

/ghi$/ =~ string # 8

Однако имеются якоря

\A

\Z

string = "abc\ndef\nghi"

/\Adef/ =~ string # nil

/def\Z/ =~ string # nil

/\Aabc/ =~ string # 0

/ghi\Z/ =~ string # 8

Якорь

\z

\Z

string = "abc\ndef\nghi"

str2 << "\n"

/ghi\Z/ =~ string # 8

/\Aabc/ =~ str2   # 8

/ghi\z/ =~ string # 8

/ghi\z/ =~ str2   # nil

Можно также устанавливать соответствие на границе слова с помощью якоря

\b

\B

gsub

str = "this is a test"

str.gsub(/\b/,"|") # "|this| |is| |a| |test|"

str.gsub(/\В/, "-") # "t-h-i-s i-s a t-e-s-t"

He существует способа отличить начало слова от конца.

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

pattern = /ax?b/

pat2 = /а[xy]?b/

pattern =~ "ab"  # 0

pattern =~ "acb" # nil

pattern =~ "axb" # 0

pat2 =~ "ayb"    # 0

pat2 =~ "acb"    # nil

Элементы часто повторяются неопределенное число раз (для формулировки этого условия служит квантор

+

pattern = /[0-9]+/

pattern =~ "1"       # 0

pattern =~ "2345678" # 0

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

+

?

pattern = /Huzzah(!+)?/ # Скобки здесь обязательны.

pattern =~ "Huzzah"     # 0

pattern =~ "Huzzah!!!!" # 0

Но есть и способ лучше. Требуемое поведение описывается квантором

*

pattern = /Huzzah!*/    # * применяется только к символу !

pattern =~ "Huzzah"     # 0

pattern =~ "Huzzah!!!!" # 0

Как распознать американский номер социального страхования? С помощью такого образца:

ssn = "987-65-4320"

pattern = /\d\d\d-\d\d-\d\d\d\d/

pattern =~ ssn # 0

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

pattern = /\d{3}-\d{2}-\d{4}/

Необязательно, что такой образец будет короче, но он более понятен читателю программы.

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

elbonian_phone = /\d{3,5}-\d{3,7}/

Нижняя и верхняя границы диапазона необязательны (но хотя бы одна должна быть задана):

/x{5}/   # Соответствует 5 x.

/x{5,7}/ # Соответствует 5-7 x.

/x{,8}/  # Соответствует не более 8 x.

/x{3,}/  # Соответствует по меньшей мере 3 x.

Ясно, что кванторы

?

+

*

/x?/ # То же, что /x{0,1}/

/x*/ # То же, что /x{0,}

/x+/ # то же, что /x{1,}

Фразеология, применяемая при описании регулярных выражений, изобилует яркими терминами: жадный (greedy), неохотный (reluctant), ленивый (lazy) и собственнический (possessive). Самым важным является различие между жадными и нежадными выражениями.

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

"Where the"

"Where the sea meets the"

str = "Where the sea meets the moon-blanch'd land,"

match = /.*the/.match(str)

p match[0] # Вывести полученное соответствие:

           # "Where the sea meets the"

Причина состоит в том, что оператор

*

str = "Where the sea meets the moon-blanch'd land,"

match = /.*?the/.match(str)

p match[0] # Вывести полученное соответствие:

           # "Where the" .

Итак, оператор

*

?

+

{m,n}

?

Я не сумел найти разумных примеров применения конструкций

{m,n}?

??

Дополнительная информация о кванторах содержится в разделе 3.13.

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

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

В следующем примере строка

"New world"

"Symphony"

"Dictionary"

s1 = "New World Dictionary"

s2 = "New World Symphony"

s3 = "New World Order"

reg = /New World(?= Dictionary | Symphony)/

m1 = reg.match(s1)

m.to_a[0]          # "New World"

m2 = reg.match(s2)

m.to_a[0]          # "New World"

m3 = reg.match(s3) # nil

Вот пример негативного заглядывания:

reg2 = /New World(?! Symphony)/

m1 = reg.match(s1)

m.to_a[0]          # "New World"

m2 = reg.match(s2)

m.to_a[0]          # nil

m3 = reg.match(s3) # "New World"

В данном случае строка

"New world"

"Symphony"

Каждая заключенная в круглые скобки часть регулярного выражения является отдельным соответствием. Они нумеруются, и есть несколько способов сослаться на такие части по номерам. Сначала рассмотрим традиционный «некрасивый» способ.

Сослаться на группы можно с помощью глобальных переменных

$1

$2

str = "а123b45с678"

if /(a\d+)(b\d+)(c\d+)/ =~ str

 puts "Частичные соответствия: '#$1', '#$2', '#$3'"

 # Печатается: Частичные соответствия: 'а123', 'b45', 'c768'

end

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

sub

gsub

str = "а123b45с678"

str.sub(/(a\d+)(b\d+)(c\d+)/, "1st=#$1, 2nd=#$2, 3rd=#$3")

# "1st=, 2nd=, 3rd="

Почему такая конструкция не работает? Потому что аргументы

sub

sub

str = "а123b45с678"

s2 = "1st=#$1, 2nd=#$2, 3rd=#$3"

reg = /(a\d+)(b\d+)(c\d+)/

str.sub(reg,s2)

# "1st=, 2nd=, 3rd="

Отсюда совершенно понятно, что значения

$1

$2

$3

В такой ситуации на помощь приходят специальные коды

\1

\2

str = "а123b45с678"

str.sub(/(a\d+)(b\d+)(c\d+)/, '1st=\1, 2nd=\2, 3rd=\3')

# "1st=a123, 2nd=b45, 3rd=c768"

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

str = "а123b45с678"

str.sub(/(a\d+)(b\d+)(c\d+)/, "1st=\1, 2nd=\2, 3rd=\3")

# "1st=\001, 2nd=\002, 3rd=\003"

Обойти эту неприятность можно за счет двойного экранирования:

str = "а123b45с678"

str.sub(/(a\d+)(b\d+)(c\d+)/, "1st=\\1, 2nd=\\2, 3rd=\\3")

# "1st=a123, 2nd=b45, 3rd=c678"

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

str = "а123b45с678"

str.sub(/(a\d+)(b\d+)(c\d+)/) { "1st=#$1, 2nd=#$2, 3rd=#$3" }

# "1st=a123, 2nd=b45, 3rd=c678"

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

Упомяну попутно о том, что существуют незапоминаемые группы (noncapturing groups). Иногда при составлении регулярного выражения нужно сгруппировать символы, но чему будет соответствовать в конечном счете такая группа, несущественно. На этот случай и предусмотрены незапоминаемые группы, описываемые синтаксической конструкцией

(?:...)

str = "а123b45с678"

str.sub(/(a\d+)(?:b\d+)(c\d+)/, "1st=\\1, 2nd=\\2, 3rd=\\3")

# "1st=a123, 2nd=c678, 3rd="

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

Лично мне не нравится ни одна из двух нотаций (

\1

$1

Метод класса

Regexp.last_match

MatchData

match

Обращаться к объекту

MatchData

pat = /(. + [aiu])(.+[aiu])(.+[aiu])(.+[aiu])/i

#

refs = pat.match("Fujiyama")

# refs is now: ["Fujiyama","Fu","ji","ya","ma"]

x = refs[1]

y = refs[2..3]

refs.to_a.each {|x| print "#{x}\n"}

Отметим, что объект

refs

each

to_a

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

begin

end

str = "alpha beta gamma delta epsilon"

#      0....5....0....5....0....5....

#      (для удобства подсчета)

pat = /(b[^ ]+ )(g[^ ]+ )(d[^ ]+ )/

# Три слова, каждое из которых представляет собой отдельное соответствие.

refs = pat.match(str)

# "beta "

p1 = refs.begin(1) # 6

p2 = refs.end(1)   # 11

# "gamma "

p3 = refs.begin(2) # 11

p4 = refs.end(2)   # 17

# "delta "

p5 = refs.begin(3) # 17

p6 = refs.end(3)   # 23

# "beta gamma delta"

p7 = refs.begin(0) # 6

p8 = refs.end(0)   # 23

Аналогично метод

offset

range0 = refs.offset(0) # [6,23]

range1 = refs.offset(1) # [6,11]

range2 = refs.offset(2) # [11,17]

range3 = refs.offset(3) # [17,23]

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

pre_match

post_match

before = refs.pre_match # "alpha "

after = refs.post_match # "epsilon"

Классы символов — это просто форма перечисления (указание альтернатив), в котором каждая группа состоит из одного символа. В простейшем случае список возможных символов заключается в квадратные скобки:

/[aeiou]/ # Соответствует любой из букв а, е, i, о, и; эквивалентно

          # /(a|e|i|o|u)/, только группа не запоминается.

Внутри класса символов управляющие последовательности типа

\n

.

?

/[.\n?]/ # Сопоставляется с точкой, символом новой строки,

         # вопросительным знаком.

Символ каре (

^

[^aeiou] # Любой символ, КРОМЕ а, е, i, о, и.

Дефис внутри класса символов обозначает диапазон (в лексикографическом порядке):

/[а-mA-М]/  # Любой символ из первой половины алфавита.

/[^а-mA-М]/ # Любой ДРУГОЙ символ, а также цифры и символы. отличные

            # от букв и цифр.

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

/[-^[\]]/ # Сопоставляется с дефисом, каре и правой квадратной скобкой.

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

[[:name:]]

[[:digit:]]

[0-9]

Есть еще такие именованные классы:

[[:print:]]

[[:alpha:]]

s1 = "abc\007def"

/[[:print:]]*/.match(s1)

m1 = Regexp::last_match[0] # "abc"

s2 = "1234def"

/[[:digit:]]*/.match(s2)

m2 = Regexp::last_match[0] # "1234"

/[[:digit:]] + [[:alpha:]]/.match(s2)

m3 = Regexp::last_match[0] # "1234d"

Каре перед именем класса символов формирует его дополнение:

/[[:^alpha:]]/ # Все символы, кроме букв.

Для многих классов имеется также сокращенная нотация. Наиболее распространены сокращения

\d

\w

\s

str1 = "Wolf 359"

/\w+/.match(str1)     # Соответствует "Wolf" (то же, что /[a-zA-Z_0-9]+/)

/\w+ \d+/.match(str1) # Соответствует "Wolf 359"

/\w+ \w+/.match(str1) # Соответствует "Wolf 359"

/\s+/.match(str1)     # Соответствует " "

«Дополнительные» формы обычно записываются в виде прописной буквы:

/\W/ # Любой символ, не входящий в состав слова.

/\D/ # Все кроме цифр.

/\S/ # Все кроме пропусков.

Дополнительная информация, относящаяся только к Oniguruma, приводится в разделе 3.13.

Регулярные выражения, особенно длинные, часто выглядят загадочно. Модификатор

x

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

addresses =

[ "409 W Jackson Ave",           "No. 27 Grande Place",

  "16000 Pennsylvania Avenue",   "2367 St. George St.",

  "22 Rue Morgue",               "33 Rue St. Denis",

  "44 Rue Zeeday",               "55 Santa Monica Blvd.",

  "123 Main St., Apt. 234",      "123 Main St., #234",

  "345 Euneva Avenue, Suite 23", "678 Euneva Ave, Suite A"]

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

No.

Apt.

Suit

#

Вот какое регулярное выражение я составил для разбора адреса. Обратите внимание, насколько подробно оно прокомментировано (может быть, даже излишне подробно):

regex = / ^                 # Начало строки.

         ((No\.?)\s+)?      # Необязательно: No[.]

         \d+ \s+            # Цифры и пробелы.

         ((\w|[.'-])+       # Название улицы... может

          \s*               # состоять из нескольких слов.

         )+

         (,\s*              # Необязательно: запятая и т.д.

          (Apt\.?|Suite|\#) # Apt[.], Suite, #

          \s+               # Пробелы.

          (\d+|[A-Z])       # Цифры или одна буква.

         )?

         $                  # Конец строки.

        /x

Идея понятна. Когда сложность регулярного выражения достигает некоего порога (какого именно — дело вкуса), делайте его обобщенным, чтобы можно было добавить форматирование и комментарии.

Возможно, вы заметили, что я пользовался обычными комментариями Ruby (

# ...

(?#...)

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

Regexp::MULTILINE

str = "Rubies are red\nAnd violets are blue.\n"

pat1 = /red./

pat2 = /red./m

str =~ pat1 # nil

str =~ pat2 # 11

Этот режим не оказывает влияния на то, где устанавливается соответствие якорям (

^

$

\A

\Z

Обычно модификаторы (например,

i

m

Существует специальная нотация для включения и выключения модификаторов. Заключенный в круглые скобки вопросительный знак, за которым следует один или несколько модификаторов, «включает» их до конца регулярного выражения. А если некоторым модификаторам предшествует минус, то соответствующие режимы «выключаются»:

/abc(?i)def/     # Соответствует abcdef, abcDEF, abcDef,

                 # но не ABCdef.

/ab(?i)cd(?-i)ef/# Соответствует abcdef, abCDef, abcDef, ...,

                 # но не ABcdef или abcdEF.

/(?imx).*/       # To же, что /.*/imx

/abc(?i-m).*/m   # Для последней части регулярного выражения включить

                 # распознавание регистра, выключить многострочный

                 # режим.

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

/ab(?i:cd)ef/ # То же, что /ab(?i)cd(?-i)ef/

По техническим причинам использовать таким образом модификатор

о

x

Для указания подвыражений применяется нотация

?>

re = /(?>abc)(?>def)/   # То же, что /abcdef/

re.match("abcdef").to_a # ["abcdef"]

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

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

str = "abccccdef"

re1 = /(abc*)cdef/

re2 = /(?>abc*)cdef/

re1 =~ str          # 0

re2 =~ str          # nil

re1.match(str).to_a # ["abccccdef", "abccc"]

re2.match(str).to_a # []

В предыдущем примере подвыражение

abc*

re2

с

Новая библиотека регулярных выражений в Ruby называется Oniguruma. Это японское слово означает что-то вроде «колесо духов». (Те, кто не владеет японским, часто пишут его неправильно; имейте в виду, что тут не обойтись без «guru»!)

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

В следующем разделе мы расскажем, как определить, присутствует ли библиотека Oniguruma. А затем покажем, как можно ее собрать, если она не включена в дистрибутив.

Если вас интересует библиотека Oniguruma, то первым делом нужно выяснить, есть ли она в вашем экземпляре Ruby. В версиях 1.8.4 и младше ее, скорее всего, нет. Стандартно она включается в дистрибутив версии 1.9.

Вот как можно без труда выяснить, присутствует ли Oniguruma, проверив три условия. Во-первых, как я сказал, она стандартно поставляется в версии 1.9 и старше. В последних версиях обеих библиотек для работы с регулярными выражениями определена строковая константа

Regexp::ENGINE

Oniguruma

SyntaxError

def oniguruma?

 return true if RUBY_VERSION >= "1.9.0"

 if defined?(Regexp::ENGINE) # Константа ENGINE определена?

  if Regexp::ENGINE.include?('Oniguruma')

   return true               # Какая-то версия Oniguruma.

  else

   return false              # Старая библиотека,

  end

 end

 eval("/(?<!a)b/")           # Новый синтаксис.

  return true                # Сработало: новая библиотека.

 rescue SyntaxError          # Не сработало: старая библиотека.

  return false

 end

puts oniguruma?

Если в вашу версию библиотека Oniguruma не включена, можете самостоятельно откомпилировать Ruby и скомпоновать с недостающей библиотекой. Ниже приведены соответствующие инструкции. Эта процедура должна работать начиная с версии 1.6.8 (хотя она уже совсем старенькая).

Получить исходный текст Oniguruma можно из архива приложений Ruby RAA (http://raa.ruby-lang.org/) или найти в другом месте. Исходные тексты Ruby, естественно, находятся на официальном сайте.

Если вы работаете на платформе UNIX (в том числе в среде Cygwin в Windows или Mac OS/X), выполните следующие действия:

1. 

gunzip oniguruma.tar.gz

2. 

tar xvf oniguruma.tar

3. 

cd oniguruma

4. 

./configure with-rubydir=<ruby-source-dir>

5. Одно из следующих:

make 16 # Для Ruby 1.6.8

make 18 # Для Ruby 1.8.0/1.8.1

6. 

cd ruby-source-dir

7. 

./configure

8. 

make clean

9. 

make

10. 

make test # Простой тест интерпретатора Ruby.

11. 

cd ../oniguruma # Укажите путь к библиотеке.

12. 

make rtest

Или:

make rtest RUBYDIR=ruby-install-dir

Если же вы работаете на платформе Win32, скажем в Windows XP, то потребуются Visual C++ и исполняемый файл patch.exe. Выполните следующие действия:

1. Распакуйте архив любой имеющейся у вас программой.

2. 

copy win32\Makefile Makefile

3. Одно из следующих:

nmake 16 RUBYDIR=ruby-source-dir # для Ruby 1.6.8

nmake 18 RUBYDIR=ruby-source-dir # для Ruby 1.8.0/1.8.1

4. Следуйте инструкции в файле

ruby-source-dir\win32\README.win32

При возникновении ошибок обратитесь в список рассылки или конференцию.

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

\d

\D

\h

\H

"abc" =~ /\h+/ #0

"DEF" =~ /\h+/ # 0

"abc" =~ /\Н+/ # nil

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

&&

reg1 = /[a-z&&[^aeiou]]/ # Задает пересечение.

А следующее выражение соответствует всему алфавиту, кроме букв от m до p:

reg2 = /[a-z&&[^m-р]]/

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

Другие возможности Oniguruma, например оглядывание назад и именованные соответствия, будут рассмотрены ниже. Все связанное с интернационализацией отложим до главы 4.

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

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

Предположим, что вам нужно проанализировать некоторую генетическую последовательность (молекула ДНК состоит из четырех основных белков, которые обозначаются А, С, G и T.) Допустим, что мы ищем все неперекрывающиеся цепочки нуклеотидов (длины 4), следующие за T. Нельзя просто попытаться найти T и взять следующие четыре символа, поскольку T может быть последним символом в предыдущем соответствии.

gene = 'GATTACAAACTGCCTGACATACGAA'

seqs = gene.scan(/T(\w{4})/)

# seqs равно: [["TACA"], ["GCCT"], ["ACGA"]]

Ho в этом коде мы пропустили цепочку

GACA

GCCT

gene = 'GATTACAAACTGCCTGACATACGAA'

seqs = gene.scan(/(?<=T)(\w{4})/)

# seqs равно: [["TACA"], ["GCCT"], ["GACA"], ["ACGA"]]

Следующий пример - небольшая модификация примера, предложенного К. Косако (К. Kosako). Предположим, что есть текст в формате XML (или HTML), и мы хотим перевести в верхний регистр весь текст вне тегов (то есть cdata) Вот как можно сделать это с помощью оглядывания назад:

text =<<-EOF

<body> <h1>This is a heading</h1>

<p> This is a paragraph with some

<i>italics</i> and some <b>boldface</b>

in it...</p>

</body>

EOF

pattern = /(?:^| # Начало или...

   (?<=>)        # текст после '>'

  )

  ([^<]*)        # И все символы, кроме '<' (запомнены).

 /x

puts text.gsub(pattern) {|s| s.upcase }

# Вывод:

# <body> <h1>THIS IS A HEADING</h1>

# <p>THIS IS A PARAGRAPH WITH SOME

# <i>ITALICS</i> AND SOME <b>BOLDFACE</b>

# IN IT...</p>

# </body>

Мы уже встречались с атомарными подвыражениями в «классической» библиотеке регулярных выражений в Ruby. Они выделяются с помощью нотации (

?>...

Oniguruma предлагает еще один способ выразить собственническую природу — с помощью квантора

+

+

?

??

+?

*?

Применение

+

r1 = /x*+/ # То же, что /(?>x*)/

r2 = /x++/ # То же, что /(?>x+)/

r3 = /x?+/ # То же, что /(?>x?)/

По техническим причинам Ruby не считает конструкцию

{n,m}+

Понятно, что новый квантор — не более чем удобное обозначение, никакой новой функциональности он не несет.

Специальной формой подвыражения является именованное выражение, которое позволяет присвоить образцу имя (а не просто порядковый номер).

Синтаксически это выглядит так: (

?<name>expr

Для чего может понадобиться именованное выражение? Например, для того, чтобы сослаться на него внутри обратной ссылки. Ниже приведен пример простого регулярного выражения для сопоставления с повторяющимся словом (см. также раздел 3.14.6):

re1 = /\s+(\w+)\s+\1\s+/

str = "Now is the the time for all..."

re1.match(str).to_a # ["the the","the"]

Здесь мы запомнили слово, а затем сослались на него по номеру

\1

\k

re2 = /\s+(?<anyword>\w+)\s+\k<anyword>\s+/

Второй вариант длиннее, зато понятнее. (Имейте в виду, что в одном и том же регулярном выражении нельзя использовать и именованные, и нумерованные обратные ссылки.) Если нравится, пользуйтесь!

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

sub

gsub

str = "I breathe when I sleep"

# Нумерованные соответствия...

r1 = /I (\w+) when I (\w+)/

s1 = str.sub(r1,' I \2 when I \1')

# Именованные соответствия...

r1 = /I (?<verb1>\w+) when I (?<verb2>\w+)/

s2 = str.sub(r2,'I \k<verb2> when I \k<verb1>')

Puts s1 # I sleep when I breathe

Puts s2 # I sleep when I breathe

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

\g

\k

re3 = /(?<spaces>\s+)(?<anyword>\w+)\g<spaces>\k<anyword>\g<spaces>/

Обратите внимание, что этот образец многократно употребляется с помощью маркера

\g

Нотацией

\g<1>

И последнее замечание об именованных соответствиях. В самых последних версиях Ruby имя (в виде строки или символа) может передаваться методу

MatchData

str = "My hovercraft is full of eels"

reg = /My (?<noun>\w+) is (?<predicate>.*)/

m = reg.match(str)

puts m[:noun] # hovercraft

puts m["predicate"] # full of eels

puts m[1] # то же, что m[:noun] или m["noun"]

Как видите, обычные индексы тоже не запрещены. Обсуждается возможность добавить в объект

MatchData

puts m.noun

puts m.predicate

Но во время работы над книгой это еще не было реализовано.

Возможность повторно обращаться к подвыражению позволяет создавать рекурсивные регулярные выражения. Например, данный код находит любое вложенное выражение с правильно расставленными скобками (спасибо Эндрю Джексону):

str = "а * ((b-c)/(d-e) - f) * g"

reg = /(?         # Начало именованного выражения.

       \(         # Открывающая круглая скобка.

        (?:       # Незапоминаемая группа.

         (?>      # Сопоставление с собственническим выражением:

           \\[()] # экранированная скобка

          |       # ЛИБО

           [^()]  # вообще не скобка. )

          )       # Конец собственнического выражения.

          |       # ЛИБО

          \g      # Вложенная группа в скобках (рекурсивный вызов).

         )*       # Незапоминаемая группа повторяется нуль или

                  # более раз.

        \)        # Закрывающая круглая скобка.

       )          # Конец именованного выражения.

      /x

m = reg.match(str).to_a # ["((b-c)/(d-e) - f)", "((b-c)/(d-e) - f)"]

Отметим, что левосторонняя рекурсия запрещена. Следующий пример допустим:

str = "bbbaccc"

re1 = /(?<foo>a|b\g<foo>c)/

re1.match(str).to_a # ["bbbaccc","bbbaccc"]

А такой — нет:

re2 = /(?<foo>a|\g<foo>c)/ # Синтаксическая ошибка!

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

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

Пусть мы хотим понять, содержит ли строка допустимый IPv4-адрес. Стандартно он записывается в точечно-десятичной нотации, то есть в виде четырех десятичных чисел, разделенных точками, причем каждое число должно находиться в диапазоне от 0 до 255.

Приведенный ниже образец решает эту задачу (за немногими исключениями типа «127.1»). Для удобства восприятия мы разобьем его на части. Отметим, что символ \d дважды экранирован, чтобы косая черта не передавалась из строки в регулярное выражение (чуть ниже мы решим и эту проблему).

num = "(\\d|[01]?\\d\\d|2[0-4]\\d\25[0-5])"

pat = ^(#{num}\.){3}#{num}$"

ip_pat = Regexp.new(pat)

ip1 = "9.53.97.102"

if ip1 =~ ip_pat # Печатается: "да"

 puts "да"

else

 puts "нет"

e

Надо признать, что в определении переменной

num

num = /(\d1[01]?\d\d|2[0-4]\d|25[0-5])/

Когда одно регулярное выражение интерполируется в другое, вызывается метод

to_s

num.to_s # "(?-mix:(\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5]))"

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

IPv6-адреса пока не очень широко распространены, но для полноты рассмотрим и их. Они записываются в виде восьми шестнадцатеричных чисел, разделенных двоеточиями, с подавлением начальных нулей.

num = /[0-9A-Fa-f]{0,4}/

pat = /^(#{num}:){7}#{num}$/

ipv6_pat = Regexp.new(pat)

v6ip = "abcd::1324:ea54::dead::beef"

if v6ip =~ ipv6_pat # Печатается: "да"

 puts "да"

else

 puts "нет"

end

Иногда приходится работать со строками вида «ключ=значение» (например, при разборе конфигурационного файла приложения).

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

pat = /(\w+)\s*=\s*(.*?)$/

str = "color = blue"

matches = pat.match(str)

puts matches[1] # "color"

puts matches[2] # "blue"

Следующее довольно сложное регулярное выражение сопоставляется с любым правильно записанным римскими цифрами числом (до 3999 включительно). Как и раньше, для удобства восприятия образец разбит на части:

rom1 = /m{0,3}/i

rom2 = /(d?c{0,3}|с[dm])/i

rom3 = /(l?x{0,3}|x[lс])/i

rom4 = /(v?i{0,3}|i[vx])/i

roman = /^#{rom1}#{rom2}#{rom3}#{rom4}$/

year1985 = "MCMLXXXV"

if year1985 =~ roman # Печатается: "да"

 puts "да"

else

 puts "нет"

end

Возможно, у вас появилось искушение поставить в конец всего выражения модификатор

i

# Это не работает!

rom1 = /m{0,3}/

rom2 = /(d?c{0,3}|с[dm])/

rom3 = /(l?x{0,3}|x[lс])/

rom4 = /(v?i{0,3}|i[vx])/

roman = /^#{rom1}#{rom2}#{rom3}#{rom4}$/i

Почему такое выражение не годится? Взгляните на этот пример и поймете:

rom1.to_s # "(?-mix:m{0,3})"

Обратите внимание, что метод

to_s

Сопоставление с простым целым десятичным числом — самое простое. Число состоит из необязательного знака и последовательности цифр (правда, Ruby позволяет использовать знак подчеркивания в качестве разделителя цифр). Отметим, что первая цифра не должна быть нулем, иначе число будет интерпретироваться как восьмеричное.

int_pat = /^[+-]?[1-9][\d_]*$/

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

hex_pat = /^[+-]?0x[\da-f_]+$/i

oct_pat = /^[+-]?0[0-7_]+$/

bin_pat = /^[+-]?0b[01_]+$/i

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

float_pat = /^(\d[\d_]*)*\.[\d_]*$/

Образец для чисел, записанных в научной нотации, основан на предыдущем:

sci_pat = /^(\d[\d_]*)?\.[\d_]*(e[+-]?)?(_*\d[\d_]*)$/i

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

Пусть надо выделить дату и время, записанные в формате

mm/dd/yy hh:mm:ss

datetime = /(\d\d)\/(\d\d)\/(\d\d) (\d\d): (\d\d): (\d\d)/

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

mo = /(0?[1-9]|1[0-2])/         # От 01 до 09 или от 1 до 9 или 10-12.

dd = /([0-2]?[1-9]| [1-3][01])/ # 1-9 или 01-09 или 11-19 и т.д.

yy = /(\d\d)/ # 00-99

hh = /([01]?[1-9]|[12][0-4])/   # 1-9 или 00-09 или...

mi = /([0-5]\d)/                # 00-59, обе цифры должны присутствовать.

ss = /([0-6]\d)?/               # разрешены еще и доли секунды ;-)

date = /(#{mo}\/#{dd}\/#{yy})/

time = /{#{hh}:#{mi}:#{ss})/

datetime = /(#{date} #{time})/

Вот как можно вызвать это регулярное выражение из метода

String#scan

str="Recorded on 11/18/07 20:31:00"

str.scan(datetime)

# [["11/18/07 20:31:00", "11/18/07", "11", "18", "00",

# "20:31:00", "20", "31", ":00"]]

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

datetime = %r{(

 (0?[1-9]|1[0-2])/        # mo: от 01 до 09 или от 1 до 9 или 10-12.

 ([0-2]?[1-9]|[1-3][01])/ # dd: 1-9 или 01-09 или 11-19 и т. д.

 (\d\d) [ ]               # yy: 00-99

 ([01]?[1-9]|[12][0-4]):  # hh: 1-9 или 00-09 или...

 ([0-5]\d):               # mm: 00-59, обе цифры должны присутствовать.

 (([0-6]\d))?             # ss: разрешены еще и доли секунды ;-)

)}x

Обратите внимание на конструкцию

%r{}

В этом разделе мы реализуем детектор повторяющихся слов. Повторение одного и того же слова два раза подряд — типичная опечатка. Следующий код распознает такие ситуации:

double_re = /\b(['A-Z]+) +\1\b/i

str="There's there's the the pattern."

str.scan(double_re) # [["There's"],["the"]]

Обратите внимание на модификатор

i

Мы упростили пример, предположив, что в тексте нет чисел, подчерков и т.д.

allcaps = /\b[A-Z]+\b/

string = "This is ALL CAPS"

string[allcaps]      # "ALL"

Suppose you want to extract every word in all-caps:

string.scan(allcaps) # ["ALL", "CAPS"]

При желании можно было бы обобщить эту идею на идентификаторы Ruby и аналогичные вещи.

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

package = "mylib-1.8.12"

matches = package.match(/(.*)-(\d+)\.(\d+)\.(\d+)/)

name, major, minor, tiny = matches[1..-1]

Завершим наш список несколькими выражениями из категории «разное». Как обычно, почти все эти задачи можно решить несколькими способами.

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

/[A-Z]{2}/

XX

ZZ

state = /^A[LKZR] ! C[AOT] | D[EC] | FL | GA | HI | I[DLNA] |

          K[SY] | LA | M[EDAINSOT] | N[EVHJMYCD] | O[HKR] |

          PA | RI | S[CD] | T[NX] | UT | V[TA] | W[AVIY]$/x

Для ясности я воспользовался обобщенным регулярным выражением (модификатор

x

Продолжая эту тему, приведем регулярное выражение для распознавания почтового индекса США (он может состоять из пяти или девяти цифр):

zip = /^\d{5}(-\d{4))?$/

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

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

phone = /^((\(\d{3}\) |\d{3}-)\d{3}-\d{4}|\d{3}\.\d{3}\.\d{4})$/

"(512) 555-1234" =~ phone # true

"512.555.1234" =~ phone   # true

"512-555-1234" =~ phone   # true

"(512)-555-1234" =~ phone # false

"512-555.1234" =~ phone   # false

Распознавание денежной суммы в долларах также не составит труда:

dollar = /^\$\d+{\.\d\d)?$/

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

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

Примечания:

8

Дж. Фридл. Регулярные выражения. — Питер, 2003 (Прим. перев.)