Регэкспы что это: Regexp — это «язык программирования». Основы / Хабр

Содержание

Regexp — это «язык программирования». Основы / Хабр

Несколько лет назад я думал, что regexp осуществляет линейный поиск по тексту, но какое моё удивление было, когда я понял, что это не так. Тогда я убедился на собственном опыте, что от простой смены местами а и b в схеме (…a…)|(…b…) поменялся полностью результат.

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

Ветвления в regexp

Регулярные выражения работают по схеме направленного дерева.
Например ветвление (a …)|(b …)|(c …) можно записать:
If (char=='a'){
...
}else if (char =='b'){
...
}else if (char =='c'){
...
}

Именно поэтому перестановка местами 'b ...' и 'a . ..' влияет на результат – потому что здесь расставляются приоритеты выполнения (в каком порядке поставишь, так и будет выполняться).

Именно поэтому стоит следить за тем, что приоритетнее и стараться условия делать оптимально вытесняющими друг друга.
Причём выполняться всё, что за ‘a’ будет при условии того, что всё до ‘a’ (включая ‘a’) выполнено.

Пишем парсер кавычек

Рассмотрим простой пример.

Давайте возьмём подопытную строку 123"ABC\"D\EF"GHI""\"KEY и начнём над ней издеваться:

Первое, что появляется в голове — /".*"/ выражение. Оно будет действовать по алгоритму:
1) Производим поиск первой одной "
2) Пока у нас любой символ (в том числе и "), мы проходим дальше
3) В конце должна быть тоже "
В результате, правильно, мы получили "ABC\"D\EF"GHI""\".
То есть нашли первую кавычку. Дальше, пока выполнялось условие брали следующие символы (в том числе и

") и делали, пока последней не оказалась ". \\\\]. (см. последний пример) В этом случае, нахождения в строке «\» не произойдёт, как и должно быть.

regexp

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

Следующие таблицы описывают элементы регулярных выражений.

Метасимволы

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

Метасимвол

Описание

Пример

.

Любой отдельный символ, включая пробел

'..ain' последовательности соответствий пяти последовательных символов тот конец с 'ain'.

[c1c2c3]

Любой символ содержится в квадратных скобках. *rp]ain’ соответствия все последовательности с четырьмя буквами тот конец в 'ain', кроме 'rain' и 'pain' и '*ain'. Например, это совпадает с 'gain', 'lain', или 'vain'.

[c1-c2]

Любой символ в области значений

c1 через c2

'[A-G]' совпадает с отдельным символом в области значений A через G.

\w

Любой алфавитный, числовой, или символ подчеркивания. Для английских наборов символов, \w эквивалентно [a-zA-Z_0-9]

'\w*' идентифицирует слово, состоявшее из любой группировки алфавитных, числовых, или символов подчеркивания.

\W

Любой символ, который не является алфавитным, числовым, или подчеркивание. 0-9]

'\w*\D\>' распознает слова, которые не заканчиваются числовой цифрой.

\oN или \o{N}

Символ восьмеричного значения N

'\o{40}' совпадает с пробелом, заданным восьмеричным 40.

\xN или \x{N}

Символ шестнадцатеричного значения N

'\x2C' совпадает с символом запятой, заданным шестнадцатеричным 2C.

Символьное представление

Оператор

Описание

\a

Предупреждение (звуковой сигнал)

\b

Клавиша Backspace

\f

Перевод формата

\n

Новая строка

\r

Возврат каретки

\t

Горизонтальная табуляция

\v

Вертикальная табуляция

'char'

Любой символ с особым значением в регулярных выражениях, с которыми вы хотите совпадать буквально (например, используйте \\ совпадать с одной обратной косой чертой)

Кванторы

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

Квантор

Выражение числа раз происходит

Пример

expr*

0 или больше раз последовательно.

'\w*' распознает слово любой длины.

expr?

0 раз или в 1 раз.

'\w*(\.m)?' распознает слова, которые опционально заканчиваются дополнительным .m.

expr+

1 или более раз последовательно.

'<img src="\w+\.gif">' совпадает с <img> HTML-тэг, когда имя файла содержит один или несколько символов.

expr{m,n}

По крайней мере, m времена, но не больше, чем n времена последовательно.

{0,1} эквивалентно ?.

'\S{4,8}' соответствия между четырьмя и восемью непробельными символами.

expr{m,}

По крайней мере, m времена последовательно.

{0,} и {1,} эквивалентны * и +, соответственно.

'<a href="\w{1,}\.html">' совпадает с <a> HTML-тэг, когда имя файла содержит один или несколько символов.

expr{n}

Точно n времена последовательно.

Эквивалентный {n,n}.

'\d{4}' соответствия четыре последовательных цифры.

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

Режим

Описание

Пример

exprq

Жадное выражение: совпадайте с как можно большим количеством символов.

Учитывая текст '<tr><td><p>text</p></td>', выражение '</?t.*>' соответствия все символы между <tr и /td>:

'<tr><td><p>text</p></td>'

exprq?

Ленивое выражение: совпадайте с таким же небольшим количеством символов по мере необходимости.

Учитывая text'<tr><td><p>text</p></td>', выражение '</?t.*?>' заканчивает каждый матч при первом вхождении закрывающей угловой скобки (>):

exprq +

Притяжательное выражение: соответствуйте как можно больше, но не повторно сканируйте фрагменты текста.

Учитывая text'<tr><td><p>text</p></td>', выражение '</?t.*+>' не возвращает соответствий, потому что закрывающая угловая скобка получена с помощью . aeiou]{2}'совпадает с гласным, сопровождаемым двумя негласными.

(?>expr)

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

'A(?>.*)Z' не совпадает с 'AtoZ', несмотря на то, что 'A(?:.*)Z' делает. Используя атомарную группу, Z получен с помощью .* и не повторно сканируется.

(expr1|expr2)

Совпадайте с выражением expr1 или выражение expr2.

Если существует соответствие с expr1, затем expr2 проигнорирован.

Можно включать ?: или ?> после вводной круглой скобки, чтобы подавить лексемы или группу атомарно.

'(let|tel)\w+' распознает слова, которые запускаются с let или tel.

Привязки

Привязки в выражении совпадают с началом или концом входного текста или слова.

M\w*’ распознает слово начиная с M в начале текста.

expr$

Конец входного текста.

'\w*m$' слова соответствий, заканчивающиеся m в конце текста.

\<expr

Начало слова.

'\<n\w*' распознает любые слова начиная с n.

expr\>

Конец слова.

'\w*e\>' соответствия любые слова, заканчивающиеся e.

Утверждения Lookaround

Утверждения Lookaround ищут шаблоны, которые сразу предшествуют или следуют за намеченным соответствием, но не являются частью соответствия.

Указатель остается в текущем местоположении и символах, которые соответствуют

test выражение не получено или отброшено. Поэтому предварительные утверждения могут совпадать с перекрывающимися группами символов.

Утверждение Lookaround

Описание

Пример

expr(?=test)

Предусмотрите для символов то соответствие test.

'\w*(?=ing)' условия соответствий, которые сопровождаются ing, такой как 'Fly' и 'fall' во входном тексте 'Flying, not falling.'

expr(?!test)

Смотрите вперед для символов, которые не совпадают с test.

'i(?!ng)' экземпляры соответствий буквы i это не сопровождается ng.

(?<=test)expr

Оглянитесь для символов то соответствие test.

'(?<=re)\w*' условия соответствий, которые следуют за 're', такой как 'new'Использование, и 'cycle' во входном тексте 'renew, reuse, recycle'

(?<!test)expr

Оглянитесь для символов, которые не совпадают с test. aeiou]’ согласные соответствий.

(?!test)expr

Совпадайте с expr и не совпадайте с test.

'(?![aeiou])[a-z]' согласные соответствий.

Логические и условные операторы

Логические и условные операторы позволяют вам тестировать состояние данного условия, и затем использовать результат, чтобы определить который шаблон, если таковые имеются, соответствовать затем. Эти операторы поддерживают логический OR, и if или if/else условия.

Условиями могут быть лексемы, lookaround операторы или динамические выражения формы ([email protected]). Динамические выражения должны возвратить логическое или числовое значение.

Условный оператор

Описание

Пример

expr1|expr2

Совпадайте с выражением expr1 или выражение expr2.

Если существует соответствие с expr1, затем expr2 проигнорирован.

'(let|tel)\w+' распознает слова, которые запускаются с let или tel.

(?(cond)expr)

Если условие cond true, затем совпадайте с expr.

'(?([email protected])[A-Z]:\\)' совпадает с именем дисковода, таким как C:\, когда работается система Windows®.

(?(cond)expr1|expr2)

Если условие cond true, затем совпадайте с expr1. В противном случае совпадайте с expr2.

'Mr(s?)\..*?(?(1)her|his) \w*' текст соответствий, который включает her когда текст начинается с Mrs, или это включает his когда текст начинается с Mr.

Маркерные операторы

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

Порядковый маркерный оператор

Описание

Пример

(expr)

Получите в лексеме символы, которые совпадают с заключенным в нихом выражение.

'Joh?n\s(\w*)' получает лексему, которая содержит фамилию любого человека с именем John или Jon.

\N

Совпадайте с Nлексема th.

'<(\w+).*>.*</\1>' лексемы получений для HTML-тэгов, таких как 'title' из текста '<title>Some text</title>'.

(?(N)expr1|expr2)

Если Nлексема th найдена, затем совпадайте с expr1. В противном случае совпадайте с expr2.

'Mr(s?)\..*?(?(1)her|his) \w*' текст соответствий, который включает her когда текст начинается с Mrs, или это включает his когда текст начинается с Mr.

Названный маркерный оператор

Описание

Пример

(?<name>expr)

Получите в именованной лексеме символы, которые совпадают с заключенным в нихом выражение.

'(?<month>\d+)-(?<day>\d+)-(?<yr>\d+)' создает названные лексемы в течение месяца, дня и года на входной дате формы mm-dd-yy.

\k<name>

Совпадайте с лексемой, упомянутой name.

'<(?<tag>\w+).*>.*</\k<tag>>' лексемы получений для HTML-тэгов, таких как 'title' из текста '<title>Some text</title>'.

(?(name)expr1|expr2)

Если именованная лексема найдена, то совпадайте с expr1. В противном случае совпадайте с expr2.

'Mr(?<sex>s?)\..*?(?(sex)her|his) \w*' текст соответствий, который включает her когда текст начинается с Mrs, или это включает his когда текст начинается с Mr.

Примечание

Если выражение вложило круглые скобки, MATLAB® получает лексемы, которые соответствуют наиболее удаленному набору круглых скобок. Например, учитывая поисковый шаблон '(and(y|rew))', MATLAB создает лексему для 'andrew' но не для 'y' или 'rew'.

Динамические регулярные выражения

Динамические выражения позволяют вам выполнять команду MATLAB или регулярное выражение, чтобы определить текст, чтобы соответствовать. (\d+)((??\\w{$1}))’ определяет сколько символов, чтобы соответствовать путем чтения цифры в начале соответствия. Динамическое выражение заключено во второй набор круглых скобок так, чтобы получившееся соответствие было получено в лексеме. Например, соответствие с '5XXXXX' лексемы получений для '5' и 'XXXXX'.

([email protected])

Выполните команду MATLAB, представленную cmd, и включайте выходной параметр, возвращенный командой в выражении соответствия.

'(.{2,}).?([email protected]($1))' находит палиндромы, которые являются по крайней мере четырьмя символами долго, такими как 'abba'.

([email protected])

Выполните команду MATLAB, представленную cmd, но отбросьте любой выходной параметр, который возвращает команда. (Полезный для диагностирования регулярных выражений.)

'\w*?(\w)([email protected]($1))\1\w*' распознает слова, которые включают двойные буквы (такие как pp), и отображает промежуточные результаты.

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

Заменяющий оператор

Описание

$& или $0

Фрагмент входного текста, который является в настоящее время соответствием

$`

Фрагмент входного текста, который предшествует текущему соответствию

$'

Фрагмент входного текста, который следует за текущим соответствием (используют $'' представлять $')

$N

Nлексема th

$<name>

Названная лексема

${cmd}

Выведите возвратился, когда MATLAB выполняет команду, cmd

Комментарии

‘characters’

Описание

Пример

(?#comment)

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

'(?# Initial digit)\<\d\w+' включает комментарий и распознает слова, которые начинаются с номера.

Поисковые флаги

Поисковые флаги изменяют поведение для соответствия с выражениями. Альтернатива использованию поискового флага в рамках выражения должна передать option входной параметр.

Флаг

Описание

(?-i)

Совпадайте с регистром (значение по умолчанию для regexp и regexprep).

(?i)

Не совпадайте с регистром (значение по умолчанию для regexpi).

(?s)

Точка соответствия (.) в шаблоне с любым символом (значение по умолчанию).

(?-s)

Точка соответствия в шаблоне с любым символом, который не является символом новой строки. и $ метасимволы вначале и конец линии.

(?-x)

Включайте пробелы и комментарии при соответствии (значение по умолчанию).

(?x)

Проигнорируйте пробелы и комментарии при соответствии. Использование и '\#' совпадать с пробелом и # ‘characters’.

Выражение, которое изменяет флаг, может появиться любой после круглых скобок, такой как

или в круглых скобках и разделенный от флага с двоеточием (:), такой как

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

Типы данных: char | cell | string

RegExp [АйТи бубен]

Регулярные выражения (regular expressions, сокр. RegExp, RegEx) — это формальный язык поиска и осуществления манипуляций с подстроками в тексте, основанный на использовании метасимволов (wildcard characters). По сути это строка-шаблон (pattern), состоящая из символов и метасимволов и задающая правило поиска.

При реализации механизмов регулярных выражений обычно используются две базовые технологии: НКА (недетерминированный конечный автомат) и ДКА (детерминированный конечный автомат). Механизмы отличаются подходом к сравнению регулярного выражений со строкой. Говорят, что механизм НКА «управляется регулярным выражением», а механизм ДКА «управляется текстом». Самым распространенным является НКА.

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

Невозможно построить универсальное регулярное выражения в отрыве от контента. …] Инвертированный символьный классЛюбой символ, не перечисленный в классе. \символ Экранирование Если перед метасимволом ставится экранирующий префикс \, то символ интерпретируется как соответствующий литерал. Например, символ "." является спецсимволом, если же нужно чтобы он воспринимался буквально, т.е. означал именно точку, то нужно записать так: "\." Квантификаторы

?
Вопросительный знакМинимальные квантификаторы. Допускается один экземпляр (ни один не требуется). Повторение предшествующего элемента ноль или один раз. Эквивалентно {0,1}
*
ЗвездочкаЖадный квантификатор. Допускается любое количество экземпляров (ни один не требуется). Повторение предшествующего элемента (включая цифры, буквы или выражения) ноль или более раз. Эквивалентно {0,} Например: [0-9]* означает любое количество цифр от 0 до 9. Крышка, домик, циркумфлексПозиция в начале строки. Если установлен флаг многострочного поиска, то начало любой строки в тексте.
\A
Позиция в начале строки. Метасимвол \A (если он поддерживается) совпадает только в начале текста независимо от режима поиска.
$
Знак доллараПозиция в конце строки. Если установлен флаг многострочного поиска, то конец любой строки в тексте.
\Z \z
Позиция в конце строки. Метасимвол \Z (если он поддерживается) обычно соответствует метасимволу $ в стандартном режиме, что часто означает совпадение в конце текста или перед символом новой строки, завершающим текст. Парный метасимвол \z совпадает только в конце строки без учета возможных символов новой строки.
\< или \b
Граница словаПозиция в начале слова. \b граница слова, т. е. позиция между словом и пробелом или переводом строки.
/> или \b
Граница словаПозиция в конце слова. \b граница слова, т. е. позиция между словом и пробелом или переводом строки.
\b
ЗабойОбычно соответствует ASCII символу <BS>, код 010 (в восьмеричной системе). Обратите внимание: во многих диалектах \b интерпретируется как символ забоя только внутри символьных классов, а за их пределами – как граница слова. Во многих реализация \b только для латинских слов и Unicode не понимает.
\B
Граница словаЛюбая позиция кроме границы слова. Прочие метасимволы
|
Конструкция выбораЛюбое из перечисленных выражений. Например, условие "или" (a или b). Так как в данном случае с обеих сторон разделителя ровно по одному символу, то можно заменить на [ab]
(…)
Круглые скобкиСлужит для ограничения конструкции выбора, группировки для применения квантификаторов и «сохранения» текста для обратных ссылок. Подвыражения нумеруются в соответствии с номером по порядку открывающей круглой скобки, начиная с 1. Подвыражения могут быть вложенными – например, (Washington(•DC)?). Обычные (сохраняющие) круглые скобки (…) могут быть применены только с целью группировки, но и в этом случае соответствующая специальная переменная заполняется текстом совпадения.
(?:…)
Круглые скобкиСлужит для группировки символов без сохранения. Т.е. нельзя использовать обратные ссылки для выражения в таких скобках.
\1,\2,…
Обратная ссылкаТекст, ранее совпавший с первой, второй и т.д. парами круглых скобок. Метасимволы для представления машиннозависимых управляющих символов
\a
СигналСигнал (при «выводе» раздается звуковой сигнал). Обычно соответствует ASCII символу <BEL>, код 007 (в восьмеричной системе).
\e
Символ EscapeОбычно соответствует ASCII символу <ESC>, код 033 (в восьмеричной системе).
\f
Перевод форматаОбычно соответствует ASCII символу <FF>, код 014 (в восьмеричной системе).
\n
Символ перевода строкиНовая строка. На большинстве платформ (включая Unix и DOS/Windows) обычно соответствует ASCII символу <LF>, код 012 (в восьмеричной системе). В системе MacOS обычно соответствует ASCII символу <CR>, код 015 (в восьмеричной системе). В Java и языках .NET всегда соответствует ASCII символу <LF> независимо от платформы.
\r
Символ возврата кареткиОбычно соответствует ASCII символу <CR>. В системе MacOS обычно соответствует ASCII символу <LF>. В Java и языках .NET всегда соответствует ASCII символу <CR> независимо от платформы.
\t
Символ горизонтальной табуляцииГоризонтальная табуляция. Обычно соответствует ASCII символу <НТ>, код 011 (в восьмеричной системе). 0-9]

Регулярное выражение .* всегда распространяет совпадение до конца строки. Это связано с тем, что .* стремится захватить все, что может. Впрочем, позднее часть захваченного может быть возвращена, если это необходимо для общего совпадения. Иногда это поведение вызывает немало проблем. Рассмотрим регулярное выражение для поиска текста, заключенного в кавычки. На первый взгляд напрашивается простое ".*", но попробуйте на основании того, что нам известно о .*, предположить, какое совпадение будет найдено в строке:

The name "McDonald's" is said "makudonarudo" in Japanese

После совпадения первого символа " управление передается конструкции .*, которая немедленно захватывает все символы до конца строки. Она начинает нехотя отступать (под нажимом механизма регулярных выражений), но только до тех пор, пока не будет найдено совпадение для последней кавычки. Если прокрутить происходящее в голове, вы поймете, что найденное совпадение будет выглядеть так(выделено нижним подчеркиванием):

The name "McDonald's" is said "makudonarudo" in Japanese

Найден совсем не тот текст, который мы искали. "\n].

В некоторых вариантах НКА поддерживаются минимальные квантификаторы, при этом *? является минимальным аналогом квантификатора *. Квантификатор стремится к минимальному захвату.

В Unicode определяется несколько символов (а также одна последовательность из двух символов), которые считаются завершителями строк (line terminators).

Завершители строк в Юникоде
Символ Описание
LF U+000A Перевод строки (ASCII)
VT U+000B Вертикальная табуляция (ASCII)
FF U+000C Перевод формата (ASCII)
CR U+000D Возврат каретки (ASCII)
CR/LF U+000D U+000A Возврат каретки/перевод строки (ASCII последовательность)
NEL Следующая строка (Юникод)
LS U+2028 Разделитель строк (Юникод)
PS U+2029 Разделитель абзацев (Юникод)

При наличии полноценной поддержки со стороны программы завершители строк влияют на результаты чтения строк из файла (в сценарных языках – включая файл, из которого читается программа). , $ и \Z

Примеры использования:

Свойства Unicode, алфавиты и блоки: \р{свойство}, \Р{свойство}. На концептуальном уровне Юникод представляет собой отображение множества символов на множество кодов, но стандарт Юникода не сводится к простому перечислению пар. Он также определяет атрибуты символов (например, «этот символ является строчной буквой», «этот символ пишется справа налево», «этот символ является диакритическим знаком, который должен объединяться с другим символом» и т. д.). Уровень поддержки этих атрибутов зависит от конкретной программы, но многие программы с поддержкой Юникода позволяют находить хотя бы некоторые из них при помощи конструкций \p{атрибут} (символ, обладающий указанным атрибутом) и \P{атрибут} (символ, не обладающий атрибутом).

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

Задача: Разбить число на разряды например запятыми. Формально задача выглядит так «вставить запятые во всех позициях, у которых количество цифр справа кратно трем, а слева есть хотя бы одна цифра»

Второе требование выполняется при помощи ретроспективной проверки. Одной цифры слева достаточно для выполнения этого требования, а этот критерий задается выражением (?⇐\d).

Группа из трех цифр определяется выражением \d\d\d. Заключим ее в конструкцию (…)+, чтобы совпадение могло состоять из нескольких групп, и завершим метасимволом $, чтобы гарантировать отсутствие символов после совпадения. Само по себе выражение (\d\d\d)+$ совпадает с группами из трех цифр, следующими до конца строки, но в конструкции опережающей проверки (?=…) оно совпадает с позицией, справа от которой до конца строки следуют группы из трех цифр. Однако перед первой цифрой запятая не ставится, поэтому совпадение дополнительно ограничивается ретроспективной проверкой (?⇐\d).

Чтобы выражение стало более эффективным можно добавить несохраняющие скобки ?: в (?:\d\d\d), в этом случае подсистема регулярных выражений не будет тратить ресурсы на сохранение текста в круглых скобках.

12. Регулярные выражения [Zabbix Documentation 5.2]

Обзор

Zabbix поддерживает Perl совместимые регулярные выражения (PCRE).

Имеется два варианта использования регулярных выражений в Zabbix:

  • ввод регулярного выражения вручную

  • использование глобальных регулярных выражений созданных в Zabbix

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

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

Глобальные регулярные выражения

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

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

Для создания глобального регулярного выражения:

  • Перейдите в: Администрирование → Общие

  • Выберите Регулярные выражения в выпадающем списке

  • Нажмите на Новое регулярное выражение

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

Все обязательные поля ввода отмечены красной звёздочкой.

Параметр Описание
Имя Укажите имя регулярного выражения. Разрешены любые Unicode символы.
Выражения Нажмите на Добавить в Блоке выражений для того, чтобы добавить новое подвыражение.
Тип выражения Выберите тип выражения:
Строка символов включена - совпадение по подстроке
Любоая строка символов включена - совпадение по любой из подстрок из списка с разделителями. Разделители в списке включают в себя запятую (,), точку (.) или прямую косую черту (/).
Строка символов не включена - совпадение по любой строке за исключением подстроки
Результат ПРАВДА - совпадение с регулярным выражением
Результат ЛОЖЬ - отсутствие совпадения с регулярным выражением
Выражение Укажите подстроку/регулярное выражение.
Разделитель Запятая (,), точка (.) или прямая косая черта (/) для разделения текстовых строк в регулярном выражении. Этот параметр доступен только когда выбран режим типа выражения “Любоая строка символов включена”.
Регистрозависимое Отметьте эту опцию чтобы указать является ли регулярное выражение чувствительным к регистру букв.

Начиная с Zabbix 2.4.0, косая черта (/) в выражении воспринимается буквально, нежели как разделитель. Таким образом возможно сохранить выражения содержащие косую черту, тогда как ранее такая запись приводила к ошибке.

В Zabbix имя пользовательского регулярного выражения может содержать запятые, пробелы и т.п. В этих случаях, там где имеется вероятность неверной интерпретации при использовании ссылки (например, запятая в параметре ключа элемента данных) нужно всю ссылку заключить в кавычки, вот таким образом: "@Мое выражение для цели, цели2". TESTDATABASE$

Выбран Тип выражения: "Результат ЛОЖЬ". Не соответствует имени, содержащему строку “TESTDATABASE”.

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

Использование следующего регулярного выражения, которое включает inline модификатор (?i) для поиска соответствия символов “error”:

(?i)error

Выбран Тип выражения: "Релультат ПРАВДА". Символы “error” совпадают.

Другой пример с использованием inline модификатора регулярного выражения

Использование следующего регулярного выражения, которое включает несколько inline модификаторов для поиска соответствия символов после указанной строки:

(?<=match (?i)everything(?-i) after this line\n)(?sx).*# мы добавили s модификатор, чтобы разрешить . соответствие символам перехода на новую строку

Выбран Тип выражения: "Релультат ПРАВДА". Символы после указанной строки совпадают.

Модификатор g нельзя указывать в строке. Список доступных модификаторов можно найти на странице помощи по pcresyntax [en]. Для получения более подробной информации о синтаксисе PCRE, пожалуйста, обратитесь к PCRE HTML документации [en].
Более сложный пример

Пользовательское регулярное выражение может состоять из нескольких подвыражений, и их можно протестировать на вкладке Тест, используя тестовую строку.

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

Общее состояние пользовательского выражения определяется как Комбинированный результат. Если задано несколько подвыражений, для вычисления Комбинированного результата Zabbix использует логический оператор И. Такое поведение означает, если по крайней мере один Результат является ЛОЖЬЮ, тогда Комбинированный результат будет также иметь состояние Ложь.

Объяснение глобальных регулярных выражений
Глобальное регулярное выражениеВыражениеОписание
File systems for discovery ^(btrfs|ext2|ext3|ext4|jfs|reiser|xfs|ffs|ufs|jfs|jfs2|vxfs|hfs|refs|ntfs|fat32|zfs)$ Соответствие “btrfs” или “ext2” или “ext3” или “ext4” или “jfs” или “reiser” или “ xfs” или “ffs” или “ufs” или “jfs” или “jfs2” или “vxfs” или “hfs” или “refs” или “ntfs” или “fat32” или “zfs”
Network interfaces for discovery ^Software Loopback Interface Соответствие строкам, которые начинаются с “Software Loopback Interface”
^lo$ Соответствие “lo”
^(In)?[Ll]oop[Bb]ack[0-9. (automatic|automatic delayed)$ Соответствие “automatic” или “automatic delayed”.
Поддержка регулярных выражений по назначению
НазначениеРегулярное выражениеГлобальное регулярное выражениеКомментарии
Элементы данных агента
eventlog[] ДаДаПараметры регулярное выражение, важность, источник, eventid
log[] Параметр регулярное выражение
log.count[]
logrt[] Да/НетПараметр регулярное выражение поддерживает оба варианта, параметр регулярное_выражение_файла поддерживает только не глобальные выражения
logrt. count[]
proc.cpu.util[] Нет Параметр cmdline
proc.mem[]
proc.num[]
sensor[] Параметры устройство и датчик в Linux 2.4
system.hw.macaddr[] Параметр интерфейс
system.sw.packages[]Параметр пакет
vfs.dir.count[] Параметры regex_вкл и regex_искл
vfs.dir.size[] Параметры regex_вкл и regex_искл
vfs.file.regexp[] Параметр регулярное выражение
vfs.file.regmatch[]
web.page.regexp[]
SNMP трапы
snmptrap[] ДаДаПареметр regexp
Предобработка значений элементов данных ДаНетПараметр шаблон
Функции триггеров
count() ДаДаПараметр шаблон, если параметр оператор равен regexp или iregexp
logeventid()Параметр шаблон
logsource()
iregexp()
regexp()
Низкоуровневое обнаружение ДаДаПоле Фильтр
Веб-мониторинг ДаНет Переменные с префиком regex:
Поле Требуемая строка
Функции макросов
regsub() ДаНет Параметр шаблон
iregsub()
Соответствие иконок ДаДаПоле Выражение

Введение в регулярные выражения в JavaScript | by Victoria Likhanova | NOP::Nuances of Programming

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

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

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

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

Конструктор регулярных выражений

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

Второй параметр — строка с флагами (flags). Не волнуйтесь, скоро мы с ними познакомимся. Этот параметр необязательный. Стоит запомнить одно: после создания регулярного выражения флаги уже нельзя будет добавить или убрать. Поэтому, если хотите использовать флаг, добавьте его на этапе создания выражения.

// Синтаксис конструктора регулярных выражений
new RegExp(pattern[, flags])// Создание регулярного выражения
// с помощью конструктора
// без флагов
const myPattern = new RegExp('[a-z]')// Создание регулярного выражения
// с помощью конструктора
// с одним флагом
const myPattern = new RegExp('[a-z]', 'g')

Литерал регулярных выражений

Второй способ — использование литерала. Как и конструктор, литерал регулярных выражений состоит из двух частей. Первая часть — это описываемый шаблон. Он заключается в слэши (//). После закрывающего слэша идёт вторая часть — флаги. Они необязательны.

// Синтаксис литерала регулярных выражений
/pattern/flags// Создание регулярного выражения
// с помощью литерала
// без флагов
const myPattern = /[a-z]/// Создание регулярного выражения
// с помощью литерала
// с одним флагом
const myPattern = /[a-z]/g

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

Конструктор или литерал?

Конструктор и литерал выполняют одну функцию, но есть одно важное различие. Регулярное выражение, созданное при помощи конструктора, компилируется при выполнении программы, литерал — на этапе загрузки скрипта. Это значит, что литерал нельзя изменить динамически, в то время как конструктор — можно.

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

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

test()

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

// Синтаксис метода test()
// /шаблон/.test('проверяемый текст')
// Проверка строки,

// когда test() не находит совпадений
myPattern.test('There was a cat and dog in the house.')
// false
// Создание переменной,
// которой присваивается текст для проверки
const myString = 'The world of code.'
// Создание шаблона
const myPattern = /code/
// Проверка текста с помощью шаблона,

// когда test() находит совпадение
myPattern.test(myString)
// true

exec()

Ещё один метод, который можно использовать — exec(). Если есть совпадение, метод exec() возвращает массив. Массив содержит в себе информацию об используемом шаблоне, позиции, на которой было найдено совпадение, проверяемом тексте и наборах. Если совпадений нет, метод exec() возвращает null.

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

// Синтаксис метода exec()
// /шаблон/.exec('проверяемый текст')
// Создание строки для проверки

const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование exec() для проверки текста,
// когда exec() находит совпадение
myPattern.exec(myString)
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// Описание другого шаблона

const myPatternTwo = /JavaScript/// Использование exec() с новым шаблоном для новой проверки текста,
// когда exec() не находит совпадений
myPatternTwo.exec(myString)
// null

test() и exec() — не единственные методы, которые можно использовать для поиска совпадений строки с шаблоном. Есть ещё search(), match() и matchAll(). Эти методы принадлежат не объекту RegExp, а строкам. Несмотря на это, они позволяют применять регулярные выражения.

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

search()

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

// Синтаксис метода search()
// 'проверяемый текст'.search(/шаблон/)
// Создание текста для проверки

const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/// Использование search() для поиска
//совпадения строки с шаблоном,
//когда search() находит совпадение

myString. search(myPattern)
// -13
// Вызов search() прямо на строке,

// когда search() не находит совпадений
'Another day in the life.'.search(myPattern)
// -1

match()

match() — второй метод объекта String, который позволяет использовать регулярные выражения. Он работает аналогично exec(): при нахождении совпадения метод match() возвращает массив с информацией об использованном шаблоне, позиции в строке, на которой было найдено совпадение, проверяемом тексте и наборах.

Так же как и exec(), match() возвращает null при отсутствии совпадений. При использовании метода match() с флагом g для поиска всех совпадений с шаблоном возвращается массив из всех совпадений.

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)
// Создание текста для проверки

const myString = 'The world of code is not full of code. '// Описание шаблона
const myPattern = /code/// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]'Another day in the life.'.match(myPattern)
// null
// Использование match() для поиска всех совпадений

// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/g // добавление флага 'g'// Использование match() для поиска совпадения в тексте
myString.match(myPattern)
// [ 'code', 'code' ]

matchAll()

Подобно методу match(), matchAll() возвращает все совпадения при использовании флага g в шаблоне. Однако работает он по-другому. Метод matchAll() возвращает объект RegExp String Iterator. Есть несколько способов извлечь из него все совпадения.

Во-первых, можно пройтись по объекту циклом for…of и вернуть или записать все совпадения. Также можно использовать Array.from(), чтобы создать массив из содержимого объекта, или оператор spread, который даст точно такой же результат, как и Array.from().

// Синтаксис метода match()
// 'проверяемый текст'.match(/шаблон/)// Создание текста для проверки
const myString = 'The world of code is not full of code.'// Описание шаблона
const myPattern = /code/g
// Обратите внимание, что используется флаг 'g'// Использование matchAll() для поиска совпадений в тексте
const matches = myString.matchAll(myPattern)// Использование цикла for...of для получения всех совпадений
for (const match of matches) {
console.log(match)
}
// [
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code. ',
// groups: undefined
// ],
// [
// 'code',
// index: 33,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// ]
// Использование Array.from() для получения всех совпадений

const matches = Array.from(myString.matchAll(myPattern))
// [
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code.',
// groups: undefined
// ],
// [
// 'code',
// index: 33,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// ]// Использование оператора spread для получения всех совпадений
const matches = [...myString.matchAll(myPattern)]
// [
// [
// 'code',
// index: 13,
// input: 'The world of code is not full of code. ',
// groups: undefined
// ],
// [
// 'code',
// index: 33,
// input: 'The world of code is not full of code.',
// groups: undefined
// ]
// ]

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

// Создание простого шаблона
// с использованием литерала регулярного выражения
const myPattern = /JavaScript/// Проверка строки на совпадения с шаблоном
myPattern.test('One of the most popular languages is also JavaScript.')
// true// Проверка строки на совпадения с шаблоном
myPattern.test('What happens if you combine Java with scripting?')
// false

До сих пор мы использовали регулярные выражения из простых шаблонов. \t\r\n\v\f]).

Примеры:

// . - любой символ, кроме первой строки
const myPattern = /./console.log(myPattern.test(''))
// falseconsole.log(myPattern.test('word'))
// trueconsole.log(myPattern.test('9'))
// true
// \d - одноразрядное число
const myPattern = /\d/console.log(myPattern.test('3'))
// trueconsole.log(myPattern.test('word'))
// false
// \w - отдельный буквенно-числовой словообразующий символ
const myPattern = /\w/console.log(myPattern.test(''))
// falseconsole.log(myPattern.test('word'))
// trueconsole.log(myPattern.test('9'))
// true
// \s - отдельный символ разделителя
const myPattern = /\s/console.log(myPattern.test(''))
// falseconsole.log(myPattern.test(' '))
// trueconsole.log(myPattern.test('foo'))
// false
// \D - отдельный нечисловой символ
const myPattern = /\D/console. log(myPattern.test('Worm'))
// trueconsole.log(myPattern.test('1'))
// false
// \W - отдельный несловообразующий символ
const myPattern = /\W/console.log(myPattern.test('Worm'))
// falseconsole.log(myPattern.test('1'))
// falseconsole.log(myPattern.test('*'))
// trueconsole.log(myPattern.test(' '))
// true
// \S - отдельный символ, который не является разделителем
const myPattern = /\S/console.log(myPattern.test('clap'))
// trueconsole.log(myPattern.test(''))
// falseconsole.log(myPattern.test('-'))
// true

Операторы контроля

Ещё один вид специальных символов — это операторы контроля. Такие символы позволяют описывать шаблоны с границами, то есть указывать, где начинается или заканчивается слово или строка. С помощью операторов контроля также можно создавать более сложные шаблоны, такие как опережающие проверки, ретроспективные проверки и условные выражения. re/console.log(myPattern.test('write'))
// falseconsole.log(myPattern.test('read'))
// trueconsole.log(myPattern.test('real'))
// trueconsole.log(myPattern.test('free'))
// false
// $ - Конец строки

const myPattern = /ne$/console.log(myPattern.test('all is done'))
// trueconsole.log(myPattern.test('on the phone'))
// trueconsole.log(myPattern.test('in Rome'))
// falseconsole.log(myPattern.test('Buy toner'))
// false
// \b - Граница слова

const myPattern = /\bro/console.log(myPattern.test('road'))
// trueconsole.log(myPattern.test('steep'))
// falseconsole.log(myPattern.test('umbro'))
// false// Или
const myPattern = /\btea\b/console.log(myPattern.test('tea'))
// trueconsole.log(myPattern.test('steap'))
// falseconsole.log(myPattern.test('tear'))
// false
// \B - Несловообразующая граница

const myPattern = /\Btea\B/console. log(myPattern.test('tea'))
// falseconsole.log(myPattern.test('steap'))
// trueconsole.log(myPattern.test('tear'))
// false
// x(?=y) - Опережающая проверка

const myPattern = /doo(?=dle)/console.log(myPattern.test('poodle'))
// falseconsole.log(myPattern.test('doodle'))
// trueconsole.log(myPattern.test('moodle'))
// false
// x(?!y) - Негативная опережающая проверка

const myPattern = /gl(?!u)/console.log(myPattern.test('glue'))
// falseconsole.log(myPattern.test('gleam'))
// true
// (?<=y)x - Ретроспективная проверка

const myPattern = /(?<=re)a/console.log(myPattern.test('realm'))
// trueconsole.log(myPattern.test('read'))
// trueconsole.log(myPattern.test('rest'))
// false
// (?<!y)x - Негативная ретроспективная проверка

const myPattern = /(?<!re)a/console.log(myPattern. test('break'))
// falseconsole.log(myPattern.test('treat'))
// falseconsole.log(myPattern.test('take'))
// true

Квантификаторы

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

/* Квантификатор - Значение */
* - 0 или более совпадений с предшествующим выражением.
+ - 1 или более совпадений с предшествующим выражением.
? - Предшествующее выражение необязательно (то есть совпадений 0 или 1).
x{n} - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно "n".
x{n, } - "n" должно быть целым положительным числом. Количество вхождений предшествующего выражения "x" равно, как минимум, "n".
x{n, m} - "n" может быть равно 0 или целому положительному числу. "m" - целое положительное число. Если "m" > "n", количество вхождений предшествующего выражения "x" равно минимум "n" и максимум "m".

Примеры:

// * - 0 или более совпадений с предшествующим выражением
const myPattern = /bo*k/console.log(myPattern.test('b'))
// falseconsole.log(myPattern.test('bk'))
// trueconsole.log(myPattern.test('bok'))
// true
// + - 1 или более совпадений с предшествующим выражением
const myPattern = /\d+/console.log(myPattern.test('word'))
// falseconsole.log(myPattern.test(13))
// true
// ? - Предшествующее выражение необязательно, совпадений 0 или 1

const myPattern = /foo?bar/console.log(myPattern.test('foobar'))
// trueconsole.log(myPattern.test('fooobar'))
// false
// x{n} - Количество вхождений предшествующего выражения "x" равно "n"
const myPattern = /bo{2}m/console.log(myPattern.test('bom'))
// falseconsole.log(myPattern.test('boom'))
// trueconsole.log(myPattern.test('booom'))
// false
// x{n, } - Количество вхождений предшествующего выражения "x" равно, как минимум, "n"
const myPattern = /do{2,}r/console. b-g]/console.log(myPattern.test('bcd'))
// false (нет других символов, кроме входящих в диапазон от 'b' до 'g')console.log(myPattern.test('jklm'))
// true (есть другие символы, кроме входящих в диапазон от 'b' до 'g')
// (x) - "x", значение запоминается для дальнейшего использования.
const myPattern = /(na)da\1/console.log(myPattern.test('nadana'))
// true - \1 запоминает и использует совпадение 'na' из первого выражения в скобках.console.log(myPattern.test('nada'))
// false
// (?<name>x) - Создание именованной скобочной группы, к которой можно обратиться по указанному имени.
const myPattern = /(?<foo>is)/console.log(myPattern.test('Work is created.'))
// trueconsole.log(myPattern.test('Just a text'))
// false
// (?:x) - "x", значение не запоминается.
const myPattern = /(?:war)/console.log(myPattern.test('warsawwar'))
// trueconsole. log(myPattern.test('arsaw'))
// false

Альтернация

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

/* Альтернация - Значение */
| - выражение до или после символа |, как в булевом ИЛИ (||).

Примеры:

// | - Выражение до или после символа |
const myPattern = /(black|white)swan/console.log(myPattern.test('black swan'))
// trueconsole.log(myPattern.test('white swan'))
// trueconsole.log(myPattern.test('gray swan'))
// false

Флаги

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

/* Флаг - Значение */
g – Глобальный поиск, не останавливается после нахождения первого совпадения. " и заканчивается "$" (начало и конец каждой строки).

Примеры:

// флаг g - Глобальный поиск
const myPattern = /xyz/gconsole.log(myPattern.test('One xyz and one more xyz'))
// true// флаг i - Игнорирование регистра
const myPattern = /xyz/iconsole.log(myPattern.test('XyZ'))
// true - регистр символов не имеет значения при нечувствительном к регистру поиске.
// флаг s - Точка (.) соответствует переводу на новую строку
const myPattern = /foo.bar/sconsole.log(myPattern.test('foo\nbar'))
// trueconsole.log(myPattern.test('foo bar'))
// trueconsole.log(myPattern.test('foobar'))
// false

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

Читайте также:

Читайте нас в телеграмме, vk и Яндекс. Дзен

Регулярные выражения в Ruby— Ruby Rush

На повестке дня — регулярные выражения.

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

План урока

  1. Что такое регулярные выражения
  2. Разбираем примеры
  3. Создаем игру «Придумай слова по шаблону»
  4. В каких ситуациях уместно использование регулярных выражений, а в каких лучше обойтись стандартными средствами

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

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

Их используют, когда надо найти в строке совпадение с каким-то шаблоном, и сделать что-то, если это совпадение найдено, например, заменить часть строки другими символами.

Можно представить регулярные выражения в виде воронки:

Данная воронка пропускает только те слова, которые содержат в себе букву е.

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

Для работы с регулярными выражениями, стандартная библиотека Ruby имеет в своем арсенале класс Regexp, а также методы определенные других классах.

Примеры

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

Начнем с поиска строк уже известным нам способом.

Здесь мы проверяем строку на наличие слова Маша, результат, соответственно, возвращает нам true:

'Маша и Гоша'.include?('Маша')
=> true

А в данном случае слово Саша в нашей строке отсутствует — получаем результат false

'Маша и Гоша'.include?('Саша')
=> false

Теперь на этом же примере воспользуемся регулярным выражением, а именно задействуем метод match, аргументом которого является искомое значение объятое слешами, т.е. /Гоша/. Метод возвращает нам найденное значение в виде объекта класса MatchData, а конкретнее имя 'Гоша' в закодированном виде:

'Маша и Гоша'.match(/Гоша/)
=> #<MatchData "\x83\xAE\xE8\xAO">

В случае же использования слова, которое строка не содержит мы получим nil:

'Маша и Гоша'.match(/Каша/)
=> nil

Также мы можем воспользоваться более лаконичным методом =~, который проделывает аналогичную работу:

'Маша и Гоша' =~ /Каша/
=> nil

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

/Каша/ =~ 'Маша и Гоша'
=> nil

Подставляем корректное слово:

'Маша и Гоша' =~ /Гоша/
=> 7

И видим, что метод вернул нам 7. Данное число означает позицию (номер символа) в строке, где впервые было встречено совпадение (искомое условие). Давайте проверим, верен ли результат:

'Маша и Гоша'.index('Гоша')
=> 7

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

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

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

'cat' =~ /c.t/
=> 0

Точка в регулярном выражении означает, что на ее месте возможен любой единственный символ, будь то ОДНО число, ОДНА буква или иной символ:

'cute' =~ /c.t/
=> 0
'scute' =~ /c.t/
=> 1
'caat' =~ /c.t/
=> nil

В последнем примере из-за использования нескольких символов на месте точки вместо одного — мы получили nil. [\w\d][email protected][\w\d]+\.[\w]+/ =~ '[email protected]'` => 0

где

\w — аналогично выражению [a-zA-Z], то есть любая буква английского алфавита, независимая от case, но помимо этого также допускается наличие знака нижнего подчеркивания _, что в общем то нам и требуется для проверки email, поскольку данный символ в адресе электронной почты допустим

\d — аналогично выражению [0-9], то есть проверяет строку на наличие любых чисел

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

'I have an old car'.gsub('an old', 'a new')
=> "I have a new car"
'I have no money'. gsub(/no/, 'a heap of')
=> "I have a heap of money"
'I have a new car'.gsub(/a/, '1')
=> "I h2ve 1 new c1r"

Создаем игру «Угадай слово»

Начнем с постановки задачи. Условия игры следующие:

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

Кроме проверки соответствия шаблону, мы также будем проверять существует ли введенное пользователем слово в природе. А поможет нам в этом Wiktionary — Wiki-словарь.

Весь код с подробнейшими комментариями скачиваем в материалах к уроку.

Когда стоит применять регулярные выражения

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

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

Также вы будете лучше понимать, в какой ситуации стоить применять тот или иной паттерн.

Почему регулярные выражения так противоречивы?



При изучении регулярных выражений (иначе известных как RegEx-es) есть много людей, которые, кажется, видят регулярные выражения как священный Grail. Что — то, что выглядит таким сложным-просто должно быть ответом на любой вопрос. Они склонны думать, что любая проблема разрешима с помощью регулярных выражений.

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

Почему регулярные выражения считаются столь спорными? Существует ли широко распространенное непонимание того, как они работают? Или это может быть широкое убеждение, что регулярные выражения, как правило, медленные?

regex
Поделиться Источник Gumbo     18 апреля 2009 в 21:33

22 ответа




136

Я думаю, что люди возражают против регулярных выражений не потому, что они медленные, а скорее потому, что их трудно читать и писать, а также сложно правильно понять. Хотя есть некоторые ситуации, когда регулярные выражения обеспечивают эффективное и компактное решение проблемы, они иногда включаются в ситуации, когда вместо этого лучше использовать easy-to-read, поддерживаемый раздел кода.

Поделиться Kyle Cronin     18 апреля 2009 в 21:37



122

Создание Ремонтопригодных Регулярных Выражений

Основным шагом к демистификации паттернов, ранее называемых “regular expressions”, является флаг Perl /x regex — иногда пишется (?x) при внедрении, — который позволяет whitespace (разрыв строки, отступ) и комментарии. Это серьезно улучшает читабельность и, следовательно, ремонтопригодность. Пустое пространство допускает когнитивное разделение, так что вы можете видеть, какие группы с чем.

Современные шаблоны также теперь поддерживают как относительно нумерованные, так и именованные обратные ссылки. Это означает, что вам больше не нужно считать группы захвата, чтобы выяснить, что вам нужно $4 или \7 . Это помогает при создании шаблонов, которые могут быть включены в другие шаблоны.

Вот пример относительно пронумерованной группы захвата:

$dupword = qr{ \b (?: ( \w+ ) (?: \s+ \g{-1} )+ ) \b }xi;
$quoted  = qr{ ( ["'] ) $dupword  \1 }x;

А вот пример превосходного подхода именованных захватов:

$dupword = qr{ \b (?: (?<word> \w+ ) (?: \s+ \k<word> )+ ) \b }xi;
$quoted  = qr{ (?<quote> ["'] ) $dupword  \g{quote} }x;

Грамматические Регулярные Выражения

Лучше всего, эти именованные захваты могут быть помещены в блок (?(DEFINE)...) , так что вы можете отделить объявление от выполнения отдельных именованных элементов ваших шаблонов. Это заставляет их действовать скорее как подпрограммы внутри шаблона.
Хороший пример такого рода “grammatical regex” можно найти в этом ответе и в этом . Они больше похожи на грамматическую декларацию.

Как последнее напоминает вам:

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

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

Вот еще один пример современного грамматического паттерна, на этот раз для разбора RFC 5322: использовать 5.10.0;

$rfc5322 = qr{

   (?(DEFINE)

     (?<address>         (?&mailbox) | (?&group))
     (?<mailbox>         (?&name_addr) | (?&addr_spec))
     (?<name_addr>       (?&display_name)? (?&angle_addr))
     (?<angle_addr>      (?&CFWS)? < (?&addr_spec) > (?&CFWS)?)
     (?<group>           (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ; (?&CFWS)?)
     (?<display_name>    (?&phrase))
     (?<mailbox_list>    (?&mailbox) (?: , (?&mailbox))*)

     (?<addr_spec>       (?&local_part) \@ (?&domain))
     (?<local_part>      (?&dot_atom) | (?&quoted_string))
     (?<domain>          (?&dot_atom) | (?&domain_literal))
     (?<domain_literal>  (?&CFWS)? \[ (?: (?&FWS)? (?&dcontent))* (?&FWS)?
                                   \] (?&CFWS)?)
     (?<dcontent>        (?&dtext) | (?&quoted_pair))
     (?<dtext>           (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e])

     (?<atext>           (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~])
     (?<atom>            (?&CFWS)? (?&atext)+ (?&CFWS)?)
     (?<dot_atom>        (?&CFWS)? (?&dot_atom_text) (?&CFWS)?)
     (?<dot_atom_text>   (?&atext)+ (?: \.  (?&atext)+)*)

     (?<text>            [\x01-\x09\x0b\x0c\x0e-\x7f])
     (?<quoted_pair>     \\ (?&text))

     (?<qtext>           (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e])
     (?<qcontent>        (?&qtext) | (?&quoted_pair))
     (?<quoted_string>   (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))*
                          (?&FWS)? (?&DQUOTE) (?&CFWS)?)

     (?<word>            (?&atom) | (?&quoted_string))
     (?<phrase>          (?&word)+)

     # Folding white space
     (?<FWS>             (?: (?&WSP)* (?&CRLF))? (?&WSP)+)
     (?<ctext>           (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e])
     (?<ccontent>        (?&ctext) | (?&quoted_pair) | (?&comment))
     (?<comment>         \( (?: (?&FWS)? (?&ccontent))* (?&FWS)? \) )
     (?<CFWS>            (?: (?&FWS)? (?&comment))*
                         (?: (?:(?&FWS)? (?&comment)) | (?&FWS)))

     # No whitespace control
     (?<NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f])

     (?<ALPHA>           [A-Za-z])
     (?<DIGIT>           [0-9])
     (?<CRLF>            \x0d \x0a)
     (?<DQUOTE>          ")
     (?<WSP>             [\x20\x09])
   )

   (?&address)

}x;

Разве это не замечательно-и великолепно? Вы можете взять BNF-style grammar и перевести его непосредственно в код, не теряя его фундаментальной структуры!

Если вам все еще недостаточно современных грамматических шаблонов, то блестящий модуль Damian Conway Regexp::Grammars предлагает еще более чистый синтаксис с превосходной отладкой. Вот тот же самый код для разбора RFC 5322, переделанный в шаблон из этого модуля:

#!/usr/bin/perl

use strict;
use warnings;
use 5.010;
use Data::Dumper "Dumper";

my $rfc5322 = do {
    use Regexp::Grammars;    # ...the magic is lexically scoped
    qr{

    # Keep the big stick handy, just in case...
    # <debug:on>

    # Match this...
    <address>

    # As defined by these...
    <token: address>         <mailbox> | <group>
    <token: mailbox>         <name_addr> | <addr_spec>
    <token: name_addr>       <display_name>? <angle_addr>
    <token: angle_addr>      <CFWS>? \< <addr_spec> \> <CFWS>?
    <token: group>           <display_name> : (?:<mailbox_list> | <CFWS>)? ; <CFWS>?
    <token: display_name>    <phrase>
    <token: mailbox_list>    <[mailbox]> ** (,)

    <token: addr_spec>       <local_part> \@ <domain>
    <token: local_part>      <dot_atom> | <quoted_string>
    <token: domain>          <dot_atom> | <domain_literal>
    <token: domain_literal>  <CFWS>? \[ (?: <FWS>? <[dcontent]>)* <FWS>?

    <token: dcontent>        <dtext> | <quoted_pair>
    <token: dtext>           <. _`{|}~]
    <token: atom>            <.CFWS>? <.atext>+ <.CFWS>?
    <token: dot_atom>        <.CFWS>? <.dot_atom_text> <.CFWS>?
    <token: dot_atom>        <.CFWS>? <.dot_atom_text> <.CFWS>?
    <token: dot_atom_text>   <.atext>+ (?: \. <.atext>+)*

    <token: text>            [\x01-\x09\x0b\x0c\x0e-\x7f]
    <token: quoted_pair>     \\ <.text>

    <token: qtext>           <.NO_WS_CTL> | [\x21\x23-\x5b\x5d-\x7e]
    <token: qcontent>        <.qtext> | <.quoted_pair>
    <token: quoted_string>   <.CFWS>? <.DQUOTE> (?:<.FWS>? <.qcontent>)*
                             <.FWS>? <.DQUOTE> <.CFWS>?

    <token: word>            <.atom> | <.quoted_string>
    <token: phrase>          <.word>+

    # Folding white space
    <token: FWS>             (?: <.WSP>* <.CRLF>)? <. WSP>+
    <token: ctext>           <.NO_WS_CTL> | [\x21-\x27\x2a-\x5b\x5d-\x7e]
    <token: ccontent>        <.ctext> | <.quoted_pair> | <.comment>
    <token: comment>         \( (?: <.FWS>? <.ccontent>)* <.FWS>? \)
    <token: CFWS>            (?: <.FWS>? <.comment>)*
                             (?: (?:<.FWS>? <.comment>) | <.FWS>)

    # No whitespace control
    <token: NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f]

    <token: ALPHA>           [A-Za-z]
    <token: DIGIT>           [0-9]
    <token: CRLF>            \x0d \x0a
    <token: DQUOTE>          "
    <token: WSP>             [\x20\x09]

    }x;

};


while (my $input = <>) {
    if ($input =~ $rfc5322) {
        say Dumper \%/;       # ...the parse tree of any successful match
                              # appears in this punctuation variable
    }
}

В MAN-странице perlre есть много хорошего, но эти драматические улучшения фундаментальных конструктивных особенностей regex ни в коем случае не ограничиваются только Perl. Действительно , Man -страница pcrepattern может быть более легкой для чтения и охватывает ту же территорию.

Современные паттерны не имеют почти ничего общего с примитивными вещами, которым вас учили в классе конечных автоматов.

Поделиться Joel Berger     29 октября 2010 в 15:44



68

Регулярные выражения-отличный инструмент, но люди думают: «Эй, какой отличный инструмент, я буду использовать его, чтобы сделать X!», где X-это то, для чего лучше использовать другой инструмент (обычно парсер). Это стандартное использование молотка там, где вам нужна проблема с отверткой.

Поделиться Chas. Owens     18 апреля 2009 в 21:40


  • Регулярные выражения для HTML

    Я пытаюсь найти следующие регулярные выражения для реализации в моей программе для анализа данного файла html. Не могли бы вы помочь мне с чем-нибудь из этого? <div> <div class=”menuItem”> <span> class=”emph” Any string beginning with < and ending with >, i.e. all tags. The…

  • Регулярные выражения-что определяет приоритет условного выражения?

    Я хотел бы понять, как регулярные выражения определяют приоритет конкретного условия. Возьмите следующие строковые очки и регулярные выражения ниже. Пример 1 (\b\w+?)(?=(?:es)\b) Спичка сделана на стекле . Пример 2 (\b\w+?)(?=(?:s)\b) Спичка сделана на Глассе . Пример 3 Объединение двух:…



53

Почти все, кого я знаю, кто регулярно использует регулярные выражения (каламбур), происходят из среды Unix-иш, где они используют инструменты, которые рассматривают REs как первоклассные программные конструкции, такие как grep, sed, awk и Perl. Поскольку почти нет синтаксических накладных расходов на использование регулярного выражения, их производительность значительно возрастает, когда они это делают.

Напротив, программисты, использующие языки, в которых REs является внешней библиотекой, как правило, не рассматривают, что регулярные выражения могут принести в таблицу. Программист «time-cost» настолько высок, что либо а) REs никогда не появлялся как часть их обучения, либо б) они не «think» в терминах REs и предпочитают возвращаться к более знакомым шаблонам.

Поделиться Barry Brown     19 апреля 2009 в 02:03



44

Регулярные выражения позволяют компактно написать пользовательский конечный автомат (FSM) для обработки строки входных данных. Есть по крайней мере две причины, по которым использование регулярных выражений трудно:

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

    Современные разработчики программного обеспечения предпочли бы выковывать код и использовать отладчик для пошагового выполнения, чтобы проверить правильность кода. Регулярные выражения не очень хорошо поддерживают этот стиль работы. Один «run» регулярного выражения фактически является атомарной операцией. Трудно наблюдать пошаговое выполнение в отладчике.

  • Слишком легко написать регулярное выражение, которое случайно принимает больше входных данных, чем вы намереваетесь. Значение регулярного выражения на самом деле не должно соответствовать допустимому входу, оно должно не соответствовать недопустимому входу . Методы выполнения «negative tests» для регулярных выражений не очень продвинуты или, по крайней мере, не широко используются.

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

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

Поделиться Bill Karwin     18 апреля 2009 в 22:19



37

Люди склонны думать, что регулярные выражения трудны, но это потому, что они используют их неправильно. Написание сложных однострочных текстов без каких-либо комментариев, отступов или именованных захватов. (Вы же не втискиваете свое сложное выражение SQL в одну строку, без комментариев, отступов или псевдонимов, не так ли?). Так что да, для многих людей они не имеют смысла.

Однако, если ваша работа имеет какое- то отношение к разбору текста (примерно любое веб-приложение там…), и вы не знаете регулярных выражений, вы отстой в своей работе, и вы тратите свое собственное время и время своего работодателя. Там есть отличные ресурсы , чтобы научить вас всему, что вам когда-либо понадобится знать, и даже больше.

Поделиться Jasper Bekkers     18 апреля 2009 в 22:06



28

Потому что у них нет самого популярного инструмента обучения в общепринятом IDEs: нет мастера Regex. Даже не Автозавершение. Вы должны кодировать все это сами.

Поделиться dkretz     18 апреля 2009 в 22:25


Поделиться Anthony     18 апреля 2009 в 21:35



16

Я не думаю, что они настолько противоречивы.

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

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

http://docs.python.org/методические указания/regex

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

Поделиться allyourcode     18 апреля 2009 в 22:09



11

Регулярные выражения для строк-то же самое, что арифметические операторы для чисел, и я бы не считал их спорными. Я думаю, что даже такой довольно воинствующий активист, как я (который склонен выбирать другие объекты вместо струн), будет трудно отказаться от них.

Поделиться CurtainDog     19 апреля 2009 в 11:52



7

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

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

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

Поделиться Svante     18 апреля 2009 в 22:17



5

С таким же успехом вы можете спросить о том, почему Гото спорны.

В принципе, когда вы получаете так много власти «obvious», люди apt злоупотребляют ими в ситуациях, для которых они не являются лучшим вариантом. Например, меня поражает количество людей, которые просят разобрать CSVs, XML или HTML в регулярных выражениях. Это неподходящий инструмент для работы. Но некоторые пользователи все равно настаивают на использовании регулярных выражений.

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

Обратите внимание, что регулярные выражения все еще можно использовать для анализа CSVs, XML, HTML и т. д. Но, как правило, не в одном regex.

Поделиться Tanktalus     18 апреля 2009 в 21:42



4

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

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

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

  • регулярное выражение не эффективно, потому что построение Верхнего не очевидно
  • некоторые программисты «forget» компилируют только один раз регулярное выражение, которое будет использоваться много раз (например, Статический шаблон в Java)
  • некоторые программисты идут на стратегию проб и ошибок — еще меньше работает с регулярными выражениями!

Поделиться e2-e4     24 августа 2010 в 19:07



4

То, что я думаю, что изучение Regex и поддержание regex делает непопулярным, большинство разработчиков ленивы или большинство из них полагаются на внешние библиотеки, чтобы сделать разбор для них. .. они полагаются на google для ответа и даже спрашивают на форумах полный код для своей проблемы. Но когда дело доходит до реализации или модификации/поддержания regex, они просто терпят неудачу.

Есть популярная поговорка «Friends dont let Friends use Regex for Parsing HTML»

Но что касается меня, то я сделал полные Парсеры HTML, используя Regex, и я нахожу, что regex лучше разбирают строки html как по скорости, так и по памяти(если у вас есть идея, чего вы хотите достичь 🙂 )

Поделиться Rajeev     31 марта 2011 в 10:18



4

Я не думаю, что 32-это правильное слово.

Но я видел массу примеров, когда люди говорили: «какое регулярное выражение мне нужно сделать such-and-such манипуляцией со строкой?» которые являются X-Y проблемами.

Другими словами, они исходили из предположения, что regex-это то, что им нужно, но им было бы лучше с split(), переводом, подобным perl-му tr///, где символы заменяются один на другой, или просто index().

Поделиться AmbroseChapel     19 апреля 2009 в 09:59



2

Регулярные выражения являются серьезной загадкой для многих людей, в том числе и для меня. Это прекрасно работает, но это все равно что смотреть на математическое уравнение. Однако я рад сообщить, что кто-то наконец-то создал консолидированное расположение различных функций регулярных выражений в http://regexlib.com/ . Теперь, если бы Microsoft только создала класс регулярных выражений, который автоматически выполнял бы большую часть обычных вещей, таких как удаление букв или фильтрация дат.

Поделиться Al Katawazi     18 апреля 2009 в 21:48



1

Иногда я нахожу регулярные выражения бесценными. Когда мне нужно сделать несколько поисков «fuzzy» и, возможно, заменить. Когда данные могут варьироваться и иметь определенную случайность. Однако когда мне нужно выполнить простой поиск и замену или проверить строку, я не использую регулярные выражения. Хотя я знаю многих людей, которые это делают, они используют его для всего. В этом и заключается противоречие.

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

Регулярные выражения должны использоваться для того, для чего они были разработаны, и не меньше.

Поделиться Brent Baisley     19 апреля 2009 в 02:25



0

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

Поделиться Satya Prakash     24 августа 2010 в 18:23



0

Приличные системы регулярных выражений, такие как используемые в lex и yacc для определения компилятора, хороши, очень полезны и чисты. В этих системах типы выражений определяются в терминах других. Это отвратительные искаженные нечитаемые линейные шумовые гигантские однострочные регулярные выражения, обычно встречающиеся в коде perl и sed (и т. д.), которые являются ‘controversial’ (мусором).

Поделиться Sam Watkins     08 ноября 2010 в 06:55



0

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

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

Поделиться Aif     27 февраля 2010 в 11:15



0

Хотя я думаю, что регулярные выражения являются важным инструментом, самое раздражающее в них то, что существуют различные реализации. Небольшие различия в синтаксисе, модификаторах и — особенно-«greed» могут сделать вещи действительно хаотичными, требуя trial-and-error и иногда порождая загадочные ошибки.

Поделиться ndr     19 апреля 2009 в 01:02



-4

Лучшее допустимое и нормальное использование для regex — это проверка формата адреса email.

Это хорошее его применение.

Я использовал регулярные выражения бесчисленное количество раз в качестве одноразовых в TextPad для массажа плоских файлов, создания csv файлов, создания SQL операторов вставки и тому подобного.

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

Многие ситуации требуют именно регулярных выражений и ничего больше.

Замена специальных непечатаемых символов безобидными символами — еще одно хорошее применение.

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

Поделиться Chris Morley     19 апреля 2009 в 02:39


Похожие вопросы:


Lua string.match использует нерегулярные регулярные выражения?

Мне любопытно, почему это не работает, и мне нужно знать, почему/как обойти это; я пытаюсь определить, является ли какой-то вход вопросом, я почти уверен, что string. match — это то, что мне нужно,…


Генеративные регулярные выражения

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


Регулярные выражения и Assembly

Я знаю 8086 Assembly и учусь MIPS Assembly. Кроме того, я изучаю регулярные выражения, тогда я хочу знать: Как я могу использовать на них регулярные выражения?


Почему регулярные выражения называются «regular» выражениями?

Почему регулярные выражения называются регулярными выражениями?


Почему Silverlight не поддерживает скомпилированные регулярные выражения?

Бета-фреймворки Silverlight 2 и Silverlight 3 не поддерживают скомпилированные регулярные выражения, т. е.: RegexOptions.Compiled Мне было бы интересно услышать рассуждения о том, почему это так,…


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

Я пытаюсь найти следующие регулярные выражения для реализации в моей программе для анализа данного файла html. Не могли бы вы помочь мне с чем-нибудь из этого? <div> <div…


Регулярные выражения-что определяет приоритет условного выражения?

Я хотел бы понять, как регулярные выражения определяют приоритет конкретного условия. Возьмите следующие строковые очки и регулярные выражения ниже. Пример 1 (\b\w+?)(?=(?:es)\b) Спичка сделана на…


Почему эти регулярные выражения выполняются медленно в Java?

Я пытаюсь использовать регулярные выражения, чтобы определить, какой формат применил пользователь при вводе входных данных в textbox. Регулярные выражения выглядят следующим образом: (\\s?[ +…


Являются ли регулярные выражения (regex) действительно регулярными?

Я понимаю, как регулярные выражения получили свое название, и прочитал связанный с этим вопрос ( почему регулярные выражения называются «regular» выражениями? ), но мне все еще интересно,…


Измените регулярные выражения vim

Есть ли способ изменить регулярные выражения vim’ на регулярные выражения python’? Я хотел бы работать с регулярными выражениями python в моем vim.

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

Обновлено: 31.12.2020, Computer Hope

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

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

Основы регулярных выражений (шпаргалка)

Приведенный выше пример может показаться ошеломляющим.abc abc, abcdef .., abc123 $ Соответствует концу строки abc $ мой: abc, 123abc, theabc . Соответствует любому символу п.в. abc, asg, a2c | Оператор ИЛИ abc | xyz abc или xyz (…) Захватить все совпадающие (а) б (в) Захватывает ‘a’ и ‘c’ (?:.abc] xyz, 123, 1de [а-я] Соответствует любым символам от «a» до «z». [б-я] до н.э., разум, xyz {x} Точное количество совпадений «x» (abc) {2} abcabc {x,} Совпадение «x» или более раз (abc) {2,} abcabc, abcabcabc {x, y} Совпадение времен «x» и «y». (а) {2,4} аа, ааа, ааааа * Жадное совпадение, которое соответствует всему вместо * ab * c abc, abbcc, abcdc + Соответствует символу до + один или несколько раз а + с ac, aac, aaac, ? Соответствует символу перед? ноль или один раз. Также используется как нежадное совпадение ab? C переменного тока, abc \ Экранируйте символ после обратной косой черты или создайте escape-последовательность.$. | * +? \ \ 0 Нулевой символ. \ а В Perl \ a является звонком или сигналом тревоги и не используется в регулярных выражениях. \ A Соответствует началу многострочной строки. \ б Граница слова в большинстве или backspace. \ B Без границы слова. \ d Соответствует любой десятичной цифре (0-9). \ D Соответствует любой цифре. \ e Сопоставьте побег. \ f Соответствует подаче страницы. \ п Сопоставьте новую строку. \ Q … \ E Игнорирует какое-либо особое значение в сопоставлении. \ r Соответствует возврату каретки. \ с Соответствует пробелу (пробел, \ t, \ r, \ n). \ S Соответствует любому символу, отличному от пробела. \ т Соответствие табуляции. \ v Соответствует вертикальной табуляции. \ w Соответствует любому символу из одного слова ([a-zA-Z_0-9]). \ Вт Соответствует любому символу, не являющемуся словом.

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

За пределами регулярного выражения (в конце) флаги помогают в сопоставлении с образцом.

Персонаж Что он делает?
я Игнорировать регистр (разрешены прописные и строчные буквы).
м Многострочный матч.
с Совместите новые строки.
x Разрешить пробелы и комментарии.
Дж Разрешены повторяющиеся имена групп.
U Нежирный матч.

Примеры регулярных выражений языка программирования Perl

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

 $ data = ~ s / bad data / good data / i; 

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

 $ data = ~ s / a / A /; 

В этом примере любая строчная a заменяется на прописную A . Итак, если $ data был «example», он стал бы «exAmple».

 $ data = ~ s / [a-z] / * /; 

В приведенном выше примере любая строчная буква от a до z заменяется звездочкой. Итак, если $ data был «Примером», он стал бы «E ******».

 $ data = ~ s / e $ / es /; 

В этом примере используется символ $, который указывает регулярному выражению соответствовать тексту перед ним в конце строки. Итак, если бы $ data был «примером», он стал бы «примерами».

 $ data = ~ s /\./!/; 

В приведенном выше примере мы заменяем точку восклицательным знаком.) указывает регулярному выражению соответствовать чему-либо в начале строки. В этом примере любая строчная буква «е» в начале строки заменяется заглавной «е». Следовательно, если $ data был «примером», он стал бы «примером».

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

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

Регулярное выражение — это специальная текстовая строка для описания шаблона поиска.Вы можете думать о регулярных выражениях как о подстановочных знаках на стероидах. Вы, вероятно, знакомы с обозначениями с подстановочными знаками, такими как * .txt, для поиска всех текстовых файлов в файловом менеджере. Эквивалент регулярного выражения. * \. Txt.

Но с регулярными выражениями можно сделать гораздо больше. В текстовом редакторе, таком как EditPad Pro, или в специализированном инструменте обработки текста, таком как PowerGREP, вы можете использовать регулярное выражение \ b [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] + \. [AZ] {2,6} \ b для поиска адреса электронной почты. Любой адрес электронной почты , если быть точным.Очень похожее регулярное выражение может использоваться программистом, чтобы проверить, ввел ли пользователь правильно отформатированный адрес электронной почты. Всего в одной строке кода, написан ли этот код на Perl, PHP, Java, языке .NET или на множестве других языков.

Поскольку «регулярные выражения» — это непросто, вы обычно встретите термин, сокращенный до «регулярное выражение» или «регулярное выражение». Мы предпочитаем «регулярное выражение», поскольку его можно легко превратить во множественное число как «регулярные выражения».

«Мне очень нравится пользоваться вашей программой, а до этого я ненавидел регулярные выражения.Теперь я перешла на темную сторону, и я люблю их ».
— Тим Галлахер
2 марта 2006 г., Канзас, США

RegexBuddy упрощает регулярные выражения

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

Немного попрактиковавшись и с помощью RegexBuddy, вы скоро научитесь создавать регулярные выражения. Да, и вам определенно не нужно быть программистом, чтобы пользоваться регулярными выражениями! (Читайте ниже.)

\ b [A-Z0-9 ._% + -] ++ @ [A-Z0-9 .-] + \. [AZ] {2,6} \ b

  • Утверждение позиции на границе слова
  • Соответствует одному символу из списка: одному из символов «._% + -», или в диапазоне от A до Z, или в диапазоне от 0 до 9
    • Между одним и неограниченное количество раз, столько раз, сколько возможно, без возврата (притяжательное)
  • Соответствует буквально символу «@»
  • Соответствует одному символу из списка: одному из символов «. — », или в диапазоне от A до Z, или в диапазоне от 0 до 9
    • От одного до неограниченного раза, столько раз, сколько возможно, отдача по мере необходимости (жадный)
  • Соответствие символу«. ” буквально
  • Сопоставьте одиночный символ в диапазоне от A до Z
    • От 2 до 6 раз, как можно больше раз, возвращая по мере необходимости (жадно)
  • Утверждение позиции на границе слова

Экономия времени и Усилия с регулярными выражениями

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

Поиск с использованием регулярных выражений позволяет получать результаты всего за один поиск вместо множества поисков. Искать слово «отдельный» и все его распространенные ошибки легко с помощью регулярного выражения s [ae] p [ae] r [ae] te. Если вы забыли номер телефона своего друга, который переехал в Ангилью, найдите в своей прошлой переписке \ b1? [- (] * 264 [-)] * \ d {3} [-] * \ d {4} \ b и получите удобный список всех телефонных номеров с кодом 264, независимо от используемого стиля записи.

Обновляйте большие объемы данных, выполняя поиск и заменяя их регулярными выражениями. Преимущество использования регулярных выражений для обновления данных заключается в том, что с помощью одного шаблона регулярного выражения вы можете динамически обновлять различные данные. Например. найдите (copyright + (© | \ (c \) | & copy;) + \ d {4}) (* [-,] * \ d {4}) * и замените на \ 1-2020, чтобы обновить все заявления об авторских правах до 2020 года, независимо от стиля символа авторского права и текущего года авторского права. «Авторское право (c) 1996-2007» заменено на «авторское право (c) 1996-2020», а «Авторское право © 2009» заменено на «Авторское право © 2009-2020» и т. Д.Это займет всего несколько минут для настройки и десятка секунд для запуска с помощью встроенного инструмента GREP RegexBuddy. Представьте, что вы вносите эти изменения вручную.

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

Объект VBScript RegExp

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

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

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

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

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

Пусть RegexBuddy делает Regex простым для вас


«Я должен сказать, что RegexBuddy — бесценный инструмент. Это, безусловно, лучший инструмент для работы с регулярными выражениями, который я когда-либо использовал. Раньше я тратил время на отладку регулярных выражений Perl, используя тонны простых операторов print. Все это ушло, и теперь я определенно лучше понимаю более сложные функции регулярных выражений благодаря этому инструменту.

«Лучшая часть RegexBuddy — это то, что я могу ввести регулярное выражение, написанное на Perl, и легко преобразовать его на другой язык. Иногда единственный вариант, который у меня есть, — это использовать VBScript, и возможность быстро и легко преобразовать мое регулярное выражение Perl в VBScript значительно экономит время.

«Мне также нравится функция« Комментировать с деревом регулярных выражений RegexBuddy ». Добавление этого объяснения регулярного выражения в мой код действительно помогает непосвященным понять, что я сделал, и упрощает поддержку моего кода.
— Мик Гроув
22 января 2007 г., Айова, США

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

Регулярные выражения — это специально закодированные текстовые строки, используемые как шаблоны для сопоставления наборов строк. Они начали появляться в 1940-х годах как способ описания обычных языков, но они действительно начали появляться в мир программирования в 1970-е годы. Первый Я мог найти их в текстовом редакторе QED, написанном Кеном Томпсоном.

«Регулярное выражение — это шаблон, который определяет набор строк. персонажей; говорят, что он соответствует определенным строкам.”—Кен Томпсон

Регулярные выражения позже стали важной частью набора инструментов. который появился в операционной системе Unix — ed , sed и vi ( vim ) редакторы, grep , AWK и другие. Но способы, которыми регулярно Реализованные выражения не всегда были такими регулярными.

Примечание

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

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

 \ d 

сокращенное обозначение символов , которое соответствует любой цифре от 0 до 9, к чему-то немного большему сложный, например:

 ^ (\ (\ d {3} \) | ^ \ d {3} [. -]?)? \ d {3} [.-]? \ d {4} $ 

, на котором мы закончим в конце этой главы: довольно надежное регулярное выражение, соответствующее 10-значному телефону в Северной Америке номер с круглыми скобками вокруг кода города или без них, с или без дефисы или точки (точки) для разделения чисел. (Скобки должны быть уравновешенный тоже; другими словами, у вас не может быть только один.)

Примечание

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

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

Иногда я представляю символы Юникода в этой книге, используя их кодовая точка — четырехзначное шестнадцатеричное (основание 16) число. Эти кодовые точки отображаются в виде U + 0000 .U + 002E, для Например, представляет собой кодовую точку для точки или точки (.).

Сначала позвольте познакомить вас с веб-сайтом Regexpal http://www.regexpal.com. Откройте сайт в браузере, например, Google Chrome или Mozilla Firefox. Вы можете посмотреть, как выглядит сайт как на рисунке 1-1.

Рисунок 1-1. Regexpal в браузере Google Chrome

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

Примечание

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

Теперь мы сопоставим номер телефона в Северной Америке с регулярным выражением. Тип телефонный номер, указанный здесь в нижней части Regexpal:

 707-827-7019 

Вы узнаете его? Это номер компании O’Reilly Media.

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

 707-827-7019 

Вы должны увидеть номер телефона, который вы ввели в нижнем поле выделены желтым от начала до конца.Если это то, что вы видите (как показано на рисунке 1-2), значит, вы занимаетесь бизнесом.

Примечание

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

Рисунок 1-2.Десятизначный номер телефона, выделенный в Regexpal

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

Теперь удалите номер в верхнем поле и замените его только на номер 7 . Вы видели, что произошло? Теперь только семерки выделены. Буквальный символ (число) 7 в регулярном выражении соответствует четырем экземпляры числа 7 в совпадающем тексте.

Что, если вы хотите сопоставить все номера в телефонном номере сразу? Или же сопоставить любое число в этом отношении?

Попробуйте сделать следующее, еще раз точно как показано в верхнем тексте box:

 [0-9] 

Все числа (точнее цифр ) в нижняя часть выделена попеременно желтым и синим цветом. Что за регулярное выражение [0-9] говорит обработчик регулярных выражений: «Сопоставьте любую цифру в диапазоне от 0 до 9.”

Квадратные скобки не совпадают буквально, потому что они обрабатываются специально как метасимволы . Метасимвол имеет специальное значение в регулярных выражениях и зарезервировано. Обычный выражение в форме [0-9] равно называется классом символов или иногда набором символов .

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

 [012789] 

Это будет соответствовать только перечисленным цифрам, то есть 0, 1, 2, 7, 8, и 9.Попробуйте в верхнем поле. Еще раз, каждая цифра в нижнем поле будут выделены чередующимися цветами.

Для соответствия любому 10-значному номеру телефона в Северной Америке, части которого разделенные дефисами, вы можете сделать следующее:

 [0-9] [0-9] [0-9] - [0-9] [0-9] [0-9] - [0-9] [ 0-9] [0-9] [0-9] 

Это сработает, но напыщенно. Есть лучший способ с то, что называется стенографией.

Еще один способ сопоставления цифр, который вы видели в начале в главе \ d , что само по себе будет соответствовать всем арабским цифрам, как и [0-9] .Попробуйте это в верхнем разделе и, как и в случае с предыдущими регулярными выражениями, цифры ниже будут выделено. Такое регулярное выражение называется Сокращение символов . (Его также называют escape-символом , но этот термин может вводить в заблуждение, поэтому я избегаю его. Я объясню позже.)

Чтобы сопоставить любую цифру в номере телефона, вы также можете сделать это:

 \ d \ d \ d- \ d \ d \ d- \ d \ d \ d \ d 

Повторение \ d три и четыре раз подряд будет точно соответствовать последовательности трех и четырех цифр.Дефис в приведенном выше регулярном выражении вводится как буквальный символ и будет сопоставлен как таковой.

А как насчет дефисов? Как вы их сопоставите? Вы можете использовать буквальный дефис (-), как уже показано, или вы можете использовать экранированный верхний регистр D ( \ D ), который соответствует любому символу, который равен , а не a цифра.

В этом примере используется \ D вместо буквальный дефис.

 \ d \ d \ d \ D \ d \ d \ d \ D \ d \ d \ d \ d 

Еще раз, весь номер телефона, включая дефисы, должен быть выделенным на этот раз.

Вы также можете сопоставить эти надоедливые дефисы с помощью точки (.):

 \ d \ d \ d. \ D \ d \ d. \ D \ d \ d \ d 

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

 707% 827% 7019 

Или вертикальная черта (|):

 707 | 827 | 7019 

Или любой другой символ.

Примечание

Как я уже упоминал, точка (официально точка) будет обычно не соответствует символу новой строки, например переводу строки (U + 000A).Однако есть способы сделать возможным сопоставление новой строки с символом точка, которую я покажу вам позже. Это часто называют dotall вариант.

Теперь вы сопоставите только часть номера телефона, используя то, что известная как группа захвата . Затем вы обратитесь к содержимое группы с обратной ссылкой . Чтобы создать захват группу, заключите \ d в пару круглые скобки, чтобы поместить его в группу, а затем следовать за ним \ 1 для обратной ссылки на то, что было захвачено:

 (\ d) \ d \ 1 

\ 1 относится к тому, что было записаны в группу, заключенную в круглые скобки.В результате это регулярное выражение соответствует префикс 707 . Вот разбивка это:

  • (\ d) соответствует первой цифре и фиксирует его (число 7 )

  • \ d соответствует следующей цифре (номер 0 ), но не захватывает его, потому что он не заключен в скобки

  • \ 1 ссылается на захваченный цифра (номер 7 )

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

Теперь вы можете сопоставить весь номер телефона с одной группой и несколько обратных ссылок:

 (\ d) 0 \ 1 \ D \ d \ d \ 1 \ D \ 1 \ d \ d \ d 

Но это не так элегантно, как могло бы быть. Давай попробуем что-нибудь это работает даже лучше.

Вот еще один способ сопоставить номер телефона с помощью другого синтаксис:

 \ d {3} -? \ d {3} -? \ d {4} 

Числа в фигурных скобках говорят процессору регулярных выражений ровно сколько вхождений этих цифр вы хотите это искать.Фигурные скобки с числами — это своего рода квантификатор . Сами брекеты считаются метасимволами.

Вопросительный знак (? ) стоит другой вид квантификатора. Он следует за дефисом в регулярное выражение выше и означает, что дефис не обязателен, т. е. что может быть ноль или один дефис (один или ни одного). Существуют и другие кванторы, такие как знак плюса ( + ), которые означает «один или несколько» или звездочку ( * ), что означает «ноль или более».”

Используя кванторы, вы можете сделать регулярное выражение еще более эффективным. краткий:

 (\ d {3,4} [.-]?) + 

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

Голова кружится? Надеюсь нет. Вот посимвольный анализ регулярного выражения выше:

  • ( открыть захват группа

  • \ сокращение начального символа (избегайте следующего символа)

  • d сокращенное обозначение конечного символа (сопоставьте любую цифру в диапазоне от 0 до 9 с \ d )

  • { открытый квантор

  • 3 минимальное количество для соответствие

  • , отдельные количества

  • 4 максимальное количество соответствует

  • } квантификатор закрытия

  • [ класс открытых символов

  • . точка или период (соответствует буквальная точка)

  • - буквенный символ для соответствия дефис

  • ] закрывающий символ класс

  • ? ноль или один квантификатор

  • ) закрытый захват группа

  • + один или несколько квантификатор

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

Так что давайте немного улучшим его:

 (\ d {3} [.-]?) {2} \ d {4} 

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

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

 ^ (\ (\ d {3} \) | ^ \ d {3} [. (каретка) в начале регулярного выражения или после
        вертикальная черта ( | ) означает, что
        номер телефона будет в начале строки. 

  • ( открывает захват группа.

  • \ ( - буквальное открытое скобка.

  • \ d соответствует цифре.

  • {3} - это количественный показатель, после \ d соответствует ровно трем цифры. совпадает с началом линия.

  • \ d соответствует цифре.

  • {3} - количественный показатель что соответствует ровно трем цифрам.

  • [.-]? соответствует необязательной точке или дефис.

  • ) закрытая группа захвата.

  • ? сделать группу необязательной, то есть префикс в группе не требуется.

  • \ d соответствует цифре.

  • {3} соответствует ровно трем цифры.

  • [.-]? совпадает с другим необязательная точка или дефис.

  • \ d соответствует цифре.

  • {4} соответствует ровно четырем цифры.

  • $ соответствует концу строки.

  • Это последнее регулярное выражение соответствует 10-значному североамериканскому номер телефона в круглых скобках, дефисах или точках или без них.Пытаться различные формы числа, чтобы увидеть, что будет соответствовать (и что не будет).

    Примечание

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

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

    TextMate - это редактор, который доступен только на Mac и использует тот же библиотека регулярных выражений как язык программирования Ruby. Вы можете использовать регулярные выражения с помощью функции поиска (поиска), как показано на рисунке 1-3. Установите флажок рядом с Regular выражение .

    Рисунок 1-3. Регулярное выражение номера телефона в TextMate

    Notepad ++ доступно в Windows и представляет собой популярный бесплатный редактор, использующий библиотека регулярных выражений PCRE. Вы можете получить к ним доступ через поиск и замените (рис. 1-4), установив переключатель рядом с to Регулярное выражение .

    Рисунок 1-4. Регулярное выражение номера телефона в Notepad ++

    Oxygen также является популярным и мощным редактором XML, который использует регулярное выражение Perl 5. синтаксис. Вы можете получить доступ к регулярным выражениям через поиск и заменить диалог, как показано на рисунке 1-5, или через его обычное построитель выражений для XML-схемы. Чтобы использовать регулярные выражения с Найти / заменить, поставить галочку напротив Regular выражение .

    Рисунок 1-5. Регулярное выражение телефонного номера в Oxygen

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

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

    • Как использовать Regexpal, простое регулярное выражение процессор

    • Как сопоставить строковые литералы

    • Как сопоставить цифры с классом символов

    • Как сопоставить цифру с сокращением символов

    • Как сопоставить не цифру с сокращением символов

    • Как использовать группу захвата и обратную ссылку

    • Как сопоставить точное количество в наборе строк

    • Как сопоставить символ (ноль или один) или один или несколько символов раз

    • Как сопоставить строки в начале или в конце линия

    • Regexpal (http: // www.regexpal.com) является веб-реализация регулярного выражения на основе JavaScript. Его не самая полная реализация, и она не все что могут делать регулярные выражения; однако это чистый, простой и очень простой в использовании инструмент обучения, и он предоставляет множество функций для вам, чтобы начать.

    • Вы можете загрузить браузер Chrome со страницы https://www.google.com/chrome или Firefox с http://www.mozilla.org/en-US/firefox/new/.

    • Почему существует так много способов делать что-то с регулярным выражения? Одна из причин заключается в том, что регулярные выражения имеют Замечательное качество называется компонуемостью .Язык, будь то формальный язык программирования или язык схем, который имеет качество компонуемость (Джеймс Кларк хорошо объясняет это на http://www.thaiopensource.com/relaxng/design.html#section:5) это тот, который позволяет вам использовать его атомарные части и методы композиции и затем легко их рекомбинировать разными способами. Как только вы узнаете различные части регулярных выражений, вы начнете в своем возможность сопоставления строк любого типа.

    • TextMate доступен по адресу http: // www.macromates.com. Для получения дополнительной информации о регулярные выражения в TextMate см. http://manual.macromates.com/en/regular_expressions.

    • Для получения дополнительной информации о Блокноте см. Http://notepad-plus-plus.org. Для документации по используя регулярные выражения в Блокноте, см. http://sourceforge.net/apps/mediawiki/notepad-plus/index.php?title=Regular_Expressions.

    • Узнайте больше о кислороде на http://www.oxygenxml.com. Для информации об использовании regex с помощью поиска и замены, см. http: // www.xygenxml.com/doc/ug-editor/topics/find-replace-dialog.html. Для получения информации об использовании его построителя регулярных выражений для XML Схема, см. Http://www.oxygenxml.com/doc/ug-editor/topics/XML-schema-regexp-builder.html.

    Конструктор RegExp () - JavaScript | MDN

    Возможны буквенные, конструкторские и заводские обозначения:

      / узор / флаги
    новый RegExp (шаблон [, флаги])
    RegExp (шаблон [, флаги])
      

    Параметры

    шаблон
    Текст регулярного выражения.
    Начиная с ES5, это также может быть другой объект или литерал RegExp (для только две нотации конструктора RegExp). Выкройки могут включать специальные символы для соответствия более широкому диапазону значений, чем буквальная строка.
    флаги

    Если указано, flags - строка, содержащая флаги для Добавить.

    В качестве альтернативы, если для шаблона предоставляется объект, flags строка заменит любой из флагов этого объекта (и lastIndex будет сброшен на 0 ) (по состоянию на ES2015).

    Если flags не указан и объект регулярных выражений указывается, флаги этого объекта (и значение lastIndex ) будут скопированы над.

    flags может содержать любую комбинацию из следующих персонажей:

    г (глобальное соответствие)
    Найти все совпадения, а не останавливаться после первого совпадения.
    i (без учета регистра)
    Если также включен флаг и , используйте сворачивание регистра Unicode. и $ ) как работа над несколькими строками. Другими словами, сопоставьте начало или конец каждая строка (разделенная на \ n или \ r ), а не только самое начало или конец всей входной строки.
    s ("dotAll")
    Позволяет . для соответствия новым строкам.
    u (юникод)
    Обрабатывать шаблон как последовательность кодовых точек Unicode.(Видеть также двоичные строки).
    y (липкий)
    Соответствует только индексу, указанному свойством lastIndex для это регулярное выражение в целевой строке. Не пытается найти соответствие ни с одним более поздние индексы.

    Литеральная нотация и конструктор

    Есть два способа создать объект RegExp : буквальное обозначение и конструктор .

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

    Следующие три выражения создают одно и то же регулярное выражение:

      / ab + c / i
    новый RegExp (/ ab + c /, 'i')
    новый RegExp ('ab + c', 'i')
      

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

    Конструктор объекта регулярного выражения - например, new RegExp ('ab + c') - приводит к компиляции во время выполнения обычного выражение. Используйте функцию-конструктор, если знаете шаблон регулярного выражения будет меняться, или вы не знаете шаблон и получаете его из другого источника, например, пользовательский ввод.

    Таблицы BCD загружаются только в браузере

    RegExp.prototype.test () - JavaScript | MDN

    Метод test () выполняет поиск совпадения между регулярное выражение и указанная строка. Возвращает истину или ложь .

    Исходный код этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, клонируйте https://github.com/mdn/interactive-examples и отправьте нам запрос на перенос.

    Параметры

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

    Возвращает

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

    Используйте test () всякий раз, когда вы хотите узнать, найден ли шаблон в нить. test () возвращает логическое значение, в отличие от Строка.prototype.search () (который возвращает индекс совпадения, или -1 , если не найден).

    Для получения дополнительной информации (но с более медленным выполнением) используйте exec () метод. (Это похоже на String.prototype.match () метод.)

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

    Использование test ()

    Простой пример, который проверяет, содержится ли " hello " в самом начале строка, возвращающая логический результат.привет / .test (str); console.log (результат);

    В следующем примере регистрируется сообщение, зависящее от успеха теста:

      function testInput (re, str) {
      пусть средняя струна;
      if (re.test (str)) {
        midstring = 'содержит';
      } еще {
        midstring = 'не содержит';
      }
      console.log (`$ {str} $ {midstring} $ {re.source}`);
    }
      

    Использование test () в регулярном выражении с «global» флаг

    Когда регулярное выражение имеет глобальный установлен флаг, test () продвинет lastIndex регулярного выражения.( RegExp.prototype.exec () также продвигает lastIndex свойство.)

    Дальнейшие звонки на test ( str ) возобновят поиск str начиная с lastIndex . В lastIndex Свойство будет продолжать увеличиваться каждый раз, когда test () возвращает истину .

    Примечание: Пока test () возвращает true , lastIndex сбрасывает , а не , даже при тестировании другой строки!

    Когда test () возвращает false , вызывающее регулярное выражение lastIndex свойство будет сброшено на 0 .

    Следующий пример демонстрирует это поведение:

      const регулярное выражение = / foo / g;
    
    
    regex.test ('фу')
    
    
    regex.test ('фу')
    
    
    regex.test ('barfoo')
    
    
    regex.test ('foobar')
    
    
    
      

    Таблицы BCD загружаются только в браузере

    Regular-Expressions.info — Учебное пособие по регулярным выражениям, примеры и справочные материалы

    Регулярное выражение (regex или regexp для краткости) — это специальная текстовая строка для описания шаблона поиска. Вы можете думать о регулярных выражениях как о подстановочных знаках на стероидах.и последний с $) может использоваться программистом, чтобы проверить, ввел ли пользователь правильно отформатированный адрес электронной почты. Всего в одной строке кода, независимо от того, написан ли этот код на Perl, PHP, Java, языке .NET или на множестве других языков.

    Быстрый старт с регулярными выражениями

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

    Полное руководство по регулярным выражениям

    Не беспокойтесь, если приведенный выше пример или краткое руководство не имеют для вас никакого смысла. Любое нетривиальное регулярное выражение выглядит устрашающим для того, кто с ним не знаком. Но, обладая небольшим опытом, вы скоро сможете создавать свои собственные регулярные выражения, как будто вы никогда больше ничего не делали. Бесплатное руководство Regular-Expressions.info объясняет все по крупицам.

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

    Учебное пособие по замене строк

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

    Приложения и языки, поддерживающие регулярные выражения

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

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

    Не только для программистов

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

    Дополнительная литература

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

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

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

    .

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *

    Theme: Overlay by Kaira Extra Text
    Cape Town, South Africa