В регулярных выражениях утверждение нулевой ширины — это специальная конструкция, которая не потребляет символы во время сопоставления; она лишь выполняет условную проверку позиции сопоставления. Это очень полезно для некоторых сложных сопоставлений с образцом, поскольку позволяет добавлять условия до или после позиции сопоставления, тем самым точнее управляя сопоставлением.
Существует 4 формы опережающих и ретроспективных проверок в регулярных выражениях:
- (?=pattern)Позитивная опережающая проверка нулевой ширины
- (?!pattern)Негативная опережающая проверка нулевой ширины
- (?<=pattern)Позитивная ретроспективная проверка нулевой ширины
- (?<!pattern)Утверждение отрицательного просмотра назад нулевой ширины
Здесь,pattern— это регулярное выражение.
Точно так же, как^обозначает начало,$обозначает конец,\bа обозначает границу слова, утверждения просмотра вперёд и просмотра назад имеют аналогичный эффект: они совпадают только с определёнными позициями и не занимают символы во время процесса сопоставления, поэтому их называют«нулевой ширины». Так называемая позиция — это позиция слева от первого символа, справа от последнего символа и между соседними символами в строке (в каждой строке), если направление текста — слева направо.
Объяснение концепции:
- Нулевая ширина: оно соответствует только позициям. Нулевая ширина означает, что утверждение не «потребляет» символы во время сопоставления; оно лишь выполняет условные проверки позиции и не включает символы до или после позиции совпадения в результат совпадения.
- Просмотр вперёд: указывает, что утверждение находится перед позицией совпадения.
- Просмотр назад: указывает, что утверждение находится после позиции совпадения.
- Положительное: соответствует выражению внутри скобок, то есть условие, проверяемое утверждением, является утвердительным; совпадение успешно только тогда, когда условие выполняется.
- Отрицательное: не соответствует выражению внутри скобок, то есть условие, проверяемое утверждением, является отрицательным; совпадение успешно только тогда, когда условие не выполняется.
Ниже приведены примеры, иллюстрирующие значение этих 4 утверждений.
(?=pattern) Утверждение положительного просмотра вперёд
Представляет позицию в строке; последовательность символов сразу после этой позиции может соответствовать pattern.
Например, для"a regular expression"этой строки, если вы хотите сопоставить re в regular, но не re в expression, можно использоватьre(?=gular); это выражение ограничивает позицию справа от re; после этой позиции находится gular, но оно не поглощает такие символы, как gular.


(?!pattern) Отрицательная опережающая проверка
Представляет позицию в строке; последовательность символов сразу после этой позиции не может соответствовать pattern.
Например, для"regex represents regular expression"этой строки, если вы хотите сопоставить re, отличные от тех, что в regex и regular, можно использоватьre(?!g); это выражение ограничиваетreпозиция справа; после этой позиции находится не символg。
Разница между отрицательной и положительной проверкой состоит в том, могут ли символы после этой позиции соответствовать выражению в скобках.

(?<=pattern) Положительная ретроспективная проверка
Представляет позицию в строке; последовательность символов непосредственно перед этой позицией может соответствовать pattern.
Например, дляregex represents regular expressionэтой строки есть 4 слова; если вы хотите сопоставить re внутри слов, но не re в начале слов, можно использовать(?<=\w)re; для re внутри слова перед re должен стоять символ слова.
Это называется ретроспективной проверкой, потому что когда движок регулярных выражений сопоставляет строку с выражением, он сканирует символы строки спереди назад один за другим и проверяет, соответствуют ли они выражению. Когда он встречает эту проверку в выражении, движку нужно проверить уже отсканированные символы в направлении начала строки, что является движением назад относительно направления сканирования.

(?<!pattern) Отрицательная lookbehind-проверка
Представляет позицию в строке; последовательность символов непосредственно перед этой позицией не может соответствовать pattern.
Например, для"regex represents regular expression"этой строки, если вы хотите сопоставить re в начале слов, можно использовать(?<!\w)re. re в начале слова,re, в этом примере, относится к re, которое не находится внутри слова,re, то естьreсимвол перед ним не является символом слова. Конечно, вы также можете использовать\breдля сопоставления.

Чтобы понять эти 4 проверки, можно рассмотреть их с двух сторон:
-
1. Что касается lookahead и lookbehind:Когда движок регулярных выражений выполняет сопоставление строки и выражения, он непрерывно сканирует символы в строке от начала до конца (спереди назад). Представьте указатель сканирования, указывающий на границу символа и перемещающийся вместе с процессом сопоставления. Для lookahead-проверки, когда указатель сканирования находится в определённой позиции, движок пытается сопоставить символы, которые указатель ещё не просканировал, достигая этих символов раньше указателя, отсюда и название lookahead. Для lookbehind-проверки движок пытается сопоставить символы, которые указатель уже просканировал, достигая их после указателя, отсюда и название lookbehind.
-
2. О положительном и отрицательном:Положительный означает сопоставление с выражением в скобках; отрицательный означает несовпадение.
Мнемонические правила для этих 4 форм проверок:
-
1. Lookahead и lookbehind:Lookbehind-проверка(?<=pattern)、(?<!pattern)содержит знак «меньше», который также является стрелкой. Для направления текста слева направо эта стрелка указывает назад, что также соответствует нашему соглашению. Если убрать знак «меньше», получится lookahead-проверка.
-
2. Положительный и отрицательный:Не равно(!=), логическое НЕ(!)оба обозначаются!знаком !, поэтому форма с!знаком ! означает отсутствие совпадения, отрицательный; замените!знак ! вместе с=знаком =, который указывает на совпадение, положительное.
Мы часто используем регулярные выражения, чтобы проверить, содержит ли строка подстроку. Также легко выразить, что строка не содержит определённый символ или определённые символы; просто используйте[^...]форму. Но как выразить, что строка не содержит определённую подстроку (состоящую из последовательности символов)?
использовать[^...]Эта форма не сработает. В этом случае нужно использовать (негативные) опережающие или ретроспективные утверждения, или использовать оба одновременно.
Например, чтобы определить, содержит ли предложениеthis, но не содержитthat。
содержитthis— с этим легко справиться; предложение, которое не содержитthat, можно считать, что символ перед каждым символом в предложении не являетсяthatили символ после каждого символа не являетсяthat. Регулярные выражения следующие:
^((?<!that).)*this((?<!that).)*$ 或 ^(.(?!that))*this(.(?!that))*$
Для предложенияthis is example testоба выражения могут успешно совпасть, тогда какthis and that is example testвсе не дают совпадений.


В целом эти два выражения в основном могут соответствовать требованиям. Рассмотрим граничные случаи, например когда предложение начинается сthatи заканчивается наthat, или когдаthatиthisсоединены, приведённые выше выражения могут быть недостаточными.example thatthis is the caseилиthis is the case, not thatи т. д.
Если гибко использовать эти утверждения, это легко решить:
^(.(?<!that))*this(.(?<!that))*$ ^(.(?<!that))*this((?!that).)*$ ^((?!that).)*this(.(?<!that))*$ ^((?!that).)*this((?!that).)*$
Эти 4 регулярных выражения были протестированы на приведённых выше предложениях, и все результаты соответствуют требованиям.
Для приведённых выше 4 утверждений шаблон внутри круглых скобок сам является регулярным выражением. Однако есть ограничения на 2 ретроспективных утверждения. В Perl и Python выражение должно быть фиксированной длины, то есть оно не может использовать*、+、?метасимволы, такие как(?<=abc)допустимы, но(?<=a*bc)не поддерживаются. В частности, когда выражение содержит ветви, соединённые |, все ветви должны иметь одинаковую длину. Причина, по которой выражения переменной длины не поддерживаются, заключается в том, что движок не может определить, сколько шагов отката необходимо при проверке утверждения просмотра назад. Java поддерживает?、{m}、{n,m}символы, такие как, но также не поддерживает*、+символ. JavaScript просто не поддерживает утверждения просмотра назад, но, вообще говоря, это не большая проблема.
Утверждения просмотра вперёд и просмотра назад в некоторой степени похожи на использованиеif-инструкций для проверки символов до и после совпадения.
Ниже перечислены варианты использования ?=, ?<=, ?!, ?<!=
exp1(?=exp2): найти exp1 перед exp2.

(?<=exp2)exp1: найти exp1 после exp2.

exp1(?!exp2): найти exp1, за которым не следует exp2.

(?<!=exp2)exp1: найти exp1, которому не предшествует exp2.

Ссылка: https://blog.51cto.com/cnn237111/749047