"S" или "s" означает Shift-JIS
"U" или "u" означает UTF-8
Литеральное регулярное выражение можно задавать и не вызывая метод new или compile. Достаточно заключить его в ограничители (символы косой черты).
pat1 = /^fоо.*/
pat2 = /bar$/i
Более подробная информация приводится в главе 4.
3.3. Экранирование специальных символов
Метод класса Regexp.escape экранирует все специальные символы, встречающиеся в регулярном выражении. К их числу относятся звездочка, вопросительный знак и квадратные скобки.
str1 = "[*?]"
str2 = Regexp.escape(str1) # "\[\*\?\]"
Синонимом является метод Regexp.quote.
3.4. Якоря
Якорь - это специальное выражение, соответствующее позиции в строке, а не конкретному символу или последовательности символов. Позже мы увидим, что это простой частный случай утверждения нулевой длины, то есть соответствия, которое не продвигает просмотр исходной строки ни на одну позицию.
Наиболее употребительные якоря уже были представлены в начале главы. Простейшими из них являются ^ и $, которые соответствуют началу и концу строки символов.
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 существует способа отличить начало слова от конца.
3.5. Кванторы
Немалая часть аппарата регулярных выражений связана с обработкой необязательных элементов и повторений. Элемент, за которым следует вопросительный знак, необязателен; он может присутствовать или отсутствовать, а общее соответствие зависит от прочих частей регулярного выражения. (Этот квантор имеет смысл применять только к подвыражению ненулевой длины, но не к якорям.)
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
Еще один типичный случай - образец, повторяющийся нуль или более раз. Конечно, это условие можно выразить с помощью кванторов + и ?. Вот, например, как сказать, что после строки Huzzah должно быть нуль или более восклицательных знаков:
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.
3.6. Позитивное и негативное заглядывание вперед
Понятно, что регулярное выражение сопоставляется со строкой линейно (осуществляя при необходимости возвраты). Поэтому существует понятие "текущего положения" в строке, это аналог указателя файла или курсора.
Термин "заглядывание" означает попытку сопоставить часть строки, находящуюся дальше текущего положения. Это утверждение нулевой длины, поскольку даже если соответствие будет найдено, никакого продвижения по строке не произойдет (то есть текущее положение не изменится).
В следующем примере строка "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".
3.7. Обратные ссылки
Каждая заключенная в круглые скобки часть регулярного выражения является отдельным соответствием. Они нумеруются, и есть несколько способов сослаться на такие части по номерам. Сначала рассмотрим традиционный "некрасивый" способ.
Сослаться на группы можно с помощью глобальных переменных $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 никак не связаны с сопоставлением, которое делается внутри вызова sub.
В такой ситуации на помощь приходят специальные коды \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 можно с помощью квадратных скобок, как если бы это был массив соответствий. Специальный элемент с индексом 0 содержит текст всей сопоставляемой строки, а элемент с индексом n ссылается на n-ую запомненную группу:
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"