В этом разница между жадными и нежадными квантификаторами.

Рассмотрим ввод 101000000000100.

При использовании 1.*1, * является жадным - он будет соответствовать полностью до конца, а затем возвращаться, пока не совпадет с 1, в результате останется 1010000000001.
.*? не является жадным. * ничего не найдет, но затем попытается сопоставить дополнительные символы, пока не совпадет с 1, в конечном итоге совпадет с 101.

Все квантификаторы имеют нежадный режим: .*?, .+?, .{2,6}? и даже .??.

В вашем случае аналогичный шаблон может быть <([^>]*)> - соответствовать чему угодно, кроме знака «больше» (строго говоря, он соответствует нулю или большему количеству символов, кроме > между < и >).

См. Шпаргалку по квантификатору.

О жадных и не жадных

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

? в качестве квантификатора повторения изменяет это поведение на не жадное, также называемое неохотным (, например, на Java) (а иногда и" ленивый "). Напротив, это повторение сначала будет пытаться сопоставить как можно несколько повторений, а когда это не сработает, и они должны вернуться назад, они начинают сопоставить еще одно повторение за раз. В результате, когда совпадение, наконец, происходит, повторение неохотно будет соответствовать как можно малому повторению.

использованная литература

• regular-expressions.info/Repetition - Лень вместо жадности

Пример 1: от А до Я

Давайте сравним эти два паттерна: A.*Z и A.*?Z.

Учитывая следующий ввод:

eeeAiiZuuuuAoooZeeee

Шаблоны дают следующие совпадения:

• A.*Z дает 1 совпадение: AiiZuuuuAoooZ (см. На rubular.com)
• A.*?Z дает 2 совпадения: AiiZ и AoooZ (см. На rubular.com)

Давайте сначала сосредоточимся на том, что делает A.*Z. Когда он соответствует первому A, .*, будучи жадным, сначала пытается сопоставить как можно больше ..

eeeAiiZuuuuAoooZeeee
   \_______________/
    A.* matched, Z can't match

Поскольку Z не совпадает, движок выполняет возврат, и .* должно соответствовать на единицу меньше .:

eeeAiiZuuuuAoooZeeee
   \______________/
    A.* matched, Z still can't match

Это происходит еще несколько раз, пока, наконец, мы не придем к следующему:

eeeAiiZuuuuAoooZeeee
   \__________/
    A.* matched, Z can now match

Теперь Z может совпадать, поэтому общий шаблон соответствует:

eeeAiiZuuuuAoooZeeee
   \___________/
    A.*Z matched

Напротив, неохотное повторение в A.*?Z сначала соответствует как можно меньшему количеству ., а затем при необходимости берется больше .. Это объясняет, почему он находит два совпадения во входных данных.

Вот визуальное представление того, что совпадают между двумя шаблонами:

eeeAiiZuuuuAoooZeeee
   \__/r   \___/r      r = reluctant
    \____g____/        g = greedy

Пример: альтернатива

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

Шаблон A[^Z]*Z также находит те же два совпадения, что и шаблон A.*?Z для указанного выше ввода (, как показано на ideone.com < / а>). [^Z] - это то, что называется инвертированным классом символов: он соответствует чему угодно, кроме Z.

• regular-expressions.info/Repetition - альтернатива лени, Отрицательные классы символов и Притяжательные квантификаторы

Пример 2: От А до Я

Этот пример должен быть иллюстративным: он показывает, как шаблоны классов символов «жадный», «неохотный» и «отрицательный» совпадают по-разному при одном и том же вводе.

eeAiiZooAuuZZeeeZZfff

Это совпадения для приведенного выше ввода:

• A[^Z]*ZZ дает 1 совпадение: AuuZZ (как показано на ideone.com)
• A.*?ZZ дает 1 совпадение: AiiZooAuuZZ (как показано на ideone.com)
• A.*ZZ дает 1 совпадение: AiiZooAuuZZeeeZZ (как показано на ideone.com)

Вот визуальное представление того, что они соответствовали:

         ___n
        /   \              n = negated character class
eeAiiZooAuuZZeeeZZfff      r = reluctant
  \_________/r   /         g = greedy
   \____________/g

похожие темы

Это ссылки на вопросы и ответы по stackoverflow, которые охватывают некоторые темы, которые могут быть интересны.

Одно жадное повторение может превзойти другое

• Регулярное выражение недостаточно жадно
• Регулярное выражение: кто жаднее

Допустим, у вас есть:

<a></a>

<(.*)> соответствует a></a, а <(.*?)> соответствует a. Последний останавливается после первого матча >. Он проверяет одно или 0 совпадений с .*, за которым следует следующее выражение.

Первое выражение <(.*)> не останавливается при сопоставлении с первым >. Это будет продолжаться до последнего совпадения >.