Extra characters on the end of replaced text

Question

In PHP and Java, I applied /^[^\pL]*|[^\pL]*$/ to ‍‍‍-A- and I got *A**. I applied a symmetric pattern and got an asymmetric result! Why? I wonder why its output is not *A*?

Pattern says that every thing except letter in the end of string should be replaced by *, it's also greedy and should replace all non-letter stuff together.

Alos note in RegexBuddy I get *A* that is what I expect.

Update: I simplified the question to focus my main concern.

Answer 1

#^[^\pL]+|[^\pL]+$#u

Replace * with +. Using * in combination with $ doesn't quite work as one would expect. In a bizarre consequence of how the regex engine works, X*$ will find two matches for X*. Using + fixes it.

Explanation

[^\pL]*$

Let's look at this part of the regex, the part that's not working as expected. Why does it put two *'s at the end of some of the strings?

1. Consider the third example string ---A--- after the first set of dashes have been replaced:

   *A---$
   

2. The regex engine finds a match for the regex here:

   *A---$
     ^
   

3. And replaces "---" with an asterisk:

   *A*$
     ^
   

4. It then moves its internal cursor to the right of the replacement string.

   *A*$
      ^
   

5. It starts at this cursor position and looks for another match. And it finds one! It finds ""—the empty string! "" consists of 0-or-more non-letters ([^\pL]*), and it's anchored at the end of the string ($), so it's a valid match. It's found the empty string, sure, but that's allowed.

   It's unexpected because it's matched the $ anchor yet again. Isn't that wrong? It shouldn't match $ again, should it? Well, actually, it should, and does. It can match $ again because $ isn't an actual character in the input string—it's a zero-width assertion. It doesn't get "used up" by the first replacement. $ is allowed to match twice.

6. And hence, it "replaces" the empty string "" with an asterisk. This is why you end up with two asterisks.

   *A**$
      ^
   

7. If the regex engine returned to step 4, it would find yet another empty string and add yet another asterisk. Conceptually speaking, there are an infinite number of empty strings there. To avoid this the engine doesn't allow the next match to start at the same position as the previous one. This rule keeps it from entering an infinite loop.

Answer 2

Correct regex would be like this:

$arr = preg_replace('#^[^\pL]+|[^\pL]+$#','*', 
           array('A','-A-','---A---','-+*A*+-','------------A------------'));

Note + instead of *. This will give output:

Array
(
    [0] => A
    [1] => *A*
    [2] => *A*
    [3] => *A*
    [4] => *A*
)

PS: Note that first element will remain unchanged due to the fact that there is no non-alpha character before and after A.