Перевод строки регулярные выражения: Регулярные выражения, пособие для новичков. Часть 1 / Хабр

20 коротких шагов для освоения регулярных выражений. Часть 4

RegEx: 20 коротких шагов для освоения регулярных выражений. Часть 1
RegEx: 20 коротких шагов для освоения регулярных выражений. Часть 2
20 коротких шагов для освоения регулярных выражений. Часть 3

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

Оригинал здесь
Шаг 16: группы без захвата (?:)В двух примерах на предыдущем шаге мы захватывали текст, который в действительности нам не нужен.

В задаче «Размеры файлов» мы захватили пробелы перед первой цифрой размеров файлов, а в задаче «CSV» мы захватили запятые между каждым токеном. Нам не нужно захватывать эти символы, но нам нужно использовать их для структурирования нашего регулярного выражения. Это идеальные варианты для использования группы без захвата, (?:).
group: 1111

(Пример)

Вы можете создать именованную группу захвата с помощью (?…) или (?’name’…) синтаксиса (.NET-совместимое регулярное выражение) или с таким синтаксисом (?P…) или (?P’name’…) (Python-совместимое регулярное выражение). Поскольку мы используем PCRE (Perl-совместимое регулярное выражение), которое поддерживает обе версии, мы можем использовать любой из них здесь. (Java 7 скопировала синтаксис .NET, но только вариант с угловыми скобками. прим. переводчика)

Чтобы повторить именованную группу захвата позже в регулярном выражении, мы используем \ или \k’name’ (.NET) или (?P=name) (Python). Опять же, PCRE поддерживает все эти различные варианты. Вы можете прочитать больше об именованных группах захвата здесь, но это была большая часть того, что вам действительно нужно знать о них.
Задачка нам в помощь:
Используйте обратные ссылки, чтобы помочь мне вспомнить … эммм … имя этого человека.

pattern: 
string:  "Hi my name's Joe." [later] "What's that guy's name? Joe?". 
group:                 111    

(Решение)
Шаг 18: взгляд вперед (lookahead) и взгляд назад (lookbehind)
Сейчас мы углубимся в некоторые расширенные функции регулярных выражений. Всё, вплоть до шага 16, я использую довольно часто. Но эти последние несколько шагов предназначены только для людей, которые очень серьезно используют regex для сопоставления очень сложных выражений. Другими словами, мастера регулярных выражений.

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

pattern: (\w+)(?=!)
string:  I like desk. 
group:                                             1111    

(Пример)

Вы можете видеть, как указанная выше группа захвата (\w+), которая обычно соответствует любому из слов в отрывке, соответствует только слову lamp. Положительный «взгляд вперед» (?=!) означает, что мы можем сопоставлять только те последовательности, которые заканчиваются на ! но, на самом деле, мы не сопоставляем сам символ восклицательного знака. Это важное различие, потому что с группами без захвата мы сопоставляем символ, но не захватываем его. С помощью lookaheads и lookbehinds мы используем символ для построения нашего регулярного выражения, но затем мы даже не сопоставляем его с ним самим. Мы можем сопоставить его позже в нашем регулярном выражении.

Всего существует четыре вида lookaheads и lookbehinds: положительный взгляд вперед (?=…), отрицательный взгляд вперед (?!…), положительный взгляд назад (?. . Здесь может помочь регулярное выражение, использующее простой взгляд назад:

pattern: (?<=\. 
group:                  11111       11111       11111    

(Решение)

Предположим, что мы очищаем базу данных и у нас есть столбец информации, который обозначает проценты. К сожалению, некоторые люди записали числа в виде десятичных значений в диапазоне [0,0, 1,0], в то время как другие написали проценты в диапазоне [0,0%, 100,0%], а третьи написали процентные значения, но забыли литерал знак процента %. Используя отрицательный взгляд вперед (?!…), можете-ли вы пометить только те значения, которые должны быть процентами, но в которых отсутствуют знаки %? Это должны быть значения, строго превышающие 1,00, но без конечного % . (Ни одно число не может содержать более двух цифр до или после десятичной точки.)

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

pattern: 
string:  0.32 100.00 5.6 0. 
group:        111111 111                1111            11111 1111    

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

Мы рассмотрели, вероятно, 95% сценариев использования простых регулярных выражений, и все, что делается на шагах 19 и 20, обычно выполняется более полнофункциональным языком манипулирования текстом, таким как awk или sed (или языком программирования общего назначения). Тем не менее, давайте продолжим, просто чтобы вы знали, на что действительно способно регулярное выражение.

Хотя регулярные выражения не являются полными по Тьюрингу, некоторые движки регулярных выражений предлагают функции, которые очень похожи на полный язык программирования.
Одна из таких особенностей является «условием». Условные выражения Regex допускают операторы if-then-else, где выбранная ветвь определяется либо «взглядом вперед», либо «взглядом назад», о которых мы узнали на предыдущем шаге.

(Решение)
Шаг 20: рекурсия и дальнейшее обучение
На самом деле, есть очень много всего, что можно втиснуть в 20-шаговое введение в любую тему, и регулярные выражения не являются исключением.

Существует множество различных реализаций и стандартов для регулярных выражений, которые можно найти в Интернете. Если вы хотите узнать больше, я предлагаю вам посетить замечательный сайт regularexpressions.info, это фантастический справочник, и я, конечно, многое узнал от туда о регулярных выражениях. Я настоятельно рекомендую его, а также regex101.com для тестирования и публикации ваших творений.

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

Простые рекурсии довольно просты, но давайте подумаем, что это значит в контексте регулярного выражения. Синтаксис простой рекурсии в регулярном выражении записывается так: (?R)? . Но, конечно, этот синтаксис должен появляться внутри самого выражения. То что мы сделаем, это вложим выражение в себя, произвольное количество раз.
group: 11111 1111111111 1111111111

(Пример)

Поскольку вложенное выражение является необязательным ((?R) сопровождается ?), то самое простое совпадение — просто полностью игнорировать рекурсию. Итак, hey, а затем oh совпадает (heyoh). Чтобы сопоставить любое более сложное выражение, чем это, мы должны найти эту совпадающую подстроку, вложенную внутрь себя в той точке выражения, в которую мы вставили (?R) последовательность. Другими словами, мы могли бы найти heyheyohoh или heyheyheyohohoh, и так далее.

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

Элементы языка регулярных выражений — краткий справочник

• 
  000Z» data-article-date-source=»ms.date»>03/30/2017
• Чтение занимает 10 мин
• 
  
  

В этой статье

Регулярное выражение – это шаблон, который обработчик регулярных выражений пытается сопоставить с введенным текстом.A regular expression is a pattern that the regular expression engine attempts to match in input text. Шаблон состоит из односимвольных или многосимвольных литералов, операторов или конструкций.A pattern consists of one or more character literals, operators, or constructs. См. краткое описание регулярных выражений .NET.For a brief introduction, see .NET Regular Expressions.

В каждом разделе этого краткого справочника приводится перечень конкретной категории символов, операторов и конструкций, которые можно использовать для задания регулярных выражений.Each section in this quick reference lists a particular category of characters, operators, and constructs that you can use to define regular expressions.

Мы также представили эту информацию в двух форматах, чтобы вы могли ее скачать и распечатать для справки:We’ve also provided this information in two formats that you can download and print for easy reference:

Escape-знакиCharacter Escapes

Обратная косая черта (\) в регулярных выражениях указывает, что следующий за ней символ либо является специальным знаком (как показано в следующей таблице), либо должен интерпретироваться буквально.The backslash character (\) in a regular expression indicates that the character that follows it either is a special character (as shown in the following table), or should be interpreted literally. Дополнительные сведения см. в разделе Escape-символы.For more information, see Character Escapes.

Escape-символEscaped character	ОписаниеDescription	ШаблонPattern	Число соответствийMatches
\a	Соответствует знаку колокольчика, \u0007.Matches a bell character, \u0007.	\a	"\u0007" в "Error!" + '\u0007'"\u0007" in "Error!" + '\u0007'
\b	В классе символов соответствует знаку BACKSPACE, \u0008.In a character class, matches a backspace, \u0008.	[\b]{3,}	"\b\b\b\b" в "\b\b\b\b""\b\b\b\b" in "\b\b\b\b"
\t	Соответствует знаку табуляции, \u0009.Matches a tab, \u0009.	(\w+)\t	"item1\t", "item2\t" в "item1\titem2\t""item1\t", "item2\t" in "item1\titem2\t"
\r	Соответствует знаку возврата каретки, \u000D.Matches a carriage return, \u000D. (\r не эквивалентен знаку начала новой строки, \n.)(\r is not equivalent to the newline character, \n. )	\r\n(\w+)	"\r\nThese" в "\r\nThese are\ntwo lines.""\r\nThese" in "\r\nThese are\ntwo lines."
\v	Соответствует знаку вертикальной табуляции, \u000B.Matches a vertical tab, \u000B.	[\v]{2,}	"\v\v\v" в "\v\v\v""\v\v\v" in "\v\v\v"
\f	Соответствует знаку перевода страницы, \u000C.Matches a form feed, \u000C.	[\f]{2,}	"\f\f\f" в "\f\f\f""\f\f\f" in "\f\f\f"
\n	Соответствует знаку новой строки, \u000A.Matches a new line, \u000A.	\r\n(\w+)	"\r\nThese" в "\r\nThese are\ntwo lines.""\r\nThese" in "\r\nThese are\ntwo lines."
\e	Соответствует escape-знаку, \u001B. Matches an escape, \u001B.	\e	"\x001B" в "\x001B""\x001B" in "\x001B"
\ nnn\ nnn	Использует восьмеричное представление для указания символа ( nnn состоит из двух или трех цифр).Uses octal representation to specify a character ( nnn consists of two or three digits).	\w\040\w	"a b", "c d" в "a bc d""a b", "c d" in "a bc d"
\x nn\x nn	Использует шестнадцатеричное представление для указания символа ( nn состоит ровно из двух цифр).Uses hexadecimal representation to specify a character ( nn consists of exactly two digits).	\w\x20\w	"a b", "c d" в "a bc d""a b", "c d" in "a bc d"
\c X\c X \c x\c x	Соответствует управляющему символу ASCII, который задан как X или x , где X или x является буквой управляющего символа. Matches the ASCII control character that is specified by X or x , where X or x is the letter of the control character.	\cC	"\x0003" в "\x0003" (Ctrl-C)"\x0003" in "\x0003" (Ctrl-C)
\u nnnn\u nnnn	Совпадение со знаком Юникода в шестнадцатеричном представлении (строго четыре цифры, представленные как nnnn ).Matches a Unicode character by using hexadecimal representation (exactly four digits, as represented by nnnn ).	\w\u0020\w	"a b", "c d" в "a bc d""a b", "c d" in "a bc d"
\	Если за этим знаком следует символ, не распознанный как escape-символ из этой и других таблиц данной темы, то соответствует в точности этому символу.When followed by a character that is not recognized as an escaped character in this and other tables in this topic, matches that character. Например, \* — это то же самое, что и \x2A, а \. — то же самое, что и \x2E.For example, \* is the same as \x2A, and \. is the same as \x2E. Это позволяет обработчику регулярных выражений распознавать языковые элементы (такие как *или ?) и символьные литералы (представленные как \* или \?).This allows the regular expression engine to disambiguate language elements (such as * or ?) and character literals (represented by \* or \?).	\d+[\+-x\*]\d+	"2+2" и "3*9" в "(2+2) * 3*9""2+2" and "3*9" in "(2+2) * 3*9"

Классы символовCharacter Classes

Класс символов соответствует какому-либо одному набору символов.A character class matches any one of a set of characters. Классы символов состоят из языковых элементов, приведенных в следующей таблице.aei]"r", "g", "n" в "reign""r", "g", "n" in "reign"[ first - last ][ first - last ]Диапазон символов: соответствует одному символу в диапазоне от первого до последнего .Character range: Matches any single character in the range from first to last .[A-Z]"A", "B" в "AB123""A", "B" in "AB123".Подстановочный знак: соответствует любому одиночному символу, кроме \n.Wildcard: Matches any single character except \n.

Для сопоставления символа точки (.To match a literal period character (. или \u002E) перед ней нужно поставить дополнительную обратную косую черту (\.).or \u002E), you must precede it with the escape character (\.).

a.e"ave" в "nave""ave" in "nave"

"ate" в "water""ate" in "water"

\p{ имя }\p{ name }Соответствует любому одиночному символу в общей категории Юникода или в именованном блоке, указанном в параметре имя .Matches any single character in the Unicode general category or named block specified by name .\p{Lu}

\p{IsCyrillic}

"C", "L" в "City Lights""C", "L" in "City Lights"

"Д", "Ж" в "ДЖem""Д", "Ж" in "ДЖem"

\P{ имя }\P{ name }Соответствует любому одиночному символу, не входящему в общую категорию Юникода или в именованный блок, указанный в параметре имя .Matches any single character that is not in the Unicode general category or named block specified by name .\P{Lu}

\P{IsCyrillic}

"i", "t", "y" в "City""i", "t", "y" in "City"

"e", "m" в "ДЖem""e", "m" in "ДЖem"

\wСоответствует любому алфавитно-цифровому знаку.Matches any word character.\w"I", "D", "A", "1", "3" в "ID A1.3""I", "D", "A", "1", "3" in "ID A1.3"\WСоответствует любому символу, который не является буквенно-цифровым знаком.Matches any non-word character.\W" ", "." в "ID A1.3"" ", "." in "ID A1.3"\sСоответствует любому знаку пробела.Matches any white-space character.\w\s"D " в "ID A1.3""D " in "ID A1.3"\SСоответствует любому знаку, не являющемуся пробелом.Matches any non-white-space character.\s\S" _" в "int __ctr"" _" in "int __ctr"\dСоответствует любой десятичной цифре.Matches any decimal digit.\d"4" в "4 = IV""4" in "4 = IV"\DСоответствует любому символу, не являющемуся десятичной цифрой.Matches any character other than a decimal digit.\D" ", "=", " ", "I", "V" в "4 = IV"" ", "=", " ", "I", "V" in "4 = IV"

ПривязкиAnchors

Привязки, или атомарные утверждения нулевой ширины, приводят к успеху или сбою сопоставления, в зависимости от текущей позиции в строке, но не предписывают обработчику перемещаться по строке или обрабатывать символы.\d{3}"901" в "901-333-""901" in "901-333-"$По умолчанию соответствие должно обнаруживаться в конце строки или перед символом \n в конце строки. В многострочном режиме соответствие должно обнаруживаться до конца линии или перед символом \n в конце линии.By default, the match must occur at the end of the string or before \n at the end of the string; in multiline mode, it must occur before the end of the line or before \n at the end of the line.-\d{3}$"-333" в "-901-333""-333" in "-901-333"\AСоответствие должно обнаруживаться в начале строки.The match must occur at the start of the string.\A\d{3}"901" в "901-333-""901" in "901-333-"\ZСоответствие должно обнаруживаться в конце строки или до символа \n в конце строки.The match must occur at the end of the string or before \n at the end of the string.-\d{3}\Z"-333" в "-901-333""-333" in "-901-333"\zСоответствие должно обнаруживаться в конце строки.The match must occur at the end of the string.-\d{3}\z"-333" в "-901-333""-333" in "-901-333"\GСоответствие должно обнаруживаться в той точке, где заканчивается предыдущее соответствие.The match must occur at the point where the previous match ended.\G\(\d\)"(1)", "(3)", "(5)" в "(1)(3)(5)[7](9)""(1)", "(3)", "(5)" in "(1)(3)(5)[7](9)"\bСоответствие должно обнаруживаться на границе между символом \w (алфавитно-цифровым) и символом \W (не алфавитно-цифровым).The match must occur on a boundary between a \w (alphanumeric) and a \W (nonalphanumeric) character.\b\w+\s\w+\b"them theme", "them them" в "them theme them them""them theme", "them them" in "them theme them them"\BСоответствие не должно обнаруживаться на границе \b.The match must not occur on a \b boundary.\Bend\w*\b"ends", "ender" в "end sends endure lender""ends", "ender" in "end sends endure lender"

Конструкции группированияGrouping Constructs

Конструкции группирования отображают части выражений регулярных выражений и обычно захватывают части строки входной строки.Grouping constructs delineate subexpressions of a regular expression and typically capture substrings of an input string. Конструкции группирования состоят из языковых элементов, приведенных в следующей таблице.Grouping constructs include the language elements listed in the following table. Для получения дополнительной информации см. Конструкции группирования.For more information, see Grouping Constructs.

Конструкция группированияGrouping construct	ОписаниеDescription	ШаблонPattern	Число соответствийMatches
( subexpression )( subexpression )	Захватывает соответствующую часть выражения и назначает ей порядковый номер, отсчитываемый от единицы.Captures the matched subexpression and assigns it a one-based ordinal number.	(\w)\1	"ee" в "deep""ee" in "deep"
(?< name > subexpression )(?< name > subexpression ) oror (?' name ' subexpression )(?' name ' subexpression )	Выделяет соответствующую часть выражения в именованную группу.Captures the matched subexpression into a named group.	(?<double>\w)\k<double>	"ee" в "deep""ee" in "deep"
(?< name1 - name2 > subexpression )(?< name1 - name2 > subexpression ) oror (?' name1 - name2 ' subexpression )(?' name1 - name2 ' subexpression )	Задает сбалансированное определение группы.Defines a balancing group definition. Дополнительные сведения см. в разделе «Сбалансированное определение группы» статьи Конструкции группирования.For more information, see the «Balancing Group Definition» section in Grouping Constructs.	(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$	"((1-3)*(3-1))" в "3+2^((1-3)*(3-1))""((1-3)*(3-1))" in "3+2^((1-3)*(3-1))"
(?: subexpression )(?: subexpression )	Определяет невыделяемую группу.Defines a noncapturing group.	Write(?:Line)?	"WriteLine" в "Console.WriteLine()""WriteLine" in "Console.WriteLine()" "Write" в "Console.Write(value)""Write" in "Console.Write(value)"
(?imnsx-imnsx: subexpression )(?imnsx-imnsx: subexpression )	Применяет или отключает указанные параметры в части выражения .Applies or disables the specified options within subexpression . Для получения дополнительной информации см. Параметры регулярных выражений.For more information, see Regular Expression Options.	A\d{2}(?i:\w+)\b	"A12xl", "A12XL" в "A12xl A12XL a12xl""A12xl", "A12XL" in "A12xl A12XL a12xl"
(?= subexpression )(?= subexpression )	Утверждение положительного просмотра вперед нулевой ширины.Zero-width positive lookahead assertion.	\w+(?=\.)	"is", "ran" и "out" в "He is. The dog ran. The sun is out.""is", "ran", and "out" in "He is. The dog ran. The sun is out."
(?! subexpression )(?! subexpression )	Утверждение отрицательного просмотра вперед нулевой ширины.Zero-width negative lookahead assertion.	\b(?!un)\w+\b	"sure", "used" в "unsure sure unity used""sure", "used" in "unsure sure unity used"
(?<= subexpression )(?<= subexpression )	Утверждение положительного просмотра назад нулевой ширины.Zero-width positive lookbehind assertion.	(?<=19)\d{2}\b	"99", "50", "05" в "1851 1999 1950 1905 2003""99", "50", "05" in "1851 1999 1950 1905 2003"
(?<! subexpression )(?<! subexpression )	Утверждение отрицательного просмотра назад нулевой ширины.Zero-width negative lookbehind assertion.	(?<!19)\d{2}\b	"51", "03" в "1851 1999 1950 1905 2003""51", "03" in "1851 1999 1950 1905 2003"
(?> subexpression )(?> subexpression )	Атомарная группа.Atomic group.	[13579](?>A+B+)	"1ABB", "3ABB" и "5AB" в "1ABB 3ABBC 5AB 5AC""1ABB", "3ABB", and "5AB" in "1ABB 3ABBC 5AB 5AC"

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

Квантор указывает количество вхождений предшествующего элемента (знака, группы или класса знаков), которое должно присутствовать во входной строке, чтобы было зафиксировано соответствие.A quantifier specifies how many instances of the previous element (which can be a character, a group, or a character class) must be present in the input string for a match to occur. Кванторы состоят из языковых элементов, приведенных в следующей таблице.Quantifiers include the language elements listed in the following table. Для получения дополнительной информации см. Квантификаторы.For more information, see Quantifiers.

КвантификаторQuantifier	ОписаниеDescription	ШаблонPattern	Число соответствийMatches
*	Соответствует предыдущему элементу ноль или более раз.Matches the previous element zero or more times.	\d*\.\d	".0", "19.9", "219.9"".0", "19.9", "219.9"
+	Соответствует предыдущему элементу один или более раз.Matches the previous element one or more times.	"be+"	"bee" в "been", "be" в "bent""bee" in "been", "be" in "bent"
?	Соответствует предыдущему элементу ноль или один раз.Matches the previous element zero or one time.	"rai?n"	"ran", "rain""ran", "rain"
{ n }

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

 Мы запустили ТГ-канал по урокам C#

Toggle navigation

Professor Web

• C# 5.0 и .NET 4.5
  • Руководство C# — Часть 1
  • Руководство C# — Часть 2
  • Основы .NET
  • Сборки .NET
  • Потоки и файлы
  • Работа с сетью
  • Оптимизация приложений
• WPF
  • Основа WPF
  • Элементы управления WPF
  • Привязка и стили
  • Графика и анимация
  • Шаблоны WPF
  • Периферия WPF
• Темы WPF
  • Dark Blue UI
  • Dark Orange UI
• Silverlight 5
• Работа с БД
  • ADO.NET
  • Entity Framework 6
  • SQL Server 2012
  • Оконные функции
• LINQ
  • LINQ to Objects
  • LINQ to XML
  • LINQ to DataSet и SQL
  • LINQ to Entities
  • Parallel LINQ
• ASP.NET
  • Основы ASP.NET
  • Веб-сайты
  • Безопасность
  • Интернет магазин
  • ASP.NET Web Forms 4.5
  • ASP.NET MVC 5
  • Аутентификация

Регулярные выражения — Википедия

Шпаргалка по регулярным выражениям

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

	Аналог	Пример	Описание
?	{0,1}	a?	одно или ноль вхождений «а»
+	{1,}	a+	одно или более вхождений «а»
*	{0,}	a*	ноль или более вхождений «а»

Модификаторы

Символ «минус» (-) меред модификатором (за исключением U) создаёт его отрицание.

	Описание
g	глобальный поиск (обрабатываются все совпадения с шаблоном поиска)
i	игнорировать регистр
m	многострочный поиск. Поясню: по умолчанию текст это одна строка, с модификатором есть отдельные строки, а значит — начало строки в тексте, — конец строки в тексте.
s	текст воспринимается как одна строка, спец символ «точка» (.) будет вкючать и перевод строки
u	используется кодировка UTF-8
U	инвертировать жадность
x	игнорировать все неэкранированные пробельные и перечисленные в классе символы

Спецсимволы

	Аналог	Описание
()		подмаска, вложенное выражение
[]		групповой символ
{a,b}		количество вхождений от «a» до «b»
|		логическое «или», в случае с односимвольными альтернативами используйте []
\		экранирование спец символа
.a	aaa aaa	начало строки
$	a$	aaa aaa	конец строки
\A	\Aa	aaa aaa aaa aaa	начало текста
\z	a\z	aaa aaa aaa aaa	конец текста
\b	a\b \ba	aaa aaa aaa aaa	граница слова, утверждение: предыдущий символ словесный, а следующий — нет, либо наоборот
\B	\Ba\B	aaa aaa	отсутствие границы слова
\G	\Ga	aaa aaa	Предыдущий успешный поиск, поиск остановился на 4-й позиции — там, где не нашлось a

Скачать в PDF, PNG.

Якоря

Якоря в регулярных выражениях указывают на начало или конец чего-либо.

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

Здесь символ обозначает начало строки. Без него шаблон соответствовал бы любой строке, содержащей цифру.

Символьные классы

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

POSIX

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

Утверждения

Поначалу практически у всех возникают трудности с пониманием утверждений, однако познакомившись с ними ближе, выбудете использовать их довольно часто. Утверждения предоставляют способ сказать: «я хочу найти в этом документекаждое слово, включающее букву “q”, за которой не следует “werty”».

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

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

Кванторы

Кванторы позволяют определить часть шаблона, которая должна повторяться несколько раз подряд. Например, если выхотите выяснить, содержит ли документ строку из от 10 до 20 (включительно) букв «a», то можно использовать этотшаблон:

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

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

Приведенный выше шаблон найдет в этой строке вот такую подстроку:

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

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

Экранирование в регулярных выражениях

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

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

Шаблон для нахождения точки таков:

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

Спецсимволы экранирования в регулярных выражениях

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

Подстановка строк

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

Группы и диапазоны

Группы и диапазоны очень-очень полезны. Вероятно, проще будет начать с диапазонов. Они позволяют указать наборподходящих символов. Например, чтобы проверить, содержит ли строка шестнадцатеричные цифры (от 0 до 9 и от A до F),следует использовать такой диапазон:

Чтобы проверить обратное, используйте отрицательный диапазон, который в нашем случае подходит под любой символ, кромецифр от 0 до 9 и букв от A до F:

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

Использовать «или» очень просто: следующий шаблон ищет «ab» или «bc»:

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

Первая часть шаблона ищет «aaa» или «bbb», объединяя найденные буквы в группу. За этим следует поиск одной или болеецифр (), и наконец . Последняя часть шаблона ссылается на первую группу и ищет тоже самое. Она ищет совпадение с текстом, уже найденным первой частью шаблона, а не соответствующее ему. Такимобразом, «aaa123bbb» не будет удовлетворять вышеприведенному шаблону, так как будет искать «aaa»после числа.

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

Первым параметром будет примерно такой шаблон (возможно вам понадобятся несколько дополнительных символов для этойконкретной функции):

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

Ею будет заменена вся найденная по шаблону строка. Мы начинаем замену с первого найденного символа (который не букваи не цифра), отмечая его . Без этого мы бы просто удалили этот символ из текста. То же касается концаподстановки (). В середину мы добавили HTML тег для жирного начертания (разумеется, вместо него выможете использовать CSS или ), выделив им вторую группу, найденную по шаблону().

Модификаторы шаблонов

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

Регулярные выражения в Perl обрамляются одним и тем же символом в начале и в конце. Это может быть любой символ (чащеиспользуется «/»), и выглядит все таким образом:

Модификаторы добавляются в конец этой строки, вот так:

Мета-символы

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

Шпаргалка представляет собой общее руководство по шаблонам регулярных выражений без учета специфики какого-либо языка.Она представлена в виде таблицы, помещающейся на одном печатном листе формата A4.Создана под лицензией Creative Commons на базе шпаргалки, автором которой является Dave Child.Скачать в PDF, PNG.

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

DC — Синтаксис регулярных выражений

Double Commander использует свободную Delphi-библиотеку TRegExpr Андрея В. Сорокина: https://regex.sorokin.engineer/ru/latest/. Большинство из приведённых далее объяснений и примеров позаимствовано из справочного файла к этой библиотеке.

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

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

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

Double Commander поддерживает регулярные выражения в следующих функциях:

(наверх)

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

Последовательность символов совпадает с такой же последовательностью во входной строке, так что шаблон «bluh» совпадет с подстрокой «bluh» во входной строке.FooBarPtr»

(наверх)

Любой символ может быть определён с помощью escape-последовательности так же, как это делается в языках C или Perl: «\n» означает начало строки, «\t» — табуляцию и т.д.

\xnn, где nn — это последовательность шестнадцатеричных цифр, означает символ с ASCII-кодом nn.

Если необходимо определить двухбайтный (Юникод) символ, используем формат «\x{nnnn}», где «nnnn» — одна или более шестнадцатеричных цифр.

Escape-последовательности
Выражение	Результат
\xnn	символ с шестнадцатеричным кодом nn
\x{nnnn}	символ с шестнадцатеричным кодом nnnn (один байт для обычного текста и два для Юникода)

Biu thức chính quy — Công nghệ lập trình Web

\	Tìm với luật dưới đây: Một dấu gạch chéo ngược sẽ biến một kí tự thường liền kế phía sau thành một kí t c biệt, tứm thm Ví d, trường hợp kí tự ‘ b ‘ không có dấu gạch chéo ngược này sẽ được khớp với các kí tự ‘b’ in thường, nhưng khi nó có thêm dấu gc chéo 9000, nhc chéo sẽ không khớp với bất kì kí tự nào nữa, lúc này nó trở thành kí tự đặc biệt.Xem thêm phần символ границы слова để biết thêm chi tiết. Tuy nhiên nếu ng trước một kí tự đặc biệt thì nó sẽ biến kí tự này thành một kí tự thường, tức là bạn có thể tìm kiếm kí tự c trong k Ví dụ, mẫu / a * / có ‘*’ là kí tự c biệt và mẫu này sẽ bị phụ thuộc vào kí tự này, nên được hiểu là sẽ tìm khớp với 0 hoặc tựhiều. Nhng, với mẫu / a \ * / thì kí tự ‘ * ‘ lúc này được hiểu là kí tự thường nên mẫu này sẽ tìm kiếm xâu con là ‘a *’.’sẽ thay đổi khi nó xuất hiện như một kí tự đầu tiên trong một lớp kí tự, xem phần дополняет наборы символов để biết thêm chi tiết.
$	Со khớp ở cuối chuỗi. Nếu gắn cờ многострочный (đa dòng), nó sẽ khớp ngay trước kí tự xuống dòng. Ví d, / t $ / không khp với ‘t’ trong chuỗi «пожиратель» nhưng li khớp trong chuỗi «есть».
*	Cho phép kí tự trước nó lặp lại 0 lần hoặc nhiều lần.Tương đương với cách viết {0,}. Ví dụ, / bo * / khớp với ‘boooo’ trong chui «Призрак освистал» nhưng không khp trong chui «Рождение трели».
+	Cho phép kí tự trước nó lặp lại 1 lần hoặc nhiều lần. Tương đương với cách viết {1,}. Ví dụ, / a + / khớp với ‘a’ trong chui «конфета» và khớp với tất cả kí tự a liền nhau trong chuỗi «caaaaaaandy».
?	Cho phép kí tự trước nó lặp lại 0 ln hoặc 1 lần duy nhất.Tương đương với cách viết {0,1}. Ví dụ, / e? Le? / Khớp với ‘el’ trong chuỗi «ангел» và ‘le’ trong chuỗi «угол» hay ‘l’ trong «осло». Nếu sử dụng kí tự này ngay sau bất kì kí tự định lng nào trong số *, + ,? хай {}, đều làm bộ định lượng «чан ан» (dừng so khớp sau ngay khi tìm được kí tự phù hợp), trái ngược với đức tính «tham lam» vốn sẵìn th k ). Ví d, áp dụng biểu mẫu / \ d + / cho «123abc» ta c «123». Nhưng áp / \ d +? / Cho chính chuỗi trên ta chỉ nhận được kết quả là «1». Bạn có thể đọc thêm trong mục x (? = Y) và x (?! Y) của bảng này.
.	Dấu. khớp với bất kì kí tự đơn nào ngoại trừ kí tự xuống dòng. Ví dụ, /.n/ khớp với ‘an’ và ‘on’ trong chuỗi «нет, яблоко на дереве», nhưng không khớp với ‘но’.
(х)	Khớp ‘x’ và nhớ kết quả so khớp này, như ví dụ ở dưới. Các dấu ngoặc tròn được gọi là các dấu ngoc có nhớ. Biểu mẫu / (foo) (bar) \ 1 \ 2 / khớp với 'foo' và 'bar' trong chuỗi «foo bar foo bar». \ 1 và \ 2 trong mẫu khớp với 2 từ cuối. Chú ý rằng \ 1 , \ 2 , \ n được sử dụng để so khớp các phần trong regex, nó đại diện cho nhóm so khớp đằng trước. Ví dụ: / (foo) (bar) \ 1 \ 2 / tương đương với biểu thức / (foo) (bar) foo bar /. Cú pháp $ 1, $ 2, $ n còn được sử dụng trong việc thay thế các phần của một regex.Ví dụ: 'bar foo'.replace (/ (...) (...) /,' $ 2 $ 1 ') sẽ đảo vị trí 2 từ’ bar ‘và’ foo ‘cho nhau.
(?: X)	Khớp ‘x’ nhưng không nhớ kết quả so khp. Nhng dặu ngoặc tròn c gọi là những du ngoặc không nhớ, nó cho phép bạn định nghĩa những biểu thức con cho những toán tử so khớp. Xem xét biểu thức đơn giản / (?: foo) {1,2} /. Nếu biểu thức này được viết là / foo {1,2} / , {1,2} sẽ chỉ áp dụng cho kí tự ‘o’ ở cuối chuỗi ‘foo’.Với những dấu ngoặc không nhớ, {1,2} sẽ áp dụng cho cả cụm ‘foo’.
x (? = Y)	Chỉ khớp ‘x’ nếu ‘x’ theo sau bởi ‘y’. Ví dụ, / Jack (? = Sprat) / chỉ khớp với ‘Jack’ nếu đằng sau nó là ‘Sprat’. / Jack (? = Sprat | Frost) / chỉ khớp ‘Джек’ nếu theo sau nó là ‘Sprat’ hoặc ‘Frost’. Tuy nhiên, cả ‘Sprat’ và ‘Frost’ đều không phải là một phần của kết quả so khớp trả về.
х (?! Y)	Chỉ khớp ‘x’ nếu ‘x’ không được theo sau bởi ‘y’. Ví dụ: /\d+(?!\.)/ chỉ khớp với số không có dấu . đằng sau. Biểu thức /\d+(?!\.)/.exec("3.141 ") cho kết quả là ‘141’ mà không phải ‘3.141’.
х | у	Khp ‘x’ hoặc ‘y’ Ví dụ, / зеленый | красный / khớp với ‘зеленый’ trong chuỗi «зеленое яблоко» và ‘red’ trong chuỗi «красное яблоко».
{n}	Kí tự đứng trước phải xuất hiện n lần. n phải là một số nguyên dương. Ví d, / a {2} / không khp với ‘a’ trong «конфета», nhưng nó khớp với tất cả kí tự ‘a’ a ‘trong «caandy», và khớp với 2 kí tự’ a ‘u ti trong «caaandy».
{n, m}	Kí tự đứng trước phải xuất hiện từ n đến m lần. n và m là số nguyên dương và n <= m.Nếu m bị bỏ qua, nó tương đương như ∞. Ví dụ, / a {1,3} / không khớp bất kì kí tự nào trong «cndy», kí tự ‘a’ trong «конфеты», 2 kí tự ‘a’ u tiên trong «caandy», và 3 ки tự ‘a’ đầu tiên trong «caaaaaaandy». Lưu ý là «caaaaaaandy» chỉ khớp với 3 ки tự ‘a’ u tiên mặc dù chuỗi đó chứa 7 kí tự ‘a’.
[xyz]	Lớp kí tự. Loại mẫu này dùng để so khớp với một kí tự bất kì trong dấu ngoặc vuông, bao gồm cả escape-последовательности.a-c], khớp với ‘r’ trong «грудинка» và ‘h’ trong «отбивная» là kí tự đầu tiên không thuộc khoảng a đến c.
[\ b]	Khớp với kí tự dịch lùi — backspace (U + 0008). Bn phải đặt trong dấu ngoặc vuông nếu muốn so khớp một kí tự dịch lùi. (Đừng nhầm lẫn với mẫu \ b).
\ b	Khớp với kí tự biên. Kí tự biên là một kí tự giả, nó khớp với vị trí mà một kí tự không được theo sau hoặc đứng trước bởi một kí tự khác.\ w | \ w $ | \ W \ w | \ w \ W). L u ý rằng một kí tự biên được khớp sẽ không bao gồm trong kết quả so khớp. Nói cách khác, độ dài của một kí tự biên là 0. (Đừng nhầm lẫn với mẫu [\ b]) Ví dụ: / \ bm / khớp với ‘m’ trong chuỗi «луна»; / oo \ b / không khớp ‘oo’ trong chuỗi «луна», bởi vì ‘oo’ được theo sau bởi kí tự ‘n’; / oon \ b / khớp với ‘oon’ trong chuỗi «луна», bởi vì ‘oon’ cuối chuỗi nên nó không được theo sau bởi một kí tự; / \ w \ b \ w / sẽ không khớp với bất kì thứ gì, bởi vì một kí tự không thể theo sau một kí tự biên và một kí tự thường. Chú ý: Engine biên dịch biểu thức chính quy trong Javascript nh nghĩa một lớp kí tự là những kí tự thường. Bt kỳ kí tự nào không thuộc lớp kí tự bị xem như một kí tự ngắt. Lớp kí tự này khá hạn chế: nó bao gồm bộ kí tự La-tinh cả hoa và thường, số thập phân và kí tự gạch dưới. Kí tự có dấu, như «é» hay «ü», không may, bị đối xử như một kí tự ngắt.
\ B	Khớp với kí tự không phải kí tự biên.Mẫu này khớp tại vị trí mà kí tự trước và kí tự sau nó cùng kiểu: hoặc cả hai là kí tự hoặc cả hai không phải là kí tự. Bắt đầu và kết thúc chuỗi không được xem là những kí tự. Ví dụ, /\B../ khớp với ‘oo’ trong «полдень», và /y\B./ khớp với ‘ye’ trong «возможно, вчера».
\ c X	X là một kí tự trong khoảng A tới Z. Mẫu này khớp với một kí tự iều khiển trong một chuỗi. Ví dụ: / \ cM / khớp với control-M (U + 000D) trong chuỗi.
\ d

Приложение A. ОБЫЧНЫЙ ПОИСК ВЫРАЖЕНИЯ

Приложение A. ОБЫЧНЫЙ ПОИСК ВЫРАЖЕНИЯ

Краткая справочная информация

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

Поддерживаемый синтаксис ^[]

Таблица A.1. Символы

\

x	Символ x
\\	Символ обратной косой черты
\ 0n с восьмеричным числом	\ 0n <= n <= 7)
\ 0nn	Символ с восьмеричным значением 0nn (0 <= n <= 7)
\ 0mnn	Символ с восьмеричным значением 0mnn (0 <= m <= 3, 0 <= n <= 7)
\ xhh	Символ с шестнадцатеричным значением 0xhh
\ uhhhh	Символ с шестнадцатеричным значением 0xhhhh
		\ u0009 ')
\ n	Символ новой строки (перевод строки) (' \ u000A ')
\ r	Символ возврата каретки (' \ u000D ')
\ f	Символ подачи страницы (' \ u000C ')
\ a	Знак предупреждения (колокольчик) (' \ u0007 ')
\ e	Управляющий символ (' \ u001B ')
\ cx	Управляющий символ, соответствующий x

9036 8 Таблица А. m-p]] a – z , а не m –
p : [a-lq-z] (вычитание)

Таблица A.\ w]

Таблица A.4. Классы символов POSIX (только US-ASCII)

\ p {Lower}	Буквенный символ нижнего регистра: [az]
\ p {Upper}	Буквенный символ верхнего регистра: [AZ]
\ p {ASCII}	Все ASCII: [\ x00- \ x7F]
\ p {Alpha}	Буквенный символ: [\ p {Lower} \ p {Upper}]
\ p {Digit}	Десятичная цифра: [0-9]
\ p {Alnum}	Буквенно-цифровой символ: [\ p {Alpha} \ p {Digit}]
\ p {Punct}	Пунктуация: одна из ! "# $% & '() * +, -._` {|} ~
\ p {Graph}	Видимый символ: [\ p {Alnum} \ p {Punct}]
\ p {Print}	Печатный символ: [\ p {Graph}]
\ p {Пусто}	Пробел или табуляция: [\ t]
\ p {Cntrl}	Управляющий символ: [\ x00- \ x1F \ x7F]
\ p {XDigit}	Шестнадцатеричная цифра: [0-9a-fA-F]
		\ p {Пробел}	Пробельный символ: [\ t \ n \ x0B \ f \ r]

Таблица A.5. Классы для блоков и категорий Unicode

\ p {InGreek}	Символ в греческом блоке (простой блок)
\ p {Lu}	Заглавная буква (простая категория)
\ p {Sc}	Символ валюты
\ P {InGreek}	Любой символ, кроме одного в греческом блоке (отрицание)
[\ p {L} && [^ \ p {Lu}]]	Любая буква, кроме прописной (вычитание)

Таблица A. Начало строки $ Конец строки \ b Граница слова \ B граница слова \ A Начало ввода \ G Конец предыдущего совпадения \ Z Конец ввода, но для финала терминатор, если есть \ z Конец входа

Таблица A.7. Жадные кванторы

X?	X, однократно или не сразу
X *	X, ноль или более
X +	X, один или несколько раз
X {n}	X, ровно n раз
X {n,}	X, не менее n раз
X {n, m}	X, не менее n, но не более м раз

Таблица А.8. Нехватка кванторов

X ??	X, один раз или не сразу
X *?	X, ноль или более раз
X +?	X, один или несколько раз
X {n}?	X, ровно n раз
X {n,}?	X, не менее n раз
X {n, m}?	X, не менее n, но не более m раз

Таблица A.9. Притяжательные кванторы

000

X ++

X? +	X, однократно или не полностью
X * +	X, ноль или более
X, один или несколько раз
X {n} +	X, ровно n раз
X {n,} +	X, не менее n раз
X {n, m} +	X, не менее n, но не более m раз

Таблица A.10. Логические операторы

Таблица A.11. Обратные ссылки

Таблица A.12. Предложение

\	Ничего, кроме кавычек следующего символа
\ Q	Ничего, но цитирует все символы до 000 \ E 000 \ E E	Ничего, но завершает котировку, начатую на \ Q

Таблица A.13. Специальные конструкции (не захватывающие)

(?: X)	X, как группа без захвата
(? Idmsux-idmsux)		Ничего, но включает / выключает флаги соответствия
(? Idmsux-idmsux: X)	X, как группа без захвата с заданными флагами вкл / выкл
(? = X)	X, через положительный просмотр вперед нулевой ширины
(?! X)	X, через отрицательный просмотр вперед нулевой ширины
(? <= X)	X, через ноль положительный просмотр назад с шириной
(?	X, через отрицательный просмотр назад с нулевой шириной
(?> X)	X, как независимый, без захвата группа

Обратные косые черты, экранирование и цитирование

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

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

Обратные косые черты в строковых литералах в исходном коде Java интерпретируются в соответствии с требованиями
Ява
Спецификация языка как Unicode
сбегает или сбегает другой персонаж.Поэтому необходимо использовать двойную обратную косую черту в строке
литералы, представляющие регулярные выражения, чтобы защитить их от интерпретации Java
компилятор байтового кода. Например, строковый литерал " \ b " соответствует одному
символ обратного пробела при интерпретации как регулярное выражение, а " \\ b " соответствует
граница слова. Строковый литерал « \ (привет \) » является недопустимым и приводит к
ошибка времени компиляции; чтобы соответствовать строке (привет) строковый литерал
Необходимо использовать " \ (привет \) ".

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

Приоритет операторов класса символов следующий, от наивысшего к низшему:

9 -0003

[пересечение [aeiou]]

1	Буквальный переход	\ x
2	Группировка	[...]
3	Диапазон	az
4	Union	[ae] [iu]
5

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

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

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

Этот тип утверждения полезен по нескольким причинам. Во-первых, он выразительный: он позволяет вам указать, что вы хотите сопоставить цифры в конце строки, но не где-либо еще. Во-вторых, это эффективно: когда вы говорите движку, что хотите найти комплексный шаблон в заданном месте, ему не нужно тратить время на попытки найти этот шаблон во многих других местах. Вот почему руководство по стилю регулярных выражений рекомендует по возможности использовать якоря, даже если ваше регулярное выражение будет соответствовать без них. называется якорем, а \ b - границей и (? a в обеих строках:
яблоко
абрикос

(прямая ссылка)

Доллар $: конец строки (или строки)

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

(прямая ссылка)
Все двигатели: совпадение в самом конце строки
Все движки согласны с одной позицией строки, где разрешено совпадение долларового якоря $: в самом конце строки.Например, если ваша строка - яблоко , привязка $ соответствует позиции после e , а e $ соответствует окончательному e , но не первому.

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

JavaScript, однако, не обладает такой гибкостью (что вас не удивит, если вы помните, что JavaScript, по большому счету, является худшим среди всех основных движков регулярных выражений).Если вы добавите разрыв строки в конце строки яблоко , как в яблоко \ n , механизм JavaScript больше не будет соответствовать окончательному e .

(прямая ссылка)
Все движки, кроме JavaScript: соответствие до одного окончательного разрыва строки

Во всех основных движках, кроме JavaScript, если в строке есть один последний разрыв строки, то привязка $ может совпадать с ним. Например, в яблоко \ n , e $ соответствует окончательному e .

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

(прямая ссылка)
Для всех механизмов, кроме PCRE, последний символ разрыва строки должен быть символом перевода строки \ n . Но в PCRE (C, PHP, R…) определение разрыва строки для привязки $ зависит от того, как был скомпилирован PCRE. В зависимости от языка и инструмента, последнему символу новой строки может быть разрешено быть переводом строки, возвратом каретки, последовательностью перевода строки и возврата каретки или любого из вышеперечисленных.

Помимо этих потенциальных различий, связанных с тем, как был скомпилирован PCRE, PCRE также позволяет вам переопределить новую строку по умолчанию (и, следовательно, поведение $ anchor) одним из специальных модификаторов начала шаблона PCRE, таких как (* ANYCRLF), ( * CR) и (* ЛЮБОЙ)

(прямая ссылка)
Многострочный режим (и Ruby по умолчанию): $ соответствует каждой строке

В Ruby привязка $ всегда соответствует концу строки. Например, e $ соответствует e в обеих строках:
яблоко
апельсин

Другие движки (включая JavaScript) также позволяют использовать $ в конце строки при включении многострочного режима (перейдите по ссылке, чтобы узнать, как включить многострочность на разных языках).и $ для соответствия в каждой строке может показаться раздражающим, потому что это нестандартно. Однако, как только вы узнаете о якорях, таких как \ A и \ Z, вы увидите, что этот способ действий имеет большой смысл, поскольку он придает якорям однозначное значение. также соответствует этой позиции.меняет свое значение, когда включена многострочная строка, \ A дает нам однозначную привязку, чтобы гарантировать, что мы действительно когда-либо сопоставляем только начало строки.

(прямая ссылка)

Самый конец строки: \ z

Строка идет
от \ A до \ z

Во всех основных разновидностях регулярных выражений, кроме JavaScript и Python (где этот токен не существует), привязка \ z утверждает, что текущая позиция движка в строке - это самый конец строки (за исключением любых возможных окончательных разрывов строки).Следовательно, в следующей строке e \ z соответствует e в orange , но не apple :
apple
orange

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

Так как привязка \ A определяет самое начало строки, мы могли ожидать в конце строки другую заглавную букву, а не строчную \ z.Вместо этого \ Z (который мы увидим дальше) дает нам некоторую гибкость при переносе строки (кроме Python). Поэтому полезно думать о строке как о переходе от \ A к \ z.

(прямая ссылка)

Конец строки (или перед необязательным разрывом строки): \ Z

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

✽ В Python токен \ Z делает то, что \ z делает в других движках: он соответствует только в самом конце строки.

✽ В .NET, Perl и Ruby разрешено совпадение \ Z перед окончательным переводом строки. Следовательно, e \ Z будет соответствовать заключительному e в строке apple \ norange \ n

✽ В Java \ Z также будет соответствовать перед последним символом разрыва строки, который может быть переводом строки или возвратом каретки и другие разделители строк.

✽ В PCRE (C, PHP, R…) \ Z также будет соответствовать перед последним символом разрыва строки. Как обсуждалось ранее, то, что PCRE определяет как символ разрыва строки, зависит от того, как он был скомпилирован, а также от потенциального присутствия специальных модификаторов начала шаблона PCRE, таких как (* ANYCRLF), (* CR) и (* ANY)

(прямая ссылка)

Наводим порядок: постоянно многострочный

Есть хороший аргумент в пользу того, чтобы всегда оставлять многострочный режим включенным, чтобы дать четкие роли всем якорям, которые мы видели до сих пор.всегда совпадать в каждой строке. И если вам нужно найти совпадение в начале или конце строки, вы можете использовать \ A, \ Z или \ z.

Фактически, это поведение Руби. К этому же и движется Perl 6. Для меня эта идея имеет большой смысл: она избавляет от многострочного режима m и делает якоря более значимыми.

(прямая ссылка)

Начало строки или конец предыдущего совпадения: \ G

.NET, PCRE (C, PHP, R…), Java, Perl и Ruby поддерживают \ G, полезную привязку, которая может соответствовать одной из двух позиций:
✽ Начало строки,
✽ Позиция, которая следует сразу за окончанием предыдущего матча.

Среди прочего, \ G может пригодиться в токенизированных строках, когда вы хотите сопоставить токены в определенных областях строки, но не в других. Рассмотрим, например, эту строку, показывающую время Джейн и Тарзана в трех отдельных тестах на плавание:
Тарзан A: 33 B: 32 C: 36 Джейн A: 35 B: 33 C: 31

Если нас интересует только сопоставление оценок Джейн, мы можем использовать:

(?: Jane | \ G) \ w +: (\ d +)

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

Как это работает? Когда движок пытается сопоставить начало строки, первый токен (?: Jane | \ G) завершается успешно, потому что \ G совпадает с началом строки. Однако следующий жетон (пробел) не работает против T Тарзана. Следующий шанс совпадения шаблона - в позиции перед Jane . Двигатель соответствует " Jane A: 35 ", что соответствует 35 Группе 1.В начальной позиции следующей попытки совпадения \ G совпадает, а двигатель соответствует " B: 33 ". Наконец, \ G снова совпадает, а двигатель соответствует " C: 31 ".

Между прочим, в PCRE, Perl и Ruby вам не нужно извлекать время из группы 1: вы можете сопоставить их напрямую с помощью этого небольшого варианта, где \ K говорит движку отбросить то, что было сопоставлено так далеко от совпадения. должен быть возвращен:
(?: Jane | \ G) \ w +: \ K \ d +

(прямая ссылка)
Матч "Начало строки": Использование или Bridling \ G
Тот факт, что \ G соответствует началу строки, не является ни удобным, ни неудобным.Половину времени мы пользуемся этим свойством. С другой половиной мы работаем.

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

Предположим, мы хотим сопоставить первые три токена, то есть A1 , B1 , C1 .N соответствует всем строкам, начинающимся с N.

Конец строки ($)

Символ доллара $ соответствует концу строки.

Отобразите строки, заканчивающиеся буквой r:

$ sed -n '/ r $ / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
104, Ананд Рам, разработчик
105, Джейн Миллер, менеджер по продажам
 

Односимвольный (.)

Специальный метасимвол «.» (точка) соответствует любому символу, кроме символа конца строки.

• . соответствует одиночному символу
• .. соответствует двум символам
• ... соответствует трем символам
• и т. Д.

В следующем примере шаблон «J, за которым следуют три символа и пробел» будет заменен на «Джейсон, за которым следует пробел». Итак, «J ...» соответствует как «Джон», так и «Джейн» из employee.txt, и эти две строки заменяются соответственно, как показано ниже.

$ sed -n 's / J ... / Джейсон / p' employee.txt
101, Джейсон Доу, генеральный директор
105, Джейсон Миллер, менеджер по продажам
 

Ноль или более вхождений (*)

Специальный символ «*» (звездочка) соответствует нулю или более вхождений предыдущего символа.Например, шаблон ’1 *’ соответствует нулю или более чем ’1 '.

Для этого примера создайте следующий файл log.txt:

$ vi log.txt
журнал: ввод подтвержден
журнал:
журнал: тестирование возобновлено
журнал:
журнал: вывод создан
 

Предположим, вы хотите просмотреть только те строки, которые содержат «log:», за которым следует сообщение. Сообщение может сразу же следовать за журналом или содержать пробелы. Вы не хотите, чтобы строки, содержащие "log:", ничего не отображали.

Отобразите все строки, которые содержат «журнал:», за которым следует один или несколько пробелов, за которыми следует символ:

$ sed -n '/ журнал: *./ p 'log.txt
журнал: ввод подтвержден
журнал: тестирование возобновлено
журнал: вывод создан
 

Примечание. В приведенном выше примере точка в конце необходима. Если не указан, sed также распечатает все строки, содержащие только «log:».

Одно или несколько происшествий (\ +)

Специальный символ «\ +» соответствует одному или нескольким вхождениям предыдущего символа. Например, пробел перед «\ +», т.е. «\ +» соответствует как минимум одному или нескольким пробелам. Давайте использовать тот же файл log.txt в качестве примера файла.

Отобразите все строки, содержащие слово «log:», за которым следует один или несколько пробелов:

$ sed -n '/ журнал: \ + / p' журнал.текст
журнал: ввод подтвержден
журнал: тестирование возобновлено
 

Примечание. В дополнение к несоответствию строк «log:» only, приведенный выше пример также не соответствует строке «log: output created», поскольку в этой строке нет места после «log:».

Ноль или один вхождение (\?)

Специальный символ «?» соответствует нулю или одному вхождению предыдущего символа, как показано ниже.

$ sed -n '/ журнал: \? / p' log.txt
журнал: ввод подтвержден
журнал:
журнал: тестирование возобновлено
журнал:
журнал: вывод создан
 

Экранирование специального символа (\)

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

$ sed -n '/127\.0\.0\.1/ p' / etc / hosts
127.0.0.1 локальный хост.localdomain локальный хост
 

Класс символов ([0-9])

Класс символов - это не что иное, как список символов, упомянутых в квадратных скобках; это используется для соответствия только одному из нескольких символов.

Соответствует любой строке, содержащей 2, 3 или 4:

$ sed -n '/ [234] / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
103, Радж Редди, системный администратор
104, Ананд Рам, разработчик
 

В квадратных скобках вы можете использовать дефис, вы можете указать диапазон символов.Например, [0123456789] может быть представлен как [0-9], а алфавитные диапазоны могут быть указаны, например, [a-z], [A-Z] и т. Д.

Соответствует любой строке, содержащей 2, 3 или 4 (альтернативная форма):

$ sed -n '/ [2-4] / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
103, Радж Редди, системный администратор
104, Ананд Рам, разработчик
 

21. Дополнительные регулярные выражения

Операция ИЛИ (|)

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

$ sed -n '/ 101 \ | 102 / p' employee.txt
101, Джон Доу, генеральный директор
102, Джейсон Смит, ИТ-менеджер
 

Обратите внимание, что | символ экранирован символом /.

Выведите строки, содержащие символы от 2 до 3 или содержащие строку 105:

$ sed -n '/ [2-3] \ | 105 / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
103, Радж Редди, системный администратор
105, Джейн Миллер, менеджер по продажам
 

Ровно M вхождений ({m})

Регулярное выражение, за которым следует {m}, соответствует точно m вхождениям предыдущего выражения.[0-9] \ {3,5 \} $ / p 'numbers.txt
123
1234
12345

Регулярное выражение, за которым следует {m,} - это особый случай, который соответствует m или более вхождениям предыдущего выражения.

Граница слова (\ b)

\ b используется для сопоставления границы слова. \ b соответствует любому символу (символам) в начале (\ bxx) и / или конце (xx \ b) слова, поэтому \ bthe \ b найдет, но не они. \ bThe найдут или они.

Создайте следующий образец файла для тестирования.

$ cat words.txt
сопоставление слов с использованием:
сопоставление слов с использованием: thethe
сопоставление слов с использованием: они
 

Сопоставьте строки, содержащие целое слово "the":

$ sed -n '/ \ b \ b / p' слова.текст
сопоставление слов с использованием:
 

Обратите внимание, что если вы не укажете \ b в конце, он будет соответствовать всем строкам.

Сопоставьте строки, содержащие слова, начинающиеся с «the»:

$ sed -n '/ \ bthe / p' words.txt
сопоставление слов с использованием:
сопоставление слов с использованием: thethe
сопоставление слов с использованием: они
 

Обратные ссылки (\ n)

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

Соответствует только строке, в которой слово "the" повторяется дважды:

$ sed -n '/ \ (\) \ 1 / p' words.txt
 

Используя ту же логику, регулярное выражение «\ ([0-9] \) \ 1» соответствует двузначному числу, в котором обе цифры являются одним и тем же числом, например 11,22,33.
...

22. Замена Sed регулярным выражением

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

Замените последние два символа в каждой строке employee.txt на ", Not Defined":

$ sed 's /..$/, не определено /' employee.txt
101, Джон Доу, C, не определено
102, Джейсон Смит, ИТ-менеджер, не определено
103, Радж Редди, Sysadm, не определено
104, Ананд Рам, Развитие, Не определено
105, Джейн Миллер, менеджер по продажам, не определено
 

Удалите оставшуюся часть строки, начиная с «Manager»:

$ sed / Manager.#. * / d '/ etc / profile
 

Вы можете преобразовать символы новой строки DOS (CR / LF) в формат Unix, используя sed. Когда вы копируете файл DOS в Unix, вы можете найти \ r \ n в конце каждой строки.

Преобразуйте формат файла DOS в формат файла Unix с помощью sed:

sed 's /.$//' имя файла
 

Регулярные выражения Kotlin - использование регулярных выражений в Kotlin

последнее изменение 5 июля 2020 г.

В учебнике по регулярным выражениям Kotlin показано, как использовать регулярные выражения
в Котлине.

Регулярные выражения используются для поиска текста и более сложного текста
манипуляции.Регулярные выражения - это встроенные инструменты, такие как grep, sed,
текстовые редакторы, такие как vi, emacs, языки программирования, включая Kotlin, JavaScript, Perl и Python.

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

В Kotlin мы создаем регулярные выражения с помощью Regex .

Regex ("книга")
"книга" .toRegex ()
Regex.fromLiteral ("книга")
 

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

Специальные символы должны быть экранированы дважды, иначе мы можем использовать Kotlin raw
струны.

После того, как мы создали шаблон, мы можем использовать одну из функций
чтобы применить узор к текстовой строке. Функции включают
соответствует () , containsMatchIn () , find () ,
findall () , replace () и split () .

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

Регулярное выражение	Значение
. abc]	Отрицание, соответствует всему, кроме a, или b, или c.
\ с	Соответствует пробелу.
\ w	Соответствует словесному символу; эквивалент [a-zA-Z_0-9]

Kotlin соответствует и содержит методы MatchIn

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

simple_regex.kt

пакет com.zetcode

fun main () {

    val words = listOf ("книга", "книжный червь", "Библия",
            «книжный», «кулинарная», «книжный магазин», «бумажник»)

    val pattern = "книга" .toRegex ()

    println ("*********************")
    println ("функция containsMatchIn")

    words.forEach {слово ->
        if (pattern.containsMatchIn (word)) {
            println ("$ word совпадает")
        }
    }

    println ("*********************")
    println ("соответствует функции")

    слова.forEach {слово ->
        if (pattern.matches (word)) {
            println ("$ word совпадает")
        }
    }
}
 

В этом примере мы используем матчей () и
containsMatchIn () методов. У нас есть список слов.
Шаблон будет искать строку "книжка" в каждом слове, используя
оба метода.

val pattern = "книга" .toRegex ()
 

Шаблон регулярного выражения создается с помощью toRegex ()
метод. Регулярное выражение состоит из четырех обычных символов.

words.forEach {слово ->
    if (pattern.containsMatchIn (word)) {
        println ("$ word совпадает")
    }
}
 

Мы перебираем список и применяем containsMatchIn () к
каждое из слов.

words.forEach {слово ->
    if (pattern.matches (word)) {
        println ("$ word совпадает")
    }
}
 

Мы снова перебираем список и применяем совпадений () к
каждое из слов.

*********************
containsMatchIn функция
забронировать спички
спички книжного червя
книжные спички
поваренная книга спички
книжный магазин спички
карманные спички
*********************
функция соответствия
забронировать спички
 

Для метода containsMatchIn () шаблон соответствует
если где-то в слове есть слово «книга»; для совпадений () ,
входная строка должна полностью соответствовать шаблону.

Метод поиска Котлина

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

regex_find.kt

пакет com.zetcode

fun main () {

    val text = "Я видел лису в лесу. У лисы был рыжий мех."

    val pattern = "лиса" .toRegex ()

    val match = pattern.find (текст)

    val m = совпадение? .value
    val idx = match? .range

    println ("$ m найдено по индексам: $ idx")

    val match3 = шаблон.найти (текст, 11)

    val m2 = match3? .значение
    val idx2 = match3? .range

    println ("$ m2 найдено по индексам: $ idx2")
}
 

В примере мы узнаем индексы совпадения термина «лиса».

val match = pattern.find (текст)

val m = совпадение? .value
val idx = match? .range
 

Мы находим первое совпадение термина «лиса». Получаем его стоимость и показатели.

val match3 = pattern.find (текст, 11)

val m2 = match3? .значение
val idx2 = match3? .range
 

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

лиса найдена по индексам: 8..10
лиса найдено по индексам: 29..31
 

Это результат.

Kotlin findAll метод

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

regex_findall.kt

пакет com.zetcode

fun main () {

    val text = "Я видел лису в лесу. У лисы был рыжий мех."
    val pattern = "лиса" .toRegex ()

    val соответствует = pattern.findAll (текст)

    совпадения.forEach {f ->
        
        val m = f.value
        val idx = f.range
        println ("$ m найдено по индексам: $ idx")
    }
}
 

В этом примере мы находим все вхождения термина «лиса» с findAll () .

Границы слов регулярного выражения Kotlin

Метасимвол \ b - это якорь, который соответствует позиции, которая
называется границей слова. Это позволяет искать слова целиком.

word_boundaries.kt

пакет com.zetcode

fun main () {

    val text = "Этот остров прекрасен"
    val pattern = "\\ bis \\ b" .toRegex ()

    val соответствует = pattern.findAll (текст)

    match.forEach {m ->
        val v = m.value
        val idx = m.range
        println ("$ v найдено по индексам: $ idx")
    }
}
 

В этом примере мы ищем - это слово. Мы не хотим включать
Это и остров слов.

val pattern = "\\ bis \\ b" .toRegex ()
 

С двумя метасимволами \ b мы ищем - это целое слово .

val соответствует = pattern.findAll (текст)
 

С помощью функции findAll () мы находим все совпадения.

находится по индексам: 12..13
 

Это результат.

Регулярное выражение Kotlin неявные границы слов

\ w - это класс символов, используемый для символа, разрешенного в слове.
Для регулярного выражения \ w + , обозначающего слово, в начале
метасимволы границ слова неявны; я.е. \ w + - это
равно \ b \ w + \ b .

implicit_word_boundaries.kt

пакет com.zetcode

fun main () {
    val content = "" "
Лисицы - всеядные млекопитающие, принадлежащие к нескольким родам.
семейства Canidae. У лисиц уплощенный череп, прямостоячие треугольные уши,
заостренная, слегка вздернутая морда и длинный пушистый хвост. Лисы живут на каждом
континент, кроме Антарктиды. Безусловно, наиболее распространенные и широко распространенные виды
лиса - это рыжая лисица. "" "

    val шаблон = "\\ ш +".toRegex ()

    val words = pattern.findAll (содержание)
    val count = words.count ()

    println ("Есть $ count слов")

    words.forEach {matchResult ->
        println (matchResult.value)
    }
}
 

В этом примере мы ищем все слова в тексте.

val pattern = "\\ w +". toRegex ()
 

Ищем слова.

val words = pattern.findAll (содержание)
val count = words.count ()
 

Находим все слова и считаем.

Символы валюты Котлина

Обычное выражение \ p {Sc} можно использовать для поиска валюты
символы.

currency_symbols.kt

пакет com.zetcode

fun main () {

    val content = "" "
Символы валюты: ฿ Тайская баня, ₹ Индийская рупия, ₾ Грузинский лари, Доллар США,
€ Евро, ¥ Йена, фунт стерлингов "" "

    val pattern = "\\ p {Sc}". toRegex (RegexOption.IGNORE_CASE)

    val соответствует = pattern.findAll (контент)

    match.forEach {matchResult ->

        val currency = matchResult.value
        val idx = matchResult.range

        println ("$ валюта в $ idx")
    }
}
 

В этом примере мы ищем символы валюты.

    val content = "" "
Символы валюты: ฿ Тайская баня, ₹ Индийская рупия, ₾ Грузинский лари, Доллар США,
€ Евро, ¥ Йена, фунт стерлингов "" "
 

В тексте есть пара символов валюты.

val pattern = "\\ p {Sc}". toRegex (RegexOption.IGNORE_CASE)
 

Мы определяем регулярное выражение для символов валюты.

val соответствует = pattern.findAll (контент)
 

Находим все совпадения.

match.forEach {matchResult ->

    val currency = matchResult.значение
    val idx = matchResult.range

    println ("$ валюта в $ idx")
}
 

Мы печатаем все совпавшие значения и их индексы.

฿ в 19..19
₹ в 36..36
₾ на 52..52
$ по 69..69
€ 79..79
¥ в размере 87..87
£ по 94..94
 

Это результат.

Функция разделения Котлина

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

regex_split.js

пакет com.zetcode

fun main () {

    val text = "Я видел лису в лесу.У лисы был рыжий мех ".

    val pattern = "\\ W +". toRegex ()
    val words = pattern.split (текст) .filter {it.isNotBlank ()}

    println (слова)
}
 

В примере мы узнаем, сколько раз встречается термин «лиса».

val pattern = "\\ W +". toRegex ()
 

Шаблон содержит именованный класс символов \ W , который
означает несловесный символ. В сочетании с +
квантификатор, шаблон ищет символы, не являющиеся словами, например пробел,
запятая или точка, которые часто используются для разделения слов в тексте.Заметка
что класс символов имеет двойное экранирование.

val words = pattern.split (текст) .filter {it.isNotBlank ()}
 

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

[Я видел лису в лесу, лису, рыжую, мех]
 

Это результат.

Соответствие без учета регистра

Чтобы включить поиск без учета регистра, мы передаем RegexOption.IGNORE_CASE
в метод toRegex () .

regex_case_insensitive.kt

пакет com.zetcode

fun main () {

    val words = listOf ("собака", "Собака", "СОБАКА", "Собака")

    val pattern = "собака" .toRegex (RegexOption.IGNORE_CASE)

    words.forEach {слово ->

        if (pattern.matches (word)) {

            println ("$ word совпадает")
        }
    }
}
 

В этом примере мы применяем шаблон к словам независимо от регистра.

val pattern = "собака".toRegex (RegexOption.IGNORE_CASE)
 

Мы используем RegexOption.IGNORE_CASE , чтобы игнорировать регистр
входной строки.

собачьи спички
Матчи для собак
Матчи DOG
 

Это результат.

Метасимвол точка

Метасимвол точка (.) Обозначает любой отдельный символ в тексте.

regex_dot_meta.kt

пакет com.zetcode

fun main () {

    val words = listOf ("семь", "даже", "предотвратить", "месть", "maven",
            «одиннадцать», «аминь», «событие»)

    val шаблон = "..even ".toRegex ()

    words.forEach {слово ->

        if (pattern.containsMatchIn (word)) {

            println ("$ word совпадает")
        }
    }
}
 

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

предотвратить матчи
одиннадцать матчей
 

Есть два слова, которые соответствуют шаблону.

Метасимвол вопросительного знака

Мета-символ вопросительного знака (?) - это квантификатор, соответствующий
предыдущий элемент ноль или один раз.

regex_qmark_meta.kt

пакет com.zetcode

fun main () {

    val words = listOf ("семь", "даже", "предотвратить", "месть", "maven",
            «одиннадцать», «аминь», «событие»)

    val шаблон = ".? даже" .toRegex ()

    words.forEach {слово ->

        if (pattern.matches (word)) {

            println ("$ word совпадает")
        }
    }
}
 

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

семь матчей
даже совпадения
 

Это результат.

Квантор {n, m}

Квантор {n, m} соответствует не менее n и не более m вхождениям
предыдущее выражение.

regex_mn_quantifier.kt

пакет com.zetcode

fun main () {

    val words = listOf ("ручка", "книга", "круто", "карандаш", "лес", "машина",
            «список», «отдых», «спросить», «точка», «глаза»)

    val pattern = "\\ w {3,4}". toRegex ()

    words.forEach {слово ->

        если (шаблон.match (word)) {

            println ("$ word совпадает")
        } else {
            println ("$ word не соответствует")
        }
    }
}
 

В этом примере мы ищем слова, в которых есть три или четыре
символы.

val pattern = "\\ w {3,4}". toRegex ()
 

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

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

Это результат.Джейн . Шаблон проверяет, находится ли строка «Джейн»
в начале текста. Модель Jane \. будет искать
«Джейн» в конце предложения.

Чередование регулярных выражений Kotlin

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

regex_alternations.kt

пакет com.zetcode

fun main () {

    val words = listOf ("Джейн", "Томас", "Роберт",
        «Люси», «Беки», «Джон», «Питер», «Энди»)

    val pattern = "Джейн | Беки | Роберт".toRegex ()

    words.forEach {слово ->

        if (pattern.matches (word)) {

            println (слово)
        }
    }
}
 

У нас в списке восемь имен.

val pattern = "Джейн | Беки | Роберт" .toRegex ()
 

Это регулярное выражение ищет строки «Джейн», «Беки» или «Роберт».

Подшаблоны регулярных выражений Kotlin

Подшаблоны — это паттерны внутри паттернов. Подшаблоны созданы
с символами ().

regex_subpatterns.kt

пакет com.zetcode

fun main () {

    val words = listOf ("книга", "книжная полка", "книжный червь",
            «книжный шкаф», «книжный», «бухгалтер», «буклет», «закладка»)

    val pattern = "книга (червь | отметка | хранитель)?". toRegex ()

    words.forEach {слово ->

        if (pattern.matches (word)) {

            println ("$ word совпадает")
        } else {

            println ("$ word не соответствует")
        }
    }
}
 

В примере создается подшаблон.

val pattern = "книга (червь | отметка | хранитель)?".toRegex ()
 

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

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

Это результат.

Классы символов регулярного выражения Kotlin

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

character_classes.kt

пакет com.zetcode

fun main () {

    val words = listOf ("серая птица", "седые волосы", "отличный вид")

    val pattern = "gr [ea] y" .toRegex ()

    words.forEach {слово ->

        if (pattern.containsMatchIn (word)) {

            println (слово)
        }
    }
}
 

В этом примере мы используем класс символов, включающий серый и серый цвета.
слова.

val pattern = "gr [ea] y" .toRegex ()
 

Класс [ea] позволяет использовать символ «e» или «a».
в выкройке.

Котлин назвал классы персонажей

Есть несколько предопределенных классов символов. \ s
соответствует пробельному символу [\ t \ n \ t \ f \ v] ,
\ d цифра [0-9] и \ w
символ слова [a-zA-Z0-9_] .

named_character_classes.kt

пакет com.zetcode

fun main () {

    val text = "Мы познакомились в 2013 году. Ей должно быть около 27 лет".

    val шаблон = "\\ d +". toRegex ()
    val found = pattern.findAll (текст)

    found.forEach {f ->
        
        val m = f.value
        println (м)
    }
}
 

В этом примере мы ищем числа в тексте.

val шаблон = "\\ d +". toRegex ()
 

Шаблон \ d + ищет любое количество наборов цифр в
текст.

val found = pattern.findAll (текст)
 

Чтобы найти все совпадения с , findAll () .

2013
27
 

Это результат.

Группы захвата регулярных выражений Kotlin

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

capturing_groups.kt

пакет com.zetcode

fun main () {

    val сайты = listOf (
        "webcode.me", "zetcode.com", "freebsd.org",
        "netbsd.org"
    )

    val pattern = "(\\ w +) \\. (\\ w +)". toRegex ()

    для (сайт на сайтах) {

        val match = pattern.findAll (сайт)

        match.forEach {matchResult ->

            println (matchResult.значение)
            println (matchResult.groupValues ​​[1])
            println (matchResult.groupValues ​​[2])
            println ("*****************")
        }
    }
}
 

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

val pattern = "(\\ w +) \\. (\\ w +)". toRegex ()
 

Мы определяем две группы скобками.

match.forEach {matchResult ->

    println (matchResult.value)
    println (matchResult.groupValues ​​[1])
    println (matchResult.groupValues ​​[2])
    println ("*****************")
}
 

Доступ к группам осуществляется через функцию groupValues ​​() .
groupValues ​​[0]) возвращает всю совпавшую строку; это
эквивалент value property.

webcode.me
веб-код
мне
*****************
zetcode.com
zetcode
com
*****************
freebsd.org
freebsd
org
*****************
netbsd.org
netbsd
org
*****************
 

Это результат.

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

regex_expressions.kt

пакет com.zetcode

fun main () {

    val выражения = listOf ("16 + 11", "12 * 5", "27/3", "2-8")
    val pattern = "(\\ d +) \\ s + ([- + * /]) \\ s + (\\ d +)". toRegex ()

    for (выражение в выражениях) {

        val соответствует = pattern.findAll (выражение)

        match.forEach {matchResult ->

            значение value1 = matchResult.groupValues ​​[1] .toInt ()
            значение значение2 = matchResult.groupValues ​​[3] .toInt ()

            val msg = когда (matchResult.groupValues ​​[2]) {

                "+" -> "$ выражение = $ {значение1 + значение2}"
                "-" -> "$ выражение = $ {значение1 - значение2}"
                "*" -> "$ выражение = $ {значение1 * значение2}"
                "/" -> "$ выражение = $ {значение1 / значение2}"
                else -> «Неизвестный оператор»
            }

            println (сообщение)
        }
    }
}
 

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

val выражения = listOf ("16 + 11", "12 * 5", "27/3", "2-8")
 

У нас есть список из четырех выражений.

val pattern = "(\\ d +) \\ s + ([- + * /]) \\ s + (\\ d +)". toRegex ()
 

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

значение value1 = matchResult.groupValues ​​[1] .toInt ()
значение значение2 = matchResult.groupValues ​​[3] .toInt ()
 

Получаем значения и преобразуем их в целые числа.

val msg = when (matchResult.groupValues ​​[2]) {

    "+" -> "$ выражение = $ {значение1 + значение2}"
    "-" -> "$ выражение = $ {значение1 - значение2}"
    "*" -> "$ выражение = $ {значение1 * значение2}"
    "/" -> "$ выражение = $ {значение1 / значение2}"
    else -> «Неизвестный оператор»
}
 

С помощью выражения when мы вычисляем выражения и строим сообщения.

16 + 11 = 27
12 * 5 = 60
27/3 = 9
2-8 = -6
 

Это результат.

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

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

regex_emails.kt

пакет com.zetcode

fun main () {

    val emails = listOf ("[email protected]", "andy @ yahoocom",
            «34234sdfa # 2345», «[email protected]», «[email protected]»)

    val шаблон = "[a-zA-Z0-9 ._-] + @ [a-zA-Z0-9 -] + \\.[а-я-я.] {2,18} ". toRegex ()

    emails.forEach {email ->

        if (pattern.matches (электронная почта)) {

            println ("$ email соответствует")
        } else {

            println ("$ email не соответствует")
        }
    }
}
 

Этот пример предлагает одно возможное решение.

val pattern = "[a-zA-Z0-9 ._-] + @ [a-zA-Z0-9 -] + \\. [a-zA-Z.] {2,18}". toRegex ()
 

Электронное письмо разделено на пять частей. Первая часть — это локальная часть.
Обычно это название компании, физического лица или псевдоним. [a-zA-Z0-9 ._-] + перечисляет все возможные символы, которые мы можем
использование в локальной части. Их можно использовать один или несколько раз.

Вторая часть состоит из буквального символа @ . Третий
part — это доменная часть. Обычно это доменное имя провайдера электронной почты.
например Yahoo или Gmail. [a-zA-Z0-9 -] +
— это класс символов, содержащий все символы, которые могут использоваться в доменном имени.
Квантификатор + позволяет использовать один или несколько из этих символов.

Четвертая часть — это точка; ему предшествует двойной escape
символ (\\), чтобы получить буквальную точку.

Последняя часть — это доменное имя верхнего уровня: [a-zA-Z.] {2,18} .
Домены верхнего уровня могут содержать от 2 до 18 символов, например sk, net, info,
путешествия, уборка, страхование путешествий. Максимальная длина может составлять 63 символа,
но большинство доменов сегодня короче 18 символов. Также есть
точечный символ. Это потому, что некоторые домены верхнего уровня состоят из двух частей;
например co.Соединенное Королевство.

[email protected] соответствует
andy @ yahoocom не соответствует
34234sdfa # 2345 не соответствует
[email protected] соответствует
[email protected] не соответствует
 

Это результат.

В этой главе мы рассмотрели регулярные выражения в Kotlin.

Список всех руководств по Kotlin.

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

— Cisco

Содержание

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

Детали регулярного выражения PCRE

Обратная косая черта

Непечатаемые символы

Общие типы символов

Свойства символов Юникода

Простые утверждения

Circumflex и доллар

Полная остановка (точка, точка)

Соответствие одному байту

Квадратные скобки и классы символов

Классы символов Posix

Вертикальная полоса

Настройка внутренних опций

Подшаблоны

Именованные подшаблоны

Повторение

Атомарная группировка и притяжательные квантификаторы

Обратные ссылки

Утверждения

Утверждения опережающего просмотра

Утверждения просмотра назад

Использование нескольких утверждений

Условные подшаблоны

Комментарии

Рекурсивные шаблоны

Подшаблоны как подпрограммы

Вызовы

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

---

• Подробности регулярного выражения PCRE

• Обратная косая черта

• Циркумфлекс и доллар

• Полная остановка (точка, точка)

• Соответствие одиночному байту

• Квадратные скобки и классы символов

• Классы символов Posix

• Вертикальная полоса

• Внутренняя настройка параметров

• Подшаблоны

• Именованные подшаблоны

• Повторение

• Атомарная группировка и притяжательные квантификаторы

• Обратные ссылки

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

• Условные подшаблоны

• Комментарии

• Рекурсивные шаблоны

• Подшаблоны как подпрограммы

• Выноски

Подробности регулярного выражения PCRE

Синтаксис и семантика регулярных выражений, поддерживаемых PCRE, описаны ниже.Регулярные выражения также описаны в документации Perl и в ряде книг, некоторые из которых содержат множество примеров. В книге Джеффри Фридла «Mastering Regular Expressions», опубликованной O’Reilly, регулярные выражения рассматриваются очень подробно. Это описание регулярных выражений PCRE предназначено как справочный материал.

Изначально PCRE выполняла операции со строками однобайтовых символов. Однако теперь также есть поддержка символьных строк UTF-8. Чтобы использовать это, вы должны собрать PCRE, чтобы включить поддержку UTF-8, а затем вызвать pcre_compile () с опцией PCRE_UTF8.Как это влияет на сопоставление с образцом, упоминается в нескольких местах ниже. Также имеется сводка возможностей UTF-8 в разделе о поддержке UTF-8 на главной странице PCRE.

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

соответствует части темы

.