класс 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 - Совпадение с точкой, где закончилось последнее совпадение

• \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 квантифицируется как непосредственным +, так и окружающим *, не имея ничего, что бы различало, что контролирует тот или иной символ. Возникающий недетерминизм приводит к производительности, зависящей от квадрата времени. (См. 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