Use of capture groups within lookarounds

user_256970 0
Viewed 72

Suppose we are given the following string:

a, b, c, d
e, f, g, h
i, j, k, l

I wish to convert that to the following string using a PCRE regex:

ab, ac, ad
ef, eg, eh
ij, ik, il

More generally, each of these letters can be regarded as a placeholder for a string of word characters, and there can be an arbitrary number of them per line and an arbitrary number of lines.

If this cannot be done, can the following string be produced?

a, ab, ac, ad
e, ef, eg, eh
i, ij, ik, il

Please demonstrate your regex using the "SUBSTITUTION" facility (which can include back-references such as $1) at regex101.com. I would particularly appreciate an explanation of how the PCRE engine is stepping through the string.

If this cannot be done with a PCRE regex I would like an explanation of why it cannot be done.

I am asking this question to improve my understanding of how capture groups within lookarounds work.

pcre regex
2 Answers

This can only be done with a regex engine that supports variable-width lookbehind patterns, which PCRE isn't. A variable-width lookbehind is required to reference the word at the beginning of each line for every subsequent word.

If variable-width lookbehind patterns are supported by your regex engine, you can then search for:

(?<=(\w+),.*)(\w+)|^\w+,\s*

and replace the matches with:

$1$2

Demo: https://regex101.com/r/XZhZyW/5/

user_68909120

I wanted to mention a possible course of action when faced with a situation, as here, where a variable-length positive lookbehind is needed but the regex engine being used does not support that operation, but does support variable-length positive lookaheads, as does PCRE (PHP), for example.

I confess to mainly having written this answer to improve my own understanding of how regex engines operate.

Basic idea

  • Reverse the string
  • Use a regex with a corresponding positive lookahead to perform replacements of matches
  • Reverse the resultant string

Example

Suppose we wish to convert the following strings:

a, bb, c, d
ee, f, g, h
i, j, kk, l

to the strings:

abb, ac, ad
eef, eeg, eeh
ij, ikk, il

We first reverse the original strings:

d ,c ,bb ,a
h ,g ,f ,ee
l ,kk ,j ,i

then match the regex:

(\w+)(?=.*,(\w+)$)|\s+,\w+$

and replace each match with $1+$2, to obtain:

da ,ca ,bba
hee ,gee ,fee
li ,kki ,ji

Lastly, reverse those strings:

abb, ac, ad
eef, eeg, eeh    
ij, ikk, il

PCRE demo

The regex performs the following operations:

(\w+)    # match 1+ word chars in cap grp 1 
(?=      # begin a positive lookahead
  .*,    # match 0+ chars (greedily), then ','
  (\w+)  # match 1+ word chars in cap grp 1
  $
)
|
\s+,\w+
$

I will represent the spaces in the string "a, bb, c, d" with little smilies (☺), to make them more distinct, and display the string thusly:

 a , ☺ b b , ☺ c , ☺ d
^

The spaces now represent the areas between adjacent characters. ^ is the initial location of the regex engine's pointer.

After (\w+) matches "a" at the beginning of the string (indicated by m below), "a" is saved to capture group 1. The positive lookahead begins right after that match:

 a , ☺ b b , ☺ c , ☺ d
 m^

The positive lookahead, (?=.*,(\w+)$) saves "d" to capture group 2.1 As the match was successful, the first match, "a" is replaced with $1+$2 #=> "ad" and the pointer moves back to its position before the lookahead was executed:

 a , ☺ b b , ☺ c , ☺ d
  ^

There is now an attempt to match (\w+) with the part of the string that begins with the first comma. That fails, as does the or part of the regex, \s+,\w+$. The pointer is then advanced one character:

 a , ☺ b b , ☺ c , ☺ d
    ^

That also fails, and the pointer is again advanced by one.

 a , ☺ b b , ☺ c , ☺ d
      ^

(\w+) now matches "bb", which is saved to capture group 1, at which point:

 a , ☺ b b , ☺ c , ☺ d
       m m^

As before, the positive lookahead saves "d" to capture group 2 and the match, "bb" is replaced with $1+$2 #=> "bbd"

After two more matching failures we are at:

 a , ☺ b b , ☺ c , ☺ d
              ^

For the same reasons as before, "c" is matched and replaced with $1+$2 => "cd" and we are now here:

 a , ☺ b b , ☺ c , ☺ d
                ^

There are no more word strings that are followed by word strings to be matched, but the end of the string, ", d", now matches the or part of the regex, \s+,\w+$. That match is then replaced with $1+$2. This time, however, the two capture groups are empty, so the match is replaced with an empty string.

1 The comma is needed. Without it, .*, being greedy, would gobble up everything before the last word character. If the string ended ", cd", for example, capture group 2 would contain only "d".

user_2569700
Related