StringRegExpReplace -uncertain word length

[jugador]

Local $Input = "May"  ;word length is 3 
Local $Output = StringRegExpReplace($Input, '\w{3}', "June")  ;it’s work

But if length of word is unknown, for my example length of word anything above 2.

then how to write it......

[mikell]

32 minutes ago, jugador said:

length of word anything above 2

Suggestion :   \w{2,}    which means : 2 or more word chars, greedy

BTW the help file is your best friend 

Edited May 29, 2019 by mikell

[jugador]

mikell  thanks 😅
any example on {x,}+ and {x,}?

Edited May 29, 2019 by jugador

[jchd]

The block of text just above the table you mention explains it all.  At least I've tried to make it as "simple" and understandable as possible, but as the inherent working of regex isn't the paradigm most users are used to in their daily programming language(s) it may need some chewing to swallow.

Greedy means that a repeated pattern will match the maximum subject input which doesn't cause the rest of the pattern to fail. That may need backtracking.

Lazy means that a repeated pattern will match the minimum subject input which doesn't cause the rest of the pattern to fail. That may need backtracking.

Possessive means that a repeated pattern will match the maximum subject input, but without ever backtracking backwards inside the "possessed" part. This may cause the rest of the pattern to fail.

_ArrayDisplay(StringRegExp("AbABAbabbbabaaabbAbAb", "(?i)([ab]+)(aba)(.*)", 1), "Greedy")
_ArrayDisplay(StringRegExp("AbABAbabbbabaaabbAbAb", "(?i)([ab]+?)(aba)(.*)", 1), "Lazy")
_ArrayDisplay(StringRegExp("AbABAbabbbabaaabbAbAb", "(?i)([ab]++)(aba)(.*)", 1), "Possessive")

I used uppercase to help you identify which substring was captured.

In the possessive case, the subpattern [ab]++ will match the whole subject, but the rest of the pattern is left with nothing to match, hence failing flat on its nose.

In general, the possessive qualifier or its father the atomic grouping (see help) is unavoidable when an unlimited subpattern is enclosed inside another unlimited subpattern and there are instances where no match is possible.  In such case the huge number of nested backtrackings required makes the regex extremely slow.  Consider this case where we're after an unbounded repeat of "words" (strings of letters) or integers.  Subjects which match this pattern will match very fast, but when they don't, the regex will have to try many (really many) nested split points in the subject before failing.

Local $s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", $t

$t = TimerInit()
For $i = 1 To 100
    StringRegExp($s, "(\w*|[-\d]*)*[xy]")
Next
ConsoleWrite("Without possessive qualifier: " & StringFormat("%7.4f\n", TimerDiff($t) / 1000))

$t = TimerInit()
For $i = 1 To 100
    StringRegExp($s, "(\w*+|[-\d]*)*[xy]")
Next
ConsoleWrite("With possessive qualifier   : " & StringFormat("%7.4f\n", TimerDiff($t) / 1000))

 

[mikell]

Nice tutorial to ease understanding of possessive quantifiers - though the few lines in the help file were explicit enough IMHO
BTW I personally appreciate the naming "docile" used on rexegg for usual greedy quantifiers (which allow backtracking if needed) against "possessive" ones (which do not)

 

[jugador]

Thanks jchd
for keeping it simple...