класс 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: Литералы 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 большую мощность и гибкость:

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

• Литералы источника

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

• Кратко обозначенные классы символов

• Якоря

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

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

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

• Unicode

• POSIX скобочные выражения

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

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

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

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

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

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

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

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

Method 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 в регулярном выражении, исключается из результата. Например, следующие два регулярных выражения почти эквивалентны:

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

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

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

  /(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 предоставляет удобный способ построения регулярного выражения с альтернативами.

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

Простое регулярное выражение сопоставляет один символ:

/\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} и его варианты не поддерживают притяжательное сопоставление.

Подробнее:

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

• О притяжательном поиске см. Исключить ненужный откат.

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

Простое регулярное выражение имеет (как максимум) одно совпадение:

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

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

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

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

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

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

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

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

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

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

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

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

Когда регулярное выражение содержит именованные захваты, безымянных захватов нет:

/\$(?<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">

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

/\$(?<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 может быть номером или именем захвата.

• Применяемое совпадение — yes, если cond захвачен; в противном случае применяется совпадение — 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

Unicode

Свойства Unicode

Конструкт /\p{property_name}/ (с маленькими p ) соответствует символам с использованием имени свойства Unicode, очень похоже на класс символов; свойство 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

См. Свойства Unicode для regexps, основанных на многочисленных свойствах.

Некоторые часто используемые свойства соответствуют выражениям 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}/: Эмодзи Unicode.

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

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

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

    • Mark (M).

    • Decimal Number (Nd)

    • Connector Punctuation (Pc).

  • Свойства Unicode:

    • Alpha

    • Join_Control

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

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

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

Категории символов Unicode

Имя категории символа Unicode:

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

• Регистронезависимо.

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

Примеры:

/\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}/

Ниже приведены сокращения и имена категорий символов Unicode. Перечисления символов в каждой категории находятся по ссылкам.

Буквы:

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

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

• Lu, Lowercase_Letter.

• Lu, Modifier_Letter.

• Lu, Other_Letter.

• Lu, Titlecase_Letter.

• Lu, Uppercase_Letter.

Знаки:

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

• Mc, Spacing_Mark.

• Me, Enclosing_Mark.

• Mn, Nonapacing_Mark.

Цифры:

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

• Nd, Decimal_Number.

• Nl, Letter_Number.

• No, Other_Number.

Пунктуация:

• 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:]]/: Соответствует числу Юникода:

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

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

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

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

• /[[:lower:]]/: Соответствует строчной букве Юникода:

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

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

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

• /[[:space:]]/: Соответствует пробельному символу Юникода:

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

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

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

• /[[:cntrl:]]/: Соответствует управляющему символу Юникода:

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

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

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

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

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

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

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

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

    • Mark (M).

    • Decimal Number (Nd)

    • Connector Punctuation (Pc).

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

    • Alpha

    • Join_Control

Комментарии

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

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

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

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

Режимы

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

• 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 возвращает целое число, значение которого показывает настройки для регистронезависимого режима, многострочного режима и расширенного режима.

Регистронезависимый режим

По умолчанию, regexp чувствителен к регистру:

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

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 с интерполяциями, сгенерированный объект Regexp сохраняется и используется для всех последующих вычислений этого литерального regexp. Без модификатора o, сгенерированный объект Regexp не сохраняется, поэтому каждое вычисление литерального 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

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

Кодировки

По умолчанию, regexp только с символами 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>
  

Regexp может быть сопоставлен с целевой строкой, если:

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

• Кодировка regexp — это фиксированная кодировка, а строка содержит только символы ASCII. Method Regexp#fixed_encoding? возвращает, имеет ли regexp фиксированную кодировку.

Если выполняется попытка сопоставления между несовместимыми кодировками, возникает исключение 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 или целевая строка получены из ненадежного источника, вредоносные значения могут стать атакой на отказ в обслуживании; чтобы предотвратить такую атаку, рекомендуется установить таймаут.

Regexp имеет два значения таймаута:

• По умолчанию таймаут класса, используемый для 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).

Сопоставление regexp может применять оптимизацию для предотвращения атак 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 книги):

• Mastering Regular Expressions Джеффри Э.Ф. Фридла.

• Regular Expressions Cookbook Яна Гойвертса и Стивена Левитана.

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

• Rubular.