Отрицание regexp: Регулярные выражения и отрицание целой группы символов [дубликат]

[a-zA-Z\ \’]+$/,

но это не сработало. Вы можете дать мне несколько советов, как это сделать?

3 ответов

\b(?:(?!word)\w)+\b

не будет соответствовать «word».

это хорошее время, чтобы использовать утверждения границы слова, как указано @FailedDev, но необходимо проявлять осторожность, чтобы избежать отклонения некоторых не слишком особых случаев, таких как wordy, wordsmith или даже не так очевидно случаи, как sword или foreword

Я считаю, что это будет хорошо работать:

\b(?!\bword\b)\w+\b

это выражение разбито:

\b        # assert at a word boundary
(?!       # look ahead and assert that what follows IS NOT. .. 
  \b      #   a word boundary
  word    #   followed by the exact characters `word`
  \b      #   followed by a word boundary
)         # end look-ahead assertion
\w+       # match one or more word characters: `[a-zA-Z0-9_]`
\b        # then a word boundary

выражение в исходном вопросе, однако, соответствует больше, чем символы слова. [a-zA-Z\ \']+ соответствует пробелам (для поддержки нескольких слов во входных данных) и одинарным кавычкам (для апострофов?). Если вам нужно разрешить слова с апострофами в них, используйте следующее выражение:

\b(?!\bword\b)[a-zA-Z']+\b

34

автор: Code Jockey

из вашего вопроса неясно, что вы хотите, но я интерпретировал его как «не соответствующий ввод, содержащий определенное слово». «]+»>.+?</a>#’;

Вот такое вот не сложное решение у нас получилось и, как видите, оно работает:

Ну а на этом у меня сегодня все. Больше о регулярных выражениях вы можете узнать из нашего курса по регулярным выражениям. Удачи!

Хотите изучить регулярные выражения на PHP?

Посмотрите 12-ти часовой видео курс по регулярным выражениям на PHP!

Смотреть

4 регулярных выражения, которые стоит знать

Регулярные выражения (RegEx или RegExp) исключительно полезны для извлечения информации из текста посредством поиска совпадения (или нескольких совпадений) со специальными поисковыми шаблонами. Эти шаблоны представляют собой последовательности символов ASCII или Unicode.

Область применения RegEx варьируется от проверки строк до их анализа и замены. Поэтому регулярные выражения очень полезны при переводе данных в другие форматы и в веб-скрейпинге.

Одна из их наиболее интересных особенностей регулярных выражений заключается в том, что, изучив их синтаксис, вы можете реально использовать этот инструмент практически во всех языках программирования (JavaScript, Java, VB, C#, C / C ++, Python, Perl, Ruby, Delphi, R, Tcl и многие другие). The end$ — точное строковое соответствие (при помощи такого шаблона можно найти строку «The end»).

Квантификаторы — * + ? и {}

Пример. Есть несколько групп символов:

abc ab acb aob a2b a42_c abccc 

abc* — соответствует строке, в которой есть сочетание букв ab, за которым (возможно) есть один или несколько символов c.

abc+ — соответствует строке, в которой есть ab, за которым есть один или несколько символов c.

abc? — соответствует строке, в которой есть ab, за которым (возможно) есть один символ c.

abc{2} -соответствует строке, в которой есть ab, за которым есть два символа c.

abc{2,} — соответствует строке, в которой есть ab, за которым есть два или более символов c.

abc{2,5} — соответствует строке, в которой есть ab, за которым есть от двух до пяти символов c.

a(bc)* — соответствует строке, в которой есть символ a, за которым (возможно) есть одна или несколько последовательностей bc.

a(bc){2,5} — соответствует строке, в которой есть символ a, за которым есть от 2 до 5 копий последовательности bc.

Скобочные выражения — []

Пример. Есть несколько групп символов:

abc ab acb aob a2b a42_c abccc

[abc] — соответствует строке, в которой есть либо a, либо b, либо c. Аналогично шаблону a|b|c.

[a-c] — то же самое, что и в предыдущем случае. ([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/

Описание:

Вначале мы даем указание парсеру искать начало строки. Внутри первой группы мы проверяем соответствие одного или более символов букв в нижнем регистре, чисел, нижних подчеркиваний, точек или дефисов. Знак точки мы экранировали, так как иначе он обозначает любой символ. Непосредственно после этого должен быть символ @.Затем идет имя домена: один или более символов букв в нижнем регистре, чисел, нижних подчеркиваний, точек или дефисов. Затем еще одна (экранированная) точка и после нее расширение, состоящее из букв и точек в количестве от 2 до 6. Мы взяли такое количество, потому что домены верхнего уровня могут быть весьма специфическими (например .ny.us или .co.uk). И далее мы хотим видеть конец строки ($).

Подходящая строка:

[email protected]

Неподходящая строка:

[email protected] (домен верхнего уровня слишком длинный)

Введение в регулярные выражения | Регулярные выражения

  Обновл. 17 Ноя 2019  | 

В этой серии обучающих уроков мы будем разбираться с регулярными выражениями (также известными как «RegExp» от англ. «Regular Expressions» или, как в простонародье, «регулярки«). Регулярные выражения — это шаблоны, используемые для сопоставления последовательностей символов.

Применение регулярных выражений

Рассмотрим случаи, в которых используются регулярные выражения:

   Поиск конкретных элементов в большом наборе текста. Например, вы можете выделить только адреса электронной почты из большого количества связанного (или несвязанного) текста.

   Заменить одни символы на другие. Например, вы можете очистить плохо отформатированные файлы с HTML разметкой, заменив все теги, написанные в верхнем регистре, эквивалентами в нижнем регистре, используя текстовой редактор.

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

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

И это не весь список применений регулярных выражений.

Давайте рассмотрим один простой пример. Следующее регулярное выражение выделит каждый экземпляр символа b, за которым следуют либо символ i, либо символ a:

Регулярное выражение: b[ia]
Пример: The bat took a bite out of the big boring apple.

Да, это не что-то сверхъестественное или мегаполезное. Но, по мере того, как мы будем углубляться в regex, примеры станут более практичными.

Где и как можно использовать регулярные выражения?

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

Хорошим примером является функция поиска в текстовых редакторах. В качестве эксперимента вы можете попрактиковаться с регулярными выражениями в редакторе Notepad++, нажав CTRL+F и поставив галочку возле «Регуляр. выражен.»:

Также вы можете попрактиковаться и в любом другом текстовом редакторе.

Изучение регулярных выражений

Когда вы впервые начинаете изучать регулярные выражения и играться с ними, то, скорее всего, вы будете много ошибаться, у вас будет что-то не получаться и так далее. И это нормально, не волнуйтесь, ведь это всего лишь часть обучения. Чем больше у вас будет проблем, тем солиднее будет ваш опыт (при условии, что вы будете решать проблемы). Вот вам несколько советов для эффективной работы с регулярными выражениями:

   Разбивайте регулярное выражение на отдельные компоненты.

   Произносите вслух содержимое регулярного выражения. Например, в примере выше мы произносим: «Сначала мы выделяем b, за которым следует i или a». (Да, это может звучать глупо, но, поверьте, это работает)

   Стройте регулярные выражения постепенно, тестируя каждую часть.

Тестирование

Вы можете использовать тестовые данные для проверки работоспособности ваших регулярных выражений. Ваше регулярное выражение может корректно работать с одним набором тестовых данных и не очень — с другим набором. Как и везде, с практикой вы научитесь создавать объёмные тестовые данные для полной проверки ваших выражений.

В качестве примера, следующее регулярное выражение ищет b, за которым следует любой символ. Если бы наша задача состояла в том, чтобы найти b, за которым следует i или a (как в примере выше), то мы бы могли использовать следующие тестовые данные и придти к неверному заключению, что наше регулярное выражение полностью рабочее:

Регулярное выражение: b.
Пример: The bat took a bite out of the big apple.

Дело в том, что мы указали данные, в которых наше выражение на все 100% сработает, но это не те данные, которые соответствуют заданию в полной мере.

Когда вы используете тестовые данные, убедитесь, что вы включили все, даже крайние случаи.

Регулярное выражение: b.
Пример: The bat took a bite out of the big boring apple.

Повторимся, это служит лишь примером и маловероятно, что может оказаться полезным на данном этапе. Но как только мы начнём погружаться в изучение регулярных выражений, то всё станет на свои места.

Оценить статью:

Загрузка…

Поделиться в социальных сетях:

Урок №9. Необязательные символы | Регулярные выражения

  Обновл. 12 Ноя 2019  | 

Как мы уже знаем из предыдущего урока, метасимволы * и + используются для указания произвольного количества повторяющихся символов в строке.

Ещё одним метасимволом, который часто встречается при сопоставлении и извлечении текста является ? (знак вопроса), который обозначает необязательность. Этот метасимвол позволяет указать на необязательный символ в выражении, например, шаблон ab?c будет соответствовать либо строкам abc, либо ac, поскольку символ b считается необязательным.

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

В упражнении ниже, обратите внимание на то, как изменяется слово file в зависимости от количества найденных файлов. Попробуйте написать шаблон, который использует метасимвол необязательности для соответствия только тем строкам, в которых был найден один или больше файлов.

Задание №9: Необязательные символы

Решите задание выше, чтобы перейти к следующему уроку, либо смотрите Решение.

Оценить статью:

Загрузка…

Поделиться в социальных сетях:

(Не бойтесь) Regexs: практическое руководство по регулярным выражениям

Перевод статьи
Джоша Хокинса «(Don’t Fear) The Regex: A Practical
Introduction to Regular Expressions».

Вам уже приходилось работать со
строками? Верно, именно с теми «массивами
символов», которые мы все знаем и любим.
Если только вы не пишете исключительно
на С, я готов поспорить, что со строками
вы встречались и, может быть, даже очень
часто.

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

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

Что такое регулярные выражения

Давайте быстро (и не слишком углубляясь в информатику) определимся с тем, что такое регулярные выражения.

Есть много лучших
пояснений того, что такое регулярные
языки, так что если приведенное здесь
определение вас не удовлетворяет, просто
погуглите пару минут.

Учимся писать регулярные
выражения

Регулярное выражение ограничивается
слэшами – //. Строка совпадает с регулярным
выражением, если она совпадает с шаблоном
между двумя косыми чертами. Например,
«Привет» совпадает с /Привет/. Поэтому
мы можем использовать данное регулярное
выражение для поиска слова «Привет» в
строке.

Регулярным выражением может быть строка (набор символов). Введенная обычным образом. Например, /Hello World/ будет соответствовать строке «Hello World».

Если нам нужно найти любое слово
(имеется в виду отдельное слово, состоящее
только из букв), мы можем упростить
поиск, применив немного магии regex: \w
будет соответствовать любому одному
слову в строке (w – word – «слово»).

Аналогичный подход можно применять
к цифрам: \d.

Пример 1

То, что мы можем посмотреть, соответствуют
ли какие-то элементы строки заданному
шаблону, это, конечно, хорошо. Но где это
может быть полезно?

Допустим, мы написали чат-бота, который
отслеживает упоминание в разговоре
имени «Джош» (имя автора статьи, – прим.
перев.). В общем, наш бот сканирует каждое
сообщение в чате, пока не найдет
соответствие. Если найдет, то отсылает
сообщение: «Ох, я надеюсь, вы не говорите
плохо о моем приятеле Джоше!».

Для поиска соответствий наш бот будет
использовать шаблон /Джош/.

Внезапно в чате появляется сообщение:
«Эли: Джош, тебе в самом деле нужно так
много кофеина?».

Наш бот сканирует это сообщение и
находит совпадение с шаблоном! Он
отсылает свой стандартный ответ, пугая
Эли. Миссия выполнена!

Или нет? Что, если бы наш робот был
немного смышленее? Что, если бы он
обращался к человеку пои мени? Например,
писал бы: « Ох, я надеюсь, вы не говорите
плохо о моем приятеле Джоше, Эли!».

Это возможно. Но для начала нам нужно
кое-что изучить. Начнем с квантификаторов.

Регулярные выражения помогут найти иголку в стогу сена.

Квантификаторы (указатели
количества вхождений символов)

0 или много

Символ «звездочка» – * – означает
любое количество (в том числе нулевое)
вхождений символа, после которого эта
звездочка стоит. Например, /a*/ будет
соответствовать «aaaaa», а также «». Верно,
это может быть и пустая строка.

Звездочка служит для обозначения
чего-то опционального, потому что
обозначаемый ею символ может не
существовать. А может и существовать.
И «существовать» много, много раз
(теоретически – бесконечное количество
раз).

Регулярное выражение /Джош/ дает нам
совпадение с «Джош». А выражение /Д*жош/
будет совпадать также с «ДДДДДДДжош»
и «жош».

1 или много

Знак «плюс» – + – означает любое
количество вхождений символа, после
которого этот плюс стоит, но не менее
одного вхождения. Он работает так же,
как и «звездочка», за исключением того,
что нулевое вхождение символа здесь
невозможно. Для совпадения должно быть
хотя бы одно вхождение.

Таким образом, выражению /Д+жош/ будет
соответствовать «Джош» и «ДДДДДДДжош»,
но не «жош».

Шаблоны (специальные символы)

Отлично, теперь мы можем находить
больше интересных вещей. Может, в этом
чате кто-нибудь будет сильно зол на меня
и будет кричать «Джоооооош!»…

А что если этот «кто-то» будет аж так
зол, что прямо будет головой об клавиатуру
биться? Как нам выловить в чате
«лавыофылджвоа», если мы не знаем, на
какую клавишу пришелся его нос?

С помощью шаблонов!

Шаблоны могут заменять собой буквально
любой символ (или даже много символов).
Синтаксически это обозначается точкой.
Да, просто точкой. Не путайте с точкой
в конце предложения.

Мы можем использовать этот шаблон
поиска в комбинации с уже известными
нам квантификаторами: /Дж+.*ош/. Давайте
разберем. Здесь у нас будет одно вхождение
«Д», одно или больше вхождение «ж», ноль
или много любых символов (.*) и одно
вхождение «ош». Можно проследить, что
здесь у нас определенные группы.

Группировка символов

Группы символов это блоки символов,
по порядку располагающиеся в строке.
Когда вы используете * или +, это указывает
на количество вхождений не просто
последнего символа, после которого
стоит квантификатор, а последней группы
символов.

Группы полезны сами по себе, но они
могут стать очень мощным инструментом
в сочетании с повторяющимися символами.
Определить группу символов можно с
помощью круглых скобок (вот этих).

Например, мы хотим повторить «Джо»,
но не «ш». Чтобы шаблону соответствовало
«ДжоДжоДжоДжоДжош». Сделать это можно
с помощью регулярного выражения
/(Джо)+ш/. Просто, правда?

И наконец, давайте вернемся к нашему
примеру с чат-ботом. Как нам «выловить»
из строки имя Эли, чтобы бот мог обратиться
именно к ней?

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

Для этого обычно вам нужно будет
использовать что-то вроде \1 – это
соответствует первой определенной
группе.

Возьмем для примера регулярное
выражение /(.+) \1/. Здесь мы видим группу
случайных символов, которая встречается
один раз или больше, после которой идет
пробел, а затем идет повтор тех же
символов. Таким образом, с этим шаблоном
будет совпадать «абв абв», но не «абв
где», хотя сама по себе группа символов
«где» совпадает с шаблоном (.+).

Возможно, это одна из самых полезных
функций регулярных выражений в
программировании.

Пример 2

Ффухх! Давайте теперь продолжим нашу
историю с чат-ботом и используем то,
чему мы научились, чтобы определить,
кто вспоминает Джоша.

Сообщение в чате выглядело так: «Эли:
Джош, тебе в самом деле нужно так много
кофеина?».

Если мы хотим «выловить» имя отправителя
сообщения, наше регулярное выражение
может выглядеть следующим образом:

/(\w+): .*Джош.*/.

В этом выражении мы видим:

• (\w+): – группу из одного или больше
  слов, за которой следует двоеточие,
• .* – любые символы, встречающиеся
  любое количество раз, включая ноль,
• строку «Джош», за которой опять
  следуют
• .* – любые символы, встречающиеся
  любое количество раз, включая ноль.

Памятка: регулярное выражение
/.*слово.*/ это простой способ найти
вхождения строки «слово», по бокам
которой могут быть, а могут и не быть
любые другие слова и символы.

В Python это регулярное выражение может
выглядеть так:

[python]import re
pattern = re.compile(ur'(\w+): .*Josh.*’) # Our regex
string = u»Eli: Josh go move your laundry» # Our string

matches = re.(Джо)+ш$/.

Перечисление символов

Допустим, вы пишете regex, напоминающий
сандвич. Вы не знаете, захочет ли клиент
пшеничный хлеб или ржаной, вам любой
подойдет. Как добавить возможность
выбора в регулярное выражение? С помощью
перечисления символов!

Перечисления символов позволяют
определить набор возможных значений
для группы. В случае с нашим сандвичем
синтаксис будет такой: (пшеничный|ржаной).
Вертикальной чертой разделяются два
допустимых варианта. Это означает, что
и «пшеничный», и «ржаной» будет приемлемым
совпадением.

Для перечисления вариантов можно
также использовать квадратные [скобки].
Здесь возможным вариантом будет каждый
из символов «с», «к», «о», «б», «к», «и»
по отдельности. Это может быть удобным
для более сложных группировок символов,
поскольку позволяет заменить какой-нибудь
символ более сложным выражением внутри
группы символов.

Модификаторы (флаги)

До сих пор мы говорили о шаблоне внутри
/слэшей/, верно? Но что располагается за
их пределами?

Слева – ничего интересного. и $
обозначают начало и конец каждой
отдельной строки, а не только всего
текста. i insensitive – «нечувствительность» Игнорирование регистра [a-zA-Z]. x extended – «расширенный» Игнорируются пробелы и текст после
# в шаблоне. X extra – «добавочный» Любой неспециальный символ после
обратного слэша \ приводит к ошибке. s single line – «одна строка» Текст вхождения считается одной
строкой. Шаблон «точка» включает и
символы новой строки. u unicode Строки шаблона воспринимаются как
UTF-16. Также заставляет управляющие
последовательности соответствовать
символам Юникода. Полезно для поддержки
кириллических символов в регулярном
выражении. U ungreedy – инвертация жадности Совпадения становятся ленивыми по
умолчанию. Теперь знак вопроса после
квантификатора делает его жадным. A anchored – «закрепленный» Шаблон привязывается к началу строки. J duplicate – «дубликат» Разрешает одинаковые имена для
подшаблонов.

Например, до сих пор все наши примеры
были чувствительными к регистру. Это
значит, что изменение регистра любого
символа приведет к несовпадению с
шаблоном. Но добавив модификатор i, мы
можем сделать наш шаблон нечувствительным
к регистру.

Возможно, Эли была настолько злая, что
решила поспамить в чате с помощью
СМеШЕНия реГисТрОВ. Не стоит бояться,
у нас же есть i! Мы можем найти вхождение
строки «Я нЕеенавижу ЖиТь С ДЖОШем!!» с
помощью регулярного выражения /я
не+навижу жить с джошем!+/i. Теперь это
будет понятнее и полезнее. Прекрасно!

Остальные модификаторы я оставлю вам
для самостоятельного разбора, замечу
лишь, что в целом чаще всего используется
igm.

Что дальше?

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

В регулярных выражениях используется
множество символов / токенов. Скорее
всего вы будете натыкаться на них на
Stack Overflow. Иногда их значение можно
угадать, исходя из своего предыдущего
опыта (например, \n это символ новой
строки). Но в любом случае, остается еще
много для изучения.

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

А если все написанное здесь для вас легкотня, обратите внимание на regex-кроссворды. Уж они заставят вас мыслить регулярными выражениями!

Отрицание в регулярных выражениях «Исследования и разработки с открытым исходным кодом

Как искать строки, не содержащие определенного шаблона, довольно просто в одних программах, неясно в других и почти невозможно в других. То есть, если выбранная вами программа поддерживает регулярные выражения. Я рассмотрю, как добиться этой функциональности в Perl, Vim, grep и vi.

Отрицание регулярного выражения в Perl

Perl имеет множество нестандартных функций, поддерживаемых при сопоставлении регулярных выражений.Одна из этих функций в прогнозе (шаблон?) . Кроме того, функция просмотра вперед поддерживает отрицание (?! Шаблон) . Для поиска в Perl строк, содержащих foo , но не сопровождаемых bar в любом месте строки:

foo (?!. * Bar)

Отрицание регулярного выражения в Vim

Сопоставление регулярных выражений в Vim более гибкое, чем в vi. В частности, vim поддерживает синтаксис @! .Вы можете найти полное описание этой функции в vim, набрав : help / @ !. Для поиска в Vim строк, содержащих foo , но не сопровождаемых bar в любом месте строки:

foo (. abc] , что означает соответствие любому символу, кроме a , b и c .Отрицание совпадений выполняется с помощью параметра командной строки -v . Для поиска в grep строк, содержащих foo , но не сопровождаемых bar в любом месте строки:

grep -o 'foo. *' File | grep -v 'бар'

Обратите внимание, что это работает только в GNU grep, а не в стандартной UNIX grep, потому что -o - это расширение GNU grep, которого нет в UNIX grep.

Отрицание регулярного выражения в vi, ed и UNIX grep

Базовые регулярные выражения (BRE) и расширенные регулярные выражения (ERE) содержат только одну форму отрицания: отрицание класса символов.Это значительно усложняет построение шаблонов, включающих отрицание шаблона. Но это не невозможно. Один из способов добиться этого - сначала создать шаблон DFA, написать формулу, описывающую DFA, а затем объединить их в регулярное выражение. br])))) * ((b (b | (ab)) * a) | (b (b | (ab)) *) | $) $

Как показано, хотя отрицание шаблона может быть трудным в простых регулярных выражениях, это возможно, как некоторые могут подумать.

Эта запись была опубликована в субботу, 14 февраля 2009 г., в 12:41 и хранится в инструментах GREP. Вы можете следить за любыми ответами на эту запись через канал RSS 2.0.

И комментарии и запросы в настоящий момент закрыты.

Negative Lookahead — тестер / отладчик регулярных выражений

соответствует целому слову — тестер / отладчик Regex

Regex Tutorial — Lookahead and Lookbehind Assertions Zero-Length Assertions

Lookahead и lookbehind, вместе называемые «lookaround», представляют собой утверждения нулевой длины, такие же, как начало и конец строки, а также привязки начала и конца слова, описанные ранее в этом руководстве.Разница в том, что поиск действительно соответствует символам, но затем отказывается от совпадения, возвращая только результат: совпадение или отсутствие совпадения. Вот почему они называются «утверждениями». Они не используют символы в строке, а только подтверждают, возможно ли совпадение. Lookaround позволяет создавать регулярные выражения, которые невозможно создать без них или которые без них были бы очень долгими.

Положительный и отрицательный взгляд вперед

Отрицательный взгляд вперед незаменим, если вы хотите сопоставить что-то, за которым не следует что-то другое.При объяснении классов символов в этом руководстве объясняется, почему вы не можете использовать инвертированный класс символов для сопоставления q, за которым не следует u. Решение дает отрицательный просмотр вперед: q (?! U). Конструкция отрицательного просмотра вперед представляет собой пару круглых скобок с открывающей скобкой, за которой следует вопросительный знак и восклицательный знак. Внутри просмотра вперед есть тривиальное регулярное выражение u.

Положительный просмотр вперед работает точно так же. q (? = u) соответствует q, за которым следует u, без включения u в совпадение.Конструкция позитивного просмотра вперед представляет собой пару круглых скобок с открывающей скобкой, за которой следует вопросительный знак и знак равенства.

Внутри просмотра вперед можно использовать любое регулярное выражение (но не смотреть назад, как описано ниже). Внутри опережающего просмотра можно использовать любое допустимое регулярное выражение. Если он содержит группы захвата, то эти группы будут захватываться как обычно, и обратные ссылки на них будут работать нормально, даже за пределами просмотра вперед. (Единственным исключением является Tcl, который обрабатывает все группы внутри lookahead как не захватывающие.) Сам по себе опережающий просмотр не является группой захвата. Он не учитывается при нумерации обратных ссылок. Если вы хотите сохранить совпадение регулярного выражения внутри просмотра вперед, вы должны поместить захватывающие скобки вокруг регулярного выражения внутри просмотра вперед, например: (? = (Regex)). Другой способ не сработает, потому что опережающий просмотр уже отбросит совпадение регулярного выражения к тому времени, когда группа захвата сохранит его совпадение.

Внутреннее устройство механизма Regex

Во-первых, давайте посмотрим, как механизм применяет q (?! U) к строке Ирака.Первый токен в регулярном выражении — это литерал q. Как мы уже знаем, это заставляет движок перемещаться по строке до тех пор, пока не будет совпадать q в строке. Положение в строке теперь является пустым после строки. Следующий токен — это опережающий просмотр. Механизм отмечает, что теперь он находится внутри конструкции просмотра вперед, и начинает сопоставление регулярного выражения внутри конструкции просмотра вперед. Итак, следующий токен — это u. Это не соответствует пустоте после строки. Движок отмечает, что регулярное выражение внутри опережающего просмотра не удалось. Поскольку предварительный просмотр отрицательный, это означает, что предварительный просмотр успешно сопоставлен с текущей позицией.На этом этапе все регулярное выражение совпало, и q возвращается как совпадение.

Давайте попробуем применить то же регулярное выражение для выхода. q соответствует q. Следующий токен — это буква u внутри просмотра вперед. Следующий символ — u. Эти совпадения. Двигатель переходит к следующему символу: i. Однако это делается с помощью регулярного выражения внутри просмотра вперед. Движок отмечает успех и отбрасывает совпадение с регулярным выражением. Это заставляет движок вернуться в строку до u.

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

Давайте еще раз заглянем внутрь, чтобы убедиться, что вы понимаете последствия просмотра вперед. Давайте применим q (? = U) i, чтобы выйти. Предварительный просмотр теперь положительный, за ним следует другой токен. Опять же, q соответствует q, а u соответствует u. Опять же, совпадение из опережающего просмотра должно быть отброшено, поэтому движок отступает от i в строке к u.Предварительный просмотр был успешным, поэтому движок продолжает работать с i. Но я не могу соответствовать тебе. Итак, эта попытка совпадения не удалась Все остальные попытки также терпят неудачу, потому что в строке больше нет q.

Регулярное выражение q (? = U) i никогда не может ничего сопоставить. Он пытается сопоставить u и i в одной позиции. Если сразу после q стоит u, то просмотр вперед завершается успешно, но тогда i не может соответствовать u. Если сразу после q стоит что-то, кроме u, то просмотр вперед не выполняется.

Положительный и отрицательный взгляд назад

Просмотр назад имеет тот же эффект, но работает в обратном направлении.Он сообщает механизму регулярных выражений временно отступить в строке, чтобы проверить, может ли там быть сопоставлен текст внутри ретроспективного выражения. (?

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

Подробнее о внутреннем устройстве Regex Engine

Давайте применим (? <= A) b к thingamabob. Механизм запускается с просмотра назад и с первого символа в строке. В этом случае ретроспективный просмотр сообщает движку сделать шаг назад на один символ и посмотреть, можно ли сопоставить там a. Двигатель не может сделать шаг назад на один символ, потому что перед t нет символов. Таким образом, ретроспективный просмотр не выполняется, и движок снова запускается со следующего символа, h.(Обратите внимание, что здесь был бы успешным отрицательный просмотр назад.) Опять же, движок временно отходит на один символ назад, чтобы проверить, есть ли там «а». Он находит t, поэтому положительный просмотр назад снова терпит неудачу.

Поиск назад продолжает давать сбой, пока регулярное выражение не достигнет m в строке. Движок снова делает шаг назад на один символ и замечает, что там можно сопоставить a. Позитивный взгляд назад соответствует. Поскольку длина строки равна нулю, текущая позиция в строке остается на m.Следующий токен — b, который здесь не может совпадать. Следующий символ — это второй a в строке. Двигатель отступает и обнаруживает, что m не соответствует a.

Следующий символ — это первый символ b в строке. Двигатель отступает назад и обнаруживает, что a удовлетворяет взгляд назад. b соответствует b, и все регулярное выражение было успешно сопоставлено. Соответствует одному символу: первому b в строке.

Важные примечания о ретроспективе

Хорошая новость заключается в том, что вы можете использовать ретроспективный просмотр в любом месте регулярного выражения, а не только в начале.s \ W] \ b (звездочка вместо плюса и \ W в классе символов). Лично мне легче понять взгляд назад. Последнее регулярное выражение, которое работает правильно, имеет двойное отрицание (\ W в инвертированном классе символов). Двойное отрицание сбивает людей с толку. Однако не для двигателей с регулярными выражениями. (За исключением, возможно, Tcl, который обрабатывает отрицательные сокращения в классах отрицательных символов как ошибку.)

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

Многие разновидности регулярных выражений, включая те, которые используются в Perl, Python и Boost, допускают только строки фиксированной длины.Вы можете использовать буквальный текст, escape-символы, escape-последовательности Unicode, отличные от \ X, и классы символов. Вы не можете использовать квантификаторы или обратные ссылки. Вы можете использовать альтернативу, но только если все альтернативы имеют одинаковую длину. Эти разновидности оценивают ретроспективный просмотр, сначала возвращаясь назад через строку темы для того количества символов, которое требуется для ретроспективного просмотра, а затем пытаются выполнить регулярное выражение внутри ретроспективного просмотра слева направо.

Perl 5.30 поддерживает просмотр назад переменной длины в качестве экспериментальной возможности.Но во многих случаях это работает некорректно. Таким образом, на практике все вышесказанное верно и для Perl 5.30.

PCRE не полностью совместим с Perl, когда дело касается ретроспективного анализа. В то время как Perl требует, чтобы альтернативы внутри lookbehind имели одинаковую длину, PCRE допускает альтернативы переменной длины. PHP, Delphi, R и Ruby также позволяют это. Каждая альтернатива по-прежнему должна быть фиксированной длины. Каждая альтернатива рассматривается как отдельный ретроспективный просмотр фиксированной длины.

Java делает шаг вперед, разрешая конечное повторение.Вы можете использовать вопросительный знак и фигурные скобки с указанным параметром max . Java определяет минимальную и максимальную возможную длину ретроспективного просмотра. Поиск назад в тесте регулярного выражения (?

Java 13 позволяет использовать звездочку и плюс внутри ретроспективного обзора, а также фигурные скобки без верхнего предела. Но в Java 13 по-прежнему используется трудоемкий метод поиска назад, представленный в Java 6. Java 13 также неправильно обрабатывает обратный просмотр с несколькими квантификаторами, если один из них неограничен. В некоторых ситуациях может появиться ошибка.В других ситуациях вы можете получить неправильные совпадения. Таким образом, как для правильности, так и для производительности, мы рекомендуем вам использовать только квантификаторы с низкой верхней границей в ретроспективе с Java 6-13.

Единственные механизмы регулярных выражений, которые позволяют вам использовать полное регулярное выражение внутри ретроспективного просмотра, включая бесконечное повторение и обратные ссылки, — это движок JGsoft и классы RegEx платформы .NET. Эти механизмы регулярных выражений действительно применяют регулярное выражение внутри ретроспективного просмотра назад, проходя через регулярное выражение внутри ретроспективного выражения и через строку объекта справа налево.Им нужно оценить ретроспективный просмотр только один раз, независимо от того, сколько различных возможных длин у него есть.

Наконец, такие разновидности, как std :: regex и Tcl, вообще не поддерживают просмотр назад, хотя они и поддерживают просмотр вперед. JavaScript был таким долгое время с момента своего появления. Но теперь ретроспективный анализ является частью спецификации ECMAScript 2018. На момент написания этой статьи (конец 2019 г.) браузер Google Chrome был единственной популярной реализацией JavaScript, поддерживающей ретроспективный просмотр. Поэтому, если кроссбраузерная совместимость имеет значение, вы не можете использовать ретроспективный просмотр в JavaScript.

Lookaround является атомарным

Тот факт, что Lookaround имеет нулевую длину, автоматически делает его атомарным. Как только условие поиска будет выполнено, механизм регулярных выражений забывает обо всем, что находится внутри поиска. Он не будет возвращаться в обход, чтобы попробовать разные перестановки.

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

По этой причине регулярное выражение (? = (\ D +)) \ w + \ 1 никогда не соответствует 123×12. Сначала поиск переводит 123 в \ 1. \ w + затем сопоставляет всю строку и выполняет возврат, пока она не совпадет только с 1. Наконец, \ w + завершается ошибкой, поскольку \ 1 не может быть сопоставлен ни в одной позиции. Теперь механизму регулярных выражений не к чему возвращаться, и общее регулярное выражение не работает. Шаги возврата, созданные \ d +, были отброшены. Никогда не доходит до точки, когда просмотр вперед захватывает только 12.

Очевидно, что механизм регулярных выражений действительно пробует дальнейшие позиции в строке.Если мы изменим строку темы, регулярное выражение (? = (\ D +)) \ w + \ 1 будет соответствовать 56×56 в 456×56.

Если вы не используете группы захвата внутри Lookaround, то все это не имеет значения. Либо условие поиска может быть выполнено, либо нет. Неважно, какими способами она может быть удовлетворена.

Сделайте пожертвование

Этот веб-сайт только что сэкономил вам поездку в книжный магазин? Пожалуйста, сделайте пожертвование в поддержку этого сайта, и вы получите неограниченного доступа к этому сайту без рекламы!

Учебное пособие по

Regexp — классы символов или наборы символов

С помощью «класса символов», также называемого «набором символов», вы можете указать механизму регулярных выражений соответствовать только одному из нескольких символов.Просто поместите символы, которые вы хотите сопоставить, в квадратные скобки. Если вы хотите сопоставить a или e, используйте [ae]. Вы можете использовать это в gr [ae] y для соответствия серому или серому цвету. Очень полезно, если вы не знаете, написан ли документ, который вы ищете, на американском или британском английском.

Класс символов соответствует только одному символу. gr [ae] y не соответствует серому, серому или тому подобному. Порядок символов внутри класса символов не имеет значения. Результаты идентичны.

Вы можете использовать дефис внутри класса символов, чтобы указать диапазон символов. [0-9] соответствует одиночной цифре от 0 до 9. Можно использовать более одного диапазона. [0-9a-fA-F] соответствует одной шестнадцатеричной цифре без учета регистра. Вы можете комбинировать диапазоны и отдельные символы. [0-9a-fxA-FX] соответствует шестнадцатеричной цифре или букве X. Опять же, порядок символов и диапазоны не имеют значения.

Символьные классы — одна из наиболее часто используемых функций регулярных выражений.Вы можете найти слово, даже если оно написано с ошибкой, например sep [ae] r [ae] te или li [cs] en [cs] e. Вы можете найти идентификатор на языке программирования с помощью [A-Za-z _] [A-Za-z_0-9] *. Вы можете найти шестнадцатеричное число в стиле C с помощью 0 [xX] [A-Fa-f0-9] +.

Отрицательные классы символов

При вводе символа вставки после открывающей квадратной скобки класс символа отменяется. В результате класс символов соответствует любому символу, который равен , а не в классе символов. В отличие от точки, инвертированные классы символов также соответствуют (невидимым) символам разрыва строки.u] означает , а не : «q, за которым не следует u». Это означает: «q, за которым следует символ, не являющийся u». Это не соответствует q в строке Ирак. Это соответствует q, а пробел после q в Ираке — это страна. В самом деле: пробел становится частью общего совпадения, потому что это «символ, который не является u», которому соответствует инвертированный класс символов в приведенном выше регулярном выражении. Если вы хотите, чтобы регулярное выражение соответствовало q и только q в обеих строках, вам нужно использовать отрицательный просмотр вперед: q (?! U)., а дефис -. Обычные метасимволы — это обычные символы внутри класса символов, и их не нужно экранировать обратной косой чертой. Чтобы найти звезду или плюс, используйте [+ *]. Ваше регулярное выражение будет работать нормально, если вы избежите обычных метасимволов внутри класса символов, но это значительно ухудшит читаемость.

Чтобы включить обратную косую черту в качестве символа без какого-либо особого значения внутри класса символов, вы должны экранировать ее с помощью другой обратной косой черты. [\\ x] соответствует обратной косой черте или x.x-] соответствует любому символу, кроме x или дефиса. Это работает со всеми вариантами, обсуждаемыми в этом руководстве. Дефисы в других позициях в символьных классах, где они не могут образовывать диапазон, могут интерпретироваться как литералы или как ошибки. Ароматы регулярных выражений довольно противоречивы по этому поводу.

Многие токены регулярных выражений, которые работают вне классов символов, также могут использоваться внутри классов символов. Это включает в себя escape-символы, восьмеричные и шестнадцатеричные escape-символы для непечатаемых символов. Для разновидностей, поддерживающих Unicode, он также включает escape-символы Unicode и свойства Unicode.[$ \ u20AC] соответствует знаку доллара или евро, если ваш вариант регулярного выражения поддерживает экранирование Unicode.

Повторяющиеся классы символов

Если вы повторяете класс символов с помощью операторов?, * Или +, вы повторяете весь класс символов. Вы не повторяете только тот символ, которому он соответствует. Регулярное выражение [0-9] + может соответствовать 837, а также 222.

Если вы хотите повторить совпадающий символ, а не класс, вам нужно использовать обратные ссылки. ([0-9]) \ 1+ соответствует 222, но не 837.При применении к строке 833337 он соответствует 3333 в середине этой строки. Если вы этого не хотите, вам нужно использовать поиск.

Взгляд изнутри обработчика регулярных выражений

Как упоминалось ранее: порядок символов внутри класса символов не имеет значения. gr [ae] y совпадает с серым в его волосах серыми или серыми?, потому что это крайнее левое совпадение . Мы уже видели, как движок применяет регулярное выражение, состоящее только из буквальных символов. Теперь посмотрим, как он применяет регулярное выражение, имеющее более одной перестановки.То есть: gr [ae] y может соответствовать как серому, так и серому.

Ничего примечательного не происходит с первыми двенадцатью символами в строке. Движок не соответствует g на каждом шаге и продолжает работу со следующим символом в строке. Когда двигатель достигает 13-го символа, совпадает g. Затем движок пытается сопоставить оставшуюся часть регулярного выражения с текстом. Следующий токен в регулярном выражении — это литерал r, который соответствует следующему символу в тексте. Таким образом, третий токен, [ae] применяется к следующему символу в тексте (e).Класс символов дает движку два варианта: сопоставить a или сопоставить e. Сначала он пытается сопоставить a и терпит неудачу.

Но поскольку мы используем движок, управляемый регулярными выражениями, он должен продолжать попытки сопоставить все другие перестановки шаблона регулярного выражения, прежде чем решить, что регулярное выражение не может быть сопоставлено с текстом, начинающимся с символа 13. Поэтому он продолжает использовать другой вариант. , и находит, что e соответствует e. Последний токен регулярного выражения — это y, который также может быть сопоставлен со следующим символом. Движок обнаружил полное совпадение с текстом, начинающимся с символа 13.Он возвращает серый цвет в качестве результата совпадения и больше не смотрит. Опять же, возвращается крайнее левое совпадение , даже несмотря на то, что мы поместили первый в класс символов, и серый цвет мог быть сопоставлен в строке. Но двигатель просто не продвинулся так далеко, потому что слева от него было найдено другое не менее достоверное совпадение. серый будет соответствовать только в том случае, если вы укажете механизму регулярных выражений продолжить поиск второго совпадения в оставшейся части строки темы после первого совпадения.

Сделайте пожертвование

Этот веб-сайт только что сэкономил вам поездку в книжный магазин? Пожалуйста, сделайте пожертвование в поддержку этого сайта, и вы получите неограниченного доступа к этому сайту без рекламы!

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

Если вы уже знаете, какая функция вам нужна, но забыли, какой синтаксис использовать, найдите ее в справочной таблице содержания регулярных выражений.$. |? * + () {}

901 Вызов подпрограммы

90 104

Unicode

P {^ Property}

\

Di Неужели этот сайт просто сэкономит вам поездку в книжный магазин? Пожалуйста, сделайте пожертвование в поддержку этого сайта, и вы получите неограниченного доступа к этому сайту без рекламы!

.