the implementation of regular expressions in javascript

[letochagone]

I would like to have the texts explaining the implementation of regular expressions in javascript.
So in the following example:

"abc".match(/x*/g)

the result is an array : [ "", "", "", "" ],
4 empty strings.
The explanation is, perhaps, that Javascript finds empty strings in the following locations: (I note "-" for an empty string)
`

-A-B-C-

`
In short, what I'm looking for is where to find the link that explains this result, who decided on this result.

N.-B: I asked on stackoverflow but I didn't get the answer I was looking for.

[https://stackoverflow.com/questions/77047894/i-dont-understand-how-an-elementary-rational-expression-works]

[yin1999]

We should be able to call this match a "zero-length substring match", for the case you given here, the regular expression is equivalent to /()/g.

The spec shows that the regular expressions in JavaScript is modelled after the regular expression facility in the Perl 5 programming language.

I have never known perl before. But I think we could infer the rule from the perl's document, see: https://perldoc.perl.org/perlre#Repeated-Patterns-Matching-a-Zero-length-Substring

However, long experience has shown that many programming tasks may be significantly simplified by using repeated subexpressions that may match zero-length substrings. Here's a simple example being:

@chars = split //, $string;           # // is not magic in split
($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /

Thus Perl allows such constructs, by forcefully breaking the infinite loop. The rules for this are different for lower-level loops given by the greedy quantifiers *+{}, and for higher-level ones like the /g modifier or split() operator.

The lower-level loops are interrupted (that is, the loop is broken) when Perl detects that a repeated expression matched a zero-length substring.

.... (many lines here)

Similarly, for repeated m/()/g the second-best match is the match at the position one notch further in the string.

From the last two sentences I given here, it can be infered that when /x*/g or /()/g matches a zero-length substring and loops infinitely, it will be interrupted by the engine and move the position one notch further in the string (which means, move to the next character). But the pattern does matches (the zero-length string ""), so the match would be appended to the result array.

So, for the regular expression given here, it will match each zero-length substrings between characters, and it's count is 4.

[Josh-Cena]

What you want is here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@match

Even when the match result is empty, the lastIndex is still advanced by 1.