класс Regexp

Регулярные выражения (regexp) — это шаблоны, описывающие содержимое строки. Они используются для проверки, содержит ли строка заданный шаблон, или для извлечения совпадающих частей. Они создаются с помощью литералов /pat/ и %r{pat} или конструктора Regexp.new.

Регулярное выражение обычно ограничено слешами (/). Например:

/hay/ =~ 'haystack'   #=> 0
/y/.match('haystack') #=> #<MatchData "y">

Если строка содержит шаблон, то говорят, что она совпадает. Литеральная строка совпадает сама с собой.

Здесь «стог сена» не содержит шаблон «игла», поэтому он не совпадает:

/needle/.match('haystack') #=> nil

Здесь «стог сена» содержит шаблон «стог», поэтому он совпадает:

/hay/.match('haystack')    #=> #<MatchData "hay">

В частности, /st/ требует, чтобы строка содержала букву s, за которой следует буква t, поэтому она совпадает со строкой стог сена.

Обратите внимание, что любое Regexp сопоставление вызовет RuntimeError, если таймаут установлен и превышен. Подробности см. в разделе “Таймаут”.

Интерполяция regexp

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

foo = 'bar'
/#{foo}/ # => /bar/

=~ и Regexp#match

Сопоставление с шаблоном можно выполнить с помощью оператора =~ или метода Regexp#match.

=~ Оператор

=~ — это базовый оператор сопоставления с шаблоном в Ruby. Когда один операнд — это регулярное выражение, а другой — это строка, то регулярное выражение используется в качестве шаблона для сопоставления со строкой. (Этот оператор эквивалентен определению Regexp и String, поэтому порядок String и Regexp не имеет значения. Другие классы могут иметь разные реализации оператора =~.) Если совпадение найдено, оператор возвращает индекс первого совпадения в строке, в противном случае возвращает nil.

/hay/ =~ 'haystack'   #=> 0
'haystack' =~ /hay/   #=> 0
/a/   =~ 'haystack'   #=> 1
/u/   =~ 'haystack'   #=> nil

Использование оператора =~ с String и Regexp устанавливает глобальную переменную $~ после успешного совпадения. $~ содержит объект MatchData. Regexp.last_match эквивалентно $~.

Regexp#match Method

Метод match возвращает объект MatchData:

/st/.match('haystack')   #=> #<MatchData "st">

Метасимволы и экранирование

Следующие являются метасимволами (, ), [, ], {, }, ., ?, +, *. Они имеют специальное значение при появлении в шаблоне. Для их буквального соответствия они должны быть экранированы обратной косой чертой. Для буквального соответствия обратной косой черты, экранируйте её: \\.

/1 \+ 2 = 3\?/.match('Does 1 + 2 = 3?') #=> #<MatchData "1 + 2 = 3?">
/a\\\\b/.match('a\\\\b')                    #=> #<MatchData "a\\b">

Шаблоны ведут себя как строки в двойных кавычках и могут содержать те же экранированные символы обратной косой чертой (значение \s отличается, однако, см. ниже).

/\s\u{6771 4eac 90fd}/.match("Go to 東京都")
    #=> #<MatchData " 東京都">

Произвольные выражения Ruby могут быть встроены в шаблоны с помощью конструкции #{...}.

place = "東京都"
/#{place}/.match("Go to 東京都")
    #=> #<MatchData "東京都">

Классы символов

Класс символов ограничен квадратными скобками ([, ]) и перечисляет символы, которые могут появиться в этом месте соответствия. /[ab]/ означает а или б, в отличие от /ab/ , которое означает а, за которым следует б.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Внутри класса символов дефис (-) — это метасимвол, обозначающий интервал символов. [abcd] эквивалентно [a-d]. Интервал может следовать за другим интервалом, поэтому [abcdwxyz] эквивалентно [a-dw-z]. Порядок, в котором появляются интервалы или отдельные символы внутри класса символов, не имеет значения.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f')     #=> #<MatchData "9">

Если первый символ класса символов — это символ вставки (^), класс инвертируется: он совпадает с любым символом кроме указанных.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

Класс символов может содержать другой класс символов. Само по себе это не очень полезно, так как [a-z[0-9]] описывает тот же набор, что и [a-z0-9]. Однако, классы символов также поддерживают оператор &&, который выполняет пересечение множеств своих аргументов. Два могут быть объединены следующим образом:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))

Это эквивалентно:

/[abh-w]/

Следующие метасимволы также ведут себя как классы символов:

• /./ — Любой символ, кроме новой строки.

• /./m — Любой символ (модификатор m включает многострочный режим)

• /\w/ — Символ слова ([a-zA-Z0-9_])

• /\W/ — Несимвол слова ([^a-zA-Z0-9_]). Обратитесь к Ошибке #4044, если используете /\W/ с модификатором /i.

• /\d/ — Символ цифры ([0-9])

• /\D/ — Несимвол цифры ([^0-9])

• /\h/ — Символ шестнадцатеричной цифры ([0-9a-fA-F])

• /\H/ — Несимвол шестнадцатеричной цифры ([^0-9a-fA-F])

• /\s/ — Символ пробела: /[ \t\r\n\f\v]/

• /\S/ — Несимвол пробела: /[^ \t\r\n\f\v]/

• /\R/ — Символ перевода строки: \n, \v, \f, \r \u0085 (следующая строка), \u2028 (разделитель строк), \u2029 (разделитель абзацев) или \r\n.

POSIX скобочные выражения также похожи на классы символов. Они предлагают портативную альтернативу вышеупомянутому, с дополнительным преимуществом, что они охватывают не-ASCII символы. Например, /\d/ соответствует только ASCII десятичным цифрам (0-9); в то время как /[[:digit:]]/ соответствует любому символу в категории Unicode Nd.

• /[[:alnum:]]/ - Алфавитно-цифровой символ

• /[[:alpha:]]/ - Алфавитный символ

• /[[:blank:]]/ - Пробел или табуляция

• /[[:cntrl:]]/ - Символ управления

• /[[:digit:]]/ - Цифра

• /[[:graph:]]/ - Непустой символ (исключает пробелы, управляющие символы и подобные)

• /[[:lower:]]/ - Символ строчной буквы алфавита

• /[[:print:]]/ - Как [:graph:], но включает символ пробела

• /[[:punct:]]/ - Символ пунктуации

• /[[:space:]]/ - Символ пробела ([:blank:], перевод строки, возврат каретки и т. д.)

• /[[:upper:]]/ - Символ заглавной буквы алфавита

• /[[:xdigit:]]/ - Цифра, допустимая в шестнадцатеричном числе (т. е., 0-9a-fA-F)

Ruby также поддерживает следующие не-POSIX классы символов:

• /[[:word:]]/ - Символ в одной из следующих категорий Unicode Letter, Mark, Number, Connector_Punctuation

• /[[:ascii:]]/ - Символ ASCII набора символов

  # U+06F2 is "EXTENDED ARABIC-INDIC DIGIT TWO"
  /[[:digit:]]/.match("\u06F2")    #=> #<MatchData "\u{06F2}">
  /[[:upper:]][[:lower:]]/.match("Hello") #=> #<MatchData "He">
  /[[:xdigit:]][[:xdigit:]]/.match("A6")  #=> #<MatchData "A6">
  

Повторение

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

• * - Ноль или более раз

• + - Один или более раз

• ? - Ноль или один раз (необязательно)

• {n} - Ровно n раз

• {n,} - n или более раз

• {,m} - m или меньше раз

• {n,m} - По крайней мере n и не более m раз

По крайней мере одна заглавная буква (‘H’), по крайней мере одна строчная буква (‘e’), две буквы ‘l’, затем одна буква ‘o’:

"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

Жадное соответствие

По умолчанию повторение жадное: соответствует как можно большему количеству вхождений, при этом все еще позволяя общему совпадению произойти. В отличие от этого, ленивое сопоставление делает минимальное количество совпадений, необходимое для общего успеха. Большинство жадных метасимволов можно сделать ленивыми, добавив за ними ?. Для шаблона {n}, поскольку он указывает на точное количество символов для сопоставления, а не на переменное число символов, метасимвол ? вместо этого делает повторяемый шаблон необязательным.

Оба шаблона ниже совпадают со строкой. Первый использует жадный квантификатор, поэтому ‘.+’ совпадает с ‘<a><b>’; второй использует ленивый квантификатор, поэтому ‘.+?’ совпадает с ‘<a>’:

/<.+>/.match("<a><b>")  #=> #<MatchData "<a><b>">
/<.+?>/.match("<a><b>") #=> #<MatchData "<a>">

Позитивное соответствие

Квантификатор, за которым следует +, соответствует положительно: после соответствия он не возвращается. Они ведут себя как жадные квантификаторы, но, выполнив соответствие, отказываются «отказываться» от своего соответствия даже если это ставит под угрозу общее соответствие.

/<.*><.+>/.match("<a><b>") #=> #<MatchData "<a><b>">
/<.*+><.+>/.match("<a><b>") #=> nil
/<.*><.++>/.match("<a><b>") #=> nil

Захват

Скобки могут использоваться для захвата. Текст, заключенный в n-ой группе скобок, может быть ссылаться на него позже с помощью n. Внутри шаблона используйте ссылку на обратное обращение \n (например, \1); вне шаблона используйте MatchData[n] (например, MatchData[1]).

В этом примере 'at' захватывается первой группой скобок, а затем ссылается на неё позднее с помощью \1:

/[csh](..) [csh]\1 in/.match("The cat sat in the hat")
    #=> #<MatchData "cat sat in" 1:"at">

Regexp#match возвращает объект MatchData, который делает доступным захваченный текст с помощью метода []:

/[csh](..) [csh]\1 in/.match("The cat sat in the hat")[1] #=> 'at'

Хотя Ruby поддерживает произвольное количество пронумерованных захваченных групп, только группы 1-9 поддерживаются с помощью синтаксиса обратной ссылки \n.

Ruby также поддерживает \0 в качестве специальной обратной ссылки, которая ссылается на всю сопоставленную строку. Это также доступно в MatchData[0]. Обратите внимание, что обратная ссылка \0 не может быть использована внутри регулярного выражения, так как обратные ссылки могут быть использованы только после окончания группы захвата, а обратная ссылка \0 использует неявную группу захвата всего совпадения. Однако вы можете использовать эту обратную ссылку при выполнении подстановки:

"The cat sat in the hat".gsub(/[csh]at/, '\0s')
  # => "The cats sats in the hats"

Именованные захваты

К группам захвата можно обращаться по имени, когда они определены с помощью конструкций (?<имя>) или (?'имя').

/\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")
    #=> #<MatchData "$3.67" dollars:"3" cents:"67">
/\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")[:dollars] #=> "3"

Именованные группы могут быть обработаны с помощью обратной ссылки \k<имя>, где имя — имя группы.

/(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')
    #=> #<MatchData "ototo" vowel:"o">

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

/(\w)(\w)/.match("ab").captures # => ["a", "b"]
/(\w)(\w)/.match("ab").named_captures # => {}

/(?<c>\w)(\w)/.match("ab").captures # => ["a"]
/(?<c>\w)(\w)/.match("ab").named_captures # => {"c"=>"a"}

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

/\$(?<dollars>\d+)\.(?<cents>\d+)/ =~ "$3.67" #=> 0
dollars #=> "3"

Группирование

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

Нижеприведенный шаблон соответствует гласной, за которой следуют 2 символа слова:

/[aeiou]\w{2}/.match("Caenorhabditis elegans") #=> #<MatchData "aen">

В то время как следующий шаблон соответствует гласной, за которой следует символ слова дважды, т.е. [aeiou]\w[aeiou]\w: ‘enor’.

/([aeiou]\w){2}/.match("Caenorhabditis elegans")
    #=> #<MatchData "enor" 1:"or">

Конструкция (?:…) обеспечивает группирование без захвата. То есть, она объединяет содержащиеся в ней термины в атомарное целое без создания обратной ссылки. Это улучшает производительность в ущерб удобочитаемости.

Первая группа скобок захватывает «n», а вторая — «ti». Ко второй группе позже обращаются с помощью обратной ссылки \2:

/I(n)ves(ti)ga\2ons/.match("Investigations")
    #=> #<MatchData "Investigations" 1:"n" 2:"ti">

Первая группа скобок теперь сделана незахватывающей с помощью ‘?:’, поэтому она всё ещё соответствует «n», но не создаёт обратной ссылки. Таким образом, обратная ссылка \1 теперь ссылается на «ti».

/I(?:n)ves(ti)ga\1ons/.match("Investigations")
    #=> #<MatchData "Investigations" 1:"ti">

Атомарное группирование

Группирование может быть сделано атомарным с помощью (?>pat). Это заставляет подвыражение pat соответствовать независимо от остальной части выражения, так что то, что оно соответствует, становится фиксированным для остальной части совпадения, если только всё подвыражение не должно быть оставлено и впоследствии пересмотрено. Таким образом, pat рассматривается как неделимое целое. Атомарное группирование обычно используется для оптимизации шаблонов, чтобы предотвратить ненужное возвращение к регулярному выражению.

" в шаблоне ниже соответствует первому символу строки, а затем .* соответствует Quote“. Это приводит к тому, что общее совпадение терпит неудачу, поэтому текст, соответствующий .* отступает на одну позицию, что оставляет последний символ строки, доступный для совпадения "

/".*"/.match('"Quote"')     #=> #<MatchData "\"Quote\"">

Если .* сгруппировано атомарно, она отказывается от возврата к Quote“, даже если это означает, что общее совпадение терпит неудачу

/"(?>.*)"/.match('"Quote"') #=> nil

Вызовы подвыражений

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

Этот шаблон соответствует символу ( и присваивает его группе paren, пытается снова вызвать подвыражение paren, но терпит неудачу, а затем соответствует литеральному символу ):

/\A(?<paren>\(\g<paren>*\))*\z/ =~ '()'

/\A(?<paren>\(\g<paren>*\))*\z/ =~ '(())' #=> 0
# ^1
#      ^2
#           ^3
#                 ^4
#      ^5
#           ^6
#                      ^7
#                       ^8
#                       ^9
#                           ^10

1. Совпадает в начале строки, т.е. перед первым символом.

2. Входит в именованную группу захвата под названием paren

3. Совпадает с литеральным символом (, первым символом в строке

4. Вызывает группу paren снова, т.е. рекурсивно возвращается к второму шагу

5. Повторно входит в группу paren

6. Совпадает с литеральным символом (, вторым символом в строке

7. Попытка вызвать paren в третий раз, но терпит неудачу, потому что это помешает общему успешному совпадению

8. Совпадает с литеральным символом ), третьим символом в строке. Помечает конец второго рекурсивного вызова

9. Совпадает с литеральным символом ), четвёртым символом в строке

10. Совпадает с концом строки

Альтернация

Метасимвол вертикальной черты (|) объединяет несколько выражений в одно, которое соответствует любому из них. Каждое выражение является альтернативой.

/\w(and|or)\w/.match("Feliformia") #=> #<MatchData "form" 1:"or">
/\w(and|or)\w/.match("furandi")    #=> #<MatchData "randi" 1:"and">
/\w(and|or)\w/.match("dissemblance") #=> nil

Свойства символов

Конструкция \p{} соответствует символам с заданным свойством, очень похоже на POSIX квадратные скобки.

• /\p{Alnum}/ - Буквальный и числовой символ

• /\p{Alpha}/ - Буквальный символ

• /\p{Blank}/ - Пробел или табуляция

• /\p{Cntrl}/ - Символ управления

• /\p{Digit}/ - Цифра

• /\p{Emoji}/ - Юникод эмодзи

• /\p{Graph}/ - Символ, не являющийся пробелом (исключает пробелы, управляющие символы и подобные)

• /\p{Lower}/ - Строчный буквенный символ

• /\p{Print}/ - Как \p{Graph}, но включает и пробел

• /\p{Punct}/ - Символ пунктуации

• /\p{Space}/ - Символ пробела ([:blank:], перевод строки, возврат каретки и т.д.)

• /\p{Upper}/ - Прописной буквенный символ

• /\p{XDigit}/ - Цифра, разрешенная в шестнадцатеричном числе (т.е., 0-9a-fA-F)

• /\p{Word}/ - Символ, являющийся частью одной из следующих универсальных категорий Юникода: Letter, Mark, Number, Connector_Punctuation

• /\p{ASCII}/ - Символ из набора символов ASCII

• /\p{Any}/ - Любой символ Юникода (включая неназначенные символы)

• /\p{Assigned}/ - Назначенный символ

Значение Универсальной категории символа Юникода также может быть сопоставлено с помощью \p{Ab}, где Ab — сокращение категории, как описано ниже:

• /\p{L}/ - ‘Letter’

• /\p{Ll}/ - ‘Letter: Lowercase’

• /\p{Lm}/ - ‘Letter: Mark’

• /\p{Lo}/ - ‘Letter: Other’

• /\p{Lt}/ - ‘Letter: Titlecase’

• /\p{Lu}/ - ‘Letter: Uppercase

• /\p{Lo}/ - ‘Letter: Other’

• /\p{M}/ - ‘Mark’

• /\p{Mn}/ - ‘Mark: Nonspacing’

• /\p{Mc}/ - ‘Mark: Spacing Combining’

• /\p{Me}/ - ‘Mark: Enclosing’

• /\p{N}/ - ‘Number’

• /\p{Nd}/ - ‘Number: Decimal Digit’

• /\p{Nl}/ - ‘Number: Letter’

• /\p{No}/ - ‘Number: Other’

• /\p{P}/ - ‘Punctuation’

• /\p{Pc}/ - ‘Punctuation: Connector’

• /\p{Pd}/ - ‘Punctuation: Dash’

• /\p{Ps}/ - ‘Punctuation: Open’

• /\p{Pe}/ - ‘Punctuation: Close’

• /\p{Pi}/ - ‘Punctuation: Initial Quote’

• /\p{Pf}/ - ‘Punctuation: Final Quote’

• /\p{Po}/ - ‘Punctuation: Other’

• /\p{S}/ - ‘Symbol’

• /\p{Sm}/ - ‘Symbol: Math’

• /\p{Sc}/ - ‘Symbol: Currency’

• /\p{Sc}/ - ‘Symbol: Currency’

• /\p{Sk}/ - ‘Symbol: Modifier’

• /\p{So}/ - ‘Symbol: Other’

• /\p{Z}/ - ‘Separator’

• /\p{Zs}/ - ‘Separator: Space’

• /\p{Zl}/ - ‘Separator: Line’

• /\p{Zp}/ - ‘Separator: Paragraph’

• /\p{C}/ - ‘Other’

• /\p{Cc}/ - ‘Other: Control’

• /\p{Cf}/ - ‘Other: Format’

• /\p{Cn}/ - ‘Other: Not Assigned’

• /\p{Co}/ - ‘Other: Private Use’

• /\p{Cs}/ - ‘Other: Surrogate’

Наконец, \p{} соответствует Unicode-скрипту символа. Поддерживаются следующие скрипты: арабский, армянский, балийский, бенгальский, бопомофо, брайлевский, бугинский, бухидский, канадский_аборигенный, карийский, чамский, чероки, общий, коптский, клинопись, кипрский, кириллический, дезерет, деванагари, эфиопский, грузинский, глаголический, готический, греческий, гуджаратский, гурмухи, хань, хангыль, хануноо, еврейский, хирагана, унаследованный, каннада, катакана, каях_ли, харошты, кхмерский, лаосский, латинский, лепча, лимбу, линейный_b, ликийский, лидийский, малаялам, монгольский, бирманский, новый_тай_лю, нко, огам, ол_чики, древнеиталийский, древнеперсидский, ория, османский, пагс_па, финикийский, режанг, рунический, саураштра, шавийский, сингальский, сунданесский, силоти_нагри, сирийский, тагальский, тагбанва, тай_ле, тамильский, телугу, тана, тайский, тибетский, тифинаг, угаритский, вай и и.

Unicode-код U+06E9 называется «АРАБСКОЕ МЕСТО САЙДАХ» и относится к арабскому скрипту:

/\p{Arabic}/.match("\u06E9") #=> #<MatchData "\u06E9">

Все свойства символов можно инвертировать, добавив к их имени символ «карет» (^).

Буква «A» не входит в категорию Unicode Ll (Буква; строчная буква), поэтому этот соответствие успешно:

/\p{^Ll}/.match("A") #=> #<MatchData "A">

Якоря

Якоря — это метасимволы, которые соответствуют позициям нулевой ширины между символами, привязывая соответствие к определённой позиции.

• ^ — Соответствует началу строки

• $ — Соответствует концу строки

• \A — Соответствует началу строки.

• \Z — Соответствует концу строки. Если строка заканчивается символом новой строки, соответствует позиции перед символом новой строки

• \z — Соответствует концу строки

• \G — Соответствует первой позиции соответствия:

  В методах, таких как String#gsub и String#scan, меняется на каждой итерации. Изначально соответствует началу строки, а на каждой последующей итерации соответствует месту, где закончилось последнее соответствие.

  "    a b c".gsub(/ /, '_')    #=> "____a_b_c"
  "    a b c".gsub(/\G /, '_')  #=> "____a b c"
  

  В методах, таких как Regexp#match и String#match, которые принимают (необязательный) смещение, соответствует месту начала поиска.

  "hello, world".match(/,/, 3)    #=> #<MatchData ",">
  "hello, world".match(/\G,/, 3)  #=> nil
  

• \b — Соответствует границам слов вне скобок; пробел назад (0x08) внутри скобок

• \B — Соответствует границам неслов

• (?=pat) — Положительное утверждение оглядывания вперёд: гарантирует, что следующие символы соответствуют pat, но не включает эти символы в сопоставленный текст

• (?!pat) — Отрицательное утверждение оглядывания вперёд: гарантирует, что следующие символы не соответствуют pat, но не включает эти символы в сопоставленный текст

• (?<=pat) — Положительное утверждение оглядывания назад: гарантирует, что предыдущие символы соответствуют pat, но не включает эти символы в сопоставленный текст

• (?<!pat) — Отрицательное утверждение оглядывания назад: гарантирует, что предыдущие символы не соответствуют pat, но не включает эти символы в сопоставленный текст

• \K — Сброс соответствия: сопоставленный контент, предшествующий \K в регулярном выражении, исключается из результата. Например, следующие два регулярных выражения почти эквивалентны:

  /ab\Kc/ =~ "abc"     #=> 0
  /(?<=ab)c/ =~ "abc"  #=> 2
  

  Они соответствуют одной и той же строке, и $& равно "c", в то время как позиция соответствия отличается.

  Также как и следующие два регулярных выражения:

  /(a)\K(b)\Kc/
  /(?<=(?<=(a))(b))c/
  

Если шаблон не привязан, он может начинаться в любой точке строки:

/real/.match("surrealist") #=> #<MatchData "real">

Привязка шаблона к началу строки заставляет соответствие начинаться там. ‘real’ не встречается в начале строки, поэтому соответствие не удается:

/\Areal/.match("surrealist") #=> nil

Соответствие ниже не удается, потому что, хотя «Demand» содержит «and», шаблон не появляется на границе слова.

/\band/.match("Demand")

В то время как в следующем примере «and» привязано к границе неслова, поэтому вместо соответствия первому «and» оно соответствует с четвёртого символа «demand»:

/\Band.+/.match("Supply and demand curve") #=> #<MatchData "and curve">

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

/(?<=<b>)\w+(?=<\/b>)/.match("Fortune favours the <b>bold</b>")
    #=> #<MatchData "bold">

Параметры

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

• /pat/i — Игнорировать регистр

• /pat/m — Рассматривать новую строку как символ, сопоставленный с .

• /pat/x — Игнорировать пробелы и комментарии в шаблоне

• /pat/o — Выполнить интерполяцию #{} только один раз

i, m, и x также могут быть применены на уровне подвыражения с помощью конструкции (?on-off), которая включает параметры on и отключает параметры off для выражения, заключенного в скобки:

/a(?i:b)c/.match('aBc')   #=> #<MatchData "aBc">
/a(?-i:b)c/i.match('ABC') #=> nil

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

/a(?i)bc/.match('abC') #=> #<MatchData "abC">

Параметры также могут быть использованы с Regexp.new:

Regexp.new("abc", Regexp::IGNORECASE)                     #=> /abc/i
Regexp.new("abc", Regexp::MULTILINE)                      #=> /abc/m
Regexp.new("abc # Comment", Regexp::EXTENDED)             #=> /abc # Comment/x
Regexp.new("abc", Regexp::IGNORECASE | Regexp::MULTILINE) #=> /abc/mi

Regexp.new("abc", "i")           #=> /abc/i
Regexp.new("abc", "m")           #=> /abc/m
Regexp.new("abc # Comment", "x") #=> /abc # Comment/x
Regexp.new("abc", "im")          #=> /abc/mi

Режим свободного форматирования и комментарии

Как упоминалось выше, параметр x включает режим свободного форматирования. Литеральные пробелы внутри шаблона игнорируются, а символ octothorpe (#) вводит комментарий до конца строки. Это позволяет организовать компоненты шаблона потенциально более читаемым способом.

Выдуманный шаблон для сопоставления числа с необязательной десятичной частью:

float_pat = /\A
    [[:digit:]]+ # 1 or more digits before the decimal point
    (\.          # Decimal point
        [[:digit:]]+ # 1 or more digits after the decimal point
    )? # The decimal point and following digits are optional
\Z/x
float_pat.match('3.14') #=> #<MatchData "3.14" 1:".14">

Существует несколько стратегий для сопоставления пробелов:

• Используйте шаблон, например, \s или \p{Space}.

• Используйте экранированные пробелы, например, \ , т.е. пробел, предшествуемый обратным слэшем.

• Используйте класс символов, например, [ ].

Комментарии могут быть включены в шаблон, не являющийся x с помощью конструкции (?#comment), где comment — произвольный текст, игнорируемый движком регулярных выражений.

Комментарии в литералах регулярных выражений не могут содержать неэкранированные символы-разделители.

Encoding

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

• /pat/u — UTF-8

• /pat/e — EUC-JP

• /pat/s — Windows-31J

• /pat/n — ASCII-8BIT

Регулярное выражение может быть сопоставлено со строкой, когда они либо разделяют кодировку, либо кодировка регулярного выражения равна US-ASCII, а кодировка строки совместима с ASCII.

Если попытка соответствия между несовместимыми кодировками, генерируется исключение Encoding::CompatibilityError.

Предикат Regexp#fixed_encoding? указывает, имеет ли регулярное выражение фиксированную кодировку, то есть кодировку, несовместимую с ASCII. Кодировка регулярного выражения может быть явно установлена, задав Regexp::FIXEDENCODING в качестве второго аргумента Regexp.new:

r = Regexp.new("a".force_encoding("iso-8859-1"),Regexp::FIXEDENCODING)
r =~ "a\u3042"
   # raises Encoding::CompatibilityError: incompatible encoding regexp match
   #         (ISO-8859-1 regexp with UTF-8 string)

Глобальные переменные Regexp

Сопоставление шаблонов устанавливает некоторые глобальные переменные:

• $~ эквивалентно Regexp.last_match;

• $& содержит весь сопоставленный текст;

• $` содержит строку перед соответствием;

• $' содержит строку после соответствия;

• $1, $2 и т. д. содержат текст, соответствующий первой, второй и т. д. группе захвата;

• $+ содержит последнюю группу захвата.

Пример:

m = /s(\w{2}).*(c)/.match('haystack') #=> #<MatchData "stac" 1:"ta" 2:"c">
$~                                    #=> #<MatchData "stac" 1:"ta" 2:"c">
Regexp.last_match                     #=> #<MatchData "stac" 1:"ta" 2:"c">

$&      #=> "stac"
        # same as m[0]
$`      #=> "hay"
        # same as m.pre_match
$'      #=> "k"
        # same as m.post_match
$1      #=> "ta"
        # same as m[1]
$2      #=> "c"
        # same as m[2]
$3      #=> nil
        # no third group in pattern
$+      #=> "c"
        # same as m[-1]

Эти глобальные переменные являются локальными переменными потока и локальными переменными метода.

Производительность

Определённые патологические комбинации конструкций могут привести к катастрофически низкой производительности.

Рассмотрим строку из 25 a, d, 4 a и c.

s = 'a' * 25 + 'd' + 'a' * 4 + 'c'
#=> "aaaaaaaaaaaaaaaaaaaaaaaaadaaaac"

Следующие шаблоны сопоставляются мгновенно, как вы и ожидали:

/(b|a)/ =~ s #=> 0
/(b|a+)/ =~ s #=> 0
/(b|a+)*/ =~ s #=> 0

Однако, следующий шаблон сопоставляется значительно дольше:

/(b|a+)*c/ =~ s #=> 26

Это происходит потому, что атом в регулярном выражении квантифицируется как непосредственным +, так и охватывающим *, без чего-либо, что отличает, какой из них управляет любым конкретным символом. Возникающий недетерминизм приводит к производительности, зависящей от степени превышения линейной зависимости. (См. Mastering Regular Expressions (3-е изд.), стр. 222, авторы Jeffery Friedl, для глубокого анализа). Этот конкретный случай можно исправить, используя атомную группировку, которая предотвращает ненужное возвращение назад:

(start = Time.now) && /(b|a+)*c/ =~ s && (Time.now - start)
   #=> 24.702736882
(start = Time.now) && /(?>b|a+)*c/ =~ s && (Time.now - start)
   #=> 0.000166571

Похожий случай иллюстрируется следующим примером, который занимает примерно 60 секунд для выполнения у меня:

Сопоставить строку из 29 a со шаблоном из 29 необязательных a, после которых следуют 29 обязательных a:

Regexp.new('a?' * 29 + 'a' * 29) =~ 'a' * 29

29 необязательных a сопоставляются со строкой, но это препятствует сопоставлению последующих 29 обязательных a. Ruby должен многократно возвращаться назад, чтобы удовлетворить как можно больше совпадений с необязательными параметрами, сохраняя при этом совпадение с обязательными 29. Для нас очевидно, что ни одно из необязательных совпадений не может быть успешным, но этот факт к сожалению ускользает от Ruby.

Лучший способ повысить производительность — значительно уменьшить количество необходимых возвращений назад. В данном случае вместо индивидуального сопоставления 29 необязательных a, можно сопоставить диапазон необязательных a сразу с помощью a{0,29}:

Regexp.new('a{0,29}' + 'a' * 29) =~ 'a' * 29

Timeout

Существует два API для установки таймаута. Один из них — Regexp.timeout=, который представляет собой глобальную для процесса настройку таймаута для Regexp сопоставления.

Regexp.timeout = 3
s = 'a' * 25 + 'd' + 'a' * 4 + 'c'
/(b|a+)*c/ =~ s  #=> This raises an exception in three seconds

Другой — ключевое слово timeout в Regexp.new.

re = Regexp.new("(b|a+)*c", timeout: 3)
s = 'a' * 25 + 'd' + 'a' * 4 + 'c'
/(b|a+)*c/ =~ s  #=> This raises an exception in three seconds

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