класс Regexp

A Regexp содержит регулярное выражение, используемое для сопоставления шаблона со строками. Регулярные выражения создаются с помощью литералов /.../ и %r{...}, а также конструктора Regexp::new.

Регулярные выражения (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, поэтому она также совпадает с стог_сена.

=~ и #match

Сопоставление шаблонов можно выполнить, используя оператор =~ или метод #match.

=~ оператор

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

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

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

#match метод

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

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

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

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

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

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

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

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

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

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

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

/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_]). Обратите внимание на Bug #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]/

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">

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

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

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

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

Захват

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

‘at’ захватывается первой группой скобок, а затем ссылается на неё позже с \1:

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

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

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

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

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

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

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

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

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

/\$(?<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<name> соответствует предыдущему подвыражению с именем name, которое может быть именем группы или номером, ещё раз. Это отличается от обратных ссылок тем, что оно повторно выполняет группу, а не просто пытается повторно сопоставить тот же текст.

Этот шаблон соответствует символу ( и присваивает его группе 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{Graph}/ - Символ, не являющийся пробелом (исключая пробелы, управляющие символы и аналогичные)

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

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

• /\p{Punct}/ - Знак препинания

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

• /\p{Upper}/ - Символ заглавной буквы

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

• /\p{Word}/ - Член одной из следующих категорий Unicode: Letter, Mark, Number, Connector_Punctuation

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

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

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

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

И наконец, \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, но не включает эти символы в сопоставленный текст

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

/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">

Параметры

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

• /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/.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

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

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

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

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 — произвольный текст, игнорируемый движком regexp.

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

Кодировка

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

• /pat/u - UTF-8

• /pat/e - EUC-JP

• /pat/s - Windows-31J

• /pat/n - ASCII-8BIT

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

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

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

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

Специальные глобальные переменные

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

• $~ эквивалентно ::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

Это происходит потому, что атом в regexp квантифицируется как немедленным +, так и окружающим *, без чего-либо, что могло бы различать, какой из них управляет тем или иным символом. Возникающая неоднозначность приводит к сверхлинейной производительности. (Обратитесь к книге «Мастерство регулярных выражений» (3-е изд.), стр. 222, Джеффри Фридл, для углубленного анализа). Этот конкретный случай можно исправить, используя атомарные группировки, которые предотвращают ненужное возвращение назад:

(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