RegExp question

[mLipok]

I have such example:

#include <Array.au3>
_Example()
Func _Example()
    Local $sTest = _
            "1a" & @CRLF & _
            "1b" & @CRLF & _
            "2" & @CRLF & _
            "1c" & @CRLF & _
            "1d" & @CRLF & _
            "2" & @CRLF & _
            "1e" & @CRLF & _
            "1f" & @CRLF & _
            "1g" & @CRLF & _
            "2" & @CRLF & _
            ""
    Local $aResult = StringRegExp($sTest, '(?is)1.*?2', $STR_REGEXPARRAYGLOBALMATCH)
    ConsoleWrite(_ArrayToString($aResult, @CRLF & @CRLF & @CRLF) & @CRLF )
EndFunc   ;==>_Example

Could somebody be so nice and explain 2 things:

Why the result is:

 

1a
1b
2


1c
1d
2


1e
1f
1g
2

I expected to get the following results.

How to get:

1b
2


1d
2


1g
2

?

Edited 3 hours ago by mLipok

[argumentum]

Spoiler

This is a classic regex trap! Let’s break down exactly why your current pattern is over-matching, and then look at how to get your expected output.

1. Why you got the first result

Your current regex is: (?is)1.*?2

Here is what is happening under the hood:

• (?is): This enables case-insensitivity (i) and "dot-all" mode (s). Dot-all means the dot . matches everything, including newlines (@CRLF).

• 1: The engine looks for the first literal 1 it can find. In your string, that's the 1 in "1a".

• .*?: This tells the engine to match any characters lazily (as few as possible) until it hits the next token.

• 2: The engine stops matching as soon as it hits the first 2.

Because it starts at "1a" and stops at the first "2", your first match group captures everything from 1a down to the first 2. Then it repeats the process starting from 1c, and then 1e.

The lazy quantifier .*? doesn't mean "skip to the closest 1 before a 2"; it just means "stop at the very first 2 you see after you've already found a 1".

2. How to get your expected result

To get only the 1 that immediately precedes the 2, you need to tell the regex engine: "Match a 1, but do not allow any other 1s to exist between it and the trailing 2."

You can achieve this by replacing the lazy dot .*? with a negated character class or a negative lookahead.

The Solution: Using a Negative Lookahead

The cleanest way to handle this with multi-character lines and newlines is to ensure that while we scan ahead to find a 2, we never cross over another 1.

Here is the updated AutoIt code:

AutoIt

#include <Array.au3>
#include <StringConstants.au3> ; Required for $STR_REGEXPARRAYGLOBALMATCH

_Example()

Func _Example()
    Local $sTest = _
            "1a" & @CRLF & _
            "1b" & @CRLF & _
            "2" & @CRLF & _
            "1c" & @CRLF & _
            "1d" & @CRLF & _
            "2" & @CRLF & _
            "1e" & @CRLF & _
            "1f" & @CRLF & _
            "1g" & @CRLF & _
            "2" & @CRLF & _
			""
			
    ; The new pattern: matches '1', ensures no other '1' follows before the '2'
    Local $aResult = StringRegExp($sTest, '(?is)1(?:(?!1).)*?2', $STR_REGEXPARRAYGLOBALMATCH)
    
    ConsoleWrite(_ArrayToString($aResult, @CRLF & @CRLF & @CRLF) & @CRLF )
EndFunc   ;==>_Example

How the new pattern works: 1(?:(?!1).)*?2

• 1: Finds a literal 1 (e.g., the one in 1a).

• (?: ... )*?: A lazy non-capturing group that loops through characters one by one.

• (?!1).: This is the magic. Before matching the next character (.), it looks ahead to make sure it is not another 1. If it is another 1 (like when moving past 1a towards 1b), the match fails for 1a, forcing the engine to discard 1a and start the whole match over again at 1b.

• 2: Closes the match once it hits the 2.

..I don't know RegEx but if the answer is good, then is a good answer 👍