Я пытаюсь разделить строку на две части с помощью регулярных выражений. Строка отформатирована следующим образом:

text to extract<number>

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

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

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

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

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

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

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

На жадных против не жадных

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

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

Ссылки

• регулярные выражения.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: от A до ZZ

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

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, которые охватывают некоторые темы, которые могут представлять интерес.

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

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

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

<a></a>

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

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