Почему.* не использует всю строку в этом Perl regex?

Running it with "use re 'debug'" results in:

Compiling REx "((.*)*)"
Final program:
   1: OPEN1 (3)
   3:   CURLYX[0] {0,32767} (12)
   5:     OPEN2 (7)
   7:       STAR (9) # <====
   8:         REG_ANY (0)
   9:     CLOSE2 (11)
  11:   WHILEM[1/1] (0)
  12:   NOTHING (13)
  13: CLOSE1 (15)
  15: END (0)
minlen 0 

Matching REx "((.*)*)" against "This is a test string"
   0 <> <This is a >         |  1:OPEN1(3)
   0 <> <This is a >         |  3:CURLYX[0] {0,32767}(12)
   0 <> <This is a >         | 11:  WHILEM[1/1](0)
                                    whilem: matched 0 out of 0..32767
   0 <> <This is a >         |  5:    OPEN2(7)
   0 <> <This is a >         |  7:    STAR(9) # <====
                                      REG_ANY can match 21 times out of 2147483647...
  21 < test string> <>       |  9:      CLOSE2(11)
  21 < test string> <>       | 11:      WHILEM[1/1](0)
                                        whilem: matched 1 out of 0..32767
  21 < test string> <>       |  5:        OPEN2(7)
  21 < test string> <>       |  7:        STAR(9) # <====

  # This is where the outputs really start to diverge
  # --------------------------------------------------------------------------------------------
                                          REG_ANY can match 0 times out of 2147483647...
  21 < test string> <>       |  9:          CLOSE2(11) # <==== Succeeded
  21 < test string> <>       | 11:          WHILEM[1/1](0)
                                            whilem: matched 2 out of 0..32767
                                            whilem: empty match detected, trying continuation...
  # --------------------------------------------------------------------------------------------

  21 < test string> <>       | 12:            NOTHING(13)
  21 < test string> <>       | 13:            CLOSE1(15)
  21 < test string> <>       | 15:            END(0)
Match successful!

Compiling REx "((.+)*)"
Final program:
   1: OPEN1 (3)
   3:   CURLYX[0] {0,32767} (12)
   5:     OPEN2 (7)
   7:       PLUS (9) # <====
   8:         REG_ANY (0)
   9:     CLOSE2 (11)
  11:   WHILEM[1/1] (0)
  12:   NOTHING (13)
  13: CLOSE1 (15)
  15: END (0)
minlen 0 

Matching REx "((.+)*)" against "This is a test string"
   0 <> <This is a >         |  1:OPEN1(3)
   0 <> <This is a >         |  3:CURLYX[0] {0,32767}(12)
   0 <> <This is a >         | 11:  WHILEM[1/1](0)
                                    whilem: matched 0 out of 0..32767
   0 <> <This is a >         |  5:    OPEN2(7)
   0 <> <This is a >         |  7:    PLUS(9) # <====
                                      REG_ANY can match 21 times out of 2147483647...
  21 < test string> <>       |  9:      CLOSE2(11)
  21 < test string> <>       | 11:      WHILEM[1/1](0)
                                        whilem: matched 1 out of 0..32767
  21 < test string> <>       |  5:        OPEN2(7)
  21 < test string> <>       |  7:        PLUS(9) # <====

  # This is where the outputs really start to diverge
  # ------------------------------------------------------------------------------------
                                          REG_ANY can match 0 times out of 2147483647...
                                          failed... # <==== Failed
                                        whilem: failed, trying continuation...
  # ------------------------------------------------------------------------------------

  21 < test string> <>       | 12:        NOTHING(13)
  21 < test string> <>       | 13:        CLOSE1(15)
  21 < test string> <>       | 15:        END(0)
Match successful!

Проблема с первым регулярным выражением является комбинацией того факта, что () * сохраняет только последнее совпадение, а . * соответствует пустой строке (т.е. ничего). Таким образом, для заданного

"aaab" =~ /(.)*/;

$ 1 будет «b» . Если вы объедините это поведение с тем фактом, что . * соответствует пустой строке, вы увидите, что есть два совпадения внутреннего захвата: «Это тестовая строка» и «». Поскольку пустая строка была последней, она сохраняется в $ 2 . $ 1 - это весь захват, поэтому он эквивалентен «Это тестовая строка». "" . Второй случай работает так, как вы ожидаете, потому что . + не будет соответствовать пустой строке.

У меня нет ответа, но у меня есть другой способ сформулировать проблему, используя более простые и, возможно, более реалистичные регулярные выражения.

Первые два примера ведут себя именно так, как я ожидал : . * использует всю строку, а регулярное выражение возвращает список только с одним элементом. Но третье регулярное выражение возвращает список из 2 элементов.

use strict;
use warnings;
use Data::Dumper;

$_ = "foo";
print Dumper( [ /^(.*)/g ] ); # ('foo')     As expected.
print Dumper( [ /.(.*)/g ] ); # ('oo')      As expected.
print Dumper( [ /(.*)/g  ] ); # ('foo', '') Why?

Во многих ответах до сих пор подчеркивалось, что . * будет соответствовать чему угодно. Хотя это правда, этот ответ не затрагивает суть вопроса, а именно: почему обработчик регулярных выражений все еще ищет после того, как . * поглотил всю строку? В других случаях (например, в первых двух примерах) . * не добавляет лишнюю пустую строку для хорошей меры.

Обновление после полезных комментариев от Часа. Оуэнс . Первая оценка любого из трех примеров приводит к совпадению . * всей строки. Если бы мы могли вмешаться и вызвать pos () в этот момент, движок действительно был бы в конце строки (по крайней мере, так, как мы воспринимаем строку; см. Комментарии от Chas. Для более подробного понимания этого ). Однако опция / g указывает Perl снова попытаться сопоставить целое регулярное выражение. Эта вторая попытка не удастся для примеров №1 и №2, и эта неудача приведет к прекращению поиска двигателя. Однако с регулярным выражением № 3 движок получит другое совпадение: пустую строку. Затем параметр / g указывает механизму попробовать еще раз весь шаблон.