Почему `\ s +` намного быстрее, чем `\ s \ s *` в этом регулярном выражении Perl?

Во-первых, даже если результирующее результирующее выражение не будет иметь то же значение, уменьшите регулярные выражения до \s*0 и \s+0 и используйте (" " x 4) . "_0" в качестве ввода. Для скептиков вы можете увидеть здесь, что отставание все еще присутствует.

Теперь рассмотрим следующий код:

$x = (" " x 4) . "_ 0";
$x =~ /\s*0/; # The slow line 
$x =~ /\s+0/; # The fast line

Копаясь немного с use re debugcolor;, получаем следующий результат:

Guessing start of match in sv for REx "\s*0" against "    _0"
Found floating substr "0" at offset 5...
start_shift: 0 check_at: 5 s: 0 endpos: 6 checked_upto: 0
Does not contradict STCLASS...
Guessed: match at offset 0
Matching REx "\s*0" against "    _0"
Matching stclass ANYOF_SYNTHETIC[\x09-\x0d 0\x85\xa0][{unicode_all}] against "    _0" (6 bytes)
   0 <    _0>|  1:STAR(3)
                                  POSIXD[\s] can match 4 times out of 2147483647...
                                  failed...
   1 <    _0>|  1:STAR(3)
                                  POSIXD[\s] can match 3 times out of 2147483647...
                                  failed...
   2 <    _0>|  1:STAR(3)
                                  POSIXD[\s] can match 2 times out of 2147483647...
                                  failed...
   3 <    _0>|  1:STAR(3)
                                  POSIXD[\s] can match 1 times out of 2147483647...
                                  failed...
   5 <    _0>|  1:STAR(3)
                                  POSIXD[\s] can match 0 times out of 2147483647...
   5 <    _0>|  3:  EXACT <0>(5)
   6 <    _0>|  5:  END(0)
Match successful!

-----------------------

Guessing start of match in sv for REx "\s+0" against "    _0"
Found floating substr "0" at offset 5...
start_shift: 1 check_at: 5 s: 0 endpos: 5 checked_upto: 0
Does not contradict STCLASS...
Guessed: match at offset 0
Matching REx "\s+0" against "    _0"
Matching stclass POSIXD[\s] against "    _" (5 bytes)
   0 <    _0>|  1:PLUS(3)
                                  POSIXD[\s] can match 4 times out of 2147483647...
                                  failed...
Contradicts stclass... [regexec_flags]
Match failed

Perl кажется оптимизирован для отказа. Сначала он будет искать постоянные строки (которые потребляют только O (N)). Здесь он будет искать 0: Found floating substr "0" at offset 5...

Затем он начнется с переменной части регулярного выражения, порядочно \s* и \s+, против всей минимальной строки, чтобы проверить:

Matching REx "\s*0" against "    _0"
Matching stclass ANYOF_SYNTHETIC[\x09-\x0d 0\x85\xa0][{unicode_all}] against "    _0" (6 bytes)
Matching REx "\s+0" against "    _0"
Matching stclass POSIXD[\s] against "    _" (5 bytes) # Only 5 bytes because there should be at least 1 "\s" char

После этого он будет искать первую позицию, удовлетворяющую требованию stclass, здесь в позиции 0.

• \s*0:
  • начинается с 0, найдите 4 пробела, затем сработает;
  • начинается с 1, найдите 3 пробела, затем не получится;
  • начинается с 2, найдите 2 пробела, а затем выполните сбой;
  • начинается с 3, найдите 1 пробел, затем выполните сбой;
  • начинается с 4, набирает 0 пробелов, затем не работает;
  • Найдите точный 0
• \s+0:
  • начинается с 0, найдите 4 пробела, затем сработает. Поскольку минимальное количество пробелов не сопоставляется, регулярное выражение не выполняется мгновенно.

Если вы хотите получать удовольствие от оптимизации регулярных выражений в Perl, вы можете рассмотреть следующие регулярные выражения / *\n и / * \n. На первый взгляд они выглядят одинаково, имеют одинаковое значение... Но если вы запустите его против (" " x 40000) . "_\n", то первый проверит все возможности, а второй будет искать " \n" и немедленно сработает.

В ванильном неоптимизированном двигателе регулярных выражений оба регулярных выражения могут привести к катастрофическому обратному отскоку, поскольку им нужно повторить шаблон, когда он сталкивается. Однако в приведенном выше примере второй не прерывается с Perl, поскольку он оптимизирован для find floating substr "0%n"

Вы можете увидеть другой пример в блог Джеффа Атвуда.

Обратите внимание также, что проблема не в рассмотрении \s, но любой шаблон, где xx* используется вместо x+, см. пример с 0s, а также кванторы экспрессии регулярных выражений

С таким более коротким примером поведение "находят", но если вы начинаете играть со сложными шаблонами, это далеко не легко заметить, например: Программа зависания регулярных выражений (100 % Использования ЦП)

\s+\n требует, чтобы символ, предшествующий \n, был SPACE.

Согласно use re qw(debug) компиляция устанавливает, что для нее требуется прямая строка известного числа пробелов, вплоть до подстроки \n, которая сначала проверяется на входе. Затем он проверяет подстроку с фиксированной длиной пробела на оставшуюся часть ввода, в противном случае, как это делается в _. Это единственная возможность проверить, независимо от того, сколько пробелов у входа. (Когда больше _\n обнаружено, что каждый из них не работает одинаково напрямую, на каждый отладочный вывод.)

Посмотрел на это таким образом, это оптимизация, о которой вы почти ожидали, используя довольно специфический шаблон поиска и повезший с этим вводом. За исключением случаев, когда они сделаны по сравнению с другими двигателями, которые явно не проводят такого рода анализ.

С \s*\n это не так. Когда найден \n и предыдущий символ не является пробелом, поиск не сработал, поскольку \s* ничего не дает (нулевые символы). Также нет подстрок с фиксированной длиной и в игре с возвратом.

Я не уверен в внутренности механизма регулярных выражений, но похоже, что он не признает, что \s+ в некотором роде тот же, что и \s\s*, поскольку во втором один он соответствует пробелу, а затем пытается сопоставить все большее количество пробелов, а в первом сразу же приходит к выводу, что совпадения нет.

Результат с использованием use re qw( Debug ); ясно показывает это, используя гораздо более короткую строку:

test_re.pl

#!/usr/bin/env perl
use re qw(debug);

$x=(" " x 10) . "_\n";
print '-'x50 . "\n";
$x =~ /\s+\n/;
print '-'x50 . "\n";
$x =~ /\s\s*\n/;
print '-'x50 . "\n";

Выход

Compiling REx "\s+\n"
Final program:
    1: PLUS (3)
    2:   SPACE (0)
    3: EXACT <\n> (5)
    5: END (0)
floating "%n" at 1..2147483647 (checking floating) stclass SPACE plus minlen 2
Compiling REx "\s\s*\n"
Final program:
    1: SPACE (2)
    2: STAR (4)
    3:   SPACE (0)
    4: EXACT <\n> (6)
    6: END (0)
floating "%n" at 1..2147483647 (checking floating) stclass SPACE minlen 2
--------------------------------------------------
Guessing start of match in sv for REx "\s+\n" against "          _%n"
Found floating substr "%n" at offset 11...
    start_shift: 1 check_at: 11 s: 0 endpos: 11
Does not contradict STCLASS...
Guessed: match at offset 0
Matching REx "\s+\n" against "          _%n"
Matching stclass SPACE against "          _" (11 bytes)
   0 <> <          >         |  1:PLUS(3)
                                  SPACE can match 10 times out of 2147483647...
                                  failed...
Contradicts stclass... [regexec_flags]
Match failed
--------------------------------------------------
Guessing start of match in sv for REx "\s\s*\n" against "          _%n"
Found floating substr "%n" at offset 11...
    start_shift: 1 check_at: 11 s: 0 endpos: 11
Does not contradict STCLASS...
Guessed: match at offset 0
Matching REx "\s\s*\n" against "          _%n"
Matching stclass SPACE against "          _" (11 bytes)
   0 <> <          >         |  1:SPACE(2)
   1 < > <         _>        |  2:STAR(4)
                                  SPACE can match 9 times out of 2147483647...
                                  failed...
   1 < > <         _>        |  1:SPACE(2)
   2 <  > <        _>        |  2:STAR(4)
                                  SPACE can match 8 times out of 2147483647...
                                  failed...
   2 <  > <        _>        |  1:SPACE(2)
   3 <   > <       _%n>      |  2:STAR(4)
                                  SPACE can match 7 times out of 2147483647...
                                  failed...
   3 <   > <       _%n>      |  1:SPACE(2)
   4 <    > <      _%n>      |  2:STAR(4)
                                  SPACE can match 6 times out of 2147483647...
                                  failed...
   4 <    > <      _%n>      |  1:SPACE(2)
   5 <     > <     _%n>      |  2:STAR(4)
                                  SPACE can match 5 times out of 2147483647...
                                  failed...
   5 <     > <     _%n>      |  1:SPACE(2)
   6 <      > <    _%n>      |  2:STAR(4)
                                  SPACE can match 4 times out of 2147483647...
                                  failed...
   6 <      > <    _%n>      |  1:SPACE(2)
   7 <       > <   _%n>      |  2:STAR(4)
                                  SPACE can match 3 times out of 2147483647...
                                  failed...
   7 <       > <   _%n>      |  1:SPACE(2)
   8 <        > <  _%n>      |  2:STAR(4)
                                  SPACE can match 2 times out of 2147483647...
                                  failed...
   8 <        > <  _%n>      |  1:SPACE(2)
   9 <         > < _%n>      |  2:STAR(4)
                                  SPACE can match 1 times out of 2147483647...
                                  failed...
   9 <         > < _%n>      |  1:SPACE(2)
  10 <          > <_%n>      |  2:STAR(4)
                                  SPACE can match 0 times out of 2147483647...
                                  failed...
Contradicts stclass... [regexec_flags]
Match failed
--------------------------------------------------
Freeing REx: "\s+\n"
Freeing REx: "\s\s*\n"