Capturing Quantifiers and Quantifier Arithmetic

by

I don’t know a regex engine that can capture a quantifier. However, it is possible with PCRE or Perl to use some tricks to check if you have the same number of characters. With your example:

@@@@ "Star Wars" ==== "1977" ---- "Science Fiction" //// "George Lucas"

you can check if @ = - / are balanced with this pattern that uses the famous Qtax trick, (are you ready?): the “possessive-optional self-referencing group”

~(?<!@)((?:@(?=[^=]*(\2?+=)[^-]*(\3?+-)[^/]*(\4?+/)))+)(?!@)(?=[^=]*\2(?!=)[^-]*\3(?!-)[^/]*\4(?!/))~

pattern details:

~                          # pattern delimiter
(?<!@)                     # negative lookbehind used as an @ boundary
(                          # first capturing group for the @
    (?:
        @                  # one @
        (?=                # checks that each @ is followed by the same number
                           # of = - /  
            [^=]*          # all that is not an =
            (\2?+=)        # The possessive optional self-referencing group:
                           # capture group 2: backreference to itself + one = 
            [^-]*(\3?+-)   # the same for -
            [^/]*(\4?+/)   # the same for /
        )                  # close the lookahead
    )+                     # close the non-capturing group and repeat
)                          # close the first capturing group
(?!@)                      # negative lookahead used as an @ boundary too.

# this checks the boundaries for all groups
(?=[^=]*\2(?!=)[^-]*\3(?!-)[^/]*\4(?!/))
~

The main idea

The non-capturing group contains only one @. Each time this group is repeated a new character is added in capture groups 2, 3 and 4.

the possessive-optional self-referencing group

How does it work?

( (?: @ (?= [^=]* (\2?+ = ) .....) )+ )

At the first occurence of the @ character the capture group 2 is not yet defined, so you can not write something like that (\2 =) that will make the pattern fail. To avoid the problem, the way is to make the backreference optional: \2?

The second aspect of this group is that the number of character = matched is incremented at each repetition of the non capturing group, since an = is added each time. To ensure that this number always increases (or the pattern fails), the possessive quantifier forces the backreference to be matched first before adding a new = character.

Note that this group can be seen like that: if group 2 exists then match it with the next =

( (?(2)\2) = )

The recursive way

~(?<!@)(?=(@(?>[^@=]+|(?-1))*=)(?!=))(?=(@(?>[^@-]+|(?-1))*-)(?!-))(?=(@(?>[^@/]+|(?-1))*/)(?!/))~

You need to use overlapped matches, since you will use the @ part several times, it is the reason why all the pattern is inside lookarounds.

pattern details:

(?<!@)                # left @ boundary
(?=                   # open a lookahead (to allow overlapped matches)
    (                 # open a capturing group
        @
        (?>           # open an atomic group
            [^@=]+    # all that is not an @ or an =, one or more times
          |           # OR
            (?-1)     # recursion: the last defined capturing group (the current here)
        )*            # repeat zero or more the atomic group
        =             #
    )                 # close the capture group
    (?!=)             # checks the = boundary
)                     # close the lookahead
(?=(@(?>[^@-]+|(?-1))*-)(?!-))  # the same for -
(?=(@(?>[^@/]+|(?-1))*/)(?!/))  # the same for /

The main difference with the precedent pattern is that this one doesn’t care about the order of = - and / groups. (However you can easily make some changes to the first pattern to deal with that, with character classes and negative lookaheads.)

Note: For the example string, to be more specific, you can replace the negative lookbehind with an anchor (^ or \A). And if you want to obtain the whole string as match result you must add .* at the end (otherwise the match result will be empty as playful notices it.)

More Related Contents:

  1. How does the ? make a quantifier lazy in regex
  2. Why is this regex allowing a caret?
  3. Regex to validate date formats dd/mm/YYYY, dd-mm-YYYY, dd.mm.YYYY, dd mmm YYYY, dd-mmm-YYYY, dd/mmm/YYYY, dd.mmm.YYYY with Leap Year Support
  4. Regular expression for floating point numbers
  5. RegEx for matching UK Postcodes
  6. Regex: ignore case sensitivity
  7. Can’t escape the backslash with regex?
  8. Regex to match URL
  9. Extracting a string between other two strings in R
  10. What is the ultimate postal code and zip regex?
  11. What is the difference between square brackets and parentheses in a regex?
  12. isnumeric() with PostgreSQL
  13. Insert commas into number string
  14. regex to match a word with unique (non-repeating) characters
  15. Is it possible to define a pattern and reuse it to capture multiple groups?
  16. What’s the technical reason for “lookbehind assertion MUST be fixed length” in regex?
  17. Regular expression to match last number in a string
  18. What are the differences between glob-style patterns and regular expressions?
  19. Regex for comments in strings, strings in comments, etc
  20. Matching math expression with regular expression?
  21. Can a URL contain a semicolon and still be valid?
  22. How do I use a regex in a shell script?
  23. Regular expression to extract whole sentences with matching word
  24. Combining $regex and $or operators in Mongo
  25. Case insensitive search in Mongo
  26. Why does VIM have its own regex syntax?
  27. Find all string matches with Regex golang
  28. Replace with whole match value using Notepad++ regex search and replace
  29. Match parenthesised block using regular expressions in vim
  30. RegEx for allowing alphanumeric at the starting and hyphen thereafter

Leave a Comment