Ruby正则表达式多次重复捕获

Question

I'm trying to parse a subset of a webpage with regex for just fun. It was fun till I encountered with the following problem. I have a paragraph like below;

foo: 1, 2, 3, 4 and 5.
bar: 1, 2 and 3.

What I am trying to do is, get the numbers in the first line of the paragraph starting with foo: by applying following regex:

foo:(?:\s(\d)(?:,|\sand|\.))+

This matches with the above string but it captures only the last occurrence of the capture group which is 5 .

How can I capture all the numbers in a paragraph starting with foo: till the first occurrence of . using single regex pattern.

Answer 1

Repeating capturing group's data aren't stored separately in most programming languages, hence you can't refer to them individually. This is a valid reason to use \\G anchor. \\G causes a match to start from where previous match ended or it will match beginning of string as same as \\A .

So we are in need of its first capability:

(?:foo:|\G(?!\A))\s*(\d+)\s*(?:,|and)?

Breakdown:

• (?: Start a non-capturing group
  • foo: Match foo:
  • | Or
  • \\G(?!\\A) Continue match from where previous match ends
• ) End of NCG
• \\s* Any number of whitespace characters
• (\\d+) Match and capture digits
• \\s* Any number of whitespae characters
• (?:,|and)? Optional , or and

This regex will begin a match on meeting foo in input string. Then tries to find a following digit that precedes a comma or and (whitespaces are allowed around digits).

\\K token will reset match. It means it will send a signal to engine to forget whatever is matched so far (but keep whatever is captured) and then leaves cursor right at that position.

I used \\K in Rubular regex to make result set not to have matched strings but captured digits. However Rubular seems to work differently and didn't need \\K . It's not a must at all.

Answer 2

This answer uses just one regex, but admittedly does a bit of pre- and post-processing. (Please allow me a bit of fun. I do think there may be some instructional value here.)

str = "foo: 1, 2, 34, 4 and 5. and 6."

r = /
    \d+             # match one or more digits
    (?=[^.]+:oof\z) # match one or more digits other than a period, followed
                    # by ":oof" at the end of the string, in a positive lookahead
    /x              # free-spacing regex definition mode

str.reverse.scan(r).join(' ').reverse.split
  #=> ["1", "2", "34", "4", "5"]

The steps are as follows.

s = str.reverse
  #=> ".6 dna .5 dna 4 ,43 ,2 ,1 :oof"
a  = s.scan r
  #=> ["5", "4", "43", "2", "1"]
b  = a.join(' ')
  #=> "5 4 43 2 1"
c  = b.reverse
  #=> "1 2 34 4 5"
c.split
  #=> ["1", "2", "34", "4", "5"]

An empty array is returned if there is no match.

So, why all the reversing? It's to allow me to use a positive lookahead , which, unlike a positive lookbehind , permits variable-length matches.