класс Regexp

Регулярное выражение (также называемое regexp) — это шаблон сопоставления (или просто шаблон).

Распространённая запись regexp использует ограничивающие символы косой черты:

/foo/

Regexp можно применить к целевой строке; часть строки (если она есть), соответствующая шаблону, называется совпадением, а про неё говорят, что она соответствует шаблону:

re = /red/
re.match?('redirect') # => true   # Match at beginning of target.
re.match?('bored')    # => true   # Match at end of target.
re.match?('credit')   # => true   # Match within target.
re.match?('foo')      # => false  # No match.

Применение Regexp

Regexp можно использовать:

• Для извлечения подстрок на основе заданного шаблона:

  re = /foo/              # => /foo/
  re.match('food')        # => #<MatchData "foo">
  re.match('good')        # => nil
  

  См. разделы Метод match и Оператор =~.

• Чтобы определить, соответствует ли строка заданному шаблону:

  re.match?('food') # => true
  re.match?('good') # => false
  

  См. раздел Метод match?.

• В качестве аргумента при вызовах некоторых методов других классов и модулей; большинство таких методов принимают аргумент, которым может быть строка или (гораздо более мощный) regexp.

  См. Методы Regexp.

Объекты Regexp

Объект regexp имеет:

• Исходное выражение; см. Исходные выражения.

• Несколько режимов; см. Режимы.

• Тайм-аут; см. Тайм-ауты.

• Кодировку; см. Кодировки.

Создание Regexp

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

• Литерала regexp с символами косой черты (см. Литералы Regexp):

  # This is a very common usage.
  /foo/ # => /foo/
  

• Литерала regexp %r (см. %r: литералы Regexp):

  # Same delimiter character at beginning and end;
  # useful for avoiding escaping characters
  %r/name\/value pair/ # => /name\/value pair/
  %r:name/value pair:  # => /name\/value pair/
  %r|name/value pair|  # => /name\/value pair/
  
  # Certain "paired" characters can be delimiters.
  %r[foo] # => /foo/
  %r{foo} # => /foo/
  %r(foo) # => /foo/
  %r<foo> # => /foo/
  

• Метода Regexp.new.

Метод match

Каждый из методов Regexp#match, String#match и Symbol#match возвращает объект MatchData, если совпадение найдено, и nil в противном случае; каждый из них также устанавливает глобальные переменные:

'food'.match(/foo/) # => #<MatchData "foo">
'food'.match(/bar/) # => nil

Оператор =~

Каждый из операторов Regexp#=~, String#=~ и Symbol#=~ возвращает целочисленное смещение, если совпадение найдено, и nil в противном случае; каждый из них также устанавливает глобальные переменные:

/bar/ =~ 'foo bar' # => 4
'foo bar' =~ /bar/ # => 4
/baz/ =~ 'foo bar' # => nil

Метод match?

Каждый из методов Regexp#match?, String#match? и Symbol#match? возвращает true, если совпадение найдено, и false в противном случае; ни один из них не устанавливает глобальные переменные:

'food'.match?(/foo/) # => true
'food'.match?(/bar/) # => false

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

Некоторые методы, связанные с regexp, присваивают значения глобальным переменным:

• match: см. Метод match.

• =~: см. Оператор =~.

Затрагиваемые глобальные переменные:

• $~: возвращает объект MatchData или nil.

• $&: возвращает совпавшую часть строки или nil.

• $`: возвращает часть строки слева от совпадения или nil.

• $': возвращает часть строки справа от совпадения или nil.

• $+: возвращает последнюю совпавшую группу или nil.

• $1, $2 и т. д.: возвращают первую, вторую и последующие совпавшие группы или nil. Обратите внимание, что $0 — совсем другое; она возвращает имя выполняемой программы.

Примеры:

# Matched string, but no matched groups.
'foo bar bar baz'.match('bar')
$~ # => #<MatchData "bar">
$& # => "bar"
$` # => "foo "
$' # => " bar baz"
$+ # => nil
$1 # => nil

# Matched groups.
/s(\w{2}).*(c)/.match('haystack')
$~ # => #<MatchData "stac" 1:"ta" 2:"c">
$& # => "stac"
$` # => "hay"
$' # => "k"
$+ # => "c"
$1 # => "ta"
$2 # => "c"
$3 # => nil

# No match.
'foo'.match('bar')
$~ # => nil
$& # => nil
$` # => nil
$' # => nil
$+ # => nil
$1 # => nil

Обратите внимание, что Regexp#match?, String#match? и Symbol#match? не устанавливают глобальные переменные.

Исходные выражения

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

re = /foo/              # => /foo/
re.match('food')        # => #<MatchData "foo">
re.match('good')        # => nil

Богатый набор доступных подвыражений наделяет regexp большой мощностью и гибкостью:

• Специальные символы

• Литералы исходных выражений

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

• Сокращённые классы символов

• Якоря

• Альтернация

• Квантификаторы

• Группы и захваты

• Юникод

• Выражения POSIX в квадратных скобках

• Комментарии

Специальные символы

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

. ? - + * ^ \ | $ ( ) [ ] { }

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

# Matches one or more 'o' characters.
/o+/.match('foo')  # => #<MatchData "oo">
# Would match 'o+'.
/o\+/.match('foo') # => nil

Чтобы сопоставить обратную косую черту буквально, экранируйте её обратной косой чертой:

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

Метод Regexp.escape возвращает экранированную строку:

Regexp.escape('.?-+*^\|$()[]{}')
# => "\\.\\?\\-\\+\\*\\^\\\\\\|\\$\\(\\)\\[\\]\\{\\}"

Литералы исходных выражений

Литерал исходного выражения во многом ведёт себя как строка в двойных кавычках; см. Строковые литералы в двойных кавычках.

В частности, литерал исходного выражения может содержать интерполированные выражения:

s = 'foo'         # => "foo"
/#{s}/            # => /foo/
/#{s.capitalize}/ # => /Foo/
/#{2 + 2}/        # => /4/

Между обычным строковым литералом и литералом исходного выражения есть различия; см. Сокращённые классы символов.

• \s в обычном строковом литерале эквивалентно пробелу; в литерале исходного выражения это сокращённая запись для сопоставления с пробельным символом.

• В обычном строковом литерале эти символы экранированы (без необходимости); в литерале исходного выражения они являются сокращёнными записями для сопоставления с различными символами:

  \w \W \d \D \h \H \S \R

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

Класс символов ограничивается квадратными скобками; он задаёт символы, которые могут совпасть в заданной позиции целевой строки:

# This character class will match any vowel.
re = /B[aeiou]rd/
re.match('Bird') # => #<MatchData "Bird">
re.match('Bard') # => #<MatchData "Bard">
re.match('Byrd') # => nil

Класс символов может содержать дефисы, задающие диапазоны символов:

# These regexps have the same effect.
/[abcdef]/.match('foo') # => #<MatchData "f">
/[a-f]/.match('foo')    # => #<MatchData "f">
/[a-cd-f]/.match('foo') # => #<MatchData "f">

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

/[^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]/

Сокращённые классы символов

Каждый из следующих метасимволов служит сокращённой записью класса символов:

• /./: соответствует любому символу, кроме символа новой строки:

  /./.match('foo') # => #<MatchData "f">
  /./.match("\n")  # => nil
  

• /./m: соответствует любому символу, включая символ новой строки; см. Многострочный режим:

  /./m.match("\n") # => #<MatchData "\n">
  

• /\w/: соответствует буквенно-цифровому символу: эквивалентно [a-zA-Z0-9_]:

  /\w/.match(' foo') # => #<MatchData "f">
  /\w/.match(' _')   # => #<MatchData "_">
  /\w/.match(' ')    # => nil
  

• /\W/: соответствует небуквенно-цифровому символу: эквивалентно [^a-zA-Z0-9_]:

  /\W/.match(' ') # => #<MatchData " ">
  /\W/.match('_') # => nil
  

• /\d/: соответствует цифре: эквивалентно [0-9]:

  /\d/.match('THX1138') # => #<MatchData "1">
  /\d/.match('foo')     # => nil
  

• /\D/: соответствует символу, не являющемуся цифрой: эквивалентно [^0-9]:

  /\D/.match('123Jump!') # => #<MatchData "J">
  /\D/.match('123')      # => nil
  

• /\h/: соответствует шестнадцатеричной цифре: эквивалентно [0-9a-fA-F]:

  /\h/.match('xyz fedcba9876543210') # => #<MatchData "f">
  /\h/.match('xyz')                  # => nil
  

• /\H/: соответствует символу, не являющемуся шестнадцатеричной цифрой: эквивалентно [^0-9a-fA-F]:

  /\H/.match('fedcba9876543210xyz') # => #<MatchData "x">
  /\H/.match('fedcba9876543210')    # => nil
  

• /\s/: соответствует пробельному символу: эквивалентно /[ \t\r\n\f\v]/:

  /\s/.match('foo bar') # => #<MatchData " ">
  /\s/.match('foo')     # => nil
  

• /\S/: соответствует непробельному символу: эквивалентно /[^ \t\r\n\f\v]/:

  /\S/.match(" \t\r\n\f\v foo") # => #<MatchData "f">
  /\S/.match(" \t\r\n\f\v")     # => nil
  

• /\R/: соответствует переводу строки независимо от платформы:

  /\R/.match("\r")     # => #<MatchData "\r">     # Carriage return (CR)
  /\R/.match("\n")     # => #<MatchData "\n">     # Newline (LF)
  /\R/.match("\f")     # => #<MatchData "\f">     # Formfeed (FF)
  /\R/.match("\v")     # => #<MatchData "\v">     # Vertical tab (VT)
  /\R/.match("\r\n")   # => #<MatchData "\r\n">   # CRLF
  /\R/.match("\u0085") # => #<MatchData "\u0085"> # Next line (NEL)
  /\R/.match("\u2028") # => #<MatchData "\u2028"> # Line separator (LSEP)
  /\R/.match("\u2029") # => #<MatchData "\u2029"> # Paragraph separator (PSEP)
  

Якоря

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

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

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

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

Якоря границ

Каждый из этих якорей соответствует границе:

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

  /^bar/.match("foo\nbar") # => #<MatchData "bar">
  /^ar/.match("foo\nbar")  # => nil
  

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

  /bar$/.match("foo\nbar") # => #<MatchData "bar">
  /ba$/.match("foo\nbar")  # => nil
  

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

  /\Afoo/.match('foo bar')  # => #<MatchData "foo">
  /\Afoo/.match(' foo bar') # => nil
  

• \Z: соответствует концу строки; если строка заканчивается одним символом новой строки, соответствует позиции перед этим завершающим символом новой строки:

  /foo\Z/.match('bar foo')     # => #<MatchData "foo">
  /foo\Z/.match('foo bar')     # => nil
  /foo\Z/.match("bar foo\n")   # => #<MatchData "foo">
  /foo\Z/.match("bar foo\n\n") # => nil
  

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

  /foo\z/.match('bar foo')   # => #<MatchData "foo">
  /foo\z/.match('foo bar')   # => nil
  /foo\z/.match("bar foo\n") # => nil
  

• \b: вне квадратных скобок соответствует границе слова; внутри скобок соответствует символу возврата на шаг ("0x08"):

  /foo\b/.match('foo bar') # => #<MatchData "foo">
  /foo\b/.match('foobar')  # => nil
  

• \B: соответствует позиции, не являющейся границей слова:

  /foo\B/.match('foobar')  # => #<MatchData "foo">
  /foo\B/.match('foo bar') # => nil
  

• \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
  

Якоря просмотра окрестности

Якоря просмотра вперёд:

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

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

Якоря просмотра назад:

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

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

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

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

Якорь сброса совпадения

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

  /ab\Kc/.match('abc')    # => #<MatchData "c">
  /(?<=ab)c/.match('abc') # => #<MatchData "c">
  

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

  То же относится к следующим двум regexp:

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

Альтернация

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

Две альтернативы:

re = /(a|b)/
re.match('foo') # => nil
re.match('bar') # => #<MatchData "b" 1:"b">

Четыре альтернативы:

re = /(a|b|c|d)/
re.match('shazam') # => #<MatchData "a" 1:"a">
re.match('cold')   # => #<MatchData "c" 1:"c">

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

re = /([a-c]|[x-z])/
re.match('bar') # => #<MatchData "b" 1:"b">
re.match('ooz') # => #<MatchData "z" 1:"z">

Метод Regexp.union предоставляет удобный способ создать regexp с альтернативами.

Квантификаторы

Простой regexp соответствует одному символу:

/\w/.match('Hello')  # => #<MatchData "H">

Добавленный квантификатор задаёт количество требуемых или допустимых совпадений:

• * — соответствует ноль или более раз:

  /\w*/.match('')
  # => #<MatchData "">
  /\w*/.match('x')
  # => #<MatchData "x">
  /\w*/.match('xyz')
  # => #<MatchData "yz">
  

• + — соответствует один или более раз:

  /\w+/.match('')    # => nil
  /\w+/.match('x')   # => #<MatchData "x">
  /\w+/.match('xyz') # => #<MatchData "xyz">
  

• ? — соответствует ноль или один раз:

  /\w?/.match('')    # => #<MatchData "">
  /\w?/.match('x')   # => #<MatchData "x">
  /\w?/.match('xyz') # => #<MatchData "x">
  

• {n} — соответствует ровно n раз:

  /\w{2}/.match('')    # => nil
  /\w{2}/.match('x')   # => nil
  /\w{2}/.match('xyz') # => #<MatchData "xy">
  

• {min,} — соответствует min или более раз:

  /\w{2,}/.match('')    # => nil
  /\w{2,}/.match('x')   # => nil
  /\w{2,}/.match('xy')  # => #<MatchData "xy">
  /\w{2,}/.match('xyz') # => #<MatchData "xyz">
  

• {,max} — соответствует max раз или менее:

  /\w{,2}/.match('')    # => #<MatchData "">
  /\w{,2}/.match('x')   # => #<MatchData "x">
  /\w{,2}/.match('xyz') # => #<MatchData "xy">
  

• {min,max} — соответствует не менее min и не более max раз:

  /\w{1,2}/.match('')    # => nil
  /\w{1,2}/.match('x')   # => #<MatchData "x">
  /\w{1,2}/.match('xyz') # => #<MatchData "xy">
  

Жадное, ленивое и притяжательное сопоставление

Сопоставление с квантификатором может быть жадным, ленивым или притяжательным:

• При жадном сопоставлении совпадает максимально возможное число повторений, при котором общее совпадение всё ещё успешно. Жадные квантификаторы: *, +, ?, {min, max} и их варианты.

• При ленивом сопоставлении совпадает минимально необходимое число повторений. Ленивые квантификаторы: *?, +?, ??, {min, max}? и их варианты.

• При притяжательном сопоставлении после обнаружения совпадения возврат не выполняется; совпадение сохраняется, даже если это мешает успешному сопоставлению всего шаблона. Притяжательные квантификаторы: *+, ++, ?+. Обратите внимание, что {min, max} и его варианты не поддерживают притяжательное сопоставление.

Дополнительные сведения:

• О жадном и ленивом сопоставлении см. Выбор минимального или максимального числа повторений.

• О притяжательном сопоставлении см. Устранение ненужного возврата.

Группы и захваты

Простой regexp имеет (не более) одного совпадения:

re = /\d\d\d\d-\d\d-\d\d/
re.match('1943-02-04')      # => #<MatchData "1943-02-04">
re.match('1943-02-04').size # => 1
re.match('foo')             # => nil

Добавление одной или нескольких пар скобок (subexpression) задаёт группы, что может привести к появлению нескольких совпавших подстрок, называемых захватами:

re = /(\d\d\d\d)-(\d\d)-(\d\d)/
re.match('1943-02-04')      # => #<MatchData "1943-02-04" 1:"1943" 2:"02" 3:"04">
re.match('1943-02-04').size # => 4

Первый захват — это вся совпавшая строка; остальные захваты — это совпавшие подстроки из групп.

У группы может быть квантификатор:

re = /July 4(th)?/
re.match('July 4')   # => #<MatchData "July 4" 1:nil>
re.match('July 4th') # => #<MatchData "July 4th" 1:"th">

re = /(foo)*/
re.match('')       # => #<MatchData "" 1:nil>
re.match('foo')    # => #<MatchData "foo" 1:"foo">
re.match('foofoo') # => #<MatchData "foofoo" 1:"foo">

re = /(foo)+/
re.match('')       # => nil
re.match('foo')    # => #<MatchData "foo" 1:"foo">
re.match('foofoo') # => #<MatchData "foofoo" 1:"foo">

Объект MatchData предоставляет доступ к совпавшим подстрокам:

re = /(\d\d\d\d)-(\d\d)-(\d\d)/
md = re.match('1943-02-04')
# => #<MatchData "1943-02-04" 1:"1943" 2:"02" 3:"04">
md[0] # => "1943-02-04"
md[1] # => "1943"
md[2] # => "02"
md[3] # => "04"

Незахватывающие группы

Группу можно сделать незахватывающей; она остаётся группой (и, например, может иметь квантификатор), но её совпавшая подстрока не включается в захваты.

Незахватывающая группа начинается с ?: (внутри скобок):

# Don't capture the year.
re = /(?:\d\d\d\d)-(\d\d)-(\d\d)/
md = re.match('1943-02-04') # => #<MatchData "1943-02-04" 1:"02" 2:"04">

Обратные ссылки

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

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

В этой таблице показано, как каждое подвыражение приведённого выше regexp соответствует подстроке целевой строки:

| Subexpression in Regexp   | Matching Substring in Target String |
|---------------------------|-------------------------------------|
|       First '[csh]'       |            Character 'c'            |
|          '(..)'           |        First substring 'at'         |
|      First space ' '      |      First space character ' '      |
|       Second '[csh]'      |            Character 's'            |
| '\1' (backreference 'at') |        Second substring 'at'        |
|           ' in'           |            Substring ' in'          |

Regexp может содержать любое количество групп:

• Для большого числа групп:

  • Обычная запись \n применяется только для n в диапазоне (1..9).

  • Запись MatchData[n] применяется для любого неотрицательного n.

• \0 — специальная обратная ссылка на всю совпавшую строку; её нельзя использовать внутри самого regexp, но можно использовать за его пределами (например, при вызове метода подстановки):

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

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

Как было показано выше, на захват можно сослаться по его номеру. Захвату также можно присвоить имя, добавив префикс ?<name> или ?'name'; это имя (в виде символа) можно использовать как индекс в MatchData[]:

md = /\$(?<dollars>\d+)\.(?'cents'\d+)/.match("$3.67")
# => #<MatchData "$3.67" dollars:"3" cents:"67">
md[:dollars]  # => "3"
md[:cents]    # => "67"
# The capture numbers are still valid.
md[2]         # => "67"

Если regexp содержит именованный захват, безымянных захватов нет:

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

На именованную группу можно сослаться как \k<name>:

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

Если (и только если) regexp содержит группы с именованными захватами и расположен перед оператором =~, захваченные подстроки присваиваются локальным переменным с соответствующими именами:

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

Метод Regexp#named_captures возвращает хеш имён захватов и подстрок; метод Regexp#names возвращает массив имён захватов.

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

Группу можно сделать атомарной с помощью (?>подвыражения).

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

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

Пример без атомарной группировки:

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

Разбор:

1. Начальное подвыражение " в шаблоне соответствует первому символу " целевой строки.

2. Следующее подвыражение .* соответствует следующей подстроке Quote“ (включая завершающую двойную кавычку).

3. Теперь в целевой строке не осталось символов, соответствующих завершающему подвыражению " в шаблоне; из-за этого общее совпадение не будет найдено.

4. Выполняется возврат на одну позицию в совпавшей подстроке: Quote.

5. Теперь последнее подвыражение " соответствует последней подстроке ", и общее совпадение успешно.

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

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

Атомарная группировка может влиять на производительность; см. Атомарная группа.

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

Как было показано выше, обратная ссылка по номеру (\n) или имени (\k<name>) предоставляет доступ к захваченной подстроке; к соответствующему подвыражению regexp также можно обратиться по номеру (\gn) или имени (\g<name>):

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

Шаблон:

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

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

3. Соответствует первому символу строки, '('.

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

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

6. Соответствует второму символу строки, '('.

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

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

9. Соответствует четвёртому символу строки, ')'.

10. Соответствует концу строки.

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

Условные конструкции

Условная конструкция имеет вид (?(cond)yes|no), где:

• cond может быть номером или именем захвата.

• Если cond захвачен, применяется совпадение yes; в противном случае применяется совпадение no.

• Если не требуется, |no можно опустить.

Примеры:

re = /\A(foo)?(?(1)(T)|(F))\z/
re.match('fooT') # => #<MatchData "fooT" 1:"foo" 2:"T" 3:nil>
re.match('F')    # => #<MatchData "F" 1:nil 2:nil 3:"F">
re.match('fooF') # => nil
re.match('T')    # => nil

re = /\A(?<xyzzy>foo)?(?(<xyzzy>)(T)|(F))\z/
re.match('fooT') # => #<MatchData "fooT" xyzzy:"foo">
re.match('F')    # => #<MatchData "F" xyzzy:nil>
re.match('fooF') # => nil
re.match('T')    # => nil

Оператор отсутствия

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

/(?~real)/.match('surrealist') # => #<MatchData "surrea">
/(?~real)ist/.match('surrealist') # => #<MatchData "ealist">
/sur(?~real)ist/.match('surrealist') # => nil

Юникод

Свойства Юникода

Конструкция /\p{property_name}/ (со строчной буквой p) сопоставляет символы по имени свойства Юникода, подобно классу символов; свойство Alpha задаёт буквенные символы:

/\p{Alpha}/.match('a') # => #<MatchData "a">
/\p{Alpha}/.match('1') # => nil

Свойство можно инвертировать, добавив перед его именем символ циркумфлекса (^):

/\p{^Alpha}/.match('1') # => #<MatchData "1">
/\p{^Alpha}/.match('a') # => nil

Или используя \P (заглавную букву P):

/\P{Alpha}/.match('1') # => #<MatchData "1">
/\P{Alpha}/.match('a') # => nil

См. Свойства Юникода, чтобы узнать о regexp на основе многочисленных свойств.

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

• /\p{Alnum}/: буквенный или числовой символ

• /\p{Alpha}/: буквенный символ

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

• /\p{Cntrl}/: управляющий символ

• /\p{Digit}/: цифры и подобные символы)

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

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

• /\p{Punct}/: знак пунктуации

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

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

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

Также часто используются следующие свойства:

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

• /\p{Graph}/: символы, за исключением /\p{Cntrl}/ и /\p{Space}/. Обратите внимание, что невидимые символы категории Юникода «Формат» включены.

• /\p{Word}/: символ, принадлежащий одной из следующих категорий Юникода (см. ниже) или имеющий одно из следующих свойств Юникода:

  • Категории Юникода:

    • Mark (M).

    • Decimal Number (Nd)

    • Connector Punctuation (Pc).

  • Свойства Юникода:

    • Alpha

    • Join_Control

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

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

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

Категории символов Юникода

Имя категории символов Юникода:

• Может быть полным или сокращённым.

• Не зависит от регистра.

• Считает пробел, дефис и символ подчёркивания эквивалентными.

Примеры:

/\p{lu}/                # => /\p{lu}/
/\p{LU}/                # => /\p{LU}/
/\p{Uppercase Letter}/  # => /\p{Uppercase Letter}/
/\p{Uppercase_Letter}/  # => /\p{Uppercase_Letter}/
/\p{UPPERCASE-LETTER}/  # => /\p{UPPERCASE-LETTER}/

Ниже приведены сокращения и названия категорий символов Юникода. Списки символов каждой категории доступны по ссылкам.

Буквы:

• L, Letter: LC, Lm или Lo.

• LC, Cased_Letter: Ll, Lt или Lu.

• Lu, Строчная_буква.

• Lu, Буква-модификатор.

• Lu, Другая_буква.

• Lu, Прописная_буква.

• Lu, Заглавная_буква.

Знаки:

• M, Mark: Mc, Me или Mn.

• Mc, Интервальный_знак.

• Me, Обрамляющий_знак.

• Mn, Непробельный_знак.

Числа:

• N, Number: Nd, Nl или No.

• Nd, Десятичное_число.

• Nl, Число-буква.

• No, Другое_число.

Пунктуация:

• P, Punctuation: Pc, Pd, Pe, Pf, Pi, Po или Ps.

• Pc, Connector_Punctuation.

• Pd, Dash_Punctuation.

• Pe, Close_Punctuation.

• Pf, Final_Punctuation.

• Pi, Initial_Punctuation.

• Po, Other_Punctuation.

• Ps, Open_Punctuation.

• S, Symbol: Sc, Sk, Sm или So.

• Sc, Currency_Symbol.

• Sk, Modifier_Symbol.

• Sm, Math_Symbol.

• So, Other_Symbol.

• Z, Separator: Zl, Zp или Zs.

• Zl, Line_Separator.

• Zp, Paragraph_Separator.

• Zs, Space_Separator.

• C, Other: Cc, Cf, Cn, Co или Cs.

• Cc, Control.

• Cf, Format.

• Cn, Unassigned.

• Co, Private_Use.

• Cs, Surrogate.

Скрипты и блоки Unicode

К свойствам Unicode относятся:

• скрипты Unicode; см. поддерживаемые скрипты.

• блоки Unicode; см. поддерживаемые блоки.

Выражения POSIX в квадратных скобках

Выражение в квадратных скобках POSIX также похоже на класс символов. Эти выражения представляют собой переносимую альтернативу описанным выше и дополнительно охватывают символы, отличные от ASCII:

• /\d/ соответствует только десятичным цифрам ASCII от 0 до 9.

• /[[:digit:]]/ соответствует любому символу категории Unicode Decimal Number (Nd); см. ниже.

Выражения POSIX в квадратных скобках:

• /[[:digit:]]/: соответствует цифре Unicode:

  /[[:digit:]]/.match('9')       # => #<MatchData "9">
  /[[:digit:]]/.match("\u1fbf9") # => #<MatchData "9">
  

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

• /[[:upper:]]/: соответствует заглавной букве Unicode:

  /[[:upper:]]/.match('A')      # => #<MatchData "A">
  /[[:upper:]]/.match("\u00c6") # => #<MatchData "Æ">
  

• /[[:lower:]]/: соответствует строчной букве Unicode:

  /[[:lower:]]/.match('a')      # => #<MatchData "a">
  /[[:lower:]]/.match("\u01fd") # => #<MatchData "ǽ">
  

• /[[:alpha:]]/: соответствует /[[:upper:]]/ или /[[:lower:]]/.

• /[[:alnum:]]/: соответствует /[[:alpha:]]/ или /[[:digit:]]/.

• /[[:space:]]/: соответствует пробельному символу Unicode:

  /[[:space:]]/.match(' ')      # => #<MatchData " ">
  /[[:space:]]/.match("\u2005") # => #<MatchData " ">
  

• /[[:blank:]]/: соответствует /[[:space:]]/ или символу табуляции:

  /[[:blank:]]/.match(' ')      # => #<MatchData " ">
  /[[:blank:]]/.match("\u2005") # => #<MatchData " ">
  /[[:blank:]]/.match("\t")     # => #<MatchData "\t">
  

• /[[:cntrl:]]/: соответствует управляющему символу Unicode:

  /[[:cntrl:]]/.match("\u0000") # => #<MatchData "\u0000">
  /[[:cntrl:]]/.match("\u009f") # => #<MatchData "\u009F">
  

• /[[:graph:]]/: соответствует любому символу, кроме /[[:space:]]/ или /[[:cntrl:]]/.

• /[[:print:]]/: соответствует /[[:graph:]]/ или пробелу.

• /[[:punct:]]/: соответствует любому символу (знак пунктуации Unicode}[www.compart.com/en/unicode/category/Po]:

Ruby также поддерживает следующие выражения в квадратных скобках (не относящиеся к POSIX):

• /[[:ascii:]]/: соответствует символу из набора символов ASCII.

• /[[:word:]]/: соответствует символу одной из следующих категорий символов Unicode или обладающему одним из следующих свойств Unicode:

  • Категории Unicode:

    • Mark (M).

    • Decimal Number (Nd)

    • Connector Punctuation (Pc).

  • Свойства Unicode:

    • Alpha

    • Join_Control

Комментарии

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

/foo(?#Ignore me)bar/.match('foobar') # => #<MatchData "foobar">

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

См. также Расширенный режим.

Режимы

Каждый из этих модификаторов задаёт режим регулярного выражения:

• i: /pattern/i включает режим без учёта регистра.

• m: /pattern/m включает многострочный режим.

• x: /pattern/x включает расширенный режим.

• o: /pattern/o включает режим интерполяции.

Можно применить любой из этих модификаторов, все или ни одного.

Модификаторы i, m и x можно применять к подвыражениям:

• (?modifier) включает режим для последующих подвыражений

• (?-modifier) отключает режим для последующих подвыражений

• (?modifier:subexp) включает режим для subexp внутри группы

• (?-modifier:subexp) отключает режим для subexp внутри группы

Пример:

re = /(?i)te(?-i)st/
re.match('test') # => #<MatchData "test">
re.match('TEst') # => #<MatchData "TEst">
re.match('TEST') # => nil
re.match('teST') # => nil

re = /t(?i:e)st/
re.match('test') # => #<MatchData "test">
re.match('tEst') # => #<MatchData "tEst">
re.match('tEST') # => nil

Метод Regexp#options возвращает целое число, значение которого показывает настройки режима без учёта регистра, многострочного режима и расширенного режима.

Режим без учёта регистра

По умолчанию регулярное выражение чувствительно к регистру:

/foo/.match('FOO')  # => nil

Модификатор i включает режим без учёта регистра:

/foo/i.match('FOO')
# => #<MatchData "FOO">

Метод Regexp#casefold? возвращает значение, указывающее, включён ли режим без учёта регистра.

Многострочный режим

Многострочный режим в Ruby — это то, что обычно называют режимом «точка соответствует всему»:

• Без модификатора m подвыражение . не соответствует символам новой строки:

  /a.c/.match("a\nc")  # => nil
  

• С модификатором оно им соответствует:

  /a.c/m.match("a\nc") # => #<MatchData "a\nc">
  

В отличие от других языков, модификатор m не влияет на якоря ^ и $. В Ruby эти якоря всегда соответствуют границам строк.

Расширенный режим

Модификатор x включает расширенный режим, в котором:

• Пробельные символы, буквально указанные в шаблоне, игнорируются.

• Символ # помечает оставшуюся часть строки, в которой он находится, как комментарий; она также игнорируется при поиске совпадений.

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

Regexp без расширенного режима (соответствует некоторым римским цифрам):

pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'
re = /#{pattern}/
re.match('MCMXLIII') # => #<MatchData "MCMXLIII" 1:"CM" 2:"XL" 3:"III">

Regexp в расширенном режиме:

pattern = <<-EOT
  ^                   # beginning of string
  M{0,3}              # thousands - 0 to 3 Ms
  (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
                      #            or 500-800 (D, followed by 0 to 3 Cs)
  (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs),
                      #        or 50-80 (L, followed by 0 to 3 Xs)
  (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
                      #        or 5-8 (V, followed by 0 to 3 Is)
  $                   # end of string
EOT
re = /#{pattern}/x
re.match('MCMXLIII') # => #<MatchData "MCMXLIII" 1:"CM" 2:"XL" 3:"III">

Режим интерполяции

Модификатор o означает, что при первом обнаружении литерала регулярного выражения с интерполяциями созданный объект Regexp сохраняется и используется при всех последующих вычислениях этого литерала. Без модификатора o созданный объект Regexp не сохраняется, поэтому при каждом вычислении литерала регулярного выражения создаётся новый объект Regexp.

Без модификатора o:

def letters; sleep 5; /[A-Z][a-z]/; end
words = %w[abc def xyz]
start = Time.now
words.each {|word| word.match(/\A[#{letters}]+\z/) }
Time.now - start # => 15.0174892

С модификатором o:

start = Time.now
words.each {|word| word.match(/\A[#{letters}]+\z/o) }
Time.now - start # => 5.0010866

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

Кодировки

По умолчанию регулярное выражение, содержащее только символы US-ASCII, имеет кодировку US-ASCII:

re = /foo/
re.source.encoding # => #<Encoding:US-ASCII>
re.encoding        # => #<Encoding:US-ASCII>

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

• /pat/n: US-ASCII, если содержит только символы US-ASCII, в противном случае ASCII-8BIT:

  /foo/n.encoding     # => #<Encoding:US-ASCII>
  /foo\xff/n.encoding # => #<Encoding:ASCII-8BIT>
  /foo\x7f/n.encoding # => #<Encoding:US-ASCII>
  

• /pat/u: UTF-8

  /foo/u.encoding # => #<Encoding:UTF-8>
  

• /pat/e: EUC-JP

  /foo/e.encoding # => #<Encoding:EUC-JP>
  

• /pat/s: Windows-31J

  /foo/s.encoding # => #<Encoding:Windows-31J>
  

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

• У них одинаковая кодировка.

• Кодировка регулярного выражения является фиксированной, а строка содержит только символы ASCII. Метод Regexp#fixed_encoding? возвращает значение, указывающее, имеет ли регулярное выражение фиксированную кодировку.

При попытке сопоставить несовместимые кодировки возникает исключение Encoding::CompatibilityError.

Пример:

re = eval("# encoding: ISO-8859-1\n/foo\\xff?/")
re.encoding                 # => #<Encoding:ISO-8859-1>
re =~ "foo".encode("UTF-8") # => 0
re =~ "foo\u0100"           # Raises Encoding::CompatibilityError

Кодировку можно явно зафиксировать, указав Regexp::FIXEDENCODING во втором аргументе метода Regexp.new:

# Regexp with encoding ISO-8859-1.
re = Regexp.new("a".force_encoding('iso-8859-1'), Regexp::FIXEDENCODING)
re.encoding  # => #<Encoding:ISO-8859-1>
# Target string with encoding UTF-8.
s = "a\u3042"
s.encoding   # => #<Encoding:UTF-8>
re.match(s)  # Raises Encoding::CompatibilityError.

Тайм-ауты

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

У Regexp есть два значения тайм-аута:

• Тайм-аут класса по умолчанию, используемый для регулярного выражения, тайм-аут экземпляра которого равен nil; изначально он равен nil, и его можно установить методом Regexp.timeout=:

  Regexp.timeout # => nil
  Regexp.timeout = 3.0
  Regexp.timeout # => 3.0
  

• Тайм-аут экземпляра, значение которого по умолчанию равно nil и которое можно установить в Regexp.new:

  re = Regexp.new('foo', timeout: 5.0)
  re.timeout # => 5.0
  

Если regexp.timeout равен nil, тайм-аут «передаётся дальше» в Regexp.timeout; если regexp.timeout не равен nil, именно это значение определяет срабатывание тайм-аута:

| regexp.timeout Value | Regexp.timeout Value |            Result           |
|----------------------|----------------------|-----------------------------|
|         nil          |          nil         |       Never times out.      |
|         nil          |         Float        | Times out in Float seconds. |
|        Float         |          Any         | Times out in Float seconds. |

Оптимизация

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

Для защиты от атак ReDoS при сопоставлении регулярных выражений может применяться оптимизация. При её использовании время сопоставления растёт линейно (а не полиномиально или экспоненциально) относительно размера входных данных, поэтому атака ReDoS невозможна.

Эта оптимизация применяется, если шаблон соответствует следующим критериям:

• Нет обратных ссылок.

• Нет вызовов подвыражений.

• Нет вложенных якорей просмотра вперёд или назад и атомарных групп.

• Нет вложенных квантификаторов с подсчётом (то есть вложенных квантификаторов в стиле {n}, {min,}, {,max} или {min,max})

Можно использовать метод Regexp.linear_time?, чтобы определить, соответствует ли шаблон этим критериям:

Regexp.linear_time?(/a*/)     # => true
Regexp.linear_time?('a*')     # => true
Regexp.linear_time?(/(a*)\1/) # => false

Однако источник может быть ненадёжным, даже если метод возвращает true, поскольку оптимизация использует мемоизацию (которая может потребовать большого объёма памяти).

Ссылки

Читайте (электронные PDF-книги):

• Искусство регулярных выражений, автор Джеффри Э. Ф. Фридл.

• Сборник рецептов по регулярным выражениям, авторы Ян Гойвартс и Стивен Левитан.

Изучайте и тестируйте (интерактивный онлайн-редактор):

• Rubular.